winter-super-cli 2026.5.27 → 2026.5.29

package/src/ai/prompts/system-prompt.js

@@ -1,9 +1,13 @@
 /**
  * Dynamic System Prompt Builder
  * Builds context-aware system prompts based on task, role, and session state.
+ * Small models get compact structural guidance so the task stays in focus.
  */
 
+import { isSmallModel, getModelCapabilityLabel } from '../model-capabilities.js';
+
 const BASE_PRINCIPLES = [
+  'Execute, don\'t describe - Do the work, don\'t write plans about doing the work',
   'Think Before Coding - State assumptions, ask when unclear',
   'Simplicity First - Minimum code that solves the problem',
   'Surgical Changes - Touch only what you must',
@@ -36,55 +40,122 @@ function buildEnvironmentSummary() {
   ].join('\n');
 }
 
-export function buildSystemPrompt({
-  role = 'coding',
-  context,
-  tools = [],
-  session,
-  environment,
-} = {}) {
-  const parts = [
-    `You are Winter, an expert AI coding assistant.`,
-    '',
-    '## Core Principles',
-    ...BASE_PRINCIPLES.map((p, i) => `${i + 1}. ${p}`),
-    '',
-    '## Runtime Environment',
-    environment || buildEnvironmentSummary(),
-    '',
-  ];
+function formatToolList(tools = []) {
+  return tools.length > 0 ? tools.slice(0, 10).join(', ') : '';
+}
 
-  if (tools.length > 0) {
-    parts.push('## Available Tools', tools.join(', '), '');
-  }
+function appendSharedContext(parts, { environment, session, design, resourceContext, context, includeResources = false } = {}) {
+  parts.push('## Runtime Environment', environment || buildEnvironmentSummary(), '');
 
   if (session?.memory?.length) {
     parts.push('## Session Memory');
-    session.memory.forEach(m => parts.push(`  - ${m.substring(0, 120)}`));
+    session.memory.slice(-5).forEach(m => parts.push('- ' + String(m).slice(0, 100)));
     parts.push('');
   }
 
   if (session?.plans?.length) {
     parts.push('## Active Plans');
-    session.plans.forEach(p => parts.push(`  - ${p.title || p.substring(0, 80)}`));
+    session.plans.slice(-3).forEach(p => parts.push('- ' + (p.title || String(p).slice(0, 80))));
     parts.push('');
   }
 
+  if (design) {
+    parts.push('## Design Context');
+    if (design.brand) {
+      parts.push('Brand: ' + design.brand);
+      parts.push(design.content.split('\n').filter(Boolean).slice(0, 18).join('\n'));
+    } else if (design.type === 'design_hint') {
+      parts.push('Available design systems: ' + design.brands.slice(0, 5).join(', '));
+    }
+    parts.push('');
+  }
+
+  if (includeResources && resourceContext) {
+    parts.push(resourceContext.trim().slice(0, 1200), '');
+  }
+
+  if (context && typeof context === 'object') {
+    parts.push('Task: ' + (context.category || 'coding') + ' / ' + (context.type || 'simple'), '');
+  }
+}
+
+function buildCompactSmallModelPrompt(options = {}) {
+  const { tools = [], modelTier } = options;
+  const parts = [
+    'You are Winter, an AI coding assistant running on a ' + getModelCapabilityLabel(modelTier) + '.',
+    '',
+    '## Operating Rules',
+    '1. Understand the user request first. If project state matters, inspect files before answering.',
+    '2. Keep context tight. Use only relevant tools and avoid long explanations.',
+    '3. For coding: Read/Grep/Glob -> Edit/Write -> Bash/test. Do not guess file paths.',
+    '4. Final answer in Vietnamese. Mention changed files and verification only.',
+    '',
+  ];
+
+  const toolList = formatToolList(tools);
+  if (toolList) parts.push('## Tools', toolList, '');
+  appendSharedContext(parts, { ...options, includeResources: false });
+
   parts.push(
-    '## Guidelines',
-    '- After using tools, always provide a direct final answer to the user.',
-    '- Answer normal questions directly without unnecessary legal or policy disclaimers.',
-    '- If a request is illegal, unsafe, or harmful, refuse briefly and offer a safe alternative.',
-    '- Be proactive: anticipate what the user needs next.',
+    '## Response Shape',
+    '- If action is needed, use tools instead of describing the action.',
+    '- Keep final output short and concrete.',
   );
 
-  return parts.join('\n');
+  return parts.filter(Boolean).join('\n');
+}
+
+function buildStandardSystemPrompt(options = {}) {
+  const { role = 'coding', tools = [], resourceContext } = options;
+  const parts = [
+    'You are Winter, an expert AI coding assistant.',
+    '',
+    '## Core Principles',
+    ...BASE_PRINCIPLES.map((p, i) => (i + 1) + '. ' + p),
+    '',
+    '## Tool Usage',
+    'Use tools when they materially improve correctness. Inspect before editing. Verify after changes.',
+    'Never invent file paths, APIs, command output, or test results.',
+    '',
+  ];
+
+  const toolList = formatToolList(tools);
+  if (toolList) parts.push('## Tools', toolList, '');
+  appendSharedContext(parts, { ...options, includeResources: Boolean(resourceContext) && (role === 'design' || role === 'ui') });
+
+  parts.push('Always respond in Vietnamese.');
+  return parts.filter(Boolean).join('\n');
+}
+
+export function buildSystemPrompt({
+  role = 'coding',
+  context,
+  tools = [],
+  session,
+  environment,
+  design,
+  resourceContext,
+  modelTier,
+} = {}) {
+  const options = { role, context, tools, session, environment, design, resourceContext, modelTier };
+  return isSmallModel(modelTier)
+    ? buildCompactSmallModelPrompt(options)
+    : buildStandardSystemPrompt(options);
 }
 
 export function buildFastSystemPrompt({
   role = 'coding',
   tools = [],
+  modelTier,
 } = {}) {
+  if (modelTier && isSmallModel(modelTier)) {
+    return [
+      'Winter (fast mode - small model). Be concise. Use tools when needed.',
+      tools.length > 0 ? `Tools: ${tools.join(', ')}` : '',
+      'Use a brief private plan, then answer in 1 sentence.',
+    ].filter(Boolean).join('\n');
+  }
+
   return [
     'You are Winter (fast mode). Be concise. Use tools when needed.',
     tools.length > 0 ? `Tools: ${tools.join(', ')}` : '',
@@ -92,20 +163,26 @@ export function buildFastSystemPrompt({
   ].filter(Boolean).join('\n');
 }
 
-export function buildAgentSystemPrompt(role, { tools = [] } = {}) {
+export function buildAgentSystemPrompt(role, { tools = [], modelTier } = {}) {
   const roleConfigs = {
     plan: 'You analyze codebases and plan multi-step implementations. Output clear steps.',
     review: 'You review code for bugs, style issues, and improvements. Be critical but constructive.',
     debug: 'You are a debug specialist. Use systematic elimination to find root causes.',
     research: 'You search codebases and documentation to answer questions comprehensively.',
     browser: 'You interact with web pages via browser automation. Report findings clearly.',
+    coding: 'You solve coding tasks directly. Inspect files, edit surgically, and verify.',
   };
 
   const base = roleConfigs[role] || roleConfigs.coding;
+  const smallNote = modelTier && isSmallModel(modelTier)
+    ? '\n\nYou are running on a small model. Keep context tight, use tools early, and keep final output short.'
+    : '';
+
   return [
     `You are Winter (${role} agent).`,
     base,
     tools.length > 0 ? `\nTools: ${tools.join(', ')}` : '',
+    smallNote,
     '\nCRITICAL: Output only the requested format. No extra commentary.',
   ].filter(Boolean).join('\n');
 }

package/src/ai/prompts/task-classifier.js

@@ -24,6 +24,8 @@ export const TASK_CATEGORIES = {
   TEST: 'test',
   CONFIG: 'config',
   INSTALL: 'install',
+  DESIGN: 'design',
+  UI: 'ui',
 };
 
 const TYPE_KEYWORDS = {
@@ -39,6 +41,8 @@ const TYPE_KEYWORDS = {
   test: ['test', 'unit test', 'integration test', 'assert', 'spec'],
   config: ['config', 'setup', 'install', 'configure', 'initialize'],
   install: ['install', 'npm install', 'pip install', 'gem install', 'cargo install', 'brew install'],
+  design: ['design', 'ui', 'brand', 'style guide', 'make it look', 'pixel perfect', 'layout', 'color scheme', 'palette', 'typography', 'theme'],
+  ui: ['ui', 'interface', 'component', 'button', 'card', 'modal', 'form', 'navbar', 'sidebar', 'header', 'footer', 'dashboard', 'landing page'],
 };
 
 const COMPLEXITY_SIGNALS = {
@@ -108,7 +112,7 @@ export function classifyTask(userInput) {
     wordCount,
     estimatedTokens,
     requiresTools: bestCategory !== TASK_CATEGORIES.EXPLAIN,
-    requiresContext: ['edit', 'refactor', 'debug', 'review', 'test'].includes(bestCategory),
+    requiresContext: ['edit', 'refactor', 'debug', 'review', 'test', 'design', 'ui'].includes(bestCategory),
   };
 }
 

package/src/ai/providers.js

@@ -8,6 +8,9 @@ import { selectExecutionProfile } from '../context/router.js';
 import { buildSystemPrompt, buildFastSystemPrompt, buildAgentSystemPrompt } from './prompts/system-prompt.js';
 import { classifyTask } from './prompts/task-classifier.js';
 import SuccessCriteria from './prompts/success-criteria.js';
+import { ReasoningConfig, REASONING_LEVELS, complexityToReasoningLevel } from './reasoning.js';
+import { buildResourceContext, getRelevantDesignGuide } from '../context/resource-loader.js';
+import { classifyModelTier } from './model-capabilities.js';
 
 function isAuthError(error) {
   const msg = String(error?.message || error || '');
@@ -23,6 +26,10 @@ export class AIProviderManager {
     this.tools = [];
     this.initialized = false;
     this.authToken = null;
+    this._cachedResourceContext = '';
+    this._cachedDesignGuide = null;
+    this._fallbackWarned = false;
+    this._modelTier = null;
   }
 
   async init() {
@@ -96,9 +103,17 @@ export class AIProviderManager {
       if (available) this.activeProvider = available;
     }
 
+    this.updateActiveModelTier();
+
     this.initialized = true;
   }
 
+  updateActiveModelTier() {
+    const providerConfig = this.providers[this.activeProvider] || {};
+    this._modelTier = classifyModelTier(providerConfig.model, this.activeProvider);
+    return this._modelTier;
+  }
+
   async loadAuthToken() {
     // 1) Honor explicit environment variables (highest priority)
     const envToken = process.env.CLAUDE_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_TOKEN || null;
@@ -158,6 +173,7 @@ export class AIProviderManager {
     const providerName = this.normalizeProviderName(name);
     if (this.providers[providerName]) {
       this.activeProvider = providerName;
+      this.updateActiveModelTier();
       return true;
     }
     return false;
@@ -229,17 +245,27 @@ export class AIProviderManager {
     const routedProvider = this.providers[executionProfile.provider] || this.providers[this.activeProvider];
     const defaultProvider = this.providers[this.activeProvider];
 
+    const routingModel = options.model || executionProfile.model;
+    const routingReasoning = options.reasoning || executionProfile.reasoningParam;
+
     try {
       return await withRetry(() => this.sendRequestToProvider(routedProvider, messages, {
         ...options,
-        model: options.model || executionProfile.model,
+        model: routingModel,
+        reasoning: routingReasoning,
+        reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
       }), { maxAttempts: 3, baseDelayMs: 150 });
     } catch (error) {
       if (isAuthError(error) && routedProvider !== defaultProvider && defaultProvider) {
-        console.warn(`[winter] ${executionProfile.provider} provider auth error, falling back to ${this.activeProvider}`);
+        if (!this._fallbackWarned) {
+          console.warn(`[winter] ${executionProfile.provider} auth error, falling back to ${this.activeProvider}`);
+          this._fallbackWarned = true;
+        }
         return await withRetry(() => this.sendRequestToProvider(defaultProvider, messages, {
           ...options,
           model: options.model || defaultProvider.model,
+          reasoning: routingReasoning,
+          reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
         }), { maxAttempts: 1, baseDelayMs: 0 });
       }
       throw error;
@@ -257,17 +283,27 @@ export class AIProviderManager {
     const routedProvider = this.providers[executionProfile.provider] || this.providers[this.activeProvider];
     const defaultProvider = this.providers[this.activeProvider];
 
+    const routingModel = options.model || executionProfile.model;
+    const routingReasoning = options.reasoning || executionProfile.reasoningParam;
+
     try {
       yield* this.streamRequestToProvider(routedProvider, messages, {
         ...options,
-        model: options.model || executionProfile.model,
+        model: routingModel,
+        reasoning: routingReasoning,
+        reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
       });
     } catch (error) {
       if (isAuthError(error) && routedProvider !== defaultProvider && defaultProvider) {
-        console.warn(`[winter] ${executionProfile.provider} provider auth error, falling back to ${this.activeProvider}`);
+        if (!this._fallbackWarned) {
+          console.warn(`[winter] ${executionProfile.provider} auth error, falling back to ${this.activeProvider}`);
+          this._fallbackWarned = true;
+        }
         yield* this.streamRequestToProvider(defaultProvider, messages, {
           ...options,
           model: options.model || defaultProvider.model,
+          reasoning: routingReasoning,
+          reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
         });
       } else {
         throw error;
@@ -285,6 +321,17 @@ export class AIProviderManager {
       messages,
     };
 
+    // Apply reasoning configuration
+    const reasoningParam = options.reasoning || this._getReasoningParam(options, provider);
+    if (reasoningParam) {
+      if (reasoningParam.reasoning_effort) {
+        body.reasoning_effort = reasoningParam.reasoning_effort;
+      }
+      if (reasoningParam.thinking) {
+        body.thinking = reasoningParam.thinking;
+      }
+    }
+
     if (this.tools.length > 0 && options.enableTools) {
       body.tools = this.tools;
     }
@@ -329,6 +376,17 @@ export class AIProviderManager {
       body.stream_options = { include_usage: true };
     }
 
+    // Apply reasoning configuration
+    const reasoningParam = options.reasoning || this._getReasoningParam(options, provider);
+    if (reasoningParam) {
+      if (reasoningParam.reasoning_effort) {
+        body.reasoning_effort = reasoningParam.reasoning_effort;
+      }
+      if (reasoningParam.thinking) {
+        body.thinking = reasoningParam.thinking;
+      }
+    }
+
     if (this.tools.length > 0 && options.enableTools) {
       body.tools = this.tools;
     }
@@ -519,32 +577,111 @@ export class AIProviderManager {
     return { error: 'Tool execution handled by REPL' };
   }
 
+  _getReasoningParam(options, provider) {
+    // 1. Explicit reasoning param passed through options
+    if (options.reasoning) return options.reasoning;
+
+    // 2. Reasoning level specified -> build from level
+    if (options.reasoningLevel) {
+      const config = new ReasoningConfig({
+        level: options.reasoningLevel,
+        provider: provider?.name || this.activeProvider,
+      });
+      return config.getApiReasoningParam();
+    }
+
+    // 3. No reasoning config at all
+    return null;
+  }
+
   getSystemPrompt(options = {}) {
     const taskInfo = options.task ? classifyTask(options.task) : null;
-    const tools = this.tools ? Object.keys(this.tools) : [];
+    const tools = Array.isArray(this.tools)
+      ? this.tools.map(tool => tool?.function?.name || tool?.name).filter(Boolean)
+      : [];
     const sessionInfo = {
       memory: options.memory || [],
       plans: options.plans || [],
     };
 
+    // Inject reasoning instructions if applicable
+    let reasoningPrompt = '';
+    if (options.reasoningLevel || options.reasoningPrompt) {
+      reasoningPrompt = options.reasoningPrompt || new ReasoningConfig({
+        level: options.reasoningLevel || REASONING_LEVELS.MEDIUM,
+        provider: this.activeProvider,
+        modelTier: this._modelTier,
+      }).getPromptInstructions();
+    } else if (taskInfo) {
+      // Auto-inject based on task complexity for providers without API reasoning
+      const level = complexityToReasoningLevel(taskInfo.type);
+      const config = new ReasoningConfig({
+        level,
+        provider: this.activeProvider,
+        modelTier: this._modelTier,
+      });
+      if (config.needsPromptInjection && level !== REASONING_LEVELS.NONE) {
+        reasoningPrompt = config.getPromptInstructions();
+      }
+    }
+
     if (options.role === 'agent') {
-      return buildAgentSystemPrompt(options.agentRole || 'coding', { tools });
+      return buildAgentSystemPrompt(options.agentRole || 'coding', { tools, modelTier: this._modelTier }) + reasoningPrompt;
     }
 
     if (options.fast) {
-      return buildFastSystemPrompt({ role: 'coding', tools });
+      return buildFastSystemPrompt({ role: 'coding', tools, modelTier: this._modelTier });
     }
 
     const successPrompt = options.task
       ? '\n\n' + SuccessCriteria.fromRequest(options.task).buildPrompt()
       : '';
 
+    const resourceContext = options.includeResources ? (this._cachedResourceContext || '') : '';
+
+    // Auto-detect relevant design guide for UI/design tasks
+    let designGuide = null;
+    if (taskInfo && (taskInfo.category === 'design' || taskInfo.category === 'ui')) {
+      this._designGuidePromise = this._designGuidePromise || this._loadDesignGuide(options.task);
+    }
+    const design = this._cachedDesignGuide || null;
+
     return buildSystemPrompt({
       role: taskInfo?.category || 'coding',
       context: taskInfo,
       tools,
       session: sessionInfo,
-    }) + successPrompt;
+      design,
+      resourceContext,
+      modelTier: this._modelTier,
+    }) + reasoningPrompt + successPrompt;
+  }
+
+  /**
+   * Load resource context (cached for session lifetime).
+   */
+  async _loadResourceContext() {
+    try {
+      this._cachedResourceContext = await buildResourceContext();
+    } catch (e) {
+      this._cachedResourceContext = '';
+    }
+    return this._cachedResourceContext;
+  }
+
+  /**
+   * Load relevant design guide for a task.
+   */
+  async _loadDesignGuide(task) {
+    try {
+      const guide = await getRelevantDesignGuide(task);
+      if (guide) {
+        this._cachedDesignGuide = guide;
+      }
+    } catch (e) {
+      // Silently fail - design context is optional
+    }
+    return this._cachedDesignGuide;
   }
 
   classifyTask(userInput) {

package/src/ai/reasoning.js

@@ -0,0 +1,190 @@
+/**
+ * Reasoning Configuration Manager
+ * 
+ * Controls reasoning effort / extended thinking per provider and task complexity.
+ * 
+ * Supported APIs:
+ * - OpenAI: reasoning_effort ("low" | "medium" | "high") — o1, o3 models
+ * - Anthropic: thinking ({ type: "enabled", budget_tokens: number }) — Claude 3.7+ Sonnet
+ * - DeepSeek: built-in CoT reasoning (no explicit param needed)
+ * - Others: falls back to prompt-level reasoning instructions
+ */
+
+import { isSmallModel } from './model-capabilities.js';
+
+export const REASONING_LEVELS = {
+  NONE: 'none',
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  MAX: 'max',
+};
+
+const REASONING_EFFORT_MAP = {
+  [REASONING_LEVELS.NONE]: null,
+  [REASONING_LEVELS.LOW]: 'low',
+  [REASONING_LEVELS.MEDIUM]: 'medium',
+  [REASONING_LEVELS.HIGH]: 'high',
+  [REASONING_LEVELS.MAX]: 'high',
+};
+
+const EXTENDED_THINKING_BUDGET_MAP = {
+  [REASONING_LEVELS.NONE]: null,
+  [REASONING_LEVELS.LOW]: 1024,
+  [REASONING_LEVELS.MEDIUM]: 4096,
+  [REASONING_LEVELS.HIGH]: 8192,
+  [REASONING_LEVELS.MAX]: 16384,
+};
+
+/**
+ * Standard reasoning prompt templates for API-level reasoning models.
+ */
+/**
+ * Unified deep reasoning prompts — ALL models use these aggressive templates.
+ * Every model, regardless of size, must think step by step with explicit structure.
+ * The structured <thinking> format forces deep reasoning, catches edge cases,
+ * and produces significantly higher quality code.
+ */
+const REASONING_PROMPT_TEMPLATES = {
+  [REASONING_LEVELS.NONE]: '',
+  [REASONING_LEVELS.LOW]:
+    'Think briefly before acting. Keep the final answer concise.',
+  [REASONING_LEVELS.MEDIUM]:
+    'Before editing: identify relevant files, make the smallest change, then verify. Do not show long reasoning.',
+  [REASONING_LEVELS.HIGH]:
+    'Use a private reasoning plan: understand the request, inspect evidence, implement surgically, verify with commands, then summarize.',
+  [REASONING_LEVELS.MAX]:
+    'For complex work, maintain a private checklist covering requirements, files, risks, implementation, and verification. Show only useful results.',
+};
+
+/**
+ * Maps task complexity to recommended reasoning level.
+ */
+export function complexityToReasoningLevel(taskType) {
+  switch (taskType) {
+    case 'quick': return REASONING_LEVELS.NONE;
+    case 'simple': return REASONING_LEVELS.LOW;
+    case 'moderate': return REASONING_LEVELS.MEDIUM;
+    case 'complex': return REASONING_LEVELS.HIGH;
+    case 'deep': return REASONING_LEVELS.MAX;
+    default: return REASONING_LEVELS.MEDIUM;
+  }
+}
+
+export class ReasoningConfig {
+  /**
+   * @param {object} options
+   * @param {string} options.level - One of REASONING_LEVELS
+   * @param {string} options.provider - Provider name (for API-specific config)
+   * @param {string} [options.modelTier] - Model capability tier from model-capabilities.js
+   * @param {object} [options.modelInfo] - Model metadata
+   * @param {object} [options.taskInfo] - Task classification result from task-classifier
+   */
+  constructor(options = {}) {
+    this.level = options.level || REASONING_LEVELS.MEDIUM;
+    this.provider = options.provider || '';
+    this.modelTier = options.modelTier || null;
+    this.modelInfo = options.modelInfo || {};
+    this.taskInfo = options.taskInfo || null;
+  }
+
+  /**
+   * Whether reasoning is enabled at all.
+   */
+  get enabled() {
+    return this.level !== REASONING_LEVELS.NONE && this.level !== null;
+  }
+
+  /**
+   * Whether this level should inject reasoning instructions into the system prompt.
+   */
+  get needsPromptInjection() {
+    return this.providerSupportsApiReasoning === false || !this.provider;
+  }
+
+  /**
+   * Check if provider has native API-level reasoning support.
+   */
+  get providerSupportsApiReasoning() {
+    const p = (this.provider || '').toLowerCase();
+    if (p === 'openai') return true;
+    if (p === 'anthropic' || p === 'claude') return true;
+    return false;
+  }
+
+  /**
+   * Whether this is a small model that needs aggressive prompting.
+   */
+  get isSmall() {
+    return this.modelTier ? isSmallModel(this.modelTier) : false;
+  }
+
+  /**
+   * Get the API-level reasoning parameter for the request body.
+   * Returns null if provider doesn't support API reasoning or level is NONE.
+   */
+  getApiReasoningParam() {
+    if (!this.enabled) return null;
+
+    const p = (this.provider || '').toLowerCase();
+
+    if (p === 'openai') {
+      const effort = REASONING_EFFORT_MAP[this.level];
+      if (!effort) return null;
+      return { reasoning_effort: effort };
+    }
+
+    if (p === 'anthropic' || p === 'claude') {
+      const budget = EXTENDED_THINKING_BUDGET_MAP[this.level];
+      if (!budget) return null;
+      return {
+        thinking: {
+          type: 'enabled',
+          budget_tokens: budget,
+        },
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Get reasoning prompt instructions to inject into the system prompt.
+   * Compact prompt-level reasoning instructions for providers without API reasoning.
+   * @param {string} [modelTier] - Unused, kept for backward compatibility.
+   * @returns {string}
+   */
+  getPromptInstructions(modelTier) {
+    if (!this.enabled || this.providerSupportsApiReasoning) return '';
+    return REASONING_PROMPT_TEMPLATES[this.level] || '';
+  }
+
+  /**
+   * Build a reasoning config for a given provider and task info.
+   */
+  static fromTask(taskInfo, provider, options = {}) {
+    const level = options.reasoningLevel
+      || (taskInfo ? complexityToReasoningLevel(taskInfo.type) : REASONING_LEVELS.MEDIUM);
+
+    return new ReasoningConfig({
+      level,
+      provider: provider || '',
+      taskInfo: taskInfo || null,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Default reasoning configuration for the system.
+ */
+export const DEFAULT_REASONING_CONFIG = {
+  defaultLevel: REASONING_LEVELS.MEDIUM,
+  maxBudgetTokens: 16384,
+  // Per-provider overrides
+  providers: {
+    openai: { supports: true, paramType: 'reasoning_effort' },
+    anthropic: { supports: true, paramType: 'thinking' },
+    claude: { supports: true, paramType: 'thinking' },
+  },
+};