@aria-cli/types 1.0.9 → 1.0.10

package/tests/logger.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
-import { log } from "../src/logger.js";
-import type { LogLevel } from "../src/logger.js";
-
-describe("leveled logger", () => {
-  let originalLevel: LogLevel;
-
-  beforeEach(() => {
-    originalLevel = log.getLevel();
-    // Reset to default "info" before each test
-    log.setLevel("info");
-  });
-
-  afterEach(() => {
-    log.setLevel(originalLevel);
-    vi.restoreAllMocks();
-  });
-
-  it('default level is "info" — log.debug() does NOT call console.debug', () => {
-    const spy = vi.spyOn(console, "debug").mockImplementation(() => {});
-    log.debug("should be suppressed");
-    expect(spy).not.toHaveBeenCalled();
-  });
-
-  it('default level "info" — log.info() DOES call console.info', () => {
-    const spy = vi.spyOn(console, "info").mockImplementation(() => {});
-    log.info("hello from info");
-    expect(spy).toHaveBeenCalledWith("hello from info");
-  });
-
-  it('default level "info" — log.warn() and log.error() work', () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    log.warn("a warning");
-    log.error("an error");
-
-    expect(warnSpy).toHaveBeenCalledWith("a warning");
-    expect(errorSpy).toHaveBeenCalledWith("an error");
-  });
-
-  it('after setLevel("debug") — log.debug() DOES call console.debug', () => {
-    log.setLevel("debug");
-    const spy = vi.spyOn(console, "debug").mockImplementation(() => {});
-    log.debug("debug message");
-    expect(spy).toHaveBeenCalledWith("debug message");
-  });
-
-  it('after setLevel("silent") — nothing calls console methods', () => {
-    log.setLevel("silent");
-
-    const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
-    const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    log.debug("nope");
-    log.info("nope");
-    log.warn("nope");
-    log.error("nope");
-
-    expect(debugSpy).not.toHaveBeenCalled();
-    expect(infoSpy).not.toHaveBeenCalled();
-    expect(warnSpy).not.toHaveBeenCalled();
-    expect(errorSpy).not.toHaveBeenCalled();
-  });
-
-  it("swallows broken-pipe logger writes", () => {
-    const brokenPipe = Object.assign(new Error("broken pipe"), { code: "EPIPE" });
-    vi.spyOn(console, "warn").mockImplementation(() => {
-      throw brokenPipe;
-    });
-    vi.spyOn(console, "error").mockImplementation(() => {
-      throw brokenPipe;
-    });
-
-    expect(() => log.warn("non-fatal warn")).not.toThrow();
-    expect(() => log.error("non-fatal error")).not.toThrow();
-  });
-
-  it("rethrows non-broken-pipe logger write failures", () => {
-    const unexpected = new Error("unexpected logger failure");
-    vi.spyOn(console, "warn").mockImplementation(() => {
-      throw unexpected;
-    });
-
-    expect(() => log.warn("should explode")).toThrow("unexpected logger failure");
-  });
-
-  it("getLevel() returns the current level", () => {
-    expect(log.getLevel()).toBe("info");
-
-    log.setLevel("debug");
-    expect(log.getLevel()).toBe("debug");
-
-    log.setLevel("error");
-    expect(log.getLevel()).toBe("error");
-
-    log.setLevel("silent");
-    expect(log.getLevel()).toBe("silent");
-  });
-});

package/tests/memoria-vitest-isolation.contract.test.ts

