claude-code-session-manager 0.98.0 → 0.101.0

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();
-  }
-});

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

@@ -1,349 +0,0 @@
-/**
- * prdMigration.test.cjs — unit tests for the one-time PRD-relocation
- * migration (PRD 808): moves legacy-global PRD .md files into their own
- * project's `<cwd>/session-manager-operations/scheduler/prds/`, based on
- * each file's frontmatter `cwd`.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdMigration.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { migratePrds } = require('../lib/prdMigration.cjs');
-const { resolvePrdWriteDir } = require('../lib/prdLocations.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkLegacyDir() {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdmigration-legacy-'));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-async function mkProjectCwd() {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdmigration-cwd-'));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-test('migratePrds moves a PRD whose frontmatter cwd resolves to an on-disk project', async () => {
-  const legacyDir = await mkLegacyDir();
-  const projectCwd = await mkProjectCwd();
-  const body = `---\ntitle: Do the thing\ncwd: ${projectCwd}\nestimateMinutes: 15\n---\n\n# Goal\n\nDo it.\n`;
-  await fsp.writeFile(path.join(legacyDir, '01-do-thing.md'), body, 'utf8');
-
-  const result = await migratePrds(legacyDir);
-
-  expect(result.moved).toBe(1);
-  expect(result.unresolved).toEqual([]);
-  expect(fs.existsSync(path.join(legacyDir, '01-do-thing.md'))).toBe(false);
-  const dest = path.join(resolvePrdWriteDir(projectCwd), '01-do-thing.md');
-  expect(fs.existsSync(dest)).toBe(true);
-  expect(await fsp.readFile(dest, 'utf8')).toBe(body);
-});
-
-test('migratePrds is idempotent — a second run over an already-migrated dir is a no-op', async () => {
-  const legacyDir = await mkLegacyDir();
-  const projectCwd = await mkProjectCwd();
-  const body = `---\ntitle: Do the thing\ncwd: ${projectCwd}\nestimateMinutes: 15\n---\n\nBody.\n`;
-  await fsp.writeFile(path.join(legacyDir, '02-do-thing.md'), body, 'utf8');
-
-  await migratePrds(legacyDir);
-  const second = await migratePrds(legacyDir);
-
-  expect(second.moved).toBe(0);
-  expect(second.unresolved).toEqual([]);
-});
-
-test('migratePrds leaves a file with no cwd in frontmatter in place and reports it unresolved', async () => {
-  const legacyDir = await mkLegacyDir();
-  const body = `---\ntitle: No cwd here\nestimateMinutes: 15\n---\n\nBody.\n`;
-  await fsp.writeFile(path.join(legacyDir, '03-no-cwd.md'), body, 'utf8');
-
-  const result = await migratePrds(legacyDir);
-
-  expect(result.moved).toBe(0);
-  expect(result.unresolved).toEqual([{ file: '03-no-cwd.md', reason: 'no cwd in frontmatter' }]);
-  expect(fs.existsSync(path.join(legacyDir, '03-no-cwd.md'))).toBe(true);
-});
-
-test('migratePrds leaves a file whose cwd does not exist on disk in place and reports it unresolved', async () => {
-  const legacyDir = await mkLegacyDir();
-  const body = `---\ntitle: Bad cwd\ncwd: /this/path/does/not/exist/anywhere\nestimateMinutes: 15\n---\n\nBody.\n`;
-  await fsp.writeFile(path.join(legacyDir, '04-bad-cwd.md'), body, 'utf8');
-
-  const result = await migratePrds(legacyDir);
-
-  expect(result.moved).toBe(0);
-  expect(result.unresolved).toHaveLength(1);
-  expect(result.unresolved[0].file).toBe('04-bad-cwd.md');
-  expect(fs.existsSync(path.join(legacyDir, '04-bad-cwd.md'))).toBe(true);
-});
-
-test('migratePrds ignores non-.md and dotfiles, and no-ops on a missing legacy dir', async () => {
-  const legacyDir = await mkLegacyDir();
-  await fsp.writeFile(path.join(legacyDir, 'notes.txt'), 'not a prd', 'utf8');
-  await fsp.writeFile(path.join(legacyDir, '.hidden.md'), 'ignored', 'utf8');
-
-  const result = await migratePrds(legacyDir);
-  expect(result).toEqual({ moved: 0, skipped: 0, unresolved: [] });
-
-  const missing = await migratePrds(path.join(legacyDir, 'nope'));
-  expect(missing).toEqual({ moved: 0, skipped: 0, unresolved: [] });
-});
-
-test('migratePrds expands a tilde-prefixed cwd and moves the file', async () => {
-  const legacyDir = await mkLegacyDir();
-  // Deliberately rooted under the REAL os.homedir() (not os.tmpdir()) — the
-  // assertion under test is tilde-expansion relative to the actual home dir,
-  // so a real homedir path is load-bearing here, not incidental. Still safe:
-  // the random suffix is never a registered project the live scheduler scans
-  // for PRDs, and it's removed in afterEach via tmpDirs/fsp.rm.
-  const projectCwd = await fsp.mkdtemp(path.join(os.homedir(), '.sm-prdmigration-tilde-'));
-  tmpDirs.push(projectCwd);
-  const tildeCwd = path.join('~', path.relative(os.homedir(), projectCwd));
-  const body = `---\ntitle: Tilde cwd\ncwd: ${tildeCwd}\nestimateMinutes: 15\n---\n\nBody.\n`;
-  await fsp.writeFile(path.join(legacyDir, '07-tilde.md'), body, 'utf8');
-
-  const result = await migratePrds(legacyDir);
-
-  expect(result.moved).toBe(1);
-  expect(result.unresolved).toEqual([]);
-  const dest = path.join(resolvePrdWriteDir(projectCwd), '07-tilde.md');
-  expect(fs.existsSync(dest)).toBe(true);
-});
-
-test('migratePrds expands a tilde cwd under a temp HOME (regression: stale installs lacking expandHome leave these unresolved)', async () => {
-  const legacyDir = await mkLegacyDir();
-  const fakeHome = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdmigration-fakehome-'));
-  tmpDirs.push(fakeHome);
-  const projectCwd = path.join(fakeHome, 'Projects', 'session-manager');
-  await fsp.mkdir(projectCwd, { recursive: true });
-
-  const originalHome = process.env.HOME;
-  process.env.HOME = fakeHome;
-  try {
-    const body = `---\ntitle: Tilde under fake HOME\ncwd: ~/Projects/session-manager\nestimateMinutes: 15\n---\n\nBody.\n`;
-    await fsp.writeFile(path.join(legacyDir, '08-tilde-fakehome.md'), body, 'utf8');
-
-    const result = await migratePrds(legacyDir);
-
-    expect(result.moved).toBe(1);
-    expect(result.unresolved).toEqual([]);
-    expect(fs.existsSync(path.join(legacyDir, '08-tilde-fakehome.md'))).toBe(false);
-    const dest = path.join(resolvePrdWriteDir(projectCwd), '08-tilde-fakehome.md');
-    expect(fs.existsSync(dest)).toBe(true);
-  } finally {
-    process.env.HOME = originalHome;
-  }
-});
-
-test('migratePrds moves multiple PRDs to different projects independently', async () => {
-  const legacyDir = await mkLegacyDir();
-  const cwdA = await mkProjectCwd();
-  const cwdB = await mkProjectCwd();
-  await fsp.writeFile(
-    path.join(legacyDir, '05-a.md'),
-    `---\ntitle: A\ncwd: ${cwdA}\nestimateMinutes: 5\n---\n\nA.\n`,
-    'utf8',
-  );
-  await fsp.writeFile(
-    path.join(legacyDir, '06-b.md'),
-    `---\ntitle: B\ncwd: ${cwdB}\nestimateMinutes: 5\n---\n\nB.\n`,
-    'utf8',
-  );
-
-  const result = await migratePrds(legacyDir);
-
-  expect(result.moved).toBe(2);
-  expect(fs.existsSync(path.join(resolvePrdWriteDir(cwdA), '05-a.md'))).toBe(true);
-  expect(fs.existsSync(path.join(resolvePrdWriteDir(cwdB), '06-b.md'))).toBe(true);
-});
-
-/* ------------------------------------------------------------------------ *
- * PRD 992 — consolidateFlatPrds must not archive a PRD with a live queue job.
- *
- * The scheduler still scans the retired flat `scheduler/prds/` dir as a PRD
- * *source* (prdLocations.cjs's resolvePrdsDirs), so a file there can have a
- * pending/running job. Consolidation used to move every .md unconditionally,
- * stranding that job with no resolvable source. Observed live 2026-08-02:
- * 980-fix-chat-typed-event-renderers.md sat there with status `running`.
- * ------------------------------------------------------------------------ */
-
-const { consolidateFlatPrds, LIVE_JOB_STATUSES } = require('../lib/prdMigration.cjs');
-
-function opsRoot(root) {
-  return path.join(root, 'session-manager-operations', 'scheduler');
-}
-
-async function makeFlatProject(root, files) {
-  const flat = path.join(opsRoot(root), 'prds');
-  await fsp.mkdir(flat, { recursive: true });
-  for (const name of files) {
-    await fsp.writeFile(path.join(flat, name), `---\ntitle: ${name}\n---\n# Goal\n`, 'utf8');
-  }
-  return flat;
-}
-
-async function writeQueue(root, jobs) {
-  const stateDir = path.join(opsRoot(root), 'state');
-  await fsp.mkdir(stateDir, { recursive: true });
-  await fsp.writeFile(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }), 'utf8');
-}
-
-function newRoot() {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-consolidate-'));
-  tmpDirs.push(d);
-  return d;
-}
-
-for (const status of LIVE_JOB_STATUSES) {
-  test(`consolidateFlatPrds leaves a file in place when its job is ${status}`, async () => {
-    const root = newRoot();
-    const flat = await makeFlatProject(root, ['980-fix-chat-typed-event-renderers.md']);
-    await writeQueue(root, [{ slug: '980-fix-chat-typed-event-renderers', status }]);
-
-    const r = await consolidateFlatPrds(root);
-
-    expect(r.moved).toBe(0);
-    expect(r.skipped).toEqual([
-      { file: '980-fix-chat-typed-event-renderers.md', reason: 'live queue job — source must survive' },
-    ]);
-    expect(fs.existsSync(path.join(flat, '980-fix-chat-typed-event-renderers.md'))).toBe(true);
-  });
-}
-
-for (const status of ['completed', 'failed']) {
-  test(`consolidateFlatPrds archives a file whose job is ${status}`, async () => {
-    const root = newRoot();
-    const flat = await makeFlatProject(root, ['700-done.md']);
-    await writeQueue(root, [{ slug: '700-done', status }]);
-
-    const r = await consolidateFlatPrds(root);
-
-    expect(r.moved).toBe(1);
-    expect(r.skipped).toEqual([]);
-    expect(fs.existsSync(path.join(flat, '700-done.md'))).toBe(false);
-    expect(fs.existsSync(path.join(opsRoot(root), 'prds-archived', '700-done.md'))).toBe(true);
-  });
-}
-
-test('consolidateFlatPrds archives a file with no job at all', async () => {
-  const root = newRoot();
-  await makeFlatProject(root, ['701-orphan.md']);
-  await writeQueue(root, []);
-
-  const r = await consolidateFlatPrds(root);
-
-  expect(r.moved).toBe(1);
-  expect(fs.existsSync(path.join(opsRoot(root), 'prds-archived', '701-orphan.md'))).toBe(true);
-});
-
-// PRD 1024: an UNRECOGNIZED/invalid status (the exact 2026-08-07 1021/1022
-// incident shape) must protect the file, not archive it — reconcile() is
-// what repairs such a row back to 'pending', and this consolidation must
-// never race that repair by moving the row's only source out from under it.
-for (const invalidStatus of ['queued', 'cancelled', 'bogus-status', '']) {
-  test(`consolidateFlatPrds does NOT archive a file whose job has the unrecognized status "${invalidStatus}"`, async () => {
-    const root = newRoot();
-    const flat = await makeFlatProject(root, ['950-invalid-status.md']);
-    await writeQueue(root, [{ slug: '950-invalid-status', status: invalidStatus }]);
-
-    const r = await consolidateFlatPrds(root);
-
-    expect(r.moved).toBe(0);
-    expect(fs.existsSync(path.join(flat, '950-invalid-status.md'))).toBe(true);
-  });
-}
-
-test('consolidateFlatPrds mixed dir: only the live one survives', async () => {
-  const root = newRoot();
-  const flat = await makeFlatProject(root, ['800-live.md', '801-done.md', '802-none.md']);
-  await writeQueue(root, [
-    { slug: '800-live', status: 'running' },
-    { slug: '801-done', status: 'completed' },
-  ]);
-
-  const r = await consolidateFlatPrds(root);
-
-  expect(r.moved).toBe(2);
-  expect(r.skipped.map((s) => s.file)).toEqual(['800-live.md']);
-  expect(fs.existsSync(path.join(flat, '800-live.md'))).toBe(true);
-});
-
-test('consolidateFlatPrds never touches dotfiles (NN allocation still uses them)', async () => {
-  const root = newRoot();
-  const flat = await makeFlatProject(root, ['900-x.md']);
-  await fsp.writeFile(path.join(flat, '.max-allocated-group'), '992', 'utf8');
-
-  await consolidateFlatPrds(root, { liveSlugs: new Set() });
-
-  expect(fs.existsSync(path.join(flat, '.max-allocated-group'))).toBe(true);
-});
-
-test('consolidateFlatPrds is idempotent and creates no -legacy- duplicate', async () => {
-  const root = newRoot();
-  await makeFlatProject(root, ['910-a.md']);
-  await writeQueue(root, []);
-
-  const first = await consolidateFlatPrds(root);
-  const second = await consolidateFlatPrds(root);
-
-  expect(first.moved).toBe(1);
-  expect(second.moved).toBe(0);
-  expect(fs.readdirSync(path.join(opsRoot(root), 'prds-archived'))).toEqual(['910-a.md']);
-});
-
-test('consolidateFlatPrds protects a live job across repeat runs, not just the first', async () => {
-  const root = newRoot();
-  await makeFlatProject(root, ['920-live.md']);
-  await writeQueue(root, [{ slug: '920-live', status: 'pending' }]);
-
-  await consolidateFlatPrds(root);
-  const second = await consolidateFlatPrds(root);
-
-  expect(second.moved).toBe(0);
-  expect(second.skipped).toHaveLength(1);
-});
-
-test('consolidateFlatPrds treats an absent queue.json as "no jobs", not an error', async () => {
-  const root = newRoot();
-  await makeFlatProject(root, ['930-fresh.md']);
-
-  const r = await consolidateFlatPrds(root);
-
-  expect(r.moved).toBe(1);
-  expect(r.skipped).toEqual([]);
-});
-
-test('consolidateFlatPrds FAILS CLOSED on an unparseable queue.json', async () => {
-  const root = newRoot();
-  const flat = await makeFlatProject(root, ['940-a.md', '941-b.md']);
-  const stateDir = path.join(opsRoot(root), 'state');
-  await fsp.mkdir(stateDir, { recursive: true });
-  await fsp.writeFile(path.join(stateDir, 'queue.json'), '{ not json', 'utf8');
-
-  const r = await consolidateFlatPrds(root);
-
-  expect(r.moved).toBe(0);
-  expect(r.skipped).toHaveLength(2);
-  expect(r.skipped[0].reason).toMatch(/queue state unreadable/);
-  expect(fs.existsSync(path.join(flat, '940-a.md'))).toBe(true);
-  expect(fs.existsSync(path.join(flat, '941-b.md'))).toBe(true);
-});
-
-test('consolidateFlatPrds returns the full shape when the flat dir is missing', async () => {
-  const r = await consolidateFlatPrds(newRoot());
-  expect(r).toEqual({ moved: 0, failed: [], skipped: [] });
-});

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

