winter-super-cli 2026.5.27 → 2026.5.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "winter-super-cli",
-  "version": "2026.5.27",
+  "version": "2026.5.28",
   "description": "❄️ AI-Powered Development CLI with Interactive REPL",
   "type": "module",
   "main": "bin/winter.js",

package/src/ai/model-capabilities.js

@@ -0,0 +1,185 @@
+/**
+ * ❄️ MODEL CAPABILITIES ❄️
+ * Detect AI model capability tier from model name.
+ * Small models need aggressive prompting to compete with large ones.
+ */
+
+export const MODEL_TIERS = {
+  TINY: 'tiny',      // <3B params — barely functional for code
+  SMALL: 'small',    // 3B-15B params — basic code ability
+  MEDIUM: 'medium',  // 15B-40B params — decent code ability
+  LARGE: 'large',    // 40B-120B params — strong code ability, could be flagship
+  FLAGSHIP: 'flagship', // 120B+ or proprietary frontier models
+};
+
+/**
+ * Ordered tiers from weakest to strongest (for comparison).
+ */
+const TIER_ORDER = [MODEL_TIERS.TINY, MODEL_TIERS.SMALL, MODEL_TIERS.MEDIUM, MODEL_TIERS.LARGE, MODEL_TIERS.FLAGSHIP];
+
+/**
+ * Classify a model name into a capability tier.
+ * @param {string} modelName - e.g. "llama3", "gpt-4", "qwen2.5:7b"
+ * @param {string} [provider] - e.g. "ollama", "openai" (optional, helps disambiguate)
+ * @returns {string} One of MODEL_TIERS
+ */
+export function classifyModelTier(modelName, provider = '') {
+  const name = (modelName || '').toLowerCase().trim();
+  const prov = (provider || '').toLowerCase().trim();
+
+  // ===== FLAGSHIP (frontier models) =====
+  const flagshipPatterns = [
+    /claude-3-5-sonnet/i, /claude-opus/i, /claude-4/i, /claude-sonnet-4/i,
+    /gpt-4o/i, /gpt-4-turbo/i, /o1/i, /o3/i,
+    /gemini-2\.5-pro/i, /gemini-2\.0-ultra/i,
+    /deepseek-v3/i, /deepseek-r1/i,
+    /llama-4/i, /llama-3-70b/i, /llama3-70b/i, /llama3\.1-70b/i, /llama3\.2-90b/i, /llama3\.3/i,
+    /qwen2\.5-?72b/i, /qwen2\.5-?70b/i, /qwen-?2\.5-?72b/i,
+    /mistral-large/i, /mixtral-8x22b/i,
+    /command-r-plus/i, /command-a/i,
+    /yi-?34b/i,
+    /dbrx-instruct/i,
+  ];
+
+  // If using a cloud provider like OpenAI/Anthropic/Groq, their default models are typically large+
+  if (prov === 'openai' || prov === 'anthropic' || prov === 'claude') {
+    if (name.includes('gpt-3.5') || name.includes('gpt-3')) return MODEL_TIERS.MEDIUM;
+    if (name.includes('claude-3-haiku') || name.includes('claude-3-5-haiku')) return MODEL_TIERS.MEDIUM;
+    return MODEL_TIERS.LARGE; // Default for OpenAI/Anthropic is >= gpt-4 level
+  }
+
+  if (prov === 'groq') {
+    // Groq runs open models, most are large but some are not
+    if (/llama.*8b|llama3.*8b|llama3\.2.*3b/i.test(name)) return MODEL_TIERS.SMALL;
+    if (/gemma2.*9b/i.test(name)) return MODEL_TIERS.SMALL;
+    if (/mixtral-8x7|llama.*70b|llama3.*70b|llama3\.1.*70b|qwen/i.test(name)) return MODEL_TIERS.LARGE;
+    return MODEL_TIERS.MEDIUM; // Default for Groq
+  }
+
+  // Check patterns for any provider
+  for (const pattern of flagshipPatterns) {
+    if (pattern.test(name)) return MODEL_TIERS.FLAGSHIP;
+  }
+
+  // ===== LARGE MODELS =====
+  const largePatterns = [
+    /claude-sonnet/i, /claude-3/i, /claude-2/i,
+    /gpt-4/i, /gpt-4-32k/i,
+    /llama-3\.1-?70b/i, /llama-3\.2-?70b/i, /llama3-?70b/i,
+    /llama-2-?70b/i,
+    /qwen-?2\.5-?32b/i, /qwen-?2-?72b/i,
+    /codellama-?70b/i,
+    /mixtral/i,
+    /deepseek-?v2/i,
+    /gemini-1\.5-pro/i, /gemini-2\.0-flash/i,
+    /command-r/i,
+    /yi-?34b/i,
+    /mistral-medium/i,
+  ];
+
+  for (const pattern of largePatterns) {
+    if (pattern.test(name)) return MODEL_TIERS.LARGE;
+  }
+
+  // ===== MEDIUM MODELS =====
+  const mediumPatterns = [
+    /qwen-?2\.5-?14b/i, /qwen-?2\.5-?7b/i, /qwen-?2/i,
+    /llama-3-?8b/i, /llama-3\.1-?8b/i, /llama-3\.2-?11b/i,
+    /llama-2-?13b/i, /llama-2-?7b/i,
+    /deepseek-coder-?6\.7b/i, /deepseek-coder-?33b/i,
+    /codellama-?34b/i, /codellama-?13b/i, /codellama-?7b/i,
+    /mistral/i, /mistral-7b/i,
+    /gemma-2-?9b/i, /gemma-?7b/i,
+    /phi-3/i, /phi-3-medium/i,
+    /nemotron/i,
+    /solar/i,
+    /dbrx/i,
+    /starcoder2/i,
+    /deepseek-llm/i,
+    /yi-?6b/i, /yi-?9b/i,
+  ];
+
+  for (const pattern of mediumPatterns) {
+    if (pattern.test(name)) return MODEL_TIERS.MEDIUM;
+  }
+
+  // ===== SMALL MODELS =====
+  const smallPatterns = [
+    /llama-3\.2-?3b/i, /llama-3\.2-?1b/i, /tinyllama/i,
+    /qwen-?2\.5-?3b/i, /qwen-?2\.5-?1\.5b/i, /qwen-?2\.5-?0\.5b/i,
+    /phi-?3-?mini/i, /phi-?2/i, /phi-?1/i,
+    /gemma-?2-?2b/i,
+    /stablelm/i,
+    /orca/i,
+    /falcon/i,
+    /red-pajama/i,
+    /pythia/i,
+    /opt/i,
+    /bloom/i,
+    /mpnet/i,
+  ];
+
+  for (const pattern of smallPatterns) {
+    if (pattern.test(name)) return MODEL_TIERS.SMALL;
+  }
+
+  if (/tiny/i.test(name) || /mini/i.test(name) || /small/i.test(name) || /nano/i.test(name)) {
+    return MODEL_TIERS.TINY;
+  }
+
+  // Fallback: if Ollama, likely small
+  if (prov === 'ollama' || prov === 'local') return MODEL_TIERS.SMALL;
+
+  // Default: assume medium
+  return MODEL_TIERS.MEDIUM;
+}
+
+/**
+ * Check if a model tier is considered "small" (needs aggressive prompting).
+ */
+export function isSmallModel(tier) {
+  return tier === MODEL_TIERS.TINY || tier === MODEL_TIERS.SMALL;
+}
+
+/**
+ * Get the index of a tier in the order array (0=weakest).
+ * @private
+ */
+function tierIndex(tier) {
+  const idx = TIER_ORDER.indexOf(tier);
+  return idx >= 0 ? idx : 2; // Default to medium index
+}
+
+/**
+ * Compare two tiers. Returns negative if a < b, positive if a > b, 0 if equal.
+ * @private
+ */
+function compareTiers(a, b) {
+  return tierIndex(a) - tierIndex(b);
+}
+
+/**
+ * Get recommended reasoning level bump for small models.
+ * Small models need more aggressive reasoning prompting to compensate.
+ */
+export function getReasoningBump(tier) {
+  switch (tier) {
+    case MODEL_TIERS.TINY: return 2;     // bump 2 levels
+    case MODEL_TIERS.SMALL: return 1;    // bump 1 level
+    default: return 0;
+  }
+}
+
+/**
+ * Build a short string describing model capability for system prompt injection.
+ */
+export function getModelCapabilityLabel(tier) {
+  switch (tier) {
+    case MODEL_TIERS.TINY: return 'tiny local model — needs maximum guidance';
+    case MODEL_TIERS.SMALL: return 'small local model — needs extra structure';
+    case MODEL_TIERS.MEDIUM: return 'medium-capability model';
+    case MODEL_TIERS.LARGE: return 'high-capability model';
+    case MODEL_TIERS.FLAGSHIP: return 'frontier model — full capability expected';
+    default: return '';
+  }
+}

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 aggressive structural guidance to compensate for limited capability.
  */
 
