fix: don't flag a concurrent vitest run's tmpdir as a leak

check-tmpdir-leaks.ts reported every agent-device-test-run-* directory
as a leak, but a concurrent vitest run in another worktree legitimately
keeps its own directory present until its own teardown finishes. On a
machine that regularly runs several worktrees at once, that made
check:unit fail on unrelated in-progress work.

Embed the owning process's pid in the directory name (still random-
suffixed via mkdtempSync, so same-pid reuse across separate runs can't
collide) and have the leak check skip any directory whose pid is still
alive (process.kill(pid, 0)) — only directories whose owning process
already exited without running its globalTeardown are real leaks.

Split the pure logic into check-tmpdir-leaks-model.ts (findLeakedRunDirectories,
with an injectable liveness check for testing) so it has a real
regression suite, including the concurrent-run case, instead of only
being exercised by hand.

Author: thymikee

package.json

@@ -136,12 +136,13 @@
     "check:command-docs": "vitest run --project unit-core src/__tests__/command-doc-coverage.test.ts",
     "check:replay-compat": "node --experimental-strip-types scripts/check-replay-compat-provenance.ts",
     "check:tmpdir-leaks": "node --experimental-strip-types scripts/check-tmpdir-leaks.ts",
+    "check:tmpdir-leaks:test": "node --experimental-strip-types --test scripts/check-tmpdir-leaks-model.test.ts",
     "check:freerange": "fr",
     "check:quick": "pnpm lint && pnpm typecheck",
     "sync:mcp-metadata": "node scripts/sync-mcp-metadata.mjs",
     "check:mcp-metadata": "node scripts/sync-mcp-metadata.mjs --check",
     "version": "pnpm sync:mcp-metadata && git add server.json",
-    "check:tooling": "pnpm format:check && pnpm lint && pnpm typecheck && pnpm check:layering && pnpm depgraph:test && pnpm check:production-exports && pnpm check:mcp-metadata && pnpm build && pnpm check:bundle-owner-files && pnpm check:package",
+    "check:tooling": "pnpm format:check && pnpm lint && pnpm typecheck && pnpm check:layering && pnpm depgraph:test && pnpm check:production-exports && pnpm check:tmpdir-leaks:test && pnpm check:mcp-metadata && pnpm build && pnpm check:bundle-owner-files && pnpm check:package",
     "check:unit": "pnpm check:contention-retry && pnpm test:unit && pnpm check:tmpdir-leaks && pnpm test:smoke",
     "check": "pnpm check:tooling && pnpm check:fallow && pnpm check:unit",
     "prepack": "pnpm check:mcp-metadata && pnpm package:npm",

scripts/check-tmpdir-leaks-model.test.ts

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import { findLeakedRunDirectories } from './check-tmpdir-leaks-model.ts';
+
+function withScratchRoot(fn: (root: string) => void): void {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'check-tmpdir-leaks-model-test-'));
+  try {
+    fn(root);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+test('a directory owned by a still-running process is not reported as a leak', () => {
+  withScratchRoot((root) => {
+    fs.mkdirSync(path.join(root, 'agent-device-test-run-4242-abcdef'));
+    const leaks = findLeakedRunDirectories(root, (pid) => pid === 4242);
+    assert.deepEqual(leaks, []);
+  });
+});
+
+test('a directory whose owning process has exited is reported as a leak', () => {
+  withScratchRoot((root) => {
+    fs.mkdirSync(path.join(root, 'agent-device-test-run-4242-abcdef'));
+    const leaks = findLeakedRunDirectories(root, () => false);
+    assert.deepEqual(leaks, ['agent-device-test-run-4242-abcdef']);
+  });
+});
+
+test('a concurrent run from another worktree does not fail the check for this one', () => {
+  withScratchRoot((root) => {
+    // Simulates two worktrees running vitest at once: pid 1111 (this
+    // invocation, still alive) and pid 2222 (a different worktree's
+    // in-progress run, also alive).
+    fs.mkdirSync(path.join(root, 'agent-device-test-run-1111-aaaaaa'));
+    fs.mkdirSync(path.join(root, 'agent-device-test-run-2222-bbbbbb'));
+    const alivePids = new Set([1111, 2222]);
+    const leaks = findLeakedRunDirectories(root, (pid) => alivePids.has(pid));
+    assert.deepEqual(leaks, []);
+  });
+});
+
+test('a mix of active and abandoned directories reports only the abandoned one', () => {
+  withScratchRoot((root) => {
+    fs.mkdirSync(path.join(root, 'agent-device-test-run-1111-aaaaaa')); // alive
+    fs.mkdirSync(path.join(root, 'agent-device-test-run-3333-cccccc')); // exited
+    const leaks = findLeakedRunDirectories(root, (pid) => pid === 1111);
+    assert.deepEqual(leaks, ['agent-device-test-run-3333-cccccc']);
+  });
+});
+
+test('a directory with no parseable pid is conservatively reported as a leak', () => {
+  withScratchRoot((root) => {
+    fs.mkdirSync(path.join(root, 'agent-device-test-run-not-a-pid'));
+    const leaks = findLeakedRunDirectories(root, () => true);
+    assert.deepEqual(leaks, ['agent-device-test-run-not-a-pid']);
+  });
+});
+
+test('non-matching directories and files are ignored', () => {
+  withScratchRoot((root) => {
+    fs.mkdirSync(path.join(root, 'unrelated-directory'));
+    fs.writeFileSync(path.join(root, 'agent-device-test-run-4242-loose-file'), '');
+    const leaks = findLeakedRunDirectories(root, () => false);
+    assert.deepEqual(leaks, []);
+  });
+});

scripts/check-tmpdir-leaks-model.ts

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import { TEST_RUN_TMP_PREFIX } from './vitest-tmpdir-global-setup.ts';
+
+const PID_SUFFIX = new RegExp(`^${TEST_RUN_TMP_PREFIX}(\\d+)-`);
+
+export function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM means the pid exists but we lack permission to signal it — still alive.
+    return (error as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}
+
+/**
+ * Directories owned by a still-running process are a concurrent vitest run
+ * (e.g. another worktree), not a leak — only report the ones whose owning
+ * process has already exited without cleaning up after itself.
+ */
+export function findLeakedRunDirectories(
+  root: string,
+  isAlive: (pid: number) => boolean = isProcessAlive,
+): string[] {
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith(TEST_RUN_TMP_PREFIX))
+    .filter((entry) => {
+      const match = PID_SUFFIX.exec(entry.name);
+      // No parseable pid means it didn't come from setup() as written — treat it as a leak.
+      if (!match) return true;
+      return !isAlive(Number(match[1]));
+    })
+    .map((entry) => entry.name);
+}

