monomind 1.19.0 → 2.0.0

package/packages/@monomind/cli/.claude/helpers/skill-registry.json

@@ -36,21 +36,6 @@
       "category": "implementation",
       "primaryAgent": "coder"
     },
-    {
-      "skill": "sparc:tdd",
-      "invoke": "Skill(\"sparc:tdd\")",
-      "description": "Test-driven development — write failing tests first, then implementation",
-      "keywords": [
-        "tdd",
-        "test driven",
-        "tests first",
-        "unit test",
-        "spec",
-        "red green refactor"
-      ],
-      "category": "testing",
-      "primaryAgent": "tester"
-    },
     {
       "skill": "agent-browser-testing",
       "invoke": "Skill(\"agent-browser-testing\")",
@@ -106,166 +91,6 @@
       "category": "testing",
       "primaryAgent": "agent-browser-testing"
     },
-    {
-      "skill": "sparc:architect",
-      "invoke": "Skill(\"sparc:architect\")",
-      "description": "System architecture design — patterns, DDD, scalability, API design",
-      "keywords": [
-        "architect",
-        "design",
-        "system design",
-        "structure",
-        "domain",
-        "ddd",
-        "patterns",
-        "scalability"
-      ],
-      "category": "architecture",
-      "primaryAgent": "architect"
-    },
-    {
-      "skill": "sparc:security-review",
-      "invoke": "Skill(\"sparc:security-review\")",
-      "description": "Security analysis — vulnerabilities, CVEs, threat modeling, input validation",
-      "keywords": [
-        "security",
-        "vulnerability",
-        "cve",
-        "threat",
-        "injection",
-        "xss",
-        "auth",
-        "exploit"
-      ],
-      "category": "security",
-      "primaryAgent": "reviewer"
-    },
-    {
-      "skill": "sparc:debugger",
-      "invoke": "Skill(\"sparc:debugger\")",
-      "description": "Systematic debugging — root cause analysis, error tracing, fix verification",
-      "keywords": [
-        "debug",
-        "bug",
-        "error",
-        "crash",
-        "fix",
-        "broken",
-        "not working",
-        "exception",
-        "trace"
-      ],
-      "category": "debugging",
-      "primaryAgent": "coder"
-    },
-    {
-      "skill": "sparc:optimizer",
-      "invoke": "Skill(\"sparc:optimizer\")",
-      "description": "Performance optimization — profiling, bottlenecks, memory, speed improvements",
-      "keywords": [
-        "optimize",
-        "performance",
-        "slow",
-        "speed",
-        "memory",
-        "bottleneck",
-        "profile",
-        "latency"
-      ],
-      "category": "performance",
-      "primaryAgent": "coder"
-    },
-    {
-      "skill": "sparc:devops",
-      "invoke": "Skill(\"sparc:devops\")",
-      "description": "DevOps and deployment — CI/CD, Docker, infrastructure, pipelines",
-      "keywords": [
-        "deploy",
-        "ci",
-        "cd",
-        "docker",
-        "pipeline",
-        "infrastructure",
-        "kubernetes",
-        "build",
-        "release"
-      ],
-      "category": "devops",
-      "primaryAgent": "devops"
-    },
-    {
-      "skill": "sparc:documenter",
-      "invoke": "Skill(\"sparc:documenter\")",
-      "description": "Documentation generation — READMEs, API docs, architecture docs, inline comments",
-      "keywords": [
-        "document",
-        "docs",
-        "readme",
-        "api docs",
-        "explain",
-        "write documentation",
-        "comment"
-      ],
-      "category": "documentation",
-      "primaryAgent": "researcher"
-    },
-    {
-      "skill": "sparc:researcher",
-      "invoke": "Skill(\"sparc:researcher\")",
-      "description": "Research and analysis — investigate, explore, gather information, summarize",
-      "keywords": [
-        "research",
-        "find",
-        "search",
-        "investigate",
-        "explore",
-        "analyse",
-        "understand",
-        "how does",
-        "what kind",
-        "what is",
-        "list",
-        "show me",
-        "available",
-        "skills",
-        "agents",
-        "capabilities"
-      ],
-      "category": "research",
-      "primaryAgent": "researcher"
-    },
-    {
-      "skill": "sparc:spec-pseudocode",
-      "invoke": "Skill(\"sparc:spec-pseudocode\")",
-      "description": "Specification and pseudocode — clarify requirements, write specs, plan logic",
-      "keywords": [
-        "spec",
-        "specification",
-        "requirements",
-        "pseudocode",
-        "plan",
-        "design logic",
-        "clarify"
-      ],
-      "category": "planning",
-      "primaryAgent": "architect"
-    },
-    {
-      "skill": "sparc:refactor",
-      "invoke": "Skill(\"sparc:coder\")",
-      "description": "Refactoring — clean up code, extract functions, improve structure without changing behavior",
-      "keywords": [
-        "refactor",
-        "clean up",
-        "restructure",
-        "extract",
-        "simplify",
-        "technical debt",
-        "improve code"
-      ],
-      "category": "implementation",
-      "primaryAgent": "coder"
-    },
     {
       "skill": "github:code-review",
       "invoke": "Skill(\"github:code-review\")",
@@ -772,20 +597,6 @@
       "category": "core",
       "primaryAgent": "coder"
     },
