winter-super-cli 2026.6.5 → 2026.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "winter-super-cli",
-  "version": "2026.6.5",
+  "version": "2026.6.6",
   "description": "❄️ AI-Powered Development CLI with Interactive REPL",
   "type": "module",
   "main": "bin/winter.js",
@@ -57,7 +57,7 @@
     "diff": "^9.0.0"
   },
   "optionalDependencies": {
+    "@colbymchenry/codegraph": "^0.7.12",
     "puppeteer": "^24.43.1"
-  },
-  "devDependencies": {}
+  }
 }

package/src/agent/runtime.js

@@ -38,6 +38,7 @@ export class AgentRuntime {
       depth,
     });
     const maxToolTurns = amplifier.maxToolTurns || 8;
+    let forceTextToolFallback = false;
 
     try {
       for (let i = 0; i < maxToolTurns; i++) {
@@ -46,6 +47,7 @@ export class AgentRuntime {
           provider: executionProfile.provider,
           model: executionProfile.model,
           enableTools: true,
+          toolPromptOnly: forceTextToolFallback,
           requireToolEvidence: requireToolEvidence && !usedTools,
         }, startedAt, totalUsage);
 
@@ -73,6 +75,7 @@ export class AgentRuntime {
               role: 'user',
               content: repl.buildToolEvidenceCorrection(messages),
             });
+            forceTextToolFallback = true;
             finalContent = '';
             continue;
           }

package/src/ai/model-capabilities.js

