flowmind 1.4.4 → 1.4.6

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [1.4.6] - 2026-06-30
+
+### Added
+- Portable demo scripts for skill listing, log audit, learning feedback, and JSON output replay from the repository root
+- Animated terminal walkthrough assets, including a VHS tape and generated demo GIF
+
+### Changed
+- Demo helpers now fall back to the local `node ./bin/flowmind.js` entrypoint when a global `flowmind` binary is unavailable
+- README and demo docs now expose the terminal walkthrough directly for GitHub and npm readers
+
+## [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,113 +4,87 @@
 
 ### **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)
+[中文](README_CN.md) | [Quick Start](#-quick-start) | [Demo](demo/DEMO.md) | [How It Works](#-how-it-works) | [Use Cases](#-use-cases) | [Architecture](#-architecture)
 
 </div>
 
 ---
 
-## 🎯 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
+For a longer walkthrough, see [demo/DEMO.md](demo/DEMO.md).
 
-**FlowMind learns once, applies forever.**
+Animated terminal walkthrough:
 
-### Core Philosophy
+![FlowMind terminal demo](https://raw.githubusercontent.com/Eleven-M/flowmind/master/demo/flowmind-demo.gif)
 
-```
-✅ First time: You teach FlowMind
-✅ Every time after: FlowMind remembers
-✅ Smarter with use: AI self-evolution
-```
+```bash
+# 1. Install
+npm install -g flowmind
 
-### One-Stop Solution
+# 2. Inspect available skills
+flowmind skills --json
 
-```
-Code Locate → Data Verify → Problem Analyze → One-Click Fix → Auto Deploy → Archive
-    ↓              ↓              ↓               ↓              ↓            ↓
-Local+MCP      RDS Read      SLS Analysis    Code Modify    Pipeline     OpenSpec+Yuque
-```
+# 3. Run a real workflow through the log-audit skill
+flowmind process --skill log-audit "查询 traceId abc123 的日志"
 
-### Smarter with Every Use
+# 4. Give explicit feedback
+flowmind "下次用表格格式"
 
-- 🧠 **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
+# 5. Programmatic / Codex-friendly access
+flowmind-codex --skill log-audit "查询 traceId abc123 的日志"
+```
 
----
+What you get today:
+- Skill routing
+- MCP/provider-aware execution contracts
+- Explicit feedback capture
+- Local persistence for preferences and learning
 
-## 🚀 Quick Start
+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
 
-### 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,119 +4,87 @@
 
 ### **学习你工作方式的 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) | [快速开始](#-快速开始) | [工作原理](#-工作原理) | [使用场景](#-使用场景) | [架构](#-架构)
+[English](README.md) | [快速开始](#-快速开始) | [演示](demo/DEMO_CN.md) | [工作原理](#-工作原理) | [使用场景](#-使用场景) | [架构](#-架构)
 
 </div>
 
 ---
 
-## 🎯 问题所在
+## 一个核心价值
 
-开发者在日常工作中面临诸多痛点：
+FlowMind 的目标不是“什么都做”，而是把**重复出现的开发工作流记住并复用**。
 
-### 1. 重复劳动
-```
-❌ 每次都要重复相同的指令：
-"输出格式用表格..."
-"用顺序列表..."
-"先检查错误再..."
-"用 source_id 连接..."
-```
+当前仓库里最可靠、最能跑通的一条主链路是：
 
-### 2. 工具分散
-```
-❌ 在多个平台间频繁切换：
-SLS 查日志 → RDS 查数据 → 代码库定位 → YApi 查接口 → 语雀写文档
-```
+1. 把请求路由到合适的 skill
+2. 通过已配置的 adapter / MCP 兼容提供者执行 skill
+3. 捕获用户的显式反馈
+4. 在下次相似请求里复用这份偏好
 
-### 3. 经验流失
-```
-❌ 宝贵的经验无法沉淀：
-架构师的设计思路 → 随项目结束而丢失
-调试的排查路径 → 下次又要重新摸索
-最佳实践 → 无法复用和传承
-```
+一句话概括：
 
-### 4. 效率低下
-```
-❌ 重复等待和低效操作：
-每次连接数据库都要配置
-每次查日志都要输完整条件
-每次部署都要手动执行多个步骤
-```
+> FlowMind 是一个给 MCP 开发工具使用的记忆层。
 
----
+## 一个可跑通的例子
 
-## 💡 解决方案
+更完整的演示见 [demo/DEMO_CN.md](demo/DEMO_CN.md)。
 
-**FlowMind 学习一次，永久应用。**
+终端操作 GIF 演示：
 
-### 核心理念
+![FlowMind 终端演示](https://raw.githubusercontent.com/Eleven-M/flowmind/master/demo/flowmind-demo.gif)
 
-```
-✅ 第一次：你教 FlowMind
-✅ 之后每次：FlowMind 自动记住
-✅ 越用越懂你：AI 自我进化
-```
+```bash
+# 1. 安装
+npm install -g flowmind
 
-### 一站式解决
+# 2. 看看有哪些技能
+flowmind skills --json
 
-```
-代码定位 → 数据验证 → 问题分析 → 一键修复 → 自动部署 → 归档记录
-   ↓           ↓           ↓           ↓           ↓           ↓
-本地+MCP    RDS读取    SLS分析    代码修改    流水线执行   OpenSpec+语雀
-```
+# 3. 走真正的日志技能链路
+flowmind process --skill log-audit "查询 traceId abc123 的日志"
 
-### 越用越智能
+# 4. 给出显式反馈
+flowmind "下次用表格格式"
 
-- 🧠 **学习积累** - 每次使用都在积累经验，越用越懂你的代码和思路
-- 🔄 **场景联动** - 不同场景下的技能自动配合，形成完整工作流
-- 💰 **Token 优化** - 通过映射文件减少 token 消耗，降低 AI 调用成本
-- ⏱️ **效率提升** - 减少重复等待，自动化处理提升 10 倍效率
-- 🎓 **经验沉淀** - 架构师和高级开发者的设计思路，永久保留复用
+# 5. 如果你在 Codex / 脚本里集成
+flowmind-codex --skill log-audit "查询 traceId abc123 的日志"
+```
 
----
+现在已经具备的能力：
+- 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 会把学习数据保存在本地，并在后续运行中应用这些显式反馈。
+
 ---
 
 ## 📖 使用方式

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/index.js

@@ -98,48 +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);
-      }
-
-      // 4. Select skill (AI-assisted if available)
-      let skill = null;
-      if (context.skill) {
-        skill = this.skills.get(context.skill);
-        if (!skill) {
-          return this.formatError(`Skill not found: ${context.skill}`, input);
-        }
+      if (!skill) {
+        return this.formatError('No matching skill found', input);
       }
 
-      const candidates = await this.skills.getCandidates(input, context);
-
-      if (!skill && 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)
@@ -149,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);
 
@@ -207,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)
     };
@@ -244,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);
@@ -277,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

@@ -292,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 || [];
   }
 
@@ -377,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({
@@ -407,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,6 +1,6 @@
 {
   "name": "flowmind",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "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/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')
       )
     )
   );