claude-code-session-manager 0.78.0 → 0.80.0

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

@@ -196,9 +196,25 @@ function makeFakeRemoteWithPrdsDir(prdsDir) {
         return { ok: false, error: e?.message };
       }
     },
+    // Minimal stand-in for scheduler.cjs's real remote.listPrds: every
+    // `<slug>.md` under the fake project's prdsDir, as a `{ slug }` row —
+    // enough for prdCreate.cjs's dependsOn-existence validation, which only
+    // ever reads `.slug` off each entry.
+    async listPrds() {
+      const entries = await fsp.readdir(prdsDir);
+      const prds = entries
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => ({ slug: f.slice(0, -3) }));
+      return { prds, total: prds.length, limit: prds.length, offset: 0, hasMore: false };
+    },
   };
 }
 
+/** Pre-seed the fake project's prdsDir with an existing (empty-body) PRD file at `slug`. */
+async function seedExistingPrd(prdsDir, slug) {
+  await fsp.writeFile(path.join(prdsDir, `${slug}.md`), '---\ntitle: seed\n---\n# Goal\n');
+}
+
 function validCreateBody(overrides = {}) {
   return {
     title: 'Add widget frobnication',
@@ -797,16 +813,20 @@ test('createPrd refuses a depth-3 fix-chain slug the same way as depth-2', async
   expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
 });
 
-test('createPrd allows a depth-1 fix slug through the same code path that rejects depth 2 (matches MAX_INVESTIGATION_DEPTH=1)', async () => {
+test('createPrd refuses a depth-1 fix slug too (PRD 1131) — that shape is reserved for spawnInvestigation-authored fix plans, not this API', async () => {
   const prdsDir = await mkTmpPrdsDir();
   const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const writePrdSpy = vi.fn(remote.writePrd);
+  remote.writePrd = writePrdSpy;
 
   const result = await createPrd(validCreateBody({ slug: 'fix-widget-frobnication' }), remote);
 
-  expect(result.ok).toBe(true);
-  expect(result.filename).toMatch(/^\d+-fix-widget-frobnication\.md$/);
-  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
-  expect(written).toMatch(/title: Add widget frobnication/);
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(400);
+  expect(result.error).toMatch(/reserved NN-fix-\.\.\. fix-plan naming convention/i);
+  expect(writePrdSpy).not.toHaveBeenCalled();
+  const entries = await fsp.readdir(prdsDir);
+  expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
 });
 
 test('createPrd is unaffected by the fix-chain guard for an ordinary slug with no fix chain at all', async () => {
@@ -820,14 +840,15 @@ test('createPrd is unaffected by the fix-chain guard for an ordinary slug with n
   expect(written).toMatch(/title: Add widget frobnication/);
 });
 
-test('createPrd is not fooled by a slug where a later segment merely reads "fix" (false-positive bait)', async () => {
+test('createPrd refuses a slug starting with "fix-" even when a later segment merely reads "fix" (isFixPlanSlug matches on the leading segment alone, unlike fixChainDepthOf)', async () => {
   const prdsDir = await mkTmpPrdsDir();
   const remote = makeFakeRemoteWithPrdsDir(prdsDir);
 
   const result = await createPrd(validCreateBody({ slug: 'fix-loop-extraction-and-round-trip' }), remote);
 
-  expect(result.ok).toBe(true);
-  expect(result.filename).toMatch(/^\d+-fix-loop-extraction-and-round-trip\.md$/);
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(400);
+  expect(result.error).toMatch(/reserved NN-fix-\.\.\. fix-plan naming convention/i);
 });
 
 test('createPrd leaves sourcePromptId unset when originClaudeSessionId matches no known Epic (plain SessionTab chat)', async () => {
@@ -850,3 +871,107 @@ test('createPrd leaves sourcePromptId unset when originClaudeSessionId matches n
     await fsp.rm(root, { recursive: true, force: true });
   }
 });
+
+// ──────────────────────────────────────────── PRD 1121: reject double-prefixed
+// slugs, validate dependsOn against existing PRDs at write time
+
+test('createPrd refuses a caller-supplied slug already starting with a numeric prefix', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: '254-perf-x' }), remote);
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(400);
+  expect(result.error).toMatch(/254-/);
+  expect(result.error).toMatch(/bare name/);
+  const entries = await fsp.readdir(prdsDir);
+  expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+});
+
+test('createPrd still accepts a bare (non-prefixed) caller-supplied slug', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'perf-x' }), remote);
+
+  expect(result.ok).toBe(true);
+  expect(result.filename).toMatch(/^\d+-perf-x\.md$/);
+});
+
+test('createPrd accepts dependsOn naming an existing bare slug', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  await seedExistingPrd(prdsDir, '3-widget-base');
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'widget-follow-up', dependsOn: ['widget-base'] }), remote);
+
+  expect(result.ok).toBe(true);
+  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+  expect(written).toMatch(/^dependsOn: \[widget-base\]$/m);
+});
+
+test('createPrd accepts dependsOn naming an existing full NN-prefixed slug', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  await seedExistingPrd(prdsDir, '3-widget-base');
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'widget-follow-up-2', dependsOn: ['3-widget-base'] }), remote);
+
+  expect(result.ok).toBe(true);
+});
+
+test('createPrd refuses dependsOn naming nothing, listing near-matches in the message, and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  await seedExistingPrd(prdsDir, '3-widget-base');
+  await seedExistingPrd(prdsDir, '4-widget-basics');
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'widget-follow-up-3', dependsOn: ['wigdet-bsae'] }), remote);
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(400);
+  expect(result.error).toMatch(/wigdet-bsae/);
+  expect(result.error).toMatch(/widget-base/);
+  const entries = await fsp.readdir(prdsDir);
+  expect(entries.filter((f) => f.endsWith('.md') && f.includes('widget-follow-up-3')).length).toBe(0);
+});
+
+test('createPrd treats an empty dependsOn array as a no-op (no listPrds call, no rejection)', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const listPrdsSpy = vi.fn(remote.listPrds);
+  remote.listPrds = listPrdsSpy;
+
+  const result = await createPrd(validCreateBody({ slug: 'no-deps-here', dependsOn: [] }), remote);
+
+  expect(result.ok).toBe(true);
+  expect(listPrdsSpy).not.toHaveBeenCalled();
+});
+
+test('createPrd treats an absent dependsOn as a no-op (no listPrds call, no rejection)', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const listPrdsSpy = vi.fn(remote.listPrds);
+  remote.listPrds = listPrdsSpy;
+
+  const result = await createPrd(validCreateBody({ slug: 'no-deps-field' }), remote);
+
+  expect(result.ok).toBe(true);
+  expect(listPrdsSpy).not.toHaveBeenCalled();
+});
+
+test('createPrd warns and skips dependsOn validation (never fails the write) when listPrds throws', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  remote.listPrds = async () => { throw new Error('simulated I/O failure'); };
+  const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+  try {
+    const result = await createPrd(validCreateBody({ slug: 'deps-during-outage', dependsOn: ['anything-at-all'] }), remote);
+    expect(result.ok).toBe(true);
+    expect(warnSpy).toHaveBeenCalled();
+  } finally {
+    warnSpy.mockRestore();
+  }
+});

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

