claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-looks-done.test.cjs

@@ -1,537 +0,0 @@
-/**
- * scheduler-looks-done.test.cjs — PRD 1102.
- *
- * reverifyNeedsReview() used to have two hard limits that left real, finished
- * work parked red forever: (1) isRescanCandidate required status ===
- * 'needs_review' — a `failed` row was never revisited at all; (2)
- * committedInWindow only looked inside [startedAt, finishedAt+60s], missing a
- * commit that landed later (a retry, a sibling run, a human). This tests the
- * widened pass: a `failed` row whose failure is unverified-shaped (no result
- * event at all — classifyRunOutcome === 'no_result') is now a rescan
- * candidate, and any candidate with a POST-window commit touching its own
- * declared paths gets annotated `looksDone` for a human — never auto-
- * completed. A `failed` row with a genuine result event (a real red gate) must
- * stay excluded, and the pre-existing needs_review heal path must be
- * unaffected.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — see
- * scheduler-reap-dead-running-jobs.test.cjs's comment for why (every path
- * this code touches is baked into a top-level const from os.homedir() at
- * require time).
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-looks-done.test.cjs
- */
-
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { execFileSync } = require('node:child_process');
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'looks-done-test-'));
-process.env.HOME = tmpHome;
-// reverifyNeedsReview's own auto-fix pass (PRD 1414 root cause): a
-// needs_review row with autoFixAttempted:true is still RETRY-eligible
-// (selectAutoFixTargets) whenever autoFixOutcome is unset/'no-plan'/'error'
-// and autoFixRetries < 1 — exactly this file's PRD-1136 fixture. reverify
-// then calls spawnInvestigation(job, ...) FIRE-AND-FORGET (no `await`, only
-// `.catch()`), so it keeps running real disk/git I/O in the background after
-// reverifyNeedsReview() (and the test awaiting it) returns. Under
-// `npm run test:unit`'s full-suite load that background work sometimes had
-// enough real time to run before this file's own assertions/next test read
-// queue.json, and was observed re-discovering '30-example' as an unstamped
-// PRD and quarantining it out from under this test (confirmed via a captured
-// failure: 'quarantining unstamped PRD 30-example ... no createdVia
-// provenance'). This file's own tests only assert reverifyNeedsReview's
-// direct return value / queue mutations, never spawnInvestigation's, so
-// disable auto-fix the same way sibling scheduler test files already do
-// (e.g. scheduler-shard-quarantine.test.cjs).
-process.env.SM_AUTOFIX_DISABLE = '1';
-
-const { reverifyNeedsReview, computeLooksDone, applyNeedsReviewAutoResolve, findSatisfyingCommitOnMain } = require('../scheduler.cjs');
-const { resolveEpicPrdWriteDir } = require('../lib/prdLocations.cjs');
-const { bustCwdCache } = require('../lib/queueStore.cjs');
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-function initRepo(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-// -b main pins the branch name regardless of the host's init.defaultBranch
-// config — findSatisfyingCommitOnMain's tests need a deterministic 'main' ref.
-function initRepoOnMain(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q', '-b', 'main'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-function commitFile(dir, relPath, content, message) {
-  const abs = path.join(dir, relPath);
-  fs.mkdirSync(path.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, content);
-  git(['add', relPath], dir);
-  git(['commit', '-q', '-m', message], dir);
-}
-
-function registerActiveProject(cwd, slug) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, slug);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-  bustCwdCache();
-}
-
-function writeProjectQueue(cwd, jobs) {
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
-  return path.join(stateDir, 'queue.json');
-}
-
-function writeRunLog(runId, slug, lines) {
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-  fs.writeFileSync(path.join(runDir, `${slug}.log`), lines.join('\n') + '\n');
-}
-
-// Epic-scoped, not the legacy flat prds/ dir: the flat dir is retired and
-// swept into prds-archived/ by consolidateFlatPrds the moment a job is no
-// longer live (pending/running/needs_review/investigating), which would
-// strand a row that starts 'failed' before reverifyNeedsReview ever gets a
-// chance to decide anything about it.
-function writePrd(cwd, slug, body) {
-  const dir = resolveEpicPrdWriteDir(cwd, 'test-fixture-epic');
-  fs.mkdirSync(dir, { recursive: true });
-  const text = `---\ntitle: Test PRD\ncwd: ${cwd}\nestimateMinutes: 30\n---\n${body}\n`;
-  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
-}
-
-// A job reverifyNeedsReview() heals to 'completed' has its PRD archived
-// immediately (archiveCompletedPrd) and its row backfilled to history.jsonl
-// + dropped from queue.json on the very same reconcile pass — see
-// scheduler-reconcile-history-backfill.test.cjs. Look in both places.
-function readTerminalRow(queuePath, projectCwd, slug) {
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  const row = jobs.find((j) => j.slug === slug);
-  if (row) return row;
-  const historyPath = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'state', 'history.jsonl');
-  if (!fs.existsSync(historyPath)) return undefined;
-  const lines = fs.readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
-  return lines.map((l) => JSON.parse(l)).reverse().find((j) => j.slug === slug);
-}
-
-async function wait(ms) {
-  await new Promise((r) => setTimeout(r, ms));
-}
-
-// Every test in this file shares ONE tmpHome (see the module-level mkdtempSync
-// above) and most call reverifyNeedsReview(), which scans EVERY project
-// registered under tmpHome/.claude/projects — not just the one this test just
-// wrote (queueStore.cjs's stateCwds unions allProjectCwds()+activeProjectCwds()
-// across the whole HOME). Without this cleanup, each later test's
-// reverifyNeedsReview() call re-processes every earlier test's already-settled
-// fixture row too (confirmed via full-suite stdout: the PRD-1136 test's own
-// reverifyNeedsReview() call was observed re-running auto-fix bookkeeping for
-// 171-example, a prior test's row), and each re-processed candidate costs 1+
-// real `git` subprocess calls (fetchAllRefs, committedInWindow, ...). That
-// backlog only grows as more tests run, so a later test's single
-// reverifyNeedsReview() call does correspondingly more child-process I/O — on
-// a loaded `npm run test:unit` worker pool this cumulative latency is what
-// occasionally pushes a later test toward vitest's 15s per-test budget
-// (vitest.config.ts documents the same class of load-timeout elsewhere),
-// while the file passes in ~10s alone with nothing to accumulate. Wiping the
-// registry after each test bounds every reverifyNeedsReview() call to just
-// that test's own row(s), removing the cross-test amplification.
-afterEach(() => {
-  fs.rmSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true, force: true });
-  bustCwdCache();
-});
-
-test('failed + no result event (unverified-shaped) + later commit touching declared path → looksDone, transitions to needs_review', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-171');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-171-slug');
-  writePrd(projectCwd, '171-example', [
-    '# Implementation notes',
-    'Edit `src/foo.js`.',
-  ].join('\n'));
-
-  const startedAt = new Date().toISOString();
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug: '171-example',
-      status: 'failed',
-      cwd: projectCwd,
-      runId: 'run-171',
-      startedAt,
-      finishedAt: new Date().toISOString(),
-      error: 'reaped: process gone (outcome=no_result) (outcome=no_result)',
-    },
-  ]);
-  writeRunLog('run-171', '171-example', ['[scheduler] starting 171-example']); // no result event
-
-  await wait(1100); // git --since has 1s resolution
-  // Must name this job's own slug to be attributable (see
-  // attributeLandedCommits's 'slug trailer' rule) — path overlap alone is no
-  // longer evidence.
-  commitFile(projectCwd, 'src/foo.js', 'hello', 'fix 171-example');
-
-  await reverifyNeedsReview();
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  assert.equal(jobs.length, 1);
-  assert.equal(jobs[0].status, 'needs_review', 'looksDone never auto-completes — only surfaces for a human');
-  assert.ok(jobs[0].looksDone, 'expected a looksDone annotation');
-  assert.equal(jobs[0].looksDone.commits.length, 1);
-  assert.equal(jobs[0].looksDone.rule, 'slug trailer');
-  assert.deepEqual(jobs[0].looksDone.paths, ['src/foo.js']);
-  assert.match(jobs[0].error, /looks done \(slug trailer\) — 1 commit/);
-});
-
-test('failed + a real result event (genuine gate failure) → not a candidate, stays failed untouched', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-real-fail');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-real-fail-slug');
-  writePrd(projectCwd, '05-real-fail', [
-    '# Implementation notes',
-    'Edit `src/bar.js`.',
-  ].join('\n'));
-
-  const startedAt = new Date().toISOString();
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug: '05-real-fail',
-      status: 'failed',
-      cwd: projectCwd,
-      runId: 'run-real-fail',
-      startedAt,
-      finishedAt: new Date().toISOString(),
-      error: 'AC gate red: tests failed',
-    },
-  ]);
-  writeRunLog('run-real-fail', '05-real-fail', [
-    '[scheduler] starting 05-real-fail',
-    JSON.stringify({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'tests failed' }),
-  ]);
-
-  await wait(1100);
-  commitFile(projectCwd, 'src/bar.js', 'hello', 'unrelated later commit touching the declared path');
-
-  await reverifyNeedsReview();
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  assert.equal(jobs.length, 1);
-  assert.equal(jobs[0].status, 'failed', 'a genuine red gate must never become a heal candidate');
-  assert.equal(jobs[0].looksDone, undefined);
-  assert.equal(jobs[0].error, 'AC gate red: tests failed');
-});
-
-test('needs_review with an in-window commit heals exactly as today (regression — unchanged heal semantics)', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-heals-today');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-heals-today-slug');
-  writePrd(projectCwd, '20-clean-feature', [
-    '# Acceptance criteria',
-    '- [ ] `npm test` passes',
-  ].join('\n'));
-
-  // Window opens a minute back: the only commit here is initRepo's, and git's --since
-  // compares whole seconds, so `new Date()` (taken AFTER initRepo) drops it out of the
-  // window whenever the clock crosses a second boundary under load.
-  const startedAt = new Date(Date.now() - 60_000).toISOString();
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug: '20-clean-feature',
-      status: 'needs_review',
-      cwd: projectCwd,
-      runId: 'run-clean',
-      startedAt,
-      finishedAt: new Date().toISOString(),
-      verifierVerdict: 'transcript_errors',
-      error: 'transcript_errors: stale verdict',
-    },
-  ]);
-  writeRunLog('run-clean', '20-clean-feature', [
-    '[scheduler] starting 20-clean-feature',
-    JSON.stringify({
-      type: 'assistant',
-      message: { role: 'assistant', content: [{ type: 'tool_use', id: 'toolu_1', name: 'Bash', input: { command: 'npm test' } }] },
-    }),
-    JSON.stringify({
-      type: 'user',
-      message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'toolu_1', content: 'all tests passed' }] },
-    }),
-    'SCHEDULER_VERDICT: PASS',
-    '[scheduler] exit code=0 (raw code=0 signal=null) duration=10s',
-  ]);
-
-  await reverifyNeedsReview();
-
-  const row = readTerminalRow(queuePath, projectCwd, '20-clean-feature');
-  assert.ok(row, 'healed job must be found in queue.json or (once archived+backfilled) history.jsonl');
-  assert.equal(row.status, 'completed', 'a clean re-verify on a RESCANNABLE verdict must still heal');
-  assert.equal(row.verifierVerdict, undefined);
-  assert.equal(row.error, null);
-});
-
-test('computeLooksDone: no declared paths on the PRD → null, never fabricates evidence', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-no-paths');
-  initRepo(projectCwd);
-  writePrd(projectCwd, '09-no-paths', [
-    '# Implementation notes',
-    'Just prose here, no backticked file paths.',
-  ].join('\n'));
-
-  const startedAt = new Date().toISOString();
-  await wait(1100);
-  commitFile(projectCwd, 'src/whatever.js', 'x', 'some later commit');
-
-  const job = { slug: '09-no-paths', cwd: projectCwd, startedAt };
-  const looksDone = await computeLooksDone(job);
-  assert.equal(looksDone, null);
-});
-
-test('needs_review row with autoFixAttempted:true is never also stamped looksDone (PRD 1136 — mutually exclusive)', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-already-fix-planned');
-  initRepo(projectCwd);
-  writePrd(projectCwd, '30-example', [
-    '# Implementation notes',
-    'Edit `src/thing.js`.',
-  ].join('\n'));
-
-  // startedAt/finishedAt are fixed well in the past so the real-time commit
-  // below lands outside committedInWindow's [startedAt, finishedAt+60s]
-  // window — otherwise the pre-existing heal pass would auto-complete the
-  // row before ever reaching the stillOpen/looksDone branch this test
-  // targets (committedInWindow, unlike computeLooksDone's landedSinceRun,
-  // has no upper bound skip).
-  const startedAt = '2020-01-01T00:00:00.000Z';
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug: '30-example',
-      status: 'needs_review',
-      cwd: projectCwd,
-      runId: 'run-30',
-      startedAt,
-      finishedAt: '2020-01-01T00:05:00.000Z',
-      verifierVerdict: 'transcript_errors',
-      error: 'transcript_errors: stale verdict',
-      // A fix-plan child was already minted for this row at finalize time —
-      // the exact ordering that always precedes a later reverifyNeedsReview
-      // pass, since autoFixAttempted is stamped synchronously in the same
-      // mutate() as the needs_review transition itself.
-      autoFixAttempted: true,
-    },
-  ]);
-  writeRunLog('run-30', '30-example', [
-    '[scheduler] starting 30-example',
-    JSON.stringify({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'still broken' }),
-  ]);
-
-  // Register LAST: the project only becomes discoverable once its PRD and queue row both
-  // exist, so a straggling background reconcile from an earlier test can't see the PRD
-  // without its row and mint a 'quarantined' adopt row over this needs_review one.
-  registerActiveProject(projectCwd, 'proj-already-fix-planned-slug');
-
-  commitFile(projectCwd, 'src/thing.js', 'hello', 'later commit touching the declared path');
-
-  await reverifyNeedsReview();
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  assert.equal(jobs.length, 1);
-  assert.equal(jobs[0].status, 'needs_review');
-  assert.equal(jobs[0].looksDone, undefined, 'a row already fix-planned must never also be stamped looksDone');
-  assert.equal(jobs[0].error, 'transcript_errors: stale verdict', 'the looksDone annotation must not overwrite the original error');
-});
-
-// findSatisfyingCommitOnMain — PRD 1136's already-satisfied-on-main evidence
-// query. Requires EVERY declared path to have landed on main since
-// queuedAt, not just one — a code-review finding (2026-09-07) confirmed
-// that a PRD citing both its real target file and a second file purely as
-// context (e.g. a `path/to/file.js:123` reference) would otherwise
-// auto-complete unattended off any unrelated commit touching only that
-// second, incidental file.
-
-test('findSatisfyingCommitOnMain: single declared path, satisfying commit lands on main → returns the sha', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-satisfied-single-path');
-  initRepoOnMain(projectCwd);
-  registerActiveProject(projectCwd, 'proj-satisfied-single-path-slug');
-  writePrd(projectCwd, '40-single-path', [
-    '# Implementation notes',
-    'Edit `src/real-work.js`.',
-  ].join('\n'));
-
-  const queuedAt = new Date().toISOString();
-  await wait(1100);
-  commitFile(projectCwd, 'src/real-work.js', 'hello', 'fix real-work');
-
-  const job = { slug: '40-single-path', cwd: projectCwd, queuedAt };
-  const commits = await findSatisfyingCommitOnMain(job);
-  assert.equal(commits.length, 1);
-});
-
-test('findSatisfyingCommitOnMain: two declared paths but only ONE lands → [] (not satisfied — no false completion off an incidental context citation)', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-satisfied-partial-path');
-  initRepoOnMain(projectCwd);
-  registerActiveProject(projectCwd, 'proj-satisfied-partial-path-slug');
-  writePrd(projectCwd, '41-partial-path', [
-    '# Implementation notes',
-    'Edit `src/real-work.js`. See `src/main/hotfile.js:123` for context.',
-  ].join('\n'));
-
-  const queuedAt = new Date().toISOString();
-  await wait(1100);
-  // Only the incidentally-cited context file gets a later, UNRELATED commit
-  // — the actual target path (src/real-work.js) never lands.
-  commitFile(projectCwd, 'src/main/hotfile.js', 'unrelated change', 'unrelated commit');
-
-  const job = { slug: '41-partial-path', cwd: projectCwd, queuedAt };
-  const commits = await findSatisfyingCommitOnMain(job);
-  assert.deepEqual(commits, [], 'partial path coverage must never be treated as satisfied');
-});
-
-test('findSatisfyingCommitOnMain: two declared paths, BOTH land → returns satisfying commits', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-satisfied-both-paths');
-  initRepoOnMain(projectCwd);
-  registerActiveProject(projectCwd, 'proj-satisfied-both-paths-slug');
-  writePrd(projectCwd, '42-both-paths', [
-    '# Implementation notes',
-    'Edit `src/real-work.js` and `src/main/hotfile.js`.',
-  ].join('\n'));
-
-  const queuedAt = new Date().toISOString();
-  await wait(1100);
-  commitFile(projectCwd, 'src/real-work.js', 'hello', 'fix real-work');
-  commitFile(projectCwd, 'src/main/hotfile.js', 'hello', 'fix hotfile too');
-
-  const job = { slug: '42-both-paths', cwd: projectCwd, queuedAt };
-  const commits = await findSatisfyingCommitOnMain(job);
-  assert.ok(commits.length >= 1, 'full path coverage must be treated as satisfied');
-});
-
-test('findSatisfyingCommitOnMain: no queuedAt on the job → [] without querying git', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-no-queued-at');
-  initRepoOnMain(projectCwd);
-  registerActiveProject(projectCwd, 'proj-no-queued-at-slug');
-  writePrd(projectCwd, '43-no-queued-at', [
-    '# Implementation notes',
-    'Edit `src/thing.js`.',
-  ].join('\n'));
-
-  const job = { slug: '43-no-queued-at', cwd: projectCwd };
-  const commits = await findSatisfyingCommitOnMain(job);
-  assert.deepEqual(commits, []);
-});
-
-test('computeLooksDone: non-git cwd → null without throwing (git-unavailable)', async () => {
-  const notARepo = fs.mkdtempSync(path.join(tmpHome, 'not-a-repo-'));
-  writePrd(notARepo, '11-no-repo', [
-    '# Implementation notes',
-    'Edit `src/thing.js`.',
-  ].join('\n'));
-
-  const job = { slug: '11-no-repo', cwd: notARepo, startedAt: new Date().toISOString() };
-  const looksDone = await computeLooksDone(job);
-  assert.equal(looksDone, null);
-});
-
-// --- Attribution regression (PRD 1204/1205 incident, 2026-09-13) ---
-//
-// Two PRDs in the SAME Epic declaring the same hot file: sibling job B lands
-// a commit on that path while job A is parked in needs_review. Path overlap
-// alone must never read as job A's own evidence — that's exactly how 1204's
-// row cited 1205's commit 5dadf3c as "looks done" while 1204's real
-// implementing commit (164184e) sat unnoticed.
-
-test('sibling PRD commit on the same declared path is not attributable — computeLooksDone returns null, applyNeedsReviewAutoResolve never promotes to completed', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-1204-sibling-incident');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-1204-sibling-incident-slug');
-  writePrd(projectCwd, '1204-job-a', [
-    '# Implementation notes',
-    'Edit `src/main/scheduler.cjs`.',
-  ].join('\n'));
-
-  const startedAt = new Date().toISOString();
-  await wait(1100);
-  // Sibling job B's commit: touches job A's declared path, but names neither
-  // job A's slug nor any `sm-job/1204-job-a` branch, and job A's row carries
-  // no landedCommit of its own.
-  commitFile(projectCwd, 'src/main/scheduler.cjs', 'sibling change', 'feat(scheduler): restructure the backlog into Epic groups (1205-job-b)');
-
-  const jobA = {
-    slug: '1204-job-a',
-    cwd: projectCwd,
-    status: 'needs_review',
-    startedAt,
-    autoFixAttempted: true,
-    autoFixOutcome: 'no-plan',
-    autoFixRetries: 1,
-    exhaustedResolveAttempts: 0,
-    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 45 * 60_000).toISOString() }],
-  };
-
-  const looksDone = await computeLooksDone(jobA);
-  assert.equal(looksDone, null, 'a sibling\'s path-overlapping commit must never be credited as job A\'s own evidence');
-
-  const outcome = applyNeedsReviewAutoResolve(jobA);
-  assert.equal(outcome, 'requeued', 'with no attributable evidence, the row must fall through to the existing requeue path, never complete');
-  assert.equal(jobA.status, 'pending');
-});
-
-test('this job\'s OWN attributable commit (landedCommit) still produces looksDone and still promotes to completed', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-1204-own-commit');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-1204-own-commit-slug');
-  writePrd(projectCwd, '1204-job-a2', [
-    '# Implementation notes',
-    'Edit `src/main/scheduler.cjs`.',
-  ].join('\n'));
-
-  const startedAt = new Date().toISOString();
-  await wait(1100);
-  // A sibling commit lands on the same path first...
-  commitFile(projectCwd, 'src/main/scheduler.cjs', 'sibling change', 'feat(scheduler): unrelated sibling work');
-  // ...then this job's OWN commit lands, exactly as spawnJob's finalize step
-  // would have recorded it on job.landedCommit.
-  commitFile(projectCwd, 'src/main/scheduler.cjs', 'this job\'s own change', 'fix(scheduler): attribution fix');
-  const ownSha = git(['rev-parse', 'HEAD'], projectCwd).trim();
-
-  const jobA = {
-    slug: '1204-job-a2',
-    cwd: projectCwd,
-    status: 'needs_review',
-    startedAt,
-    landedCommit: ownSha,
-    autoFixAttempted: true,
-    autoFixOutcome: 'no-plan',
-    autoFixRetries: 1,
-    exhaustedResolveAttempts: 0,
-    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 45 * 60_000).toISOString() }],
-  };
-
-  const looksDone = await computeLooksDone(jobA);
-  assert.ok(looksDone, 'this job\'s own landedCommit must be recognized as attributable evidence');
-  assert.equal(looksDone.rule, 'landedCommit');
-  assert.deepEqual(looksDone.commits, [ownSha], 'only this job\'s own commit is evidence — never the sibling\'s');
-
-  jobA.looksDone = looksDone;
-  const outcome = applyNeedsReviewAutoResolve(jobA);
-  assert.equal(outcome, 'completed', 'strong, attributable evidence must still promote the row');
-  assert.equal(jobA.status, 'completed');
-});

