claude-code-session-manager 0.85.0 → 0.87.0

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

@@ -163,6 +163,25 @@ test('appendHistory dedupes by slug+runId against what is already on disk', asyn
   expect(read.length).toBe(1);
 });
 
+test('appendHistory: a needs_review ledger line and a terminal row sharing slug+runId do NOT dedupe against each other', async () => {
+  // An entry and its resolution line (needsReviewLedger.cjs) deliberately
+  // reference the SAME runId as each other — and a slug's terminal archive
+  // row can later reuse that same runId too (same run, different `kind`).
+  // jobKey must bucket by kind or the second/third write looks like a
+  // crash-replay of the first and silently never lands.
+  const entryLine = { kind: 'needs_review_entry', slug: 'ledger-dup', runId: 'shared-run', at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize' };
+  const resolutionLine = { kind: 'needs_review_resolution', slug: 'ledger-dup', runId: 'shared-run', at: new Date(NOW).toISOString(), resolvedTo: 'completed', ladderRung: 'reverify', source: 'reverifyNeedsReview:heal', dwellMs: 1000 };
+  const terminalLine = old({ slug: 'ledger-dup', runId: 'shared-run' });
+  const r1 = await queueHistory.appendHistory([entryLine]);
+  const r2 = await queueHistory.appendHistory([resolutionLine]);
+  const r3 = await queueHistory.appendHistory([terminalLine]);
+  expect(r1.appended).toBe(1);
+  expect(r2.appended).toBe(1);
+  expect(r3.appended).toBe(1);
+  const read = await queueHistory.readHistory({ limit: 10 });
+  expect(read.filter((j) => j.slug === 'ledger-dup')).toHaveLength(3);
+});
+
 test('readHistory respects limit and returns [] when file is absent', async () => {
   const empty = await queueHistory.readHistory({ limit: 5 });
   expect(empty).toEqual([]);
@@ -220,6 +239,18 @@ test('selectHistoryJobs: default historyEntries=[] preserves old call shape', ()
   expect(merged.map((j) => j.slug)).toEqual(['01-fresh']);
 });
 
+test('selectHistoryJobs: needs_review ledger lines (kind !== "terminal") are excluded from the merged result', () => {
+  // The History view renders ScheduleJob-shaped rows (status, exitCode, ...)
+  // — a needs_review_entry/needs_review_resolution line (needsReviewLedger.cjs)
+  // has neither, and must not slip through as a statusless row in that table.
+  const { selectHistoryJobs } = require('../scheduler.cjs');
+  const terminalEntry = old({ slug: 'hist-1', runId: 'rhist1' });
+  const ledgerEntry = { kind: 'needs_review_entry', slug: 'ledger-1', runId: 'rledger1', at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize' };
+  const ledgerResolution = { kind: 'needs_review_resolution', slug: 'ledger-1', runId: 'rledger1', at: new Date(NOW).toISOString(), resolvedTo: 'completed', ladderRung: 'reverify', source: 'reverifyNeedsReview:heal', dwellMs: 500 };
+  const merged = selectHistoryJobs([], 10, [terminalEntry, ledgerEntry, ledgerResolution]);
+  expect(merged.map((j) => j.slug)).toEqual(['hist-1']);
+});
+
 // ---------- historyTerminalBySlug ----------
 //
 // Guards against scheduler.cjs's reconcile() resurrecting an already-
@@ -258,6 +289,22 @@ test('historyTerminalBySlug: cache invalidates after a new appendHistory call (m
   expect(second.has('cache-2')).toBe(true);
 });
 
+test('historyTerminalBySlug: ignores needs_review ledger lines, even a LATER one for an already-terminal slug', async () => {
+  // Chronological order matters here: the terminal row lands first, and a
+  // needs_review_entry for the SAME slug (a later re-run parking again)
+  // lands after it. Without the kind guard, last-line-wins would replace
+  // the true 'completed' record with a status-less ledger row.
+  const terminal = old({ slug: 'mixed-1', status: 'completed', runId: 'rterm' });
+  await queueHistory.appendHistory([terminal]);
+  await queueHistory.appendHistory([{
+    kind: 'needs_review_entry', slug: 'mixed-1', runId: 'rlater', cwd: null,
+    at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize',
+  }]);
+
+  const map = await queueHistory.historyTerminalBySlug();
+  expect(map.get('mixed-1')).toEqual({ status: 'completed', finishedAt: terminal.finishedAt, landedCommit: null });
+});
+
 // ---------- completedSlugsForCwd (PRD 1122) ----------
 //
 // Feeds scheduler.cjs's computeDepHistorySatisfaction: a dependsOn slug with
@@ -290,3 +337,19 @@ test('completedSlugsForCwd: returns an empty Set when the project has no history
   const slugs = await queueHistory.completedSlugsForCwd(freshCwd);
   expect(slugs.size).toBe(0);
 });
+
+test('completedSlugsForCwd: ignores needs_review ledger lines even when they are the newest line for a completed slug', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-ledger-'));
+  await queueHistory.appendHistory([
+    old({ slug: '900-base', status: 'completed', runId: 'ra', cwd: projectCwd }),
+  ]);
+  // A later needs_review park for a NEW run of the same slug must not blank
+  // out the earlier 'completed' record read by completedSlugsForCwd.
+  await queueHistory.appendHistory([{
+    kind: 'needs_review_entry', slug: '900-base', runId: 'rb', cwd: projectCwd,
+    at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize',
+  }]);
+
+  const slugs = await queueHistory.completedSlugsForCwd(projectCwd);
+  expect(slugs.has('900-base')).toBe(true);
+});

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

