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

package/hooks/track-response.js

@@ -85,10 +85,10 @@ try {
     save(session) {
       try {
         if (!fs.existsSync(PLEXOR_DIR)) {
-          fs.mkdirSync(PLEXOR_DIR, { recursive: true });
+          fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
         }
         session.last_activity = Date.now();
-        fs.writeFileSync(this.sessionPath, JSON.stringify(session, null, 2));
+        fs.writeFileSync(this.sessionPath, JSON.stringify(session, null, 2), { mode: 0o600 });
       } catch {}
     }
 
@@ -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,314 @@
+/**
+ * Shared config utilities for Plexor slash commands.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+const { PLEXOR_DIR, CONFIG_PATH } = require('./constants');
+
+const DISABLED_HINT_VALUES = new Set(['', 'auto', 'none', 'off']);
+const VALID_ORCHESTRATION_MODES = new Set(['supervised', 'autonomous', 'danger-full-auto']);
+const VALID_ROUTING_MODES = new Set(['eco', 'balanced', 'quality', 'passthrough', 'cost']);
+const MANAGED_HEADER_KEYS = new Set([
+  'x-force-provider',
+  'x-force-model',
+  'x-allow-providers',
+  'x-deny-providers',
+  'x-allow-models',
+  'x-deny-models',
+  'x-plexor-mode',
+  'x-plexor-orchestration-mode'
+]);
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+
+function normalizeForcedProvider(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized || normalized === 'auto') {
+    return 'auto';
+  }
+  return normalized;
+}
+
+function normalizeForcedModel(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim();
+  if (!normalized || DISABLED_HINT_VALUES.has(normalized.toLowerCase())) {
+    return null;
+  }
+  return normalized;
+}
+
+function normalizeCsv(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const tokens = value
+    .split(',')
+    .map((token) => token.trim())
+    .filter(Boolean);
+  if (!tokens.length) {
+    return null;
+  }
+  return tokens.join(',');
+}
+
+function parseCustomHeaders(raw) {
+  if (typeof raw !== 'string' || !raw.trim()) {
+    return {};
+  }
+  const trimmedRaw = raw.trim();
+
+  // Backward compatibility: older plugin versions persisted ANTHROPIC_CUSTOM_HEADERS
+  // as a JSON object string. Parse that first so managed key replacement works.
+  if (trimmedRaw.startsWith('{')) {
+    try {
+      const legacy = JSON.parse(trimmedRaw);
+      if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+        const out = {};
+        for (const [key, value] of Object.entries(legacy)) {
+          const normalizedKey = String(key || '').trim().toLowerCase();
+          const normalizedValue = String(value ?? '').trim();
+          if (!normalizedKey || !normalizedValue) {
+            continue;
+          }
+          out[normalizedKey] = normalizedValue;
+        }
+        return out;
+      }
+    } catch {
+      // Fall through to line-based parser.
+    }
+  }
+
+  const parsed = {};
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const idx = trimmed.indexOf(':');
+    if (idx <= 0) {
+      continue;
+    }
+    const key = trimmed.slice(0, idx).trim().toLowerCase();
+    const value = trimmed.slice(idx + 1).trim();
+    if (!key || !value) {
+      continue;
+    }
+    parsed[key] = value;
+  }
+  return parsed;
+}
+
+function serializeCustomHeaders(headers) {
+  return Object.entries(headers)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join('\n');
+}
+
+function buildManagedAnthropicHeaders(config) {
+  const settings = config?.settings || {};
+  const headers = {};
+
+  const modeRaw = String(settings.mode || '')
+    .trim()
+    .toLowerCase();
+  if (VALID_ROUTING_MODES.has(modeRaw)) {
+    headers['x-plexor-mode'] = modeRaw === 'cost' ? 'eco' : modeRaw;
+  }
+
+  const orchestrationRaw = String(
+    settings.orchestrationMode || settings.orchestration_mode || ''
+  )
+    .trim()
+    .toLowerCase();
+  if (VALID_ORCHESTRATION_MODES.has(orchestrationRaw)) {
+    headers['x-plexor-orchestration-mode'] = orchestrationRaw;
+  }
+
+  const forceProvider = normalizeForcedProvider(
+    settings.preferred_provider ?? settings.preferredProvider ?? 'auto'
+  );
+  if (forceProvider && forceProvider !== 'auto') {
+    headers['x-force-provider'] = forceProvider;
+  }
+
+  const forceModel = normalizeForcedModel(settings.preferred_model ?? settings.preferredModel);
+  if (forceModel) {
+    headers['x-force-model'] = forceModel;
+  }
+
+  const allowProviders = normalizeCsv(
+    settings.provider_allowlist ?? settings.providerAllowlist ?? ''
+  );
+  if (allowProviders) {
+    headers['x-allow-providers'] = allowProviders;
+  }
+
+  const denyProviders = normalizeCsv(settings.provider_denylist ?? settings.providerDenylist ?? '');
+  if (denyProviders) {
+    headers['x-deny-providers'] = denyProviders;
+  }
+
+  const allowModels = normalizeCsv(settings.model_allowlist ?? settings.modelAllowlist ?? '');
+  if (allowModels) {
+    headers['x-allow-models'] = allowModels;
+  }
+
+  const denyModels = normalizeCsv(settings.model_denylist ?? settings.modelDenylist ?? '');
+  if (denyModels) {
+    headers['x-deny-models'] = denyModels;
+  }
+
+  return headers;
+}
+
+function syncClaudeCustomHeaders(config) {
+  try {
+    let settings = {};
+    if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const raw = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+      settings = raw.trim() ? JSON.parse(raw) : {};
+    }
+
+    if (typeof settings !== 'object' || settings === null || Array.isArray(settings)) {
+      settings = {};
+    }
+    settings.env = settings.env && typeof settings.env === 'object' ? settings.env : {};
+
+    const existing = parseCustomHeaders(settings.env.ANTHROPIC_CUSTOM_HEADERS);
+    for (const key of MANAGED_HEADER_KEYS) {
+      delete existing[key];
+    }
+
+    const managed = buildManagedAnthropicHeaders(config);
+    const merged = { ...existing, ...managed };
+
+    if (Object.keys(merged).length) {
+      settings.env.ANTHROPIC_CUSTOM_HEADERS = serializeCustomHeaders(merged);
+    } else {
+      delete settings.env.ANTHROPIC_CUSTOM_HEADERS;
+    }
+
+    const claudeDir = path.dirname(CLAUDE_SETTINGS_PATH);
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true, mode: 0o700 });
+    }
+    const tempPath = path.join(claudeDir, `.settings.${crypto.randomBytes(8).toString('hex')}.tmp`);
+    fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function hasForcedHintConflict(config) {
+  const settings = config?.settings || {};
+  const provider = normalizeForcedProvider(
+    settings.preferred_provider ?? settings.preferredProvider ?? 'auto'
+  );
+  const model = normalizeForcedModel(settings.preferred_model ?? settings.preferredModel);
+  return Boolean(model) && provider !== 'auto';
+}
+
+function validateForcedHintConfig(config) {
+  if (!hasForcedHintConflict(config)) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    message:
+      'Invalid Plexor config: set only one force hint. Use preferred_provider OR preferred_model, not both.'
+  };
+}
+
+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 {
+    const validation = validateForcedHintConfig(config);
+    if (!validation.ok) {
+      console.error(`Error: ${validation.message}`);
+      return false;
+    }
+
+    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);
+    // Best-effort sync to Claude client headers so force hints are respected.
+    syncClaudeCustomHeaders(config);
+    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,
+  hasForcedHintConflict,
+  validateForcedHintConfig,
+  parseCustomHeaders,
+  serializeCustomHeaders,
+  buildManagedAnthropicHeaders
+};

package/lib/config.js

@@ -5,6 +5,7 @@
 const fs = require('fs');
 const path = require('path');
 const { CONFIG_PATH, PLEXOR_DIR, DEFAULT_API_URL, DEFAULT_TIMEOUT } = require('./constants');
+const { validateForcedHintConfig } = require('./config-utils');
 
 class ConfigManager {
   constructor() {
@@ -22,7 +23,10 @@ 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',
+        preferredModel: cfg.settings?.preferredModel || cfg.settings?.preferred_model || null,
+        orchestrationMode:
+          cfg.settings?.orchestrationMode || cfg.settings?.orchestration_mode || 'autonomous'
       };
     } catch {
       return { enabled: false, apiKey: '', apiUrl: DEFAULT_API_URL };
@@ -52,11 +56,26 @@ 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,
+          preferred_model:
+            config.preferredModel ??
+            config.preferred_model ??
+            existing.settings?.preferredModel ??
+            existing.settings?.preferred_model,
+          orchestrationMode:
+            config.orchestrationMode ??
+            config.orchestration_mode ??
+            existing.settings?.orchestrationMode ??
+            existing.settings?.orchestration_mode
         }
       };
 
-      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2));
+      const validation = validateForcedHintConfig(updated);
+      if (!validation.ok) {
+        return false;
+      }
+
+      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2), { mode: 0o600 });
       return true;
     } catch {
       return false;