claude-code-session-manager 0.79.0 → 0.81.0

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__/rcaReport.test.cjs

@@ -240,3 +240,27 @@ test('writeRcaReport: SM_RCA_DISABLE=1 skips without writing', async () => {
   expect(res.reason).toBe('disabled');
   expect(fs.readdirSync(runDir).filter((f) => f.startsWith('root-cause-'))).toHaveLength(0);
 });
+
+test('classifyFailure: blocked_by_foreign_wip_streak verdict classifies as BLOCKED_BY_FOREIGN_WIP, never UNKNOWN', () => {
+  const failureClass = rcaReport.classifyFailure({ verdict: 'blocked_by_foreign_wip_streak', logTail: 'anything' });
+  expect(failureClass).toBe(rcaReport.FAILURE_CLASSES.BLOCKED_BY_FOREIGN_WIP);
+});
+
+test('writeRcaReport: a blocked_by_foreign_wip_streak verdict points at the sibling job, not "re-run the gate"', async () => {
+  const cwd = makeProject();
+  const runDir = path.join(tmpHome, 'run-blocked');
+  writeRun(runDir, 'blockedslug');
+  writePrd(cwd, 'blockedslug');
+
+  const res = await rcaReport.writeRcaReport({
+    job: baseJob({ cwd, slug: 'blockedslug' }),
+    runDir,
+    verdict: 'blocked_by_foreign_wip_streak',
+  });
+
+  expect(res.filed).toBe(true);
+  expect(res.failureClass).toBe(rcaReport.FAILURE_CLASSES.BLOCKED_BY_FOREIGN_WIP);
+  const body = fs.readFileSync(res.path, 'utf8');
+  expect(body).toMatch(/sibling job/i);
+  expect(body).not.toMatch(/Re-run the acceptance criteria gate/);
+});

package/src/main/__tests__/runVerify-blocked-by-foreign-wip.test.cjs

