claude-code-session-manager 0.98.0 → 0.100.0

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

@@ -1,183 +0,0 @@
-/**
- * schedulerMcpServerProjectHome.test.cjs — the single project_home_write MCP
- * tool that wraps POST /admin/project-home/write.
- * Covers: presence in TOOLS, catalog-composed descriptions, correct
- * route/payload dispatch via a stubbed admin HTTP server, cwd defaulting to
- * SM_PROJECT_ROOT/process.cwd() when omitted, and the app-not-running failure
- * shape.
- *
- * Same HOME-repointing pattern as schedulerMcpServerHelp.test.cjs — see that
- * file's header for why.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerMcpServerProjectHome.test.cjs
- */
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const http = require('node:http');
-const os = require('node:os');
-const path = require('node:path');
-
-const SERVER_PATH = path.join(__dirname, '../../../../scripts/scheduler-mcp-server.cjs');
-const { MCP_TOOL_CATALOG, composeDescription } = require('../mcpToolCatalog.cjs');
-
-const TOOL_NAME = 'project_home_write';
-const OLD_TOOL_NAMES = [
-  'project_home_get_contract',
-  'project_home_validate_summary',
-  'project_home_render',
-  'project_home_status',
-];
-
-const tmpDirs = [];
-const servers = [];
-let originalHome;
-let originalProjectRoot;
-
-afterEach(async () => {
-  if (originalHome !== undefined) {
-    process.env.HOME = originalHome;
-    originalHome = undefined;
-  }
-  if (originalProjectRoot !== undefined) {
-    if (originalProjectRoot === null) delete process.env.SM_PROJECT_ROOT;
-    else process.env.SM_PROJECT_ROOT = originalProjectRoot;
-    originalProjectRoot = undefined;
-  }
-  delete require.cache[require.resolve(SERVER_PATH)];
-  while (servers.length) {
-    const s = servers.pop();
-    await new Promise((resolve) => s.close(resolve));
-  }
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkTmp() {
-  const d = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-mcp-project-home-'));
-  tmpDirs.push(d);
-  return d;
-}
-
-/** Starts a fake admin HTTP server that records every request and answers with `body`. */
-function startFakeAdminServer(token, body) {
-  const requests = [];
-  return new Promise((resolve) => {
-    const server = http.createServer((req, res) => {
-      const chunks = [];
-      req.on('data', (c) => chunks.push(c));
-      req.on('end', () => {
-        if (req.headers.authorization !== `Bearer ${token}`) {
-          res.writeHead(401, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ ok: false, error: 'bad token' }));
-          return;
-        }
-        const raw = Buffer.concat(chunks).toString('utf8');
-        requests.push({
-          method: req.method,
-          url: req.url,
-          body: raw ? JSON.parse(raw) : undefined,
-        });
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(body));
-      });
-    });
-    server.listen(0, '127.0.0.1', () => resolve({ server, requests }));
-  });
-}
-
-function requireServerWithHome(homeDir) {
-  originalHome = process.env.HOME;
-  process.env.HOME = homeDir;
-  delete require.cache[require.resolve(SERVER_PATH)];
-  const mod = require(SERVER_PATH);
-  // HOME stays redirected until afterEach: admin-token path resolves lazily.
-  return mod;
-}
-
-async function writeAdminConfig(homeDir, { port, token }) {
-  const tokenPath = path.join(homeDir, '.claude', 'session-manager', 'admin-api.json');
-  await fsp.mkdir(path.dirname(tokenPath), { recursive: true });
-  await fsp.writeFile(tokenPath, JSON.stringify({ port, token }), 'utf8');
-}
-
-function callTool(handleCallTool, name, args) {
-  return handleCallTool({ params: { name, arguments: args } });
-}
-
-test('project_home_write is the only project_home_* tool, with html required and cwd optional', async () => {
-  const homeDir = await mkTmp();
-  const { TOOLS } = requireServerWithHome(homeDir);
-  expect(TOOLS.filter((t) => t.name.startsWith('project_home_')).map((t) => t.name)).toEqual([TOOL_NAME]);
-  for (const old of OLD_TOOL_NAMES) expect(TOOLS.find((t) => t.name === old)).toBeUndefined();
-  const tool = TOOLS.find((t) => t.name === TOOL_NAME);
-  expect(tool.inputSchema.type).toBe('object');
-  expect(tool.inputSchema.properties.cwd).toBeTruthy();
-  expect(tool.inputSchema.properties.html).toBeTruthy();
-  expect(tool.inputSchema.required).toEqual(['html']);
-});
-
-test('project_home_write description equals the catalog-composed string; old entries are gone', async () => {
-  const homeDir = await mkTmp();
-  const { TOOLS } = requireServerWithHome(homeDir);
-  const tool = TOOLS.find((t) => t.name === TOOL_NAME);
-  const entry = MCP_TOOL_CATALOG.find((e) => e.name === TOOL_NAME);
-  expect(entry).toBeTruthy();
-  expect(entry.group).toBe('project-home');
-  expect(tool.description).toBe(composeDescription(entry));
-  for (const old of OLD_TOOL_NAMES) expect(MCP_TOOL_CATALOG.find((e) => e.name === old)).toBeUndefined();
-});
-
-test('project_home_write dispatches POST /admin/project-home/write with cwd+html', async () => {
-  const homeDir = await mkTmp();
-  const token = 'test-token';
-  const { server, requests } = await startFakeAdminServer(token, { ok: true, path: '/abs/home.html', bytes: 12 });
-  servers.push(server);
-  await writeAdminConfig(homeDir, { port: server.address().port, token });
-
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const html = '<!DOCTYPE html><html></html>';
-  const result = await callTool(handleCallTool, TOOL_NAME, { cwd: '/home/bilko/Projects/session-manager', html });
-  expect(result.isError).toBeFalsy();
-  expect(requests).toHaveLength(1);
-  expect(requests[0].method).toBe('POST');
-  expect(requests[0].url).toBe('/admin/project-home/write');
-  expect(requests[0].body).toEqual({ cwd: '/home/bilko/Projects/session-manager', html });
-});
-
-test('project_home_write requires a non-empty html', async () => {
-  const homeDir = await mkTmp();
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  for (const args of [{ cwd: '/x' }, { cwd: '/x', html: '' }]) {
-    const result = await callTool(handleCallTool, TOOL_NAME, args);
-    expect(result.isError).toBe(true);
-    expect(result.content[0].text).toContain('html');
-  }
-});
-
-test('project_home_write defaults cwd to SM_PROJECT_ROOT when omitted', async () => {
-  const homeDir = await mkTmp();
-  const token = 'test-token';
-  const { server, requests } = await startFakeAdminServer(token, { ok: true });
-  servers.push(server);
-  await writeAdminConfig(homeDir, { port: server.address().port, token });
-
-  originalProjectRoot = process.env.SM_PROJECT_ROOT ?? null;
-  process.env.SM_PROJECT_ROOT = '/home/bilko/Projects/session-manager/session-manager-operations/scheduler/epics/some-epic/worktree';
-
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  await callTool(handleCallTool, TOOL_NAME, { html: '<p>x</p>' });
-  expect(requests).toHaveLength(1);
-  expect(requests[0].body.cwd).toBe(process.env.SM_PROJECT_ROOT);
-});
-
-test('project_home_write returns the app-not-running error when the admin API is unreachable', async () => {
-  const homeDir = await mkTmp();
-  const { handleCallTool, NOT_RUNNING_ERROR } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, TOOL_NAME, { html: '<p>x</p>' });
-  expect(result.isError).toBe(true);
-  expect(result.content[0].text).toBe(NOT_RUNNING_ERROR);
-});

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

