flowmind 1.1.0 → 1.2.2

package/core/honor-engine.js

@@ -0,0 +1,255 @@
+/**
+ * FlowMind Honor Engine
+ * Tracks honor points earned through usage and manages dragon totem levels
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const eventBus = require('./event-bus');
+
+const HONOR_POINTS = {
+  init: 1,
+  skill_use: 1,
+  new_skill: 2,
+  learning: 3
+};
+
+const DRAGON_LEVELS = [
+  { level: 0, minPoints: 0,  name: 'Egg',       state: 'dormant' },
+  { level: 1, minPoints: 1,  name: 'Hatchling',  state: 'awakening' },
+  { level: 2, minPoints: 10, name: 'Juvenile',   state: 'growing' },
+  { level: 3, minPoints: 30, name: 'Adult',       state: 'soaring' },
+  { level: 4, minPoints: 60, name: 'Elder',       state: 'wise' },
+  { level: 5, minPoints: 100, name: 'Ascended',   state: 'transcendent' }
+];
+
+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.skillsPath = config.get('skills.path', path.join(__dirname, '..', 'skills'));
+    this.data = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize honor engine
+   */
+  async init() {
+    try {
+      if (await fs.pathExists(this.honorPath)) {
+        this.data = await fs.readJson(this.honorPath);
+      } else {
+        this.data = this.createDefaultData();
+        // Seed knownSkills by scanning skills/ directory
+        await this.seedKnownSkills();
+        await this.save();
+      }
+      this.initialized = true;
+    } catch (error) {
+      // Non-blocking: create default data in memory
+      this.data = this.createDefaultData();
+      this.initialized = true;
+    }
+  }
+
+  /**
+   * Create default honor data structure
+   */
+  createDefaultData() {
+    return {
+      version: '1.0',
+      points: 0,
+      level: 0,
+      history: [],
+      knownSkills: [],
+      stats: {
+        initCount: 0,
+        skillUseCount: 0,
+        newSkillCount: 0,
+        learningCount: 0
+      },
+      lastUpdated: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Seed knownSkills by scanning skills/ directory
+   */
+  async seedKnownSkills() {
+    try {
+      if (await fs.pathExists(this.skillsPath)) {
+        const entries = await fs.readdir(this.skillsPath);
+        for (const entry of entries) {
+          const fullPath = path.join(this.skillsPath, entry);
+          const stat = await fs.stat(fullPath);
+          if (stat.isDirectory()) {
+            this.data.knownSkills.push(entry);
+          }
+        }
+      }
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+
+  /**
+   * Award honor points for an action
+   */
+  async award(action, description) {
+    if (!this.initialized) await this.init();
+
+    try {
+      const points = HONOR_POINTS[action] || 0;
+      if (points === 0) return;
+
+      // Check init action: only award once
+      if (action === 'init' && this.data.stats.initCount > 0) {
+        return;
+      }
+
+      // Award points
+      this.data.points += points;
+      this.data.level = this.getLevel(this.data.points);
+
+      // Update stats
+      const statKey = `${action}Count`;
+      if (this.data.stats[statKey] !== undefined) {
+        this.data.stats[statKey]++;
+      }
+
+      // Add to history
+      this.data.history.push({
+        action,
+        points,
+        description,
+        timestamp: new Date().toISOString()
+      });
+
+      // Keep history to last 100 entries
+      if (this.data.history.length > 100) {
+        this.data.history = this.data.history.slice(-100);
+      }
+
+      this.data.lastUpdated = new Date().toISOString();
+      await this.save();
+
+      // Emit honor event for TUI/dashboard monitoring
+      eventBus.emit('honor:awarded', {
+        action,
+        points,
+        description,
+        level: this.data.level,
+        levelName: this.getLevelName(this.data.level),
+        total: this.data.points,
+        timestamp: this.data.lastUpdated
+      });
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+
+  /**
+   * Check if a skill name is already known
+   */
+  isKnownSkill(name) {
+    return this.data && this.data.knownSkills.includes(name);
+  }
+
+  /**
+   * Add a skill to the known list
+   */
+  async addKnownSkill(name) {
+    if (!this.initialized) await this.init();
+    try {
+      if (!this.data.knownSkills.includes(name)) {
+        this.data.knownSkills.push(name);
+        await this.save();
+      }
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+
+  /**
+   * Get the honor data
+   */
+  getData() {
+    return this.data || this.createDefaultData();
+  }
+
+  /**
+   * Get level for a given point total
+   */
+  getLevel(points) {
+    let level = 0;
+    for (const tier of DRAGON_LEVELS) {
+      if (points >= tier.minPoints) {
+        level = tier.level;
+      }
+    }
+    return level;
+  }
+
+  /**
+   * Get level name for a given level number
+   */
+  getLevelName(level) {
+    const tier = DRAGON_LEVELS.find(t => t.level === level);
+    return tier ? tier.name : 'Unknown';
+  }
+
+  /**
+   * Get level info including next level hint
+   */
+  getLevelInfo(points) {
+    const level = this.getLevel(points);
+    const currentTier = DRAGON_LEVELS.find(t => t.level === level);
+    const nextTier = DRAGON_LEVELS.find(t => t.level === level + 1);
+
+    return {
+      level,
+      name: currentTier.name,
+      state: currentTier.state,
+      points,
+      nextLevel: nextTier ? nextTier.level : null,
+      nextLevelName: nextTier ? nextTier.name : null,
+      pointsToNext: nextTier ? nextTier.minPoints - points : 0
+    };
+  }
+
+  /**
+   * Export honor data for publishing
+   */
+  exportForPublish() {
+    const info = this.getLevelInfo(this.data.points);
+    return {
+      version: this.data.version,
+      points: this.data.points,
+      level: info.level,
+      levelName: info.name,
+      state: info.state,
+      stats: this.data.stats,
+      knownSkillsCount: this.data.knownSkills.length,
+      recentHistory: this.data.history.slice(-20),
+      exportedAt: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Save honor data to disk
+   */
+  async save() {
+    try {
+      await fs.ensureDir(path.dirname(this.honorPath));
+      await fs.writeJson(this.honorPath, this.data, { spaces: 2 });
+    } catch (error) {
+      // Non-blocking
+    }
+  }
+}
+
+module.exports = HonorEngine;

package/core/index.js

@@ -5,18 +5,21 @@
 
 const SkillLoader = require('./skill-loader');
 const LearningEngine = require('./learning-engine');
+const HonorEngine = require('./honor-engine');
 const SceneMatcher = require('./scene-matcher');
 const ConfigManager = require('./config-manager');
 const ComponentRegistry = require('./component-registry');
 const ModelManager = require('./ai/model-manager');
+const eventBus = require('./event-bus');
 
 class FlowMind {
   constructor(options = {}) {
     this.config = new ConfigManager(options.configPath);
-    this.learning = new LearningEngine(this.config);
+    this.honor = new HonorEngine(this.config);
+    this.learning = new LearningEngine(this.config, this.honor);
     this.matcher = new SceneMatcher(this.config, this.learning);
     this.components = new ComponentRegistry(this.config);
-    this.skills = new SkillLoader(this.config, this.learning, this.components);
+    this.skills = new SkillLoader(this.config, this.learning, this.components, this.honor);
     this.ai = new ModelManager(options.ai || {});
     this.initialized = false;
   }
@@ -30,6 +33,7 @@ class FlowMind {
     await this.config.load();
     await this.components.init();
     await this.components.initAll();
+    await this.honor.init();
     await this.learning.init();
     await this.skills.loadAll();
     await this.matcher.loadScenes();
@@ -55,6 +59,8 @@ class FlowMind {
 
     const startTime = Date.now();
 
+    eventBus.emit('process:start', { input, timestamp: new Date().toISOString() });
+
     try {
       // 1. AI Intent Understanding (if available)
       const intent = await this.ai.understandIntent(input, context);
@@ -114,7 +120,7 @@ class FlowMind {
       });
 
       // 8. Format and return
-      return this.formatResult(summary || result, {
+      const formatted = this.formatResult(summary || result, {
         skill: skill.name,
         duration: Date.now() - startTime,
         sceneMatch: sceneMatch,
@@ -122,7 +128,18 @@ class FlowMind {
         aiEnhanced: !!summary
       });
 
+      eventBus.emit('process:complete', {
+        input,
+        skill: skill.name,
+        duration: formatted.metadata.duration,
+        success: true,
+        timestamp: formatted.timestamp
+      });
+
+      return formatted;
+
     } catch (error) {
+      eventBus.emit('process:error', { input, error: error.message, timestamp: new Date().toISOString() });
       return this.formatError(error.message, input);
     }
   }
@@ -131,6 +148,8 @@ class FlowMind {
    * Execute skill with learning applied
    */
   async executeWithLearning(skill, input, context) {
+    const skillStartTime = Date.now();
+
     // Get learning rules for this skill
     const learnings = await this.learning.getSkillLearnings(skill.name);
 
@@ -144,6 +163,19 @@ class FlowMind {
     // Execute skill
     const result = await skill.execute(input, enhancedContext);
 
+    const duration = Date.now() - skillStartTime;
+
+    // Emit skill execution event
+    eventBus.emit('skill:executed', {
+      name: skill.name,
+      duration,
+      success: true,
+      timestamp: new Date().toISOString()
+    });
+
+    // Award honor point for skill use
+    await this.honor.award('skill_use', `Used skill: ${skill.name}`);
+
     return result;
   }
 
@@ -227,6 +259,13 @@ class FlowMind {
     return this.learning.getStats();
   }
 
+  /**
+   * Get honor data
+   */
+  getHonorData() {
+    return this.honor.getData();
+  }
+
   /**
    * Get the component registry
    * @returns {ComponentRegistry}

package/core/learning-engine.js

@@ -6,10 +6,12 @@
 const fs = require('fs-extra');
 const path = require('path');
 const { v4: uuidv4 } = require('uuid');
+const eventBus = require('./event-bus');
 
 class LearningEngine {
-  constructor(config) {
+  constructor(config, honorEngine = null) {
     this.config = config;
+    this.honorEngine = honorEngine;
     this.learningPath = config.get('learning.storagePath', '~/.flowmind/learning');
     this.records = {};
     this.skillBindings = {};
@@ -170,6 +172,13 @@ class LearningEngine {
     // Update stats
     await this.updateStats('correction', record.skill);
 
+    eventBus.emit('learning:recorded', {
+      type: 'correction',
+      skill: record.skill,
+      recordId: record.id,
+      severity: record.severity
+    });
+
     return {
       type: 'correction',
       record: record,
@@ -204,6 +213,13 @@ class LearningEngine {
     // Update stats
     await this.updateStats('scene_mapping', 'global');
 
+    eventBus.emit('learning:recorded', {
+      type: 'scene_mapping',
+      skill: 'global',
+      recordId: record.id,
+      keywords: record.keywords
+    });
+
     return {
       type: 'scene_mapping',
       record: record,
@@ -232,6 +248,13 @@ class LearningEngine {
     // Update stats
     await this.updateStats('preference', record.skill);
 
+    eventBus.emit('learning:recorded', {
+      type: 'preference',
+      skill: record.skill,
+      recordId: record.id,
+      preferenceType: record.preferenceType
+    });
+
     return {
       type: 'preference',
       record: record,
@@ -398,6 +421,11 @@ class LearningEngine {
 
     const statsPath = path.join(this.expandPath(this.learningPath), 'stats.json');
     await fs.writeJson(statsPath, this.stats, { spaces: 2 });
+
+    // Award honor points for learning
+    if (this.honorEngine) {
+      await this.honorEngine.award('learning', `Learned: ${type} for ${skill}`);
+    }
   }
 
   /**

package/core/skill-loader.js

@@ -7,10 +7,11 @@ const fs = require('fs-extra');
 const path = require('path');
 
 class SkillLoader {
-  constructor(config, learning, componentRegistry = null) {
+  constructor(config, learning, componentRegistry = null, honorEngine = null) {
     this.config = config;
     this.learning = learning;
     this.componentRegistry = componentRegistry;
+    this.honorEngine = honorEngine;
     this.skills = new Map();
     this.skillPath = config.get('skills.path', path.join(__dirname, '..', 'skills'));
   }
@@ -68,6 +69,13 @@ class SkillLoader {
       };
 
       this.skills.set(name, skill);
+
+      // Award honor points for new (previously unknown) skills
+      if (this.honorEngine && !this.honorEngine.isKnownSkill(name)) {
+        await this.honorEngine.award('new_skill', `New skill loaded: ${name}`);
+        await this.honorEngine.addKnownSkill(name);
+      }
+
       return skill;
     } catch (error) {
       console.error(`Failed to load skill ${name}:`, error.message);

package/dashboard/app.jsx

@@ -0,0 +1,29 @@
+const React = require('react');
+const { Box, useApp, useInput } = require('ink');
+const ActivityFeed = require('./components/ActivityFeed.jsx');
+const StatsRow = require('./components/StatsRow.jsx');
+const DragonPanel = require('./components/DragonPanel.jsx');
+const McpStatusBar = require('./components/McpStatusBar.jsx');
+
+function DashboardApp({ flowmind, eventBus }) {
+  const { exit } = useApp();
+
+  useInput((input, key) => {
+    if (key.ctrl && input === 'c') exit();
+  });
+
+  return (
+    React.createElement(Box, { flexDirection: 'column', width: '100%', height: '100%' },
+      React.createElement(Box, { flexDirection: 'row', flexGrow: 1 },
+        React.createElement(ActivityFeed, { eventBus: eventBus }),
+        React.createElement(Box, { flexDirection: 'column', width: '60%', flexGrow: 1 },
+          React.createElement(StatsRow, { flowmind: flowmind }),
+          React.createElement(DragonPanel, { flowmind: flowmind })
+        )
+      ),
+      React.createElement(McpStatusBar, { eventBus: eventBus })
+    )
+  );
+}
+
+module.exports = DashboardApp;

package/dashboard/components/ActivityFeed.jsx

@@ -0,0 +1,86 @@
+const React = require('react');
+const { Box, Text } = require('ink');
+
+const EVENT_COLORS = {
+  'skill:executed': 'green',
+  'honor:awarded': 'yellow',
+  'learning:recorded': 'cyan',
+  'mcp:tool_called': 'magenta',
+  'process:start': 'blue',
+  'process:complete': 'green',
+  'process:error': 'red',
+};
+
+function formatTime(timestamp) {
+  if (!timestamp) return '??:??';
+  return new Date(timestamp).toTimeString().substring(0, 8);
+}
+
+function formatEvent(event) {
+  switch (event.type) {
+    case 'skill:executed':
+      return 'skill:' + (event.data?.name || '?') + ' ' + (event.data?.success ? '\u2713' : '\u2717');
+    case 'honor:awarded':
+      return 'honor +' + (event.data?.points || 0) + ' (' + (event.data?.description || '') + ')';
+    case 'learning:recorded':
+      return 'learning:' + (event.data?.type || '?') + ' ' + (event.data?.skill || '');
+    case 'mcp:tool_called':
+      return 'MCP:' + (event.data?.tool || '?') + ' ' + (event.data?.success ? '\u2713' : '\u2717') + ' ' + (event.data?.duration || 0) + 'ms';
+    case 'process:start':
+      return 'process: ' + (event.data?.input?.substring(0, 30) || '?') + '...';
+    case 'process:complete':
+      return 'done:' + (event.data?.skill || '?') + ' ' + (event.data?.duration || 0) + 'ms';
+    case 'process:error':
+      return 'error: ' + (event.data?.error?.substring(0, 40) || '?');
+    default:
+      return event.type || 'unknown';
+  }
+}
+
+function ActivityFeed({ eventBus }) {
+  const [events, setEvents] = React.useState([]);
+
+  React.useEffect(() => {
+    if (!eventBus) return;
+
+    const handler = (eventType) => (data) => {
+      setEvents(prev => {
+        const next = [...prev, { type: eventType, data, timestamp: data.timestamp || new Date().toISOString() }];
+        if (next.length > 100) next.shift();
+        return next;
+      });
+    };
+
+    const eventTypes = ['skill:executed', 'honor:awarded', 'learning:recorded', 'mcp:tool_called', 'process:start', 'process:complete', 'process:error'];
+    const handlers = eventTypes.map(type => {
+      const h = handler(type);
+      eventBus.on(type, h);
+      return { type, handler: h };
+    });
+
+    return () => {
+      for (const { type, handler: h } of handlers) {
+        eventBus.removeListener(type, h);
+      }
+    };
+  }, [eventBus]);
+
+  const displayEvents = events.slice(-30);
+
+  return (
+    React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'green', paddingX: 1, width: '40%' },
+      React.createElement(Text, { bold: true, color: 'green' }, 'Activity Feed'),
+      React.createElement(Box, { flexDirection: 'column', marginTop: 1, overflow: 'hidden' },
+        displayEvents.length === 0 && React.createElement(Text, { color: 'gray' }, 'Waiting for events...'),
+        displayEvents.map((event, i) =>
+          React.createElement(Text, { key: i },
+            React.createElement(Text, { color: 'gray' }, formatTime(event.timestamp) + ' '),
+            React.createElement(Text, { color: EVENT_COLORS[event.type] || 'white' }, formatEvent(event))
+          )
+        )
+      )
+    )
+  );
+}
+
+module.exports = ActivityFeed;

package/dashboard/components/DragonPanel.jsx

@@ -0,0 +1,67 @@
+const React = require('react');
+const { Box, Text } = require('ink');
+
+const DRAGON_ARTS = {
+  0: ['        ╭─────╮        ','       ╱  ╭─╮  ╲       ','      │  │   │  │      ','      │  │ ◎ │  │      ','      │   ╰─╯   │      ','       ╲       ╱       ','        ╰─────╯        '],
+  1: ['           ╭──╮            ','      ╭────╯  ╰───╮        ','     ╱  ◎    ╰─╯   ╲      ','    ╱    ▽           ╲     ','    ╲    ╱╲   ╱╲     ╱     ','     ╲╱╱  ╲╱╱  ╲╱╲╱       '],
+  2: ['        ╭─╮  ╭─╮             ','   ╭────╯ ╰──╯ ╰───╮         ','  ╱  ◎      ╰──╯     ╲       ',' ╱      ╭────────╮     ╲     ',' ╲     ╱ ╱╱╱╱╱╱╱╱ ╲    ╱     ','  ╲───╯ ╱╱╱╱╱╱╱╱╱╱ ╰──╱      ','   ╰─╯            ╰─╯       '],
+  3: ['      ╭───╮  ╭───╮               ','  ╭───╯   ╰──╯   ╰───╮           ',' ╱  ◎        ╰───╯     ╲         ','│     ╭──────────╮      │        ','│    ╱ ╱╱╱╱╱╱╱╱╱╱ ╲     │        ',' ╲──╯ ╱╱╱╱╱╱╱╱╱╱╱╱ ╰───╯        ','  ╲  ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ╱         ','   ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱          ','    ╰───╯       ╰───╯            '],
+  4: ['    ╭───╮      ╭───╮                 ','╭───╯   ╰──────╯   ╰───╮             ','│  ◎           ╰───╯     │           ','│      ╭────────────╮    │           ','│     ╱ ╱╱╱╱╱╱╱╱╱╱╱╱ ╲   │           ',' ╲───╯ ╱╱╱╱╱╱╱╱╱╱╱╱╱╱ ╰──╯          ','  ╲   ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ╲          ','   ╲─╯╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰─╲         ','    ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱         ','     ╰───╯         ╰───╯             '],
+  5: ['  ★  ╭───╮          ╭───╮  ★           ','╭─╯   ╰──╯          ╰──╯   ╰─╮         ','│  ◎            ╰───╯         │         ','│       ╭──────────────╮      │         ','│      ╱ ★╱╱╱╱╱╱╱╱╱╱★╱╱ ╲     │         ',' ╲────╯ ╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱ ╰───╯         ','  ╲    ╱╱╱╱★╱╱╱╱╱╱╱╱★╱╱╱╱╱  ╲          ','   ╲──╯╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰──╲         ','    ╲─╯╱╱╱★╱╱╱╱╱╱╱╱★╱╱╱╱╱╰──╲         ','  ★  ╲╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱  ★       ','       ╰───╯           ╰───╯            '],
+};
+
+const LEVEL_NAMES = ['Egg', 'Hatchling', 'Juvenile', 'Adult', 'Elder', 'Ascended'];
+const LEVEL_STATES = ['dormant', 'awakening', 'growing', 'soaring', 'wise', 'transcendent'];
+const LEVEL_COLORS = ['gray', 'cyan', 'cyan', 'cyanBright', 'cyanBright', 'cyanBright'];
+
+function DragonPanel({ flowmind }) {
+  const [honorData, setHonorData] = React.useState({ points: 0, level: 0, stats: {} });
+
+  React.useEffect(() => {
+    if (!flowmind) return;
+    const refresh = () => {
+      try { setHonorData(flowmind.getHonorData()); } catch (e) { /* ignore */ }
+    };
+    refresh();
+    const interval = setInterval(refresh, 5000);
+    return () => clearInterval(interval);
+  }, [flowmind]);
+
+  const level = honorData.level || 0;
+  const art = DRAGON_ARTS[level] || DRAGON_ARTS[0];
+  const color = LEVEL_COLORS[level] || 'gray';
+  const levelName = LEVEL_NAMES[level] || 'Unknown';
+  const state = LEVEL_STATES[level] || 'unknown';
+  const nextLevelPoints = [1, 10, 30, 60, 100];
+  const nextPoints = nextLevelPoints[level] || null;
+  const pointsToNext = nextPoints !== null ? nextPoints - honorData.points : 0;
+
+  return (
+    React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'cyan', paddingX: 1, flexGrow: 1 },
+      React.createElement(Text, { bold: true, color: 'cyan' }, 'Dragon Totem'),
+      React.createElement(Box, { flexDirection: 'row', marginTop: 1 },
+        React.createElement(Box, { flexDirection: 'column' },
+          art.map((line, i) => React.createElement(Text, { key: i, color: color }, line))
+        ),
+        React.createElement(Box, { flexDirection: 'column', marginLeft: 3, justifyContent: 'center' },
+          React.createElement(Text, null,
+            React.createElement(Text, { color: 'yellow', bold: true }, 'Lv' + level),
+            React.createElement(Text, { color: 'white' }, ' ' + levelName)
+          ),
+          React.createElement(Text, { color: 'gray' }, 'State: ' + state),
+          React.createElement(Text, null,
+            React.createElement(Text, { color: 'yellow' }, '' + honorData.points),
+            React.createElement(Text, { color: 'gray' }, ' points')
+          ),
+          pointsToNext > 0 && React.createElement(Text, { color: 'gray' }, pointsToNext + ' to next'),
+          React.createElement(Box, { flexDirection: 'column', marginTop: 1 },
+            React.createElement(Text, { color: 'gray' }, 'Skills: ' + (honorData.stats?.skillUseCount || 0)),
+            React.createElement(Text, { color: 'gray' }, 'Learnings: ' + (honorData.stats?.learningCount || 0))
+          )
+        )
+      )
+    )
+  );
+}
+
+module.exports = DragonPanel;

package/dashboard/components/McpStatusBar.jsx

@@ -0,0 +1,43 @@
+const React = require('react');
+const { Box, Text } = require('ink');
+
+function McpStatusBar({ eventBus }) {
+  const [toolCount, setToolCount] = React.useState(0);
+  const [lastCall, setLastCall] = React.useState(null);
+  const [serverState, setServerState] = React.useState('running');
+
+  React.useEffect(() => {
+    if (!eventBus) return;
+    const handler = (data) => {
+      setToolCount(prev => prev + 1);
+      setLastCall(data.timestamp || new Date().toISOString());
+    };
+    eventBus.on('mcp:tool_called', handler);
+    return () => { eventBus.removeListener('mcp:tool_called', handler); };
+  }, [eventBus]);
+
+  const formatTime = (ts) => ts ? new Date(ts).toTimeString().substring(0, 8) : 'none';
+
+  return (
+    React.createElement(Box, { borderStyle: 'single', borderColor: 'gray', paddingX: 1, justifyContent: 'space-between' },
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'MCP Server: '),
+        React.createElement(Text, { color: 'green' }, serverState)
+      ),
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'Port: '),
+        React.createElement(Text, { color: 'white' }, 'stdin/stdout')
+      ),
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'Tool calls: '),
+        React.createElement(Text, { color: 'white' }, '' + toolCount)
+      ),
+      React.createElement(Text, null,
+        React.createElement(Text, { color: 'gray' }, 'Last call: '),
+        React.createElement(Text, { color: 'white' }, formatTime(lastCall))
+      )
+    )
+  );
+}
+
+module.exports = McpStatusBar;