@@ -32,6 +32,7 @@ export function classifyModelTier(modelName, provider = '') {
     /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,
+    /minimax-?m2\.5/i, /minimax.*m2\.5/i, /minimax/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,
@@ -123,7 +124,7 @@ export function classifyModelTier(modelName, provider = '') {
     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)) {
+  if (/\btiny\b/i.test(name) || /(?:^|[-_:/])mini(?:$|[-_:/])/i.test(name) || /\bsmall\b/i.test(name) || /\bnano\b/i.test(name)) {
     return MODEL_TIERS.TINY;
   }
 

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

@@ -1,10 +1,9 @@
 /**
  * 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.
+ * Winter always gives every model the strongest available agent instructions.
  */
 
-import { isSmallModel, getModelCapabilityLabel } from '../model-capabilities.js';
 import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from '../../cli/runtime-env.js';
 
 const BASE_PRINCIPLES = [
@@ -74,35 +73,6 @@ function appendSharedContext(parts, { environment, session, design, resourceCont
   }
 }
 
-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. Operate as an agent: inspect -> hypothesize -> act -> verify -> final.',
-    '3. Keep context tight. Use only relevant tools and avoid long explanations.',
-    '4. For coding/debug: Read/Grep/Glob/logs -> Edit/Write -> Bash/test/browser smoke. Do not guess file paths.',
-    '5. For UI/design: inspect existing components/styles/resources before changing visuals.',
-    '6. 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(
-    '## Response Shape',
-    '- If action is needed, use tools instead of describing the action.',
-    '- If an image is provided, analyze the image directly and tie findings to project files when relevant.',
-    '- Keep final output short and concrete.',
-  );
-
-  return parts.filter(Boolean).join('\n');
-}
-
 function buildStandardSystemPrompt(options = {}) {
   const { role = 'coding', tools = [], resourceContext } = options;
   const parts = [
@@ -113,6 +83,7 @@ function buildStandardSystemPrompt(options = {}) {
     '',
     '## Tool Usage',
     'Use tools when they materially improve correctness. Inspect before editing. Verify after changes.',
+    'Use maximum reasoning discipline for every model tier, including tiny, local, free, and routed models.',
     'Never invent file paths, APIs, command output, or test results.',
     'For debug work, locate the first hard failure, patch the root cause, and verify with the closest test/build/browser smoke.',
     'For design/UI work, inspect the existing interface and design resources first; avoid generic placeholder layouts.',
@@ -139,9 +110,7 @@ export function buildSystemPrompt({
   modelTier,
 } = {}) {
   const options = { role, context, tools, session, environment, design, resourceContext, modelTier };
-  return isSmallModel(modelTier)
-    ? buildCompactSmallModelPrompt(options)
-    : buildStandardSystemPrompt(options);
+  return buildStandardSystemPrompt(options);
 }
 
 export function buildFastSystemPrompt({
@@ -149,18 +118,10 @@ export function buildFastSystemPrompt({
   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.',
+    'You are Winter (fast mode with maximum correctness). Be concise, but inspect and use tools when needed.',
     tools.length > 0 ? `Tools: ${tools.join(', ')}` : '',
-    'Keep responses brief and focused on the immediate task.',
+    'Use a brief private plan, then execute or answer with concrete evidence.',
   ].filter(Boolean).join('\n');
 }
 
@@ -176,15 +137,13 @@ export function buildAgentSystemPrompt(role, { tools = [], modelTier } = {}) {
   };
 
   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.'
-    : '';
+  const strengthNote = '\n\nWinter Strength Mode: use the full agent loop, inspect real code, reason carefully, verify results, and avoid unsupported claims regardless of base model size.';
 
   return [
     `You are Winter (${role} agent).`,
     base,
     tools.length > 0 ? `\nTools: ${tools.join(', ')}` : '',
-    smallNote,
+    strengthNote,
     '\nCRITICAL: Output only the requested format. No extra commentary.',
   ].filter(Boolean).join('\n');
 }

package/src/ai/providers.js

@@ -293,6 +293,44 @@ export class AIProviderManager {
     this.tools = tools;
   }
 
+  normalizeToolDefinitionsForApi(tools = []) {
+    if (!Array.isArray(tools)) return [];
+
+    return tools
+      .map(tool => {
+        if (!tool || typeof tool !== 'object') return null;
+
+        if (tool.type === 'function' && tool.function && typeof tool.function === 'object') {
+          return tool;
+        }
+
+        if (tool.name && tool.parameters) {
+          return {
+            type: 'function',
+            function: {
+              name: tool.name,
+              description: tool.description || '',
+              parameters: tool.parameters,
+            },
+          };
+        }
+
+        if (tool.function?.name) {
+          return {
+            type: 'function',
+            function: {
+              name: tool.function.name,
+              description: tool.function.description || tool.description || '',
+              parameters: tool.function.parameters || tool.parameters || { type: 'object', properties: {} },
+            },
+          };
+        }
+
+        return null;
+      })
+      .filter(Boolean);
+  }
+
   async chat(message, options = {}) {
     await this.init();
     const messages = [
@@ -405,8 +443,9 @@ export class AIProviderManager {
       }
     }
 
-    if (this.tools.length > 0 && options.enableTools) {
-      body.tools = this.tools;
+    if (this.tools.length > 0 && options.enableTools && !options.toolPromptOnly) {
+      const tools = this.normalizeToolDefinitionsForApi(this.tools);
+      if (tools.length > 0) body.tools = tools;
     }
 
     const headers = {
@@ -460,8 +499,9 @@ export class AIProviderManager {
       }
     }
 
-    if (this.tools.length > 0 && options.enableTools) {
-      body.tools = this.tools;
+    if (this.tools.length > 0 && options.enableTools && !options.toolPromptOnly) {
+      const tools = this.normalizeToolDefinitionsForApi(this.tools);
+      if (tools.length > 0) body.tools = tools;
     }
 
     const headers = {
@@ -586,7 +626,7 @@ export class AIProviderManager {
       const body = {
         model: options.model || provider.model,
         messages: currentMessages,
-        tools: this.tools.length > 0 ? this.tools : undefined,
+        tools: this.tools.length > 0 ? this.normalizeToolDefinitionsForApi(this.tools) : undefined,
       };
 
       const headers = {
@@ -681,13 +721,13 @@ export class AIProviderManager {
     let reasoningPrompt = '';
     if (options.reasoningLevel || options.reasoningPrompt) {
       reasoningPrompt = options.reasoningPrompt || new ReasoningConfig({
-        level: options.reasoningLevel || REASONING_LEVELS.MEDIUM,
+        level: options.reasoningLevel || REASONING_LEVELS.MAX,
         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 level = REASONING_LEVELS.MAX;
       const config = new ReasoningConfig({
         level,
         provider: this.activeProvider,

package/src/ai/small-model-amplifier.js

@@ -1,30 +1,19 @@
-import { isSmallModel } from './model-capabilities.js';
-
 export function isWeakTier(modelTier = '') {
-  return isSmallModel(modelTier);
+  return true;
 }
 
 export function buildSmallModelAmplification({ modelTier = '', workflowProfile = 'general', depth = 'standard' } = {}) {
-  const weak = isWeakTier(modelTier);
-  if (!weak) {
-    return {
-      weak: false,
-      maxToolTurns: 8,
-      enforceSelfCritique: false,
-      hint: '',
-    };
-  }
-
   const deepLike = depth === 'deep' || /debug|backend|data|devops|ai/.test(workflowProfile);
-  const maxToolTurns = deepLike ? 14 : 10;
+  const maxToolTurns = deepLike ? 18 : 14;
 
   const hint = [
-    '[Small Model Amplifier]',
-    '- You are running in weak-model compensation mode.',
+    '[Winter Strength Amplifier]',
+    '- Every model, including tiny/local/free models, must run at Winter maximum capability.',
     '- Mandatory loop: PLAN (requirements + files + risks) -> TOOL ACTIONS -> VERIFY -> SELF-CHECK -> FINAL.',
     '- Do not skip verification. If verification fails, iterate until max loops.',
     '- Before final answer, run a private self-critique: missing edge cases, missing tests, over-claims, and incorrect assumptions.',
     '- Prefer concrete evidence from tool outputs over reasoning guesses.',
+    '- Use CodeGraph/codebase index context before broad file reads when available.',
   ].join('\n');
 
   return {
@@ -34,4 +23,3 @@ export function buildSmallModelAmplification({ modelTier = '', workflowProfile =
     hint,
   };
 }
-

package/src/cli/commands.js

@@ -962,6 +962,150 @@ EXECUTION CONTRACT:
     );
   }
 
+  buildPlanSlug(task) {
+    return String(task || 'plan')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .slice(0, 48) || 'plan';
+  }
+
+  getPlanScaffoldSpec(task, workflow = {}) {
+    const slug = this.buildPlanSlug(task);
+    const featureName = slug.replace(/-/g, ' ');
+    const profile = String(workflow.profile || 'general');
+    const family = profile.split('-')[0] || 'general';
+
+    const common = {
+      dirs: ['docs', 'tests'],
+      files: {
+        'docs/plan-notes.md': [
+          `# ${featureName}`,
+          '',
+          `- Profile: ${profile}`,
+          '- Status: scaffolded by Winter plan apply',
+          '',
+        ].join('\n'),
+        'tests/README.md': [
+          '# Test Plan',
+          '',
+          '- Add smoke tests for the generated plan.',
+          '- Keep verification commands close to the final implementation stack.',
+          '',
+        ].join('\n'),
+      },
+    };
+
+    const specs = {
+      webapp: {
+        dirs: ['src/app', `src/features/${slug}`, 'src/components', 'src/lib', 'tests/e2e'],
+        files: {
+          [`src/features/${slug}/README.md`]: `# ${featureName}\n\nFeature slice for the plan.\n`,
+          [`src/features/${slug}/tasks.md`]: '',
+          'tests/e2e/README.md': '# E2E Tests\n\nAdd Playwright or browser smoke tests here.\n',
+        },
+      },
+      mobile: {
+        dirs: ['src/navigation', `src/features/${slug}`, 'src/screens', 'src/services', 'src/components', 'src/state', 'tests'],
+        files: {
+          [`src/features/${slug}/README.md`]: `# ${featureName}\n\nMobile feature module for screens, hooks, API calls, and state.\n`,
+          [`src/features/${slug}/tasks.md`]: '',
+          'src/navigation/README.md': '# Navigation\n\nDefine app navigation graph and route ownership here.\n',
+          'src/services/README.md': '# Services\n\nPlace API clients, storage adapters, and platform services here.\n',
+        },
+      },
+      backend: {
+        dirs: [`src/modules/${slug}`, `src/modules/${slug}/dto`, `src/modules/${slug}/tests`, 'src/config', 'src/common'],
+        files: {
+          [`src/modules/${slug}/README.md`]: `# ${featureName}\n\nBackend module scaffold for routes/controllers/services/tests.\n`,
+          [`src/modules/${slug}/tasks.md`]: '',
+          'src/config/README.md': '# Config\n\nDocument environment variables and runtime config here.\n',
+        },
+      },
+      desktop: {
+        dirs: ['src/main', 'src/preload', 'src/renderer', `src/features/${slug}`, 'tests'],
+        files: {
+          [`src/features/${slug}/README.md`]: `# ${featureName}\n\nDesktop feature module scaffold.\n`,
+          [`src/features/${slug}/tasks.md`]: '',
+          'src/main/README.md': '# Main Process\n\nKeep privileged runtime code here.\n',
+          'src/preload/README.md': '# Preload\n\nExpose minimal validated IPC APIs here.\n',
+        },
+      },
+      ai: {
+        dirs: ['src/ingestion', 'src/retrieval', 'src/generation', 'src/evals', `src/features/${slug}`],
+        files: {
+          [`src/features/${slug}/README.md`]: `# ${featureName}\n\nAI feature scaffold for pipeline wiring and evals.\n`,
+          [`src/features/${slug}/tasks.md`]: '',
+          'src/evals/README.md': '# Evals\n\nTrack regression prompts, datasets, and quality thresholds here.\n',
+        },
+      },
+    };
+
+    const spec = specs[family] || {
+      dirs: [`src/features/${slug}`, 'src/lib', 'tests'],
+      files: {
+        [`src/features/${slug}/README.md`]: `# ${featureName}\n\nFeature scaffold generated from Winter plan apply.\n`,
+        [`src/features/${slug}/tasks.md`]: '',
+      },
+    };
+
+    return {
+      slug,
+      family,
+      dirs: [...common.dirs, ...spec.dirs],
+      files: { ...common.files, ...spec.files },
+    };
+  }
+
+  async writeFileIfMissing(filePath, content) {
+    try {
+      await fs.writeFile(filePath, content, { encoding: 'utf8', flag: 'wx' });
+      return true;
+    } catch (error) {
+      if (error?.code === 'EEXIST') return false;
+      throw error;
+    }
+  }
+
+  async applyPlanProfileScaffold({ task, selected, workflow }) {
+    const spec = this.getPlanScaffoldSpec(task, workflow);
+    const created = [];
+    const skipped = [];
+
+    for (const dir of spec.dirs) {
+      const dirPath = path.join(this.projectPath, dir);
+      await fs.mkdir(dirPath, { recursive: true });
+      created.push(dir);
+    }
+
+    const taskListContent = [
+      `# ${selected.title}`,
+      '',
+      `- Task: ${task}`,
+      `- Profile: ${workflow.profile}`,
+      '',
+      '## Steps',
+      ...selected.steps.map(step => `- [ ] ${step}`),
+      '',
+    ].join('\n');
+
+    const files = { ...spec.files };
+    for (const fileName of Object.keys(files)) {
+      if (fileName.endsWith('/tasks.md')) {
+        files[fileName] = taskListContent;
+      }
+    }
+
+    for (const [relativePath, content] of Object.entries(files)) {
+      const filePath = path.join(this.projectPath, relativePath);
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      const didCreate = await this.writeFileIfMissing(filePath, content);
+      (didCreate ? created : skipped).push(relativePath);
+    }
+
+    return { ...spec, created, skipped };
+  }
+
   async exportPlanArtifact({ task, workflow, selected, outputPath, format = 'md' }) {
     const normalizedFormat = format === 'json' ? 'json' : 'md';
     const finalPath = this.resolvePlanOutputPath(task, normalizedFormat, outputPath);
@@ -1004,6 +1148,7 @@ EXECUTION CONTRACT:
   }
 
   async applyPlanSkeleton({ task, selected, workflow, exportPath = null }) {
+    const scaffold = await this.applyPlanProfileScaffold({ task, selected, workflow });
     const targetPath = path.join(this.projectPath, '.winter', 'plan-task-list.md');
     const skeleton = [
       '# Plan Task List',
@@ -1012,10 +1157,15 @@ EXECUTION CONTRACT:
       `- Profile: ${workflow.profile}`,
       `- Plan: ${selected.title}`,
       ...(exportPath ? [`- Plan File: ${path.relative(this.projectPath, exportPath) || exportPath}`] : []),
+      `- Scaffold Profile: ${scaffold.family}`,
       '',
       '## TODO',
       ...selected.steps.map(step => `- [ ] ${step}`),
       '',
+      '## Scaffold Created',
+      ...scaffold.created.map(item => `- ${item}`),
+      ...(scaffold.skipped.length ? ['', '## Existing Files Kept', ...scaffold.skipped.map(item => `- ${item}`)] : []),
+      '',
     ].join('\n');
     await fs.mkdir(path.dirname(targetPath), { recursive: true });
     await fs.writeFile(targetPath, skeleton, 'utf8');