claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-blocked-by-foreign-wip.test.cjs

@@ -1,107 +0,0 @@
-/**
- * scheduler-blocked-by-foreign-wip.test.cjs — validateForeignWipBlockClaim
- * (the manifest-membership check that stops an executor from laundering a
- * real regression into a BLOCKED_BY_FOREIGN_WIP verdict) and
- * requeueForeignWipBlockedJobs (reconcile()'s auto-clear-and-resume pass).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-blocked-by-foreign-wip.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  validateForeignWipBlockClaim,
-  requeueForeignWipBlockedJobs,
-  FOREIGN_WIP_BLOCK_STREAK_LIMIT,
-} = require('../scheduler.cjs');
-
-// ─── validateForeignWipBlockClaim ──────────────────────────────────────────
-
-test('validateForeignWipBlockClaim: ok when every claimed path is in preRunDirtyPaths', () => {
-  const job = { preRunDirtyPaths: ['src/a.ts', 'src/b.ts'] };
-  const v = validateForeignWipBlockClaim(['src/a.ts'], job);
-  expect(v.ok).toBe(true);
-  expect(v.validPaths).toEqual(['src/a.ts']);
-  expect(v.invalidPaths).toEqual([]);
-});
-
-test('validateForeignWipBlockClaim: ok when every claimed path is in carriedPaths', () => {
-  const job = { carriedPaths: ['config/settings.json'] };
-  const v = validateForeignWipBlockClaim(['config/settings.json'], job);
-  expect(v.ok).toBe(true);
-  expect(v.validPaths).toEqual(['config/settings.json']);
-});
-
-test('validateForeignWipBlockClaim: rejects an unlisted path — the launder-a-regression case', () => {
-  // The job's real, disclosed foreign-WIP manifest never mentioned this path
-  // — an executor naming it anyway must not get away with claiming a block.
-  const job = { preRunDirtyPaths: ['src/a.ts'] };
-  const v = validateForeignWipBlockClaim(['src/a.ts', 'src/my-own-broken-file.ts'], job);
-  expect(v.ok).toBe(false);
-  expect(v.validPaths).toEqual(['src/a.ts']);
-  expect(v.invalidPaths).toEqual(['src/my-own-broken-file.ts']);
-});
-
-test('validateForeignWipBlockClaim: rejects a claim naming ONLY an unlisted path', () => {
-  const job = { preRunDirtyPaths: ['src/a.ts'] };
-  const v = validateForeignWipBlockClaim(['src/totally-unrelated.ts'], job);
-  expect(v.ok).toBe(false);
-  expect(v.invalidPaths).toEqual(['src/totally-unrelated.ts']);
-});
-
-test('validateForeignWipBlockClaim: rejects an empty claim (no evidence at all)', () => {
-  const job = { preRunDirtyPaths: ['src/a.ts'] };
-  expect(validateForeignWipBlockClaim([], job).ok).toBe(false);
-  expect(validateForeignWipBlockClaim(null, job).ok).toBe(false);
-});
-
-test('validateForeignWipBlockClaim: rejects against an empty/missing manifest', () => {
-  expect(validateForeignWipBlockClaim(['src/a.ts'], {}).ok).toBe(false);
-  expect(validateForeignWipBlockClaim(['src/a.ts'], null).ok).toBe(false);
-});
-
-// ─── requeueForeignWipBlockedJobs ──────────────────────────────────────────
-
-test('requeueForeignWipBlockedJobs: promotes skipped/blocked job to pending once its paths are clean', async () => {
-  const job = {
-    slug: '10-foo', status: 'skipped', cwd: '/repo', blockedByForeignWip: true,
-    foreignWipBlockedPaths: ['src/a.ts'], statusHistory: [],
-  };
-  await requeueForeignWipBlockedJobs([job], { getDirtyPaths: async () => [] });
-  expect(job.status).toBe('pending');
-  expect(job.blockedByForeignWip).toBeUndefined();
-  expect(job.foreignWipBlockedPaths).toBeUndefined();
-});
-
-test('requeueForeignWipBlockedJobs: leaves the job parked while any blocked path is still dirty', async () => {
-  const job = {
-    slug: '10-foo', status: 'skipped', cwd: '/repo', blockedByForeignWip: true,
-    foreignWipBlockedPaths: ['src/a.ts', 'src/b.ts'], statusHistory: [],
-  };
-  await requeueForeignWipBlockedJobs([job], { getDirtyPaths: async () => ['src/a.ts'] });
-  expect(job.status).toBe('skipped');
-  expect(job.blockedByForeignWip).toBe(true);
-});
-
-test('requeueForeignWipBlockedJobs: ignores jobs not in the blocked-skipped shape', async () => {
-  const skippedNotBlocked = { slug: '1', status: 'skipped', cwd: '/repo', statusHistory: [] };
-  const runningBlocked = { slug: '2', status: 'running', cwd: '/repo', blockedByForeignWip: true, foreignWipBlockedPaths: ['x'], statusHistory: [] };
-  const getDirtyPaths = async () => [];
-  await requeueForeignWipBlockedJobs([skippedNotBlocked, runningBlocked], { getDirtyPaths });
-  expect(skippedNotBlocked.status).toBe('skipped');
-  expect(runningBlocked.status).toBe('running');
-});
-
-test('requeueForeignWipBlockedJobs: leaves the row alone when the cwd is not a git repo (getDirtyPaths → null)', async () => {
-  const job = {
-    slug: '10-foo', status: 'skipped', cwd: '/not-a-repo', blockedByForeignWip: true,
-    foreignWipBlockedPaths: ['src/a.ts'], statusHistory: [],
-  };
-  await requeueForeignWipBlockedJobs([job], { getDirtyPaths: async () => null });
-  expect(job.status).toBe('skipped');
-});
-
-test('FOREIGN_WIP_BLOCK_STREAK_LIMIT is 3', () => {
-  expect(FOREIGN_WIP_BLOCK_STREAK_LIMIT).toBe(3);
-});

package/src/main/__tests__/scheduler-boot-orphans.test.cjs

@@ -1,153 +0,0 @@
-/**
- * scheduler-boot-orphans.test.cjs — boot-time reconciliation of 'running' jobs
- * left behind by an app crash/restart (PRD 686: consolidated in from the
- * external watchdog's reconcileQueueOffline(), which is now deleted from
- * src/main/lib/watchdogHelpers.cjs).
- *
- * Covers:
- *   - a proven-alive row is ADOPTED (left running, never signalled) and only
- *     proven-dead / exited rows are finalized (partitionBootOrphans)
- *   - the ORPHAN_REQUEUE_CAP re-queue/exhaustion boundary (applyOrphanOutcome)
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-boot-orphans.test.cjs
- */
-
-'use strict';
-
-const { spawn } = require('node:child_process');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const {
-  writeSupervisorRecord,
-} = require('../lib/jobSupervisorRecord.cjs');
-const {
-  partitionBootOrphans,
-  applyOrphanOutcome,
-} = require('../scheduler.cjs');
-const { ORPHAN_REQUEUE_CAP } = require('../lib/reaperHelpers.cjs');
-
-function spawnStub() {
-  return spawn(process.execPath, ['-e', 'setTimeout(() => {}, 30000)'], { stdio: 'ignore' });
-}
-
-function withRunsDir(fn) {
-  const runsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sched-boot-runs-'));
-  try { return fn(runsDir); } finally { fs.rmSync(runsDir, { recursive: true, force: true }); }
-}
-
-test('a running row with a live pid survives boot untouched — adopted, no kill issued', () => {
-  const child = spawnStub();
-  const killSpy = vi.spyOn(process, 'kill');
-  try {
-    const jobs = [{ slug: 'alive-orphan', status: 'running', runtime: { pid: child.pid } }];
-    const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: (pid) => pid === child.pid, runsDir: os.tmpdir() });
-    assert.deepEqual(adopted, ['alive-orphan']);
-    assert.deepEqual(immediate, []);
-    assert.equal(killSpy.mock.calls.length, 0, 'boot classification must never signal an executor');
-    assert.equal(jobs[0].status, 'running', 'the row must not transition');
-  } finally {
-    killSpy.mockRestore();
-    child.kill();
-  }
-});
-
-test('a dead-pid row and a pidless row with no liveness evidence are finalized', () => {
-  const jobs = [
-    { slug: 'dead-orphan', status: 'running', runtime: { pid: 222 } },
-    { slug: 'no-pid-orphan', status: 'running', runtime: {} },
-    { slug: 'not-running', status: 'pending' },
-  ];
-  const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: () => false, runsDir: os.tmpdir() });
-  assert.deepEqual(immediate.sort(), ['dead-orphan', 'no-pid-orphan']);
-  assert.deepEqual(adopted, []);
-});
-
-test('a pidless row is adopted on any one of the reaper liveness signals', () => {
-  const job = () => ({ slug: 'p', status: 'running', runtime: {} });
-  const base = { pidAlive: (pid) => pid === 77, runsDir: os.tmpdir(), now: 1_000_000 };
-  assert.deepEqual(partitionBootOrphans([job()], { ...base, getLogMtimeMs: () => 999_000, logFreshWindowMs: 5_000 }).adopted, ['p'], 'fresh log');
-  assert.deepEqual(partitionBootOrphans([job()], { ...base, getLogPid: () => 77 }).adopted, ['p'], 'log pid alive');
-  assert.deepEqual(partitionBootOrphans([job()], { ...base, findLiveProcess: () => 88 }).adopted, ['p'], '/proc scan');
-  assert.deepEqual(partitionBootOrphans([job()], { ...base, getLogMtimeMs: () => 1_000, logFreshWindowMs: 5_000 }).immediate, ['p'], 'stale log');
-});
-
-test('a row whose supervisor record says exited is finalized from its meta, not adopted', () => {
-  withRunsDir((runsDir) => {
-    const runDir = path.join(runsDir, 'run-1');
-    fs.mkdirSync(runDir, { recursive: true });
-    writeSupervisorRecord({ runDir, slug: 'exited-row', pid: 4242, runId: 'run-1', startedAt: Date.now() });
-    fs.writeFileSync(path.join(runDir, 'exited-row.meta.json'), JSON.stringify({ slug: 'exited-row', exitCode: 0 }));
-    const job = { slug: 'exited-row', status: 'running', runId: 'run-1', runtime: { pid: 4242 } };
-    // Even with the pid reported alive (recycled/lingering), the exit marker wins.
-    const { immediate, adopted } = partitionBootOrphans([job], { pidAlive: () => true, runsDir });
-    assert.deepEqual(immediate, ['exited-row']);
-    assert.deepEqual(adopted, []);
-    applyOrphanOutcome(job, 'success');
-    assert.equal(job.status, 'completed');
-  });
-});
-
-test('a record with a live, same-identity pid is adopted; a dead record without an exit marker is finalized', () => {
-  withRunsDir((runsDir) => {
-    const runDir = path.join(runsDir, 'run-2');
-    fs.mkdirSync(runDir, { recursive: true });
-    writeSupervisorRecord({ runDir, slug: 'live-rec', pid: 31337, runId: 'run-2', startedAt: Date.now() });
-    writeSupervisorRecord({ runDir, slug: 'dead-rec', pid: 31338, runId: 'run-2', startedAt: Date.now() });
-    const jobs = [
-      { slug: 'live-rec', status: 'running', runId: 'run-2', runtime: { pid: 31337 } },
-      { slug: 'dead-rec', status: 'running', runId: 'run-2', runtime: { pid: 31338 } },
-    ];
-    const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: (pid) => pid === 31337, identityOf: () => null, runsDir });
-    assert.deepEqual(adopted, ['live-rec']);
-    assert.deepEqual(immediate, ['dead-rec']);
-  });
-});
-
-test('partitionBootOrphans ignores non-running jobs entirely', () => {
-  const jobs = [
-    { slug: 'a', status: 'completed', runtime: { pid: 1 } },
-    { slug: 'b', status: 'failed', runtime: { pid: 2 } },
-  ];
-  const { immediate, adopted } = partitionBootOrphans(jobs, { pidAlive: () => true, runsDir: os.tmpdir() });
-  assert.deepEqual(immediate, []);
-  assert.deepEqual(adopted, []);
-});
-
-test('applyOrphanOutcome: success finalizes to completed, clears runtime', () => {
-  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, exitCode: null };
-  applyOrphanOutcome(job, 'success');
-  assert.equal(job.status, 'completed');
-  assert.equal(job.exitCode, 0);
-  assert.equal(job.error, null);
-  assert.ok(job.finishedAt);
-  assert.equal(job.runtime, undefined);
-});
-
-test('applyOrphanOutcome: failed finalizes to failed with orphan note', () => {
-  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, exitCode: null };
-  applyOrphanOutcome(job, 'failed', ' (orphan pid=1: killed)');
-  assert.equal(job.status, 'failed');
-  assert.equal(job.exitCode, 1);
-  assert.match(job.error, /orphaned: app restarted while running \(orphan pid=1: killed\)/);
-  assert.equal(job.runtime, undefined);
-});
-
-test('applyOrphanOutcome: no_result re-queues to pending under the cap and increments orphanRetries', () => {
-  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, orphanRetries: 0 };
-  applyOrphanOutcome(job, 'no_result');
-  assert.equal(job.status, 'pending');
-  assert.equal(job.orphanRetries, 1);
-  assert.match(job.error, /re-queued \(attempt 1/);
-  assert.equal(job.runtime, undefined);
-});
-
-test('applyOrphanOutcome: no_result at the cap fails terminally instead of re-queuing again', () => {
-  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, orphanRetries: ORPHAN_REQUEUE_CAP };
-  applyOrphanOutcome(job, 'unknown');
-  assert.equal(job.status, 'failed');
-  assert.match(job.error, new RegExp(`exhausted ${ORPHAN_REQUEUE_CAP} re-queue attempts`));
-  assert.equal(job.runtime, undefined);
-});

