claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/flatPrdTickSweep.test.cjs

@@ -1,110 +0,0 @@
-/**
- * flatPrdTickSweep.test.cjs — the retired flat `scheduler/prds/` dir must be
- * TRULY inert, not just documented as such.
- *
- * Prior to this PRD, `runPrdMigration()`'s consolidation of the flat dir into
- * `prds-archived/` ran ONLY at Electron boot (src/main/scheduler.cjs). But
- * `prdLocations.cjs`'s `resolvePrdsDirs()` unconditionally keeps scanning the
- * flat dir as a live PRD source, and `reconcile()` runs on every tick — so a
- * PRD hand-written into the flat dir *after* boot sat there live and WOULD
- * get reconciled into a pending job and executed (observed 2026-08-07:
- * 1021/1022 PRDs in social-signals-trader executed once their status was
- * repaired), contradicting the develop skill's documented claim that
- * anything landed there is "auto-consolidated ... WITHOUT being executed."
- *
- * The fix: `consolidateAllFlatPrds()` now also runs at the START of every
- * `reconcile()` call itself (not just one caller like tickQueue's poll — every
- * caller of reconcile gets the guarantee), BEFORE reconcile scans the flat
- * dir. A freshly hand-written PRD has no queue row yet (reconcile hasn't
- * seen it), so it is never in LIVE_JOB_STATUSES — this sweep archives it
- * before reconcile ever gets a chance to turn it into a job. This test
- * proves that invariant directly against `consolidateAllFlatPrds`: a file
- * with no matching queue job is swept into `prds-archived/` on the very next
- * call, which prdLocations.cjs's `resolvePrdsDirs()` never scans as a live
- * source — so it can never be reconciled into a job afterward.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/flatPrdTickSweep.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 { consolidateAllFlatPrds } = require('../scheduler.cjs');
-const { resolvePrdWriteDir, resolvePrdsDirs } = require('../lib/prdLocations.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-function newProjectRoot() {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-flat-tick-sweep-'));
-  tmpDirs.push(d);
-  return d;
-}
-
-test('a PRD hand-written into the retired flat dir after boot is swept before it could ever be reconciled', async () => {
-  const cwd = newProjectRoot();
-  const flatDir = resolvePrdWriteDir(cwd);
-  await fsp.mkdir(flatDir, { recursive: true });
-  const filename = '999-hand-written-bypass.md';
-  await fsp.writeFile(
-    path.join(flatDir, filename),
-    `---\ntitle: Hand-written bypass\ncwd: ${cwd}\nestimateMinutes: 10\n---\n\n# Goal\n\nSomething.\n`,
-    'utf8',
-  );
-  // No queue.json at all yet — this is exactly the state of a PRD dropped on
-  // disk moments ago, before any reconcile() pass has scanned it into a job.
-
-  await consolidateAllFlatPrds([cwd]);
-
-  // Swept out of the live flat dir...
-  expect(fs.existsSync(path.join(flatDir, filename))).toBe(false);
-  // ...and into prds-archived/, which resolvePrdsDirs() never returns as a
-  // scan source — so no future reconcile() pass can find it and queue it.
-  const archivedPath = path.join(path.dirname(flatDir), 'prds-archived', filename);
-  expect(fs.existsSync(archivedPath)).toBe(true);
-
-  const liveDirs = resolvePrdsDirs(Infinity, { projectsDir: path.join(cwd, '.nonexistent') });
-  expect(liveDirs.every((d) => !d.includes('prds-archived'))).toBe(true);
-});
-
-test('consolidateAllFlatPrds still protects a PRD that already has a live queue job (PRD 992 invariant preserved)', async () => {
-  const cwd = newProjectRoot();
-  const flatDir = resolvePrdWriteDir(cwd);
-  await fsp.mkdir(flatDir, { recursive: true });
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  await fsp.mkdir(stateDir, { recursive: true });
-  await fsp.writeFile(
-    path.join(flatDir, '998-live.md'),
-    `---\ntitle: Live\ncwd: ${cwd}\nestimateMinutes: 10\n---\n\n# Goal\n`,
-    'utf8',
-  );
-  await fsp.writeFile(
-    path.join(stateDir, 'queue.json'),
-    JSON.stringify({ jobs: [{ slug: '998-live', status: 'running' }] }),
-    'utf8',
-  );
-
-  await consolidateAllFlatPrds([cwd]);
-
-  expect(fs.existsSync(path.join(flatDir, '998-live.md'))).toBe(true);
-});
-
-test('consolidateAllFlatPrds never throws when a project errors — one bad cwd does not block the sweep of the rest', async () => {
-  const good = newProjectRoot();
-  const flatDir = resolvePrdWriteDir(good);
-  await fsp.mkdir(flatDir, { recursive: true });
-  await fsp.writeFile(path.join(flatDir, '997-ok.md'), `---\ntitle: Ok\ncwd: ${good}\nestimateMinutes: 5\n---\n\n# Goal\n`, 'utf8');
-
-  await expect(consolidateAllFlatPrds([null, good])).resolves.toBeUndefined();
-
-  expect(fs.existsSync(path.join(flatDir, '997-ok.md'))).toBe(false);
-});

package/src/main/__tests__/health-build-freshness.test.cjs

@@ -1,39 +0,0 @@
-/**
- * health-build-freshness.test.cjs — evaluateBuildFreshness separates
- * restart-needed (installed differs from running) from publish-needed
- * (repo HEAD differs from installed); both reported, never critical.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-build-freshness.test.cjs
- */
-'use strict';
-
-import { test, expect } from 'vitest';
-const { evaluateBuildFreshness } = require('../health.cjs');
-
-test('all shas equal → nothing needed', () => {
-  const r = evaluateBuildFreshness({ running: 'abc1234', installedOnDisk: 'abc1234', repoHead: 'abc1234' });
-  expect(r).toMatchObject({ ok: true, restartNeeded: false, publishNeeded: false });
-});
-
-test('installed differs from running → restart needed only', () => {
-  const r = evaluateBuildFreshness({ running: 'aaa1111', installedOnDisk: 'bbb2222', repoHead: 'bbb2222' });
-  expect(r).toMatchObject({ ok: true, restartNeeded: true, publishNeeded: false });
-});
-
-test('repo HEAD differs from installed → publish needed only', () => {
-  const r = evaluateBuildFreshness({ running: 'bbb2222', installedOnDisk: 'bbb2222', repoHead: 'ccc3333' });
-  expect(r).toMatchObject({ ok: true, restartNeeded: false, publishNeeded: true });
-});
-
-test('both differ → both reported, still ok (non-critical)', () => {
-  const r = evaluateBuildFreshness({ running: 'aaa1111', installedOnDisk: 'bbb2222', repoHead: 'ccc3333' });
-  expect(r).toMatchObject({ ok: true, restartNeeded: true, publishNeeded: true });
-  expect(r.note).toMatch(/restart needed/);
-  expect(r.note).toMatch(/publish needed/);
-});
-
-test('unknown inputs never claim a difference; short/long sha prefixes match', () => {
-  expect(evaluateBuildFreshness({})).toMatchObject({ restartNeeded: false, publishNeeded: false });
-  expect(evaluateBuildFreshness({ running: null, installedOnDisk: 'abc1234', repoHead: 'abc1234567890' }))
-    .toMatchObject({ restartNeeded: false, publishNeeded: false });
-});

