claude-code-session-manager 0.98.0 → 0.101.0

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

@@ -1,205 +0,0 @@
-/**
- * prdCreateAdoption.test.cjs — PRD 1446: scheduler_create_prd wrote a PRD
- * file and promised its queue row "on the next reconcile pass (~1 minute)",
- * but nothing reliably ran that pass. The 60s pollLoop only reaches
- * reconcile() via maybeLaunchWhenAvailable, which returns early while zero
- * rows are pending; the 10-minute rescheduleTimer awaits refreshNextReset()
- * -> billing.fetchUsage() BEFORE reconciling, and stalled indefinitely while
- * the usage meter was rate-limited (PRDs 1420-1441 sat unadopted 17+
- * minutes, 2026-09-25).
- *
- * Two fixes, exercised here:
- *  1. scheduler.remote gained `requestReconcile()` — the SAME broadcast
- *     coalescer / reconcile() seam `remote.resetJob` already used (no
- *     second reconcile implementation) — and prdCreate.cjs's createPrd()
- *     calls it right after a successful write.
- *  2. rescheduleTimer's refreshNextReset() await is now bounded by a
- *     RESCHEDULE_TIMER_BILLING_RACE_MS Promise.race against the cached
- *     reset value, so its own mutate(reconcile) still runs even when
- *     billing.fetchUsage() never resolves.
- *
- * HOME-isolated + fixture-project pattern mirrors reconcileTiming.test.cjs.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/prdCreateAdoption.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 usage;
-let config;
-let createPrd;
-
-/** A bare cwd for the fake-remote createPrd() tests below — these don't go
- *  through a real Epic/queue, so all they need is a directory config.cjs's
- *  validatePath will accept. Not os.homedir(): this file's beforeAll swaps
- *  process.env.HOME for scheduler.cjs's isolation, so os.homedir() called
- *  from inside a test would resolve to tmpHome instead of the real home
- *  config.cjs's allowedRoots snapshot was seeded with at import time. */
-function makeAllowedCwd(prefix) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  config.addAllowedRoot(cwd);
-  return cwd;
-}
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-adoption-home-'));
-  process.env.HOME = tmpHome;
-
-  // Required AFTER HOME is swapped, never at module top level: activeSessions.cjs
-  // (pulled in transitively by prdCreate.cjs/scheduler.cjs) snapshots
-  // `os.homedir()` into a module-scope constant at first require — loading it
-  // before this reassignment would permanently bake in the vitest sandbox's
-  // own HOME (tests/setup/schedulerSandbox.globalSetup.cjs) instead of this
-  // file's tmpHome, silently breaking every ~/.claude/projects-scan-dependent
-  // assertion below (allProjectCwds/reconcile would always come back empty).
-  scheduler = require('../scheduler.cjs');
-  usage = require('../usage.cjs');
-  config = require('../config.cjs');
-  ({ createPrd } = require('../lib/prdCreate.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();
-  vi.useRealTimers();
-});
-
-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: Adoption fixture\ncwd: ${cwd}\nestimateMinutes: 10\nsourcePromptId: ${epicId}\ncreatedVia: scheduler-api\nissuedAt: 2026-09-25T00:00:00.000Z\n---\n\n# Goal\n\nSomething.\n`,
-    'utf8',
-  );
-}
-
-test('remote.requestReconcile() adopts a freshly-created PRD into a pending row with no tickQueue call', async () => {
-  const cwd = makeFixtureProject('sm-prd-adoption-fresh-');
-  writeCanonicalPrd(cwd, 'epic-fresh', '9001-fresh');
-
-  const tickQueueSpy = vi.spyOn(scheduler, 'tickQueue');
-
-  await scheduler.remote.requestReconcile();
-
-  expect(tickQueueSpy).not.toHaveBeenCalled();
-  const job = await scheduler.remote.getJob('9001-fresh');
-  expect(job).not.toBeNull();
-  expect(job.status).toBe('pending');
-});
-
-test('createPrd() calls remote.requestReconcile() once after a successful write and reports enqueued:true once the row exists', async () => {
-  const writes = new Map();
-  const requestReconcile = vi.fn(async () => {});
-  const remote = {
-    async allocateParallelGroup() { return '9002'; },
-    async readPrd(slug) {
-      return writes.has(slug) ? { ok: true, text: writes.get(slug) } : { ok: false, error: 'missing' };
-    },
-    async writePrd(slug, body) {
-      writes.set(slug, body);
-      return { ok: true, path: `/fake/${slug}.md` };
-    },
-    async listPrds() { return { prds: [], total: 0, limit: 0, offset: 0, hasMore: false }; },
-    requestReconcile,
-    // Simulates the reconcile pass having already produced the queue row by
-    // the time createPrd() checks for it.
-    async getJob(slug) { return writes.has(slug) ? { slug, status: 'pending' } : null; },
-  };
-
-  const result = await createPrd({
-    title: 'Adoption wiring check',
-    cwd: makeAllowedCwd('sm-prd-adoption-hit-'),
-    estimateMinutes: 10,
-    goal: 'g',
-    acceptanceCriteria: ['a'],
-    implementationNotes: 'n',
-  }, remote);
-
-  expect(result.ok).toBe(true);
-  expect(requestReconcile).toHaveBeenCalledTimes(1);
-  expect(result.enqueued).toBe(true);
-  expect(result.note).not.toMatch(/derived by the next scheduler reconcile pass/);
-});
-
-test('createPrd() reports enqueued:false with the deferred-pass note when the row is not visible right after reconcile', async () => {
-  const writes = new Map();
-  const requestReconcile = vi.fn(async () => {});
-  const remote = {
-    async allocateParallelGroup() { return '9003'; },
-    async readPrd(slug) {
-      return writes.has(slug) ? { ok: true, text: writes.get(slug) } : { ok: false, error: 'missing' };
-    },
-    async writePrd(slug, body) {
-      writes.set(slug, body);
-      return { ok: true, path: `/fake/${slug}.md` };
-    },
-    async listPrds() { return { prds: [], total: 0, limit: 0, offset: 0, hasMore: false }; },
-    requestReconcile,
-    async getJob() { return null; },
-  };
-
-  const result = await createPrd({
-    title: 'Adoption wiring miss',
-    cwd: makeAllowedCwd('sm-prd-adoption-miss-'),
-    estimateMinutes: 10,
-    goal: 'g',
-    acceptanceCriteria: ['a'],
-    implementationNotes: 'n',
-  }, remote);
-
-  expect(result.ok).toBe(true);
-  expect(requestReconcile).toHaveBeenCalledTimes(1);
-  expect(result.enqueued).toBe(false);
-  expect(result.note).toMatch(/derived by the next scheduler reconcile pass/);
-});
-
-test('rescheduleTimer still reconciles when billing.fetchUsage() never resolves', async () => {
-  const cwd = makeFixtureProject('sm-prd-adoption-stall-');
-  writeCanonicalPrd(cwd, 'epic-stall', '9004-stall');
-
-  vi.spyOn(usage, 'fetchUsage').mockImplementation(() => new Promise(() => {}));
-  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
-
-  const pending = scheduler.rescheduleTimer();
-  await vi.advanceTimersByTimeAsync(scheduler.RESCHEDULE_TIMER_BILLING_RACE_MS);
-  await pending;
-
-  vi.useRealTimers();
-
-  const job = await scheduler.remote.getJob('9004-stall');
-  expect(job).not.toBeNull();
-  expect(job.status).toBe('pending');
-}, 15_000);

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

