@plexor-dev/claude-code-plugin 0.1.0-beta.16 → 0.1.0-beta.19

package/commands/plexor-config.md

@@ -40,3 +40,5 @@ Other commands:
 - /plexor-provider - Change provider
 - /plexor-enabled - Enable/disable proxy
 ```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-enabled.md

@@ -52,3 +52,5 @@ Plexor Proxy: DISABLED
 Your prompts will go directly to Anthropic at full price.
 Run /plexor-enabled to re-enable optimization.
 ```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-login.md

@@ -82,3 +82,5 @@ Dashboard: https://plexor.dev/dashboard
 ```
 
 If the API call fails, tell the user the key may be invalid and ask them to check it.
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-logout.md

@@ -40,3 +40,5 @@ To use Plexor again, run /plexor-login
 
 Dashboard: https://plexor.dev/dashboard
 ```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-mode.md

@@ -45,3 +45,5 @@ Mode Details:
 Current mode: [mode]
 Run /plexor-status to see your savings.
 ```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-provider.md

@@ -45,3 +45,5 @@ Provider options:
 Current provider: [preferredProvider]
 Run /plexor-status to see your usage.
 ```
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-settings.md

@@ -56,3 +56,5 @@ Options:
 4. **Timeout** - Change request timeout
 
 Then update `~/.plexor/config.json` with the new value using the Write tool.
+
+**IMPORTANT**: After completing the task, STOP. Do not run additional commands or explore the codebase.

package/commands/plexor-status.js

