monomind 1.19.0 → 2.0.1

package/.claude/commands/workflows/README.md

@@ -1,65 +0,0 @@
----
-name: workflows:README
-description: Workflow skills index — run, validate, and manage multi-agent workflows using real CLI subcommands and MCP tools
----
-
-# Workflows Skills
-
-Skills for running and managing multi-agent workflows in Monomind.
-
-## Available Skills
-
-- [workflow-execute](./workflow-execute.md) — Run workflows using built-in templates
-- [workflow-create](./workflow-create.md) — Create and save custom workflow templates
-- [workflow-export](./workflow-export.md) — Manage and list workflow templates
-- [development](./development.md) — Development workflow coordination pattern
-- [research](./research.md) — Research workflow coordination pattern
-
-## Real CLI Subcommands
-
-```bash
-# Run a workflow from a template
-npx monomind workflow run -t development --task "Build auth system"
-npx monomind workflow run -t research --task "Analyze performance"
-npx monomind workflow run -f ./workflow.yaml
-
-# Validate a workflow file
-npx monomind workflow validate -f ./workflow.yaml --strict
-
-# List running/completed workflows
-npx monomind workflow list --status all --limit 10
-
-# Check workflow status
-npx monomind workflow status <workflowId>
-
-# Stop a running workflow
-npx monomind workflow stop <workflowId>
-
-# Manage templates
-npx monomind workflow template list
-npx monomind workflow template show development
-npx monomind workflow template create --name "my-workflow"
-```
-
-## Built-in Templates
-
-| Template | Stages | Agents |
-|----------|--------|--------|
-| `development` | Planning → Implementation → Testing → Review → Integration | coder, tester, reviewer |
-| `research` | Discovery → Analysis → Synthesis → Documentation | researcher, analyst |
-| `testing` | Unit → Integration → E2E → Performance | tester, coder |
-| `security-audit` | Threat Model → Static → Dynamic → Report | security-architect, auditor |
-| `code-review` | Initial → Security → Quality → Feedback | reviewer, auditor, analyst |
-| `refactoring` | Analysis → Planning → Refactor → Validation | architect, coder, reviewer |
-| `sparc` | Spec → Pseudocode → Architecture → Refinement → Completion | architect, coder, tester, reviewer |
-| `custom` | Define your own stages | configurable |
-
-## MCP Tools
-
-```javascript
-mcp__monomind__workflow_run({ template: "development", task: "Build feature", options: { parallel: true } })
-mcp__monomind__workflow_list({ status: "all", limit: 10 })
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-mcp__monomind__workflow_create({})
-mcp__monomind__workflow_template({})
-```

package/.claude/commands/workflows/development.md

@@ -1,86 +0,0 @@
----
-name: workflows:development
-description: Development workflow coordination pattern — hierarchical swarm for structured implementation tasks using real MCP tools and npx monomind workflow run -t development
----
-
-# Development Workflow Coordination
-
-Structure multi-agent development tasks using the built-in development template for maximum efficiency.
-
-## How to Invoke
-
-```
-Skill("workflows:development")
-```
-
----
-
-## Quick Start
-
-```bash
-# Run the built-in development workflow
-npx monomind workflow run -t development --task "Build REST API with auth"
-
-# Preview stages without executing
-npx monomind workflow run -t development --dry-run
-
-# Show template details (stages, agents, duration)
-npx monomind workflow template show development
-```
-
-## Stages
-
-The `development` template runs these stages:
-1. **Planning** — Requirements, architecture decisions
-2. **Implementation** — Code writing
-3. **Testing** — Unit and integration tests
-4. **Review** — Code quality and security check
-5. **Integration** — Connect all pieces
-
-Agents: `coder`, `tester`, `reviewer` (in parallel where possible)
-
-## MCP Coordination
-
-For custom development coordination via MCP:
-
-```javascript
-// Initialize hierarchical swarm for development
-mcp__monomind__swarm_init({
-  topology: "hierarchical",
-  maxAgents: 8,
-  strategy: "specialized"
-})
-
-// Run the development workflow
-mcp__monomind__workflow_run({
-  template: "development",
-  task: "Build REST API with authentication",
-  options: { parallel: true, maxAgents: 6 }
-})
-
-// Check progress
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-
-// Store findings for future sessions
-mcp__monomind__memory_store({
-  key: "dev-pattern-rest-api",
-  value: "JWT auth + Express + Zod validation worked well",
-  namespace: "patterns"
-})
-```
-
-## What Claude Code Actually Does
-
-Claude Code handles all execution via native tools:
-1. **Read/Write/Edit** tools — create and modify files
-2. **Bash** tool — run tests, builds, type checks
-3. **TodoWrite** tool — track implementation steps
-4. **Task** tool — spawn parallel agent workers
-
-The workflow template defines the coordination strategy; Claude Code does the actual work.
-
-## Related Skills
-
-- `workflows:workflow-execute` — Full workflow run reference
-- `swarm:development` — Direct swarm-based development coordination
-- `swarm:swarm-strategies` — Strategy selection guide

