claude-code-session-manager 0.39.0 → 0.39.2

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

@@ -1,7 +1,7 @@
 /**
  * runVerify.test.cjs — unit tests for the post-run reconciliation verifier.
  *
- * Run standalone: node src/main/__tests__/runVerify.test.cjs
+ * Run standalone: timeout 180 npx vitest run src/main/__tests__/runVerify.test.cjs
  *
  * Three fixture scenarios (matching the 2026-05-23→24 incident window):
  *
@@ -19,13 +19,12 @@
  *      Expected: clean → null (caller may stamp 'completed')
  */
 
-'use strict';
-
-const { test } = require('node:test');
+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 { execFileSync } = require('node:child_process');
 const { verifyRun } = require('../runVerify.cjs');
 
 // ─── helpers ──────────────────────────────────────────────────────────────────
@@ -389,6 +388,220 @@ test('FAIL recovered within 30 events → clean', async () => {
   }
 });
 
+// ─── self-recovery: sleep-prefix normalization (RCA 745-pr188-ci-lint-docs-integrity) ──
+
+/**
+ * Build N innocuous tool_use/tool_result pairs, used to push a later error
+ * event into the last-20%-of-transcript window that the is_error scan
+ * requires (parseLog counts every tool_use/tool_result as its own event).
+ */
+function paddingEvents(n) {
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    out.push({
+      type: 'assistant',
+      message: { role: 'assistant', content: [{ type: 'tool_use', id: `toolu_pad${i}`, name: 'Bash', input: { command: 'echo ok', description: `padding step ${i}` } }] },
+    });
+    out.push({
+      type: 'user',
+      message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: `toolu_pad${i}`, content: 'ok', is_error: false }] },
+    });
+  }
+  return out;
+}
+
+test('sleep-prefixed FAIL recovered by a bare retry of the same command → clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '812-sleep-prefix-recovery';
+    const logEvents = [
+      ...paddingEvents(8),
+      // First attempt: polls too early with a `sleep 20 &&` prefix, gets a
+      // pending/error result.
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_r1',
+            name: 'Bash',
+            input: {
+              command: 'sleep 20 && gh pr checks 188 --repo midt-bg/sigma 2>&1',
+              description: 'sleep 20 && gh pr checks 188 --repo midt-bg/sigma',
+            },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_r1',
+            content: 'Exit code 8\ncheck\tpending\t0\thttps://github.com/midt-bg/sigma/actions/runs/1/job/1',
+            is_error: true,
+          }],
+        },
+      },
+      // Later retry: same underlying command, no sleep prefix, succeeds.
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_r2',
+            name: 'Bash',
+            input: {
+              command: 'gh pr checks 188 --repo midt-bg/sigma 2>&1',
+              description: 'gh pr checks 188 --repo midt-bg/sigma',
+            },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_r2',
+            content: 'check\tpass\t2m16s\thttps://github.com/midt-bg/sigma/actions/runs/1/job/1',
+            is_error: false,
+          }],
+        },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+        result: 'CI is green.\nSCHEDULER_VERDICT: PASS',
+      },
+    ];
+
+    writeLog(tmp, slug, logEvents);
+    const prdPath = writePrd(tmp, slug, '# Sleep-prefix recovery test');
+
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: true,
+    });
+
+    assert.equal(verdict.verdict, 'clean', `sleep-prefix recovery should yield clean, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('normalizeDescForRecovery only strips the sleep wrapper, not unrelated text', () => {
+  const { normalizeDescForRecovery } = require('../runVerify.cjs');
+  assert.equal(
+    normalizeDescForRecovery('sleep 20 && gh pr checks 188 --repo midt-bg/sigma'),
+    'gh pr checks 188 --repo midt-bg/sigma',
+  );
+  assert.equal(
+    normalizeDescForRecovery('sleep 90; gh pr checks 188 --repo midt-bg/sigma'),
+    'gh pr checks 188 --repo midt-bg/sigma',
+  );
+  assert.equal(
+    normalizeDescForRecovery('gh pr checks 188 --repo midt-bg/sigma'),
+    'gh pr checks 188 --repo midt-bg/sigma',
+  );
+});
+
+test('two different commands, one sleep-prefixed, are not paired as recovered', () => {
+  // Exercise isSelfRecovered directly (via parseLog) rather than the full
+  // verifyRun pipeline: a SCHEDULER_VERDICT: PASS + landed commit legitimately
+  // overrides a transcript_errors finding at the verifyRun layer by design
+  // (see verifyRun's sentinel-override comment), which would mask the
+  // narrower claim this test makes — that the sleep-prefix strip alone must
+  // not pair two genuinely different commands.
+  const { isSelfRecovered, parseLog } = require('../runVerify.cjs');
+  const tmp = makeTmpDir();
+  try {
+    const slug = '812-sleep-prefix-no-false-pair';
+    const logEvents = [
+      // First attempt: sleep-prefixed poll of PR 188, fails.
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_r1',
+            name: 'Bash',
+            input: {
+              command: 'sleep 20 && gh pr checks 188 --repo midt-bg/sigma 2>&1',
+              description: 'sleep 20 && gh pr checks 188 --repo midt-bg/sigma',
+            },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_r1',
+            content: 'Exit code 8\ncheck\tpending\t0\thttps://github.com/midt-bg/sigma/actions/runs/1/job/1',
+            is_error: true,
+          }],
+        },
+      },
+      // "Retry" is actually a different command (different PR number) —
+      // after stripping the sleep wrapper it must NOT be treated as the
+      // same underlying command.
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_r2',
+            name: 'Bash',
+            input: {
+              command: 'gh pr checks 999 --repo midt-bg/sigma 2>&1',
+              description: 'gh pr checks 999 --repo midt-bg/sigma',
+            },
+          }],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_r2',
+            content: 'check\tpass\t2m16s\thttps://github.com/midt-bg/sigma/actions/runs/2/job/2',
+            is_error: false,
+          }],
+        },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+        result: 'Done.\nSCHEDULER_VERDICT: PASS',
+      },
+    ];
+
+    writeLog(tmp, slug, logEvents);
+    const { events } = parseLog(path.join(tmp, `${slug}.log`));
+    const failedToolUse = events.find((ev) => ev.kind === 'tool_use' && ev.toolUseId === 'toolu_r1');
+    assert.ok(failedToolUse, 'fixture should contain the failing tool_use event');
+
+    const recovered = isSelfRecovered(events, failedToolUse.seq, failedToolUse.description);
+    assert.equal(recovered, false, 'a differently-numbered PR check must not be treated as a recovered retry of the sleep-prefixed one');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
 // ─── fixtures: feedback 2026-06-10-01 — quoted-error false positives ─────────
 
 /** Build a one-Bash-call log: tool_use → tool_result(content) → result event. */
@@ -922,6 +1135,248 @@ test('pass_no_commit: fix-plan job (slug ^\\d+-fix-) with PASS but no commit is
   }
 });
 
+// ─── pass_no_commit_already_shipped: original PRD re-run after landing ─────
+// (incident: 655-needs-review-rca-feedback-hook, 2026-07-31)
+
+const { extractPrdDeliverablePaths, allDeliverablesAlreadyTracked } = require('../runVerify.cjs');
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+
+test('pass_no_commit: original PRD, PASS no commit, all deliverable paths already tracked in git → pass_no_commit_already_shipped', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '655-needs-review-rca-feedback-hook';
+    writeLog(tmp, slug, noOpRunEvents('Verified rcaFeedbackHook.cjs already shipped in e13168d; typecheck + tests green; no commit needed.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'Deliverables: `src/main/lib/rcaFeedbackHook.cjs` and `src/main/__tests__/rcaFeedbackHook.test.cjs`.');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit_already_shipped', `expected already-shipped exemption, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('pass_no_commit: original PRD, PASS no commit, one deliverable path untracked → falls through to pass_no_commit', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '655-needs-review-rca-feedback-hook';
+    writeLog(tmp, slug, noOpRunEvents('Nothing to do here.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'Deliverables: `src/main/lib/rcaFeedbackHook.cjs` and `src/main/lib/does-not-exist-xyz.cjs`.');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected fallback to pass_no_commit, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('pass_no_commit: original PRD, PASS no commit, zero extractable deliverable paths → falls through to pass_no_commit', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '999-some-vague-prd';
+    writeLog(tmp, slug, noOpRunEvents('Nothing to do here.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'This PRD names no file paths at all, just prose.');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected fallback to pass_no_commit, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// (incident: 812-commit-guard-retry-on-worktree-ref-visibility-delay — a
+// stale scheduler process, booted before the already-shipped exemption
+// landed, produced a false pass_no_commit for exactly this shape of re-run)
+test('pass_no_commit: commit-guard-retry PRD naming scheduler.cjs + its committed-in-window test, PASS no commit → pass_no_commit_already_shipped', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '812-commit-guard-retry-on-worktree-ref-visibility-delay';
+    writeLog(tmp, slug, noOpRunEvents('Retry + tests already present; nothing to change.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(
+      tmp,
+      slug,
+      'Deliverables: `src/main/scheduler.cjs` and `src/main/__tests__/scheduler-committed-in-window.test.cjs`.',
+    );
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit_already_shipped', `expected already-shipped exemption, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('extractPrdDeliverablePaths: extracts backticked repo-relative paths, ignores prose', () => {
+  const body = 'Deliverables: `src/main/lib/rcaFeedbackHook.cjs` and `src/main/__tests__/rcaFeedbackHook.test.cjs`. Also see node_modules/foo/bar.js which should be excluded.';
+  const paths = extractPrdDeliverablePaths(body);
+  assert.deepEqual(paths, ['src/main/lib/rcaFeedbackHook.cjs', 'src/main/__tests__/rcaFeedbackHook.test.cjs']);
+  assert.deepEqual(extractPrdDeliverablePaths(''), []);
+  assert.deepEqual(extractPrdDeliverablePaths(undefined), []);
+});
+
+test('allDeliverablesAlreadyTracked: fail-safe on empty paths, non-git cwd, and git errors', () => {
+  assert.equal(allDeliverablesAlreadyTracked({ cwd: REPO_ROOT, paths: [] }), false);
+  assert.equal(allDeliverablesAlreadyTracked({
+    cwd: REPO_ROOT,
+    paths: ['src/main/runVerify.cjs'],
+    execImpl: () => { throw new Error('boom'); },
+  }), false);
+  assert.equal(allDeliverablesAlreadyTracked({
+    cwd: REPO_ROOT,
+    paths: ['src/main/runVerify.cjs'],
+    execImpl: () => '',
+  }), true);
+});
+
+// ─── repo-root config deliverable extraction ────────────────────────────────
+// (incident: 816-vitest-register-runverify-test, 2026-07-31 — PRD named only
+// `vitest.config.ts` as its deliverable; the source-dir-only regex extracted
+// nothing, so allDeliverablesAlreadyTracked early-returned false even though
+// the config edit was already tracked in git)
+
+test('extractPrdDeliverablePaths: extracts a root-config file alongside a src path', () => {
+  const body = 'Register the test in `vitest.config.ts` and port `src/main/__tests__/runVerify.test.cjs` onto vitest.';
+  const paths = extractPrdDeliverablePaths(body);
+  assert.deepEqual(new Set(paths), new Set(['vitest.config.ts', 'src/main/__tests__/runVerify.test.cjs']));
+});
+
+test('extractPrdDeliverablePaths: root-config-only PRD body yields a non-empty result', () => {
+  const body = 'The only deliverable is `vitest.config.ts` — add the missing test.include entry.';
+  const paths = extractPrdDeliverablePaths(body);
+  assert.deepEqual(paths, ['vitest.config.ts']);
+});
+
+test('extractPrdDeliverablePaths: nested or non-allowlisted root files do not produce spurious root-config entries', () => {
+  const body = 'See `some/nested/package.json` for the dependency, and update README.md with notes.';
+  const paths = extractPrdDeliverablePaths(body);
+  assert.equal(paths.includes('package.json'), false);
+  assert.equal(paths.includes('README.md'), false);
+  assert.deepEqual(paths, []);
+});
+
+test('pass_no_commit: root-config-only PRD, PASS no commit, config already tracked → pass_no_commit_already_shipped', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '816-vitest-register-runverify-test';
+    writeLog(tmp, slug, noOpRunEvents('Registered already in vitest.config.ts; 48 tests green.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'Deliverable: register the test file in `vitest.config.ts`.');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit_already_shipped', `expected already-shipped exemption, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+// ─── pass_no_commit_prior_run_verified: re-fired slug whose PRIOR run landed ─
+// (incident: 812-workbench-review-nits-cleanup, 2026-07-31)
+
+const { isAncestorCommit } = require('../runVerify.cjs');
+const REPO_ROOT_COMMIT = execFileSync('git', ['rev-list', '--max-parents=0', 'HEAD'], {
+  cwd: REPO_ROOT, encoding: 'utf8',
+}).trim().split('\n')[0];
+
+test('pass_no_commit: PASS, no commit, priorLandedCommit is an ancestor of HEAD → pass_no_commit_prior_run_verified', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '812-workbench-review-nits-cleanup';
+    writeLog(tmp, slug, noOpRunEvents('Re-checked every AC item; all already implemented by an earlier run.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'This PRD names no deliverable paths, just prose.');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+      priorLandedCommit: REPO_ROOT_COMMIT,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit_prior_run_verified', `expected prior-run exemption, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, null);
+    assert.equal(verdict.priorLandedCommit, REPO_ROOT_COMMIT);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('pass_no_commit: PASS, no commit, priorLandedCommit is NOT an ancestor of HEAD → pass_no_commit', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '812-workbench-review-nits-cleanup';
+    writeLog(tmp, slug, noOpRunEvents('Nothing to do here.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'This PRD names no deliverable paths, just prose.');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+      priorLandedCommit: '0000000000000000000000000000000000000000',
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected fallback to pass_no_commit, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
+test('isAncestorCommit: fail-safe on missing sha and on a throwing execImpl (git error)', () => {
+  assert.equal(isAncestorCommit({ cwd: REPO_ROOT, sha: null }), false);
+  assert.equal(isAncestorCommit({
+    cwd: REPO_ROOT,
+    sha: REPO_ROOT_COMMIT,
+    execImpl: () => { throw new Error('git: command not found'); },
+  }), false);
+  assert.equal(isAncestorCommit({
+    cwd: REPO_ROOT,
+    sha: REPO_ROOT_COMMIT,
+    execImpl: () => '',
+  }), true);
+});
+
+test('pass_no_commit: PASS, no commit, priorLandedCommit not supplied (null) → pass_no_commit (regression guard)', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '812-workbench-review-nits-cleanup';
+    writeLog(tmp, slug, noOpRunEvents('Nothing to do here.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'This PRD names no deliverable paths, just prose.');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running', cwd: REPO_ROOT },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected pass_no_commit with no priorLandedCommit, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally {
+    rmdir(tmp);
+  }
+});
+
 // (e) halt + sentinel PASS → still halt (override must not apply to halt)
 test('halt result + sentinel PASS + committedDuringRun:true → still halt', async () => {
   const tmp = makeTmpDir();

package/src/main/__tests__/scheduler-admin-routes.test.cjs

@@ -47,9 +47,17 @@ function makeFakeRemote({ jobs = [] } = {}) {
     async listJobs() {
       return jobs.map((j) => ({ slug: j.slug, title: j.title, status: j.status, cwd: j.cwd }));
     },
-    async resetJob(slug) {
+    // Mirrors the real scheduler.cjs remote.resetJob's force-guard so this
+    // fake exercises the SAME contract the admin route promises callers.
+    async resetJob(slug, opts = {}) {
       const job = jobs.find((j) => j.slug === slug);
       if (!job) return { ok: false, error: 'not found' };
+      if (job.status === 'completed' && opts.force !== true) {
+        return {
+          ok: false,
+          error: 'job already completed — resetting it would re-execute shipped work; archive the PRD instead, or pass force:true',
+        };
+      }
       job.status = 'pending';
       job.runId = null;
       job.startedAt = null;
@@ -64,9 +72,15 @@ function makeFakeRemote({ jobs = [] } = {}) {
 }
 
 async function startWithRemote(remote) {
+  // Force the e2e-suffixed token path so this suite never races the real
+  // ~/.claude/session-manager/admin-api.json against other test files (or a
+  // live production instance) that also call createAdminHttp() concurrently.
+  const prevE2e = process.env.SM_E2E;
+  process.env.SM_E2E = '1';
   const admin = createAdminHttp();
   registerAdminRoutes(admin, remote);
   const { port, token } = await admin.start();
+  if (prevE2e === undefined) delete process.env.SM_E2E; else process.env.SM_E2E = prevE2e;
   return { admin, port, token };
 }
 
@@ -114,11 +128,11 @@ test('POST /admin/scheduler/reset-job without slug returns 400', async () => {
   }
 });
 
-test('POST /admin/scheduler/reset-job with known slug flips job to pending and clears run fields', async () => {
+test('POST /admin/scheduler/reset-job with known needs_review slug flips job to pending and clears run fields', async () => {
   const job = {
     slug: '10-foo',
     title: 'Foo',
-    status: 'completed',
+    status: 'needs_review',
     cwd: '/tmp/foo',
     runId: 'run-1',
     startedAt: 100,
@@ -148,3 +162,38 @@ test('POST /admin/scheduler/reset-job with known slug flips job to pending and c
     await admin.stop();
   }
 });
+
+test('POST /admin/scheduler/reset-job on a completed job without force refuses and does not mutate', async () => {
+  const job = { slug: '10-foo', title: 'Foo', status: 'completed', cwd: '/tmp/foo', runId: 'run-1' };
+  const remote = makeFakeRemote({ jobs: [job] });
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: '10-foo' },
+    });
+    expect(res.status).toBe(200);
+    expect(res.json.ok).toBe(false);
+    expect(res.json.error).toMatch(/force:true/);
+    expect(job.status).toBe('completed');
+    expect(job.runId).toBe('run-1');
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/reset-job on a completed job WITH force:true resets it', async () => {
+  const job = { slug: '10-foo', title: 'Foo', status: 'completed', cwd: '/tmp/foo', runId: 'run-1' };
+  const remote = makeFakeRemote({ jobs: [job] });
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: '10-foo', force: true },
+    });
+    expect(res.status).toBe(200);
+    expect(res.json).toEqual({ ok: true, slug: '10-foo', status: 'pending' });
+    expect(job.status).toBe('pending');
+    expect(job.runId).toBe(null);
+  } finally {
+    await admin.stop();
+  }
+});

package/src/main/__tests__/scheduler-archive-completed-prd.test.cjs

@@ -0,0 +1,102 @@
+/**
+ * scheduler-archive-completed-prd.test.cjs — unit tests for archiveCompletedPrd
+ * (PRD 812 dormant-default-session-review-nits recurrence fix): a job's PRD
+ * `.md` must move from its `prds/` dir into the SIBLING `prds-archived/` dir
+ * the moment its job transitions to `completed`, so a re-fired scheduler
+ * tick can never pick the same finished slug back up.
+ *
+ * Uses a temp cwd fixture (`prdDirForCwd` is a pure path join off `cwd`) so
+ * this never touches the real `~/.claude/session-manager/` tree.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-archive-completed-prd.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { archiveCompletedPrd, prdDirForCwd } = require('../scheduler.cjs');
+
+const tmpDirs = [];
+
+function makeFixtureCwd() {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-archive-prd-'));
+  tmpDirs.push(cwd);
+  return cwd;
+}
+
+afterEach(() => {
+  while (tmpDirs.length) {
+    const dir = tmpDirs.pop();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('archiveCompletedPrd moves the .md from prds/ into sibling prds-archived/', async () => {
+  const cwd = makeFixtureCwd();
+  const slug = 'test-archive-on-completed';
+  const prdsDir = prdDirForCwd(cwd);
+  fs.mkdirSync(prdsDir, { recursive: true });
+  const src = path.join(prdsDir, `${slug}.md`);
+  fs.writeFileSync(src, '# Goal\n\ntest\n', 'utf8');
+
+  await archiveCompletedPrd(slug, cwd);
+
+  expect(fs.existsSync(src)).toBe(false);
+  const archivedPath = path.join(prdsDir, '..', 'prds-archived', `${slug}.md`);
+  expect(fs.existsSync(archivedPath)).toBe(true);
+  expect(fs.readFileSync(archivedPath, 'utf8')).toBe('# Goal\n\ntest\n');
+});
+
+test('a job left in needs_review never has its PRD archived (the .md stays in prds/)', async () => {
+  const cwd = makeFixtureCwd();
+  const slug = 'test-no-archive-on-needs-review';
+  const prdsDir = prdDirForCwd(cwd);
+  fs.mkdirSync(prdsDir, { recursive: true });
+  const src = path.join(prdsDir, `${slug}.md`);
+  fs.writeFileSync(src, '# Goal\n\ntest\n', 'utf8');
+
+  // scheduler.cjs only calls archiveCompletedPrd from status==='completed'
+  // transition sites — a needs_review (or failed/running) transition never
+  // invokes it, so the source file is untouched.
+
+  expect(fs.existsSync(src)).toBe(true);
+  const archivedPath = path.join(prdsDir, '..', 'prds-archived', `${slug}.md`);
+  expect(fs.existsSync(archivedPath)).toBe(false);
+});
+
+test('archiveCompletedPrd is a silent no-op when the source .md is missing (ENOENT)', async () => {
+  const cwd = makeFixtureCwd();
+  const slug = 'test-archive-enoent-noop';
+  const prdsDir = prdDirForCwd(cwd);
+  fs.mkdirSync(prdsDir, { recursive: true });
+
+  await expect(archiveCompletedPrd(slug, cwd)).resolves.toBeUndefined();
+
+  const archivedPath = path.join(prdsDir, '..', 'prds-archived', `${slug}.md`);
+  expect(fs.existsSync(archivedPath)).toBe(false);
+});
+
+test('archiveCompletedPrd refuses a slug that would resolve outside the PRD dir', async () => {
+  const cwd = makeFixtureCwd();
+  const prdsDir = prdDirForCwd(cwd);
+  fs.mkdirSync(prdsDir, { recursive: true });
+
+  // A slug crafted to escape prdsDir via '..' segments (SLUG_RE normally
+  // blocks this at the IPC boundary; archiveCompletedPrd itself must still
+  // refuse it as defense-in-depth, matching schedule:clear-queue's check).
+  const outsideDir = path.join(prdsDir, '..');
+  const escapeSlug = '../escaped-outside';
+  const outsideTarget = path.join(outsideDir, 'escaped-outside.md');
+  fs.writeFileSync(outsideTarget, 'should never be touched', 'utf8');
+
+  await expect(archiveCompletedPrd(escapeSlug, cwd)).resolves.toBeUndefined();
+
+  // Untouched in place — containment check refused before any rename.
+  expect(fs.existsSync(outsideTarget)).toBe(true);
+  expect(fs.readFileSync(outsideTarget, 'utf8')).toBe('should never be touched');
+  const archivedPath = path.join(prdsDir, '..', 'prds-archived', 'escaped-outside.md');
+  expect(fs.existsSync(archivedPath)).toBe(false);
+});