@@ -92,8 +92,18 @@ async function main() {
   const cacheEnabled = localCache ? 'Enabled' : 'Disabled';
   const cacheRate = formatPct((summary.cache_hit_rate || 0) * 100);
 
-  // Build dashboard URL
-  const dashboardUrl = apiUrl.replace('.api.', '.').replace('/api', '') + '/dashboard.html';
+  // Build dashboard URL from API URL
+  // API: https://api.plexor.dev or https://staging.api.plexor.dev
+  // Dashboard: https://plexor.dev/dashboard or https://staging.plexor.dev/dashboard
+  let dashboardUrl = 'https://plexor.dev/dashboard';
+  try {
+    const url = new URL(apiUrl);
+    // Remove 'api.' prefix from hostname if present
+    const host = url.hostname.replace(/^api\./, '').replace(/\.api\./, '.');
+    dashboardUrl = `${url.protocol}//${host}/dashboard`;
+  } catch {
+    // If URL parsing fails, use default
+  }
 
   // Output formatted status - each line is exactly 43 chars inner width
   const line = (content) => `  │  ${content.padEnd(43)}│`;

package/commands/plexor-status.md

@@ -10,4 +10,12 @@ Run this command to display Plexor statistics:
 node ~/.claude/plugins/plexor/commands/plexor-status.js
 ```
 
-Use the Bash tool to execute this single command. Do not read files manually or format output yourself.
+Use the Bash tool to execute this single command.
+
+**IMPORTANT**: After running this command and displaying the output, STOP. Do not:
+- Read any files
+- Explore the codebase
+- Run additional commands
+- Ask follow-up questions
+
+The command output is the complete response. Simply show the output and wait for the user's next input.

package/hooks/intercept.js

@@ -1,17 +1,39 @@
 #!/usr/bin/env node
 
 /**
- * Plexor Interception Hook
+ * Plexor Interception Hook - Phase 3 Hypervisor Architecture
  *
- * This script intercepts Claude Code prompts before they are sent to the LLM.
- * It optimizes the prompt and optionally routes to a cheaper provider.
+ * This script intercepts Claude Code requests before they reach the LLM.
+ *
+ * In HYPERVISOR MODE (ANTHROPIC_BASE_URL points to Plexor):
+ *   - All requests pass through unchanged
+ *   - Server handles all optimization, routing, and quality control
+ *   - Plugin just adds session tracking metadata
+ *   - This is the recommended setup for best user experience
+ *
+ * In PLUGIN MODE (direct to Anthropic):
+ *   - Plugin does local optimization (legacy behavior)
+ *   - Less reliable due to client-side state management
  *
  * Input: JSON object with messages, model, max_tokens, etc.
- * Output: Modified JSON object with optimized messages
+ * Output: Passthrough (hypervisor mode) or optimized messages (plugin mode)
  */
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Generate a unique request ID for tracking.
+ * Format: pass_<timestamp>_<random> for passthrough requests
+ * This ensures every request can be tracked, even passthroughs.
+ * Issue #701: Missing request_id caused response tracking to fail.
+ */
+function generateRequestId(prefix = 'pass') {
+  const timestamp = Date.now().toString(36);
+  const random = crypto.randomBytes(4).toString('hex');
+  return `${prefix}_${timestamp}_${random}`;
+}
 
 // Try to load lib modules, fall back to inline implementations
 let ConfigManager, SessionManager, LocalCache, Logger, PlexorClient;
@@ -157,12 +179,27 @@ async function main() {
     input = await readStdin();
     request = JSON.parse(input);
 
-    // Issue #687: Auto-disable hook when ANTHROPIC_BASE_URL points to Plexor
-    // If already using Plexor as proxy, don't run local hook (avoid double-processing)
+    // Phase 3 Hypervisor Mode Detection
+    // When ANTHROPIC_BASE_URL points to Plexor, all intelligence is server-side
+    // The plugin just passes through - server handles optimization, routing, quality
     const baseUrl = process.env.ANTHROPIC_BASE_URL || '';
-    if (baseUrl.includes('plexor')) {
-      logger.debug('Plexor proxy detected via ANTHROPIC_BASE_URL, passing through');
-      return output(request);
+    const isHypervisorMode = baseUrl.includes('plexor') || baseUrl.includes('staging.api');
+
+    if (isHypervisorMode) {
+      // HYPERVISOR MODE: Server handles everything
+      // Just pass through with minimal metadata for session tracking
+      logger.debug('[Plexor] Hypervisor mode active - server handles all optimization');
+
+      // Add session tracking metadata (server will use this for analytics)
+      return output({
+        ...request,
+        _plexor_client: {
+          mode: 'hypervisor',
+          plugin_version: '0.1.0-beta.18',
+          cwd: process.cwd(),
+          timestamp: Date.now(),
+        }
+      });
     }
 
     // CRITICAL: Check for slash commands FIRST (before agentic check)
@@ -175,6 +212,7 @@ async function main() {
         ...request,
         plexor_cwd: process.cwd(),
         _plexor: {
+          request_id: generateRequestId('slash'),  // Issue #701: Add request_id for tracking
           source: 'passthrough_slash_command',
           reason: 'slash_command_detected',
           cwd: process.cwd(),
@@ -192,6 +230,7 @@ async function main() {
         ...request,
         plexor_cwd: process.cwd(),
         _plexor: {
+          request_id: generateRequestId('cli'),  // Issue #701: Add request_id for tracking
           source: 'passthrough_cli',
           reason: 'cli_tool_execution_detected',
           cwd: process.cwd(),
@@ -209,6 +248,7 @@ async function main() {
         ...request,
         plexor_cwd: process.cwd(),
         _plexor: {
+          request_id: generateRequestId('agent'),  // Issue #701: Add request_id for tracking
           source: 'passthrough_agentic',
           reason: 'tool_use_detected',
           cwd: process.cwd(),
@@ -221,12 +261,30 @@ async function main() {
 
     if (!settings.enabled) {
       logger.debug('Plexor disabled, passing through');
-      return output(request);
+      session.recordPassthrough();
+      return output({
+        ...request,
+        _plexor: {
+          request_id: generateRequestId('disabled'),  // Issue #701: Add request_id for tracking
+          source: 'passthrough_disabled',
+          reason: 'plexor_disabled',
+          latency_ms: Date.now() - startTime
+        }
+      });
     }
 
     if (!settings.apiKey) {
       logger.info('Not authenticated. Run /plexor-login to enable optimization.');
-      return output(request);
+      session.recordPassthrough();
+      return output({
+        ...request,
+        _plexor: {
+          request_id: generateRequestId('noauth'),  // Issue #701: Add request_id for tracking
+          source: 'passthrough_no_auth',
+          reason: 'not_authenticated',
+          latency_ms: Date.now() - startTime
+        }
+      });
     }
 
     const client = new PlexorClient({
@@ -248,6 +306,7 @@ async function main() {
       return output({
         ...request,
         _plexor: {
+          request_id: generateRequestId('cache'),  // Issue #701: Add request_id for tracking
           source: 'local_cache',
           latency_ms: Date.now() - startTime
         }
@@ -312,11 +371,15 @@ async function main() {
     logger.error(`[Plexor] Error: ${error.message}`);
     logger.debug(error.stack);
 
+    const errorRequestId = generateRequestId('error');  // Issue #701: Add request_id for tracking
+
     // Use already-parsed request if available, otherwise pass through raw
     if (request) {
+      session.recordPassthrough();
       return output({
         ...request,
         _plexor: {
+          request_id: errorRequestId,
           error: error.message,
           source: 'passthrough_error'
         }
@@ -325,9 +388,11 @@ async function main() {
       // Try to parse the input we already read
       try {
         const req = JSON.parse(input);
+        session.recordPassthrough();
         return output({
           ...req,
           _plexor: {
+            request_id: errorRequestId,
             error: error.message,
             source: 'passthrough_error'
           }
@@ -476,11 +541,10 @@ function isAgenticRequest(request) {
     }
   }
 
-  // Check for multi-turn conversations (likely agentic)
-  const assistantMessages = messages.filter(m => m.role === 'assistant');
-  if (assistantMessages.length > 2) {
-    return true;
-  }
+  // NOTE: Removed multi-turn check (Issue #701)
+  // Multi-turn conversations WITHOUT tool use are NOT agentic
+  // The old check caused normal conversations to be marked as agentic
+  // after just 2 assistant messages, leading to infinite loops
 
   return false;
 }

package/hooks/track-response.js

@@ -6,6 +6,10 @@
  * This script runs after the LLM response is received.
  * It tracks response metrics for analytics and updates session stats.
  *
+ * Issue #701 Fix: Now tracks ALL responses including passthroughs.
+ * Previously, responses without request_id would exit early without tracking,
+ * leading to "0 tokens" display and potential context issues.
+ *
  * Input: JSON object with response content, tokens used, etc.
  * Output: Passthrough (no modifications)
  */
@@ -13,17 +17,22 @@
 const path = require('path');
 
 // Use lib modules
-let ConfigManager, SessionManager, LocalCache, Logger, PlexorClient;
+let ConfigManager, SessionManager, LocalCache, Logger, ServerSync;
 try {
   ConfigManager = require('../lib/config');
   SessionManager = require('../lib/session');
   LocalCache = require('../lib/cache');
   Logger = require('../lib/logger');
-  PlexorClient = require('../lib/plexor-client');
+  // Issue #701: Phase 2 - Server sync for persistent session state
+  const serverSyncModule = require('../lib/server-sync');
+  ServerSync = serverSyncModule.getServerSync;
 } catch {
   // Fallback inline implementations if lib not found
   const fs = require('fs');
   const CONFIG_PATH = path.join(process.env.HOME || '', '.plexor', 'config.json');
+  const SESSION_PATH = path.join(process.env.HOME || '', '.plexor', 'session.json');
+  const PLEXOR_DIR = path.join(process.env.HOME || '', '.plexor');
+  const SESSION_TIMEOUT_MS = 30 * 60 * 1000;
 
   ConfigManager = class {
     async load() {
@@ -40,9 +49,84 @@ try {
     }
   };
 
+  // Inline SessionManager for fallback (Issue #701: proper tracking)
   SessionManager = class {
-    recordOptimization() {}
-    recordPassthrough() {}
+    constructor() {
+      this.sessionPath = SESSION_PATH;
+    }
+
+    load() {
+      try {
+        const data = fs.readFileSync(this.sessionPath, 'utf8');
+        const session = JSON.parse(data);
+        if (Date.now() - session.last_activity > SESSION_TIMEOUT_MS) {
+          return this.createNew();
+        }
+        return session;
+      } catch {
+        return this.createNew();
+      }
+    }
+
+    createNew() {
+      const session = {
+        session_id: `session_${Date.now()}`,
+        started_at: new Date().toISOString(),
+        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,  // Issue #701: Track output tokens
+        baseline_cost: 0, actual_cost: 0, cost_saved: 0
+      };
+      this.save(session);
+      return session;
+    }
+
+    save(session) {
+      try {
+        if (!fs.existsSync(PLEXOR_DIR)) {
+          fs.mkdirSync(PLEXOR_DIR, { recursive: true });
+        }
+        session.last_activity = Date.now();
+        fs.writeFileSync(this.sessionPath, JSON.stringify(session, null, 2));
+      } catch {}
+    }
+
+    recordOptimization(result) {
+      const s = this.load();
+      s.requests++;
+      s.optimizations++;
+      s.original_tokens += result.original_tokens || 0;
+      s.optimized_tokens += result.optimized_tokens || 0;
+      s.tokens_saved += result.tokens_saved || 0;
+      s.output_tokens += result.output_tokens || 0;  // Issue #701
+      s.baseline_cost += result.baseline_cost || 0;
+      s.actual_cost += result.estimated_cost || result.actual_cost || 0;
+      s.cost_saved += (result.baseline_cost || 0) - (result.estimated_cost || result.actual_cost || 0);
+      this.save(s);
+      return s;
+    }
+
+    recordCacheHit() {
+      const s = this.load();
+      s.requests++;
+      s.cache_hits++;
+      this.save(s);
+      return s;
+    }
+
+    recordPassthrough(outputTokens = 0) {
+      const s = this.load();
+      s.requests++;
+      s.passthroughs = (s.passthroughs || 0) + 1;
+      s.output_tokens += outputTokens;  // Issue #701: Track output even for passthroughs
+      this.save(s);
+      return s;
+    }
+
+    getStats() {
+      return this.load();
+    }
   };
 
   LocalCache = class {
@@ -50,10 +134,28 @@ try {
   };
 
   Logger = class {
-    info(msg) { console.error(msg); }
-    error(msg) { console.error(`[ERROR] ${msg}`); }
-    debug() {}
+    constructor(name) { this.name = name; }
+    info(msg, data) {
+      if (data) {
+        console.error(`[${this.name}] ${msg}`, JSON.stringify(data));
+      } else {
+        console.error(`[${this.name}] ${msg}`);
+      }
+    }
+    error(msg) { console.error(`[${this.name}] [ERROR] ${msg}`); }
+    debug(msg) {
+      if (process.env.PLEXOR_DEBUG) {
+        console.error(`[${this.name}] [DEBUG] ${msg}`);
+      }
+    }
   };
+
+  // Issue #701: Fallback ServerSync that does nothing
+  ServerSync = () => ({
+    syncSession: async () => ({ synced: false, message: 'Server sync not available' }),
+    scheduleSync: () => {},
+    needsSync: () => false
+  });
 }
 
 const logger = new Logger('track-response');
@@ -61,69 +163,185 @@ const config = new ConfigManager();
 const cache = new LocalCache();
 const session = new SessionManager();
 
+// Issue #701: Phase 2 - Initialize server sync (lazy, initialized on first use)
+let serverSync = null;
+
+async function getServerSync() {
+  if (serverSync) return serverSync;
+
+  try {
+    const settings = await config.load();
+    if (settings.apiKey && settings.enabled) {
+      serverSync = ServerSync({
+        apiKey: settings.apiKey,
+        baseUrl: settings.apiUrl || 'https://api.plexor.dev',
+        enabled: settings.serverSyncEnabled !== false
+      });
+    } else {
+      serverSync = ServerSync({ enabled: false });
+    }
+  } catch {
+    serverSync = ServerSync({ enabled: false });
+  }
+  return serverSync;
+}
+
 async function main() {
+  let response;
+  let input;
+
   try {
-    const input = await readStdin();
-    const response = JSON.parse(input);
+    input = await readStdin();
+    response = JSON.parse(input);
 
-    const settings = await config.load();
+    // Calculate output tokens for ALL responses (Issue #701)
+    const outputTokens = estimateOutputTokens(response);
 
-    // If Plexor is disabled or no API key, just pass through
-    if (!settings.enabled || !settings.apiKey) {
-      return output(response);
+    // Get Plexor metadata if present
+    const plexorMeta = response._plexor;
+
+    // Issue #701: Track ALL responses, not just when enabled
+    // This ensures session stats are always accurate
+    if (plexorMeta) {
+      await trackResponseWithMetadata(plexorMeta, outputTokens);
+    } else {
+      // No Plexor metadata - still track the output tokens
+      session.recordPassthrough(outputTokens);
+      logger.debug('Response tracked without Plexor metadata');
     }
 
-    // Check if this response has Plexor metadata
-    const plexorMeta = response._plexor;
-    if (!plexorMeta || !plexorMeta.request_id) {
-      // No Plexor metadata, but still record the request
-      session.recordPassthrough();
+    // Issue #701: Phase 2 - Schedule server sync (non-blocking)
+    // This syncs local session stats to the server for persistence
+    try {
+      const sync = await getServerSync();
+      const localStats = session.getStats();
+      sync.scheduleSync(localStats);
+    } catch (syncError) {
+      // Server sync failures should not affect response passthrough
+      logger.debug(`Server sync scheduling failed: ${syncError.message}`);
+    }
+
+    // Pass through unchanged
+    return output(response);
+
+  } catch (error) {
+    logger.error(`Tracking error: ${error.message}`);
+
+    // On any error, try to pass through the response unchanged
+    if (response) {
       return output(response);
+    } else if (input) {
+      try {
+        return output(JSON.parse(input));
+      } catch {
+        process.exit(1);
+      }
+    } else {
+      process.exit(1);
     }
+  }
+}
 
-    // Get stored metadata for this request
-    const metadata = await cache.getMetadata(plexorMeta.request_id);
+/**
+ * Track response using Plexor metadata.
+ * Issue #701: Handles ALL source types, not just plexor_api.
+ */
+async function trackResponseWithMetadata(plexorMeta, outputTokens) {
+  const source = plexorMeta.source || 'unknown';
+  const requestId = plexorMeta.request_id;
 
-    // Calculate output tokens (approximate)
-    const outputTokens = estimateTokens(response.content || '');
+  logger.debug(`Tracking response: source=${source}, request_id=${requestId}`);
 
-    // Update session stats with response data
-    if (plexorMeta.source === 'plexor_api') {
+  switch (source) {
+    case 'plexor_api':
+      // Full optimization was applied
       session.recordOptimization({
         original_tokens: plexorMeta.original_tokens || 0,
         optimized_tokens: plexorMeta.optimized_tokens || 0,
         tokens_saved: plexorMeta.tokens_saved || 0,
         baseline_cost: plexorMeta.baseline_cost || 0,
-        estimated_cost: plexorMeta.estimated_cost || 0
+        estimated_cost: plexorMeta.estimated_cost || 0,
+        output_tokens: outputTokens
       });
-
-      logger.info('[Plexor] Response tracked', {
-        request_id: plexorMeta.request_id,
+      logger.info('[Plexor] Optimized response tracked', {
+        request_id: requestId,
         input_tokens: plexorMeta.optimized_tokens,
         output_tokens: outputTokens,
+        savings_percent: plexorMeta.savings_percent,
         provider: plexorMeta.recommended_provider
       });
-    } else if (plexorMeta.source === 'local_cache') {
+      break;
+
+    case 'local_cache':
       session.recordCacheHit();
-      logger.info('[Plexor] Cache hit recorded');
-    } else {
-      session.recordPassthrough();
-    }
+      logger.info('[Plexor] Cache hit recorded', { request_id: requestId });
+      break;
 
-    // Pass through unchanged
-    return output(response);
+    case 'passthrough_agentic':
+    case 'passthrough_slash_command':
+    case 'passthrough_cli':
+    case 'passthrough_disabled':
+    case 'passthrough_no_auth':
+    case 'passthrough_error':
+    case 'passthrough':
+      // Passthrough - still track output tokens
+      session.recordPassthrough(outputTokens);
+      logger.debug(`Passthrough recorded: ${source}`, {
+        request_id: requestId,
+        reason: plexorMeta.reason,
+        output_tokens: outputTokens
+      });
+      break;
 
-  } catch (error) {
-    logger.error(`Tracking error: ${error.message}`);
+    default:
+      // Unknown source - treat as passthrough
+      session.recordPassthrough(outputTokens);
+      logger.debug(`Unknown source tracked as passthrough: ${source}`, {
+        request_id: requestId,
+        output_tokens: outputTokens
+      });
+  }
+}
 
-    // On any error, pass through unchanged
-    try {
-      const input = await readStdin();
-      return output(JSON.parse(input));
-    } catch {
-      process.exit(1);
+/**
+ * Estimate output tokens from response content.
+ * Handles both string and structured content formats.
+ */
+function estimateOutputTokens(response) {
+  if (!response) return 0;
+
+  // Try to get content from various response formats
+  let text = '';
+
+  // Anthropic format: content array with text blocks
+  if (Array.isArray(response.content)) {
+    for (const block of response.content) {
+      if (block.type === 'text' && block.text) {
+        text += block.text;
+      } else if (block.type === 'tool_use') {
+        // Tool use blocks contribute to token count
+        text += JSON.stringify(block.input || {});
+      }
     }
   }
+  // Simple string content
+  else if (typeof response.content === 'string') {
+    text = response.content;
+  }
+  // OpenAI format: choices array
+  else if (response.choices && response.choices[0]) {
+    const choice = response.choices[0];
+    if (choice.message && choice.message.content) {
+      text = choice.message.content;
+    } else if (choice.text) {
+      text = choice.text;
+    }
+  }
+
+  if (!text) return 0;
+
+  // Approximate: ~4 characters per token (rough estimate)
+  return Math.max(1, Math.ceil(text.length / 4));
 }
 
 async function readStdin() {
@@ -152,12 +370,6 @@ function output(data) {
   process.exit(0);
 }
 
-function estimateTokens(text) {
-  if (!text) return 0;
-  // Approximate: ~4 characters per token
-  return Math.max(1, Math.ceil(text.length / 4));
-}
-
 main().catch((error) => {
   console.error(`[Plexor] Fatal error: ${error.message}`);
   process.exit(1);

package/lib/server-sync.js

@@ -0,0 +1,237 @@
+/**
+ * Plexor Server Sync Module
+ *
+ * Issue #701: Syncs local plugin session state to the Plexor server.
+ * This ensures accurate token tracking even for passthrough requests.
+ *
+ * Phase 2 of the hypervisor architecture implementation.
+ */
+
+const https = require('https');
+const http = require('http');
+
+class ServerSync {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl || 'https://api.plexor.dev';
+    this.timeout = options.timeout || 5000;
+    this.enabled = options.enabled !== false;
+    this.lastSyncTime = null;
+    this.syncInterval = options.syncInterval || 60000; // 1 minute default
+    this.pendingSync = null;
+    this.serverSessionId = null;
+  }
+
+  /**
+   * Sync local session stats to the server.
+   * Issue #701: Ensures server has accurate metrics even for passthroughs.
+   *
+   * @param {Object} localSession - Local session stats from SessionManager
+   * @returns {Promise<Object>} Server response with synced metrics
+   */
+  async syncSession(localSession) {
+    if (!this.enabled || !this.apiKey) {
+      return { synced: false, message: 'Server sync disabled or no API key' };
+    }
+
+    try {
+      const syncData = {
+        session_id: this.serverSessionId,
+        requests: localSession.requests || 0,
+        optimizations: localSession.optimizations || 0,
+        cache_hits: localSession.cache_hits || 0,
+        passthroughs: localSession.passthroughs || 0,
+        original_tokens: localSession.original_tokens || 0,
+        optimized_tokens: localSession.optimized_tokens || 0,
+        tokens_saved: localSession.tokens_saved || 0,
+        output_tokens: localSession.output_tokens || 0,
+        baseline_cost: localSession.baseline_cost || 0,
+        actual_cost: localSession.actual_cost || 0,
+        cost_saved: localSession.cost_saved || 0
+      };
+
+      const response = await this._postToServer('/v1/plugin/session/sync', syncData);
+
+      if (response.synced) {
+        this.serverSessionId = response.server_session_id;
+        this.lastSyncTime = Date.now();
+      }
+
+      return response;
+    } catch (error) {
+      // Don't throw - server sync failures shouldn't break the plugin
+      return {
+        synced: false,
+        message: `Server sync failed: ${error.message}`,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get server-side session state.
+   *
+   * @param {string} sessionId - Session ID to query
+   * @returns {Promise<Object>} Server session state
+   */
+  async getServerSession(sessionId) {
+    if (!this.enabled || !this.apiKey) {
+      return { found: false, message: 'Server sync disabled or no API key' };
+    }
+
+    try {
+      return await this._getFromServer(`/v1/plugin/session/${sessionId}`);
+    } catch (error) {
+      return {
+        found: false,
+        message: `Failed to get server session: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Schedule periodic sync (debounced).
+   *
+   * @param {Object} localSession - Local session stats
+   */
+  scheduleSync(localSession) {
+    // Debounce: don't sync more than once per interval
+    if (this.pendingSync) {
+      clearTimeout(this.pendingSync);
+    }
+
+    this.pendingSync = setTimeout(async () => {
+      await this.syncSession(localSession);
+      this.pendingSync = null;
+    }, 1000); // Sync 1 second after last request
+  }
+
+  /**
+   * POST data to the Plexor server.
+   *
+   * @param {string} path - API path
+   * @param {Object} data - Data to send
+   * @returns {Promise<Object>} Parsed JSON response
+   */
+  _postToServer(path, data) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(path, this.baseUrl);
+      const isHttps = url.protocol === 'https:';
+      const client = isHttps ? https : http;
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+          'X-Plexor-Plugin-Version': '0.1.0-beta.5',
+          'X-Plexor-Issue': '701'
+        },
+        timeout: this.timeout
+      };
+
+      const req = client.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(body);
+            resolve(parsed);
+          } catch (e) {
+            reject(new Error(`Invalid JSON response: ${body.substring(0, 100)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      req.write(JSON.stringify(data));
+      req.end();
+    });
+  }
+
+  /**
+   * GET data from the Plexor server.
+   *
+   * @param {string} path - API path
+   * @returns {Promise<Object>} Parsed JSON response
+   */
+  _getFromServer(path) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(path, this.baseUrl);
+      const isHttps = url.protocol === 'https:';
+      const client = isHttps ? https : http;
+
+      const options = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname,
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+          'X-Plexor-Plugin-Version': '0.1.0-beta.5'
+        },
+        timeout: this.timeout
+      };
+
+      const req = client.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(body));
+          } catch (e) {
+            reject(new Error(`Invalid JSON response: ${body.substring(0, 100)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      req.end();
+    });
+  }
+
+  /**
+   * Check if sync is needed based on time elapsed.
+   */
+  needsSync() {
+    if (!this.lastSyncTime) return true;
+    return Date.now() - this.lastSyncTime > this.syncInterval;
+  }
+}
+
+// Singleton instance
+let _serverSync = null;
+
+function getServerSync(options = {}) {
+  if (!_serverSync) {
+    _serverSync = new ServerSync(options);
+  } else if (options.apiKey && options.apiKey !== _serverSync.apiKey) {
+    // Update API key if changed
+    _serverSync.apiKey = options.apiKey;
+    _serverSync.baseUrl = options.baseUrl || _serverSync.baseUrl;
+  }
+  return _serverSync;
+}
+
+function resetServerSync() {
+  _serverSync = null;
+}
+
+module.exports = {
+  ServerSync,
+  getServerSync,
+  resetServerSync
+};

