flowmind 1.3.0 → 1.4.1

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+## [1.3.0] - 2026-06-26
+
+### Fixed
+- Missing `os` import in config-manager.js
+- MCP Server version hardcoded instead of reading from package.json
+- `config --set` and `skill --set` CLI commands broken (Commander arg parsing)
+- `learn --reset` and `learn --delete` were unimplemented stubs
+- Learning engine race condition on concurrent file writes (added WriteQueue)
+- TUI/Dashboard crash on non-TTY stdin (Ink raw mode error)
+
+### Added
+- All 17 skills now have working `execute()` implementations
+- Global uncaughtException/unhandledRejection handlers
+- Graceful exit handling in TUI via onExit callback
+
+## [1.2.2] - 2026-06-26
+
+### Fixed
+- ChatPanel React import issue with ink-text-input and ink-spinner ESM/CJS interop
+
+## [1.2.0] - 2026-06-26
+
+### Added
+- TUI with split panels, skill browser, dragon display
+- Dashboard with real-time activity feed and stats
+- Event system for cross-component communication
+- Update command for auto-updating flowmind
+
+## [1.1.0] - 2026-06-25
+
+### Added
+- Mainstream AI model providers (GLM, MiMo, Qwen, ERNIE, DeepSeek)
+- AI model integration with rule-based fallback
+- MCP Server for Claude/Codex integration
+
+## [1.0.1] - 2026-06-24
+
+### Added
+- Initial release
+- Skill loading and execution engine
+- Learning engine for user corrections and preferences
+- Honor engine with dragon totem gamification
+- Scene matcher for workflow automation
+- Configuration manager

package/README.md

@@ -8,7 +8,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
-[![Version](https://img.shields.io/badge/version-1.1.0-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-1.3.0-blue)](CHANGELOG.md)
 
 [中文](README_CN.md) | [Quick Start](#-quick-start) | [How It Works](#-how-it-works) | [Use Cases](#-use-cases) | [Architecture](#-architecture)
 

package/bin/flowmind.js

@@ -1460,6 +1460,52 @@ program
     }
   });
 
+// Doctor command - System health check
+program
+  .command('doctor')
+  .description('Run system health checks and diagnostics')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      const fm = await initFlowMind();
+      const result = await fm.doctor();
+
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      console.log(chalk.cyan('\nFlowMind Health Check\n'));
+      console.log('─'.repeat(60));
+
+      for (const check of result.checks) {
+        const icon = check.status === 'ok' ? chalk.green('✓')
+          : check.status === 'warning' ? chalk.yellow('⚠')
+          : chalk.red('✗');
+        console.log(`  ${icon} ${check.name.padEnd(20)} ${check.message}`);
+      }
+
+      console.log('─'.repeat(60));
+      const { ok, warnings, errors } = result.summary;
+      const summaryLine = [
+        chalk.green(`${ok} ok`),
+        warnings > 0 ? chalk.yellow(`${warnings} warning(s)`) : null,
+        errors > 0 ? chalk.red(`${errors} error(s)`) : null
+      ].filter(Boolean).join(', ');
+      console.log(`\n  Result: ${summaryLine}`);
+
+      if (errors > 0) {
+        console.log(chalk.red('\n  Some checks failed. Please fix the errors above.'));
+      } else if (warnings > 0) {
+        console.log(chalk.yellow('\n  Some warnings detected. Review for potential issues.'));
+      } else {
+        console.log(chalk.green('\n  All checks passed!'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Doctor Error:'), error.message);
+    }
+  });
+
 // Update command - Auto-update flowmind
 program
   .command('update')

package/core/ai/base-model.js

@@ -8,48 +8,27 @@ class BaseModel {
     this.name = name;
     this.config = config;
     this.initialized = false;
+    this.requestTimeout = config.requestTimeout || 30000;
+    this.maxRetries = config.maxRetries || 3;
+    this.retryDelay = config.retryDelay || 1000;
   }
 
-  /**
-   * 初始化模型
-   * @returns {Promise<void>}
-   */
   async init() {
     throw new Error('init() must be implemented by subclass');
   }
 
-  /**
-   * 发送聊天请求
-   * @param {Array} messages - 消息数组 [{role, content}]
-   * @param {Object} options - 请求选项
-   * @returns {Promise<string>} 模型响应
-   */
   async chat(messages, options = {}) {
     throw new Error('chat() must be implemented by subclass');
   }
 