package/.claude/commands/workflows/research.md

@@ -1,89 +0,0 @@
----
-name: workflows:research
-description: Research workflow coordination pattern — mesh swarm for comprehensive exploration using real MCP tools and npx monomind workflow run -t research
----
-
-# Research Workflow Coordination
-
-Coordinate multi-agent research activities for comprehensive, systematic exploration.
-
-## How to Invoke
-
-```
-Skill("workflows:research")
-```
-
----
-
-## Quick Start
-
-```bash
-# Run the built-in research workflow
-npx monomind workflow run -t research --task "Analyze modern web framework performance"
-
-# Preview stages without executing
-npx monomind workflow run -t research --dry-run
-
-# Show template details
-npx monomind workflow template show research
-```
-
-## Stages
-
-The `research` template runs these stages:
-1. **Discovery** — Identify sources, gather raw information
-2. **Analysis** — Evaluate and compare findings
-3. **Synthesis** — Combine into coherent conclusions
-4. **Documentation** — Write up findings
-
-Agents: `researcher`, `analyst` (mesh topology for broad coverage)
-
-## MCP Coordination
-
-For custom research coordination via MCP:
-
-```javascript
-// Initialize mesh swarm for broad exploration
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 5,
-  strategy: "balanced"
-})
-
-// Run the research workflow
-mcp__monomind__workflow_run({
-  template: "research",
-  task: "Research modern web frameworks performance",
-  options: { parallel: true, maxAgents: 4 }
-})
-
-// Store research findings in memory
-mcp__monomind__memory_store({
-  key: "research-web-frameworks-2026",
-  value: "React/Next.js leads for SSR; Astro for static; Svelte for performance",
-  namespace: "research"
-})
-
-// Search past research before starting
-mcp__monomind__memory_search({
-  query: "web framework performance analysis",
-  namespace: "research",
-  limit: 5
-})
-```
-
-## What Claude Code Actually Does
-
-1. **WebSearch** tool — finds relevant resources
-2. **Read** tool — analyzes documentation and code
-3. **Task** tool — spawns parallel research agents for different angles
-4. Synthesizes findings in the conversation
-5. Stores insights in memory for future sessions
-
-The workflow template coordinates the research strategy; Claude Code does the actual searching and reading.
-
-## Related Skills
-
-- `workflows:workflow-execute` — Full workflow run reference
-- `swarm:research` — Direct swarm-based research coordination
-- `memory:memory-search` — Search past research findings

package/.claude/commands/workflows/workflow-create.md

@@ -1,84 +0,0 @@
----
-name: workflows:workflow-create
-description: Create and save custom workflow templates using npx monomind workflow template create — save successful workflows for reuse
----
-
-# Workflow Create
-
-Create and save custom workflow templates for reuse.
-
-## How to Invoke
-
-```
-Skill("workflows:workflow-create")
-```
-
----
-
-## CLI Reference
-
-```bash
-# Create a template from a workflow ID
-npx monomind workflow template create --name "my-api-workflow" --workflow wf-abc123
-
-# Create a template from a workflow file
-npx monomind workflow template create --name "deploy-workflow" --file ./workflow.yaml
-
-# List existing templates
-npx monomind workflow template list
-
-# Show a specific template's stages and agents
-npx monomind workflow template show development
-npx monomind workflow template show sparc
-```
-
-## Template Create Flags
-
-| Flag | Short | Description |
-|------|-------|-------------|
-| `--name` | `-n` | Template name (required) |
-| `--workflow` | `-w` | Workflow ID to save as template |
-| `--file` | `-f` | Workflow file to save as template |
-
-## MCP Tools
-
-```javascript
-// Create a workflow definition
-mcp__monomind__workflow_create({
-  name: "my-workflow",
-  template: "development",
-  task: "Build auth system"
-})
-
-// List available templates
-mcp__monomind__workflow_template({})
-
-// Execute workflow from template
-mcp__monomind__workflow_run({
-  template: "my-workflow",
-  task: "Build feature X"
-})
-```
-
-## Workflow
-
-1. Run a workflow that works well:
-   ```bash
-   npx monomind workflow run -t development --task "Build auth"
-   # Note the workflowId in the output
-   ```
-
-2. Save it as a reusable template:
-   ```bash
-   npx monomind workflow template create --name "auth-workflow" --workflow <workflowId>
-   ```
-
-3. Reuse it:
-   ```bash
-   npx monomind workflow run -t auth-workflow --task "New auth task"
-   ```
-
-## Related Skills
-
-- `workflows:workflow-execute` — Run workflows from templates
-- `workflows:workflow-export` — Browse and manage templates

