claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/lib/__tests__/projectBriefCore.test.cjs

@@ -1,216 +0,0 @@
-// projectBriefCore.cjs — pure logic for the Brief backend (PRD 837).
-// vitest globals (test/beforeEach/afterEach) — same convention as the other .cjs tests.
-const assert = require('node:assert/strict');
-const {
-  computeDrift,
-  buildSources,
-  buildSynthesisPrompt,
-  validateBriefShape,
-  applyPinEnforcement,
-  buildPersistedBrief,
-  computeSetPin,
-  computeUpdate,
-} = require('../projectBriefCore.cjs');
-
-test('computeDrift: true only when mtime strictly newer than synthesizedAt', () => {
-  assert.equal(computeDrift(200, 100), true);
-  assert.equal(computeDrift(100, 200), false);
-  assert.equal(computeDrift(100, 100), false);
-  assert.equal(computeDrift(null, 100), false);
-  assert.equal(computeDrift(200, null), false);
-});
-
-test('buildSources: omits null sources, computes drift per source', () => {
-  const synthesizedAt = new Date(1_000_000).toISOString();
-  const sources = buildSources({
-    synthesizedAt,
-    claudeMd: { detail: '40 lines', mtimeMs: 500_000 },
-    epics: { detail: '2 active · 1 archived', mtimeMs: 2_000_000 },
-    sessions: null,
-    git: { detail: '12 commits', mtimeMs: 900_000 },
-  });
-  assert.equal(sources.length, 3);
-  const byLabel = Object.fromEntries(sources.map((s) => [s.label, s]));
-  assert.equal(byLabel['CLAUDE.md'].drift, false);
-  assert.equal(byLabel['Epics'].drift, true);
-  assert.equal(byLabel['Git'].drift, false);
-  assert.equal(byLabel['Sessions'], undefined);
-});
-
-test('buildSources: no synthesizedAt yet means nothing drifts', () => {
-  const sources = buildSources({
-    synthesizedAt: null,
-    claudeMd: { detail: '1 line', mtimeMs: 999 },
-    epics: null,
-    sessions: null,
-    git: null,
-  });
-  assert.equal(sources[0].drift, false);
-});
-
-test('buildSynthesisPrompt includes CLAUDE.md, epics, git log, tree, and pinned block instruction', () => {
-  const prompt = buildSynthesisPrompt({
-    claudeMdText: '# Project X',
-    epics: [{ status: 'active', tag: 'feature', goalText: 'Ship the thing' }],
-    gitLogLines: ['abc123 fix bug'],
-    srcTree: 'src/\n  main/\n  renderer/',
-    pinnedBlocks: { conventions: ['Never use shell:true'] },
-  });
-  assert.match(prompt, /# Project X/);
-  assert.match(prompt, /Ship the thing/);
-  assert.match(prompt, /abc123 fix bug/);
-  assert.match(prompt, /src\/\n  main\//);
-  assert.match(prompt, /PINNED BLOCK "conventions"/);
-  assert.match(prompt, /Never use shell:true/);
-  assert.doesNotMatch(prompt, /PINNED BLOCK "what"/);
-});
-
-test('validateBriefShape: accepts a well-formed object, rejects malformed ones', () => {
-  const good = { purpose: 'x', what: [], areas: [], scope: [], conventions: [] };
-  assert.deepEqual(validateBriefShape(good), { ok: true, error: null });
-  assert.equal(validateBriefShape(null).ok, false);
-  assert.equal(validateBriefShape({ ...good, purpose: '' }).ok, false);
-  assert.equal(validateBriefShape({ ...good, what: 'not an array' }).ok, false);
-  assert.equal(validateBriefShape({ ...good, areas: undefined }).ok, false);
-});
-
-test('applyPinEnforcement: overwrites a pinned block with the frozen copy, carries pins/pinned forward', () => {
-  const raw = { purpose: 'p', what: ['fresh what'], areas: [], scope: [], conventions: ['fresh conventions'] };
-  const priorPins = { what: false, conventions: true };
-  const priorPinned = { what: null, conventions: ['frozen conventions'] };
-  const merged = applyPinEnforcement(raw, priorPins, priorPinned);
-  assert.deepEqual(merged.what, ['fresh what']);
-  assert.deepEqual(merged.conventions, ['frozen conventions']);
-  assert.deepEqual(merged.pins, priorPins);
-  assert.deepEqual(merged.pinned, priorPinned);
-});
-
-test('applyPinEnforcement: unpinned brief passes model output through untouched', () => {
-  const raw = { purpose: 'p', what: ['fresh'], areas: [], scope: [], conventions: ['fresh'] };
-  const merged = applyPinEnforcement(raw, null, null);
-  assert.deepEqual(merged.what, ['fresh']);
-  assert.deepEqual(merged.conventions, ['fresh']);
-  assert.deepEqual(merged.pins, { what: false, conventions: false });
-});
-
-test('buildPersistedBrief stamps version/synthesizedAt/model and enforces pins', () => {
-  const raw = { purpose: 'p', what: ['fresh'], areas: [{ name: 'a', files: 1, note: '', epic: null, heat: 0.1 }], scope: [], conventions: ['fresh'] };
-  const persisted = buildPersistedBrief({
-    rawBrief: raw,
-    priorPins: { what: true, conventions: false },
-    priorPinned: { what: ['frozen what'], conventions: null },
-    model: 'claude-sonnet-5',
-    nowIso: '2026-07-31T00:00:00.000Z',
-  });
-  assert.equal(persisted.version, 1);
-  assert.equal(persisted.synthesizedAt, '2026-07-31T00:00:00.000Z');
-  assert.equal(persisted.model, 'claude-sonnet-5');
-  assert.deepEqual(persisted.what, ['frozen what']);
-  assert.deepEqual(persisted.conventions, ['fresh']);
-  assert.deepEqual(persisted.areas, raw.areas);
-});
-
-test('computeSetPin: errors when there is no brief yet', () => {
-  const res = computeSetPin(null, 'what', true);
-  assert.equal(res.ok, false);
-});
-
-test('computeSetPin: errors on an unpinnable block', () => {
-  const brief = { purpose: 'p', what: [], areas: [], scope: [], conventions: [], pins: {}, pinned: {} };
-  const res = computeSetPin(brief, 'areas', true);
-  assert.equal(res.ok, false);
-});
-
-test('computeSetPin: pinning freezes current block content, unpinning clears it', () => {
-  const brief = {
-    purpose: 'p',
-    what: ['a', 'b'],
-    areas: [],
-    scope: [],
-    conventions: ['c1'],
-    pins: { what: false, conventions: false },
-    pinned: { what: null, conventions: null },
-  };
-  const pinned = computeSetPin(brief, 'what', true);
-  assert.equal(pinned.ok, true);
-  assert.equal(pinned.brief.pins.what, true);
-  assert.deepEqual(pinned.brief.pinned.what, ['a', 'b']);
-
-  const unpinned = computeSetPin(pinned.brief, 'what', false);
-  assert.equal(unpinned.ok, true);
-  assert.equal(unpinned.brief.pins.what, false);
-  assert.equal(unpinned.brief.pinned.what, null);
-});
-
-// ── computeUpdate: the hand-edit ("maintain") path ────────────────────────
-function baseBrief() {
-  return {
-    version: 1,
-    synthesizedAt: '2026-07-31T00:00:00.000Z',
-    editedAt: null,
-    model: 'sonnet',
-    purpose: 'p',
-    what: ['a'],
-    areas: [{ name: 'x', files: 1, note: '', epic: null, heat: 0.1 }],
-    scope: [],
-    conventions: ['c1'],
-    pins: { what: false, conventions: false },
-    pinned: { what: null, conventions: null },
-  };
-}
-
-test('computeUpdate: errors when there is no brief yet', () => {
-  const res = computeUpdate(null, { what: ['x'] }, '2026-08-01T00:00:00.000Z');
-  assert.equal(res.ok, false);
-  assert.match(res.error, /generate one first/);
-});
-
-test('computeUpdate: rejects an empty patch and non-editable fields', () => {
-  assert.equal(computeUpdate(baseBrief(), {}, 'NOW').ok, false);
-  const res = computeUpdate(baseBrief(), { model: 'opus' }, 'NOW');
-  assert.equal(res.ok, false);
-  assert.match(res.error, /not editable: model/);
-});
-
-test('computeUpdate: rejects field shapes the renderer could not render', () => {
-  assert.equal(computeUpdate(baseBrief(), { purpose: '   ' }, 'NOW').ok, false);
-  assert.equal(computeUpdate(baseBrief(), { what: 'not an array' }, 'NOW').ok, false);
-  assert.equal(computeUpdate(baseBrief(), { conventions: [1, 2] }, 'NOW').ok, false);
-  assert.equal(computeUpdate(baseBrief(), { areas: ['nope'] }, 'NOW').ok, false);
-});
-
-test('computeUpdate: applies the patch, stamps editedAt, leaves other fields alone', () => {
-  const before = baseBrief();
-  const res = computeUpdate(before, { purpose: 'sharper' }, '2026-08-01T00:00:00.000Z');
-  assert.equal(res.ok, true);
-  assert.equal(res.brief.purpose, 'sharper');
-  assert.equal(res.brief.editedAt, '2026-08-01T00:00:00.000Z');
-  assert.deepEqual(res.brief.what, ['a']);
-  assert.equal(res.brief.synthesizedAt, before.synthesizedAt);
-  // purpose is not pinnable — a refresh legitimately re-derives it.
-  assert.equal(res.brief.pins.what, false);
-});
-
-test('computeUpdate: editing a pinnable block auto-pins it with the edited content', () => {
-  const res = computeUpdate(baseBrief(), { what: ['edited one', 'edited two'] }, 'NOW');
-  assert.equal(res.ok, true);
-  assert.equal(res.brief.pins.what, true);
-  assert.deepEqual(res.brief.pinned.what, ['edited one', 'edited two']);
-  assert.equal(res.brief.pins.conventions, false);
-  assert.equal(res.brief.pinned.conventions, null);
-});
-
-test('computeUpdate: an edited block survives the next synthesis via pin enforcement', () => {
-  const edited = computeUpdate(baseBrief(), { conventions: ['hand-written rule'] }, 'NOW').brief;
-  const persisted = buildPersistedBrief({
-    rawBrief: { purpose: 'new', what: ['fresh'], areas: [], scope: [], conventions: ['model rewrote it'] },
-    priorPins: edited.pins,
-    priorPinned: edited.pinned,
-    model: 'sonnet',
-    nowIso: '2026-08-02T00:00:00.000Z',
-    priorEditedAt: edited.editedAt,
-  });
-  assert.deepEqual(persisted.conventions, ['hand-written rule']);
-  assert.deepEqual(persisted.what, ['fresh']);
-  assert.equal(persisted.editedAt, 'NOW');
-});

package/src/main/lib/__tests__/projectRootResolve.test.cjs

@@ -1,148 +0,0 @@
-/**
- * projectRootResolve.test.cjs — resolveProjectContext (PRD: worktree-cwd
- * Epic-lookup hazard). Exercises the resolver purely in-process with injected
- * deps (no Electron, no real git worktrees) — see prdCreate.test.cjs for the
- * end-to-end fixture reproducing the live starry-night-ships shape.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/projectRootResolve.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const { resolveProjectContext } = require('../projectRootResolve.cjs');
-
-function makeDeps({ projectRootOfImpl, allCwds = [], indexes = {}, ephemeral = [] } = {}) {
-  return {
-    projectRootOf: projectRootOfImpl || ((p) => p),
-    allProjectCwds: () => allCwds,
-    readActiveIndex: (cwd) => ({ sessions: indexes[cwd] || {}, events: {} }),
-    isEphemeralCwd: (cwd) => ephemeral.includes(cwd),
-    warn: vi.fn(),
-  };
-}
-
-test('a plain project root (no worktree, no ops-internal segment) is returned unchanged', () => {
-  const deps = makeDeps();
-  const result = resolveProjectContext({ cwd: '/home/bilko/Projects/some-app' }, deps);
-  expect(result).toEqual({ cwd: '/home/bilko/Projects/some-app', epicId: null, epicCwd: null, source: 'cwd' });
-});
-
-test('a worktree cwd normalizes to the main tree', () => {
-  const deps = makeDeps({
-    projectRootOfImpl: (p) => (p.startsWith('/tmp/worktree') ? '/home/bilko/Projects/starry-night-ships' : p),
-  });
-  const result = resolveProjectContext({ cwd: '/tmp/worktree/abc/epic-1' }, deps);
-  expect(result.cwd).toBe('/home/bilko/Projects/starry-night-ships');
-  expect(result.source).toBe('cwd');
-});
-
-test('an ops-internal cwd normalizes to the project root', () => {
-  const deps = makeDeps({
-    projectRootOfImpl: (p) => (p.includes('session-manager-operations') ? '/home/bilko/Projects/foo' : p),
-  });
-  const result = resolveProjectContext({ cwd: '/home/bilko/Projects/foo/session-manager-operations/scheduler/state' }, deps);
-  expect(result.cwd).toBe('/home/bilko/Projects/foo');
-});
-
-test('Epic found in the normalized cwd\'s own active-index — source epic-index', () => {
-  const deps = makeDeps({
-    indexes: {
-      '/home/bilko/Projects/foo': { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', status: 'active' } },
-    },
-  });
-  const result = resolveProjectContext({ cwd: '/home/bilko/Projects/foo', originClaudeSessionId: 'sess-1' }, deps);
-  expect(result).toEqual({ cwd: '/home/bilko/Projects/foo', epicId: 'epic-1', epicCwd: '/home/bilko/Projects/foo', source: 'epic-index' });
-});
-
-test('Epic found only via cross-project scan — epicCwd wins over the supplied cwd', () => {
-  const deps = makeDeps({
-    allCwds: ['/home/bilko/Projects/foo', '/home/bilko/Projects/bar'],
-    indexes: {
-      '/home/bilko/Projects/bar': { 'epic-2': { id: 'epic-2', claudeSessionId: 'sess-2', status: 'active' } },
-    },
-  });
-  const result = resolveProjectContext({ cwd: '/home/bilko/Projects/foo', originClaudeSessionId: 'sess-2' }, deps);
-  expect(result.epicId).toBe('epic-2');
-  expect(result.epicCwd).toBe('/home/bilko/Projects/bar');
-  expect(result.cwd).toBe('/home/bilko/Projects/bar');
-  expect(result.source).toBe('cross-project-scan');
-});
-
-test('no match anywhere → epicId null, cwd unchanged', () => {
-  const deps = makeDeps({ allCwds: ['/home/bilko/Projects/foo'] });
-  const result = resolveProjectContext({ cwd: '/home/bilko/Projects/foo', originClaudeSessionId: 'sess-unknown' }, deps);
-  expect(result).toEqual({ cwd: '/home/bilko/Projects/foo', epicId: null, epicCwd: null, source: 'cwd' });
-});
-
-test('explicit epicId (sourcePromptId) resolves cwd when no cwd was supplied at all', () => {
-  const deps = makeDeps({
-    allCwds: ['/home/bilko/Projects/foo'],
-    indexes: {
-      '/home/bilko/Projects/foo': { 'epic-3': { id: 'epic-3', claudeSessionId: 'sess-3', status: 'proposed' } },
-    },
-  });
-  const result = resolveProjectContext({ epicId: 'epic-3' }, deps);
-  expect(result.cwd).toBe('/home/bilko/Projects/foo');
-  expect(result.epicId).toBe('epic-3');
-});
-
-test('duplicate claudeSessionId across two projects: prefers the non-ephemeral, status=active row and warns naming both', () => {
-  const deps = makeDeps({
-    allCwds: ['/tmp/session-manager-epic-worktrees/abc/epic-1', '/home/bilko/Projects/starry-night-ships'],
-    indexes: {
-      '/tmp/session-manager-epic-worktrees/abc/epic-1': {
-        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-dup', status: 'proposed' },
-      },
-      '/home/bilko/Projects/starry-night-ships': {
-        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-dup', status: 'active' },
-      },
-    },
-    ephemeral: ['/tmp/session-manager-epic-worktrees/abc/epic-1'],
-  });
-  const result = resolveProjectContext({ originClaudeSessionId: 'sess-dup' }, deps);
-  expect(result.epicCwd).toBe('/home/bilko/Projects/starry-night-ships');
-  expect(result.source).toBe('cross-project-scan');
-  expect(deps.warn).toHaveBeenCalledTimes(1);
-  const warnMsg = deps.warn.mock.calls[0][0];
-  expect(warnMsg).toContain('/tmp/session-manager-epic-worktrees/abc/epic-1');
-  expect(warnMsg).toContain('/home/bilko/Projects/starry-night-ships');
-});
-
-test('an originProjectRoot hint outranks the supplied cwd, but a resolved Epic still outranks the hint', () => {
-  const deps = makeDeps({
-    indexes: {
-      '/home/bilko/Projects/hinted': { 'epic-4': { id: 'epic-4', claudeSessionId: 'sess-4', status: 'active' } },
-    },
-  });
-  const noEpic = resolveProjectContext({ cwd: '/home/bilko/Projects/guessed', originProjectRoot: '/home/bilko/Projects/hinted' }, deps);
-  expect(noEpic.cwd).toBe('/home/bilko/Projects/hinted');
-
-  const withEpic = resolveProjectContext(
-    { cwd: '/home/bilko/Projects/guessed', originProjectRoot: '/home/bilko/Projects/hinted', originClaudeSessionId: 'sess-4' },
-    deps,
-  );
-  expect(withEpic.cwd).toBe('/home/bilko/Projects/hinted');
-  expect(withEpic.epicId).toBe('epic-4');
-});
-
-test('never throws on missing cwd/originClaudeSessionId/epicId — returns an all-null result', () => {
-  const deps = makeDeps();
-  expect(resolveProjectContext({}, deps)).toEqual({ cwd: null, epicId: null, epicCwd: null, source: 'cwd' });
-  expect(resolveProjectContext(undefined, deps)).toEqual({ cwd: null, epicId: null, epicCwd: null, source: 'cwd' });
-});
-
-test('bounded: reads each candidate project\'s active-index exactly once per call', () => {
-  const readActiveIndex = vi.fn((cwd) => ({ sessions: {}, events: {} }));
-  const deps = {
-    projectRootOf: (p) => p,
-    allProjectCwds: () => ['/home/bilko/Projects/a', '/home/bilko/Projects/b', '/home/bilko/Projects/c'],
-    readActiveIndex,
-    isEphemeralCwd: () => false,
-    warn: vi.fn(),
-  };
-  resolveProjectContext({ cwd: '/home/bilko/Projects/a', originClaudeSessionId: 'sess-x' }, deps);
-  expect(readActiveIndex).toHaveBeenCalledTimes(3);
-  const calledCwds = readActiveIndex.mock.calls.map((c) => c[0]);
-  expect(new Set(calledCwds).size).toBe(3);
-});

package/src/main/lib/__tests__/queueHealth.test.cjs

@@ -1,58 +0,0 @@
-/**
- * queueHealth.test.cjs — computeQueueHealth: the pure per-project rollup
- * behind the periodic queue-health sweep (PRD 1109).
- *
- * Pure helper, no electron import — mirrors reaperHelpers.test.cjs's pattern
- * so it never needs scheduler.cjs's mocked IPC surface.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/queueHealth.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { computeQueueHealth } = require('../queueHealth.cjs');
-
-test('counts never_ran, looksDone, and stuck per project cwd', () => {
-  const jobs = [
-    { slug: 'a', cwd: '/proj-1', status: 'failed', gateOutcome: 'never_ran' },
-    { slug: 'b', cwd: '/proj-1', status: 'failed', looksDone: { commits: ['abc1234'] } },
-    { slug: 'c', cwd: '/proj-1', status: 'needs_review' },
-    { slug: 'd', cwd: '/proj-2', status: 'quarantined' },
-  ];
-  const rollup = computeQueueHealth(jobs);
-  const byProj = Object.fromEntries(rollup.map((r) => [r.cwd, r]));
-  assert.deepStrictEqual(byProj['/proj-1'], { cwd: '/proj-1', neverRan: 1, looksDone: 1, stuck: 1 });
-  assert.deepStrictEqual(byProj['/proj-2'], { cwd: '/proj-2', neverRan: 0, looksDone: 0, stuck: 1 });
-});
-
-test('a project with zero drift across all three counters is omitted entirely', () => {
-  const jobs = [
-    { slug: 'clean', cwd: '/proj-clean', status: 'completed' },
-    { slug: 'running', cwd: '/proj-clean', status: 'running' },
-    { slug: 'pending', cwd: '/proj-clean', status: 'pending' },
-  ];
-  assert.deepStrictEqual(computeQueueHealth(jobs), []);
-});
-
-test('gateOutcome values other than never_ran do not count', () => {
-  const jobs = [
-    { slug: 'a', cwd: '/proj', status: 'completed', gateOutcome: 'passed' },
-    { slug: 'b', cwd: '/proj', status: 'failed', gateOutcome: 'failed' },
-    { slug: 'c', cwd: '/proj', status: 'failed', gateOutcome: 'unknown' },
-  ];
-  assert.deepStrictEqual(computeQueueHealth(jobs), []);
-});
-
-test('empty/missing jobs array is handled without throwing', () => {
-  assert.deepStrictEqual(computeQueueHealth([]), []);
-  assert.deepStrictEqual(computeQueueHealth(undefined), []);
-});
-
-test('is a pure read: never mutates the input jobs array or its rows', () => {
-  const jobs = [{ slug: 'a', cwd: '/proj', status: 'needs_review', gateOutcome: 'never_ran' }];
-  const snapshot = JSON.parse(JSON.stringify(jobs));
-  computeQueueHealth(jobs);
-  assert.deepStrictEqual(jobs, snapshot);
-});

package/src/main/lib/__tests__/queueStoreAtomicWrite.test.cjs

@@ -1,88 +0,0 @@
-/**
- * queueStoreAtomicWrite.test.cjs — regression test for the tmp-path collision
- * that tore `scheduler-machine.json` four times (`.corrupt-*` Sep 7/10/11,
- * plus a `.bak-*`). The old `writeJsonAtomic`/`writeJsonAtomicSync` used
- * `${file}.tmp-${process.pid}` — keyed on PID ONLY, so two overlapping writes
- * inside the SAME process shared one tmp path. A long write mid-flight gets
- * clobbered by a short write's O_TRUNC open on the same tmp file, and the
- * short write's remaining buffered bytes land past the short write's own
- * EOF; `rename()` is atomic, but the shared tmp file underneath it never was
- * — the publish carries the interleaved bytes.
- *
- * This drives two REAL concurrent async writes (one large enough that
- * Node's fs writeFile chunks it — see WRITE_CHUNK_BYTES below — so the two
- * calls' internal awaits actually interleave on the event loop) against the
- * same target path, and asserts the result is one clean payload with no
- * trailing bytes. Confirmed by hand against the pre-fix pid-only tmp name
- * (reverting just the tmp-path line): this test fails there — the read
- * either doesn't parse or parses to neither payload — and passes against the
- * unique-per-call tmp name shipped in this commit.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/queueStoreAtomicWrite.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { writeJsonAtomic } = require('../queueStore.cjs');
-
-// Node's fs.promises writeFile-style chunking writes large buffers in ~512KB
-// pieces, awaiting each one — large enough here to guarantee the short
-// write's open+truncate+write+rename lands in the middle of the long write's
-// remaining chunks when raced with Promise.all.
-const LONG_PAYLOAD = { kind: 'long', blob: 'A'.repeat(4 * 1024 * 1024) };
-const SHORT_PAYLOAD = { kind: 'short' };
-
-const tmpDirs = [];
-
-afterEach(async () => {
-  while (tmpDirs.length) {
-    await fsp.rm(tmpDirs.pop(), { recursive: true, force: true }).catch(() => {});
-  }
-});
-
-test('two concurrent writeJsonAtomic calls against the same path never interleave', async () => {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'queueStore-atomic-'));
-  tmpDirs.push(dir);
-  const target = path.join(dir, 'race-target.json');
-
-  // Repeat a handful of times — the race is timing-dependent, and this
-  // guards against a lucky single run masking a reintroduced bug.
-  for (let attempt = 0; attempt < 5; attempt++) {
-    await Promise.all([
-      writeJsonAtomic(target, LONG_PAYLOAD),
-      writeJsonAtomic(target, SHORT_PAYLOAD),
-    ]);
-
-    const raw = fs.readFileSync(target, 'utf8');
-    const parsed = JSON.parse(raw); // throws if the file is torn — that alone is a failure
-    const matchesLong = JSON.stringify(parsed) === JSON.stringify(LONG_PAYLOAD);
-    const matchesShort = JSON.stringify(parsed) === JSON.stringify(SHORT_PAYLOAD);
-    expect(matchesLong || matchesShort).toBe(true);
-
-    // No trailing bytes beyond the serialized payload (the exact shape of
-    // the real corruption: a complete object followed by an orphaned tail).
-    const expected = JSON.stringify(parsed, null, 2);
-    expect(raw).toBe(expected);
-  }
-});
-
-test('a failed write never leaves a stray .tmp-* file behind', async () => {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'queueStore-atomic-fail-'));
-  tmpDirs.push(dir);
-  const target = path.join(dir, 'target.json');
-  // Target is a directory, not a file — mkdir + open + write all succeed,
-  // but the final rename() onto an existing directory fails with EISDIR,
-  // exercising the unlink-the-tmp-on-error path specifically (not just a
-  // trivial pre-write failure).
-  fs.mkdirSync(target);
-
-  await expect(writeJsonAtomic(target, { a: 1 })).rejects.toThrow();
-
-  const leftovers = fs.readdirSync(dir).filter((f) => f.includes('.tmp-'));
-  expect(leftovers).toEqual([]);
-});