monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/.claude/skills/memory-toolkit/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: memory-toolkit
+description: >
+  Use monomind's persistent memory store (LanceDB + pure-JS HNSW) to save,
+  search, list, and retrieve cross-session knowledge — patterns, solutions,
+  decisions. Trigger on "remember this", "store in memory", "search memory",
+  "have we solved this before", "recall past decisions", or before starting
+  work that benefits from prior context (debugging, refactors, repeated tasks).
+---
+
+# Memory Toolkit
+
+Monomind ships a persistent, namespaced memory store backed by LanceDB with
+a pure-JS HNSW index for approximate nearest-neighbor vector search. Use it
+to avoid re-solving the same problem twice across sessions.
+
+## Before starting non-trivial work
+
+Search for prior art first:
+
+```bash
+npx monomind memory search --query "[task keywords]" --namespace patterns
+npx monomind memory search --query "[task keywords]" --namespace solutions
+```
+
+## Store data
+
+```bash
+# REQUIRED: --key and --value. OPTIONAL: --namespace (default: "default"), --ttl, --tags
+npx monomind memory store --key "pattern-auth" --value "JWT with refresh tokens" --namespace patterns
+npx monomind memory store --key "bug-fix-123" --value "Fixed null check in parser" --namespace solutions --tags "bugfix,auth"
+```
+
+## Search data (semantic / keyword / hybrid)
+
+```bash
+# REQUIRED: --query. OPTIONAL: --namespace, --limit, --threshold, --type
+npx monomind memory search --query "authentication patterns"
+npx monomind memory search --query "JWT" --type keyword
+npx monomind memory search --query "error handling" --namespace patterns --limit 5
+```
+
+| Search type | Description                  | Best for                  |
+| ----------- | ----------------------------- | -------------------------- |
+| `semantic`  | Vector similarity search       | Concept / meaning matching |
+| `keyword`   | BM25 full-text search          | Exact term matching        |
+| `hybrid`    | Combined semantic + keyword    | General purpose (default)  |
+
+Use `--build-hnsw` before searching large memory stores (1,000+ entries) —
+it builds a pure-JS HNSW index for O(log n) queries instead of O(n) linear
+scan (one-time build cost).
+
+## List and retrieve
+
+```bash
+npx monomind memory list --namespace patterns --limit 10
+npx monomind memory retrieve --key "pattern-auth" --namespace patterns
+```
+
+## MCP equivalents
+
+```javascript
+mcp__monomind__memory_store({ key: "pattern-auth", value: "...", namespace: "patterns" })
+mcp__monomind__memory_search({ query: "authentication patterns", namespace: "default", limit: 10, threshold: 0.7, type: "hybrid" })
+```
+
+## After completing non-trivial work
+
+Store what worked so the next session (or agent) doesn't start from zero:
+
+```bash
+npx monomind memory store --key "[short-name]" --value "[what worked and why]" --namespace patterns
+```
+
+See also: `.claude/commands/memory/memory-search.md` for the full flag reference.

package/packages/@monomind/cli/.claude/skills/specialagent/SKILL.md

@@ -62,7 +62,7 @@ The available domains and their agent counts are:
 Once the domain is selected, use only the agent names for that domain:
 
 ### development
-sparc-coder, coder, backend-dev, Frontend Developer, mobile-dev, ml-developer, Rapid Prototyper, base-template-generator, LSP/Index Engineer, macOS Spatial/Metal Engineer, Terminal Integration Specialist, Embedded Firmware Engineer, Solidity Smart Contract Engineer, WeChat Mini Program Developer, Feishu Integration Developer, Roblox Systems Scripter, Godot Gameplay Scripter, Unity Architect, Unreal Systems Engineer, visionOS Spatial Engineer
+coder, backend-dev, Frontend Developer, mobile-dev, ml-developer, Rapid Prototyper, base-template-generator, LSP/Index Engineer, macOS Spatial/Metal Engineer, Terminal Integration Specialist, Embedded Firmware Engineer, Solidity Smart Contract Engineer, WeChat Mini Program Developer, Feishu Integration Developer, Roblox Systems Scripter, Godot Gameplay Scripter, Unity Architect, Unreal Systems Engineer, visionOS Spatial Engineer
 
 ### testing
 tdd-london-swarm, API Tester, production-validator, Evidence Collector, agent-browser-testing, Accessibility Auditor, Reality Checker, Code Reviewer, code-analyzer, feature-dev:code-reviewer