package/.claude/commands/workflows/workflow-execute.md

@@ -1,103 +0,0 @@
----
-name: workflows:workflow-execute
-description: Run multi-agent workflows using built-in templates (development, research, testing, sparc, security-audit, etc.) via real npx monomind workflow run CLI
----
-
-# Workflow Execute
-
-Run multi-agent workflows using built-in templates or custom workflow files.
-
-## How to Invoke
-
-```
-Skill("workflows:workflow-execute")
-```
-
----
-
-## CLI Reference
-
-```bash
-# Run a built-in template
-npx monomind workflow run -t development --task "Build REST API with auth"
-npx monomind workflow run -t research --task "Analyze performance bottlenecks"
-npx monomind workflow run -t testing
-npx monomind workflow run -t security-audit
-npx monomind workflow run -t sparc --task "New payment module"
-
-# Run from a workflow file
-npx monomind workflow run -f ./workflow.yaml
-npx monomind workflow run -f ./workflow.json
-
-# Validate without executing
-npx monomind workflow run -t development --dry-run
-```
-
-## All Flags
-
-| Flag | Short | Default | Description |
-|------|-------|---------|-------------|
-| `--template` | `-t` | — | Built-in template name |
-| `--file` | `-f` | — | Workflow definition file (YAML/JSON) |
-| `--task` | — | — | Task description passed to the workflow |
-| `--parallel` | `-p` | `true` | Enable parallel agent execution |
-| `--max-agents` | `-m` | `5` | Maximum agents to spawn |
-| `--timeout` | — | `30` | Timeout in minutes |
-| `--dry-run` | `-d` | `false` | Validate without executing |
-
-## Built-in Templates
-
-| Template | Stages | Agent Types |
-|----------|--------|-------------|
-| `development` | Planning → Implementation → Testing → Review → Integration | coder, tester, reviewer |
-| `research` | Discovery → Analysis → Synthesis → Documentation | researcher, analyst |
-| `testing` | Unit → Integration → E2E → Performance | tester, coder |
-| `security-audit` | Threat Model → Static → Dynamic → Report | security-architect, auditor |
-| `code-review` | Initial → Security → Quality → Feedback | reviewer, auditor, analyst |
-| `refactoring` | Analysis → Planning → Refactor → Validation | architect, coder, reviewer |
-| `sparc` | Spec → Pseudocode → Architecture → Refinement → Completion | architect, coder, tester, reviewer |
-| `custom` | Define your own | configurable |
-
-## MCP Tools
-
-```javascript
-// Run a workflow
-mcp__monomind__workflow_run({
-  template: "development",
-  task: "Build REST API with auth",
-  options: {
-    parallel: true,
-    maxAgents: 6,
-    timeout: 30,
-    dryRun: false
-  }
-})
-
-// Check workflow status after launch
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-
-// List all workflows
-mcp__monomind__workflow_list({ status: "running", limit: 10 })
-
-// Stop a running workflow
-mcp__monomind__workflow_cancel({ workflowId: "wf-123" })
-```
-
-## After Launch
-
-Track progress:
-
-```bash
-# Check status by ID (shown after run)
-npx monomind workflow status <workflowId>
-
-# List all running workflows
-npx monomind workflow list --status running
-```
-
-## Related Skills
-
-- `workflows:workflow-create` — Save a custom workflow template
-- `workflows:development` — Development workflow coordination pattern
-- `workflows:research` — Research workflow coordination pattern
-- `swarm:swarm` — Direct swarm init for custom coordination

package/.claude/commands/workflows/workflow-export.md

