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

package/hooks/intercept.js

@@ -35,6 +35,91 @@ 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;
+  }
+  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;
@@ -56,10 +141,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 +173,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 };
@@ -187,9 +290,15 @@ async function main() {
     // 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);
+
     // 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 +308,24 @@ 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');
+      logger.ux(
+        `Hypervisor mode active (${gatewayMode}/${orchestrationMode}); routing handled server-side`
+      );
 
       // 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(),
         }
@@ -217,6 +336,7 @@ async function main() {
     // 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,
@@ -235,6 +355,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,
@@ -249,10 +370,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,
@@ -267,6 +387,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,
@@ -293,7 +414,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,
@@ -321,10 +443,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 = {
@@ -360,7 +488,8 @@ async function main() {
     return output(optimizedRequest);
 
   } catch (error) {
-    logger.error(`[Plexor] Error: ${error.message}`);
+    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
@@ -625,6 +754,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/hooks/track-response.js

@@ -133,6 +133,17 @@ try {
     async getMetadata() { return null; }
   };
 
+  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 = class {
     constructor(name) { this.name = name; }
     info(msg, data) {
@@ -143,6 +154,10 @@ try {
       }
     }
     error(msg) { console.error(`[${this.name}] [ERROR] ${msg}`); }
+    ux(msg) {
+      if (!uxMessagesEnabled) return;
+      console.error(`${CYAN}${formatUx(msg)}${RESET}`);
+    }
     debug(msg) {
       if (process.env.PLEXOR_DEBUG) {
         console.error(`[${this.name}] [DEBUG] ${msg}`);
@@ -194,11 +209,17 @@ async function main() {
     input = await readStdin();
     response = JSON.parse(input);
 
+    // Normalize known Plexor recovery text into explicit [PLEXOR: ...] format
+    // and mirror high-signal UX hints to stderr in cyan.
+    response = normalizePlexorResponseMessages(response);
+    emitPlexorUxMessages(response);
+
     // Calculate output tokens for ALL responses (Issue #701)
     const outputTokens = estimateOutputTokens(response);
 
     // Get Plexor metadata if present
     const plexorMeta = response._plexor;
+    emitPlexorOutcomeSummary(response, plexorMeta, outputTokens);
 
     // Issue #701: Track ALL responses, not just when enabled
     // This ensures session stats are always accurate
@@ -374,3 +395,282 @@ main().catch((error) => {
   console.error(`[Plexor] Fatal error: ${error.message}`);
   process.exit(1);
 });
+
+function normalizePlexorText(text) {
+  if (typeof text !== 'string' || !text) {
+    return text;
+  }
+
+  let normalized = text;
+
+  if (
+    normalized.includes("I've been repeating the same operation without making progress.") &&
+    !normalized.includes("[PLEXOR: I've been repeating the same operation without making progress.]")
+  ) {
+    normalized = normalized.replace(
+      "I've been repeating the same operation without making progress.",
+      "[PLEXOR: I've been repeating the same operation without making progress.]"
+    );
+  }
+
+  normalized = normalized.replace(
+    /\[The repeated operation has been blocked\.[^\]]*\]/g,
+    (match) => `[PLEXOR: ${match.slice(1, -1)}]`
+  );
+  normalized = normalized.replace(
+    /\[All tasks have been completed\. Session ending\.\]/g,
+    '[PLEXOR: All tasks have been completed. Session ending.]'
+  );
+  normalized = normalized.replace(
+    /\[Blocked destructive cleanup command while recovering from prior errors\.[^\]]*\]/g,
+    (match) => `[PLEXOR: ${match.slice(1, -1)}]`
+  );
+
+  return normalized;
+}
+
+function normalizePlexorResponseMessages(response) {
+  if (!response || typeof response !== 'object') {
+    return response;
+  }
+
+  // Anthropic format
+  if (Array.isArray(response.content)) {
+    response.content = response.content.map((block) => {
+      if (!block || block.type !== 'text' || typeof block.text !== 'string') {
+        return block;
+      }
+      return { ...block, text: normalizePlexorText(block.text) };
+    });
+    return response;
+  }
+
+  // String content format
+  if (typeof response.content === 'string') {
+    response.content = normalizePlexorText(response.content);
+    return response;
+  }
+
+  // OpenAI choices format
+  if (Array.isArray(response.choices)) {
+    response.choices = response.choices.map((choice) => {
+      if (!choice || typeof choice !== 'object') return choice;
+      const updated = { ...choice };
+      if (typeof updated.text === 'string') {
+        updated.text = normalizePlexorText(updated.text);
+      }
+      if (updated.message && typeof updated.message.content === 'string') {
+        updated.message = {
+          ...updated.message,
+          content: normalizePlexorText(updated.message.content)
+        };
+      }
+      return updated;
+    });
+  }
+
+  return response;
+}
+
+function collectResponseText(response) {
+  const texts = [];
+  if (!response || typeof response !== 'object') {
+    return texts;
+  }
+
+  if (Array.isArray(response.content)) {
+    for (const block of response.content) {
+      if (block?.type === 'text' && typeof block.text === 'string') {
+        texts.push(block.text);
+      }
+    }
+  } else if (typeof response.content === 'string') {
+    texts.push(response.content);
+  }
+
+  if (Array.isArray(response.choices)) {
+    for (const choice of response.choices) {
+      if (typeof choice?.text === 'string') {
+        texts.push(choice.text);
+      }
+      if (typeof choice?.message?.content === 'string') {
+        texts.push(choice.message.content);
+      }
+    }
+  }
+
+  return texts;
+}
+
+function emitPlexorUxMessages(response) {
+  if (!logger || typeof logger.ux !== 'function') {
+    return;
+  }
+
+  const lines = collectResponseText(response).join('\n');
+  if (!lines) {
+    return;
+  }
+
+  const signals = new Set();
+
+  if (lines.includes("I've been repeating the same operation without making progress.")) {
+    signals.add("[PLEXOR: I've been repeating the same operation without making progress.]");
+  }
+  if (/repeated operation has been blocked/i.test(lines)) {
+    signals.add('[PLEXOR: The repeated operation has been blocked; switching approach.]');
+  }
+  if (/circuit breaker has fired/i.test(lines)) {
+    signals.add('[PLEXOR: Circuit breaker fired; recovery guidance active.]');
+  }
+  if (/blocked destructive cleanup command/i.test(lines)) {
+    signals.add('[PLEXOR: Blocked destructive cleanup command during recovery.]');
+  }
+  if (/all tasks have been completed\. session ending\./i.test(lines)) {
+    signals.add('[PLEXOR: All tasks completed; session ending.]');
+  }
+
+  const explicitPlexorMessages = lines.match(/\[PLEXOR:[^\]]+\]/g) || [];
+  for (const explicit of explicitPlexorMessages) {
+    signals.add(explicit);
+  }
+
+  for (const signal of signals) {
+    logger.ux(signal);
+  }
+}
+
+function toNumber(value) {
+  if (value === null || value === undefined || value === '') {
+    return null;
+  }
+  const parsed = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function toBoolean(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (['true', '1', 'yes', 'on'].includes(normalized)) return true;
+    if (['false', '0', 'no', 'off'].includes(normalized)) return false;
+  }
+  return null;
+}
+
+function formatUsd(value) {
+  if (value === null || value === undefined || !Number.isFinite(value)) {
+    return null;
+  }
+  return `$${value.toFixed(6)}`;
+}
+
+function extractGatewayOutcome(response, plexorMeta, outputTokens) {
+  const provider =
+    response?.plexor_provider_used ||
+    response?.plexor?.provider_used ||
+    plexorMeta?.recommended_provider ||
+    null;
+  const selectedModel =
+    response?.plexor_selected_model ||
+    response?.plexor?.selected_model ||
+    plexorMeta?.recommended_model ||
+    null;
+  const requestedModel = response?.model || null;
+  const routingSource = response?.plexor_routing_source || response?.plexor?.routing_source || null;
+  const authTier = response?.plexor_auth_tier || response?.plexor?.auth_tier || null;
+  const stopReason = response?.stop_reason || response?.choices?.[0]?.finish_reason || null;
+  const agentHalt = toBoolean(response?.plexor_agent_halt);
+  const fallbackUsed =
+    toBoolean(response?.plexor_fallback_used) ??
+    toBoolean(response?.fallback_used) ??
+    toBoolean(response?.plexor?.fallback_used);
+  const costUsd =
+    toNumber(response?.plexor_cost_usd) ??
+    toNumber(response?.cost_usd) ??
+    toNumber(plexorMeta?.estimated_cost) ??
+    null;
+  const savingsUsd =
+    toNumber(response?.plexor_savings_usd) ??
+    toNumber(response?.savings_usd) ??
+    null;
+  const inputTokens =
+    toNumber(response?.usage?.input_tokens) ??
+    toNumber(response?.usage?.prompt_tokens) ??
+    toNumber(plexorMeta?.optimized_tokens) ??
+    null;
+  const emittedOutputTokens =
+    toNumber(response?.usage?.output_tokens) ??
+    toNumber(response?.usage?.completion_tokens) ??
+    toNumber(outputTokens);
+
+  return {
+    provider,
+    selectedModel,
+    requestedModel,
+    routingSource,
+    authTier,
+    stopReason,
+    agentHalt,
+    fallbackUsed,
+    costUsd,
+    savingsUsd,
+    inputTokens,
+    emittedOutputTokens,
+  };
+}
+
+function emitPlexorOutcomeSummary(response, plexorMeta, outputTokens) {
+  if (!logger || typeof logger.ux !== 'function') {
+    return;
+  }
+
+  const outcome = extractGatewayOutcome(response, plexorMeta, outputTokens);
+  const messages = [];
+
+  if (outcome.provider || outcome.selectedModel || outcome.requestedModel) {
+    const parts = [];
+    if (outcome.provider) parts.push(`provider=${outcome.provider}`);
+    if (outcome.selectedModel) parts.push(`selected_model=${outcome.selectedModel}`);
+    if (!outcome.selectedModel && outcome.requestedModel) {
+      parts.push(`requested_model=${outcome.requestedModel}`);
+    }
+    if (outcome.routingSource) parts.push(`routing=${outcome.routingSource}`);
+    if (outcome.authTier) parts.push(`auth_tier=${outcome.authTier}`);
+    messages.push(`Routing summary: ${parts.join(' ')}`);
+  }
+
+  if (outcome.stopReason || outcome.agentHalt !== null || outcome.fallbackUsed !== null) {
+    const parts = [];
+    if (outcome.stopReason) parts.push(`stop_reason=${outcome.stopReason}`);
+    if (outcome.agentHalt === true) parts.push('agent_halt=auto_continue');
+    if (outcome.fallbackUsed !== null) parts.push(`fallback_used=${outcome.fallbackUsed}`);
+    if (parts.length > 0) {
+      messages.push(`Execution status: ${parts.join(' ')}`);
+    }
+  }
+
+  if (
+    outcome.costUsd !== null ||
+    outcome.savingsUsd !== null ||
+    outcome.inputTokens !== null ||
+    outcome.emittedOutputTokens !== null
+  ) {
+    const parts = [];
+    const costStr = formatUsd(outcome.costUsd);
+    const savingsStr = formatUsd(outcome.savingsUsd);
+    if (costStr) parts.push(`cost=${costStr}`);
+    if (savingsStr) parts.push(`savings=${savingsStr}`);
+    if (outcome.inputTokens !== null) parts.push(`input_tokens=${Math.round(outcome.inputTokens)}`);
+    if (outcome.emittedOutputTokens !== null) {
+      parts.push(`output_tokens=${Math.round(outcome.emittedOutputTokens)}`);
+    }
+    if (parts.length > 0) {
+      messages.push(`Usage summary: ${parts.join(' ')}`);
+    }
+  }
+
+  for (const msg of messages) {
+    logger.ux(msg);
+  }
+}

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
         }
       };