@@ -0,0 +1,58 @@
+/**
+ * runVerify-blocked-by-foreign-wip.test.cjs — scanSentinel's new
+ * BLOCKED_BY_FOREIGN_WIP token and the scanForeignWipPathsClaim evidence-line
+ * scanner (the executor-facing half of "give the executor a first-class
+ * verdict for a sibling job's in-flight file, but validate the claim").
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/runVerify-blocked-by-foreign-wip.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { scanSentinel, scanForeignWipPathsClaim } = require('../runVerify.cjs');
+
+function resultEventFor(text) {
+  return { kind: 'result', seq: 0, subtype: 'success', resultText: text };
+}
+
+test('scanSentinel: recognizes BLOCKED_BY_FOREIGN_WIP alongside PASS/FAIL', () => {
+  expect(scanSentinel(resultEventFor('SCHEDULER_VERDICT: PASS'), [])).toBe('pass');
+  expect(scanSentinel(resultEventFor('SCHEDULER_VERDICT: FAIL bad thing'), [])).toBe('fail');
+  expect(scanSentinel(resultEventFor('SCHEDULER_VERDICT: BLOCKED_BY_FOREIGN_WIP'), [])).toBe('blocked_by_foreign_wip');
+});
+
+test('scanSentinel: BLOCKED_BY_FOREIGN_WIP only matches at line start, like PASS/FAIL', () => {
+  expect(scanSentinel(resultEventFor('I saw a SCHEDULER_VERDICT: BLOCKED_BY_FOREIGN_WIP mention mid-sentence'), [])).toBe(null);
+});
+
+test('scanSentinel: falls back to the last tool_result content when no resultEvent matches', () => {
+  const events = [
+    { kind: 'tool_result', seq: 1, toolUseId: 'a', content: 'nothing here' },
+    { kind: 'tool_result', seq: 2, toolUseId: 'b', content: 'SCHEDULER_VERDICT: BLOCKED_BY_FOREIGN_WIP\nFOREIGN_WIP_PATHS: src/foo.ts' },
+  ];
+  expect(scanSentinel(null, events)).toBe('blocked_by_foreign_wip');
+});
+
+test('scanForeignWipPathsClaim: extracts a comma-separated FOREIGN_WIP_PATHS line from resultEvent', () => {
+  const text = 'SCHEDULER_VERDICT: BLOCKED_BY_FOREIGN_WIP\nFOREIGN_WIP_PATHS: src/foo.ts, src/bar.ts';
+  expect(scanForeignWipPathsClaim(resultEventFor(text), [])).toEqual(['src/foo.ts', 'src/bar.ts']);
+});
+
+test('scanForeignWipPathsClaim: dedupes and trims whitespace', () => {
+  const text = 'FOREIGN_WIP_PATHS:  src/foo.ts ,src/foo.ts, src/bar.ts ';
+  expect(scanForeignWipPathsClaim(resultEventFor(text), [])).toEqual(['src/foo.ts', 'src/bar.ts']);
+});
+
+test('scanForeignWipPathsClaim: returns [] when no FOREIGN_WIP_PATHS line is present', () => {
+  expect(scanForeignWipPathsClaim(resultEventFor('SCHEDULER_VERDICT: FAIL nope'), [])).toEqual([]);
+  expect(scanForeignWipPathsClaim(null, [])).toEqual([]);
+});
+
+test('scanForeignWipPathsClaim: falls back to the last tool_result content', () => {
+  const events = [
+    { kind: 'tool_result', seq: 1, toolUseId: 'a', content: 'FOREIGN_WIP_PATHS: src/stale.ts' },
+    { kind: 'tool_result', seq: 2, toolUseId: 'b', content: 'FOREIGN_WIP_PATHS: src/latest.ts' },
+  ];
+  expect(scanForeignWipPathsClaim(null, events)).toEqual(['src/latest.ts']);
+});

package/src/main/__tests__/runVerify-policy-denial.test.cjs

@@ -0,0 +1,89 @@
+/**
+ * runVerify-policy-denial.test.cjs — a PreToolUse hook denial (`Blocked: ...`
+ * tool_result) must not downgrade an otherwise-clean run, but a genuine
+ * late-run failure must still downgrade normally.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/runVerify-policy-denial.test.cjs
+ */
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { verifyRun } = require('../runVerify.cjs');
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'run-verify-policy-denial-test-'));
+}
+
+function rmdir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writeLog(dir, slug, events) {
+  const lines = ['[scheduler] starting ' + slug + ' at 2026-09-02T00:00:00.000Z'];
+  for (const ev of events) lines.push(JSON.stringify(ev));
+  lines.push('[scheduler] exit code=0 (raw code=0 signal=null) duration=47s');
+  fs.writeFileSync(path.join(dir, `${slug}.log`), lines.join('\n') + '\n');
+}
+
+function writePrd(dir, slug, body) {
+  const text = `---\ntitle: Test PRD\ncwd: /tmp\nestimateMinutes: 30\n---\n${body}\n`;
+  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
+  return path.join(dir, `${slug}.md`);
+}
+
+test('PreToolUse policy denial (Blocked: ...) in final 20% → clean, surfaced as annotation', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1106-policy-denial-exempt';
+    const events = [];
+    for (let k = 0; k < 8; k++) {
+      events.push({ type: 'assistant', message: { role: 'assistant', content: [
+        { type: 'tool_use', id: `t${k}`, name: 'Read', input: { description: `read ${k}` } }] } });
+      events.push({ type: 'user', message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: `t${k}`, content: 'ok', is_error: false }] } });
+    }
+    events.push({ type: 'assistant', message: { role: 'assistant', content: [
+      { type: 'tool_use', id: 'tgit', name: 'Bash', input: { command: 'git stash', description: 'stash before checkout' } }] } });
+    events.push({ type: 'user', message: { role: 'user', content: [
+      { type: 'tool_result', tool_use_id: 'tgit',
+        content: 'Blocked: `stash` in what this hook believes is a SHARED working tree (/home/bilko/Projects/session-manager).',
+        is_error: true }] } });
+    events.push({ type: 'result', subtype: 'success', result: 'All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS' });
+
+    writeLog(tmp, slug, events);
+    const prdPath = writePrd(tmp, slug, '# Policy denial exempt');
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
+    assert.equal(verdict.verdict, 'clean', `policy denial must not flag, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.ok(
+      Array.isArray(verdict.annotations) && verdict.annotations.some((a) => a.verdict === 'policy_denial'),
+      `expected a policy_denial annotation, got ${JSON.stringify(verdict.annotations)}`,
+    );
+  } finally { rmdir(tmp); }
+});
+
+test('genuine late-run failure (not a policy denial) still downgrades to transcript_errors', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '1106-genuine-failure-still-flags';
+    const events = [];
+    for (let k = 0; k < 8; k++) {
+      events.push({ type: 'assistant', message: { role: 'assistant', content: [
+        { type: 'tool_use', id: `t${k}`, name: 'Read', input: { description: `read ${k}` } }] } });
+      events.push({ type: 'user', message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: `t${k}`, content: 'ok', is_error: false }] } });
+    }
+    events.push({ type: 'assistant', message: { role: 'assistant', content: [
+      { type: 'tool_use', id: 'ttest', name: 'Bash', input: { command: 'npm test', description: 'run tests' } }] } });
+    events.push({ type: 'user', message: { role: 'user', content: [
+      { type: 'tool_result', tool_use_id: 'ttest', content: 'FAILED: 1 test failed', is_error: true }] } });
+    events.push({ type: 'result', subtype: 'success', result: 'All acceptance criteria verified.' });
+
+    writeLog(tmp, slug, events);
+    const prdPath = writePrd(tmp, slug, '# Genuine failure still flags');
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
+    assert.equal(verdict.verdict, 'transcript_errors', `genuine failure must still flag, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally { rmdir(tmp); }
+});

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-already-satisfied-on-main.test.cjs