@@ -1,108 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const FILE_ISOLATED_TARGET_ENV = "ARIA_VITEST_FILE_ISOLATED_TARGET";
-const ORIGINAL_FILE_ISOLATED_TARGET = process.env[FILE_ISOLATED_TARGET_ENV];
-const VITEST_UNIT_ONLY_ENV = "VITEST_UNIT_ONLY";
-const ORIGINAL_VITEST_UNIT_ONLY = process.env[VITEST_UNIT_ONLY_ENV];
-
-async function importRunner() {
-  vi.resetModules();
-  return import(new URL("../../../scripts/run-vitest-projects.mjs", import.meta.url).href);
-}
-
-async function importMemoriaVitestConfig() {
-  vi.resetModules();
-  return import(new URL("../../../packages/memoria/vitest.config.ts", import.meta.url).href);
-}
-
-afterEach(() => {
-  vi.resetModules();
-  if (ORIGINAL_FILE_ISOLATED_TARGET === undefined) {
-    delete process.env[FILE_ISOLATED_TARGET_ENV];
-  } else {
-    process.env[FILE_ISOLATED_TARGET_ENV] = ORIGINAL_FILE_ISOLATED_TARGET;
-  }
-  if (ORIGINAL_VITEST_UNIT_ONLY === undefined) {
-    delete process.env[VITEST_UNIT_ONLY_ENV];
-  } else {
-    process.env[VITEST_UNIT_ONLY_ENV] = ORIGINAL_VITEST_UNIT_ONLY;
-  }
-});
-
-describe("memoria vitest isolation contract", () => {
-  it("propagates the full-suite Vitest concurrency budget to child package runs", async () => {
-    const { buildVitestSpawnEnv } = await importRunner();
-
-    const env = buildVitestSpawnEnv("packages/server/vitest.config.ts", [], {}, 11);
-
-    expect(env.VITEST_CONCURRENT_PROCESSES).toBe("11");
-  });
-
-  it("does not mark memoria file targets as isolated shards now that file isolation is removed", async () => {
-    const { buildVitestSpawnEnv } = await importRunner();
-
-    const env = buildVitestSpawnEnv(
-      "packages/memoria/vitest.config.ts",
-      ["tests/storage/sqlite.test.ts", "--passWithNoTests"],
-      {},
-      11,
-    );
-
-    expect(env.ARIA_VITEST_FILE_ISOLATED_TARGET).toBeUndefined();
-  });
-
-  it("does not mark package-wide memoria runs as isolated file shards", async () => {
-    const { buildVitestSpawnEnv } = await importRunner();
-
-    const env = buildVitestSpawnEnv(
-      "packages/memoria/vitest.config.ts",
-      ["--passWithNoTests"],
-      {},
-      11,
-    );
-
-    expect(env.ARIA_VITEST_FILE_ISOLATED_TARGET).toBeUndefined();
-  });
-
-  it("treats explicit memoria file targets as regular args since file isolation is removed", async () => {
-    const { getVitestTargets } = await importRunner();
-
-    expect(
-      getVitestTargets("packages/memoria/vitest.config.ts", [
-        "tests/apr-evidence-gate.test.ts",
-        "--passWithNoTests",
-      ]),
-    ).toEqual([[]]);
-  });
-
-  it("keeps forks when the outer runner already isolates memoria to one file", async () => {
-    process.env[FILE_ISOLATED_TARGET_ENV] = "1";
-    delete process.env[VITEST_UNIT_ONLY_ENV];
-
-    const { default: config } = await importMemoriaVitestConfig();
-
-    expect(config.test?.pool).toBe("forks");
-    expect(config.test?.maxWorkers).toBeGreaterThanOrEqual(2);
-  });
-
-  it("uses threads with parallel workers for package-wide memoria unit runs", async () => {
-    delete process.env[FILE_ISOLATED_TARGET_ENV];
-    process.env[VITEST_UNIT_ONLY_ENV] = "true";
-
-    const { default: config } = await importMemoriaVitestConfig();
-
-    expect(config.test?.pool).toBe("threads");
-    expect(config.test?.maxWorkers).toBeGreaterThanOrEqual(2);
-  });
-
-  it("keeps fork isolation for package-wide non-unit memoria config factories", async () => {
-    delete process.env[FILE_ISOLATED_TARGET_ENV];
-    delete process.env[VITEST_UNIT_ONLY_ENV];
-
-    const { createMemoriaVitestConfig } = await importMemoriaVitestConfig();
-    const config = createMemoriaVitestConfig(false);
-
-    expect(config.test?.pool).toBe("forks");
-    expect(config.test?.maxWorkers).toBe(1);
-  });
-});

package/tests/test-lane-manifest.ts

