claude-code-session-manager 0.82.0 → 0.84.0

package/src/main/__tests__/health-usage-poller.test.cjs

@@ -0,0 +1,97 @@
+/**
+ * health-usage-poller.test.cjs — `npm run health` must report non-GREEN when
+ * the usage/rate-limit poller's (scheduler.cjs pollLoop) consecutiveFailures
+ * streak, persisted to ~/.claude/session-manager/scheduler-state.json,
+ * reaches FAILURE_STREAK_WARN_THRESHOLD — the SAME count that gates the
+ * one-time opsErrorLog WARN (rateLimitPollerStreak.test.cjs shouldWarnFailureStreak
+ * fires at `>= threshold`), so the log line and the health-GREEN flip happen
+ * on the exact same failure, not one apart. Exercises evaluateUsagePollerHealth()
+ * and loadUsagePollerState() directly since both are pure/file-scoped, matching
+ * every other evaluate* helper's test pattern in this file — deliberately NOT
+ * driving the full (slow, machine-state-coupled) check() for this.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/health-usage-poller.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const { evaluateUsagePollerHealth, loadUsagePollerState } = require('../health.cjs');
+const { FAILURE_STREAK_WARN_THRESHOLD } = require('../scheduler.cjs');
+
+test('missing state (fresh install / poller never ran) is ok, not applicable', () => {
+  expect(evaluateUsagePollerHealth(null)).toEqual({ ok: true, applicable: false });
+  expect(evaluateUsagePollerHealth(undefined)).toEqual({ ok: true, applicable: false });
+});
+
+test('consecutiveFailures below the threshold is GREEN', () => {
+  const result = evaluateUsagePollerHealth({ consecutiveFailures: FAILURE_STREAK_WARN_THRESHOLD - 1, backoffMs: 240_000, lastPollAt: Date.now() });
+  expect(result.ok).toBe(true);
+  expect(result.applicable).toBe(true);
+  expect(result.message).toBeUndefined();
+});
+
+test('consecutiveFailures AT the threshold is already non-GREEN — same count the WARN fires at', () => {
+  // Must match shouldWarnFailureStreak's `>= threshold` exactly (scheduler.cjs)
+  // so the opsErrorLog WARN and this health flip happen on the same failure.
+  const result = evaluateUsagePollerHealth({ consecutiveFailures: FAILURE_STREAK_WARN_THRESHOLD, backoffMs: 480_000, lastPollAt: Date.now() });
+  expect(result.ok).toBe(false);
+  expect(result.message).toMatch(new RegExp(`${FAILURE_STREAK_WARN_THRESHOLD} consecutive failures`));
+});
+
+test('consecutiveFailures well past the threshold is non-GREEN with a diagnostic message', () => {
+  const result = evaluateUsagePollerHealth({ consecutiveFailures: 57, backoffMs: 480_000, lastPollAt: Date.now() });
+  expect(result.ok).toBe(false);
+  expect(result.consecutiveFailures).toBe(57);
+  expect(result.backoffMs).toBe(480_000);
+  expect(result.message).toMatch(/57 consecutive failures/);
+});
+
+test('respects a custom threshold argument', () => {
+  expect(evaluateUsagePollerHealth({ consecutiveFailures: 3 }, 3).ok).toBe(false);
+  expect(evaluateUsagePollerHealth({ consecutiveFailures: 2 }, 3).ok).toBe(true);
+});
+
+test('tolerates a malformed/partial state object without throwing', () => {
+  const result = evaluateUsagePollerHealth({});
+  expect(result.ok).toBe(true);
+  expect(result.consecutiveFailures).toBe(0);
+});
+
+// loadUsagePollerState: must distinguish "never ran" (ENOENT) from "corrupt"
+// (unparseable) — the exact silent-masking bug class as the sibling
+// scheduler-machine.json torn-write incident (f56bdc0), just for this sidecar.
+// Uses a real scratch temp dir/file, never the real ~/.claude/session-manager/.
+let scratchDir;
+function makeScratchPath() {
+  scratchDir = mkdtempSync(join(tmpdir(), 'sm-usage-poller-health-'));
+  return join(scratchDir, 'scheduler-state.json');
+}
+
+test('loadUsagePollerState: missing file -> { missing: true }', () => {
+  const p = join(makeScratchPath()); // never written
+  const result = loadUsagePollerState(p);
+  expect(result).toEqual({ missing: true });
+  rmSync(scratchDir, { recursive: true, force: true });
+});
+
+test('loadUsagePollerState: corrupt/unparseable JSON -> errorMessage, not missing', () => {
+  const p = makeScratchPath();
+  writeFileSync(p, '{ not: valid json', 'utf8');
+  const result = loadUsagePollerState(p);
+  expect(result.missing).toBeUndefined();
+  expect(result.state).toBeUndefined();
+  expect(result.errorMessage).toMatch(/corrupt/);
+  rmSync(scratchDir, { recursive: true, force: true });
+});
+
+test('loadUsagePollerState: valid JSON -> { state }', () => {
+  const p = makeScratchPath();
+  writeFileSync(p, JSON.stringify({ consecutiveFailures: 12, backoffMs: 480_000, lastPollAt: 123 }), 'utf8');
+  const result = loadUsagePollerState(p);
+  expect(result.state).toEqual({ consecutiveFailures: 12, backoffMs: 480_000, lastPollAt: 123 });
+  rmSync(scratchDir, { recursive: true, force: true });
+});

package/src/main/__tests__/health-worktree-cap-blocked.test.cjs

@@ -0,0 +1,65 @@
+/**
+ * health-worktree-cap-blocked.test.cjs — `npm run health` must report
+ * non-GREEN when the worktree cap (gitWorktree.cjs's reserveWorktreeSlot) is
+ * blocking every dispatchable pending job with nothing running. Before this
+ * check existed that state was invisible to health.cjs: rows in four
+ * separate project queues carried heldReason 'worktree cap reached (5
+ * concurrent)' for 16 hours with zero entries in
+ * session-manager-operations/logs/ and nothing non-GREEN here — only a
+ * console.log line and the heldReason field itself, which nothing surfaced.
+ *
+ * Exercises evaluateWorktreeCapBlocked() directly — pure, no fs — matching
+ * every other evaluate* helper's test pattern in this file (see
+ * health-usage-poller.test.cjs's header).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/health-worktree-cap-blocked.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { evaluateWorktreeCapBlocked } = require('../health.cjs');
+
+test('a pending job held on "worktree cap reached" with 0 running is non-GREEN, blocked', () => {
+  const jobs = [
+    { slug: 'a', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' },
+    { slug: 'b', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' },
+  ];
+  const result = evaluateWorktreeCapBlocked(jobs, 0);
+  expect(result.ok).toBe(false);
+  expect(result.blocked).toBe(true);
+  expect(result.capBlockedSlugs).toEqual(['a', 'b']);
+});
+
+test('accepts a job map (queueStore.readMergedSync federated shape), not just an array', () => {
+  const jobs = {
+    a: { slug: 'a', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' },
+    b: { slug: 'b', status: 'completed' },
+  };
+  const result = evaluateWorktreeCapBlocked(jobs, 0);
+  expect(result.ok).toBe(false);
+  expect(result.capBlockedSlugs).toEqual(['a']);
+});
+
+test('the same cap-reached row stays GREEN while at least one job is running', () => {
+  const jobs = [{ slug: 'a', status: 'pending', heldReason: 'worktree cap reached (5 concurrent)' }];
+  const result = evaluateWorktreeCapBlocked(jobs, 1);
+  expect(result.ok).toBe(true);
+  expect(result.blocked).toBe(false);
+});
+
+test('a pending row with an unrelated heldReason (or none) stays GREEN', () => {
+  const jobs = [
+    { slug: 'a', status: 'pending', heldReason: 'launch blocked (rate_limit) — re-probe at 2026-09-11T00:00:00Z' },
+    { slug: 'b', status: 'pending' },
+  ];
+  const result = evaluateWorktreeCapBlocked(jobs, 0);
+  expect(result.ok).toBe(true);
+  expect(result.blocked).toBe(false);
+});
+
+test('no pending jobs at all stays GREEN', () => {
+  const result = evaluateWorktreeCapBlocked([], 0);
+  expect(result.ok).toBe(true);
+  expect(result.blocked).toBe(false);
+});

package/src/main/__tests__/opsErrorLogTelemetryTap.test.cjs

@@ -0,0 +1,143 @@
+/**
+ * opsErrorLogTelemetryTap.test.cjs — unit tests for appendError()'s telemetry
+ * mirror. Kept separate from opsErrorLog.test.cjs (whose pre-existing tests
+ * stay unmodified in intent) since this is new behavior this PRD adds.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/opsErrorLogTelemetryTap.test.cjs
+ */
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const opsErrorLog = require('../lib/opsErrorLog.cjs');
+
+const tmpDirs = [];
+let originalHome;
+
+afterEach(async () => {
+  if (originalHome !== undefined) process.env.HOME = originalHome;
+  const telemetryPath = require.resolve('../lib/telemetryClient.cjs');
+  delete require.cache[telemetryPath];
+  const activeSessionsPath = require.resolve('../../../scripts/lib/activeSessions.cjs');
+  delete require.cache[activeSessionsPath];
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+function mkTmpProject() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-opslog-telemetry-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+function readLines(cwd) {
+  const file = opsErrorLog.todayFile(cwd);
+  if (!fs.existsSync(file)) return [];
+  return fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
+}
+
+function stubTelemetryClient(exportsObj) {
+  const telemetryPath = require.resolve('../lib/telemetryClient.cjs');
+  require.cache[telemetryPath] = { id: telemetryPath, filename: telemetryPath, loaded: true, exports: exportsObj };
+}
+
+// ─── AFTER local write, never blocks it ──────────────────────────────────
+
+test('a throwing telemetry stub never prevents or corrupts the local JSONL write', () => {
+  const cwd = mkTmpProject();
+  stubTelemetryClient({
+    reportError: () => { throw new Error('telemetry boom'); },
+    logLine: () => { throw new Error('telemetry boom'); },
+  });
+
+  expect(() => opsErrorLog.appendError({ cwd, scope: 'pty', message: 'boom happened' })).not.toThrow();
+
+  const lines = readLines(cwd);
+  expect(lines.length).toBe(1);
+  expect(lines[0].message).toBe('boom happened');
+});
+
+test('level "warn" routes to telemetryClient.logLine, default "error" routes to reportError', () => {
+  const cwd = mkTmpProject();
+  const reportErrorCalls = [];
+  const logLineCalls = [];
+  stubTelemetryClient({
+    reportError: (o) => reportErrorCalls.push(o),
+    logLine: (o) => logLineCalls.push(o),
+  });
+
+  opsErrorLog.appendError({ cwd, scope: 'chatRunner', level: 'warn', message: 'careful' });
+  expect(logLineCalls).toHaveLength(1);
+  expect(reportErrorCalls).toHaveLength(0);
+
+  opsErrorLog.appendError({ cwd, scope: 'chatRunner', message: 'broke' });
+  expect(reportErrorCalls).toHaveLength(1);
+});
+
+// ─── ephemeral cwd: local refused, telemetry still fires ─────────────────
+
+test('an ephemeral cwd yields zero local lines but one telemetry record, with a normalized projectHash', () => {
+  const { KIND_CONFIG } = require('../lib/gitWorktree.cjs');
+  const worktreeCwd = path.join(KIND_CONFIG.epic.root, 'fakehash', 'fake-epic-id');
+  const realRoot = '/home/bilko/Projects/real-project';
+
+  const activeSessionsPath = require.resolve('../../../scripts/lib/activeSessions.cjs');
+  const original = require('../../../scripts/lib/activeSessions.cjs');
+  require.cache[activeSessionsPath] = {
+    id: activeSessionsPath,
+    filename: activeSessionsPath,
+    loaded: true,
+    exports: { ...original, projectRootOf: (p) => (p === worktreeCwd ? realRoot : p) },
+  };
+
+  const reportErrorCalls = [];
+  stubTelemetryClient({ reportError: (o) => reportErrorCalls.push(o), logLine: () => {} });
+
+  opsErrorLog.appendError({ cwd: worktreeCwd, scope: 'chatRunner', message: 'worktree err' });
+
+  expect(fs.existsSync(opsErrorLog.todayFile(worktreeCwd))).toBe(false);
+  expect(reportErrorCalls).toHaveLength(1);
+  expect(reportErrorCalls[0].context.cwd).toBe(realRoot);
+  expect(reportErrorCalls[0].context.cwd).not.toBe(worktreeCwd);
+});
+
+// ─── PII: no prompt text, no absolute path ────────────────────────────────
+
+test('a realistic error with an absolute path and a prompt-like string never reaches the telemetry payload verbatim', async () => {
+  originalHome = process.env.HOME;
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-opslog-telemetry-home-'));
+  tmpDirs.push(home);
+  process.env.HOME = home;
+
+  for (const p of ['../lib/telemetryClient.cjs', '../config.cjs', '../lib/telemetrySettings.cjs', '../lib/machineProfile.cjs']) {
+    const resolved = require.resolve(p);
+    delete require.cache[resolved];
+  }
+  const client = require('../lib/telemetryClient.cjs');
+  client._setMachineProfileBuilder(async () => ({
+    appVersion: '0.83.0', platform: 'linux', arch: 'x64', machineDigest: 'deadbeefcafe',
+  }));
+
+  const cwd = mkTmpProject();
+  const absPath = `${home}/Projects/super-secret-client/src/main/index.cjs`;
+  const promptLike = 'write me a function that deletes all files matching *.secret and email me the results';
+  opsErrorLog.appendError({
+    cwd,
+    scope: 'chatRunner',
+    message: `run failed while processing "${promptLike}" at ${absPath}`,
+  });
+
+  await new Promise((r) => setTimeout(r, 50));
+
+  const raw = await fsp.readFile(client.queuePath(), 'utf8');
+  expect(raw).not.toContain(home);
+  expect(raw).not.toContain(absPath);
+  expect(raw).not.toContain(promptLike);
+  client.shutdown();
+});

package/src/main/__tests__/pollLoop-dispatch-on-failure.test.cjs

@@ -0,0 +1,120 @@
+/**
+ * pollLoop-dispatch-on-failure.test.cjs — PRD: 27 pending jobs across two
+ * projects sat at 0 running for days while every surface reported healthy.
+ * Root cause: under firePolicy 'when-available', maybeLaunchWhenAvailable()
+ * (the only thing that ever calls tickQueue() on the poll timer) was reached
+ * from exactly two of pollLoop()'s branches — 'ok' and 'meter_rate_limited'.
+ * The auth branch, the transient/config branch, and the outer catch all
+ * incremented consecutiveFailures and returned WITHOUT attempting a
+ * dispatch, so a poller that started failing (for any reason) silently
+ * stopped driving the queue even though slots/memory/utilization were fine.
+ *
+ * This suite drives the REAL pollLoop() (not a reimplementation) through a
+ * transient billing failure and a thrown error, and asserts a dispatch was
+ * actually attempted in both cases — observed via `lastDispatchAttemptAt`,
+ * which tickQueue() stamps the moment it reaches the picker, independent of
+ * whether that pass ends in an actual job launch (see classifyQueueStarvation's
+ * header for why this must be distinct from `lastRunAt`).
+ *
+ * No existing test in this repo mocks a module import (see
+ * pty-epic-worktree-spawn-cwd.test.cjs's header) — this monkey-patches
+ * usage.cjs's cached module object directly instead, same pattern.
+ *
+ * Run: timeout 180 npx vitest run src/main/__tests__/pollLoop-dispatch-on-failure.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let scheduler;
+let queueStore;
+let billing;
+let originalFetchUsage;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pollloop-dispatch-'));
+  process.env.HOME = tmpHome;
+  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
+  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
+  scheduler = require('../scheduler.cjs');
+  queueStore = require('../lib/queueStore.cjs');
+  billing = require('../usage.cjs');
+  originalFetchUsage = billing.fetchUsage;
+});
+
+afterAll(() => {
+  billing.fetchUsage = originalFetchUsage;
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  billing.fetchUsage = originalFetchUsage;
+  delete process.env.SM_E2E;
+  delete process.env.SM_MOCK_BILLING_KIND;
+});
+
+// allProjectCwds()/activeProjectCwds() (queueStore.cjs's stateCwds) discover
+// project cwds by scanning ~/.claude/projects/*/*.jsonl for a `cwd` field —
+// fake one project transcript pointing at the fixture cwd, same pattern as
+// prdAdminRoutes.test.cjs / scheduler-verify-prd-path.test.cjs.
+function mkProject() {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pollloop-project-'));
+  const slug = `9001-pollloop-dispatch-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const projDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'projects', 'sm-pollloop-fake-'));
+  fs.writeFileSync(path.join(projDir, 'session.jsonl'), `${JSON.stringify({ cwd })}\n`, 'utf8');
+  return { cwd, slug };
+}
+
+async function seedOnePendingJob() {
+  const { cwd, slug } = mkProject();
+  await scheduler.writeQueue({
+    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
+    config: {},
+    paused: null,
+  });
+  return { cwd, slug };
+}
+
+async function lastDispatchAttemptAt() {
+  return queueStore.readMergedSync().lastDispatchAttemptAt;
+}
+
+// After pollLoop() fires maybeLaunchWhenAvailable() fire-and-forget, the tick
+// it enqueues lands on the shared, serialized tickTail chain that tickQueue()
+// itself maintains. A follow-up tickQueue() call is appended to that SAME
+// chain, so awaiting it guarantees the earlier tick (if any was enqueued)
+// has already settled.
+async function flushPendingTick() {
+  await scheduler.tickQueue();
+}
+
+test('pollLoop still attempts a dispatch after a transient billing failure', async () => {
+  await seedOnePendingJob();
+  expect(await lastDispatchAttemptAt()).toBeNull();
+
+  process.env.SM_E2E = '1';
+  process.env.SM_MOCK_BILLING_KIND = 'transient';
+  await scheduler.pollLoop();
+  await flushPendingTick();
+
+  expect(await lastDispatchAttemptAt()).not.toBeNull();
+});
+
+test('pollLoop still attempts a dispatch after the billing poll throws', async () => {
+  await seedOnePendingJob();
+  expect(await lastDispatchAttemptAt()).toBeNull();
+
+  billing.fetchUsage = async () => { throw new Error('simulated IPC transport failure'); };
+  await scheduler.pollLoop();
+  await flushPendingTick();
+
+  expect(await lastDispatchAttemptAt()).not.toBeNull();
+});

package/src/main/__tests__/queue-starvation-dispatch-driver.test.cjs

@@ -0,0 +1,143 @@
+/**
+ * queue-starvation-dispatch-driver.test.cjs — two liveness gaps in the
+ * queue-starvation watchdog itself, both observed live on 2026-09-11
+ * (27 pending jobs across two projects, 0 running, for days):
+ *
+ * 1. classifyQueueStarvation/runQueueStarvationWatchdog used to measure
+ *    idleness from `lastRunAt`, which the poll loop kept looking fresh even
+ *    while nothing was actually dispatching — masking the very stall the
+ *    watchdog exists to catch. It must measure from `lastDispatchAttemptAt`
+ *    instead (stamped by tickQueue() the moment it reaches the picker,
+ *    regardless of outcome — see tickQueue's own comment).
+ * 2. tickQueue()'s very first real guard returns {fired:false,
+ *    reason:'cancelled'} whenever the in-process cancelToken is wedged
+ *    true — historically only ever reset by runDueJobs() (force-tick/
+ *    run-now/resume-timer). A pause that clears WITHOUT going through
+ *    clearPause() (e.g. a direct queue-state write) leaves the token
+ *    wedged forever with nothing left to un-wedge it. The starvation
+ *    watchdog is the last line of defence, so it must reset the token
+ *    itself before forcing its tick.
+ *
+ * Run: timeout 180 npx vitest run src/main/__tests__/queue-starvation-dispatch-driver.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let originalClaudeBin;
+let scheduler;
+let queueStore;
+
+// A forced tick actually dispatches the one pending job it finds. Without a
+// stub, that spawns the real `claude` binary (or fails trying to), leaving
+// scheduler.cjs's module-scoped runningSet non-empty by the time the next
+// test in this file runs — classifyQueueStarvation's `runningCount > 0`
+// guard then makes runQueueStarvationWatchdog return null for a reason that
+// has nothing to do with what that test is actually checking.
+function writeClaudeStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-starve-driver-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');
+    process.exit(0);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  originalClaudeBin = process.env.SM_CLAUDE_BIN;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-starve-driver-'));
+  process.env.HOME = tmpHome;
+  process.env.SM_CLAUDE_BIN = writeClaudeStub();
+  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
+  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
+  scheduler = require('../scheduler.cjs');
+  queueStore = require('../lib/queueStore.cjs');
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  if (originalClaudeBin === undefined) delete process.env.SM_CLAUDE_BIN;
+  else process.env.SM_CLAUDE_BIN = originalClaudeBin;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+// allProjectCwds()/activeProjectCwds() (queueStore.cjs's stateCwds) discover
+// project cwds by scanning ~/.claude/projects/*/*.jsonl for a `cwd` field —
+// fake one project transcript pointing at the fixture cwd, same pattern as
+// prdAdminRoutes.test.cjs / scheduler-verify-prd-path.test.cjs.
+function mkProject() {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-starve-driver-project-'));
+  const slug = `9002-starve-driver-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const projDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'projects', 'sm-starve-driver-fake-'));
+  fs.writeFileSync(path.join(projDir, 'session.jsonl'), `${JSON.stringify({ cwd })}\n`, 'utf8');
+  return { cwd, slug };
+}
+
+test('the watchdog reads idleness from lastDispatchAttemptAt, not the always-fresh poll timestamp', async () => {
+  const { cwd, slug } = mkProject();
+  await scheduler.writeQueue({
+    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
+    config: {},
+    paused: null,
+  });
+
+  const now = Date.now();
+  // The exact shape of the live incident: the poll timestamp is seconds old
+  // (the poll loop itself keeps succeeding), but nothing has actually
+  // attempted a dispatch in 40 minutes.
+  const state = {
+    ...queueStore.readMergedSync(),
+    lastRunAt: new Date(now - 5_000).toISOString(),
+    lastDispatchAttemptAt: new Date(now - 40 * 60_000).toISOString(),
+  };
+
+  const verdict = await scheduler.runQueueStarvationWatchdog(state, { now });
+  expect(verdict).not.toBeNull();
+  expect(verdict.kind).toBe('starved');
+});
+
+test('a wedged cancelToken does not block the watchdog from actually driving a tick', async () => {
+  const { cwd, slug } = mkProject();
+  await scheduler.writeQueue({
+    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
+    config: {},
+    paused: null,
+  });
+
+  // Wedge the in-process cancel token exactly the way a pause does, then
+  // clear the pause through a path that does NOT run clearPause()'s own
+  // applyPauseCleared reset (a direct state write, not the clearPause()
+  // helper) — leaving the token permanently cancelled with paused: null.
+  await scheduler.setPaused('rate_limit', null);
+  await scheduler.writeQueue({
+    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
+    config: {},
+    paused: null,
+  });
+
+  const before = queueStore.readMergedSync().lastDispatchAttemptAt;
+
+  const now = Date.now();
+  const state = {
+    ...queueStore.readMergedSync(),
+    lastRunAt: null,
+    lastDispatchAttemptAt: new Date(now - 40 * 60_000).toISOString(),
+  };
+  const verdict = await scheduler.runQueueStarvationWatchdog(state, { now });
+  expect(verdict.kind).toBe('starved');
+
+  // tickQueue() only stamps lastDispatchAttemptAt once it gets PAST the
+  // cancelToken guard — so this only advances if the watchdog actually
+  // un-wedged the token before forcing its tick.
+  const after = queueStore.readMergedSync().lastDispatchAttemptAt;
+  expect(after).not.toBe(before);
+  expect(after).not.toBeNull();
+});

