claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,127 +0,0 @@
-'use strict';
-
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerBatchProjectCap.test.cjs
-//
-// Regression coverage for the per-project job cap (PRD 1066): the global
-// sessionSlots pool is machine-wide and project-blind, so all of it can land
-// on one project — measured 2026-08-31 as 4 concurrent executors on one
-// project, loadavg 25.89/14 cores, silently converting that project's
-// timing-sensitive test gate into a no-op. These tests pin the fix: an INNER
-// per-cwd cap inside pickNextBatch/pickForProject, layered under the existing
-// global pool (never a replacement for it).
-
-const assert = require('node:assert/strict');
-const { pickNextBatch, pickForProject } = require('../schedulerBatch.cjs');
-
-const CWD_A = '/home/user/Projects/project-a';
-const CWD_B = '/home/user/Projects/project-b';
-
-function job(slug, status, cwd, extra = {}) {
-  return {
-    slug,
-    status,
-    cwd,
-    parallelGroup: Number(String(slug).match(/^(\d+)-/)?.[1] ?? 99),
-    dependsOn: [],
-    ...extra,
-  };
-}
-
-const ORIGINAL_CAP_ENV = process.env.SM_PROJECT_JOB_CAP;
-afterEach(() => {
-  if (ORIGINAL_CAP_ENV === undefined) delete process.env.SM_PROJECT_JOB_CAP;
-  else process.env.SM_PROJECT_JOB_CAP = ORIGINAL_CAP_ENV;
-});
-
-test('three eligible jobs in one project, default cap 2 -> exactly 2 selected', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('101-a', 'pending', CWD_A),
-    job('102-b', 'pending', CWD_A),
-    job('103-c', 'pending', CWD_A),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5);
-  assert.deepEqual(batch.map((j) => j.slug), ['101-a', '102-b']);
-});
-
-test('cap is per-project: two projects with 2 eligible jobs each (cap 2) both fire in full', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('101-a', 'pending', CWD_A),
-    job('102-b', 'pending', CWD_A),
-    job('201-a', 'pending', CWD_B),
-    job('202-b', 'pending', CWD_B),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5);
-  // A global cap of 2 would only ever admit 2 total; the per-project cap
-  // admits up to 2 PER cwd, so all 4 fire here against a 5-slot pool.
-  assert.deepEqual(
-    batch.map((j) => j.slug).sort(),
-    ['101-a', '102-b', '201-a', '202-b'],
-  );
-});
-
-test('SM_PROJECT_JOB_CAP=1 -> exactly 1 selected', () => {
-  process.env.SM_PROJECT_JOB_CAP = '1';
-  const jobs = [
-    job('101-a', 'pending', CWD_A),
-    job('102-b', 'pending', CWD_A),
-    job('103-c', 'pending', CWD_A),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5);
-  assert.deepEqual(batch.map((j) => j.slug), ['101-a']);
-});
-
-test('a job deferred by the project cap stays eligible and fires once a sibling finishes', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('101-a', 'running', CWD_A),
-    job('102-b', 'running', CWD_A),
-    job('103-c', 'pending', CWD_A),
-  ];
-  // Tick 1: both slots for this project are already running (cap 2) -> 103-c
-  // is held, NOT failed/skipped, and remains 'pending' in the queue.
-  const running1 = new Set(['101-a', '102-b']);
-  const tick1 = pickNextBatch(jobs, running1, 5);
-  assert.deepEqual(tick1.batch, []);
-  assert.match(tick1.reason, /project-cap/);
-  assert.equal(jobs.find((j) => j.slug === '103-c').status, 'pending');
-
-  // Tick 2: 101-a finished (removed from running, its row now 'completed');
-  // 103-c is still eligible and fires on this later tick.
-  const jobsTick2 = [
-    job('101-a', 'completed', CWD_A),
-    job('102-b', 'running', CWD_A),
-    job('103-c', 'pending', CWD_A),
-  ];
-  const running2 = new Set(['102-b']);
-  const tick2 = pickNextBatch(jobsTick2, running2, 5);
-  assert.deepEqual(tick2.batch.map((j) => j.slug), ['103-c']);
-});
-
-test('cap counts an untracked running row (boot-orphan grace window), not just the tracked running Set', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    // status:running but its slug is absent from the caller's `running` Set —
-    // e.g. still alive during BOOT_ORPHAN_KILL_GRACE_MS before reconciliation
-    // catches up. Must still count against the cap.
-    job('101-a', 'running', CWD_A),
-    job('102-b', 'running', CWD_A),
-    job('103-c', 'pending', CWD_A),
-  ];
-  const { batch, reason } = pickNextBatch(jobs, new Set(), 5);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /project-cap/);
-});
-
-test('pickForProject: cap counts jobs already running in that project', () => {
-  delete process.env.SM_PROJECT_JOB_CAP;
-  const jobs = [
-    job('101-a', 'running', CWD_A),
-    job('102-b', 'running', CWD_A),
-    job('103-c', 'pending', CWD_A),
-  ];
-  const { batch, reason } = pickForProject(jobs, new Set(['101-a', '102-b']), 5);
-  assert.deepEqual(batch, []);
-  assert.match(reason, /project-cap/);
-});

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

