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

package/commands/plexor-logout.js

@@ -115,9 +115,9 @@ function main() {
     process.exit(1);
   }
 
-  // CRITICAL FIX: Disable Claude Code routing in ~/.claude/settings.json
-  // This removes ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN so Claude Code
-  // no longer tries to route through Plexor with removed credentials
+  // Disable Claude Code routing in ~/.claude/settings.json.
+  // This removes the Plexor gateway URL and managed Plexor headers so Claude
+  // no longer routes through Plexor with removed credentials.
   const routingDisabled = settingsManager.disablePlexorRouting();
 
   // Clear session

package/commands/plexor-setup.js

@@ -93,7 +93,7 @@ function getGatewayLabel(apiUrl) {
 }
 
 function isRunningInsideClaudeSession(env = process.env) {
-  return Boolean(env.CLAUDECODE);
+  return Boolean(env.CLAUDECODE || env.PLEXOR_SETUP_IN_CLAUDE);
 }
 
 function createSkipVerifyResult() {
@@ -143,6 +143,14 @@ function printUsage() {
   console.log('  PLEXOR_API_KEY=plx_... /plexor-setup');
 }
 
+function printRestartBanner() {
+  const BRIGHT_YELLOW = '\x1b[93m';
+  const BOLD = '\x1b[1m';
+  const RESET = '\x1b[0m';
+  console.log('');
+  console.log(`${BOLD}${BRIGHT_YELLOW}RESTART CLAUDE NOW.${RESET}`);
+}
+
 function printReceipt({ user, gateway, previousAuthPreserved, verifyResult }) {
   const line = (content) => `│  ${String(content).slice(0, 43).padEnd(43)}│`;
 
@@ -169,7 +177,11 @@ function printReceipt({ user, gateway, previousAuthPreserved, verifyResult }) {
   }
   console.log('└─────────────────────────────────────────────┘');
 
-  if (!verifyResult.ok) {
+  if (verifyResult.pendingRestart) {
+    printRestartBanner();
+  }
+
+  if (!verifyResult.ok && !verifyResult.pendingRestart) {
     console.log('');
     console.log(`Verification failed: ${verifyResult.reason}`);
   }

package/commands/plexor-setup.md

@@ -1,14 +1,14 @@
 description: Guided first-run setup for Plexor with Claude Code (user)
 ---
 
-**RULE: Execute this workflow EXACTLY ONCE. After the Bash tool returns output, your ONLY action is to present that output to the user. DO NOT restart the workflow.**
+**RULE: Execute this workflow EXACTLY ONCE. After the Bash tool returns output, your ONLY action is to present that output to the user. If the output says restart is required, add one standalone line exactly `RESTART CLAUDE NOW.` after the tool output. DO NOT restart the workflow.**
 
 Plexor setup is the primary human setup flow.
 
 If `$ARGUMENTS` already contains a Plexor API key (`plx_...`), run:
 
 ```bash
-node ~/.claude/plugins/plexor/commands/plexor-setup.js $ARGUMENTS
+PLEXOR_SETUP_IN_CLAUDE=1 node ~/.claude/plugins/plexor/commands/plexor-setup.js $ARGUMENTS
 ```
 
 If the user did not provide a key yet, ask them:
@@ -18,11 +18,11 @@ If the user did not provide a key yet, ask them:
 After the user replies with the key, run:
 
 ```bash
-node ~/.claude/plugins/plexor/commands/plexor-setup.js <user_key>
+PLEXOR_SETUP_IN_CLAUDE=1 node ~/.claude/plugins/plexor/commands/plexor-setup.js <user_key>
 ```
 
 This command:
 - saves the Plexor key
 - routes Claude through the Plexor staging gateway
-- preserves prior direct Claude auth for restore on logout/uninstall
+- keeps Claude's existing direct auth intact and adds Plexor auth via managed headers
 - runs a deterministic Claude verification step

package/commands/plexor-status.js

@@ -8,6 +8,7 @@
 const fs = require('fs');
 const path = require('path');
 const https = require('https');
+const { parseCustomHeaders } = require('../lib/config-utils');
 
 // Import centralized constants with HOME directory validation
 const { HOME_DIR, CONFIG_PATH, SESSION_PATH, SESSION_TIMEOUT_MS } = require('../lib/constants');
@@ -26,12 +27,15 @@ function isManagedGatewayUrl(baseUrl = '') {
 }
 
 function getPlexorAuthKey(env = {}) {
+  const headers = parseCustomHeaders(env.ANTHROPIC_CUSTOM_HEADERS);
+  const headerApiKey = headers['x-plexor-key'] || '';
   const apiKey = env.ANTHROPIC_API_KEY || '';
   const authToken = env.ANTHROPIC_AUTH_TOKEN || '';
 
+  if (headerApiKey.startsWith('plx_')) return headerApiKey;
   if (apiKey.startsWith('plx_')) return apiKey;
   if (authToken.startsWith('plx_')) return authToken;
-  return apiKey || authToken || '';
+  return '';
 }
 
 function getDirectClaudeAuthState() {
@@ -58,7 +62,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,15 +18,24 @@
 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 home directory, handling sudo case
 function getHomeDir() {
-  if (process.env.SUDO_USER) {
-    const platform = os.platform();
-    if (platform === 'darwin') {
-      return path.join('/Users', process.env.SUDO_USER);
-    } else if (platform === 'linux') {
-      return path.join('/home', process.env.SUDO_USER);
+  if (os.platform() !== 'win32' && process.env.SUDO_USER) {
+    try {
+      if (typeof process.getuid === 'function' && process.getuid() === 0) {
+        const entry = execSync(`getent passwd ${process.env.SUDO_USER}`, { encoding: 'utf8' }).trim();
+        const fields = entry.split(':');
+        if (fields.length >= 6 && fields[5]) {
+          return fields[5];
+        }
+      }
+    } catch {
+      // Fall through to HOME/os.homedir below.
     }
   }
   return process.env.HOME || process.env.USERPROFILE || os.homedir();
@@ -36,22 +45,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 +114,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 +191,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 +234,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 +284,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 +295,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 +325,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 +363,7 @@ function main() {
     }
   }
 
-  // 3. Remove plugin directory
+  // 4. Remove plugin directory
   const pluginRemoved = removePluginDirectory();
   if (!quiet) {
     console.log(pluginRemoved
@@ -312,7 +371,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 +396,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();