claude-code-session-manager 0.79.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__/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'],
   ];

package/src/main/__tests__/scheduler-autofix-outcome.test.cjs

@@ -10,6 +10,13 @@
  * coverage in scheduler-autofix-select.test.cjs (node --test) exercises the
  * same helpers in more granular detail.
  *
+ * PRD 1129 added one sub-shape to case (d): "outcome 'plan' WITH a queue
+ * row is neither retried nor annotated" only holds while that queue row
+ * (the fix-plan child) is still alive. Once the child itself reaches a
+ * terminal, non-completed status, isFixPlanDead makes the parent eligible
+ * for exactly one further attempt (stamped autoFixReopened: true), after
+ * which it is permanently excluded and annotated again.
+ *
  * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-autofix-outcome.test.cjs
  */
 
@@ -17,7 +24,7 @@
 
 import { test, expect } from 'vitest';
 const {
-  selectAutoFixTargets, isExhaustedAutoFix, isPlanUnqueued, fixSlugFor,
+  selectAutoFixTargets, isExhaustedAutoFix, isPlanUnqueued, isFixPlanDead, fixSlugFor,
 } = require('../scheduler.cjs');
 
 const noSiblingOnDisk = () => false;
@@ -82,6 +89,71 @@ test("(d) outcome 'plan' with the fix slug present in the queue is neither retri
   expect(isAnnotatable(job, queuedSlugs)).toBe(false);
 });
 
+// (e) dead fix-plan child: outcome 'plan' whose fix-plan row itself died —
+// the parent is eligible again, exactly once.
+test('(e) a dead fix-plan child makes the parent eligible for one further attempt', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const deadChild = { slug: fixSlugFor(job), status: 'needs_review', parallelGroup: job.parallelGroup };
+  const jobs = [job, deadChild];
+  expect(isFixPlanDead(job, jobs)).toBe(true);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(true);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
+test('(e) a failed, quarantined, or skipped fix-plan child also counts as dead', () => {
+  for (const status of ['failed', 'quarantined', 'skipped']) {
+    const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+    const deadChild = { slug: fixSlugFor(job), status, parallelGroup: job.parallelGroup };
+    expect(isFixPlanDead(job, [job, deadChild])).toBe(true);
+  }
+});
+
+test('(e) an already-reopened parent is annotated, never eligible again — even with another dead child', () => {
+  const job = makeJob({
+    autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 1, autoFixReopened: true,
+  });
+  const deadChild = { slug: fixSlugFor(job), status: 'needs_review', parallelGroup: job.parallelGroup };
+  const jobs = [job, deadChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isExhaustedAutoFix(job)).toBe(true);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(true);
+});
+
+test('(e) a reopened parent whose second attempt is still in flight (outcome cleared) is untouched — not re-eligible, not yet annotated', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 1, autoFixReopened: true });
+  expect(isFixPlanDead(job, [job])).toBe(false);
+  expect(selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isExhaustedAutoFix(job)).toBe(false);
+});
+
+test('(e) a fix-plan child that is still pending leaves the parent untouched', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const pendingChild = { slug: fixSlugFor(job), status: 'pending', parallelGroup: job.parallelGroup };
+  const jobs = [job, pendingChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
+test('(e) a fix-plan child that is still running leaves the parent untouched', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const runningChild = { slug: fixSlugFor(job), status: 'running', parallelGroup: job.parallelGroup };
+  const jobs = [job, runningChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
+test('(e) a fix-plan child that completed leaves the parent untouched (unchanged from today)', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const completedChild = { slug: fixSlugFor(job), status: 'completed', parallelGroup: job.parallelGroup };
+  const jobs = [job, completedChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
 // (invariant) every needs_review job is either an auto-fix target or
 // annotatable (would receive a non-null verifierVerdict) — never both false.
 test('invariant: fresh, retry-eligible, exhausted, and plan-unqueued jobs are always selected or annotatable', () => {

package/src/main/__tests__/scheduler-autofix-select.test.cjs

@@ -308,6 +308,23 @@ test('isFixPlanBeyondDepthCap: fix-plan at depth 1 is not capped, depth 2 is', (
   assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH + 1), true);
 });
 
+// PRD 1131: classification is now provenance-aware (isFixPlan), not slug-only.
+// A legacy row with no `isFixPlan` argument at all still falls back to the
+// slug-only heuristic above (no re-classification of live history).
+
+test('isFixPlanBeyondDepthCap: a scheduler-authored fix plan (isFixPlan:true) is still classified as one and capped at the same depth', () => {
+  assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH, true), false);
+  assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH + 1, true), true);
+});
+
+test('isFixPlanBeyondDepthCap: a human-authored PRD (isFixPlan:false) whose slug merely matches "fix-" is never capped, even with no investigationDepth (PRD 1126 regression)', () => {
+  assert.strictEqual(isFixPlanBeyondDepthCap('126-fix-plan-death-reopens-parent', undefined, false), false);
+});
+
+test('isFixPlanBeyondDepthCap: a legacy row (isFixPlan argument omitted/undefined) with a fix- slug and no depth field is still treated as a fix plan via the slug fallback', () => {
+  assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', undefined, undefined), true);
+});
+
 test('healTargetForFix: depth-2 fix-of-a-fix slug resolves back to the depth-1 fix job (521-fix-recorder-export-footer-redesign)', () => {
   // Depth-1 fix job: originally authored to fix job 521, itself in needs_review.
   const depth1FixJob = {

package/src/main/__tests__/scheduler-commit-guard-noop.test.cjs

@@ -24,6 +24,7 @@
 
 import { test, expect } from 'vitest';
 const { commitGuardVerdict } = require('../scheduler.cjs');
+const { resolveIsFixPlan } = require('../lib/fixPlanSlug.cjs');
 
 test('commitGuardVerdict: legitimate no-op verdict (pass_no_commit_already_shipped) + concurrent dirt → no flag (655 incident)', () => {
   const verifyResult = {
@@ -102,6 +103,25 @@ test('commitGuardVerdict: fix-plan job (523-fix-bounded-fix-plan-retry incident)
   expect(verdict).toBeNull();
 });
 
+test('commitGuardVerdict: a zero-edit run of a human-authored PRD whose slug merely starts with "fix-" still yields silent_no_op (PRD 1131 — not exempted by name alone)', () => {
+  // Mirrors PRD 1126: authored via scheduler_create_prd (isFixPlan stamped
+  // false at reconcile time), slug happens to read "fix-...". Feeding the
+  // job's own persisted isFixPlan through resolveIsFixPlan (the same call
+  // spawnJob makes) must NOT exempt this zero-edit run from the guard.
+  const job = { slug: '126-fix-plan-death-reopens-parent', isFixPlan: false };
+  const verdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    isFixPlanJob: resolveIsFixPlan(job.slug, job.isFixPlan),
+    verifyResult: null,
+  });
+  expect(verdict).not.toBeNull();
+  expect(verdict.verdict).toBe('silent_no_op');
+  expect(verdict.downgradeTo).toBe('needs_review');
+});
+
 test('commitGuardVerdict: fix-plan job that DID leave real dirt behind is still flagged (isFixPlanJob only exempts the zero-edit case)', () => {
   const verdict = commitGuardVerdict({
     newlyDirty: ['src/main/someFeature.cjs'],