moflo 4.8.10 → 4.8.12

package/.claude/commands/training/specialization.md

@@ -1,63 +1,63 @@
-# Agent Specialization Training
-
-## Purpose
-Train agents to become experts in specific domains for better performance.
-
-## Specialization Areas
-
-### 1. By File Type
-Agents automatically specialize based on file extensions:
-- **.js/.ts**: Modern JavaScript patterns
-- **.py**: Pythonic idioms
-- **.go**: Go best practices
-- **.rs**: Rust safety patterns
-
-### 2. By Task Type
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {
-  "type": "coder",
-  "capabilities": ["react", "typescript", "testing"],
-  "name": "React Specialist"
-}
-```
-
-### 3. Training Process
-The system trains through:
-- Successful edit operations
-- Code review patterns
-- Error fix approaches
-- Performance optimizations
-
-### 4. Specialization Benefits
-```
-# Check agent specializations
-Tool: mcp__claude-flow__agent_list
-Parameters: {"swarmId": "current"}
-
-Result shows expertise levels:
-{
-  "agents": [
-    {
-      "id": "coder-123",
-      "specializations": {
-        "javascript": 0.95,
-        "react": 0.88,
-        "testing": 0.82
-      }
-    }
-  ]
-}
-```
-
-## Continuous Improvement
-Agents share learnings across sessions for cumulative expertise!
-
-## CLI Usage
-```bash
-# Train agent specialization via CLI
-npx claude-flow train agent --type coder --capabilities "react,typescript"
-
-# Check specializations
-npx claude-flow agent list --specializations
+# Agent Specialization Training
+
+## Purpose
+Train agents to become experts in specific domains for better performance.
+
+## Specialization Areas
+
+### 1. By File Type
+Agents automatically specialize based on file extensions:
+- **.js/.ts**: Modern JavaScript patterns
+- **.py**: Pythonic idioms
+- **.go**: Go best practices
+- **.rs**: Rust safety patterns
+
+### 2. By Task Type
+```
+Tool: mcp__moflo__agent_spawn
+Parameters: {
+  "type": "coder",
+  "capabilities": ["react", "typescript", "testing"],
+  "name": "React Specialist"
+}
+```
+
+### 3. Training Process
+The system trains through:
+- Successful edit operations
+- Code review patterns
+- Error fix approaches
+- Performance optimizations
+
+### 4. Specialization Benefits
+```
+# Check agent specializations
+Tool: mcp__moflo__agent_list
+Parameters: {"swarmId": "current"}
+
+Result shows expertise levels:
+{
+  "agents": [
+    {
+      "id": "coder-123",
+      "specializations": {
+        "javascript": 0.95,
+        "react": 0.88,
+        "testing": 0.82
+      }
+    }
+  ]
+}
+```
+
+## Continuous Improvement
+Agents share learnings across sessions for cumulative expertise!
+
+## CLI Usage
+```bash
+# Train agent specialization via CLI
+npx claude-flow train agent --type coder --capabilities "react,typescript"
+
+# Check specializations
+npx claude-flow agent list --specializations
 ```

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

