claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/lib/__tests__/jobSupervisorRecord.test.cjs

@@ -1,78 +0,0 @@
-/**
- * jobSupervisorRecord.test.cjs — record round-trip, live listing, retention
- * claim, and the pure classifyAdoption matrix.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/jobSupervisorRecord.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 rec = require('../jobSupervisorRecord.cjs');
-
-let root;
-beforeEach(() => { root = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-supervisor-')); });
-afterEach(() => { fs.rmSync(root, { recursive: true, force: true }); });
-
-const base = (over = {}) => ({
-  runDir: path.join(root, 'run-1'), slug: 'p1', cwd: '/x', runId: 'run-1', pid: 42, pgid: 42,
-  identity: { pid: 42, startTicks: 7, cmdline: 'claude -p', complete: true },
-  execCwd: '/wt', worktreeDir: '/wt', worktreeBranch: 'sm-job/p1', sessionId: 's',
-  startedAt: 1_000, budgetMs: 10_000, maxDurationMs: null, idleKillMs: 5_000, schedulerPid: 1, codeSha: 'abc', ...over,
-});
-
-test('write → read round-trips every field at <runDir>/<slug>.supervisor.json', () => {
-  const input = base();
-  rec.writeSupervisorRecord(input);
-  expect(fs.existsSync(path.join(input.runDir, 'p1.supervisor.json'))).toBe(true);
-  const back = rec.readSupervisorRecord(input.runDir, 'p1');
-  const { runDir, ...persisted } = input;
-  expect(back).toMatchObject({ ...persisted, kind: 'job' });
-  expect(back.runDir).toBeUndefined();
-});
-
-test('readSupervisorRecord returns null for absent or torn files', () => {
-  expect(rec.readSupervisorRecord(path.join(root, 'nope'), 'p1')).toBeNull();
-  fs.mkdirSync(path.join(root, 'r'));
-  fs.writeFileSync(path.join(root, 'r', 'p1.supervisor.json'), '{"pid":');
-  expect(rec.readSupervisorRecord(path.join(root, 'r'), 'p1')).toBeNull();
-});
-
-test('listLiveSupervisorRecords skips exited (meta.json) and stale records', () => {
-  rec.writeSupervisorRecord(base({ slug: 'live' }));
-  rec.writeSupervisorRecord(base({ slug: 'done' }));
-  fs.writeFileSync(path.join(root, 'run-1', 'done.meta.json'), '{}');
-  const live = rec.listLiveSupervisorRecords(root, { maxAgeMs: 60_000 });
-  expect(live.map((r) => r.slug)).toEqual(['live']);
-  expect(live[0].runDir).toBe(path.join(root, 'run-1'));
-  expect(rec.listLiveSupervisorRecords(root, { maxAgeMs: 1, now: Date.now() + 10_000 })).toEqual([]);
-  expect(rec.listLiveSupervisorRecords(path.join(root, 'missing'), { maxAgeMs: 1 })).toEqual([]);
-});
-
-test('investigation records use the .investigation.log exit line as their marker', () => {
-  const runDir = path.join(root, 'run-1');
-  rec.writeSupervisorRecord(base({ slug: 'p1.investigation', kind: 'investigation' }));
-  fs.writeFileSync(path.join(runDir, 'p1.investigation.log'), 'working\n');
-  expect(rec.listLiveSupervisorRecords(root, { maxAgeMs: 60_000 })).toHaveLength(1);
-  fs.appendFileSync(path.join(runDir, 'p1.investigation.log'), '\n[scheduler] investigation exit code=0\n');
-  expect(rec.listLiveSupervisorRecords(root, { maxAgeMs: 60_000 })).toEqual([]);
-});
-
-test('classifyAdoption matrix', () => {
-  const r = base();
-  const same = { pid: 42, startTicks: 7, cmdline: 'claude -p', complete: true };
-  const other = { pid: 42, startTicks: 99, cmdline: 'claude -p', complete: true };
-  const now = 2_000;
-  const c = (o) => rec.classifyAdoption(r, { identity: same, pidAlive: true, logMtimeMs: now, exitMarker: false, now, ...o });
-  expect(c({})).toBe('adopt');
-  expect(c({ pidAlive: false })).toBe('dead');
-  expect(c({ pidAlive: false, exitMarker: true })).toBe('exited');
-  expect(c({ identity: other })).toBe('foreign-pid');
-  expect(c({ identity: { pid: 42, startTicks: null, cmdline: null, complete: false } })).toBe('adopt'); // fail-closed
-  expect(c({ now: 1_000 + 10_001, logMtimeMs: 1_000 + 10_000 })).toBe('over-budget');
-  expect(c({ now: 1_000 + 5_001, logMtimeMs: 1_000 })).toBe('over-budget'); // log stalled past idleKillMs
-  expect(rec.classifyAdoption(base({ budgetMs: null, maxDurationMs: 100 }), { identity: same, pidAlive: true, logMtimeMs: 1_050, now: 1_200 })).toBe('over-budget');
-  expect(rec.classifyAdoption(base({ budgetMs: null, idleKillMs: null }), { identity: same, pidAlive: true, now: 9e9 })).toBe('adopt');
-});

package/src/main/lib/__tests__/jobWorktree.test.cjs

@@ -1,199 +0,0 @@
-/**
- * jobWorktree.test.cjs — PRD 994: per-job `git worktree` isolation.
- *
- * Exercises the real `git worktree` plumbing against throwaway repos under
- * os.tmpdir() (fast — no network, no Electron). Covers: create/integrate/
- * cleanup happy path, the two documented fallback reasons (non-git cwd, dirty
- * base tree), the concurrency cap, the kill-switch env var, a real merge
- * conflict surfacing as an explicit integration failure (branch preserved,
- * not silently discarded), and boot-time reconciliation of a leaked worktree.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/jobWorktree.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 jobWorktree = require('../jobWorktree.cjs');
-
-let tmpRoot;
-let repoCwd;
-let originalDisable;
-let originalMax;
-
-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);
-}
-
-beforeEach(() => {
-  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-jobworktree-'));
-  repoCwd = path.join(tmpRoot, 'repo');
-  initRepo(repoCwd);
-  originalDisable = process.env.SM_JOB_WORKTREE_DISABLE;
-  originalMax = process.env.SM_JOB_WORKTREE_MAX;
-  delete process.env.SM_JOB_WORKTREE_DISABLE;
-  delete process.env.SM_JOB_WORKTREE_MAX;
-  jobWorktree._resetActiveWorktreeCountForTests(0);
-});
-
-afterEach(async () => {
-  if (originalDisable === undefined) delete process.env.SM_JOB_WORKTREE_DISABLE;
-  else process.env.SM_JOB_WORKTREE_DISABLE = originalDisable;
-  if (originalMax === undefined) delete process.env.SM_JOB_WORKTREE_MAX;
-  else process.env.SM_JOB_WORKTREE_MAX = originalMax;
-  // Best-effort: prune any worktree this test created before removing the repo.
-  try { await jobWorktree.reconcileWorktreesOnBoot([repoCwd]); } catch { /* ignore */ }
-  fs.rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-test('createJobWorktree creates a linked worktree on a fresh branch from HEAD', async () => {
-  const slug = 'test-slug-create';
-  const result = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug });
-  expect(result.ok).toBe(true);
-  expect(fs.existsSync(result.dir)).toBe(true);
-  expect(fs.existsSync(path.join(result.dir, 'README.md'))).toBe(true);
-  expect(result.branch).toBe(`sm-job/${slug}`);
-
-  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
-  expect(fs.existsSync(result.dir)).toBe(false);
-});
-
-test('a commit made inside the worktree becomes visible on the main tree HEAD after integrateJobBranch', async () => {
-  const slug = 'test-slug-integrate';
-  const worktree = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug });
-  expect(worktree.ok).toBe(true);
-
-  fs.writeFileSync(path.join(worktree.dir, 'new-file.txt'), 'job output\n', 'utf8');
-  git(['add', '-A'], worktree.dir);
-  git(['commit', '-q', '-m', 'job commit'], worktree.dir);
-  const jobCommitSha = git(['rev-parse', 'HEAD'], worktree.dir).trim();
-
-  const headBefore = git(['rev-parse', 'HEAD'], repoCwd).trim();
-  const outcome = await jobWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
-  expect(outcome.ok).toBe(true);
-  expect(outcome.integrated).toBe(true);
-
-  const headAfter = git(['rev-parse', 'HEAD'], repoCwd).trim();
-  expect(headAfter).not.toBe(headBefore);
-  // Fast-forward, since the main tree never advanced independently.
-  expect(headAfter).toBe(jobCommitSha);
-  expect(fs.existsSync(path.join(repoCwd, 'new-file.txt'))).toBe(true);
-
-  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch });
-  expect(fs.existsSync(worktree.dir)).toBe(false);
-});
-
-test('integrateJobBranch is a no-op (integrated:false) when the branch has no new commits', async () => {
-  const slug = 'test-slug-noop';
-  const worktree = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug });
-  const outcome = await jobWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
-  expect(outcome.ok).toBe(true);
-  expect(outcome.integrated).toBe(false);
-  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch });
-});
-
-test('a real merge conflict surfaces as an explicit integration failure and preserves the branch', async () => {
-  const slug = 'test-slug-conflict';
-  const worktree = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug });
-
-  // Job edits README.md in its worktree and commits.
-  fs.writeFileSync(path.join(worktree.dir, 'README.md'), 'job edit\n', 'utf8');
-  git(['add', '-A'], worktree.dir);
-  git(['commit', '-q', '-m', 'job edits README'], worktree.dir);
-
-  // Main tree ALSO advances with a conflicting edit to the same line.
-  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'main tree edit\n', 'utf8');
-  git(['add', '-A'], repoCwd);
-  git(['commit', '-q', '-m', 'main tree edits README'], repoCwd);
-
-  const outcome = await jobWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
-  expect(outcome.ok).toBe(false);
-  expect(outcome.reason).toMatch(/conflict|merge failed/i);
-
-  // cwd must not be left mid-merge.
-  const status = git(['status', '--porcelain'], repoCwd);
-  expect(status.trim()).toBe('');
-
-  // Branch is preserved (keepBranch) — the job's commit is not discarded.
-  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
-  const branches = git(['branch', '--list', worktree.branch], repoCwd);
-  expect(branches).toContain(worktree.branch.replace('sm-job/', ''));
-});
-
-test('falls back with a reason for a non-git cwd', async () => {
-  const nonGitDir = path.join(tmpRoot, 'not-a-repo');
-  fs.mkdirSync(nonGitDir, { recursive: true });
-  const result = await jobWorktree.createJobWorktree({ cwd: nonGitDir, slug: 'x' });
-  expect(result.ok).toBe(false);
-  expect(result.reason).toMatch(/not a git repository/);
-});
-
-test('a dirty tracked base file is carried into the worktree instead of disabling isolation (never silently drops uncommitted human WIP)', async () => {
-  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
-  const result = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
-  expect(result.ok).toBe(true);
-  expect(result.carriedPaths).toEqual(['README.md']);
-  expect(fs.readFileSync(path.join(result.dir, 'README.md'), 'utf8')).toBe('uncommitted tracked edit\n');
-  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: result.dir, branch: result.branch });
-});
-
-test('falls back once the concurrency cap is reached, and recovers after cleanup', async () => {
-  process.env.SM_JOB_WORKTREE_MAX = '1';
-  const first = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug: 'cap-1' });
-  expect(first.ok).toBe(true);
-
-  const second = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug: 'cap-2' });
-  expect(second.ok).toBe(false);
-  expect(second.reason).toMatch(/cap reached/);
-
-  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: first.dir, branch: first.branch });
-
-  const third = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug: 'cap-3' });
-  expect(third.ok).toBe(true);
-  await jobWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: third.dir, branch: third.branch });
-});
-
-test('SM_JOB_WORKTREE_DISABLE=1 restores in-place behaviour', async () => {
-  process.env.SM_JOB_WORKTREE_DISABLE = '1';
-  const result = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug: 'x' });
-  expect(result.ok).toBe(false);
-  expect(result.reason).toMatch(/SM_JOB_WORKTREE_DISABLE/);
-});
-
-test('reconcileWorktreesOnBoot removes a leaked worktree (simulated crash) and its branch', async () => {
-  const slug = 'test-slug-leak';
-  const worktree = await jobWorktree.createJobWorktree({ cwd: repoCwd, slug });
-  expect(fs.existsSync(worktree.dir)).toBe(true);
-  // Simulate a crash: the in-memory counter resets (as it would on restart)
-  // and nothing calls cleanupJobWorktree — the checkout is left registered.
-  jobWorktree._resetActiveWorktreeCountForTests(0);
-
-  await jobWorktree.reconcileWorktreesOnBoot([repoCwd]);
-
-  expect(fs.existsSync(worktree.dir)).toBe(false);
-  const branches = git(['branch', '--list', worktree.branch], repoCwd);
-  expect(branches.trim()).toBe('');
-});
-
-test('reconcileWorktreesOnBoot never touches a worktree outside WORKTREE_ROOT', async () => {
-  const humanWorktreeDir = path.join(tmpRoot, 'human-made-worktree');
-  git(['worktree', 'add', '-b', 'human-branch', humanWorktreeDir, 'HEAD'], repoCwd);
-  await jobWorktree.reconcileWorktreesOnBoot([repoCwd]);
-  expect(fs.existsSync(humanWorktreeDir)).toBe(true);
-  // cleanup so afterEach's rm doesn't leave a dangling worktree registration.
-  git(['worktree', 'remove', '--force', humanWorktreeDir], repoCwd);
-});