@@ -1,177 +0,0 @@
-import { readdirSync, statSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { getMaxWorkers } from "../../../vitest.shared.ts";
-
-export type TypesTestLaneId = "unit";
-export type TypesTestProofClassId = "gate" | "system" | "live";
-
-export interface TypesTestPlacement {
-  lane: TypesTestLaneId;
-  proofClass: TypesTestProofClassId;
-  resourceKeys: string[];
-}
-
-export interface TypesTestLaneManifest {
-  defaultLane: "unit";
-  lanes: Record<TypesTestLaneId, string[]>;
-  setupFiles: Record<TypesTestLaneId, string[]>;
-  maxWorkers: Record<TypesTestLaneId, number>;
-  pool: Record<TypesTestLaneId, "forks">;
-  fileParallelism: Record<TypesTestLaneId, boolean>;
-  unclassified: string[];
-  proofClasses: Record<TypesTestProofClassId, string[]>;
-  resourceKeysByFile: Record<string, string[]>;
-  unclassifiedProofClasses: string[];
-}
-
-const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const scanRoots = [path.join(packageRoot, "tests"), path.join(packageRoot, "src")];
-const EMPTY_SETUP: string[] = [];
-const SAFE_UNIT_WORKERS = Math.min(4, getMaxWorkers());
-
-function normalizeRelativePath(filePath: string): string {
-  return path.relative(packageRoot, filePath).split(path.sep).join("/");
-}
-
-function statSafe(targetPath: string): ReturnType<typeof statSync> | null {
-  try {
-    return statSync(targetPath);
-  } catch {
-    return null;
-  }
-}
-
-function collectTestFiles(dir: string, out: string[]): void {
-  if (!statSafe(dir)?.isDirectory()) return;
-
-  for (const entry of readdirSync(dir)) {
-    if (entry === "node_modules" || entry === "dist" || entry === ".worktrees") continue;
-
-    const fullPath = path.join(dir, entry);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory()) {
-      collectTestFiles(fullPath, out);
-      continue;
-    }
-
-    if (entry.endsWith(".test.ts") || entry.endsWith(".test.tsx")) {
-      out.push(normalizeRelativePath(fullPath));
-    }
-  }
-}
-
-function isTestFile(relativePath: string): boolean {
-  return relativePath.endsWith(".test.ts") || relativePath.endsWith(".test.tsx");
-}
-
-export function classifyTypesTestPlacement(relativePath: string): TypesTestPlacement | null {
-  const normalized = relativePath.split(path.sep).join("/");
-  if (!isTestFile(normalized)) {
-    return null;
-  }
-
-  return {
-    lane: "unit",
-    proofClass: "gate",
-    resourceKeys: [],
-  };
-}
-
-export function classifyTypesTestFile(relativePath: string): TypesTestLaneId | null {
-  return classifyTypesTestPlacement(relativePath)?.lane ?? null;
-}
-
-export function classifyTypesTestProofClass(relativePath: string): TypesTestProofClassId | null {
-  return classifyTypesTestPlacement(relativePath)?.proofClass ?? null;
-}
-
-export function loadTypesTestLaneManifest(): TypesTestLaneManifest {
-  const files: string[] = [];
-  for (const scanRoot of scanRoots) {
-    collectTestFiles(scanRoot, files);
-  }
-
-  const manifest: TypesTestLaneManifest = {
-    defaultLane: "unit",
-    lanes: {
-      unit: [],
-    },
-    setupFiles: {
-      unit: EMPTY_SETUP,
-    },
-    maxWorkers: {
-      unit: SAFE_UNIT_WORKERS,
-    },
-    pool: {
-      unit: "forks",
-    },
-    fileParallelism: {
-      unit: true,
-    },
-    unclassified: [],
-    proofClasses: {
-      gate: [],
-      system: [],
-      live: [],
-    },
-    resourceKeysByFile: {},
-    unclassifiedProofClasses: [],
-  };
-
-  for (const relativePath of files.sort()) {
-    const placement = classifyTypesTestPlacement(relativePath);
-    if (!placement) {
-      manifest.unclassified.push(relativePath);
-      manifest.unclassifiedProofClasses.push(relativePath);
-      continue;
-    }
-
-    manifest.lanes[placement.lane].push(relativePath);
-    manifest.proofClasses[placement.proofClass].push(relativePath);
-    manifest.resourceKeysByFile[relativePath] = [...placement.resourceKeys];
-  }
-
-  return manifest;
-}
-
-export function getTypesTestLaneFiles(lane: TypesTestLaneId): string[] {
-  return [...loadTypesTestLaneManifest().lanes[lane]];
-}
-
-export function getTypesTestLaneSetupFiles(lane: TypesTestLaneId): string[] {
-  return [...loadTypesTestLaneManifest().setupFiles[lane]];
-}
-
-export function getTypesTestLaneMaxWorkers(lane: TypesTestLaneId): number {
-  return loadTypesTestLaneManifest().maxWorkers[lane];
-}
-
-export function getTypesTestLanePool(lane: TypesTestLaneId): "forks" {
-  return loadTypesTestLaneManifest().pool[lane];
-}
-
-export function getTypesTestLaneFileParallelism(lane: TypesTestLaneId): boolean {
-  return loadTypesTestLaneManifest().fileParallelism[lane];
-}
-
-export function getTypesDiagnosticBreadthFiles(
-  view: "unit" | "integration" | "e2e" | "native",
-): string[] {
-  return view === "unit" ? getTypesTestLaneFiles("unit") : [];
-}
-
-export function getTypesTestProofClassFiles(proofClass: TypesTestProofClassId): string[] {
-  return [...loadTypesTestLaneManifest().proofClasses[proofClass]];
-}
-
-export const PACKAGE_TEST_AUTHORITY = {
-  classifyPlacement: classifyTypesTestPlacement,
-  classifyLane: classifyTypesTestFile,
-  classifyProofClass: classifyTypesTestProofClass,
-  loadManifest: loadTypesTestLaneManifest,
-  getLaneFiles: getTypesTestLaneFiles,
-  getLaneGlobalSetup: () => [],
-  getDiagnosticBreadthFiles: getTypesDiagnosticBreadthFiles,
-  getProofClassFiles: getTypesTestProofClassFiles,
-};

