claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/schedulerBatchRootBlocker.test.cjs

@@ -1,117 +0,0 @@
-'use strict';
-
-// PRD 1123 — a single row parked in `needs_review` (or `failed`/`skipped`)
-// several dependsOn hops down used to read as generic starvation: the picker
-// only ever named a held job's IMMEDIATE dep, which is very often just
-// another `pending` row, not the actual cause. These tests pin the root-
-// blocker walk: the reason must name the transitive ancestor that is itself
-// not blocked by anything, plus the count of jobs held behind it and its
-// status — and must terminate (not hang) on a dependsOn cycle.
-//
-// Run: timeout 120 npx vitest run src/main/__tests__/schedulerBatchRootBlocker.test.cjs
-
-const assert = require('node:assert/strict');
-const { pickForProject, DEFAULT_PROJECT_CWD } = require('../lib/schedulerBatch.cjs');
-
-const CWD = DEFAULT_PROJECT_CWD;
-
-function job(slug, status, extra = {}) {
-  return { slug, status, cwd: CWD, dependsOn: [], ...extra };
-}
-
-test('a 3-deep chain rooted at a needs_review row names the ROOT, not the middle link', () => {
-  const jobs = [
-    job('100-root', 'needs_review'),
-    job('101-middle', 'pending', { dependsOn: ['100-root'] }),
-    job('102-leaf', 'pending', { dependsOn: ['101-middle'] }),
-  ];
-  const { batch, reason, holds } = pickForProject(jobs, new Set(), 3);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /depends-gate/);
-  // Names the root, not the immediate (middle) dep as the cause.
-  assert.match(reason, /root blocker 100-root/);
-  assert.match(reason, /needs_review/);
-  assert.match(reason, /is a QUESTION awaiting a human/);
-  // Both downstream jobs are counted as held behind the root.
-  assert.match(reason, /holding 2 job\(s\)/);
-  assert.match(reason, /101-middle/);
-  assert.match(reason, /102-leaf/);
-
-  const leafHold = holds.find((h) => h.slug === '102-leaf');
-  assert.equal(leafHold.dep, '101-middle'); // immediate dep still recorded
-  assert.equal(leafHold.rootSlug, '100-root'); // but the row also knows the root
-  assert.equal(leafHold.rootStatus, 'needs_review');
-});
-
-test('the same 3-deep chain rooted at a FAILED row names the root, not the middle link', () => {
-  const jobs = [
-    job('200-root', 'failed'),
-    job('201-middle', 'pending', { dependsOn: ['200-root'] }),
-    job('202-leaf', 'pending', { dependsOn: ['201-middle'] }),
-  ];
-  const { batch, reason, holds } = pickForProject(jobs, new Set(), 3);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /root blocker 200-root/);
-  assert.match(reason, /\(failed\)/);
-  assert.match(reason, /holding 1 job\(s\)/); // only 202-leaf: 201-middle is caught by the shallow failed-dep bucket
-  assert.match(reason, /Reset or archive 200-root/);
-
-  const leafHold = holds.find((h) => h.slug === '202-leaf');
-  assert.equal(leafHold.rootSlug, '200-root');
-  assert.equal(leafHold.rootStatus, 'failed');
-  const middleHold = holds.find((h) => h.slug === '201-middle');
-  assert.equal(middleHold.rootSlug, '200-root');
-  assert.equal(middleHold.rootStatus, 'failed');
-});
-
-test('a 2-node dependsOn cycle is reported as its own reason, not a hang', () => {
-  const jobs = [
-    job('300-a', 'pending', { dependsOn: ['301-b'] }),
-    job('301-b', 'pending', { dependsOn: ['300-a'] }),
-  ];
-  const start = Date.now();
-  const { batch, reason } = pickForProject(jobs, new Set(), 3);
-  assert.ok(Date.now() - start < 5000, 'must terminate quickly, not hang');
-  assert.deepEqual(batch, []);
-  assert.match(reason, /CYCLE/);
-  assert.match(reason, /300-a/);
-  assert.match(reason, /301-b/);
-  // Reported exactly once, not once per member.
-  assert.equal((reason.match(/CYCLE/g) || []).length, 1);
-});
-
-test('no false stall reported when the gate is not the reason the batch is empty (slots exhausted)', () => {
-  const jobs = [job('400-a', 'pending'), job('401-b', 'pending')];
-  const { batch, reason } = pickForProject(jobs, new Set(), 0);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /no slots free/);
-  assert.doesNotMatch(reason, /root blocker/);
-});
-
-test('no false stall reported when the gate is not the reason the batch is empty (project cap)', () => {
-  const prevCap = process.env.SM_PROJECT_JOB_CAP;
-  process.env.SM_PROJECT_JOB_CAP = '1';
-  try {
-    const jobs = [
-      job('402-running', 'running'),
-      job('403-pending', 'pending'),
-    ];
-    const { batch, reason } = pickForProject(jobs, new Set(['402-running']), 3);
-    assert.deepEqual(batch, []);
-    assert.match(reason, /project-cap/);
-    assert.doesNotMatch(reason, /root blocker/);
-  } finally {
-    if (prevCap === undefined) delete process.env.SM_PROJECT_JOB_CAP;
-    else process.env.SM_PROJECT_JOB_CAP = prevCap;
-  }
-});
-
-test('a running/pending-rooted chain reports no stall reason (expected to clear on its own)', () => {
-  const jobs = [
-    job('500-root', 'running'),
-    job('501-dependent', 'pending', { dependsOn: ['500-root'] }),
-  ];
-  const { batch, reason } = pickForProject(jobs, new Set(['500-root']), 3);
-  assert.deepEqual(batch, []);
-  assert.equal(reason, null);
-});