@@ -0,0 +1,135 @@
+/**
+ * reconcileTiming.test.cjs — proves reconcile() (src/main/scheduler.cjs)
+ * records a per-phase timing breakdown and emits exactly one warn-level
+ * `logs.writeLine` when a pass exceeds RECONCILE_SLOW_PASS_MS
+ * (src/main/lib/schedulerConfig.cjs), and stays silent on a normal-speed
+ * pass. Before this, diagnosing a slow reconcile pass (the
+ * "schedule.state timed out after 5000ms" toast) required hand-timing the
+ * filesystem scans from a throwaway script.
+ *
+ * HOME-isolated (mirrors reconcileFlatPrdSweep.test.cjs): stub HOME to a
+ * mkdtemp dir before requiring scheduler.cjs, and register the fixture
+ * project as "active" via a fake ~/.claude/projects transcript — reconcile's
+ * PRD discovery (prdLocations.cjs) only scans cwds it can find that way.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/reconcileTiming.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let scheduler;
+let queueHistory;
+let logs;
+let RECONCILE_SLOW_PASS_MS;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-timing-home-'));
+  process.env.HOME = tmpHome;
+
+  scheduler = require('../scheduler.cjs');
+  queueHistory = require('../lib/queueHistory.cjs');
+  logs = require('../logs.cjs');
+  ({ RECONCILE_SLOW_PASS_MS } = require('../lib/schedulerConfig.cjs'));
+
+  if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
+    throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
+  }
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+function registerActiveProject(cwd) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+}
+
+function makeFixtureProject(prefix) {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  registerActiveProject(cwd);
+  return cwd;
+}
+
+function writeCanonicalPrd(cwd, epicId, slug) {
+  const epicPrdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
+  fs.mkdirSync(epicPrdsDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(epicPrdsDir, `${slug}.md`),
+    `---\ntitle: Timing fixture\ncwd: ${cwd}\nestimateMinutes: 10\nsourcePromptId: ${epicId}\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\n\nSomething.\n`,
+    'utf8',
+  );
+}
+
+function warnCallsMatching(spy) {
+  return spy.mock.calls
+    .map(([payload]) => payload)
+    .filter((payload) => payload?.level === 'warn' && payload?.scope === 'scheduler' && /reconcile\(\) pass took/.test(payload?.message ?? ''));
+}
+
+test('a normal-speed reconcile() pass logs nothing', async () => {
+  const cwd = makeFixtureProject('sm-reconcile-timing-fast-proj-');
+  writeCanonicalPrd(cwd, 'epic-fast', '1600-fast');
+
+  const writeLineSpy = vi.spyOn(logs, 'writeLine');
+  const state = { jobs: [], invalidJobs: [], paused: null };
+  await scheduler.reconcile(state);
+
+  expect(warnCallsMatching(writeLineSpy)).toHaveLength(0);
+});
+
+test('a slow reconcile() pass emits exactly one warn with the per-phase breakdown', async () => {
+  const cwd = makeFixtureProject('sm-reconcile-timing-slow-proj-');
+  writeCanonicalPrd(cwd, 'epic-slow', '1601-slow');
+
+  const realHistoryTerminalBySlug = queueHistory.historyTerminalBySlug.bind(queueHistory);
+  vi.spyOn(queueHistory, 'historyTerminalBySlug').mockImplementation(async (...args) => {
+    await new Promise((resolve) => { setTimeout(resolve, RECONCILE_SLOW_PASS_MS + 200); });
+    return realHistoryTerminalBySlug(...args);
+  });
+  const writeLineSpy = vi.spyOn(logs, 'writeLine');
+
+  const state = { jobs: [], invalidJobs: [], paused: null };
+  await scheduler.reconcile(state);
+
+  const warnCalls = warnCallsMatching(writeLineSpy);
+  expect(warnCalls).toHaveLength(1);
+  const { meta } = warnCalls[0];
+  expect(meta.totalMs).toBeGreaterThan(RECONCILE_SLOW_PASS_MS);
+  expect(meta.phaseMs).toHaveProperty('flatPrdSweep');
+  expect(meta.phaseMs).toHaveProperty('prdDirResolve');
+  expect(meta.phaseMs).toHaveProperty('parseLoop');
+  expect(meta.phaseMs).toHaveProperty('historyLookup');
+  expect(meta.phaseMs).toHaveProperty('queueWrite');
+  expect(meta.phaseMs.historyLookup).toBeGreaterThanOrEqual(RECONCILE_SLOW_PASS_MS);
+  expect(typeof meta.prdFileCount).toBe('number');
+  expect(typeof meta.resolvedDirCount).toBe('number');
+  expect(meta.prdFileCount).toBeGreaterThanOrEqual(1);
+}, 15_000);
+
+test('reconcile() surfaces its own error and does not swallow it while timing', async () => {
+  vi.spyOn(queueHistory, 'partitionJobs').mockImplementation(() => {
+    throw new Error('boom: injected failure for timing-swallow test');
+  });
+
+  const cwd = makeFixtureProject('sm-reconcile-timing-throw-proj-');
+  writeCanonicalPrd(cwd, 'epic-throw', '1602-throw');
+
+  const state = { jobs: [], invalidJobs: [], paused: null };
+  await expect(scheduler.reconcile(state)).rejects.toThrow('boom: injected failure for timing-swallow test');
+});

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

@@ -6,7 +6,7 @@
  */
 'use strict';
 