@@ -80,7 +80,7 @@ Data Engineer, AI Engineer, Database Optimizer, AI Data Remediation Engineer, Mo
 system-architect, Software Architect, Backend Architect, Plan, UX Architect, Workflow Architect
 
 ### research
-sparc:researcher, Explore, Trend Researcher, Technical Writer, api-docs
+Explore, Trend Researcher, Technical Writer, api-docs
 
 ### marketing
 AI Citation Strategist, App Store Optimizer, Baidu SEO Specialist, Bilibili Content Strategist, Carousel Growth Engine, China E-Commerce Operator, Content Creator, Cross-Border E-Commerce Specialist, Developer Advocate, Douyin Strategist, Growth Hacker, Healthcare Marketing Compliance Specialist, Instagram Curator, Kuaishou Strategist, LinkedIn Content Creator, Podcast Strategist, Reddit Community Builder, SEO Specialist, Short-Video Editing Coach, Social Media Strategist, TikTok Strategist, Twitter Engager, WeChat Official Account Manager, Weibo Strategist, Xiaohongshu Specialist, Zhihu Strategist, Livestream Commerce Coach
@@ -125,7 +125,6 @@ Analytics Reporter, Executive Summary Generator, Finance Tracker, Support Respon
 Use this to convert the chosen agent name to a callable slug:
 
 ```
-sparc-coder → sparc-coder
 coder → coder
 backend-dev → backend-dev
 Frontend Developer → Frontend Developer
@@ -158,7 +157,6 @@ Software Architect → Software Architect
 Backend Architect → Backend Architect
 Plan → Plan
 UX Architect → UX Architect
-sparc:researcher → sparc:researcher
 Explore → Explore
 Trend Researcher → Trend Researcher
 Technical Writer → Technical Writer

package/packages/@monomind/cli/.claude/skills/swarm-advanced/SKILL.md

@@ -917,7 +917,6 @@ mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 4 })
 
 ## Related Skills
 
-- `sparc-methodology` - Systematic development workflow
 - `github-integration` - Repository management and automation
 - `neural-patterns` - AI-powered coordination optimization
 - `memory-management` - Cross-session state persistence

package/packages/@monomind/cli/README.md

@@ -66,7 +66,7 @@ flowchart TD
     R["Reviewer"]
     M["Growth Marketer"]
     BOARD[("Shared\nTask Board")]
-    MEM[("LanceDB\nMemory")]
+    MEM[("Persistent\nMemory")]
 
     U --> CO --> RO --> BOSS
     BOSS -->|spawns| W
@@ -126,7 +126,7 @@ Type "go" to save, or describe changes.
 | **Boss agent** | Coordinator type, no supervisor — owns the goal |
 | **Role agents** | Spawned on demand, specialized by task type |
 | **Task board** | Todo → Doing → Done, shared across all agents |
-| **Memory** | All output stored in org-scoped LanceDB namespace |
+| **Memory** | All output stored in an org-scoped memory namespace |
 | **Checkpoint** | State saved every 30 min — survives crashes and restarts |
 | **Governance** | `auto` (free), `board` (approve sensitive), `strict` (approve all external actions) |
 
@@ -202,10 +202,7 @@ monomind init
 # 3. Wire into Claude Code as an MCP server
 claude mcp add monomind npx monomind mcp start
 
-# 4. Start the background daemon
-monomind daemon start
-
-# 5. Health check
+# 4. Health check
 monomind doctor --fix
 ```
 
@@ -221,13 +218,13 @@ Open Claude Code. You now have 80+ slash commands available:
 
 ## 🧠 Memory That Persists
 