@@ -1,91 +0,0 @@
-/**
- * prdMigrationLegacyAdopt.test.cjs — legacyAdoptExistingPrds() (PRD-authoring-
- * lockdown rollout migration): every PRD .md already on disk when the
- * provenance gate ships must be stamped `createdVia: legacy-adopted` before
- * reconcile() ever runs its quarantine check against it, so the rollout
- * itself never quarantines pre-existing work.
- *
- * HOME-isolated (mirrors scheduler-reconcile-quarantine.test.cjs): stamping
- * relies on resolvePrdsDirs(), which discovers projects via
- * ~/.claude/projects transcripts.
- *
- * Run: timeout 60 npx vitest run src/main/__tests__/prdMigrationLegacyAdopt.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 legacyAdoptExistingPrds;
-let parsePrdFile;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-legacy-adopt-home-'));
-  process.env.HOME = tmpHome;
-  ({ legacyAdoptExistingPrds } = require('../lib/prdMigration.cjs'));
-  ({ parsePrdFile } = require('../lib/prdFrontmatter.cjs'));
-});
-
-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);
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  return { cwd, prdsDir };
-}
-
-test('stamps a pre-existing unstamped PRD as createdVia: legacy-adopted', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-legacy-adopt-proj-');
-  try {
-    const prdPath = path.join(prdsDir, '01-old.md');
-    fs.writeFileSync(prdPath, `---\ntitle: Old PRD\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nOld work.\n`, 'utf8');
-
-    const result = await legacyAdoptExistingPrds();
-    expect(result.stamped).toBeGreaterThanOrEqual(1);
-    expect(result.failed).toEqual([]);
-
-    const { frontmatter } = parsePrdFile(fs.readFileSync(prdPath, 'utf8'));
-    expect(frontmatter.createdVia).toBe('legacy-adopted');
-    expect(typeof frontmatter.issuedAt).toBe('string');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('is idempotent — never overwrites an already-stamped PRD', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-legacy-adopt-idempotent-');
-  try {
-    const prdPath = path.join(prdsDir, '02-already-stamped.md');
-    fs.writeFileSync(
-      prdPath,
-      `---\ntitle: Already stamped\ncwd: ${cwd}\nestimateMinutes: 15\ncreatedVia: scheduler-api\nissuedAt: 2026-08-01T00:00:00.000Z\n---\n\n# Goal\nDone.\n`,
-      'utf8',
-    );
-
-    await legacyAdoptExistingPrds();
-
-    const { frontmatter } = parsePrdFile(fs.readFileSync(prdPath, 'utf8'));
-    expect(frontmatter.createdVia).toBe('scheduler-api'); // unchanged
-    expect(frontmatter.issuedAt).toBe('2026-08-01T00:00:00.000Z'); // unchanged
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});