claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-prd-persona-spawn.test.cjs

@@ -1,178 +0,0 @@
-/**
- * scheduler-prd-persona-spawn.test.cjs — PRD 1115: a PRD's `agentType`
- * frontmatter must actually drive the headless spawn (--append-system-prompt
- * with the persona's frontmatter-stripped, capped body, and --model with the
- * persona's own model), not just sit in the prompt as prose the executor may
- * or may not obey. Covers buildClaudeSpawnArgs' pure argv shape plus a real
- * executeJob spawn (stub `claude` binary) proving the resolved persona
- * actually reaches the child process, and that a dangling agentType still
- * runs the job to completion (never parks or fails it).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-prd-persona-spawn.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } 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 executeJob;
-let buildClaudeSpawnArgs;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-persona-spawn-'));
-  process.env.HOME = tmpHome;
-  ({ executeJob, buildClaudeSpawnArgs } = require('../scheduler.cjs'));
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-});
-
-// ---------- buildClaudeSpawnArgs: systemPrompt -> --append-system-prompt ----------
-
-test('buildClaudeSpawnArgs: a given systemPrompt is passed via --append-system-prompt', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'opus', sessionId: 'sid', resume: false, systemPrompt: 'You are dev-lead.' });
-  const idx = args.indexOf('--append-system-prompt');
-  expect(idx).toBeGreaterThanOrEqual(0);
-  expect(args[idx + 1]).toBe('You are dev-lead.');
-});
-
-test('buildClaudeSpawnArgs: omits --append-system-prompt entirely when systemPrompt is absent', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'sonnet', sessionId: 'sid', resume: false });
-  expect(args).not.toContain('--append-system-prompt');
-});
-
-test('buildClaudeSpawnArgs: model is never omitted even without a systemPrompt', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'x', model: 'sonnet', sessionId: 'sid', resume: false });
-  const idx = args.indexOf('--model');
-  expect(idx).toBeGreaterThanOrEqual(0);
-  expect(args[idx + 1]).toBe('sonnet');
-});
-
-// ---------- real spawn: persona actually reaches the child process ----------
-
-// Stub `claude` binary: dumps its own argv into a marker file, then emits a
-// stream-json success result and exits 0 — same technique as
-// scheduler-bash-timeout-env.test.cjs's env-var proof, applied to argv.
-function writeClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'argv.marker'), JSON.stringify(process.argv.slice(2)), 'utf8');
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-function writePersona(dir, name, frontmatterLines, bodyText) {
-  fs.mkdirSync(dir, { recursive: true });
-  const lines = ['---', `name: ${name}`, ...frontmatterLines, '---', bodyText];
-  fs.writeFileSync(path.join(dir, `${name}.md`), lines.join('\n'));
-}
-
-async function runJobWithAgentType({ agentType, overlay }) {
-  // Under tmpHome so config.validatePath's home-dir boundary admits the project overlay.
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-prd-persona-main-'));
-  if (overlay) writePersona(path.join(mainCwd, '.claude', 'agents'), overlay.name, overlay.frontmatter, overlay.body || '');
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-persona-run-'));
-  const slug = `1115-test-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const prdsDir = path.join(mainCwd, 'session-manager-operations', 'scheduler', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Do the thing.', 'utf8');
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  const job = { slug, cwd: mainCwd, agentType };
-  const result = await executeJob(job, runDir, mainCwd, () => Promise.resolve());
-  const argv = JSON.parse(fs.readFileSync(path.join(mainCwd, 'argv.marker'), 'utf8'));
-  fs.rmSync(mainCwd, { recursive: true, force: true });
-  fs.rmSync(runDir, { recursive: true, force: true });
-  return { result, argv };
-}
-
-test('executeJob: a resolvable agentType reaches the spawned child as --append-system-prompt + --model', async () => {
-  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
-  writePersona(globalAgentsDir, 'dev-lead', ['model: opus'], 'You are dev-lead. Ship it.');
-
-  const { result, argv } = await runJobWithAgentType({ agentType: 'dev-lead' });
-
-  expect(result.exitCode).toBe(0);
-  const spIdx = argv.indexOf('--append-system-prompt');
-  expect(spIdx).toBeGreaterThanOrEqual(0);
-  expect(argv[spIdx + 1]).toBe('You are dev-lead. Ship it.');
-  const modelIdx = argv.indexOf('--model');
-  expect(argv[modelIdx + 1]).toBe('opus');
-});
-
-test('executeJob: a dangling agentType (no resolvable persona file) still runs the job to completion, falling back to sonnet with no --append-system-prompt', async () => {
-  const { result, argv } = await runJobWithAgentType({ agentType: 'renamed-or-deleted-persona' });
-
-  expect(result.exitCode).toBe(0);
-  expect(argv).not.toContain('--append-system-prompt');
-  const modelIdx = argv.indexOf('--model');
-  expect(argv[modelIdx + 1]).toBe('sonnet');
-});
-
-test('executeJob: a job with no agentType at all runs unaffected (no persona, sonnet fallback)', async () => {
-  const { result, argv } = await runJobWithAgentType({ agentType: null });
-
-  expect(result.exitCode).toBe(0);
-  expect(argv).not.toContain('--append-system-prompt');
-  const modelIdx = argv.indexOf('--model');
-  expect(argv[modelIdx + 1]).toBe('sonnet');
-});
-
-// ---------- persona effort → --effort ----------
-
-test('buildClaudeSpawnArgs: effort appends --effort <level>; null/inherit/absent add no token', () => {
-  const base = { prompt: 'x', model: 'sonnet', sessionId: 'sid', resume: false };
-  const args = buildClaudeSpawnArgs({ ...base, effort: 'high' });
-  expect(args[args.indexOf('--effort') + 1]).toBe('high');
-  expect(args.indexOf('--model')).toBeGreaterThanOrEqual(0);
-  for (const effort of [null, 'inherit', undefined]) {
-    expect(buildClaudeSpawnArgs({ ...base, effort })).not.toContain('--effort');
-  }
-});
-
-test('executeJob: persona effort reaches the child as --effort; inherit yields no --effort token', async () => {
-  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
-  writePersona(globalAgentsDir, 'effort-high', ['model: opus', 'effort: high'], 'body');
-  writePersona(globalAgentsDir, 'effort-inherit', ['model: opus', 'effort: inherit'], 'body');
-
-  const high = await runJobWithAgentType({ agentType: 'effort-high' });
-  expect(high.argv[high.argv.indexOf('--effort') + 1]).toBe('high');
-  expect(high.argv[high.argv.indexOf('--model') + 1]).toBe('opus');
-
-  const inherit = await runJobWithAgentType({ agentType: 'effort-inherit' });
-  expect(inherit.argv).not.toContain('--effort');
-  expect(inherit.argv).not.toContain('inherit');
-});
-
-// ---------- project overlay MERGE: frontmatter-only overlay patches the runtime fields ----------
-
-test('executeJob: a frontmatter-only project overlay changes --model/--effort while the global persona body still reaches --append-system-prompt', async () => {
-  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
-  writePersona(globalAgentsDir, 'dev-lead', ['model: sonnet'], 'You are dev-lead. Global body.');
-
-  const { result, argv } = await runJobWithAgentType({
-    agentType: 'dev-lead',
-    overlay: { name: 'dev-lead', frontmatter: ['model: claude-opus-4-6', 'effort: high'], body: '' },
-  });
-
-  expect(result.exitCode).toBe(0);
-  expect(argv[argv.indexOf('--model') + 1]).toBe('claude-opus-4-6');
-  expect(argv[argv.indexOf('--effort') + 1]).toBe('high');
-  expect(argv[argv.indexOf('--append-system-prompt') + 1]).toBe('You are dev-lead. Global body.');
-});

package/src/main/__tests__/scheduler-quarantine-autoresolve.test.cjs

@@ -1,165 +0,0 @@
-/**
- * scheduler-quarantine-autoresolve.test.cjs
- *
- * Covers the bounded automatic exit for a quarantined row that never
- * received a `createdVia` provenance stamp (this PRD): the pure selector
- * `selectQuarantineAutoResolveTargets`, the async applier
- * `autoResolveQuarantine` (which re-reads the PRD file's frontmatter fresh
- * from disk immediately before transitioning, so it can never race
- * reconcile()'s own adopt path), and the kill switch
- * `quarantineAutoResolveDisabled`.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
- * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
- * under $HOME/.claude/session-manager/audit-log.jsonl).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-quarantine-autoresolve.test.cjs
- */
-
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'quarantine-autoresolve-test-'));
-process.env.HOME = tmpHome;
-
-const {
-  selectQuarantineAutoResolveTargets,
-  autoResolveQuarantine,
-  QUARANTINE_RESOLVE_CAP,
-  quarantineAutoResolveDisabled,
-} = require('../scheduler.cjs');
-
-const MIN_MS = 60_000;
-const THRESHOLD_MS = 60 * MIN_MS;
-
-function quarantinedJob(overrides = {}) {
-  return {
-    slug: 'quarantined-row',
-    cwd: '/home/user/project',
-    status: 'quarantined',
-    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 90 * MIN_MS).toISOString() }],
-    ...overrides,
-  };
-}
-
-function registerActiveProject(cwd) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-function makeFixtureProject(prefix) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  registerActiveProject(cwd);
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'test-epic-1', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  return { cwd, prdsDir };
-}
-
-// --- selectQuarantineAutoResolveTargets ---
-
-test('a fresh quarantined row (under threshold) is not selected', () => {
-  const job = quarantinedJob({
-    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 2 * MIN_MS).toISOString() }],
-  });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a non-quarantined status is never selected', () => {
-  const job = quarantinedJob({ status: 'failed' });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a quarantined row with no statusHistory entry cannot have its age proven, and is skipped', () => {
-  const job = quarantinedJob({ statusHistory: [] });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a quarantined row past threshold, under the cap, is selected', () => {
-  const job = quarantinedJob({ quarantineResolveAttempts: 0 });
-  const found = selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS);
-  assert.equal(found.length, 1);
-  assert.equal(found[0].slug, 'quarantined-row');
-  assert.ok(found[0].ageMs >= 90 * MIN_MS - 1000);
-});
-
-test('a quarantined row that already spent its resolve cap is excluded', () => {
-  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
-  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('quarantineAutoResolveDisabled reflects SM_QUARANTINE_AUTORESOLVE_DISABLE', () => {
-  const saved = process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
-  try {
-    delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
-    assert.equal(quarantineAutoResolveDisabled(), false);
-    process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = '1';
-    assert.equal(quarantineAutoResolveDisabled(), true);
-  } finally {
-    if (saved === undefined) delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
-    else process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = saved;
-  }
-});
-
-// --- autoResolveQuarantine: the applier ---
-
-test('a quarantined row whose PRD file still has no createdVia is auto-resolved to skipped', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-noprovenance-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, 'quarantined-row.md'),
-      `---\ntitle: Unstamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nDo the thing.\n`,
-      'utf8',
-    );
-    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
-    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
-    assert.equal(outcome, 'skipped');
-    assert.equal(job.status, 'skipped');
-    assert.equal(job.quarantineResolveAttempts, 1);
-    assert.ok(typeof job.error === 'string' && /createdVia/.test(job.error));
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('a quarantined row whose PRD file HAS been stamped with createdVia is left alone — reconcile owns it now', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-stamped-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, 'quarantined-row.md'),
-      `---\ntitle: Stamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\nDo the thing.\n`,
-      'utf8',
-    );
-    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
-    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
-    assert.equal(outcome, null);
-    assert.equal(job.status, 'quarantined'); // untouched — the adopt path owns the next pass
-    assert.equal(job.quarantineResolveAttempts, 0);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('autoResolveQuarantine race-guards against a row that moved off quarantined', async () => {
-  const job = quarantinedJob({ status: 'pending', quarantineResolveAttempts: 0 });
-  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
-  assert.equal(job.status, 'pending'); // untouched
-});
-
-test('autoResolveQuarantine race-guards against a row whose resolve cap is already spent', async () => {
-  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
-  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
-  assert.equal(job.status, 'quarantined'); // untouched
-});
-
-test('a quarantined row whose PRD file is missing entirely is treated as still lacking provenance and auto-resolved', async () => {
-  const job = quarantinedJob({ cwd: '/nonexistent/project/path', quarantineResolveAttempts: 0 });
-  const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
-  assert.equal(outcome, 'skipped');
-  assert.equal(job.status, 'skipped');
-});

