claude-code-session-manager 0.25.0 → 0.25.1

package/dist/index.html

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-H0IXEKiC.js"></script>
+    <script type="module" crossorigin src="./assets/index-CK5Ob11w.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
     <link rel="stylesheet" crossorigin href="./assets/index-Cu9X6oyA.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

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

@@ -0,0 +1,183 @@
+/**
+ * dod-batchkey.test.cjs — unit tests for definitionOfDone.cjs helpers.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/dod-batchkey.test.cjs
+ */
+
+'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 { batchKey, reportPathFor, reportExists } = require('../lib/definitionOfDone.cjs');
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'dod-batchkey-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function makeJob(slug, runId) {
+  return { slug, runId };
+}
+
+// ─── batchKey: order-independence ─────────────────────────────────────────────
+
+test('batchKey is order-independent', () => {
+  const jobsA = [
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+    makeJob('102-bar', '2026-06-01T11-00-00-000Z'),
+  ];
+  const jobsB = [
+    makeJob('102-bar', '2026-06-01T11-00-00-000Z'),
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+  ];
+  assert.strictEqual(batchKey(jobsA), batchKey(jobsB));
+});
+
+// ─── batchKey: adding a real job changes the key ─────────────────────────────
+
+test('adding a real job changes the batchKey', () => {
+  const base = [
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+  ];
+  const extended = [
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+    makeJob('102-bar', '2026-06-01T11-00-00-000Z'),
+  ];
+  assert.notStrictEqual(batchKey(base), batchKey(extended));
+});
+
+// ─── batchKey: adding a meta/dod job does NOT change the key ─────────────────
+
+test('adding a dod-prefixed slug does not change batchKey', () => {
+  const base = [makeJob('101-foo', '2026-06-01T10-00-00-000Z')];
+  const withDod = [
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+    makeJob('dod-gate', '2026-06-01T12-00-00-000Z'),
+  ];
+  assert.strictEqual(batchKey(base), batchKey(withDod));
+});
+
+test('adding a dod-suffixed slug does not change batchKey', () => {
+  const base = [makeJob('101-foo', '2026-06-01T10-00-00-000Z')];
+  const withDod = [
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+    makeJob('gate-dod', '2026-06-01T12-00-00-000Z'),
+  ];
+  assert.strictEqual(batchKey(base), batchKey(withDod));
+});
+
+test('adding a definition-of-done slug does not change batchKey', () => {
+  const base = [makeJob('101-foo', '2026-06-01T10-00-00-000Z')];
+  const withDod = [
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+    makeJob('definition-of-done-pass', '2026-06-01T12-00-00-000Z'),
+  ];
+  assert.strictEqual(batchKey(base), batchKey(withDod));
+});
+
+test('adding an inline dod slug (dod between dashes) does not change batchKey', () => {
+  const base = [makeJob('101-foo', '2026-06-01T10-00-00-000Z')];
+  const withDod = [
+    makeJob('101-foo', '2026-06-01T10-00-00-000Z'),
+    makeJob('batch-dod-check', '2026-06-01T12-00-00-000Z'),
+  ];
+  assert.strictEqual(batchKey(base), batchKey(withDod));
+});
+
+// ─── batchKey: empty set ──────────────────────────────────────────────────────
+
+test('empty job list produces a stable key', () => {
+  assert.strictEqual(typeof batchKey([]), 'string');
+  assert.strictEqual(batchKey([]), batchKey([]));
+});
+
+// ─── batchKey: same slug different runId produces different keys ──────────────
+
+test('same slug but different runId produces different keys', () => {
+  const a = [makeJob('101-foo', '2026-06-01T10-00-00-000Z')];
+  const b = [makeJob('101-foo', '2026-06-01T11-00-00-000Z')];
+  assert.notStrictEqual(batchKey(a), batchKey(b));
+});
+
+// ─── reportPathFor ────────────────────────────────────────────────────────────
+
+test('reportPathFor returns a path ending with definition-of-done-<key>.md', () => {
+  const key = batchKey([makeJob('101-foo', '2026-06-01T10-00-00-000Z')]);
+  const p = reportPathFor(key);
+  assert.ok(p.endsWith(`definition-of-done-${key}.md`), `path: ${p}`);
+  assert.ok(p.includes('scheduled-plans/runs/'), `path: ${p}`);
+});
+
+// ─── reportExists ─────────────────────────────────────────────────────────────
+
+test('reportExists returns false when runs/ dir does not exist', () => {
+  const key = batchKey([makeJob('101-foo', '2026-06-01T10-00-00-000Z')]);
+  const tmpDir = makeTmpDir();
+  try {
+    const runsDir = path.join(tmpDir, 'runs');
+    // runsDir intentionally not created
+    assert.strictEqual(reportExists(key, runsDir), false);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('reportExists returns false when no matching file exists', () => {
+  const key = batchKey([makeJob('101-foo', '2026-06-01T10-00-00-000Z')]);
+  const tmpDir = makeTmpDir();
+  try {
+    const runsDir = path.join(tmpDir, 'runs');
+    const runDir = path.join(runsDir, '2026-06-01T10-00-00-000Z');
+    fs.mkdirSync(runDir, { recursive: true });
+    fs.writeFileSync(path.join(runDir, 'some-other-file.md'), '# other');
+    assert.strictEqual(reportExists(key, runsDir), false);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('reportExists returns true when matching file exists in any run subdir', () => {
+  const key = batchKey([makeJob('101-foo', '2026-06-01T10-00-00-000Z')]);
+  const tmpDir = makeTmpDir();
+  try {
+    const runsDir = path.join(tmpDir, 'runs');
+    const runDir = path.join(runsDir, '2026-06-01T10-00-00-000Z');
+    fs.mkdirSync(runDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(runDir, `definition-of-done-${key}.md`),
+      '# DoD report'
+    );
+    assert.strictEqual(reportExists(key, runsDir), true);
+  } finally {
+    rmdir(tmpDir);
+  }
+});
+
+test('reportExists finds match in a nested run directory (not first subdir)', () => {
+  const key = batchKey([makeJob('101-foo', '2026-06-01T10-00-00-000Z')]);
+  const tmpDir = makeTmpDir();
+  try {
+    const runsDir = path.join(tmpDir, 'runs');
+    // Two subdirs; match is in the second
+    const runDir1 = path.join(runsDir, '2026-06-01T09-00-00-000Z');
+    const runDir2 = path.join(runsDir, '2026-06-01T10-00-00-000Z');
+    fs.mkdirSync(runDir1, { recursive: true });
+    fs.mkdirSync(runDir2, { recursive: true });
+    fs.writeFileSync(path.join(runDir1, 'other.md'), '# other');
+    fs.writeFileSync(
+      path.join(runDir2, `definition-of-done-${key}.md`),
+      '# DoD report'
+    );
+    assert.strictEqual(reportExists(key, runsDir), true);
+  } finally {
+    rmdir(tmpDir);
+  }
+});

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();
 }