claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/queue-health-verdict.test.cjs

@@ -1,170 +0,0 @@
-/**
- * queue-health-verdict.test.cjs — classifyQueueHealth is the Scheduler
- * page's queue-health header: the single honest read of WHY a queue looks
- * stale (saturated slots / blocked dependencies / genuinely idle / the
- * dispatch driver itself stalled / a decision to pause / an open launch
- * circuit breaker), reusing classifyQueueStarvation so the header can never
- * disagree with the starvation watchdog's own read of the same state.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/queue-health-verdict.test.cjs
- */
-
-'use strict';
-
-import { test, afterAll } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// HOME before require: every state path is baked from os.homedir() at load.
-const originalHome = process.env.HOME;
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'queue-health-test-'));
-process.env.HOME = tmpHome;
-fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-
-const { classifyQueueHealth, QUEUE_STARVATION_MS } = require('../scheduler.cjs');
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-const CWD = '/home/bilko/Projects/starry-night-ships';
-const NOW = Date.parse('2026-09-13T20:00:00.000Z');
-const LONG = QUEUE_STARVATION_MS + 60_000;
-
-test('saturated: jobs running, zero free slots', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'running', startedAt: new Date(NOW - LONG).toISOString(), dependsOn: [] },
-    { slug: '2-b', cwd: CWD, status: 'pending', dependsOn: [] },
-  ];
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks: {}, runningSet: new Set(['1-a']),
-    freeSlots: 0, totalSlots: 4, lastRunAtMs: NOW, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.kind, 'saturated');
-  assert.equal(v.runningCount, 1);
-  assert.equal(v.totalSlots, 4);
-  // Dispatchable/blocked counts stay real numbers even in a kind whose
-  // headline cause is slot saturation, not dependency shape — the header
-  // must still be able to show them alongside the verdict.
-  assert.equal(v.pending, 1);
-  assert.equal(v.dispatchable, 1);
-  assert.deepEqual(v.blockedChains, []);
-});
-
-test('blocked: every pending row terminates in a failed dependency', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'failed', dependsOn: [] },
-    { slug: '2-b', cwd: CWD, status: 'pending', dependsOn: ['1-a'] },
-  ];
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
-    freeSlots: 4, totalSlots: 4, lastRunAtMs: NOW - 5_000, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.kind, 'blocked');
-  assert.equal(v.pending, 1);
-  assert.equal(v.dispatchable, 0);
-  assert.equal(v.blockedChains.length, 1);
-  assert.deepEqual(v.blockedChains[0].blockedBy, ['1-a']);
-});
-
-test('idle: nothing pending', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'completed', dependsOn: [] },
-  ];
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
-    freeSlots: 4, totalSlots: 4, lastRunAtMs: NOW, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.kind, 'idle');
-  assert.equal(v.pending, 0);
-  assert.equal(v.dispatchable, 0);
-});
-
-test('stalled: dispatchable work, nothing running, driver idle past threshold', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [] },
-  ];
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
-    freeSlots: 4, totalSlots: 4, lastRunAtMs: NOW - LONG, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.kind, 'stalled');
-  assert.equal(v.dispatchable, 1);
-  assert.ok(v.idleMs >= QUEUE_STARVATION_MS);
-});
-
-test('running: dispatchable work, nothing running yet, but driver has not been idle long enough to call it a stall', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [] },
-  ];
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
-    freeSlots: 4, totalSlots: 4, lastRunAtMs: NOW - 5_000, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.kind, 'running');
-});
-
-test('paused: a decision, not a stall — takes priority over everything else', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [] },
-  ];
-  const v = classifyQueueHealth({
-    jobs, paused: { reason: 'manual', since: NOW }, launchBlocks: {}, runningSet: new Set(),
-    freeSlots: 0, totalSlots: 4, lastRunAtMs: NOW - LONG, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.kind, 'paused');
-  assert.equal(v.reason, 'manual');
-  assert.equal(v.pending, 1);
-  assert.equal(v.dispatchable, 1);
-});
-
-test('launch-blocked: an open circuit breaker for a persona a pending row actually uses', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [], agentType: 'dev-lead' },
-  ];
-  const launchBlocks = {
-    'dev-lead': { kind: 'model_config_rejected', attempts: 3, hint: 'update the CLI', until: null },
-  };
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks, runningSet: new Set(),
-    freeSlots: 4, totalSlots: 4, lastRunAtMs: NOW - LONG, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.kind, 'launch-blocked');
-  assert.equal(v.agentType, 'dev-lead');
-  assert.equal(v.pending, 1);
-  assert.equal(v.dispatchable, 1);
-});
-
-test('launch-blocked is scoped: a breaker for a persona nothing pending here uses does not fire', () => {
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [], agentType: 'dev-lead' },
-  ];
-  const launchBlocks = {
-    'architect': { kind: 'model_config_rejected', attempts: 3, hint: 'update the CLI', until: null },
-  };
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks, runningSet: new Set(),
-    freeSlots: 4, totalSlots: 4, lastRunAtMs: NOW - 5_000, now: NOW, cwd: CWD,
-  });
-  assert.notEqual(v.kind, 'launch-blocked');
-});
-
-test('needsReviewCount and cwd scoping: another project\'s rows never leak into this scope\'s counts', () => {
-  const other = '/home/bilko/Projects/session-manager';
-  const jobs = [
-    { slug: '1-a', cwd: CWD, status: 'needs_review', dependsOn: [] },
-    { slug: '2-b', cwd: CWD, status: 'pending', dependsOn: [] },
-    { slug: '3-c', cwd: other, status: 'pending', dependsOn: [] },
-    { slug: '4-d', cwd: other, status: 'needs_review', dependsOn: [] },
-  ];
-  const v = classifyQueueHealth({
-    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
-    freeSlots: 4, totalSlots: 4, lastRunAtMs: NOW - 5_000, now: NOW, cwd: CWD,
-  });
-  assert.equal(v.pending, 1);
-  assert.equal(v.needsReviewCount, 1);
-});

