claude-code-session-manager 0.76.0 → 0.77.0

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

@@ -0,0 +1,39 @@
+'use strict';
+
+// Run: timeout 60 npx vitest run src/main/lib/__tests__/quietMachineLease.test.cjs
+
+const assert = require('node:assert/strict');
+const lease = require('../quietMachineLease.cjs');
+
+afterEach(() => {
+  lease.__resetForTests();
+});
+
+test('free lease: isHeld false, acquire succeeds and reports the holder', () => {
+  assert.equal(lease.isHeld(), false);
+  assert.equal(lease.acquire('101-quiet'), true);
+  assert.equal(lease.isHeld(), true);
+  assert.equal(lease.holder(), '101-quiet');
+});
+
+test('a second acquire while held fails — exclusive by construction', () => {
+  assert.equal(lease.acquire('101-quiet'), true);
+  assert.equal(lease.acquire('102-other'), false);
+  assert.equal(lease.holder(), '101-quiet');
+});
+
+test('release frees the lease so the next acquire can succeed', () => {
+  lease.acquire('101-quiet');
+  assert.equal(lease.release('101-quiet'), true);
+  assert.equal(lease.isHeld(), false);
+  assert.equal(lease.acquire('102-other'), true);
+});
+
+test('release is idempotent: releasing an unheld lease, or a slug that does not hold it, is a no-op', () => {
+  assert.equal(lease.release('nobody'), false);
+  lease.acquire('101-quiet');
+  assert.equal(lease.release('wrong-slug'), false);
+  assert.equal(lease.isHeld(), true);
+  assert.equal(lease.release('101-quiet'), true);
+  assert.equal(lease.release('101-quiet'), false);
+});

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

@@ -16,7 +16,7 @@
 // vitest, NOT node:test — this repo's suite is vitest-only (CLAUDE.md).
 import { test } from 'vitest';
 const assert = require('node:assert/strict');
-const { selectReapableJobs } = require('../reaperHelpers.cjs');
+const { selectReapableJobs, mapOutcomeToGateOutcome } = require('../reaperHelpers.cjs');
 
 const NOW = Date.parse('2026-09-01T12:00:00.000Z');
 const agoMin = (m) => new Date(NOW - m * 60_000).toISOString();
@@ -110,3 +110,24 @@ test('mixed batch: each row classified independently', () => {
   assert.deepStrictEqual(reapable.map((r) => r.slug).sort(), ['dead', 'zombie']);
   assert.deepStrictEqual(warnings.map((w) => w.slug), ['bad-started-at']);
 });
+
+// mapOutcomeToGateOutcome — classifyRunOutcome's four-way result collapsed
+// onto the persisted `gateOutcome` field (PRD 1109). 'no_result' -> 'never_ran'
+// is the one non-obvious mapping: a missing verdict event means the gate
+// never fired, a distinct fact from 'failed' (a verdict event exists and
+// says error).
+test('mapOutcomeToGateOutcome: success -> passed', () => {
+  assert.strictEqual(mapOutcomeToGateOutcome('success'), 'passed');
+});
+
+test('mapOutcomeToGateOutcome: failed -> failed', () => {
+  assert.strictEqual(mapOutcomeToGateOutcome('failed'), 'failed');
+});
+
+test('mapOutcomeToGateOutcome: no_result -> never_ran', () => {
+  assert.strictEqual(mapOutcomeToGateOutcome('no_result'), 'never_ran');
+});
+
+test('mapOutcomeToGateOutcome: unknown -> unknown', () => {
+  assert.strictEqual(mapOutcomeToGateOutcome('unknown'), 'unknown');
+});

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

@@ -0,0 +1,125 @@
+'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'));
+});

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