scripts/check-tmpdir-leaks.ts

@@ -1,29 +1,27 @@
-// Fails if any agent-device-test-run-* directory remains under
-// TEST_RUN_TMP_ROOT after the unit suite finishes. scripts/vitest-tmpdir-global-setup.ts
-// creates exactly one such directory per `vitest run` invocation and removes
-// it in its globalTeardown; a leftover one means that invocation's process
-// was killed (crash, OOM, timeout) before teardown could run. Run this after
-// `pnpm test:unit`, not concurrently with it.
+// Fails if any agent-device-test-run-* directory under TEST_RUN_TMP_ROOT is
+// abandoned — its owning process has exited without running its
+// globalTeardown (crash, OOM, timeout kill). Directories owned by a still-
+// running process are left alone: a concurrent `vitest run` in another
+// worktree keeps its own directory present until its own teardown, which is
+// not a leak. See check-tmpdir-leaks-model.ts for the liveness check.
 //
 // Only covers vitest runs. node --test lanes (test:smoke,
 // test:integration:node, ...) still use the real os.tmpdir() unredirected.
 
-import fs from 'node:fs';
 import path from 'node:path';
-import { TEST_RUN_TMP_PREFIX, TEST_RUN_TMP_ROOT } from './vitest-tmpdir-global-setup.ts';
+import { findLeakedRunDirectories } from './check-tmpdir-leaks-model.ts';
+import { TEST_RUN_TMP_ROOT } from './vitest-tmpdir-global-setup.ts';
 
-const leaks = fs
-  .readdirSync(TEST_RUN_TMP_ROOT, { withFileTypes: true })
-  .filter((entry) => entry.isDirectory() && entry.name.startsWith(TEST_RUN_TMP_PREFIX));
+const leaks = findLeakedRunDirectories(TEST_RUN_TMP_ROOT);
 
 if (leaks.length > 0) {
-  const details = leaks.map((entry) => `- ${path.join(TEST_RUN_TMP_ROOT, entry.name)}`).join('\n');
+  const details = leaks.map((name) => `- ${path.join(TEST_RUN_TMP_ROOT, name)}`).join('\n');
   throw new Error(
-    `Found ${leaks.length} leftover ${TEST_RUN_TMP_PREFIX}* director${leaks.length === 1 ? 'y' : 'ies'} in ${TEST_RUN_TMP_ROOT}:\n${details}\n` +
-      'A vitest run was killed before its globalTeardown could run; investigate the run that produced them.',
+    `Found ${leaks.length} abandoned agent-device-test-run-* director${leaks.length === 1 ? 'y' : 'ies'} in ${TEST_RUN_TMP_ROOT}:\n${details}\n` +
+      'Their owning process has already exited, so their globalTeardown never ran (crash, OOM, timeout kill); investigate the run that produced them.',
   );
 }
 
 process.stdout.write(
-  `No leaked ${TEST_RUN_TMP_PREFIX}* directories found in ${TEST_RUN_TMP_ROOT}.\n`,
+  `No abandoned agent-device-test-run-* directories found in ${TEST_RUN_TMP_ROOT}.\n`,
 );

scripts/vitest-tmpdir-global-setup.ts

@@ -26,7 +26,13 @@ export const TEST_RUN_TMP_PREFIX = 'agent-device-test-run-';
 let testRunTmpDir: string;
 
 export function setup(): void {
-  testRunTmpDir = fs.mkdtempSync(path.join(TEST_RUN_TMP_ROOT, TEST_RUN_TMP_PREFIX));
+  // The pid is embedded so check-tmpdir-leaks.ts can tell a directory that's
+  // still in active use (its vitest process is alive — a concurrent run in
+  // another worktree, say) apart from one actually abandoned by a killed
+  // process; the trailing mkdtemp suffix still guards against same-pid reuse.
+  testRunTmpDir = fs.mkdtempSync(
+    path.join(TEST_RUN_TMP_ROOT, `${TEST_RUN_TMP_PREFIX}${process.pid}-`),
+  );
   process.env.TMPDIR = testRunTmpDir;
 }