package/lib/session.js

@@ -38,9 +38,11 @@ class SessionManager {
       requests: 0,
       optimizations: 0,
       cache_hits: 0,
+      passthroughs: 0,  // Issue #701: Track passthroughs
       original_tokens: 0,
       optimized_tokens: 0,
       tokens_saved: 0,
+      output_tokens: 0,  // Issue #701: Track output tokens
       baseline_cost: 0,
       actual_cost: 0,
       cost_saved: 0
@@ -71,6 +73,7 @@ class SessionManager {
       session.original_tokens += stats.original_tokens || 0;
       session.optimized_tokens += stats.optimized_tokens || 0;
       session.tokens_saved += stats.tokens_saved || 0;
+      session.output_tokens = (session.output_tokens || 0) + (stats.output_tokens || 0);  // Issue #701
       session.baseline_cost += stats.baseline_cost || 0;
       session.actual_cost += stats.actual_cost || 0;
       session.cost_saved += stats.cost_saved || 0;
@@ -80,6 +83,12 @@ class SessionManager {
       session.cache_hits++;
     }
 
+    // Issue #701: Track passthroughs and their output tokens
+    if (stats.passthrough) {
+      session.passthroughs = (session.passthroughs || 0) + 1;
+      session.output_tokens = (session.output_tokens || 0) + (stats.output_tokens || 0);
+    }
+
     this.save(session);
     return session;
   }
@@ -90,6 +99,7 @@ class SessionManager {
       original_tokens: result.original_tokens || 0,
       optimized_tokens: result.optimized_tokens || 0,
       tokens_saved: result.tokens_saved || 0,
+      output_tokens: result.output_tokens || 0,  // Issue #701: Track output tokens
       baseline_cost: result.baseline_cost || 0,
       actual_cost: result.estimated_cost || result.actual_cost || 0,
       cost_saved: (result.baseline_cost || 0) - (result.estimated_cost || result.actual_cost || 0)
@@ -100,8 +110,9 @@ class SessionManager {
     return this.recordRequest({ cache_hit: true });
   }
 
-  recordPassthrough() {
-    return this.recordRequest({});
+  recordPassthrough(outputTokens = 0) {
+    // Issue #701: Track passthroughs and their output tokens
+    return this.recordRequest({ passthrough: true, output_tokens: outputTokens });
   }
 
   getStats() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.16",
+  "version": "0.1.0-beta.19",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
   "scripts": {

package/scripts/plexor-cli.sh

@@ -1,18 +1,31 @@
 #!/bin/bash
 # Plexor CLI - Claude Code with intelligent optimization
+# This wrapper auto-enables hypervisor mode for direct gateway routing
 
-# Only show Plexor branding if ANTHROPIC_BASE_URL points to Plexor
-if [[ "$ANTHROPIC_BASE_URL" == *"plexor"* ]]; then
-    # Colors
-    CYAN='\033[0;36m'
-    GREEN='\033[0;32m'
-    YELLOW='\033[0;33m'
-    DIM='\033[2m'
-    NC='\033[0m' # No Color
+# Colors
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+DIM='\033[2m'
+NC='\033[0m' # No Color
 
-    # Plexor ASCII art
-    echo -e "${CYAN}"
-    cat << 'EOF'
+CONFIG_FILE="$HOME/.plexor/config.json"
+
+# Auto-configure ANTHROPIC_BASE_URL if Plexor is enabled
+if [ -f "$CONFIG_FILE" ]; then
+    ENABLED=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('enabled', False))" 2>/dev/null)
+    API_URL=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('apiUrl', ''))" 2>/dev/null)
+    API_KEY=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('auth',{}).get('api_key', ''))" 2>/dev/null)
+    MODE=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('mode', 'balanced'))" 2>/dev/null)
+
+    if [ "$ENABLED" = "True" ] && [ -n "$API_URL" ] && [ -n "$API_KEY" ]; then
+        # Set ANTHROPIC_BASE_URL to Plexor gateway (hypervisor mode)
+        export ANTHROPIC_BASE_URL="${API_URL}/gateway/anthropic/v1"
+        export ANTHROPIC_API_KEY="$API_KEY"
+
+        # Show Plexor branding
+        echo -e "${CYAN}"
+        cat << 'EOF'
     ____  __
    / __ \/ /__  _  ______  _____
   / /_/ / / _ \| |/_/ __ \/ ___/
