claude-flow-novice 2.3.8 → 2.4.0

package/SYNC_USAGE.md

@@ -0,0 +1,191 @@
+# Claude Flow Novice - Sync Guide
+
+## Installation & Setup
+
+### 1. Install Package
+
+```bash
+npm install claude-flow-novice
+```
+
+### 2. Sync Agents, Commands, and Hooks
+
+After installation, sync the latest agents, slash commands, and validation hooks to your project:
+
+```bash
+# Sync everything with backup
+npx claude-flow-sync --backup
+
+# Or use the longer form
+node node_modules/claude-flow-novice/scripts/sync-from-package.js --backup
+```
+
+## Sync Options
+
+### Sync Everything (Recommended for first time)
+
+```bash
+npx claude-flow-sync --backup
+```
+
+This syncs:
+- `.claude/agents/` - All agent definitions (94 files)
+- `.claude/commands/` - Slash commands
+- `config/hooks/` - Validation hooks
+
+### Selective Sync
+
+```bash
+# Sync only agents
+npx claude-flow-sync --agents --backup
+
+# Sync only commands
+npx claude-flow-sync --commands --backup
+
+# Sync only hooks
+npx claude-flow-sync --hooks --backup
+
+# Combine multiple
+npx claude-flow-sync --agents --hooks --backup
+```
+
+### Force Overwrite
+
+Use `--force` to overwrite existing files without prompting:
+
+```bash
+npx claude-flow-sync --force --backup
+```
+
+**⚠️ Warning**: `--force` will overwrite your customizations. Always use `--backup` with `--force`.
+
+## Update Workflow
+
+### When Package Updates
+
+```bash
+# 1. Update package
+npm update claude-flow-novice
+
+# 2. Sync new changes (creates backup automatically)
+npx claude-flow-sync --backup
+
+# 3. Review changes
+git diff .claude/ config/
+
+# 4. Merge customizations if needed
+# Restore from .backup-YYYY-MM-DD if you need your custom changes
+```
+
+### Customizing Agents/Commands
+
+1. **Initial sync**:
+   ```bash
+   npx claude-flow-sync --backup
+   ```
+
+2. **Customize** your local copies in:
+   - `.claude/agents/`
+   - `.claude/commands/`
+   - `config/hooks/`
+
+3. **Update from package** (preserves your changes):
+   ```bash
+   # WITHOUT --force, you'll be warned about existing files
+   npx claude-flow-sync --backup
+   
+   # Review what changed in the package
+   diff -r .claude/agents/ .claude/agents.backup-YYYY-MM-DD/
+   
+   # Manually merge changes you want
+   ```
+
+## File Locations After Sync
+
+```
+your-project/
+├── .claude/
+│   ├── agents/           # ✅ Synced from package (94 files)
+│   └── commands/         # ✅ Synced from package
+├── config/
+│   └── hooks/            # ✅ Synced from package (13+ files)
+└── node_modules/
+    └── claude-flow-novice/
+        ├── .claude/      # Source (in npm package)
+        ├── config/       # Source (in npm package)
+        └── scripts/      # Source (in npm package)
+```
+
+## Backup Management
+
+Backups are created as:
+- `.claude/agents.backup-2025-10-17/`
+- `.claude/commands.backup-2025-10-17/`
+- `config/hooks.backup-2025-10-17/`
+
+### Restore from Backup
+
+```bash
+# If you need to restore
+rm -rf .claude/agents/
+mv .claude/agents.backup-2025-10-17/ .claude/agents/
+```
+
+## Examples
+
+### First-Time Setup
+```bash
+npm install claude-flow-novice
+npx claude-flow-sync --backup
+```
+
+### Regular Updates
+```bash
+npm update claude-flow-novice
+npx claude-flow-sync --backup
+# Review changes with: git diff
+```
+
+### Force Update Everything
+```bash
+npx claude-flow-sync --force --backup
+```
+
+### Update Only Hooks (Get Latest Validators)
+```bash
+npx claude-flow-sync --hooks --force --backup
+```
+
+## What Gets Synced
+
+| Directory | Files | Description |
+|-----------|-------|-------------|
+| `.claude/agents/` | 94 | Agent definitions (optimized, Phase 4) |
+| `.claude/commands/` | 50+ | Slash commands |
+| `config/hooks/` | 13+ | Validation hooks (post-edit, etc.) |
+
+## What Doesn't Get Synced
+
+- `scripts/` - Only package utilities, not project-specific scripts
+- `readme/` - Package documentation (not project-specific)
+- `src/` - Package source code (not for project use)
+
+## Troubleshooting
+
+### "Source directory not found"
+Your package might be outdated. Update it:
+```bash
+npm update claude-flow-novice
+```
+
+### "Destination exists" Warning
+Without `--force`, sync won't overwrite. Use:
+```bash
+npx claude-flow-sync --force --backup
+```
+
+### Lost Customizations
+Restore from backup:
+```bash
+mv .claude/agents.backup-YYYY-MM-DD/ .claude/agents/
+```

