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

package/hooks/intercept.js

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

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