claude-code-session-manager 0.86.0 → 0.87.0

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

@@ -0,0 +1,222 @@
+/**
+ * prdSetDisposition.test.cjs — scheduler wave-disposition PRD:
+ * scheduler.remote.setPrdDisposition (backing the renderer's
+ * `schedule:set-prd-disposition` IPC action) is how a human changes an
+ * already-written PRD's disposition from the Scheduler UI — promoting an
+ * appended wave to its own head, or re-attaching a head behind another
+ * chain. Validates via prdDisposition.cjs's computeDispositionRewrite
+ * (cycle-safety, running/completed rows untouched) before delegating the
+ * actual write to the SAME remote.updatePrd every other PRD edit path uses.
+ *
+ * Mirrors prdUpdateDependsOn.test.cjs's HOME-isolation fixture.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdSetDisposition.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 scheduler;
+let queueStore;
+let config;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-set-disposition-home-'));
+  process.env.HOME = tmpHome;
+
+  scheduler = require('../scheduler.cjs');
+  queueStore = require('../lib/queueStore.cjs');
+  config = require('../config.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 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);
+  config.addAllowedRoot(cwd);
+  const opsRoot = path.join(cwd, 'session-manager-operations');
+  const prdsDir = path.join(opsRoot, 'scheduler', 'epics', 'test-epic-1', 'prds');
+  const stateDir = path.join(opsRoot, 'scheduler', 'state');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
+  queueStore.bustCwdCache();
+  return { cwd, prdsDir, stateDir };
+}
+
+function writePrd(prdsDir, filename, cwd, extraFrontmatter = '') {
+  fs.writeFileSync(
+    path.join(prdsDir, filename),
+    `---\ntitle: ${filename}\ncwd: ${cwd}\nestimateMinutes: 10\ncreatedVia: scheduler-api\n${extraFrontmatter}---\n\n# Goal\nDo the thing.\n`,
+    'utf8',
+  );
+}
+
+/** Seeds a queue.json row for `slug` with the given status — setPrdDisposition
+ *  (like updatePrd) reads job status off the live queue, not the PRD file. */
+function seedQueueJob(stateDir, slug, status) {
+  fs.writeFileSync(
+    path.join(stateDir, 'queue.json'),
+    JSON.stringify({ jobs: [{ slug, status, title: slug, cwd: '' }] }, null, 2),
+    'utf8',
+  );
+  queueStore.bustCwdCache();
+}
+
+test('append sets the expected edges', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-set-disposition-append-');
+  try {
+    writePrd(prdsDir, '3-wave1-tail.md', cwd);
+    writePrd(prdsDir, '4-wave2-root.md', cwd);
+
+    const result = await scheduler.remote.setPrdDisposition({
+      slug: '4-wave2-root',
+      cwd,
+      disposition: 'append',
+      dependsOn: ['3-wave1-tail'],
+    });
+
+    expect(result.ok).toBe(true);
+    const written = fs.readFileSync(path.join(prdsDir, '4-wave2-root.md'), 'utf8');
+    expect(written).toMatch(/^dependsOn: \[3-wave1-tail\]$/m);
+    expect(written).toMatch(/^disposition: append$/m);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('new-head sets none', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-set-disposition-new-head-');
+  try {
+    writePrd(prdsDir, '3-wave1-tail.md', cwd);
+    writePrd(prdsDir, '4-wave2-root.md', cwd, 'dependsOn: [wave1-tail]\ndisposition: append\n');
+
+    const result = await scheduler.remote.setPrdDisposition({
+      slug: '4-wave2-root',
+      cwd,
+      disposition: 'new-head',
+    });
+
+    expect(result.ok).toBe(true);
+    const written = fs.readFileSync(path.join(prdsDir, '4-wave2-root.md'), 'utf8');
+    expect(written).not.toContain('dependsOn');
+    expect(written).toMatch(/^disposition: new-head$/m);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('promoting a wave to a head removes exactly its root edges', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-set-disposition-promote-');
+  try {
+    writePrd(prdsDir, '3-wave1-tail.md', cwd);
+    writePrd(prdsDir, '5-other-head.md', cwd);
+    writePrd(prdsDir, '4-wave2-root.md', cwd, 'dependsOn: [wave1-tail]\ndisposition: append\n');
+
+    const result = await scheduler.remote.setPrdDisposition({
+      slug: '4-wave2-root',
+      cwd,
+      disposition: 'new-head',
+    });
+
+    expect(result.ok).toBe(true);
+    const promoted = fs.readFileSync(path.join(prdsDir, '4-wave2-root.md'), 'utf8');
+    expect(promoted).not.toContain('dependsOn');
+    // The unrelated sibling head is untouched by this call.
+    const other = fs.readFileSync(path.join(prdsDir, '5-other-head.md'), 'utf8');
+    expect(other).not.toContain('dependsOn');
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('a change that would create a cycle is rejected, and nothing is written', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-set-disposition-cycle-');
+  try {
+    writePrd(prdsDir, '3-a.md', cwd, 'dependsOn: [b]\n');
+    writePrd(prdsDir, '4-b.md', cwd);
+    const before = fs.readFileSync(path.join(prdsDir, '4-b.md'), 'utf8');
+
+    const result = await scheduler.remote.setPrdDisposition({
+      slug: '4-b',
+      cwd,
+      disposition: 'append',
+      dependsOn: ['3-a'],
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/cycle/i);
+    const after = fs.readFileSync(path.join(prdsDir, '4-b.md'), 'utf8');
+    expect(after).toBe(before);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('running rows are untouched', async () => {
+  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-set-disposition-running-');
+  try {
+    writePrd(prdsDir, '3-wave1-tail.md', cwd);
+    writePrd(prdsDir, '4-wave2-root.md', cwd, 'dependsOn: [wave1-tail]\ndisposition: append\n');
+    seedQueueJob(stateDir, '4-wave2-root', 'running');
+    const before = fs.readFileSync(path.join(prdsDir, '4-wave2-root.md'), 'utf8');
+
+    const result = await scheduler.remote.setPrdDisposition({
+      slug: '4-wave2-root',
+      cwd,
+      disposition: 'new-head',
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/running/i);
+    const after = fs.readFileSync(path.join(prdsDir, '4-wave2-root.md'), 'utf8');
+    expect(after).toBe(before);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('completed rows are untouched', async () => {
+  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-set-disposition-completed-');
+  try {
+    writePrd(prdsDir, '3-wave1-tail.md', cwd);
+    writePrd(prdsDir, '4-wave2-root.md', cwd, 'dependsOn: [wave1-tail]\ndisposition: append\n');
+    seedQueueJob(stateDir, '4-wave2-root', 'completed');
+    const before = fs.readFileSync(path.join(prdsDir, '4-wave2-root.md'), 'utf8');
+
+    const result = await scheduler.remote.setPrdDisposition({
+      slug: '4-wave2-root',
+      cwd,
+      disposition: 'new-head',
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/completed/i);
+    const after = fs.readFileSync(path.join(prdsDir, '4-wave2-root.md'), 'utf8');
+    expect(after).toBe(before);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/queue-health-verdict.test.cjs

@@ -0,0 +1,170 @@
+/**
+ * queue-health-verdict.test.cjs — classifyQueueHealth is the Scheduler
+ * page's queue-health header: the single honest read of WHY a queue looks
+ * stale (saturated slots / blocked dependencies / genuinely idle / the
+ * dispatch driver itself stalled / a decision to pause / an open launch
+ * circuit breaker), reusing classifyQueueStarvation so the header can never
+ * disagree with the starvation watchdog's own read of the same state.
+ *
+ * Run: timeout 180 npx vitest run src/main/__tests__/queue-health-verdict.test.cjs
+ */
+
+'use strict';
+
+import { test, afterAll } from 'vitest';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+// HOME before require: every state path is baked from os.homedir() at load.
+const originalHome = process.env.HOME;
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'queue-health-test-'));
+process.env.HOME = tmpHome;
+fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
+fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
+
+const { classifyQueueHealth, QUEUE_STARVATION_MS } = require('../scheduler.cjs');
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+const CWD = '/home/bilko/Projects/starry-night-ships';
+const NOW = Date.parse('2026-09-13T20:00:00.000Z');
+const LONG = QUEUE_STARVATION_MS + 60_000;
+
+test('saturated: jobs running, zero free slots', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'running', startedAt: new Date(NOW - LONG).toISOString(), dependsOn: [] },
+    { slug: '2-b', cwd: CWD, status: 'pending', dependsOn: [] },
+  ];
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks: {}, runningSet: new Set(['1-a']),
+    freeSlots: 0, totalSlots: 4, lastDispatchAttemptAtMs: NOW, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.kind, 'saturated');
+  assert.equal(v.runningCount, 1);
+  assert.equal(v.totalSlots, 4);
+  // Dispatchable/blocked counts stay real numbers even in a kind whose
+  // headline cause is slot saturation, not dependency shape — the header
+  // must still be able to show them alongside the verdict.
+  assert.equal(v.pending, 1);
+  assert.equal(v.dispatchable, 1);
+  assert.deepEqual(v.blockedChains, []);
+});
+
+test('blocked: every pending row terminates in a failed dependency', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'failed', dependsOn: [] },
+    { slug: '2-b', cwd: CWD, status: 'pending', dependsOn: ['1-a'] },
+  ];
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
+    freeSlots: 4, totalSlots: 4, lastDispatchAttemptAtMs: NOW - 5_000, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.kind, 'blocked');
+  assert.equal(v.pending, 1);
+  assert.equal(v.dispatchable, 0);
+  assert.equal(v.blockedChains.length, 1);
+  assert.deepEqual(v.blockedChains[0].blockedBy, ['1-a']);
+});
+
+test('idle: nothing pending', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'completed', dependsOn: [] },
+  ];
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
+    freeSlots: 4, totalSlots: 4, lastDispatchAttemptAtMs: NOW, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.kind, 'idle');
+  assert.equal(v.pending, 0);
+  assert.equal(v.dispatchable, 0);
+});
+
+test('stalled: dispatchable work, nothing running, driver idle past threshold', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [] },
+  ];
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
+    freeSlots: 4, totalSlots: 4, lastDispatchAttemptAtMs: NOW - LONG, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.kind, 'stalled');
+  assert.equal(v.dispatchable, 1);
+  assert.ok(v.idleMs >= QUEUE_STARVATION_MS);
+});
+
+test('running: dispatchable work, nothing running yet, but driver has not been idle long enough to call it a stall', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [] },
+  ];
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
+    freeSlots: 4, totalSlots: 4, lastDispatchAttemptAtMs: NOW - 5_000, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.kind, 'running');
+});
+
+test('paused: a decision, not a stall — takes priority over everything else', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [] },
+  ];
+  const v = classifyQueueHealth({
+    jobs, paused: { reason: 'manual', since: NOW }, launchBlocks: {}, runningSet: new Set(),
+    freeSlots: 0, totalSlots: 4, lastDispatchAttemptAtMs: NOW - LONG, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.kind, 'paused');
+  assert.equal(v.reason, 'manual');
+  assert.equal(v.pending, 1);
+  assert.equal(v.dispatchable, 1);
+});
+
+test('launch-blocked: an open circuit breaker for a persona a pending row actually uses', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [], agentType: 'dev-lead' },
+  ];
+  const launchBlocks = {
+    'dev-lead': { kind: 'model_config_rejected', attempts: 3, hint: 'update the CLI', until: null },
+  };
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks, runningSet: new Set(),
+    freeSlots: 4, totalSlots: 4, lastDispatchAttemptAtMs: NOW - LONG, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.kind, 'launch-blocked');
+  assert.equal(v.agentType, 'dev-lead');
+  assert.equal(v.pending, 1);
+  assert.equal(v.dispatchable, 1);
+});
+
+test('launch-blocked is scoped: a breaker for a persona nothing pending here uses does not fire', () => {
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'pending', dependsOn: [], agentType: 'dev-lead' },
+  ];
+  const launchBlocks = {
+    'architect': { kind: 'model_config_rejected', attempts: 3, hint: 'update the CLI', until: null },
+  };
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks, runningSet: new Set(),
+    freeSlots: 4, totalSlots: 4, lastDispatchAttemptAtMs: NOW - 5_000, now: NOW, cwd: CWD,
+  });
+  assert.notEqual(v.kind, 'launch-blocked');
+});
+
+test('needsReviewCount and cwd scoping: another project\'s rows never leak into this scope\'s counts', () => {
+  const other = '/home/bilko/Projects/session-manager';
+  const jobs = [
+    { slug: '1-a', cwd: CWD, status: 'needs_review', dependsOn: [] },
+    { slug: '2-b', cwd: CWD, status: 'pending', dependsOn: [] },
+    { slug: '3-c', cwd: other, status: 'pending', dependsOn: [] },
+    { slug: '4-d', cwd: other, status: 'needs_review', dependsOn: [] },
+  ];
+  const v = classifyQueueHealth({
+    jobs, paused: null, launchBlocks: {}, runningSet: new Set(),
+    freeSlots: 4, totalSlots: 4, lastDispatchAttemptAtMs: NOW - 5_000, now: NOW, cwd: CWD,
+  });
+  assert.equal(v.pending, 1);
+  assert.equal(v.needsReviewCount, 1);
+});

package/src/main/__tests__/queue-starvation-per-project.test.cjs

@@ -16,14 +16,21 @@
 
 'use strict';
 
-import { test } from 'vitest';
+import { test, afterAll } from 'vitest';
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
 // HOME before require: every state path is baked from os.homedir() at load.
-process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-per-project-test-'));
+// beforeAll runs AFTER module evaluation, so this assignment must stay at
+// top level — see pollLoop-dispatch-on-failure.test.cjs:40-56 for the
+// beforeAll/afterAll pattern this restore mirrors.
+const originalHome = process.env.HOME;
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-per-project-test-'));
+process.env.HOME = tmpHome;
+fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
+fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
 
 const {
   classifyQueueStarvation,
@@ -31,6 +38,11 @@ const {
   QUEUE_STARVATION_MS,
 } = require('../scheduler.cjs');
 
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
 const PROJECT_A = '/home/bilko/Projects/starry-night-ships';
 const PROJECT_B = '/home/bilko/Projects/session-manager';
 const NOW = Date.parse('2026-09-12T20:00:00.000Z');

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');
+});