package/src/main/__tests__/schedulerStateSidecarRestore.test.cjs

@@ -1,110 +0,0 @@
-/**
- * schedulerStateSidecarRestore.test.cjs — covers PRD 1392: scheduler-state.json
- * previously left lastPollOk, lastFailureKind, backoffNextAt, cachedUtilization and
- * cachedBindingWindowName memory-only, so a fresh boot showed misleading footer/KPI
- * placeholders (a healthy poller reading "failed", a still-rate-limited state
- * un-showable, utilization stuck at "—") until the next post-boot billing poll
- * overwrote them. Proves loadSchedulerState() restores all five from disk instead of
- * leaving the hardcoded defaults (false / null / null / null / null) in place.
- *
- * scheduler.cjs is a plain CJS require (like rateLimitPollerStreak.test.cjs's), so its
- * module-level `let`s are a singleton for this test file's process — the first test
- * below captures the pre-load snapshot itself (the hardcoded defaults) rather than
- * assuming a fresh module per test, so the proof doesn't depend on test ordering.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/schedulerStateSidecarRestore.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const { loadSchedulerState, persistSchedulerState, getSchedulerStateSnapshot } = require('../scheduler.cjs');
-const schedulerPaths = require('../lib/schedulerPaths.cjs');
-
-function writeSidecar(data) {
-  fs.mkdirSync(path.dirname(schedulerPaths.schedulerStatePath()), { recursive: true });
-  fs.writeFileSync(schedulerPaths.schedulerStatePath(), JSON.stringify(data));
-}
-
-beforeEach(() => {
-  try { fs.unlinkSync(schedulerPaths.schedulerStatePath()); } catch { /* no sidecar yet */ }
-});
-
-test('loadSchedulerState restores lastPollOk/lastFailureKind/backoffNextAt/cachedUtilization/cachedBindingWindowName from the sidecar, not the hardcoded defaults', () => {
-  // Before a restore, the module starts (or was left, by whatever ran before this test
-  // in-process) at whatever it was — capture it so the assertion below is a genuine
-  // "changed to match the file" proof, not an assumption about fresh-module defaults.
-  const before = getSchedulerStateSnapshot();
-
-  const written = {
-    version: 1,
-    lastPollOk: true,
-    lastFailureKind: 'meter_rate_limited',
-    backoffNextAt: 1_726_000_000_000,
-    cachedUtilization: 42,
-    cachedBindingWindowName: 'five_hour',
-  };
-  writeSidecar(written);
-
-  // Simulate a restart: a fresh process starts from the hardcoded module defaults
-  // (false / null / null / null / null) until loadSchedulerState() runs.
-  loadSchedulerState();
-
-  const after = getSchedulerStateSnapshot();
-  expect(after).toEqual({
-    lastPollOk: true,
-    lastFailureKind: 'meter_rate_limited',
-    backoffNextAt: 1_726_000_000_000,
-    cachedUtilization: 42,
-    cachedBindingWindowName: 'five_hour',
-  });
-  // The restore must have actually changed something relative to the pre-load
-  // snapshot — proves this run exercised the restore path, not a no-op.
-  expect(after).not.toEqual(before);
-});
-
-test('persistSchedulerState writes the same five fields back out, round-tripping through the sidecar', () => {
-  writeSidecar({
-    version: 1,
-    lastPollOk: false,
-    lastFailureKind: 'auth',
-    backoffNextAt: 1_726_100_000_000,
-    cachedUtilization: 87.5,
-    cachedBindingWindowName: 'weekly_all',
-  });
-  loadSchedulerState();
-
-  persistSchedulerState();
-
-  const onDisk = JSON.parse(fs.readFileSync(schedulerPaths.schedulerStatePath(), 'utf8'));
-  expect(onDisk.lastPollOk).toBe(false);
-  expect(onDisk.lastFailureKind).toBe('auth');
-  expect(onDisk.backoffNextAt).toBe(1_726_100_000_000);
-  expect(onDisk.cachedUtilization).toBe(87.5);
-  expect(onDisk.cachedBindingWindowName).toBe('weekly_all');
-});
-
-test('loadSchedulerState against a sidecar missing the five fields leaves the in-memory values unchanged (pre-PRD-1392 file)', () => {
-  // Establish a known non-default in-memory state first.
-  writeSidecar({
-    version: 1,
-    lastPollOk: true,
-    lastFailureKind: 'transient',
-    backoffNextAt: 5000,
-    cachedUtilization: 10,
-    cachedBindingWindowName: 'seven_day',
-  });
-  loadSchedulerState();
-  const established = getSchedulerStateSnapshot();
-
-  // A sidecar written before PRD 1392 (or first-boot with only the older fields) has
-  // none of the five new keys — loadSchedulerState's per-field `typeof` guards must
-  // leave whatever was already in memory alone, not stomp it back to a hardcoded default.
-  writeSidecar({ version: 1, lastPollAt: 123 });
-  loadSchedulerState();
-
-  expect(getSchedulerStateSnapshot()).toEqual(established);
-});

