llm-switcher 1.2.7 → 1.2.8

package/tests/live-optimizer-interop.mjs

@@ -1,205 +1,205 @@
-// LIVE test: requires a running gateway (switch on) and a real upstream (costs tokens).
-// Offline test, no network needed: npm test
-const GATEWAY_PORT = Number(process.env.LLM_SWITCHER_PORT) || 3456;
-const BASE_URL = `http://127.0.0.1:${GATEWAY_PORT}`;
-
-console.log('================================================================');
-console.log('  LLM SWITCHER — TOKEN OPTIMIZER INTEROPERABILITY TEST SUITE   ');
-console.log('  Simulating failure modes from Headroom, RTK, and Ponytail    ');
-console.log('================================================================\n');
-
-let passed = 0;
-let failed = 0;
-
-async function runTest(name, fn) {
-  process.stdout.write(`[TEST] ${name}... `);
-  const t0 = Date.now();
-  try {
-    const detail = await fn();
-    console.log(`PASS (${Date.now() - t0}ms)`);
-    if (detail) console.log(`       ↳ ${detail}`);
-    passed++;
-  } catch (err) {
-    console.log(`FAIL (${Date.now() - t0}ms)`);
-    console.log(`       ↳ ERROR: ${err.message}`);
-    failed++;
-  }
-}
-
-// -----------------------------------------------------------------------------
-// TEST 1: Headroom Failure Mode — Orphaned tool_result
-// When Headroom prunes history to save tokens, it drops the assistant tool_use turn.
-// Anthropic strictly throws: 400 invalid_request_error: 'tool_use_id does not correspond to any tool_use'
-// LLM Switcher Healer Engine: Repairs orphaned result into context text -> 200 OK
-// -----------------------------------------------------------------------------
-await runTest('Headroom Simulation: Orphaned tool_result turn', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 40,
-    messages: [
-      { role: 'user', content: 'Context turn before pruning' },
-      {
-        role: 'user',
-        content: [
-          { type: 'tool_result', tool_use_id: 'headroom_pruned_call_99', content: 'Database query result: 42 rows found' },
-          { type: 'text', text: 'Reply: healed successfully' }
-        ]
-      }
-    ],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    const err = await res.text();
-    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
-  }
-  const json = await res.json();
-  const text = json.content?.map(c => c.text).join('') || '';
-  return `Healed orphaned tool_result. Response HTTP 200: "${text.slice(0, 50).replace(/\n/g, ' ')}..."`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 2: Headroom Failure Mode — Consecutive User turns (Roles must alternate)
-// When Headroom collapses history, multiple user turns occur back-to-back.
-// Anthropic strictly throws: 400 invalid_request_error: 'roles must alternate'
-// LLM Switcher Healer Engine: Merges consecutive same-role turns -> 200 OK
-// -----------------------------------------------------------------------------
-await runTest('Headroom Simulation: Consecutive User turns (Role alternation violation)', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 30,
-    messages: [
-      { role: 'user', content: 'User message turn 1' },
-      { role: 'user', content: 'User message turn 2 (no assistant in between)' },
-      { role: 'user', content: 'User message turn 3: reply pong' }
-    ],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    const err = await res.text();
-    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
-  }
-  const json = await res.json();
-  return `Merged consecutive turns seamlessly. Stop reason: ${json.stop_reason}`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 3: Headroom / RTK Failure Mode — Stripped Thinking Parameter
-// Optimizer stripped the 'thinking' object to reduce tokens.
-// LLM Switcher Thinking Guard: Detects reasoning model (ag/claude-opus-4-6-thinking)
-// and restores thinking.budget_tokens automatically -> thinking_delta emitted!
-// -----------------------------------------------------------------------------
-await runTest('Thinking Guard: Restoring stripped thinking parameter on reasoning models', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 200,
-    // Note: NO thinking parameter included (simulating optimizer stripping it)
-    messages: [
-      { role: 'user', content: 'Solve step by step: what is 17 * 23? Show reasoning.' }
-    ],
-    stream: true
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    throw new Error(`Expected HTTP 200, got ${res.status}`);
-  }
-
-  const text = await res.text();
-  const hasThinkingDelta = text.includes('thinking_delta');
-  const hasSignatureDelta = text.includes('signature_delta');
-  const hasTextDelta = text.includes('text_delta');
-
-  if (!hasThinkingDelta) {
-    throw new Error('Thinking Guard failed: thinking_delta was NOT emitted in stream!');
-  }
-
-  return `Automatically restored thinking: thinking_delta=${hasThinkingDelta}, signature_delta=${hasSignatureDelta}, text_delta=${hasTextDelta}`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 4: RTK & Intermediary Headers Passthrough
-// RTK / tracing tools inject headers: x-rtk-version, traceparent, x-request-id.
-// LLM Switcher: Transparently preserves all tracking headers without rejection.
-// -----------------------------------------------------------------------------
-await runTest('RTK Intermediary: Custom headers and traceparent passthrough', async () => {
-  const payload = {
-    model: 'claude-opus-4-6',
-    max_tokens: 20,
-    messages: [{ role: 'user', content: 'ping' }],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'anthropic-version': '2023-06-01',
-      'x-rtk-version': '0.37.2',
-      'x-optimizer-id': 'rtk-cli-hook',
-      'traceparent': '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01'
-    },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    throw new Error(`Expected HTTP 200, got ${res.status}`);
-  }
-  return `Headers accepted cleanly with HTTP 200 OK`;
-});
-
-// -----------------------------------------------------------------------------
-// TEST 5: OpenAI Chat Healer Mode — Orphaned Tool Result in Chat Completions
-// Same test but over /v1/chat/completions: tool role message without prior tool_calls assistant message.
-// OpenAI API strictly throws: 400 'messages with role tool must be a response to a preceding message with tool_calls'
-// LLM Switcher: Converts orphaned tool to user text message -> 200 OK
-// -----------------------------------------------------------------------------
-await runTest('OpenAI Chat Healer: Orphaned role tool without preceding assistant tool_calls', async () => {
-  const payload = {
-    model: 'ag/gpt-oss-120b-medium',
-    max_tokens: 30,
-    messages: [
-      { role: 'user', content: 'Turn 1 context' },
-      { role: 'tool', tool_call_id: 'orphaned_chat_call_77', content: 'Tool execution logs: OK' },
-      { role: 'user', content: 'reply pong' }
-    ],
-    stream: false
-  };
-
-  const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(payload)
-  });
-
-  if (res.status !== 200) {
-    const err = await res.text();
-    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
-  }
-  const json = await res.json();
-  return `Chat Healer rescued orphaned tool role. Stop reason: ${json.choices?.[0]?.finish_reason}`;
-});
-
-console.log('\n================================================================');
-console.log(`  TEST RESULTS: ${passed} PASSED / ${failed} FAILED               `);
-console.log('================================================================\n');
-
-process.exit(failed ? 1 : 0);
+// LIVE test: requires a running gateway (switch on) and a real upstream (costs tokens).
+// Offline test, no network needed: npm test
+const GATEWAY_PORT = Number(process.env.LLM_SWITCHER_PORT) || 3456;
+const BASE_URL = `http://127.0.0.1:${GATEWAY_PORT}`;
+
+console.log('================================================================');
+console.log('  LLM SWITCHER — TOKEN OPTIMIZER INTEROPERABILITY TEST SUITE   ');
+console.log('  Simulating failure modes from Headroom, RTK, and Ponytail    ');
+console.log('================================================================\n');
+
+let passed = 0;
+let failed = 0;
+
+async function runTest(name, fn) {
+  process.stdout.write(`[TEST] ${name}... `);
+  const t0 = Date.now();
+  try {
+    const detail = await fn();
+    console.log(`PASS (${Date.now() - t0}ms)`);
+    if (detail) console.log(`       ↳ ${detail}`);
+    passed++;
+  } catch (err) {
+    console.log(`FAIL (${Date.now() - t0}ms)`);
+    console.log(`       ↳ ERROR: ${err.message}`);
+    failed++;
+  }
+}
+
+// -----------------------------------------------------------------------------
+// TEST 1: Headroom Failure Mode — Orphaned tool_result
+// When Headroom prunes history to save tokens, it drops the assistant tool_use turn.
+// Anthropic strictly throws: 400 invalid_request_error: 'tool_use_id does not correspond to any tool_use'
+// LLM Switcher Healer Engine: Repairs orphaned result into context text -> 200 OK
+// -----------------------------------------------------------------------------
+await runTest('Headroom Simulation: Orphaned tool_result turn', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 40,
+    messages: [
+      { role: 'user', content: 'Context turn before pruning' },
+      {
+        role: 'user',
+        content: [
+          { type: 'tool_result', tool_use_id: 'headroom_pruned_call_99', content: 'Database query result: 42 rows found' },
+          { type: 'text', text: 'Reply: healed successfully' }
+        ]
+      }
+    ],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    const err = await res.text();
+    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
+  }
+  const json = await res.json();
+  const text = json.content?.map(c => c.text).join('') || '';
+  return `Healed orphaned tool_result. Response HTTP 200: "${text.slice(0, 50).replace(/\n/g, ' ')}..."`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 2: Headroom Failure Mode — Consecutive User turns (Roles must alternate)
+// When Headroom collapses history, multiple user turns occur back-to-back.
+// Anthropic strictly throws: 400 invalid_request_error: 'roles must alternate'
+// LLM Switcher Healer Engine: Merges consecutive same-role turns -> 200 OK
+// -----------------------------------------------------------------------------
+await runTest('Headroom Simulation: Consecutive User turns (Role alternation violation)', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 30,
+    messages: [
+      { role: 'user', content: 'User message turn 1' },
+      { role: 'user', content: 'User message turn 2 (no assistant in between)' },
+      { role: 'user', content: 'User message turn 3: reply pong' }
+    ],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    const err = await res.text();
+    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
+  }
+  const json = await res.json();
+  return `Merged consecutive turns seamlessly. Stop reason: ${json.stop_reason}`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 3: Headroom / RTK Failure Mode — Stripped Thinking Parameter
+// Optimizer stripped the 'thinking' object to reduce tokens.
+// LLM Switcher Thinking Guard: Detects reasoning model (ag/claude-opus-4-6-thinking)
+// and restores thinking.budget_tokens automatically -> thinking_delta emitted!
+// -----------------------------------------------------------------------------
+await runTest('Thinking Guard: Restoring stripped thinking parameter on reasoning models', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 200,
+    // Note: NO thinking parameter included (simulating optimizer stripping it)
+    messages: [
+      { role: 'user', content: 'Solve step by step: what is 17 * 23? Show reasoning.' }
+    ],
+    stream: true
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    throw new Error(`Expected HTTP 200, got ${res.status}`);
+  }
+
+  const text = await res.text();
+  const hasThinkingDelta = text.includes('thinking_delta');
+  const hasSignatureDelta = text.includes('signature_delta');
+  const hasTextDelta = text.includes('text_delta');
+
+  if (!hasThinkingDelta) {
+    throw new Error('Thinking Guard failed: thinking_delta was NOT emitted in stream!');
+  }
+
+  return `Automatically restored thinking: thinking_delta=${hasThinkingDelta}, signature_delta=${hasSignatureDelta}, text_delta=${hasTextDelta}`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 4: RTK & Intermediary Headers Passthrough
+// RTK / tracing tools inject headers: x-rtk-version, traceparent, x-request-id.
+// LLM Switcher: Transparently preserves all tracking headers without rejection.
+// -----------------------------------------------------------------------------
+await runTest('RTK Intermediary: Custom headers and traceparent passthrough', async () => {
+  const payload = {
+    model: 'claude-opus-4-6',
+    max_tokens: 20,
+    messages: [{ role: 'user', content: 'ping' }],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/messages`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'anthropic-version': '2023-06-01',
+      'x-rtk-version': '0.37.2',
+      'x-optimizer-id': 'rtk-cli-hook',
+      'traceparent': '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01'
+    },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    throw new Error(`Expected HTTP 200, got ${res.status}`);
+  }
+  return `Headers accepted cleanly with HTTP 200 OK`;
+});
+
+// -----------------------------------------------------------------------------
+// TEST 5: OpenAI Chat Healer Mode — Orphaned Tool Result in Chat Completions
+// Same test but over /v1/chat/completions: tool role message without prior tool_calls assistant message.
+// OpenAI API strictly throws: 400 'messages with role tool must be a response to a preceding message with tool_calls'
+// LLM Switcher: Converts orphaned tool to user text message -> 200 OK
+// -----------------------------------------------------------------------------
+await runTest('OpenAI Chat Healer: Orphaned role tool without preceding assistant tool_calls', async () => {
+  const payload = {
+    model: 'ag/gpt-oss-120b-medium',
+    max_tokens: 30,
+    messages: [
+      { role: 'user', content: 'Turn 1 context' },
+      { role: 'tool', tool_call_id: 'orphaned_chat_call_77', content: 'Tool execution logs: OK' },
+      { role: 'user', content: 'reply pong' }
+    ],
+    stream: false
+  };
+
+  const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload)
+  });
+
+  if (res.status !== 200) {
+    const err = await res.text();
+    throw new Error(`Expected HTTP 200, got ${res.status}: ${err}`);
+  }
+  const json = await res.json();
+  return `Chat Healer rescued orphaned tool role. Stop reason: ${json.choices?.[0]?.finish_reason}`;
+});
+
+console.log('\n================================================================');
+console.log(`  TEST RESULTS: ${passed} PASSED / ${failed} FAILED               `);
+console.log('================================================================\n');
+
+process.exit(failed ? 1 : 0);

package/tests/plugin.test.mjs

@@ -0,0 +1,132 @@
+// Installing the launch hook into the two coding tools, without editing any configuration of theirs.
+//
+// Claude Code loads any folder under a skills directory that holds `.claude-plugin/plugin.json` as
+// a plugin, on the next session, with no marketplace and no install step. Codex loads
+// `$CODEX_HOME/hooks.json` by itself. So both tools get the hook from a file of their own, and
+// `settings.json` and `config.toml` are never touched.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { renderClaudePlugin, renderClaudeHooks, renderCodexHooks, installPlugin, uninstallPlugin, pluginStatus } =
+  await import(pathToFileURL(path.join(ROOT, 'plugin.mjs')).href);
+
+function dirs(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-plug-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const claudeSkillsDir = path.join(home, '.claude', 'skills');
+  const codexHome = path.join(home, '.codex');
+  fs.mkdirSync(claudeSkillsDir, { recursive: true });
+  fs.mkdirSync(codexHome, { recursive: true });
+  return { home, claudeSkillsDir, codexHome, opts: { claudeSkillsDir, codexHome } };
+}
+
+const readJson = (f) => JSON.parse(fs.readFileSync(f, 'utf8'));
+
+test('the Claude plugin manifest and hooks name the hook script and the tool claude', () => {
+  const manifest = JSON.parse(renderClaudePlugin());
+  assert.equal(typeof manifest.name, 'string');
+  assert.ok(manifest.name.length > 0, 'a plugin needs a name, it becomes the skills-dir id');
+  assert.ok(manifest.version, 'and a version');
+  const hooks = JSON.parse(renderClaudeHooks());
+  const entry = hooks.hooks.SessionStart[0].hooks[0];
+  assert.equal(entry.type, 'command');
+  assert.match(JSON.stringify(entry), /hook-status\.mjs/);
+  assert.match(JSON.stringify(entry), /"claude"/, 'the claude plugin asks about claude');
+  assert.doesNotMatch(JSON.stringify(entry), /codex/);
+});
+
+test('the Codex hooks file asks about codex and matches a fresh start or a resume', () => {
+  const hooks = JSON.parse(renderCodexHooks());
+  const group = hooks.hooks.SessionStart[0];
+  assert.match(group.matcher, /startup/, 'the first open of a session');
+  assert.match(group.matcher, /resume/, 'and a resumed session, which is the bypass this exists for');
+  const entry = group.hooks[0];
+  assert.equal(entry.type, 'command');
+  assert.match(entry.command, /hook-status\.mjs/);
+  assert.match(entry.command, /codex/);
+});
+
+test('install writes a plugin for Claude Code and a hooks file for Codex, and repeats cleanly', (t) => {
+  const { claudeSkillsDir, codexHome, opts } = dirs(t);
+  const first = installPlugin(opts);
+  assert.deepEqual(first.failed, [], 'nothing failed');
+  assert.deepEqual(first.installed.sort(), ['claude', 'codex']);
+
+  const manifest = path.join(claudeSkillsDir, 'llm-switcher-status', '.claude-plugin', 'plugin.json');
+  assert.ok(fs.existsSync(manifest), 'the manifest is what makes the folder a plugin');
+  assert.ok(fs.existsSync(path.join(claudeSkillsDir, 'llm-switcher-status', 'hooks', 'hooks.json')));
+  assert.ok(fs.existsSync(path.join(codexHome, 'hooks.json')));
+
+  // The whole point: neither tool's own configuration file is created or changed.
+  assert.equal(fs.existsSync(path.join(codexHome, 'config.toml')), false, 'config.toml is never written');
+
+  const second = installPlugin(opts);
+  assert.deepEqual(second.failed, [], 'a second install is a no-op that still succeeds');
+  assert.equal(JSON.parse(fs.readFileSync(path.join(codexHome, 'hooks.json'), 'utf8')).hooks.SessionStart.length, 1,
+    'and it does not add a second copy of our entry');
+});
+
+test('install keeps a Codex hook that belongs to someone else', (t) => {
+  const { codexHome, opts } = dirs(t);
+  fs.writeFileSync(path.join(codexHome, 'hooks.json'), JSON.stringify({
+    description: 'the rule gate of this machine',
+    hooks: {
+      PreToolUse: [{ matcher: '^Bash$', hooks: [{ type: 'command', command: 'node rule-gate.js' }] }],
+      SessionStart: [{ matcher: 'startup', hooks: [{ type: 'command', command: 'node someone-else.js' }] }]
+    }
+  }, null, 2));
+
+  installPlugin(opts);
+  const after = readJson(path.join(codexHome, 'hooks.json'));
+  assert.equal(after.hooks.PreToolUse.length, 1, 'another event is untouched');
+  assert.match(JSON.stringify(after.hooks.PreToolUse), /rule-gate/);
+  const commands = after.hooks.SessionStart.flatMap(g => g.hooks.map(h => h.command));
+  assert.ok(commands.some(c => /someone-else\.js/.test(c)), 'the other SessionStart hook survives');
+  assert.ok(commands.some(c => /hook-status\.mjs/.test(c)), 'and ours is added beside it');
+
+  const removed = uninstallPlugin(opts);
+  assert.deepEqual(removed.failed, []);
+  const end = readJson(path.join(codexHome, 'hooks.json'));
+  const endCommands = JSON.stringify(end);
+  assert.match(endCommands, /someone-else\.js/, 'uninstall leaves the other hook in place');
+  assert.match(endCommands, /rule-gate/);
+  assert.doesNotMatch(endCommands, /hook-status\.mjs/, 'and takes only ours away');
+});
+
+test('install refuses a Codex hooks file it cannot parse, and changes nothing', (t) => {
+  const { codexHome, opts } = dirs(t);
+  const f = path.join(codexHome, 'hooks.json');
+  fs.writeFileSync(f, '{ not json at all');
+  const r = installPlugin(opts);
+  assert.equal(fs.readFileSync(f, 'utf8'), '{ not json at all', 'a file that may hold real hooks is never overwritten');
+  assert.ok(r.failed.some(x => x.tool === 'codex'), 'and the refusal is reported');
+  assert.ok(r.installed.includes('claude'), 'while the other tool still gets its plugin');
+});
+
+test('install leaves a folder that is not our plugin alone', (t) => {
+  const { claudeSkillsDir, opts } = dirs(t);
+  const dir = path.join(claudeSkillsDir, 'llm-switcher-status');
+  fs.mkdirSync(path.join(dir, '.claude-plugin'), { recursive: true });
+  fs.writeFileSync(path.join(dir, '.claude-plugin', 'plugin.json'), JSON.stringify({ name: 'someone-elses-work' }));
+  const r = installPlugin(opts);
+  assert.match(fs.readFileSync(path.join(dir, '.claude-plugin', 'plugin.json'), 'utf8'), /someone-elses-work/);
+  assert.ok(r.failed.some(x => x.tool === 'claude'));
+});
+
+test('status reports each tool, and says plainly when nothing is installed', (t) => {
+  const { opts } = dirs(t);
+  const before = pluginStatus(opts);
+  assert.equal(before.claude.installed, false);
+  assert.equal(before.codex.installed, false);
+  installPlugin(opts);
+  const after = pluginStatus(opts);
+  assert.equal(after.claude.installed, true);
+  assert.equal(after.codex.installed, true);
+  assert.match(after.claude.path, /llm-switcher-status/);
+  assert.match(after.codex.path, /hooks\.json$/);
+});

package/tests/real-user-sim.test.mjs

@@ -324,7 +324,7 @@ test('Real User Sim 3: Gemini / Vertex healing of empty & complex tool schemas',
   await post('/api/switch', { tool: 'claude', profile: 'chat' });
 });
 
-test('Real User Sim 4: Codex WebSocket turns (warmup -> prompt -> apply_patch -> continue)', async () => {
+test('Real User Sim 4: Codex WebSocket turns (warmup -> prompt -> apply_patch -> continue)', { skip: typeof WebSocket === 'undefined' && 'global WebSocket needs Node 22+' }, async () => {
   const ws = new WebSocket(`ws://127.0.0.1:${proxyPort}/v1/responses`);
   const messages = [];
 
@@ -387,7 +387,7 @@ test('Real User Sim 4: Codex WebSocket turns (warmup -> prompt -> apply_patch ->
   ws.close();
 });
 
-test('Real User Sim 5: High-concurrency dual-tool execution (Claude streaming + Codex WS simultaneously)', async () => {
+test('Real User Sim 5: High-concurrency dual-tool execution (Claude streaming + Codex WS simultaneously)', { skip: typeof WebSocket === 'undefined' && 'global WebSocket needs Node 22+' }, async () => {
   const ws = new WebSocket(`ws://127.0.0.1:${proxyPort}/v1/responses`);
   await new Promise(r => { ws.onopen = r; });
   const wsMessages = [];

package/tests/service.test.mjs

@@ -16,6 +16,8 @@ const HAS_XMLLINT = (() => { try { execFileSync('xmllint', ['--version'], { stdi
 test('serviceEnv passes only the variables that change where the gateway reads and writes', () => {
   const env = serviceEnv({ CLAUDE_CONFIG_DIR: '/c', LLM_SWITCHER_CONFIG: '/cfg.json', LLM_SWITCHER_BLINDFOLD_CERTS: '', HOME: '/h', PATH: '/bin' });
   assert.deepEqual(env, [['CLAUDE_CONFIG_DIR', '/c'], ['LLM_SWITCHER_CONFIG', '/cfg.json']]);
+  // The data folder override must reach the service too, or it reads another config.json.
+  assert.deepEqual(serviceEnv({ LLM_SWITCHER_HOME: '/data' }), [['LLM_SWITCHER_HOME', '/data']]);
 });
 
 test('systemd unit quotes the command and carries the environment', () => {