@@ -1,90 +0,0 @@
----
-name: workflows:workflow-export
-description: Browse, inspect, and manage workflow templates — list built-in templates, show template details and stages, validate workflow files
----
-
-# Workflow Templates
-
-Browse and manage workflow templates — inspect built-in templates and validate custom workflow files.
-
-## How to Invoke
-
-```
-Skill("workflows:workflow-export")
-```
-
----
-
-## CLI Reference
-
-```bash
-# List all available templates
-npx monomind workflow template list
-
-# Show details for a specific template (stages, agents, estimated duration)
-npx monomind workflow template show development
-npx monomind workflow template show sparc
-npx monomind workflow template show security-audit
-
-# Validate a custom workflow file
-npx monomind workflow validate -f ./workflow.yaml
-npx monomind workflow validate -f ./workflow.json --strict
-
-# List past workflow runs
-npx monomind workflow list --status completed --limit 20
-npx monomind workflow list --status all
-```
-
-## Built-in Templates Reference
-
-| Template | Stages | Estimated Duration |
-|----------|--------|--------------------|
-| `development` | Planning → Implementation → Testing → Review → Integration | 15-30 min |
-| `research` | Discovery → Analysis → Synthesis → Documentation | 10-20 min |
-| `testing` | Unit → Integration → E2E → Performance | 5-15 min |
-| `security-audit` | Threat Model → Static → Dynamic → Report | 20-40 min |
-| `code-review` | Initial → Security → Quality → Feedback | 10-25 min |
-| `refactoring` | Analysis → Planning → Refactor → Validation | 15-35 min |
-| `sparc` | Spec → Pseudocode → Architecture → Refinement → Completion | 25-45 min |
-| `custom` | Define your own stages | varies |
-
-## MCP Tools
-
-```javascript
-// List templates
-mcp__monomind__workflow_template({})
-
-// List past workflow runs
-mcp__monomind__workflow_list({ status: "completed", limit: 20 })
-
-// Get status of a specific run
-mcp__monomind__workflow_status({ workflowId: "wf-123" })
-```
-
-## Workflow File Format
-
-To create a custom workflow file for use with `workflow run -f`:
-
-```yaml
-name: my-workflow
-stages:
-  - name: Planning
-    agents: [architect]
-  - name: Implementation
-    agents: [coder]
-  - name: Testing
-    agents: [tester]
-  - name: Review
-    agents: [reviewer]
-```
-
-Validate before running:
-
-```bash
-npx monomind workflow validate -f ./my-workflow.yaml --strict
-```
-
-## Related Skills
-
-- `workflows:workflow-execute` — Run workflows from templates
-- `workflows:workflow-create` — Save a custom workflow as a template

package/.claude/helpers/control-start.cjs