package/src/main/__tests__/seedAgentPersonas.test.cjs

@@ -1,184 +0,0 @@
-/**
- * seedAgentPersonas.test.cjs — unit tests for src/main/seedAgentPersonas.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/seedAgentPersonas.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');
-
-let tmpHome;
-let realHome;
-let seedAgentPersonas;
-
-// config.cjs bakes os.homedir() into top-level consts at first require
-// (allowedRoots/WRITE_PREFIXES, used by writeJsonSync) — must be purged
-// alongside seedAgentPersonas.cjs so each test's tmpHome takes effect.
-const MODULES_TO_RELOAD = ['../seedAgentPersonas.cjs', '../config.cjs'];
-
-function purgeRequireCache() {
-  for (const m of MODULES_TO_RELOAD) {
-    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
-  }
-}
-
-beforeEach(() => {
-  realHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-agent-personas-test-'));
-  process.env.HOME = tmpHome;
-  delete process.env.SM_SEED_AGENT_PERSONAS_DISABLE;
-  purgeRequireCache();
-  ({ seedAgentPersonas } = require('../seedAgentPersonas.cjs'));
-});
-
-afterEach(() => {
-  process.env.HOME = realHome;
-  delete process.env.SM_SEED_AGENT_PERSONAS_DISABLE;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-  purgeRequireCache();
-});
-
-function agentsDir() {
-  return path.join(tmpHome, '.claude', 'agents');
-}
-
-function markerPath() {
-  return path.join(tmpHome, '.claude', 'session-manager', '.agent-personas-seeded');
-}
-
-function silentLogger() {
-  return { log: () => {}, warn: () => {} };
-}
-
-const ALL_PERSONAS = ['architect', 'dev-lead', 'project-home-builder', 'validator'];
-
-test('fresh seed writes every persona file', async () => {
-  await seedAgentPersonas({ logger: silentLogger() });
-
-  for (const name of ALL_PERSONAS) {
-    const dest = path.join(agentsDir(), `${name}.md`);
-    expect(fs.existsSync(dest)).toBe(true);
-    const bundled = fs.readFileSync(path.join(__dirname, '..', '..', 'seed', 'agents', `${name}.md`), 'utf8');
-    expect(fs.readFileSync(dest, 'utf8')).toBe(bundled);
-  }
-
-  const marker = JSON.parse(fs.readFileSync(markerPath(), 'utf8'));
-  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
-});
-
-test('a pre-existing persona file is left byte-identical', async () => {
-  fs.mkdirSync(agentsDir(), { recursive: true });
-  const architect = path.join(agentsDir(), 'architect.md');
-  const customContent = '# My custom architect\nnever overwrite me\n';
-  fs.writeFileSync(architect, customContent);
-
-  await seedAgentPersonas({ logger: silentLogger() });
-
-  expect(fs.readFileSync(architect, 'utf8')).toBe(customContent);
-  // dev-lead and project-home-builder had no pre-existing file, so they should still be seeded.
-  expect(fs.existsSync(path.join(agentsDir(), 'dev-lead.md'))).toBe(true);
-  expect(fs.existsSync(path.join(agentsDir(), 'project-home-builder.md'))).toBe(true);
-});
-
-test('a machine already fully seeded under the old done:true marker only picks up a newly added persona', async () => {
-  const mPath = markerPath();
-  fs.mkdirSync(path.dirname(mPath), { recursive: true });
-  // Legacy marker shape from before the seeded-set change — no `seeded` array.
-  fs.writeFileSync(mPath, JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
-  fs.mkdirSync(agentsDir(), { recursive: true });
-  fs.writeFileSync(path.join(agentsDir(), 'architect.md'), 'old architect content\n');
-  fs.writeFileSync(path.join(agentsDir(), 'dev-lead.md'), 'old dev-lead content\n');
-
-  await seedAgentPersonas({ logger: silentLogger() });
-
-  // Pre-existing files from the old run are untouched...
-  expect(fs.readFileSync(path.join(agentsDir(), 'architect.md'), 'utf8')).toBe('old architect content\n');
-  expect(fs.readFileSync(path.join(agentsDir(), 'dev-lead.md'), 'utf8')).toBe('old dev-lead content\n');
-  // ...but the newly added persona is delivered.
-  expect(fs.existsSync(path.join(agentsDir(), 'project-home-builder.md'))).toBe(true);
-
-  const marker = JSON.parse(fs.readFileSync(mPath, 'utf8'));
-  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
-});
-
-test('a machine already seeded under the new seeded-set marker picks up a newly added persona', async () => {
-  const mPath = markerPath();
-  fs.mkdirSync(path.dirname(mPath), { recursive: true });
-  fs.writeFileSync(mPath, JSON.stringify({ seeded: ['architect', 'dev-lead'], attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
-
-  await seedAgentPersonas({ logger: silentLogger() });
-
-  expect(fs.existsSync(path.join(agentsDir(), 'project-home-builder.md'))).toBe(true);
-  const marker = JSON.parse(fs.readFileSync(mPath, 'utf8'));
-  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
-});
-
-test('a machine with every known persona already in the seeded set short-circuits without touching agents dir', async () => {
-  const mPath = markerPath();
-  fs.mkdirSync(path.dirname(mPath), { recursive: true });
-  fs.writeFileSync(mPath, JSON.stringify({ seeded: ALL_PERSONAS, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
-
-  await seedAgentPersonas({ logger: silentLogger() });
-
-  expect(fs.existsSync(agentsDir())).toBe(false);
-});
-
-test('a corrupt/unparseable marker file still seeds correctly', async () => {
-  const mPath = markerPath();
-  fs.mkdirSync(path.dirname(mPath), { recursive: true });
-  fs.writeFileSync(mPath, '{ not valid json');
-
-  await seedAgentPersonas({ logger: silentLogger() });
-
-  for (const name of ALL_PERSONAS) {
-    expect(fs.existsSync(path.join(agentsDir(), `${name}.md`))).toBe(true);
-  }
-});
-
-test('the bundled project-home-builder persona contains no session-manager-repo paths', () => {
-  const content = fs.readFileSync(
-    path.join(__dirname, '..', '..', 'seed', 'agents', 'project-home-builder.md'),
-    'utf8'
-  );
-  const forbidden = [
-    'session-manager-operations/architecture/',
-    '.claude/agents/',
-    'session-manager-operations/design-mocks/',
-    'scripts/',
-    'npm run build:project-pages',
-  ];
-  for (const substr of forbidden) {
-    expect(content).not.toContain(substr);
-  }
-});
-
-test('seeded dev-lead persona pins an executor-tier model', () => {
-  const { splitFrontmatter } = require('../lib/prdFrontmatter.cjs');
-  const raw = fs.readFileSync(path.join(__dirname, '..', '..', 'seed', 'agents', 'dev-lead.md'), 'utf8');
-  const { fm } = splitFrontmatter(raw);
-  expect(fm.model).toBe('sonnet');
-});
-
-test('seeded dev-lead body fits AGENT_BODY_CHAR_CAP and carries the run contract', () => {
-  const { splitFrontmatter } = require('../lib/prdFrontmatter.cjs');
-  const { AGENT_BODY_CHAR_CAP } = require('../lib/agentModelResolve.cjs');
-  const raw = fs.readFileSync(path.join(__dirname, '..', '..', 'seed', 'agents', 'dev-lead.md'), 'utf8');
-  const { body } = splitFrontmatter(raw);
-  const trimmed = body.trim();
-  expect(trimmed.length).toBeLessThan(AGENT_BODY_CHAR_CAP);
-  expect(trimmed).toContain('## Run contract');
-  expect(trimmed).toContain('SCHEDULER_VERDICT: PASS');
-});
-
-test('SM_SEED_AGENT_PERSONAS_DISABLE=1 short-circuits', async () => {
-  process.env.SM_SEED_AGENT_PERSONAS_DISABLE = '1';
-
-  await seedAgentPersonas({ logger: silentLogger() });
-
-  expect(fs.existsSync(agentsDir())).toBe(false);
-  expect(fs.existsSync(markerPath())).toBe(false);
-});

package/src/main/__tests__/seedSchedulerMcp.test.cjs

@@ -1,211 +0,0 @@
-/**
- * seedSchedulerMcp.test.cjs — unit tests for src/main/seedSchedulerMcp.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/seedSchedulerMcp.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');
-
-let tmpHome;
-let realHome;
-let seedSchedulerMcp;
-
-// config.cjs bakes os.homedir() into top-level consts at first require
-// (allowedRoots/WRITE_PREFIXES, used by writeJsonSync) — must be purged
-// alongside seedSchedulerMcp.cjs so each test's tmpHome takes effect.
-const MODULES_TO_RELOAD = ['../seedSchedulerMcp.cjs', '../config.cjs'];
-
-function purgeRequireCache() {
-  for (const m of MODULES_TO_RELOAD) {
-    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
-  }
-}
-
-beforeEach(() => {
-  realHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-scheduler-mcp-test-'));
-  process.env.HOME = tmpHome;
-  delete process.env.SM_SEED_SCHEDULER_MCP_DISABLE;
-  purgeRequireCache();
-  ({ seedSchedulerMcp } = require('../seedSchedulerMcp.cjs'));
-});
-
-afterEach(() => {
-  process.env.HOME = realHome;
-  delete process.env.SM_SEED_SCHEDULER_MCP_DISABLE;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-  purgeRequireCache();
-});
-
-function markerPath() {
-  return path.join(tmpHome, '.claude', 'session-manager', '.scheduler-mcp-seeded');
-}
-
-function claudeJsonPath() {
-  return path.join(tmpHome, '.claude.json');
-}
-
-function silentLogger() {
-  return { log: () => {}, warn: () => {} };
-}
-
-function readMarker() {
-  return JSON.parse(fs.readFileSync(markerPath(), 'utf8'));
-}
-
-test('fresh registration calls addFn with the absolute server path and writes done marker', async () => {
-  const calls = [];
-  const addFn = async (serverPath) => {
-    calls.push(serverPath);
-    return { ok: true, exitCode: 0 };
-  };
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn });
-
-  expect(calls).toHaveLength(1);
-  expect(path.isAbsolute(calls[0])).toBe(true);
-  expect(calls[0].endsWith(path.join('scripts', 'scheduler-mcp-server.cjs'))).toBe(true);
-
-  const marker = readMarker();
-  expect(marker.done).toBe(true);
-  expect(marker.attempts).toBe(0);
-});
-
-test('already-registered at user scope short-circuits without calling addFn', async () => {
-  fs.writeFileSync(
-    claudeJsonPath(),
-    JSON.stringify({
-      mcpServers: {
-        'session-manager-scheduler': { type: 'stdio', command: 'node', args: ['/some/path/scheduler-mcp-server.cjs'] },
-        fetch: { type: 'stdio', command: 'uvx', args: ['mcp-server-fetch'] },
-      },
-    })
-  );
-  let called = false;
-  const addFn = async () => { called = true; return { ok: true }; };
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn });
-
-  expect(called).toBe(false);
-  const marker = readMarker();
-  expect(marker.done).toBe(true);
-
-  // Untouched — the pre-existing registration (and sibling entries) stay as-is.
-  const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath(), 'utf8'));
-  expect(claudeJson.mcpServers['session-manager-scheduler'].args).toEqual(['/some/path/scheduler-mcp-server.cjs']);
-  expect(claudeJson.mcpServers.fetch).toBeDefined();
-});
-
-test('done:true marker short-circuits without calling addFn', async () => {
-  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
-  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
-  let called = false;
-  const addFn = async () => { called = true; return { ok: true }; };
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn });
-
-  expect(called).toBe(false);
-});
-
-test('SM_SEED_SCHEDULER_MCP_DISABLE=1 short-circuits', async () => {
-  process.env.SM_SEED_SCHEDULER_MCP_DISABLE = '1';
-  let called = false;
-  const addFn = async () => { called = true; return { ok: true }; };
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn });
-
-  expect(called).toBe(false);
-  expect(fs.existsSync(markerPath())).toBe(false);
-});
-
-test('a failed attempt bumps the counter and stops after MAX_ATTEMPTS', async () => {
-  const addFn = async () => ({ ok: false, error: 'boom' });
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn });
-  expect(readMarker()).toMatchObject({ done: false, attempts: 1 });
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn });
-  expect(readMarker()).toMatchObject({ done: false, attempts: 2 });
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn });
-  expect(readMarker()).toMatchObject({ done: false, attempts: 3 });
-
-  // MAX_ATTEMPTS reached — a 4th run must not call addFn again or bump further.
-  let called = false;
-  const trackedAddFn = async () => { called = true; return { ok: false, error: 'boom' }; };
-  await seedSchedulerMcp({ logger: silentLogger(), addFn: trackedAddFn });
-
-  expect(called).toBe(false);
-  expect(readMarker()).toMatchObject({ done: false, attempts: 3 });
-});
-
-// ─────────────────────────────── repair: marker done, script path stale
-
-test('marker done + user-scope script path missing -> removes then re-adds, marker stays done', async () => {
-  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
-  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
-  fs.writeFileSync(
-    claudeJsonPath(),
-    JSON.stringify({
-      mcpServers: {
-        'session-manager-scheduler': { type: 'stdio', command: 'node', args: ['/definitely/does/not/exist.cjs'] },
-      },
-    })
-  );
-
-  const removeCalls = [];
-  const removeFn = async () => { removeCalls.push(1); return { ok: true }; };
-  const addCalls = [];
-  const addFn = async (serverPath) => { addCalls.push(serverPath); return { ok: true, exitCode: 0 }; };
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn, removeFn });
-
-  expect(removeCalls).toHaveLength(1);
-  expect(addCalls).toHaveLength(1);
-  expect(path.isAbsolute(addCalls[0])).toBe(true);
-  expect(readMarker().done).toBe(true);
-});
-
-test('marker done + user-scope entry ABSENT (deliberate remove) stays removed, no repair attempted', async () => {
-  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
-  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
-  // No ~/.claude.json at all — same as a deliberate `claude mcp remove`.
-
-  let removeCalled = false;
-  let addCalled = false;
-  const removeFn = async () => { removeCalled = true; return { ok: true }; };
-  const addFn = async () => { addCalled = true; return { ok: true }; };
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn, removeFn });
-
-  expect(removeCalled).toBe(false);
-  expect(addCalled).toBe(false);
-});
-
-test('marker done + user-scope script path exists -> healthy, no repair attempted', async () => {
-  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
-  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
-  fs.writeFileSync(
-    claudeJsonPath(),
-    JSON.stringify({
-      mcpServers: {
-        'session-manager-scheduler': { type: 'stdio', command: 'node', args: [markerPath()] }, // any existing file
-      },
-    })
-  );
-
-  let removeCalled = false;
-  let addCalled = false;
-  const removeFn = async () => { removeCalled = true; return { ok: true }; };
-  const addFn = async () => { addCalled = true; return { ok: true }; };
-
-  await seedSchedulerMcp({ logger: silentLogger(), addFn, removeFn });
-
-  expect(removeCalled).toBe(false);
-  expect(addCalled).toBe(false);
-});