+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,15 +40,36 @@ function buildEnvironmentSummary() {
   ].join('\n');
 }
 
-export function buildSystemPrompt({
+/**
+ * Build a "boosted" system prompt for small/tiny models.
+ * Small models need: more explicit structure, strict formats, explicit step-by-step forcing.
+ */
+function buildSmallModelSystemPrompt({
   role = 'coding',
   context,
   tools = [],
   session,
   environment,
+  design,
+  resourceContext,
+  modelTier,
 } = {}) {
   const parts = [
-    `You are Winter, an expert AI coding assistant.`,
+    `You are Winter, an expert AI coding assistant. You are running on a ${getModelCapabilityLabel(modelTier)}.`,
+    '',
+    '## CRITICAL: YOU MUST THINK STEP BY STEP',
+    '',
+    'Because you are a smaller model, you MUST use structured thinking to produce quality results.',
+    'Before any response, use <thinking> tags to reason through the problem.',
+    '',
+    'Your thinking must cover:',
+    '1. What does the user want? (restate briefly)',
+    '2. What files/tools do I need to use?',
+    '3. What is the best approach?',
+    '4. What could go wrong? Edge cases?',
+    '5. Is my solution complete and correct?',
+    '',
+    'After thinking, THEN act. Never skip the thinking step.',
     '',
     '## Core Principles',
     ...BASE_PRINCIPLES.map((p, i) => `${i + 1}. ${p}`),
@@ -70,21 +95,79 @@ export function buildSystemPrompt({
     parts.push('');
   }
 
+  if (design) {
+    parts.push('## Design Guidelines');
+    if (design.brand) {
+      parts.push(`Brand: ${design.brand}`);
+      parts.push('');
+      const lines = design.content.split('\n').filter(Boolean);
+      const preview = lines.slice(0, 40).join('\n');
+      parts.push(preview);
+      if (lines.length > 40) parts.push('... (design file truncated)');
+    } else if (design.type === 'design_hint') {
+      parts.push('Design-related task detected. Consider applying one of the available design systems.');
+      parts.push(`Available: ${design.brands.join(', ')}`);
+    }
+    parts.push('');
+  }
+
+  if (resourceContext) {
+    parts.push(resourceContext);
+  }
+
   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.',
+    '## Execution Rules (STRICT)',
+    '- EXECUTE FIRST. Read files, then edit. Do NOT describe what you will do — just do it.',
+    '- Keep explanations under 2 sentences. Say what you changed, not what you could do.',
+    '- After using tools, give only a one-line summary of what was done.',
+    '- Answer questions directly — no disclaimers or warnings.',
+    '- If a request is unsafe, refuse briefly and stop.',
+    '',
+    '## Thinking Format (MANDATORY)',
+    '<thinking>',
+    'Step-by-step reasoning here...',
+    '</thinking>',
+    '[Your action/answer here]',
   );
 
   return parts.join('\n');
 }
+export function buildSystemPrompt({
+  role = 'coding',
+  context,
+  tools = [],
+  session,
+  environment,
+  design,
+  resourceContext,
+  modelTier,
+} = {}) {
+  // ALL models get the deep-thinking system prompt for maximum code quality
+  return buildSmallModelSystemPrompt({
+    role,
+    context,
+    tools,
+    session,
+    environment,
+    design,
+    resourceContext,
+    modelTier,
+  });
+}
 
 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(', ')}` : '',
+      'THINK inside <thinking> before acting. Keep responses to 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,7 +175,7 @@ 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.',
@@ -102,10 +185,15 @@ export function buildAgentSystemPrompt(role, { tools = [] } = {}) {
   };
 
   const base = roleConfigs[role] || roleConfigs.coding;
+  const smallNote = modelTier && isSmallModel(modelTier)
+    ? '\n\nYou are running on a small model. Use <thinking> tags and reason step by step before each action.'
+    : '';
+
   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,6 +103,13 @@ export class AIProviderManager {
       if (available) this.activeProvider = available;
     }
 
+    // Auto-detect model capability tier
+    const providerConfig = this.providers[this.activeProvider] || {};
+    this._modelTier = classifyModelTier(providerConfig.model, this.activeProvider);
+
+    // Eager-load local resources (design systems, agent instructions) for contextual injection
+    this._loadResourceContext(); // fire-and-forget
+
     this.initialized = true;
   }
 
@@ -229,17 +243,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 +281,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 +319,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 +374,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,6 +575,23 @@ 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) : [];
@@ -527,24 +600,85 @@ export class AIProviderManager {
       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()
       : '';
 
+    // Use cached resource context (eager-loaded in init())
+    const resourceContext = 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,266 @@
+/**
+ * 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 step by step before responding. Use <thinking> tags for your reasoning, then provide your answer.',
+  [REASONING_LEVELS.MEDIUM]:
+    'CRITICAL: You MUST think step by step inside <thinking> tags before every response.\n' +
+    '\n' +
+    '<thinking>\n' +
+    '1. What is the user asking for? (restate briefly)\n' +
+    '2. What do I know / what files do I need?\n' +
+    '3. What is the correct approach?\n' +
+    '4. What could go wrong? (edge cases, errors)\n' +
+    '5. How do I verify my solution?\n' +
+    '</thinking>\n' +
+    'Then provide your answer clearly and directly.',
+  [REASONING_LEVELS.HIGH]:
+    'CRITICAL DEEP REASONING REQUIRED. Use this EXACT structured thinking process:\n' +
+    '\n' +
+    '<thinking>\n' +
+    '## STEP 1: UNDERSTAND\n' +
+    '- Restate the problem in your own words\n' +
+    '- Identify all key requirements (explicit + implicit)\n' +
+    '\n' +
+    '## STEP 2: ANALYZE\n' +
+    '- What information is provided? What is missing?\n' +
+    '- Consider multiple approaches\n' +
+    '- List potential edge cases and pitfalls\n' +
+    '\n' +
+    '## STEP 3: PLAN\n' +
+    '- Outline your solution step by step\n' +
+    '- For code: plan the exact files and changes needed\n' +
+    '- Verify each step makes sense\n' +
+    '\n' +
+    '## STEP 4: VERIFY\n' +
+    '- Check your solution against all requirements\n' +
+    '- Look for mistakes, regressions, or missing pieces\n' +
+    '- How will you confirm it works?\n' +
+    '</thinking>\n' +
+    'After thinking, provide your final answer. The thinking is internal — be concise in your response.',
+  [REASONING_LEVELS.MAX]:
+    '## MANDATORY DEEP REASONING\n' +
+    'You MUST do extremely thorough reasoning before every response. Do not skip any step.\n' +
+    '\n' +
+    'Follow this EXACT thinking structure — fill out every section:\n' +
+    '\n' +
+    '<thinking>\n' +
+    '## PROBLEM RESTATEMENT\n' +
+    'State what the user needs in one sentence.\n' +
+    '\n' +
+    '## REQUIREMENTS ANALYSIS\n' +
+    '- Explicit requirements:\n' +
+    '- Implicit requirements:\n' +
+    '- Constraints / boundaries:\n' +
+    '\n' +
+    '## CONTEXT & CODEBASE ANALYSIS\n' +
+    '- What files are relevant?\n' +
+    '- What existing patterns should I follow?\n' +
+    '- What assumptions am I making?\n' +
+    '\n' +
+    '## APPROACH COMPARISON\n' +
+    '- Option 1: [describe]\n' +
+    '  Pros: ... Cons: ...\n' +
+    '- Option 2: [describe]\n' +
+    '  Pros: ... Cons: ...\n' +
+    '- Best choice: [pick and explain why]\n' +
+    '\n' +
+    '## IMPLEMENTATION PLAN\n' +
+    'Step-by-step what needs to happen:\n' +
+    '1. ...\n' +
+    '2. ...\n' +
+    '3. ...\n' +
+    '(For code: include exact files to read, edit, or create)\n' +
+    '\n' +
+    '## EDGE CASES & RISKS\n' +
+    '- What could go wrong?\n' +
+    '- How will I handle errors?\n' +
+    '- What about performance / security?\n' +
+    '\n' +
+    '## VERIFICATION STRATEGY\n' +
+    '- How will I confirm this works?\n' +
+    '- What tests or checks should be run?\n' +
+    '- What could break with these changes?\n' +
+    '</thinking>\n' +
+    '\n' +
+    'After closing </thinking>, provide your final implementation.\n' +
+    'Keep the reasoning internal — only show the user your result and a brief summary.',
+};
+
+/**
+ * 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.
+   * ALL models use the unified deep-reasoning templates.
+   * @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' },
+  },
+};

package/src/cli/repl-commands.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import { colors } from './snowflake-logo.js';
+import { SLASH_COMMANDS } from './slash-commands.js';
 
 /**
  * Handle slash commands in the Winter REPL.

package/src/cli/repl.js

@@ -241,6 +241,7 @@ export class WinterREPL {
     // Show banner only if not already shown
     if (!process.env.WINTER_BANNER_SHOWN) {
       console.log(welcomeBanner(this.version, info));
+      this.showCommandMenu();
       process.env.WINTER_BANNER_SHOWN = '1';
     } else {
       this.showStatus();
@@ -315,6 +316,7 @@ export class WinterREPL {
     console.log(`${colors.dim}Project: ${this.projectPath}${colors.reset}`);
     console.log(`${colors.dim}Provider: ${this.ai.getActiveProvider()}${colors.reset}`);
     console.log(`${colors.dim}Session: ${this.session.getSessionId().substring(0, 8)}${colors.reset}`);
+    console.log(`${colors.dim}Type ${colors.cyan}/help${colors.dim} for commands or ${colors.cyan}/${colors.dim} for menu${colors.reset}`);
     console.log('');
   }
 
@@ -1042,7 +1044,7 @@ ${colors.reset}
         const currentToolSignature = this.buildToolCallSignature(toolCalls);
         if (currentToolSignature && currentToolSignature === lastToolSignature) {
           console.log(`
-${colors.yellow}ℹ AI đang lặp lại cùng một chuỗi tool call. Dừng vòng lặp để tránh spam.${colors.reset}`);
+${colors.yellow}ℹ AI tool loop detected. Breaking out.${colors.reset}`);
           reachedToolLimit = false;
           break;
         }