@@ -1,226 +0,0 @@
-/**
- * schedulerPaths.test.cjs — every machine-wide scheduler root resolves lazily
- * through lib/schedulerPaths.cjs, so SM_SCHEDULER_HOME redirects ALL of them.
- *
- * SM_SCHEDULER_HOME is set to a temp dir BEFORE the modules under test are
- * required; nothing here touches ~/.claude/session-manager.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerPaths.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 REPO = path.resolve(__dirname, '..', '..', '..', '..');
-// Every module the PRD routes through the resolver — a half-redirect in any of
-// them fails the source scan below.
-const ROUTED_MODULES = [
-  'src/main/scheduler.cjs',
-  'src/main/queueOps.cjs',
-  'src/main/lib/queueStore.cjs',
-  'src/main/lib/sessionSlots.cjs',
-  'src/main/lib/localAdminHttp.cjs',
-  'src/main/lib/watchdogHelpers.cjs',
-  'src/main/health.cjs',
-  'scripts/scheduler-watchdog.cjs',
-  'src/main/lib/auditLog.cjs',
-  'src/main/lib/historyRollup.cjs',
-  'src/main/lib/queueHistory.cjs',
-  'src/main/lib/instanceLock.cjs',
-  'src/main/lib/procName.cjs',
-  'src/main/heapSnapshot.cjs',
-  'scripts/scheduler-mcp-server.cjs',
-  'scripts/replay-verdicts.cjs',
-  'scripts/audit-ops-hygiene.cjs',
-];
-
-const ENV_KEYS = ['SM_SCHEDULER_HOME', 'SM_SCHEDULER_LOG_CWD', 'SM_ADMIN_TOKEN_PATH', 'SM_DEV', 'SM_E2E'];
-const savedEnv = {};
-let tmpHome;
-let sp;
-
-beforeAll(() => {
-  for (const k of ENV_KEYS) savedEnv[k] = process.env[k];
-  for (const k of ['SM_SCHEDULER_LOG_CWD', 'SM_ADMIN_TOKEN_PATH', 'SM_DEV', 'SM_E2E']) delete process.env[k];
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-scheduler-home-'));
-  process.env.SM_SCHEDULER_HOME = tmpHome;
-  sp = require('../schedulerPaths.cjs');
-});
-
-afterAll(() => {
-  for (const k of ENV_KEYS) {
-    if (savedEnv[k] === undefined) delete process.env[k]; else process.env[k] = savedEnv[k];
-  }
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('every resolver lands under SM_SCHEDULER_HOME', () => {
-  expect(sp.schedulerHome()).toBe(tmpHome);
-  const plans = path.join(tmpHome, 'scheduled-plans');
-  expect(sp.scheduledPlansRoot()).toBe(plans);
-  expect(sp.runsDir()).toBe(path.join(plans, 'runs'));
-  expect(sp.prdsRoot()).toBe(path.join(plans, 'prds'));
-  expect(sp.legacyQueuePath()).toBe(path.join(plans, 'queue.json'));
-  expect(sp.machineStatePath()).toBe(path.join(tmpHome, 'scheduler-machine.json'));
-  expect(sp.schedulerStatePath()).toBe(path.join(tmpHome, 'scheduler-state.json'));
-  expect(sp.heartbeatPath()).toBe(path.join(tmpHome, 'scheduler-heartbeat.log'));
-  expect(sp.sessionSlotsConfigPath()).toBe(path.join(tmpHome, 'session-slots-config.json'));
-  expect(sp.adminTokenPath()).toBe(path.join(tmpHome, 'admin-api.json'));
-  expect(sp.watchdogLogsDir()).toBe(path.join(tmpHome, 'logs'));
-});
-
-test('resolvers are lazy: changing the env changes the result without re-requiring', () => {
-  const other = path.join(tmpHome, 'other');
-  process.env.SM_SCHEDULER_HOME = other;
-  try {
-    expect(sp.runsDir()).toBe(path.join(other, 'scheduled-plans', 'runs'));
-  } finally {
-    process.env.SM_SCHEDULER_HOME = tmpHome;
-  }
-});
-
-test('default home is ~/.claude/session-manager', () => {
-  delete process.env.SM_SCHEDULER_HOME;
-  try {
-    expect(sp.schedulerHome()).toBe(path.join(os.homedir(), '.claude', 'session-manager'));
-  } finally {
-    process.env.SM_SCHEDULER_HOME = tmpHome;
-  }
-});
-
-test('adminTokenPath keeps the SM_ADMIN_TOKEN_PATH > SM_DEV > SM_E2E ladder', () => {
-  try {
-    process.env.SM_E2E = '1';
-    expect(sp.adminTokenPath()).toBe(path.join(tmpHome, 'admin-api.e2e.json'));
-    process.env.SM_DEV = '1';
-    expect(sp.adminTokenPath()).toBe(path.join(tmpHome, 'admin-api.dev.json'));
-    process.env.SM_ADMIN_TOKEN_PATH = path.join(os.tmpdir(), 'explicit-token.json');
-    expect(sp.adminTokenPath()).toBe(path.join(os.tmpdir(), 'explicit-token.json'));
-  } finally {
-    delete process.env.SM_E2E; delete process.env.SM_DEV; delete process.env.SM_ADMIN_TOKEN_PATH;
-  }
-});
-
-test('machineStateLogCwd is the literal ~/Projects/session-manager unless overridden (never process.cwd())', () => {
-  expect(sp.machineStateLogCwd()).toBe(path.join(os.homedir(), 'Projects', 'session-manager'));
-  process.env.SM_SCHEDULER_LOG_CWD = path.join(os.tmpdir(), 'log-cwd');
-  try {
-    expect(sp.machineStateLogCwd()).toBe(path.join(os.tmpdir(), 'log-cwd'));
-  } finally {
-    delete process.env.SM_SCHEDULER_LOG_CWD;
-  }
-});
-
-test('queueStore: paths and readMergedSync resolve under the override', () => {
-  const queueStore = require('../queueStore.cjs');
-  expect(queueStore.MACHINE_STATE_PATH).toBe(sp.machineStatePath());
-  expect(queueStore.LEGACY_QUEUE_PATH).toBe(sp.legacyQueuePath());
-  fs.writeFileSync(sp.machineStatePath(), JSON.stringify({ paused: null, lastRunAt: 4242 }));
-  const merged = queueStore.readMergedSync();
-  expect(merged.unreadable).toBeUndefined();
-  expect(merged.lastRunAt).toBe(4242);
-});
-
-test('sessionSlots: persisted cap is read from and written under the override', () => {
-  const slots = require('../sessionSlots.cjs');
-  slots.setCap(7);
-  const cfg = sp.sessionSlotsConfigPath();
-  expect(JSON.parse(fs.readFileSync(cfg, 'utf8')).cap).toBe(7);
-  expect(slots.totalSlots()).toBe(7);
-  slots.__resetForTests?.();
-});
-
-test('localAdminHttp: TOKEN_PATH / resolveTokenPath follow the resolver', () => {
-  const admin = require('../localAdminHttp.cjs');
-  expect(admin.TOKEN_PATH).toBe(path.join(tmpHome, 'admin-api.json'));
-  expect(admin.resolveTokenPath()).toBe(admin.TOKEN_PATH);
-});
-
-test('scheduler / queueOps / watchdogHelpers path exports follow the override', () => {
-  const scheduler = require('../../scheduler.cjs');
-  expect(scheduler.ROOT).toBe(sp.scheduledPlansRoot());
-  expect(scheduler.PRDS_DIR).toBe(sp.prdsRoot());
-  expect(scheduler.RUNS_DIR).toBe(sp.runsDir());
-  expect(scheduler.SCHEDULER_STATE_PATH).toBe(sp.schedulerStatePath());
-  const queueOps = require('../../queueOps.cjs');
-  expect(queueOps.PRDS_DIR).toBe(sp.prdsRoot());
-  expect(queueOps.PRDS_ARCHIVE_DIR).toBe(path.join(sp.scheduledPlansRoot(), 'prds-archived'));
-  const wd = require('../watchdogHelpers.cjs');
-  expect(wd.DEFAULT_HEARTBEAT_PATH).toBe(sp.heartbeatPath());
-  expect(wd.DEFAULT_LOCK_PATH).toBe(sp.historyRollupLockPath());
-  expect(wd.DEFAULT_STAMP_PATH).toBe(sp.historyRollupStampPath());
-  expect(wd.DEFAULT_RELAUNCH_STATE_PATH).toBe(sp.watchdogRelaunchStatePath());
-});
-
-test('auditLog, historyRollup, queueHistory, instanceLock, procName, heapSnapshot land under SM_SCHEDULER_HOME', () => {
-  const saved = {};
-  for (const k of ['SM_HISTORY_PATH_OVERRIDE', 'SM_SCHEDULER_LOCK_PATH']) { saved[k] = process.env[k]; delete process.env[k]; }
-  try {
-    const auditLog = require('../auditLog.cjs');
-    expect(auditLog.auditLogPath()).toBe(path.join(tmpHome, 'audit-log.jsonl'));
-    auditLog.appendAuditEvent('schedulerPaths_test', {});
-    expect(fs.existsSync(path.join(tmpHome, 'audit-log.jsonl'))).toBe(true);
-    expect(require('../historyRollup.cjs').historyRollupPath()).toBe(path.join(tmpHome, 'history-rollup.jsonl'));
-    expect(require('../queueHistory.cjs').historyPath()).toBe(path.join(tmpHome, 'scheduled-plans', 'history.jsonl'));
-    expect(require('../instanceLock.cjs').lockPath()).toBe(path.join(tmpHome, 'scheduler-owner.lock'));
-    expect(require('../procName.cjs').procnamesRoot()).toBe(path.join(tmpHome, 'procnames'));
-    expect(sp.heapSnapshotDir()).toBe(tmpHome);
-  } finally {
-    for (const k of Object.keys(saved)) { if (saved[k] === undefined) delete process.env[k]; else process.env[k] = saved[k]; }
-  }
-});
-
-test.each(ROUTED_MODULES)('%s derives no home-rooted path from os.homedir() itself', (rel) => {
-  const src = fs.readFileSync(path.join(REPO, rel), 'utf8');
-  const offenders = src.split('\n').filter((l) => {
-    const t = l.trim();
-    if (t.startsWith('*') || t.startsWith('//')) return false;
-    return /os\.homedir\(\).*(\.claude|session-manager|scheduled-plans)/.test(l)
-      || (/os\.homedir\(\)/.test(l) && /Projects/.test(l));
-  });
-  expect(offenders).toEqual([]);
-  expect(src).toMatch(/schedulerPaths\.cjs/);
-});
-
-test('assertNotLiveRoot throws under vitest for a path outside the override roots and os.tmpdir(), naming resolver + path', () => {
-  const live = path.join(path.parse(os.homedir()).root, 'definitely-not-tmp', 'live-root');
-  // os.tmpdir() may itself be "/", so only assert the throw when the path is really outside it.
-  const rel = path.relative(os.tmpdir(), live);
-  if (rel.startsWith('..') || path.isAbsolute(rel)) {
-    expect(() => sp.assertNotLiveRoot(live, 'someResolver')).toThrow(/someResolver.*live-root|live-root.*someResolver/s);
-  }
-  const ok = path.join(os.tmpdir(), 'fine');
-  expect(sp.assertNotLiveRoot(ok, 'someResolver')).toBe(ok);
-});
-
-test('an empty SM_SCHEDULER_HOME falls through to the real ~/.claude and the guard fires', () => {
-  const { spawnSync } = require('node:child_process');
-  const r = spawnSync(process.execPath, ['-e', "require('./src/main/lib/schedulerPaths.cjs').schedulerHome()"], {
-    cwd: REPO,
-    env: { ...process.env, SM_SCHEDULER_HOME: '', VITEST: '1', HOME: '/home/definitely-live-user' },
-    encoding: 'utf8',
-  });
-  expect(r.status).not.toBe(0);
-  expect(r.stderr).toMatch(/schedulerHome\(\) resolved to live root/);
-});
-
-// 2026-09-18 defaultCwd leak: the guard's allow-list is env-derived, so a live SM_SCHEDULER_HOME
-// (inherited from the app) or a mid-test HOME swap let a test write the LIVE machine file.
-// The passwd-home anchor must refuse the live root no matter what the env says.
-test('under VITEST the passwd-home live root is refused even when SM_SCHEDULER_HOME names it', async () => {
-  const liveHome = path.join(os.userInfo().homedir, '.claude', 'session-manager');
-  process.env.SM_SCHEDULER_HOME = liveHome;
-  try {
-    expect(() => sp.machineStatePath()).toThrow(/live root/);
-    // the path the leak wrote through: the machine-state read/write refuses instead of touching it
-    const queueStore = require('../queueStore.cjs');
-    expect(() => queueStore.MACHINE_STATE_PATH).toThrow(/live root/);
-    await expect(queueStore.writeSplit({ jobs: [], config: {} }, os.tmpdir())).rejects.toThrow(/live root/);
-  } finally {
-    process.env.SM_SCHEDULER_HOME = tmpHome;
-  }
-});

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

@@ -1,133 +0,0 @@
-/**
- * schedulerPathsWorktree.test.cjs — SM_WORKTREE_ROOT moves the job + epic
- * worktree roots (and isEphemeralCwd) as a unit; the real os.tmpdir() roots are
- * never touched.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerPathsWorktree.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 gitWorktree = require('../gitWorktree.cjs');
-const schedulerPaths = require('../schedulerPaths.cjs');
-const { isEphemeralCwd } = require('../ephemeralCwd.cjs');
-
-let scratch;
-let override;
-let repo;
-let prevRoot;
-let prevDisable;
-
-function git(args, cwd) { return execFileSync('git', args, { cwd, encoding: 'utf8' }); }
-// Probe checkouts (keys starting wtroot-probe) found anywhere under a root. Other
-// suites in the same worker pool share the real root, so a whole-listing
-// comparison would be flaky; the probe key is unique to this file.
-function probesUnder(root) {
-  const found = [];
-  let hashes = [];
-  try { hashes = fs.readdirSync(root); } catch { return found; }
-  for (const h of hashes) {
-    try {
-      for (const k of fs.readdirSync(path.join(root, h))) if (k.startsWith('wtroot-probe')) found.push(`${h}/${k}`);
-    } catch { /* not a dir */ }
-  }
-  return found;
-}
-
-beforeEach(() => {
-  prevRoot = process.env.SM_WORKTREE_ROOT;
-  prevDisable = process.env.SM_JOB_WORKTREE_DISABLE;
-  delete process.env.SM_JOB_WORKTREE_DISABLE;
-  scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-wtroot-test-'));
-  override = path.join(scratch, 'override');
-  repo = path.join(scratch, 'repo');
-  fs.mkdirSync(override, { recursive: true });
-  fs.mkdirSync(repo, { recursive: true });
-  git(['init', '-q'], repo);
-  git(['config', 'user.email', 't@example.com'], repo);
-  git(['config', 'user.name', 'T'], repo);
-  fs.writeFileSync(path.join(repo, 'README.md'), 'hi\n');
-  git(['add', '-A'], repo);
-  git(['commit', '-q', '-m', 'init'], repo);
-  process.env.SM_WORKTREE_ROOT = override;
-});
-
-afterEach(() => {
-  if (prevRoot === undefined) delete process.env.SM_WORKTREE_ROOT; else process.env.SM_WORKTREE_ROOT = prevRoot;
-  if (prevDisable === undefined) delete process.env.SM_JOB_WORKTREE_DISABLE; else process.env.SM_JOB_WORKTREE_DISABLE = prevDisable;
-  fs.rmSync(scratch, { recursive: true, force: true });
-});
-
-test('resolver and KIND_CONFIG roots follow SM_WORKTREE_ROOT together', () => {
-  expect(schedulerPaths.worktreeRoot('job')).toBe(path.join(override, 'session-manager-job-worktrees'));
-  expect(schedulerPaths.worktreeRoot('epic')).toBe(path.join(override, 'session-manager-epic-worktrees'));
-  expect(gitWorktree.KIND_CONFIG.job.root).toBe(schedulerPaths.worktreeRoot('job'));
-  expect(gitWorktree.KIND_CONFIG.epic.root).toBe(schedulerPaths.worktreeRoot('epic'));
-});
-
-test('unset SM_WORKTREE_ROOT resolves the persistent per-user dir (0700, created), never os.tmpdir()', () => {
-  const state = path.join(scratch, 'state');
-  const prevXdg = process.env.XDG_STATE_HOME;
-  process.env.XDG_STATE_HOME = state;
-  delete process.env.SM_WORKTREE_ROOT;
-  try {
-    // scratch lives under os.tmpdir(), so the state dir passes the (unchanged) guard as a tmp child.
-    const base = schedulerPaths.worktreeBase();
-    expect(base).toBe(path.join(state, 'session-manager'));
-    expect(base).not.toBe(os.tmpdir());
-    expect(fs.statSync(base).mode & 0o777).toBe(0o700);
-    expect(schedulerPaths.worktreeRoot('epic')).toBe(path.join(base, 'session-manager-epic-worktrees'));
-  } finally {
-    if (prevXdg === undefined) delete process.env.XDG_STATE_HOME; else process.env.XDG_STATE_HOME = prevXdg;
-  }
-});
-
-test('the vitest guard still throws for a live default (no SM_WORKTREE_ROOT, real ~/.local/state) and creates nothing', () => {
-  const prevXdg = process.env.XDG_STATE_HOME;
-  delete process.env.XDG_STATE_HOME;
-  delete process.env.SM_WORKTREE_ROOT;
-  const prevHome = process.env.HOME;
-  const fakeHome = path.join(scratch, 'nohome');
-  process.env.HOME = '/nonexistent-live-home-for-guard-test';
-  try {
-    expect(() => schedulerPaths.worktreeBase()).toThrow(/live root/);
-    expect(fs.existsSync(path.join(fakeHome, '.local'))).toBe(false);
-  } finally {
-    process.env.HOME = prevHome;
-    if (prevXdg !== undefined) process.env.XDG_STATE_HOME = prevXdg;
-  }
-});
-
-test('SM_WORKTREE_ROOT set wins over the persistent default', () => {
-  process.env.XDG_STATE_HOME = path.join(scratch, 'ignored');
-  try {
-    expect(schedulerPaths.worktreeBase()).toBe(override);
-    expect(fs.existsSync(path.join(scratch, 'ignored'))).toBe(false);
-  } finally { delete process.env.XDG_STATE_HOME; }
-});
-
-test('create / sweep / isEphemeralCwd operate under the override, never the real root', async () => {
-  const realJobRoot = path.join(os.tmpdir(), 'session-manager-job-worktrees');
-  expect(probesUnder(realJobRoot)).toEqual([]);
-
-  const res = await gitWorktree.createJobWorktree({ cwd: repo, slug: 'wtroot-probe' });
-  expect(res.ok).toBe(true);
-  expect(res.dir.startsWith(path.join(override, 'session-manager-job-worktrees') + path.sep)).toBe(true);
-  expect(isEphemeralCwd(res.dir)).toBe(true);
-
-  const sweep = await gitWorktree.sweepStaleWorktreeCheckouts('job', { staleAgeMs: 0, holders: new Set() });
-  expect(sweep.checkoutsRemoved).toBeGreaterThanOrEqual(1);
-  expect(fs.existsSync(res.dir)).toBe(false);
-
-  const again = await gitWorktree.createJobWorktree({ cwd: repo, slug: 'wtroot-probe-2' });
-  expect(again.ok).toBe(true);
-  await gitWorktree.cleanupJobWorktree({ cwd: repo, dir: again.dir, branch: again.branch });
-  expect(fs.existsSync(override)).toBe(true); // the guard never rmdir's the base
-
-  expect(probesUnder(realJobRoot)).toEqual([]);
-});

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