@@ -20,19 +33,13 @@ if [[ "$ANTHROPIC_BASE_URL" == *"plexor"* ]]; then
 /_/   /_/\___/_/|_|\____/_/
 
 EOF
-    echo -e "${NC}"
-
-    # Show status
-    CONFIG_FILE="$HOME/.plexor/config.json"
-    if [ -f "$CONFIG_FILE" ]; then
-        ENABLED=$(jq -r '.settings.enabled // false' "$CONFIG_FILE" 2>/dev/null)
-        MODE=$(jq -r '.settings.mode // "balanced"' "$CONFIG_FILE" 2>/dev/null)
-
-        if [ "$ENABLED" = "true" ]; then
-            echo -e "${GREEN}●${NC} Optimization: ${GREEN}Active${NC} (${MODE} mode)"
-        else
-            echo -e "${YELLOW}○${NC} Optimization: ${DIM}Disabled${NC}"
-        fi
+        echo -e "${NC}"
+        echo -e "${GREEN}●${NC} Hypervisor Mode: ${GREEN}Active${NC}"
+        echo -e "   Gateway: ${DIM}${ANTHROPIC_BASE_URL}${NC}"
+        echo -e "   Mode: ${MODE}"
+        echo ""
+    else
+        echo -e "${YELLOW}○${NC} Plexor: ${DIM}Disabled${NC} (run /plexor-login to enable)"
         echo ""
     fi
 fi