package/src/main/lib/__tests__/jobWorktreeBootLive.test.cjs

@@ -1,82 +0,0 @@
-/**
- * jobWorktreeBootLive.test.cjs — PRD 1162: pure unit tests for the `isLive`
- * predicate the scheduler's boot worktree sweep hands to
- * jobWorktree.reconcileWorktreesOnBoot. Liveness is fully injected/stubbed —
- * no /proc, no git, no electron.
- *
- * Run: timeout 60 npx vitest run src/main/lib/__tests__/jobWorktreeBootLive.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const { buildJobWorktreeIsLive } = require('../jobWorktreeBootLive.cjs');
-
-test('isLive returns true when the row is running with a live pid', () => {
-  const claudePidAlive = vi.fn(() => true);
-  const hasLiveHolder = vi.fn(() => false);
-  const isLive = buildJobWorktreeIsLive({
-    bootJobs: [{ slug: 'job-a', status: 'running', runtime: { pid: 4242 } }],
-    claudePidAlive,
-    hasLiveHolder,
-  });
-  expect(isLive('job-a', { worktree: '/tmp/whatever' })).toBe(true);
-  expect(claudePidAlive).toHaveBeenCalledWith(4242);
-  expect(hasLiveHolder).not.toHaveBeenCalled();
-});
-
-test('isLive returns false when the row is running but the pid is dead and no cwd holder exists', () => {
-  const isLive = buildJobWorktreeIsLive({
-    bootJobs: [{ slug: 'job-a', status: 'running', runtime: { pid: 4242 } }],
-    claudePidAlive: () => false,
-    hasLiveHolder: () => false,
-  });
-  expect(isLive('job-a', { worktree: '/tmp/whatever' })).toBe(false);
-});
-
-test('isLive returns true via hasLiveHolder when the row is absent/terminal but a process still holds the checkout as cwd', () => {
-  const claudePidAlive = vi.fn(() => true);
-  const hasLiveHolder = vi.fn(() => true);
-  const isLive = buildJobWorktreeIsLive({
-    bootJobs: [{ slug: 'job-b', status: 'completed', runtime: { pid: 999 } }],
-    claudePidAlive,
-    hasLiveHolder,
-  });
-  expect(isLive('job-b', { worktree: '/tmp/checkout-b' })).toBe(true);
-  // Terminal row never even consults claudePidAlive — only a 'running' row does.
-  expect(claudePidAlive).not.toHaveBeenCalled();
-  expect(hasLiveHolder).toHaveBeenCalledWith('/tmp/checkout-b', undefined);
-});
-
-test('isLive returns false when there is no matching row and no cwd holder', () => {
-  const isLive = buildJobWorktreeIsLive({
-    bootJobs: [],
-    claudePidAlive: () => true,
-    hasLiveHolder: () => false,
-  });
-  expect(isLive('job-c', { worktree: '/tmp/checkout-c' })).toBe(false);
-});
-
-test('a precomputed cwdHolders set is forwarded through to hasLiveHolder unchanged', () => {
-  const holders = new Set(['/tmp/precomputed']);
-  const hasLiveHolder = vi.fn(() => false);
-  const isLive = buildJobWorktreeIsLive({
-    bootJobs: [],
-    claudePidAlive: () => false,
-    hasLiveHolder,
-    cwdHolders: holders,
-  });
-  isLive('job-d', { worktree: '/tmp/checkout-d' });
-  expect(hasLiveHolder).toHaveBeenCalledWith('/tmp/checkout-d', holders);
-});
-
-test('rowPid (the record/log ladder) is consulted instead of runtime.pid alone', () => {
-  const claudePidAlive = vi.fn((pid) => pid === 777);
-  const isLive = buildJobWorktreeIsLive({
-    bootJobs: [{ slug: 'job-e', status: 'running' }],
-    claudePidAlive,
-    hasLiveHolder: () => false,
-    rowPid: () => 777,
-  });
-  expect(isLive('job-e', { worktree: '/tmp/checkout-e' })).toBe(true);
-});

package/src/main/lib/__tests__/landedSinceRun.test.cjs

@@ -1,133 +0,0 @@
-/**
- * landedSinceRun.test.cjs — the widened, path-scoped commit evidence helper
- * behind reverifyNeedsReview's looksDone annotation (PRD 1102).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/landedSinceRun.test.cjs
- */
-
-'use strict';
-
-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');
-const { execFileSync } = require('node:child_process');
-const { landedSinceRun, landedOnMainSince } = require('../landedSinceRun.cjs');
-
-function mkRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-since-run-'));
-  execFileSync('git', ['-C', dir, 'init', '-q']);
-  execFileSync('git', ['-C', dir, 'config', 'user.email', 'test@test.com']);
-  execFileSync('git', ['-C', dir, 'config', 'user.name', 'Test']);
-  return dir;
-}
-
-// -b main pins the branch name regardless of the host's init.defaultBranch
-// config — landedOnMainSince's tests need a deterministic 'main' ref.
-function mkRepoOnMain() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-on-main-'));
-  execFileSync('git', ['-C', dir, 'init', '-q', '-b', 'main']);
-  execFileSync('git', ['-C', dir, 'config', 'user.email', 'test@test.com']);
-  execFileSync('git', ['-C', dir, 'config', 'user.name', 'Test']);
-  return dir;
-}
-
-function commitFile(dir, relPath, content, message) {
-  const abs = path.join(dir, relPath);
-  fs.mkdirSync(path.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, content);
-  execFileSync('git', ['-C', dir, 'add', relPath]);
-  execFileSync('git', ['-C', dir, 'commit', '-q', '-m', message]);
-}
-
-test('finds a commit landed after sinceIso that touches a declared path', async () => {
-  const dir = mkRepo();
-  const since = new Date().toISOString();
-  await new Promise((r) => setTimeout(r, 1100)); // git --since has 1s resolution
-  commitFile(dir, 'src/foo.js', 'hello', 'touch foo');
-  const shas = await landedSinceRun(dir, since, ['src/foo.js']);
-  assert.strictEqual(shas.length, 1);
-});
-
-test('ignores a commit that does not touch any declared path', async () => {
-  const dir = mkRepo();
-  const since = new Date().toISOString();
-  await new Promise((r) => setTimeout(r, 1100));
-  commitFile(dir, 'src/unrelated.js', 'hello', 'touch unrelated');
-  const shas = await landedSinceRun(dir, since, ['src/foo.js']);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('empty paths never fabricates evidence — resolves []', async () => {
-  const dir = mkRepo();
-  commitFile(dir, 'src/foo.js', 'hello', 'touch foo');
-  const shas = await landedSinceRun(dir, new Date(0).toISOString(), []);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('no cwd resolves [] without throwing', async () => {
-  const shas = await landedSinceRun(null, new Date().toISOString(), ['src/foo.js']);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('git-unavailable (non-repo cwd) resolves [] without throwing', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-since-run-norepo-'));
-  const shas = await landedSinceRun(dir, new Date().toISOString(), ['src/foo.js']);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('has a bounded default timeout', () => {
-  const { LANDED_SINCE_RUN_TIMEOUT_MS } = require('../landedSinceRun.cjs');
-  assert.ok(LANDED_SINCE_RUN_TIMEOUT_MS > 0 && LANDED_SINCE_RUN_TIMEOUT_MS <= 60_000);
-});
-
-// landedOnMainSince — PRD 1136's already-satisfied-on-main evidence query:
-// scoped to `main` (not --all) and to the PRD's declared paths.
-
-test('landedOnMainSince: finds a commit on main after sinceIso touching a declared path', async () => {
-  const dir = mkRepoOnMain();
-  commitFile(dir, 'README.md', 'hello', 'initial');
-  const since = new Date().toISOString();
-  await new Promise((r) => setTimeout(r, 1100));
-  commitFile(dir, 'src/foo.js', 'hello', 'fix foo');
-  const shas = await landedOnMainSince(dir, since, ['src/foo.js']);
-  assert.strictEqual(shas.length, 1);
-});
-
-test('landedOnMainSince: ignores a commit that does not touch any declared path', async () => {
-  const dir = mkRepoOnMain();
-  commitFile(dir, 'README.md', 'hello', 'initial');
-  const since = new Date().toISOString();
-  await new Promise((r) => setTimeout(r, 1100));
-  commitFile(dir, 'src/unrelated.js', 'hello', 'touch unrelated');
-  const shas = await landedOnMainSince(dir, since, ['src/foo.js']);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('landedOnMainSince: a commit older than sinceIso is not evidence', async () => {
-  const dir = mkRepoOnMain();
-  commitFile(dir, 'src/foo.js', 'hello', 'fix foo');
-  await new Promise((r) => setTimeout(r, 1100));
-  const since = new Date().toISOString();
-  const shas = await landedOnMainSince(dir, since, ['src/foo.js']);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('landedOnMainSince: empty paths never fabricates evidence — resolves []', async () => {
-  const dir = mkRepoOnMain();
-  commitFile(dir, 'src/foo.js', 'hello', 'fix foo');
-  const shas = await landedOnMainSince(dir, new Date(0).toISOString(), []);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('landedOnMainSince: no cwd resolves [] without throwing', async () => {
-  const shas = await landedOnMainSince(null, new Date().toISOString(), ['src/foo.js']);
-  assert.deepStrictEqual(shas, []);
-});
-
-test('landedOnMainSince: git-unavailable (non-repo cwd) resolves [] without throwing', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-on-main-norepo-'));
-  const shas = await landedOnMainSince(dir, new Date().toISOString(), ['src/foo.js']);
-  assert.deepStrictEqual(shas, []);
-});