winter-super-cli 2026.5.30 → 2026.5.31

package/bin/winter.js

@@ -18,7 +18,7 @@ const version = pkg.version;
 
 const COMMANDS = new Set([
   'chat', 'call', 'benchmark', 'session', 'skill', 'plugin', 'design', 'config', 'init',
-  'help', 'project', 'code', 'review', 'mcp', 'permissions',
+  'help', 'project', 'code', 'review', 'debug', 'auto', 'mcp', 'permissions',
   'provider', 'providers', 'model', 'models',
 ]);
 
@@ -68,6 +68,8 @@ Commands:
   winter config               Show config
   winter init                 Initialize local state
   winter review               Code review mode
+  winter debug <error/task>   Auto-debug with verification
+  winter auto <task>          Auto-heal with test/build loop
   winter code                 Code analysis mode
 
 Flags:

package/package.json

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

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

@@ -5,6 +5,7 @@
  */
 
 import { isSmallModel, getModelCapabilityLabel } from '../model-capabilities.js';
+import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from '../../cli/runtime-env.js';
 
 const BASE_PRINCIPLES = [
   'Execute, don\'t describe - Do the work, don\'t write plans about doing the work',
@@ -25,18 +26,9 @@ const TOOL_CATEGORIES = {
 };
 
 function buildEnvironmentSummary() {
-  const os = process.platform === 'win32' ? 'Windows'
-    : process.platform === 'darwin' ? 'macOS'
-    : process.platform === 'linux' ? 'Linux' : process.platform;
-
-  const shellHint = process.platform === 'win32'
-    ? 'Use shell:"powershell" for PowerShell, shell:"cmd" for cmd.exe'
-    : `Shell: ${process.env.SHELL || 'bash'}`;
-
   return [
-    `Host OS: ${os}`,
+    formatRuntimeEnvironmentSummary(getRuntimeEnvironment()),
     `Node: ${process.version}`,
-    shellHint,
   ].join('\n');
 }
 

package/src/cli/commands.js

@@ -12,6 +12,7 @@ import { PluginManager } from '../plugins/manager.js';
 import { MCPClient } from '../mcp/client.js';
 import { BenchmarkRunner } from '../ai/benchmark.js';
 import { redactSecrets } from './secret-env.js';
+import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from './runtime-env.js';
 
 export { redactSecrets } from './secret-env.js';
 
@@ -60,6 +61,8 @@ export class CommandParser {
       design: this.handleDesign.bind(this),
       code: this.handleCode.bind(this),
       review: this.handleReview.bind(this),
+      debug: this.handleDebug.bind(this),
+      auto: this.handleDebug.bind(this),
       config: this.handleConfig.bind(this),
       init: this.handleInit.bind(this),
       help: this.handleHelp.bind(this),
@@ -104,6 +107,8 @@ export class CommandParser {
       '/models': () => this.showModels(),
       '/mcp': () => this.handleMcp(args),
       '/permissions': () => this.handlePermissions(args),
+      '/debug': () => this.handleDebug(args),
+      '/auto': () => this.handleDebug(args),
       '/exit': () => process.exit(0),
     };
 
@@ -115,6 +120,11 @@ export class CommandParser {
     }
   }
 
+  async handleDebug(args) {
+    const task = args.join(' ') || 'Find the root cause, patch it, and verify with the closest test or build command';
+    return this.handleChat([`AUTO DEBUG: ${task}`]);
+  }
+
   async handleChat(args) {
     const message = args.join(' ');
     if (!message) {
@@ -638,12 +648,7 @@ export class CommandParser {
 
   getWinterSystemPrompt() {
     const environmentSummary = [
-      `Host OS: ${process.platform === 'win32' ? 'Windows' : process.platform === 'darwin' ? 'macOS' : process.platform === 'linux' ? 'Linux' : process.platform}`,
-      `Node platform: ${process.platform}`,
-      `Current shell hint: ${process.platform === 'win32' ? 'powershell-capable or cmd/unknown' : (process.env.SHELL || 'bash/sh')}`,
-      process.platform === 'win32'
-        ? 'Shell rule: Use shell:"powershell" for PowerShell cmdlets, shell:"cmd" for cmd.exe syntax, and shell:"auto" when unsure.'
-        : 'Shell rule: Use the native POSIX shell on non-Windows hosts and leave shell unspecified unless a specific shell is required.',
+      formatRuntimeEnvironmentSummary(getRuntimeEnvironment()),
     ].join('\n');
 
     return `You are Winter, an expert AI coding assistant.

package/src/cli/context-loader.js

@@ -1,6 +1,10 @@
 import { promises as fs } from 'fs';
+import { existsSync } from 'fs';
 import path from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 
 /**
  * ContextLoader — Loads project context, resource paths, and instruction files.
@@ -42,8 +46,18 @@ export class ContextLoader {
     return files;
   }
 
+  getResourceRoot() {
+    const projectLocalRoot = path.join(this.projectPath, 'resources', 'local');
+    const packageLocalRoot = path.join(PACKAGE_ROOT, 'resources', 'local');
+
+    if (this.projectPath === PACKAGE_ROOT) return projectLocalRoot;
+    if (existsSync(projectLocalRoot)) return projectLocalRoot;
+
+    return packageLocalRoot;
+  }
+
   getResourcePaths() {
-    const localRoot = path.join(this.projectPath, 'resources', 'local');
+    const localRoot = this.getResourceRoot();
     return {
       codex: {
         root: path.join(localRoot, 'codex'),

package/src/cli/project-docs.js

@@ -0,0 +1,188 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const GENERATED_MARKER = 'File này được tự động tạo bởi Winter CLI.';
+
+const CORE_SKILLS = [
+  ['coding', 'Inspect source first, make focused code changes, and verify syntax/tests.'],
+  ['debug', 'Trace the concrete failing path, explain the first hard blocker, then patch it.'],
+  ['design', 'Use awesome-design-md before inventing UI style, spacing, or brand language.'],
+  ['refactor', 'Keep behavior stable while reducing complexity in small, reviewable steps.'],
+  ['test', 'Add regression coverage near the changed behavior and run the narrow test first.'],
+  ['security', 'Protect secrets, validate inputs, avoid unsafe shell/file operations.'],
+  ['performance', 'Measure or reason from the hot path before optimizing.'],
+];
+
+async function readJsonIfExists(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw.replace(/^\uFEFF/, ''));
+  } catch {
+    return null;
+  }
+}
+
+async function listEntries(target, { directories = true, files = false, limit = 100 } = {}) {
+  try {
+    const entries = await fs.readdir(target, { withFileTypes: true });
+    return entries
+      .filter(entry => (directories && entry.isDirectory()) || (files && entry.isFile()))
+      .map(entry => entry.name)
+      .sort((a, b) => a.localeCompare(b))
+      .slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+
+function formatBytes(bytes = 0) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return '0 B';
+  const mb = bytes / 1024 / 1024;
+  if (mb >= 1) return `${mb.toFixed(1)} MB`;
+  const kb = bytes / 1024;
+  return `${kb.toFixed(1)} KB`;
+}
+
+function getResource(manifest, name) {
+  return (manifest?.localResources || []).find(resource => resource.name === name);
+}
+
+function bulletList(items, emptyText) {
+  if (!items.length) return `- ${emptyText}`;
+  return items.map(item => `- ${item}`).join('\n');
+}
+
+function generatedFooter() {
+  return `---\n*${GENERATED_MARKER}*`;
+}
+
+export function isWinterGeneratedProjectDoc(content = '') {
+  return /File n(?:ày|ày) .*Winter CLI/i.test(content)
+    || /được tự động tạo bởi Winter CLI/i.test(content)
+    || /được tự động tạo bởi Winter CLI/i.test(content);
+}
+
+export async function buildDesignDoc({ projectPath, resourcePaths }) {
+  const manifest = await readJsonIfExists(resourcePaths.manifest);
+  const designResource = getResource(manifest, 'awesome-design-md');
+  const brandNames = await listEntries(resourcePaths.designs, { directories: true, limit: 40 });
+  const relativeDesignPath = path.relative(projectPath, resourcePaths.designs) || resourcePaths.designs;
+  const relativeReadmePath = path.join(path.relative(projectPath, path.dirname(resourcePaths.designs)), 'README.md');
+  const corpusStatus = brandNames.length > 0
+    ? `Corpus local sẵn sàng tại \`${relativeDesignPath}\`.`
+    : 'Corpus chi tiết chưa có trong working tree hiện tại. Dùng manifest để biết index, hoặc cài/copy resource pack đầy đủ trước khi làm UI/brand task.';
+
+  return `# Design Guidance
+
+File này không phải danh bạ trang trí. Đây là checklist bắt buộc khi Winter xử lý UI, brand, landing page, dashboard, hoặc component.
+
+## Resource Status
+- Source: \`${relativeReadmePath}\`
+- Corpus: \`${relativeDesignPath}\`
+- Manifest: ${designResource ? `${designResource.files} files, ${formatBytes(designResource.bytes)}` : 'không có entry awesome-design-md'}
+- Status: ${corpusStatus}
+
+## How Winter Must Use This
+1. Khi task liên quan UI/design/brand, tìm brand hoặc style gần nhất trong \`awesome-design-md/design-md\` trước khi viết code.
+2. Nếu user nêu brand cụ thể, ưu tiên đúng brand đó; nếu không có, chọn brand gần nhất theo domain và nói rõ giả định.
+3. Không tự bịa palette, spacing, typography, tone khi local design guide có dữ liệu phù hợp.
+4. Với app/work tool, ưu tiên layout rõ, dense, dễ scan; không dùng hero marketing nếu user đang cần tool thật.
+5. Sau khi sửa UI, kiểm tra responsive và text overflow nếu có thể chạy app.
+
+## Available Brand Samples (${brandNames.length}${brandNames.length >= 40 ? '+' : ''})
+${bulletList(brandNames, 'Chưa tìm thấy brand folder trong working tree hiện tại.')}
+
+## Useful Commands
+- \`/designs\` để liệt kê hoặc tìm design systems.
+- \`/read resources/local/awesome-design-md/README.md\` để đọc overview.
+- \`/grep <brand> resources/local/awesome-design-md/design-md\` để tìm brand/style guide.
+
+${generatedFooter()}`;
+}
+
+export async function buildSkillDoc({ contextLoader }) {
+  const catalog = await contextLoader.getStartupSkillCatalog();
+  const skills = [...catalog]
+    .filter(skill => skill && !skill.startsWith('.'))
+    .sort((a, b) => a.localeCompare(b));
+
+  return `# Skill Guidance
+
+File này định nghĩa cách Winter chọn và áp dụng skill. Không chỉ liệt kê tên skill.
+
+## Default Rule
+- Luôn đọc yêu cầu, repo context, và file liên quan trước khi quyết định skill.
+- Skill là operational context: áp dụng vào hành động thật, không chỉ nhắc lại trong câu trả lời.
+- Model nhỏ vẫn phải theo cùng tiêu chuẩn: inspect, edit bằng tool, verify, rồi mới kết luận.
+
+## Core Skills
+${CORE_SKILLS.map(([name, description]) => `- **${name}**: ${description}`).join('\n')}
+
+## Available Local Skills (${skills.length})
+${bulletList(skills, 'Chưa tìm thấy skill local ngoài core skills.')}
+
+## When To Apply
+- Code change: coding + test, thêm debug nếu có lỗi cụ thể.
+- UI/page/component: design + coding + test.
+- Bug/runtime log: debug trước, coding sau.
+- Refactor lớn: refactor + test, giữ behavior stable.
+- Security/config/secret: security bắt buộc.
+- Performance/flicker/slow tool call: performance + debug.
+
+${generatedFooter()}`;
+}
+
+export async function buildRuleDoc({ projectPath, resourcePaths, userResourcePaths, readProjectInstructionFiles }) {
+  const manifest = await readJsonIfExists(resourcePaths.manifest);
+  const resources = manifest?.localResources || [];
+  const instructionFiles = (await readProjectInstructionFiles())
+    .map(file => file.relativePath)
+    .filter(relativePath => relativePath !== 'rule.md');
+  const bundledRuleFiles = await listEntries(resourcePaths.codex.rules, { directories: false, files: true, limit: 30 });
+  const userRuleFiles = await listEntries(userResourcePaths?.codexRules, { directories: false, files: true, limit: 30 });
+  const karpathyPath = path.relative(projectPath, path.join(resourcePaths.karpathy, 'CLAUDE.md'));
+  const agentsPath = path.relative(projectPath, path.join(resourcePaths.agents, 'AGENTS.md'));
+
+  return `# Project Operating Rules
+
+File này là contract vận hành cho Winter trong project này.
+
+## Non-Negotiable Behavior
+- Không nói đã sửa/chạy/kiểm tra nếu chưa có tool result trong lượt đó.
+- Trước khi sửa code: đọc file liên quan, hiểu entrypoint/runtime path, rồi mới patch.
+- Giữ thay đổi hẹp, không revert code user không yêu cầu.
+- Sau khi sửa: chạy syntax check hoặc test gần nhất có thể.
+- Với model nhỏ: bắt buộc chia việc thành inspect -> implement -> verify -> report.
+
+## Project Instruction Files
+${instructionFiles.length ? instructionFiles.map(file => `- [${file}](./${file})`).join('\n') : '- Chưa có instruction file khác.'}
+
+## Mandatory Local Resources
+- Karpathy tools: \`${karpathyPath}\`
+- Agents guide: \`${agentsPath}\`
+- Design corpus: \`${path.relative(projectPath, resourcePaths.designs)}\`
+
+## Resource Inventory
+${resources.length ? resources.map(resource => `- **${resource.name}**: ${resource.files} files, ${formatBytes(resource.bytes)}`).join('\n') : '- Không đọc được manifest resource.'}
+
+## Extra Rule Files
+- Bundled Codex rules: ${bundledRuleFiles.length ? bundledRuleFiles.join(', ') : 'none found'}
+- User Codex rules: ${userRuleFiles.length ? userRuleFiles.join(', ') : 'none found'}
+
+## Acceptance Checklist
+- Đúng provider/model user chọn, không tự route sai.
+- Tool call phải dùng đúng schema; lỗi thì retry/recover trước khi báo user.
+- Memory/session phải giữ đúng project.
+- UI docs/design phải dùng local resources khi task liên quan.
+- Final answer ngắn, nêu file đã sửa và verification thật.
+
+${generatedFooter()}`;
+}
+
+export async function buildProjectDocs(options) {
+  return [
+    { filename: 'design.md', content: await buildDesignDoc(options) },
+    { filename: 'skill.md', content: await buildSkillDoc(options) },
+    { filename: 'rule.md', content: await buildRuleDoc(options) },
+  ];
+}

package/src/cli/prompt-builder.js

@@ -1,3 +1,5 @@
+import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from './runtime-env.js';
+
 /**
  * PromptBuilder — Builds system prompts for Winter CLI agents.
  * Extracted from WinterREPL to reduce repl.js size.
@@ -79,6 +81,7 @@ export class PromptBuilder {
       `Use tools when they materially help. For coding tasks: inspect first, edit second, verify third.`,
       `Prefer Read/Grep/Glob before editing. Use Write/Edit for file changes.`,
       `When a task touches coding, agents, UI, brand, or design, inspect the relevant required local resource in depth before deciding.`,
+      `If the user asks you to modify, run, inspect, check, publish, commit, or otherwise act on the project, you MUST use tools. Do not claim completion without a tool result from this turn.`,
       ``,
       `## Session`,
       `Working directory: ${this.projectPath}`,
@@ -143,9 +146,7 @@ export class PromptBuilder {
 
     const rolePrompt = rolePrompts[role] || 'You are a Winter coding subagent. Solve the task directly, use tools when needed, and return a concise result.';
 
-    const osInfo = process.platform === 'win32'
-      ? 'Windows; Bash auto-detects PowerShell and cmd.exe syntax. Use shell="powershell" or shell="cmd" when needed.'
-      : process.platform;
+    const runtimeSummary = this.tools?.getRuntimeEnvironmentSummary?.() || this._defaultEnvironmentSummary();
 
     return [
       '## CRITICAL AI RULES (MUST FOLLOW STRICTLY):',
@@ -161,8 +162,9 @@ export class PromptBuilder {
       '## Tool Rules',
       '- Canonical tools: Read, Write, Edit, Bash, Glob, Grep, TaskCreate, TaskUpdate, TaskList, BrowserDebug, WebFetch, WebSearch.',
       '- Treat skills, memories, bundled resources, local project rules, and the tool list as operational context. Use them proactively when relevant.',
-      `- Current OS is ${osInfo}.`,
+      `- Runtime environment:\n${runtimeSummary}`,
       '- Prefer Write/Edit for writing files. Bash accepts both PowerShell and cmd.exe on Windows, but do not use long echo chains for code files.',
+      '- For action requests, use tools before claiming anything is done. Never claim files changed, tests ran, or checks passed unless this conversation contains the matching tool result.',
       '- If a tool call fails because of an unknown alias, call the canonical tool name next.',
       '- Always start with a brief plan, then refine it when new facts appear.',
       '',
@@ -196,14 +198,7 @@ export class PromptBuilder {
 
   /** @private */
   _defaultEnvironmentSummary() {
-    return [
-      `Host OS: ${process.platform === 'win32' ? 'Windows' : process.platform === 'darwin' ? 'macOS' : process.platform === 'linux' ? 'Linux' : process.platform}`,
-      `Node platform: ${process.platform}`,
-      `Current shell hint: ${process.platform === 'win32' ? 'powershell-capable or cmd/unknown' : (process.env.SHELL || 'bash/sh')}`,
-      process.platform === 'win32'
-        ? 'Shell rule: Use shell:"powershell" for PowerShell cmdlets, shell:"cmd" for cmd.exe syntax, and shell:"auto" when unsure.'
-        : 'Shell rule: Use the native POSIX shell on non-Windows hosts and leave shell unspecified unless a specific shell is required.',
-    ].join('\n');
+    return formatRuntimeEnvironmentSummary(getRuntimeEnvironment());
   }
 
   /** @private */

package/src/cli/repl-commands.js

@@ -217,6 +217,10 @@ export async function handleSlashCommand(repl, input) {
       const task = args.join(' ') || 'Run tests until they pass';
       await repl.runAutoHealing(task);
       return;
+    case '/debug':
+      const debugTask = args.join(' ') || 'Find the root cause of the current failure, patch it, and verify with the closest test or build command';
+      await repl.runAutoHealing(`AUTO DEBUG: ${debugTask}`);
+      return;
     case '/plan:':
     case '/plan-gen':
       if (args.length === 0) {

package/src/cli/repl.js

@@ -21,6 +21,7 @@ import { formatMarkdown } from './markdown-format.js';
 import { Spinner } from './spinner.js';
 import { ContextLoader } from './context-loader.js';
 import { PromptBuilder } from './prompt-builder.js';
+import { buildProjectDocs, isWinterGeneratedProjectDoc } from './project-docs.js';
 import { classifyModelTier, isSmallModel } from '../ai/model-capabilities.js';
 import {
   addUsage as mergeUsage,
@@ -231,104 +232,30 @@ export class WinterREPL {
     }
 
     // ── Tự động tạo design.md, skill.md, rule.md nếu chưa có ──────────────
-    const autoCreateDocs = [
-      {
-        filename: 'design.md',
-        generate: async () => {
-          const designDir = this.getResourcePaths().designs;
-          let brands = [];
-          try {
-            const entries = await fsPromises.readdir(designDir, { withFileTypes: true });
-            brands = entries.filter(e => e.isDirectory()).map(e => e.name).sort();
-          } catch {}
-          return `# Design Resources
-
-Danh sách các design system có sẵn trong local resources:
-
-## Available Brands (${brands.length})
-
-${brands.length > 0 ? brands.map(b => `- ${b}`).join('\n') : '- Không tìm thấy design system nào.'}
-
----
-*File này được tự động tạo bởi Winter CLI.*`;
-        },
-      },
-      {
-        filename: 'skill.md',
-        generate: async () => {
-          const catalog = await this.contextLoader.getStartupSkillCatalog();
-          const skills = [...catalog].sort();
-          return `# Available Skills
-
-Danh sách các skill có sẵn trong hệ thống:
-
-## Core Skills
-- **coding**: Code analysis, generation, review
-- **design**: Design system integration
-- **debug**: Debugging assistance
-- **refactor**: Code refactoring
-- **test**: Test generation
-- **security**: Security review
-- **performance**: Performance optimization
-
-## All Available Skills (${skills.length})
-
-${skills.map(s => `- ${s}`).join('\n')}
-
----
-*File này được tự động tạo bởi Winter CLI.*`;
-        },
-      },
-      {
-        filename: 'rule.md',
-        generate: async () => {
-          const parts = ['# Project Rules', '', '## Quy tắc dự án', ''];
-          // Load từ các instruction files đã có
-          const files = await this.readProjectInstructionFiles();
-          for (const file of files) {
-            if (file.relativePath === 'rule.md') continue; // skip self
-            parts.push(`- [${file.relativePath}](./${file.relativePath})`);
-          }
-          // Liệt kê các thư mục rules
-          const rulesDirs = [
-            this.getResourcePaths().codex.rules,
-            this.getUserResourcePaths()?.codexRules,
-          ].filter(Boolean);
-          for (const dir of rulesDirs) {
-            try {
-              const entries = await fsPromises.readdir(dir, { withFileTypes: true });
-              const ruleFiles = entries.filter(e => e.isFile() && e.name.endsWith('.md')).map(e => e.name);
-              if (ruleFiles.length > 0) {
-                parts.push('', `## Rules from ${path.basename(path.dirname(dir))}/${path.basename(dir)}`, '');
-                for (const f of ruleFiles) {
-                  parts.push(`- ${f}`);
-                }
-              }
-            } catch {}
-          }
-          // Liệt kê local resource rules
-          parts.push('', '## Local Resource Guidelines', '');
-          parts.push('- Karpathy tools guidelines available in local resources');
-          parts.push('- Agents.md project guidelines available in local resources');
-          parts.push('', '---', '*File này được tự động tạo bởi Winter CLI.*');
-          return parts.join('\n');
-        },
-      },
-    ];
+    const autoCreateDocs = await buildProjectDocs({
+      projectPath: this.projectPath,
+      resourcePaths: this.getResourcePaths(),
+      userResourcePaths: this.getUserResourcePaths(),
+      contextLoader: this.contextLoader,
+      readProjectInstructionFiles: () => this.readProjectInstructionFiles(),
+    });
 
     for (const doc of autoCreateDocs) {
       const filePath = path.join(this.projectPath, doc.filename);
       try {
-        await fsPromises.stat(filePath);
-        // File đã tồn tại, bỏ qua
+        const existing = await fsPromises.readFile(filePath, 'utf8');
+        if (!isWinterGeneratedProjectDoc(existing)) continue;
+
+        await fsPromises.writeFile(filePath, doc.content, 'utf8');
+        console.log(`${colors.green}✓ Đã nâng cấp file ${doc.filename} từ local resources.${colors.reset}`);
+        const memoryKey = `[Quy tắc dự án từ ${doc.filename}]`;
+        await this.session.replaceMemory(memoryKey, doc.content);
       } catch {
-        // File chưa tồn tại, tự động tạo
         try {
-          const content = await doc.generate();
-          await fsPromises.writeFile(filePath, content, 'utf8');
+          await fsPromises.writeFile(filePath, doc.content, 'utf8');
           console.log(`${colors.green}✓ Đã tự động tạo file ${doc.filename} từ local resources!${colors.reset}`);
           const memoryKey = `[Quy tắc dự án từ ${doc.filename}]`;
-          await this.session.replaceMemory(memoryKey, content);
+          await this.session.replaceMemory(memoryKey, doc.content);
         } catch (err) {
           // Bỏ qua nếu không tạo được
         }
@@ -894,7 +821,8 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
       row(`${c.yellow}/config${c.reset}  Xem cấu hình`, `${c.yellow}/exit${c.reset}     Thoát`),
       '',
       `${c.bright}AI & Công cụ${c.reset}`,
-      row(`${c.yellow}/auto${c.reset}    TDD tự sửa lỗi`, `${c.yellow}/agent${c.reset}   Chạy sub-agent`),
+      row(`${c.yellow}/auto${c.reset}    TDD t? s?a l?i`, `${c.yellow}/debug${c.reset}   Auto debug l?i`),
+      row(`${c.yellow}/agent${c.reset}   Ch?y sub-agent`, `${c.yellow}/swe${c.reset}     SWE workflow`),
       row(`${c.yellow}/read${c.reset}    Đọc file`, `${c.yellow}/write${c.reset}   Ghi file`),
       row(`${c.yellow}/bash${c.reset}    Chạy lệnh terminal`, `${c.yellow}/grep${c.reset}    Tìm trong file`),
       row(`${c.yellow}/glob${c.reset}    Tìm file theo pattern`, `${c.yellow}/image${c.reset}   Phân tích UI`),
@@ -949,6 +877,8 @@ ${colors.white}Plans & Tasks:${colors.reset}
   /task <desc>      Create task
   /tasks            List tasks
   /agent [role] <task>  Run a subagent
+  /auto [task]      Auto-heal with test/build loop
+  /debug [error]    Auto-debug and verify a failure
 
 ${colors.white}Tools:${colors.reset}
   /read <file>      Read file
@@ -1150,6 +1080,8 @@ ${colors.reset}
     const totalUsage = {};
     const toolSignatureHistory = [];
     const executionProfile = this.selectExecutionProfile(messages, { enableTools: true });
+    const requireToolEvidence = this.actionRequiresTools(messages);
+    let noToolActionRetries = 0;
     try {
       for (let i = 0; i < 8; i++) {
         if (this.isCancelled) throw new Error('AbortError');
@@ -1157,6 +1089,7 @@ ${colors.reset}
           provider: executionProfile.provider,
           model: executionProfile.model,
           enableTools: true,
+          requireToolEvidence: requireToolEvidence && !usedTools,
         }, startedAt, totalUsage);
 
         const assistantMsg = turn.assistantMsg || {};
@@ -1167,6 +1100,25 @@ ${colors.reset}
         }
 
         if (toolCalls.length === 0) {
+          if (turn.finishReason === 'tool_evidence_required') {
+            noToolActionRetries++;
+            if (noToolActionRetries > 2) {
+              finalContent = 'Chưa thực hiện được: model trả lời mà không dùng tool nên Winter đã chặn để tránh báo xạo.';
+              console.log(`\n${colors.yellow}${finalContent}${colors.reset}\n`);
+              reachedToolLimit = false;
+              break;
+            }
+            messages.push({
+              role: 'assistant',
+              content: assistantMsg.content || '',
+            });
+            messages.push({
+              role: 'user',
+              content: this.buildToolEvidenceCorrection(messages),
+            });
+            finalContent = '';
+            continue;
+          }
           if (turn.finishReason === 'length') {
             console.log(`\n${colors.yellow}ℹ Phản hồi bị cắt cụt do hết token. Đang tự động tiếp tục...${colors.reset}`);
             messages.push({
@@ -1304,6 +1256,51 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     return { finalContent, usedTools };
   }
 
+  getLatestUserText(messages = []) {
+    const list = Array.isArray(messages) ? messages : [{ role: 'user', content: String(messages || '') }];
+    for (let i = list.length - 1; i >= 0; i--) {
+      const message = list[i];
+      if (message?.role && message.role !== 'user') continue;
+      const content = message?.content;
+      if (typeof content === 'string') return content;
+      if (Array.isArray(content)) {
+        return content.map(part => part?.text || '').filter(Boolean).join('\n');
+      }
+    }
+    return '';
+  }
+
+  actionRequiresTools(messages = []) {
+    const text = this.getLatestUserText(messages).toLowerCase();
+    if (!text.trim()) return false;
+
+    const actionPattern = /\b(fix|repair|bug|debug|implement|create|write|edit|modify|update|delete|remove|refactor|run|test|build|commit|push|publish|install|check|inspect|read|scan|grep|search|change|apply|patch)\b|(?:sửa|fix|làm|tạo|ghi|đọc|xóa|xoá|chạy|test|build|commit|push|publish|kiểm tra|check|cài|thêm|đổi|sửa lỗi|refactor|review|soát|quét|tìm|áp dụng)/i;
+    const targetPattern = /\b(file|repo|project|code|src|test|build|git|npm|node|folder|directory|cli|tool|provider|model|config|readme|package\.json)\b|[A-Za-z]:[\\/]|\.js\b|\.ts\b|\.tsx\b|\.json\b|\.md\b|(?:dự án|mã|thư mục|tệp|file|cấu hình|lỗi|chức năng|tool|provider|model)/i;
+    const pureQuestionPattern = /^(what|why|how|when|where|is|are|can|could|should|would|tại sao|vì sao|là gì|có nên|có phải)\b/i;
+
+    if (pureQuestionPattern.test(text) && !actionPattern.test(text)) return false;
+    return actionPattern.test(text) && targetPattern.test(text);
+  }
+
+  responseNeedsToolEvidence(content = '') {
+    const text = String(content || '').toLowerCase();
+    if (!text.trim()) return false;
+
+    const clarification = /(?:cần thêm|cho mình|vui lòng|please provide|which file|what file|need more|clarify|không rõ|chưa rõ|file nào|thư mục nào)/i;
+    if (clarification.test(text)) return false;
+    return true;
+  }
+
+  buildToolEvidenceCorrection(messages = []) {
+    const request = this.getLatestUserText(messages);
+    return [
+      'Runtime correction: the user requested an action that requires tool evidence.',
+      'Your previous response did not use any tool, so it was blocked to avoid falsely claiming completion.',
+      'Now use the available tools to inspect/edit/run/check as needed. Do not say the task is done until a tool result proves it.',
+      `Original user request: ${request}`,
+    ].join('\n');
+  }
+
   async requestAssistantTurn(messages, options, startedAt, totalUsage) {
     if (typeof this.ai.streamRequest === 'function') {
       try {
@@ -1321,6 +1318,9 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     const finishReason = response.choices?.[0]?.finish_reason;
 
     if (assistantMsg.content && toolCalls.length === 0) {
+      if (options?.requireToolEvidence && this.responseNeedsToolEvidence(assistantMsg.content)) {
+        return { assistantMsg, toolCalls, finalContent: '', finishReason: 'tool_evidence_required' };
+      }
       this.printAssistantAnswer(assistantMsg.content, startedAt, totalUsage);
       return { assistantMsg, toolCalls, finalContent: assistantMsg.content, finishReason };
     }
@@ -1389,6 +1389,14 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     const visibleContent = inlineToolExtraction.content || content;
 
     if (bufferToolModeContent && toolCalls.length === 0 && visibleContent) {
+      if (options?.requireToolEvidence && this.responseNeedsToolEvidence(visibleContent)) {
+        return {
+          assistantMsg: { content: visibleContent },
+          toolCalls,
+          finalContent: '',
+          finishReason: 'tool_evidence_required',
+        };
+      }
       this.printAssistantAnswer(visibleContent, startedAt, totalUsage);
       return {
         assistantMsg: { content: visibleContent },
@@ -1576,8 +1584,9 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     if (query === '/') {
       const preferred = [
         '/help', '/exit', '/pwd', '/cd',
-        '/provider', '/model', '/models', '/providers',
-        '/read', '/write', '/glob', '/grep', '/bash',
+          '/provider', '/model', '/models', '/providers',
+          '/auto', '/debug', '/swe',
+          '/read', '/write', '/glob', '/grep', '/bash',
         '/codex', '/claude', '/karpathy', '/agents',
         '/resources', '/designs', '/skills',
       ];

package/src/cli/runtime-env.js

@@ -0,0 +1,130 @@
+import { execFileSync } from 'child_process';
+
+let cachedDefaultProfile = null;
+let cachedParentProcessName = null;
+
+export function getHostOs(platform = process.platform) {
+  if (platform === 'win32') return 'Windows';
+  if (platform === 'darwin') return 'macOS';
+  if (platform === 'linux') return 'Linux';
+  return platform;
+}
+
+export function detectTerminalApp(env = process.env, platform = process.platform) {
+  if (env.WT_SESSION) return 'Windows Terminal';
+  if (env.TERM_PROGRAM) return env.TERM_PROGRAM;
+  if (env.VSCODE_PID || env.TERM_PROGRAM === 'vscode') return 'VS Code integrated terminal';
+  if (env.ConEmuANSI || env.ConEmuBuild) return 'ConEmu/Cmder';
+  if (env.TERMINUS_SUBLIME || env.TERMINUS_SESSION) return 'Terminus';
+  if (env.TERM) return env.TERM;
+  if (platform === 'win32') return 'Windows console host';
+  return 'unknown';
+}
+
+export function detectCurrentShell(env = process.env, platform = process.platform) {
+  if (platform !== 'win32') {
+    return {
+      name: env.SHELL ? env.SHELL.split(/[\\/]/).pop() : 'sh',
+      kind: env.SHELL ? env.SHELL.split(/[\\/]/).pop() : 'sh',
+      source: 'SHELL',
+      path: env.SHELL || '',
+    };
+  }
+
+  const shellPath = env.SHELL || '';
+  const lowerShell = shellPath.toLowerCase();
+  const parentName = detectParentProcessName(env, platform).toLowerCase();
+  const parentProcess = [
+    env.WINTER_PARENT_PROCESS,
+    env.npm_config_script_shell,
+    parentName,
+  ].filter(Boolean).join(' ').toLowerCase();
+
+  if (lowerShell.includes('pwsh') || parentProcess.includes('pwsh')) {
+    return { name: 'pwsh', kind: 'powershell', source: 'env', path: shellPath };
+  }
+  if (lowerShell.includes('powershell') || parentProcess.includes('powershell')) {
+    return { name: 'powershell.exe', kind: 'powershell', source: 'env', path: shellPath };
+  }
+  if (lowerShell.includes('cmd.exe') || parentProcess.includes('cmd.exe')) {
+    return { name: 'cmd.exe', kind: 'cmd', source: 'parent/env', path: shellPath || env.ComSpec || '' };
+  }
+  return {
+    name: parentName || 'unknown Windows shell',
+    kind: 'unknown',
+    source: parentName ? 'parent' : 'unknown',
+    path: shellPath || env.ComSpec || '',
+  };
+}
+
+export function detectParentProcessName(env = process.env, platform = process.platform) {
+  if (env.WINTER_PARENT_PROCESS) return env.WINTER_PARENT_PROCESS;
+  if (platform !== 'win32') return '';
+  if (env === process.env && cachedParentProcessName !== null) return cachedParentProcessName;
+
+  try {
+    const script = `$p=(Get-CimInstance Win32_Process -Filter "ProcessId=${process.ppid}" -ErrorAction SilentlyContinue); if($p){$p.Name}`;
+    const parentName = execFileSync('powershell.exe', ['-NoProfile', '-Command', script], {
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 1500,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    if (env === process.env) cachedParentProcessName = parentName;
+    return parentName;
+  } catch {
+    if (env === process.env) cachedParentProcessName = '';
+    return '';
+  }
+}
+
+export function getRuntimeEnvironment(env = process.env, platform = process.platform) {
+  if (env === process.env && platform === process.platform && cachedDefaultProfile) {
+    return cachedDefaultProfile;
+  }
+
+  const shell = detectCurrentShell(env, platform);
+  const terminalApp = detectTerminalApp(env, platform);
+  const defaultExecutionShell = platform === 'win32'
+    ? (shell.kind === 'cmd' ? 'cmd' : 'powershell')
+    : (env.SHELL || 'sh');
+
+  const profile = {
+    hostOs: getHostOs(platform),
+    platform,
+    arch: process.arch,
+    terminalApp,
+    shell,
+    defaultExecutionShell,
+    isWindows: platform === 'win32',
+  };
+
+  if (env === process.env && platform === process.platform) {
+    cachedDefaultProfile = profile;
+  }
+
+  return profile;
+}
+
+export function formatRuntimeEnvironmentSummary(profile = getRuntimeEnvironment()) {
+  const shellPath = profile.shell?.path ? ` (${profile.shell.path})` : '';
+  const shellRule = profile.isWindows
+    ? [
+        'Bash tool shell rules:',
+        '- default/auto executes PowerShell unless the command clearly uses cmd.exe syntax.',
+        '- use shell:"powershell" for PowerShell cmdlets, pipes, Get-ChildItem, Select-String, npm/node commands.',
+        '- use shell:"cmd" for cmd builtins such as type, copy, del, dir /b, echo foo>file, && chains.',
+        '- do not mix PowerShell-only syntax with shell:"cmd" or cmd-only redirection with shell:"powershell".',
+      ].join('\n')
+    : 'Bash tool shell rule: use the native POSIX shell; leave shell unspecified unless a specific shell is required.';
+
+  return [
+    `Host OS: ${profile.hostOs}`,
+    `Node platform: ${profile.platform}`,
+    `CPU arch: ${profile.arch}`,
+    `Terminal app: ${profile.terminalApp}`,
+    `Detected current shell: ${profile.shell?.name || 'unknown'} [${profile.shell?.kind || 'unknown'}]${shellPath}`,
+    `Bash default execution shell: ${profile.defaultExecutionShell}`,
+    shellRule,
+  ].join('\n');
+}

package/src/cli/slash-commands.js

@@ -14,6 +14,9 @@ export const SLASH_COMMANDS = [
   { cmd: '/tasks', desc: 'List tasks' },
   { cmd: '/task', desc: 'Create task', usage: '/task <description>' },
   { cmd: '/agent', desc: 'Launch subagent', usage: '/agent <task>' },
+  { cmd: '/auto', desc: 'Auto-heal with test/build loop', usage: '/auto [task]' },
+  { cmd: '/debug', desc: 'Auto-debug errors with tool verification', usage: '/debug [error or task]' },
+  { cmd: '/tdd', desc: 'Alias for auto-healing loop', usage: '/tdd [task]' },
   { cmd: '/read', desc: 'Read file', usage: '/read <file>' },
   { cmd: '/write', desc: 'Write file', usage: '/write <file> <content>' },
   { cmd: '/glob', desc: 'Find files', usage: '/glob <pattern>' },
@@ -47,4 +50,3 @@ export const SLASH_COMMANDS = [
   { cmd: '/exit', desc: 'Exit Winter' },
   { cmd: '/quit', desc: 'Exit Winter' },
 ];
-

package/src/session/manager.js

@@ -40,12 +40,40 @@ export class SessionManager {
       console.log(`\x1b[33m⚠ Không tìm thấy session ${options.sessionId}, tạo session mới...\x1b[0m`);
     }
 
-    // Luôn tạo session mới nếu không yêu cầu load hoặc load thất bại
+    // Mặc định resume session mới nhất của đúng project để /memories không bị rỗng sau restart.
+    if (options.resume !== false && !options.newSession) {
+      const success = await this.loadLatestProjectSession(options.project || process.cwd());
+      if (success) {
+        await this.rememberProject(this.currentSession?.project || options.project || process.cwd());
+        this.initialized = true;
+        return;
+      }
+    }
+
     await this.newSession(options);
     await this.rememberProject(options.project || this.currentSession?.project || process.cwd());
     this.initialized = true;
   }
 
+  normalizeProjectPath(projectPath) {
+    if (!projectPath) return '';
+    const normalized = path.resolve(projectPath);
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+  }
+
+  hydrateSession(session) {
+    this.currentSession = session;
+    this.context = session.context || {};
+    this.plans = session.plans || [];
+    this.memory = session.memory || [];
+    this.currentSession.history = session.history || [];
+  }
+
+  async writeCurrentPointer(sessionId) {
+    const currentPath = path.join(this.sessionsDir, 'active', 'current.json');
+    await fs.writeFile(currentPath, JSON.stringify({ id: sessionId }));
+  }
+
   async loadSession(sessionId) {
     const sessionPath = path.join(this.sessionsDir, 'active', `${sessionId}.json`);
     try {
@@ -64,6 +92,43 @@ export class SessionManager {
     }
   }
 
+  async loadLatestProjectSession(projectPath) {
+    const activeDir = path.join(this.sessionsDir, 'active');
+    const targetProject = this.normalizeProjectPath(projectPath);
+    if (!targetProject) return false;
+
+    try {
+      const files = await fs.readdir(activeDir);
+      const candidates = [];
+
+      for (const file of files) {
+        if (!file.endsWith('.json') || file === 'current.json') continue;
+
+        try {
+          const sessionData = await fs.readFile(path.join(activeDir, file), 'utf8');
+          const session = JSON.parse(sessionData);
+          if (this.normalizeProjectPath(session.project) !== targetProject) continue;
+
+          candidates.push({
+            session,
+            time: Date.parse(session.updatedAt || session.createdAt || 0) || 0,
+          });
+        } catch {
+          // Skip corrupt or partially-written session files.
+        }
+      }
+
+      candidates.sort((a, b) => b.time - a.time);
+      if (candidates.length === 0) return false;
+
+      this.hydrateSession(candidates[0].session);
+      await this.writeCurrentPointer(this.currentSession.id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   async newSession(options = {}) {
     const sessionId = crypto.randomUUID();
     const sessionPath = path.join(this.sessionsDir, 'active', `${sessionId}.json`);

package/src/tools/executor.js

@@ -20,6 +20,7 @@ import { AgentTool } from './agent.js';
 import { InsertTextTool } from './insert-text.js';
 import { StrReplaceAllTool } from './str-replace-all.js';
 import { WebArchiveTool } from './web-archive.js';
+import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from '../cli/runtime-env.js';
 
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
@@ -44,28 +45,7 @@ export class ToolExecutor {
   }
 
   getRuntimeEnvironmentSummary() {
-    const hostOs = process.platform === 'win32'
-      ? 'Windows'
-      : process.platform === 'darwin'
-        ? 'macOS'
-        : process.platform === 'linux'
-          ? 'Linux'
-          : process.platform;
-
-    const currentShell = process.platform === 'win32'
-      ? (process.env.PSModulePath ? 'powershell-capable' : 'cmd/unknown')
-      : (process.env.SHELL || 'bash/sh');
-
-    const shellGuidance = process.platform === 'win32'
-      ? 'Use shell:"powershell" for PowerShell cmdlets, shell:"cmd" for cmd.exe syntax, and shell:"auto" when unsure.'
-      : 'Use the native POSIX shell on non-Windows hosts and leave shell unspecified unless a specific shell is required.';
-
-    return [
-      `Host OS: ${hostOs}`,
-      `Node platform: ${process.platform}`,
-      `Current shell hint: ${currentShell}`,
-      `Shell rule: ${shellGuidance}`,
-    ].join('\n');
+    return formatRuntimeEnvironmentSummary(getRuntimeEnvironment());
   }
 
   getToolDefinitions() {
@@ -1057,6 +1037,9 @@ export class ToolExecutor {
     }
 
     try {
+      const executedShell = process.platform === 'win32'
+        ? (requestedShell === 'auto' ? this.detectWindowsShell(command) : requestedShell)
+        : (process.env.SHELL || 'native');
       const { stdout, stderr } = process.platform === 'win32'
         ? await this.execWindowsCommand(command, cwd, timeout, requestedShell)
         : await execAsync(command, { cwd, timeout, shell: true, maxBuffer: 10 * 1024 * 1024 });
@@ -1064,7 +1047,8 @@ export class ToolExecutor {
         success: true,
         stdout: stdout || '',
         stderr: stderr || '',
-        exitCode: 0
+        exitCode: 0,
+        shell: executedShell,
       };
     } catch (error) {
       return {