package/tests/vitest-project-runner.contract.test.ts

@@ -1,309 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-async function importRunner() {
-  vi.resetModules();
-  return import(new URL("../../../scripts/run-vitest-projects.mjs", import.meta.url).href);
-}
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  vi.resetModules();
-  vi.doUnmock("node:child_process");
-});
-
-class FakeChild extends EventEmitter {
-  stdout = new PassThrough();
-  stderr = new PassThrough();
-  pid = 0;
-  exitCode: number | null = null;
-  signalCode: NodeJS.Signals | null = null;
-  unrefCalls = 0;
-
-  kill(_signal?: NodeJS.Signals | number): boolean {
-    return true;
-  }
-
-  unref(): this {
-    this.unrefCalls += 1;
-    return this;
-  }
-}
-
-describe("vitest project runner", () => {
-  it("enumerates every package vitest config in deterministic order", async () => {
-    const { PROJECT_VITEST_CONFIGS } = await importRunner();
-
-    expect(PROJECT_VITEST_CONFIGS).toEqual([
-      "packages/types/vitest.config.ts",
-      "packages/models/vitest.config.ts",
-      "packages/memoria/vitest.config.ts",
-      "packages/memoria-bridge/vitest.config.ts",
-      "packages/tools/vitest.config.ts",
-      "packages/wireguard/vitest.config.ts",
-      "packages/aria/vitest.config.ts",
-      "packages/auth/vitest.config.ts",
-      "packages/benchmark/vitest.config.ts",
-      "packages/server/vitest.config.ts",
-      "packages/cli/vitest.config.ts",
-    ]);
-  });
-
-  it("enumerates every package integration vitest config in deterministic order and excludes packages without an integration lane", async () => {
-    const { PROJECT_INTEGRATION_VITEST_CONFIGS } = await importRunner();
-
-    expect(PROJECT_INTEGRATION_VITEST_CONFIGS).toEqual([
-      "packages/models/vitest.integration.config.ts",
-      "packages/memoria/vitest.integration.config.ts",
-      "packages/memoria-bridge/vitest.integration.config.ts",
-      "packages/tools/vitest.integration.config.ts",
-      "packages/wireguard/vitest.integration.config.ts",
-      "packages/aria/vitest.integration.config.ts",
-      "packages/auth/vitest.integration.config.ts",
-      "packages/benchmark/vitest.integration.config.ts",
-      "packages/server/vitest.integration.config.ts",
-      "packages/cli/vitest.integration.config.ts",
-    ]);
-    expect(PROJECT_INTEGRATION_VITEST_CONFIGS).not.toContain(
-      "packages/types/vitest.integration.config.ts",
-    );
-  });
-
-  it("runs package suites sequentially and stops on the first failure", async () => {
-    const { runProjectSuites } = await importRunner();
-    const calls: string[] = [];
-
-    const exitCode = await runProjectSuites(
-      ["first", "second", "third"],
-      ["--passWithNoTests"],
-      async (configPath, args) => {
-        calls.push(`${configPath} ${args.join(" ")}`);
-        return configPath === "second" ? 1 : 0;
-      },
-    );
-
-    expect(exitCode).toBe(1);
-    expect(calls).toEqual(["first --passWithNoTests", "second --passWithNoTests"]);
-  });
-
-  it("launches each vitest config from its package root so config-relative paths stay local", async () => {
-    const { buildVitestInvocation } = await importRunner();
-
-    expect(
-      buildVitestInvocation("packages/server/vitest.config.ts", ["--passWithNoTests"]),
-    ).toEqual({
-      cwd: "packages/server",
-      args: ["run", "--config", "vitest.config.ts", "--passWithNoTests"],
-    });
-  });
-
-  it("runs memoria as a single vitest invocation instead of per-file splits", async () => {
-    const { getVitestTargets } = await importRunner();
-
-    const targets = getVitestTargets("packages/memoria/vitest.config.ts", ["--passWithNoTests"]);
-
-    expect(targets).toEqual([[]]);
-  });
-
-  it("keeps coverage runs as a single package invocation so Vitest can aggregate coverage", async () => {
-    const { getVitestTargets } = await importRunner();
-
-    expect(getVitestTargets("packages/memoria/vitest.config.ts", ["--coverage"])).toEqual([[]]);
-  });
-
-  it("passes explicit memoria file targets through exactly once instead of expanding the package", async () => {
-    const { runProjectSuites } = await importRunner();
-    const calls: string[] = [];
-
-    const exitCode = await runProjectSuites(
-      ["packages/memoria/vitest.config.ts"],
-      ["tests/apr-evidence-gate.test.ts", "--passWithNoTests"],
-      async (_configPath, args) => {
-        calls.push(args.join(" "));
-        return 0;
-      },
-    );
-
-    expect(exitCode).toBe(0);
-    expect(calls).toEqual(["tests/apr-evidence-gate.test.ts --passWithNoTests"]);
-  });
-
-  it("reports a failing package with config context", async () => {
-    const { runProjectSuites } = await importRunner();
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const exitCode = await runProjectSuites(
-      ["packages/memoria/vitest.config.ts"],
-      ["--passWithNoTests"],
-      async () => 1,
-    );
-
-    expect(exitCode).toBe(1);
-    expect(errorSpy).toHaveBeenCalledWith(
-      expect.stringContaining("packages/memoria/vitest.config.ts"),
-    );
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("exit code 1"));
-  });
-
-  it("reports child signal failures instead of collapsing them into an anonymous nonzero exit", async () => {
-    const { runProjectSuites } = await importRunner();
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const exitCode = await runProjectSuites(["packages/server/vitest.config.ts"], [], async () => ({
-      exitCode: 1,
-      signal: "SIGTERM",
-    }));
-
-    expect(exitCode).toBe(1);
-    expect(errorSpy).toHaveBeenCalledWith(
-      expect.stringContaining("packages/server/vitest.config.ts"),
-    );
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("signal SIGTERM"));
-  });
-
-  it("derives the vitest lease from the active absolute git dir so sibling worktrees do not serialize package lanes", async () => {
-    const { vitestRunnerLeaseDir } = await importRunner();
-    const runnerSource = fs.readFileSync(
-      path.resolve(import.meta.dirname, "../../../scripts/run-vitest-projects.mjs"),
-      "utf8",
-    );
-
-    expect(runnerSource.includes('["rev-parse", "--absolute-git-dir"]')).toBe(true);
-    expect(runnerSource.includes('["rev-parse", "--git-common-dir"]')).toBe(false);
-
-    expect(
-      vitestRunnerLeaseDir("/repo/.worktrees/feature", () => "/repo/.git/worktrees/feature"),
-    ).toBe(
-      "/repo/.git/worktrees/feature/.vitest-runner.lock",
-    );
-
-    expect(
-      vitestRunnerLeaseDir("/repo/.worktrees/feature", () => "/repo/.git/worktrees/feature"),
-    ).toBe("/repo/.git/worktrees/feature/.vitest-runner.lock");
-    expect(vitestRunnerLeaseDir("/repo", () => "/repo/.git")).toBe(
-      "/repo/.git/.vitest-runner.lock",
-    );
-    expect(runnerSource.includes('["rev-parse", "--absolute-git-dir"]')).toBe(true);
-    expect(runnerSource.includes('["rev-parse", "--git-common-dir"]')).toBe(false);
-  });
-
-  it("resolves the active absolute git dir instead of the shared common dir for linked worktrees", async () => {
-    const { resolveGitDir } = await importRunner();
-    const exec = vi.fn(() => "/repo/.git/worktrees/feature\n");
-
-    expect(resolveGitDir("/repo/.worktrees/feature", exec)).toBe("/repo/.git/worktrees/feature");
-    expect(exec).toHaveBeenCalledWith("git", ["rev-parse", "--absolute-git-dir"], {
-      cwd: "/repo/.worktrees/feature",
-      encoding: "utf8",
-    });
-  });
-
-  it("routes cli suite execution through the worktree-local vitest lease", async () => {
-    const { runVitestProjectsCli } = await importRunner();
-    const withVitestRunnerLease = vi.fn(async (action: () => Promise<number>) => await action());
-    const runCommand = vi.fn(async () => 0);
-
-    const exitCode = await runVitestProjectsCli(
-      ["packages/types/vitest.config.ts", "--passWithNoTests"],
-      {
-        withVitestRunnerLease,
-        runCommand,
-      },
-    );
-
-    expect(exitCode).toBe(0);
-    expect(withVitestRunnerLease).toHaveBeenCalledTimes(1);
-    expect(runCommand).toHaveBeenCalledTimes(1);
-  });
-
-  it("uses a bounded vitest lease wait with worktree-local metadata instead of an unbounded shared lease", async () => {
-    const { withVitestRunnerLease } = await importRunner();
-    const withDirectoryLockImpl = vi.fn(
-      async (
-        lockDir: string,
-        action: () => Promise<number>,
-        options?: {
-          timeoutMs?: number | null;
-          lockDescription?: string;
-          metadata?: Record<string, unknown>;
-        },
-      ) => {
-        expect(lockDir).toBe("/repo/.git/worktrees/feature/.vitest-runner.lock");
-        expect(options?.lockDescription).toBe("vitest runner lease");
-        expect(options?.metadata).toEqual({
-          purpose: "vitest-runner",
-          root: "/repo/.worktrees/feature",
-        });
-        expect(typeof options?.timeoutMs).toBe("number");
-        expect((options?.timeoutMs ?? 0) > 0).toBe(true);
-        return await action();
-      },
-    );
-
-    const result = await withVitestRunnerLease(async () => 7, {
-      repoRoot: "/repo/.worktrees/feature",
-      lockDir: "/repo/.git/worktrees/feature/.vitest-runner.lock",
-      withDirectoryLockImpl,
-    });
-
-    expect(result).toBe(7);
-    expect(withDirectoryLockImpl).toHaveBeenCalledTimes(1);
-  });
-
-  it("resolves the Vitest binary through node_modules/.bin instead of a hardcoded package path", async () => {
-    const { vitestBinaryPath } = await importRunner();
-    const expectedSuffix =
-      process.platform === "win32" ? "node_modules/.bin/vitest.cmd" : "node_modules/.bin/vitest";
-
-    expect(vitestBinaryPath("/repo")).toBe("/repo/" + expectedSuffix);
-  });
-
-  it("resolves detached vitest children on exit without waiting for close", async () => {
-    const child = new FakeChild();
-    let spawned = false;
-    const { spawnVitest } = await importRunner();
-    const resultPromise = spawnVitest("packages/server/vitest.config.ts", ["--passWithNoTests"], {
-      waitForCapacityImpl: vi.fn().mockResolvedValue(undefined),
-      spawnImpl: () => {
-        spawned = true;
-        return child as never;
-      },
-    });
-
-    await Promise.resolve();
-    expect(spawned).toBe(true);
-    child.stdout.write("partial stdout\n");
-    child.exitCode = 0;
-    child.emit("exit", 0, null);
-
-    const result = await Promise.race([
-      resultPromise,
-      new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error("spawnVitest did not resolve on exit")), 100),
-      ),
-    ]);
-
-    expect(result).toEqual({ exitCode: 0, signal: null });
-    expect(child.stdout.destroyed).toBe(true);
-    expect(child.stderr.destroyed).toBe(true);
-    expect(child.unrefCalls).toBe(1);
-  });
-
-  it("preserves detached vitest child signals as conventional shell status", async () => {
-    const child = new FakeChild();
-    const { spawnVitest } = await importRunner();
-    const resultPromise = spawnVitest("packages/server/vitest.config.ts", ["--passWithNoTests"], {
-      waitForCapacityImpl: vi.fn().mockResolvedValue(undefined),
-      spawnImpl: () => child as never,
-    });
-
-    await Promise.resolve();
-    child.signalCode = "SIGTERM";
-    child.emit("exit", null, "SIGTERM");
-
-    await expect(resultPromise).resolves.toEqual({ exitCode: 143, signal: "SIGTERM" });
-  });
-});