@@ -1,78 +1,78 @@
-# Development Workflow Coordination
-
-## Purpose
-Structure Claude Code's approach to complex development tasks for maximum efficiency.
-
-## Step-by-Step Coordination
-
-### 1. Initialize Development Framework
-```
-Tool: mcp__claude-flow__swarm_init
-Parameters: {"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}
-```
-Creates hierarchical structure for organized, top-down development.
-
-### 2. Define Development Perspectives
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {
-  "type": "architect",
-  "name": "System Design",
-  "capabilities": ["api-design", "database-schema"]
-}
-```
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {
-  "type": "coder",
-  "name": "Implementation Focus",
-  "capabilities": ["nodejs", "typescript", "express"]
-}
-```
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {
-  "type": "tester",
-  "name": "Quality Assurance",
-  "capabilities": ["unit-testing", "integration-testing"]
-}
-```
-Sets up architectural and implementation thinking patterns.
-
-### 3. Coordinate Implementation
-```
-Tool: mcp__claude-flow__task_orchestrate
-Parameters: {
-  "task": "Build REST API with authentication",
-  "strategy": "parallel",
-  "priority": "high",
-  "dependencies": ["database setup", "auth system"]
-}
-```
-
-### 4. Monitor Progress
-```
-Tool: mcp__claude-flow__task_status
-Parameters: {"taskId": "api-build-task-123"}
-```
-
-## What Claude Code Actually Does
-1. Uses **Write** tool to create new files
-2. Uses **Edit/MultiEdit** tools for code modifications
-3. Uses **Bash** tool for testing and building
-4. Uses **TodoWrite** tool for task tracking
-5. Follows coordination patterns for systematic implementation
-
-Remember: All code is written by Claude Code using its native tools!
-
-## CLI Usage
-```bash
-# Start development workflow via CLI
-npx claude-flow workflow dev "REST API with auth"
-
-# Create custom workflow
-npx claude-flow workflow create --name "api-dev" --steps "design,implement,test,deploy"
-
-# Execute saved workflow
-npx claude-flow workflow execute api-dev
+# Development Workflow Coordination
+
+## Purpose
+Structure Claude Code's approach to complex development tasks for maximum efficiency.
+
+## Step-by-Step Coordination
+
+### 1. Initialize Development Framework
+```
+Tool: mcp__moflo__swarm_init
+Parameters: {"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}
+```
+Creates hierarchical structure for organized, top-down development.
+
+### 2. Define Development Perspectives
+```
+Tool: mcp__moflo__agent_spawn
+Parameters: {
+  "type": "architect",
+  "name": "System Design",
+  "capabilities": ["api-design", "database-schema"]
+}
+```
+```
+Tool: mcp__moflo__agent_spawn
+Parameters: {
+  "type": "coder",
+  "name": "Implementation Focus",
+  "capabilities": ["nodejs", "typescript", "express"]
+}
+```
+```
+Tool: mcp__moflo__agent_spawn
+Parameters: {
+  "type": "tester",
+  "name": "Quality Assurance",
+  "capabilities": ["unit-testing", "integration-testing"]
+}
+```
+Sets up architectural and implementation thinking patterns.
+
+### 3. Coordinate Implementation
+```
+Tool: mcp__moflo__task_orchestrate
+Parameters: {
+  "task": "Build REST API with authentication",
+  "strategy": "parallel",
+  "priority": "high",
+  "dependencies": ["database setup", "auth system"]
+}
+```
+
+### 4. Monitor Progress
+```
+Tool: mcp__moflo__task_status
+Parameters: {"taskId": "api-build-task-123"}
+```
+
+## What Claude Code Actually Does
+1. Uses **Write** tool to create new files
+2. Uses **Edit/MultiEdit** tools for code modifications
+3. Uses **Bash** tool for testing and building
+4. Uses **TodoWrite** tool for task tracking
+5. Follows coordination patterns for systematic implementation
+
+Remember: All code is written by Claude Code using its native tools!
+
+## CLI Usage
+```bash
+# Start development workflow via CLI
+npx claude-flow workflow dev "REST API with auth"
+
+# Create custom workflow
+npx claude-flow workflow create --name "api-dev" --steps "design,implement,test,deploy"
+
+# Execute saved workflow
+npx claude-flow workflow execute api-dev
 ```

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