package/src/main/__tests__/queue-starvation-dispatch-driver.test.cjs

@@ -1,286 +0,0 @@
-/**
- * queue-starvation-dispatch-driver.test.cjs — two liveness gaps in the
- * queue-starvation watchdog itself, both observed live on 2026-09-11
- * (27 pending jobs across two projects, 0 running, for days):
- *
- * 1. classifyQueueStarvation/runQueueStarvationWatchdog used to measure
- *    idleness from `lastRunAt`, which the poll loop kept looking fresh even
- *    while nothing was actually dispatching — masking the very stall the
- *    watchdog exists to catch. It must measure from `lastDispatchAttemptAt`
- *    instead (stamped by tickQueue() the moment it reaches the picker,
- *    regardless of outcome — see tickQueue's own comment).
- * 2. tickQueue()'s very first real guard returns {fired:false,
- *    reason:'cancelled'} whenever the in-process cancelToken is wedged
- *    true — historically only ever reset by runDueJobs() (force-tick/
- *    run-now/resume-timer). A pause that clears WITHOUT going through
- *    clearPause() (e.g. a direct queue-state write) leaves the token
- *    wedged forever with nothing left to un-wedge it. The starvation
- *    watchdog is the last line of defence, so it must reset the token
- *    itself before forcing its tick.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/queue-starvation-dispatch-driver.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-
-let tmpHome;
-let originalHome;
-let originalClaudeBin;
-let originalAutofixDisable;
-let scheduler;
-let queueStore;
-
-// A forced tick actually dispatches the one pending job it finds. Without a
-// stub, that spawns the real `claude` binary (or fails trying to), leaving
-// scheduler.cjs's module-scoped runningSet non-empty by the time the next
-// test in this file runs — classifyQueueStarvation's `runningCount > 0`
-// guard then makes runQueueStarvationWatchdog return null for a reason that
-// has nothing to do with what that test is actually checking.
-function writeClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  originalClaudeBin = process.env.SM_CLAUDE_BIN;
-  originalAutofixDisable = process.env.SM_AUTOFIX_DISABLE;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-starve-driver-'));
-  process.env.HOME = tmpHome;
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-  // The forced tick's dispatched job has no PRD file and makes no commit, so
-  // it lands 'needs_review' and (without this) immediately fires a
-  // fire-and-forget auto-fix investigation — ANOTHER real claude spawn, under
-  // its own queue row, that can still be in runningSet by the time the next
-  // test in this file reads it (see writeClaudeStub's header comment; this
-  // closes the same gap one layer further down the cascade).
-  process.env.SM_AUTOFIX_DISABLE = '1';
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalClaudeBin === undefined) delete process.env.SM_CLAUDE_BIN;
-  else process.env.SM_CLAUDE_BIN = originalClaudeBin;
-  if (originalAutofixDisable === undefined) delete process.env.SM_AUTOFIX_DISABLE;
-  else process.env.SM_AUTOFIX_DISABLE = originalAutofixDisable;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-// allProjectCwds()/activeProjectCwds() (queueStore.cjs's stateCwds) discover
-// project cwds by scanning ~/.claude/projects/*/*.jsonl for a `cwd` field —
-// fake one project transcript pointing at the fixture cwd, same pattern as
-// prdAdminRoutes.test.cjs / scheduler-verify-prd-path.test.cjs.
-function mkProject() {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-starve-driver-project-'));
-  const slug = `9002-starve-driver-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const projDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'projects', 'sm-starve-driver-fake-'));
-  fs.writeFileSync(path.join(projDir, 'session.jsonl'), `${JSON.stringify({ cwd })}\n`, 'utf8');
-  return { cwd, slug };
-}
-
-test('ticks that launch nothing do NOT refresh the clock — idleness reads lastRunAt, not lastDispatchAttemptAt', async () => {
-  const { cwd, slug } = mkProject();
-  await scheduler.writeQueue({
-    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
-    config: {},
-    paused: null,
-  });
-
-  const now = Date.now();
-  // The structural repeat of f18e161: the loop ticks every 30 s (so
-  // lastDispatchAttemptAt is seconds old) but nothing has LAUNCHED in 40
-  // minutes (lastRunAt). The boot stamp is aged out so it can't mask it.
-  const bootedAtMs = now - 3 * 60 * 60_000;
-  const state = {
-    ...queueStore.readMergedSync(),
-    lastRunAt: new Date(now - 40 * 60_000).toISOString(),
-    lastDispatchAttemptAt: new Date(now - 5_000).toISOString(),
-  };
-
-  const verdict = await scheduler.runQueueStarvationWatchdog(state, { now, bootedAtMs });
-  expect(verdict).not.toBeNull();
-  expect(verdict.kind).toBe('starved');
-
-  // The watchdog's forced tick above dispatches this job for real (see
-  // writeClaudeStub's header comment) — tickQueue doesn't await the spawned
-  // process to completion, so runningSet can still hold this slug for a
-  // moment after this test's own `await` returns. Under a fast, unloaded
-  // machine the stub exits before the NEXT test's watchdog call ever reads
-  // runningSet, which is racy rather than deterministic — under a heavily
-  // loaded machine (e.g. the full test:unit run) it reliably loses,
-  // stranding a slug in runningSet and making
-  // classifyQueueStarvation's `runningCount > 0` guard return null for the
-  // next test, which has nothing to do with what that test actually checks.
-  // Wait for this job to actually leave 'running' before moving on.
-  const deadline = Date.now() + 5_000;
-  while (Date.now() < deadline) {
-    const row = queueStore.readMergedSync().jobs.find((j) => j.slug === slug);
-    if (!row || row.status !== 'running') break;
-    await new Promise((r) => setTimeout(r, 25));
-  }
-});
-
-test('a wedged cancelToken does not block the watchdog from actually driving a tick', async () => {
-  const { cwd, slug } = mkProject();
-  await scheduler.writeQueue({
-    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
-    config: {},
-    paused: null,
-  });
-
-  // Wedge the in-process cancel token exactly the way a pause does, then
-  // clear the pause through a path that does NOT run clearPause()'s own
-  // applyPauseCleared reset (a direct state write, not the clearPause()
-  // helper) — leaving the token permanently cancelled with paused: null.
-  await scheduler.setPaused('rate_limit', null);
-  // setPaused's own broadcast({flush:true}) and a still-draining
-  // fire-and-forget mutate() from the PRIOR test's forced dispatch (e.g.
-  // tickQueue's own finally-chained call) both write through the SAME
-  // serialized mutate() queue this raw writeQueue() call bypasses — one of
-  // them can land AFTER this write and re-persist the stale paused:{...}
-  // object it read before this clear, purely by losing the race. Re-assert
-  // paused:null until it actually sticks, rather than trusting one write to
-  // win a race against mutations this test doesn't control the timing of.
-  const pausedClearDeadline = Date.now() + 5_000;
-  do {
-    await scheduler.writeQueue({
-      jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
-      config: {},
-      paused: null,
-    });
-    if (!queueStore.readMergedSync().paused) break;
-    await new Promise((r) => setTimeout(r, 25));
-  } while (Date.now() < pausedClearDeadline);
-
-  const before = queueStore.readMergedSync().lastDispatchAttemptAt;
-
-  const now = Date.now();
-  const state = {
-    ...queueStore.readMergedSync(),
-    lastRunAt: new Date(now - 40 * 60_000).toISOString(),
-    lastDispatchAttemptAt: new Date(now - 40 * 60_000).toISOString(),
-  };
-  const verdict = await scheduler.runQueueStarvationWatchdog(state, { now, bootedAtMs: now - 3 * 60 * 60_000 });
-  expect(verdict.kind).toBe('starved');
-
-  // tickQueue() only stamps lastDispatchAttemptAt once it gets PAST the
-  // cancelToken guard — so this only advances if the watchdog actually
-  // un-wedged the token before forcing its tick.
-  const after = queueStore.readMergedSync().lastDispatchAttemptAt;
-  expect(after).not.toBe(before);
-  expect(after).not.toBeNull();
-});
-
-const NOW = Date.parse('2026-09-18T12:00:00.000Z');
-const CWD = '/tmp/sm-starve-clock-project';
-const pendingRow = (slug, extra = {}) => ({ slug, cwd: CWD, status: 'pending', dependsOn: [], ...extra });
-const idleFor = (ms) => NOW - ms;
-
-test('a real launch (fresh lastRunAt) refreshes the clock; so do a pause clear and a boot', () => {
-  const jobs = [pendingRow('a')];
-  const base = { jobs, paused: null, runningCount: 0, now: NOW };
-  const stale = idleFor(3 * 60 * 60_000);
-  expect(scheduler.classifyQueueStarvation({ ...base, lastRunAtMs: stale }).kind).toBe('starved');
-  expect(scheduler.classifyQueueStarvation({ ...base, lastRunAtMs: idleFor(5_000) })).toBeNull();
-  expect(scheduler.classifyQueueStarvation({ ...base, lastRunAtMs: stale, lastPauseClearedAtMs: idleFor(5_000) })).toBeNull();
-  expect(scheduler.classifyQueueStarvation({ ...base, lastRunAtMs: stale, schedulerBootedAtMs: idleFor(5_000) })).toBeNull();
-  expect(scheduler.dispatchIdleMs({ lastRunAtMs: 1000, lastPauseClearedAtMs: 4000, schedulerBootedAtMs: 2000, now: 10_000 })).toBe(6000);
-  expect(scheduler.dispatchIdleMs({ now: 10_000 })).toBe(Infinity);
-});
-
-test('rows held by a launch breaker / lease read blocked, not starved (per project too)', () => {
-  const jobs = [pendingRow('a'), pendingRow('b')];
-  const args = { jobs, paused: null, runningCount: 0, lastRunAtMs: idleFor(3 * 60 * 60_000), now: NOW };
-  expect(scheduler.classifyQueueStarvation(args).kind).toBe('starved');
-  const partial = scheduler.classifyQueueStarvation({ ...args, heldSlugs: new Set(['a']) });
-  expect(partial.kind).toBe('starved');
-  expect(partial.dispatchable).toBe(1);
-  const all = scheduler.classifyQueueStarvation({ ...args, heldSlugs: new Map([['a', 'x'], ['b', 'y']]) });
-  expect(all.kind).toBe('blocked');
-  expect(all.dispatchable).toBe(0);
-  const byProject = scheduler.classifyQueueStarvationByProject({
-    jobs, paused: null, runningSet: new Set(), lastRunAtMs: args.lastRunAtMs, heldSlugs: new Set(['a', 'b']), now: NOW,
-  });
-  expect(byProject.map((v) => v.kind)).toEqual(['blocked']);
-});
-
-test('a starved queue forces its tick with bypassLoadGate:true — the CPU load gate must not freeze the last-resort dispatch', async () => {
-  // Regression for the 2026-09-23 freeze: 3 dispatchable jobs, 0 running,
-  // lastTickReason 'load-deferred' unbroken 07:00→13:06. The watchdog is the
-  // safety net for exactly that state, but it used to force its tick with
-  // bypassLoadGate:false, so a box loaded by ANOTHER process held the net's
-  // own tick behind the load gate and nothing ever ran. Spy the exported
-  // tickQueue seam (the call is routed via module.exports precisely so this
-  // is assertable without manufacturing real machine load, which
-  // SM_LOAD_GATE_PER_CORE clamps at 0.25 and can't force deterministically).
-  const cwd = '/tmp/sm-starve-bypass-project';
-  const jobs = [{ slug: 'bypass-a', cwd, status: 'pending', dependsOn: [] }];
-  const state = { jobs, paused: null, lastRunAt: new Date(NOW - 40 * 60_000).toISOString() };
-  const opts = { now: NOW, bootedAtMs: NOW - 3 * 60 * 60_000 };
-  const tickSpy = vi.spyOn(scheduler, 'tickQueue').mockResolvedValue({ fired: false, reason: 'drained' });
-  try {
-    const verdict = await scheduler.runQueueStarvationWatchdog(state, opts);
-    expect(verdict.kind).toBe('starved');
-    expect(tickSpy).toHaveBeenCalledTimes(1);
-    expect(tickSpy).toHaveBeenCalledWith({ bypassLoadGate: true });
-  } finally {
-    tickSpy.mockRestore();
-  }
-});
-
-test('the bypass is not unconditional — a queue with something already running never force-ticks at all', async () => {
-  // Guard against the bypass becoming an escape hatch: the watchdog only
-  // reaches its forced tick on a genuine 'starved' verdict (0 running). When
-  // a job is already running, classifyQueueStarvation returns null and no
-  // forced tick fires — so bypassLoadGate never even comes into play.
-  const cwd = '/tmp/sm-running-nobypass-project';
-  const jobs = [
-    { slug: 'run-a', cwd, status: 'running', dependsOn: [] },
-    { slug: 'pend-b', cwd, status: 'pending', dependsOn: [] },
-  ];
-  const state = { jobs, paused: null, lastRunAt: new Date(NOW - 40 * 60_000).toISOString() };
-  const opts = { now: NOW, bootedAtMs: NOW - 3 * 60 * 60_000 };
-  const tickSpy = vi.spyOn(scheduler, 'tickQueue').mockResolvedValue({ fired: false, reason: 'drained' });
-  try {
-    const verdict = await scheduler.runQueueStarvationWatchdog(state, opts);
-    expect(verdict).toBeNull();
-    expect(tickSpy).not.toHaveBeenCalled();
-  } finally {
-    tickSpy.mockRestore();
-  }
-});
-
-test('the watchdog latches: one forced tick / audit per starve episode, re-armed by threshold or running-count change', async () => {
-  const cwd = '/tmp/sm-starve-latch-project';
-  const jobs = [{ slug: 'latch-a', cwd, status: 'pending', dependsOn: [] }];
-  const opts = { bootedAtMs: NOW - 3 * 60 * 60_000 };
-  const state = { jobs, paused: null, lastRunAt: new Date(NOW - 40 * 60_000).toISOString() };
-  const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-  const starvedLogs = () => warn.mock.calls.filter((c) => String(c[0]).includes('QUEUE STARVED')).length;
-  try {
-    // The row exists only in this hand-built state, never in queue.json, so
-    // the forced tick has nothing real to launch.
-    expect((await scheduler.runQueueStarvationWatchdog(state, { now: NOW, ...opts })).kind).toBe('starved');
-    expect(starvedLogs()).toBe(1);
-    // Same episode, well inside QUEUE_STARVATION_MS: still reported, not re-forced.
-    expect((await scheduler.runQueueStarvationWatchdog(state, { now: NOW + 60_000, ...opts })).kind).toBe('starved');
-    expect(starvedLogs()).toBe(1);
-    // QUEUE_STARVATION_MS elapsed again: a new episode.
-    await scheduler.runQueueStarvationWatchdog(state, { now: NOW + scheduler.QUEUE_STARVATION_MS + 1, ...opts });
-    expect(starvedLogs()).toBe(2);
-  } finally {
-    warn.mockRestore();
-  }
-});

package/src/main/__tests__/queue-starvation-per-project.test.cjs

@@ -1,147 +0,0 @@
-/**
- * queue-starvation-per-project.test.cjs — classifyQueueStarvation's
- * runningCount used to be fed the MACHINE-WIDE runningSet.size, so one
- * long-lived job in ANY project disarmed the starvation watchdog for EVERY
- * other project on the box. Observed live 2026-09-12: a job in
- * starry-night-ships ran 80+ minutes while two other projects sat
- * starved/blocked for hours — the watchdog never fired once because "work is
- * flowing" was true somewhere else.
- *
- * classifyQueueStarvationByProject partitions jobs by cwd (the same grouping
- * computeBlockedChains already uses) and evaluates each project on its OWN
- * running/pending/idle evidence.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/queue-starvation-per-project.test.cjs
- */
-
-'use strict';
-
-import { test, afterAll } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// HOME before require: every state path is baked from os.homedir() at load.
-// beforeAll runs AFTER module evaluation, so this assignment must stay at
-// top level — see pollLoop-dispatch-on-failure.test.cjs:40-56 for the
-// beforeAll/afterAll pattern this restore mirrors.
-const originalHome = process.env.HOME;
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-per-project-test-'));
-process.env.HOME = tmpHome;
-fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-
-const {
-  classifyQueueStarvation,
-  classifyQueueStarvationByProject,
-  QUEUE_STARVATION_MS,
-} = require('../scheduler.cjs');
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-const PROJECT_A = '/home/bilko/Projects/starry-night-ships';
-const PROJECT_B = '/home/bilko/Projects/session-manager';
-const NOW = Date.parse('2026-09-12T20:00:00.000Z');
-const LONG = QUEUE_STARVATION_MS + 60_000;
-const idleFor = (ms) => NOW - ms;
-
-test('one long-running job in project A no longer masks project B being starved', () => {
-  const jobs = [
-    { slug: '246-neptune', cwd: PROJECT_A, status: 'running', dependsOn: [] },
-    { slug: '1169-x', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
-    { slug: '1170-y', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
-  ];
-
-  // Pre-change shape: the machine-wide runningCount (1, from project A) hides
-  // project B's starvation entirely. This is the bug this PRD fixes — assert
-  // it still holds for the old, single-project entry point so a revert of
-  // the new driver is caught by this test going red.
-  const globalVerdict = classifyQueueStarvation({
-    jobs,
-    paused: false,
-    runningCount: 1,
-    lastRunAtMs: idleFor(LONG),
-    now: NOW,
-  });
-  assert.equal(globalVerdict, null);
-
-  // Per-project: project B has 0 of its OWN rows running and 2 dispatchable
-  // pending rows idle past the threshold — it must be reported as starved
-  // regardless of project A's running job.
-  const verdicts = classifyQueueStarvationByProject({
-    jobs,
-    paused: false,
-    runningSet: new Set(),
-    lastRunAtMs: idleFor(LONG),
-    now: NOW,
-  });
-  const forB = verdicts.find((v) => v.cwd === PROJECT_B);
-  assert.ok(forB, 'expected a verdict naming project B cwd');
-  assert.equal(forB.kind, 'starved');
-  assert.equal(forB.pending, 2);
-  assert.equal(forB.dispatchable, 2);
-
-  // Project A itself has a running row — never starved on its own account.
-  const forA = verdicts.find((v) => v.cwd === PROJECT_A);
-  assert.equal(forA, undefined);
-});
-
-test('a project fully blocked behind a terminal dependency is "blocked", not "starved", even while another project is starved in the same pass', () => {
-  const jobs = [
-    // Project A: every pending row sits behind a failed dependency — a tick
-    // cannot help this project, it needs a human/heal pass.
-    { slug: '206-lava-ape', cwd: PROJECT_A, status: 'failed', dependsOn: [] },
-    { slug: '207-body', cwd: PROJECT_A, status: 'pending', dependsOn: ['206-lava-ape'] },
-    // Project B: dispatchable right now — genuinely starved.
-    { slug: '1171-z', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
-  ];
-
-  const verdicts = classifyQueueStarvationByProject({
-    jobs,
-    paused: false,
-    runningSet: new Set(),
-    lastRunAtMs: idleFor(LONG),
-    now: NOW,
-  });
-
-  const forA = verdicts.find((v) => v.cwd === PROJECT_A);
-  assert.ok(forA, 'expected a verdict for the blocked project');
-  assert.equal(forA.kind, 'blocked');
-
-  const forB = verdicts.find((v) => v.cwd === PROJECT_B);
-  assert.ok(forB, 'expected a verdict for the starved project');
-  assert.equal(forB.kind, 'starved');
-});
-
-test('the whole-machine paused short-circuit is preserved for every project', () => {
-  const jobs = [
-    { slug: '1169-x', cwd: PROJECT_A, status: 'pending', dependsOn: [] },
-    { slug: '1170-y', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
-  ];
-  const verdicts = classifyQueueStarvationByProject({
-    jobs,
-    paused: { reason: 'rate_limit', resumeAt: null },
-    runningSet: new Set(),
-    lastRunAtMs: idleFor(LONG),
-    now: NOW,
-  });
-  assert.deepEqual(verdicts, []);
-});
-
-test('a running-set membership (not just a status:"running" row) counts as that project having flowing work', () => {
-  const jobs = [
-    { slug: '9001-a', cwd: PROJECT_A, status: 'pending', dependsOn: [] },
-  ];
-  const verdicts = classifyQueueStarvationByProject({
-    jobs,
-    paused: false,
-    runningSet: new Set(['9001-a']),
-    lastRunAtMs: idleFor(LONG),
-    now: NOW,
-  });
-  assert.deepEqual(verdicts, []);
-});