package/src/context/resource-loader.js

@@ -0,0 +1,136 @@
+/**
+ * Resource Loader - Auto-discovers and indexes local resources
+ * (design systems, agent instructions, skills) for contextual injection.
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+const LOCAL_ROOT = path.join(PROJECT_ROOT, 'resources', 'local');
+
+// ── Design Systems ──────────────────────────────────────────────────────────
+
+const DESIGN_MD_DIR = path.join(LOCAL_ROOT, 'awesome-design-md', 'design-md');
+
+/**
+ * Discover all available design system brands.
+ */
+export async function discoverDesignBrands() {
+  try {
+    const entries = await fs.readdir(DESIGN_MD_DIR, { withFileTypes: true });
+    return entries
+      .filter(e => e.isDirectory())
+      .map(e => e.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Load a DESIGN.md file for a specific brand.
+ */
+export async function loadDesignMd(brand) {
+  try {
+    const dir = path.join(DESIGN_MD_DIR, brand);
+    const files = ['DESIGN.md', 'README.md'];
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      await fs.access(filePath);
+      return { brand, file, content: await fs.readFile(filePath, 'utf8') };
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Search design systems by keyword (brand name or description).
+ */
+export async function searchDesignSystems(query) {
+  const brands = await discoverDesignBrands();
+  const q = query.toLowerCase();
+  const matched = brands.filter(b => b.includes(q));
+  return matched.slice(0, 10);
+}
+
+// ── Resource Manifest ──────────────────────────────────────────────────────
+
+const MANIFEST_PATH = path.join(LOCAL_ROOT, 'manifest.json');
+
+export async function loadResourceManifest() {
+  try {
+    const raw = await fs.readFile(MANIFEST_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return { localResources: [] };
+  }
+}
+
+// ── Context Builder ─────────────────────────────────────────────────────────
+
+/**
+ * Build a concise context summary of all available local resources.
+ * Used for automatic injection into system prompts.
+ */
+export async function buildResourceContext() {
+  const manifest = await loadResourceManifest();
+  const resources = manifest.localResources || [];
+  const designBrands = await discoverDesignBrands();
+
+  const parts = [];
+
+  if (resources.length > 0) {
+    parts.push('## Local Resources');
+    resources.forEach(r => {
+      parts.push(`  - ${r.name}: ${r.fileCount} files, ${(r.size / 1024).toFixed(0)}KB`);
+    });
+    parts.push('');
+  }
+
+  if (designBrands.length > 0) {
+    const brandsStr = designBrands.slice(0, 40).join(', ');
+    const leftover = designBrands.length - 40;
+    parts.push(`## Design Systems (${designBrands.length} available)`);
+    parts.push(`  ${brandsStr}${leftover > 0 ? `, +${leftover} more` : ''}`);
+    parts.push('');
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Get a relevant DESIGN.md content based on the task description.
+ * Uses keyword matching between the task text and design system brand names.
+ */
+export async function getRelevantDesignGuide(taskText) {
+  if (!taskText) return null;
+
+  const brands = await discoverDesignBrands();
+  const text = taskText.toLowerCase();
+
+  // Match by brand name in task text
+  for (const brand of brands) {
+    if (text.includes(brand)) {
+      const design = await loadDesignMd(brand);
+      if (design) return design;
+    }
+  }
+
+  // Match by context clues (e.g., "design", "ui", "looks like", "brand")
+  const designHint = /\b(design|ui|looks? like|brand guide|style guide|make it look)\b/i.test(text);
+  if (designHint && brands.length > 0) {
+    // Return the first few brands as options
+    return {
+      brand: null,
+      type: 'design_hint',
+      brands: brands.slice(0, 5),
+      note: 'Design-related task detected. Available design systems listed above.',
+    };
+  }
+
+  return null;
+}

package/src/context/router.js

@@ -11,26 +11,83 @@ function flattenMessageText(messages) {
     : String(messages || '').toLowerCase();
 }
 
-export function selectExecutionProfile({ messages = [], activeProvider = null, providers = {}, options = {} } = {}) {
-  const text = flattenMessageText(messages);
-  const providerNames = Object.keys(providers).filter(name => providers[name]?.ready || providers[name]?.model);
-  const hasProvider = name => providerNames.includes(name);
+import { ReasoningConfig, REASONING_LEVELS } from '../ai/reasoning.js';
+import { classifyModelTier, isSmallModel, getReasoningBump, MODEL_TIERS } from '../ai/model-capabilities.js';
 
-  const explicitProvider = options.provider && hasProvider(options.provider) ? options.provider : null;
-  let provider = explicitProvider || (activeProvider && hasProvider(activeProvider) ? activeProvider : providerNames[0] || null);
-
-  if (explicitProvider) {
-    provider = explicitProvider;
-  } else if (/\b(review|refactor|debug|fix|bug|error|stack trace|test|tool|patch|code)\b/.test(text) && hasProvider('claude')) {
-    provider = 'claude';
-  } else if (/\b(summary|summarize|commit message|changelog|docs|explain|rewrite)\b/.test(text) && hasProvider('openai')) {
-    provider = 'openai';
-  } else if (/\b(local|offline|privacy|private|on-device)\b/.test(text) && hasProvider('ollama')) {
-    provider = 'ollama';
-  } else if (/\b(quick|brief|short|fast)\b/.test(text) && hasProvider('groq')) {
-    provider = 'groq';
-  }
+/**
+ * Bump reasoning level by N steps.
+ */
+function bumpReasoningLevel(level, steps) {
+  const order = [REASONING_LEVELS.NONE, REASONING_LEVELS.LOW, REASONING_LEVELS.MEDIUM, REASONING_LEVELS.HIGH, REASONING_LEVELS.MAX];
+  const idx = order.indexOf(level);
+  if (idx === -1) return level;
+  const newIdx = Math.min(idx + steps, order.length - 1);
+  return order[newIdx];
+}	export function selectExecutionProfile({ messages = [], activeProvider = null, providers = {}, options = {} } = {}) {
+	  const text = flattenMessageText(messages);
+	  const providerNames = Object.keys(providers).filter(name => providers[name]?.ready || providers[name]?.model);
+	  const hasProvider = name => providerNames.includes(name);
+	
+	  const explicitProvider = options.provider && hasProvider(options.provider) ? options.provider : null;
+	  let provider = explicitProvider || (activeProvider && hasProvider(activeProvider) ? activeProvider : providerNames[0] || null);
+	
+	  if (explicitProvider) {
+	    provider = explicitProvider;
+	  } else if (/\b(review|refactor|debug|fix|bug|error|stack trace|test|tool|patch|code)\b/.test(text) && hasProvider('claude')) {
+	    provider = 'claude';
+	  } else if (/\b(summary|summarize|commit message|changelog|docs|explain|rewrite)\b/.test(text) && hasProvider('openai')) {
+	    provider = 'openai';
+	  } else if (/\b(local|offline|privacy|private|on-device)\b/.test(text) && hasProvider('ollama')) {
+	    provider = 'ollama';
+	  } else if (/\b(quick|brief|short|fast)\b/.test(text) && hasProvider('groq')) {
+	    provider = 'groq';
+	  }
+	
+	  const providerConfig = providers[provider] || providers[activeProvider] || {};
+	  const model = options.model || providerConfig.model || providers[activeProvider]?.model || null;
+	
+	  // Detect model capability tier
+	  const modelTier = classifyModelTier(model, provider);
+	  const isSmall = isSmallModel(modelTier);
+	  const reasoningBump = getReasoningBump(modelTier);
+	
+	  // Determine reasoning level based on task complexity signals
+	  // Default: HIGH for coding — all models must think deeply
+	  let reasoningLevel = options.reasoningLevel || REASONING_LEVELS.HIGH;
+	  if (!options.reasoningLevel) {
+	    const hasDeepSignals = /\b(refactor|architecture|redesign|migrate|complex|full stack|e2e|end to end|security|optimize|performance|implement|build|create)\b/.test(text);
+	    const hasComplexSignals = /\b(debug|fix|test|multiple|integrate|design|plan|review|analyze)\b/.test(text);
+	
+	    if (hasDeepSignals && text.length > 30) {
+	      reasoningLevel = REASONING_LEVELS.MAX;
+	    } else if (hasComplexSignals && text.length > 20) {
+	      reasoningLevel = REASONING_LEVELS.MAX;
+	    } else if (text.split(/\s+/).length > 10) {
+	      reasoningLevel = REASONING_LEVELS.HIGH;
+	    } else if (text.split(/\s+/).length < 3) {
+	      reasoningLevel = REASONING_LEVELS.MEDIUM;
+	    } else {
+	      reasoningLevel = REASONING_LEVELS.HIGH;
+	    }
+	
+	    // If small model, bump reasoning level even more to compensate
+	    if (isSmall && reasoningBump > 0) {
+	      reasoningLevel = bumpReasoningLevel(reasoningLevel, reasoningBump);
+	    }
+	  }
 
-  const model = options.model || providers[provider]?.model || providers[activeProvider]?.model || null;
-  return { provider, model };
+  const reasoning = new ReasoningConfig({
+    level: reasoningLevel,
+    provider: provider || activeProvider,
+    modelTier,
+  });
+
+  return {
+    provider,
+    model,
+    modelTier,
+    reasoningLevel,
+    reasoningParam: reasoning.getApiReasoningParam(),
+    reasoningPrompt: reasoning.getPromptInstructions(),
+  };
 }