package/src/main/__tests__/scheduler-quiet-machine-lease.test.cjs

@@ -1,257 +0,0 @@
-/**
- * scheduler-quiet-machine-lease.test.cjs — PRD 1107: the exclusive
- * quiet-machine lease must be released on EVERY spawnJob exit path,
- * including a killed job (SIGKILL/exit 137), not just a clean exit — the
- * same finally block that already releases the sessionSlots token. Drives
- * spawnJob end-to-end against a real git fixture repo with a stub `claude`
- * binary that exits 137 mid-run (same pattern as
- * scheduler-inplace-salvage.test.cjs), then asserts:
- *   1. the lease is released once the job settles, and
- *   2. an ordinary pending job — held behind the lease while it was held —
- *      is now eligible to dispatch.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-quiet-machine-lease.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-const { execFileSync } = require('node:child_process');
-
-let tmpHome;
-let originalHome;
-let originalDisable;
-let spawnJob;
-let quietMachineLease;
-let pickNextBatch;
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-function initRepo(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-// See scheduler-inplace-salvage.test.cjs's identical helper: readQueue()'s
-// per-project discovery walks ~/.claude/projects/*/*.jsonl transcripts for a
-// `cwd` field to find known project queue.json shards.
-function registerActiveProject(cwd) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-// Every real scheduler row is born from a real PRD .md file — reconcile()'s
-// auto-archive-drop path (a terminal job whose slug has no on-disk PRD
-// anywhere is treated as "archived on purpose": dropped from queue.json and
-// backfilled to history.jsonl, see scheduler-reconcile-history-backfill.
-// test.cjs) fires the moment a completion path reconciles with
-// broadcast({flush:true}). Without a matching PRD source, a row this test
-// drives to a terminal status vanishes from queue.json before the assertions
-// below ever read it back. Epic-scoped (not the legacy flat prds/ dir) so
-// it's never swept by consolidateFlatPrds either.
-// Some tests author their own real PRD (e.g. with `quietMachine: true`
-// frontmatter) before calling writeProjectQueue — never shadow that with a
-// blank fixture, which would silently overwrite its parsed frontmatter on
-// the next reconcile() refresh (onDisk.set(slug, ...) keeps whichever file a
-// later scan pass parses).
-function prdAlreadyExists(cwd, slug) {
-  const flatPath = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds', `${slug}.md`);
-  if (fs.existsSync(flatPath)) return true;
-  const epicsRoot = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics');
-  if (!fs.existsSync(epicsRoot)) return false;
-  return fs.readdirSync(epicsRoot).some((epicId) => fs.existsSync(path.join(epicsRoot, epicId, 'prds', `${slug}.md`)));
-}
-
-function writeFixturePrd(cwd, slug) {
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Test fixture PRD.', 'utf8');
-}
-
-function writeProjectQueue(cwd, jobs) {
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
-  for (const job of jobs) {
-    if (job && job.slug && !prdAlreadyExists(job.cwd || cwd, job.slug)) writeFixturePrd(job.cwd || cwd, job.slug);
-  }
-  return path.join(stateDir, 'queue.json');
-}
-
-// Stub `claude` binary that exits 137 (SIGKILL) with no result:success event,
-// simulating a leased job killed mid-run before it could finish and release
-// naturally through its own clean-exit path. Dirties the tree first (like
-// scheduler-inplace-salvage.test.cjs's stub) so the scheduler classifies this
-// as a genuine kill-with-partial-work, not an auto-retryable transient blip
-// with no evidence of real execution.
-function writeKilledClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'job-output.txt'), 'work in progress when killed\\n', 'utf8');
-    process.exit(137);
-  ` });
-}
-
-let reapDeadRunningJobs;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-quiet-lease-'));
-  process.env.HOME = tmpHome;
-  originalDisable = process.env.SM_JOB_WORKTREE_DISABLE;
-  process.env.SM_JOB_WORKTREE_DISABLE = '1';
-  ({ spawnJob, reapDeadRunningJobs } = require('../scheduler.cjs'));
-  ({ pickNextBatch } = require('../lib/schedulerBatch.cjs'));
-  quietMachineLease = require('../lib/quietMachineLease.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalDisable === undefined) delete process.env.SM_JOB_WORKTREE_DISABLE;
-  else process.env.SM_JOB_WORKTREE_DISABLE = originalDisable;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  quietMachineLease.__resetForTests();
-});
-
-test('a killed quietMachine job releases the exclusive lease, and an ordinary job dispatches on the next pick', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-quiet-lease-project-'));
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd);
-
-  const quietSlug = `1107-test-quiet-killed-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const ordinarySlug = `1107-test-ordinary-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  // Epic-scoped, not the legacy flat prds/ dir: the flat dir is retired and
-  // swept into prds-archived/ by consolidateFlatPrds the moment a job is no
-  // longer pending/running, which would silently strip this PRD's
-  // `quietMachine: true` frontmatter from the row on the very next
-  // reconcile() refresh (or drop the row entirely once terminal — see
-  // scheduler-reconcile-history-backfill.test.cjs).
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${quietSlug}.md`), '---\nquietMachine: true\n---\nMeasure timing without contention, then get killed.', 'utf8');
-  fs.writeFileSync(path.join(prdsDir, `${ordinarySlug}.md`), 'An ordinary PRD queued behind the quiet job.', 'utf8');
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug: quietSlug, status: 'pending', cwd: projectCwd, quietMachine: true },
-    { slug: ordinarySlug, status: 'pending', cwd: projectCwd, createdAt: new Date().toISOString() },
-  ]);
-
-  process.env.SM_CLAUDE_BIN = writeKilledClaudeStub();
-
-  const runId = `run-${quietSlug}`;
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-
-  try {
-    // Before spawnJob ever runs, demonstrate that a held lease (as it would
-    // be while quietSlug is genuinely running) blocks EVERY dispatch,
-    // including the ordinary sibling job sitting right behind it in the same
-    // project. Uses a standalone dummy holder so it doesn't interact with
-    // spawnJob's own acquire/release of the real lease below.
-    expect(quietMachineLease.acquire('dummy-holder-simulating-in-flight-run')).toBe(true);
-    const heldPick = pickNextBatch(
-      [
-        { slug: quietSlug, status: 'running', cwd: projectCwd, quietMachine: true },
-        { slug: ordinarySlug, status: 'pending', cwd: projectCwd, createdAt: new Date().toISOString() },
-      ],
-      new Set([quietSlug]),
-      5,
-      { leaseHeld: quietMachineLease.isHeld(), machineInUse: 1, now: Date.now() },
-    );
-    expect(heldPick.batch).toEqual([]);
-    quietMachineLease.release('dummy-holder-simulating-in-flight-run');
-
-    // Now the real thing: spawnJob acquires the lease itself for quietSlug,
-    // runs the killed stub, and must release it on this exit path.
-    await spawnJob({ slug: quietSlug, cwd: projectCwd, quietMachine: true }, runId, runDir, projectCwd);
-
-    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    const quietRow = jobs.find((j) => j.slug === quietSlug);
-    expect(quietRow).toBeTruthy();
-    expect(quietRow.exitCode).toBe(137);
-    expect(quietRow.quietMachine).toBe(true);
-
-    // The lease was released on this killed-job exit path — spawnJob's own
-    // finally block, the same one that releases the sessionSlots token.
-    expect(quietMachineLease.isHeld()).toBe(false);
-
-    // With the lease free again, the ordinary sibling job is now eligible.
-    const nextPick = pickNextBatch(
-      [
-        { slug: quietSlug, status: 'failed', cwd: projectCwd, quietMachine: true },
-        { slug: ordinarySlug, status: 'pending', cwd: projectCwd, createdAt: new Date().toISOString() },
-      ],
-      new Set(),
-      5,
-      { leaseHeld: quietMachineLease.isHeld(), machineInUse: 0, now: Date.now() },
-    );
-    expect(nextPick.batch.map((j) => j.slug)).toEqual([ordinarySlug]);
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-}, 30_000);
-
-test('reapDeadRunningJobs releases a quietMachine job\'s lease too — the process vanished without spawnJob\'s own finally ever running', async () => {
-  // This reaper exists exactly for the case spawnJob's own finally never
-  // runs (the process dies without the completion mutate() finishing) — see
-  // reapDeadRunningJobs's header comment. A quietMachine row reaped through
-  // THIS path must release the lease itself, or it stays wedged forever.
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-quiet-lease-reap-project-'));
-  registerActiveProject(projectCwd);
-
-  const slug = `1107-test-reaped-quiet-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug,
-      status: 'running',
-      cwd: projectCwd,
-      quietMachine: true,
-      runId: `run-${slug}`,
-      runtime: { pid: 999999 }, // guaranteed-dead pid (see reaperHelpers tests)
-    },
-  ]);
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', `run-${slug}`);
-  fs.mkdirSync(runDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(runDir, `${slug}.log`),
-    '{"type":"result","subtype":"success","result":"done","is_error":false}\n',
-  );
-
-  // Simulate the lease as held by this row, exactly as it would be if
-  // spawnJob's own acquire ran but its finally never got the chance to.
-  expect(quietMachineLease.acquire(slug)).toBe(true);
-
-  try {
-    await reapDeadRunningJobs();
-
-    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    const row = jobs.find((j) => j.slug === slug);
-    expect(row).toBeTruthy();
-    expect(row.status).toBe('completed');
-
-    // The lease must be released here too, not just in spawnJob's finally.
-    expect(quietMachineLease.isHeld()).toBe(false);
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});