claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-mechanical-recovery.test.cjs

@@ -1,245 +0,0 @@
-/**
- * scheduler-mechanical-recovery.test.cjs — PRD 1130: a fix-plan job parked
- * needs_review at investigationDepth >= 2 (isFixPlanBeyondDepthCap,
- * scheduler.cjs) gets no further investigation, and resume-first recovery
- * (selectResumeRecoveryTarget) is hard-gated on verdict 'uncommitted_changes'
- * — so a depth-capped job whose failure is fully mechanical (verdict
- * 'worktree_integration_failed') was previously stranded needs_review
- * forever (216-jupiter-sand-kazekage, 2026-09-06). This adds one bounded,
- * model-free recovery rung, evaluated independently of depth.
- *
- * selectMechanicalRecoveryTarget is the pure eligibility rule (no I/O, no
- * depth check); performMechanicalRecovery is the git plumbing + queue
- * transition, exercised against a real throwaway repo under os.tmpdir()
- * (same pattern as scheduler-leftover-quarantine.test.cjs and
- * scheduler-reap-dead-running-jobs.test.cjs).
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs, since
- * queue.json I/O (mutate/readQueue/writeQueue) is baked into a top-level
- * ROOT const derived from os.homedir() at require time — this test must
- * never touch real state.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-mechanical-recovery.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-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(), 'sm-mechanical-recovery-test-'));
-process.env.HOME = tmpHome;
-
-const scheduler = require('../scheduler.cjs');
-const {
-  selectMechanicalRecoveryTarget, performMechanicalRecovery, MECHANICALLY_RESOLVABLE_VERDICTS,
-} = scheduler;
-const jobWorktree = require('../lib/jobWorktree.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, 'a.txt'), 'original a\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-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 registerActiveProject(cwd, slugDirName) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, slugDirName);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-let originalDisable;
-
-beforeEach(() => {
-  originalDisable = process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-  delete process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-});
-
-afterEach(() => {
-  if (originalDisable === undefined) delete process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-  else process.env.SM_MECHANICAL_RECOVERY_DISABLE = originalDisable;
-});
-
-// ──────────────────────────────────────────── selectMechanicalRecoveryTarget (pure)
-
-function eligibleJob(overrides = {}) {
-  return {
-    slug: 'depth-capped-fix-plan',
-    cwd: '/tmp/whatever-not-read-by-the-selector',
-    status: 'needs_review',
-    verifierVerdict: 'worktree_integration_failed',
-    investigationDepth: 2,
-    ...overrides,
-  };
-}
-
-test('selectMechanicalRecoveryTarget: eligible depth-2 worktree_integration_failed job returns a target, depth never disqualifies it', () => {
-  const target = selectMechanicalRecoveryTarget(eligibleJob({ investigationDepth: 5 }));
-  expect(target).not.toBeNull();
-  expect(target.slug).toBe('depth-capped-fix-plan');
-  expect(target.branch).toBe(jobWorktree.branchNameFor('depth-capped-fix-plan'));
-});
-
-test('selectMechanicalRecoveryTarget: already-attempted job is not eligible', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ mechanicalRecoveryAttempted: true }))).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: a verdict outside the closed set is not eligible', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ verifierVerdict: 'uncommitted_changes' }))).toBeNull();
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ verifierVerdict: 'transcript_errors' }))).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: wrong status is not eligible', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ status: 'failed' }))).toBeNull();
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ status: 'completed' }))).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: kill-switch SM_MECHANICAL_RECOVERY_DISABLE=1 always returns null', () => {
-  process.env.SM_MECHANICAL_RECOVERY_DISABLE = '1';
-  expect(selectMechanicalRecoveryTarget(eligibleJob())).toBeNull();
-});
-
-const conflictJob = (o = {}) => eligibleJob({ integrationFailureKind: 'content_conflict', integrationBaseHeadSha: 'aaa111', ...o });
-
-test('selectMechanicalRecoveryTarget: content_conflict with unchanged HEAD is skipped', () => {
-  expect(selectMechanicalRecoveryTarget(conflictJob(), 'aaa111')).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: content_conflict with a moved HEAD returns a target', () => {
-  expect(selectMechanicalRecoveryTarget(conflictJob(), 'bbb222')).not.toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: blocking_paths with unchanged HEAD still returns a target', () => {
-  const job = eligibleJob({ integrationFailureKind: 'blocking_paths', integrationBaseHeadSha: 'aaa111' });
-  expect(selectMechanicalRecoveryTarget(job, 'aaa111')).not.toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: a pre-mc-01 row with no integrationFailureKind still returns a target', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob(), 'aaa111')).not.toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: null currentHeadSha never skips', () => {
-  expect(selectMechanicalRecoveryTarget(conflictJob(), null)).not.toBeNull();
-});
-
-test('MECHANICALLY_RESOLVABLE_VERDICTS: closed set contains exactly worktree_integration_failed', () => {
-  expect(Array.from(MECHANICALLY_RESOLVABLE_VERDICTS)).toEqual(['worktree_integration_failed']);
-});
-
-// ──────────────────────────────────────────── performMechanicalRecovery (real git + queue)
-
-test('performMechanicalRecovery: successful re-integration transitions needs_review -> completed, clears verifierVerdict, deletes the branch', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-success');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-success-slug');
-
-  const slug = 'fix-plan-depth2';
-  const branch = jobWorktree.branchNameFor(slug);
-  // Simulate a job whose worktree branch has one committed change, preserved
-  // (never deleted) because its earlier integration attempt failed.
-  git(['checkout', '-q', '-b', branch], projectCwd);
-  fs.writeFileSync(path.join(projectCwd, 'b.txt'), 'from the fix plan\n', 'utf8');
-  git(['add', '-A'], projectCwd);
-  git(['commit', '-q', '-m', 'fix plan work'], projectCwd);
-  git(['checkout', '-q', 'master'], projectCwd);
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug,
-      status: 'needs_review',
-      cwd: projectCwd,
-      verifierVerdict: 'worktree_integration_failed',
-      investigationDepth: 2,
-      error: 'worktree branch integration FAILED (merge failed) — branch preserved for manual recovery',
-    },
-  ]);
-
-  const target = selectMechanicalRecoveryTarget({ slug, cwd: projectCwd, status: 'needs_review', verifierVerdict: 'worktree_integration_failed' });
-  expect(target).not.toBeNull();
-
-  await performMechanicalRecovery({ slug, cwd: projectCwd }, target);
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  expect(jobs).toHaveLength(1);
-  expect(jobs[0].status).toBe('completed');
-  expect(jobs[0].verifierVerdict).toBeUndefined();
-  expect(jobs[0].mechanicalRecoveryAttempted).toBe(true);
-  expect(jobs[0].statusHistory.at(-1).source).toBe('scheduler:mechanicalRecovery');
-  expect(fs.readFileSync(path.join(projectCwd, 'b.txt'), 'utf8')).toBe('from the fix plan\n');
-  // The branch, now merged, is cleaned up.
-  const branchList = git(['branch', '--list', branch], projectCwd);
-  expect(branchList.trim()).toBe('');
-});
-
-test('performMechanicalRecovery: a real merge conflict keeps the job needs_review, stamps mechanicalRecoveryAttempted, appends the failure text', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-conflict');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-conflict-slug');
-
-  const slug = 'fix-plan-conflict';
-  const branch = jobWorktree.branchNameFor(slug);
-  git(['checkout', '-q', '-b', branch], projectCwd);
-  fs.writeFileSync(path.join(projectCwd, 'a.txt'), 'branch version\n', 'utf8');
-  git(['add', '-A'], projectCwd);
-  git(['commit', '-q', '-m', 'branch edits a.txt'], projectCwd);
-  git(['checkout', '-q', 'master'], projectCwd);
-  // Main tree diverges on the SAME line — a genuine, unresolvable conflict.
-  fs.writeFileSync(path.join(projectCwd, 'a.txt'), 'main version\n', 'utf8');
-  git(['add', '-A'], projectCwd);
-  git(['commit', '-q', '-m', 'main edits a.txt'], projectCwd);
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug, status: 'needs_review', cwd: projectCwd, verifierVerdict: 'worktree_integration_failed', investigationDepth: 3, error: 'prior failure note' },
-  ]);
-
-  const target = selectMechanicalRecoveryTarget({ slug, cwd: projectCwd, status: 'needs_review', verifierVerdict: 'worktree_integration_failed' });
-  await performMechanicalRecovery({ slug, cwd: projectCwd }, target);
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  expect(jobs[0].status).toBe('needs_review');
-  expect(jobs[0].mechanicalRecoveryAttempted).toBe(true);
-  expect(jobs[0].error).toMatch(/prior failure note/);
-  expect(jobs[0].error).toMatch(/Mechanical recovery retry failed/);
-  // The branch is preserved for manual recovery, exactly like the original failure.
-  const branchList = git(['branch', '--list', branch], projectCwd);
-  expect(branchList.trim()).not.toBe('');
-});
-
-test('performMechanicalRecovery: a branch that no longer exists is handled without throwing, and stamps an explicit reason', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-missing-branch');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-missing-branch-slug');
-
-  const slug = 'fix-plan-already-merged';
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug, status: 'needs_review', cwd: projectCwd, verifierVerdict: 'worktree_integration_failed', investigationDepth: 2 },
-  ]);
-
-  const target = selectMechanicalRecoveryTarget({ slug, cwd: projectCwd, status: 'needs_review', verifierVerdict: 'worktree_integration_failed' });
-
-  await expect(performMechanicalRecovery({ slug, cwd: projectCwd }, target)).resolves.not.toThrow();
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  expect(jobs[0].status).toBe('needs_review');
-  expect(jobs[0].mechanicalRecoveryAttempted).toBe(true);
-  expect(jobs[0].error).toMatch(/not found/);
-});

package/src/main/__tests__/scheduler-meta-code-sha.test.cjs

@@ -1,46 +0,0 @@
-/**
- * scheduler-meta-code-sha.test.cjs — unit tests for the SCHEDULER_BOOTED_AT /
- * SCHEDULER_CODE_SHA constants stamped into every run's meta sidecar (PRD
- * 812-fix-commit-guard-retry-on-worktree-ref-visibility-delay): a stale
- * scheduler process is otherwise invisible in the run record, which cost a
- * full investigation to diagnose a false pass_no_commit.
- *
- * SCHEDULER_CODE_SHA now resolves through src/main/lib/buildIdentity.cjs
- * (build-identity-stamp PRD): a production npx install ships no .git, so a
- * runtime `git rev-parse` was structurally always null there — this file
- * used to accept that null unconditionally, which made the dead stamp green
- * forever. With src/main/build-info.json present (ensured below — the exact
- * artifact scripts/write-build-info.cjs bakes at publish time), the sha must
- * be real.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-meta-code-sha.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterAll } from 'vitest';
-const fs = require('node:fs');
-const path = require('node:path');
-
-const BUILD_INFO_PATH = path.join(__dirname, '..', 'build-info.json');
-const preexistingBuildInfo = fs.existsSync(BUILD_INFO_PATH) ? fs.readFileSync(BUILD_INFO_PATH, 'utf8') : null;
-if (preexistingBuildInfo === null) {
-  // eslint-disable-next-line global-require
-  require('../../../scripts/write-build-info.cjs').writeBuildInfo();
-}
-
-const { SCHEDULER_BOOTED_AT, SCHEDULER_CODE_SHA } = require('../scheduler.cjs');
-
-afterAll(() => {
-  if (preexistingBuildInfo === null) fs.rmSync(BUILD_INFO_PATH, { force: true });
-  else fs.writeFileSync(BUILD_INFO_PATH, preexistingBuildInfo);
-});
-
-test('SCHEDULER_BOOTED_AT is a valid ISO date string', () => {
-  expect(typeof SCHEDULER_BOOTED_AT).toBe('string');
-  expect(Number.isNaN(new Date(SCHEDULER_BOOTED_AT).getTime())).toBe(false);
-});
-
-test('SCHEDULER_CODE_SHA is a real short git hex SHA when build-info.json is present — never null', () => {
-  expect(SCHEDULER_CODE_SHA).toMatch(/^[0-9a-f]{7,40}$/);
-});

package/src/main/__tests__/scheduler-needs-review-autoresolve.test.cjs

@@ -1,197 +0,0 @@
-/**
- * scheduler-needs-review-autoresolve.test.cjs
- *
- * Covers the bounded automatic terminal decision for an EXHAUSTED
- * needs_review row (isExhaustedAutoFix === true): selectExhaustedNeedsReviewTargets
- * (the pure selector), applyNeedsReviewAutoResolve (the three-branch policy
- * applier, extracted from the 10-minute interval body so it's testable
- * without queue.json IO), needsReviewAutoResolveDisabled (its kill switch),
- * and the dependsOn carve-out in schedulerBatch.cjs's findBlockingDep that
- * lets a chain actually drain once this pass auto-skips a row.
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
- * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
- * under $HOME/.claude/session-manager/audit-log.jsonl).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-needs-review-autoresolve.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 tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'needs-review-autoresolve-test-'));
-process.env.HOME = tmpHome;
-
-// Fixture cwd must be a REAL, writable dir: every transitionJob out of
-// needs_review fire-and-forgets a history append under <cwd>/session-manager-operations.
-// A fake path ('/home/user/project') made that append fail with EACCES *after*
-// the synchronous test returned, so its console.error landed while vitest was
-// closing the worker ("Closing rpc while onUserConsoleLog was pending" -> exit 1).
-const PROJECT_CWD = path.join(tmpHome, 'project');
-fs.mkdirSync(PROJECT_CWD, { recursive: true });
-
-const {
-  selectExhaustedNeedsReviewTargets,
-  applyNeedsReviewAutoResolve,
-  NEEDS_REVIEW_RESOLVE_CAP,
-  needsReviewAutoResolveDisabled,
-} = require('../scheduler.cjs');
-
-const { pickForProject } = require('../lib/schedulerBatch.cjs');
-
-const MIN_MS = 60_000;
-const THRESHOLD_MS = 30 * MIN_MS;
-
-function exhaustedJob(overrides = {}) {
-  return {
-    slug: 'exhausted-row',
-    cwd: PROJECT_CWD,
-    status: 'needs_review',
-    autoFixAttempted: true,
-    autoFixOutcome: 'no-plan',
-    autoFixRetries: 1, // spent, per isExhaustedAutoFix
-    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 45 * MIN_MS).toISOString() }],
-    ...overrides,
-  };
-}
-
-// --- selectExhaustedNeedsReviewTargets ---
-
-test('a fresh exhausted needs_review row (under threshold) is not selected', () => {
-  const job = exhaustedJob({
-    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 2 * MIN_MS).toISOString() }],
-  });
-  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a non-exhausted needs_review row (still eligible for a real auto-fix investigation) is left alone', () => {
-  // autoFixRetries: 0 — isExhaustedAutoFix is false here (an unspent retry
-  // remains); this pass must never steal a row selectAutoFixTargets still owns.
-  const job = exhaustedJob({ autoFixRetries: 0 });
-  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('a non-needs_review status is never selected', () => {
-  const job = exhaustedJob({ status: 'failed' });
-  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('an exhausted row past threshold, under the cap, is selected', () => {
-  const job = exhaustedJob({ exhaustedResolveAttempts: 0 });
-  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
-  assert.equal(found.length, 1);
-  assert.equal(found[0].slug, 'exhausted-row');
-  assert.equal(found[0].attempts, 0);
-});
-
-test('an exhausted row AT the cap is still selected — this is the pass that must terminally skip it', () => {
-  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
-  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
-  assert.equal(found.length, 1);
-});
-
-test('a row already past the cap (defensive — should never occur once skipped) is excluded', () => {
-  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP + 1 });
-  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
-});
-
-test('needsReviewAutoResolveDisabled reflects SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE', () => {
-  const saved = process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
-  try {
-    delete process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
-    assert.equal(needsReviewAutoResolveDisabled(), false);
-    process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE = '1';
-    assert.equal(needsReviewAutoResolveDisabled(), true);
-  } finally {
-    if (saved === undefined) delete process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
-    else process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE = saved;
-  }
-});
-
-// --- applyNeedsReviewAutoResolve: the three policy branches ---
-
-test('branch 1: a looksDone annotation resolves the row to completed', () => {
-  const job = exhaustedJob({
-    exhaustedResolveAttempts: 1,
-    looksDone: { commits: ['abc1234'], paths: ['src/main/scheduler.cjs'], detectedAt: new Date().toISOString() },
-  });
-  const outcome = applyNeedsReviewAutoResolve(job);
-  assert.equal(outcome, 'completed');
-  assert.equal(job.status, 'completed');
-});
-
-test('branch 2: no looksDone, under the cap, requeues to pending and increments the attempt counter', () => {
-  const job = exhaustedJob({ exhaustedResolveAttempts: 0 });
-  const outcome = applyNeedsReviewAutoResolve(job);
-  assert.equal(outcome, 'requeued');
-  assert.equal(job.status, 'pending');
-  assert.equal(job.exhaustedResolveAttempts, 1);
-});
-
-test('branch 2 again: a second requeue at attempts=1 also succeeds (cap is 2)', () => {
-  const job = exhaustedJob({ exhaustedResolveAttempts: 1 });
-  const outcome = applyNeedsReviewAutoResolve(job);
-  assert.equal(outcome, 'requeued');
-  assert.equal(job.status, 'pending');
-  assert.equal(job.exhaustedResolveAttempts, 2);
-});
-
-test('branch 3: once the cap is spent, the row is auto-skipped with the reason recorded in job.error', () => {
-  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
-  const outcome = applyNeedsReviewAutoResolve(job);
-  assert.equal(outcome, 'skipped');
-  assert.equal(job.status, 'skipped');
-  assert.ok(typeof job.error === 'string' && job.error.length > 0, 'job.error must name the exhausted auto-fix path');
-  assert.match(job.error, /exhausted auto-fix/i);
-  assert.equal(job.needsReviewAutoResolvedSkip, true);
-});
-
-test('applyNeedsReviewAutoResolve race-guards against a row that moved off needs_review', () => {
-  const job = exhaustedJob({ status: 'completed', exhaustedResolveAttempts: 0 });
-  assert.equal(applyNeedsReviewAutoResolve(job), null);
-  assert.equal(job.status, 'completed'); // untouched
-});
-
-// --- chain drain: the actual point of this PRD ---
-
-test('a 3-row dependsOn chain drains: the exhausted middle row auto-skips and the third row becomes eligible', () => {
-  const now = Date.now();
-  const rowA = {
-    slug: 'a-first', cwd: PROJECT_CWD, status: 'completed',
-  };
-  const rowB = exhaustedJob({
-    slug: 'b-middle',
-    cwd: PROJECT_CWD,
-    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
-    dependsOn: ['a-first'],
-  });
-  const rowC = {
-    slug: 'c-last', cwd: PROJECT_CWD, status: 'pending', dependsOn: ['b-middle'],
-  };
-  const jobs = [rowA, rowB, rowC];
-
-  // Before resolution: C is blocked behind B's live needs_review row.
-  const before = pickForProject(jobs, new Set(), 5);
-  assert.equal(before.batch.length, 0, 'C must not be eligible while B still sits in needs_review');
-
-  const targets = selectExhaustedNeedsReviewTargets(jobs, now, THRESHOLD_MS);
-  assert.equal(targets.length, 1);
-  assert.equal(targets[0].slug, 'b-middle');
-  const outcome = applyNeedsReviewAutoResolve(rowB);
-  assert.equal(outcome, 'skipped');
-  assert.equal(rowB.status, 'skipped');
-
-  const after = pickForProject(jobs, new Set(), 5);
-  assert.ok(after.batch.some((j) => j.slug === 'c-last'), 'C must become eligible once B is auto-skipped');
-});
-
-test('a generic (non-auto-resolved) skipped dep still blocks forever — the carve-out is narrow', () => {
-  const rowB = { slug: 'b-middle', cwd: PROJECT_CWD, status: 'skipped' }; // no needsReviewAutoResolvedSkip marker
-  const rowC = { slug: 'c-last', cwd: PROJECT_CWD, status: 'pending', dependsOn: ['b-middle'] };
-  const { batch } = pickForProject([rowB, rowC], new Set(), 5);
-  assert.equal(batch.length, 0, 'a PRD-source-vanished skip must remain a permanent block, unaffected by this carve-out');
-});

package/src/main/__tests__/scheduler-never-stop.test.cjs

@@ -1,157 +0,0 @@
-/**
- * scheduler-never-stop.test.cjs — the invariant: if a queue holds ready PRDs,
- * something must drive them.
- *
- * Every stall observed in this codebase was a different CAUSE with the same
- * SHAPE — ready rows, nothing running, nobody ticking:
- *   - a rate-limited exit stamped terminal 'failed' (2026-09-05: 42 rows)
- *   - a spin loop past the manual-clear cooldown
- *   - a worktree merge-back leaving the project on a job branch
- *   - a job parked needs_review with no fix plan
- *   - app churn under session-manager-operations/ counted as unfinished work
- *   - the billing meter itself 429ing so utilization never reported
- * Guarding each cause individually always lags the next one, so the watchdog
- * guards the shape.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-never-stop.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — this repo's suite is vitest-only (CLAUDE.md).
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// HOME before require: every state path is baked from os.homedir() at load.
-process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'never-stop-test-'));
-
-const {
-  classifyQueueStarvation,
-  QUEUE_STARVATION_MS,
-  stripAppOwnedChurn,
-} = require('../scheduler.cjs');
-
-const CWD = '/home/bilko/Projects/starry-night-ships';
-const NOW = Date.parse('2026-09-05T23:00:00.000Z');
-const idleFor = (ms) => NOW - ms;
-const LONG = QUEUE_STARVATION_MS + 60_000;
-
-const base = (over = {}) => ({
-  jobs: [{ slug: 'a', cwd: CWD, status: 'pending', dependsOn: [] }],
-  paused: null,
-  runningCount: 0,
-  lastRunAtMs: idleFor(LONG),
-  now: NOW,
-  ...over,
-});
-
-// ── the invariant ────────────────────────────────────────────────────────────
-
-test('ready work + nothing running + long idle => starved, and a tick would help', () => {
-  const v = classifyQueueStarvation(base());
-  assert.equal(v.kind, 'starved');
-  assert.equal(v.pending, 1);
-  assert.equal(v.dispatchable, 1);
-});
-
-test('the real incident shape: 40 ready rows, 0 running, idle for hours', () => {
-  const jobs = Array.from({ length: 40 }, (_, i) => ({
-    slug: `${207 + i}-step`, cwd: CWD, status: 'pending', dependsOn: [],
-  }));
-  const v = classifyQueueStarvation(base({ jobs, lastRunAtMs: idleFor(3 * 60 * 60_000) }));
-  assert.equal(v.kind, 'starved');
-  assert.equal(v.dispatchable, 40);
-});
-
-// ── it must NOT fire when the queue is legitimately quiet ────────────────────
-
-test('a running job means the queue is flowing — never starved', () => {
-  assert.equal(classifyQueueStarvation(base({ runningCount: 1 })), null);
-});
-
-test('no pending rows is not a stall', () => {
-  assert.equal(classifyQueueStarvation(base({ jobs: [{ slug: 'a', cwd: CWD, status: 'completed' }] })), null);
-});
-
-test('paused is a DECISION, not a stall — the watchdog must never override it', () => {
-  assert.equal(classifyQueueStarvation(base({ paused: { reason: 'rate_limit', resumeAt: null } })), null);
-});
-
-test('inside the idle threshold the normal path gets its chance first', () => {
-  assert.equal(classifyQueueStarvation(base({ lastRunAtMs: idleFor(QUEUE_STARVATION_MS - 1000) })), null);
-});
-
-test('a never-recorded lastRunAt counts as infinitely idle, not as healthy', () => {
-  const v = classifyQueueStarvation(base({ lastRunAtMs: NaN }));
-  assert.equal(v.kind, 'starved');
-});
-
-// ── blocked is a DIFFERENT verdict from starved ──────────────────────────────
-
-test('every pending row behind a terminal dep => blocked, not starved (a tick cannot help)', () => {
-  const jobs = [
-    { slug: '206-lava-ape', cwd: CWD, status: 'failed', dependsOn: [] },
-    { slug: '207-body', cwd: CWD, status: 'pending', dependsOn: ['206-lava-ape'] },
-    { slug: '208-docs', cwd: CWD, status: 'pending', dependsOn: ['207-body'] },
-  ];
-  const v = classifyQueueStarvation(base({ jobs }));
-  assert.equal(v.kind, 'blocked');
-  assert.equal(v.pending, 2);
-  assert.equal(v.dispatchable, 0);
-  assert.deepEqual(v.blockedChains[0].blockedBy, ['206-lava-ape']);
-});
-
-test('one dispatchable row among blocked ones still counts as starved — the queue can make progress', () => {
-  const jobs = [
-    { slug: 'x-dead', cwd: CWD, status: 'failed', dependsOn: [] },
-    { slug: 'y-blocked', cwd: CWD, status: 'pending', dependsOn: ['x-dead'] },
-    { slug: 'z-ready', cwd: CWD, status: 'pending', dependsOn: [] },
-  ];
-  const v = classifyQueueStarvation(base({ jobs }));
-  assert.equal(v.kind, 'starved');
-  assert.equal(v.dispatchable, 1);
-});
-
-test('a project blocked while ANOTHER project has ready work is still starved overall', () => {
-  const jobs = [
-    { slug: 'a-dead', cwd: '/p/one', status: 'failed', dependsOn: [] },
-    { slug: 'b-blocked', cwd: '/p/one', status: 'pending', dependsOn: ['a-dead'] },
-    { slug: 'c-ready', cwd: '/p/two', status: 'pending', dependsOn: [] },
-  ];
-  assert.equal(classifyQueueStarvation(base({ jobs })).kind, 'starved');
-});
-
-// ── app-owned churn must never be blamed on a job ────────────────────────────
-
-test('stripAppOwnedChurn drops session-manager-operations churn, keeps real source', () => {
-  const out = stripAppOwnedChurn([
-    'src/main/scheduler.cjs',
-    'session-manager-operations/scheduler/state/queue.json',
-    'session-manager-operations/scheduler/state/history.jsonl',
-    'session-manager-operations/prompt-sessions/active-index.json',
-    'dashboard/panels/outcome-stats.jsx',
-  ]);
-  assert.deepEqual(out, ['src/main/scheduler.cjs', 'dashboard/panels/outcome-stats.jsx']);
-});
-
-test('stripAppOwnedChurn preserves the null contract (git status unavailable != left nothing)', () => {
-  assert.equal(stripAppOwnedChurn(null), null);
-  assert.equal(stripAppOwnedChurn(undefined), undefined);
-});
-
-test('stripAppOwnedChurn only matches a whole path segment, never a substring', () => {
-  assert.deepEqual(
-    stripAppOwnedChurn(['docs/session-manager-operations-guide.md', 'a/session-manager-operations/x.json']),
-    ['docs/session-manager-operations-guide.md'],
-  );
-});
-
-test('a job that leaves REAL source dirty still parks — the filter must not excuse that', () => {
-  assert.deepEqual(
-    stripAppOwnedChurn(['session-manager-operations/scheduler/state/queue.json', 'scripts/arena/titan.gd']),
-    ['scripts/arena/titan.gd'],
-  );
-});