@plexor-dev/claude-code-plugin-staging 0.1.0-beta.27 → 0.1.0-beta.29

package/hooks/track-response.js

@@ -17,7 +17,7 @@
 const path = require('path');
 
 // Use lib modules
-let ConfigManager, SessionManager, LocalCache, Logger, ServerSync;
+let ConfigManager, SessionManager, LocalCache, Logger, ServerSync, SupervisorEmitter;
 try {
   ConfigManager = require('../lib/config');
   SessionManager = require('../lib/session');
@@ -26,6 +26,8 @@ try {
   // Issue #701: Phase 2 - Server sync for persistent session state
   const serverSyncModule = require('../lib/server-sync');
   ServerSync = serverSyncModule.getServerSync;
+  // Phase 1 supervisor UX
+  SupervisorEmitter = require('../lib/supervisor').SupervisorEmitter;
 } catch {
   // Fallback inline implementations if lib not found
   const fs = require('fs');
@@ -171,12 +173,18 @@ try {
     scheduleSync: () => {},
     needsSync: () => false
   });
+
+  // Fallback SupervisorEmitter (no-op)
+  SupervisorEmitter = class {
+    emit() {}
+  };
 }
 
 const logger = new Logger('track-response');
 const config = new ConfigManager();
 const cache = new LocalCache();
 const session = new SessionManager();
+const supervisor = new SupervisorEmitter();
 
 // Issue #701: Phase 2 - Initialize server sync (lazy, initialized on first use)
 let serverSync = null;
