claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,312 +0,0 @@
-'use strict';
-
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerBatchDepends.test.cjs
-//
-// Regression coverage for dependsOn eligibility in pickForProject. The
-// bare-slug cases below are the ones that shipped broken: a PRD's filename
-// carries the auto-allocated `NN-` prefix, but `dependsOn:` is authored with
-// the bare name (the author can't know the number the allocator will issue),
-// so every such dep silently resolved to "no row -> already done" and the
-// gate never held anything.
-
-// vitest globals (test) — same convention as the other .cjs tests.
-const assert = require('node:assert/strict');
-const { pickForProject, findBlockingDep, DEFAULT_PROJECT_CWD, DEP_HISTORY_FAIL_OPEN } = require('../schedulerBatch.cjs');
-
-const CWD = DEFAULT_PROJECT_CWD;
-
-function job(slug, status, extra = {}) {
-return {
-  slug,
-  status,
-  cwd: CWD,
-  parallelGroup: Number(String(slug).match(/^(\d+)-/)?.[1] ?? 99),
-  dependsOn: [],
-  ...extra,
-};
-}
-
-function pick(jobs, running = new Set(), slots = 3) {
-return pickForProject(jobs, running, slots);
-}
-
-test('holds a dependent whose bare-named dep is still running (NN- prefix stripped)', () => {
-  const jobs = [
-    job('873-leftnav-two-face-framework', 'running'),
-    job('874-nav-face-project-home', 'pending', { dependsOn: ['leftnav-two-face-framework'] }),
-  ];
-  const { batch } = pick(jobs, new Set(['873-leftnav-two-face-framework']));
-  assert.deepEqual(batch.map((j) => j.slug), []);
-});
-
-test('holds a dependent whose bare-named dep is still pending', () => {
-  const jobs = [
-    job('873-leftnav-two-face-framework', 'pending'),
-    job('895-home-global-behavior-settings', 'pending', {
-      dependsOn: ['leftnav-two-face-framework', 'nav-face-session-manager-config'],
-    }),
-    job('890-nav-face-session-manager-config', 'pending', {
-      dependsOn: ['leftnav-two-face-framework'],
-    }),
-  ];
-  const { batch } = pick(jobs);
-  // Only the framework PRD (no deps) is eligible; both dependents are held.
-  assert.deepEqual(batch.map((j) => j.slug), ['873-leftnav-two-face-framework']);
-});
-
-test('releases a dependent once its bare-named dep is completed', () => {
-  const jobs = [
-    job('873-leftnav-two-face-framework', 'completed'),
-    job('874-nav-face-project-home', 'pending', { dependsOn: ['leftnav-two-face-framework'] }),
-  ];
-  const { batch } = pick(jobs);
-  assert.deepEqual(batch.map((j) => j.slug), ['874-nav-face-project-home']);
-});
-
-test('still resolves an exact-slug dep (dep written WITH the NN- prefix)', () => {
-  const jobs = [
-    job('873-leftnav-two-face-framework', 'pending'),
-    job('874-nav-face-project-home', 'pending', {
-      dependsOn: ['873-leftnav-two-face-framework'],
-    }),
-  ];
-  const { batch } = pick(jobs);
-  assert.deepEqual(batch.map((j) => j.slug), ['873-leftnav-two-face-framework']);
-});
-
-// PRD 1122 — a dep slug with no live row is no longer auto-satisfied by
-// absence alone. It must show up in the caller's precomputed
-// history/archive Set (5th arg, built once per tick by
-// scheduler.cjs's computeDepHistorySatisfaction) or it HOLDS as
-// 'unresolved'. Observed live on starry-night-ships: a typo'd/format-
-// mismatched dep slug used to be silently indistinguishable from one
-// genuinely retired to history.
-test('a dep with no row IS treated as done when the caller supplies it as history/archive-satisfied', () => {
-  const jobs = [
-    job('874-nav-face-project-home', 'pending', { dependsOn: ['some-long-archived-prd'] }),
-  ];
-  const { batch } = pickForProject(jobs, new Set(), 3, new Map(), new Set(['some-long-archived-prd']));
-  assert.deepEqual(batch.map((j) => j.slug), ['874-nav-face-project-home']);
-});
-
-test('a dep with no row and NOT in the history/archive set HOLDS as unresolved, with a named actionable reason', () => {
-  const jobs = [
-    job('874-nav-face-project-home', 'pending', { dependsOn: ['some-typo-d-prd'] }),
-  ];
-  const { batch, reason, holds } = pick(jobs);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /depends-gate/);
-  assert.match(reason, /unresolvable dependencies/);
-  assert.match(reason, /874-nav-face-project-home <- some-typo-d-prd/);
-  assert.match(reason, /fix the dependsOn entry or archive the dependent/);
-  const hold = holds.find((h) => h.slug === '874-nav-face-project-home');
-  assert.equal(hold.depStatus, 'unresolved');
-});
-
-test('the double-prefixed-row regression: a row named 253-253-x referenced as bare x holds as unresolved', () => {
-  // bareSlug strips exactly ONE leading `NN-` run, so '253-253-x' bares to
-  // '253-x' — it does NOT bare-match dependsOn's 'x'. The double-prefixed row
-  // is therefore genuinely invisible to both exact and bare matching, the
-  // same as a typo — this is the exact 2026-09-06 starry-night-ships report.
-  const jobs = [
-    job('253-253-x', 'running'),
-    job('254-next', 'pending', { dependsOn: ['x'] }),
-  ];
-  const { batch, holds, reason } = pick(jobs);
-  assert.deepEqual(batch.map((j) => j.slug), []);
-  assert.match(reason, /unresolvable dependencies/);
-  const hold = holds.find((h) => h.slug === '254-next');
-  assert.equal(hold.dep, 'x');
-  assert.equal(hold.depStatus, 'unresolved');
-});
-
-test('DEP_HISTORY_FAIL_OPEN preserves the pre-1122 fail-open behaviour for a read failure', () => {
-  const jobs = [
-    job('874-nav-face-project-home', 'pending', { dependsOn: ['some-long-archived-prd'] }),
-  ];
-  const { batch } = pickForProject(jobs, new Set(), 3, new Map(), DEP_HISTORY_FAIL_OPEN);
-  assert.deepEqual(batch.map((j) => j.slug), ['874-nav-face-project-home']);
-});
-
-test('findBlockingDep: bare-name resolution against satisfiedSlugs matches the live-row bare-name rule', () => {
-  const dependent = job('254-next', 'pending', { dependsOn: ['x'] });
-  assert.equal(findBlockingDep(dependent, [dependent], new Set(['253-x'])), undefined);
-  assert.equal(findBlockingDep(dependent, [dependent], new Set()), 'x');
-});
-
-test('a FAILED bare-named dep holds the dependent and reports an explicit reason', () => {
-  const jobs = [
-    job('873-leftnav-two-face-framework', 'failed'),
-    job('874-nav-face-project-home', 'pending', { dependsOn: ['leftnav-two-face-framework'] }),
-  ];
-  const { batch, reason } = pick(jobs);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /depends-gate/);
-  assert.match(reason, /874-nav-face-project-home <- leftnav-two-face-framework/);
-});
-
-test('a SKIPPED (never-ran) bare-named dep holds the dependent and reports an explicit reason', () => {
-  const jobs = [
-    job('873-leftnav-two-face-framework', 'skipped'),
-    job('874-nav-face-project-home', 'pending', { dependsOn: ['leftnav-two-face-framework'] }),
-  ];
-  const { batch, reason } = pick(jobs);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /depends-gate/);
-  assert.match(reason, /never-ran dependencies/);
-  assert.match(reason, /874-nav-face-project-home <- leftnav-two-face-framework/);
-});
-
-// ---------------------------------------------------------------------------
-// Parallelism regression coverage.
-//
-// `parallelGroup` used to gate batch membership: the picker fired at most one
-// group per tick and held every higher group while a lower one was in flight.
-// PRD 832 made the number strictly unique per PRD, so every group became a
-// singleton and the batch was always exactly ONE job — measured max
-// concurrency 1 across 25 recorded runs against a 5-slot pool. These tests
-// pin the corrected contract: dependsOn is the only barrier, parallelGroup is
-// a priority hint.
-// ---------------------------------------------------------------------------
-
-test('fires EVERY dependency-eligible job, not one per parallelGroup', () => {
-  // This test predates the per-project job cap (PRD 1066, default 2) and
-  // asserts against the parallelGroup barrier specifically — raise the cap
-  // so it isn't incidentally exercising that unrelated limit.
-  const prevCap = process.env.SM_PROJECT_JOB_CAP;
-  process.env.SM_PROJECT_JOB_CAP = '10';
-  try {
-    const jobs = [
-      job('983-a', 'pending'),
-      job('984-b', 'pending'),
-      job('985-c', 'pending'),
-      job('986-d', 'pending'),
-    ];
-    const { batch } = pick(jobs, new Set(), 5);
-    // Pre-fix this returned exactly ['983-a'] — one singleton group.
-    assert.deepEqual(batch.map((j) => j.slug), ['983-a', '984-b', '985-c', '986-d']);
-  } finally {
-    if (prevCap === undefined) delete process.env.SM_PROJECT_JOB_CAP;
-    else process.env.SM_PROJECT_JOB_CAP = prevCap;
-  }
-});
-
-test('a higher-numbered job is NOT held behind an in-flight lower-numbered one', () => {
-  const jobs = [
-    job('979-running', 'running'),
-    job('988-independent', 'pending'),
-  ];
-  const { batch } = pick(jobs, new Set(['979-running']), 5);
-  // Pre-fix: held by the running-gate ("g979 in flight, holding g988"), which
-  // is how the fix for this very bug ended up stuck behind the bug.
-  assert.deepEqual(batch.map((j) => j.slug), ['988-independent']);
-});
-
-test('dependency-blocked jobs are excluded while independent siblings fire together', () => {
-  const jobs = [
-    job('985-foundation', 'pending'),
-    job('986-dependent', 'pending', { dependsOn: ['foundation'] }),
-    job('987-independent', 'pending'),
-  ];
-  const { batch } = pick(jobs, new Set(), 5);
-  assert.deepEqual(batch.map((j) => j.slug), ['985-foundation', '987-independent']);
-});
-
-test('a FAILED job holds its transitive dependents but not unrelated jobs', () => {
-  const jobs = [
-    job('980-broken', 'failed'),
-    job('981-direct', 'pending', { dependsOn: ['broken'] }),
-    job('982-transitive', 'pending', { dependsOn: ['direct'] }),
-    job('983-unrelated', 'pending'),
-  ];
-  const { batch } = pick(jobs, new Set(), 5);
-  // Pre-fix the cross-group failure gate held 983 too, purely for having a
-  // higher number than the failure.
-  assert.deepEqual(batch.map((j) => j.slug), ['983-unrelated']);
-});
-
-test('parallelGroup orders the batch when eligible jobs exceed free slots', () => {
-  const jobs = [
-    job('990-c', 'pending'),
-    job('988-a', 'pending'),
-    job('989-b', 'pending'),
-  ];
-  const { batch } = pick(jobs, new Set(), 2);
-  assert.deepEqual(batch.map((j) => j.slug), ['988-a', '989-b']);
-});
-
-test('zero free slots holds everything with an explicit reason', () => {
-  const jobs = [job('988-a', 'pending'), job('989-b', 'pending')];
-  const { batch, reason } = pick(jobs, new Set(), 0);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /no slots free/);
-});
-
-// ---------------------------------------------------------------------------
-// Per-job hold records (PRD 990). The picker already knew exactly which dep
-// held which row; it only ever reached console.log. These pin it as data.
-// ---------------------------------------------------------------------------
-
-test('reports a per-job hold record naming the blocking dep and its status', () => {
-  const jobs = [
-    job('985-foundation', 'pending'),
-    job('986-dependent', 'pending', { dependsOn: ['foundation'] }),
-  ];
-  const { batch, holds } = pick(jobs, new Set(), 5);
-  assert.deepEqual(batch.map((j) => j.slug), ['985-foundation']);
-  assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'pending', rootSlug: '985-foundation', rootStatus: 'pending' },
-  ]);
-});
-
-test('hold record carries a running dep status', () => {
-  const jobs = [
-    job('985-foundation', 'running'),
-    job('986-dependent', 'pending', { dependsOn: ['foundation'] }),
-  ];
-  const { holds } = pick(jobs, new Set(['985-foundation']), 5);
-  assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'running', rootSlug: '985-foundation', rootStatus: 'running' },
-  ]);
-});
-
-test('hold record carries a failed dep status alongside the depends-gate reason', () => {
-  const jobs = [
-    job('985-foundation', 'failed'),
-    job('986-dependent', 'pending', { dependsOn: ['foundation'] }),
-  ];
-  const { batch, reason, holds } = pick(jobs, new Set(), 5);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /depends-gate/);
-  assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'failed', rootSlug: '985-foundation', rootStatus: 'failed' },
-  ]);
-});
-
-test('hold record carries a skipped dep status alongside the depends-gate reason', () => {
-  const jobs = [
-    job('985-foundation', 'skipped'),
-    job('986-dependent', 'pending', { dependsOn: ['foundation'] }),
-  ];
-  const { batch, reason, holds } = pick(jobs, new Set(), 5);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /depends-gate/);
-  assert.match(reason, /never-ran dependencies/);
-  assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'skipped', rootSlug: '985-foundation', rootStatus: 'skipped' },
-  ]);
-});
-
-test('no holds when nothing is dependency-blocked', () => {
-  const jobs = [job('988-a', 'pending'), job('989-b', 'pending')];
-  const { batch, holds } = pick(jobs, new Set(), 5);
-  assert.equal(batch.length, 2);
-  assert.deepEqual(holds, []);
-});
-
-test('an idle queue reports no holds (empty must not read as blocked)', () => {
-  const jobs = [job('988-a', 'completed')];
-  const { batch, holds } = pick(jobs, new Set(), 5);
-  assert.deepEqual(batch, []);
-  assert.deepEqual(holds, []);
-});

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