package/src/main/__tests__/health-claude-md-budget.test.cjs

@@ -1,57 +0,0 @@
-/**
- * health-claude-md-budget.test.cjs — CLAUDE.md SIZE BUDGET enforcement
- * (PRD 1039, following CLAUDE.md's growth from 3,871 to 65,768 chars between
- * 2026-05-09 and 2026-08-13 with zero of 359 PRDs ever pruning it). Exercises
- * parseClaudeMdBudget()/evaluateClaudeMdBudget() directly since they're pure —
- * no need to spawn the full check() to cover this.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-claude-md-budget.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { parseClaudeMdBudget, evaluateClaudeMdBudget } = require('../health.cjs');
-
-test('under budget reports ok with no issue', () => {
-  const result = evaluateClaudeMdBudget(11873, 12000);
-  expect(result.ok).toBe(true);
-  expect(result.applicable).toBe(true);
-  expect(result.message).toBeUndefined();
-});
-
-test('exactly at budget reports ok with no issue', () => {
-  const result = evaluateClaudeMdBudget(12000, 12000);
-  expect(result.ok).toBe(true);
-  expect(result.applicable).toBe(true);
-});
-
-test('over budget reports one issue with actual size and budget in the message', () => {
-  const result = evaluateClaudeMdBudget(13210, 12000);
-  expect(result.ok).toBe(false);
-  expect(result.overage).toBe(1210);
-  expect(result.message).toContain('13210');
-  expect(result.message).toContain('12000');
-  expect(result.message).toContain('1210');
-});
-
-test('no SIZE BUDGET line present -> parses to null, evaluator skips silently', () => {
-  const text = '# Some Project\n\nJust a normal CLAUDE.md with no budget declared.\n';
-  const budget = parseClaudeMdBudget(text);
-  expect(budget).toBeNull();
-  const result = evaluateClaudeMdBudget(50000, budget);
-  expect(result.ok).toBe(true);
-  expect(result.applicable).toBe(false);
-});
-
-test('malformed/unparseable budget line -> null, no throw', () => {
-  const text = '> **SIZE BUDGET — a lot of chars**, checked before every commit.';
-  expect(() => parseClaudeMdBudget(text)).not.toThrow();
-  const budget = parseClaudeMdBudget(text);
-  expect(budget).toBeNull();
-});
-
-test('comma-separated form parses to a plain integer', () => {
-  const text = '> **SIZE BUDGET — 12,000 chars**, checked with `wc -c CLAUDE.md` before every commit.';
-  expect(parseClaudeMdBudget(text)).toBe(12000);
-});

package/src/main/__tests__/health-credentials.test.cjs

@@ -1,81 +0,0 @@
-/**
- * health-credentials.test.cjs — the credential health component.
- *
- * An expired/absent Claude OAuth token silently voids the whole scheduler:
- * headless `claude -p` jobs cannot authenticate, so the queue "runs" but
- * nothing completes. On this machine the token expired 2026-04-04 with no
- * refresh token, yet `npm run health` read GREEN — no component pointed the
- * operator at `claude login`. evaluateCredentialHealth is the missing signal.
- * Pure over an injected credState (the shape refreshIfNeeded returns), so no
- * Keychain access here.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-credentials.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { evaluateCredentialHealth } = require('../health.cjs');
-
-const NOW = Date.parse('2026-09-23T15:00:00.000Z');
-
-test('an expired token is not ok, names claude login, and reports how long ago it lapsed', () => {
-  const expiredAt = NOW - 90 * 60_000; // 90 min ago
-  const { component, issues } = evaluateCredentialHealth({
-    credState: { kind: 'auth', message: 'Credentials expired.', expiredAt },
-    now: NOW,
-  });
-  expect(component.ok).toBe(false);
-  expect(component.state).toBe('expired');
-  expect(component.expiredAt).toBe(expiredAt);
-  expect(component.message).toMatch(/claude login/);
-  expect(component.message).toMatch(/90m ago/);
-  expect(issues.length).toBe(1);
-  expect(issues[0]).toMatch(/cannot authenticate/i);
-});
-
-test('an auth failure with no expiredAt still fails and still names the fix', () => {
-  const { component, issues } = evaluateCredentialHealth({
-    credState: { kind: 'auth', message: 'refresh rejected: HTTP 401' },
-    now: NOW,
-  });
-  expect(component.ok).toBe(false);
-  expect(component.state).toBe('expired');
-  expect(component.message).toMatch(/claude login/);
-  expect(component.message).not.toMatch(/NaN/);
-  expect(issues.length).toBe(1);
-});
-
-test('unreadable/absent credentials (kind:config) fail with the login fix', () => {
-  const { component, issues } = evaluateCredentialHealth({
-    credState: { kind: 'config', message: 'credentials not found' },
-    now: NOW,
-  });
-  expect(component.ok).toBe(false);
-  expect(component.state).toBe('unreadable');
-  expect(component.message).toMatch(/claude login/);
-  expect(issues.length).toBe(1);
-});
-
-test('a fresh token is ok and raises no issue', () => {
-  const { component, issues } = evaluateCredentialHealth({ credState: { kind: 'ok' }, now: NOW });
-  expect(component.ok).toBe(true);
-  expect(component.state).toBe('valid');
-  expect(issues.length).toBe(0);
-});
-
-test('kind:unsupported (auto-refresh unavailable, token still valid) is ok — the token works, refresh just can not', () => {
-  const { component, issues } = evaluateCredentialHealth({ credState: { kind: 'unsupported' }, now: NOW });
-  expect(component.ok).toBe(true);
-  expect(component.state).toBe('valid-no-refresh');
-  expect(issues.length).toBe(0);
-});
-
-test('a missing/garbage credState never throws and never fails health (unknown, not a false alarm)', () => {
-  for (const bad of [undefined, null, 'nope', 42]) {
-    const { component, issues } = evaluateCredentialHealth({ credState: bad, now: NOW });
-    expect(component.ok).toBe(true);
-    expect(component.state).toBe('unknown');
-    expect(issues.length).toBe(0);
-  }
-});

package/src/main/__tests__/health-delegation-chain.test.cjs

@@ -1,124 +0,0 @@
-/**
- * health-delegation-chain.test.cjs — "can this machine actually delegate
- * work to the scheduler?" health section (PRD 1049), built on top of the
- * delegation-readiness probe (delegationReadiness.cjs, PRD 1048). Exercises
- * evaluateDelegationChainHealth() directly since it's pure — no need to spawn
- * the full check() to cover shaping/degradation — plus one end-to-end check()
- * run against this repo's own real config, where every check is expected to
- * pass (this repo registers the scheduler MCP in its own .mcp.json and wires
- * guard-prd-writes in .claude/settings.json).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-delegation-chain.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { evaluateDelegationChainHealth, check } = require('../health.cjs');
-
-function makeCheck(id, ok, overrides = {}) {
-  return { id, label: `${id} label`, ok, detail: `${id} detail`, fix: ok ? null : `fix ${id}`, ...overrides };
-}
-
-test('all checks passing -> component ok, no issues', () => {
-  const delegationResult = {
-    ok: true,
-    checks: [
-      makeCheck('scheduler-mcp', true),
-      makeCheck('scheduler-mcp-live', true),
-      makeCheck('scheduler-mcp-project-duplicate', true, { warn: false }),
-      makeCheck('dev-plugin', true),
-      makeCheck('agent-personas', true),
-      makeCheck('prd-write-guard', true),
-    ],
-  };
-  const { component, issues } = evaluateDelegationChainHealth(delegationResult);
-  expect(component.ok).toBe(true);
-  expect(component.checks).toHaveLength(6);
-  expect(issues).toEqual([]);
-});
-
-test('one failing check -> component not ok, one issue citing label/detail/fix', () => {
-  const delegationResult = {
-    ok: false,
-    checks: [
-      makeCheck('scheduler-mcp', false, { label: 'Scheduler MCP server registered', detail: 'no entry found', fix: 'claude mcp add ...' }),
-      makeCheck('scheduler-mcp-live', true, { skipped: true }),
-      makeCheck('scheduler-mcp-project-duplicate', true, { warn: false }),
-      makeCheck('dev-plugin', true),
-      makeCheck('agent-personas', true),
-      makeCheck('prd-write-guard', true),
-    ],
-  };
-  const { component, issues } = evaluateDelegationChainHealth(delegationResult);
-  expect(component.ok).toBe(false);
-  expect(issues).toHaveLength(1);
-  expect(issues[0]).toContain('Scheduler MCP server registered');
-  expect(issues[0]).toContain('no entry found');
-  expect(issues[0]).toContain('claude mcp add ...');
-});
-
-test('multiple failing checks -> one issue per failing check, passing checks silent', () => {
-  const delegationResult = {
-    ok: false,
-    checks: [
-      makeCheck('scheduler-mcp', false),
-      makeCheck('scheduler-mcp-live', false),
-      makeCheck('scheduler-mcp-project-duplicate', true, { warn: false }),
-      makeCheck('dev-plugin', false),
-      makeCheck('agent-personas', true),
-      makeCheck('prd-write-guard', true),
-    ],
-  };
-  const { issues } = evaluateDelegationChainHealth(delegationResult);
-  expect(issues).toHaveLength(3);
-});
-
-test('failing check with no fix omits the "(fix: ...)" suffix', () => {
-  const delegationResult = {
-    ok: false,
-    checks: [makeCheck('scheduler-mcp', false, { fix: null })],
-  };
-  const { issues } = evaluateDelegationChainHealth(delegationResult);
-  expect(issues[0]).not.toContain('(fix:');
-});
-
-test('end-to-end: check() reports delegation_chain for this repo, expected to pass here', async () => {
-  // Probes THIS machine's real user-scope config (~/.claude.json MCP registration, guard
-  // shims), so it reads the real home — not the per-run sandbox HOME. Read-only: scheduler
-  // state stays redirected to the sandbox (SM_SCHEDULER_HOME re-pinned after the HOME swap).
-  const sandboxHome = process.env.HOME;
-  const sandboxSchedulerHome = process.env.SM_SCHEDULER_HOME;
-  process.env.HOME = require('node:os').userInfo().homedir;
-  if (sandboxSchedulerHome !== undefined) process.env.SM_SCHEDULER_HOME = sandboxSchedulerHome;
-  process.env.SM_ALLOW_LIVE_ROOT_READS = '1';
-  let status;
-  try {
-    // skipTypecheck: this test asserts on delegation_chain only; the tsc shell-out was
-    // ~15s of the ~16s idle runtime and starved to the 90s budget under CPU load.
-    status = await check({ skipTypecheck: true });
-  } finally {
-    delete process.env.SM_ALLOW_LIVE_ROOT_READS;
-    process.env.HOME = sandboxHome;
-  }
-  expect(status.components.delegation_chain).toBeDefined();
-  expect(status.components.delegation_chain.checks).toHaveLength(9);
-  const ids = status.components.delegation_chain.checks.map((c) => c.id);
-  expect(ids).toEqual([
-    'scheduler-mcp',
-    'scheduler-mcp-live',
-    'scheduler-mcp-project-duplicate',
-    'dev-plugin',
-    'agent-personas',
-    'prd-write-guard',
-    'destructive-git-guard',
-    'inline-implementation-guard',
-    'self-schedule-guard',
-  ]);
-  // This repo registers the scheduler MCP at user scope (~/.claude.json) and
-  // wires guard-prd-writes in .claude/settings.json, and no longer carries a
-  // project-scope duplicate in its own .mcp.json, so on this machine every
-  // check is expected to pass — a failure here means the probe or the
-  // wiring is wrong, not that the assertion should be relaxed.
-  expect(status.components.delegation_chain.ok).toBe(true);
-}, 90_000);

package/src/main/__tests__/health-per-project-stall.test.cjs

@@ -1,84 +0,0 @@
-/**
- * health-per-project-stall.test.cjs — per-project problem-count rollup and
- * per-project stall-past-threshold escalation for the scheduler_queue health
- * check. Covers the gap where a project holding ONLY failed/needs_review/
- * quarantined rows (0 running, 0 pending) never tripped evaluateTickLiveness
- * (which requires actual pending work) — the exact way the burrow project's
- * four quarantined PRDs went dark.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-per-project-stall.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — see the sibling note in
-// scheduler-stall-per-project.test.cjs. node:assert works inside vitest.
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const {
-  computeProjectProblemCounts,
-  evaluatePerProjectStall,
-  TICK_STALL_THRESHOLD_MS,
-} = require('../health.cjs');
-const { computeStallSummary } = require('../scheduler.cjs');
-
-test('computeProjectProblemCounts: breaks down failed/needs_review/quarantined by project, ignores healthy statuses', () => {
-  const jobs = [
-    { slug: 'a', cwd: '/burrow', status: 'quarantined' },
-    { slug: 'b', cwd: '/burrow', status: 'quarantined' },
-    { slug: 'c', cwd: '/burrow', status: 'quarantined' },
-    { slug: 'd', cwd: '/burrow', status: 'quarantined' },
-    { slug: 'e', cwd: '/other', status: 'failed' },
-    { slug: 'f', cwd: '/other', status: 'needs_review' },
-    { slug: 'g', cwd: '/other', status: 'running' },
-    { slug: 'h', cwd: '/other', status: 'pending' },
-    { slug: 'i', cwd: '/other', status: 'completed' },
-  ];
-  const counts = computeProjectProblemCounts(jobs);
-  assert.deepStrictEqual(counts['/burrow'], { failed: 0, needs_review: 0, quarantined: 4 });
-  assert.deepStrictEqual(counts['/other'], { failed: 1, needs_review: 1, quarantined: 0 });
-});
-
-test('evaluatePerProjectStall: fully-stalled project past threshold flags pastThreshold=true', () => {
-  const state = {
-    lastRunAt: new Date(Date.now() - (TICK_STALL_THRESHOLD_MS + 60_000)).toISOString(),
-    paused: null,
-    jobs: [
-      { slug: 'a', cwd: '/burrow', status: 'quarantined' },
-      { slug: 'b', cwd: '/other', status: 'running' },
-    ],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  const result = evaluatePerProjectStall(summary, state.lastRunAt, Date.now(), TICK_STALL_THRESHOLD_MS);
-  assert.strictEqual(result['/burrow'].stalled, true);
-  assert.strictEqual(result['/burrow'].pastThreshold, true);
-  assert.strictEqual(result['/other'].stalled, false);
-});
-
-test('evaluatePerProjectStall: stalled but NOT yet past threshold flags pastThreshold=false', () => {
-  const state = {
-    lastRunAt: new Date(Date.now() - 1000).toISOString(), // just ticked
-    paused: null,
-    jobs: [{ slug: 'a', cwd: '/burrow', status: 'quarantined' }],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  const result = evaluatePerProjectStall(summary, state.lastRunAt, Date.now(), TICK_STALL_THRESHOLD_MS);
-  assert.strictEqual(result['/burrow'].stalled, true);
-  assert.strictEqual(result['/burrow'].pastThreshold, false);
-});
-
-test('evaluatePerProjectStall: no lastRunAt yet — stalled but not asserted past threshold (caveat, not a false RED)', () => {
-  const state = {
-    lastRunAt: null,
-    paused: null,
-    jobs: [{ slug: 'a', cwd: '/burrow', status: 'quarantined' }],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  const result = evaluatePerProjectStall(summary, state.lastRunAt, Date.now(), TICK_STALL_THRESHOLD_MS);
-  assert.strictEqual(result['/burrow'].stalled, true);
-  assert.strictEqual(result['/burrow'].pastThreshold, false);
-  assert.strictEqual(result['/burrow'].caveat, 'no-lastRunAt');
-});

package/src/main/__tests__/health-prd-migration.test.cjs

@@ -1,37 +0,0 @@
-/**
- * health-prd-migration.test.cjs — stranded-PRD-migration health signal
- * (behind two real 2026-07-31 incidents: a single stranded PRD causing an
- * instant ENOENT job failure, and 223 stranded legacy PRDs + a missing
- * history.jsonl resurrecting 189 completed jobs). Exercises
- * evaluatePrdMigrationHealth() directly since it's pure — no need to spawn
- * the full check() (which shells out to npm run typecheck) to cover this.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-prd-migration.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { evaluatePrdMigrationHealth } = require('../health.cjs');
-
-const LEGACY_DIR = '/home/user/.claude/session-manager/scheduled-plans/prds';
-
-test('reports ok when nothing is stranded', () => {
-  const result = evaluatePrdMigrationHealth({ moved: 3, skipped: 0, unresolved: [] }, LEGACY_DIR);
-  expect(result.ok).toBe(true);
-  expect(result.strandedCount).toBe(0);
-  expect(result.legacyDir).toBe(LEGACY_DIR);
-  expect(result.unresolved).toBeUndefined();
-});
-
-test('reports RED with count and legacy dir path when files are stranded', () => {
-  const unresolved = [
-    { file: '01-stuck.md', reason: 'no cwd in frontmatter' },
-    { file: '02-stuck.md', reason: 'cwd does not exist on disk' },
-  ];
-  const result = evaluatePrdMigrationHealth({ moved: 0, skipped: 0, unresolved }, LEGACY_DIR);
-  expect(result.ok).toBe(false);
-  expect(result.strandedCount).toBe(2);
-  expect(result.legacyDir).toBe(LEGACY_DIR);
-  expect(result.unresolved).toEqual(unresolved);
-});

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

@@ -1,135 +0,0 @@
-/**
- * health-queue-dispatch.test.cjs — `npm run health` must report non-GREEN
- * when there is at least one DISPATCHABLE pending job (reusing
- * classifyQueueStarvation's own 'starved' verdict, not merely "pending"),
- * nothing running, and no launch in a long time — the exact shape
- * of the 2026-09-11 incident (27 pending across two projects, 0 running, for
- * days, every other health surface reporting green). A dependsOn-blocked
- * queue must NOT trip this the same way: ticking can't fix a blocked chain,
- * so it stays GREEN (reported as 'blocked' instead, distinctly).
- *
- * Exercises evaluateQueueDispatchHealth() directly — pure, no fs — matching
- * every other evaluate* helper's test pattern in this file (see
- * health-usage-poller.test.cjs's header).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/health-queue-dispatch.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { evaluateQueueDispatchHealth, DISPATCH_STALL_THRESHOLD_MS, DISPATCH_WARN_THRESHOLD_MS } = require('../health.cjs');
-
-const CWD = '/home/bilko/Projects/starry-night-ships';
-const NOW = Date.parse('2026-09-11T12:00:00.000Z');
-const idleFor = (ms) => new Date(NOW - ms).toISOString();
-
-test('a dispatchable pending job, 0 running, stale past the threshold — non-GREEN, starved', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-    paused: null,
-    lastRunAt: idleFor(DISPATCH_STALL_THRESHOLD_MS + 60_000),
-  };
-  const result = evaluateQueueDispatchHealth(state, 0, NOW);
-  expect(result.ok).toBe(false);
-  expect(result.starved).toBe(true);
-  expect(result.dispatchable).toBe(1);
-  expect(result.message).toMatch(/dispatch appears stuck/);
-});
-
-test('every pending row behind a blocked dependsOn chain stays GREEN, reported as blocked', () => {
-  const state = {
-    jobs: [
-      { slug: 'dead', cwd: CWD, status: 'failed', dependsOn: [] },
-      { slug: 'blocked-child', cwd: CWD, status: 'pending', dependsOn: ['dead'] },
-    ],
-    paused: null,
-    lastRunAt: idleFor(DISPATCH_STALL_THRESHOLD_MS + 60_000),
-  };
-  const result = evaluateQueueDispatchHealth(state, 0, NOW);
-  expect(result.ok).toBe(true);
-  expect(result.blocked).toBe(true);
-  expect(result.starved).toBeUndefined();
-  expect(result.message).toMatch(/blocked/);
-});
-
-test('healthy queue (recent dispatch attempt) is GREEN with no verdict', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-    paused: null,
-    lastRunAt: idleFor(60_000),
-  };
-  const result = evaluateQueueDispatchHealth(state, 0, NOW);
-  expect(result).toEqual({ ok: true });
-});
-
-test('nothing pending is GREEN regardless of how stale the dispatch timestamp is', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'completed' }],
-    paused: null,
-    lastRunAt: idleFor(DISPATCH_STALL_THRESHOLD_MS + 60_000),
-  };
-  const result = evaluateQueueDispatchHealth(state, 0, NOW);
-  expect(result).toEqual({ ok: true });
-});
-
-test('work already running is GREEN — the queue is flowing', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-    paused: null,
-    lastRunAt: idleFor(DISPATCH_STALL_THRESHOLD_MS + 60_000),
-  };
-  const result = evaluateQueueDispatchHealth(state, 1, NOW);
-  expect(result).toEqual({ ok: true });
-});
-
-test('the two tiers are exported: 15-minute warn, 2-hour cold report', () => {
-  expect(DISPATCH_WARN_THRESHOLD_MS).toBe(15 * 60_000);
-  expect(DISPATCH_STALL_THRESHOLD_MS).toBe(2 * 60 * 60_000);
-});
-
-test('starved between the warn and cold thresholds — ok:true but flagged warn', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-    paused: null,
-    lastRunAt: idleFor(DISPATCH_WARN_THRESHOLD_MS + 60_000),
-  };
-  const result = evaluateQueueDispatchHealth(state, 0, NOW);
-  expect(result.ok).toBe(true);
-  expect(result.warn).toBe(true);
-  expect(result.starved).toBeUndefined();
-  expect(result.dispatchable).toBe(1);
-});
-
-test('below the warn threshold is plain GREEN', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-    paused: null,
-    lastRunAt: idleFor(DISPATCH_WARN_THRESHOLD_MS - 60_000),
-  };
-  expect(evaluateQueueDispatchHealth(state, 0, NOW)).toEqual({ ok: true });
-});
-
-test('ticks that launch nothing (fresh lastDispatchAttemptAt, stale lastRunAt) still go non-GREEN', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-    paused: null,
-    lastDispatchAttemptAt: idleFor(5_000),
-    lastRunAt: idleFor(DISPATCH_STALL_THRESHOLD_MS + 60_000),
-  };
-  const result = evaluateQueueDispatchHealth(state, 0, NOW);
-  expect(result.ok).toBe(false);
-  expect(result.starved).toBe(true);
-});
-
-test('rows held by an open launch breaker read blocked, not starved', () => {
-  const state = {
-    jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-    paused: null,
-    lastRunAt: idleFor(DISPATCH_STALL_THRESHOLD_MS + 60_000),
-    launchBlocks: { default: { kind: 'auth', at: NOW - 1000 } },
-  };
-  const result = evaluateQueueDispatchHealth(state, 0, NOW);
-  expect(result.ok).toBe(true);
-  expect(result.blocked).toBe(true);
-});