flowmind 1.4.3 → 1.4.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.4.5] - 2026-06-29
+
+### Fixed
+- Skill routing now prefers explicit skill execution before treating input as generic learning feedback
+- `learning-feedback` now receives the active FlowMind runtime and current skill context for proper feedback injection
+- `resource-bind list` now reads registry data through a stable `getAll()` API instead of a broken internal path
+- `log-audit` now executes real adapter log queries when an adapter is configured, instead of returning a query plan only
+- TUI focus handling now keeps sidebar/chat input behavior and status display aligned
+
+### Added
+- Core regression tests for routing order, learning bindings, registry listing, and executable skill behavior
+
 ## [1.3.0] - 2026-06-26
 
 ### Fixed

package/README.md

@@ -4,11 +4,11 @@
 
 ### **The AI Agent That Learns How You Work**
 
-*Stop repeating yourself. FlowMind learns your workflows and applies them automatically.*
+*An adaptive memory and workflow layer for MCP-based developer tools.*
 
 [![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.3.0-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-1.4.5-blue)](CHANGELOG.md)
 
 [中文](README_CN.md) | [Quick Start](#-quick-start) | [How It Works](#-how-it-works) | [Use Cases](#-use-cases) | [Architecture](#-architecture)
 
@@ -16,101 +16,69 @@
 
 ---
 
-## 🎯 The Problem
+## One Core Value
 
-Whether you're a developer, architect, product manager, or tech lead, you face these challenges:
+FlowMind helps you **teach a developer workflow once and reuse it later**.
 
-### 1. Repetitive Labor
-```
-❌ Same instructions every single time:
-"Format output as table..."
-"Use sequential list..."
-"Check errors first then..."
-"Connect using source_id..."
-```
+Today, the most reliable path in this repository is:
 
-### 2. Scattered Tools
-```
-❌ Constantly switching between platforms:
-SLS for logs → RDS for data → Code repo → YApi for APIs → Yuque for docs
-```
+1. Route a request to a skill
+2. Execute that skill through a configured adapter or MCP-compatible provider
+3. Capture explicit user feedback
+4. Re-apply that preference on the next similar run
 
-### 3. Lost Experience
-```
-❌ Valuable experience cannot be preserved:
-Architect's design thinking → Lost with project end
-Debugging paths → Have to摸索 again next time
-Best practices → Cannot be reused or传承
-```
+If you want one sentence:
 
-### 4. Low Efficiency
-```
-❌ Repetitive waiting and inefficient operations:
-Configure database connection every time
-Enter complete conditions for every log query
-Manually execute multiple steps for each deployment
-```
+> FlowMind is a memory layer for repetitive MCP-based developer operations.
 
----
+## A Runnable Example
 
-## 💡 The Solution
+```bash
+# 1. Install
+npm install -g flowmind
 
-**FlowMind learns once, applies forever.**
+# 2. Inspect available skills
+flowmind skills --json
 
-### Core Philosophy
+# 3. Run a real workflow through the log-audit skill
+flowmind process --skill log-audit "查询 traceId abc123 的日志"
 
-```
-✅ First time: You teach FlowMind
-✅ Every time after: FlowMind remembers
-✅ Smarter with use: AI self-evolution
-```
+# 4. Give explicit feedback
+flowmind "下次用表格格式"
 
-### One-Stop Solution
-
-```
-Code Locate → Data Verify → Problem Analyze → One-Click Fix → Auto Deploy → Archive
-    ↓              ↓              ↓               ↓              ↓            ↓
-Local+MCP      RDS Read      SLS Analysis    Code Modify    Pipeline     OpenSpec+Yuque
+# 5. Programmatic / Codex-friendly access
+flowmind-codex --skill log-audit "查询 traceId abc123 的日志"
 ```
 
-### Smarter with Every Use
+What you get today:
+- Skill routing
+- MCP/provider-aware execution contracts
+- Explicit feedback capture
+- Local persistence for preferences and learning
 
-- 🧠 **Learning Accumulation** - Every use accumulates experience, understands your code and thinking better
-- 🔄 **Scene Coordination** - Skills auto-coordinate across different scenarios, forming complete workflows
-- 💰 **Token Optimization** - Reduce token consumption through mapping files, lower AI costs
-- ⏱️ **Efficiency Boost** - Reduce repetitive waiting, 10x efficiency through automation
-- 🎓 **Experience Retention** - Architect and senior developer design thinking, permanently preserved
-
----
+What this project is not yet:
+- A full autonomous coding agent
+- A complete SSH/remote code execution platform
+- A one-click deploy system for every workflow
 
-## 🚀 Quick Start
-
-### Installation
+## Quick Start
 
 ```bash
 npm install -g flowmind
-```
-
-### Initialize
-
-```bash
 flowmind init
+flowmind skills --json
+flowmind process --skill log-audit "查询 traceId abc123 的日志"
 ```
 
-> One-time configuration, permanent effect. Configure resource connections, learning preferences, output formats - no need to repeat setup.
-
-### Start Using
+If you are integrating with Codex or scripts:
 
 ```bash
-# First time - teach FlowMind your preference
-flowmind "查询 traceId 日志，用顺序列表格式"
-FlowMind: [Executes and learns your preference]
-
-# Next time - FlowMind remembers!
-flowmind "查询 traceId abc123 的日志"
-FlowMind: [Automatically uses sequential list format] ✓
+flowmind-codex skills
+flowmind-codex --skill log-audit "查询 traceId abc123 的日志"
 ```
 
+FlowMind stores learning data locally and uses that state to apply explicit feedback on future runs.
+
 ---
 
 ## 🧠 How It Works

package/README_CN.md

@@ -4,11 +4,11 @@
 
 ### **学习你工作方式的 AI 智能体**
 
-*不再重复自己。FlowMind 学习你的工作流程并自动应用。*
+*一个面向 MCP 开发工作流的可学习记忆层。*
 
 [![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.4.5-blue)](CHANGELOG.md)
 
 [English](README.md) | [快速开始](#-快速开始) | [工作原理](#-工作原理) | [使用场景](#-使用场景) | [架构](#-架构)
 
@@ -16,107 +16,69 @@
 
 ---
 
-## 🎯 问题所在
+## 一个核心价值
 
-开发者在日常工作中面临诸多痛点：
+FlowMind 的目标不是“什么都做”，而是把**重复出现的开发工作流记住并复用**。
 
-### 1. 重复劳动
-```
-❌ 每次都要重复相同的指令：
-"输出格式用表格..."
-"用顺序列表..."
-"先检查错误再..."
-"用 source_id 连接..."
-```
+当前仓库里最可靠、最能跑通的一条主链路是：
 
-### 2. 工具分散
-```
-❌ 在多个平台间频繁切换：
-SLS 查日志 → RDS 查数据 → 代码库定位 → YApi 查接口 → 语雀写文档
-```
+1. 把请求路由到合适的 skill
+2. 通过已配置的 adapter / MCP 兼容提供者执行 skill
+3. 捕获用户的显式反馈
+4. 在下次相似请求里复用这份偏好
 
-### 3. 经验流失
-```
-❌ 宝贵的经验无法沉淀：
-架构师的设计思路 → 随项目结束而丢失
-调试的排查路径 → 下次又要重新摸索
-最佳实践 → 无法复用和传承
-```
+一句话概括：
 
-### 4. 效率低下
-```
-❌ 重复等待和低效操作：
-每次连接数据库都要配置
-每次查日志都要输完整条件
-每次部署都要手动执行多个步骤
-```
+> FlowMind 是一个给 MCP 开发工具使用的记忆层。
 
----
+## 一个可跑通的例子
 
-## 💡 解决方案
-
-**FlowMind 学习一次，永久应用。**
+```bash
+# 1. 安装
+npm install -g flowmind
 
-### 核心理念
+# 2. 看看有哪些技能
+flowmind skills --json
 
-```
-✅ 第一次：你教 FlowMind
-✅ 之后每次：FlowMind 自动记住
-✅ 越用越懂你：AI 自我进化
-```
+# 3. 走真正的日志技能链路
+flowmind process --skill log-audit "查询 traceId abc123 的日志"
 
-### 一站式解决
+# 4. 给出显式反馈
+flowmind "下次用表格格式"
 
+# 5. 如果你在 Codex / 脚本里集成
+flowmind-codex --skill log-audit "查询 traceId abc123 的日志"
 ```
-代码定位 → 数据验证 → 问题分析 → 一键修复 → 自动部署 → 归档记录
-   ↓           ↓           ↓           ↓           ↓           ↓
-本地+MCP    RDS读取    SLS分析    代码修改    流水线执行   OpenSpec+语雀
-```
-
-### 越用越智能
 
-- 🧠 **学习积累** - 每次使用都在积累经验，越用越懂你的代码和思路
-- 🔄 **场景联动** - 不同场景下的技能自动配合，形成完整工作流
-- 💰 **Token 优化** - 通过映射文件减少 token 消耗，降低 AI 调用成本
-- ⏱️ **效率提升** - 减少重复等待，自动化处理提升 10 倍效率
-- 🎓 **经验沉淀** - 架构师和高级开发者的设计思路，永久保留复用
+现在已经具备的能力：
+- skill 路由
+- 面向 MCP/provider 的执行协议
+- 显式反馈学习
+- 本地持久化学习记录和偏好
 
----
-
-## 🚀 快速开始
+当前还不应该过度承诺的部分：
+- 不是完整的自治编码 Agent
+- 不是通用 SSH 远程执行平台
+- 不是所有工作流都已实现一键自动化
 
-### 安装
+## 快速开始
 
 ```bash
 npm install -g flowmind
-```
-
-### 初始化
-
-```bash
-# 基础初始化
 flowmind init
-
-# 带 AI 模型初始化 (推荐)
-flowmind init --ai openai
-flowmind init --ai anthropic
-flowmind init --ai ollama
+flowmind skills --json
+flowmind process --skill log-audit "查询 traceId abc123 的日志"
 ```
 
-> 一次配置，永久生效。配置资源连接、学习偏好、输出格式，无需每次重复设置。
-
-### 开始使用
+如果你要集成到 Codex 或脚本：
 
 ```bash
-# 第一次 - 教 FlowMind 你的偏好
-flowmind "查询 traceId 日志，用顺序列表格式"
-FlowMind: [执行并学习你的偏好]
-
-# 下次 - FlowMind 自动记住！
-flowmind "查询 traceId abc123 的日志"
-FlowMind: [自动使用顺序列表格式] ✓
+flowmind-codex skills
+flowmind-codex --skill log-audit "查询 traceId abc123 的日志"
 ```
 
+FlowMind 会把学习数据保存在本地，并在后续运行中应用这些显式反馈。
+
 ---
 
 ## 📖 使用方式
@@ -319,6 +281,16 @@ Claude：我来使用 FlowMind 的代码审查技能...
 通过 JSON 输出与 Codex 集成。
 
 ```bash
+# 推荐：使用 Codex 包装命令
+flowmind-codex "查询最近1小时的错误日志"
+flowmind-codex skills
+flowmind-codex skill log-audit
+flowmind-codex doctor
+
+# 默认使用当前工作区的 .flowmind-codex/
+# 也可以自定义目录
+# FLOWMIND_CODEX_HOME=/your/path flowmind-codex skills
+
 # 获取技能列表 (JSON 格式)
 flowmind skills --json
 

package/bin/flowmind-codex.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const fs = require('fs-extra');
+const path = require('path');
+const FlowMind = require('../core');
+const { version } = require('../package.json');
+
+function printJson(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+
+function fail(message, extra = {}) {
+  printJson({
+    ok: false,
+    error: {
+      message,
+      ...extra
+    }
+  });
+  process.exitCode = 1;
+}
+
+async function createFlowMind() {
+  const codexHome = process.env.FLOWMIND_CODEX_HOME || path.join(process.cwd(), '.flowmind-codex');
+  process.env.FLOWMIND_HOME = process.env.FLOWMIND_HOME || codexHome;
+
+  const configPath = path.join(codexHome, 'config.json');
+  await fs.ensureDir(codexHome);
+
+  if (!await fs.pathExists(configPath)) {
+    await fs.writeJson(configPath, {
+      version: '1.0.0',
+      name: 'FlowMind Codex Workspace',
+      storagePath: codexHome,
+      learning: {
+        storagePath: path.join(codexHome, 'learning')
+      }
+    }, { spaces: 2 });
+  }
+
+  const flowmind = new FlowMind({ configPath });
+  await flowmind.init();
+  return flowmind;
+}
+
+program
+  .name('flowmind-codex')
+  .description('Codex-friendly JSON wrapper for FlowMind')
+  .version(version);
+
+program
+  .argument('[input...]', 'Process a FlowMind request directly')
+  .option('-s, --skill <skill>', 'Use a specific skill')
+  .action(async (inputParts, options) => {
+    if (!inputParts.length) {
+      return;
+    }
+
+    try {
+      const flowmind = await createFlowMind();
+      const input = inputParts.join(' ');
+      const result = await flowmind.process(input, {
+        skill: options.skill
+      });
+
+      printJson({
+        ok: result.type !== 'error',
+        command: 'ask',
+        input,
+        result
+      });
+
+      if (result.type === 'error') {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      fail(error.message, { command: 'ask' });
+    }
+  });
+
+program
+  .command('ask')
+  .description('Process a request and emit JSON')
+  .argument('<input...>', 'Input to process')
+  .option('-s, --skill <skill>', 'Use a specific skill')
+  .action(async (inputParts, options) => {
+    try {
+      const flowmind = await createFlowMind();
+      const input = inputParts.join(' ');
+      const result = await flowmind.process(input, {
+        skill: options.skill
+      });
+
+      printJson({
+        ok: result.type !== 'error',
+        command: 'ask',
+        input,
+        result
+      });
+
+      if (result.type === 'error') {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      fail(error.message, { command: 'ask' });
+    }
+  });
+
+program
+  .command('skills')
+  .description('List skills as JSON')
+  .action(async () => {
+    try {
+      const flowmind = await createFlowMind();
+      printJson({
+        ok: true,
+        command: 'skills',
+        skills: flowmind.skills.list()
+      });
+    } catch (error) {
+      fail(error.message, { command: 'skills' });
+    }
+  });
+
+program
+  .command('skill')
+  .description('Get one skill as JSON')
+  .argument('<name>', 'Skill name')
+  .action(async (name) => {
+    try {
+      const flowmind = await createFlowMind();
+      const skill = flowmind.skills.get(name);
+
+      if (!skill) {
+        fail(`Skill not found: ${name}`, { command: 'skill', skill: name });
+        return;
+      }
+
+      printJson({
+        ok: true,
+        command: 'skill',
+        skill: {
+          name: skill.name,
+          description: skill.definition?.description,
+          category: skill.definition?.category || skill.definition?.metadata?.category,
+          version: skill.definition?.version || skill.definition?.metadata?.version,
+          author: skill.definition?.author || skill.definition?.metadata?.author,
+          triggers: skill.definition?.triggers || [],
+          componentDependencies: skill.definition?.componentDependencies || []
+        }
+      });
+    } catch (error) {
+      fail(error.message, { command: 'skill', skill: name });
+    }
+  });
+
+program
+  .command('doctor')
+  .description('Run health checks as JSON')
+  .action(async () => {
+    try {
+      const flowmind = await createFlowMind();
+      const result = await flowmind.doctor();
+      printJson({
+        ok: result.summary?.errors === 0,
+        command: 'doctor',
+        result
+      });
+
+      if (result.summary?.errors > 0) {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      fail(error.message, { command: 'doctor' });
+    }
+  });
+
+program
+  .command('ai-status')
+  .description('Show AI status as JSON')
+  .action(async () => {
+    try {
+      const flowmind = await createFlowMind();
+      printJson({
+        ok: true,
+        command: 'ai-status',
+        result: flowmind.getAIStatus()
+      });
+    } catch (error) {
+      fail(error.message, { command: 'ai-status' });
+    }
+  });
+
+program.parseAsync(process.argv).catch((error) => {
+  fail(error.message);
+});

package/bin/flowmind.js

@@ -24,8 +24,10 @@ function restoreTerminal() {
       process.stdin.setRawMode(false);
     }
   } catch (e) { /* ignore */ }
-  // Show cursor, reset colors, clear scroll region
-  process.stdout.write('\x1b[?25h\x1b[0m\x1b[r');
+  if (process.stdout.isTTY) {
+    // Show cursor, reset colors, clear scroll region
+    process.stdout.write('\x1b[?25h\x1b[0m\x1b[r');
+  }
 }
 
 // Global error handlers to prevent silent CLI crashes
@@ -503,6 +505,7 @@ program
   .alias('p')
   .description('Process a request')
   .argument('[input]', 'Input to process')
+  .option('-j, --json', 'Output as JSON (for tool integration)')
   .option('-s, --skill <skill>', 'Use specific skill')
   .option('-v, --verbose', 'Verbose output')
   .action(async (input, options) => {
@@ -514,18 +517,36 @@ program
         await runInteractiveMode(fm);
       } else {
         // Single command mode
-        const spinner = ora('Processing...').start();
+        const spinner = options.json ? null : ora('Processing...').start();
 
         const result = await fm.process(input, {
           skill: options.skill,
           verbose: options.verbose
         });
 
-        spinner.stop();
-        displayResult(result);
+        if (spinner) {
+          spinner.stop();
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          if (result.type === 'error') {
+            process.exitCode = 1;
+          }
+        } else {
+          displayResult(result);
+        }
       }
     } catch (error) {
-      console.error(chalk.red('Error:'), error.message);
+      if (options.json) {
+        console.log(JSON.stringify({
+          type: 'error',
+          message: error.message
+        }, null, 2));
+        process.exitCode = 1;
+      } else {
+        console.error(chalk.red('Error:'), error.message);
+      }
     } finally {
       restoreTerminal();
     }

package/core/component-registry.js

@@ -233,6 +233,30 @@ class ComponentRegistry {
     return result;
   }
 
+  /**
+   * Get a flat list of all registered component providers.
+   * @returns {object[]}
+   */
+  getAll() {
+    const result = [];
+
+    for (const type of Object.values(ComponentType)) {
+      const typeAdapters = this.adapters.get(type);
+      if (!typeAdapters) continue;
+
+      for (const [name, adapter] of typeAdapters) {
+        result.push({
+          name,
+          type,
+          active: this.activeProviders.get(type) === name,
+          ...adapter.getStatus()
+        });
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Get the active provider name for a component type.
    * @param {string} componentType

package/core/config-manager.js

@@ -312,7 +312,7 @@ class ConfigManager {
    * Get home directory
    */
   getHomeDir() {
-    return process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return process.env.FLOWMIND_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir();
   }
 
   /**

package/core/honor-engine.js

@@ -26,20 +26,26 @@ const DRAGON_LEVELS = [
 class HonorEngine {
   constructor(config) {
     this.config = config;
-    this.honorPath = path.join(
-      config.get('storagePath') || path.join(process.env.HOME || process.env.USERPROFILE, '.flowmind'),
-      'honor.json'
-    );
+    this.honorPath = null;
     this.skillsPath = config.get('skills.path', path.join(__dirname, '..', 'skills'));
     this.data = null;
     this.initialized = false;
   }
 
+  resolveHonorPath() {
+    const storagePath = this.config.get('storagePath')
+      || process.env.FLOWMIND_HOME
+      || path.join(process.env.HOME || process.env.USERPROFILE, '.flowmind');
+    return path.join(storagePath, 'honor.json');
+  }
+
   /**
    * Initialize honor engine
    */
   async init() {
     try {
+      this.honorPath = this.resolveHonorPath();
+
       if (await fs.pathExists(this.honorPath)) {
         this.data = await fs.readJson(this.honorPath);
       } else {

package/core/index.js

@@ -98,41 +98,33 @@ class FlowMind {
       // 1. AI Intent Understanding (if available)
       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, enhancedContext);
-      const learningResult = aiLearningResult?.isLearning
-        ? aiLearningResult
-        : await this.learning.detectLearning(input, enhancedContext);
-      if (learningResult) {
-        return this.formatLearningResponse(learningResult);
-      }
+      // 2. Select skill (AI-assisted if available)
+      const skill = await this.selectSkill(input, context);
 
-      // 3. Check scene mappings (with AI intent if available)
-      const sceneMatch = await this.matcher.match(input, intent);
-      if (sceneMatch && sceneMatch.confidence >= 0.7) {
-        return this.executeSceneWorkflow(sceneMatch, input, context);
+      if (!skill) {
+        return this.formatError('No matching skill found', input);
       }
 
-      // 4. Select skill (AI-assisted if available)
-      let skill = null;
-      const candidates = await this.skills.getCandidates(input, context);
-
-      if (candidates.length > 0) {
-        // Use AI to select skill if available
-        const aiSelection = await this.ai.selectSkill(input, candidates);
-        if (aiSelection && aiSelection.selectedSkill) {
-          skill = this.skills.get(aiSelection.selectedSkill);
+      // 3. Capture explicit learning feedback after skill resolution so bindings are accurate.
+      if (this.shouldCaptureLearningInput(input, skill, enhancedContext)) {
+        const learningContext = {
+          ...enhancedContext,
+          flowmind: this,
+          currentSkill: this.resolveLearningTargetSkill(skill, enhancedContext)
+        };
+        const aiLearningResult = await this.ai.analyzeLearningFeedback(input, learningContext);
+        const learningResult = aiLearningResult?.isLearning
+          ? aiLearningResult
+          : await this.learning.detectLearning(input, learningContext);
+        if (learningResult) {
+          return this.formatLearningResponse(learningResult);
         }
       }
 
-      // Fallback to rule-based selection
-      if (!skill) {
-        skill = await this.skills.select(input, context);
-      }
-
-      if (!skill) {
-        return this.formatError('No matching skill found', input);
+      // 4. Check scene mappings (with AI intent if available)
+      const sceneMatch = await this.matcher.match(input, intent);
+      if (sceneMatch && sceneMatch.confidence >= 0.7 && !context.skill) {
+        return this.executeSceneWorkflow(sceneMatch, input, enhancedContext);
       }
 
       // 5. Extract parameters using AI (if available)
@@ -142,7 +134,9 @@ class FlowMind {
       const executeContext = {
         ...enhancedContext,
         ...extractedParams,
-        intent: intent
+        intent: intent,
+        flowmind: this,
+        currentSkill: skill.name
       };
       const result = await this.executeWithLearning(skill, input, executeContext);
 
@@ -200,6 +194,8 @@ class FlowMind {
     // Apply learning rules to context
     const enhancedContext = {
       ...context,
+      flowmind: context.flowmind || this,
+      currentSkill: context.currentSkill || skill.name,
       learnings: learnings,
       preferences: await this.learning.getPreferences(skill.name)
     };
@@ -237,7 +233,9 @@ class FlowMind {
       const stepContext = {
         ...context,
         params: { ...step.params, ...params },
-        previousResults: results
+        previousResults: results,
+        flowmind: this,
+        currentSkill: step.skill
       };
 
       const result = await this.executeWithLearning(skill, input, stepContext);
@@ -270,6 +268,61 @@ class FlowMind {
     };
   }
 
+  async selectSkill(input, context = {}) {
+    if (context.skill) {
+      const explicitSkill = this.skills.get(context.skill);
+      if (!explicitSkill) {
+        return null;
+      }
+      return explicitSkill;
+    }
+
+    const candidates = await this.skills.getCandidates(input, context);
+
+    if (candidates.length > 0) {
+      const aiSelection = await this.ai.selectSkill(input, candidates);
+      if (aiSelection && aiSelection.selectedSkill) {
+        const selected = this.skills.get(aiSelection.selectedSkill);
+        if (selected) {
+          return selected;
+        }
+      }
+    }
+
+    return this.skills.select(input, context);
+  }
+
+  shouldCaptureLearningInput(input, skill, context = {}) {
+    if (skill?.name === 'learning-feedback') {
+      return true;
+    }
+
+    const normalized = input.trim();
+    const explicitFeedbackPatterns = [
+      /^(不对|错了|应该是|正确的是|改成|改为|重新处理|重来|下次|以后|记住|别再|不要|别这样)/i,
+      /^(wrong|should be|change to|next time|remember|don't|do not)/i
+    ];
+
+    return explicitFeedbackPatterns.some((pattern) => pattern.test(normalized))
+      && context.conversationHistory?.length > 0;
+  }
+
+  resolveLearningTargetSkill(skill, context = {}) {
+    if (context.currentSkill) {
+      return context.currentSkill;
+    }
+
+    if (skill && skill.name !== 'learning-feedback') {
+      return skill.name;
+    }
+
+    const previousSkill = [...this.conversationHistory]
+      .reverse()
+      .find((entry) => entry.skill && entry.skill !== 'learning-feedback');
+
+    return previousSkill?.skill || 'global';
+  }
+
   /**
    * Format result
    */

package/core/learning-engine.js

@@ -32,7 +32,7 @@ class LearningEngine {
   constructor(config, honorEngine = null) {
     this.config = config;
     this.honorEngine = honorEngine;
-    this.learningPath = config.get('learning.storagePath', '~/.flowmind/learning');
+    this.learningPath = null;
     this.writeQueue = new WriteQueue();
     this.records = {};
     this.skillBindings = {};
@@ -44,6 +44,11 @@ class LearningEngine {
    * Initialize learning engine
    */
   async init() {
+    this.learningPath = this.config.get(
+      'learning.storagePath',
+      path.join(process.env.FLOWMIND_HOME || process.env.HOME || process.env.USERPROFILE || '', '.flowmind', 'learning')
+    );
+
     // Ensure directories exist
     await fs.ensureDir(this.expandPath(this.learningPath));
     await fs.ensureDir(path.join(this.expandPath(this.learningPath), 'records'));
@@ -287,7 +292,7 @@ class LearningEngine {
    * Get learning rules for a skill
    */
   async getSkillLearnings(skillName) {
-    const bindings = this.skillBindings[skillName] || { records: [], rules: [] };
+    const bindings = this.skillBindings.bindings?.[skillName] || { records: [], rules: [] };
     return bindings.rules || [];
   }
 
@@ -372,15 +377,17 @@ class LearningEngine {
    * Update skill bindings
    */
   async updateSkillBindings(record) {
-    if (!this.skillBindings[record.skill]) {
-      this.skillBindings[record.skill] = {
+    this.skillBindings.bindings = this.skillBindings.bindings || {};
+
+    if (!this.skillBindings.bindings[record.skill]) {
+      this.skillBindings.bindings[record.skill] = {
         learningCount: 0,
         records: [],
         rules: []
       };
     }
 
-    const binding = this.skillBindings[record.skill];
+    const binding = this.skillBindings.bindings[record.skill];
     binding.learningCount++;
     binding.lastLearning = record.timestamp;
     binding.records.push({
@@ -402,6 +409,7 @@ class LearningEngine {
 
     if (await fs.pathExists(bindingsPath)) {
       this.skillBindings = await fs.readJson(bindingsPath);
+      this.skillBindings.bindings = this.skillBindings.bindings || {};
     } else {
       this.skillBindings = { version: '1.0', bindings: {} };
     }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "flowmind",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "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": {
     "flowmind": "./bin/flowmind.js",
+    "flowmind-codex": "./bin/flowmind-codex.js",
     "flowmind-mcp": "./mcp/server.js"
   },
   "scripts": {

package/skills/learning-feedback/index.js

@@ -50,7 +50,7 @@ module.exports = {
         type: 'learning',
         skill: 'learning-feedback',
         learningType: 'preference',
-        message: `Recorded preference: ${preference.type} = ${preference.value}`,
+        message: `Recorded preference: ${preference.preferenceType}`,
         data: record,
         input,
         timestamp: new Date().toISOString()
@@ -65,7 +65,7 @@ module.exports = {
         type: 'learning',
         skill: 'learning-feedback',
         learningType: 'scene_mapping',
-        message: `Recorded scene mapping for skill: ${scene.skill}`,
+        message: 'Recorded scene mapping for future matching',
         data: record,
         input,
         timestamp: new Date().toISOString()

package/skills/log-audit/index.js

@@ -24,34 +24,23 @@ module.exports = {
       };
     }
 
-    // If we have a log service, format the query for MCP tools
-    if (params.traceId) {
-      return {
-        type: 'result',
-        skill: 'log-audit',
-        message: `Trace query for: ${params.traceId}`,
-        data: {
-          action: 'trace',
-          traceId: params.traceId,
-          query: `* and "${params.traceId}"`,
-          timeRange: params.timeRange || 'last 1 hour',
-          endpoint: params.endpoint || 'cn-shenzhen.log.aliyuncs.com'
-        },
-        input,
-        timestamp: new Date().toISOString()
-      };
-    }
+    const queryInput = buildLogQueryInput(params);
+    const queryParams = typeof logService.buildQueryParams === 'function'
+      ? logService.buildQueryParams(queryInput)
+      : queryInput;
+    const execution = await logService.queryLogs(queryParams);
 
     return {
       type: 'result',
       skill: 'log-audit',
-      message: `Log query: ${params.service || 'all services'}, ${params.level || 'all levels'}, ${params.timeRange || 'last 1 hour'}`,
+      message: params.traceId
+        ? `Executed trace query for: ${params.traceId}`
+        : `Executed log query: ${params.service || 'all services'}, ${params.level || 'all levels'}, ${params.timeRange || 'last 1 hour'}`,
       data: {
-        action: 'query',
-        query: buildSLSQuery(params),
-        timeRange: params.timeRange || 'last 1 hour',
-        endpoint: params.endpoint || 'cn-shenzhen.log.aliyuncs.com',
-        limit: params.limit || 100
+        action: params.traceId ? 'trace' : 'query',
+        provider: logService.providerName,
+        queryParams,
+        execution
       },
       input,
       timestamp: new Date().toISOString()
@@ -86,3 +75,15 @@ function buildSLSQuery(params) {
   if (params.keyword) parts.push(`"${params.keyword}"`);
   return parts.length > 0 ? parts.join(' and ') : '*';
 }
+
+function buildLogQueryInput(params) {
+  return {
+    project: params.project,
+    logstore: params.logstore,
+    env: params.env,
+    query: params.traceId ? `* and "${params.traceId}"` : buildSLSQuery(params),
+    from: params.from,
+    to: params.to,
+    line: params.limit || 100
+  };
+}

package/skills/resource-bind/index.js

@@ -14,12 +14,21 @@ module.exports = {
     const params = parseResourceParams(input);
 
     if (params.action === 'list') {
-      const components = registry ? registry.getAll() : [];
+      const components = registry?.getAll ? registry.getAll() : [];
       return {
         type: 'result',
         skill: 'resource-bind',
         message: `Found ${components.length} configured component(s)`,
-        data: { components: components.map(c => ({ name: c.name, type: c.type, active: c.active })) },
+        data: {
+          components: components.map(c => ({
+            name: c.name,
+            type: c.type,
+            provider: c.provider,
+            active: c.active,
+            initialized: c.initialized,
+            mcpServer: c.mcpServer
+          }))
+        },
         input,
         timestamp: new Date().toISOString()
       };

package/tui/app.jsx

@@ -68,7 +68,7 @@ function App({ flowmind }) {
           React.createElement(ResultPanel, { results: results })
         )
       ),
-      React.createElement(StatusBar, { flowmind: flowmind })
+      React.createElement(StatusBar, { flowmind: flowmind, focusPanel: focusPanel })
     )
   );
 }

package/tui/components/ChatPanel.jsx

@@ -69,8 +69,8 @@ function ChatPanel({ onSubmit, isProcessing, onExit, focused }) {
   const displayHistory = history.slice(-20);
 
   return (
-    React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'green', paddingX: 1 },
-      React.createElement(Text, { bold: true, color: 'green' }, 'Command Input'),
+    React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: focused ? 'green' : 'gray', paddingX: 1 },
+      React.createElement(Text, { bold: true, color: focused ? 'green' : 'gray' }, focused ? 'Command Input [Focused]' : 'Command Input'),
       React.createElement(Box, { flexDirection: 'column', marginTop: 1, minHeight: 6 },
         displayHistory.length === 0 && React.createElement(Text, { color: 'gray' }, 'Type a command to get started. Type "exit" to quit.'),
         displayHistory.map((msg, i) =>
@@ -94,8 +94,15 @@ function ChatPanel({ onSubmit, isProcessing, onExit, focused }) {
               ' Processing...'
             )
           : React.createElement(Box, null,
-              React.createElement(Text, { color: 'green', bold: true }, '> '),
-              React.createElement(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit })
+              React.createElement(Text, { color: focused ? 'green' : 'gray', bold: true }, '> '),
+              React.createElement(TextInput, {
+                value: input,
+                onChange: setInput,
+                onSubmit: handleSubmit,
+                focus: focused,
+                showCursor: focused,
+                placeholder: focused ? 'Ask FlowMind to do something...' : 'Press Tab to focus input'
+              })
             )
       )
     )

package/tui/components/Sidebar.jsx

@@ -36,7 +36,8 @@ function Sidebar({ flowmind, width, onSkillSelect, focused }) {
   const progressBar = '\u2588'.repeat(filled) + '\u2591'.repeat(barWidth - filled);
 
   return (
-    React.createElement(Box, { flexDirection: 'column', width: width, borderStyle: 'single', borderColor: 'cyan', paddingX: 1 },
+    React.createElement(Box, { flexDirection: 'column', width: width, borderStyle: 'single', borderColor: focused ? 'cyan' : 'gray', paddingX: 1 },
+      React.createElement(Text, { color: focused ? 'cyan' : 'gray' }, focused ? 'Sidebar [Focused]' : 'Sidebar'),
       React.createElement(DragonTotem, { honorData: honorData, compact: true }),
       React.createElement(Box, { flexDirection: 'column', marginTop: 1 },
         React.createElement(Text, { bold: true, color: 'cyan' }, 'Progress'),
@@ -52,12 +53,16 @@ function Sidebar({ flowmind, width, onSkillSelect, focused }) {
             const category = skill.category || 'general';
             const prefix = isSelected ? '\u25B6 ' : '  ';
             return React.createElement(Text, { key: skill.name },
-              React.createElement(Text, { color: isSelected ? 'green' : 'white' }, prefix + skill.name),
+              React.createElement(Text, { color: isSelected ? (focused ? 'green' : 'yellow') : 'white' }, prefix + skill.name),
               React.createElement(Text, { color: 'gray' }, ' [' + category + ']')
             );
           })
         )
       ),
+      React.createElement(Box, { flexDirection: 'column', marginTop: 1 },
+        React.createElement(Text, { color: 'gray' }, 'Tab: switch focus'),
+        React.createElement(Text, { color: 'gray' }, 'Enter: inspect skill')
+      ),
       React.createElement(Box, { flexDirection: 'column', marginTop: 1 },
         React.createElement(Text, { bold: true, color: 'cyan' }, 'Stats'),
         React.createElement(Text, { color: 'gray' }, 'Skills used: ' + (honorData.stats?.skillUseCount || 0)),

package/tui/components/StatusBar.jsx

@@ -3,7 +3,7 @@ const { Box, Text } = require('ink');
 
 const LEVEL_NAMES = ['Egg', 'Hatchling', 'Juvenile', 'Adult', 'Elder', 'Ascended'];
 
-function StatusBar({ flowmind }) {
+function StatusBar({ flowmind, focusPanel }) {
   const [aiStatus, setAiStatus] = React.useState(null);
   const [componentStatus, setComponentStatus] = React.useState(null);
   const [honorData, setHonorData] = React.useState(null);
@@ -41,6 +41,11 @@ function StatusBar({ flowmind }) {
         React.createElement(Text, { color: 'gray' }, 'Honor: '),
         React.createElement(Text, { color: 'yellow' }, LEVEL_NAMES[level]),
         React.createElement(Text, { color: 'gray' }, ' (' + points + ' pts)')
+      ),
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'Focus: '),
+        React.createElement(Text, { color: focusPanel === 'chat' ? 'green' : 'cyan' }, focusPanel || 'chat'),
+        React.createElement(Text, { color: 'gray' }, ' | Tab switch')
       )
     )
   );