-  /**
-   * 发送补全请求
-   * @param {string} prompt - 提示词
-   * @param {Object} options - 请求选项
-   * @returns {Promise<string>} 模型响应
-   */
   async complete(prompt, options = {}) {
     throw new Error('complete() must be implemented by subclass');
   }
 
-  /**
-   * 检查模型是否可用
-   * @returns {Promise<boolean>}
-   */
   async isAvailable() {
     throw new Error('isAvailable() must be implemented by subclass');
   }
 
-  /**
-   * 获取模型信息
-   * @returns {Object}
-   */
   getInfo() {
     return {
       name: this.name,
@@ -58,13 +37,53 @@ class BaseModel {
     };
   }
 
-  /**
-   * 验证配置
-   * @returns {boolean}
-   */
   validateConfig() {
     return true;
   }
+
+  /**
+   * Fetch with retry, timeout, and exponential backoff
+   */
+  async fetchWithRetry(url, options = {}) {
+    const timeout = options.timeout || this.requestTimeout;
+    const maxRetries = options.retries || this.maxRetries;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal
+        });
+
+        clearTimeout(timer);
+
+        // Retry on rate limit (429) and server errors (5xx)
+        if (response.status === 429 || response.status >= 500) {
+          if (attempt < maxRetries) {
+            const delay = this.retryDelay * Math.pow(2, attempt);
+            await new Promise(r => setTimeout(r, delay));
+            continue;
+          }
+        }
+
+        return response;
+      } catch (error) {
+        if (error.name === 'AbortError') {
+          if (attempt < maxRetries) continue;
+          throw new Error(`Request timeout after ${timeout}ms`);
+        }
+        if (attempt < maxRetries) {
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
 }
 
 module.exports = BaseModel;

package/core/ai/model-manager.js

@@ -28,6 +28,9 @@ class ModelManager {
     };
     this.fallbackToRules = config.fallbackToRules !== false;
     this.initialized = false;
+    this.cache = new Map();
+    this.cacheMaxAge = config.cacheMaxAge || 300000; // 5 minutes
+    this.cacheMaxSize = config.cacheMaxSize || 100;
   }
 
   /**
@@ -119,30 +122,16 @@ class ModelManager {
    * @returns {Promise<Object>} 意图分析结果
    */
   async understandIntent(input, context = {}) {
-    if (!this.features.intentUnderstanding) {
-      return null;
-    }
-
-    const provider = this.getDefaultProvider();
-    if (!provider) {
-      return this._fallback('intentUnderstanding', input, context);
-    }
+    if (!this.features.intentUnderstanding) return null;
 
-    try {
+    return this._callWithFailover(async (provider) => {
       const messages = [
         { role: 'system', content: prompts.intent.system },
         { role: 'user', content: prompts.intent.user(input, context) }
       ];
-
-      const response = await provider.chat(messages, {
-        responseFormat: { type: 'json_object' }
-      });
-
+      const response = await provider.chat(messages, { responseFormat: { type: 'json_object' } });
       return JSON.parse(response);
-    } catch (error) {
-      console.warn(`AI intent understanding failed: ${error.message}`);
-      return this._fallback('intentUnderstanding', input, context);
-    }
+    }, 'intentUnderstanding');
   }
 
   /**
@@ -153,30 +142,16 @@ class ModelManager {
    * @returns {Promise<Object>} 提取的参数
    */
   async extractParameters(input, skillName, skillSchema = {}) {
-    if (!this.features.parameterExtraction) {
-      return {};
-    }
+    if (!this.features.parameterExtraction) return {};
 
-    const provider = this.getDefaultProvider();
-    if (!provider) {
-      return this._fallback('parameterExtraction', input, { skillName });
-    }
-
-    try {
+    return this._callWithFailover(async (provider) => {
       const messages = [
         { role: 'system', content: prompts.extraction.system },
         { role: 'user', content: prompts.extraction.user(input, skillName, skillSchema) }
       ];
-
-      const response = await provider.chat(messages, {
-        responseFormat: { type: 'json_object' }
-      });
-
+      const response = await provider.chat(messages, { responseFormat: { type: 'json_object' } });
       return JSON.parse(response);
-    } catch (error) {
-      console.warn(`AI parameter extraction failed: ${error.message}`);
-      return this._fallback('parameterExtraction', input, { skillName });
-    }
+    }, 'parameterExtraction');
   }
 
   /**
@@ -186,30 +161,16 @@ class ModelManager {
    * @returns {Promise<Object>} 选择的技能
    */
   async selectSkill(input, candidates) {
-    if (!this.features.skillSelection) {
-      return null;
-    }
+    if (!this.features.skillSelection) return null;
 
-    const provider = this.getDefaultProvider();
-    if (!provider) {
-      return this._fallback('skillSelection', input, { candidates });
-    }
-
-    try {
+    return this._callWithFailover(async (provider) => {
       const messages = [
         { role: 'system', content: prompts.selection.system },
         { role: 'user', content: prompts.selection.user(input, candidates) }
       ];
-
-      const response = await provider.chat(messages, {
-        responseFormat: { type: 'json_object' }
-      });
-
+      const response = await provider.chat(messages, { responseFormat: { type: 'json_object' } });
       return JSON.parse(response);
-    } catch (error) {
-      console.warn(`AI skill selection failed: ${error.message}`);
-      return this._fallback('skillSelection', input, { candidates });
-    }
+    }, 'skillSelection');
   }
 
   /**
@@ -219,26 +180,15 @@ class ModelManager {
    * @returns {Promise<string>} 摘要文本
    */
   async summarizeResult(result, context = {}) {
-    if (!this.features.resultSummary) {
-      return null;
-    }
+    if (!this.features.resultSummary) return null;
 
-    const provider = this.getDefaultProvider();
-    if (!provider) {
-      return this._fallback('resultSummary', result, context);
-    }
-
-    try {
+    return this._callWithFailover(async (provider) => {
       const messages = [
         { role: 'system', content: prompts.summary.system },
         { role: 'user', content: prompts.summary.user(result, context) }
       ];
-
       return await provider.chat(messages);
-    } catch (error) {
-      console.warn(`AI result summary failed: ${error.message}`);
-      return this._fallback('resultSummary', result, context);
-    }
+    }, 'resultSummary');
   }
 
   /**
@@ -248,42 +198,102 @@ class ModelManager {
    * @returns {Promise<Object>} 学习分析结果
    */
   async analyzeLearningFeedback(input, context = {}) {
-    if (!this.features.learningFeedback) {
-      return null;
-    }
-
-    const provider = this.getDefaultProvider();
-    if (!provider) {
-      return this._fallback('learningFeedback', input, context);
-    }
+    if (!this.features.learningFeedback) return null;
 
-    try {
+    return this._callWithFailover(async (provider) => {
       const messages = [
         { role: 'system', content: prompts.learning.system },
         { role: 'user', content: prompts.learning.user(input, context) }
       ];
+      const response = await provider.chat(messages, { responseFormat: { type: 'json_object' } });
+      return JSON.parse(response);
+    }, 'learningFeedback');
+  }
 
-      const response = await provider.chat(messages, {
-        responseFormat: { type: 'json_object' }
-      });
+  /**
+   * Get cached result if available and not expired
+   * @private
+   */
+  _getCached(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.timestamp > this.cacheMaxAge) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
 
-      return JSON.parse(response);
-    } catch (error) {
-      console.warn(`AI learning feedback analysis failed: ${error.message}`);
-      return this._fallback('learningFeedback', input, context);
+  /**
+   * Set cache entry, evicting oldest if at capacity
+   * @private
+   */
+  _setCache(key, value) {
+    if (this.cache.size >= this.cacheMaxSize) {
+      const oldest = this.cache.keys().next().value;
+      this.cache.delete(oldest);
+    }
+    this.cache.set(key, { value, timestamp: Date.now() });
+  }
+
+  /**
+   * Clear the AI response cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+
+  /**
+   * Call AI with automatic failover to other providers
+   * @private
+   */
+  async _callWithFailover(fn, feature) {
+    // Try default provider first
+    const defaultProvider = this.getDefaultProvider();
+    if (defaultProvider) {
+      try {
+        return await fn(defaultProvider);
+      } catch (error) {
+        console.warn(`Default provider (${this.defaultProvider}) failed for ${feature}: ${error.message}`);
+      }
     }
+
+    // Try other providers
+    for (const [name, provider] of this.providers) {
+      if (name === this.defaultProvider || !provider.initialized) continue;
+      try {
+        console.warn(`Failing over to provider: ${name} for ${feature}`);
+        return await fn(provider);
+      } catch (error) {
+        console.warn(`Failover provider ${name} failed for ${feature}: ${error.message}`);
+      }
+    }
+
+    // All providers failed, use rule-based fallback
+    return this._fallback(feature);
   }
 
   /**
-   * 降级处理
+   * Rule-based fallback when AI is unavailable
    * @private
    */
-  _fallback(feature, input, context) {
-    if (!this.fallbackToRules) {
-      return null;
+  _fallback(feature) {
+    if (!this.fallbackToRules) return null;
+
+    switch (feature) {
+      case 'intentUnderstanding':
+        return { intent: 'unknown', confidence: 0, source: 'rules' };
+      case 'parameterExtraction':
+        return {};
+      case 'skillSelection':
+        return { selectedSkill: null, confidence: 0, source: 'rules' };
+      case 'resultSummary':
+        return null;
+      case 'learningFeedback':
+        return { isLearning: false, source: 'rules' };
+      default:
+        return null;
     }
-    // 返回 null，让调用方使用规则引擎
-    return null;
   }
 
   /**

package/core/ai/providers/anthropic.js

@@ -8,7 +8,7 @@ class AnthropicProvider extends BaseModel {
   constructor(config = {}) {
     super('anthropic', config);
     this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
-    this.model = config.model || 'claude-3-sonnet-20240229';
+    this.model = config.model || 'claude-sonnet-4-20250514';
     this.baseUrl = config.baseUrl || 'https://api.anthropic.com';
     this.maxTokens = config.maxTokens ?? 2000;
     this.temperature = config.temperature ?? 0.3;
@@ -26,14 +26,10 @@ class AnthropicProvider extends BaseModel {
   }
 
   async chat(messages, options = {}) {
-    if (!this.initialized) {
-      await this.init();
-    }
+    if (!this.initialized) await this.init();
 
-    // 转换消息格式：提取 system 消息
     let systemPrompt = '';
     const userMessages = [];
-
     for (const msg of messages) {
       if (msg.role === 'system') {
         systemPrompt = msg.content;
@@ -42,7 +38,7 @@ class AnthropicProvider extends BaseModel {
       }
     }
 
-    const response = await fetch(`${this.baseUrl}/v1/messages`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/v1/messages`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -74,19 +70,30 @@ class AnthropicProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      // Anthropic 没有 models 端点，直接尝试调用
-      return true;
+      // Anthropic has no /models endpoint; make a lightweight messages call to verify
+      const response = await this.fetchWithRetry(`${this.baseUrl}/v1/messages`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: 1,
+          messages: [{ role: 'user', content: 'hi' }]
+        }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400; // 400 = bad request but API is reachable
     } catch {
       return false;
     }
   }
 
   getInfo() {
-    return {
-      ...super.getInfo(),
-      model: this.model,
-      baseUrl: this.baseUrl
-    };
+    return { ...super.getInfo(), model: this.model, baseUrl: this.baseUrl };
   }
 }
 

package/core/ai/providers/deepseek.js

@@ -31,7 +31,7 @@ class DeepSeekProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,7 +61,17 @@ class DeepSeekProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      return true;
+      const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400;
     } catch {
       return false;
     }

package/core/ai/providers/ernie.js

@@ -26,7 +26,7 @@ class ERNIEProvider extends BaseModel {
   }
 
   async refreshAccessToken() {
-    const response = await fetch(
+    const response = await this.fetchWithRetry(
       `https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=${this.apiKey}&client_secret=${this.secretKey}`,
       { method: 'POST' }
     );
@@ -51,7 +51,7 @@ class ERNIEProvider extends BaseModel {
     const model = options.model || this.model;
     const endpoint = this.getEndpoint(model);
 
-    const response = await fetch(`${this.baseUrl}${endpoint}?access_token=${this.accessToken}`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}${endpoint}?access_token=${this.accessToken}`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json'

package/core/ai/providers/glm.js

@@ -31,7 +31,7 @@ class GLMProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,7 +61,17 @@ class GLMProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      return true;
+      const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400;
     } catch {
       return false;
     }

package/core/ai/providers/mimo.js

@@ -31,7 +31,7 @@ class MiMoProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,7 +61,17 @@ class MiMoProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      return true;
+      const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400;
     } catch {
       return false;
     }

package/core/ai/providers/ollama.js

@@ -34,7 +34,7 @@ class OllamaProvider extends BaseModel {
     // 转换消息格式为 Ollama 格式
     const prompt = this._convertMessagesToPrompt(messages);
 
-    const response = await fetch(`${this.baseUrl}/api/generate`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/api/generate`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json'
@@ -64,7 +64,7 @@ class OllamaProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/api/generate`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/api/generate`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json'
@@ -91,9 +91,10 @@ class OllamaProvider extends BaseModel {
 
   async isAvailable() {
     try {
-      const response = await fetch(`${this.baseUrl}/api/tags`, {
+      const response = await this.fetchWithRetry(`${this.baseUrl}/api/tags`, {
         method: 'GET',
-        signal: AbortSignal.timeout(5000) // 5秒超时
+        retries: 1,
+        timeout: 5000
       });
       return response.ok;
     } catch {

package/core/ai/providers/openai.js

@@ -8,7 +8,7 @@ class OpenAIProvider extends BaseModel {
   constructor(config = {}) {
     super('openai', config);
     this.apiKey = config.apiKey || process.env.OPENAI_API_KEY;
-    this.model = config.model || 'gpt-4';
+    this.model = config.model || 'gpt-4o';
     this.baseUrl = config.baseUrl || 'https://api.openai.com/v1';
     this.temperature = config.temperature ?? 0.3;
     this.maxTokens = config.maxTokens ?? 2000;
@@ -26,11 +26,9 @@ class OpenAIProvider extends BaseModel {
   }
 
   async chat(messages, options = {}) {
-    if (!this.initialized) {
-      await this.init();
-    }
+    if (!this.initialized) await this.init();
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,8 +59,10 @@ class OpenAIProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      const response = await fetch(`${this.baseUrl}/models`, {
-        headers: { 'Authorization': `Bearer ${this.apiKey}` }
+      const response = await this.fetchWithRetry(`${this.baseUrl}/models`, {
+        headers: { 'Authorization': `Bearer ${this.apiKey}` },
+        retries: 1,
+        timeout: 10000
       });
       return response.ok;
     } catch {
@@ -71,11 +71,7 @@ class OpenAIProvider extends BaseModel {
   }
 
   getInfo() {
-    return {
-      ...super.getInfo(),
-      model: this.model,
-      baseUrl: this.baseUrl
-    };
+    return { ...super.getInfo(), model: this.model, baseUrl: this.baseUrl };
   }
 }
 

package/core/ai/providers/qwen.js

@@ -31,7 +31,7 @@ class QwenProvider extends BaseModel {
       await this.init();
     }
 
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+    const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -61,7 +61,17 @@ class QwenProvider extends BaseModel {
   async isAvailable() {
     try {
       if (!this.apiKey) return false;
-      return true;
+      const response = await this.fetchWithRetry(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ model: this.model, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        retries: 1,
+        timeout: 10000
+      });
+      return response.ok || response.status === 400;
     } catch {
       return false;
     }

package/core/honor-engine.js

@@ -50,7 +50,7 @@ class HonorEngine {
       }
       this.initialized = true;
     } catch (error) {
-      // Non-blocking: create default data in memory
+      console.warn('HonorEngine init failed, using defaults:', error.message);
       this.data = this.createDefaultData();
       this.initialized = true;
     }
@@ -92,7 +92,7 @@ class HonorEngine {
         }
       }
     } catch (error) {
-      // Non-blocking
+      console.warn('HonorEngine seedKnownSkills failed:', error.message);
     }
   }
 
@@ -148,7 +148,7 @@ class HonorEngine {
         timestamp: this.data.lastUpdated
       });
     } catch (error) {
-      // Non-blocking
+      console.warn('HonorEngine award failed:', error.message);
     }
   }
 
@@ -170,7 +170,7 @@ class HonorEngine {
         await this.save();
       }
     } catch (error) {
-      // Non-blocking
+      console.warn('HonorEngine addKnownSkill failed:', error.message);
     }
   }
 
@@ -247,7 +247,7 @@ class HonorEngine {
       await fs.ensureDir(path.dirname(this.honorPath));
       await fs.writeJson(this.honorPath, this.data, { spaces: 2 });
     } catch (error) {
-      // Non-blocking
+      console.warn('HonorEngine save failed:', error.message);
     }
   }
 }

package/core/index.js

@@ -22,6 +22,8 @@ class FlowMind {
     this.skills = new SkillLoader(this.config, this.learning, this.components, this.honor);
     this.ai = new ModelManager(options.ai || {});
     this.initialized = false;
+    this.conversationHistory = [];
+    this.maxHistoryLength = options.maxHistoryLength || 50;
   }
 
   /**
@@ -31,6 +33,13 @@ class FlowMind {
     if (this.initialized) return this;
 
     await this.config.load();
+
+    // Validate configuration
+    const validation = this.config.validate();
+    if (!validation.valid) {
+      console.warn('Configuration warnings:', validation.errors.join(', '));
+    }
+
     await this.components.init();
     await this.components.initAll();
     await this.honor.init();
@@ -49,6 +58,19 @@ class FlowMind {
     return this;
   }
 
+  /**
+   * Process a user request with streaming support
+   * Yields progress updates as an async generator
+   */
+  async *processStream(input, context = {}) {
+    yield { type: 'start', input, timestamp: new Date().toISOString() };
+
+    const result = await this.process(input, context);
+
+    yield { type: 'progress', message: `Skill: ${result.metadata?.skill || 'unknown'}`, timestamp: new Date().toISOString() };
+    yield { type: 'result', data: result, timestamp: new Date().toISOString() };
+  }
+
   /**
    * Process a user request
    */
@@ -57,20 +79,31 @@ class FlowMind {
       await this.init();
     }
 
+    if (!input || typeof input !== 'string') {
+      return this.formatError('Invalid input: expected a non-empty string', input);
+    }
+
     const startTime = Date.now();
 
+    // Build context with conversation history
+    const enhancedContext = {
+      ...context,
+      conversationHistory: this.conversationHistory.slice(-10),
+      sessionId: context.sessionId || 'default'
+    };
+
     eventBus.emit('process:start', { input, timestamp: new Date().toISOString() });
 
     try {
       // 1. AI Intent Understanding (if available)
-      const intent = await this.ai.understandIntent(input, context);
+      const intent = await this.ai.understandIntent(input, enhancedContext);
 
       // 2. Check for learning patterns (corrections, feedback)
       // Use AI to analyze learning feedback if available
-      const aiLearningResult = await this.ai.analyzeLearningFeedback(input, context);
+      const aiLearningResult = await this.ai.analyzeLearningFeedback(input, enhancedContext);
       const learningResult = aiLearningResult?.isLearning
         ? aiLearningResult
-        : await this.learning.detectLearning(input, context);
+        : await this.learning.detectLearning(input, enhancedContext);
       if (learningResult) {
         return this.formatLearningResponse(learningResult);
       }
@@ -106,12 +139,12 @@ class FlowMind {
       const extractedParams = await this.ai.extractParameters(input, skill.name);
 
       // 6. Execute with learning applied
-      const enhancedContext = {
-        ...context,
+      const executeContext = {
+        ...enhancedContext,
         ...extractedParams,
         intent: intent
       };
-      const result = await this.executeWithLearning(skill, input, enhancedContext);
+      const result = await this.executeWithLearning(skill, input, executeContext);
 
       // 7. Generate AI summary (if available)
       const summary = await this.ai.summarizeResult(result, {
@@ -128,6 +161,17 @@ class FlowMind {
         aiEnhanced: !!summary
       });
 
+      // Save to conversation history
+      this.conversationHistory.push({
+        input,
+        output: formatted,
+        skill: skill.name,
+        timestamp: new Date().toISOString()
+      });
+      if (this.conversationHistory.length > this.maxHistoryLength) {
+        this.conversationHistory.shift();
+      }
+
       eventBus.emit('process:complete', {
         input,
         skill: skill.name,
@@ -320,6 +364,146 @@ class FlowMind {
   async importLearnings(data) {
     return this.learning.import(data);
   }
+
+  /**
+   * Get conversation history
+   */
+  getConversationHistory(sessionId) {
+    if (sessionId) {
+      return this.conversationHistory.filter(h => h.sessionId === sessionId);
+    }
+    return this.conversationHistory;
+  }
+
+  /**
+   * Clear conversation history
+   */
+  clearHistory() {
+    this.conversationHistory = [];
+  }
+
+  /**
+   * Graceful shutdown - flush pending data and clean up
+   */
+  async shutdown() {
+    eventBus.emit('shutdown:start', { timestamp: new Date().toISOString() });
+
+    // Save learning data
+    try {
+      if (this.learning?.skillBindings) {
+        await this.learning.saveSkillBindings();
+      }
+      if (this.learning?.stats) {
+        await this.learning.saveStats();
+      }
+    } catch (e) {
+      console.warn('Failed to save learning data during shutdown:', e.message);
+    }
+
+    // Save honor data
+    try {
+      if (this.honor?.save) {
+        await this.honor.save();
+      }
+    } catch (e) {
+      console.warn('Failed to save honor data during shutdown:', e.message);
+    }
+
+    // Clear conversation history
+    this.conversationHistory = [];
+
+    this.initialized = false;
+    eventBus.emit('shutdown:complete', { timestamp: new Date().toISOString() });
+  }
+
+  /**
+   * Run system health checks (doctor)
+   */
+  async doctor() {
+    const checks = [];
+
+    // 1. Config check
+    try {
+      await this.config.load();
+      checks.push({ name: 'Configuration', status: 'ok', message: 'Config loaded successfully' });
+    } catch (e) {
+      checks.push({ name: 'Configuration', status: 'error', message: e.message });
+    }
+
+    // 2. Skills check
+    try {
+      const skills = this.skills.list();
+      checks.push({ name: 'Skills', status: 'ok', message: `${skills.length} skill(s) loaded` });
+    } catch (e) {
+      checks.push({ name: 'Skills', status: 'error', message: e.message });
+    }
+
+    // 3. Learning engine check
+    try {
+      const stats = await this.learning.getStats();
+      checks.push({ name: 'Learning Engine', status: 'ok', message: `${stats.totalRecords || 0} records` });
+    } catch (e) {
+      checks.push({ name: 'Learning Engine', status: 'error', message: e.message });
+    }
+
+    // 4. Honor engine check
+    try {
+      const honor = this.honor.getData();
+      checks.push({ name: 'Honor Engine', status: 'ok', message: `Level ${honor.level}, ${honor.points} pts` });
+    } catch (e) {
+      checks.push({ name: 'Honor Engine', status: 'error', message: e.message });
+    }
+
+    // 5. AI providers check
+    try {
+      const aiStatus = this.ai.getStatus();
+      const providerCount = Object.keys(aiStatus.providers || {}).length;
+      const activeCount = Object.values(aiStatus.providers || {}).filter(p => p.initialized).length;
+      checks.push({ name: 'AI Providers', status: activeCount > 0 ? 'ok' : 'warning', message: `${activeCount}/${providerCount} active` });
+    } catch (e) {
+      checks.push({ name: 'AI Providers', status: 'warning', message: e.message });
+    }
+
+    // 6. Components check
+    try {
+      const compStatus = this.components.getStatus();
+      const compCount = Object.keys(compStatus).length;
+      checks.push({ name: 'Components', status: 'ok', message: `${compCount} registered` });
+    } catch (e) {
+      checks.push({ name: 'Components', status: 'warning', message: e.message });
+    }
+
+    // 7. Node.js version check
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1));
+    checks.push({
+      name: 'Node.js',
+      status: major >= 18 ? 'ok' : 'warning',
+      message: `${nodeVersion} ${major < 18 ? '(recommend >= 18)' : ''}`
+    });
+
+    // 8. Disk space for learning data
+    try {
+      const fs = require('fs-extra');
+      const learningPath = this.learning.expandPath(this.learning.learningPath);
+      if (await fs.pathExists(learningPath)) {
+        checks.push({ name: 'Learning Storage', status: 'ok', message: learningPath });
+      } else {
+        checks.push({ name: 'Learning Storage', status: 'warning', message: 'Directory not yet created' });
+      }
+    } catch (e) {
+      checks.push({ name: 'Learning Storage', status: 'warning', message: e.message });
+    }
+
+    const errors = checks.filter(c => c.status === 'error').length;
+    const warnings = checks.filter(c => c.status === 'warning').length;
+
+    return {
+      healthy: errors === 0,
+      checks,
+      summary: { total: checks.length, ok: checks.filter(c => c.status === 'ok').length, warnings, errors }
+    };
+  }
 }
 
 module.exports = FlowMind;

package/core/learning-engine.js

@@ -7,6 +7,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const { v4: uuidv4 } = require('uuid');
 const eventBus = require('./event-bus');
+const { expandPath } = require('./utils');
 
 /**
  * Per-key write queue to prevent concurrent read-modify-write races
@@ -580,10 +581,7 @@ class LearningEngine {
    * Helper methods
    */
   expandPath(filePath) {
-    if (filePath.startsWith('~')) {
-      return path.join(process.env.HOME || process.env.USERPROFILE, filePath.slice(1));
-    }
-    return filePath;
+    return expandPath(filePath);
   }
 
   extractCondition(input) {

package/core/scene-matcher.js

@@ -5,6 +5,7 @@
 
 const fs = require('fs-extra');
 const path = require('path');
+const { expandPath } = require('./utils');
 
 class SceneMatcher {
   constructor(config, learning) {
@@ -316,10 +317,7 @@ class SceneMatcher {
    * Helper to expand path
    */
   expandPath(filePath) {
-    if (filePath.startsWith('~')) {
-      return path.join(process.env.HOME || process.env.USERPROFILE, filePath.slice(1));
-    }
-    return filePath;
+    return expandPath(filePath);
   }
 }
 

package/core/skill-loader.js

@@ -327,6 +327,13 @@ class SkillLoader {
     const skill = this.skills.get(name);
     if (!skill) return null;
 
+    // Clear require cache to actually reload the module
+    const indexPath = require('path').join(skill.path, 'index.js');
+    const resolvedPath = require.resolve(indexPath);
+    if (require.cache[resolvedPath]) {
+      delete require.cache[resolvedPath];
+    }
+
     return await this.loadSkill(name, skill.path);
   }
 

package/core/utils.js

@@ -0,0 +1,18 @@
+/**
+ * Shared utility functions
+ */
+
+const path = require('path');
+const os = require('os');
+
+/**
+ * Expand ~ in file paths to home directory
+ */
+function expandPath(filePath) {
+  if (filePath.startsWith('~')) {
+    return path.join(process.env.HOME || process.env.USERPROFILE || os.homedir(), filePath.slice(1));
+  }
+  return filePath;
+}
+
+module.exports = { expandPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowmind",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "The AI Agent That Learns How You Work - Stop repeating yourself, FlowMind learns your workflows and applies them automatically.",
   "main": "core/index.js",
   "bin": {

package/tui/app.jsx

@@ -26,7 +26,7 @@ function App({ flowmind }) {
       if (!mountedRef.current) return;
       if (result.type === 'result') {
         const text = typeof result.data === 'string' ? result.data : JSON.stringify(result.data, null, 2);
-        addResponse(text.substring(0, 200) + (text.length > 200 ? '...' : ''));
+        addResponse(text);
       } else if (result.type === 'learning') {
         addResponse(result.message || 'Learning recorded');
       } else if (result.type === 'error') {

package/tui/components/ChatPanel.jsx

@@ -1,20 +1,53 @@
 const React = require('react');
-const { Box, Text } = require('ink');
+const { Box, Text, useInput } = require('ink');
 const TextInput = require('ink-text-input').default || require('ink-text-input');
 const Spinner = require('ink-spinner').default || require('ink-spinner');
 
 function ChatPanel({ onSubmit, isProcessing, onExit }) {
   const [input, setInput] = React.useState('');
   const [history, setHistory] = React.useState([]);
+  const [cmdHistory, setCmdHistory] = React.useState([]);
+  const [historyIndex, setHistoryIndex] = React.useState(-1);
+  const [savedInput, setSavedInput] = React.useState('');
   const mountedRef = React.useRef(true);
 
   React.useEffect(() => {
     return () => { mountedRef.current = false; };
   }, []);
 
+  // Handle Up/Down arrow for command history
+  useInput((ch, key) => {
+    if (isProcessing) return;
+
+    if (key.upArrow && cmdHistory.length > 0) {
+      const newIndex = historyIndex === -1
+        ? cmdHistory.length - 1
+        : Math.max(0, historyIndex - 1);
+      if (historyIndex === -1) setSavedInput(input);
+      setHistoryIndex(newIndex);
+      setInput(cmdHistory[newIndex]);
+    } else if (key.downArrow) {
+      if (historyIndex === -1) return;
+      const newIndex = historyIndex + 1;
+      if (newIndex >= cmdHistory.length) {
+        setHistoryIndex(-1);
+        setInput(savedInput);
+      } else {
+        setHistoryIndex(newIndex);
+        setInput(cmdHistory[newIndex]);
+      }
+    }
+  });
+
   const handleSubmit = (value) => {
     if (!value.trim()) return;
     setHistory(prev => [...prev, { role: 'user', text: value }]);
+    // Add to command history (deduplicate consecutive)
+    if (cmdHistory.length === 0 || cmdHistory[cmdHistory.length - 1] !== value) {
+      setCmdHistory(prev => [...prev, value]);
+    }
+    setHistoryIndex(-1);
+    setSavedInput('');
     setInput('');
     if (value.toLowerCase() === 'exit' || value.toLowerCase() === 'quit') {
       if (onExit) onExit();