claude-code-session-manager 0.75.3 → 0.77.0

package/src/main/__tests__/scheduler-looks-done.test.cjs

@@ -0,0 +1,241 @@
+/**
+ * scheduler-looks-done.test.cjs — PRD 1102.
+ *
+ * reverifyNeedsReview() used to have two hard limits that left real, finished
+ * work parked red forever: (1) isRescanCandidate required status ===
+ * 'needs_review' — a `failed` row was never revisited at all; (2)
+ * committedInWindow only looked inside [startedAt, finishedAt+60s], missing a
+ * commit that landed later (a retry, a sibling run, a human). This tests the
+ * widened pass: a `failed` row whose failure is unverified-shaped (no result
+ * event at all — classifyRunOutcome === 'no_result') is now a rescan
+ * candidate, and any candidate with a POST-window commit touching its own
+ * declared paths gets annotated `looksDone` for a human — never auto-
+ * completed. A `failed` row with a genuine result event (a real red gate) must
+ * stay excluded, and the pre-existing needs_review heal path must be
+ * unaffected.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — see
+ * scheduler-reap-dead-running-jobs.test.cjs's comment for why (every path
+ * this code touches is baked into a top-level const from os.homedir() at
+ * require time).
+ *
+ * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-looks-done.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 { execFileSync } = require('node:child_process');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'looks-done-test-'));
+process.env.HOME = tmpHome;
+
+const { reverifyNeedsReview, computeLooksDone } = require('../scheduler.cjs');
+const { resolvePrdWriteDir } = require('../lib/prdLocations.cjs');
+const { bustCwdCache } = require('../lib/queueStore.cjs');
+
+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);
+}
+
+function commitFile(dir, relPath, content, message) {
+  const abs = path.join(dir, relPath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+  git(['add', relPath], dir);
+  git(['commit', '-q', '-m', message], dir);
+}
+
+function registerActiveProject(cwd, slug) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, slug);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+  bustCwdCache();
+}
+
+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));
+  return path.join(stateDir, 'queue.json');
+}
+
+function writeRunLog(runId, slug, lines) {
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, `${slug}.log`), lines.join('\n') + '\n');
+}
+
+function writePrd(cwd, slug, body) {
+  const dir = resolvePrdWriteDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  const text = `---\ntitle: Test PRD\ncwd: ${cwd}\nestimateMinutes: 30\n---\n${body}\n`;
+  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
+}
+
+async function wait(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+
+test('failed + no result event (unverified-shaped) + later commit touching declared path → looksDone, transitions to needs_review', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-171');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-171-slug');
+  writePrd(projectCwd, '171-example', [
+    '# Implementation notes',
+    'Edit `src/foo.js`.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '171-example',
+      status: 'failed',
+      cwd: projectCwd,
+      runId: 'run-171',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      error: 'reaped: process gone (outcome=no_result) (outcome=no_result)',
+    },
+  ]);
+  writeRunLog('run-171', '171-example', ['[scheduler] starting 171-example']); // no result event
+
+  await wait(1100); // git --since has 1s resolution
+  commitFile(projectCwd, 'src/foo.js', 'hello', 'fix 171');
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'needs_review', 'looksDone never auto-completes — only surfaces for a human');
+  assert.ok(jobs[0].looksDone, 'expected a looksDone annotation');
+  assert.equal(jobs[0].looksDone.commits.length, 1);
+  assert.deepEqual(jobs[0].looksDone.paths, ['src/foo.js']);
+  assert.match(jobs[0].error, /looks done — 1 commit/);
+});
+
+test('failed + a real result event (genuine gate failure) → not a candidate, stays failed untouched', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-real-fail');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-real-fail-slug');
+  writePrd(projectCwd, '05-real-fail', [
+    '# Implementation notes',
+    'Edit `src/bar.js`.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '05-real-fail',
+      status: 'failed',
+      cwd: projectCwd,
+      runId: 'run-real-fail',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      error: 'AC gate red: tests failed',
+    },
+  ]);
+  writeRunLog('run-real-fail', '05-real-fail', [
+    '[scheduler] starting 05-real-fail',
+    JSON.stringify({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'tests failed' }),
+  ]);
+
+  await wait(1100);
+  commitFile(projectCwd, 'src/bar.js', 'hello', 'unrelated later commit touching the declared path');
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'failed', 'a genuine red gate must never become a heal candidate');
+  assert.equal(jobs[0].looksDone, undefined);
+  assert.equal(jobs[0].error, 'AC gate red: tests failed');
+});
+
+test('needs_review with an in-window commit heals exactly as today (regression — unchanged heal semantics)', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-heals-today');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-heals-today-slug');
+  writePrd(projectCwd, '20-clean-feature', [
+    '# Acceptance criteria',
+    '- [ ] `npm test` passes',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '20-clean-feature',
+      status: 'needs_review',
+      cwd: projectCwd,
+      runId: 'run-clean',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      verifierVerdict: 'transcript_errors',
+      error: 'transcript_errors: stale verdict',
+    },
+  ]);
+  writeRunLog('run-clean', '20-clean-feature', [
+    '[scheduler] starting 20-clean-feature',
+    JSON.stringify({
+      type: 'assistant',
+      message: { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'npm test' } }] },
+    }),
+    JSON.stringify({
+      type: 'user',
+      message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'all tests passed' }] },
+    }),
+    'SCHEDULER_VERDICT: PASS',
+    '[scheduler] exit code=0 (raw code=0 signal=null) duration=10s',
+  ]);
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'completed', 'a clean re-verify on a RESCANNABLE verdict must still heal');
+  assert.equal(jobs[0].verifierVerdict, undefined);
+  assert.equal(jobs[0].error, null);
+});
+
+test('computeLooksDone: no declared paths on the PRD → null, never fabricates evidence', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-no-paths');
+  initRepo(projectCwd);
+  writePrd(projectCwd, '09-no-paths', [
+    '# Implementation notes',
+    'Just prose here, no backticked file paths.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  await wait(1100);
+  commitFile(projectCwd, 'src/whatever.js', 'x', 'some later commit');
+
+  const job = { slug: '09-no-paths', cwd: projectCwd, startedAt };
+  const looksDone = await computeLooksDone(job);
+  assert.equal(looksDone, null);
+});
+
+test('computeLooksDone: non-git cwd → null without throwing (git-unavailable)', async () => {
+  const notARepo = fs.mkdtempSync(path.join(tmpHome, 'not-a-repo-'));
+  writePrd(notARepo, '11-no-repo', [
+    '# Implementation notes',
+    'Edit `src/thing.js`.',
+  ].join('\n'));
+
+  const job = { slug: '11-no-repo', cwd: notARepo, startedAt: new Date().toISOString() };
+  const looksDone = await computeLooksDone(job);
+  assert.equal(looksDone, null);
+});

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

@@ -0,0 +1,135 @@
+/**
+ * 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');
+
+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() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-argv-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const 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);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+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 }) {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-persona-main-'));
+  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');
+});

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

@@ -0,0 +1,222 @@
+/**
+ * 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 { 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');
+}
+
+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));
+  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() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-quiet-killed-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const 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);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+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)}`;
+  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', '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 });
+  }
+});