@@ -1,213 +0,0 @@
-'use strict';
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerBatchFairness.test.cjs
-//
-// PRDs 1086 + 1087 — cross-project fairness and starvation escalation.
-// pickNextBatch used to order projects by their lowest pending parallelGroup.
-// NN numbers are allocated PER PROJECT and only grow, so that compared
-// unrelated sequences: on 2026-09-01 social-signals-trader (8 pending, lowest
-// NN 3887) got zero starts for 3.5 h while starry-night-ships (lowest NN 158)
-// took every freed slot. These tests pin the replacement contract: fewest
-// running first, oldest pending as tiebreak, cwd last, and ROUND-ROBIN slot
-// hand-out — plus the escalation that makes any regression visible.
-const assert = require('node:assert/strict');
-const {
-  pickNextBatch, enqueueTimestamp, findStarvedProjects,
-} = require('../schedulerBatch.cjs');
-
-const A = '/home/user/Projects/starry-night-ships';
-const B = '/home/user/Projects/social-signals-trader';
-const C = '/home/user/Projects/burrow';
-const D = '/home/user/Projects/sigma';
-
-function job(slug, status, cwd, extra = {}) {
-  return {
-    slug,
-    status,
-    cwd,
-    parallelGroup: Number(String(slug).match(/^(\d+)-/)?.[1] ?? 99),
-    dependsOn: [],
-    ...extra,
-  };
-}
-const ORIGINAL_CAP_ENV = process.env.SM_PROJECT_JOB_CAP;
-afterEach(() => {
-  if (ORIGINAL_CAP_ENV === undefined) delete process.env.SM_PROJECT_JOB_CAP;
-  else process.env.SM_PROJECT_JOB_CAP = ORIGINAL_CAP_ENV;
-});
-
-// ─── the reported bug ───────────────────────────────────────────────────────
-
-test('a project with high NN numbers is never starved behind a project with low ones (freeSlots=1, repeated ticks)', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [];
-  for (let n = 158; n <= 172; n++) jobs.push(job(`${n}-a`, 'pending', A));
-  for (let n = 3887; n <= 3941; n++) jobs.push(job(`${n}-b`, 'pending', B));
-  const running = new Set();
-  const dispatched = [];
-  for (let tick = 0; tick < 2; tick++) {
-    const { batch } = pickNextBatch(jobs, running, 1);
-    assert.equal(batch.length, 1, `tick ${tick} should dispatch exactly one job`);
-    const picked = batch[0];
-    dispatched.push(picked);
-    // simulate the picked job going to running
-    const row = jobs.find((j) => j.slug === picked.slug);
-    row.status = 'running';
-    running.add(row.slug);
-  }
-  assert.ok(dispatched.some((j) => j.cwd === B), `B must get a start within 2 ticks, got ${dispatched.map((j) => j.slug)}`);
-  assert.ok(dispatched.some((j) => j.cwd === A), 'A still gets its start too');
-});
-
-// ─── round-robin ────────────────────────────────────────────────────────────
-
-test('round-robin: 4 projects x 3 eligible, freeSlots=4 -> exactly one job from each project', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [];
-  for (const [i, cwd] of [A, B, C, D].entries()) {
-    for (let k = 1; k <= 3; k++) jobs.push(job(`${(i + 1) * 100 + k}-${k}`, 'pending', cwd));
-  }
-  const { batch } = pickNextBatch(jobs, new Set(), 4);
-  assert.equal(batch.length, 4);
-  assert.deepEqual(new Set(batch.map((j) => j.cwd)), new Set([A, B, C, D]));
-});
-
-test('round-robin keeps cycling: 2 projects x 3 eligible, freeSlots=4, cap 2 -> 2 from each, not 3+1', () => {
-  process.env.SM_PROJECT_JOB_CAP = '2';
-  const jobs = [
-    job('101-a', 'pending', A), job('102-a', 'pending', A), job('103-a', 'pending', A),
-    job('201-b', 'pending', B), job('202-b', 'pending', B), job('203-b', 'pending', B),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 4);
-  assert.equal(batch.length, 4);
-  assert.equal(batch.filter((j) => j.cwd === A).length, 2);
-  assert.equal(batch.filter((j) => j.cwd === B).length, 2);
-});
-
-test('the per-project cap holds ACROSS passes (a project already at cap is offered nothing more this tick)', () => {
-  process.env.SM_PROJECT_JOB_CAP = '2';
-  const jobs = [
-    job('101-a', 'pending', A), job('102-a', 'pending', A), job('103-a', 'pending', A), job('104-a', 'pending', A),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5);
-  assert.deepEqual(batch.map((j) => j.slug), ['101-a', '102-a']);
-});
-
-test('within a project, parallelGroup ascending is still the priority hint', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [job('105-a', 'pending', A), job('101-a', 'pending', A)];
-  const { batch } = pickNextBatch(jobs, new Set(), 1);
-  assert.equal(batch[0].slug, '101-a');
-});
-
-// ─── ordering keys ──────────────────────────────────────────────────────────
-
-test('fewest running first: a project already running 1 job sorts behind one running 0, even with the older pending job', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('100-a-running', 'running', A),
-    job('101-a', 'pending', A, { queuedAt: '2026-09-01T00:00:00Z' }), // older
-    job('900-b', 'pending', B, { queuedAt: '2026-09-01T01:00:00Z' }), // newer, but B runs nothing
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(['100-a-running']), 1);
-  assert.equal(batch[0].slug, '900-b');
-});
-
-test('tiebreak on the oldest pending enqueue time when running counts are equal', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('101-a', 'pending', A, { queuedAt: '2026-09-01T01:00:00Z' }),
-    job('900-b', 'pending', B, { queuedAt: '2026-09-01T00:00:00Z' }), // older -> first
-  ];
-  assert.equal(pickNextBatch(jobs, new Set(), 1).batch[0].slug, '900-b');
-});
-
-test('unprovable ages sort LAST, and the final tiebreak is the cwd string', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('101-a', 'pending', A), // no timestamp
-    job('900-b', 'pending', B, { queuedAt: '2026-09-01T00:00:00Z' }),
-  ];
-  assert.equal(pickNextBatch(jobs, new Set(), 1).batch[0].slug, '900-b');
-  // Both unprovable -> the lexicographically smaller cwd wins: '.../burrow' (C) < '.../starry-night-ships' (A).
-  const tie = [job('900-b', 'pending', A), job('101-a', 'pending', C)];
-  assert.equal(pickNextBatch(tie, new Set(), 1).batch[0].slug, '101-a');
-});
-
-test('holds are aggregated once per slug across passes and reason is non-null only for an empty batch', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('100-dep', 'failed', A),
-    job('101-a', 'pending', A, { dependsOn: ['100-dep'] }),
-  ];
-  const r = pickNextBatch(jobs, new Set(), 3);
-  assert.equal(r.batch.length, 0);
-  assert.match(r.reason, /failed dependencies/);
-  assert.equal(r.holds.filter((h) => h.slug === '101-a').length, 1);
-});
-
-// ─── enqueueTimestamp ───────────────────────────────────────────────────────
-
-test('enqueueTimestamp resolves createdAt -> queuedAt -> statusHistory(to pending) -> startedAt -> Infinity', () => {
-  const t = (s) => Date.parse(s);
-  assert.equal(enqueueTimestamp({ createdAt: '2026-01-01T00:00:00Z', queuedAt: '2026-02-01T00:00:00Z' }), t('2026-01-01T00:00:00Z'));
-  assert.equal(enqueueTimestamp({ queuedAt: '2026-02-01T00:00:00Z' }), t('2026-02-01T00:00:00Z'));
-  assert.equal(enqueueTimestamp({ statusHistory: [{ from: null, to: 'pending', at: '2026-03-01T00:00:00Z' }] }), t('2026-03-01T00:00:00Z'));
-  assert.equal(enqueueTimestamp({ startedAt: '2026-04-01T00:00:00Z' }), t('2026-04-01T00:00:00Z'));
-  assert.equal(enqueueTimestamp({}), Infinity);
-  assert.equal(enqueueTimestamp({ queuedAt: 'garbage' }), Infinity);
-  assert.equal(enqueueTimestamp(null), Infinity);
-});
-
-// ─── findStarvedProjects (PRD 1087) ────────────────────────────────────────
-
-const NOW = Date.parse('2026-09-01T12:00:00Z');
-const H = 60 * 60_000;
-
-test('a genuinely starved project is reported with its oldest pending slug and age', () => {
-  const jobs = [
-    job('158-a', 'running', A),
-    job('3887-b', 'pending', B, { queuedAt: new Date(NOW - 3 * H).toISOString() }),
-    job('3888-b', 'pending', B, { queuedAt: new Date(NOW - 1 * H).toISOString() }),
-  ];
-  const out = findStarvedProjects(jobs, NOW, 45 * 60_000);
-  assert.equal(out.length, 1);
-  assert.equal(out[0].cwd, B);
-  assert.equal(out[0].pendingCount, 2);
-  assert.equal(out[0].oldestPendingSlug, '3887-b');
-  assert.equal(out[0].ageMs, 3 * H);
-});
-
-test('NOT reported when no project at all is running (idle/paused machine)', () => {
-  const jobs = [job('3887-b', 'pending', B, { queuedAt: new Date(NOW - 5 * H).toISOString() })];
-  assert.deepEqual(findStarvedProjects(jobs, NOW, 45 * 60_000), []);
-});
-
-test('NOT reported when every pending job is younger than the threshold', () => {
-  const jobs = [
-    job('158-a', 'running', A),
-    job('3887-b', 'pending', B, { queuedAt: new Date(NOW - 10 * 60_000).toISOString() }),
-  ];
-  assert.deepEqual(findStarvedProjects(jobs, NOW, 45 * 60_000), []);
-});
-
-test('NOT reported when the project has a running job of its own', () => {
-  const jobs = [
-    job('158-a', 'running', A),
-    job('3880-b', 'running', B),
-    job('3887-b', 'pending', B, { queuedAt: new Date(NOW - 5 * H).toISOString() }),
-  ];
-  assert.deepEqual(findStarvedProjects(jobs, NOW, 45 * 60_000), []);
-});
-
-test('NOT reported (but warned) when the pending rows carry no provable enqueue time', () => {
-  const warns = [];
-  const orig = console.warn;
-  console.warn = (m) => warns.push(String(m));
-  try {
-    const jobs = [job('158-a', 'running', A), job('3887-b', 'pending', B)];
-    assert.deepEqual(findStarvedProjects(jobs, NOW, 45 * 60_000), []);
-    assert.ok(warns.some((w) => w.includes(B) && w.includes('cannot prove age')));
-  } finally {
-    console.warn = orig;
-  }
-});

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

