@plexor-dev/claude-code-plugin-staging 0.1.0-beta.2 → 0.1.0-beta.21

package/commands/plexor-uninstall.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Uninstall Command (STAGING)
+ *
+ * Comprehensive cleanup before npm uninstall.
+ *
+ * CRITICAL: npm's preuninstall hook does NOT run for global package uninstalls.
+ * Users MUST run this command BEFORE running npm uninstall -g.
+ *
+ * This command:
+ * 1. Removes Plexor routing from ~/.claude/settings.json
+ * 2. Removes slash command .md files from ~/.claude/commands/
+ * 3. Removes plugin directory ~/.claude/plugins/plexor/
+ * 4. Optionally removes ~/.plexor/ config directory
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// 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);
+    }
+  }
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+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 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
+ */
+function loadSettingsManager() {
+  // Try plugin dir first (installed location)
+  try {
+    const pluginLib = path.join(CLAUDE_PLUGINS_DIR, 'lib', 'settings-manager.js');
+    if (fs.existsSync(pluginLib)) {
+      const lib = require(pluginLib);
+      return lib.settingsManager;
+    }
+  } catch {
+    // Continue to fallback
+  }
+
+  // Try package lib (during npm lifecycle)
+  try {
+    const lib = require('../lib/settings-manager');
+    return lib.settingsManager;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Disable Plexor routing in Claude settings manually
+ * Fallback when settings-manager is not available
+ */
+function disableRoutingManually() {
+  const settingsPath = path.join(CLAUDE_DIR, 'settings.json');
+
+  try {
+    if (!fs.existsSync(settingsPath)) {
+      return { success: true, message: 'Settings file does not exist' };
+    }
+
+    const data = fs.readFileSync(settingsPath, 'utf8');
+    if (!data || data.trim() === '') {
+      return { success: true, message: 'Settings file is empty' };
+    }
+
+    const settings = JSON.parse(data);
+
+    if (!settings.env) {
+      return { success: true, message: 'No env block in settings' };
+    }
+
+    const isManagedGatewayUrl = (baseUrl = '') =>
+      baseUrl.includes('plexor') ||
+      baseUrl.includes('staging.api') ||
+      baseUrl.includes('localhost') ||
+      baseUrl.includes('127.0.0.1') ||
+      baseUrl.includes('ngrok') ||
+      baseUrl.includes('localtunnel');
+    const isPlexorApiKey = (value = '') =>
+      typeof value === 'string' && value.startsWith('plx_');
+
+    const hasManagedBaseUrl = isManagedGatewayUrl(settings.env.ANTHROPIC_BASE_URL || '');
+    const hasPlexorAuthToken = isPlexorApiKey(settings.env.ANTHROPIC_AUTH_TOKEN || '');
+    const hasPlexorApiKey = isPlexorApiKey(settings.env.ANTHROPIC_API_KEY || '');
+
+    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey) {
+      return { success: true, message: 'Plexor routing not active' };
+    }
+
+    if (hasManagedBaseUrl) {
+      delete settings.env.ANTHROPIC_BASE_URL;
+    }
+    if (hasPlexorAuthToken) {
+      delete settings.env.ANTHROPIC_AUTH_TOKEN;
+    }
+    if (hasPlexorApiKey) {
+      delete settings.env.ANTHROPIC_API_KEY;
+    }
+
+    if (!settings.env.ANTHROPIC_API_KEY && settings.env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY) {
+      settings.env.ANTHROPIC_API_KEY = settings.env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY;
+    }
+    if (!settings.env.ANTHROPIC_AUTH_TOKEN && settings.env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN) {
+      settings.env.ANTHROPIC_AUTH_TOKEN = settings.env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN;
+    }
+
+    delete settings.env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY;
+    delete settings.env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN;
+
+    // Clean up empty env block
+    if (Object.keys(settings.env).length === 0) {
+      delete settings.env;
+    }
+
+    // Atomic write
+    const crypto = require('crypto');
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(CLAUDE_DIR, `.settings.${tempId}.tmp`);
+
+    fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, settingsPath);
+
+    return { success: true, message: 'Routing disabled' };
+  } catch (err) {
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Remove slash command files
+ */
+function removeSlashCommands() {
+  let removed = 0;
+  let restored = 0;
+
+  for (const cmd of PLEXOR_COMMANDS) {
+    const cmdPath = path.join(CLAUDE_COMMANDS_DIR, cmd);
+    const backupPath = cmdPath + '.backup';
+
+    try {
+      if (fs.existsSync(cmdPath)) {
+        fs.unlinkSync(cmdPath);
+        removed++;
+
+        // Restore backup if exists
+        if (fs.existsSync(backupPath)) {
+          fs.renameSync(backupPath, cmdPath);
+          restored++;
+        }
+      }
+    } catch {
+      // Continue with other files
+    }
+  }
+
+  return { removed, restored };
+}
+
+/**
+ * Remove plugin directory
+ */
+function removePluginDirectory() {
+  try {
+    if (fs.existsSync(CLAUDE_PLUGINS_DIR)) {
+      fs.rmSync(CLAUDE_PLUGINS_DIR, { recursive: true, force: true });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+/**
+ * Remove config directory
+ */
+function removeConfigDirectory() {
+  try {
+    if (fs.existsSync(PLEXOR_CONFIG_DIR)) {
+      fs.rmSync(PLEXOR_CONFIG_DIR, { recursive: true, force: true });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  // Handle help flag
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('');
+    console.log('  Usage: plexor-uninstall [options]');
+    console.log('');
+    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('    --quiet, -q          Suppress output messages');
+    console.log('    --help, -h           Show this help message');
+    console.log('');
+    console.log('  After running this command:');
+    console.log('    npm uninstall -g @plexor-dev/claude-code-plugin-staging');
+    console.log('');
+    process.exit(0);
+  }
+
+  const removeConfig = args.includes('--remove-config') || args.includes('-c');
+  const quiet = args.includes('--quiet') || args.includes('-q');
+
+  if (!quiet) {
+    console.log('');
+    console.log('  Plexor Uninstall (STAGING) - Cleaning up...');
+    console.log('');
+  }
+
+  // 1. Remove routing from ~/.claude/settings.json
+  let routingResult;
+  const settingsManager = loadSettingsManager();
+
+  if (settingsManager) {
+    try {
+      const success = settingsManager.disablePlexorRouting();
+      routingResult = { success, message: success ? 'Routing disabled via manager' : 'Already clean' };
+    } catch (err) {
+      routingResult = disableRoutingManually();
+    }
+  } else {
+    routingResult = disableRoutingManually();
+  }
+
+  if (!quiet) {
+    console.log(routingResult.success
+      ? '  ✓ Removed Plexor routing from Claude settings'
+      : `  ✗ Failed to remove routing: ${routingResult.message}`);
+  }
+
+  // 2. Remove slash command .md files
+  const cmdResult = removeSlashCommands();
+  if (!quiet) {
+    console.log(`  ✓ Removed ${cmdResult.removed} slash command files`);
+    if (cmdResult.restored > 0) {
+      console.log(`  ✓ Restored ${cmdResult.restored} backed-up files`);
+    }
+  }
+
+  // 3. Remove plugin directory
+  const pluginRemoved = removePluginDirectory();
+  if (!quiet) {
+    console.log(pluginRemoved
+      ? '  ✓ Removed plugin directory'
+      : '  ○ Plugin directory not found (already clean)');
+  }
+
+  // 4. Optionally remove config directory
+  if (removeConfig) {
+    const configRemoved = removeConfigDirectory();
+    if (!quiet) {
+      console.log(configRemoved
+        ? '  ✓ Removed ~/.plexor config directory'
+        : '  ○ Config directory not found');
+    }
+  }
+
+  // Show next steps
+  if (!quiet) {
+    console.log('');
+    console.log('  ┌─────────────────────────────────────────────────────────────────┐');
+    console.log('  │  Cleanup complete! Now run:                                     │');
+    console.log('  │                                                                 │');
+    console.log('  │    npm uninstall -g @plexor-dev/claude-code-plugin-staging      │');
+    console.log('  │                                                                 │');
+    console.log('  └─────────────────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('  Your Claude Code is ready to work normally again.');
+    console.log('');
+
+    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('');
+    }
+  }
+}
+
+main();

package/commands/plexor-uninstall.md

@@ -0,0 +1,12 @@
+---
+name: plexor-uninstall
+description: Clean up Plexor integration before uninstalling
+---
+
+**RULE: Execute the bash command below EXACTLY ONCE. After the Bash tool returns output, your ONLY action is to present that output to the user. DO NOT re-execute the command. DO NOT call any other tools.**
+
+**IMPORTANT**: Run this BEFORE `npm uninstall -g @plexor-dev/claude-code-plugin-staging`. Pass `--remove-config` to also remove ~/.plexor/ config directory.
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-uninstall.js $ARGUMENTS 2>&1 || plexor-uninstall $ARGUMENTS 2>&1
+```

package/hooks/intercept.js

@@ -35,6 +35,129 @@ function generateRequestId(prefix = 'pass') {
   return `${prefix}_${timestamp}_${random}`;
 }
 
+const VALID_ORCHESTRATION_MODES = new Set([
+  'supervised',
+  'autonomous',
+  'danger-full-auto'
+]);
+
+const VALID_GATEWAY_MODES = new Set(['eco', 'balanced', 'quality', 'passthrough', 'cost']);
+const VALID_PROVIDER_HINTS = new Set([
+  'auto',
+  'anthropic',
+  'claude',
+  'openai',
+  'deepseek',
+  'mistral',
+  'gemini',
+  'grok',
+  'cohere'
+]);
+
+const DISABLED_MODEL_HINTS = new Set(['auto', 'none', 'off']);
+
+function normalizeOrchestrationMode(mode) {
+  if (typeof mode !== 'string') {
+    return null;
+  }
+  const normalized = mode.trim().toLowerCase();
+  if (!VALID_ORCHESTRATION_MODES.has(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+
+function normalizeGatewayMode(mode) {
+  if (typeof mode !== 'string') {
+    return null;
+  }
+  const normalized = mode.trim().toLowerCase();
+  if (!VALID_GATEWAY_MODES.has(normalized)) {
+    return null;
+  }
+  return normalized === 'cost' ? 'eco' : normalized;
+}
+
+function normalizePreferredProvider(provider) {
+  if (typeof provider !== 'string') {
+    return null;
+  }
+  const normalized = provider.trim().toLowerCase();
+  if (!VALID_PROVIDER_HINTS.has(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+
+function resolveOrchestrationMode(settings) {
+  const envMode = normalizeOrchestrationMode(process.env.PLEXOR_ORCHESTRATION_MODE);
+  if (envMode) {
+    return envMode;
+  }
+  const cfgMode = normalizeOrchestrationMode(
+    settings?.orchestrationMode || settings?.orchestration_mode
+  );
+  return cfgMode || 'autonomous';
+}
+
+function resolveGatewayMode(settings) {
+  const envMode = normalizeGatewayMode(process.env.PLEXOR_MODE);
+  if (envMode) {
+    return envMode;
+  }
+  const cfgMode = normalizeGatewayMode(settings?.mode);
+  return cfgMode || 'balanced';
+}
+
+function resolvePreferredProvider(settings) {
+  const envProvider = normalizePreferredProvider(
+    process.env.PLEXOR_PROVIDER || process.env.PLEXOR_PREFERRED_PROVIDER
+  );
+  if (envProvider) {
+    return envProvider;
+  }
+  const cfgProvider = normalizePreferredProvider(
+    settings?.preferredProvider || settings?.preferred_provider
+  );
+  return cfgProvider || 'auto';
+}
+
+function normalizePreferredModel(model) {
+  if (typeof model !== 'string') {
+    return null;
+  }
+  const trimmed = model.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (DISABLED_MODEL_HINTS.has(trimmed.toLowerCase())) {
+    return null;
+  }
+  return trimmed;
+}
+
+function resolvePreferredModel(settings) {
+  const envModel = normalizePreferredModel(
+    process.env.PLEXOR_MODEL || process.env.PLEXOR_PREFERRED_MODEL
+  );
+  if (envModel) {
+    return envModel;
+  }
+  const cfgModel = normalizePreferredModel(settings?.preferredModel || settings?.preferred_model);
+  return cfgModel || null;
+}
+
+function validateForceHintSelection(preferredProvider, preferredModel) {
+  if (!preferredModel || preferredProvider === 'auto') {
+    return;
+  }
+  const error = new Error(
+    'Invalid Plexor config: force only one hint. Set preferred_provider OR preferred_model, not both.'
+  );
+  error.code = 'PLEXOR_CONFIG_CONFLICT';
+  throw error;
+}
+
 // Try to load lib modules, fall back to inline implementations
 let ConfigManager, SessionManager, LocalCache, Logger, PlexorClient;
 let config, session, cache, logger;
@@ -56,10 +179,25 @@ try {
   const SESSION_PATH = path.join(process.env.HOME || '', '.plexor', 'session.json');
   const SESSION_TIMEOUT_MS = 30 * 60 * 1000;
 
+  const uxMessagesEnabled = !/^(0|false|no|off)$/i.test(
+    String(process.env.PLEXOR_UX_MESSAGES ?? process.env.PLEXOR_UX_DEBUG_MESSAGES ?? 'true')
+  );
+  const CYAN = '\x1b[36m';
+  const RESET = '\x1b[0m';
+  const formatUx = (msg) => {
+    const text = String(msg || '').trim();
+    if (!text) return '[PLEXOR: message]';
+    return text.startsWith('[PLEXOR:') ? text : `[PLEXOR: ${text}]`;
+  };
+
   logger = {
     debug: (msg) => process.env.PLEXOR_DEBUG && console.error(`[DEBUG] ${msg}`),
     info: (msg) => console.error(msg),
-    error: (msg) => console.error(`[ERROR] ${msg}`)
+    error: (msg) => console.error(`[ERROR] ${msg}`),
+    ux: (msg) => {
+      if (!uxMessagesEnabled) return;
+      console.error(`${CYAN}${formatUx(msg)}${RESET}`);
+    }
   };
 
   config = {
@@ -73,7 +211,11 @@ try {
           apiUrl: cfg.settings?.apiUrl || 'https://api.plexor.dev',
           timeout: cfg.settings?.timeout || 5000,
           localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
-          mode: cfg.settings?.mode || 'balanced'
+          mode: cfg.settings?.mode || 'balanced',
+          preferredProvider: cfg.settings?.preferred_provider || 'auto',
+          preferredModel: cfg.settings?.preferredModel || cfg.settings?.preferred_model || null,
+          orchestrationMode:
+            cfg.settings?.orchestrationMode || cfg.settings?.orchestration_mode || 'autonomous'
         };
       } catch {
         return { enabled: false };
@@ -106,9 +248,9 @@ try {
   const saveSession = (s) => {
     try {
       const dir = path.dirname(SESSION_PATH);
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
       s.last_activity = Date.now();
-      fs.writeFileSync(SESSION_PATH, JSON.stringify(s, null, 2));
+      fs.writeFileSync(SESSION_PATH, JSON.stringify(s, null, 2), { mode: 0o600 });
     } catch {}
   };
 
@@ -179,52 +321,69 @@ async function main() {
     input = await readStdin();
     request = JSON.parse(input);
 
+    // Issue #2042: Check for slash commands FIRST, before ANY other processing
+    // Slash commands must pass through completely clean — no metadata injection
+    // Adding _plexor_client or _plexor to slash command requests adds context noise
+    // that causes the model to re-execute commands in a loop
+    // Note: session.recordPassthrough() intentionally omitted — slash commands are
+    // not API requests and should not pollute session analytics
+    if (isSlashCommand(request)) {
+      logger.debug('Slash command detected, clean passthrough (no metadata)');
+      logger.ux('Slash command passthrough (no optimization applied)');
+      return output(request);  // Completely clean — no metadata added
+    }
+
+    const settings = await config.load();
+    const orchestrationMode = resolveOrchestrationMode(settings);
+    const gatewayMode = resolveGatewayMode(settings);
+    const preferredProvider = resolvePreferredProvider(settings);
+    const preferredModel = resolvePreferredModel(settings);
+    validateForceHintSelection(preferredProvider, preferredModel);
+
     // 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 || '';
-    const isHypervisorMode = baseUrl.includes('plexor') || baseUrl.includes('staging.api');
+    const isHypervisorMode =
+      baseUrl.includes('plexor') ||
+      baseUrl.includes('staging.api') ||
+      baseUrl.includes('localhost') ||
+      baseUrl.includes('127.0.0.1');
 
     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');
+      logger.debug('Hypervisor mode active - server handles all optimization');
+      logger.ux(
+        `Hypervisor mode active (${gatewayMode}/${orchestrationMode}); routing handled server-side`
+      );
 
       // Add session tracking metadata (server will use this for analytics)
       return output({
         ...request,
+        ...(preferredModel ? { model: preferredModel } : {}),
+        plexor_mode: gatewayMode,
+        ...(preferredProvider !== 'auto' ? { plexor_provider: preferredProvider } : {}),
+        plexor_orchestration_mode: orchestrationMode,
         _plexor_client: {
+          ...(request._plexor_client || {}),
           mode: 'hypervisor',
           plugin_version: '0.1.0-beta.18',
+          orchestration_mode: orchestrationMode,
+          plexor_mode: gatewayMode,
+          preferred_provider: preferredProvider,
+          preferred_model: preferredModel,
           cwd: process.cwd(),
           timestamp: Date.now(),
         }
       });
     }
 
-    // CRITICAL: Check for slash commands FIRST (before agentic check)
-    // Slash commands like /plexor-status should pass through unchanged
-    // Must check before isAgenticRequest since all Claude Code requests have tools
-    if (isSlashCommand(request)) {
-      logger.debug('Slash command detected, passing through unchanged');
-      session.recordPassthrough();
-      return output({
-        ...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(),
-          latency_ms: Date.now() - startTime
-        }
-      });
-    }
-
     // CRITICAL: Skip optimization for CLI commands requiring tool execution
     // Azure CLI, AWS CLI, kubectl, etc. need tools to be preserved
     if (requiresToolExecution(request)) {
       logger.debug('CLI tool execution detected, passing through unchanged');
+      logger.ux('Tool-execution request detected; preserving tools via passthrough');
       session.recordPassthrough();
       return output({
         ...request,
@@ -243,6 +402,7 @@ async function main() {
     // Modifying messages breaks the agent loop and causes infinite loops
     if (isAgenticRequest(request)) {
       logger.debug('Agentic request detected, passing through unchanged');
+      logger.ux('Agentic/tool-use request detected; passthrough to avoid loop breakage');
       session.recordPassthrough();
       return output({
         ...request,
@@ -257,10 +417,9 @@ async function main() {
       });
     }
 
-    const settings = await config.load();
-
     if (!settings.enabled) {
       logger.debug('Plexor disabled, passing through');
+      logger.ux('Plexor plugin is disabled; forwarding request unchanged');
       session.recordPassthrough();
       return output({
         ...request,
@@ -275,6 +434,7 @@ async function main() {
 
     if (!settings.apiKey) {
       logger.info('Not authenticated. Run /plexor-login to enable optimization.');
+      logger.ux('Not authenticated. Run /plexor-login to enable Plexor routing');
       session.recordPassthrough();
       return output({
         ...request,
@@ -301,7 +461,8 @@ async function main() {
     const cachedResponse = await cache.get(cacheKey);
 
     if (cachedResponse && settings.localCacheEnabled) {
-      logger.info('[Plexor] Local cache hit');
+      logger.info('Local cache hit');
+      logger.ux('Local cache hit');
       session.recordCacheHit();
       return output({
         ...request,
@@ -329,10 +490,16 @@ async function main() {
 
     const savingsPercent = ((result.original_tokens - result.optimized_tokens) / result.original_tokens * 100).toFixed(1);
 
-    logger.info(`[Plexor] Optimized: ${result.original_tokens} → ${result.optimized_tokens} tokens (${savingsPercent}% saved)`);
+    logger.info(`Optimized: ${result.original_tokens} → ${result.optimized_tokens} tokens (${savingsPercent}% saved)`);
+    logger.ux(
+      `Optimized ${result.original_tokens} -> ${result.optimized_tokens} tokens (${savingsPercent}% saved)`
+    );
 
     if (result.recommended_provider !== 'anthropic') {
-      logger.info(`[Plexor] Recommended: ${result.recommended_provider} (~$${result.estimated_cost.toFixed(4)})`);
+      logger.info(`Recommended: ${result.recommended_provider} (~$${result.estimated_cost.toFixed(4)})`);
+      logger.ux(
+        `Provider recommendation: ${result.recommended_provider} (~$${result.estimated_cost.toFixed(4)})`
+      );
     }
 
     const optimizedRequest = {
@@ -368,7 +535,15 @@ async function main() {
     return output(optimizedRequest);
 
   } catch (error) {
-    logger.error(`[Plexor] Error: ${error.message}`);
+    if (error?.code === 'PLEXOR_CONFIG_CONFLICT') {
+      logger.error(`Configuration error: ${error.message}`);
+      logger.ux(error.message);
+      process.stderr.write(`\n[Plexor] ${error.message}\n`);
+      process.exit(1);
+    }
+
+    logger.error(`Error: ${error.message}`);
+    logger.ux(`Optimization hook error: ${error.message}`);
     logger.debug(error.stack);
 
     const errorRequestId = generateRequestId('error');  // Issue #701: Add request_id for tracking
@@ -578,12 +753,16 @@ function isSlashCommand(request) {
   }
 
   // Check for system messages with skill instructions
+  // Issue #2042: Updated to match new RULE-based .md format (old H1 headers removed)
   for (const msg of messages) {
     if (msg.role === 'system') {
       const content = typeof msg.content === 'string' ? msg.content : '';
       if (/# Plexor (?:Status|Login|Logout|Mode|Provider|Enabled|Settings)/i.test(content)) {
         return true;
       }
+      if (/plexor\/commands\/plexor-/i.test(content)) {
+        return true;
+      }
     }
   }
 
@@ -629,6 +808,6 @@ function requiresToolExecution(request) {
 }
 
 main().catch((error) => {
-  console.error(`[Plexor] Fatal error: ${error.message}`);
+  console.error(`\x1b[1m\x1b[37m\x1b[41m PLEXOR \x1b[0m \x1b[31mFatal: ${error.message}\x1b[0m`);
   process.exit(1);
 });