package/config/hooks/post-edit-pipeline.js

@@ -1480,6 +1480,43 @@ class UnifiedPostEditPipeline {
         }
 
         const projectDir = this.findProjectRoot(filePath);
+
+        // TypeScript incremental type checking (single-file mode)
+        if (language === 'typescript' && tool === 'tsc') {
+            const tsArgs = [...args, '--skipLibCheck', filePath];
+
+            try {
+                const result = await this.runCommand(tool, tsArgs, projectDir);
+
+                // Parse TypeScript error output from both stdout and stderr
+                const allOutput = result.stdout + result.stderr;
+                const errorLines = allOutput.split('\n').filter(line => line.includes('error TS'));
+                const errorCount = errorLines.length;
+
+                return {
+                    success: result.code === 0 && errorCount === 0,
+                    message: result.code === 0 ? 'TypeScript compilation passed' : `${errorCount} TypeScript error(s)`,
+                    output: allOutput,
+                    errors: errorCount > 0 ? errorLines.join('\n') : '',
+                    errorCount,
+                    errorLines: errorLines.slice(0, 10), // First 10 errors for feedback
+                    wasmAccelerated
+                };
+            } catch (error) {
+                // Handle TypeScript compiler crashes gracefully
+                return {
+                    success: false,
+                    message: 'TypeScript compiler error',
+                    output: error.message || error.stderr || '',
+                    errors: error.message || 'TypeScript compilation failed',
+                    errorCount: 1,
+                    errorLines: [(error.message || 'Unknown compiler error')],
+                    wasmAccelerated
+                };
+            }
+        }
+
+        // Standard type checking for other languages
         const result = await this.runCommand(tool, args, projectDir);
 
         return {
@@ -2126,6 +2163,18 @@ class UnifiedPostEditPipeline {
         if (!results.steps.typeCheck.success) {
             results.summary.errors.push(`Type errors in ${path.basename(filePath)}`);
             results.summary.success = false;
+
+            // Send TYPE_ERROR feedback to agent
+            await this.sendAgentFeedback({
+                type: 'TYPE_ERROR',
+                file: filePath,
+                severity: 'error',
+                language,
+                errorCount: results.steps.typeCheck.errorCount || 0,
+                errorLines: results.steps.typeCheck.errorLines || [],
+                errors: results.steps.typeCheck.errors,
+                message: `${results.steps.typeCheck.errorCount || 'Unknown'} TypeScript error(s) in ${path.basename(filePath)}`
+            });
         }
 
         // Step 4: Rust Quality Enforcement (if Rust and strict mode)

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.3.8",
+  "version": "2.4.0",
   "description": "AI Agent Orchestration CLI",
   "main": "src/index.ts",
   "bin": {
-    "claude-flow-novice": "./src/cli/index.ts"
+    "claude-flow-novice": "./src/cli/index.ts",
+    "claude-flow-sync": "./scripts/sync-from-package.js"
   },
   "files": [
     "src",
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
+    "SYNC_USAGE.md",
     "config",
     "scripts",
     ".claude",
@@ -21,6 +23,8 @@
     "clean": "rimraf dist",
     "lint": "eslint . --ext .ts",
     "typecheck": "tsc --noEmit",
+    "type-coverage": "type-coverage --detail --ignore-files 'src/__tests__/**' --ignore-files '**/*.test.ts'",
+    "type-coverage:ci": "type-coverage --at-least 80 --ignore-files 'src/__tests__/**' --ignore-files '**/*.test.ts'",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "prepublish-checks": "node scripts/prepublish-checks.js",
@@ -28,7 +32,8 @@
     "security-scan": "snyk test && npm audit --audit-level=high",
     "bundle-size-check": "bundlesize",
     "smoke-test": "npm pack && node scripts/smoke-test.js",
-    "changelog": "standard-version"
+    "changelog": "standard-version",
+    "create:component": "node scripts/create-component.js"
   },
   "keywords": [
     "ai",
@@ -53,15 +58,19 @@
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "jest": "^29.0.0",
+    "bundlesize": "^0.18.1",
     "eslint": "^8.0.0",
-    "rollup": "^3.0.0",
+    "husky": "^8.0.0",
+    "jest": "^29.0.0",
     "rimraf": "^5.0.0",
-    "bundlesize": "^0.18.1",
-    "snyk": "^1.0.0",
+    "rollup": "^3.0.0",
     "semantic-release": "^21.0.0",
+    "snyk": "^1.0.0",
     "standard-version": "^9.0.0",
-    "husky": "^8.0.0"
+    "type-coverage": "^2.29.7",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "ioredis": "^5.8.1"
   }
 }

package/scripts/create-component.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+/**
+ * Component Template Generator
+ * Creates TypeScript components with proper type declarations and tests
+ *
+ * Usage:
+ *   node scripts/create-component.js <ComponentName> <directory>
+ *
+ * Example:
+ *   node scripts/create-component.js SwarmCoordinator src/coordination
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const [, , componentName, componentDir] = process.argv;
+
+if (!componentName || !componentDir) {
+  console.log(`
+🔧 Component Template Generator
+
+Usage: node scripts/create-component.js <ComponentName> <directory>
+
+Arguments:
+  ComponentName    Name of the component (PascalCase)
+  directory        Target directory (e.g., src/coordination)
+
+Examples:
+  node scripts/create-component.js SwarmCoordinator src/coordination
+  node scripts/create-component.js TaskValidator src/validation
+  node scripts/create-component.js RedisClient src/services
+
+Generated files:
+  ✅ <directory>/<ComponentName>.ts        - Main implementation
+  ✅ <directory>/<ComponentName>.test.ts   - Test file with basic setup
+  ✅ <directory>/types.ts                  - Type definitions (if doesn't exist)
+  `);
+  process.exit(1);
+}
+
+const projectRoot = path.resolve(__dirname, '..');
+
+// Validate component name (PascalCase)
+if (!/^[A-Z][a-zA-Z0-9]*$/.test(componentName)) {
+  console.error(`❌ Error: Component name must be PascalCase (e.g., SwarmCoordinator, not swarm-coordinator)`);
+  process.exit(1);
+}
+
+// Create directory if it doesn't exist
+const targetDir = path.join(projectRoot, componentDir);
+if (!fs.existsSync(targetDir)) {
+  fs.mkdirSync(targetDir, { recursive: true });
+  console.log(`📁 Created directory: ${componentDir}/`);
+}
+
+// Component file template
+const componentTemplate = `/**
+ * ${componentName}
+ *
+ * TODO: Add component description
+ */
+
+export interface ${componentName}Options {
+  // TODO: Define configuration options
+}
+
+export class ${componentName} {
+  private options: ${componentName}Options;
+
+  constructor(options: ${componentName}Options) {
+    this.options = options;
+  }
+
+  // TODO: Implement methods
+  async initialize(): Promise<void> {
+    // Initialization logic
+  }
+
+  async execute(): Promise<void> {
+    // Main execution logic
+  }
+
+  async cleanup(): Promise<void> {
+    // Cleanup logic
+  }
+}
+`;
+
+// Test file template
+const testTemplate = `import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { ${componentName} } from './${componentName}';
+
+describe('${componentName}', () => {
+  let component: ${componentName};
+
+  beforeEach(() => {
+    component = new ${componentName}({
+      // TODO: Add test configuration
+    });
+  });
+
+  afterEach(async () => {
+    await component.cleanup();
+  });
+
+  describe('initialization', () => {
+    it('should initialize successfully', async () => {
+      await component.initialize();
+      // TODO: Add assertions
+      expect(component).toBeDefined();
+    });
+  });
+
+  describe('execution', () => {
+    it('should execute successfully', async () => {
+      await component.initialize();
+      await component.execute();
+      // TODO: Add assertions
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle errors gracefully', async () => {
+      // TODO: Test error scenarios
+    });
+  });
+});
+`;
+
+// Types file template (only create if doesn't exist)
+const typesTemplate = `/**
+ * Type definitions for ${componentDir}
+ */
+
+export interface BaseOptions {
+  enabled?: boolean;
+  debug?: boolean;
+}
+
+// Add shared types here
+`;
+
+// Write component file
+const componentPath = path.join(targetDir, `${componentName}.ts`);
+if (fs.existsSync(componentPath)) {
+  console.error(`❌ Error: Component file already exists: ${componentPath}`);
+  process.exit(1);
+}
+fs.writeFileSync(componentPath, componentTemplate);
+console.log(`✅ Created: ${path.relative(projectRoot, componentPath)}`);
+
+// Write test file
+const testPath = path.join(targetDir, `${componentName}.test.ts`);
+if (fs.existsSync(testPath)) {
+  console.warn(`⚠️  Warning: Test file already exists: ${testPath} (skipping)`);
+} else {
+  fs.writeFileSync(testPath, testTemplate);
+  console.log(`✅ Created: ${path.relative(projectRoot, testPath)}`);
+}
+
+// Create types file if doesn't exist
+const typesPath = path.join(targetDir, 'types.ts');
+if (!fs.existsSync(typesPath)) {
+  fs.writeFileSync(typesPath, typesTemplate);
+  console.log(`✅ Created: ${path.relative(projectRoot, typesPath)}`);
+} else {
+  console.log(`ℹ️  Types file exists: ${path.relative(projectRoot, typesPath)} (not modified)`);
+}
+
+// Create index.ts barrel export if doesn't exist
+const indexPath = path.join(targetDir, 'index.ts');
+const exportLine = `export * from './${componentName}';\n`;
+
+if (fs.existsSync(indexPath)) {
+  const content = fs.readFileSync(indexPath, 'utf8');
+  if (!content.includes(`from './${componentName}'`)) {
+    fs.appendFileSync(indexPath, exportLine);
+    console.log(`✅ Added export to: ${path.relative(projectRoot, indexPath)}`);
+  } else {
+    console.log(`ℹ️  Export already exists in: ${path.relative(projectRoot, indexPath)}`);
+  }
+} else {
+  fs.writeFileSync(indexPath, `export * from './types';\n${exportLine}`);
+  console.log(`✅ Created: ${path.relative(projectRoot, indexPath)}`);
+}
+
+console.log(`
+✨ Component generated successfully!
+
+Next steps:
+  1. Implement ${componentName} logic in ${componentPath}
+  2. Write tests in ${testPath}
+  3. Run tests: npm test -- ${componentName}
+  4. Run type check: npm run typecheck
+`);

package/scripts/subcategorize-agents.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+
+/**
+ * Create subcategories within each main agent category
+ * Provides finer-grained organization for easier browsing
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const AGENTS_DIR = path.join(__dirname, '../agents');
+
+// Subcategory definitions for each main category
+const SUBCATEGORIES = {
+  'development-engineering': {
+    'backend': {
+      keywords: ['backend', 'api', 'rest', 'graphql', 'server', 'node', 'django', 'flask', 'express', 'fastapi'],
+      description: 'Backend development, APIs, server-side programming'
+    },
+    'frontend': {
+      keywords: ['frontend', 'react', 'angular', 'vue', 'ui', 'javascript', 'typescript', 'css', 'html', 'web-ui'],
+      description: 'Frontend frameworks, UI development, client-side'
+    },
+    'mobile': {
+      keywords: ['mobile', 'ios', 'android', 'react-native', 'flutter', 'swift', 'kotlin'],
+      description: 'Mobile app development (iOS, Android)'
+    },
+    'devops': {
+      keywords: ['devops', 'docker', 'kubernetes', 'ci-cd', 'cicd', 'deployment', 'container', 'gitops', 'argocd', 'flux', 'jenkins'],
+      description: 'DevOps, CI/CD, containerization, orchestration'
+    },
+    'testing': {
+      keywords: ['test', 'qa', 'quality', 'acceptance', 'cypress', 'jest', 'playwright', 'e2e', 'integration-test', 'unit-test', 'fuzz'],
+      description: 'Testing, QA, quality assurance, test automation'
+    },
+    'database': {
+      keywords: ['database', 'sql', 'nosql', 'postgres', 'mysql', 'mongodb', 'redis', 'data-model'],
+      description: 'Database design, SQL, NoSQL, data modeling'
+    },
+    'architecture': {
+      keywords: ['architect', 'architecture', 'design-pattern', 'microservices', 'system-design', 'scalability'],
+      description: 'Software architecture, system design, patterns'
+    },
+    'integration': {
+      keywords: ['integration', 'api-integration', 'third-party', 'webhook', 'payment-integration', 'oauth'],
+      description: 'API integration, third-party services, webhooks'
+    }
+  },
+
+  'industry-specific': {
+    'healthcare': {
+      keywords: ['health', 'medical', 'clinical', 'patient', 'doctor', 'hospital', 'telemedicine', 'pharmaceutical'],
+      description: 'Healthcare, medical, clinical systems'
+    },
+    'finance': {
+      keywords: ['finance', 'banking', 'fintech', 'trading', 'investment', 'accounting', 'ledger', 'financial'],
+      description: 'Finance, banking, fintech, trading'
+    },
+    'legal': {
+      keywords: ['legal', 'law', 'attorney', 'court', 'litigation', 'contract', 'compliance-legal'],
+      description: 'Legal services, law firms, compliance'
+    },
+    'education': {
+      keywords: ['education', 'learning', 'student', 'teacher', 'academic', 'e-learning', 'training', 'course'],
+      description: 'Education, e-learning, academic systems'
+    },
+    'retail': {
+      keywords: ['retail', 'e-commerce', 'shop', 'store', 'pos', 'inventory', 'product', 'catalog'],
+      description: 'Retail, e-commerce, point-of-sale'
+    },
+    'manufacturing': {
+      keywords: ['manufactur', 'production', 'factory', 'supply-chain', 'logistics', 'warehouse', 'industrial'],
+      description: 'Manufacturing, production, supply chain'
+    },
+    'entertainment': {
+      keywords: ['entertainment', 'media', 'gaming', 'sports', 'music', 'video', 'streaming', 'content'],
+      description: 'Entertainment, media, gaming, sports'
+    },
+    'other': {
+      keywords: ['real-estate', 'hospitality', 'tourism', 'energy', 'utilities', 'telecom', 'insurance', 'nonprofit'],
+      description: 'Other industries (real estate, hospitality, etc.)'
+    }
+  },
+
+  'ai-ml-automation': {
+    'machine-learning': {
+      keywords: ['machine-learning', 'ml', 'supervised', 'unsupervised', 'classification', 'regression', 'scikit'],
+      description: 'Traditional machine learning, classification, regression'
+    },
+    'deep-learning': {
+      keywords: ['deep-learning', 'neural', 'tensorflow', 'pytorch', 'keras', 'cnn', 'rnn', 'transformer'],
+      description: 'Deep learning, neural networks, frameworks'
+    },
+    'nlp': {
+      keywords: ['nlp', 'natural-language', 'text', 'sentiment', 'chatbot', 'language-model', 'tokeniz'],
+      description: 'Natural language processing, text analysis'
+    },
+    'computer-vision': {
+      keywords: ['vision', 'image', 'video', 'object-detection', 'facial', 'ocr', 'recognition'],
+      description: 'Computer vision, image processing, object detection'
+    },
+    'mlops': {
+      keywords: ['mlops', 'model-deployment', 'training-pipeline', 'experiment-tracking', 'model-serving'],
+      description: 'MLOps, model deployment, training pipelines'
+    },
+    'automation': {
+      keywords: ['automation', 'intelligent-automation', 'workflow', 'orchestration', 'agent-based'],
+      description: 'Intelligent automation, workflow automation'
+    }
+  },
+
+  'business-operations': {
+    'strategy': {
+      keywords: ['strategy', 'strategic', 'planning', 'competitive', 'positioning', 'vision'],
+      description: 'Business strategy, strategic planning'
+    },
+    'growth': {
+      keywords: ['growth', 'scaling', 'expansion', 'market-expansion', 'growth-hacking'],
+      description: 'Business growth, scaling, expansion'
+    },
+    'revenue': {
+      keywords: ['revenue', 'sales', 'monetization', 'pricing', 'billing', 'subscription'],
+      description: 'Revenue optimization, sales, monetization'
+    },
+    'customer': {
+      keywords: ['customer', 'client', 'user-experience', 'crm', 'support', 'journey', 'satisfaction'],
+      description: 'Customer experience, CRM, support'
+    },
+    'operations': {
+      keywords: ['operations', 'operational', 'process', 'workflow', 'efficiency', 'optimization'],
+      description: 'Operations management, process optimization'
+    },
+    'leadership': {
+      keywords: ['leadership', 'management', 'executive', 'team-building', 'organizational'],
+      description: 'Leadership, management, organizational development'
+    }
+  },
+
+  'data-analytics': {
+    'business-intelligence': {
+      keywords: ['business-intelligence', 'bi', 'dashboard', 'reporting', 'kpi', 'metrics'],
+      description: 'Business intelligence, dashboards, reporting'
+    },
+    'data-engineering': {
+      keywords: ['etl', 'elt', 'pipeline', 'data-pipeline', 'warehouse', 'lake', 'ingestion'],
+      description: 'Data engineering, ETL/ELT, data pipelines'
+    },
+    'analytics': {
+      keywords: ['analytics', 'analysis', 'insights', 'statistical', 'predictive', 'prescriptive'],
+      description: 'Data analytics, statistical analysis, insights'
+    },
+    'forecasting': {
+      keywords: ['forecast', 'prediction', 'time-series', 'trend', 'anomaly-detection'],
+      description: 'Forecasting, time-series analysis, predictions'
+    },
+    'visualization': {
+      keywords: ['visualization', 'chart', 'graph', 'tableau', 'power-bi', 'data-viz'],
+      description: 'Data visualization, charts, dashboards'
+    }
+  },
+
+  'personal-professional': {
+    'career': {
+      keywords: ['career', 'job', 'interview', 'resume', 'job-search', 'promotion', 'transition'],
+      description: 'Career development, job search, interviews'
+    },
+    'leadership': {
+      keywords: ['leadership', 'leader', 'management', 'executive', 'mentoring', 'coaching'],
+      description: 'Leadership development, coaching, mentoring'
+    },
+    'productivity': {
+      keywords: ['productivity', 'time-management', 'efficiency', 'goal', 'planning', 'organization'],
+      description: 'Productivity, time management, goal setting'
+    },
+    'communication': {
+      keywords: ['communication', 'presentation', 'public-speaking', 'writing', 'listening', 'feedback'],
+      description: 'Communication skills, presentations, feedback'
+    },
+    'wellness': {
+      keywords: ['wellness', 'stress', 'work-life', 'balance', 'mindfulness', 'mental-health', 'emotional'],
+      description: 'Wellness, work-life balance, mental health'
+    }
+  },
+
+  'security-compliance': {
+    'cybersecurity': {
+      keywords: ['cybersecurity', 'security', 'threat', 'vulnerability', 'penetration', 'firewall', 'encryption'],
+      description: 'Cybersecurity, threat analysis, penetration testing'
+    },
+    'compliance': {
+      keywords: ['compliance', 'regulatory', 'audit', 'gdpr', 'hipaa', 'sox', 'pci', 'iso'],
+      description: 'Compliance, regulatory requirements, auditing'
+    },
+    'privacy': {
+      keywords: ['privacy', 'data-privacy', 'gdpr', 'personal-data', 'consent', 'anonymization'],
+      description: 'Data privacy, GDPR, personal data protection'
+    },
+    'access-control': {
+      keywords: ['access-control', 'authentication', 'authorization', 'identity', 'zero-trust', 'iam'],
+      description: 'Access control, authentication, identity management'
+    }
+  },
+
+  'payment-financial': {
+    'payment-gateways': {
+      keywords: ['stripe', 'paypal', 'square', 'braintree', 'checkout', 'payment-gateway', 'merchant'],
+      description: 'Payment gateways (Stripe, PayPal, Square, etc.)'
+    },
+    'bnpl': {
+      keywords: ['bnpl', 'afterpay', 'klarna', 'affirm', 'installment', 'buy-now-pay-later'],
+      description: 'Buy-now-pay-later, installment payments'
+    },
+    'cryptocurrency': {
+      keywords: ['crypto', 'bitcoin', 'ethereum', 'blockchain', 'wallet', 'web3'],
+      description: 'Cryptocurrency, blockchain, Web3 payments'
+    },
+    'billing': {
+      keywords: ['billing', 'invoice', 'subscription', 'recurring', 'pricing'],
+      description: 'Billing systems, invoicing, subscriptions'
+    }
+  }
+};
+
+/**
+ * Extract YAML frontmatter from markdown file
+ */
+function extractFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+
+  const frontmatter = {};
+  const lines = match[1].split('\n');
+
+  for (const line of lines) {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) continue;
+
+    const key = line.substring(0, colonIndex).trim();
+    const value = line.substring(colonIndex + 1).trim();
+    frontmatter[key] = value;
+  }
+
+  return frontmatter;
+}
+
+/**
+ * Categorize agent into subcategory
+ */
+function subcategorizeAgent(filename, content, mainCategory) {
+  const subcategories = SUBCATEGORIES[mainCategory];
+  if (!subcategories) return null;
+
+  const frontmatter = extractFrontmatter(content);
+  const searchText = (filename + ' ' + (frontmatter?.name || '') + ' ' + (frontmatter?.description || '')).toLowerCase();
+
+  let bestSubcategory = null;
+  let bestScore = 0;
+
+  for (const [subcategory, config] of Object.entries(subcategories)) {
+    let score = 0;
+    for (const keyword of config.keywords) {
+      if (searchText.includes(keyword.toLowerCase())) {
+        score++;
+      }
+    }
+
+    if (score > bestScore) {
+      bestScore = score;
+      bestSubcategory = subcategory;
+    }
+  }
+
+  // Default to first subcategory or 'other' if no match
+  if (!bestSubcategory) {
+    bestSubcategory = subcategories.other ? 'other' : Object.keys(subcategories)[0];
+  }
+
+  return bestSubcategory;
+}
+
+/**
+ * Process a single main category
+ */
+function processCategory(mainCategory) {
+  const categoryDir = path.join(AGENTS_DIR, mainCategory);
+  if (!fs.existsSync(categoryDir)) {
+    console.log(`⏭️  Skipping ${mainCategory} (not found)`);
+    return null;
+  }
+
+  console.log(`\n📂 Processing ${mainCategory}...`);
+
+  // Read agent files
+  const files = fs.readdirSync(categoryDir)
+    .filter(f => f.endsWith('.md') && f !== 'INDEX.md');
+
+  if (files.length === 0) {
+    console.log(`  No agents found in ${mainCategory}`);
+    return null;
+  }
+
+  console.log(`  Found ${files.length} agents`);
+
+  // Categorize into subcategories
+  const subcategorization = {};
+  const subcategoryConfigs = SUBCATEGORIES[mainCategory];
+
+  for (const subcategory of Object.keys(subcategoryConfigs)) {
+    subcategorization[subcategory] = [];
+  }
+
+  for (const file of files) {
+    const filePath = path.join(categoryDir, file);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const subcategory = subcategorizeAgent(file, content, mainCategory);
+
+    if (subcategory && subcategorization[subcategory]) {
+      subcategorization[subcategory].push(file);
+    }
+  }
+
+  // Display subcategorization
+  console.log(`\n  Subcategories:`);
+  for (const [subcategory, files] of Object.entries(subcategorization)) {
+    if (files.length > 0) {
+      console.log(`    ${subcategory}: ${files.length} agents`);
+    }
+  }
+
+  // Create subdirectories and move files
+  for (const [subcategory, config] of Object.entries(subcategoryConfigs)) {
+    const subcategoryDir = path.join(categoryDir, subcategory);
+    const filesToMove = subcategorization[subcategory];
+
+    if (filesToMove.length === 0) continue;
+
+    // Create directory
+    if (!fs.existsSync(subcategoryDir)) {
+      fs.mkdirSync(subcategoryDir, { recursive: true });
+    }
+
+    // Move files
+    for (const file of filesToMove) {
+      const src = path.join(categoryDir, file);
+      const dest = path.join(subcategoryDir, file);
+      fs.renameSync(src, dest);
+    }
+
+    // Create subcategory index
+    const indexContent = `# ${subcategory.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+**Description:** ${config.description}
+**Agent Count:** ${filesToMove.length}
+
+## Available Agents
+
+${filesToMove.sort().map(f => `- [${f.replace('.md', '')}](./${f})`).join('\n')}
+`;
+
+    fs.writeFileSync(path.join(subcategoryDir, 'INDEX.md'), indexContent);
+  }
+
+  // Update main category index
+  const mainIndexContent = `# ${mainCategory.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+**Total Agents:** ${files.length}
+
+## Subcategories
+
+${Object.entries(subcategorization)
+  .filter(([_, files]) => files.length > 0)
+  .sort((a, b) => b[1].length - a[1].length)
+  .map(([subcat, files]) => {
+    const config = subcategoryConfigs[subcat];
+    return `### [${subcat}](${subcat}/INDEX.md) (${files.length} agents)
+
+${config.description}
+`;
+  }).join('\n')}
+
+## Quick Navigation
+
+${Object.entries(subcategorization)
+  .filter(([_, files]) => files.length > 0)
+  .map(([subcat, files]) => `- [${subcat}](${subcat}/INDEX.md) - ${files.length} agents`)
+  .join('\n')}
+`;
+
+  fs.writeFileSync(path.join(categoryDir, 'INDEX.md'), mainIndexContent);
+
+  return {
+    category: mainCategory,
+    totalAgents: files.length,
+    subcategories: Object.fromEntries(
+      Object.entries(subcategorization).filter(([_, files]) => files.length > 0)
+    )
+  };
+}
+
+/**
+ * Main subcategorization process
+ */
+async function subcategorizeAgents() {
+  console.log('🔍 Subcategorizing agents within each main category...\n');
+
+  const results = {};
+
+  for (const mainCategory of Object.keys(SUBCATEGORIES)) {
+    const result = processCategory(mainCategory);
+    if (result) {
+      results[mainCategory] = result;
+    }
+  }
+
+  console.log('\n\n✅ Subcategorization complete!\n');
+
+  // Generate summary
+  console.log('📊 Summary by Main Category:\n');
+  for (const [category, data] of Object.entries(results)) {
+    console.log(`${category}: ${data.totalAgents} agents in ${Object.keys(data.subcategories).length} subcategories`);
+  }
+
+  console.log('\n✨ Done!\n');
+}
+
+// Run
+subcategorizeAgents().catch(console.error);

package/scripts/sync-from-package.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * Sync agents, commands, and hooks from npm package to local project
+ * Usage: npx claude-flow-novice sync [--force] [--backup] [--agents] [--commands] [--hooks]
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const args = process.argv.slice(2);
+const flags = {
+  force: args.includes('--force'),
+  backup: args.includes('--backup'),
+  agents: args.includes('--agents') || args.length === 0,
+  commands: args.includes('--commands') || args.length === 0,
+  hooks: args.includes('--hooks') || args.length === 0,
+  help: args.includes('--help') || args.includes('-h')
+};
+
+if (flags.help) {
+  console.log(`
+Claude Flow Novice - Sync Script
+
+Syncs agents, commands, and hooks from npm package to your local project.
+
+Usage:
+  npx claude-flow-novice sync [options]
+
+Options:
+  --agents     Sync .claude/agents/ only
+  --commands   Sync .claude/commands/ only  
+  --hooks      Sync config/hooks/ only
+  --force      Overwrite existing files without prompting
+  --backup     Create backup before syncing (recommended)
+  --help, -h   Show this help message
+
+Examples:
+  npx claude-flow-novice sync                    # Sync everything
+  npx claude-flow-novice sync --agents --backup  # Sync agents with backup
+  npx claude-flow-novice sync --force --backup   # Force sync all with backup
+`);
+  process.exit(0);
+}
+
+// Find package location
+const packagePath = path.join(__dirname, '..');
+const projectRoot = process.cwd();
+
+console.log('🚀 Claude Flow Novice - Sync Script\n');
+console.log(`📦 Package: ${packagePath}`);
+console.log(`📁 Project: ${projectRoot}\n`);
+
+const syncItems = [
+  {
+    name: 'agents',
+    enabled: flags.agents,
+    source: path.join(packagePath, '.claude', 'agents'),
+    dest: path.join(projectRoot, '.claude', 'agents'),
+    description: 'Agent definitions'
+  },
+  {
+    name: 'commands',
+    enabled: flags.commands,
+    source: path.join(packagePath, '.claude', 'commands'),
+    dest: path.join(projectRoot, '.claude', 'commands'),
+    description: 'Slash commands'
+  },
+  {
+    name: 'hooks',
+    enabled: flags.hooks,
+    source: path.join(packagePath, 'config', 'hooks'),
+    dest: path.join(projectRoot, 'config', 'hooks'),
+    description: 'Validation hooks'
+  }
+];
+
+// Backup function
+function createBackup(destPath) {
+  if (!fs.existsSync(destPath)) return null;
+  
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+  const backupPath = `${destPath}.backup-${timestamp}`;
+  
+  console.log(`  📋 Creating backup: ${path.basename(backupPath)}`);
+  execSync(`cp -r "${destPath}" "${backupPath}"`);
+  return backupPath;
+}
+
+// Copy directory recursively
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) {
+    console.error(`  ❌ Source not found: ${src}`);
+    return false;
+  }
+
+  // Create destination directory
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  let fileCount = 0;
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+      fileCount++;
+    }
+  }
+
+  return fileCount;
+}
+
+// Count files in directory
+function countFiles(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  
+  let count = 0;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      count += countFiles(path.join(dir, entry.name));
+    } else {
+      count++;
+    }
+  }
+  
+  return count;
+}
+
+// Main sync process
+let totalSynced = 0;
+
+for (const item of syncItems) {
+  if (!item.enabled) continue;
+
+  console.log(`\n📂 Syncing ${item.description}...`);
+  console.log(`   Source: ${item.source}`);
+  console.log(`   Dest:   ${item.dest}`);
+
+  // Check if source exists
+  if (!fs.existsSync(item.source)) {
+    console.log(`  ⚠️  Source directory not found, skipping`);
+    continue;
+  }
+
+  // Backup if requested
+  if (flags.backup) {
+    createBackup(item.dest);
+  }
+
+  // Check if destination exists and not forcing
+  if (fs.existsSync(item.dest) && !flags.force) {
+    const beforeCount = countFiles(item.dest);
+    console.log(`  ⚠️  Destination exists with ${beforeCount} files`);
+    console.log(`  💡 Use --force to overwrite or --backup to create backup first`);
+    continue;
+  }
+
+  // Perform sync
+  const fileCount = copyDir(item.source, item.dest);
+  console.log(`  ✅ Synced ${fileCount} files`);
+  totalSynced += fileCount;
+}
+
+console.log(`\n✨ Sync complete! ${totalSynced} files synced.\n`);
+
+if (totalSynced > 0) {
+  console.log('Next steps:');
+  console.log('  1. Review synced files');
+  console.log('  2. Customize as needed for your project');
+  console.log('  3. Commit changes to version control\n');
+}

package/src/cli/hybrid-routing/spawn-workers.js

@@ -923,7 +923,8 @@ Execute the task using available tools. Report confidence score (0.0-1.0) at the
       const MAX_TOOL_ITERATIONS = 1000; // Increased from 25 to allow comprehensive optimization tasks
       let content = '';
 
-      // Tool use loop
+      // Tool use loop with context window management
+      const MAX_CONTEXT_MESSAGES = 20; // Keep only last 20 messages
       while (toolUseCount < MAX_TOOL_ITERATIONS) {
         const response = await this.anthropic.createMessage({
           model: this.model,
@@ -979,6 +980,12 @@ Execute the task using available tools. Report confidence score (0.0-1.0) at the
         });
 
         toolUseCount++;
+
+        // Trim context window to prevent memory leak
+        if (messages.length > MAX_CONTEXT_MESSAGES) {
+          // Keep first message (initial task) + last N messages
+          messages = [messages[0], ...messages.slice(-MAX_CONTEXT_MESSAGES + 1)];
+        }
       }
 
       if (toolUseCount >= MAX_TOOL_ITERATIONS) {
@@ -1103,7 +1110,7 @@ Execute the task using available tools. Report confidence score (0.0-1.0) at the
   }
 
   /**
-   * Recursively scan directory for .md files
+   * Recursively scan directory for .md files (excludes node_modules)
    */
   async scanAgentFiles(dirPath, basePath) {
     const { promises: fs } = await import('fs');
@@ -1115,6 +1122,11 @@ Execute the task using available tools. Report confidence score (0.0-1.0) at the
       const entries = await fs.readdir(dirPath, { withFileTypes: true });
 
       for (const entry of entries) {
+        // Skip node_modules to prevent memory leak
+        if (entry.name === 'node_modules') {
+          continue;
+        }
+
         const fullPath = path.join(dirPath, entry.name);
 
         if (entry.isDirectory()) {

package/src/index.ts

@@ -27,10 +27,10 @@ export const AgentType = {
   API_DOCS: 'api-docs',
   BACKEND_DEV: 'backend-dev',
   FRONTEND_DEV: 'frontend-dev',
-  MOBILE_DEV: 'mobile-dev'
+  MOBILE_DEV: 'mobile-dev',
 } as const;
 
-export type AgentType = typeof AgentType[keyof typeof AgentType];
+export type AgentType = (typeof AgentType)[keyof typeof AgentType];
 
 // Version
 export const VERSION = '2.0.4';
@@ -41,6 +41,6 @@ export const defaultConfig = {
   strategy: 'development',
   mode: 'mesh',
   persistence: true,
-  consensusThreshold: 0.90,
-  gateThreshold: 0.75
+  consensusThreshold: 0.9,
+  gateThreshold: 0.75,
 };