claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-shard-quarantine.test.cjs

@@ -1,115 +0,0 @@
-/**
- * scheduler-shard-quarantine.test.cjs — a torn per-project queue shard
- * quarantines THAT project only. tickQueue keeps dispatching the healthy
- * project, never scans/mints rows for the torn project's PRDs, never touches
- * the torn file, and health names the quarantined cwd (non-GREEN).
- *
- * Everything runs under a temp HOME; the stub `claude` writes a marker into
- * its own cwd so the test can prove where a spawn did (not) happen.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-shard-quarantine.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');
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-
-let tmpHome;
-let originalHome;
-let originalWt;
-let scheduler;
-
-function registerActiveProject(cwd) {
-  const slugDir = path.join(tmpHome, '.claude', 'projects', `fake-project-slug-${path.basename(cwd)}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-function makeProject(name) {
-  const cwd = path.join(tmpHome, 'Projects', name);
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'fixture-epic', 'prds');
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.mkdirSync(prdsDir, { recursive: true });
-  registerActiveProject(cwd);
-  return { cwd, prdsDir, queueFile: path.join(stateDir, 'queue.json') };
-}
-
-function writeClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    require('fs').writeFileSync(require('path').join(process.cwd(), 'ran-here.marker'), 'yes');
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');
-    process.exit(0);
-  ` });
-}
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  originalWt = process.env.SM_JOB_WORKTREE_DISABLE;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-shard-quarantine-'));
-  process.env.HOME = tmpHome;
-  process.env.SM_JOB_WORKTREE_DISABLE = '1';
-  process.env.SM_AUTOFIX_DISABLE = '1';
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-  scheduler = require('../scheduler.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalWt === undefined) delete process.env.SM_JOB_WORKTREE_DISABLE;
-  else process.env.SM_JOB_WORKTREE_DISABLE = originalWt;
-  delete process.env.SM_AUTOFIX_DISABLE;
-  delete process.env.SM_CLAUDE_BIN;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('tickQueue dispatches the healthy project while the torn project is skipped; health names it', async () => {
-  const good = makeProject('good-proj');
-  const torn = makeProject('torn-proj');
-  const goodSlug = `9101-good-${process.pid}`;
-  const tornSlug = `9102-torn-${process.pid}`;
-  fs.writeFileSync(path.join(good.prdsDir, `${goodSlug}.md`), 'Healthy PRD.', 'utf8');
-  fs.writeFileSync(path.join(torn.prdsDir, `${tornSlug}.md`), 'PRD in the torn project.', 'utf8');
-  fs.writeFileSync(good.queueFile, JSON.stringify({
-    jobs: [{ slug: goodSlug, title: 'good', status: 'pending', cwd: good.cwd, dependsOn: [], createdAt: new Date().toISOString() }],
-  }));
-  // A running row was in flight when the shard tore — must never become pending.
-  const TORN = '{"jobs":[{"slug":"' + tornSlug + '","status":"running"}]}{"jobs":[{"slug":"';
-  fs.writeFileSync(torn.queueFile, TORN);
-  const before = fs.readFileSync(torn.queueFile);
-  process.env.SM_CLAUDE_BIN = writeClaudeStub();
-
-  const result = await scheduler.tickQueue({ bypassLoadGate: true });
-  expect(result.reason).not.toBe('unreadable');
-  expect(result.fired).toBe(true);
-  // flagUnreadable (via tickQueue's readQueue) snapshots the torn shard beside itself.
-  const snaps = fs.readdirSync(path.dirname(torn.queueFile)).filter((f) => f.startsWith('queue.json.corrupt-'));
-  expect(snaps).toHaveLength(1);
-
-  // 60s, not 20s: under npm run test:unit's full-suite parallel-worker load
-  // this occasionally needed more than 20s for the real child-process
-  // dispatch to land (PRD 1414 — confirmed flaky only inside the full suite,
-  // never in isolation or under synthetic single-file CPU load). The
-  // surrounding vitest test timeout below (120s) already budgets for this.
-  await new Promise((resolve, reject) => {
-    const t0 = Date.now();
-    const poll = () => {
-      if (fs.existsSync(path.join(good.cwd, 'ran-here.marker'))) return resolve();
-      if (Date.now() - t0 > 60_000) return reject(new Error('healthy project never dispatched'));
-      setTimeout(poll, 100);
-    };
-    poll();
-  });
-
-  expect(fs.existsSync(path.join(torn.cwd, 'ran-here.marker'))).toBe(false);
-  expect(fs.readFileSync(torn.queueFile).equals(before)).toBe(true);
-
-  const health = await require('../health.cjs').check({ skipTypecheck: true });
-  expect(health.components.scheduler_queue.ok).toBe(false);
-  expect(health.components.scheduler_queue.quarantinedCwds).toEqual([torn.cwd]);
-  expect(health.issues.some((i) => i.includes(torn.cwd))).toBe(true);
-}, 120_000); // skipTypecheck: this asserts scheduler_queue only; tsc was the tens of seconds

package/src/main/__tests__/scheduler-shared-tree-guard.test.cjs

@@ -1,380 +0,0 @@
-/**
- * scheduler-shared-tree-guard.test.cjs — the shared-tree stash guard added
- * for the 2026-09-01 social-signals-trader incident: a headless PRD executor
- * ran a blanket `git stash` in a working tree shared with a live trading
- * service, silently reverting an uncommitted operator config edit with no
- * error anywhere.
- *
- * evaluateSharedTreeGuard is the pure diff (no I/O); checkSharedTreeGuard is
- * the orchestrator that also restores a single unambiguous stash, using the
- * same module.exports spy pattern computeCommittedDuringRun/committedInWindow
- * use so the underlying git calls never actually run.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-shared-tree-guard.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi, afterEach } from 'vitest';
-const fs = require('node:fs');
-const scheduler = require('../scheduler.cjs');
-const { evaluateSharedTreeGuard, checkSharedTreeGuard } = scheduler;
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-test('evaluateSharedTreeGuard: no-op when nothing changed', () => {
-  const result = evaluateSharedTreeGuard({
-    stashBefore: ['aaa stash@{0} WIP on main: aaa old'],
-    stashAfter: ['aaa stash@{0} WIP on main: aaa old'],
-    dirtyBefore: ['data/spread_config.json'],
-    dirtyAfter: ['data/spread_config.json'],
-    pathsCommittedDuringRun: [],
-  });
-  expect(result.newStashes).toEqual([]);
-  expect(result.reverted).toEqual([]);
-});
-
-test('evaluateSharedTreeGuard: flags one new stash entry not present in the baseline', () => {
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: ['bbb stash@{0} WIP on fix/x: bbb f5ae98f'],
-    dirtyBefore: [],
-    dirtyAfter: [],
-    pathsCommittedDuringRun: [],
-  });
-  expect(result.newStashes).toEqual([{ hash: 'bbb', ref: 'stash@{0}', subject: 'WIP on fix/x: bbb f5ae98f' }]);
-});
-
-test('evaluateSharedTreeGuard: two new stash entries both surface (caller decides ambiguity, not this function)', () => {
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [
-      'bbb stash@{0} WIP on fix/x: bbb newest',
-      'ccc stash@{1} WIP on fix/x: ccc older',
-    ],
-    dirtyBefore: [],
-    dirtyAfter: [],
-    pathsCommittedDuringRun: [],
-  });
-  expect(result.newStashes).toHaveLength(2);
-  expect(result.newStashes.map((e) => e.ref)).toEqual(['stash@{0}', 'stash@{1}']);
-});
-
-test('evaluateSharedTreeGuard: baseline-dirty path clean after the run with no commit to explain it is flagged reverted', () => {
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore: ['data/spread_config.json'],
-    dirtyAfter: [],
-    pathsCommittedDuringRun: [],
-  });
-  expect(result.reverted).toEqual(['data/spread_config.json']);
-});
-
-test('evaluateSharedTreeGuard: baseline-dirty path clean after the run but touched by a commit made during the run is NOT flagged', () => {
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore: ['src/foo.js'],
-    dirtyAfter: [],
-    pathsCommittedDuringRun: ['src/foo.js'],
-  });
-  expect(result.reverted).toEqual([]);
-});
-
-test('checkSharedTreeGuard: no-op when nothing changed returns null', async () => {
-  vi.spyOn(scheduler, 'stashList').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha1');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue([]);
-  const restoreSpy = vi.spyOn(scheduler, 'restoreSpecificStash');
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: [],
-    headBefore: 'sha1',
-    slug: 'job-1',
-  });
-  expect(result).toBeNull();
-  expect(restoreSpy).not.toHaveBeenCalled();
-});
-
-test('checkSharedTreeGuard: a single new stash is restored via apply+drop of that specific ref', async () => {
-  vi.spyOn(scheduler, 'stashList').mockResolvedValue(['newhash stash@{0} WIP on main: f5ae98f']);
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha1');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue([]);
-  const restoreSpy = vi.spyOn(scheduler, 'restoreSpecificStash').mockResolvedValue({ ok: true });
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: [],
-    headBefore: 'sha1',
-    slug: 'job-1',
-  });
-  expect(restoreSpy).toHaveBeenCalledWith('/repo', 'stash@{0}');
-  expect(result).toEqual({ restoredStash: 'stash@{0}' });
-});
-
-test('checkSharedTreeGuard: a baseline-dirty path stashed by the job and successfully restored is not ALSO flagged reverted', async () => {
-  vi.spyOn(scheduler, 'stashList').mockResolvedValue(['newhash stash@{0} WIP on main: f5ae98f']);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha1');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'restoreSpecificStash').mockResolvedValue({ ok: true });
-  // uncommittedChanges is queried AFTER the restore attempt in the fixed
-  // implementation — simulate the stashed file reappearing dirty once the
-  // apply+drop succeeds (this is the exact 2026-09-01 incident shape: an
-  // operator's pre-existing dirty file gets swept into the job's stash).
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue(['data/spread_config.json']);
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: ['data/spread_config.json'],
-    headBefore: 'sha1',
-    slug: 'job-1',
-  });
-  expect(result).toEqual({ restoredStash: 'stash@{0}' });
-});
-
-test('checkSharedTreeGuard: two new stashes are reported, not restored (ambiguous)', async () => {
-  vi.spyOn(scheduler, 'stashList').mockResolvedValue([
-    'aaa stash@{0} WIP on main: newest',
-    'bbb stash@{1} WIP on main: older',
-  ]);
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha1');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue([]);
-  const restoreSpy = vi.spyOn(scheduler, 'restoreSpecificStash');
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: [],
-    headBefore: 'sha1',
-    slug: 'job-1',
-  });
-  expect(restoreSpy).not.toHaveBeenCalled();
-  expect(result.ambiguousStashes).toEqual(['stash@{0}', 'stash@{1}']);
-  expect(result.restoredStash).toBeUndefined();
-});
-
-test('checkSharedTreeGuard: a baseline-dirty path reverted with no stash and no commit is flagged reverted', async () => {
-  vi.spyOn(scheduler, 'stashList').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha1');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue([]);
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: ['data/spread_config.json'],
-    headBefore: 'sha1',
-    slug: 'job-1',
-  });
-  expect(result).toEqual({ reverted: ['data/spread_config.json'] });
-});
-
-test('checkSharedTreeGuard: a failed restore is reported as restoreFailed, entry left in place', async () => {
-  vi.spyOn(scheduler, 'stashList').mockResolvedValue(['newhash stash@{0} WIP on main: f5ae98f']);
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha1');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'restoreSpecificStash').mockResolvedValue({ ok: false, error: 'conflict applying stash' });
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: [],
-    headBefore: 'sha1',
-    slug: 'job-1',
-  });
-  expect(result.restoreFailed).toMatch(/stash@\{0\}.*conflict applying stash/);
-});
-
-test('checkSharedTreeGuard never throws when the underlying git calls reject', async () => {
-  vi.spyOn(scheduler, 'stashList').mockRejectedValue(new Error('boom'));
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha1');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue([]);
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: [],
-    headBefore: 'sha1',
-    slug: 'job-1',
-  });
-  expect(result).toBeNull();
-});
-
-// --- 2026-09-12 false-positive: an untracked path that merely became
-// IGNORED during the run (a .gitignore edit) is not a revert. See the
-// evaluateSharedTreeGuard doc comment for the full incident writeup. Each
-// test below is written to FAIL against the pre-fix implementation (which
-// computed `reverted = dirtyBefore - dirtyAfter - committed` with no
-// existence/tracked-status distinction at all) and PASS after it.
-
-test('evaluateSharedTreeGuard: an untracked path that disappears from git status but STILL EXISTS on disk is nowIgnored, not reverted', () => {
-  // Pre-fix behavior: this path would land in `reverted` (dirtyBefore minus
-  // dirtyAfter minus committed, no existence check at all) — FAILS pre-fix.
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore: [{ code: '??', path: 'session-manager-operations/logs/errors-2026-09-12.jsonl' }],
-    dirtyAfter: [],
-    pathsCommittedDuringRun: ['.gitignore'],
-    existsAfter: ['session-manager-operations/logs/errors-2026-09-12.jsonl'],
-  });
-  expect(result.reverted).toEqual([]);
-  expect(result.nowIgnored).toEqual(['session-manager-operations/logs/errors-2026-09-12.jsonl']);
-});
-
-test('evaluateSharedTreeGuard: an untracked path that disappears from git status AND no longer exists on disk is still reverted', () => {
-  // Proves the fix is not a blanket "stop reporting reverted": a genuinely
-  // deleted untracked file (the guard's real purpose — catching a job that
-  // discarded uncommitted work) must still surface. If the fix had simply
-  // stopped reporting any untracked-and-missing path as reverted, this test
-  // would fail (reverted would come back empty instead of containing the
-  // path).
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore: [{ code: '??', path: 'data/scratch.txt' }],
-    dirtyAfter: [],
-    pathsCommittedDuringRun: [],
-    existsAfter: [], // file no longer exists on disk
-  });
-  expect(result.reverted).toEqual(['data/scratch.txt']);
-  expect(result.nowIgnored).toEqual([]);
-});
-
-test('evaluateSharedTreeGuard: a TRACKED path clean after the run is still reverted even though it exists on disk', () => {
-  // A tracked file leaving the dirty set means its content was restored to
-  // HEAD — exactly the discard this guard exists to catch — regardless of
-  // whether the file is still present. Pre-fix this already worked by
-  // accident (no existence check existed at all); this test pins the
-  // behavior now that existence checks exist for the untracked branch, so a
-  // future change can't accidentally start trusting `existsAfter` for
-  // tracked paths too.
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore: [{ code: ' M', path: 'src/config.js' }],
-    dirtyAfter: [],
-    pathsCommittedDuringRun: [],
-    existsAfter: ['src/config.js'], // file exists, but content was reset to HEAD
-  });
-  expect(result.reverted).toEqual(['src/config.js']);
-  expect(result.nowIgnored).toEqual([]);
-});
-
-test('checkSharedTreeGuard end-to-end: the real 2026-09-12 incident shape — untracked logs path ignored by a committed .gitignore change, file still on disk — must NOT verdict shared_tree_reverted', async () => {
-  // PRD 1181's exact shape: a bare `logs/` pattern lands in .gitignore during
-  // the run (committed), eleven untracked log paths vanish from `git status`,
-  // and the files are untouched on disk. Pre-fix, checkSharedTreeGuard's
-  // `reverted` would contain this path (no existsAfter computation existed),
-  // driving the caller's `verdict: 'shared_tree_reverted'` downgrade — FAILS
-  // pre-fix.
-  const logPath = 'session-manager-operations/logs/errors-2026-09-12.jsonl';
-  vi.spyOn(scheduler, 'stashList').mockResolvedValue([]);
-  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha-after');
-  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue(['.gitignore']);
-  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]); // the log path no longer shows up at all
-  // checkSharedTreeGuard's existence check runs concurrently via
-  // fs.promises.access (fsp === fs.promises — same object) rather than
-  // fs.existsSync, so a large untracked baseline doesn't block the event
-  // loop with hundreds of synchronous stats back-to-back.
-  vi.spyOn(fs.promises, 'access').mockImplementation((p) => (
-    String(p).includes('errors-2026-09-12.jsonl') ? Promise.resolve() : Promise.reject(new Error('ENOENT'))
-  ));
-
-  const result = await checkSharedTreeGuard({
-    cwd: '/repo',
-    stashBaseline: [],
-    dirtyBaseline: [{ code: '??', path: logPath }],
-    headBefore: 'sha-before',
-    slug: 'job-1181',
-  });
-
-  expect(result.reverted).toBeUndefined();
-  expect(result.nowIgnored).toEqual([logPath]);
-});
-
-// --- landedCommit ground truth (2026-09-18, 1229-fo-03 false positive) ---
-// Real temp git fixture, never the live repo. Baseline-dirty path `cfg.txt`
-// goes clean with no commit covering it (the shape that makes the baseline
-// diff say "reverted"); only the landedCommit ancestry decides the verdict.
-const { execFileSync } = require('node:child_process');
-const os = require('node:os');
-const nodePath = require('node:path');
-
-function gitIn(dir, ...args) {
-  return execFileSync('git', args, { cwd: dir, encoding: 'utf8' }).trim();
-}
-
-function fixtureRepo() {
-  const dir = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'shared-tree-landed-'));
-  gitIn(dir, 'init', '-q');
-  gitIn(dir, 'config', 'user.email', 't@example.com');
-  gitIn(dir, 'config', 'user.name', 'T');
-  fs.writeFileSync(nodePath.join(dir, 'cfg.txt'), 'base\n');
-  gitIn(dir, 'add', '-A');
-  gitIn(dir, 'commit', '-q', '-m', 'base');
-  const base = gitIn(dir, 'rev-parse', 'HEAD');
-  fs.writeFileSync(nodePath.join(dir, 'cfg.txt'), 'human wip\n'); // baseline-dirty
-  return { dir, base };
-}
-
-function commitPath(dir, rel, msg) {
-  fs.writeFileSync(nodePath.join(dir, rel), `${msg}\n`);
-  gitIn(dir, 'add', rel);
-  gitIn(dir, 'commit', '-q', '-m', msg);
-  return gitIn(dir, 'rev-parse', 'HEAD');
-}
-
-test('checkSharedTreeGuard: landedCommit still an ancestor of HEAD plus an unrelated later commit is NOT reverted', async () => {
-  const { dir, base } = fixtureRepo();
-  const landed = commitPath(dir, 'job.txt', 'job work');
-  gitIn(dir, 'checkout', '--', 'cfg.txt'); // baseline-dirty path goes clean, no commit covers it
-  commitPath(dir, 'later.txt', 'unrelated human commit');
-
-  const result = await checkSharedTreeGuard({
-    cwd: dir, stashBaseline: [], dirtyBaseline: [{ code: ' M', path: 'cfg.txt' }],
-    headBefore: base, slug: 'job-a', landedCommit: landed,
-  });
-  expect(result).toBeNull();
-});
-
-test('checkSharedTreeGuard: landedCommit absent from history still parks as reverted', async () => {
-  const { dir, base } = fixtureRepo();
-  const landed = commitPath(dir, 'job.txt', 'job work');
-  gitIn(dir, 'reset', '-q', '--hard', base); // job commit discarded
-  commitPath(dir, 'later.txt', 'unrelated human commit');
-
-  const result = await checkSharedTreeGuard({
-    cwd: dir, stashBaseline: [], dirtyBaseline: [{ code: ' M', path: 'cfg.txt' }],
-    headBefore: base, slug: 'job-b', landedCommit: landed,
-  });
-  expect(result).toEqual({ reverted: ['cfg.txt'] });
-});
-
-test('checkSharedTreeGuard: no landedCommit at all still parks as reverted', async () => {
-  const { dir, base } = fixtureRepo();
-  gitIn(dir, 'checkout', '--', 'cfg.txt');
-  const result = await checkSharedTreeGuard({
-    cwd: dir, stashBaseline: [], dirtyBaseline: [{ code: ' M', path: 'cfg.txt' }],
-    headBefore: base, slug: 'job-c', landedCommit: null,
-  });
-  expect(result).toEqual({ reverted: ['cfg.txt'] });
-});
-
-test('landedCommitIsAncestorOfHead: empty/unknown sha is false, never throws', async () => {
-  const { dir } = fixtureRepo();
-  expect(await scheduler.landedCommitIsAncestorOfHead(dir, '')).toBe(false);
-  expect(await scheduler.landedCommitIsAncestorOfHead(dir, 'deadbeefdeadbeef')).toBe(false);
-});

package/src/main/__tests__/scheduler-sigterm-commit.test.cjs

@@ -1,43 +0,0 @@
-/**
- * scheduler-sigterm-commit.test.cjs — a run SIGTERM'd (exit 143) mid an
- * interactive/headless-incompatible AC step (xvfb Electron screenshot,
- * playwright electron.launch — see the 776/779 incidents, 2026-07-30) can
- * still have landed its deliverable commit before it died. classifySigtermWithCommit
- * decides whether that run should be routed to needs_review (commit found —
- * a human should verify the rest of the AC) instead of staying `failed`
- * forever, without ever silently auto-promoting to `completed`.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-sigterm-commit.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { classifySigtermWithCommit } = require('../scheduler.cjs');
-
-test('classifySigtermWithCommit: exit 143 + commit found in window → needs_review', () => {
-  const decision = classifySigtermWithCommit(143, true);
-  expect(decision.status).toBe('needs_review');
-  expect(decision.reason).toMatch(/SIGTERM/);
-  expect(decision.reason).toMatch(/verify AC/i);
-});
-
-test('classifySigtermWithCommit: exit 143 + no commit found in window → still failed (regression check)', () => {
-  const decision = classifySigtermWithCommit(143, false);
-  expect(decision).toBeNull();
-});
-
-test('classifySigtermWithCommit: exit 1 (non-143 code) is unaffected even with a commit found', () => {
-  const decision = classifySigtermWithCommit(1, true);
-  expect(decision).toBeNull();
-});
-
-test('classifySigtermWithCommit: exit 137 (SIGKILL) is unaffected — scoped narrowly to 143', () => {
-  const decision = classifySigtermWithCommit(137, true);
-  expect(decision).toBeNull();
-});
-
-test('classifySigtermWithCommit: exit 0 is unaffected', () => {
-  const decision = classifySigtermWithCommit(0, true);
-  expect(decision).toBeNull();
-});

package/src/main/__tests__/scheduler-stall-per-project.test.cjs

@@ -1,126 +0,0 @@
-/**
- * scheduler-stall-per-project.test.cjs — unit tests for computeStallSummary's
- * per-project `stalled` verdict and findStaleQuarantinedJobs' age-based
- * escalation.
- *
- * Covers the exact burrow-vs-others shape observed live: one project (burrow)
- * holds only quarantined rows (0 running, 0 pending) while another project
- * has running + pending work — the machine-wide `stalled` boolean reads
- * false (masking burrow), but burrow's own byProject entry must read true.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-stall-per-project.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — this repo's suite is vitest-only (see CLAUDE.md:
-// "This repo does not use `node --test`"). A node:test file loads under
-// vitest as "No test suite found" and contributes zero tests, so the guard
-// silently doesn't exist. node:assert works fine inside a vitest run.
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { computeStallSummary, findStaleQuarantinedJobs, QUARANTINE_ESCALATE_MS } = require('../scheduler.cjs');
-
-test('computeStallSummary: burrow fully stalled (quarantined only) while another project is busy — machine-wide false, burrow true', () => {
-  const state = {
-    paused: null,
-    jobs: [
-      { slug: '821-a', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
-      { slug: '822-b', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
-      { slug: '823-c', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
-      { slug: '824-d', cwd: '/home/bilko/Projects/burrow', status: 'quarantined' },
-      { slug: '900-e', cwd: '/home/bilko/Projects/other', status: 'running' },
-      { slug: '901-f', cwd: '/home/bilko/Projects/other', status: 'pending' },
-    ],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  assert.strictEqual(summary.stalled, false, 'machine-wide must NOT read stalled — other project is busy');
-  assert.strictEqual(summary.byProject['/home/bilko/Projects/burrow'].stalled, true, 'burrow must read stalled on its own');
-  assert.strictEqual(summary.byProject['/home/bilko/Projects/other'].stalled, false);
-});
-
-test('computeStallSummary: both projects busy — neither stalled', () => {
-  const state = {
-    paused: null,
-    jobs: [
-      { slug: 'a', cwd: '/p1', status: 'running' },
-      { slug: 'b', cwd: '/p2', status: 'pending' },
-    ],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  assert.strictEqual(summary.stalled, false);
-  assert.strictEqual(summary.byProject['/p1'].stalled, false);
-  assert.strictEqual(summary.byProject['/p2'].stalled, false);
-});
-
-test('computeStallSummary: both projects stalled — machine-wide AND both per-project read true', () => {
-  const state = {
-    paused: null,
-    jobs: [
-      { slug: 'a', cwd: '/p1', status: 'failed' },
-      { slug: 'b', cwd: '/p2', status: 'needs_review' },
-    ],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  assert.strictEqual(summary.stalled, true);
-  assert.strictEqual(summary.byProject['/p1'].stalled, true);
-  assert.strictEqual(summary.byProject['/p2'].stalled, true);
-});
-
-test('computeStallSummary: paused scheduler never reads stalled, machine-wide or per-project', () => {
-  const state = {
-    paused: { reason: 'rate_limit' },
-    jobs: [{ slug: 'a', cwd: '/p1', status: 'quarantined' }],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  assert.strictEqual(summary.stalled, false);
-  assert.strictEqual(summary.byProject['/p1'].stalled, false);
-});
-
-test('findStaleQuarantinedJobs: fires past threshold, not before', () => {
-  const now = Date.parse('2026-08-08T12:00:00.000Z');
-  const jobs = [
-    {
-      slug: 'fresh',
-      cwd: '/p1',
-      status: 'quarantined',
-      statusHistory: [{ to: 'quarantined', at: new Date(now - 1 * 60 * 60_000).toISOString() }],
-    },
-    {
-      slug: 'stale',
-      cwd: '/p1',
-      status: 'quarantined',
-      statusHistory: [{ to: 'quarantined', at: new Date(now - 25 * 60 * 60_000).toISOString() }],
-    },
-    {
-      slug: 'exactly-at-threshold',
-      cwd: '/p1',
-      status: 'quarantined',
-      statusHistory: [{ to: 'quarantined', at: new Date(now - QUARANTINE_ESCALATE_MS).toISOString() }],
-    },
-    { slug: 'no-history', cwd: '/p1', status: 'quarantined' },
-    { slug: 'not-quarantined', cwd: '/p1', status: 'pending' },
-  ];
-  const stale = findStaleQuarantinedJobs(jobs, now, QUARANTINE_ESCALATE_MS);
-  const slugs = stale.map((s) => s.slug).sort();
-  assert.deepStrictEqual(slugs, ['exactly-at-threshold', 'stale']);
-  assert.strictEqual(stale.find((s) => s.slug === 'stale').cwd, '/p1');
-});
-
-test('computeStallSummary: a fully drained project (all completed) is idle, not stalled', () => {
-  const state = {
-    paused: null,
-    jobs: [
-      { slug: 'a', cwd: '/p1', status: 'completed' },
-      { slug: 'b', cwd: '/p2', status: 'running' },
-    ],
-    invalidJobs: [],
-  };
-  const summary = computeStallSummary(state);
-  assert.strictEqual(summary.byProject['/p1'].stalled, false);
-  assert.strictEqual(computeStallSummary({ paused: null, jobs: [{ slug: 'a', cwd: '/p1', status: 'completed' }], invalidJobs: [] }).stalled, false);
-});