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

package/commands/plexor-provider.js

@@ -1,110 +1,91 @@
 #!/usr/bin/env node
 
 /**
- * Plexor Provider Command
- * Force a specific LLM provider
+ * 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 fs = require('fs');
-const path = require('path');
-
-const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
-const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
-
-const VALID_PROVIDERS = ['auto', 'claude', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini', 'google'];
-
-const PROVIDER_INFO = {
-  auto: 'Automatic routing based on task and mode',
-  claude: 'Anthropic Claude models (alias for anthropic)',
-  anthropic: 'Anthropic Claude models',
-  openai: 'OpenAI GPT models',
-  deepseek: 'DeepSeek models (excellent for code)',
-  mistral: 'Mistral AI models',
-  gemini: 'Google Gemini models',
-  google: 'Google Gemini models (alias for gemini)'
+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)'
 };
-
-function loadConfig() {
-  try {
-    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
-    return JSON.parse(data);
-  } catch {
-    return { version: 1, auth: {}, settings: {} };
-  }
-}
-
-function saveConfig(config) {
-  if (!fs.existsSync(PLEXOR_DIR)) {
-    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
-  }
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
-}
-
-function normalizeProvider(provider) {
-  const normalized = provider.toLowerCase();
-  if (normalized === 'claude') return 'anthropic';
-  if (normalized === 'google') return 'gemini';
-  return normalized;
-}
+const ALIASES = { claude: 'anthropic' };
 
 function main() {
   const args = process.argv.slice(2);
   const config = loadConfig();
-  const currentProvider = config.settings?.preferred_provider || 'auto';
+  const current = readSetting(config, 'preferred_provider', null, 'PLEXOR_PROVIDER', VALID, 'auto');
 
-  // No args - show current provider and options
   if (args.length === 0) {
-    console.log(`┌─────────────────────────────────────────────┐`);
-    console.log(`│  Plexor Provider Routing                    │`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Current: ${currentProvider.padEnd(33)}│`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Available providers:                       │`);
-
-    const displayProviders = ['auto', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini'];
-    for (const provider of displayProviders) {
-      const marker = provider === currentProvider ? '●' : '○';
-      const info = PROVIDER_INFO[provider];
-      console.log(`│  ${marker} ${provider.padEnd(10)} ${info.substring(0, 29).padEnd(29)}│`);
+    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(`│  Usage: /plexor-provider <provider>         │`);
-    console.log(`│  Example: /plexor-provider deepseek         │`);
-    console.log(`│  Aliases: claude→anthropic, google→gemini   │`);
-    console.log(`└─────────────────────────────────────────────┘`);
+    console.log('');
+    console.log('Set: /plexor-provider <name>');
     return;
   }
 
-  const inputProvider = args[0].toLowerCase();
+  let requested = args[0].toLowerCase().trim();
+  if (ALIASES[requested]) requested = ALIASES[requested];
 
-  if (!VALID_PROVIDERS.includes(inputProvider)) {
-    console.error(`Error: Invalid provider "${args[0]}"`);
-    console.error(`Valid providers: auto, anthropic, openai, deepseek, mistral, gemini`);
-    console.error(`Aliases: claude (→anthropic), google (→gemini)`);
+  if (!VALID.includes(requested)) {
+    console.error(`Invalid provider: "${args[0]}"`);
+    console.error(`Valid: ${VALID.join(', ')}`);
     process.exit(1);
   }
 
-  const newProvider = normalizeProvider(inputProvider);
+  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 (newProvider === currentProvider) {
-    console.log(`Provider is already set to "${currentProvider}"`);
+  if (requested === current.value && current.source === 'config') {
+    console.log(`Already set to "${requested}".`);
     return;
   }
 
   config.settings = config.settings || {};
-  config.settings.preferred_provider = newProvider;
-  saveConfig(config);
+  config.settings.preferred_provider = requested;
+  if (requested !== 'auto') {
+    delete config.settings.preferred_model;
+    delete config.settings.preferredModel;
+  }
+  if (!saveConfig(config)) { process.exit(1); }
 
-  const info = PROVIDER_INFO[newProvider];
-  console.log(`┌─────────────────────────────────────────────┐`);
-  console.log(`│  ✓ Provider Updated                         │`);
-  console.log(`├─────────────────────────────────────────────┤`);
-  console.log(`│  Previous: ${currentProvider.padEnd(32)}│`);
-  console.log(`│  New: ${newProvider.padEnd(37)}│`);
-  console.log(`├─────────────────────────────────────────────┤`);
-  console.log(`│  ${info.padEnd(42)}│`);
-  console.log(`└─────────────────────────────────────────────┘`);
+  console.log(`Provider: ${current.value} → ${requested}`);
+  if (requested !== 'auto') {
+    console.log('  Cleared preferred_model to keep provider/model force hints mutually exclusive.');
+  }
+  console.log(`  ${DESC[requested]}`);
+  console.log('  Takes effect on next request.');
 }
 
 main();

package/commands/plexor-provider.md

@@ -1,27 +1,37 @@
 ---
-description: Force a specific LLM provider (claude/openai/deepseek/mistral/gemini/auto) (user)
+description: Set Plexor LLM provider — auto, anthropic, openai, deepseek, gemini, etc. (user)
 ---
 
-# Plexor Provider
+**Step 1: Check if arguments were provided.**
 
-Run this command to view or set the preferred provider:
+If `$ARGUMENTS` contains a value (e.g., `/plexor-provider anthropic`), apply it directly:
 
 ```bash
-node ~/.claude/plugins/plexor/commands/plexor-provider.js
+node ~/.claude/plugins/plexor/commands/plexor-provider.js $ARGUMENTS
 ```
 
-To set a specific provider:
+Present the output to the user and STOP. Do NOT call any other tools.
+
+**Step 2: If NO arguments were provided** (just `/plexor-provider`), first show the current state:
 
 ```bash
-node ~/.claude/plugins/plexor/commands/plexor-provider.js deepseek
+node ~/.claude/plugins/plexor/commands/plexor-provider.js
 ```
 
-Use the Bash tool to execute this command.
+Then immediately use **AskUserQuestion** to let the user pick a provider:
+
+- **Question**: "Which LLM provider?"
+- **Header**: "Provider"
+- **Options** (exactly 4 — "Other" auto-covers mistral, gemini, grok, cohere):
+  1. **auto (Recommended)** — "Let Plexor choose the best provider automatically"
+  2. **anthropic** — "Claude models (Opus, Sonnet, Haiku)"
+  3. **openai** — "GPT models (GPT-4o, GPT-4.1, o1)"
+  4. **deepseek** — "DeepSeek models (Chat, Reasoner)"
 
-**IMPORTANT**: After running this command and displaying the output, STOP. Do not:
-- Read any files
-- Explore the codebase
-- Run additional commands
-- Ask follow-up questions
+**Step 3: After the user selects**, apply their choice. If the user picks "Other", they will type the provider name (mistral, gemini, grok, cohere):
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js <selected_value>
+```
 
-The command output is the complete response. Simply show the output and wait for the user's next input.
+Present the output and STOP. Do NOT re-execute commands or call other tools.

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,37 @@
+---
+description: Set Plexor routing mode — eco, balanced, quality, or passthrough (user)
+---
+
+**Step 1: Check if arguments were provided.**
+
+If `$ARGUMENTS` contains a value (e.g., `/plexor-routing eco`), apply it directly:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-routing.js $ARGUMENTS
+```
+
+Present the output to the user and STOP. Do NOT call any other tools.
+
+**Step 2: If NO arguments were provided** (just `/plexor-routing`), first show the current state:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-routing.js
+```
+
+Then immediately use **AskUserQuestion** to let the user pick a mode:
+
+- **Question**: "Which routing mode?"
+- **Header**: "Routing"
+- **Options** (exactly 4):
+  1. **eco (Recommended)** — "Cheapest models first, best cost efficiency"
+  2. **balanced** — "Balance cost and quality, smart model selection"
+  3. **quality** — "Premium models, best output quality"
+  4. **passthrough** — "Direct provider access, no routing logic"
+
+**Step 3: After the user selects**, apply their choice:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-routing.js <selected_value>
+```
+
+Present the output and STOP. Do NOT re-execute commands or call other tools.

package/commands/plexor-settings.js

@@ -1,155 +1,193 @@
 #!/usr/bin/env node
 
 /**
- * Plexor Settings Command
- * View and update Plexor configuration settings
+ * 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 fs = require('fs');
-const path = require('path');
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
 
-const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
-const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+// ── Definitions ──────────────────────────────────────────────────────────────
 
-const SETTING_KEYS = {
-  'api-url': 'apiUrl',
-  'apiurl': 'apiUrl',
-  'url': 'apiUrl',
-  'timeout': 'timeout',
-  'cache': 'localCacheEnabled',
-  'local-cache': 'localCacheEnabled'
+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' };
 
-function loadConfig() {
-  try {
-    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
-    return JSON.parse(data);
-  } catch {
-    return { version: 1, auth: {}, settings: {} };
-  }
+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 saveConfig(config) {
-  if (!fs.existsSync(PLEXOR_DIR)) {
-    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+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);
   }
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
-}
 
-function parseValue(key, value) {
-  const normalizedKey = SETTING_KEYS[key.toLowerCase()] || key;
-
-  switch (normalizedKey) {
-    case 'localCacheEnabled':
-      return ['true', 'on', 'yes', '1'].includes(value.toLowerCase());
-    case 'timeout':
-      const num = parseInt(value, 10);
-      if (isNaN(num) || num < 1000 || num > 60000) {
-        throw new Error('Timeout must be between 1000-60000ms');
-      }
-      return num;
-    case 'apiUrl':
-      if (!value.startsWith('http://') && !value.startsWith('https://')) {
-        throw new Error('API URL must start with http:// or https://');
-      }
-      return value;
-    default:
-      return value;
+  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 (configKey === 'preferred_provider' && resolved !== 'auto') {
+    delete config.settings.preferred_model;
+    delete config.settings.preferredModel;
+  }
+  if (configKeyAlt && config.settings[configKeyAlt]) {
+    delete config.settings[configKeyAlt];
+  }
+
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`${label} updated: ${current.value} → ${resolved}`);
+  if (configKey === 'preferred_provider' && resolved !== 'auto') {
+    console.log('  Cleared preferred_model to keep provider/model force hints mutually exclusive.');
   }
+  console.log(`  ${descMap[resolved]}`);
+  console.log(`  Takes effect on next request.`);
 }
 
+// ── Main ─────────────────────────────────────────────────────────────────────
+
 function main() {
   const args = process.argv.slice(2);
   const config = loadConfig();
-  const settings = config.settings || {};
 
-  // No args - show current settings
   if (args.length === 0) {
-    const enabled = settings.enabled ?? false;
-    const mode = settings.mode || 'balanced';
-    const provider = settings.preferred_provider || 'auto';
-    const apiUrl = settings.apiUrl || 'https://api.plexor.dev';
-    const timeout = settings.timeout || 5000;
-    const cache = settings.localCacheEnabled ?? false;
-    const hasApiKey = !!config.auth?.api_key;
-
-    console.log(`┌─────────────────────────────────────────────┐`);
-    console.log(`│  Plexor Settings                            │`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Authentication                             │`);
-    console.log(`│  └── API Key: ${(hasApiKey ? 'Configured' : 'Not set').padEnd(29)}│`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Proxy                                      │`);
-    console.log(`│  ├── Enabled: ${(enabled ? 'Yes' : 'No').padEnd(29)}│`);
-    console.log(`│  └── API URL: ${apiUrl.substring(0, 29).padEnd(29)}│`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Optimization                               │`);
-    console.log(`│  ├── Mode: ${mode.padEnd(32)}│`);
-    console.log(`│  └── Provider: ${provider.padEnd(27)}│`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Performance                                │`);
-    console.log(`│  ├── Local Cache: ${(cache ? 'Enabled' : 'Disabled').padEnd(24)}│`);
-    console.log(`│  └── Timeout: ${(timeout + 'ms').padEnd(29)}│`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Modify settings:                           │`);
-    console.log(`│    /plexor-settings <key> <value>           │`);
-    console.log(`│                                             │`);
-    console.log(`│  Available keys:                            │`);
-    console.log(`│    api-url, timeout, cache                  │`);
-    console.log(`│                                             │`);
-    console.log(`│  Other commands:                            │`);
-    console.log(`│    /plexor-mode     - Set optimization mode │`);
-    console.log(`│    /plexor-provider - Set provider routing  │`);
-    console.log(`│    /plexor-enabled  - Enable/disable proxy  │`);
-    console.log(`└─────────────────────────────────────────────┘`);
+    showDashboard(config);
     return;
   }
 
-  // Get setting
   if (args.length === 1) {
-    const key = args[0].toLowerCase();
-    const normalizedKey = SETTING_KEYS[key] || key;
-    const value = settings[normalizedKey];
-
-    if (value === undefined) {
-      console.error(`Unknown setting: ${args[0]}`);
-      console.error(`Available: api-url, timeout, cache`);
-      process.exit(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]}`);
     }
-
-    console.log(`${normalizedKey}: ${value}`);
     return;
   }
 
-  // Set setting
-  const key = args[0].toLowerCase();
-  const normalizedKey = SETTING_KEYS[key];
-
-  if (!normalizedKey) {
-    console.error(`Unknown setting: ${args[0]}`);
-    console.error(`Available: api-url, timeout, cache`);
-    process.exit(1);
-  }
-
-  try {
-    const value = parseValue(key, args[1]);
-    const oldValue = settings[normalizedKey];
-
-    config.settings = config.settings || {};
-    config.settings[normalizedKey] = value;
-    saveConfig(config);
-
-    console.log(`┌─────────────────────────────────────────────┐`);
-    console.log(`│  ✓ Setting Updated                          │`);
-    console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Key: ${normalizedKey.padEnd(37)}│`);
-    console.log(`│  Previous: ${String(oldValue ?? 'not set').substring(0, 32).padEnd(32)}│`);
-    console.log(`│  New: ${String(value).substring(0, 37).padEnd(37)}│`);
-    console.log(`└─────────────────────────────────────────────┘`);
-  } catch (err) {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-  }
+  setDimension(args[0], args[1], config);
 }
 
 main();