-Every session, every agent, every org writes to **LanceDB** — a hybrid SQLite + HNSW vector store that survives across sessions. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.
+Every session, every agent, every org writes to a persistent memory store — a JSON pattern store with episodic recall that survives across sessions. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.
 
 ```mermaid
 graph TD
     L0["L0 - In-flight\nCurrent session drawers\nephemeral"]
     L1["L1 - Working\nCross-session memory\nBM25 K1=1.5, B=0.75"]
-    L2["L2 - Long-term\nLanceDB + HNSW index\nSemantic search"]
+    L2["L2 - Long-term\nEpisodic store\nSemantic recall"]
     L3["L3 - Shared\nCross-agent namespace\nFederated swarm reads"]
 
     L0 -->|promoted| L1 --> L2 --> L3
@@ -259,7 +256,7 @@ Before touching any file, Monomind queries **Monograph** — a SQLite-backed kno
 # → "find all callers of validateToken()"
 ```
 
-23 MCP tools. Impact analysis. Shortest-path queries. Community detection. Zero grep.
+19 default MCP tools (+27 advanced via `MONOGRAPH_MCP_ADVANCED=1`). Impact analysis. Community detection. Zero grep.
 
 ---
 
@@ -275,11 +272,11 @@ flowchart LR
     H --> I["route\nlearn\nbuild-agents"]
     H --> T["teammate-idle\ntask-completed"]
 