-import { test, expect } from 'vitest';
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
 const fs = require('node:fs');
 const crypto = require('node:crypto');
 const {
@@ -17,6 +17,7 @@ const {
   _resetRefusedTransitionCountForTests,
 } = require('../lib/scheduleJobTransitions.cjs');
 const auditLog = require('../lib/auditLog.cjs');
+const queueHistory = require('../lib/queueHistory.cjs');
 
 function uniqueSlug(label) {
   return `test-${label}-${crypto.randomUUID().slice(0, 8)}`;
@@ -175,3 +176,102 @@ test('_resetRefusedTransitionCountForTests resets the counter', () => {
   _resetRefusedTransitionCountForTests();
   expect(getRefusedTransitionCount()).toBe(0);
 });
+
+// ---------- needs_review ledger (PRD: needs_review durability) ----------
+//
+// transitionJob is the ONE place every needs_review entry/resolution is
+// decided (this file's own header comment) — these tests exercise that
+// hook directly rather than going through scheduler.cjs's many call sites.
+// queueHistory.appendHistory is mocked so these tests never touch disk or
+// race its own fire-and-forget promise; queueHistory.test.cjs already
+// covers appendHistory's real I/O.
+
+let appendHistorySpy;
+
+beforeEach(() => {
+  appendHistorySpy = vi.spyOn(queueHistory, 'appendHistory').mockResolvedValue({ appended: 1 });
+});
+
+afterEach(() => {
+  appendHistorySpy.mockRestore();
+});
+
+test('needs_review entry: transitioning INTO needs_review appends a kind:needs_review_entry ledger line', () => {
+  const slug = uniqueSlug('nr-entry');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-abc', verifierVerdict: 'uncommitted_changes' };
+
+  transitionJob(job, 'needs_review', { reason: 'finish protocol incomplete', source: 'spawnJob:finalize' });
+
+  expect(appendHistorySpy).toHaveBeenCalledTimes(1);
+  const [lines] = appendHistorySpy.mock.calls[0];
+  expect(lines).toHaveLength(1);
+  expect(lines[0]).toMatchObject({
+    kind: 'needs_review_entry',
+    slug,
+    cwd: '/tmp/proj',
+    runId: 'run-abc',
+    reason: 'uncommitted_changes',
+    source: 'spawnJob:finalize',
+  });
+  expect(typeof lines[0].at).toBe('string');
+  // Episode bookkeeping stamped on the job so a later resolution can
+  // reference this SAME runId even if job.runId is reassigned meanwhile.
+  expect(job.needsReviewEntryRunId).toBe('run-abc');
+  expect(job.needsReviewEnteredAt).toBe(lines[0].at);
+});
+
+test('needs_review resolution: transitioning OUT of needs_review appends a paired line referencing the ENTRY runId, with dwellMs', () => {
+  const slug = uniqueSlug('nr-resolve');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-1' };
+
+  transitionJob(job, 'needs_review', { reason: 'park', source: 'spawnJob:finalize' });
+  const enteredAt = job.needsReviewEnteredAt;
+
+  // A resume-recovery re-dispatch (or any later attempt) mints a FRESH runId
+  // before this episode resolves — the resolution must still reference the
+  // ENTRY's runId, not whatever the job carries now.
+  job.runId = 'run-2';
+  transitionJob(job, 'completed', { reason: 'boot reverify: stale needs_review healed', source: 'reverifyNeedsReview:heal' });
+
+  expect(appendHistorySpy).toHaveBeenCalledTimes(2);
+  const [resolutionLines] = appendHistorySpy.mock.calls[1];
+  expect(resolutionLines).toHaveLength(1);
+  const resolution = resolutionLines[0];
+  expect(resolution.kind).toBe('needs_review_resolution');
+  expect(resolution.runId).toBe('run-1'); // the ENTRY's runId
+  expect(resolution.resolvedTo).toBe('completed');
+  expect(resolution.ladderRung).toBe('reverify');
+  expect(typeof resolution.dwellMs).toBe('number');
+  expect(resolution.dwellMs).toBeGreaterThanOrEqual(0);
+  expect(Date.parse(enteredAt) + resolution.dwellMs).toBe(Date.parse(resolution.at));
+
+  // Episode bookkeeping cleared once resolved.
+  expect(job.needsReviewEntryRunId).toBeUndefined();
+  expect(job.needsReviewEnteredAt).toBeUndefined();
+});
+
+test('a slug that parks twice produces two independent entry/resolution pairs, not one merged episode', () => {
+  const { reduceNeedsReviewLedger } = require('../lib/needsReviewLedger.cjs');
+  const slug = uniqueSlug('nr-twice');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-A' };
+
+  transitionJob(job, 'needs_review', { reason: 'park 1', source: 'spawnJob:finalize' });
+  transitionJob(job, 'pending', { reason: 'manual reset', source: 'ipc:schedule:reset-job' });
+  transitionJob(job, 'running', { reason: 'redispatched', source: 'spawnJob:dispatch' });
+  job.runId = 'run-B';
+  transitionJob(job, 'needs_review', { reason: 'park 2', source: 'spawnJob:finalize' });
+  transitionJob(job, 'completed', { reason: 'healed', source: 'reverifyNeedsReview:heal' });
+
+  const ledgerLines = appendHistorySpy.mock.calls.map((call) => call[0][0]);
+  const entries = ledgerLines.filter((l) => l.kind === 'needs_review_entry');
+  const resolutions = ledgerLines.filter((l) => l.kind === 'needs_review_resolution');
+  expect(entries).toHaveLength(2);
+  expect(resolutions).toHaveLength(2);
+  expect(entries.map((l) => l.runId).sort()).toEqual(['run-A', 'run-B']);
+  expect(resolutions.map((l) => l.runId).sort()).toEqual(['run-A', 'run-B']);
+
+  const rollup = reduceNeedsReviewLedger(ledgerLines);
+  expect(rollup.unresolvedCount).toBe(0);
+  expect(rollup.byLadderRung['manual-reset']).toBe(1);
+  expect(rollup.byLadderRung['reverify']).toBe(1);
+});

package/src/main/__tests__/scheduler-boot-orphans.test.cjs

@@ -2,7 +2,7 @@
  * scheduler-boot-orphans.test.cjs — boot-time reconciliation of 'running' jobs
  * left behind by an app crash/restart (PRD 686: consolidated in from the
  * external watchdog's reconcileQueueOffline(), which is now deleted from
- * scripts/lib/watchdogHelpers.cjs).
+ * src/main/lib/watchdogHelpers.cjs).
  *
  * Covers the two behaviors most likely to drift in the move:
  *   - a still-alive orphaned pid must be DEFERRED, never classified from its
@@ -101,7 +101,7 @@ test('feedbackSweepDue gates on the tick interval, not every tick', () => {
 });
 
 test('scheduler.cjs reuses watchdogHelpers.sweep verbatim (no forked copy)', () => {
-  const { sweep } = require('../../../scripts/lib/watchdogHelpers.cjs');
+  const { sweep } = require('../lib/watchdogHelpers.cjs');
   assert.equal(sweepFeedback, sweep, 'scheduler.cjs must import the same sweep function, not reimplement it');
 });
 

package/src/main/__tests__/scheduler-broadcast-reconcile.test.cjs

@@ -0,0 +1,121 @@
+/**
+ * scheduler-broadcast-reconcile.test.cjs — broadcast() used to do its own bare
+ * `readQueue() -> reconcile(state) -> writeQueue(state)` BEFORE ever touching
+ * the broadcastCoalescer, so a burst of N broadcast() calls inside one
+ * BROADCAST_COALESCE_MS window cost N full reconcile passes + N queue writes
+ * to produce ONE coalesced payload — and did so outside mutate()'s lock, so a
+ * concurrent mutation's update could be lost. The fix moves the
+ * reconcile+write pair inside the coalescer's `getPayload`, run through
+ * `mutate()`, so N broadcast() calls in one window cost exactly one reconcile
+ * and one write.
+ *
+ * `reconcile` is a bare local call inside getPayload's mutate() callback, so
+ * — matching this file's existing testable-seam convention (module.exports.
+ * stashList / evaluateSharedTreeGuard / committedInWindow) — it is invoked as
+ * `module.exports.reconcile(state)` specifically so tests can spy on it here.
+ * `queueStore.readMerged`/`writeSplit` are genuine cross-module property
+ * calls already, so they're spied on directly with no source change needed.
+ *
+ * HOME-isolated (mirrors reconcileFlatPrdSweep.test.cjs): stub HOME to a
+ * mkdtemp dir before requiring scheduler.cjs so `ensureDirs()` (called by the
+ * real `writeQueue()` wrapper before the now-mocked `queueStore.writeSplit`)
+ * never touches the real machine.
+ *
+ * Run: timeout 60 npx vitest run src/main/__tests__/scheduler-broadcast-reconcile.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeAll, afterAll, beforeEach, afterEach, vi } 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;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-broadcast-reconcile-home-'));
+  process.env.HOME = tmpHome;
+
+  scheduler = require('../scheduler.cjs');
+  queueStore = require('../lib/queueStore.cjs');
+
+  if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
+    throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
+  }
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+function freshState() {
+  return { config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
+}
+
+function fakeWindow() {
+  return {
+    isDestroyed: () => false,
+    webContents: { isDestroyed: () => false, isCrashed: () => false, send: vi.fn() },
+  };
+}
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  scheduler.attachWindow(null);
+});
+
+test('10 broadcast() calls inside one coalesce window trigger exactly one reconcile and one queue write', async () => {
+  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
+  const writeSpy = vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
+  const reconcileSpy = vi.spyOn(scheduler, 'reconcile').mockResolvedValue(undefined);
+
+  for (let i = 0; i < 10; i += 1) scheduler.broadcast();
+
+  // BROADCAST_COALESCE_MS is 200ms; give the trailing-edge timer room to fire.
+  await wait(400);
+
+  expect(reconcileSpy).toHaveBeenCalledTimes(1);
+  expect(writeSpy).toHaveBeenCalledTimes(1);
+});
+
+test('a window-less (flush) broadcast() still reconciles, even with no window attached', async () => {
+  scheduler.attachWindow(null);
+  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
+  const writeSpy = vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
+  const reconcileSpy = vi.spyOn(scheduler, 'reconcile').mockResolvedValue(undefined);
+
+  await scheduler.broadcast({ flush: true });
+
+  expect(reconcileSpy).toHaveBeenCalledTimes(1);
+  expect(writeSpy).toHaveBeenCalledTimes(1);
+});
+
+test('a reconcile() that throws does not wedge the coalescer — the next broadcast() still sends', async () => {
+  const win = fakeWindow();
+  scheduler.attachWindow(win);
+  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
+  vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
+  const reconcileSpy = vi.spyOn(scheduler, 'reconcile')
+    .mockRejectedValueOnce(new Error('boom'))
+    .mockResolvedValue(undefined);
+
+  scheduler.broadcast();
+  await wait(400);
+  expect(win.webContents.send).not.toHaveBeenCalled();
+
+  scheduler.broadcast();
+  await wait(400);
+
+  expect(reconcileSpy).toHaveBeenCalledTimes(2);
+  expect(win.webContents.send).toHaveBeenCalledTimes(1);
+  expect(win.webContents.send).toHaveBeenCalledWith('schedule:state', expect.any(Object));
+});

package/src/main/__tests__/scheduler-cross-project-batch.test.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+// Ported from the retired top-level test-root directory (a node:test suite,
+// never runnable by this repo's vitest-only setup — see CLAUDE.md's Commands
+// section). Pins the two basic cross-project pickNextBatch contracts that
+// were asserted there but not literally exercised elsewhere: N independent
+// projects each with a single pending job all fire together when the global
+// slot pool is generous, and a global cap BELOW the total pending count
+// across projects admits exactly that many, not more.
+//
+// Run: timeout 120 npx vitest run src/main/__tests__/scheduler-cross-project-batch.test.cjs
+
+const assert = require('node:assert/strict');
+const { pickNextBatch } = require('../lib/schedulerBatch.cjs');
+
+function job(slug, status, cwd, parallelGroup) {
+  return { slug, status, cwd, parallelGroup, dependsOn: [] };
+}
+
+test('3 independent projects, 1 pending each, generous cap (6) → all 3 fire', () => {
+  const jobs = [
+    job('a-job', 'pending', '/a', 5),
+    job('b-job', 'pending', '/b', 5),
+    job('c-job', 'pending', '/c', 5),
+  ];
+  const { batch, reason } = pickNextBatch(jobs, new Set(), 6);
+  assert.equal(batch.length, 3);
+  assert.equal(reason, null);
+  const slugs = new Set(batch.map((j) => j.slug));
+  assert.ok(slugs.has('a-job'));
+  assert.ok(slugs.has('b-job'));
+  assert.ok(slugs.has('c-job'));
+});
+
+test('3 independent projects, 1 pending each, cap 2 (below total pending) → exactly 2 fire', () => {
+  const jobs = [
+    job('a-job', 'pending', '/a', 5),
+    job('b-job', 'pending', '/b', 5),
+    job('c-job', 'pending', '/c', 5),
+  ];
+  const { batch } = pickNextBatch(jobs, new Set(), 2);
+  assert.equal(batch.length, 2);
+});

package/src/main/__tests__/scheduler-failed-autoreset.test.cjs

@@ -0,0 +1,121 @@
+/**
+ * scheduler-failed-autoreset.test.cjs
+ *
+ * Covers selectFailedAutoResetTargets (the bounded failed -> pending
+ * auto-reset selector, PRD 1151) and failedAutoResetDisabled (its kill
+ * switch) in isolation. selectFailedAutoResetTargets is pure — no IO, no
+ * `require` inside the function — so unlike findStuckFailedJobs' own test
+ * file, there is no run-log fixture to set up here.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — see
+ * scheduler-reap-dead-running-jobs.test.cjs's comment for why.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-failed-autoreset.test.cjs
+ */
+
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'failed-autoreset-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  selectFailedAutoResetTargets,
+  FAILED_AUTORESET_CAP,
+  failedAutoResetDisabled,
+} = require('../scheduler.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 10 * MIN_MS;
+
+test('a fresh failed row (under threshold) is not selected', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'fresh-failure',
+    status: 'failed',
+    statusHistory: [{ to: 'failed', at: new Date(now - 2 * MIN_MS).toISOString() }],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('a row past threshold is selected, with its current attempt count', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'ripe-for-reset',
+    cwd: '/home/user/project',
+    status: 'failed',
+    failedAutoResetAttempts: 1,
+    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
+  };
+  const found = selectFailedAutoResetTargets([job], now, THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, 'ripe-for-reset');
+  assert.equal(found[0].cwd, '/home/user/project');
+  assert.equal(found[0].attempts, 1);
+  assert.ok(found[0].ageMs >= 15 * MIN_MS - 1000);
+});
+
+test('a row at the cap (failedAutoResetAttempts: 3) is not selected', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'cap-exhausted',
+    status: 'failed',
+    failedAutoResetAttempts: FAILED_AUTORESET_CAP,
+    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('a non-failed status is never selected', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'needs-review-row',
+    status: 'needs_review',
+    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('the newest failed entry gates the threshold, not the first one', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'refailed-recently',
+    status: 'failed',
+    failedAutoResetAttempts: 1,
+    statusHistory: [
+      { to: 'failed', at: new Date(now - 2 * 24 * 60 * MIN_MS).toISOString() },
+      { to: 'pending', at: new Date(now - 23 * 60 * MIN_MS).toISOString() },
+      { to: 'failed', at: new Date(now - 2 * MIN_MS).toISOString() },
+    ],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0, 'the old failed entry must not be used to gate this row');
+});
+
+test('a row whose newest failed entry came from spawnJob:fail-dirty is never selected — that source is a deliberate do-not-auto-requeue decision', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'dirty-worktree',
+    status: 'failed',
+    statusHistory: [
+      { to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString(), source: 'spawnJob:fail-dirty' },
+    ],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('failedAutoResetDisabled reflects SM_FAILED_AUTORESET_DISABLE', () => {
+  const saved = process.env.SM_FAILED_AUTORESET_DISABLE;
+  try {
+    delete process.env.SM_FAILED_AUTORESET_DISABLE;
+    assert.equal(failedAutoResetDisabled(), false);
+    process.env.SM_FAILED_AUTORESET_DISABLE = '1';
+    assert.equal(failedAutoResetDisabled(), true);
+  } finally {
+    if (saved === undefined) delete process.env.SM_FAILED_AUTORESET_DISABLE;
+    else process.env.SM_FAILED_AUTORESET_DISABLE = saved;
+  }
+});