claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,125 +0,0 @@
-/**
- * prdFrontmatterDisposition.test.cjs — scheduler wave-disposition PRD:
- * `disposition` ('append' | 'new-head') is a recognized, patchable PRD
- * frontmatter key, same pattern as `dependsOn` in
- * prdFrontmatterDependsOn.test.cjs. It records the authoring-time decision
- * for a wave's root PRD: does it extend the Epic's existing dependsOn chain
- * (append) or start an independent, parallel-eligible chain (new-head)?
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdFrontmatterDisposition.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const { parsePrdFile, serializePrdFile, RECOGNIZED_KEYS } = require('../lib/prdFrontmatter.cjs');
-
-test('disposition is a recognized key', () => {
-  expect(RECOGNIZED_KEYS.has('disposition')).toBe(true);
-});
-
-test('parsePrdFile parses disposition: append and round-trips it byte-identically when unedited', () => {
-  const raw = [
-    '---',
-    'title: A second wave',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'dependsOn: [widget-base]',
-    'disposition: append',
-    '---',
-    '# Goal',
-    '',
-    'Extend the chain.',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  expect(frontmatter.disposition).toBe('append');
-  expect(serializePrdFile(frontmatter, body)).toBe(raw);
-});
-
-test('parsePrdFile parses disposition: new-head', () => {
-  const raw = [
-    '---',
-    'title: A parallel wave',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'disposition: new-head',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-
-  const { frontmatter } = parsePrdFile(raw);
-  expect(frontmatter.disposition).toBe('new-head');
-});
-
-test('parsePrdFile leaves disposition unset for an unrecognized value rather than throwing', () => {
-  const raw = [
-    '---',
-    'title: A hand-edited PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'disposition: sideways',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-
-  const { frontmatter } = parsePrdFile(raw);
-  expect(frontmatter.disposition).toBeUndefined();
-});
-
-test('parsePrdFile leaves disposition undefined when omitted — a PRD authored before this field existed round-trips unaffected', () => {
-  const raw = [
-    '---',
-    'title: An older PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 10',
-    '---',
-    '# Goal',
-    '',
-    'Do the thing.',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  expect(frontmatter.disposition).toBeUndefined();
-  expect(serializePrdFile(frontmatter, body)).toBe(raw);
-});
-
-test('serializePrdFile emits a newly-set disposition onto a frontmatter object that lacked one', () => {
-  const raw = [
-    '---',
-    'title: Legacy PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 5',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  const updated = serializePrdFile({ ...frontmatter, disposition: 'new-head' }, body);
-  expect(updated).toContain('disposition: new-head');
-});
-
-test('serializePrdFile patches an existing disposition (promoting append to new-head)', () => {
-  const raw = [
-    '---',
-    'title: A second wave',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'dependsOn: [widget-base]',
-    'disposition: append',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  const updated = serializePrdFile({ ...frontmatter, dependsOn: [], disposition: 'new-head' }, body);
-  expect(updated).toContain('disposition: new-head');
-  expect(updated).not.toContain('dependsOn');
-});

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

@@ -1,108 +0,0 @@
-/**
- * prdFrontmatterQuietMachine.test.cjs — PRD 1107: `quietMachine: true` is an
- * optional PRD frontmatter field, recognized by prdFrontmatter.cjs's
- * parsePrdFile/serializePrdFile round-trip AND by scheduler/prdParser.cjs's
- * dispatch-time parsePrdRaw. Only a literal `true` opts in; omitted or any
- * other value behaves exactly like today (additive-only, no required-field
- * regression for the thousands of PRDs written before this field existed).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdFrontmatterQuietMachine.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const { parsePrdFile, serializePrdFile } = require('../lib/prdFrontmatter.cjs');
-const { parsePrdRaw, _resetCache } = require('../scheduler/prdParser.cjs');
-
-function mkTmpPrdsDir() {
-  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-quietmachine-'));
-}
-
-test('parsePrdFile recognizes quietMachine: true and serializePrdFile round-trips it byte-identically', () => {
-  const raw = [
-    '---',
-    'title: A timing-sensitive PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 30',
-    'quietMachine: true',
-    '---',
-    '# Goal',
-    '',
-    'Measure frame time without contention.',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  expect(frontmatter.quietMachine).toBe(true);
-  expect(serializePrdFile(frontmatter, body)).toBe(raw);
-});
-
-test('parsePrdFile ignores quietMachine: false — only a literal true opts in', () => {
-  const raw = [
-    '---',
-    'title: Not opted in',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 30',
-    'quietMachine: false',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-  const { frontmatter } = parsePrdFile(raw);
-  expect(frontmatter.quietMachine).toBeUndefined();
-});
-
-test('parsePrdFile leaves quietMachine undefined when omitted — additive-only, no regression for old PRDs', () => {
-  const raw = [
-    '---',
-    'title: An older PRD authored before this field existed',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 30',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-  const { frontmatter } = parsePrdFile(raw);
-  expect(frontmatter.quietMachine).toBeUndefined();
-});
-
-test('scheduler/prdParser.cjs parsePrdRaw exposes quietMachine as a typed boolean, true only when the frontmatter literally says true', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-
-  const quietPath = path.join(dir, '1-quiet.md');
-  await fsp.writeFile(quietPath, [
-    '---',
-    'title: Quiet job',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 10',
-    'quietMachine: true',
-    '---',
-    '# Goal',
-    '',
-    'Do the thing quietly.',
-    '',
-  ].join('\n'));
-  const quiet = await parsePrdRaw(quietPath);
-  expect(quiet.quietMachine).toBe(true);
-
-  const ordinaryPath = path.join(dir, '2-ordinary.md');
-  await fsp.writeFile(ordinaryPath, [
-    '---',
-    'title: Ordinary job',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 10',
-    '---',
-    '# Goal',
-    '',
-    'Do the thing.',
-    '',
-  ].join('\n'));
-  const ordinary = await parsePrdRaw(ordinaryPath);
-  expect(ordinary.quietMachine).toBe(false);
-});

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

@@ -1,195 +0,0 @@
-/**
- * prdLocations.test.cjs — unit tests for prdLocations.cjs's per-project PRD
- * directory resolution (PRD 808).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdLocations.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  resolvePrdWriteDir,
-  resolvePrdsDirs,
-  resolveEpicPrdWriteDir,
-  listEpicPrdDirs,
-} = require('../lib/prdLocations.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-test('resolvePrdWriteDir joins the project-scoped PRDs subpath onto cwd', () => {
-  expect(resolvePrdWriteDir('/home/user/Projects/foo')).toBe(
-    path.join('/home/user/Projects/foo', 'session-manager-operations', 'scheduler', 'prds'),
-  );
-});
-
-test('resolvePrdWriteDir throws on a missing cwd', () => {
-  expect(() => resolvePrdWriteDir()).toThrow();
-  expect(() => resolvePrdWriteDir('')).toThrow();
-});
-
-test('resolvePrdsDirs still finds a QUIET project\'s PRDs dir (no recency filter)', async () => {
-  // Regression cover for 2026-07-31: discovery used activeProjectCwds' 90-min
-  // window, so a project nobody had touched recently became unscannable — and
-  // reconcile() reads an unscannable PRD as a deleted one and drops its queue
-  // row. 142 PRDs across 6 quiet projects were affected.
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-quiet-projects-'));
-  tmpDirs.push(projectsDir);
-  const quietCwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-quiet-cwd-'));
-  tmpDirs.push(quietCwd);
-
-  // The project owns a real PRDs dir on disk...
-  fs.mkdirSync(resolvePrdWriteDir(quietCwd), { recursive: true });
-
-  const projDir = path.join(projectsDir, 'quiet-project');
-  fs.mkdirSync(projDir, { recursive: true });
-  const transcript = path.join(projDir, 'session1.jsonl');
-  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: quietCwd })}\n`);
-  // ...but its last session was a week ago, far outside the active window.
-  const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
-  fs.utimesSync(transcript, weekAgo, weekAgo);
-
-  const dirs = resolvePrdsDirs(90, { projectsDir });
-  expect(dirs).toContain(resolvePrdWriteDir(quietCwd));
-});
-
-test('resolvePrdsDirs skips a quiet project that owns no PRDs dir', async () => {
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-nodir-projects-'));
-  tmpDirs.push(projectsDir);
-  const quietCwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-nodir-cwd-'));
-  tmpDirs.push(quietCwd);
-
-  const projDir = path.join(projectsDir, 'quiet-no-prds');
-  fs.mkdirSync(projDir, { recursive: true });
-  const transcript = path.join(projDir, 'session1.jsonl');
-  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: quietCwd })}\n`);
-  const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
-  fs.utimesSync(transcript, weekAgo, weekAgo);
-
-  expect(resolvePrdsDirs(90, { projectsDir })).not.toContain(resolvePrdWriteDir(quietCwd));
-});
-
-test('resolvePrdsDirs maps each active project cwd to its own PRDs dir', async () => {
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdlocations-projects-'));
-  tmpDirs.push(projectsDir);
-  const projectCwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdlocations-cwd-'));
-  tmpDirs.push(projectCwd);
-
-  const slug = 'abc123';
-  const projDir = path.join(projectsDir, slug);
-  fs.mkdirSync(projDir, { recursive: true });
-  const transcript = path.join(projDir, 'session1.jsonl');
-  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: projectCwd })}\n`);
-
-  const dirs = resolvePrdsDirs(90, { projectsDir });
-  expect(dirs).toEqual([resolvePrdWriteDir(projectCwd)]);
-  expect(dirs[0].endsWith(path.join('session-manager-operations', 'scheduler', 'prds'))).toBe(true);
-});
-
-test('resolvePrdsDirs returns [] when no project has a recent transcript', () => {
-  const dirs = resolvePrdsDirs(90, { projectsDir: '/nonexistent-projects-dir' });
-  expect(dirs).toEqual([]);
-});
-
-test('listEpicPrdDirs memoizes on the Epics-root mtime: no readdir on a repeat call, but a freshly minted Epic prds dir is picked up on the very next call', async () => {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-memo-cwd-'));
-  tmpDirs.push(cwd);
-  fs.mkdirSync(resolveEpicPrdWriteDir(cwd, 'epic-1'), { recursive: true });
-
-  const first = listEpicPrdDirs(cwd);
-  expect(first).toEqual([resolveEpicPrdWriteDir(cwd, 'epic-1')]);
-
-  const readdirSpy = vi.spyOn(fs, 'readdirSync');
-  try {
-    // Nothing under the Epics root changed — the cached result comes back
-    // without a fresh readdir of the Epics root.
-    const second = listEpicPrdDirs(cwd);
-    expect(second).toEqual(first);
-    expect(readdirSpy).not.toHaveBeenCalled();
-  } finally {
-    readdirSpy.mockRestore();
-  }
-
-  // A brand-new Epic's prds/ dir is a NEW entry under the Epics root, which
-  // bumps the root's own mtime — no TTL wait required to see it.
-  fs.mkdirSync(resolveEpicPrdWriteDir(cwd, 'epic-2'), { recursive: true });
-  const third = listEpicPrdDirs(cwd);
-  expect(third).toEqual(
-    expect.arrayContaining([resolveEpicPrdWriteDir(cwd, 'epic-1'), resolveEpicPrdWriteDir(cwd, 'epic-2')]),
-  );
-});
-
-test('listEpicPrdDirs: an unreadable Epics root does not write a poisoned entry that survives the dir becoming readable', async () => {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-unreadable-cwd-'));
-  tmpDirs.push(cwd);
-
-  // No Epics root at all yet.
-  expect(listEpicPrdDirs(cwd)).toEqual([]);
-
-  // The root now exists, with a real Epic prds dir inside it.
-  fs.mkdirSync(resolveEpicPrdWriteDir(cwd, 'epic-1'), { recursive: true });
-  expect(listEpicPrdDirs(cwd)).toEqual([resolveEpicPrdWriteDir(cwd, 'epic-1')]);
-});
-
-test('resolvePrdsDirs EDGE (non-negotiable): a new epics/<id>/prds dir created after a prior call is visible on the VERY NEXT call, no TTL wait', async () => {
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-freshness-projects-'));
-  tmpDirs.push(projectsDir);
-  const projectCwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-freshness-cwd-'));
-  tmpDirs.push(projectCwd);
-
-  const projDir = path.join(projectsDir, 'freshness-project');
-  fs.mkdirSync(projDir, { recursive: true });
-  fs.writeFileSync(path.join(projDir, 'session1.jsonl'), `${JSON.stringify({ cwd: projectCwd })}\n`);
-
-  const before = resolvePrdsDirs(90, { projectsDir });
-  const newEpicPrdDir = resolveEpicPrdWriteDir(projectCwd, 'freshly-minted-epic');
-  expect(before).not.toContain(newEpicPrdDir);
-
-  fs.mkdirSync(newEpicPrdDir, { recursive: true });
-
-  const after = resolvePrdsDirs(90, { projectsDir });
-  expect(after).toContain(newEpicPrdDir);
-});
-
-test('resolvePrdsDirs: calls with an explicit { projectsDir } opts are keyed separately per projectsDir and never share a stale cache entry', async () => {
-  const projectsDirA = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-keyed-a-'));
-  tmpDirs.push(projectsDirA);
-  const projectsDirB = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-keyed-b-'));
-  tmpDirs.push(projectsDirB);
-  const cwdA = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-keyed-cwd-a-'));
-  tmpDirs.push(cwdA);
-  const cwdB = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-keyed-cwd-b-'));
-  tmpDirs.push(cwdB);
-
-  const projDirA = path.join(projectsDirA, 'proj-a');
-  fs.mkdirSync(projDirA, { recursive: true });
-  fs.writeFileSync(path.join(projDirA, 'session1.jsonl'), `${JSON.stringify({ cwd: cwdA })}\n`);
-  fs.mkdirSync(resolvePrdWriteDir(cwdA), { recursive: true });
-
-  const projDirB = path.join(projectsDirB, 'proj-b');
-  fs.mkdirSync(projDirB, { recursive: true });
-  fs.writeFileSync(path.join(projDirB, 'session1.jsonl'), `${JSON.stringify({ cwd: cwdB })}\n`);
-  fs.mkdirSync(resolvePrdWriteDir(cwdB), { recursive: true });
-
-  const dirsA = resolvePrdsDirs(90, { projectsDir: projectsDirA });
-  const dirsB = resolvePrdsDirs(90, { projectsDir: projectsDirB });
-
-  expect(dirsA).toContain(resolvePrdWriteDir(cwdA));
-  expect(dirsA).not.toContain(resolvePrdWriteDir(cwdB));
-  expect(dirsB).toContain(resolvePrdWriteDir(cwdB));
-  expect(dirsB).not.toContain(resolvePrdWriteDir(cwdA));
-
-  // Re-querying A after B was resolved must still reflect A's own state, not
-  // B's — proof the two opts objects never shared one cache key.
-  expect(resolvePrdsDirs(90, { projectsDir: projectsDirA })).toEqual(dirsA);
-});

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

@@ -1,201 +0,0 @@
-/**
- * prdLocationsArchived.test.cjs — unit tests for the archived-PRD discovery
- * that backs `schedule:list-prds` including archived PRDs (PRD 926): an
- * Epic's "PRDs" tab count must reflect its REAL historical PRD count, not
- * just whatever is still sitting in its live `prds/` dir — a completed
- * PRD's source .md moves to the sibling `prds-archived/` dir the instant its
- * scheduler job finishes (scheduler.cjs's archiveCompletedPrd), which the
- * old list-prds handler never read.
- *
- * Covers:
- *   - resolveArchivedPrdsDirs finds an Epic's own `prds-archived/` dir
- *     alongside the project's flat sibling one.
- *   - deriveEpicIdFromPrdPath resolves an epicId for a file under
- *     `prds-archived/`, not just the live `prds/` dir.
- *   - scheduler.cjs's candidateArchivedPrdsDirs + candidatePrdsDirs
- *     together surface both a still-pending PRD and an already-archived one
- *     for the same Epic, without double-counting.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdLocationsArchived.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  resolveArchivedPrdsDirs,
-  resolvePrdsDirs,
-  resolveEpicPrdWriteDir,
-  deriveEpicIdFromPrdPath,
-} = require('../lib/prdLocations.cjs');
-const { candidatePrdsDirs, candidateArchivedPrdsDirs, resolveArchivedPrdStatus } = require('../scheduler.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-function mkEpicProject() {
-  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-archived-cwd-'));
-}
-
-test('resolveArchivedPrdsDirs finds an Epic\'s own prds-archived/ dir for an active project', async () => {
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-archived-projects-'));
-  tmpDirs.push(projectsDir);
-  const projectCwd = await mkEpicProject();
-  tmpDirs.push(projectCwd);
-
-  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, 'epic-1');
-  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
-  fs.mkdirSync(epicArchiveDir, { recursive: true });
-
-  const projDir = path.join(projectsDir, 'epic-project');
-  fs.mkdirSync(projDir, { recursive: true });
-  const transcript = path.join(projDir, 'session1.jsonl');
-  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: projectCwd })}\n`);
-
-  const dirs = resolveArchivedPrdsDirs(90, { projectsDir });
-  expect(dirs).toContain(path.resolve(epicArchiveDir));
-});
-
-test('deriveEpicIdFromPrdPath resolves epicId for a file under prds-archived/, not just prds/', async () => {
-  const projectCwd = await mkEpicProject();
-  tmpDirs.push(projectCwd);
-
-  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, 'epic-42');
-  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
-  fs.mkdirSync(epicArchiveDir, { recursive: true });
-
-  const archivedFile = path.join(epicArchiveDir, '917-example.md');
-  fs.writeFileSync(archivedFile, '---\ntitle: example\n---\n\n# Goal\n');
-
-  expect(deriveEpicIdFromPrdPath(archivedFile)).toBe('epic-42');
-  // Still works for the live dir too — no regression.
-  const liveFile = path.join(epicPrdsDir, '918-example.md');
-  fs.mkdirSync(epicPrdsDir, { recursive: true });
-  fs.writeFileSync(liveFile, '---\ntitle: example\n---\n\n# Goal\n');
-  expect(deriveEpicIdFromPrdPath(liveFile)).toBe('epic-42');
-});
-
-test('deriveEpicIdFromPrdPath returns null for an unrelated dir name', () => {
-  expect(deriveEpicIdFromPrdPath('/some/random/dir/917-example.md')).toBeNull();
-});
-
-test('resolvePrdsDirs + resolveArchivedPrdsDirs together surface a pending PRD dir and an archived PRD dir for the same Epic, with no overlap', async () => {
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-both-projects-'));
-  tmpDirs.push(projectsDir);
-  const projectCwd = await mkEpicProject();
-  tmpDirs.push(projectCwd);
-
-  const epicId = `test-epic-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, epicId);
-  const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
-  fs.mkdirSync(epicPrdsDir, { recursive: true });
-  fs.mkdirSync(epicArchiveDir, { recursive: true });
-
-  const pendingSlug = `926-pending-${process.pid}`;
-  const archivedSlug = `917-archived-${process.pid}`;
-  fs.writeFileSync(path.join(epicPrdsDir, `${pendingSlug}.md`), `---\ntitle: pending\ncwd: ${projectCwd}\n---\n\n# Goal\n`);
-  fs.writeFileSync(path.join(epicArchiveDir, `${archivedSlug}.md`), `---\ntitle: archived\ncwd: ${projectCwd}\n---\n\n# Goal\n`);
-
-  const projDir = path.join(projectsDir, 'both-project');
-  fs.mkdirSync(projDir, { recursive: true });
-  fs.writeFileSync(path.join(projDir, 'session1.jsonl'), `${JSON.stringify({ cwd: projectCwd })}\n`);
-
-  const liveDirs = resolvePrdsDirs(90, { projectsDir });
-  const archivedDirs = resolveArchivedPrdsDirs(90, { projectsDir });
-  expect(liveDirs).toContain(epicPrdsDir);
-  expect(archivedDirs.map((d) => path.resolve(d))).toContain(path.resolve(epicArchiveDir));
-
-  // No overlap between the two dir sets for this Epic — an archived PRD's
-  // dir is never also scanned as a live one, and vice versa.
-  expect(liveDirs).not.toContain(epicArchiveDir);
-  expect(archivedDirs).not.toContain(epicPrdsDir);
-});
-
-test('resolveArchivedPrdStatus prefers the live queue.json row over history', () => {
-  const liveStatusBySlug = new Map([['917-slug', 'failed']]);
-  const histBySlug = new Map([['917-slug', { status: 'completed' }]]);
-  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, histBySlug)).toBe('failed');
-});
-
-test('resolveArchivedPrdStatus falls back to history.jsonl when there is no live row', () => {
-  const liveStatusBySlug = new Map();
-  const histBySlug = new Map([['917-slug', { status: 'failed' }]]);
-  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, histBySlug)).toBe('failed');
-});
-
-test('resolveArchivedPrdStatus defaults to completed when neither source has the slug', () => {
-  expect(resolveArchivedPrdStatus('917-slug', new Map(), new Map())).toBe('completed');
-});
-
-test('resolveArchivedPrdStatus normalizes any non-failed status (e.g. needs_review) to completed', () => {
-  const liveStatusBySlug = new Map([['917-slug', 'needs_review']]);
-  expect(resolveArchivedPrdStatus('917-slug', liveStatusBySlug, new Map())).toBe('completed');
-});
-
-test('scheduler.cjs exports candidateArchivedPrdsDirs alongside candidatePrdsDirs', () => {
-  expect(typeof candidatePrdsDirs).toBe('function');
-  expect(typeof candidateArchivedPrdsDirs).toBe('function');
-  // Both scan the real machine's projects — just assert they run without
-  // throwing and return arrays; per-Epic coverage is exercised above via
-  // the opts-injectable prdLocations functions directly.
-  expect(Array.isArray(candidatePrdsDirs())).toBe(true);
-  expect(Array.isArray(candidateArchivedPrdsDirs())).toBe(true);
-});
-
-test('resolveArchivedPrdsDirs: a prds-archived/ dir created inside an ALREADY-EXISTING Epic (the archiveCompletedPrd shape — does not bump the Epics root mtime) is bounded-stale, not stale forever', async () => {
-  // archiveCompletedPrd (scheduler.cjs) creates `epics/<id>/prds-archived/`
-  // as a new entry INSIDE an already-existing `epics/<id>/` dir — unlike a
-  // brand-new Epic's `prds/` (created in the same mkdirSync call as
-  // `epics/<id>/` itself), this does NOT bump the Epics root's own mtime,
-  // so the mtime-keyed freshness key alone would never invalidate. The
-  // short TTL backstop (same idiom as activeSessions.cjs's cwdScanCache)
-  // bounds that blind spot instead of leaving it stale indefinitely.
-  //
-  // Why this test is sensitive to the process environment: the code under test
-  // keys its cache on REAL directory mtimes and expires it via Date.now(); the
-  // fixtures are mkdtemp'd under os.tmpdir(), which a TMPDIR override moves.
-  // Installing fake timers BEFORE the async fs fixture setup let the fake timer
-  // queue interleave with real fs completions. Build every fixture on the real
-  // clock first, then fake ONLY Date — the sole clock the TTL reads.
-  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdloc-blindspot-projects-'));
-  tmpDirs.push(projectsDir);
-  const projectCwd = await mkEpicProject();
-  tmpDirs.push(projectCwd);
-
-  const epicId = `blindspot-epic-${process.pid}`;
-  const epicPrdsDir = resolveEpicPrdWriteDir(projectCwd, epicId);
-  fs.mkdirSync(epicPrdsDir, { recursive: true }); // Epic already exists, well before archiving.
-
-  const projDir = path.join(projectsDir, 'blindspot-project');
-  fs.mkdirSync(projDir, { recursive: true });
-  fs.writeFileSync(path.join(projDir, 'session1.jsonl'), `${JSON.stringify({ cwd: projectCwd })}\n`);
-
-  vi.useFakeTimers({ toFake: ['Date'] });
-  try {
-    // Prime the cache — no prds-archived/ dir exists yet.
-    const before = resolveArchivedPrdsDirs(90, { projectsDir });
-    const epicArchiveDir = path.join(epicPrdsDir, '..', 'prds-archived');
-    expect(before).not.toContain(path.resolve(epicArchiveDir));
-
-    // The archiveCompletedPrd shape: a NEW prds-archived/ dir appears inside
-    // the ALREADY-EXISTING epic dir. This does not change the Epics root's
-    // own mtime.
-    fs.mkdirSync(epicArchiveDir, { recursive: true });
-
-    // Bounded staleness is acceptable — but it must actually be bounded.
-    vi.advanceTimersByTime(121_000); // TTL is 120 s — above the 60 s dispatch-loop interval
-    const after = resolveArchivedPrdsDirs(90, { projectsDir });
-    expect(after.map((d) => path.resolve(d))).toContain(path.resolve(epicArchiveDir));
-  } finally {
-    vi.useRealTimers();
-  }
-});