-    I --> DB[("LanceDB\npatterns.json")]
+    I --> DB[("patterns.json\nmemory store")]
     DB -->|next session| CE
 ```
 
-**12 background workers** run continuously: `security` · `health` · `swarm` · `learning` · `patterns` · `git` · `performance` and more.
+**15 background workers** run at session start (staleness-gated, refreshed when older than 6 hours): `security` · `health` · `swarm` · `learning` · `patterns` · `git` · `performance` and more.
 
 ---
 
@@ -341,7 +338,7 @@ Everything runs from inside Claude Code via slash commands. Here's the highlight
 | Package | npm | Purpose |
 |---|---|---|
 | `monomind` | [![npm](https://img.shields.io/npm/v/monomind?style=flat-square&color=00D2AA)](https://www.npmjs.com/package/monomind) | Umbrella — **install this one** |
-| `@monoes/monomindcli` | [![npm](https://img.shields.io/npm/v/@monoes/monomindcli?style=flat-square&color=4F46E5)](https://www.npmjs.com/package/@monoes/monomindcli) | CLI engine (41 commands) |
+| `@monoes/monomindcli` | [![npm](https://img.shields.io/npm/v/@monoes/monomindcli?style=flat-square&color=4F46E5)](https://www.npmjs.com/package/@monoes/monomindcli) | CLI engine (31 commands) |
 | `monofence-ai` | [![npm](https://img.shields.io/npm/v/monofence-ai?style=flat-square&color=EF4444)](https://www.npmjs.com/package/monofence-ai) | AI manipulation defence |
 | `@monoes/monograph` | [![npm](https://img.shields.io/npm/v/@monoes/monograph?style=flat-square&color=F59E0B)](https://www.npmjs.com/package/@monoes/monograph) | Code knowledge graph |
 
@@ -353,15 +350,15 @@ Everything runs from inside Claude Code via slash commands. Here's the highlight
 graph TD
     CC["Claude Code"]
     MCP["MCP Server\nmonomind mcp start"]
-    D["Background Daemon\n12 workers"]
+    D["Background Workers\n(@monomind/hooks, in-process)"]
 
-    CC <-->|"23 tools: monograph, memory, swarm"| MCP
+    CC <-->|"MCP tools: monograph, memory, swarm"| MCP
     MCP <--> D
 
-    D --> ADB[("LanceDB\nSQLite + HNSW")]
+    D --> ADB[("Memory store\npatterns + episodes")]
     D --> MG[("Monograph\ncode graph")]
     D --> HK["Hooks\n22 event types"]
-    D --> SW["Swarm\n6 topologies\n5 consensus algos"]
+    D --> SW["Swarm\n4 topologies\n3 consensus strategies"]
 
     CC -->|"Task tool - spawns agents"| AG["Agent Swarm\narchitect, coder\ntester, reviewer\nsecurity, perf"]
     AG <-->|reads and writes| ADB
@@ -383,7 +380,6 @@ graph TD
 - 📋 [All Slash Commands](https://monoes.github.io/monomind/#slash)
 - 🐛 [Issues](https://github.com/monoes/monomind/issues)
 - 💬 [Discussions](https://github.com/monoes/monomind/discussions)
-- 📦 [Changelog v1.11](https://github.com/monoes/monomind/blob/main/CHANGELOG-v1.11.md)
 
 ---
 

package/packages/@monomind/cli/dist/src/autopilot-state.js

@@ -11,6 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { randomUUID } from 'crypto';
+import { writeJsonFileAtomic } from './utils/json-file.js';
 // ── Constants ─────────────────────────────────────────────────
 export const STATE_DIR = '.monomind/data';
 export const STATE_FILE = `${STATE_DIR}/autopilot-state.json`;
@@ -121,11 +122,9 @@ export function saveState(state) {
     if (state.history.length > MAX_HISTORY_ENTRIES) {
         state.history = state.history.slice(-MAX_HISTORY_ENTRIES);
     }
-    // Unique tmp filename — concurrent autopilot_enable/disable/reset calls
-    // must not collide on the same .tmp path.
-    const tmpFile = `${path.resolve(STATE_FILE)}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(tmpFile, JSON.stringify(state, null, 2));
-    fs.renameSync(tmpFile, path.resolve(STATE_FILE));
+    // writeJsonFileAtomic uses a pid+timestamp-suffixed tmp path internally, so
+    // concurrent autopilot_enable/disable/reset calls won't collide.
+    writeJsonFileAtomic(path.resolve(STATE_FILE), state);
 }
 export function appendLog(entry) {
     const filePath = path.resolve(LOG_FILE);

package/packages/@monomind/cli/dist/src/browser/dashboard/server.js

@@ -1,10 +1,60 @@
 import { createServer } from 'http';
-import { readFile } from 'fs/promises';
+import { readFile, readdir, writeFile, rename, mkdir } from 'fs/promises';
 import { join, dirname } from 'path';
+import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_PORT = 4242;
+// 4243: the main monomind dashboard owns 4242 — keep this server off that port
+const DEFAULT_PORT = 4243;
+const RUNS_FILE = join(homedir(), '.monomind', 'browse-runs.json');
+const MAX_PERSISTED_RUNS = 50;
+// Persist recent runs so the main dashboard's /api/workflow-runs endpoint stays live.
+// Atomic: write to a temp file, then rename over the target.
+async function persistRuns(runs) {
+    try {
+        await mkdir(dirname(RUNS_FILE), { recursive: true });
+        const tmp = RUNS_FILE + '.tmp';
+        await writeFile(tmp, JSON.stringify(runs.slice(0, MAX_PERSISTED_RUNS), null, 2), 'utf8');
+        await rename(tmp, RUNS_FILE);
+    }
+    catch {
+        // best-effort — dashboard persistence must never break a workflow run
+    }
+}
+async function readJsonSafe(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function readMetricsDir(root) {
+    const metricsDir = join(root, '.monomind', 'metrics');
+    const out = {};
+    try {
+        const files = await readdir(metricsDir);
+        await Promise.all(files.map(async (f) => {
+            if (!f.endsWith('.json') || f.startsWith('.'))
+                return;
+            out[f.replace(/\.json$/, '')] = await readJsonSafe(join(metricsDir, f));
+        }));
+    }
+    catch {
+        // metrics dir may not exist yet — workers write it at session start (or: hooks worker run <name>)
+    }
+    return out;
+}
+async function collectDashboardState(root) {
+    const [workerMetrics, swarmState, lastRoute, autoMemory] = await Promise.all([
+        readMetricsDir(root),
+        readJsonSafe(join(root, '.monomind', 'swarm', 'swarm-state.json')),
+        readJsonSafe(join(root, '.monomind', 'last-route.json')),
+        readJsonSafe(join(root, '.monomind', 'data', 'auto-memory-store.json')),
+    ]);
+    return { workerMetrics, swarmState, lastRoute, autoMemory };
+}
 let instance = null;
 export function getDashboardServer(port = DEFAULT_PORT) {
     if (instance)
@@ -30,6 +80,39 @@ export function getDashboardServer(port = DEFAULT_PORT) {
             res.end(JSON.stringify(recentRuns));
             return;
         }
+        if (req.method === 'GET' && req.url === '/api/metrics') {
+            try {
+                const { workerMetrics, swarmState, lastRoute } = await collectDashboardState(process.cwd());
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ workerMetrics, swarmState, lastRoute, ts: Date.now() }));
+            }
+            catch {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'failed to collect metrics' }));
+            }
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/api/dashboard') {
+            try {
+                const { workerMetrics, swarmState, lastRoute, autoMemory } = await collectDashboardState(process.cwd());
+                const worker_metrics = Object.keys(workerMetrics).filter((k) => workerMetrics[k] != null);
+                const summary = {
+                    worker_metrics,
+                    swarm_status: swarmState ?? null,
+                    last_route: lastRoute ?? null,
+                    pattern_count: Array.isArray(autoMemory) ? autoMemory.length : 0,
+                    memory_health: autoMemory ? 'ok' : 'unknown',
+                    ts: Date.now(),
+                };
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(summary));
+            }
+            catch {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'failed to collect dashboard summary' }));
+            }
+            return;
+        }
         if (req.method === 'POST' && req.url === '/api/mastermind/event') {
             const chunks = [];
             req.on('data', (chunk) => chunks.push(chunk));
@@ -60,9 +143,53 @@ export function getDashboardServer(port = DEFAULT_PORT) {
         ws.on('error', () => clients.delete(ws));
     });
     httpServer.listen(port);
