@plexor-dev/claude-code-plugin-staging 0.1.0-beta.21 → 0.1.0-beta.23

package/commands/plexor-enabled.js

@@ -243,7 +243,8 @@ function main() {
     console.log(`│  Run /plexor-setup first.                   │`);
     console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  Get your API key at:                       │`);
-    console.log(`│  https://staging.plexorlabs.com             │`);
+    console.log(`│  https://staging.plexorlabs.com/            │`);
+    console.log(`│  api-keys.html                              │`);
     console.log(`└─────────────────────────────────────────────┘`);
     process.exit(1);
   }

package/commands/plexor-login.js

@@ -262,7 +262,8 @@ async function main() {
     console.log(`│  Human first-run: /plexor-setup             │`);
     console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  Get your API key at:                       │`);
-    console.log(`│  https://staging.plexorlabs.com             │`);
+    console.log(`│  https://staging.plexorlabs.com/            │`);
+    console.log(`│  api-keys.html                              │`);
     console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  Secure usage (recommended):                │`);
     console.log(`│    echo "plx_..." | /plexor-login           │`);
@@ -340,7 +341,7 @@ async function main() {
     }
     console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  Human first-run: /plexor-setup             │`);
-    console.log(`│  Automation complete. Status: /plexor-status│`);
+    console.log(`│  Restart Claude before testing prompts      │`);
     console.log(`└─────────────────────────────────────────────┘`);
   } catch (err) {
     console.error(`┌─────────────────────────────────────────────┐`);

package/commands/plexor-logout.js

@@ -102,7 +102,8 @@ function main() {
   const currentSettings = settingsManager.load();
   const hadPriorAuth = Boolean(
     currentSettings.env?.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY ||
-    currentSettings.env?.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN
+    currentSettings.env?.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN ||
+    currentSettings.env?.PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY
   );
 
   // Clear credentials

package/commands/plexor-setup.js

@@ -128,9 +128,9 @@ function printReceipt({ user, gateway, previousAuthPreserved, verifyResult }) {
   console.log(line(`Previous Claude auth: ${previousAuthPreserved ? 'Saved' : 'None found'}`));
   console.log('├─────────────────────────────────────────────┤');
   if (verifyResult.ok) {
-    console.log(line('Claude is now routed through Plexor'));
+    console.log(line('Plexor routing is configured'));
+    console.log(line('Restart Claude, then send a prompt'));
     console.log(line('Logout/uninstall restores prior auth'));
-    console.log(line('Next: Run /plexor-status for health + stats'));
   } else {
     console.log(line('Claude routing was configured'));
     console.log(line('Verification did not pass'));
@@ -217,7 +217,8 @@ async function main() {
   const currentSettings = settingsManager.load();
   const previousAuthPreserved = Boolean(
     currentSettings.env?.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY ||
-    currentSettings.env?.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN
+    currentSettings.env?.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN ||
+    currentSettings.env?.PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY
   );
 
   const verifyResult = skipVerify

package/commands/plexor-setup.md

@@ -13,7 +13,7 @@ node ~/.claude/plugins/plexor/commands/plexor-setup.js $ARGUMENTS
 
 If the user did not provide a key yet, ask them:
 
-`Please paste your Plexor API key (starts with plx_). You can get one at https://staging.plexorlabs.com.`
+`Please paste your Plexor API key (starts with plx_). You can get one at https://staging.plexorlabs.com/api-keys.html.`
 
 After the user replies with the key, run:
 

package/commands/plexor-status.js

@@ -12,6 +12,7 @@ const https = require('https');
 // Import centralized constants with HOME directory validation
 const { HOME_DIR, CONFIG_PATH, SESSION_PATH, SESSION_TIMEOUT_MS } = require('../lib/constants');
 const CLAUDE_SETTINGS_PATH = path.join(HOME_DIR, '.claude', 'settings.json');
+const CLAUDE_STATE_PATH = path.join(HOME_DIR, '.claude.json');
 
 function isManagedGatewayUrl(baseUrl = '') {
   return (
@@ -33,6 +34,49 @@ function getPlexorAuthKey(env = {}) {
   return apiKey || authToken || '';
 }
 
+function getDirectClaudeAuthState() {
+  try {
+    const data = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+    const settings = JSON.parse(data);
+    const env = settings.env || {};
+    const baseUrl = env.ANTHROPIC_BASE_URL || '';
+    const apiKey = env.ANTHROPIC_API_KEY || '';
+    const authToken = env.ANTHROPIC_AUTH_TOKEN || '';
+
+    if (!isManagedGatewayUrl(baseUrl)) {
+      if (apiKey && !apiKey.startsWith('plx_')) {
+        return { present: true, source: 'Claude settings' };
+      }
+      if (authToken && !authToken.startsWith('plx_')) {
+        return { present: true, source: 'Claude settings' };
+      }
+    }
+  } catch {
+    // Ignore missing or unreadable Claude settings.
+  }
+
+  try {
+    const data = fs.readFileSync(CLAUDE_STATE_PATH, 'utf8');
+    const state = JSON.parse(data);
+    if (state.primaryApiKey) {
+      return { present: true, source: '/login managed key' };
+    }
+  } catch {
+    // Ignore missing or unreadable Claude state.
+  }
+
+  const envApiKey = process.env.ANTHROPIC_API_KEY || '';
+  const envAuthToken = process.env.ANTHROPIC_AUTH_TOKEN || '';
+  if (envApiKey && !envApiKey.startsWith('plx_')) {
+    return { present: true, source: 'shell env' };
+  }
+  if (envAuthToken && !envAuthToken.startsWith('plx_')) {
+    return { present: true, source: 'shell env' };
+  }
+
+  return { present: false, source: null };
+}
+
 /**
  * Check if Claude Code is actually routing through Plexor
  * by reading ~/.claude/settings.json
@@ -204,8 +248,24 @@ async function main() {
   const localCache = config.settings?.localCacheEnabled ?? false;
   const apiUrl = config.settings?.apiUrl || 'https://api.plexor.dev';
   const verification = config.health || {};
+  const routing = getRoutingStatus();
+  const partialState = detectPartialState();
+  const directClaudeAuth = getDirectClaudeAuthState();
 
   if (!apiKey) {
+    if (!enabled && !routing.active && !partialState.partial && directClaudeAuth.present) {
+      printHealthSummary({
+        installed: 'OK',
+        connected: 'Direct Claude auth',
+        routing: 'Inactive',
+        verified: 'Restored',
+        nextAction: 'Run /plexor-setup'
+      });
+      console.log('');
+      console.log(`  Claude is using ${directClaudeAuth.source}. Plexor is inactive.`);
+      process.exit(0);
+    }
+
     printHealthSummary({
       installed: 'OK',
       connected: 'Missing key',
@@ -277,7 +337,7 @@ async function main() {
   let dashboardUrl = 'https://plexor.dev/dashboard';
   try {
     const url = new URL(apiUrl);
-    if (url.hostname.includes('staging.api.plexor.dev')) {
+    if (url.hostname === 'staging.api.plexor.dev') {
       dashboardUrl = 'https://staging.plexorlabs.com/dashboard';
     } else {
       const host = url.hostname.replace(/^api\./, '').replace(/\.api\./, '.');
@@ -321,10 +381,8 @@ ${line(`└── Cost saved: $${sessionCostSaved}`)}
 ` : '';
 
   // Get routing status from Claude settings.json
-  const routing = getRoutingStatus();
   const routingIndicator = routing.active ? '🟢 PLEXOR MODE: ON' : '🔴 PLEXOR MODE: OFF';
   const envLabel = routing.isStaging ? '(staging)' : '(production)';
-  const partialState = detectPartialState();
   const stateMismatch = checkStateMismatch(enabled, routing.active);
   const connectedState = userFetchWorked ? 'OK' : 'Unknown';
   const verifiedState = verification.verified

package/commands/plexor-uninstall.js

@@ -82,6 +82,9 @@ function loadSettingsManager() {
  */
 function disableRoutingManually() {
   const settingsPath = path.join(CLAUDE_DIR, 'settings.json');
+  const statePath = path.join(HOME_DIR, '.claude.json');
+  const previousPrimaryApiKeyEnv = 'PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY';
+  const crypto = require('crypto');
 
   try {
     if (!fs.existsSync(settingsPath)) {
@@ -113,7 +116,9 @@ function disableRoutingManually() {
     const hasPlexorAuthToken = isPlexorApiKey(settings.env.ANTHROPIC_AUTH_TOKEN || '');
     const hasPlexorApiKey = isPlexorApiKey(settings.env.ANTHROPIC_API_KEY || '');
 
-    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey) {
+    const hasPreviousPrimaryApiKey = Boolean(settings.env[previousPrimaryApiKeyEnv]);
+
+    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey && !hasPreviousPrimaryApiKey) {
       return { success: true, message: 'Plexor routing not active' };
     }
 
@@ -136,6 +141,30 @@ function disableRoutingManually() {
 
     delete settings.env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY;
     delete settings.env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN;
+    const previousPrimaryApiKey = settings.env[previousPrimaryApiKeyEnv] || '';
+    if (previousPrimaryApiKey) {
+      let claudeState = {};
+      try {
+        if (fs.existsSync(statePath)) {
+          const stateData = fs.readFileSync(statePath, 'utf8');
+          if (stateData && stateData.trim()) {
+            claudeState = JSON.parse(stateData);
+          }
+        }
+      } catch {
+        claudeState = {};
+      }
+
+      if (!claudeState.primaryApiKey) {
+        claudeState.primaryApiKey = previousPrimaryApiKey;
+      }
+      delete settings.env[previousPrimaryApiKeyEnv];
+
+      const stateTempId = crypto.randomBytes(8).toString('hex');
+      const stateTempPath = path.join(HOME_DIR, `.claude.${stateTempId}.tmp`);
+      fs.writeFileSync(stateTempPath, JSON.stringify(claudeState, null, 2), { mode: 0o600 });
+      fs.renameSync(stateTempPath, statePath);
+    }
 
     // Clean up empty env block
     if (Object.keys(settings.env).length === 0) {
@@ -143,7 +172,6 @@ function disableRoutingManually() {
     }
 
     // Atomic write
-    const crypto = require('crypto');
     const tempId = crypto.randomBytes(8).toString('hex');
     const tempPath = path.join(CLAUDE_DIR, `.settings.${tempId}.tmp`);
 

package/lib/plexor-client.js

@@ -31,7 +31,7 @@ class PlexorClient {
           'Content-Type': 'application/json',
           'X-API-Key': this.apiKey,
           'X-Plexor-Key': this.apiKey,
-          'User-Agent': 'plexor-claude-code-plugin/0.1.0-beta.22'
+          'User-Agent': 'plexor-claude-code-plugin/0.1.0-beta.23'
         },
         timeout: this.timeout
       };

package/lib/settings-manager.js

@@ -16,6 +16,7 @@ const os = require('os');
 const crypto = require('crypto');
 
 const CLAUDE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude');
+const CLAUDE_STATE_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude.json');
 const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
 const LOCK_TIMEOUT_MS = 5000; // 5 second lock timeout
 
@@ -24,6 +25,7 @@ const PLEXOR_STAGING_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
 const PLEXOR_PROD_URL = 'https://api.plexor.dev/gateway/anthropic';
 const PREVIOUS_API_KEY_ENV = 'PLEXOR_PREVIOUS_ANTHROPIC_API_KEY';
 const PREVIOUS_AUTH_TOKEN_ENV = 'PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN';
+const PREVIOUS_PRIMARY_API_KEY_ENV = 'PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY';
 
 /**
  * Check if a base URL is a Plexor-managed gateway URL.
@@ -118,10 +120,39 @@ function clearPlexorRoutingEnv(env = {}) {
   return true;
 }
 
+function stashDirectPrimaryApiKey(env = {}, claudeState = {}, plexorApiKey = '') {
+  const currentPrimaryApiKey = claudeState.primaryApiKey || '';
+  if (!currentPrimaryApiKey || isPlexorApiKey(currentPrimaryApiKey) || currentPrimaryApiKey === plexorApiKey) {
+    return false;
+  }
+
+  env[PREVIOUS_PRIMARY_API_KEY_ENV] = currentPrimaryApiKey;
+  delete claudeState.primaryApiKey;
+  return true;
+}
+
+function restoreDirectPrimaryApiKey(env = {}, claudeState = {}, options = {}) {
+  const { consumeBackup = true } = options;
+  const previousPrimaryApiKey = env[PREVIOUS_PRIMARY_API_KEY_ENV] || '';
+  if (!previousPrimaryApiKey) {
+    return false;
+  }
+
+  if (!claudeState.primaryApiKey) {
+    claudeState.primaryApiKey = previousPrimaryApiKey;
+  }
+
+  if (consumeBackup) {
+    delete env[PREVIOUS_PRIMARY_API_KEY_ENV];
+  }
+  return true;
+}
+
 class ClaudeSettingsManager {
   constructor() {
     this.settingsPath = SETTINGS_PATH;
     this.claudeDir = CLAUDE_DIR;
+    this.claudeStatePath = CLAUDE_STATE_PATH;
   }
 
   /**
@@ -209,6 +240,56 @@ class ClaudeSettingsManager {
     return null;
   }
 
+  loadClaudeState() {
+    try {
+      if (!fs.existsSync(this.claudeStatePath)) {
+        return {};
+      }
+
+      const data = fs.readFileSync(this.claudeStatePath, 'utf8');
+      if (!data || data.trim() === '') {
+        return {};
+      }
+
+      const parsed = JSON.parse(data);
+      if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return {};
+      }
+
+      return parsed;
+    } catch (err) {
+      if (err.code === 'ENOENT' || err instanceof SyntaxError) {
+        return {};
+      }
+      console.warn('Warning: Failed to load Claude auth state:', err.message);
+      return {};
+    }
+  }
+
+  saveClaudeState(state) {
+    try {
+      const stateDir = path.dirname(this.claudeStatePath);
+      if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+      }
+
+      const tempId = crypto.randomBytes(8).toString('hex');
+      const tempPath = path.join(stateDir, `.claude.${tempId}.tmp`);
+      const content = JSON.stringify(state, null, 2);
+      fs.writeFileSync(tempPath, content, { mode: 0o600 });
+      fs.renameSync(tempPath, this.claudeStatePath);
+      return true;
+    } catch (err) {
+      if (err.code === 'EACCES' || err.code === 'EPERM') {
+        console.error(`Error: Cannot write to ${this.claudeStatePath}`);
+        console.error('       Check file permissions or run with appropriate access.');
+      } else {
+        console.error('Failed to save Claude auth state:', err.message);
+      }
+      return false;
+    }
+  }
+
   /**
    * Save Claude settings using atomic write pattern
    * Prevents race conditions by writing to temp file then renaming
@@ -265,6 +346,7 @@ class ClaudeSettingsManager {
 
     try {
       const settings = this.load();
+      const claudeState = this.loadClaudeState();
 
       // Initialize env block if doesn't exist
       if (!settings.env) {
@@ -275,15 +357,23 @@ class ClaudeSettingsManager {
       // runtime path uses the gateway instead of any previously saved direct key.
       settings.env.ANTHROPIC_BASE_URL = apiUrl;
       setPlexorAuthKey(settings.env, apiKey);
+      const claudeStateChanged = stashDirectPrimaryApiKey(settings.env, claudeState, apiKey);
 
       const success = this.save(settings);
+      if (!success) {
+        return false;
+      }
+
+      if (claudeStateChanged && !this.saveClaudeState(claudeState)) {
+        return false;
+      }
 
       if (success) {
         console.log(`✓ Plexor routing enabled`);
         console.log(`  Base URL: ${apiUrl}`);
         console.log(`  API Key: ${apiKey.substring(0, 12)}...`);
-        console.log(`\n  All Claude Code sessions will now route through Plexor.`);
-        console.log(`  Changes take effect immediately (no restart needed).`);
+        console.log(`\n  New Claude launches will route through Plexor.`);
+        console.log(`  Restart Claude before testing routed prompts.`);
       }
 
       return success;
@@ -303,31 +393,50 @@ class ClaudeSettingsManager {
   disablePlexorRouting() {
     try {
       const settings = this.load();
+      const claudeState = this.loadClaudeState();
+      const originalClaudeState = JSON.parse(JSON.stringify(claudeState));
 
       if (!settings.env) {
         console.log('Plexor routing is not currently enabled.');
         return true;
       }
 
-      if (!clearPlexorRoutingEnv(settings.env)) {
+      const routingChanged = clearPlexorRoutingEnv(settings.env);
+      const claudeStateChanged = restoreDirectPrimaryApiKey(settings.env, claudeState, {
+        consumeBackup: false
+      });
+
+      if (!routingChanged && !claudeStateChanged) {
         console.log('Plexor routing is not currently enabled.');
         return true;
       }
 
+      if (claudeStateChanged && !this.saveClaudeState(claudeState)) {
+        return false;
+      }
+
+      if (claudeStateChanged) {
+        delete settings.env[PREVIOUS_PRIMARY_API_KEY_ENV];
+      }
+
       // Clean up empty env block
       if (Object.keys(settings.env).length === 0) {
         delete settings.env;
       }
 
       const success = this.save(settings);
-
-      if (success) {
-        console.log('✓ Plexor routing disabled');
-        console.log('  Claude Code will now connect directly to Anthropic.');
-        console.log('  Changes take effect immediately (no restart needed).');
+      if (!success) {
+        if (claudeStateChanged) {
+          this.saveClaudeState(originalClaudeState);
+        }
+        return false;
       }
 
-      return success;
+      console.log('✓ Plexor routing disabled');
+      console.log('  New Claude launches will connect directly to Anthropic.');
+      console.log('  Restart Claude if it is still open.');
+
+      return true;
     } catch (err) {
       console.error('Failed to disable Plexor routing:', err.message);
       return false;
@@ -369,6 +478,7 @@ class ClaudeSettingsManager {
   detectPartialState() {
     try {
       const settings = this.load();
+      const claudeState = this.loadClaudeState();
       const baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
       const authKey = getPlexorAuthKey(settings.env);
       const isPlexorUrl = isManagedGatewayUrl(baseUrl);
@@ -379,6 +489,9 @@ class ClaudeSettingsManager {
       if (isPlexorUrl && !isPlexorApiKey(authKey)) {
         return { partial: true, issue: 'Plexor URL set but auth key is not a Plexor key' };
       }
+      if (isPlexorUrl && claudeState.primaryApiKey && !isPlexorApiKey(claudeState.primaryApiKey)) {
+        return { partial: true, issue: 'Plexor URL set but Claude managed API key is still active' };
+      }
       return { partial: false, issue: null };
     } catch {
       return { partial: false, issue: null };
@@ -442,6 +555,7 @@ module.exports = {
   settingsManager,
   isManagedGatewayUrl,
   CLAUDE_DIR,
+  CLAUDE_STATE_PATH,
   SETTINGS_PATH,
   PLEXOR_STAGING_URL,
   PLEXOR_PROD_URL

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin-staging",
-  "version": "0.1.0-beta.21",
+  "version": "0.1.0-beta.23",
   "description": "STAGING - LLM cost optimization plugin for Claude Code (internal testing)",
   "main": "lib/constants.js",
   "bin": {

package/scripts/postinstall.js

@@ -167,6 +167,7 @@ function isManagedGatewayUrl(baseUrl) {
 const THIS_VARIANT_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
 const PREVIOUS_API_KEY_ENV = 'PLEXOR_PREVIOUS_ANTHROPIC_API_KEY';
 const PREVIOUS_AUTH_TOKEN_ENV = 'PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN';
+const PREVIOUS_PRIMARY_API_KEY_ENV = 'PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY';
 
 /**
  * Check for orphaned Plexor routing in settings.json without valid config.
@@ -198,6 +199,36 @@ function syncManagedAuthEnv(env, managedAuthKey) {
   env.ANTHROPIC_AUTH_TOKEN = managedAuthKey;
 }
 
+function syncManagedPrimaryApiKey(env, managedAuthKey) {
+  const statePath = path.join(HOME_DIR, '.claude.json');
+  try {
+    if (!fs.existsSync(statePath)) {
+      return false;
+    }
+
+    const data = fs.readFileSync(statePath, 'utf8');
+    if (!data || !data.trim()) {
+      return false;
+    }
+
+    const claudeState = JSON.parse(data);
+    const primaryApiKey = claudeState.primaryApiKey || '';
+    if (!primaryApiKey || primaryApiKey.startsWith('plx_') || primaryApiKey === managedAuthKey) {
+      return false;
+    }
+
+    env[PREVIOUS_PRIMARY_API_KEY_ENV] = primaryApiKey;
+    delete claudeState.primaryApiKey;
+
+    const tempPath = `${statePath}.tmp.${Date.now()}`;
+    fs.writeFileSync(tempPath, JSON.stringify(claudeState, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, statePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function checkOrphanedRouting() {
   // Use the resolved HOME_DIR (not process.env.HOME which may be wrong under sudo -u)
   const settingsPath = path.join(HOME_DIR, '.claude', 'settings.json');
@@ -223,6 +254,11 @@ function checkOrphanedRouting() {
         settingsChanged = true;
         console.log('\n  Synced Plexor auth into ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN');
       }
+      if (managedAuthKey && syncManagedPrimaryApiKey(env, managedAuthKey)) {
+        settings.env = env;
+        settingsChanged = true;
+        console.log('\n  Suspended Claude managed API key while Plexor is active');
+      }
       // Check if there's a valid Plexor config
       let hasValidConfig = false;
       try {

package/scripts/uninstall.js

@@ -56,6 +56,7 @@ const results = {
   restored: [],
   pluginDir: false
 };
+const PREVIOUS_PRIMARY_API_KEY_ENV = 'PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY';
 
 function isManagedGatewayUrl(baseUrl = '') {
   return (
@@ -104,6 +105,36 @@ function clearPlexorRoutingEnv(env = {}) {
   return true;
 }
 
+function restoreClaudePrimaryApiKey(env = {}) {
+  const previousPrimaryApiKey = env[PREVIOUS_PRIMARY_API_KEY_ENV] || '';
+  if (!previousPrimaryApiKey) {
+    return false;
+  }
+
+  const statePath = path.join(home, '.claude.json');
+  let claudeState = {};
+  try {
+    if (fs.existsSync(statePath)) {
+      const data = fs.readFileSync(statePath, 'utf8');
+      if (data && data.trim()) {
+        claudeState = JSON.parse(data);
+      }
+    }
+  } catch {
+    claudeState = {};
+  }
+
+  if (!claudeState.primaryApiKey) {
+    claudeState.primaryApiKey = previousPrimaryApiKey;
+  }
+  delete env[PREVIOUS_PRIMARY_API_KEY_ENV];
+
+  const tempPath = `${statePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(claudeState, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, statePath);
+  return true;
+}
+
 // 1. Remove routing from settings.json
 // This is CRITICAL - do NOT depend on settings-manager module since it may not load during uninstall
 try {
@@ -114,13 +145,14 @@ try {
       const settings = JSON.parse(data);
       if (settings.env) {
         const routingChanged = clearPlexorRoutingEnv(settings.env);
+        const primaryApiKeyRestored = restoreClaudePrimaryApiKey(settings.env);
 
         // Clean up empty env block
         if (Object.keys(settings.env).length === 0) {
           delete settings.env;
         }
 
-        if (routingChanged) {
+        if (routingChanged || primaryApiKeyRestored) {
           fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
           results.routing = true;
         }