@@ -0,0 +1,136 @@
+/**
+ * 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__/prdUpdateDependsOn.test.cjs

@@ -0,0 +1,160 @@
+/**
+ * prdUpdateDependsOn.test.cjs — PRD 1124: scheduler.remote.updatePrd accepts
+ * a `dependsOn` array patch, validates it write-time against the SAME
+ * resolver (depSlugResolve.cjs) scheduler_create_prd's prdCreate.cjs uses,
+ * and accepts an explicit empty array to CLEAR the dependency.
+ *
+ * Mirrors scheduler-reconcile-quarantine.test.cjs's HOME-isolation fixture.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdUpdateDependsOn.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 scheduler;
+let queueStore;
+let config;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-update-prd-dependson-home-'));
+  process.env.HOME = tmpHome;
+
+  scheduler = require('../scheduler.cjs');
+  queueStore = require('../lib/queueStore.cjs');
+  config = require('../config.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 });
+});
+
+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);
+  // updatePrd writes through config.writeTextAtomic, which enforces
+  // validatePath's allowed-write-root boundary (os.homedir() by default).
+  // The live app widens this via pty.cjs's spawn / activeIndexMerge.cjs's
+  // boot registration as a side effect of opening the project; a test that
+  // never spawns a PTY has to register it explicitly, same as
+  // prdCreate.cjs's own createPrd does for a chat-only Epic.
+  config.addAllowedRoot(cwd);
+  const opsRoot = path.join(cwd, 'session-manager-operations');
+  const prdsDir = path.join(opsRoot, 'scheduler', 'epics', 'test-epic-1', 'prds');
+  const stateDir = path.join(opsRoot, 'scheduler', 'state');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
+  queueStore.bustCwdCache();
+  return { cwd, prdsDir, stateDir };
+}
+
+function writePrd(prdsDir, filename, cwd, extraFrontmatter = '') {
+  fs.writeFileSync(
+    path.join(prdsDir, filename),
+    `---\ntitle: ${filename}\ncwd: ${cwd}\nestimateMinutes: 10\ncreatedVia: scheduler-api\n${extraFrontmatter}---\n\n# Goal\nDo the thing.\n`,
+    'utf8',
+  );
+}
+
+test('updatePrd patches dependsOn to a new valid list naming an existing bare slug', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-valid-');
+  try {
+    writePrd(prdsDir, '3-widget-base.md', cwd);
+    writePrd(prdsDir, '4-widget-follow-up.md', cwd);
+
+    const result = await scheduler.remote.updatePrd({
+      slug: '4-widget-follow-up',
+      cwd,
+      frontmatter: { dependsOn: ['widget-base'] },
+    });
+
+    expect(result.ok).toBe(true);
+    const written = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
+    expect(written).toMatch(/^dependsOn: \[widget-base\]$/m);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('updatePrd refuses a dependsOn entry that resolves to no existing PRD, with a near-match suggestion, and writes nothing', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-invalid-');
+  try {
+    writePrd(prdsDir, '3-widget-base.md', cwd);
+    writePrd(prdsDir, '4-widget-follow-up.md', cwd);
+    const before = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
+
+    const result = await scheduler.remote.updatePrd({
+      slug: '4-widget-follow-up',
+      cwd,
+      frontmatter: { dependsOn: ['wigdet-bsae'] },
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/does not resolve to any existing PRD/);
+    expect(result.error).toMatch(/widget-base/);
+    const after = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
+    expect(after).toBe(before);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('updatePrd patches dependsOn to an explicit empty array, clearing a previously-set dependency without validation', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-clear-');
+  try {
+    writePrd(prdsDir, '3-widget-base.md', cwd);
+    writePrd(prdsDir, '4-widget-follow-up.md', cwd, 'dependsOn: [widget-base]\n');
+
+    const result = await scheduler.remote.updatePrd({
+      slug: '4-widget-follow-up',
+      cwd,
+      frontmatter: { dependsOn: [] },
+    });
+
+    expect(result.ok).toBe(true);
+    const written = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
+    expect(written).not.toContain('dependsOn');
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('updatePrd patching an unrelated field leaves a PRD with no dependsOn unaffected', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-unrelated-');
+  try {
+    writePrd(prdsDir, '3-standalone.md', cwd);
+
+    const result = await scheduler.remote.updatePrd({
+      slug: '3-standalone',
+      cwd,
+      frontmatter: { estimateMinutes: 25 },
+    });
+
+    expect(result.ok).toBe(true);
+    const written = fs.readFileSync(path.join(prdsDir, '3-standalone.md'), 'utf8');
+    expect(written).not.toContain('dependsOn');
+    expect(written).toMatch(/^estimateMinutes: 25$/m);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});

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

@@ -257,3 +257,36 @@ test('historyTerminalBySlug: cache invalidates after a new appendHistory call (m
   expect(second.has('cache-1')).toBe(true);
   expect(second.has('cache-2')).toBe(true);
 });
+
+// ---------- completedSlugsForCwd (PRD 1122) ----------
+//
+// Feeds scheduler.cjs's computeDepHistorySatisfaction: a dependsOn slug with
+// no live queue row is only satisfied when it shows up here (or in
+// prds-archived/) — scoped to ONE project's own history shard so a
+// same-named PRD in an unrelated project can never satisfy a dep.
+
+test('completedSlugsForCwd: returns slugs completed in this project\'s own shard only', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-projA-'));
+  const otherCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-projB-'));
+  await queueHistory.appendHistory([
+    old({ slug: '900-base', status: 'completed', runId: 'ra', cwd: projectCwd }),
+    old({ slug: '901-failed', status: 'failed', runId: 'rb', cwd: projectCwd }),
+    old({ slug: '900-base', status: 'completed', runId: 'rc', cwd: otherCwd }),
+  ]);
+
+  const slugs = await queueHistory.completedSlugsForCwd(projectCwd);
+  expect(slugs.has('900-base')).toBe(true);
+  expect(slugs.has('901-failed')).toBe(false);
+
+  // Same slug completed in a DIFFERENT project must not leak across.
+  const otherSlugs = await queueHistory.completedSlugsForCwd(otherCwd);
+  expect(otherSlugs.has('900-base')).toBe(true);
+  const unrelatedCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-projC-'));
+  expect((await queueHistory.completedSlugsForCwd(unrelatedCwd)).size).toBe(0);
+});
+
+test('completedSlugsForCwd: returns an empty Set when the project has no history shard yet', async () => {
+  const freshCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-fresh-'));
+  const slugs = await queueHistory.completedSlugsForCwd(freshCwd);
+  expect(slugs.size).toBe(0);
+});

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

@@ -20,6 +20,7 @@ const {
   isRetentionEnabled,
   applyRetention,
   liveKeysFromJobs,
+  runningRunIdsFromJobs,
   isLiveJob,
   runBootSweep,
 } = require('../lib/runLogRetention.cjs');
@@ -407,6 +408,64 @@ test('runBootSweep: a deletion failure (permission error) is caught, logged in r
   }
 });
 
+// ─── orphan pass: empty run directories (PRD 1120) ─────────────────────────
+
+test('runningRunIdsFromJobs: only status===running jobs with a runId are protected', () => {
+  const ids = runningRunIdsFromJobs([
+    { slug: 'a', status: 'running', runId: 'run-a' },
+    { slug: 'b', status: 'pending', runId: 'run-b' },
+    { slug: 'c', status: 'running', runId: null },
+    null,
+  ]);
+  expect(ids.has('run-a')).toBe(true);
+  expect(ids.has('run-b')).toBe(false);
+  expect(ids.size).toBe(1);
+});
+
+test('applyRetention orphan pass: an empty run directory 1 minute old is removed while a directory with a .log is retained', () => {
+  const now = Date.now();
+  // Orphan: minted by pickRunDir but the dispatch aborted before executeJob
+  // ever wrote into it — no meta.json, so scanRunEntries never sees it.
+  const orphanDir = path.join(runsDir, '2026-09-05T14-00-00-000Z');
+  fs.mkdirSync(orphanDir, { recursive: true });
+  const orphanTime = (now - 60_000) / 1000;
+  fs.utimesSync(orphanDir, orphanTime, orphanTime);
+
+  // Real run: has a .log, must survive regardless of the orphan pass.
+  makeRun('2026-09-05T15-00-00-000Z', 'real-slug', { finishedAt: now - 60_000 });
+
+  const settings = { schedulerRunLogRetention: { enabled: true, policy: { maxAgeDays: 7, keepPerSlug: 1 } } };
+  const result = applyRetention(runsDir, settings, { now, jobs: [] });
+
+  expect(result.orphanDirsRemoved).toBe(1);
+  expect(fs.existsSync(orphanDir)).toBe(false);
+  expect(fs.existsSync(path.join(runsDir, '2026-09-05T15-00-00-000Z', 'real-slug.log'))).toBe(true);
+});
+
+test('applyRetention orphan pass: skips an empty directory whose runId belongs to a currently-running job (spawn in flight)', () => {
+  const now = Date.now();
+  const inFlightRunId = '2026-09-05T16-00-00-000Z';
+  const inFlightDir = path.join(runsDir, inFlightRunId);
+  fs.mkdirSync(inFlightDir, { recursive: true });
+
+  const settings = { schedulerRunLogRetention: { enabled: true, policy: { maxAgeDays: 7, keepPerSlug: 1 } } };
+  const jobs = [{ slug: 'mid-dispatch', status: 'running', runId: inFlightRunId }];
+  const result = applyRetention(runsDir, settings, { now, jobs });
+
+  expect(result.orphanDirsRemoved).toBe(0);
+  expect(fs.existsSync(inFlightDir)).toBe(true);
+});
+
+test('applyRetention orphan pass: never runs when retention is not opted in (dry-run)', () => {
+  const now = Date.now();
+  const orphanDir = path.join(runsDir, '2020-01-01T00-00-00-000Z');
+  fs.mkdirSync(orphanDir, { recursive: true });
+
+  const result = applyRetention(runsDir, undefined, { now, jobs: [] });
+  expect(result.deleted).toBe(false);
+  expect(fs.existsSync(orphanDir)).toBe(true);
+});
+
 test('applyRetention: dry-run path (enabled=false) never reads queueStore for live protection', () => {
   const now = Date.now();
   makeRun('2020-05-01T00-00-00-000Z', 'no-touch-slug', { finishedAt: now - 400 * DAY_MS });

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

@@ -120,6 +120,7 @@ test('LEGAL_TRANSITIONS covers every real scheduler.cjs edge', () => {
     ['needs_review', 'investigating'],
     ['needs_review', 'pending'],
     ['needs_review', 'completed'],
+    ['needs_review', 'running'],
     ['completed', 'pending'],
     ['skipped', 'pending'],
   ];