package/src/main/__tests__/scheduler-broadcast-reconcile.test.cjs

@@ -1,121 +0,0 @@
-/**
- * scheduler-broadcast-reconcile.test.cjs — broadcast() used to do its own bare
- * `readQueue() -> reconcile(state) -> writeQueue(state)` BEFORE ever touching
- * the broadcastCoalescer, so a burst of N broadcast() calls inside one
- * BROADCAST_COALESCE_MS window cost N full reconcile passes + N queue writes
- * to produce ONE coalesced payload — and did so outside mutate()'s lock, so a
- * concurrent mutation's update could be lost. The fix moves the
- * reconcile+write pair inside the coalescer's `getPayload`, run through
- * `mutate()`, so N broadcast() calls in one window cost exactly one reconcile
- * and one write.
- *
- * `reconcile` is a bare local call inside getPayload's mutate() callback, so
- * — matching this file's existing testable-seam convention (module.exports.
- * stashList / evaluateSharedTreeGuard / committedInWindow) — it is invoked as
- * `module.exports.reconcile(state)` specifically so tests can spy on it here.
- * `queueStore.readMerged`/`writeSplit` are genuine cross-module property
- * calls already, so they're spied on directly with no source change needed.
- *
- * HOME-isolated (mirrors reconcileFlatPrdSweep.test.cjs): stub HOME to a
- * mkdtemp dir before requiring scheduler.cjs so `ensureDirs()` (called by the
- * real `writeQueue()` wrapper before the now-mocked `queueStore.writeSplit`)
- * never touches the real machine.
- *
- * Run: timeout 60 npx vitest run src/main/__tests__/scheduler-broadcast-reconcile.test.cjs
- */
-'use strict';
-
-import { test, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-let queueStore;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-broadcast-reconcile-home-'));
-  process.env.HOME = tmpHome;
-
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-
-  if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
-    throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-function freshState() {
-  return { config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
-}
-
-function fakeWindow() {
-  return {
-    isDestroyed: () => false,
-    webContents: { isDestroyed: () => false, isCrashed: () => false, send: vi.fn() },
-  };
-}
-
-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  scheduler.attachWindow(null);
-});
-
-test('10 broadcast() calls inside one coalesce window trigger exactly one reconcile and one queue write', async () => {
-  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
-  const writeSpy = vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
-  const reconcileSpy = vi.spyOn(scheduler, 'reconcile').mockResolvedValue(undefined);
-
-  for (let i = 0; i < 10; i += 1) scheduler.broadcast();
-
-  // BROADCAST_COALESCE_MS is 200ms; give the trailing-edge timer room to fire.
-  await wait(400);
-
-  expect(reconcileSpy).toHaveBeenCalledTimes(1);
-  expect(writeSpy).toHaveBeenCalledTimes(1);
-});
-
-test('a window-less (flush) broadcast() still reconciles, even with no window attached', async () => {
-  scheduler.attachWindow(null);
-  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
-  const writeSpy = vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
-  const reconcileSpy = vi.spyOn(scheduler, 'reconcile').mockResolvedValue(undefined);
-
-  await scheduler.broadcast({ flush: true });
-
-  expect(reconcileSpy).toHaveBeenCalledTimes(1);
-  expect(writeSpy).toHaveBeenCalledTimes(1);
-});
-
-test('a reconcile() that throws does not wedge the coalescer — the next broadcast() still sends', async () => {
-  const win = fakeWindow();
-  scheduler.attachWindow(win);
-  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
-  vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
-  const reconcileSpy = vi.spyOn(scheduler, 'reconcile')
-    .mockRejectedValueOnce(new Error('boom'))
-    .mockResolvedValue(undefined);
-
-  scheduler.broadcast();
-  await wait(400);
-  expect(win.webContents.send).not.toHaveBeenCalled();
-
-  scheduler.broadcast();
-  await wait(400);
-
-  expect(reconcileSpy).toHaveBeenCalledTimes(2);
-  expect(win.webContents.send).toHaveBeenCalledTimes(1);
-  expect(win.webContents.send).toHaveBeenCalledWith('schedule:state', expect.any(Object));
-});