package/src/main/__tests__/scheduler-manual-pause.test.cjs

@@ -1,118 +0,0 @@
-/**
- * scheduler-manual-pause.test.cjs — user-initiated pause (schedule:pause /
- * POST /admin/scheduler/pause). A 'manual' pause stops NEW dispatch, never
- * kills running jobs, survives restart, and is cleared only by an explicit
- * Resume / Run now — never by the rate-limit reset timer or network recovery.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-manual-pause.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, beforeEach } 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;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-manual-pause-'));
-  process.env.HOME = tmpHome;
-  process.env.SM_JOB_WORKTREE_DISABLE = '1';
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  delete process.env.SM_JOB_WORKTREE_DISABLE;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-beforeEach(async () => {
-  await scheduler.clearPause('manual');
-});
-
-test('pause engages reason "manual" with no resumeAt, even inside the manual-override cooldown', async () => {
-  await scheduler.clearPause('manual'); // starts the 5-minute cooldown
-  await scheduler.setPaused('manual', null);
-  const state = await queueStore.readMerged();
-  expect(state.paused).toBeTruthy();
-  expect(state.paused.reason).toBe('manual');
-  expect(state.paused.resumeAt).toBeNull();
-});
-
-test('a manual pause never arms a resume time, even if a resumeAt is supplied', async () => {
-  await scheduler.setPaused('manual', new Date(Date.now() + 3_600_000).toISOString());
-  const state = await queueStore.readMerged();
-  expect(state.paused.resumeAt).toBeNull();
-});
-
-test('pause blocks tickQueue dispatch', async () => {
-  await scheduler.setPaused('manual', null);
-  const result = await scheduler.tickQueue();
-  expect(result.fired).toBe(false);
-  expect(result.reason).toBe('paused');
-});
-
-test('an auto rate_limit / network / auth pause cannot displace a manual pause', async () => {
-  await scheduler.setPaused('manual', null);
-  await scheduler.setPaused('rate_limit', new Date(Date.now() + 3_600_000).toISOString());
-  await scheduler.setPaused('network', null);
-  await scheduler.setPaused('auth', null);
-  const state = await queueStore.readMerged();
-  expect(state.paused.reason).toBe('manual');
-  expect(state.paused.resumeAt).toBeNull();
-});
-
-test('poll recovery and the resume-time computation never clear/arm a manual pause', () => {
-  expect(scheduler.pollRecoveryClearSource('manual', true)).toBeNull();
-  expect(scheduler.pollRecoveryClearSource('manual', false)).toBeNull();
-  expect(scheduler.computeEffectiveResumeAt('manual', null)).toBeNull();
-});
-
-test('a running job survives a pause untouched', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(tmpHome, 'pause-survivor-'));
-  const slugDir = path.join(tmpHome, '.claude', 'projects', 'pause-survivor-slug');
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd: projectCwd }) + '\n');
-  queueStore.bustCwdCache();
-  const stateDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({
-    jobs: [{ slug: 'pause-survivor', status: 'running', cwd: projectCwd, pid: process.pid, runId: 'r1', startedAt: new Date().toISOString() }],
-  }));
-  await scheduler.setPaused('manual', null);
-  const state = await queueStore.readMerged();
-  const row = state.jobs.find((j) => j.slug === 'pause-survivor');
-  expect(row.status).toBe('running');
-  expect(row.runId).toBe('r1');
-});
-
-test('a manual pause survives restart (re-read from disk; boot never clears it)', async () => {
-  await scheduler.setPaused('manual', null);
-  const onDisk = await queueStore.readMerged(); // what a fresh process reads at boot
-  expect(onDisk.paused.reason).toBe('manual');
-  // Boot only clears a pause whose resumeAt has elapsed / re-arms one with a
-  // resumeAt; a manual pause has none, so neither branch applies.
-  expect(onDisk.paused.resumeAt).toBeNull();
-});
-
-test('resume clears a manual pause', async () => {
-  await scheduler.setPaused('manual', null);
-  await scheduler.clearPause('manual');
-  const state = await queueStore.readMerged();
-  expect(state.paused).toBeNull();
-});
-
-test('remote.pause / remote.resume are the admin-route twins of the IPC handlers', async () => {
-  expect(await scheduler.remote.pause()).toEqual({ ok: true });
-  expect((await queueStore.readMerged()).paused.reason).toBe('manual');
-  expect(await scheduler.remote.resume()).toEqual({ ok: true });
-  expect((await queueStore.readMerged()).paused).toBeNull();
-});