@@ -1,109 +0,0 @@
-'use strict';
-
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerBatchQuietMachine.test.cjs
-//
-// Pure-logic coverage for the `quietMachine: true` exclusive lease (PRD
-// 1107): dispatched only when zero other jobs are running machine-wide,
-// blocks every other dispatch while its lease is held, degrades (dispatches
-// anyway) once it has waited past the configurable interval, and never
-// touches the ordinary dispatch path for a PRD that doesn't opt in.
-
-const assert = require('node:assert/strict');
-const { pickNextBatch } = require('../schedulerBatch.cjs');
-
-const CWD_A = '/home/user/Projects/project-a';
-const CWD_B = '/home/user/Projects/project-b';
-
-function job(slug, status, cwd, extra = {}) {
-  return {
-    slug,
-    status,
-    cwd,
-    parallelGroup: Number(String(slug).match(/^(\d+)-/)?.[1] ?? 99),
-    dependsOn: [],
-    ...extra,
-  };
-}
-
-const ORIGINAL_WAIT_ENV = process.env.SM_QUIET_MACHINE_WAIT_MINUTES;
-afterEach(() => {
-  if (ORIGINAL_WAIT_ENV === undefined) delete process.env.SM_QUIET_MACHINE_WAIT_MINUTES;
-  else process.env.SM_QUIET_MACHINE_WAIT_MINUTES = ORIGINAL_WAIT_ENV;
-});
-
-test('a quietMachine job dispatches alone when the machine is idle, even with ordinary work also pending', () => {
-  const jobs = [
-    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: new Date().toISOString() }),
-    job('102-ordinary', 'pending', CWD_A, { createdAt: new Date().toISOString() }),
-    job('201-other', 'pending', CWD_B, { createdAt: new Date().toISOString() }),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 0, now: Date.now() });
-  assert.deepEqual(batch.map((j) => j.slug), ['101-quiet']);
-  assert.equal(batch[0].quietLeaseDegraded, false);
-});
-
-test('a quietMachine job does NOT dispatch while another job is running machine-wide, and ordinary jobs dispatch unaffected', () => {
-  const jobs = [
-    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: new Date().toISOString() }),
-    job('201-other', 'pending', CWD_B, { createdAt: new Date().toISOString() }),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 1, now: Date.now() });
-  assert.deepEqual(batch.map((j) => j.slug), ['201-other']);
-});
-
-test('leaseHeld blocks EVERY project from dispatching, not just the quiet job\'s own project', () => {
-  const jobs = [
-    job('101-quiet', 'running', CWD_A, { quietMachine: true }),
-    job('201-other', 'pending', CWD_B, { createdAt: new Date().toISOString() }),
-  ];
-  const { batch, reason } = pickNextBatch(jobs, new Set(['101-quiet']), 5, { leaseHeld: true, machineInUse: 1, now: Date.now() });
-  assert.deepEqual(batch, []);
-  assert.match(reason, /quiet-machine/);
-});
-
-test('a quietMachine job blocked by dependsOn is skipped even when the machine is idle', () => {
-  const jobs = [
-    job('100-dep', 'pending', CWD_A, { createdAt: new Date().toISOString() }),
-    job('101-quiet', 'pending', CWD_A, { quietMachine: true, dependsOn: ['100-dep'], createdAt: new Date().toISOString() }),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 0, now: Date.now() });
-  // The quiet job is blocked by its dep; the dep itself is an ordinary job
-  // and dispatches normally.
-  assert.deepEqual(batch.map((j) => j.slug), ['100-dep']);
-});
-
-test('a quietMachine job waiting under the configured interval stays held while the machine is busy', () => {
-  process.env.SM_QUIET_MACHINE_WAIT_MINUTES = '30';
-  const now = Date.now();
-  const queuedAt = new Date(now - 10 * 60_000).toISOString(); // waited 10m
-  const jobs = [
-    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: queuedAt }),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 1, now });
-  assert.deepEqual(batch, []);
-});
-
-test('a quietMachine job past the configured wait interval dispatches anyway, marked degraded', () => {
-  process.env.SM_QUIET_MACHINE_WAIT_MINUTES = '30';
-  const now = Date.now();
-  const queuedAt = new Date(now - 31 * 60_000).toISOString(); // waited 31m
-  const jobs = [
-    job('101-quiet', 'pending', CWD_A, { quietMachine: true, createdAt: queuedAt }),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5, { leaseHeld: false, machineInUse: 1, now });
-  assert.deepEqual(batch.map((j) => j.slug), ['101-quiet']);
-  assert.equal(batch[0].quietLeaseDegraded, true);
-});
-
-test('ordinary dispatch path is unchanged when no quietMachine job is present (no quietOpts passed at all)', () => {
-  const jobs = [
-    job('101-a', 'pending', CWD_A),
-    job('102-b', 'pending', CWD_A),
-    job('201-a', 'pending', CWD_B),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 5);
-  assert.deepEqual(
-    batch.map((j) => j.slug).sort(),
-    ['101-a', '102-b', '201-a'],
-  );
-});

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