+    // Maintain RunRecords from step events and persist run transitions to
+    // ~/.monomind/browse-runs.json so /api/workflow-runs on the main dashboard is live.
+    function trackRun(event) {
+        let run = recentRuns.find((r) => r.id === event.runId);
+        if (!run) {
+            run = {
+                id: event.runId,
+                workflowId: event.workflowId,
+                workflowName: event.workflowName,
+                status: 'running',
+                startedAt: event.timestamp,
+                itemsProcessed: 0,
+                itemsTotal: event.itemTotal ?? 0,
+            };
+            recentRuns.unshift(run);
+            if (recentRuns.length > MAX_PERSISTED_RUNS)
+                recentRuns.length = MAX_PERSISTED_RUNS;
+        }
+        if (event.itemTotal != null)
+            run.itemsTotal = event.itemTotal;
+        if (event.eventType === 'step_completed' && event.itemIndex != null) {
+            run.itemsProcessed = Math.max(run.itemsProcessed, event.itemIndex + 1);
+        }
+        if (event.eventType === 'run_completed') {
+            run.status = 'completed';
+            run.completedAt = event.timestamp;
+        }
+        else if (event.eventType === 'run_stopped') {
+            run.status = 'stopped';
+            run.completedAt = event.timestamp;
+        }
+        else if (event.eventType === 'step_failed') {
+            run.status = 'failed';
+            run.completedAt = event.timestamp;
+            if (event.error)
+                run.error = event.error;
+        }
+        // Persist on run lifecycle transitions (start/complete/stop/fail)
+        if (event.eventType === 'run_started' || event.eventType === 'run_completed' ||
+            event.eventType === 'run_stopped' || event.eventType === 'step_failed') {
+            void persistRuns(recentRuns);
+        }
+    }
     instance = {
         port,
         broadcast(event) {
+            trackRun(event);
             const msg = JSON.stringify(event);
             for (const client of clients) {
                 if (client.readyState === client.OPEN)