@@ -1,184 +0,0 @@
-#!/usr/bin/env node
-/**
- * Monomind Control Start
- * Ensures the Monomind Neural Control Room (web UI) is running.
- * Called from SessionStart hook — exits immediately after spawning.
- *
- * Status written to: .monomind/control.json
- * Port: 4242 (default, auto-increments on collision)
- */
-
-/* eslint-disable @typescript-eslint/no-var-requires */
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-
-const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const STATUS_FILE = path.join(CWD, '.monomind', 'control.json');
-// Overridable for test isolation — production always uses the 4242 default.
-const DEFAULT_PORT = Number(process.env.MONOMIND_CONTROL_PORT) || 4242;
-
-function readStatus() {
-  try {
-    if (fs.existsSync(STATUS_FILE)) {
-      // Guard against OOM: control.json should never exceed 4 KiB
-      const stat = fs.statSync(STATUS_FILE);
-      if (stat.size > 4 * 1024) return null;
-      return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf-8'));
-    }
-  } catch { /* ignore */ }
-  return null;
-}
-
-function isPidAlive(pid) {
-  // Validate pid is a positive integer — negative or zero pid would signal the process group
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function writeStatus(pid, port) {
-  try {
-    fs.mkdirSync(path.dirname(STATUS_FILE), { recursive: true });
-    fs.writeFileSync(STATUS_FILE, JSON.stringify({
-      pid,
-      port,
-      url: `http://localhost:${port}`,
-      startedAt: new Date().toISOString(),
-    }), 'utf-8');
-  } catch { /* ignore */ }
-}
-
-function findCliPath() {
-  // Try local monorepo server.mjs first (direct — no CLI subcommand needed)
-  const serverMjs = path.join(CWD, 'packages', '@monomind', 'cli', 'dist', 'src', 'ui', 'server.mjs');
-  if (fs.existsSync(serverMjs)) return { cmd: process.execPath, args: [serverMjs], usePort: true };
-
-  // Try local CLI bin as fallback
-  const local = path.join(CWD, 'packages', '@monomind', 'cli', 'bin', 'cli.js');
-  if (fs.existsSync(local)) return { cmd: process.execPath, args: [local], usePort: false };
-
-  // Try global npm install paths for both package names
-  // npm root -g is slow; probe known conventional paths instead
-  const globalCandidates = [];
-  try {
-    const { execSync } = require('child_process');
-    const npmRoot = execSync('npm root -g', { timeout: 3000, encoding: 'utf-8' }).trim();
-    if (npmRoot) {
-      globalCandidates.push(
-        path.join(npmRoot, 'monomind', 'packages', '@monomind', 'cli', 'dist', 'src', 'ui', 'server.mjs'),
-        path.join(npmRoot, '@monoes', 'monomindcli', 'dist', 'src', 'ui', 'server.mjs'),
-        path.join(npmRoot, 'monomind', 'packages', '@monomind', 'cli', 'bin', 'cli.js'),
-        path.join(npmRoot, '@monoes', 'monomindcli', 'bin', 'cli.js'),
-      );
-    }
-  } catch { /* npm root -g failed — skip */ }
-
-  for (const candidate of globalCandidates) {
-    if (fs.existsSync(candidate)) {
-      const usePort = candidate.endsWith('server.mjs');
-      return { cmd: process.execPath, args: [candidate], usePort };
-    }
-  }
-
-  // Try npx monomind as last resort
-  return { cmd: 'npx', args: ['monomind@latest'], usePort: false };
-}
-
-function probeStatus(p) {
-  const http = require('http');
-  return new Promise((resolve) => {
-    const req = http.get({ hostname: 'localhost', port: p, path: '/api/status', timeout: 1000 }, (res) => {
-      let body = '';
-      res.on('data', (c) => { if (body.length < 64 * 1024) body += c; });
-      res.on('end', () => {
-        if (res.statusCode >= 500) return resolve(null);
-        try { resolve(JSON.parse(body)); } catch { resolve({}); }
-      });
-    });
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
-  });
-}
-
-async function main() {
-  // If already running, do nothing
-  const status = readStatus();
-  if (status && status.pid && isPidAlive(status.pid)) {
-    process.stdout.write(`[control] already running on port ${status.port} (pid ${status.pid})\n`);
-    process.exit(0);
-  }
-
-  // Adopt an already-listening server (e.g. started manually or by another session)
-  // instead of spawning a duplicate that would bind port+1 and clobber control.json.
-  for (let delta = 0; delta <= 10; delta++) {
-    const p = DEFAULT_PORT + delta;
-    const live = await probeStatus(p);
-    if (live) {
-      writeStatus(live.pid || 0, p);
-      process.stdout.write(`[control] adopted running server on port ${p} (pid ${live.pid || 'unknown'})\n`);
-      process.exit(0);
-    }
-  }
-
-  const { cmd, args, usePort } = findCliPath();
-  // server.mjs accepts port as second positional arg; CLI uses 'ui --no-open --port N'
-  const allArgs = usePort
-    ? [...args, String(DEFAULT_PORT)]
-    : [...args, 'ui', '--no-open', '--port', String(DEFAULT_PORT)];
-
-  const child = spawn(cmd, allArgs, {
-    detached: true,
-    stdio: 'ignore',
-    cwd: CWD,
-    env: { ...process.env, CLAUDE_PROJECT_DIR: CWD },
-  });
-
-  child.unref();
-
-  // Write optimistic status with DEFAULT_PORT immediately so dependent scripts
-  // (hooks, boss agents) have something to read while the server starts up.
-  writeStatus(child.pid, DEFAULT_PORT);
-  process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${child.pid})\n`);
-
-  // If port 4242 was in use, server.mjs auto-increments (up to +10).
-  // Poll a few ports to find where it actually bound and update control.json.
-  const http = require('http');
-  function probePort(p) {
-    return new Promise((resolve) => {
-      const req = http.get({ hostname: 'localhost', port: p, path: '/api/status', timeout: 1000 }, (res) => {
-        res.resume();
-        resolve(res.statusCode < 500);
-      });
-      req.on('error', () => resolve(false));
-      req.on('timeout', () => { req.destroy(); resolve(false); });
-    });
-  }
-
-  // Give the server up to ~3 s to start, then confirm the actual port.
-  async function confirmPort() {
-    for (let attempt = 0; attempt < 6; attempt++) {
-      await new Promise(r => setTimeout(r, 500));
-      for (let delta = 0; delta <= 10; delta++) {
-        const p = DEFAULT_PORT + delta;
-        if (await probePort(p)) {
-          if (p !== DEFAULT_PORT) {
-            writeStatus(child.pid, p);
-            process.stdout.write(`[control] server bound to port ${p} (updated control.json)\n`);
-          }
-          return;
-        }
-      }
-    }
-    // Server didn't respond in time — leave control.json as-is (best-effort)
-    process.stdout.write('[control] server did not respond within 3 s — control.json may have wrong port\n');
-  }
-
-  confirmPort().catch(() => {}).finally(() => process.exit(0));
-}
-
-main().catch(() => process.exit(0));