package/scripts/postinstall.js

@@ -11,23 +11,49 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+/**
+ * Get the correct home directory, accounting for sudo.
+ * When running with sudo, os.homedir() returns /root, but we want
+ * the actual user's home directory.
+ */
+function getHomeDir() {
+  // Check if running with sudo - SUDO_USER contains the original username
+  if (process.env.SUDO_USER) {
+    // On Linux/Mac, home directories are typically /home/<user> or /Users/<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);
+    }
+  }
+  return os.homedir();
+}
+
+const HOME_DIR = getHomeDir();
 const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
-const CLAUDE_COMMANDS_DIR = path.join(os.homedir(), '.claude', 'commands');
-const PLEXOR_CONFIG_DIR = path.join(os.homedir(), '.plexor');
+const CLAUDE_COMMANDS_DIR = path.join(HOME_DIR, '.claude', 'commands');
+const PLEXOR_PLUGINS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'commands');
+const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
 
 function main() {
   try {
     // Create ~/.claude/commands/ if not exists
     fs.mkdirSync(CLAUDE_COMMANDS_DIR, { recursive: true });
 
+    // Create ~/.claude/plugins/plexor/commands/ for JS executors
+    fs.mkdirSync(PLEXOR_PLUGINS_DIR, { recursive: true });
+
     // Create ~/.plexor/ with secure permissions (owner only)
     fs.mkdirSync(PLEXOR_CONFIG_DIR, { recursive: true, mode: 0o700 });
 
-    // Get list of command files
-    const files = fs.readdirSync(COMMANDS_SOURCE)
+    // Get list of command files (.md for Claude, .js for executors)
+    const mdFiles = fs.readdirSync(COMMANDS_SOURCE)
       .filter(f => f.endsWith('.md'));
+    const jsFiles = fs.readdirSync(COMMANDS_SOURCE)
+      .filter(f => f.endsWith('.js'));
 
-    if (files.length === 0) {
+    if (mdFiles.length === 0) {
       console.error('No command files found in package. Installation may be corrupt.');
       process.exit(1);
     }
@@ -35,7 +61,8 @@ function main() {
     const installed = [];
     const backed_up = [];
 
-    for (const file of files) {
+    // Copy .md command files to ~/.claude/commands/
+    for (const file of mdFiles) {
       const src = path.join(COMMANDS_SOURCE, file);
       const dest = path.join(CLAUDE_COMMANDS_DIR, file);
 
@@ -55,6 +82,17 @@ function main() {
       installed.push(file.replace('.md', ''));
     }
 
+    // Copy .js executor files to ~/.claude/plugins/plexor/commands/
+    const jsInstalled = [];
+    for (const file of jsFiles) {
+      const src = path.join(COMMANDS_SOURCE, file);
+      const dest = path.join(PLEXOR_PLUGINS_DIR, file);
+      fs.copyFileSync(src, dest);
+      // Make executable
+      fs.chmodSync(dest, 0o755);
+      jsInstalled.push(file);
+    }
+
     // Print success message
     console.log('');
     console.log('  ╔═══════════════════════════════════════════════════════════╗');
@@ -74,6 +112,12 @@ function main() {
       backed_up.forEach(f => console.log(`    ${f}`));
     }
 
+    if (jsInstalled.length > 0) {
+      console.log('');
+      console.log('  Executors installed to ~/.claude/plugins/plexor/commands/:');
+      jsInstalled.forEach(f => console.log(`    ${f}`));
+    }
+
     console.log('');
     console.log('  Next steps:');
     console.log('    1. Open Claude Code');