claude-code-session-manager 0.97.0 → 0.100.0

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

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

@@ -1,74 +0,0 @@
-/**
- * prdParserHighWater.test.cjs — regression test for allocateParallelGroup's
- * high-water mark: once queueOps.cjs's autoArchiveCompleted starts moving
- * old NN-*.md files out of prds/ into prds-archived/, a bare directory scan
- * (maxParallelGroupInUse) can regress once the highest-NN files age out —
- * letting a later allocation reissue an already-used NN and collide with an
- * archived group. The high-water-mark sidecar (.max-allocated-group) must
- * keep the allocator monotonic even after every file is archived away.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/prdParserHighWater.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 { allocateParallelGroup, maxParallelGroupInUse, _resetCache } = require('../scheduler/prdParser.cjs');
-
-function mkTmpPrdsDir() {
-  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-highwater-'));
-}
-
-test('allocator stays monotonic after every NN-*.md file (and its reservation marker) is archived away', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-
-  // Directly-authored legacy files (never allocated via allocateParallelGroup
-  // — e.g. /develop's deliberate-sibling path — so no .reserved-NN marker
-  // exists for them). This is the real gap: reservation markers alone would
-  // already protect any NN the allocator itself minted, so the regression
-  // this PRD guards against is specifically legacy/directly-authored NNs.
-  await fsp.writeFile(path.join(dir, '10-a.md'), '# a\n');
-  await fsp.writeFile(path.join(dir, '544-b.md'), '# b\n');
-
-  // A scan (via allocateParallelGroup) observes 544 and persists it as the
-  // high-water mark before returning the next free NN.
-  const first = await allocateParallelGroup(dir);
-  expect(first).toBe(545);
-
-  // Simulate autoArchiveCompleted moving every .md out of the live dir, and
-  // also strip the reservation marker the allocation above created — so
-  // nothing on disk still evidences 544/545 except the high-water sidecar.
-  await fsp.unlink(path.join(dir, '10-a.md'));
-  await fsp.unlink(path.join(dir, '544-b.md'));
-  await fsp.unlink(path.join(dir, '.reserved-545'));
-
-  const bareScanMax = await maxParallelGroupInUse(dir);
-  expect(bareScanMax).toBe(0);
-
-  _resetCache();
-  const second = await allocateParallelGroup(dir);
-  expect(second).toBeGreaterThan(545);
-  expect(second).toBe(546);
-});
-
-test('high-water mark also protects against a fresh scan that is lower than a prior allocation, without any archiving involved', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-
-  await fsp.writeFile(path.join(dir, '5-only.md'), '# x\n');
-  const nn = await allocateParallelGroup(dir);
-  expect(nn).toBe(6);
-
-  // A slow/partial directory listing (or a caller passing a differently
-  // scoped dir) must not be able to walk the allocator backwards.
-  const rescanMax = await maxParallelGroupInUse(dir);
-  expect(rescanMax).toBe(6); // the .reserved-6 marker from the allocation above still counts
-
-  const next = await allocateParallelGroup(dir);
-  expect(next).toBe(7);
-});

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

@@ -1,65 +0,0 @@
-/**
- * prdParserSourcePromptId.test.cjs — parsePrdRaw() tolerates both presence
- * and absence of the optional `sourcePromptId` frontmatter key (PRD 749).
- * Additive-only: PRDs written before this field existed must still parse
- * identically (no required-field regression).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdParserSourcePromptId.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 { parsePrdRaw, _resetCache } = require('../scheduler/prdParser.cjs');
-
-function mkTmpPrdsDir() {
-  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-sourceprompt-'));
-}
-
-test('parsePrdRaw extracts sourcePromptId when present in frontmatter', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-  const filePath = path.join(dir, '1-with-source.md');
-  await fsp.writeFile(filePath, [
-    '---',
-    'title: Has a source ticket',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 10',
-    'sourcePromptId: ticket-xyz-789',
-    '---',
-    '# Goal',
-    '',
-    'Do the thing.',
-    '',
-  ].join('\n'));
-
-  const parsed = await parsePrdRaw(filePath);
-  expect(parsed.sourcePromptId).toBe('ticket-xyz-789');
-  expect(parsed.title).toBe('Has a source ticket');
-});
-
-test('parsePrdRaw returns null sourcePromptId for a PRD authored before this field existed', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-  const filePath = path.join(dir, '2-legacy.md');
-  await fsp.writeFile(filePath, [
-    '---',
-    'title: Legacy PRD, no sourcePromptId',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 5',
-    '---',
-    '# Goal',
-    '',
-    'Do the other thing.',
-    '',
-  ].join('\n'));
-
-  const parsed = await parsePrdRaw(filePath);
-  expect(parsed.sourcePromptId).toBe(null);
-  expect(parsed.title).toBe('Legacy PRD, no sourcePromptId');
-  expect(parsed.cwd).toBe(path.join(os.homedir(), 'Projects', 'session-manager'));
-});