@@ -189,7 +197,7 @@ async function getServerSync() {
     if (settings.apiKey && settings.enabled) {
       serverSync = ServerSync({
         apiKey: settings.apiKey,
-        baseUrl: settings.apiUrl || 'https://api.plexor.dev',
+        baseUrl: settings.apiUrl || 'http://127.0.0.1:8000',
         enabled: settings.serverSyncEnabled !== false
       });
     } else {
@@ -221,6 +229,11 @@ async function main() {
     const plexorMeta = response._plexor;
     emitPlexorOutcomeSummary(response, plexorMeta, outputTokens);
 
+    // Phase 1 supervisor UX: concise single-line routing summary
+    supervisor.emit(response, plexorMeta);
+
+    // Context warnings now handled by supervisor.emit() (Phase 5) to avoid duplicates
+
     // Issue #701: Track ALL responses, not just when enabled
     // This ensures session stats are always accurate
     if (plexorMeta) {
@@ -674,3 +687,29 @@ function emitPlexorOutcomeSummary(response, plexorMeta, outputTokens) {
     logger.ux(msg);
   }
 }
+
+/**
+ * Proactive compact warning: emit context-size alerts at 70K and 80K prompt tokens.
+ * Uses the per-request prompt token count (usage.input_tokens / usage.prompt_tokens)
+ * which represents the current context window size for that call.
+ */
+function emitCompactWarning(response, plexorMeta) {
+  if (!logger || typeof logger.ux !== 'function') return;
+
+  const promptTokens =
+    toNumber(response?.plexor_prompt_tokens) ??
+    toNumber(response?.usage?.input_tokens) ??
+    toNumber(response?.usage?.prompt_tokens) ??
+    toNumber(plexorMeta?.optimized_tokens) ??
+    null;
+
+  if (promptTokens === null || promptTokens < 70000) return;
+
+  const tokensK = Math.round(promptTokens / 1000);
+
+  if (promptTokens >= 80000) {
+    logger.ux(`\u26a0 Context at ${tokensK}K tokens \u2014 recommend /compact to prevent errors`);
+  } else {
+    logger.ux(`Context at ${tokensK}K tokens \u2014 approaching provider limits`);
+  }
+}

package/lib/supervisor.js

@@ -1,5 +1,5 @@
 /**
- * Plexor Supervisor Emitter — Phases 1-4
+ * Plexor Supervisor Emitter — Phases 1-5
  *
  * Phase 1: Basic routing summary
  *   [PLEXOR: Routed to {provider}/{model}, {latency}ms, {routing_source}]
@@ -13,15 +13,31 @@
  * Phase 4: Scaffolding gate blocked detection
  *   [PLEXOR: Scaffolding gate: {model} blocked, using {alternative}]
  *
+ * Phase 5: Session narration — cumulative tokens, cost, provider reliability,
+ *   context warnings, auto-compact suggestions
+ *   [PLEXOR: Session: 12 turns, $0.42 cost, 45K tokens]
+ *   [PLEXOR: Provider reliability (last 5): DeepSeek 4/5 tool_calls, Gemini 1/5]
+ *   [PLEXOR: Context at 72K tokens — approaching provider limits]
+ *   [PLEXOR: Context at 82K — recommend /compact to prevent errors]
+ *
  * This module is consumed by track-response.js to surface routing
  * decisions to the developer without requiring them to parse verbose logs.
  */
 
+const fs = require('fs');
+const path = require('path');
+
 const CYAN = '\x1b[36m';
 const YELLOW = '\x1b[33m';
 const RED = '\x1b[31m';
+const MAGENTA = '\x1b[35m';
 const RESET = '\x1b[0m';
 
+const CONTEXT_WARNING_THRESHOLD = 70000;
+const CONTEXT_COMPACT_THRESHOLD = 80000;
+const SESSION_STATE_PATH = path.join(process.env.HOME || '', '.plexor', 'supervisor-session.json');
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 min — start fresh if idle
+
 class SupervisorEmitter {
   /**
    * @param {object} [opts]
@@ -34,6 +50,55 @@ class SupervisorEmitter {
     } else {
       this.enabled = opts.enabled !== false;
     }
+
+    // Phase 5: Session-level state — restored from disk across hook invocations
+    this._loadSessionState();
+  }
+
+  /**
+   * Load persisted session state from disk. Resets if stale (>30 min idle).
+   */
+  _loadSessionState() {
+    try {
+      const raw = fs.readFileSync(SESSION_STATE_PATH, 'utf8');
+      const state = JSON.parse(raw);
+      const lastTs = state.lastTimestamp || 0;
+      if (Date.now() - lastTs > SESSION_TIMEOUT_MS) {
+        // Session expired — start fresh
+        this._resetSessionState();
+        return;
+      }
+      this._turnCount = state.turnCount || 0;
+      this._contextTokens = state.contextTokens || 0; // current context window size
+      this._cumulativeCost = state.cumulativeCost || 0;
+      this._providerHistory = state.providerHistory || [];
+    } catch {
+      this._resetSessionState();
+    }
+  }
+
+  _resetSessionState() {
+    this._turnCount = 0;
+    this._contextTokens = 0;
+    this._cumulativeCost = 0;
+    this._providerHistory = [];
+  }
+
+  /**
+   * Persist session state to disk for cross-process continuity.
+   */
+  _saveSessionState() {
+    try {
+      const dir = path.dirname(SESSION_STATE_PATH);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(SESSION_STATE_PATH, JSON.stringify({
+        turnCount: this._turnCount,
+        contextTokens: this._contextTokens,
+        cumulativeCost: this._cumulativeCost,
+        providerHistory: this._providerHistory.slice(-20), // keep last 20
+        lastTimestamp: Date.now(),
+      }));
+    } catch { /* best-effort persistence */ }
   }
 
   /**
@@ -201,6 +266,9 @@ class SupervisorEmitter {
       return;
     }
 
+    // Phase 5: Accumulate session state before emitting
+    this._accumulateSessionState(response, plexorMeta);
+
     // Phase 4: Scaffolding gate (highest priority — emit first if present)
     const scaffoldingNotice = this.buildScaffoldingGateNotice(response, plexorMeta);
     if (scaffoldingNotice) {
@@ -218,8 +286,134 @@ class SupervisorEmitter {
     if (summary) {
       process.stderr.write(`${CYAN}${summary}${RESET}\n`);
     }
+
+    // Phase 5: Session narration (after per-turn messages)
+    this._emitSessionNarration();
+  }
+
+  // ---- Phase 5: session narration ----
+
+  /**
+   * Accumulate per-turn data into session state.
+   * Called at the start of emit() so all session fields are current
+   * before any Phase 5 messages are built.
+   */
+  _accumulateSessionState(response, plexorMeta) {
+    this._turnCount++;
+
+    // Context window size — prompt_tokens IS the current context size (not cumulative).
+    // Each turn's prompt_tokens includes the full conversation context.
+    const usage = response?.usage || response?.plexor?.usage || {};
+    const promptTokens = Number(usage.prompt_tokens) || 0;
+    if (promptTokens > 0) {
+      this._contextTokens = promptTokens; // replace, not accumulate
+    }
+
+    // Cumulative cost
+    const costUsd = Number(
+      response?.plexor_cost_usd ??
+      response?.plexor?.cost_usd ??
+      plexorMeta?.cost_usd ??
+      0
+    );
+    if (Number.isFinite(costUsd)) {
+      this._cumulativeCost += costUsd;
+    }
+
+    // Provider reliability tracking
+    const provider = this._resolveProvider(response, plexorMeta);
+    if (provider) {
+      const stopReason =
+        response?.stop_reason ||
+        response?.choices?.[0]?.finish_reason ||
+        response?.plexor?.stop_reason ||
+        null;
+      this._providerHistory.push({
+        provider,
+        hadToolCalls: stopReason === 'tool_use' || stopReason === 'tool_calls',
+      });
+    }
+  }
+
+  /**
+   * Emit session-level narration lines based on accumulated state.
+   */
+  _emitSessionNarration() {
+    // Session summary line — every turn
+    const tokenStr = this._formatTokenCount(this._contextTokens);
+    const costStr = this._cumulativeCost < 0.01
+      ? `$${this._cumulativeCost.toFixed(4)}`
+      : `$${this._cumulativeCost.toFixed(2)}`;
+    process.stderr.write(
+      `${MAGENTA}[PLEXOR: Session: ${this._turnCount} turns, ${costStr} cost, ${tokenStr} context]${RESET}\n`
+    );
+
+    // Provider reliability digest — every 5th turn
+    if (this._turnCount % 5 === 0 && this._providerHistory.length > 0) {
+      const digest = this._buildProviderReliabilityDigest();
+      if (digest) {
+        process.stderr.write(`${MAGENTA}${digest}${RESET}\n`);
+      }
+    }
+
+    // Context warning at 70K tokens (uses real context window size, not cumulative)
+    if (this._contextTokens >= CONTEXT_COMPACT_THRESHOLD) {
+      const kTokens = Math.round(this._contextTokens / 1000);
+      process.stderr.write(
+        `${YELLOW}[PLEXOR: Context at ${kTokens}K \u2014 recommend /compact to prevent errors]${RESET}\n`
+      );
+    } else if (this._contextTokens >= CONTEXT_WARNING_THRESHOLD) {
+      const kTokens = Math.round(this._contextTokens / 1000);
+      process.stderr.write(
+        `${YELLOW}[PLEXOR: Context at ${kTokens}K tokens \u2014 approaching provider limits]${RESET}\n`
+      );
+    }
+
+    // Persist state for next hook invocation
+    this._saveSessionState();
   }
 
+  /**
+   * Build provider reliability digest from the last 5 entries in history.
+   * Format: [PLEXOR: Provider reliability (last 5): DeepSeek 4/5 tool_calls, Gemini 1/5]
+   */
+  _buildProviderReliabilityDigest() {
+    const recent = this._providerHistory.slice(-5);
+    const totals = {};
+    const toolHits = {};
+
+    for (const entry of recent) {
+      const p = entry.provider;
+      totals[p] = (totals[p] || 0) + 1;
+      if (entry.hadToolCalls) {
+        toolHits[p] = (toolHits[p] || 0) + 1;
+      }
+    }
+
+    const parts = Object.keys(totals).map(p => {
+      const hits = toolHits[p] || 0;
+      return `${p}: ${hits}/${totals[p]} tool_calls`;
+    });
+
+    if (parts.length === 0) return null;
+    return `[PLEXOR: Provider reliability (last 5): ${parts.join(', ')}]`;
+  }
+
+  /**
+   * Format token count: 1234 -> "1.2K", 123456 -> "123K"
+   */
+  _formatTokenCount(tokens) {
+    if (tokens < 1000) return String(tokens);
+    if (tokens < 10000) return `${(tokens / 1000).toFixed(1)}K`;
+    return `${Math.round(tokens / 1000)}K`;
+  }
+
+  // ---- Phase 5 accessors (for testing) ----
+
+  get turnCount() { return this._turnCount; }
+  get cumulativeTokens() { return this._contextTokens; }
+  get cumulativeCost() { return this._cumulativeCost; }
+
   // ---- private helpers ----
 
   _resolveProvider(response, meta) {

package/package.json

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