@@ -1,201 +0,0 @@
-/**
- * prdCreateDisposition.test.cjs — scheduler wave-disposition PRD:
- * createPrd()'s authoring-time disposition gate. A PRD landing as a wave
- * ROOT (no dependsOn of its own) in an Epic that already has incomplete
- * PRDs must record an explicit 'append'/'new-head' choice — required for an
- * interactive caller, defaulted (and logged) for a non-interactive one.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdCreateDisposition.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const config = require('../config.cjs');
-const prdParser = require('../scheduler/prdParser.cjs');
-const { parsePrdFile } = require('../lib/prdFrontmatter.cjs');
-const { createPrd } = require('../lib/prdCreate.cjs');
-
-async function mkTmpPrdsDir() {
-  const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-disposition-create-prd-'));
-  config.addAllowedRoot(root);
-  const prdsDir = path.join(root, '.claude', 'prds');
-  await fsp.mkdir(prdsDir, { recursive: true });
-  return prdsDir;
-}
-
-/** Minimal fake `remote` — same shape as prdCreate.test.cjs's
- *  makeFakeRemoteWithPrdsDir, but listPrds also reports sourcePromptId/
- *  dependsOn (read back from each seeded file's real frontmatter) and
- *  status (from the test-supplied statusBySlug map) — the fields
- *  createPrd()'s disposition gate actually reads. */
-function makeFakeRemote(prdsDir, statusBySlug = {}) {
-  return {
-    async allocateParallelGroup() {
-      return prdParser.allocateParallelGroup(prdsDir);
-    },
-    async readPrd(slug) {
-      try {
-        const text = await fsp.readFile(path.join(prdsDir, `${slug}.md`), 'utf8');
-        return { ok: true, text };
-      } catch (e) {
-        return { ok: false, error: e?.message };
-      }
-    },
-    async writePrd(slug, body) {
-      try {
-        const filePath = path.join(prdsDir, `${slug}.md`);
-        await config.writeTextAtomic(filePath, body, { writer: 'scheduler' });
-        return { ok: true };
-      } catch (e) {
-        return { ok: false, error: e?.message };
-      }
-    },
-    async listPrds() {
-      const entries = await fsp.readdir(prdsDir);
-      const prds = [];
-      for (const f of entries) {
-        if (!f.endsWith('.md')) continue;
-        const slug = f.slice(0, -3);
-        const raw = await fsp.readFile(path.join(prdsDir, f), 'utf8');
-        const { frontmatter } = parsePrdFile(raw);
-        prds.push({
-          slug,
-          sourcePromptId: frontmatter.sourcePromptId ?? null,
-          dependsOn: frontmatter.dependsOn ?? null,
-          status: statusBySlug[slug] ?? null,
-        });
-      }
-      return { prds, total: prds.length, limit: prds.length, offset: 0, hasMore: false };
-    },
-  };
-}
-
-/** Seeds a fixture PRD file directly (bypassing createPrd) at an explicit,
- *  already-NN-prefixed slug, so tests can assert dependsOn against a known
- *  name instead of a freshly-allocated one. */
-async function seedPrd(prdsDir, slug, { sourcePromptId, dependsOn } = {}) {
-  const lines = ['---', 'title: seed', `sourcePromptId: ${sourcePromptId}`];
-  if (dependsOn && dependsOn.length) lines.push(`dependsOn: [${dependsOn.join(', ')}]`);
-  lines.push('---', '# Goal', '', 'seed body', '');
-  await fsp.writeFile(path.join(prdsDir, `${slug}.md`), lines.join('\n'));
-}
-
-function validBody(overrides = {}) {
-  return {
-    title: 'Wave 2 root',
-    cwd: os.homedir(),
-    estimateMinutes: 10,
-    goal: 'Do the follow-on work.',
-    acceptanceCriteria: ['a'],
-    implementationNotes: 'n',
-    ...overrides,
-  };
-}
-
-// This suite's own process may itself be running as a scheduled job (this
-// file's disposition gate keys directly off SM_SCHEDULER_JOB_SLUG — see
-// createPrd()) — never assume it's unset going in; each test controls it
-// explicitly.
-const originalJobSlug = process.env.SM_SCHEDULER_JOB_SLUG;
-beforeEach(() => {
-  delete process.env.SM_SCHEDULER_JOB_SLUG;
-});
-afterEach(() => {
-  if (originalJobSlug === undefined) delete process.env.SM_SCHEDULER_JOB_SLUG;
-  else process.env.SM_SCHEDULER_JOB_SLUG = originalJobSlug;
-});
-
-test('refuses to write, without a disposition, a new root joining an Epic that already has an incomplete PRD', async () => {
-  const prdsDir = await mkTmpPrdsDir();
-  await seedPrd(prdsDir, '1-wave1-tail', { sourcePromptId: 'epic-1' });
-  const remote = makeFakeRemote(prdsDir, { '1-wave1-tail': 'pending' });
-
-  const result = await createPrd(validBody({ sourcePromptId: 'epic-1' }), remote);
-
-  expect(result.ok).toBe(false);
-  expect(result.status).toBe(400);
-  expect(result.error).toMatch(/disposition/i);
-});
-
-test('disposition: append attaches the new root behind the Epic\'s current terminal PRD', async () => {
-  const prdsDir = await mkTmpPrdsDir();
-  await seedPrd(prdsDir, '1-wave1-tail', { sourcePromptId: 'epic-1' });
-  const remote = makeFakeRemote(prdsDir, { '1-wave1-tail': 'pending' });
-
-  const result = await createPrd(validBody({ sourcePromptId: 'epic-1', disposition: 'append' }), remote);
-
-  expect(result.ok).toBe(true);
-  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
-  expect(written).toMatch(/^dependsOn: \[1-wave1-tail\]$/m);
-  expect(written).toMatch(/^disposition: append$/m);
-});
-
-test('disposition: new-head leaves the new root independent (no dependsOn)', async () => {
-  const prdsDir = await mkTmpPrdsDir();
-  await seedPrd(prdsDir, '1-wave1-tail', { sourcePromptId: 'epic-1' });
-  const remote = makeFakeRemote(prdsDir, { '1-wave1-tail': 'pending' });
-
-  const result = await createPrd(validBody({ sourcePromptId: 'epic-1', disposition: 'new-head' }), remote);
-
-  expect(result.ok).toBe(true);
-  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
-  expect(written).not.toContain('dependsOn');
-  expect(written).toMatch(/^disposition: new-head$/m);
-});
-
-test('a non-interactive caller (SM_SCHEDULER_JOB_SLUG set) with no disposition defaults to append, logged as a default', async () => {
-  const prdsDir = await mkTmpPrdsDir();
-  await seedPrd(prdsDir, '1-wave1-tail', { sourcePromptId: 'epic-1' });
-  const remote = makeFakeRemote(prdsDir, { '1-wave1-tail': 'pending' });
-  process.env.SM_SCHEDULER_JOB_SLUG = 'some-running-job';
-
-  const result = await createPrd(validBody({ sourcePromptId: 'epic-1' }), remote);
-
-  expect(result.ok).toBe(true);
-  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
-  expect(written).toMatch(/^dependsOn: \[1-wave1-tail\]$/m);
-  expect(written).toMatch(/^disposition: append$/m);
-});
-
-test('no disposition required for the first PRD in a brand-new Epic', async () => {
-  const prdsDir = await mkTmpPrdsDir();
-  const remote = makeFakeRemote(prdsDir);
-
-  const result = await createPrd(validBody({ sourcePromptId: 'epic-empty' }), remote);
-
-  expect(result.ok).toBe(true);
-  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
-  expect(written).not.toContain('disposition');
-});
-
-test('no disposition required when every existing PRD in the Epic is already completed', async () => {
-  const prdsDir = await mkTmpPrdsDir();
-  await seedPrd(prdsDir, '1-wave1-tail', { sourcePromptId: 'epic-done' });
-  const remote = makeFakeRemote(prdsDir, { '1-wave1-tail': 'completed' });
-
-  const result = await createPrd(validBody({ sourcePromptId: 'epic-done' }), remote);
-
-  expect(result.ok).toBe(true);
-  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
-  expect(written).not.toContain('disposition');
-});
-
-test('an explicit dependsOn bypasses the disposition gate entirely', async () => {
-  const prdsDir = await mkTmpPrdsDir();
-  await seedPrd(prdsDir, '1-wave1-tail', { sourcePromptId: 'epic-1' });
-  const remote = makeFakeRemote(prdsDir, { '1-wave1-tail': 'pending' });
-
-  const result = await createPrd(
-    validBody({ sourcePromptId: 'epic-1', dependsOn: ['1-wave1-tail'] }),
-    remote,
-  );
-
-  expect(result.ok).toBe(true);
-  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
-  expect(written).toMatch(/^dependsOn: \[1-wave1-tail\]$/m);
-  expect(written).not.toContain('disposition');
-});

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