package/src/main/__tests__/scheduler-clear-queue-history.test.cjs

@@ -1,134 +0,0 @@
-/**
- * scheduler-clear-queue-history.test.cjs — schedule:clear-queue must never
- * drop a job row with zero audit trail. Before this PRD, the handler did
- * `s.jobs = s.jobs.filter(...)` straight over every non-running victim with
- * no history.jsonl write at all — a queue row (e.g. the 2026-08-30 sigma
- * `788-pr-sweep-final-gate` incident) could vanish leaving no trace anywhere.
- *
- * Exercises `applyClearQueueVictims` (the core mutation extracted from the
- * `schedule:clear-queue` IPC handler so it's testable without ipcMain/
- * electron) directly against a synthetic state, then feeds its output
- * through the REAL `queueHistory.appendHistory`. Job fixtures carry a real
- * absolute `cwd` under a per-test mkdtemp dir (never the live operations
- * root) because appendHistory routes each entry to its OWN project's
- * `<cwd>/session-manager-operations/scheduler/state/history.jsonl` shard
- * whenever the entry has a `cwd` — SM_HISTORY_PATH_OVERRIDE only affects
- * cwd-less entries, and the AC here requires every entry to carry a cwd.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-clear-queue-history.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const queueHistory = require('../lib/queueHistory.cjs');
-const { projectHistoryPath } = require('../lib/queueStore.cjs');
-const scheduler = require('../scheduler.cjs');
-
-let tmpCwd;
-
-beforeEach(() => {
-  tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-clear-queue-history-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpCwd, { recursive: true, force: true });
-});
-
-function pendingJob(slug, overrides = {}) {
-  return { slug, cwd: tmpCwd, status: 'pending', runId: null, finishedAt: null, ...overrides };
-}
-
-function historyPath() {
-  return projectHistoryPath(tmpCwd);
-}
-
-function readHistoryRows() {
-  const text = fs.readFileSync(historyPath(), 'utf8').trim();
-  return text ? text.split('\n').map((l) => JSON.parse(l)) : [];
-}
-
-test('applyClearQueueVictims transitions N pending jobs to skipped, drops them from state.jobs, and appendHistory writes N rows with source clear-queue', async () => {
-  const jobs = [pendingJob('101-a'), pendingJob('102-b'), pendingJob('103-c')];
-  const running = { slug: '104-running', cwd: tmpCwd, status: 'running', runId: 'run-104', finishedAt: null };
-  const state = { jobs: [...jobs, running] };
-  const victimSlugs = new Set(jobs.map((j) => j.slug));
-  const archiveNoteBySlug = new Map(jobs.map((j) => [j.slug, 'PRD file archived to /fake/archive/dir']));
-
-  const historyEntries = scheduler.applyClearQueueVictims(state, victimSlugs, archiveNoteBySlug, '/fake/archive/dir');
-
-  // Running job is untouched, exempt from clear-queue, and got no history row.
-  expect(state.jobs.map((j) => j.slug)).toEqual(['104-running']);
-  expect(historyEntries.map((e) => e.slug).sort()).toEqual(['101-a', '102-b', '103-c']);
-  for (const entry of historyEntries) {
-    expect(entry.status).toBe('skipped'); // NEVER 'completed' — a manually cleared job did not ship
-    expect(entry.cwd).toBe(tmpCwd);
-    expect(entry.finishedAt).toBeTruthy();
-    const last = entry.statusHistory[entry.statusHistory.length - 1];
-    expect(last.source).toBe('clear-queue');
-    expect(last.reason).toContain('/fake/archive/dir');
-  }
-
-  const { appended } = await queueHistory.appendHistory(historyEntries);
-  expect(appended).toBe(3);
-  const onDisk = readHistoryRows();
-  expect(onDisk.length).toBe(3);
-  expect(onDisk.every((e) => e.status === 'skipped')).toBe(true);
-  expect(onDisk.every((e) => e.statusHistory.at(-1).source === 'clear-queue')).toBe(true);
-
-  // queue.json (state.jobs, what writeQueue serializes) no longer lists them.
-  expect(state.jobs.some((j) => victimSlugs.has(j.slug))).toBe(false);
-});
-
-test('running jobs are exempt from clear-queue and never appear in the returned history entries', () => {
-  const running = { slug: '201-running', cwd: tmpCwd, status: 'running', runId: 'run-201', finishedAt: null };
-  const state = { jobs: [running] };
-  const victimSlugs = new Set(); // schedule:clear-queue never includes running jobs as victims
-
-  const historyEntries = scheduler.applyClearQueueVictims(state, victimSlugs, new Map(), '/fake/archive/dir');
-
-  expect(historyEntries).toEqual([]);
-  expect(state.jobs).toEqual([running]);
-});
-
-test('a victim already terminal (completed) keeps its real status, not skipped, but still gets a clear-queue history row', () => {
-  const completed = { slug: '301-done', cwd: tmpCwd, status: 'completed', runId: 'run-301', finishedAt: '2026-08-29T00:00:00.000Z', statusHistory: [] };
-  const state = { jobs: [completed] };
-  const victimSlugs = new Set(['301-done']);
-
-  const historyEntries = scheduler.applyClearQueueVictims(state, victimSlugs, new Map(), '/fake/archive/dir');
-
-  expect(state.jobs).toEqual([]);
-  expect(historyEntries.length).toBe(1);
-  expect(historyEntries[0].status).toBe('completed'); // real outcome preserved, not overwritten to skipped
-  const last = historyEntries[0].statusHistory.at(-1);
-  expect(last.source).toBe('clear-queue');
-  expect(last.from).toBe('completed');
-  expect(last.to).toBe('completed');
-});
-
-test('appendHistory dedupe: clearing an already-cleared queue twice does not double-write rows', async () => {
-  const jobs = [pendingJob('401-x'), pendingJob('402-y')];
-  const state = { jobs: [...jobs] };
-  const victimSlugs = new Set(jobs.map((j) => j.slug));
-
-  const historyEntries = scheduler.applyClearQueueVictims(state, victimSlugs, new Map(), '/fake/archive/dir');
-  expect(state.jobs).toEqual([]);
-
-  const r1 = await queueHistory.appendHistory(historyEntries);
-  expect(r1.appended).toBe(2);
-
-  // A crash-replay of the SAME batch through appendHistory (the dedupe
-  // queueHistory itself guards against) must not double-write — this is
-  // what protects a second clear-queue pass, or a retry after a crash
-  // between the mutate() and appendHistory calls, from duplicating rows.
-  const r2 = await queueHistory.appendHistory(historyEntries);
-  expect(r2.appended).toBe(0);
-
-  const onDisk = readHistoryRows();
-  expect(onDisk.length).toBe(2);
-});