claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,214 +0,0 @@
-/**
- * localAdminHttp.test.cjs — unit tests for the generic loopback-only HTTP
- * transport (PRD 689 — extracted from the former standalone admin HTTP server
- * module). Covers
- * only transport concerns: auth rejection, token persistence, route dispatch,
- * and 404 on unknown routes. Route *logic* tests live beside their owning
- * module (scheduler.cjs's admin routes, prdCreate.cjs's create-prd route).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/localAdminHttp.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterAll } from 'vitest';
-const http = require('node:http');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const { createAdminHttp, TOKEN_PATH, resolveTokenPath } = require('../localAdminHttp.cjs');
-
-// Redirect every start() in this file away from the PRODUCTION admin-api.json.
-// Without this, these tests overwrote the running app's port+token with a
-// throwaway server's, orphaning scheduler-mcp-server.cjs until an app restart
-// (confirmed live 2026-08-01). Tests that specifically exercise path
-// resolution unset this override themselves.
-// Must live under the home dir: config.writeJson enforces allowedRoots.
-const TEST_TOKEN_PATH = path.join(path.dirname(TOKEN_PATH), `admin-api.test-${process.pid}.json`);
-process.env.SM_ADMIN_TOKEN_PATH = TEST_TOKEN_PATH;
-
-afterAll(() => { fs.rmSync(TEST_TOKEN_PATH, { force: true }); });
-
-function request(port, { method = 'GET', path: reqPath, token, body }) {
-  return new Promise((resolve, reject) => {
-    const headers = {};
-    if (token !== undefined) headers.Authorization = `Bearer ${token}`;
-    let payload;
-    if (body !== undefined) {
-      payload = JSON.stringify(body);
-      headers['Content-Type'] = 'application/json';
-      headers['Content-Length'] = Buffer.byteLength(payload);
-    }
-    const req = http.request({ hostname: '127.0.0.1', port, method, path: reqPath, headers }, (res) => {
-      const chunks = [];
-      res.on('data', (c) => chunks.push(c));
-      res.on('end', () => {
-        const text = Buffer.concat(chunks).toString('utf8');
-        let json = null;
-        try { json = JSON.parse(text); } catch { /* leave null for non-JSON bodies */ }
-        resolve({ status: res.statusCode, json, text });
-      });
-    });
-    req.on('error', reject);
-    if (payload) req.write(payload);
-    req.end();
-  });
-}
-
-test('request without bearer token returns 401', async () => {
-  const admin = createAdminHttp();
-  admin.registerRoute('GET', '/ping', async (req, res) => { res.writeHead(200); res.end('{}'); });
-  const { port } = await admin.start();
-  try {
-    const res = await request(port, { path: '/ping' });
-    expect(res.status).toBe(401);
-    expect(res.json.ok).toBe(false);
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('request with wrong bearer token returns 401', async () => {
-  const admin = createAdminHttp();
-  admin.registerRoute('GET', '/ping', async (req, res) => { res.writeHead(200); res.end('{}'); });
-  const { port } = await admin.start();
-  try {
-    const res = await request(port, { path: '/ping', token: 'not-the-token' });
-    expect(res.status).toBe(401);
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('registered route with correct token is dispatched', async () => {
-  const admin = createAdminHttp();
-  admin.registerRoute('GET', '/ping', async (req, res) => {
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ ok: true, pong: true }));
-  });
-  const { port, token } = await admin.start();
-  try {
-    const res = await request(port, { path: '/ping', token });
-    expect(res.status).toBe(200);
-    expect(res.json).toEqual({ ok: true, pong: true });
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('unregistered path/method returns 404', async () => {
-  const admin = createAdminHttp();
-  const { port, token } = await admin.start();
-  try {
-    const res = await request(port, { path: '/nope', token });
-    expect(res.status).toBe(404);
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('server binds only to 127.0.0.1', async () => {
-  const admin = createAdminHttp();
-  await admin.start();
-  try {
-    expect(admin.server.address().address).toBe('127.0.0.1');
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('start() persists token file with port + token, mode 0600', async () => {
-  const admin = createAdminHttp();
-  const { port, token } = await admin.start();
-  try {
-    const raw = fs.readFileSync(TEST_TOKEN_PATH, 'utf8');
-    const parsed = JSON.parse(raw);
-    expect(parsed.port).toBe(port);
-    expect(parsed.token).toBe(token);
-    const mode = fs.statSync(TEST_TOKEN_PATH).mode & 0o777;
-    expect(mode).toBe(0o600);
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('SM_DEV=1 writes to a dev-suffixed path, never the production admin-api.json', async () => {
-  const devPath = path.join(path.dirname(TOKEN_PATH), 'admin-api.dev.json');
-  const prevMtime = fs.existsSync(TOKEN_PATH) ? fs.statSync(TOKEN_PATH).mtimeMs : null;
-  const prevEnv = process.env.SM_DEV;
-  const prevOverride = process.env.SM_ADMIN_TOKEN_PATH;
-  delete process.env.SM_ADMIN_TOKEN_PATH;
-  process.env.SM_DEV = '1';
-  const admin = createAdminHttp();
-  try {
-    const { port, token } = await admin.start();
-    expect(resolveTokenPath()).toBe(devPath);
-    const parsed = JSON.parse(fs.readFileSync(devPath, 'utf8'));
-    expect(parsed.port).toBe(port);
-    expect(parsed.token).toBe(token);
-    // Production file must be untouched by the dev-mode instance.
-    // Content, not mtime: a live Session Manager on this machine legitimately rewrites the real
-    // admin-api.json at any moment (mtime drifted 12ms mid-test under load). What must hold is
-    // that THIS dev instance never wrote its port/token there.
-    if (prevMtime !== null) {
-      const prod = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8'));
-      expect(prod.token).not.toBe(token);
-    } else {
-      expect(fs.existsSync(TOKEN_PATH)).toBe(false);
-    }
-  } finally {
-    await admin.stop();
-    if (prevEnv === undefined) delete process.env.SM_DEV; else process.env.SM_DEV = prevEnv;
-    if (prevOverride !== undefined) process.env.SM_ADMIN_TOKEN_PATH = prevOverride;
-    fs.rmSync(devPath, { force: true });
-  }
-});
-
-test('with neither SM_DEV nor SM_E2E set, resolves to the original admin-api.json path', () => {
-  // Path RESOLUTION only — deliberately does not start() a server here. This
-  // test used to boot one with no override set, which wrote a throwaway
-  // port+token straight into the live app's admin-api.json and cut
-  // scheduler-mcp-server.cjs off from the running app. Persistence itself is
-  // covered by the 0600 test above, against the redirected test path.
-  const prevDev = process.env.SM_DEV;
-  const prevE2e = process.env.SM_E2E;
-  const prevOverride = process.env.SM_ADMIN_TOKEN_PATH;
-  delete process.env.SM_DEV;
-  delete process.env.SM_E2E;
-  delete process.env.SM_ADMIN_TOKEN_PATH;
-  try {
-    expect(resolveTokenPath()).toBe(path.join(require('../schedulerPaths.cjs').schedulerHome(), 'admin-api.json'));
-  } finally {
-    if (prevDev === undefined) delete process.env.SM_DEV; else process.env.SM_DEV = prevDev;
-    if (prevE2e === undefined) delete process.env.SM_E2E; else process.env.SM_E2E = prevE2e;
-    if (prevOverride !== undefined) process.env.SM_ADMIN_TOKEN_PATH = prevOverride;
-  }
-});
-
-test('dev and production token paths never collide', () => {
-  const prevEnv = process.env.SM_DEV;
-  const prevOverride = process.env.SM_ADMIN_TOKEN_PATH;
-  delete process.env.SM_ADMIN_TOKEN_PATH;
-  try {
-    process.env.SM_DEV = '1';
-    const devPath = resolveTokenPath();
-    delete process.env.SM_DEV;
-    const prodPath = resolveTokenPath();
-    expect(devPath).not.toBe(prodPath);
-  } finally {
-    if (prevEnv === undefined) delete process.env.SM_DEV; else process.env.SM_DEV = prevEnv;
-    if (prevOverride !== undefined) process.env.SM_ADMIN_TOKEN_PATH = prevOverride;
-  }
-});
-
-test('start()s self-check answers on the health path with the fresh bearer token', async () => {
-  const admin = createAdminHttp();
-  const { port, token } = await admin.start();
-  try {
-    const res = await request(port, { path: '/__admin/health', token });
-    expect(res.status).toBe(200);
-    expect(res.json).toEqual({ ok: true });
-  } finally {
-    await admin.stop();
-  }
-});

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

@@ -1,68 +0,0 @@
-/**
- * loopDelay.test.cjs — event-loop delay probe used by crashDiagnostics's heartbeat.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/loopDelay.test.cjs
- */
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const { createLoopDelayMonitor, stallVerdict, LOOP_STALL_WARN_MS } = require('../loopDelay.cjs');
-
-// Histogram stub: values in ns, like perf_hooks.
-function stubHistogram(state) {
-  return () => ({
-    enabled: false,
-    enable() { this.enabled = true; },
-    disable() { this.enabled = false; },
-    percentile(p) { return p === 50 ? state.p50 : state.p99; },
-    get max() { return state.max; },
-    reset() { state.resets += 1; state.p50 = 0; state.p99 = 0; state.max = 0; },
-  });
-}
-
-test('normal beat: converts ns to ms (1 decimal) and does not flag a stall', () => {
-  const state = { p50: 21_040_000, p99: 34_960_000, max: 40_000_000, resets: 0 };
-  const m = createLoopDelayMonitor(stubHistogram(state));
-  m.enable();
-  const snap = m.snapshot();
-  expect(snap).toEqual({ loopDelayP50Ms: 21, loopDelayP99Ms: 35, loopDelayMaxMs: 40 });
-  expect(stallVerdict(snap)).toBeNull();
-});
-
-test('stall beat: max above threshold yields warn "main loop stall"', () => {
-  const state = { p50: 20_000_000, p99: 300_000_000, max: 412_300_000, resets: 0 };
-  const snap = createLoopDelayMonitor(stubHistogram(state)).snapshot();
-  expect(snap.loopDelayMaxMs).toBe(412.3);
-  expect(stallVerdict(snap)).toEqual({ level: 'warn', message: 'main loop stall' });
-  expect(stallVerdict({ loopDelayMaxMs: LOOP_STALL_WARN_MS })).toBeNull(); // strictly greater
-});
-
-test('reset between beats: a stall does not bleed into the next interval', () => {
-  const state = { p50: 20_000_000, p99: 300_000_000, max: 500_000_000, resets: 0 };
-  const m = createLoopDelayMonitor(stubHistogram(state));
-  expect(stallVerdict(m.snapshot())).not.toBeNull();
-  expect(state.resets).toBe(1);
-  const second = m.snapshot();
-  expect(second.loopDelayMaxMs).toBe(0);
-  expect(stallVerdict(second)).toBeNull();
-  expect(state.resets).toBe(2);
-});
-
-test('passes a 20 ms resolution to the histogram factory and disable() stops it', () => {
-  let opts; let h;
-  const m = createLoopDelayMonitor((o) => { opts = o; h = stubHistogram({ resets: 0 })(); return h; });
-  m.enable();
-  expect(opts).toEqual({ resolution: 20 });
-  expect(h.enabled).toBe(true);
-  m.disable();
-  expect(h.enabled).toBe(false);
-});
-
-test('real perf_hooks histogram produces finite numbers', () => {
-  const m = createLoopDelayMonitor();
-  m.enable();
-  const snap = m.snapshot();
-  m.disable();
-  for (const v of Object.values(snap)) expect(Number.isFinite(v)).toBe(true);
-});

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

@@ -1,107 +0,0 @@
-/**
- * mcpToolCatalog.test.cjs — parity + shape gate for PRD (mcpToolCatalog):
- * asserts the catalog and the live scheduler-mcp-server.cjs TOOLS array can
- * never drift apart, that every catalog entry is a well-formed
- * documentation record, and that each tool's exampleArgs is actually
- * runnable against that tool's own inputSchema.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/mcpToolCatalog.test.cjs
- */
-'use strict';
-
-import { test, expect } from 'vitest';
-const path = require('node:path');
-const { MCP_TOOL_CATALOG, MCP_RECIPES, CatalogEntrySchema, composeDescription } = require('../mcpToolCatalog.cjs');
-// scheduler-mcp-server.cjs guards its stdio-server main() behind
-// `require.main === module`, so requiring it here (require.main is the test
-// runner, not this file) just loads TOOLS without opening a stdio transport.
-const { TOOLS } = require(path.join(__dirname, '../../../../scripts/scheduler-mcp-server.cjs'));
-
-const LIVE_MCP_TOOL_NAMES = TOOLS.map((t) => t.name);
-
-test('every live MCP tool name has a catalog entry', () => {
-  const catalogNames = new Set(MCP_TOOL_CATALOG.map((e) => e.name));
-  const missing = LIVE_MCP_TOOL_NAMES.filter((n) => !catalogNames.has(n));
-  expect(missing).toEqual([]);
-});
-
-test('every catalog entry corresponds to a live MCP tool', () => {
-  const liveNames = new Set(LIVE_MCP_TOOL_NAMES);
-  const extra = MCP_TOOL_CATALOG.filter((e) => !liveNames.has(e.name)).map((e) => e.name);
-  expect(extra).toEqual([]);
-});
-
-test.each(TOOLS)('$name description is composed from the catalog, not a separate literal', (tool) => {
-  const entry = MCP_TOOL_CATALOG.find((e) => e.name === tool.name);
-  expect(entry).toBeTruthy();
-  expect(tool.description).toBe(composeDescription(entry));
-  expect(tool.description.length).toBeGreaterThan(0);
-});
-
-test.each(MCP_TOOL_CATALOG)('$name has all required catalog fields', (entry) => {
-  expect(() => CatalogEntrySchema.parse(entry)).not.toThrow();
-  expect(entry.name).toBeTruthy();
-  expect(entry.group).toBeTruthy();
-  expect(entry.purpose).toBeTruthy();
-  expect(entry.whenToUse).toBeTruthy();
-  expect(entry.whenNotToUse).toBeTruthy();
-  expect(entry.exampleArgs).toBeTruthy();
-});
-
-test('a catalog entry missing a required field fails schema validation', () => {
-  const broken = {
-    name: 'some_tool',
-    group: 'scheduler',
-    purpose: '',
-    whenToUse: 'x',
-    whenNotToUse: 'y',
-    exampleArgs: {},
-    notes: null,
-  };
-  expect(() => CatalogEntrySchema.parse(broken)).toThrow();
-
-  const missingField = {
-    name: 'some_tool',
-    group: 'scheduler',
-    purpose: 'x',
-    whenToUse: 'y',
-    // whenNotToUse omitted entirely
-    exampleArgs: {},
-    notes: null,
-  };
-  expect(() => CatalogEntrySchema.parse(missingField)).toThrow();
-});
-
-test.each(MCP_TOOL_CATALOG)('$name composeDescription joins purpose/whenToUse/whenNotToUse/notes deterministically', (entry) => {
-  const expected = [entry.purpose, entry.whenToUse, entry.whenNotToUse, entry.notes].filter(Boolean).join(' ');
-  expect(composeDescription(entry)).toBe(expected);
-  expect(composeDescription(entry).length).toBeGreaterThan(0);
-});
-
-test('project-home group is exactly the single project_home_write tool', () => {
-  expect(MCP_TOOL_CATALOG.filter((e) => e.group === 'project-home').map((e) => e.name)).toEqual(['project_home_write']);
-});
-
-test('MCP_RECIPES covers queue-work, unstick-needs-review, and hand-off-to-another-project', () => {
-  const ids = MCP_RECIPES.map((r) => r.id);
-  expect(ids).toContain('queue-work-via-develop');
-  expect(ids).toContain('unstick-needs-review-job');
-  expect(ids).toContain('hand-finding-to-another-project');
-  // the single-tool project_home_write needs no recipe; the old 4-step one is gone
-  expect(ids).not.toContain('generate-project-home');
-  for (const recipe of MCP_RECIPES) {
-    expect(recipe.title).toBeTruthy();
-    expect(Array.isArray(recipe.steps)).toBe(true);
-    expect(recipe.steps.length).toBeGreaterThan(0);
-  }
-});
-
-test.each(MCP_TOOL_CATALOG)('$name exampleArgs satisfies its own inputSchema required fields', (entry) => {
-  const tool = TOOLS.find((t) => t.name === entry.name);
-  expect(tool).toBeTruthy();
-  const required = tool.inputSchema?.required ?? [];
-  for (const key of required) {
-    expect(Object.prototype.hasOwnProperty.call(entry.exampleArgs, key)).toBe(true);
-    expect(entry.exampleArgs[key]).not.toBeUndefined();
-  }
-});

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

@@ -1,202 +0,0 @@
-'use strict';
-import { describe, it, expect, vi } from 'vitest';
-const { resolveModelCatalog, CATALOG_FLOOR, parseAliases, parseEffortLevels, scanModelIds } = require('../modelCatalog.cjs');
-
-const MODEL_OUT = 'Usage: /model <name>. Available: sonnet, opus, haiku, fable, best, sonnet[1m], opus[1m], fable[1m], opusplan, default, or a full model ID.';
-const EFFORT_OUT = 'Usage: /effort <low|medium|high|xhigh|max|auto>';
-const NOW = Date.parse('2026-09-20T00:00:00Z');
-
-function mk(over = {}) {
-  const files = over.files || {};
-  const fsImpl = {
-    readFileSync: (f) => { if (f in files) return files[f]; if (String(f).endsWith('claude-settings-schema.json')) return JSON.stringify({ properties: { effortLevel: { enum: ['low', 'medium', 'high', 'xhigh'] } } }); throw new Error('ENOENT'); },
-    realpathSync: (p) => p,
-    statSync: () => ({ isFile: () => true, size: 200 * 1024 * 1024 }),
-    openSync: () => 1, readSync: (fd, buf) => { buf.write('\x7fELF'); return 4; }, closeSync: () => {},
-    ...over.fs,
-  };
-  const runClaudeP = vi.fn(async (prompt) => ({ ok: true, out: prompt === '/model' ? MODEL_OUT : EFFORT_OUT }));
-  const writeJson = vi.fn(async () => {});
-  const deps = {
-    env: {}, now: () => NOW, homeDir: () => '/home/u', projectRootOf: (c) => c,
-    probeClaudeVersion: async () => '2.1.277', resolveClaudeBin: () => '/bin/claude',
-    scanModelIds: () => ['claude-opus-5', 'claude-sonnet-5'], fs: fsImpl, runClaudeP, writeJson, ...over.deps,
-  };
-  return { deps, runClaudeP, writeJson };
-}
-const CACHE = '/home/u/.claude/session-manager/model-catalog.json';
-const cacheEntry = (o = {}) => JSON.stringify({ aliases: ['sonnet'], models: ['claude-old-1'], effortLevels: ['low'], settingsEffortLevels: ['low'], claudeVersion: '2.1.277', probedAt: new Date(NOW - 1000).toISOString(), degraded: false, ...o });
-
-describe('parsers', () => {
-  it('parses aliases, dropping the "or a full model ID" clause and keeping [1m]', () => {
-    expect(parseAliases(`Current model: x\n${MODEL_OUT}`)).toEqual(['sonnet', 'opus', 'haiku', 'fable', 'best', 'sonnet[1m]', 'opus[1m]', 'fable[1m]', 'opusplan', 'default']);
-  });
-  it('parses effort levels', () => {
-    expect(parseEffortLevels(EFFORT_OUT)).toEqual(['low', 'medium', 'high', 'xhigh', 'max', 'auto']);
-  });
-  it('returns null on garbage', () => {
-    expect(parseAliases('nope')).toBeNull();
-    expect(parseEffortLevels('nope')).toBeNull();
-  });
-});
-
-describe('scanModelIds', () => {
-  const scanBuf = (content, opts) => {
-    const data = Buffer.from(content, 'latin1');
-    let pos = 0;
-    const fsImpl = {
-      openSync: () => 1, closeSync: () => {},
-      readSync: (fd, buf, off, len) => { const n = Math.min(len, data.length - pos); data.copy(buf, off, pos, pos + n); pos += n; return n; },
-    };
-    return scanModelIds('/x', { fsImpl, ...opts });
-  };
-  it('finds an id split across a chunk boundary', () => {
-    const content = 'x'.repeat(13) + 'claude-opus-4-8' + '\0' + 'y'.repeat(20) + 'claude-haiku-4-5-20251001\0';
-    // chunk 20 cuts the first id after "claude-opus" (offset 13..28)
-    expect(scanBuf(content, { chunkSize: 20, overlap: 64 })).toEqual(['claude-haiku-4-5-20251001', 'claude-opus-4-8']);
-  });
-  it('does not report a truncated id when the tail is cut mid-number', () => {
-    expect(scanBuf('aaaaclaude-opus-4-8zz', { chunkSize: 14, overlap: 64 })).toEqual(['claude-opus-4-8']);
-  });
-});
-
-describe('resolveModelCatalog', () => {
-  it('happy path: merges probes, binary, schema, allowlist and writes cache', async () => {
-    const t = mk({ files: { '/home/u/.claude/settings.json': JSON.stringify({ availableModels: ['opus', 'haiku'] }), '/p/.claude/settings.local.json': JSON.stringify({ availableModels: ['haiku', 'sonnet'] }) } });
-    const c = await resolveModelCatalog({ cwd: '/p', force: true, deps: t.deps });
-    expect(c.aliases).toContain('opus[1m]');
-    expect(c.effortLevels).toEqual(['low', 'medium', 'high', 'xhigh', 'max']); // `auto` is a reset verb, not selectable
-    expect(c.models).toEqual(['claude-opus-5', 'claude-sonnet-5']);
-    expect(c.settingsEffortLevels).toEqual(['low', 'medium', 'high', 'xhigh']);
-    expect(c.availableModels).toEqual(['opus', 'haiku', 'sonnet']);
-    expect(c.sources).toEqual({ aliases: 'probe', models: 'binary', effortLevels: 'probe' });
-    expect(c.degraded).toBe(false);
-    expect(c.claudeVersion).toBe('2.1.277');
-    expect(t.runClaudeP).toHaveBeenCalledWith('/model', { model: 'haiku', timeoutMs: 45000 });
-    expect(t.runClaudeP).toHaveBeenCalledWith('/effort', { model: 'haiku', timeoutMs: 45000 });
-    expect(t.writeJson).toHaveBeenCalledWith(CACHE, c);
-  });
-  it('availableModels is null when no scope defines it', async () => {
-    const c = await resolveModelCatalog({ cwd: '/p', force: true, deps: mk().deps });
-    expect(c.availableModels).toBeNull();
-  });
-  it('fresh matching cache is returned without spawning; force bypasses it', async () => {
-    const t = mk({ files: { [CACHE]: cacheEntry() } });
-    const c = await resolveModelCatalog({ deps: t.deps });
-    expect(c.aliases).toEqual(['sonnet']);
-    expect(c.sources.aliases).toBe('cache');
-    expect(t.runClaudeP).not.toHaveBeenCalled();
-    await resolveModelCatalog({ force: true, deps: t.deps });
-    expect(t.runClaudeP).toHaveBeenCalledTimes(2);
-  });
-  it('probe timeout falls back to stale cache and marks degraded', async () => {
-    const t = mk({ files: { [CACHE]: cacheEntry({ probedAt: new Date(NOW - 48 * 3600e3).toISOString() }) }, deps: { runClaudeP: vi.fn(async () => ({ ok: false, error: 'timeout' })) } });
-    const c = await resolveModelCatalog({ deps: t.deps });
-    expect(c.aliases).toEqual(['sonnet']);
-    expect(c.effortLevels).toEqual(['low']);
-    expect(c.sources.aliases).toBe('cache');
-    expect(c.sources.effortLevels).toBe('cache');
-    expect(c.sources.models).toBe('binary');
-    expect(c.degraded).toBe(true);
-    expect(t.writeJson).not.toHaveBeenCalled();
-  });
-  it('stale cache from a different CLI version is used before the floor; no cache → floor', async () => {
-    const fail = { runClaudeP: vi.fn(async () => ({ ok: false })), scanModelIds: () => { throw new Error('ENOENT'); } };
-    const stale = mk({ files: { [CACHE]: cacheEntry({ claudeVersion: '1.0.0' }) }, deps: fail });
-    const c1 = await resolveModelCatalog({ deps: stale.deps });
-    expect(c1.aliases).toEqual(['sonnet']);
-    expect(c1.models).toEqual(['claude-old-1']);
-    const none = mk({ deps: fail });
-    const c2 = await resolveModelCatalog({ deps: none.deps });
-    expect(c2.aliases).toEqual(CATALOG_FLOOR.aliases);
-    expect(c2.effortLevels).toEqual(CATALOG_FLOOR.effortLevels);
-    expect(c2.models).toEqual([]);
-    expect(c2.sources).toEqual({ aliases: 'floor', models: 'floor', effortLevels: 'floor' });
-    expect(c2.degraded).toBe(true);
-  });
-  it('corrupt cache degrades to floor without throwing', async () => {
-    const t = mk({ files: { [CACHE]: '{not json' }, deps: { runClaudeP: vi.fn(async () => ({ ok: false })) } });
-    const c = await resolveModelCatalog({ deps: t.deps });
-    expect(c.aliases).toEqual(CATALOG_FLOOR.aliases);
-  });
-  it('single-flight collapses concurrent calls into one probe pair', async () => {
-    const t = mk();
-    const [a, b] = await Promise.all([resolveModelCatalog({ force: true, deps: t.deps }), resolveModelCatalog({ force: true, deps: t.deps })]);
-    expect(a).toBe(b);
-    expect(t.runClaudeP).toHaveBeenCalledTimes(2);
-  });
-  it('SM_E2E=1 never spawns: floor, or a cache when present', async () => {
-    const t = mk({ deps: { env: { SM_E2E: '1' } } });
-    const c = await resolveModelCatalog({ force: true, deps: t.deps });
-    expect(c.aliases).toEqual(CATALOG_FLOOR.aliases);
-    expect(t.runClaudeP).not.toHaveBeenCalled();
-    const t2 = mk({ files: { [CACHE]: cacheEntry() }, deps: { env: { SM_E2E: '1' } } });
-    expect((await resolveModelCatalog({ deps: t2.deps })).aliases).toEqual(['sonnet']);
-    expect(t2.runClaudeP).not.toHaveBeenCalled();
-  });
-});
-
-describe('catalog cache file (real write boundary)', () => {
-  it('is written under ~/.claude, a path the real validateWrite accepts', async () => {
-    const os = require('node:os'); const pth = require('node:path');
-    const config = require('../../config.cjs');
-    const realHome = os.homedir();
-    const file = pth.join(realHome, '.claude', 'session-manager', 'model-catalog.json');
-    const t = mk({ deps: { homeDir: () => realHome, writeJson: undefined } });
-    const written = [];
-    t.deps.writeJson = async (f, d) => { written.push(f); config.validateWrite(f); };
-    await resolveModelCatalog({ force: true, deps: t.deps });
-    expect(written).toEqual([file]);
-  });
-  it('a userData path is rejected by validateWrite (why the cache must not live there)', () => {
-    const config = require('../../config.cjs');
-    expect(() => config.validateWrite('/somewhere/userData/model-catalog.json')).toThrow(/outside allowed write boundaries/);
-  });
-});
-
-describe('binary scan guard', () => {
-  it('never scans a small shell-script stub; degrades to the floor', async () => {
-    const scan = vi.fn(() => ['claude-x-1']);
-    const t = mk({ fs: { statSync: () => ({ isFile: () => true, size: 300 }) }, deps: { scanModelIds: scan } });
-    const c = await resolveModelCatalog({ force: true, deps: t.deps });
-    expect(scan).not.toHaveBeenCalled();
-    expect(c.sources.models).toBe('floor');
-    expect(c.degraded).toBe(true);
-  });
-  it('never scans a large file that is a shell script', async () => {
-    const scan = vi.fn(() => ['claude-x-1']);
-    const t = mk({ fs: { readSync: (fd, buf) => { buf.write('#!/bin/bash\n'); return 12; } }, deps: { scanModelIds: scan } });
-    await resolveModelCatalog({ force: true, deps: t.deps });
-    expect(scan).not.toHaveBeenCalled();
-  });
-});
-
-describe('null CLI version key', () => {
-  it('neither serves a cache as fresh nor writes one', async () => {
-    const t = mk({ files: { [CACHE]: cacheEntry({ claudeVersion: null }) }, deps: { probeClaudeVersion: async () => null } });
-    const c = await resolveModelCatalog({ deps: t.deps });
-    expect(t.runClaudeP).toHaveBeenCalled();
-    expect(c.claudeVersion).toBeNull();
-    expect(t.writeJson).not.toHaveBeenCalled();
-  });
-  it('a null-version cache entry is never a fresh hit for a real version', async () => {
-    const t = mk({ files: { [CACHE]: cacheEntry({ claudeVersion: null }) } });
-    await resolveModelCatalog({ deps: t.deps });
-    expect(t.runClaudeP).toHaveBeenCalled();
-  });
-});
-
-describe('effort auto is never a flag value', () => {
-  it('drops `auto` from live and cached effort levels', async () => {
-    const t = mk({ files: { [CACHE]: cacheEntry({ effortLevels: ['low', 'auto'], probedAt: new Date(NOW - 48 * 3600e3).toISOString() }) }, deps: { runClaudeP: vi.fn(async () => ({ ok: false })) } });
-    const c = await resolveModelCatalog({ deps: t.deps });
-    expect(c.effortLevels).toEqual(['low']);
-  });
-  it('effortArgs and resolveEpicEffort never emit --effort auto', () => {
-    const { effortArgs } = require('../agentEffortResolve.cjs');
-    expect(effortArgs('auto')).toEqual([]);
-    expect(effortArgs('AUTO')).toEqual([]);
-    expect(effortArgs('inherit')).toEqual([]);
-    expect(effortArgs('high')).toEqual(['--effort', 'high']);
-  });
-});