@@ -1,56 +0,0 @@
-// schedulerRuntimeState.cjs + quietMachineLease.cjs — fail-closed expiry.
-const assert = require('node:assert');
-const state = require('../schedulerRuntimeState.cjs');
-const lease = require('../quietMachineLease.cjs');
-
-const NOW = 10_000_000;
-const GRACE = 10 * 60 * 1000;
-
-beforeEach(() => { state.__resetForTests(); lease.__resetForTests(); });
-afterEach(() => { state.__resetForTests(); lease.__resetForTests(); });
-
-test('lease: expires only when holder not running AND past grace', () => {
-  lease.acquire('q', { claimedAt: NOW - GRACE - 1 });
-  assert.equal(lease.expireDead({ liveSlugs: new Set(['q']), now: NOW, graceMs: GRACE }), false, 'running row keeps it');
-  assert.equal(lease.isHeld(), true);
-  assert.equal(lease.expireDead({ liveSlugs: new Set(), now: NOW, graceMs: GRACE }), true);
-  assert.equal(lease.isHeld(), false);
-});
-
-test('lease: inside the grace window or claimed after the pass began is kept', () => {
-  lease.acquire('q', { claimedAt: NOW - 1000 });
-  assert.equal(lease.expireDead({ liveSlugs: new Set(), now: NOW, graceMs: GRACE }), false);
-  lease.release('q');
-  lease.acquire('q', { claimedAt: NOW + 10 });
-  assert.equal(lease.expireDead({ liveSlugs: new Set(), now: NOW, graceMs: GRACE }), false);
-  assert.equal(lease.isHeld(), true);
-});
-
-test('investigations: set semantics, no double reservation, idempotent release', () => {
-  assert.equal(state.reserveInvestigation('a'), true);
-  assert.equal(state.reserveInvestigation('a'), false);
-  assert.equal(state.investigationCount(), 1);
-  assert.equal(state.releaseInvestigation('a'), true);
-  assert.equal(state.releaseInvestigation('a'), false);
-  assert.equal(state.investigationCount(), 0);
-});
-
-test('investigations: dead stamped pid with no investigating row expires; live pid/row survives', () => {
-  state.reserveInvestigation('dead', { claimedAt: NOW - 1000 });
-  state.stampInvestigationPid('dead', 111);
-  state.reserveInvestigation('alive', { claimedAt: NOW - 1000 });
-  state.stampInvestigationPid('alive', 222);
-  state.reserveInvestigation('rowlive', { claimedAt: NOW - 2 * GRACE });
-  const out = state.expireDeadInvestigations({
-    liveSlugs: new Set(['rowlive']), pidAlive: (p) => p === 222, now: NOW, graceMs: GRACE,
-  });
-  assert.deepEqual(out, ['dead']);
-  assert.equal(state.investigationCount(), 2);
-});
-
-test('investigations: pidless reservation expires past grace only', () => {
-  state.reserveInvestigation('old', { claimedAt: NOW - GRACE - 1 });
-  state.reserveInvestigation('fresh', { claimedAt: NOW - 1000 });
-  const out = state.expireDeadInvestigations({ liveSlugs: new Set(), pidAlive: () => false, now: NOW, graceMs: GRACE });
-  assert.deepEqual(out, ['old']);
-});