@@ -0,0 +1,105 @@
+/**
+ * scheduler-already-satisfied-on-main.test.cjs — PRD 1136.
+ *
+ * Two live rows (1133-reaper-must-verify-integration-before-completed,
+ * 1134-land-stranded-sm-job-branches) were false-negatived on 2026-09-06:
+ * their work had already landed on main before their runs dispatched, so
+ * each run exited 0, made no commit, and left a clean tree — the exact
+ * 'silent_no_op' shape commitGuardVerdict parks as needs_review ("finish
+ * protocol incomplete"). Both then auto-minted a redundant `-fix-` child
+ * queued to re-do already-shipped work.
+ *
+ * This exercises the full finalize decision chain — commitGuardVerdict
+ * (unchanged) feeding resolveCommitGuardOutcome (new) — entirely at the
+ * pure-function level, per standards.md's TDD guidance and the PRD's own
+ * implementation note to prefer a pure isAlreadySatisfiedOnMain-style helper
+ * over driving the whole spawnJob pipeline.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-already-satisfied-on-main.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { commitGuardVerdict, selectAutoFixTargets } = require('../scheduler.cjs');
+const { resolveCommitGuardOutcome, isAlreadySatisfiedOnMain } = require('../lib/reaperHelpers.cjs');
+
+const noSiblingOnDisk = () => false;
+
+// AC 1: exit 0 / no commit / clean tree, with a commit on main newer than
+// queuedAt touching the PRD's declared paths → completed, naming the sha.
+test('silent_no_op + a satisfying commit on main → completed-shaped verdict naming the sha, not needs_review', () => {
+  const guardVerdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    isFixPlanJob: false,
+    verifyResult: null,
+  });
+  expect(guardVerdict.verdict).toBe('silent_no_op'); // sanity: this is the shape 1133/1134 hit
+
+  const outcome = resolveCommitGuardOutcome(guardVerdict, ['5de4134abc123']);
+  expect(outcome.verdict).toBe('already_satisfied_on_main');
+  expect(outcome.verdict).not.toBe('needs_review');
+  expect(outcome.satisfyingSha).toBe('5de4134abc123');
+  expect(outcome.reason).toMatch(/5de4134abc123/);
+});
+
+// AC 2: the inverse — same clean-tree/no-commit shape, but NO commit on main
+// satisfies it → still parks as the existing 'finish protocol incomplete'
+// verdict. The gate must not be weakened into always-passing.
+test('silent_no_op + NO satisfying commit on main → unchanged silent_no_op verdict, still parks needs_review', () => {
+  const guardVerdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    isFixPlanJob: false,
+    verifyResult: null,
+  });
+
+  const outcome = resolveCommitGuardOutcome(guardVerdict, []);
+  expect(outcome).toBe(guardVerdict); // untouched — same object, not just same shape
+  expect(outcome.verdict).toBe('silent_no_op');
+  expect(outcome.downgradeTo).toBe('needs_review');
+  expect(outcome.reason).toMatch(/finish protocol incomplete/);
+});
+
+test('resolveCommitGuardOutcome never touches the uncommitted_changes shape, satisfied or not', () => {
+  const guardVerdict = commitGuardVerdict({
+    newlyDirty: ['src/main/someFeature.cjs'],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    verifyResult: null,
+  });
+  expect(guardVerdict.verdict).toBe('uncommitted_changes');
+
+  const outcome = resolveCommitGuardOutcome(guardVerdict, ['5de4134abc123']);
+  expect(outcome).toBe(guardVerdict);
+  expect(outcome.verdict).toBe('uncommitted_changes');
+});
+
+test('resolveCommitGuardOutcome: null guardVerdict (no violation) passes through as null', () => {
+  expect(resolveCommitGuardOutcome(null, ['5de4134'])).toBeNull();
+});
+
+// AC 3: a job terminalised via the already-satisfied path never becomes a
+// fix-plan target — selectAutoFixTargets only ever considers needs_review
+// rows, and the already-satisfied path never produces one.
+test('a job whose status is completed (the already-satisfied outcome) is never selected for an auto-fix child', () => {
+  const jobs = [{
+    slug: '1133-reaper-must-verify-integration-before-completed',
+    status: 'completed',
+    runId: '2026-09-06T13-03-00-000Z',
+    verifierVerdict: 'already_satisfied_on_main',
+  }];
+  const targets = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  expect(targets).toEqual([]);
+});
+
+test('isAlreadySatisfiedOnMain picks the newest (first) satisfying commit when several land', () => {
+  const verdict = isAlreadySatisfiedOnMain(['newest111', 'older222']);
+  expect(verdict.sha).toBe('newest111');
+});