@@ -0,0 +1,109 @@
+'use strict';
+
+// Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerBatchQuietMachine.test.cjs
+//
+// Pure-logic coverage for the `quietMachine: true` exclusive lease (PRD
+// 1107): dispatched only when zero other jobs are running machine-wide,
+// blocks every other dispatch while its lease is held, degrades (dispatches
+// anyway) once it has waited past the configurable interval, and never
+// touches the ordinary dispatch path for a PRD that doesn't opt in.
+
+const assert = require('node:assert/strict');
+const { pickNextBatch } = require('../schedulerBatch.cjs');
+
+const CWD_A = '/home/user/Projects/project-a';
+const CWD_B = '/home/user/Projects/project-b';
+
+function job(slug, status, cwd, extra = {}) {
+  return {
+    slug,
+    status,
+    cwd,
+    parallelGroup: Number(String(slug).match(/^(\d+)-/)?.[1] ?? 99),
+    dependsOn: [],
+    ...extra,
+  };
+}
+
+const ORIGINAL_WAIT_ENV = process.env.SM_QUIET_MACHINE_WAIT_MINUTES;
+afterEach(() => {
+  if (ORIGINAL_WAIT_ENV === undefined) delete process.env.SM_QUIET_MACHINE_WAIT_MINUTES;
+  else process.env.SM_QUIET_MACHINE_WAIT_MINUTES = ORIGINAL_WAIT_ENV;
+});
+
+test('a quietMachine job dispatches alone when the machine is idle, even with ordinary work also pending', () => {
+  const jobs = [
+    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: new Date().toISOString() }),
+    job('102-ordinary', 'pending', CWD_A, { createdAt: new Date().toISOString() }),
+    job('201-other', 'pending', CWD_B, { createdAt: new Date().toISOString() }),
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 0, now: Date.now() });
+  assert.deepEqual(batch.map((j) => j.slug), ['101-quiet']);
+  assert.equal(batch[0].quietLeaseDegraded, false);
+});
+
+test('a quietMachine job does NOT dispatch while another job is running machine-wide, and ordinary jobs dispatch unaffected', () => {
+  const jobs = [
+    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: new Date().toISOString() }),
+    job('201-other', 'pending', CWD_B, { createdAt: new Date().toISOString() }),
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 1, now: Date.now() });
+  assert.deepEqual(batch.map((j) => j.slug), ['201-other']);
+});
+
+test('leaseHeld blocks EVERY project from dispatching, not just the quiet job\'s own project', () => {
+  const jobs = [
+    job('101-quiet', 'running', CWD_A, { quietMachine: true }),
+    job('201-other', 'pending', CWD_B, { createdAt: new Date().toISOString() }),
+  ];
+  const { batch, reason } = pickNextBatch(jobs, new Set(['101-quiet']), 5, { leaseHeld: true, machineInUse: 1, now: Date.now() });
+  assert.deepEqual(batch, []);
+  assert.match(reason, /quiet-machine/);
+});
+
+test('a quietMachine job blocked by dependsOn is skipped even when the machine is idle', () => {
+  const jobs = [
+    job('100-dep', 'pending', CWD_A, { createdAt: new Date().toISOString() }),
+    job('101-quiet', 'pending', CWD_A, { quietMachine: true, dependsOn: ['100-dep'], createdAt: new Date().toISOString() }),
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 0, now: Date.now() });
+  // The quiet job is blocked by its dep; the dep itself is an ordinary job
+  // and dispatches normally.
+  assert.deepEqual(batch.map((j) => j.slug), ['100-dep']);
+});
+
+test('a quietMachine job waiting under the configured interval stays held while the machine is busy', () => {
+  process.env.SM_QUIET_MACHINE_WAIT_MINUTES = '30';
+  const now = Date.now();
+  const queuedAt = new Date(now - 10 * 60_000).toISOString(); // waited 10m
+  const jobs = [
+    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: queuedAt }),
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 1, now });
+  assert.deepEqual(batch, []);
+});
+
+test('a quietMachine job past the configured wait interval dispatches anyway, marked degraded', () => {
+  process.env.SM_QUIET_MACHINE_WAIT_MINUTES = '30';
+  const now = Date.now();
+  const queuedAt = new Date(now - 31 * 60_000).toISOString(); // waited 31m
+  const jobs = [
+    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: queuedAt }),
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 1, now });
+  assert.deepEqual(batch.map((j) => j.slug), ['101-quiet']);
+  assert.equal(batch[0].quietLeaseDegraded, true);
+});
+
+test('ordinary dispatch path is unchanged when no quietMachine job is present (no quietOpts passed at all)', () => {
+  const jobs = [
+    job('101-a', 'pending', CWD_A),
+    job('102-b', 'pending', CWD_A),
+    job('201-a', 'pending', CWD_B),
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 5);
+  assert.deepEqual(
+    batch.map((j) => j.slug).sort(),
+    ['101-a', '102-b', '201-a'],
+  );
+});

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