@@ -1,132 +0,0 @@
-/**
- * prdCreatePlanId.test.cjs — createPrd() stamps a durable `planId` (wave identity):
- * first-ever PRD mints, append inherits the terminal's, new-head mints, explicit
- * multi-dep inherits the lowest-numbered dependency's (diverged ids logged once).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdCreatePlanId.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach, vi } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const config = require('../config.cjs');
-const prdParser = require('../scheduler/prdParser.cjs');
-const { parsePrdFile } = require('../lib/prdFrontmatter.cjs');
-const { createPrd } = require('../lib/prdCreate.cjs');
-const { resolveInheritedPlanId, isValidPlanId } = require('../lib/prdDisposition.cjs');
-
-async function mkTmpPrdsDir() {
-  const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-planid-create-prd-'));
-  config.addAllowedRoot(root);
-  const prdsDir = path.join(root, '.claude', 'prds');
-  await fsp.mkdir(prdsDir, { recursive: true });
-  return prdsDir;
-}
-
-function makeFakeRemote(prdsDir, statusBySlug = {}) {
-  return {
-    async allocateParallelGroup() { return prdParser.allocateParallelGroup(prdsDir); },
-    async readPrd(slug) {
-      try { return { ok: true, text: await fsp.readFile(path.join(prdsDir, `${slug}.md`), 'utf8') }; }
-      catch (e) { return { ok: false, error: e?.message }; }
-    },
-    async writePrd(slug, body) {
-      await config.writeTextAtomic(path.join(prdsDir, `${slug}.md`), body, { writer: 'scheduler' });
-      return { ok: true };
-    },
-    async listPrds() {
-      const prds = [];
-      for (const f of await fsp.readdir(prdsDir)) {
-        if (!f.endsWith('.md')) continue;
-        const slug = f.slice(0, -3);
-        const { frontmatter } = parsePrdFile(await fsp.readFile(path.join(prdsDir, f), 'utf8'));
-        prds.push({
-          slug,
-          sourcePromptId: frontmatter.sourcePromptId ?? null,
-          dependsOn: frontmatter.dependsOn ?? null,
-          planId: frontmatter.planId ?? null,
-          status: statusBySlug[slug] ?? null,
-        });
-      }
-      return { prds, total: prds.length, limit: prds.length, offset: 0, hasMore: false };
-    },
-  };
-}
-
-async function seedPrd(prdsDir, slug, { planId, dependsOn } = {}) {
-  const lines = ['---', 'title: seed', 'sourcePromptId: epic-1'];
-  if (dependsOn) lines.push(`dependsOn: [${dependsOn.join(', ')}]`);
-  if (planId) lines.push(`planId: ${planId}`);
-  lines.push('---', '# Goal', '', 'seed', '');
-  await fsp.writeFile(path.join(prdsDir, `${slug}.md`), lines.join('\n'));
-}
-
-const body = (o = {}) => ({
-  title: 'Next wave', cwd: os.homedir(), estimateMinutes: 10, goal: 'g',
-  acceptanceCriteria: ['a'], implementationNotes: 'n', ...o,
-});
-const planIdOf = async (dir, result) =>
-  parsePrdFile(await fsp.readFile(path.join(dir, result.filename), 'utf8')).frontmatter.planId;
-
-const originalJobSlug = process.env.SM_SCHEDULER_JOB_SLUG;
-beforeEach(() => { delete process.env.SM_SCHEDULER_JOB_SLUG; });
-afterEach(() => {
-  vi.restoreAllMocks();
-  if (originalJobSlug === undefined) delete process.env.SM_SCHEDULER_JOB_SLUG;
-  else process.env.SM_SCHEDULER_JOB_SLUG = originalJobSlug;
-});
-
-test('first-ever PRD in an Epic mints a valid planId', async () => {
-  const dir = await mkTmpPrdsDir();
-  const r = await createPrd(body({ sourcePromptId: 'epic-1' }), makeFakeRemote(dir));
-  expect(r.ok).toBe(true);
-  expect(isValidPlanId(await planIdOf(dir, r))).toBe(true);
-});
-
-test('a caller-supplied planId is ignored (API-owned)', async () => {
-  const dir = await mkTmpPrdsDir();
-  const r = await createPrd(body({ planId: 'evil-id' }), makeFakeRemote(dir));
-  expect(await planIdOf(dir, r)).not.toBe('evil-id');
-});
-
-test('append inherits the chain terminal\'s planId', async () => {
-  const dir = await mkTmpPrdsDir();
-  await seedPrd(dir, '1-tail', { planId: 'pl-abc' });
-  const r = await createPrd(body({ sourcePromptId: 'epic-1', disposition: 'append' }), makeFakeRemote(dir, { '1-tail': 'pending' }));
-  expect(r.ok).toBe(true);
-  expect(await planIdOf(dir, r)).toBe('pl-abc');
-});
-
-test('new-head mints a fresh planId, distinct from the existing plan', async () => {
-  const dir = await mkTmpPrdsDir();
-  await seedPrd(dir, '1-tail', { planId: 'pl-abc' });
-  const r = await createPrd(body({ sourcePromptId: 'epic-1', disposition: 'new-head' }), makeFakeRemote(dir, { '1-tail': 'pending' }));
-  const id = await planIdOf(dir, r);
-  expect(isValidPlanId(id)).toBe(true);
-  expect(id).not.toBe('pl-abc');
-});
-
-test('explicit multi-dep across two plans inherits the lowest-numbered dependency\'s and warns once', async () => {
-  const dir = await mkTmpPrdsDir();
-  await seedPrd(dir, '9-late', { planId: 'pl-late' });
-  await seedPrd(dir, '2-early', { planId: 'pl-early' });
-  const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-  const r = await createPrd(body({ dependsOn: ['9-late', '2-early'] }), makeFakeRemote(dir));
-  expect(r.ok).toBe(true);
-  expect(await planIdOf(dir, r)).toBe('pl-early');
-  expect(warn.mock.calls.filter((c) => String(c[0]).includes('spans plans')).length).toBe(1);
-});
-
-test('deps that predate the stamp fall back to a freshly minted planId', async () => {
-  const dir = await mkTmpPrdsDir();
-  await seedPrd(dir, '1-legacy');
-  const r = await createPrd(body({ dependsOn: ['1-legacy'] }), makeFakeRemote(dir));
-  expect(isValidPlanId(await planIdOf(dir, r))).toBe(true);
-});
-
-test('resolveInheritedPlanId ignores garbage planIds', () => {
-  expect(resolveInheritedPlanId(['1-a'], [{ slug: '1-a', planId: 'bad id,[x]' }]).planId).toBeNull();
-});

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

@@ -1,117 +0,0 @@
-/**
- * prdFrontmatterAgentType.test.cjs — PRD 1114: `agentType` (WHO executes a
- * PRD, distinct from `tag` — the WORK TYPE) is a recognized PRD frontmatter
- * key, round-tripped byte-identically by prdFrontmatter.cjs's
- * parsePrdFile/serializePrdFile pair, and surfaced (with read-time tolerance
- * for a dangling persona) by scheduler/prdParser.cjs's parsePrdRaw.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdFrontmatterAgentType.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const fs = require('node:fs');
-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');
-const { todayFile } = require('../lib/opsErrorLog.cjs');
-
-function mkTmpPrdsDir() {
-  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-agenttype-fm-'));
-}
-
-test('parsePrdFile recognizes agentType and serializePrdFile round-trips it byte-identically', () => {
-  const raw = [
-    '---',
-    'title: A PRD with a persona',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 30',
-    'tag: bug',
-    'agentType: dev-lead',
-    '---',
-    '# Goal',
-    '',
-    'Fix the thing.',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  expect(frontmatter.agentType).toBe('dev-lead');
-  expect(serializePrdFile(frontmatter, body)).toBe(raw);
-});
-
-test('parsePrdFile leaves agentType 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.agentType).toBeUndefined();
-});
-
-// Real opsErrorLog write path (not a mock) — see prdAgentType.test.cjs's
-// header for why a plain mkdtemp() cwd is safe to use here (not "ephemeral").
-test('scheduler/prdParser.cjs parsePrdRaw exposes agentType, and tolerates a dangling persona by logging once instead of throwing', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-
-  const danglingPath = path.join(dir, '1-dangling.md');
-  await fsp.writeFile(danglingPath, [
-    '---',
-    'title: A PRD whose persona was later deleted',
-    `cwd: ${dir}`,
-    'estimateMinutes: 10',
-    'agentType: ghost-persona-that-does-not-exist-anywhere',
-    '---',
-    '# Goal',
-    '',
-    'Still loads.',
-    '',
-  ].join('\n'));
-
-  const parsed = await parsePrdRaw(danglingPath);
-  expect(parsed.agentType).toBe('ghost-persona-that-does-not-exist-anywhere');
-
-  const lines = fs.readFileSync(todayFile(dir), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
-  const matches = lines.filter((l) => l.message.includes('ghost-persona-that-does-not-exist-anywhere'));
-  expect(matches).toHaveLength(1);
-  expect(matches[0].scope).toBe('prdAgentType');
-  expect(matches[0].level).toBe('warn');
-
-  // A second parse of the SAME (cwd, agentType) pair must not log again.
-  _resetCache();
-  await parsePrdRaw(danglingPath);
-  const linesAfter = fs.readFileSync(todayFile(dir), 'utf8').split('\n').filter(Boolean);
-  expect(linesAfter).toHaveLength(1);
-});
-
-test('scheduler/prdParser.cjs parsePrdRaw leaves agentType null when omitted', async () => {
-  const dir = await mkTmpPrdsDir();
-  _resetCache();
-
-  const ordinaryPath = path.join(dir, '2-ordinary.md');
-  await fsp.writeFile(ordinaryPath, [
-    '---',
-    'title: Ordinary job',
-    `cwd: ${dir}`,
-    'estimateMinutes: 10',
-    '---',
-    '# Goal',
-    '',
-    'Do the thing.',
-    '',
-  ].join('\n'));
-
-  const parsed = await parsePrdRaw(ordinaryPath);
-  expect(parsed.agentType).toBeNull();
-});