@monoes/monomindcli 1.6.0 → 1.6.3

package/dist/src/mcp-tools/agent-tools.js

@@ -4,9 +4,17 @@
  * Tool definitions for agent lifecycle management with file persistence.
  * Includes model routing integration for intelligent model selection.
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
+function logEvent(kind, data) {
+    try {
+        const dir = join(getProjectCwd(), '.monomind', 'swarm');
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        const event = { ts: new Date().toISOString(), source: 'mcp', kind, ...data };
+        appendFileSync(join(dir, 'events.jsonl'), JSON.stringify(event) + '\n');
+    } catch { }
+}
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const AGENT_DIR = 'agents';
@@ -189,6 +197,7 @@ export const agentTools = [
                 register(agentId, sandbox);
             }
             catch { /* optional — @monoes/security may not be installed */ }
+            logEvent('agent.spawn', { agentId, agentType, model: routingResult.model, routedBy: routingResult.routedBy, domain: input.domain, task });
             // Include Agent Booster routing info if applicable
             const response = {
                 success: true,
@@ -228,8 +237,10 @@ export const agentTools = [
             const store = loadAgentStore();
             const agentId = input.agentId;
             if (store.agents[agentId]) {
+                const agentType = store.agents[agentId].agentType;
                 store.agents[agentId].status = 'terminated';
                 saveAgentStore(store);
+                logEvent('agent.terminate', { agentId, agentType });
                 // Task 46: AgentSandboxing — clean up sandbox on termination
                 try {
                     const { cleanup } = await import('@monoes/security');

package/dist/src/mcp-tools/hive-mind-tools.js

@@ -3,10 +3,18 @@
  *
  * Tool definitions for collective intelligence and swarm coordination.
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { weightedTally } from '../consensus/vote-signer.js';
+function logEvent(kind, data) {
+    try {
+        const dir = join(getProjectCwd(), '.monomind', 'swarm');
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        const event = { ts: new Date().toISOString(), source: 'mcp', kind, ...data };
+        appendFileSync(join(dir, 'events.jsonl'), JSON.stringify(event) + '\n');
+    } catch { }
+}
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const HIVE_DIR = 'hive-mind';
@@ -190,6 +198,9 @@ export const hiveMindTools = [
             }
             saveAgentStore(agentStore);
             saveHiveState(state);
+            for (const w of spawnedWorkers) {
+                logEvent('hive.spawn', { agentId: w.agentId, role: w.role, agentType });
+            }
             return {
                 success: true,
                 spawned: count,
@@ -224,6 +235,7 @@ export const hiveMindTools = [
                 term: 1,
             };
             saveHiveState(state);
+            logEvent('hive.init', { hiveId, topology: state.topology, consensus: input.consensus || 'byzantine', queenId });
             return {
                 success: true,
                 hiveId,
@@ -464,6 +476,7 @@ export const hiveMindTools = [
                 };
                 state.consensus.pending.push(proposal);
                 saveHiveState(state);
+                logEvent('hive.consensus.propose', { proposalId, type: proposal.type, strategy, proposedBy: proposal.proposedBy, totalNodes });
                 return {
                     action,
                     proposalId,
@@ -585,9 +598,11 @@ export const hiveMindTools = [
                 // Try to resolve
                 const resolution = divergenceGateOpen ? tryResolveProposal(proposal, totalNodes) : null;
                 let resolved = false;
+                logEvent('hive.consensus.vote', { proposalId: proposal.proposalId, voterId, vote: voteValue, strategy: proposalStrategy, votesFor, votesAgainst });
                 if (resolution !== null) {
                     resolved = true;
                     proposal.status = resolution;
+                    logEvent('hive.consensus.resolved', { proposalId: proposal.proposalId, result: resolution, strategy: proposalStrategy, votesFor, votesAgainst });
                     state.consensus.history.push({
                         proposalId: proposal.proposalId,
                         type: proposal.type,
@@ -735,6 +750,7 @@ export const hiveMindTools = [
             // Keep only last 100 broadcasts
             state.sharedMemory.broadcasts = messages.slice(-100);
             saveHiveState(state);
+            logEvent('hive.broadcast', { messageId, fromId: input.fromId || 'system', message: input.message, priority: input.priority || 'normal', recipients: state.workers.length });
             return {
                 success: true,
                 messageId,
@@ -784,6 +800,7 @@ export const hiveMindTools = [
             // Reset hive state
             const shutdownTime = new Date().toISOString();
             const previousQueen = state.queen?.agentId;
+            logEvent('hive.shutdown', { workersTerminated: workerCount, previousQueen, graceful, pendingConsensus, topology: state.topology });
             state.initialized = false;
             state.queen = undefined;
             state.workers = [];

package/dist/src/mcp-tools/hooks-tools.js

@@ -2,9 +2,17 @@
  * Hooks MCP Tools
  * Provides intelligent hooks functionality via MCP protocol
  */
-import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync, appendFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { getProjectCwd } from './types.js';
+function logEvent(kind, data) {
+    try {
+        const dir = join(getProjectCwd(), '.monomind', 'swarm');
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        const event = { ts: new Date().toISOString(), source: 'hook', kind, ...data };
+        appendFileSync(join(dir, 'events.jsonl'), JSON.stringify(event) + '\n');
+    } catch { }
+}
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 async function getRealSearchFunction() {
@@ -1094,6 +1102,7 @@ export const hooksPreTask = {
             }
         }
         catch { /* non-critical */ }
+        logEvent('task.start', { taskId, description: description?.slice(0, 200), complexity, suggestedAgent: suggestion.agents[0], modelTier: modelRouting?.tier });
         return {
             taskId,
             description,
@@ -1256,6 +1265,7 @@ export const hooksPostTask = {
             storeAs: 'heuristics',
             note: 'Spawn agents sequentially: Diagnoser → Critics in parallel → Aggregator',
         } : { needed: false };
+        logEvent('task.end', { taskId, success, duration, agent, quality, task: taskText?.slice(0, 200) });
         return {
             taskId,
             success,

package/dist/src/mcp-tools/swarm-tools.js

@@ -4,9 +4,17 @@
  * Tool definitions for swarm coordination with file-based state persistence.
  * Replaces previous stub implementations with real state tracking.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
+function logEvent(kind, data) {
+    try {
+        const dir = join(getProjectCwd(), '.monomind', 'swarm');
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        const event = { ts: new Date().toISOString(), source: 'mcp', kind, ...data };
+        appendFileSync(join(dir, 'events.jsonl'), JSON.stringify(event) + '\n');
+    } catch { }
+}
 // Swarm state persistence
 const SWARM_DIR = '.monomind/swarm';
 const SWARM_STATE_FILE = 'swarm-state.json';
@@ -88,6 +96,7 @@ export const swarmTools = [
             const store = loadSwarmStore();
             store.swarms[swarmId] = swarmState;
             saveSwarmStore(store);
+            logEvent('swarm.init', { swarmId, topology, strategy, maxAgents, config: swarmState.config });
             return {
                 success: true,
                 swarmId,
@@ -195,6 +204,7 @@ export const swarmTools = [
             target.status = 'terminated';
             target.updatedAt = new Date().toISOString();
             saveSwarmStore(store);
+            logEvent('swarm.shutdown', { swarmId: target.swarmId, topology: target.topology, agentCount: target.agents.length, graceful: input.graceful ?? true });
             return {
                 success: true,
                 swarmId: target.swarmId,

package/dist/src/ui/collector.mjs

@@ -119,16 +119,104 @@ function collectSessions(projectDir) {
   };
 }
 
+const _appendedSwarmIds = new Set();
+
 function collectSwarm(projectDir) {
   const base = path.join(projectDir, '.monomind');
+  const state = readJSON(path.join(base, 'swarm', 'swarm-state.json')) || {};
+  const dotSwarmState = readJSON(path.join(projectDir, '.swarm', 'state.json')) || {};
+  const merged = { ...dotSwarmState, ...state };
+
+  const terminalStatuses = ['stopped', 'terminated', 'completed', 'error'];
+  const swarmId = merged.swarmId || merged.id;
+  if (swarmId && terminalStatuses.includes(merged.status) && !_appendedSwarmIds.has(swarmId)) {
+    _appendedSwarmIds.add(swarmId);
+    const agents = (merged.agents || merged.agentPlan || []).map(a => ({
+      id: a.id || a.type || a.role,
+      type: a.type || a.role || '?',
+      role: a.role || 'worker',
+      tasksCompleted: a.tasksCompleted || a.count || 0,
+      tasksFailed: a.tasksFailed || 0,
+      messageCount: a.messageCount || 0,
+      utilization: a.utilization || 0,
+    }));
+    const entry = {
+      swarmId,
+      topology: merged.topology || '—',
+      consensus: merged.consensus || '—',
+      strategy: merged.strategy || '—',
+      status: merged.status,
+      agents,
+      messages: merged.messages || [],
+      errors: merged.errors || [],
+      findings: merged.findings || [],
+      taskCount: merged.taskCount || 0,
+      completedTasks: merged.completedTasks || 0,
+      failedTasks: merged.failedTasks || 0,
+      startedAt: merged.startedAt || merged.createdAt || new Date().toISOString(),
+      endedAt: merged.stoppedAt || merged.endedAt || new Date().toISOString(),
+      durationMs: 0,
+    };
+    if (entry.startedAt && entry.endedAt) {
+      entry.durationMs = new Date(entry.endedAt).getTime() - new Date(entry.startedAt).getTime();
+    }
+    try { appendSwarmHistory(projectDir, entry); } catch {}
+  }
+
   return {
-    state: readJSON(path.join(base, 'swarm', 'swarm-state.json')) || {},
+    state: merged,
     activity: readJSON(path.join(base, 'metrics', 'swarm-activity.json')) || {},
     suggestion: {},
-    config: readJSON(path.join(base, 'swarm-config.json')) || {}
+    config: readJSON(path.join(base, 'swarm-config.json')) || {},
   };
 }
 
+function collectSwarmHistory(projectDir) {
+  const historyPath = path.join(projectDir, '.monomind', 'swarm', 'history.jsonl');
+  return readJSONL(historyPath).reverse(); // newest-first
+}
+
+function appendSwarmHistory(projectDir, entry) {
+  const dir = path.join(projectDir, '.monomind', 'swarm');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const historyPath = path.join(dir, 'history.jsonl');
+  fs.appendFileSync(historyPath, JSON.stringify(entry) + '\n');
+}
+
+function collectSwarmEvents(projectDir, opts = {}) {
+  const eventsPath = path.join(projectDir, '.monomind', 'swarm', 'events.jsonl');
+  const events = readJSONL(eventsPath, opts.last || null);
+  if (opts.swarmId) return events.filter(e => e.swarmId === opts.swarmId);
+  if (opts.agentId) return events.filter(e => e.agentId === opts.agentId);
+  return events;
+}
+
+function getSwarmDataSize(projectDir) {
+  const dir = path.join(projectDir, '.monomind', 'swarm');
+  let totalBytes = 0;
+  let fileCount = 0;
+  const files = ['history.jsonl', 'events.jsonl'];
+  for (const f of files) {
+    const stat = fileStat(path.join(dir, f));
+    if (stat) { totalBytes += stat.size; fileCount++; }
+  }
+  return { totalBytes, fileCount, humanSize: totalBytes < 1024 ? totalBytes + ' B' : totalBytes < 1048576 ? (totalBytes / 1024).toFixed(1) + ' KB' : (totalBytes / 1048576).toFixed(1) + ' MB' };
+}
+
+function cleanSwarmData(projectDir) {
+  const dir = path.join(projectDir, '.monomind', 'swarm');
+  const files = ['history.jsonl', 'events.jsonl'];
+  let removed = 0;
+  for (const f of files) {
+    const fp = path.join(dir, f);
+    try { fs.unlinkSync(fp); removed++; } catch {}
+  }
+  _appendedSwarmIds.clear();
+  return { removed, files };
+}
+
 function collectAgents(projectDir) {
   const base = path.join(projectDir, '.monomind');
   const regsDir = path.join(base, 'agents', 'registrations');
@@ -420,12 +508,12 @@ export function collectAllProjects() {
     // Last activity = most recent session mtime
     const lastActivity = sessions.length ? sessions[0].mtime : null;
 
-    // Read memory palace if available
-    let drawerCount = 0;
+    // Count auto-memory files from ~/.claude/projects/<slug>/memory/
+    let memoryCount = 0;
     try {
-      const drawersPath = path.join(diskPath, '.monomind', 'palace', 'drawers.jsonl');
-      if (fs.existsSync(drawersPath)) {
-        drawerCount = fs.readFileSync(drawersPath, 'utf8').split('\n').filter(Boolean).length;
+      const memDir = path.join(os.homedir(), '.claude', 'projects', slug, 'memory');
+      if (fs.existsSync(memDir)) {
+        memoryCount = fs.readdirSync(memDir).filter(f => f.endsWith('.md') && f !== 'MEMORY.md').length;
       }
     } catch {}
 
@@ -437,7 +525,7 @@ export function collectAllProjects() {
       sessionCount: sessions.length,
       sessions: sessions.slice(0, 5), // top 5 most recent
       lastActivity,
-      drawerCount,
+      memoryCount,
       totalSize: sessions.reduce((sum, s) => sum + (s.size || 0), 0),
     });
   }
@@ -473,7 +561,7 @@ export function collectAll(projectDir) {
   };
 }
 
-export { collectProject, collectSessions, collectSwarm, collectAgents, collectTokens, collectHooks, collectKnowledge, collectMetrics, collectMemory, collectMemoryFiles, collectSystem };
+export { collectProject, collectSessions, collectSwarm, collectSwarmHistory, appendSwarmHistory, collectSwarmEvents, getSwarmDataSize, cleanSwarmData, collectAgents, collectTokens, collectHooks, collectKnowledge, collectMetrics, collectMemory, collectMemoryFiles, collectSystem };
 
 export function getWatchPaths(projectDir) {
   const resolvedDir = path.resolve(projectDir);
@@ -483,6 +571,7 @@ export function getWatchPaths(projectDir) {
   return [
     // Swarm
     path.join(m, 'swarm', 'swarm-state.json'),
+    path.join(m, 'swarm', 'history.jsonl'),
     path.join(m, 'swarm-config.json'),
     // Metrics
     path.join(m, 'metrics', 'swarm-activity.json'),