claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,128 +0,0 @@
-/**
- * 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 pure pieces of the fix: the shared backoff
- * curve/cap (nextBackoffMs), the once-per-streak WARN gate
- * (shouldWarnFailureStreak), and the periodic escalation ladder that fires
- * every FAILURE_STREAK_ESCALATION_MS while a streak PERSISTS past the
- * initial WARN, re-arming once the streak clears (shouldEscalateFailureStreak).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/rateLimitPollerStreak.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  nextBackoffMs,
-  shouldWarnFailureStreak,
-  shouldEscalateFailureStreak,
-  restoreFailureStreakWarnedAt,
-  persistedStreakMinutes,
-  BACKOFF_MAX_MS,
-  FAILURE_STREAK_WARN_THRESHOLD,
-  FAILURE_STREAK_ESCALATION_MS,
-} = 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);
-});
-
-test('shouldEscalateFailureStreak: false below the WARN threshold, regardless of elapsed time', () => {
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD - 1, null, Date.now())).toBe(false);
-});
-
-test('shouldEscalateFailureStreak: fires immediately the first time (lastEscalatedAtMs null) once past the WARN threshold', () => {
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, Date.now())).toBe(true);
-});
-
-test('shouldEscalateFailureStreak: does not re-fire before FAILURE_STREAK_ESCALATION_MS has elapsed since the last one', () => {
-  const lastEscalatedAtMs = 1_000_000;
-  const tooSoon = lastEscalatedAtMs + FAILURE_STREAK_ESCALATION_MS - 1;
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, lastEscalatedAtMs, tooSoon)).toBe(false);
-});
-
-test('shouldEscalateFailureStreak: fires again once FAILURE_STREAK_ESCALATION_MS has elapsed — the persisting-streak ladder', () => {
-  const lastEscalatedAtMs = 1_000_000;
-  const dueNow = lastEscalatedAtMs + FAILURE_STREAK_ESCALATION_MS;
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, lastEscalatedAtMs, dueNow)).toBe(true);
-});
-
-test('shouldEscalateFailureStreak: re-arms after a streak clears (lastEscalatedAtMs reset to null) — a later independent streak escalates again', () => {
-  const firstStreakNow = 1_000_000;
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, firstStreakNow)).toBe(true);
-  // Streak clears (a success resets both failureStreakWarned and the
-  // escalation timestamp) — a LATER, independent streak crossing the WARN
-  // threshold again must escalate again immediately, not wait out a stale
-  // 30-minute window from the previous incident.
-  const laterStreakNow = firstStreakNow + 5 * 60_000; // well under 30 min later
-  expect(shouldEscalateFailureStreak(FAILURE_STREAK_WARN_THRESHOLD, null, laterStreakNow)).toBe(true);
-});
-
-test('restoreFailureStreakWarnedAt backfills now when warned=true has no numeric timestamp', () => {
-  expect(restoreFailureStreakWarnedAt(true, null, 5000)).toBe(5000);
-  expect(restoreFailureStreakWarnedAt(true, 1000, 5000)).toBe(1000);
-  expect(restoreFailureStreakWarnedAt(false, null, 5000)).toBeNull();
-});
-
-test('persistedStreakMinutes is always a number, never null', () => {
-  expect(persistedStreakMinutes(null, 5000)).toBe(0);
-  expect(persistedStreakMinutes(0, 120_000)).toBe(2);
-  expect(persistedStreakMinutes(restoreFailureStreakWarnedAt(true, undefined, 5000), 5000)).toBe(0);
-});

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

@@ -1,266 +0,0 @@
-/**
- * rcaReport.test.cjs — unit tests for src/main/lib/rcaReport.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/rcaReport.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let realHome;
-let rcaReport;
-
-// config.cjs bakes os.homedir() into top-level consts at first require
-// (allowedRoots/WRITE_PREFIXES). Node's require cache must be purged per test
-// so each test's tmpHome takes effect — vi.resetModules() only resets vitest's
-// ESM graph, not require().
-const MODULES_TO_RELOAD = ['../lib/rcaReport.cjs', '../config.cjs'];
-
-function purgeRequireCache() {
-  for (const m of MODULES_TO_RELOAD) {
-    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
-  }
-}
-
-beforeEach(() => {
-  realHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'rca-report-test-'));
-  process.env.HOME = tmpHome;
-  delete process.env.SM_RCA_DISABLE;
-  purgeRequireCache();
-  rcaReport = require('../lib/rcaReport.cjs');
-});
-
-afterEach(() => {
-  process.env.HOME = realHome;
-  delete process.env.SM_RCA_DISABLE;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-  purgeRequireCache();
-});
-
-// ─── helpers ──────────────────────────────────────────────────────────────────
-
-function makeProject(name = 'proj') {
-  const cwd = path.join(tmpHome, name);
-  fs.mkdirSync(cwd, { recursive: true });
-  return cwd;
-}
-
-function writeRun(runDir, slug, { logLines = ['line1', 'line2'], exitCode = 1, durationMs = 1234 } = {}) {
-  fs.mkdirSync(runDir, { recursive: true });
-  fs.writeFileSync(path.join(runDir, `${slug}.log`), logLines.join('\n') + '\n');
-  fs.writeFileSync(path.join(runDir, `${slug}.meta.json`), JSON.stringify({ exitCode, durationMs }));
-}
-
-function writePrd(cwd, slug, { acBody = '- [ ] `timeout 10 echo ok` passes.' } = {}) {
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  const body = ['---', `title: ${slug}`, '---', '', '# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', acBody, '', '# Out of scope', '', '- N/A'].join('\n');
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
-}
-
-function baseJob(overrides = {}) {
-  return { slug: 'testslug', runId: '2026-07-24T00-00-00-000Z', exitCode: 1, error: 'something broke', ...overrides };
-}
-
-function readSessions(cwd) {
-  const p = path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
-  if (!fs.existsSync(p)) return {};
-  return JSON.parse(fs.readFileSync(p, 'utf8')).sessions ?? {};
-}
-
-// ─── report writing ──────────────────────────────────────────────────────────
-
-test('writeRcaReport: writes root-cause-<slug>.md into the run directory', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(true);
-  expect(res.path).toBe(path.join(runDir, 'root-cause-testslug.md'));
-  const body = fs.readFileSync(res.path, 'utf8');
-  expect(body).toContain('prdSlug: testslug');
-  expect(body).toContain('# What happened');
-  expect(body).toContain('# The PRD\'s acceptance criteria');
-  expect(body).toContain('timeout 10 echo ok');
-  expect(res.summary).toContain('testslug');
-  expect(res.summary.split('\n')).toHaveLength(1);
-});
-
-test('writeRcaReport: creates no Epic — a parked job never opens work on its own', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(readSessions(cwd)).toEqual({});
-});
-
-test('writeRcaReport: a second call for the same run overwrites in place, never duplicates', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-  const job = baseJob({ cwd });
-
-  const first = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
-  const second = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
-
-  expect(second.path).toBe(first.path);
-  expect(fs.readdirSync(runDir).filter((f) => f.startsWith('root-cause-'))).toHaveLength(1);
-});
-
-test('writeRcaReport: investigationText enriches the report in place', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-  const job = baseJob({ cwd });
-
-  const first = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
-  expect(fs.readFileSync(first.path, 'utf8')).not.toContain('## Investigation analysis');
-
-  const second = await rcaReport.writeRcaReport({
-    job, runDir, verdict: 'transcript_errors', investigationText: 'Root cause: forgot to bound the poll loop.',
-  });
-
-  expect(second.path).toBe(first.path);
-  const enriched = fs.readFileSync(second.path, 'utf8');
-  expect(enriched).toContain('## Investigation analysis');
-  expect(enriched).toContain('forgot to bound the poll loop');
-});
-
-test('writeRcaReport: works for a job whose PRD cannot be read (no acceptance criteria on record)', async () => {
-  const cwd = makeProject('bare-proj');
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(true);
-  expect(fs.readFileSync(res.path, 'utf8')).toContain('acceptance criteria not found');
-});
-
-// ─── skip paths ──────────────────────────────────────────────────────────────
-
-test('writeRcaReport: rejects a slug containing path-traversal segments', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  fs.mkdirSync(runDir, { recursive: true });
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd, slug: '../../etc/passwd' }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(false);
-  expect(res.reason).toBe('unsafe-slug');
-});
-
-test('writeRcaReport: skips when there is no run directory to write into', async () => {
-  const cwd = makeProject();
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(false);
-  expect(res.reason).toBe('no-run-dir');
-});
-
-// ─── recovery actions ────────────────────────────────────────────────────────
-
-test('RECOVERY_ACTIONS: every FAILURE_CLASSES member has an entry from the closed set', () => {
-  const CLOSED_SET = new Set(['archive', 'resume-and-commit', 'verify-and-close', 'investigate']);
-  for (const failureClass of Object.values(rcaReport.FAILURE_CLASSES)) {
-    expect(rcaReport.RECOVERY_ACTIONS).toHaveProperty(failureClass);
-    expect(CLOSED_SET.has(rcaReport.RECOVERY_ACTIONS[failureClass])).toBe(true);
-  }
-});
-
-test('recoveryActionFor: maps each known failure class to its expected action', () => {
-  const { FAILURE_CLASSES, recoveryActionFor } = rcaReport;
-  expect(recoveryActionFor(FAILURE_CLASSES.ALREADY_SHIPPED)).toBe('archive');
-  expect(recoveryActionFor(FAILURE_CLASSES.UNCOMMITTED)).toBe('resume-and-commit');
-  expect(recoveryActionFor(FAILURE_CLASSES.NO_SENTINEL)).toBe('verify-and-close');
-  expect(recoveryActionFor(FAILURE_CLASSES.SELF_QUEUE)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.STUCK_LOOP)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.POST_AC_OVERRUN)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.TRANSCRIPT_ERRORS)).toBe('investigate');
-  expect(recoveryActionFor(FAILURE_CLASSES.UNKNOWN)).toBe('investigate');
-});
-
-test('recoveryActionFor: defaults to investigate for an unrecognised class', () => {
-  expect(rcaReport.recoveryActionFor('totally-made-up-class')).toBe('investigate');
-  expect(rcaReport.recoveryActionFor(undefined)).toBe('investigate');
-});
-
-test('writeRcaReport: markdown carries a machine-readable recovery-action line matching recoveryActionFor, for each failure class', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  const cases = [
-    { verdict: 'pass_no_commit', logTail: 'The work was already implemented in a prior commit.', expectedClass: rcaReport.FAILURE_CLASSES.ALREADY_SHIPPED },
-    { verdict: 'transcript_errors', logTail: 'Launching skill: session-manager-dev:develop', expectedClass: rcaReport.FAILURE_CLASSES.SELF_QUEUE },
-    { verdict: 'transcript_errors', logTail: 'while true; do sleep 1; done', expectedClass: rcaReport.FAILURE_CLASSES.STUCK_LOOP },
-    { verdict: 'uncommitted_changes', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.UNCOMMITTED },
-    { verdict: 'no_verdict_sentinel', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.NO_SENTINEL },
-    { verdict: 'transcript_errors', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.TRANSCRIPT_ERRORS },
-    { verdict: 'some_other_verdict', logTail: 'plain log tail', expectedClass: rcaReport.FAILURE_CLASSES.UNKNOWN },
-  ];
-
-  for (const { verdict, logTail, expectedClass } of cases) {
-    writeRun(runDir, 'testslug', { logLines: logTail.split('\n') });
-    const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict });
-    expect(res.failureClass).toBe(expectedClass);
-    const expectedAction = rcaReport.recoveryActionFor(expectedClass);
-    expect(res.recoveryAction).toBe(expectedAction);
-    const body = fs.readFileSync(res.path, 'utf8');
-    expect(body).toContain(`recovery-action: ${expectedAction}`);
-  }
-});
-
-test('writeRcaReport: SM_RCA_DISABLE=1 skips without writing', async () => {
-  process.env.SM_RCA_DISABLE = '1';
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-
-  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
-
-  expect(res.filed).toBe(false);
-  expect(res.reason).toBe('disabled');
-  expect(fs.readdirSync(runDir).filter((f) => f.startsWith('root-cause-'))).toHaveLength(0);
-});
-
-test('classifyFailure: blocked_by_foreign_wip_streak verdict classifies as BLOCKED_BY_FOREIGN_WIP, never UNKNOWN', () => {
-  const failureClass = rcaReport.classifyFailure({ verdict: 'blocked_by_foreign_wip_streak', logTail: 'anything' });
-  expect(failureClass).toBe(rcaReport.FAILURE_CLASSES.BLOCKED_BY_FOREIGN_WIP);
-});
-
-test('writeRcaReport: a blocked_by_foreign_wip_streak verdict points at the sibling job, not "re-run the gate"', async () => {
-  const cwd = makeProject();
-  const runDir = path.join(tmpHome, 'run-blocked');
-  writeRun(runDir, 'blockedslug');
-  writePrd(cwd, 'blockedslug');
-
-  const res = await rcaReport.writeRcaReport({
-    job: baseJob({ cwd, slug: 'blockedslug' }),
-    runDir,
-    verdict: 'blocked_by_foreign_wip_streak',
-  });
-
-  expect(res.filed).toBe(true);
-  expect(res.failureClass).toBe(rcaReport.FAILURE_CLASSES.BLOCKED_BY_FOREIGN_WIP);
-  const body = fs.readFileSync(res.path, 'utf8');
-  expect(body).toMatch(/sibling job/i);
-  expect(body).not.toMatch(/Re-run the acceptance criteria gate/);
-});

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

@@ -1,119 +0,0 @@
-/**
- * reconcileFlatPrdSweep.test.cjs — end-to-end proof that `reconcile()` itself
- * (not just `consolidateAllFlatPrds()` in isolation) never turns a
- * hand-written flat-dir PRD into a queue job, regardless of which of
- * reconcile's several callers (tickQueue's poll, job completion, the
- * schedule:state/schedule:rescan IPC handlers, rescheduleTimer) triggered
- * the pass.
- *
- * A code-review pass on this PRD flagged that gating only `tickQueue()` left
- * every OTHER caller of `reconcile()` free to still turn a freshly
- * hand-written flat-dir PRD into a `pending` job — the fix moved the sweep
- * inside `reconcile()` itself instead. This test exercises the real
- * `reconcile()` (not a stand-in) against a real on-disk flat-dir PRD with no
- * pre-existing queue row (exactly the state of a file dropped there moments
- * ago) and asserts it never appears in `state.jobs` afterward.
- *
- * HOME-isolated (mirrors scheduler-reconcile-invalid-repair.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__/reconcileFlatPrdSweep.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 bustCwdCache;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-flatsweep-home-'));
-  process.env.HOME = tmpHome;
-
-  scheduler = require('../scheduler.cjs');
-  ({ bustCwdCache } = 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 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');
-  // Each test registers a NEW project mid-file; without busting queueStore's
-  // stateCwds cache (CACHE_MS 120s), a reconcile() call from an EARLIER test
-  // in this file can leave a stale cwd list cached that this test's freshly
-  // registered project is invisible to — reconcile() then never discovers
-  // its PRD at all (confirmed: this is what made
-  // 'reconcile() still onboards a PRD written to the canonical Epic-scoped
-  // dir' intermittently fail under full-suite load, PRD 1414).
-  bustCwdCache();
-}
-
-function makeFixtureProject(prefix) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  registerActiveProject(cwd);
-  const opsRoot = path.join(cwd, 'session-manager-operations');
-  const flatPrdsDir = path.join(opsRoot, 'scheduler', 'prds');
-  const stateDir = path.join(opsRoot, 'scheduler', 'state');
-  fs.mkdirSync(flatPrdsDir, { recursive: true });
-  fs.mkdirSync(stateDir, { recursive: true });
-  return { cwd, flatPrdsDir, stateDir, archiveDir: path.join(opsRoot, 'scheduler', 'prds-archived') };
-}
-
-test('reconcile() never turns a hand-written flat-dir PRD into a job, no matter which caller triggers it', async () => {
-  const { cwd, flatPrdsDir, archiveDir } = makeFixtureProject('sm-reconcile-flatsweep-proj-');
-  const filename = '1500-hand-written-bypass.md';
-  fs.writeFileSync(
-    path.join(flatPrdsDir, filename),
-    `---\ntitle: Hand-written bypass\ncwd: ${cwd}\nestimateMinutes: 10\n---\n\n# Goal\n\nSomething.\n`,
-    'utf8',
-  );
-  // No queue.json at all — the exact state of a PRD dropped on disk moments
-  // ago, before any prior reconcile() pass has scanned it into a job.
-
-  const state = { jobs: [], invalidJobs: [], paused: null };
-  await scheduler.reconcile(state);
-
-  const found = state.jobs.find((j) => j.slug === '1500-hand-written-bypass');
-  expect(found).toBeUndefined();
-  expect(fs.existsSync(path.join(flatPrdsDir, filename))).toBe(false);
-  expect(fs.existsSync(path.join(archiveDir, filename))).toBe(true);
-});
-
-test('reconcile() still onboards a PRD written to the canonical Epic-scoped dir (the sweep only touches the flat dir)', async () => {
-  const { cwd } = makeFixtureProject('sm-reconcile-flatsweep-epic-proj-');
-  const epicId = 'epic-abc';
-  const epicPrdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
-  fs.mkdirSync(epicPrdsDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(epicPrdsDir, '1501-canonical.md'),
-    `---\ntitle: Canonical\ncwd: ${cwd}\nestimateMinutes: 10\nsourcePromptId: ${epicId}\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\n\nSomething.\n`,
-    'utf8',
-  );
-
-  const state = { jobs: [], invalidJobs: [], paused: null };
-  await scheduler.reconcile(state);
-
-  const found = state.jobs.find((j) => j.slug === '1501-canonical');
-  expect(found).toBeDefined();
-  expect(found.status).toBe('pending');
-});

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

@@ -1,135 +0,0 @@
-/**
- * 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');
-});