claude-code-session-manager 0.98.0 → 0.100.0

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

@@ -1,136 +0,0 @@
-/**
- * prdFrontmatterDependsOn.test.cjs — PRD 1124: `dependsOn` is a recognized,
- * patchable PRD frontmatter key. Before this PRD, RECOGNIZED_KEYS omitted
- * `dependsOn`, so it only round-tripped verbatim via `extras` and
- * scheduler_update_prd could not patch it — the only repair path for a
- * wrong dependsOn was archive-and-recreate, which is unsafe (archiving
- * marks the PRD completed, freeing its dependents with zero work done).
- *
- * Covers the pure parse/serialize contract in prdFrontmatter.cjs. The
- * write-time FK validation + clearing semantics wired into
- * scheduler.remote.updatePrd are covered by
- * prdUpdateDependsOn.test.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdFrontmatterDependsOn.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const { parsePrdFile, serializePrdFile, RECOGNIZED_KEYS } = require('../lib/prdFrontmatter.cjs');
-
-test('dependsOn is a recognized key', () => {
-  expect(RECOGNIZED_KEYS.has('dependsOn')).toBe(true);
-});
-
-test('parsePrdFile parses an inline dependsOn list into an array, and round-trips it byte-identically when unedited', () => {
-  const raw = [
-    '---',
-    'title: A follow-up PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'agentType: dev-lead',
-    'dependsOn: [widget-base, widget-shared]',
-    '---',
-    '# Goal',
-    '',
-    'Build on the base.',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  expect(frontmatter.dependsOn).toEqual(['widget-base', 'widget-shared']);
-  expect(serializePrdFile(frontmatter, body)).toBe(raw);
-});
-
-test('parsePrdFile leaves dependsOn undefined when omitted — a PRD with no dependsOn round-trips unaffected', () => {
-  const raw = [
-    '---',
-    'title: An older PRD authored before dependsOn was patchable',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 10',
-    '---',
-    '# Goal',
-    '',
-    'Do the thing.',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  expect(frontmatter.dependsOn).toBeUndefined();
-  expect(serializePrdFile(frontmatter, body)).toBe(raw);
-
-  // An unrelated patch (title) must not introduce a dependsOn line.
-  const updated = serializePrdFile({ ...frontmatter, title: 'Renamed' }, body);
-  expect(updated).not.toContain('dependsOn');
-});
-
-test('serializePrdFile emits a newly-set dependsOn 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, dependsOn: ['some-other-prd'] }, body);
-  expect(updated).toContain('dependsOn: [some-other-prd]');
-});
-
-test('serializePrdFile patches an existing dependsOn to a new list', () => {
-  const raw = [
-    '---',
-    'title: A follow-up PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'dependsOn: [widget-base]',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  const updated = serializePrdFile({ ...frontmatter, dependsOn: ['widget-shared', 'widget-extra'] }, body);
-  expect(updated).toContain('dependsOn: [widget-shared, widget-extra]');
-  expect(updated).not.toContain('widget-base');
-});
-
-test('serializePrdFile patching dependsOn to an explicit empty array CLEARS it', () => {
-  const raw = [
-    '---',
-    'title: A follow-up PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'dependsOn: [widget-base]',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  const updated = serializePrdFile({ ...frontmatter, dependsOn: [] }, body);
-  expect(updated).not.toContain('dependsOn');
-});
-
-test('unrelated recognized-key patch leaves an existing dependsOn line untouched', () => {
-  const raw = [
-    '---',
-    'title: A follow-up PRD',
-    'cwd: ~/Projects/session-manager',
-    'estimateMinutes: 20',
-    'dependsOn: [widget-base]',
-    '---',
-    'body',
-    '',
-  ].join('\n');
-
-  const { frontmatter, body } = parsePrdFile(raw);
-  const updated = serializePrdFile({ ...frontmatter, estimateMinutes: 30 }, body);
-  expect(updated).toContain('dependsOn: [widget-base]');
-  expect(updated).toContain('estimateMinutes: 30');
-});

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