@plexor-dev/claude-code-plugin-staging 0.1.0-beta.13 → 0.1.0-beta.15

package/commands/plexor-agent.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Agent — set agent autonomy level.
+ *
+ * Agent modes control how the AI agent behaves:
+ *   supervised:         Agent describes actions, waits for your confirmation
+ *   autonomous:         Agent acts independently within safe bounds (default)
+ *   danger-full-auto:   Full autonomy, no guardrails — forces tool execution
+ *
+ * Usage:
+ *   /plexor-agent                      Show current agent mode
+ *   /plexor-agent supervised           Confirm before every action
+ *   /plexor-agent autonomous           Smart autonomy (default)
+ *   /plexor-agent danger-full-auto     No guardrails
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+const VALID = ['supervised', 'autonomous', 'danger-full-auto'];
+const DESC = {
+  supervised:         'Confirm before acting',
+  autonomous:         'Acts within safe bounds (default)',
+  'danger-full-auto': 'Full autonomy, no guardrails'
+};
+const ALIASES = {
+  auto: 'autonomous',
+  fullauto: 'danger-full-auto',
+  'full-auto': 'danger-full-auto',
+  full_auto: 'danger-full-auto',
+  danger: 'danger-full-auto'
+};
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const current = readSetting(config, 'orchestrationMode', 'orchestration_mode', 'PLEXOR_ORCHESTRATION_MODE', VALID, 'autonomous');
+
+  if (args.length === 0) {
+    console.log(`Agent Mode: ${current.value} (${current.source})`);
+    console.log(`  ${DESC[current.value]}`);
+    console.log('');
+    console.log('Options:');
+    for (const v of VALID) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(20)} ${DESC[v]}`);
+    }
+    console.log('');
+    console.log('Set: /plexor-agent <mode>');
+    return;
+  }
+
+  let requested = args[0].toLowerCase().trim();
+  if (ALIASES[requested]) requested = ALIASES[requested];
+
+  if (!VALID.includes(requested)) {
+    console.error(`Invalid agent mode: "${args[0]}"`);
+    console.error(`Valid: ${VALID.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (current.source === 'environment' && requested !== current.value) {
+    console.log(`Warning: PLEXOR_ORCHESTRATION_MODE env var is set to "${current.value}". Config updated but env var takes priority.`);
+  }
+
+  if (requested === current.value && current.source === 'config') {
+    console.log(`Already set to "${requested}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.orchestrationMode = requested;
+  if (config.settings.orchestration_mode) delete config.settings.orchestration_mode;
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`Agent mode: ${current.value} → ${requested}`);
+  console.log(`  ${DESC[requested]}`);
+  if (requested === 'danger-full-auto') {
+    console.log('  Warning: This forces tool execution on every turn with tools.');
+  }
+  console.log('  Takes effect on next request.');
+}
+
+main();

package/commands/plexor-agent.md

@@ -0,0 +1,11 @@
+---
+description: Set Plexor agent autonomy — supervised, autonomous, or danger-full-auto (user)
+---
+
+**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.**
+
+Show current agent mode (no args) or set it (supervised, autonomous, danger-full-auto).
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-agent.js $ARGUMENTS
+```

package/commands/plexor-provider.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Provider — select which LLM provider to use.
+ *
+ * Provider options:
+ *   auto:       Best model for task (router decides, default)
+ *   anthropic:  Claude (Anthropic)
+ *   openai:     GPT (OpenAI)
+ *   deepseek:   DeepSeek
+ *   mistral:    Mistral
+ *   gemini:     Gemini (Google)
+ *   grok:       Grok (xAI)
+ *   cohere:     Command-R (Cohere)
+ *
+ * Usage:
+ *   /plexor-provider              Show current provider
+ *   /plexor-provider auto         Let router decide (default)
+ *   /plexor-provider anthropic    Force Claude
+ *   /plexor-provider openai       Force GPT
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+const VALID = ['auto', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini', 'grok', 'cohere'];
+const DESC = {
+  auto:      'Best model for task (router decides)',
+  anthropic: 'Claude (Anthropic)',
+  openai:    'GPT (OpenAI)',
+  deepseek:  'DeepSeek',
+  mistral:   'Mistral',
+  gemini:    'Gemini (Google)',
+  grok:      'Grok (xAI)',
+  cohere:    'Command-R (Cohere)'
+};
+const ALIASES = { claude: 'anthropic' };
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const current = readSetting(config, 'preferred_provider', null, 'PLEXOR_PROVIDER', VALID, 'auto');
+
+  if (args.length === 0) {
+    console.log(`Provider: ${current.value} (${current.source})`);
+    console.log(`  ${DESC[current.value]}`);
+    console.log('');
+    console.log('Options:');
+    for (const v of VALID) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(12)} ${DESC[v]}`);
+    }
+    console.log('');
+    console.log('Set: /plexor-provider <name>');
+    return;
+  }
+
+  let requested = args[0].toLowerCase().trim();
+  if (ALIASES[requested]) requested = ALIASES[requested];
+
+  if (!VALID.includes(requested)) {
+    console.error(`Invalid provider: "${args[0]}"`);
+    console.error(`Valid: ${VALID.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (current.source === 'environment' && requested !== current.value) {
+    console.log(`Warning: PLEXOR_PROVIDER env var is set to "${current.value}". Config updated but env var takes priority.`);
+  }
+
+  if (requested === current.value && current.source === 'config') {
+    console.log(`Already set to "${requested}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.preferred_provider = requested;
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`Provider: ${current.value} → ${requested}`);
+  console.log(`  ${DESC[requested]}`);
+  console.log('  Takes effect on next request.');
+}
+
+main();

package/commands/plexor-provider.md

@@ -0,0 +1,11 @@
+---
+description: Set Plexor LLM provider — auto, anthropic, openai, deepseek, gemini, etc. (user)
+---
+
+**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.**
+
+Show current provider (no args) or set it (auto, anthropic, openai, deepseek, mistral, gemini, grok, cohere).
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js $ARGUMENTS
+```

package/commands/plexor-routing.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Routing — set the cost/quality routing mode.
+ *
+ * Routing modes control how aggressively Plexor optimizes for cost:
+ *   eco:         60-90% savings, cheapest models
+ *   balanced:    40-60% savings, good balance (default)
+ *   quality:     20-40% savings, premium models
+ *   passthrough: No optimization, direct to provider
+ *
+ * Usage:
+ *   /plexor-routing              Show current routing mode
+ *   /plexor-routing eco          Set to eco (maximum savings)
+ *   /plexor-routing balanced     Set to balanced
+ *   /plexor-routing quality      Set to quality
+ *   /plexor-routing passthrough  Set to passthrough (no optimization)
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+const VALID = ['eco', 'balanced', 'quality', 'passthrough'];
+const DESC = {
+  eco:         '60-90% savings, cheapest models',
+  balanced:    '40-60% savings, good balance',
+  quality:     '20-40% savings, premium models',
+  passthrough: 'No optimization, direct to provider'
+};
+const ALIASES = { cost: 'eco' };
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const current = readSetting(config, 'mode', null, 'PLEXOR_MODE', VALID, 'balanced');
+
+  if (args.length === 0) {
+    console.log(`Routing Mode: ${current.value} (${current.source})`);
+    console.log(`  ${DESC[current.value]}`);
+    console.log('');
+    console.log('Options:');
+    for (const v of VALID) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(14)} ${DESC[v]}`);
+    }
+    console.log('');
+    console.log('Set: /plexor-routing <mode>');
+    return;
+  }
+
+  let requested = args[0].toLowerCase().trim();
+  if (ALIASES[requested]) requested = ALIASES[requested];
+
+  if (!VALID.includes(requested)) {
+    console.error(`Invalid routing mode: "${args[0]}"`);
+    console.error(`Valid: ${VALID.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (current.source === 'environment' && requested !== current.value) {
+    console.log(`Warning: PLEXOR_MODE env var is set to "${current.value}". Config updated but env var takes priority.`);
+  }
+
+  if (requested === current.value && current.source === 'config') {
+    console.log(`Already set to "${requested}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.mode = requested;
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`Routing mode: ${current.value} → ${requested}`);
+  console.log(`  ${DESC[requested]}`);
+  console.log('  Takes effect on next request.');
+}
+
+main();

package/commands/plexor-routing.md

@@ -0,0 +1,11 @@
+---
+description: Set Plexor routing mode — eco, balanced, quality, or passthrough (user)
+---
+
+**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.**
+
+Show current routing mode (no args) or set it (eco, balanced, quality, passthrough).
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-routing.js $ARGUMENTS
+```

package/commands/plexor-settings.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Settings — unified dashboard for all Plexor configuration.
+ *
+ * Usage:
+ *   /plexor-settings                          Show all settings
+ *   /plexor-settings routing <value>          Set routing mode
+ *   /plexor-settings agent <value>            Set agent autonomy
+ *   /plexor-settings provider <value>         Set LLM provider
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+// ── Definitions ──────────────────────────────────────────────────────────────
+
+const ROUTING_MODES = ['eco', 'balanced', 'quality', 'passthrough'];
+const ROUTING_DESC = {
+  eco:         '60-90% savings, cheapest models',
+  balanced:    '40-60% savings, good balance',
+  quality:     '20-40% savings, premium models',
+  passthrough: 'No optimization, direct to provider'
+};
+const ROUTING_ALIASES = { cost: 'eco' };
+
+const AGENT_MODES = ['supervised', 'autonomous', 'danger-full-auto'];
+const AGENT_DESC = {
+  supervised:         'Confirm before acting',
+  autonomous:         'Acts within safe bounds',
+  'danger-full-auto': 'Full autonomy, no guardrails'
+};
+const AGENT_ALIASES = { auto: 'autonomous', fullauto: 'danger-full-auto', 'full-auto': 'danger-full-auto', full_auto: 'danger-full-auto' };
+
+const PROVIDERS = ['auto', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini', 'grok', 'cohere'];
+const PROVIDER_DESC = {
+  auto:      'Best model for task (router decides)',
+  anthropic: 'Claude (Anthropic)',
+  openai:    'GPT (OpenAI)',
+  deepseek:  'DeepSeek',
+  mistral:   'Mistral',
+  gemini:    'Gemini (Google)',
+  grok:      'Grok (xAI)',
+  cohere:    'Command-R (Cohere)'
+};
+const PROVIDER_ALIASES = { claude: 'anthropic' };
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function pad(s, n) { return String(s).padEnd(n); }
+
+function showDashboard(config) {
+  const routing  = readSetting(config, 'mode', null, 'PLEXOR_MODE', ROUTING_MODES, 'balanced');
+  const agent    = readSetting(config, 'orchestrationMode', 'orchestration_mode', 'PLEXOR_ORCHESTRATION_MODE', AGENT_MODES, 'autonomous');
+  const provider = readSetting(config, 'preferred_provider', null, 'PLEXOR_PROVIDER', PROVIDERS, 'auto');
+
+  const W = 56;
+  const line = '─'.repeat(W - 2);
+  const row = (label, val, desc, src) => {
+    const marker = `${val} (${src})`;
+    console.log(`│ ${pad(label, 10)} ${pad(marker, 28)} ${pad(desc, W - 43)}│`);
+  };
+
+  console.log(`┌${line}┐`);
+  console.log(`│${pad('  Plexor Settings', W - 2)}│`);
+  console.log(`├${line}┤`);
+  row('routing', routing.value, ROUTING_DESC[routing.value], routing.source);
+  row('agent', agent.value, AGENT_DESC[agent.value], agent.source);
+  row('provider', provider.value, PROVIDER_DESC[provider.value], provider.source);
+  console.log(`├${line}┤`);
+  console.log(`│${pad('  Set:', W - 2)}│`);
+  console.log(`│${pad('    /plexor-settings routing eco', W - 2)}│`);
+  console.log(`│${pad('    /plexor-settings agent danger-full-auto', W - 2)}│`);
+  console.log(`│${pad('    /plexor-settings provider anthropic', W - 2)}│`);
+  console.log(`├${line}┤`);
+  console.log(`│${pad('  Shortcuts:', W - 2)}│`);
+  console.log(`│${pad('    /plexor-routing   /plexor-agent   /plexor-provider', W - 2)}│`);
+  console.log(`└${line}┘`);
+}
+
+function setDimension(dimension, value, config) {
+  let validValues, aliases, configKey, configKeyAlt, envVar, defaultVal, descMap, label;
+
+  switch (dimension) {
+    case 'routing':
+    case 'mode':
+      validValues = ROUTING_MODES; aliases = ROUTING_ALIASES;
+      configKey = 'mode'; configKeyAlt = null; envVar = 'PLEXOR_MODE';
+      defaultVal = 'balanced'; descMap = ROUTING_DESC; label = 'Routing Mode';
+      break;
+    case 'agent':
+    case 'orchestration':
+      validValues = AGENT_MODES; aliases = AGENT_ALIASES;
+      configKey = 'orchestrationMode'; configKeyAlt = 'orchestration_mode'; envVar = 'PLEXOR_ORCHESTRATION_MODE';
+      defaultVal = 'autonomous'; descMap = AGENT_DESC; label = 'Agent Mode';
+      break;
+    case 'provider':
+      validValues = PROVIDERS; aliases = PROVIDER_ALIASES;
+      configKey = 'preferred_provider'; configKeyAlt = null; envVar = 'PLEXOR_PROVIDER';
+      defaultVal = 'auto'; descMap = PROVIDER_DESC; label = 'Provider';
+      break;
+    default:
+      console.error(`Unknown setting: "${dimension}"`);
+      console.error('Valid settings: routing, agent, provider');
+      process.exit(1);
+  }
+
+  let resolved = (value || '').toLowerCase().trim();
+  if (aliases[resolved]) resolved = aliases[resolved];
+
+  if (!validValues.includes(resolved)) {
+    console.error(`Invalid ${dimension} value: "${value}"`);
+    console.error(`Valid values: ${validValues.join(', ')}`);
+    process.exit(1);
+  }
+
+  const current = readSetting(config, configKey, configKeyAlt, envVar, validValues, defaultVal);
+
+  if (current.source === 'environment' && resolved !== current.value) {
+    console.log(`Warning: ${envVar} environment variable is set to "${current.value}".`);
+    console.log(`Config will be updated, but env var takes priority.`);
+  }
+
+  if (resolved === current.value && current.source === 'config') {
+    console.log(`${label} is already set to "${resolved}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings[configKey] = resolved;
+  if (configKeyAlt && config.settings[configKeyAlt]) {
+    delete config.settings[configKeyAlt];
+  }
+
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`${label} updated: ${current.value} → ${resolved}`);
+  console.log(`  ${descMap[resolved]}`);
+  console.log(`  Takes effect on next request.`);
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+
+  if (args.length === 0) {
+    showDashboard(config);
+    return;
+  }
+
+  if (args.length === 1) {
+    // Show one dimension's current value + options
+    const dim = args[0].toLowerCase();
+    let validValues, descMap, configKey, configKeyAlt, envVar, defaultVal, label;
+    switch (dim) {
+      case 'routing': case 'mode':
+        validValues = ROUTING_MODES; descMap = ROUTING_DESC;
+        configKey = 'mode'; configKeyAlt = null; envVar = 'PLEXOR_MODE';
+        defaultVal = 'balanced'; label = 'Routing Mode'; break;
+      case 'agent': case 'orchestration':
+        validValues = AGENT_MODES; descMap = AGENT_DESC;
+        configKey = 'orchestrationMode'; configKeyAlt = 'orchestration_mode'; envVar = 'PLEXOR_ORCHESTRATION_MODE';
+        defaultVal = 'autonomous'; label = 'Agent Mode'; break;
+      case 'provider':
+        validValues = PROVIDERS; descMap = PROVIDER_DESC;
+        configKey = 'preferred_provider'; configKeyAlt = null; envVar = 'PLEXOR_PROVIDER';
+        defaultVal = 'auto'; label = 'Provider'; break;
+      default:
+        console.error(`Unknown setting: "${dim}". Valid: routing, agent, provider`);
+        process.exit(1);
+    }
+    const current = readSetting(config, configKey, configKeyAlt, envVar, validValues, defaultVal);
+    console.log(`${label}: ${current.value} (${current.source})`);
+    console.log('Options:');
+    for (const v of validValues) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(18)} ${descMap[v]}`);
+    }
+    return;
+  }
+
+  setDimension(args[0], args[1], config);
+}
+
+main();

package/commands/plexor-settings.md

@@ -0,0 +1,15 @@
+---
+description: View and change Plexor settings — routing mode, agent autonomy, LLM provider (user)
+---
+
+**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.**
+
+Show all settings (no args), or set a specific dimension:
+- `/plexor-settings` — dashboard
+- `/plexor-settings routing eco` — set routing mode
+- `/plexor-settings agent danger-full-auto` — set agent autonomy
+- `/plexor-settings provider anthropic` — set LLM provider
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-settings.js $ARGUMENTS
+```

package/hooks/intercept.js

@@ -35,6 +35,93 @@ 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'
+]);
+
+function normalizeOrchestrationMode(mode) {
+  if (typeof mode !== 'string') {
+    return null;
+  }
+  const normalized = mode.trim().toLowerCase();
+  if (!VALID_ORCHESTRATION_MODES.has(normalized)) {
+    return null;
+  }
+  // Accept legacy 'full-auto' as alias for 'danger-full-auto'
+  if (normalized === 'full-auto') return 'danger-full-auto';
+  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';
+}
+
 // Try to load lib modules, fall back to inline implementations
 let ConfigManager, SessionManager, LocalCache, Logger, PlexorClient;
 let config, session, cache, logger;
@@ -73,7 +160,10 @@ 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',
+          orchestrationMode:
+            cfg.settings?.orchestrationMode || cfg.settings?.orchestration_mode || 'autonomous'
         };
       } catch {
         return { enabled: false };
@@ -190,6 +280,11 @@ async function main() {
       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);
+
     // 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
@@ -199,14 +294,21 @@ async function main() {
     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');
 
       // Add session tracking metadata (server will use this for analytics)
       return output({
         ...request,
+        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,
           cwd: process.cwd(),
           timestamp: Date.now(),
         }
@@ -249,8 +351,6 @@ async function main() {
       });
     }
 
-    const settings = await config.load();
-
     if (!settings.enabled) {
       logger.debug('Plexor disabled, passing through');
       session.recordPassthrough();
@@ -293,7 +393,7 @@ async function main() {
     const cachedResponse = await cache.get(cacheKey);
 
     if (cachedResponse && settings.localCacheEnabled) {
-      logger.info('[Plexor] Local cache hit');
+      logger.info('Local cache hit');
       session.recordCacheHit();
       return output({
         ...request,
@@ -321,10 +421,10 @@ 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)`);
 
     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)})`);
     }
 
     const optimizedRequest = {
@@ -360,7 +460,7 @@ async function main() {
     return output(optimizedRequest);
 
   } catch (error) {
-    logger.error(`[Plexor] Error: ${error.message}`);
+    logger.error(`Error: ${error.message}`);
     logger.debug(error.stack);
 
     const errorRequestId = generateRequestId('error');  // Issue #701: Add request_id for tracking
@@ -625,6 +725,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);
 });

package/lib/config-utils.js

@@ -0,0 +1,74 @@
+/**
+ * Shared config utilities for Plexor slash commands.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { PLEXOR_DIR, CONFIG_PATH } = require('./constants');
+
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    if (!data || data.trim() === '') {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      try { fs.copyFileSync(CONFIG_PATH, CONFIG_PATH + '.corrupted'); } catch { /* ignore */ }
+    }
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  try {
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(PLEXOR_DIR, `.config.${tempId}.tmp`);
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CONFIG_PATH);
+    return true;
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error('Error: Cannot write to ~/.plexor/config.json');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    return false;
+  }
+}
+
+/**
+ * Read a setting with env-var → config → default precedence.
+ * @param {object} config - Loaded config object
+ * @param {string} configKey - Primary key in config.settings (camelCase)
+ * @param {string|null} configKeyAlt - Alternative key (snake_case legacy)
+ * @param {string} envVar - Environment variable name
+ * @param {string[]} validValues - Accepted values
+ * @param {string} defaultValue - Fallback
+ * @returns {{ value: string, source: string }}
+ */
+function readSetting(config, configKey, configKeyAlt, envVar, validValues, defaultValue) {
+  const env = process.env[envVar];
+  if (env && validValues.includes(env.toLowerCase())) {
+    return { value: env.toLowerCase(), source: 'environment' };
+  }
+  const cfg = config.settings?.[configKey] || (configKeyAlt && config.settings?.[configKeyAlt]);
+  if (cfg && validValues.includes(cfg.toLowerCase())) {
+    return { value: cfg.toLowerCase(), source: 'config' };
+  }
+  return { value: defaultValue, source: 'default' };
+}
+
+module.exports = { loadConfig, saveConfig, readSetting };

package/lib/config.js

@@ -22,7 +22,9 @@ class ConfigManager {
         timeout: cfg.settings?.timeout || DEFAULT_TIMEOUT,
         localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
         mode: cfg.settings?.mode || 'balanced',
-        preferredProvider: cfg.settings?.preferred_provider || 'auto'
+        preferredProvider: cfg.settings?.preferred_provider || 'auto',
+        orchestrationMode:
+          cfg.settings?.orchestrationMode || cfg.settings?.orchestration_mode || 'autonomous'
       };
     } catch {
       return { enabled: false, apiKey: '', apiUrl: DEFAULT_API_URL };
@@ -52,7 +54,12 @@ class ConfigManager {
           timeout: config.timeout ?? existing.settings?.timeout,
           localCacheEnabled: config.localCacheEnabled ?? existing.settings?.localCacheEnabled,
           mode: config.mode ?? existing.settings?.mode,
-          preferred_provider: config.preferredProvider ?? existing.settings?.preferred_provider
+          preferred_provider: config.preferredProvider ?? existing.settings?.preferred_provider,
+          orchestrationMode:
+            config.orchestrationMode ??
+            config.orchestration_mode ??
+            existing.settings?.orchestrationMode ??
+            existing.settings?.orchestration_mode
         }
       };
 

package/lib/logger.js

@@ -2,8 +2,25 @@
  * Plexor Logger
  *
  * Simple logger that outputs to stderr to avoid interfering with stdout JSON.
+ * Uses ANSI-colored badges for branded Plexor messages.
  */
 
+// ANSI color codes for branded badge output
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const WHITE = '\x1b[37m';
+const YELLOW_FG = '\x1b[33m';
+const RED_FG = '\x1b[31m';
+const BLUE_BG = '\x1b[44m';
+const YELLOW_BG = '\x1b[43m';
+const RED_BG = '\x1b[41m';
+
+// Pre-built badge strings
+const BADGE_INFO = `${BOLD}${WHITE}${BLUE_BG} PLEXOR ${RESET}`;
+const BADGE_WARN = `${BOLD}${WHITE}${YELLOW_BG} PLEXOR ${RESET}`;
+const BADGE_ERROR = `${BOLD}${WHITE}${RED_BG} PLEXOR ${RESET}`;
+
 class Logger {
   constructor(component = 'plexor') {
     this.component = component;
@@ -12,23 +29,23 @@ class Logger {
 
   debug(msg, data = null) {
     if (this.debug_enabled) {
-      const output = data ? `[DEBUG][${this.component}] ${msg} ${JSON.stringify(data)}` : `[DEBUG][${this.component}] ${msg}`;
+      const output = data ? `${DIM}[${this.component}]${RESET} ${msg} ${JSON.stringify(data)}` : `${DIM}[${this.component}]${RESET} ${msg}`;
       console.error(output);
     }
   }
 
   info(msg, data = null) {
-    const output = data ? `${msg} ${JSON.stringify(data)}` : msg;
+    const output = data ? `${BADGE_INFO} ${msg} ${JSON.stringify(data)}` : `${BADGE_INFO} ${msg}`;
     console.error(output);
   }
 
   warn(msg, data = null) {
-    const output = data ? `[WARN][${this.component}] ${msg} ${JSON.stringify(data)}` : `[WARN][${this.component}] ${msg}`;
+    const output = data ? `${BADGE_WARN} ${YELLOW_FG}${msg} ${JSON.stringify(data)}${RESET}` : `${BADGE_WARN} ${YELLOW_FG}${msg}${RESET}`;
     console.error(output);
   }
 
   error(msg, data = null) {
-    const output = data ? `[ERROR][${this.component}] ${msg} ${JSON.stringify(data)}` : `[ERROR][${this.component}] ${msg}`;
+    const output = data ? `${BADGE_ERROR} ${RED_FG}${msg} ${JSON.stringify(data)}${RESET}` : `${BADGE_ERROR} ${RED_FG}${msg}${RESET}`;
     console.error(output);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin-staging",
-  "version": "0.1.0-beta.13",
+  "version": "0.1.0-beta.15",
   "description": "STAGING - LLM cost optimization plugin for Claude Code (internal testing)",
   "main": "lib/constants.js",
   "bin": {
@@ -8,7 +8,11 @@
     "plexor-enabled": "./commands/plexor-enabled.js",
     "plexor-login": "./commands/plexor-login.js",
     "plexor-logout": "./commands/plexor-logout.js",
-    "plexor-uninstall": "./commands/plexor-uninstall.js"
+    "plexor-uninstall": "./commands/plexor-uninstall.js",
+    "plexor-settings": "./commands/plexor-settings.js",
+    "plexor-routing": "./commands/plexor-routing.js",
+    "plexor-agent": "./commands/plexor-agent.js",
+    "plexor-provider": "./commands/plexor-provider.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",