-    {
-      "skill": "sparc-methodology",
-      "invoke": "Skill(\"sparc-methodology\")",
-      "description": "SPARC development methodology — Specification, Pseudocode, Architecture, Refinement, Completion",
-      "keywords": [
-        "sparc",
-        "methodology",
-        "architecture",
-        "specification",
-        "development"
-      ],
-      "category": "core",
-      "primaryAgent": "architect"
-    },
     {
       "skill": "specialagent",
       "invoke": "Skill(\"specialagent\")",

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

@@ -0,0 +1,60 @@
+---
+name: github-toolkit
+description: >
+  GitHub workflow guidance for monomind projects — issues, PRs, releases,
+  repo structure, and multi-package sync. Trigger on "open a PR", "manage
+  issues", "cut a release", "sync packages", or any GitHub Actions/repo
+  automation request. All GitHub operations use the `gh` CLI plus monomind's
+  MCP GitHub tools — there is no `monomind github` CLI command group.
+---
+
+# GitHub Toolkit
+
+Guidance for GitHub-integrated workflows in monomind projects. All GitHub
+operations go through the `gh` CLI directly (for PRs, issues, releases) or
+through monomind's MCP GitHub tools when running inside a swarm.
+
+## Core operations
+
+- **Issues** — triage, label, and track via `gh issue` or `mcp__monomind__github_issue_track`.
+  See `.claude/commands/github/issue-tracker.md`.
+- **Pull requests** — create, review, and merge via `gh pr` or `mcp__monomind__github_pr_manage`.
+  See `.claude/commands/github/pr-manager.md`.
+- **Releases** — version bump, changelog, tag, and publish coordination.
+  See `.claude/commands/github/release-manager.md`.
+- **Repo structure** — multi-repo layout and package boundary decisions.
+  See `.claude/commands/github/repo-architect.md`.
+- **Multi-package sync** — version alignment and dependency sync across a monorepo.
+  See `.claude/commands/github/sync-coordinator.md`.
+- **Integration modes overview** — which mode to use for which workflow.
+  See `.claude/commands/github/github-modes.md`.
+
+## Quick reference
+
+```bash
+# Issues
+gh issue list --state open
+gh issue create --title "..." --body "..."
+
+# Pull requests
+gh pr create --title "..." --body "..."
+gh pr view <number> --json reviews,statusCheckRollup
+
+# Releases
+gh release create v1.2.3 --generate-notes
+```
+
+## MCP tools (when running inside a swarm)
+
+```javascript
+mcp__monomind__github_pr_manage({ action: "review", pr: 123 })
+mcp__monomind__github_issue_track({ action: "list", state: "open" })
+mcp__monomind__github_metrics({ repo: "owner/repo" })
+```
+
+## When to reach for the full docs
+
+Each linked command file under `.claude/commands/github/` has the complete
+option/flag reference and swarm-coordination patterns for its area — read
+the relevant one before doing multi-step GitHub automation (e.g. spawning
+a `pr-manager` or `release-manager` agent).

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

@@ -234,20 +234,6 @@ Task("Database Architect", "Design PostgreSQL schema...", "code-analyzer")
 Task("Test Engineer", "Create Jest test suite...", "tester")
 ```
 
-### With SPARC Methodology
-
-```bash
-# Use hive mind for SPARC workflow
-npx monomind sparc tdd "User authentication" --hive-mind
-
-# Spawns:
-# - Specification agent
-# - Architecture agent
-# - Coder agents
-# - Tester agents
-# - Reviewer agents
-```
-
 ### With GitHub Integration
 
 ```bash
@@ -691,7 +677,6 @@ npx monomind hive-mind spawn "Review PR #456" \
 - `swarm-orchestration`: Basic swarm coordination
 - `consensus-mechanisms`: Distributed decision making
 - `memory-systems`: Advanced memory management
-- `sparc-methodology`: Structured development workflow
 - `github-integration`: Repository coordination
 
 ## References

package/packages/@monomind/cli/.claude/skills/hooks-automation/SKILL.md

@@ -1185,7 +1185,6 @@ npx monomind hook validate-config
 ### Integration with Other Skills
 
 This skill works seamlessly with:
-- **SPARC Methodology** - Hooks enhance SPARC workflows
 - **Pair Programming** - Automated quality in pairing sessions
 - **Verification Quality** - Truth-score validation in hooks
 - **GitHub Workflows** - Git integration for commits/PRs

package/packages/@monomind/cli/.claude/skills/mastermind-skills/_protocol.md

@@ -396,7 +396,7 @@ SUCCESS CRITERIA:
 - [ ] [Concrete checkable item 1]
 - [ ] [Concrete checkable item 2]
 
-AGENT: [agent slug, e.g. backend-dev | sparc-coder | frontend-dev]
+AGENT: [agent slug, e.g. backend-dev | frontend-dev]
 SWARM: [topology agent-count consensus, e.g. \"hierarchical 4 raft\"]
 
 DEPENDENCIES: [task IDs, or \"none\"]

package/packages/@monomind/cli/.claude/skills/mastermind-skills/build.md

@@ -106,7 +106,7 @@ SCOPE: [exact file paths in scope]
 CONSTRAINTS: [must-not-break items, existing APIs to preserve]
 SUCCESS CRITERIA:
 - [ ] [checkable item]
-AGENT: [backend-dev | frontend-dev | tester | reviewer | sparc-coder]
+AGENT: [backend-dev | frontend-dev | tester | reviewer]
 SWARM: hierarchical 4 raft
 DEPENDENCIES: [task IDs or \"none\"]
 OUTPUT FORMAT: unified output schema"
@@ -118,7 +118,6 @@ Spawn one Task agent per task (all in parallel where dependencies allow):
 - Frontend tasks: subagent_type "frontend-dev"
 - Testing tasks: subagent_type "tester"
 - Code review: subagent_type "reviewer"
-- TDD/SPARC work: subagent_type "sparc-coder"
 
 Also run /mastermind:do --board <board_id> to track execution.
 

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

@@ -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
 ```
 
@@ -353,7 +350,7 @@ 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
     MCP <--> D

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,44 @@
 import { createServer } from 'http';
-import { readFile } from 'fs/promises';
+import { readFile, readdir } from 'fs/promises';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_PORT = 4242;
+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 — daemon hasn't run
+    }
+    return out;
+}
+async function collectDashboardState(root) {
+    const [daemonMetrics, swarmState, hiveMindState, lastRoute, autoMemory] = await Promise.all([
+        readMetricsDir(root),
+        readJsonSafe(join(root, '.monomind', 'swarm', 'swarm-state.json')),
+        readJsonSafe(join(root, '.monomind', 'hive-mind', 'state.json')),
+        readJsonSafe(join(root, '.monomind', 'last-route.json')),
+        readJsonSafe(join(root, '.monomind', 'data', 'auto-memory-store.json')),
+    ]);
+    return { daemonMetrics, swarmState, hiveMindState, lastRoute, autoMemory };
+}
 let instance = null;
 export function getDashboardServer(port = DEFAULT_PORT) {
     if (instance)
@@ -30,6 +64,40 @@ export function getDashboardServer(port = DEFAULT_PORT) {
             res.end(JSON.stringify(recentRuns));
             return;
         }
+        if (req.method === 'GET' && req.url === '/api/metrics') {
+            try {
+                const { daemonMetrics, swarmState, hiveMindState, lastRoute } = await collectDashboardState(process.cwd());
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ daemonMetrics, swarmState, hiveMindState, 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 { daemonMetrics, swarmState, hiveMindState, lastRoute, autoMemory } = await collectDashboardState(process.cwd());
+                const daemon_workers = Object.keys(daemonMetrics).filter((k) => daemonMetrics[k] != null);
+                const summary = {
+                    daemon_workers,
+                    swarm_status: swarmState ?? null,
+                    hive_mind_decisions: hiveMindState?.decisions ?? hiveMindState ?? 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));