package/src/main/__tests__/rateLimitPollerStreak.test.cjs

@@ -0,0 +1,79 @@
+/**
+ * rateLimitPollerStreak.test.cjs — covers the fix for the silent
+ * consecutiveFailures streak on the usage/rate-limit poller (scheduler.cjs
+ * pollLoop): the 'meter_rate_limited' branch used to never back off and
+ * never call persistSchedulerState(), letting scheduler-state.json freeze
+ * stale while the loop kept failing every POLL_INTERVAL_MS underneath it.
+ * This suite covers the two pure pieces of the fix: the shared backoff
+ * curve/cap (nextBackoffMs) and the once-per-streak WARN gate
+ * (shouldWarnFailureStreak).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/rateLimitPollerStreak.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const {
+  nextBackoffMs,
+  shouldWarnFailureStreak,
+  BACKOFF_MAX_MS,
+  FAILURE_STREAK_WARN_THRESHOLD,
+} = require('../scheduler.cjs');
+
+test('nextBackoffMs starts at 30s from a zero/falsy backoff', () => {
+  expect(nextBackoffMs(0)).toBe(30_000);
+  expect(nextBackoffMs(null)).toBe(30_000);
+});
+
+test('nextBackoffMs doubles each call', () => {
+  let ms = 0;
+  ms = nextBackoffMs(ms); // 30_000
+  ms = nextBackoffMs(ms); // 60_000
+  ms = nextBackoffMs(ms); // 120_000
+  expect(ms).toBe(120_000);
+});
+
+test('nextBackoffMs caps at BACKOFF_MAX_MS (8 minutes) and never exceeds it', () => {
+  let ms = 0;
+  for (let i = 0; i < 20; i++) ms = nextBackoffMs(ms);
+  expect(ms).toBe(BACKOFF_MAX_MS);
+  expect(BACKOFF_MAX_MS).toBe(480_000);
+  // One more doubling from an already-capped value must still be capped, not climb further.
+  expect(nextBackoffMs(ms)).toBe(BACKOFF_MAX_MS);
+});
+
+test('shouldWarnFailureStreak is false below the threshold', () => {
+  expect(shouldWarnFailureStreak(1, false)).toBe(false);
+  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD - 1, false)).toBe(false);
+});
+
+test('shouldWarnFailureStreak fires exactly once when the threshold is crossed', () => {
+  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, false)).toBe(true);
+});
+
+test('shouldWarnFailureStreak does not spam on every subsequent failure in the same streak', () => {
+  // Simulate a 57-failure streak: warn fires once, then `alreadyWarned` stays
+  // true for every remaining failure — this is the no-repeat property.
+  let warned = false;
+  let warnCount = 0;
+  for (let failures = 1; failures <= 57; failures++) {
+    if (shouldWarnFailureStreak(failures, warned)) {
+      warned = true;
+      warnCount++;
+    }
+  }
+  expect(warnCount).toBe(1);
+  expect(warned).toBe(true);
+});
+
+test('shouldWarnFailureStreak re-arms after a streak resets (alreadyWarned back to false)', () => {
+  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, false)).toBe(true);
+  // A later, independent streak crossing the threshold again must warn again.
+  expect(shouldWarnFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, false)).toBe(true);
+});
+
+test('shouldWarnFailureStreak respects a custom threshold', () => {
+  expect(shouldWarnFailureStreak(3, false, 3)).toBe(true);
+  expect(shouldWarnFailureStreak(2, false, 3)).toBe(false);
+});