@monoes/monomindcli 1.6.0 → 1.6.2

package/.claude/commands/monomind-do.md

@@ -55,6 +55,35 @@ If `cargo` is also missing, output this and STOP:
 
 ---
 
+## Step 1.5: Initialize Loop State
+
+Generate a loop ID and write the initial state file so the dashboard can track this run:
+```bash
+mkdir -p .monomind/loops
+export DO_LOOP_ID="do-$(date +%s%3N)"
+cat > ".monomind/loops/${DO_LOOP_ID}.json" << EOF
+{
+  "id": "${DO_LOOP_ID}",
+  "type": "do",
+  "prompt": "/monomind:do $ARGUMENTS",
+  "currentTask": "discovering...",
+  "spaceId": "${SPACE_ID:-}",
+  "boardId": "${TASK_BOARD_ID:-}",
+  "filter": "${FILTER:-}",
+  "startedAt": $(date +%s%3N),
+  "lastRunAt": $(date +%s%3N),
+  "nextRunAt": 0,
+  "status": "running"
+}
+EOF
+```
+
+Also check if a stop was requested from a previous cycle:
+```bash
+[ -f ".monomind/loops/${DO_LOOP_ID}.stop" ] && echo "DO_STOP_REQUESTED=true"
+```
+If `DO_STOP_REQUESTED=true`, output `[monomind:do] Stop requested via dashboard. Halting.`, remove state files, and STOP.
+
 ## Step 2: Find Next Task
 
 1. List cards in `Todo` first (prioritized), then `Backlog`:
@@ -69,6 +98,13 @@ If `cargo` is also missing, output this and STOP:
    ```
    [monomind:do] No tasks in Todo or Backlog. Checking again in 2 minutes...
    ```
+   Update loop state before scheduling:
+   ```bash
+   NEXT_AT=$(( $(date +%s%3N) + 120000 ))
+   cat > ".monomind/loops/${DO_LOOP_ID}.json" << EOF
+   {"id":"${DO_LOOP_ID}","type":"do","prompt":"/monomind:do $ARGUMENTS","currentTask":"queue empty — waiting","spaceId":"${SPACE_ID:-}","boardId":"${TASK_BOARD_ID:-}","filter":"${FILTER:-}","startedAt":$(cat .monomind/loops/${DO_LOOP_ID}.json 2>/dev/null | python3 -c "import sys,json;print(json.load(sys.stdin).get('startedAt',0))" 2>/dev/null || date +%s%3N),"lastRunAt":$(date +%s%3N),"nextRunAt":${NEXT_AT},"status":"waiting"}
+   EOF
+   ```
    Then use `ScheduleWakeup` with `delaySeconds: 120` and prompt `/monomind:do --space $SPACE_ID --board $TASK_BOARD_ID` (plus `--filter` if one was set) to check again. STOP this iteration.
 
 4. Store `CURRENT_CARD_ID` and `CURRENT_CARD_TITLE`.
@@ -273,4 +309,9 @@ If no tasks remain, output:
 [monomind:do] All tasks processed. Queue empty.
 ```
 
+Remove the loop state file:
+```bash
+rm -f ".monomind/loops/${DO_LOOP_ID}.json" ".monomind/loops/${DO_LOOP_ID}.stop"
+```
+
 Do NOT schedule another wake-up. STOP.

package/.claude/commands/monomind-repeat.md

@@ -37,6 +37,27 @@ Extract:
 - `MAX_REPS` — from `--times` flag, default `10`
 - `PROMPT` — everything remaining after flags are removed
 - `CURRENT_REP` — starts at `1`
+- `LOOP_ID` — generate as `repeat-<unix-timestamp-ms>` (use `date +%s000`)
+
+Write the initial loop state file so the dashboard can track this run:
+```bash
+mkdir -p .monomind/loops
+LOOP_ID="repeat-$(date +%s%3N)"
+cat > ".monomind/loops/${LOOP_ID}.json" << EOF
+{
+  "id": "${LOOP_ID}",
+  "type": "repeat",
+  "prompt": "PROMPT",
+  "interval": INTERVAL,
+  "currentRep": 1,
+  "maxReps": MAX_REPS,
+  "startedAt": $(date +%s%3N),
+  "lastRunAt": $(date +%s%3N),
+  "nextRunAt": $(date +%s%3N),
+  "status": "running"
+}
+EOF
+```
 
 Output:
 ```
@@ -58,6 +79,16 @@ Run the `PROMPT` as if the user typed it directly. This means:
 
 ## Step 3: Report and Schedule Next
 
+Before scheduling the next run, check if a stop was requested:
+```bash
+[ -f ".monomind/loops/${LOOP_ID}.stop" ] && echo "STOP_REQUESTED=true"
+```
+If `STOP_REQUESTED=true`, output `[monomind:repeat] Stop requested via dashboard. Halting.` and remove the state files:
+```bash
+rm -f ".monomind/loops/${LOOP_ID}.json" ".monomind/loops/${LOOP_ID}.stop"
+```
+Then STOP.
+
 After execution completes, output:
 ```
 [monomind:repeat] Run CURRENT_REP/MAX_REPS complete. Next in INTERVAL minutes...
@@ -69,9 +100,32 @@ If `CURRENT_REP > MAX_REPS`, output:
 ```
 [monomind:repeat] All MAX_REPS repetitions complete.
 ```
+Remove the state file:
+```bash
+rm -f ".monomind/loops/${LOOP_ID}.json"
+```
 STOP. Do NOT schedule another wake-up.
 
-Otherwise, use `ScheduleWakeup` with:
+Otherwise, update the loop state before scheduling:
+```bash
+NEXT_AT=$(( $(date +%s%3N) + INTERVAL * 60 * 1000 ))
+cat > ".monomind/loops/${LOOP_ID}.json" << EOF
+{
+  "id": "${LOOP_ID}",
+  "type": "repeat",
+  "prompt": "PROMPT",
+  "interval": INTERVAL,
+  "currentRep": CURRENT_REP,
+  "maxReps": MAX_REPS,
+  "startedAt": STARTED_AT,
+  "lastRunAt": $(date +%s%3N),
+  "nextRunAt": ${NEXT_AT},
+  "status": "running"
+}
+EOF
+```
+
+Use `ScheduleWakeup` with:
 - `delaySeconds`: `INTERVAL * 60`
 - `prompt`: `/monomind:repeat --every INTERVAL --times MAX_REPS --rep CURRENT_REP PROMPT`
 - `reason`: `"repeat run CURRENT_REP/MAX_REPS of: PROMPT"`

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'),