claude-code-session-manager 0.25.0 → 0.26.0

package/src/main/__tests__/dod-report.test.cjs

@@ -0,0 +1,304 @@
+/**
+ * dod-report.test.cjs — unit tests for flagRiskySurfaces + writeReport.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/dod-report.test.cjs
+ *
+ * Fixtures: os.tmpdir() only — never writes into real runs/.
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { flagRiskySurfaces, writeReport } = require('../lib/definitionOfDone.cjs');
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'dod-report-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writePrd(prdsDir, slug, implNotes, cwd) {
+  const body = [
+    '---',
+    `title: ${slug}`,
+    `cwd: ${cwd}`,
+    'estimateMinutes: 5',
+    '---',
+    '',
+    '# Goal',
+    '',
+    'Test fixture.',
+    '',
+    '# Acceptance criteria',
+    '',
+    '- [ ] `timeout 10 node -e "process.exit(0)"` passes.',
+    '',
+    '# Implementation notes',
+    '',
+    implNotes,
+    '',
+    '# Out of scope',
+    '',
+    '- N/A',
+  ].join('\n');
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
+  return { slug, cwd };
+}
+
+// ─── flagRiskySurfaces: money-path ────────────────────────────────────────────
+
+test('flagRiskySurfaces: flags money-path when impl notes reference payment', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '201-billing', '- Edit `src/payment-processor.js`\n- Update order schema', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.strictEqual(flags[0].slug, '201-billing');
+    assert.ok(flags[0].surfaces.includes('money-path'), `expected money-path in ${JSON.stringify(flags[0].surfaces)}`);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: flags auth when impl notes reference auth/token', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '202-auth', '- Modify `src/auth-middleware.py`\n- Update token refresh logic', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.ok(flags[0].surfaces.includes('auth'));
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: flags migration when impl notes reference .sql file', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '203-schema', '- Run `db/migrations/0042_users.sql`', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.ok(flags[0].surfaces.includes('migration'));
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: clean job is not returned', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const job = writePrd(prdsDir, '204-clean', '- Update `src/ui/button.tsx`\n- Add tooltip component', cwd);
+  try {
+    const flags = flagRiskySurfaces([job], { prdsDir });
+    assert.strictEqual(flags.length, 0);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: job with no PRD file is skipped (not thrown)', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  try {
+    const flags = flagRiskySurfaces([{ slug: '205-missing', cwd }], { prdsDir });
+    assert.strictEqual(flags.length, 0);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('flagRiskySurfaces: mixed batch returns only risky jobs', () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  const jobRisky = writePrd(prdsDir, '206-risky', '- Modify `src/trade-engine.js`', cwd);
+  const jobClean = writePrd(prdsDir, '207-clean', '- Update `src/tooltip.tsx`', cwd);
+  try {
+    const flags = flagRiskySurfaces([jobRisky, jobClean], { prdsDir });
+    assert.strictEqual(flags.length, 1);
+    assert.strictEqual(flags[0].slug, '206-risky');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+// ─── writeReport: structure ────────────────────────────────────────────────────
+
+test('writeReport: all three jobs appear in AC table', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [
+    { slug: '101-pass',  status: 'pass',         code: 0,    ms: 500 },
+    { slug: '102-fail',  status: 'fail',         code: 1,    ms: 300 },
+    { slug: '103-risky', status: 'pass',         code: 0,    ms: 400 },
+  ];
+  const riskFlags = [{ slug: '103-risky', surfaces: ['money-path'] }];
+  try {
+    const reportPath = writeReport('abcd1234', { acResults, riskFlags, runsDir });
+    assert.ok(fs.existsSync(reportPath), `report missing at ${reportPath}`);
+    const content = fs.readFileSync(reportPath, 'utf8');
+    assert.ok(content.includes('101-pass'), 'missing 101-pass in table');
+    assert.ok(content.includes('102-fail'), 'missing 102-fail in table');
+    assert.ok(content.includes('103-risky'), 'missing 103-risky in table');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: fail and risky slug both appear in needs-attention list', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [
+    { slug: '101-pass',  status: 'pass', code: 0, ms: 500 },
+    { slug: '102-fail',  status: 'fail', code: 1, ms: 300 },
+    { slug: '103-risky', status: 'pass', code: 0, ms: 400 },
+  ];
+  const riskFlags = [{ slug: '103-risky', surfaces: ['money-path'] }];
+  try {
+    const reportPath = writeReport('abcd1234', { acResults, riskFlags, runsDir });
+    const content = fs.readFileSync(reportPath, 'utf8');
+    // Both should appear in the Needs Human Attention section
+    const attentionIdx = content.indexOf('## Needs Human Attention');
+    assert.ok(attentionIdx !== -1, 'missing Needs Human Attention section');
+    const attentionSection = content.slice(attentionIdx);
+    assert.ok(attentionSection.includes('102-fail'), '102-fail missing from attention list');
+    assert.ok(attentionSection.includes('103-risky'), '103-risky missing from attention list');
+    // Clean pass should NOT be in attention list
+    const passInAttention = attentionSection.includes('101-pass');
+    assert.ok(!passInAttention, '101-pass should not appear in attention list');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: report states review is recommended, not auto-run', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  try {
+    const reportPath = writeReport('abcd1234', { acResults: [], riskFlags: [], runsDir });
+    const content = fs.readFileSync(reportPath, 'utf8');
+    assert.ok(
+      content.toLowerCase().includes('recommended') && content.toLowerCase().includes('not auto-run'),
+      'report must state review is recommended, not auto-run'
+    );
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: no .tmp files left after write', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [{ slug: '101-pass', status: 'pass', code: 0, ms: 100 }];
+  try {
+    writeReport('deadbeef', { acResults, riskFlags: [], runsDir });
+    // Walk all files in runsDir recursively, check none end in .tmp-*
+    function findTmps(dir) {
+      const hits = [];
+      try {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, e.name);
+          if (e.isDirectory()) hits.push(...findTmps(full));
+          else if (e.name.includes('.tmp-')) hits.push(full);
+        }
+      } catch { /* */ }
+      return hits;
+    }
+    const tmps = findTmps(runsDir);
+    assert.deepStrictEqual(tmps, [], `found leftover tmp files: ${tmps.join(', ')}`);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: second call with same batchKey produces clean report, no tmp files', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  const acResults = [
+    { slug: '101-pass', status: 'pass', code: 0, ms: 100 },
+    { slug: '102-fail', status: 'fail', code: 1, ms: 200 },
+  ];
+  const riskFlags = [{ slug: '101-pass', surfaces: ['auth'] }];
+  try {
+    writeReport('cafebabe', { acResults, riskFlags, runsDir });
+    // Small delay to guarantee different timestamp dir
+    const t = Date.now() + 2;
+    while (Date.now() < t) { /* busy wait 2ms */ }
+    const report2 = writeReport('cafebabe', { acResults, riskFlags, runsDir });
+
+    // Second report must exist and be valid
+    assert.ok(fs.existsSync(report2));
+    const content = fs.readFileSync(report2, 'utf8');
+
+    // No duplicate rows in the AC table — slice only the AC table section.
+    const acStart = content.indexOf('## AC Results');
+    const riskStart = content.indexOf('## Risk Flags');
+    const acSection = content.slice(acStart, riskStart === -1 ? undefined : riskStart);
+    const passCount = (acSection.match(/101-pass/g) || []).length;
+    const failCount = (acSection.match(/102-fail/g) || []).length;
+    assert.strictEqual(passCount, 1, `101-pass appears ${passCount} times in AC table`);
+    assert.strictEqual(failCount, 1, `102-fail appears ${failCount} times in AC table`);
+
+    // No tmp files anywhere
+    function findTmps(dir) {
+      const hits = [];
+      try {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, e.name);
+          if (e.isDirectory()) hits.push(...findTmps(full));
+          else if (e.name.includes('.tmp-')) hits.push(full);
+        }
+      } catch { /* */ }
+      return hits;
+    }
+    assert.deepStrictEqual(findTmps(runsDir), []);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: report filename contains the batchKey', () => {
+  const tmpDir = makeTmpDir();
+  const runsDir = path.join(tmpDir, 'runs');
+  try {
+    const reportPath = writeReport('feed1234', { acResults: [], riskFlags: [], runsDir });
+    assert.ok(path.basename(reportPath).includes('feed1234'));
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('writeReport: invalid batchKey throws', () => {
+  assert.throws(
+    () => writeReport('not-hex!!', { acResults: [], riskFlags: [] }),
+    /invalid batchKey/
+  );
+});

package/src/main/__tests__/dod-reverify.test.cjs

@@ -0,0 +1,285 @@
+/**
+ * dod-reverify.test.cjs — unit tests for extractAcCommand / reverifyAc / reverifyBatch.
+ *
+ * Run: timeout 180 node --test src/main/__tests__/dod-reverify.test.cjs
+ *
+ * Fixtures: os.tmpdir() only — never touches the real prds dir or scheduler queue.
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { extractAcCommand, reverifyAc, reverifyBatch } = require('../lib/definitionOfDone.cjs');
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'dod-reverify-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+/** Write a minimal PRD file and return the job object. */
+function writePrd(prdsDir, slug, acLine, cwd) {
+  const body = [
+    '---',
+    `title: ${slug}`,
+    `cwd: ${cwd}`,
+    'estimateMinutes: 5',
+    '---',
+    '',
+    '# Goal',
+    '',
+    'Test fixture.',
+    '',
+    '# Acceptance criteria',
+    '',
+    acLine,
+    '',
+    '# Out of scope',
+    '',
+    '- N/A',
+  ].join('\n');
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
+  return { slug, cwd };
+}
+
+// ─── extractAcCommand: backtick-quoted timeout ─────────────────────────────
+
+test('extractAcCommand: extracts timeout from backtick-quoted inline code', () => {
+  const body = [
+    '# Acceptance criteria',
+    '',
+    '- [ ] Test `timeout 120 node --test src/main/__tests__/foo.test.cjs` passes.',
+  ].join('\n');
+  assert.strictEqual(extractAcCommand(body), 'timeout 120 node --test src/main/__tests__/foo.test.cjs');
+});
+
+test('extractAcCommand: extracts timeout from raw (non-backtick) AC line', () => {
+  const body = [
+    '# Acceptance criteria',
+    '',
+    '- [ ] timeout 60 node -c src/main/lib/definitionOfDone.cjs',
+  ].join('\n');
+  assert.strictEqual(extractAcCommand(body), 'timeout 60 node -c src/main/lib/definitionOfDone.cjs');
+});
+
+test('extractAcCommand: returns first timeout command when multiple AC lines match', () => {
+  const body = [
+    '# Acceptance criteria',
+    '',
+    '- [ ] `timeout 60 node -c foo.cjs` parses clean.',
+    '- [ ] `timeout 120 node --test bar.test.cjs` passes.',
+  ].join('\n');
+  assert.strictEqual(extractAcCommand(body), 'timeout 60 node -c foo.cjs');
+});
+
+test('extractAcCommand: returns null when no timeout command in AC section', () => {
+  const body = [
+    '# Acceptance criteria',
+    '',
+    '- [ ] The widget renders without errors.',
+    '- [ ] The config file is valid JSON.',
+  ].join('\n');
+  assert.strictEqual(extractAcCommand(body), null);
+});
+
+test('extractAcCommand: returns null for null/empty body', () => {
+  assert.strictEqual(extractAcCommand(null), null);
+  assert.strictEqual(extractAcCommand(''), null);
+  assert.strictEqual(extractAcCommand(undefined), null);
+});
+
+test('extractAcCommand: skips commands with shell pipes (needs shell:true)', () => {
+  const body = [
+    '# Acceptance criteria',
+    '',
+    '- [ ] `timeout 150 python -m pytest 2>&1 | tail -15` passes.',
+    '- [ ] `timeout 60 node -c src/lib/foo.cjs` parses clean.',
+  ].join('\n');
+  // Pipe command is rejected; falls back to the second clean command.
+  assert.strictEqual(extractAcCommand(body), 'timeout 60 node -c src/lib/foo.cjs');
+});
+
+test('extractAcCommand: works when body contains frontmatter strip artifact', () => {
+  const body = [
+    '# Goal',
+    '',
+    'Do something.',
+    '',
+    '# Acceptance criteria',
+    '',
+    '- [ ] `timeout 30 node --test tests/foo.test.cjs` passes.',
+  ].join('\n');
+  assert.strictEqual(extractAcCommand(body), 'timeout 30 node --test tests/foo.test.cjs');
+});
+
+// ─── reverifyAc: pass ─────────────────────────────────────────────────────────
+
+test('reverifyAc: returns pass when AC command exits 0', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  // Write a tiny node script that exits 0
+  fs.writeFileSync(path.join(cwd, 'ok.cjs'), 'process.exit(0);');
+
+  const job = writePrd(prdsDir, '101-pass', '- [ ] `timeout 10 node ok.cjs` succeeds.', cwd);
+  try {
+    const result = await reverifyAc(job, { timeoutMs: 15_000, prdsDir });
+    assert.strictEqual(result.slug, '101-pass');
+    assert.strictEqual(result.status, 'pass');
+    assert.strictEqual(result.code, 0);
+    assert.ok(typeof result.ms === 'number' && result.ms >= 0, `ms should be >= 0, got ${result.ms}`);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+// ─── reverifyAc: fail ─────────────────────────────────────────────────────────
+
+test('reverifyAc: returns fail when AC command exits non-zero', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  fs.writeFileSync(path.join(cwd, 'fail.cjs'), 'process.exit(1);');
+
+  const job = writePrd(prdsDir, '102-fail', '- [ ] `timeout 10 node fail.cjs` succeeds.', cwd);
+  try {
+    const result = await reverifyAc(job, { timeoutMs: 15_000, prdsDir });
+    assert.strictEqual(result.slug, '102-fail');
+    assert.strictEqual(result.status, 'fail');
+    assert.strictEqual(result.code, 1);
+    assert.ok(typeof result.ms === 'number' && result.ms >= 0);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+// ─── reverifyAc: unverifiable ─────────────────────────────────────────────────
+
+test('reverifyAc: returns unverifiable when PRD has no parseable AC command', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+
+  const job = writePrd(prdsDir, '103-nocmd', '- [ ] The widget renders correctly.', cwd);
+  try {
+    const result = await reverifyAc(job, { timeoutMs: 15_000, prdsDir });
+    assert.strictEqual(result.slug, '103-nocmd');
+    assert.strictEqual(result.status, 'unverifiable');
+    assert.strictEqual(result.code, null);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('reverifyAc: returns unverifiable when cwd does not exist', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  fs.mkdirSync(prdsDir);
+  const missingCwd = path.join(tmpDir, 'nonexistent-project');
+
+  const job = writePrd(prdsDir, '104-nocwd', '- [ ] `timeout 5 node -e "process.exit(0)"` passes.', missingCwd);
+  try {
+    const result = await reverifyAc(job, { timeoutMs: 15_000, prdsDir });
+    assert.strictEqual(result.status, 'unverifiable');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('reverifyAc: returns unverifiable when PRD file does not exist', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+
+  // job.slug points to a missing .md file
+  const job = { slug: '105-missing-prd', cwd };
+  try {
+    const result = await reverifyAc(job, { timeoutMs: 15_000, prdsDir });
+    assert.strictEqual(result.status, 'unverifiable');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+// ─── reverifyBatch: all three statuses ────────────────────────────────────────
+
+test('reverifyBatch: returns pass/fail/unverifiable for a mixed batch', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+
+  fs.writeFileSync(path.join(cwd, 'ok.cjs'), 'process.exit(0);');
+  fs.writeFileSync(path.join(cwd, 'fail.cjs'), 'process.exit(1);');
+
+  const jobPass = writePrd(prdsDir, '201-pass', '- [ ] `timeout 10 node ok.cjs` passes.', cwd);
+  const jobFail = writePrd(prdsDir, '202-fail', '- [ ] `timeout 10 node fail.cjs` passes.', cwd);
+  const jobNone = writePrd(prdsDir, '203-noop', '- [ ] The result is correct.', cwd);
+
+  try {
+    const results = await reverifyBatch([jobPass, jobFail, jobNone], {
+      timeoutMs: 15_000,
+      batchTimeoutMs: 120_000,
+      prdsDir,
+    });
+    assert.strictEqual(results.length, 3);
+
+    const bySlug = Object.fromEntries(results.map((r) => [r.slug, r]));
+    assert.strictEqual(bySlug['201-pass'].status, 'pass');
+    assert.strictEqual(bySlug['202-fail'].status, 'fail');
+    assert.strictEqual(bySlug['203-noop'].status, 'unverifiable');
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+// ─── reverifyBatch: batch wall-time cap ───────────────────────────────────────
+
+test('reverifyBatch: marks remaining jobs unverifiable when batch cap is hit', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+
+  // Slow job — sleeps longer than batchTimeoutMs
+  fs.writeFileSync(path.join(cwd, 'slow.cjs'), 'setTimeout(() => process.exit(0), 30_000);');
+  const jobSlow = writePrd(prdsDir, '301-slow', '- [ ] `timeout 60 node slow.cjs` passes.', cwd);
+  fs.writeFileSync(path.join(cwd, 'ok.cjs'), 'process.exit(0);');
+  const jobAfter = writePrd(prdsDir, '302-after', '- [ ] `timeout 10 node ok.cjs` passes.', cwd);
+
+  try {
+    // Kill the slow job after 500ms; the batch cap (200ms) ensures jobAfter
+    // is never started. Total test wall-time ≈ 500ms.
+    const results = await reverifyBatch([jobSlow, jobAfter], {
+      timeoutMs: 500,
+      batchTimeoutMs: 200,
+      prdsDir,
+    });
+    assert.strictEqual(results.length, 2);
+    // The slow job ran but the batch cap check fires before jobAfter starts.
+    // (The slow job itself may finish or not within the timeoutMs; we only care
+    // that jobAfter is unverifiable due to the batch cap.)
+    const after = results.find((r) => r.slug === '302-after');
+    assert.strictEqual(after.status, 'unverifiable');
+  } finally {
+    rmdir(tmpDir);
+  }
+});

package/src/main/index.cjs

@@ -57,6 +57,9 @@ let powerBlockerId = -1;
 // `systemd-inhibit` child, which talks straight to logind and is
 // desktop-agnostic. Handle to the child so we can release it on quit.
 let systemdInhibitChild = null;
+// Belt-and-suspenders: re-assert the inhibitor on a slow cadence so it can never
+// stay dead (idempotent — startSystemdInhibit no-ops if a live holder exists).
+let inhibitReassertTimer = null;
 
 function startSystemdInhibit() {
   if (process.platform !== 'linux') return;
@@ -70,7 +73,11 @@ function startSystemdInhibit() {
     // this the child reparents to init on a hard kill and the inhibitor leaks
     // forever (one stranded lock per crash). 5s tick = worst-case 5s of stale
     // lock after death, which errs toward "stay awake" — the safe direction.
-    const child = spawn('systemd-inhibit', [
+    // Absolute path — a GUI/desktop-launched Electron can boot with a minimal
+    // PATH that lacks /usr/bin, so a bare `systemd-inhibit` would ENOENT.
+    const inhibitBin = require('node:fs').existsSync('/usr/bin/systemd-inhibit')
+      ? '/usr/bin/systemd-inhibit' : 'systemd-inhibit';
+    const child = spawn(inhibitBin, [
       '--what=sleep:idle',
       '--who=Claude Session Manager',
       '--why=Scheduler polling and claude -p jobs must survive idle',
@@ -80,6 +87,17 @@ function startSystemdInhibit() {
     child.on('error', (e) => {
       logs.writeLine({ scope: 'main', level: 'warn', message: 'systemd-inhibit spawn failed', meta: { error: e?.message } });
     });
+    // Self-heal: if the holder ever dies while the app is alive (a missed
+    // suspend, an external kill, a transient spawn that didn't hold), revive it.
+    // Without this the lock is held exactly once at boot and never recovers —
+    // the machine then idle-suspends with the app open (the reported bug).
+    child.on('exit', (code, signal) => {
+      logs.writeLine({ scope: 'main', level: 'warn', message: 'systemd-inhibit holder exited', meta: { code, signal } });
+      if (!teardownDone && systemdInhibitChild === child) {
+        systemdInhibitChild = null;
+        setTimeout(() => { if (!teardownDone) startSystemdInhibit(); }, 2000);
+      }
+    });
     if (child.pid) {
       systemdInhibitChild = child;
       logs.writeLine({ scope: 'main', level: 'info', message: 'systemd-inhibit block lock held', meta: { pid: child.pid } });
@@ -952,6 +970,12 @@ app.whenReady().then(async () => {
   }
   // Linux backstop — Electron's blocker no-ops under COSMIC (see above).
   startSystemdInhibit();
+  // Re-assert every 60s so a dead holder self-revives even if its exit handler
+  // was missed. Idempotent; unref'd so it never holds the loop open at quit.
+  if (process.platform === 'linux' && !inhibitReassertTimer) {
+    inhibitReassertTimer = setInterval(() => { if (!teardownDone) startSystemdInhibit(); }, 60_000);
+    if (inhibitReassertTimer.unref) inhibitReassertTimer.unref();
+  }
 
   // OTEL: load persisted config and start the exporter only if `enabled`.
   // Failures are non-fatal — the app must keep working without telemetry.
@@ -987,6 +1011,7 @@ function runShutdownCleanup() {
     try { powerSaveBlocker.stop(powerBlockerId); } catch { /* */ }
     powerBlockerId = -1;
   }
+  if (inhibitReassertTimer) { clearInterval(inhibitReassertTimer); inhibitReassertTimer = null; }
   stopSystemdInhibit();
 }