@@ -1,71 +0,0 @@
-/**
- * schedulerMcpServerHeadlessRefusal.test.cjs — scheduler_create_prd is
- * refused at the authoring boundary when called from inside a headless
- * scheduled job (issue #11 list C1: PRD 460 called /develop from inside its
- * own run, spawned a duplicate PRD, and exited 0 having done nothing).
- * scheduler.cjs stamps SM_SCHEDULER_JOB_SLUG on every job spawn and
- * SM_SCHEDULER_JOB_MAY_QUEUE=1 only for decomposition personas.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerMcpServerHeadlessRefusal.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const SERVER_PATH = path.join(__dirname, '../../../../scripts/scheduler-mcp-server.cjs');
-
-const tmpDirs = [];
-const savedEnv = {};
-for (const k of ['SM_SCHEDULER_JOB_SLUG', 'SM_SCHEDULER_JOB_MAY_QUEUE', 'HOME']) savedEnv[k] = process.env[k];
-
-afterEach(async () => {
-  for (const [k, v] of Object.entries(savedEnv)) {
-    if (v === undefined) delete process.env[k]; else process.env[k] = v;
-  }
-  delete require.cache[require.resolve(SERVER_PATH)];
-  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { recursive: true, force: true });
-});
-
-async function freshServer() {
-  const homeDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-mcp-headless-'));
-  tmpDirs.push(homeDir);
-  process.env.HOME = homeDir;
-  delete require.cache[require.resolve(SERVER_PATH)];
-  return require(SERVER_PATH);
-}
-
-const PRD_ARGS = { title: 'x', goal: 'y', acceptanceCriteria: ['z'] };
-
-test('scheduler_create_prd inside a headless job is refused before any admin request', async () => {
-  process.env.SM_SCHEDULER_JOB_SLUG = '460-some-prd';
-  delete process.env.SM_SCHEDULER_JOB_MAY_QUEUE;
-  const { handleCallTool } = await freshServer();
-  const result = await handleCallTool({ params: { name: 'scheduler_create_prd', arguments: PRD_ARGS } });
-  expect(result.isError).toBe(true);
-  const text = result.content[0].text;
-  expect(text).toMatch(/refused/);
-  expect(text).toMatch(/460-some-prd/);
-  expect(text).toMatch(/never queues follow-on work/);
-});
-
-test('scheduler_create_prd inside a headless job with SM_SCHEDULER_JOB_MAY_QUEUE=1 is not refused by the gate', async () => {
-  process.env.SM_SCHEDULER_JOB_SLUG = '461-architect-plan';
-  process.env.SM_SCHEDULER_JOB_MAY_QUEUE = '1';
-  const { handleCallTool } = await freshServer();
-  const result = await handleCallTool({ params: { name: 'scheduler_create_prd', arguments: PRD_ARGS } });
-  // No admin API is configured in this tmp HOME, so the call fails LATER at
-  // the admin request — the point is that it was not the headless refusal.
-  const text = result.content[0].text;
-  expect(text).not.toMatch(/never queues follow-on work/);
-});
-
-test('scheduler_create_prd outside a headless job is not refused by the gate', async () => {
-  delete process.env.SM_SCHEDULER_JOB_SLUG;
-  const { handleCallTool } = await freshServer();
-  const result = await handleCallTool({ params: { name: 'scheduler_create_prd', arguments: PRD_ARGS } });
-  expect(result.content[0].text).not.toMatch(/never queues follow-on work/);
-});

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

@@ -1,216 +0,0 @@
-/**
- * schedulerMcpServerHelp.test.cjs — session_manager_help argument handling
- * (none/tool/topic/unknown/both) and the pointer-suffix contract every
- * isError return in scheduler-mcp-server.cjs now carries. Also covers the
- * "app not running" degradation: the static catalog must still answer even
- * when the admin API is unreachable — only the readiness section may report
- * unavailable.
- *
- * The admin token path (schedulerPaths.adminTokenPath) resolves lazily from
- * os.homedir(). Since os.homedir() reads process.env.HOME on POSIX, each test
- * repoints HOME at a fresh tmp dir for its duration (restored in afterEach)
- * so the token path resolves under that tmp dir, never the real
- * ~/.claude/session-manager/admin-api.json.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/schedulerMcpServerHelp.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 tmpDirs = [];
-const servers = [];
-let originalHome;
-
-afterEach(async () => {
-  if (originalHome !== undefined) {
-    process.env.HOME = originalHome;
-    originalHome = 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-help-'));
-  tmpDirs.push(d);
-  return d;
-}
-
-/** Starts a fake admin HTTP server answering GET /admin/mcp/readiness. */
-function startFakeAdminServer(token, readinessBody) {
-  return new Promise((resolve) => {
-    const server = http.createServer((req, res) => {
-      if (req.headers.authorization !== `Bearer ${token}`) {
-        res.writeHead(401, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: false, error: 'bad token' }));
-        return;
-      }
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(readinessBody));
-    });
-    server.listen(0, '127.0.0.1', () => resolve(server));
-  });
-}
-
-/** Requires a fresh scheduler-mcp-server.cjs with TOKEN_PATH under `homeDir`. */
-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('session_manager_help with no arguments returns grouped tool list + recipe titles + readiness', async () => {
-  const homeDir = await mkTmp();
-  const token = 'test-token';
-  const server = await startFakeAdminServer(token, { ok: true, ready: true, checks: [{ id: 'scheduler-mcp', ok: true }] });
-  servers.push(server);
-  await writeAdminConfig(homeDir, { port: server.address().port, token });
-
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, 'session_manager_help', {});
-  expect(result.isError).toBeFalsy();
-  const body = JSON.parse(result.content[0].text);
-  expect(Array.isArray(body.tools)).toBe(true);
-  expect(body.tools.some((t) => t.name === 'session_manager_help')).toBe(true);
-  expect(Array.isArray(body.recipes)).toBe(true);
-  expect(body.recipes.some((r) => r.id === 'queue-work-via-develop')).toBe(true);
-  expect(body.tool).toBeUndefined();
-  expect(body.recipe).toBeUndefined();
-  expect(body.readiness.available).toBe(true);
-  expect(body.readiness.ok).toBe(true);
-});
-
-test('session_manager_help with a valid tool returns that entry including exampleArgs', async () => {
-  const homeDir = await mkTmp();
-  const token = 'test-token';
-  const server = await startFakeAdminServer(token, { ok: true, ready: true, checks: [] });
-  servers.push(server);
-  await writeAdminConfig(homeDir, { port: server.address().port, token });
-
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, 'session_manager_help', { tool: 'scheduler_create_prd' });
-  expect(result.isError).toBeFalsy();
-  const body = JSON.parse(result.content[0].text);
-  expect(body.tool.name).toBe('scheduler_create_prd');
-  expect(body.tool.exampleArgs).toBeTruthy();
-  expect(body.tools).toBeUndefined();
-});
-
-test('session_manager_help with a valid topic returns that recipe\'s steps', async () => {
-  const homeDir = await mkTmp();
-  const token = 'test-token';
-  const server = await startFakeAdminServer(token, { ok: true, ready: true, checks: [] });
-  servers.push(server);
-  await writeAdminConfig(homeDir, { port: server.address().port, token });
-
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, 'session_manager_help', { topic: 'unstick-needs-review-job' });
-  expect(result.isError).toBeFalsy();
-  const body = JSON.parse(result.content[0].text);
-  expect(body.recipe.id).toBe('unstick-needs-review-job');
-  expect(Array.isArray(body.recipe.steps)).toBe(true);
-  expect(body.recipe.steps.length).toBeGreaterThan(0);
-});
-
-test('session_manager_help accepts both tool and topic together, returning both sections', async () => {
-  const homeDir = await mkTmp();
-  const token = 'test-token';
-  const server = await startFakeAdminServer(token, { ok: true, ready: true, checks: [] });
-  servers.push(server);
-  await writeAdminConfig(homeDir, { port: server.address().port, token });
-
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, 'session_manager_help', {
-    tool: 'scheduler_list_jobs',
-    topic: 'queue-work-via-develop',
-  });
-  expect(result.isError).toBeFalsy();
-  const body = JSON.parse(result.content[0].text);
-  expect(body.tool.name).toBe('scheduler_list_jobs');
-  expect(body.recipe.id).toBe('queue-work-via-develop');
-});
-
-test('session_manager_help with an unknown tool returns a helpful error listing valid names', async () => {
-  const homeDir = await mkTmp();
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, 'session_manager_help', { tool: 'not_a_real_tool' });
-  expect(result.isError).toBe(true);
-  expect(result.content[0].text).toContain('not_a_real_tool');
-  expect(result.content[0].text).toContain('scheduler_create_prd');
-  expect(result.content[0].text).toContain('call session_manager_help for the correct usage');
-});
-
-test('session_manager_help with an unknown topic returns a helpful error listing valid ids', async () => {
-  const homeDir = await mkTmp();
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, 'session_manager_help', { topic: 'not-a-real-recipe' });
-  expect(result.isError).toBe(true);
-  expect(result.content[0].text).toContain('not-a-real-recipe');
-  expect(result.content[0].text).toContain('queue-work-via-develop');
-});
-
-test('session_manager_help still returns the static catalog when the app is not running, with readiness unavailable', async () => {
-  // No admin-api.json written under this tmp HOME at all — simulates the app
-  // being down. The catalog is bundled in-process, so this must NOT fail
-  // wholesale; only the readiness half degrades.
-  const homeDir = await mkTmp();
-  const { handleCallTool } = requireServerWithHome(homeDir);
-  const result = await callTool(handleCallTool, 'session_manager_help', {});
-  expect(result.isError).toBeFalsy();
-  const body = JSON.parse(result.content[0].text);
-  expect(Array.isArray(body.tools)).toBe(true);
-  expect(body.tools.length).toBeGreaterThan(0);
-  expect(body.readiness.available).toBe(false);
-  expect(typeof body.readiness.reason).toBe('string');
-  expect(body.readiness.reason.length).toBeGreaterThan(0);
-});
-
-test('every isError return from the tool handler carries the session_manager_help pointer', async () => {
-  const homeDir = await mkTmp();
-  const { handleCallTool } = requireServerWithHome(homeDir);
-
-  const missingSlug = await callTool(handleCallTool, 'scheduler_reset_job', {});
-  expect(missingSlug.isError).toBe(true);
-  expect(missingSlug.content[0].text).toContain('call session_manager_help for the correct usage');
-
-  const unknownTool = await callTool(handleCallTool, 'not_a_tool_at_all', {});
-  expect(unknownTool.isError).toBe(true);
-  expect(unknownTool.content[0].text).toContain('call session_manager_help for the correct usage');
-});
-
-test('NOT_RUNNING_ERROR (app not running) carries the pointer and is surfaced via isError', async () => {
-  const homeDir = await mkTmp();
-  const { handleCallTool, NOT_RUNNING_ERROR } = requireServerWithHome(homeDir);
-  expect(NOT_RUNNING_ERROR).toContain('call session_manager_help for the correct usage');
-
-  const result = await callTool(handleCallTool, 'scheduler_list_jobs', {});
-  expect(result.isError).toBe(true);
-  expect(result.content[0].text).toBe(NOT_RUNNING_ERROR);
-});