@@ -0,0 +1,71 @@
+/**
+ * schedulerMcpServerHeadlessRefusal.test.cjs — scheduler_create_prd is
+ * refused at the authoring boundary when called from inside a headless
+ * scheduled job (issue #11 list C1: PRD 460 called /develop from inside its
+ * own run, spawned a duplicate PRD, and exited 0 having done nothing).
+ * scheduler.cjs stamps SM_SCHEDULER_JOB_SLUG on every job spawn and
+ * SM_SCHEDULER_JOB_MAY_QUEUE=1 only for decomposition personas.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerMcpServerHeadlessRefusal.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const SERVER_PATH = path.join(__dirname, '../../../../scripts/scheduler-mcp-server.cjs');
+
+const tmpDirs = [];
+const savedEnv = {};
+for (const k of ['SM_SCHEDULER_JOB_SLUG', 'SM_SCHEDULER_JOB_MAY_QUEUE', 'HOME']) savedEnv[k] = process.env[k];
+
+afterEach(async () => {
+  for (const [k, v] of Object.entries(savedEnv)) {
+    if (v === undefined) delete process.env[k]; else process.env[k] = v;
+  }
+  delete require.cache[require.resolve(SERVER_PATH)];
+  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { recursive: true, force: true });
+});
+
+async function freshServer() {
+  const homeDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-mcp-headless-'));
+  tmpDirs.push(homeDir);
+  process.env.HOME = homeDir;
+  delete require.cache[require.resolve(SERVER_PATH)];
+  return require(SERVER_PATH);
+}
+
+const PRD_ARGS = { title: 'x', goal: 'y', acceptanceCriteria: ['z'] };
+
+test('scheduler_create_prd inside a headless job is refused before any admin request', async () => {
+  process.env.SM_SCHEDULER_JOB_SLUG = '460-some-prd';
+  delete process.env.SM_SCHEDULER_JOB_MAY_QUEUE;
+  const { handleCallTool } = await freshServer();
+  const result = await handleCallTool({ params: { name: 'scheduler_create_prd', arguments: PRD_ARGS } });
+  expect(result.isError).toBe(true);
+  const text = result.content[0].text;
+  expect(text).toMatch(/refused/);
+  expect(text).toMatch(/460-some-prd/);
+  expect(text).toMatch(/never queues follow-on work/);
+});
+
+test('scheduler_create_prd inside a headless job with SM_SCHEDULER_JOB_MAY_QUEUE=1 is not refused by the gate', async () => {
+  process.env.SM_SCHEDULER_JOB_SLUG = '461-architect-plan';
+  process.env.SM_SCHEDULER_JOB_MAY_QUEUE = '1';
+  const { handleCallTool } = await freshServer();
+  const result = await handleCallTool({ params: { name: 'scheduler_create_prd', arguments: PRD_ARGS } });
+  // No admin API is configured in this tmp HOME, so the call fails LATER at
+  // the admin request — the point is that it was not the headless refusal.
+  const text = result.content[0].text;
+  expect(text).not.toMatch(/never queues follow-on work/);
+});
+
+test('scheduler_create_prd outside a headless job is not refused by the gate', async () => {
+  delete process.env.SM_SCHEDULER_JOB_SLUG;
+  const { handleCallTool } = await freshServer();
+  const result = await handleCallTool({ params: { name: 'scheduler_create_prd', arguments: PRD_ARGS } });
+  expect(result.content[0].text).not.toMatch(/never queues follow-on work/);
+});