@@ -1,125 +0,0 @@
-'use strict';
-
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerBatchLaunchHold.test.cjs
-//
-// The launch circuit breaker (lib/launchFailure.cjs, issue #11) hands the
-// picker a Map of slug → hold reason. A held row must be invisible to every
-// pick — it must NOT shadow a pickable sibling behind it, must not make a
-// project a round-robin candidate on its own, and must not be offered as a
-// quiet-machine job — while still surfacing as a per-row hold for the UI.
-
-const assert = require('node:assert/strict');
-const { pickForProject, pickNextBatch, DEFAULT_PROJECT_CWD } = require('../schedulerBatch.cjs');
-const { computeLaunchHolds } = require('../../scheduler.cjs');
-const lf = require('../launchFailure.cjs');
-
-const CWD = DEFAULT_PROJECT_CWD;
-
-function job(slug, status = 'pending', extra = {}) {
-  return {
-    slug,
-    status,
-    cwd: CWD,
-    parallelGroup: Number(String(slug).match(/^(\d+)-/)?.[1] ?? 99),
-    dependsOn: [],
-    createdAt: '2026-09-02T18:00:00.000Z',
-    ...extra,
-  };
-}
-
-test('pickForProject: a held row is skipped and the sibling behind it is picked', () => {
-  const jobs = [job('10-blocked'), job('11-free')];
-  const held = new Map([['10-blocked', 'launch blocked (model_config_rejected) — re-probe in 5 min']]);
-  const r = pickForProject(jobs, new Set(), 1, held);
-  assert.deepEqual(r.batch.map((j) => j.slug), ['11-free']);
-  const hold = r.holds.find((h) => h.slug === '10-blocked');
-  assert.ok(hold, 'held row surfaces as a hold record');
-  assert.equal(hold.dep, null);
-  assert.match(hold.reason, /launch blocked/);
-});
-
-test('pickForProject: every pending row held → empty batch, holds still reported, no dep reason invented', () => {
-  const jobs = [job('10-a'), job('11-b')];
-  const held = new Map([['10-a', 'launch blocked'], ['11-b', 'launch blocked']]);
-  const r = pickForProject(jobs, new Set(), 3, held);
-  assert.equal(r.batch.length, 0);
-  assert.equal(r.reason, null);
-  assert.deepEqual(r.holds.map((h) => h.slug).sort(), ['10-a', '11-b']);
-});
-
-test('pickForProject: a held row still counts as a blocking dependency for its dependents', () => {
-  const jobs = [job('10-base'), job('11-child', 'pending', { dependsOn: ['10-base'] })];
-  const held = new Map([['10-base', 'launch blocked']]);
-  const r = pickForProject(jobs, new Set(), 3, held);
-  assert.equal(r.batch.length, 0, 'the child must not run ahead of its held dependency');
-  const childHold = r.holds.find((h) => h.slug === '11-child');
-  assert.equal(childHold.dep, '10-base');
-});
-
-test('pickNextBatch: heldSlugs option threads through; a project with only held rows is not a candidate', () => {
-  const other = '/tmp/other-project';
-  const jobs = [job('10-held'), job('20-other', 'pending', { cwd: other })];
-  const held = new Map([['10-held', 'launch blocked (auth_failed)']]);
-  const r = pickNextBatch(jobs, new Set(), 2, { heldSlugs: held, now: Date.parse('2026-09-02T18:05:00Z') });
-  assert.deepEqual(r.batch.map((j) => j.slug), ['20-other']);
-  assert.ok(r.holds.some((h) => h.slug === '10-held' && /auth_failed/.test(h.reason)));
-});
-
-test('pickNextBatch: a held quiet-machine row is never dispatched exclusively', () => {
-  const jobs = [job('10-quiet', 'pending', { quietMachine: true }), job('11-plain')];
-  const held = new Map([['10-quiet', 'launch blocked']]);
-  const r = pickNextBatch(jobs, new Set(), 1, { heldSlugs: held, machineInUse: 0 });
-  assert.deepEqual(r.batch.map((j) => j.slug), ['11-plain']);
-});
-
-test('pickNextBatch: nothing pickable at all → empty batch with holds, not a crash', () => {
-  const jobs = [job('10-held')];
-  const r = pickNextBatch(jobs, new Set(), 2, { heldSlugs: new Map([['10-held', 'launch blocked']]) });
-  assert.equal(r.batch.length, 0);
-  assert.equal(r.holds[0].slug, '10-held');
-});
-
-// ─── computeLaunchHolds (scheduler.cjs) ─────────────────────────────────────
-
-const T0 = Date.parse('2026-09-02T18:00:00Z');
-
-test('computeLaunchHolds: no blocks → empty map without probing the CLI', async () => {
-  const held = await computeLaunchHolds({ jobs: [job('10-a')], launchBlocks: {} }, { now: T0, claudeVersion: 'v1' });
-  assert.equal(held.size, 0);
-});
-
-test('computeLaunchHolds: inside backoff every pending row of the blocked persona is held; other personas run', async () => {
-  const block = lf.armLaunchBlock(null, { kind: 'model_config_rejected', message: 'm', now: T0, claudeVersion: 'v1' });
-  const state = {
-    jobs: [job('10-a', 'pending', { agentType: 'dev-lead' }), job('11-b', 'pending', { agentType: 'dev-lead' }), job('12-c', 'pending', { agentType: 'architect' }), job('13-done', 'completed', { agentType: 'dev-lead' })],
-    launchBlocks: { 'dev-lead': block },
-  };
-  const held = await computeLaunchHolds(state, { now: T0 + 1000, claudeVersion: 'v1' });
-  assert.deepEqual([...held.keys()].sort(), ['10-a', '11-b']);
-  assert.match(held.get('10-a'), /launch blocked \(model_config_rejected\)/);
-});
-
-test('computeLaunchHolds: after backoff exactly ONE row per persona is released as the probe', async () => {
-  const block = lf.armLaunchBlock(null, { kind: 'api_overloaded', message: 'm', now: T0, claudeVersion: 'v1' });
-  const state = {
-    jobs: [job('10-a', 'pending', { agentType: 'dev-lead' }), job('11-b', 'pending', { agentType: 'dev-lead' })],
-    launchBlocks: { 'dev-lead': block },
-  };
-  const held = await computeLaunchHolds(state, { now: Date.parse(block.until) + 1, claudeVersion: 'v1' });
-  assert.deepEqual([...held.keys()], ['11-b']);
-  assert.match(held.get('11-b'), /waiting for this tick's probe/);
-});
-
-test('computeLaunchHolds: a CLI version change releases everything', async () => {
-  const block = lf.armLaunchBlock(null, { kind: 'model_config_rejected', message: 'm', now: T0, claudeVersion: 'v1' });
-  const state = { jobs: [job('10-a', 'pending', { agentType: 'dev-lead' })], launchBlocks: { 'dev-lead': block } };
-  const held = await computeLaunchHolds(state, { now: T0 + 1, claudeVersion: 'v2' });
-  assert.equal(held.size, 0);
-});
-
-test('computeLaunchHolds: rows with no agentType are keyed as default', async () => {
-  const block = lf.armLaunchBlock(null, { kind: 'auth_failed', message: 'm', now: T0, claudeVersion: 'v1' });
-  const state = { jobs: [job('10-a')], launchBlocks: { default: block } };
-  const held = await computeLaunchHolds(state, { now: T0 + 1, claudeVersion: 'v1' });
-  assert.ok(held.has('10-a'));
-});