@@ -1,63 +1,63 @@
-# Research Workflow Coordination
-
-## Purpose
-Coordinate Claude Code's research activities for comprehensive, systematic exploration.
-
-## Step-by-Step Coordination
-
-### 1. Initialize Research Framework
-```
-Tool: mcp__claude-flow__swarm_init
-Parameters: {"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}
-```
-Creates a mesh topology for comprehensive exploration from multiple angles.
-
-### 2. Define Research Perspectives
-```
-Tool: mcp__claude-flow__agent_spawn
-Parameters: {"type": "researcher", "name": "Literature Review"}
-```
-```
-Tool: mcp__claude-flow__agent_spawn  
-Parameters: {"type": "analyst", "name": "Data Analysis"}
-```
-Sets up different analytical approaches for Claude Code to use.
-
-### 3. Execute Coordinated Research
-```
-Tool: mcp__claude-flow__task_orchestrate
-Parameters: {
-  "task": "Research modern web frameworks performance",
-  "strategy": "adaptive",
-  "priority": "medium"
-}
-```
-
-### 4. Store Research Findings
-```
-Tool: mcp__claude-flow__memory_usage
-Parameters: {
-  "action": "store",
-  "key": "research_findings",
-  "value": "framework performance analysis results",
-  "namespace": "research"
-}
-```
-
-## What Claude Code Actually Does
-1. Uses **WebSearch** tool for finding resources
-2. Uses **Read** tool for analyzing documentation
-3. Uses **Task** tool for parallel exploration
-4. Synthesizes findings using coordination patterns
-5. Stores insights in memory for future reference
-
-Remember: The swarm coordinates HOW Claude Code researches, not WHAT it finds.
-
-## CLI Usage
-```bash
-# Start research workflow via CLI
-npx claude-flow workflow research "modern web frameworks"
-
-# Export research workflow
-npx claude-flow workflow export research --format json
+# Research Workflow Coordination
+
+## Purpose
+Coordinate Claude Code's research activities for comprehensive, systematic exploration.
+
+## Step-by-Step Coordination
+
+### 1. Initialize Research Framework
+```
+Tool: mcp__moflo__swarm_init
+Parameters: {"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}
+```
+Creates a mesh topology for comprehensive exploration from multiple angles.
+
+### 2. Define Research Perspectives
+```
+Tool: mcp__moflo__agent_spawn
+Parameters: {"type": "researcher", "name": "Literature Review"}
+```
+```
+Tool: mcp__moflo__agent_spawn  
+Parameters: {"type": "analyst", "name": "Data Analysis"}
+```
+Sets up different analytical approaches for Claude Code to use.
+
+### 3. Execute Coordinated Research
+```
+Tool: mcp__moflo__task_orchestrate
+Parameters: {
+  "task": "Research modern web frameworks performance",
+  "strategy": "adaptive",
+  "priority": "medium"
+}
+```
+
+### 4. Store Research Findings
+```
+Tool: mcp__moflo__memory_usage
+Parameters: {
+  "action": "store",
+  "key": "research_findings",
+  "value": "framework performance analysis results",
+  "namespace": "research"
+}
+```
+
+## What Claude Code Actually Does
+1. Uses **WebSearch** tool for finding resources
+2. Uses **Read** tool for analyzing documentation
+3. Uses **Task** tool for parallel exploration
+4. Synthesizes findings using coordination patterns
+5. Stores insights in memory for future reference
+
+Remember: The swarm coordinates HOW Claude Code researches, not WHAT it finds.
+
+## CLI Usage
+```bash
+# Start research workflow via CLI
+npx claude-flow workflow research "modern web frameworks"
+
+# Export research workflow
+npx claude-flow workflow export research --format json
 ```

package/.claude/guidance/moflo-bootstrap.md

@@ -0,0 +1,129 @@
+<!-- AUTO-GENERATED by moflo session-start. Do not edit — changes will be overwritten. -->
+<!-- Source: node_modules/moflo/.claude/guidance/agent-bootstrap.md -->
+
+# MoFlo Agent Bootstrap Guide
+
+**Purpose:** Quick-start reference for subagents spawned by coordinators. Every subagent should follow this protocol before doing any work.
+
+---
+
+## 1. Search Memory FIRST
+
+**Before reading any files or exploring code, search memory for guidance relevant to your task.**
+
+### Three namespaces to search:
+
+| Namespace | When to search | What it returns |
+|-----------|---------------|-----------------|
+| `guidance` | Understanding patterns, rules, conventions | Guidance docs, coding rules, domain context |
+| `code-map` | Finding where code lives (files, types, services) | Project overviews, directory contents, type-to-file mappings |
+| `patterns` | Prior solutions, gotchas, implementation patterns | Learned patterns from previous task execution |
+
+**Always search `patterns` alongside `guidance`.** It contains solutions to problems already solved — skipping it means repeating past mistakes or re-discovering known approaches.
+
+**Search `code-map` BEFORE using Glob/Grep for navigation.** It's faster and returns structured results including file-level type mappings.
+
+### Option A: MCP Tools (Preferred)
+
+If you have MCP tools available (check for `mcp__moflo__*`), use them directly:
+
+| Tool | Purpose |
+|------|---------|
+| `mcp__moflo__memory_search` | Semantic search with domain-aware embeddings |
+| `mcp__moflo__memory_store` | Store patterns with auto-vectorization |
+| `mcp__moflo__hooks_route` | Get agent routing suggestions |
+
+### Option B: CLI via Bash
+
+```bash
+npx flo memory search --query "[describe your task]" --namespace guidance --limit 5
+```
+
+| Your task involves... | Search namespace | Example query |
+|-----------------------|------------------|---------------|
+| Database/entities | `guidance` + `patterns` | `"database entity migration"` |
+| Frontend components | `guidance` + `patterns` | `"React frontend component"` |
+| API endpoints | `guidance` + `patterns` | `"API route endpoint pattern"` |
+| Authentication | `guidance` + `patterns` | `"auth middleware JWT"` |
+| Unit tests | `guidance` + `patterns` | `"test mock vitest"` |
+| Prior solutions/gotchas | `patterns` | `"audit log service pattern"` |
+| Where is a file/type? | `code-map` | `"CompanyEntity file location"` |
+| What's in a directory? | `code-map` | `"back-office api routes"` |
+
+Use results with score > 0.3. If no good results, fall back to reading project guidance docs.
+
+---
+
+## 2. Check Project-Specific Bootstrap
+
+**After reading this file, check for a project-specific bootstrap:**
+
+```bash
+# Project-specific bootstrap (has domain rules, patterns, templates)
+cat .claude/guidance/agent-bootstrap.md 2>/dev/null | head -10
+```
+
+If `.claude/guidance/agent-bootstrap.md` exists, **read it next**. It contains project-specific rules (entity patterns, multi-tenancy, tech stack conventions) that override generic guidance.
+
+If no project bootstrap exists, look for general project guidance:
+
+```bash
+ls .claude/guidance/ 2>/dev/null
+cat .claude/guidance/core.md 2>/dev/null | head -50
+```
+
+Project guidance always takes precedence over generic patterns.
+
+---
+
+## 3. Universal Rules
+
+### Memory Protocol
+- Search memory before exploring files
+- Store discoveries back to memory when done
+- Use `patterns` namespace for solutions and gotchas
+- Use `decisions` namespace for architectural choices
+
+### Git/Branches
+- Use conventional commit prefixes: `feat:`, `fix:`, `refactor:`, `test:`, `chore:`
+- Use branch prefixes: `feature/`, `fix/`, `refactor/`
+- Use kebab-case for branch names
+
+### File Organization
+- Never save working files to repository root
+- Keep changes focused (3-10 files)
+- Stay within feature scope
+
+### Build & Test
+- Build and test after code changes
+- Never leave failing tests
+
+---
+
+## 4. Store Discoveries
+
+If you discover something new (pattern, solution, gotcha), store it:
+
+### MCP (Preferred):
+```
+mcp__moflo__memory_store
+  namespace: "patterns"
+  key: "brief-descriptive-key"
+  value: "1-2 sentence insight"
+```
+
+### CLI Fallback:
+```bash
+npx flo memory store --namespace patterns --key "brief-descriptive-key" --value "1-2 sentence insight"
+```
+
+**Store:** Solutions to tricky bugs, patterns that worked, gotchas, workarounds
+**Skip:** Summaries of retrieved guidance, general rules, file locations
+
+---
+
+## 5. When Complete
+
+1. Report findings to coordinator
+2. Store learnings if you discovered something new
+3. Coordinator will mark your task as completed