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

package/hooks/intercept.js

@@ -12,6 +12,19 @@
 
 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;
@@ -162,6 +175,8 @@ async function main() {
     const baseUrl = process.env.ANTHROPIC_BASE_URL || '';
     if (baseUrl.includes('plexor')) {
       logger.debug('Plexor proxy detected via ANTHROPIC_BASE_URL, passing through');
+      // Note: Don't add _plexor metadata here - the proxy will add its own
+      // This passthrough is transparent to avoid double-processing
       return output(request);
     }
 
@@ -175,6 +190,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 +208,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 +226,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 +239,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 +284,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 +349,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 +366,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 +519,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.17",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
   "scripts": {