@plexor-dev/claude-code-plugin-staging 0.1.0-beta.24 → 0.1.0-beta.25

package/commands/plexor-status.js

@@ -58,7 +58,7 @@ function getDirectClaudeAuthState() {
   try {
     const data = fs.readFileSync(CLAUDE_STATE_PATH, 'utf8');
     const state = JSON.parse(data);
-    if (state.primaryApiKey) {
+    if (state.primaryApiKey && !state.primaryApiKey.startsWith('plx_')) {
       return { present: true, source: '/login managed key' };
     }
   } catch {

package/commands/plexor-uninstall.js

@@ -18,6 +18,9 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { removeManagedStatusLine } = require('../lib/statusline-manager');
+const { removeManagedHooks, cleanupLegacyManagedHooksFile } = require('../lib/hooks-manager');
+const { removeManagedClaudeCustomHeadersFromEnv } = require('../lib/config-utils');
 
 // Get home directory, handling sudo case
 function getHomeDir() {
@@ -36,22 +39,12 @@ const HOME_DIR = getHomeDir();
 const CLAUDE_DIR = path.join(HOME_DIR, '.claude');
 const CLAUDE_COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands');
 const CLAUDE_PLUGINS_DIR = path.join(CLAUDE_DIR, 'plugins', 'plexor');
+const CLAUDE_SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_HOOKS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_LEGACY_HOOKS_PATH = path.join(CLAUDE_DIR, 'hooks.json');
 const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
 
 // All Plexor slash command files
-const PLEXOR_COMMANDS = [
-  'plexor-enabled.md',
-  'plexor-login.md',
-  'plexor-logout.md',
-  'plexor-setup.md',
-  'plexor-status.md',
-  'plexor-uninstall.md',
-  'plexor-mode.md',
-  'plexor-provider.md',
-  'plexor-settings.md',
-  'plexor-config.md'
-];
-
 /**
  * Load settings manager if available
  */
@@ -115,10 +108,11 @@ function disableRoutingManually() {
     const hasManagedBaseUrl = isManagedGatewayUrl(settings.env.ANTHROPIC_BASE_URL || '');
     const hasPlexorAuthToken = isPlexorApiKey(settings.env.ANTHROPIC_AUTH_TOKEN || '');
     const hasPlexorApiKey = isPlexorApiKey(settings.env.ANTHROPIC_API_KEY || '');
+    const removedManagedHeaders = removeManagedClaudeCustomHeadersFromEnv(settings.env);
 
     const hasPreviousPrimaryApiKey = Boolean(settings.env[previousPrimaryApiKeyEnv]);
 
-    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey && !hasPreviousPrimaryApiKey) {
+    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey && !hasPreviousPrimaryApiKey && !removedManagedHeaders) {
       return { success: true, message: 'Plexor routing not active' };
     }
 
@@ -191,7 +185,12 @@ function removeSlashCommands() {
   let removed = 0;
   let restored = 0;
 
-  for (const cmd of PLEXOR_COMMANDS) {
+  if (!fs.existsSync(CLAUDE_COMMANDS_DIR)) {
+    return { removed, restored };
+  }
+
+  const plexorCommands = fs.readdirSync(CLAUDE_COMMANDS_DIR).filter((entry) => /^plexor-.*\.md$/i.test(entry));
+  for (const cmd of plexorCommands) {
     const cmdPath = path.join(CLAUDE_COMMANDS_DIR, cmd);
     const backupPath = cmdPath + '.backup';
 
@@ -229,6 +228,30 @@ function removePluginDirectory() {
   return false;
 }
 
+function removeManagedStatusLineConfig() {
+  try {
+    return removeManagedStatusLine(CLAUDE_SETTINGS_PATH, HOME_DIR);
+  } catch (err) {
+    return { changed: false, restored: false, error: err.message };
+  }
+}
+
+function removeManagedHooksConfig() {
+  try {
+    return removeManagedHooks(CLAUDE_HOOKS_PATH);
+  } catch (err) {
+    return { changed: false, removed: 0, error: err.message };
+  }
+}
+
+function removeLegacyManagedHooksConfig() {
+  try {
+    return cleanupLegacyManagedHooksFile(CLAUDE_LEGACY_HOOKS_PATH);
+  } catch (err) {
+    return { changed: false, removed: 0, error: err.message };
+  }
+}
+
 /**
  * Remove config directory
  */
@@ -255,7 +278,8 @@ function main() {
     console.log('  Cleans up Plexor integration before npm uninstall.');
     console.log('');
     console.log('  Options:');
-    console.log('    --remove-config, -c  Also remove ~/.plexor/ config directory');
+    console.log('    --keep-config, -k    Preserve ~/.plexor/ config directory');
+    console.log('    --remove-config, -c  Legacy alias (config is removed by default)');
     console.log('    --quiet, -q          Suppress output messages');
     console.log('    --help, -h           Show this help message');
     console.log('');
@@ -265,7 +289,7 @@ function main() {
     process.exit(0);
   }
 
-  const removeConfig = args.includes('--remove-config') || args.includes('-c');
+  const removeConfig = !(args.includes('--keep-config') || args.includes('-k'));
   const quiet = args.includes('--quiet') || args.includes('-q');
 
   if (!quiet) {
@@ -295,7 +319,36 @@ function main() {
       : `  ✗ Failed to remove routing: ${routingResult.message}`);
   }
 
-  // 2. Remove slash command .md files
+  // 2. Remove managed Plexor status line
+  const statusLineResult = removeManagedStatusLineConfig();
+  if (!quiet) {
+    if (statusLineResult.error) {
+      console.log(`  ✗ Failed to clean Plexor status line: ${statusLineResult.error}`);
+    } else if (statusLineResult.changed) {
+      console.log('  ✓ Restored Claude status line configuration');
+    } else {
+      console.log('  ○ Claude status line already clean');
+    }
+  }
+
+  const hooksResult = removeManagedHooksConfig();
+  const legacyHooksResult = removeLegacyManagedHooksConfig();
+  if (!quiet) {
+    if (hooksResult.error) {
+      console.log(`  ✗ Failed to clean Plexor hooks: ${hooksResult.error}`);
+    } else if (hooksResult.changed) {
+      console.log('  ✓ Restored Claude hook configuration');
+    } else {
+      console.log('  ○ Claude hooks already clean');
+    }
+    if (legacyHooksResult.error) {
+      console.log(`  ✗ Failed to clean legacy ~/.claude/hooks.json: ${legacyHooksResult.error}`);
+    } else if (legacyHooksResult.changed) {
+      console.log('  ✓ Cleaned legacy ~/.claude/hooks.json');
+    }
+  }
+
+  // 3. Remove slash command .md files
   const cmdResult = removeSlashCommands();
   if (!quiet) {
     console.log(`  ✓ Removed ${cmdResult.removed} slash command files`);
@@ -304,7 +357,7 @@ function main() {
     }
   }
 
-  // 3. Remove plugin directory
+  // 4. Remove plugin directory
   const pluginRemoved = removePluginDirectory();
   if (!quiet) {
     console.log(pluginRemoved
@@ -312,7 +365,7 @@ function main() {
       : '  ○ Plugin directory not found (already clean)');
   }
 
-  // 4. Optionally remove config directory
+  // 5. Remove config directory unless explicitly preserved
   if (removeConfig) {
     const configRemoved = removeConfigDirectory();
     if (!quiet) {
@@ -337,8 +390,7 @@ function main() {
 
     if (!removeConfig) {
       console.log('  Note: ~/.plexor/ config directory was preserved.');
-      console.log('  To also remove it: plexor-uninstall --remove-config');
-      console.log('  Or manually: rm -rf ~/.plexor');
+      console.log('  To remove it manually: rm -rf ~/.plexor');
       console.log('');
     }
   }

package/hooks/session-sync.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { CONFIG_PATH, SESSION_PATH, PLEXOR_DIR } = require('../lib/constants');
+
+function readJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw && raw.trim() ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonAtomically(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.resume();
+  });
+}
+
+function clampNonNegative(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+
+function finiteOrZero(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+
+function parseStats(payload) {
+  const summary = payload?.summary || payload || {};
+  return {
+    total_requests: Number(summary.total_requests ?? payload?.total_requests ?? 0),
+    total_optimizations: Number(summary.total_optimizations ?? payload?.total_optimizations ?? 0),
+    original_tokens: Number(summary.original_tokens ?? payload?.original_tokens ?? 0),
+    optimized_tokens: Number(summary.optimized_tokens ?? payload?.optimized_tokens ?? 0),
+    tokens_saved: Number(summary.tokens_saved ?? payload?.tokens_saved ?? 0),
+    total_cost: Number(summary.total_cost ?? payload?.total_cost ?? 0),
+    baseline_cost: Number(summary.baseline_cost ?? payload?.baseline_cost ?? payload?.total_baseline_cost ?? 0),
+    cost_saved: Number(summary.cost_saved ?? payload?.cost_saved ?? payload?.total_savings ?? 0)
+  };
+}
+
+function fetchJson(apiUrl, endpoint, apiKey) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, apiUrl.replace(/\/$/, '') + '/');
+    const client = url.protocol === 'https:' ? https : http;
+    const req = client.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: `${url.pathname}${url.search}`,
+      method: 'GET',
+      headers: {
+        'X-API-Key': apiKey,
+        'X-Plexor-Key': apiKey,
+        'User-Agent': 'plexor-session-sync/0.1.0-beta.24'
+      },
+      timeout: 5000
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(body);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
+          }
+        } catch {
+          reject(new Error(`Invalid JSON response: ${body.slice(0, 120)}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy(new Error('Request timeout'));
+    });
+    req.end();
+  });
+}
+
+function loadConfig() {
+  const config = readJson(CONFIG_PATH);
+  const apiKey = config?.auth?.api_key || '';
+  const apiUrl = config?.settings?.apiUrl || 'https://staging.api.plexor.dev';
+  const enabled = config?.settings?.enabled !== false;
+  if (!enabled || !apiKey.startsWith('plx_')) {
+    return null;
+  }
+  return { config, apiKey, apiUrl };
+}
+
+function buildSessionRecord(sessionId, baseline, nowIso) {
+  return {
+    session_id: sessionId || `session_${Date.now()}`,
+    started_at: nowIso,
+    last_activity: Date.now(),
+    requests: 0,
+    optimizations: 0,
+    cache_hits: 0,
+    passthroughs: 0,
+    original_tokens: 0,
+    optimized_tokens: 0,
+    tokens_saved: 0,
+    output_tokens: 0,
+    baseline_cost: 0,
+    actual_cost: 0,
+    cost_delta: 0,
+    cost_saved: 0,
+    _baseline: baseline
+  };
+}
+
+async function main() {
+  const mode = process.argv[2] || 'stop';
+  const inputRaw = await readStdin();
+  let input = {};
+  try {
+    input = inputRaw && inputRaw.trim() ? JSON.parse(inputRaw) : {};
+  } catch {
+    input = {};
+  }
+
+  if (mode === 'end') {
+    try {
+      fs.rmSync(SESSION_PATH, { force: true });
+    } catch {
+      // Session cleanup must not interrupt Claude shutdown.
+    }
+    process.exit(0);
+  }
+
+  const loaded = loadConfig();
+  if (!loaded) {
+    process.exit(0);
+  }
+
+  try {
+    const statsPayload = await fetchJson(loaded.apiUrl, '/v1/stats', loaded.apiKey);
+    const current = parseStats(statsPayload);
+    const nowIso = new Date().toISOString();
+    const sessionId = input.session_id || input.sessionId || null;
+    const existing = readJson(SESSION_PATH);
+
+    if (mode === 'start' || !existing || !existing._baseline || (sessionId && existing.session_id !== sessionId)) {
+      const baseline = { ...current };
+      writeJsonAtomically(SESSION_PATH, buildSessionRecord(sessionId, baseline, nowIso));
+      process.exit(0);
+    }
+
+    const baseline = existing._baseline || {};
+    const baselineCost = clampNonNegative(current.baseline_cost - Number(baseline.baseline_cost || 0));
+    const actualCost = clampNonNegative(current.total_cost - Number(baseline.total_cost || 0));
+    const next = {
+      ...existing,
+      session_id: sessionId || existing.session_id,
+      last_activity: Date.now(),
+      requests: clampNonNegative(current.total_requests - Number(baseline.total_requests || 0)),
+      optimizations: clampNonNegative(current.total_optimizations - Number(baseline.total_optimizations || 0)),
+      original_tokens: clampNonNegative(current.original_tokens - Number(baseline.original_tokens || 0)),
+      optimized_tokens: clampNonNegative(current.optimized_tokens - Number(baseline.optimized_tokens || 0)),
+      tokens_saved: clampNonNegative(current.tokens_saved - Number(baseline.tokens_saved || 0)),
+      baseline_cost: baselineCost,
+      actual_cost: actualCost,
+      cost_delta: finiteOrZero(baselineCost - actualCost),
+      cost_saved: clampNonNegative(current.cost_saved - Number(baseline.cost_saved || 0)),
+      _baseline: baseline
+    };
+
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeJsonAtomically(SESSION_PATH, next);
+  } catch {
+    // Hook failures must not interrupt Claude.
+  }
+}
+
+main();

package/hooks/statusline.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const { PREVIOUS_STATUS_LINE_KEY, getManagedStatusLineCommand } = require('../lib/statusline-manager');
+
+const ANSI_BLUE = '\x1b[38;5;153m';
+const ANSI_GREEN = '\x1b[32m';
+const ANSI_RESET = '\x1b[0m';
+
+function readJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw && raw.trim() ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function isManagedGatewayUrl(baseUrl = '') {
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel')
+  );
+}
+
+function getGatewayLabel(baseUrl = '') {
+  if (baseUrl.includes('staging.api')) return 'staging';
+  if (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')) return 'localhost';
+  return 'prod';
+}
+
+function formatUsd(value) {
+  if (!Number.isFinite(value)) {
+    return '';
+  }
+
+  if (Math.abs(value) === 0) {
+    return '$0.00';
+  }
+  if (Math.abs(value) >= 1) {
+    return `$${value.toFixed(2)}`;
+  }
+  if (Math.abs(value) >= 0.01) {
+    return `$${value.toFixed(3)}`;
+  }
+  return `$${value.toFixed(4)}`;
+}
+
+function runPreviousStatusLine(statusLine, homeDir) {
+  if (!statusLine || typeof statusLine !== 'object' || statusLine.type !== 'command' || !statusLine.command) {
+    return '';
+  }
+
+  const managedCommand = getManagedStatusLineCommand(homeDir);
+  if (String(statusLine.command) === managedCommand) {
+    return '';
+  }
+
+  try {
+    const output = execSync(String(statusLine.command), {
+      cwd: homeDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 1000
+    }).trim();
+    return output.split('\n')[0] || '';
+  } catch {
+    return '';
+  }
+}
+
+function buildPlexorSegment(config, settings) {
+  const authKey = config?.auth?.api_key || '';
+  const enabled = config?.settings?.enabled !== false;
+  const baseUrl = settings?.env?.ANTHROPIC_BASE_URL || '';
+  if (!enabled || !authKey.startsWith('plx_') || !isManagedGatewayUrl(baseUrl)) {
+    return '';
+  }
+
+  const gateway = getGatewayLabel(baseUrl);
+  const mode = config?.settings?.mode || 'balanced';
+  const provider = config?.settings?.preferred_provider || 'auto';
+  return `PLEXOR ${gateway} ${mode} ${provider}`;
+}
+
+function buildSavingsSegment(session) {
+  const explicitDelta = Number(session?.cost_delta);
+  const costSaved = Number(session?.cost_saved);
+  const rawCostDelta = Number.isFinite(explicitDelta)
+    ? explicitDelta
+    : ((Number.isFinite(costSaved) && costSaved !== 0)
+      ? costSaved
+      : (Number(session?.baseline_cost) - Number(session?.actual_cost)));
+  const costDelta = Number.isFinite(rawCostDelta) ? rawCostDelta : 0;
+  return `cost-delta ${costDelta < 0 ? '-' : ''}${formatUsd(Math.abs(costDelta))}`;
+}
+
+function main() {
+  const homeDir = os.homedir();
+  const config = readJson(path.join(homeDir, '.plexor', 'config.json')) || {};
+  const settings = readJson(path.join(homeDir, '.claude', 'settings.json')) || {};
+  const session = readJson(path.join(homeDir, '.plexor', 'session.json')) || {};
+
+  const plexorSegment = buildPlexorSegment(config, settings);
+  const savingsSegment = plexorSegment ? buildSavingsSegment(session) : '';
+  const previous = runPreviousStatusLine(settings[PREVIOUS_STATUS_LINE_KEY], homeDir);
+
+  const coloredPlexor = plexorSegment ? `${ANSI_BLUE}${plexorSegment}${ANSI_RESET}` : '';
+  const coloredSavings = savingsSegment ? `${ANSI_GREEN}${savingsSegment}${ANSI_RESET}` : '';
+
+  if (!coloredPlexor && previous) {
+    process.stdout.write(previous);
+    return;
+  }
+
+  const line = [coloredPlexor, coloredSavings, previous].filter(Boolean).join(' · ');
+  if (line) {
+    process.stdout.write(line);
+  }
+}
+
+main();

package/lib/config-utils.js

@@ -113,6 +113,30 @@ function serializeCustomHeaders(headers) {
     .join('\n');
 }
 
+function removeManagedClaudeCustomHeadersFromEnv(env = {}) {
+  const existing = parseCustomHeaders(env.ANTHROPIC_CUSTOM_HEADERS);
+  let removed = false;
+
+  for (const key of MANAGED_HEADER_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(existing, key)) {
+      delete existing[key];
+      removed = true;
+    }
+  }
+
+  if (!removed) {
+    return false;
+  }
+
+  if (Object.keys(existing).length) {
+    env.ANTHROPIC_CUSTOM_HEADERS = serializeCustomHeaders(existing);
+  } else {
+    delete env.ANTHROPIC_CUSTOM_HEADERS;
+  }
+
+  return true;
+}
+
 function buildManagedAnthropicHeaders(config) {
   const settings = config?.settings || {};
   const headers = {};
@@ -308,6 +332,7 @@ module.exports = {
   readSetting,
   hasForcedHintConflict,
   validateForcedHintConfig,
+  removeManagedClaudeCustomHeadersFromEnv,
   parseCustomHeaders,
   serializeCustomHeaders,
   buildManagedAnthropicHeaders

package/lib/hooks-manager.js

@@ -0,0 +1,209 @@
+const fs = require('fs');
+const path = require('path');
+
+function quoteForPosixShell(value) {
+  return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function writeJsonAtomically(filePath, value) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
+function normalizeSettings(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+
+function normalizeHookMatchers(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+
+function normalizeHookList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+
+function readSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return { settings: {}, existed: false };
+  }
+
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf8');
+    if (!raw || !raw.trim()) {
+      return { settings: {}, existed: true };
+    }
+    return { settings: normalizeSettings(JSON.parse(raw)), existed: true };
+  } catch {
+    return { settings: {}, existed: true };
+  }
+}
+
+function getManagedSessionSyncPath(homeDir) {
+  return path.join(homeDir, '.claude', 'plugins', 'plexor', 'hooks', 'session-sync.js');
+}
+
+function getSafeManagedCommand(scriptPath, args = []) {
+  const quotedPath = quoteForPosixShell(scriptPath);
+  const quotedArgs = args.map(quoteForPosixShell).join(' ');
+  const argSuffix = quotedArgs ? ` ${quotedArgs}` : '';
+  return `/bin/sh -lc 'script=$1; shift; [ -x \"$script\" ] || exit 0; exec \"$script\" \"$@\"' -- ${quotedPath}${argSuffix}`;
+}
+
+function getManagedSessionSyncCommand(homeDir, mode) {
+  return getSafeManagedCommand(getManagedSessionSyncPath(homeDir), [mode]);
+}
+
+function getManagedHookMatchers(homeDir) {
+  return {
+    SessionStart: [{
+      matcher: 'startup|resume|clear|compact',
+      hooks: [{
+        type: 'command',
+        command: getManagedSessionSyncCommand(homeDir, 'start'),
+        timeout: 5
+      }]
+    }],
+    Stop: [{
+      hooks: [{
+        type: 'command',
+        command: getManagedSessionSyncCommand(homeDir, 'stop'),
+        timeout: 5
+      }]
+    }],
+    SessionEnd: [{
+      hooks: [{
+        type: 'command',
+        command: getManagedSessionSyncCommand(homeDir, 'end'),
+        timeout: 5
+      }]
+    }]
+  };
+}
+
+function isManagedCommandHook(hook) {
+  const command = String(hook?.command || '');
+  return command.includes('/.claude/plugins/plexor/hooks/session-sync.js');
+}
+
+function isManagedMatcher(entry) {
+  const hooks = normalizeHookList(entry?.hooks);
+  return hooks.some(isManagedCommandHook);
+}
+
+function upsertManagedHooks(settingsPath, homeDir) {
+  const { settings, existed } = readSettings(settingsPath);
+  const currentSettings = normalizeSettings(settings);
+  const currentHooks = normalizeSettings(currentSettings.hooks);
+  const managedMatchers = getManagedHookMatchers(homeDir);
+  const nextHooks = { ...currentHooks };
+
+  for (const [eventName, managedEntries] of Object.entries(managedMatchers)) {
+    const preserved = normalizeHookMatchers(currentHooks[eventName]).filter((entry) => !isManagedMatcher(entry));
+    nextHooks[eventName] = [...preserved, ...managedEntries];
+  }
+
+  const nextSettings = { ...currentSettings, hooks: nextHooks };
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, existed };
+}
+
+function removeManagedHooks(settingsPath) {
+  const { settings, existed } = readSettings(settingsPath);
+  if (!existed) {
+    return { changed: false, removed: 0 };
+  }
+
+  const currentSettings = normalizeSettings(settings);
+  const currentHooks = normalizeSettings(currentSettings.hooks);
+  const nextHooks = { ...currentHooks };
+  let removed = 0;
+
+  for (const [eventName, entries] of Object.entries(currentHooks)) {
+    const normalizedEntries = normalizeHookMatchers(entries);
+    const filteredEntries = normalizedEntries.filter((entry) => !isManagedMatcher(entry));
+    removed += normalizedEntries.length - filteredEntries.length;
+    if (filteredEntries.length > 0) {
+      nextHooks[eventName] = filteredEntries;
+    } else {
+      delete nextHooks[eventName];
+    }
+  }
+
+  const nextSettings = { ...currentSettings };
+  if (Object.keys(nextHooks).length > 0) {
+    nextSettings.hooks = nextHooks;
+  } else {
+    delete nextSettings.hooks;
+  }
+
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, removed };
+}
+
+function cleanupLegacyManagedHooksFile(legacyHooksPath) {
+  if (!fs.existsSync(legacyHooksPath)) {
+    return { changed: false, removed: 0 };
+  }
+
+  try {
+    const raw = fs.readFileSync(legacyHooksPath, 'utf8');
+    if (!raw || !raw.trim()) {
+      fs.rmSync(legacyHooksPath, { force: true });
+      return { changed: true, removed: 0 };
+    }
+
+    const parsed = JSON.parse(raw);
+    const currentHooks = normalizeHookList(parsed.hooks);
+    const nextHooks = currentHooks.filter((entry) => {
+      const event = String(entry?.event || '');
+      const script = String(entry?.script || '');
+      const isLegacyManagedEvent = event === 'pre_model_request' || event === 'post_model_response';
+      const isLegacyManagedScript = script.includes('/.claude/plugins/plexor/hooks/intercept.js') ||
+        script.includes('/.claude/plugins/plexor/hooks/track-response.js');
+      return !(isLegacyManagedEvent && isLegacyManagedScript);
+    });
+    const removed = currentHooks.length - nextHooks.length;
+
+    if (removed === 0) {
+      return { changed: false, removed: 0 };
+    }
+
+    if (nextHooks.length === 0) {
+      fs.rmSync(legacyHooksPath, { force: true });
+    } else {
+      writeJsonAtomically(legacyHooksPath, { ...parsed, hooks: nextHooks });
+    }
+    return { changed: true, removed };
+  } catch {
+    return { changed: false, removed: 0 };
+  }
+}
+
+module.exports = {
+  getManagedSessionSyncPath,
+  getManagedSessionSyncCommand,
+  getManagedHookMatchers,
+  upsertManagedHooks,
+  removeManagedHooks,
+  cleanupLegacyManagedHooksFile
+};

package/lib/settings-manager.js

@@ -14,6 +14,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const { removeManagedClaudeCustomHeadersFromEnv } = require('./config-utils');
 
 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');
@@ -92,8 +93,9 @@ function clearPlexorRoutingEnv(env = {}) {
   const hasManagedBaseUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL || '');
   const hasPlexorApiKey = isPlexorApiKey(env.ANTHROPIC_API_KEY || '');
   const hasPlexorAuthToken = isPlexorApiKey(env.ANTHROPIC_AUTH_TOKEN || '');
+  const removedManagedHeaders = removeManagedClaudeCustomHeadersFromEnv(env);
 
-  if (!hasManagedBaseUrl && !hasPlexorApiKey && !hasPlexorAuthToken) {
+  if (!hasManagedBaseUrl && !hasPlexorApiKey && !hasPlexorAuthToken && !removedManagedHeaders) {
     return false;
   }
 
@@ -346,6 +348,7 @@ class ClaudeSettingsManager {
 
     try {
       const settings = this.load();
+      const previousSettings = JSON.parse(JSON.stringify(settings));
       const claudeState = this.loadClaudeState();
 
       // Initialize env block if doesn't exist
@@ -365,6 +368,7 @@ class ClaudeSettingsManager {
       }
 
       if (claudeStateChanged && !this.saveClaudeState(claudeState)) {
+        this.save(previousSettings);
         return false;
       }
 

package/lib/statusline-manager.js

@@ -0,0 +1,135 @@
+const fs = require('fs');
+const path = require('path');
+
+const PREVIOUS_STATUS_LINE_KEY = 'PLEXOR_PREVIOUS_STATUS_LINE';
+
+function quoteForPosixShell(value) {
+  return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function writeJsonAtomically(filePath, value) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
+function normalizeSettings(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+
+function readSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return { settings: {}, existed: false };
+  }
+
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf8');
+    if (!raw || !raw.trim()) {
+      return { settings: {}, existed: true };
+    }
+    return { settings: normalizeSettings(JSON.parse(raw)), existed: true };
+  } catch {
+    return { settings: {}, existed: true };
+  }
+}
+
+function getManagedStatusLinePath(homeDir) {
+  return path.join(homeDir, '.claude', 'plugins', 'plexor', 'hooks', 'statusline.js');
+}
+
+function getManagedStatusLineCommand(homeDir) {
+  const scriptPath = getManagedStatusLinePath(homeDir);
+  return `/bin/sh -lc 'script=$1; [ -x \"$script\" ] || exit 0; exec \"$script\"' -- ${quoteForPosixShell(scriptPath)}`;
+}
+
+function isManagedStatusLine(statusLine, homeDir) {
+  const managedCommand = getManagedStatusLineCommand(homeDir);
+  const normalizedManaged = managedCommand.replace(/^"|"$/g, '');
+  const command = String(statusLine?.command || '');
+
+  return (
+    statusLine?.type === 'command' &&
+    (
+      command === managedCommand ||
+      command === normalizedManaged ||
+      command.includes('/.claude/plugins/plexor/hooks/statusline.js')
+    )
+  );
+}
+
+function getManagedStatusLine(homeDir) {
+  return {
+    type: 'command',
+    command: getManagedStatusLineCommand(homeDir),
+    padding: 0
+  };
+}
+
+function upsertManagedStatusLine(settingsPath, homeDir) {
+  const { settings, existed } = readSettings(settingsPath);
+  const currentSettings = normalizeSettings(settings);
+  const nextSettings = { ...currentSettings };
+  const currentStatusLine = currentSettings.statusLine;
+
+  if (
+    currentStatusLine &&
+    !isManagedStatusLine(currentStatusLine, homeDir) &&
+    !Object.prototype.hasOwnProperty.call(currentSettings, PREVIOUS_STATUS_LINE_KEY)
+  ) {
+    nextSettings[PREVIOUS_STATUS_LINE_KEY] = currentStatusLine;
+  }
+
+  nextSettings.statusLine = getManagedStatusLine(homeDir);
+
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, existed };
+}
+
+function removeManagedStatusLine(settingsPath, homeDir) {
+  const { settings, existed } = readSettings(settingsPath);
+  if (!existed) {
+    return { changed: false, restored: false };
+  }
+
+  const currentSettings = normalizeSettings(settings);
+  const nextSettings = { ...currentSettings };
+  const managed = isManagedStatusLine(currentSettings.statusLine, homeDir);
+  const previousStatusLine = currentSettings[PREVIOUS_STATUS_LINE_KEY];
+  let restored = false;
+
+  if (managed) {
+    if (previousStatusLine && typeof previousStatusLine === 'object') {
+      nextSettings.statusLine = previousStatusLine;
+      restored = true;
+    } else {
+      delete nextSettings.statusLine;
+    }
+  }
+
+  delete nextSettings[PREVIOUS_STATUS_LINE_KEY];
+
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, restored };
+}
+
+module.exports = {
+  PREVIOUS_STATUS_LINE_KEY,
+  getManagedStatusLine,
+  getManagedStatusLineCommand,
+  isManagedStatusLine,
+  upsertManagedStatusLine,
+  removeManagedStatusLine
+};

package/package.json

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

package/scripts/postinstall.js

@@ -11,6 +11,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const { upsertManagedStatusLine } = require('../lib/statusline-manager');
+const { upsertManagedHooks, cleanupLegacyManagedHooksFile } = require('../lib/hooks-manager');
 
 /**
  * Resolve the home directory for a given username by querying /etc/passwd.
@@ -137,12 +139,16 @@ function chownRecursive(dirPath, uid, gid) {
 
 const HOME_DIR = getHomeDir();
 const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
+const HOOKS_SOURCE = path.join(__dirname, '..', 'hooks');
 const LIB_SOURCE = path.join(__dirname, '..', 'lib');
 const CLAUDE_COMMANDS_DIR = path.join(HOME_DIR, '.claude', 'commands');
 const PLEXOR_PLUGINS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'commands');
+const PLEXOR_HOOKS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'hooks');
 const PLEXOR_LIB_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'lib');
 const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
 const PLEXOR_CONFIG_FILE = path.join(PLEXOR_CONFIG_DIR, 'config.json');
+const CLAUDE_SETTINGS_FILE = path.join(HOME_DIR, '.claude', 'settings.json');
+const CLAUDE_LEGACY_HOOKS_FILE = path.join(HOME_DIR, '.claude', 'hooks.json');
 
 /**
  * Check if a base URL is a Plexor-managed gateway URL.
@@ -199,33 +205,41 @@ function syncManagedAuthEnv(env, managedAuthKey) {
   env.ANTHROPIC_AUTH_TOKEN = managedAuthKey;
 }
 
+function writeJsonAtomically(filePath, value) {
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
 function syncManagedPrimaryApiKey(env, managedAuthKey) {
   const statePath = path.join(HOME_DIR, '.claude.json');
   try {
     if (!fs.existsSync(statePath)) {
-      return false;
+      return { changed: false };
     }
 
     const data = fs.readFileSync(statePath, 'utf8');
     if (!data || !data.trim()) {
-      return false;
+      return { changed: false };
     }
 
     const claudeState = JSON.parse(data);
     const primaryApiKey = claudeState.primaryApiKey || '';
     if (!primaryApiKey || primaryApiKey.startsWith('plx_') || primaryApiKey === managedAuthKey) {
-      return false;
+      return { changed: 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;
+    const nextClaudeState = { ...claudeState };
+    delete nextClaudeState.primaryApiKey;
+
+    return {
+      changed: true,
+      statePath,
+      claudeState: nextClaudeState
+    };
   } catch {
-    return false;
+    return { changed: false };
   }
 }
 
@@ -240,6 +254,7 @@ function checkOrphanedRouting() {
     const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
     const env = settings.env || {};
     let settingsChanged = false;
+    let managedPrimaryApiKeySync = null;
 
     const hasPlexorUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL);
 
@@ -254,10 +269,11 @@ function checkOrphanedRouting() {
         settingsChanged = true;
         console.log('\n  Synced Plexor auth into ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN');
       }
-      if (managedAuthKey && syncManagedPrimaryApiKey(env, managedAuthKey)) {
+      const primaryApiKeySync = managedAuthKey ? syncManagedPrimaryApiKey(env, managedAuthKey) : { changed: false };
+      if (primaryApiKeySync.changed) {
         settings.env = env;
         settingsChanged = true;
-        console.log('\n  Suspended Claude managed API key while Plexor is active');
+        managedPrimaryApiKeySync = primaryApiKeySync;
       }
       // Check if there's a valid Plexor config
       let hasValidConfig = false;
@@ -299,6 +315,16 @@ function checkOrphanedRouting() {
       fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
       fs.renameSync(tempPath, settingsPath);
     }
+
+    if (managedPrimaryApiKeySync?.changed) {
+      try {
+        writeJsonAtomically(managedPrimaryApiKeySync.statePath, managedPrimaryApiKeySync.claudeState);
+        console.log('\n  Suspended Claude managed API key while Plexor is active');
+      } catch (e) {
+        console.log('\n  Warning: Saved Claude key backup but could not suspend Claude managed API key');
+        console.log(`  ${e.message}`);
+      }
+    }
   } catch (e) {
     // Ignore errors in detection - don't break install
   }
@@ -334,6 +360,9 @@ function main() {
     // Create ~/.claude/plugins/plexor/commands/ for JS executors
     fs.mkdirSync(PLEXOR_PLUGINS_DIR, { recursive: true });
 
+    // Create ~/.claude/plugins/plexor/hooks/ for hook scripts
+    fs.mkdirSync(PLEXOR_HOOKS_DIR, { recursive: true });
+
     // Create ~/.claude/plugins/plexor/lib/ for shared modules
     fs.mkdirSync(PLEXOR_LIB_DIR, { recursive: true });
 
@@ -356,6 +385,9 @@ function main() {
       .filter(f => f.endsWith('.md'));
     const jsFiles = fs.readdirSync(COMMANDS_SOURCE)
       .filter(f => f.endsWith('.js'));
+    const hookFiles = fs.existsSync(HOOKS_SOURCE)
+      ? fs.readdirSync(HOOKS_SOURCE).filter(f => f.endsWith('.js'))
+      : [];
 
     if (mdFiles.length === 0) {
       console.error('No command files found in package. Installation may be corrupt.');
@@ -397,6 +429,16 @@ function main() {
       jsInstalled.push(file);
     }
 
+    // Copy hook files to ~/.claude/plugins/plexor/hooks/
+    const hooksInstalled = [];
+    for (const file of hookFiles) {
+      const src = path.join(HOOKS_SOURCE, file);
+      const dest = path.join(PLEXOR_HOOKS_DIR, file);
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, 0o755);
+      hooksInstalled.push(file);
+    }
+
     // Copy lib files to ~/.claude/plugins/plexor/lib/
     // CRITICAL: These are required for commands to work
     const libInstalled = [];
@@ -431,6 +473,10 @@ function main() {
       console.error('');
     }
 
+    const statusLineRegistration = upsertManagedStatusLine(CLAUDE_SETTINGS_FILE, HOME_DIR);
+    const hooksRegistration = upsertManagedHooks(CLAUDE_SETTINGS_FILE, HOME_DIR);
+    const legacyHooksCleanup = cleanupLegacyManagedHooksFile(CLAUDE_LEGACY_HOOKS_FILE);
+
     // Fix file ownership when running with sudo
     // Files are created as root but should be owned by the original user
     if (targetUser) {
@@ -457,9 +503,21 @@ function main() {
     if (jsInstalled.length > 0) {
       console.log(`  ✓ Installed ${jsInstalled.length} executors to ~/.claude/plugins/plexor/commands/`);
     }
+    if (hooksInstalled.length > 0) {
+      console.log(`  ✓ Installed ${hooksInstalled.length} hook scripts to ~/.claude/plugins/plexor/hooks/`);
+    }
     if (libInstalled.length > 0) {
       console.log(`  ✓ Installed ${libInstalled.length} lib modules to ~/.claude/plugins/plexor/lib/`);
     }
+    if (statusLineRegistration.changed || statusLineRegistration.existed) {
+      console.log('  ✓ Registered Plexor status line in ~/.claude/settings.json');
+    }
+    if (hooksRegistration.changed || hooksRegistration.existed) {
+      console.log('  ✓ Registered Plexor hooks in ~/.claude/settings.json');
+    }
+    if (legacyHooksCleanup.changed) {
+      console.log('  ✓ Cleaned up legacy ~/.claude/hooks.json entries');
+    }
     if (targetUser) {
       console.log(`  ✓ Set file ownership to ${targetUser.user}`);
     }
@@ -474,10 +532,11 @@ function main() {
     console.log('    2. Write ~/.plexor/config.json');
     console.log('    3. Point Claude at the Plexor staging gateway');
     console.log('    4. Preserve prior Claude auth for restore on logout');
-    console.log('    5. Verify Claude routing with a deterministic check');
+    console.log('    5. Show Plexor state in Claude footer via status line');
+    console.log('    6. Update session savings in real time via Claude hooks');
     console.log('');
     console.log('  ┌─────────────────────────────────────────────────────────────────┐');
-    console.log('  │  No shell edits or Claude restart required after setup        │');
+    console.log('  │  After /plexor-setup, restart Claude before first prompt     │');
     console.log('  └─────────────────────────────────────────────────────────────────┘');
     console.log('');
     console.log('  Available commands:');

package/scripts/uninstall.js

@@ -17,6 +17,9 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const { removeManagedStatusLine } = require('../lib/statusline-manager');
+const { removeManagedHooks, cleanupLegacyManagedHooksFile } = require('../lib/hooks-manager');
+const { removeManagedClaudeCustomHeadersFromEnv } = require('../lib/config-utils');
 
 /**
  * Get the correct home directory for the process's effective user.
@@ -52,11 +55,16 @@ console.log('');
 
 const results = {
   routing: false,
+  statusLine: false,
+  hooks: false,
   commands: [],
   restored: [],
   pluginDir: false
 };
 const PREVIOUS_PRIMARY_API_KEY_ENV = 'PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY';
+const CLAUDE_SETTINGS_PATH = path.join(home, '.claude', 'settings.json');
+const CLAUDE_HOOKS_PATH = path.join(home, '.claude', 'settings.json');
+const CLAUDE_LEGACY_HOOKS_PATH = path.join(home, '.claude', 'hooks.json');
 
 function isManagedGatewayUrl(baseUrl = '') {
   return (
@@ -77,8 +85,9 @@ function clearPlexorRoutingEnv(env = {}) {
   const hasManagedBaseUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL || '');
   const hasPlexorAuthToken = isPlexorApiKey(env.ANTHROPIC_AUTH_TOKEN || '');
   const hasPlexorApiKey = isPlexorApiKey(env.ANTHROPIC_API_KEY || '');
+  const removedManagedHeaders = removeManagedClaudeCustomHeadersFromEnv(env);
 
-  if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey) {
+  if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey && !removedManagedHeaders) {
     return false;
   }
 
@@ -105,10 +114,16 @@ function clearPlexorRoutingEnv(env = {}) {
   return true;
 }
 
+function writeJsonAtomically(filePath, value) {
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
 function restoreClaudePrimaryApiKey(env = {}) {
   const previousPrimaryApiKey = env[PREVIOUS_PRIMARY_API_KEY_ENV] || '';
   if (!previousPrimaryApiKey) {
-    return false;
+    return { restored: false, warning: null };
   }
 
   const statePath = path.join(home, '.claude.json');
@@ -127,12 +142,14 @@ function restoreClaudePrimaryApiKey(env = {}) {
   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;
+  try {
+    writeJsonAtomically(statePath, claudeState);
+    delete env[PREVIOUS_PRIMARY_API_KEY_ENV];
+    return { restored: true, warning: null };
+  } catch (e) {
+    return { restored: false, warning: e.message };
+  }
 }
 
 // 1. Remove routing from settings.json
@@ -145,17 +162,20 @@ try {
       const settings = JSON.parse(data);
       if (settings.env) {
         const routingChanged = clearPlexorRoutingEnv(settings.env);
-        const primaryApiKeyRestored = restoreClaudePrimaryApiKey(settings.env);
+        const primaryApiKeyRestore = restoreClaudePrimaryApiKey(settings.env);
 
         // Clean up empty env block
         if (Object.keys(settings.env).length === 0) {
           delete settings.env;
         }
 
-        if (routingChanged || primaryApiKeyRestored) {
+        if (routingChanged || primaryApiKeyRestore.restored) {
           fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
           results.routing = true;
         }
+        if (primaryApiKeyRestore.warning) {
+          console.log(`  Warning: Could not restore Claude managed API key: ${primaryApiKeyRestore.warning}`);
+        }
       }
     }
   }
@@ -163,24 +183,34 @@ try {
   console.log(`  Warning: Could not clean settings.json: ${e.message}`);
 }
 
-// 2. Remove slash command files
-// These are the Plexor-specific command files that get installed to ~/.claude/commands/
-const plexorCommands = [
-  'plexor-config.md',
-  'plexor-enabled.md',
-  'plexor-login.md',
-  'plexor-logout.md',
-  'plexor-mode.md',
-  'plexor-provider.md',
-  'plexor-settings.md',
-  'plexor-setup.md',
-  'plexor-status.md',
-  'plexor-uninstall.md'
-];
+// 2. Remove managed Claude status line
+try {
+  const statusLineRemoval = removeManagedStatusLine(CLAUDE_SETTINGS_PATH, home);
+  results.statusLine = statusLineRemoval.changed;
+} catch (e) {
+  console.log(`  Warning: Could not clean Plexor status line: ${e.message}`);
+}
+
+// 2b. Remove managed Claude hooks
+try {
+  const hooksRemoval = removeManagedHooks(CLAUDE_HOOKS_PATH);
+  results.hooks = hooksRemoval.changed;
+} catch (e) {
+  console.log(`  Warning: Could not clean Plexor hooks: ${e.message}`);
+}
+try {
+  const legacyHooksRemoval = cleanupLegacyManagedHooksFile(CLAUDE_LEGACY_HOOKS_PATH);
+  results.hooks = results.hooks || legacyHooksRemoval.changed;
+} catch (e) {
+  console.log(`  Warning: Could not clean legacy Plexor hooks file: ${e.message}`);
+}
 
+// 3. Remove slash command files
+// These are the Plexor-specific command files that get installed to ~/.claude/commands/
 try {
   const commandsDir = path.join(home, '.claude', 'commands');
   if (fs.existsSync(commandsDir)) {
+    const plexorCommands = fs.readdirSync(commandsDir).filter((entry) => /^plexor-.*\.md$/i.test(entry));
     for (const cmd of plexorCommands) {
       const cmdPath = path.join(commandsDir, cmd);
       const backupPath = cmdPath + '.backup';
@@ -201,7 +231,7 @@ try {
   console.log(`  Warning: Could not clean commands: ${e.message}`);
 }
 
-// 3. Remove plugin directory
+// 4. Remove plugin directory
 try {
   const pluginDir = path.join(home, '.claude', 'plugins', 'plexor');
   if (fs.existsSync(pluginDir)) {
@@ -212,8 +242,19 @@ try {
   console.log(`  Warning: Could not remove plugin directory: ${e.message}`);
 }
 
+// 5. Remove config directory
+try {
+  const configDir = path.join(home, '.plexor');
+  if (fs.existsSync(configDir)) {
+    fs.rmSync(configDir, { recursive: true, force: true });
+    results.configDir = true;
+  }
+} catch (e) {
+  console.log(`  Warning: Could not remove ~/.plexor config directory: ${e.message}`);
+}
+
 // Output results
-if (results.routing || results.commands.length > 0 || results.pluginDir) {
+if (results.routing || results.statusLine || results.hooks || results.commands.length > 0 || results.pluginDir) {
   console.log('  Plexor plugin uninstalled');
   console.log('');
 
@@ -223,6 +264,16 @@ if (results.routing || results.commands.length > 0 || results.pluginDir) {
     console.log('');
   }
 
+  if (results.statusLine) {
+    console.log('  Removed Plexor Claude status line');
+    console.log('');
+  }
+
+  if (results.hooks) {
+    console.log('  Removed Plexor Claude hooks');
+    console.log('');
+  }
+
   if (results.commands.length > 0) {
     console.log('  Removed commands:');
     results.commands.forEach(cmd => console.log(`    /${cmd}`));
@@ -239,10 +290,10 @@ if (results.routing || results.commands.length > 0 || results.pluginDir) {
     console.log('  Removed plugin directory');
     console.log('');
   }
-
-  console.log('  Note: ~/.plexor/ config directory was preserved.');
-  console.log('  To remove it: rm -rf ~/.plexor');
-  console.log('');
+  if (results.configDir) {
+    console.log('  Removed ~/.plexor config directory');
+    console.log('');
+  }
 } else {
   console.log('  No Plexor components found to clean up.');
   console.log('');