claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/init/claude-commands/claude-flow-commands.js

@@ -1,9 +1,10 @@
-import { promises as fs } from "fs";
+import { promises as fs } from 'fs';
 // claude-flow-commands.js - Claude-Flow specific slash commands
+
 // Create Claude-Flow specific commands
 export async function createClaudeFlowCommands(workingDir) {
-    // Help command
-    const helpCommand = `---
+  // Help command
+  const helpCommand = `---
 name: claude-flow-help
 description: Show Claude-Flow commands and usage
 ---
@@ -107,10 +108,12 @@ npx -y claude-flow@latest init --sparc
 - Examples: https://github.com/ruvnet/claude-code-flow/examples
 - Issues: https://github.com/ruvnet/claude-code-flow/issues
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
-    console.log('  ✓ Created slash command: /claude-flow-help');
-    // Memory command
-    const memoryCommand = `---
+
+  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
+  console.log('  ✓ Created slash command: /claude-flow-help');
+
+  // Memory command
+  const memoryCommand = `---
 name: claude-flow-memory
 description: Interact with Claude-Flow memory system
 ---
@@ -218,10 +221,12 @@ The memory system provides persistent storage for cross-session and cross-agent
 ./claude-flow-novice memory export project-$(date +%Y%m%d).json --namespace project
 \`\`\`
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
-    console.log('  ✓ Created slash command: /claude-flow-memory');
-    // Swarm command
-    const swarmCommand = `---
+
+  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
+  console.log('  ✓ Created slash command: /claude-flow-memory');
+
+  // Swarm command
+  const swarmCommand = `---
 name: claude-flow-swarm
 description: Coordinate multi-agent swarms for complex tasks
 ---
@@ -427,6 +432,7 @@ Swarms automatically use distributed memory for collaboration:
 
 For detailed documentation, see: https://github.com/ruvnet/claude-code-flow/docs/swarm-system.md
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
-    console.log('  ✓ Created slash command: /claude-flow-swarm');
+
+  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
+  console.log('  ✓ Created slash command: /claude-flow-swarm');
 }

package/dist/src/cli/simple-commands/init/claude-commands/optimized-claude-flow-commands.js

@@ -1,9 +1,10 @@
-import { promises as fs } from "fs";
+import { promises as fs } from 'fs';
 // optimized-claude-flow-commands.js - Batchtools-optimized Claude-Flow specific slash commands
+
 // Create batchtools-optimized Claude-Flow specific commands
 export async function createOptimizedClaudeFlowCommands(workingDir) {
-    // Help command with batchtools optimization
-    const helpCommand = `---
+  // Help command with batchtools optimization
+  const helpCommand = `---
 name: claude-flow-help
 description: Show Claude-Flow commands and usage with batchtools optimization
 ---
@@ -237,10 +238,12 @@ npx -y claude-flow@latest init --sparc --force
 
 For comprehensive documentation and optimization guides, see the resources above.
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
-    console.log('  ✓ Created optimized slash command: /claude-flow-help (Batchtools enhanced)');
-    // Memory command with batchtools optimization
-    const memoryCommand = `---
+
+  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
+  console.log('  ✓ Created optimized slash command: /claude-flow-help (Batchtools enhanced)');
+
+  // Memory command with batchtools optimization
+  const memoryCommand = `---
 name: claude-flow-memory
 description: Interact with Claude-Flow memory system using batchtools optimization
 ---
@@ -526,10 +529,12 @@ The memory system provides persistent storage for cross-session and cross-agent
 
 For comprehensive memory system documentation and optimization guides, see: https://github.com/ruvnet/claude-code-flow/docs/memory-batchtools.md
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
-    console.log('  ✓ Created optimized slash command: /claude-flow-memory (Batchtools enhanced)');
-    // Swarm command with batchtools optimization
-    const swarmCommand = `---
+
+  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
+  console.log('  ✓ Created optimized slash command: /claude-flow-memory (Batchtools enhanced)');
+
+  // Swarm command with batchtools optimization
+  const swarmCommand = `---
 name: claude-flow-swarm
 description: Coordinate multi-agent swarms for complex tasks with batchtools optimization
 ---
@@ -865,6 +870,7 @@ Swarms automatically use distributed memory with parallel processing for collabo
 
 For detailed documentation and optimization guides, see: https://github.com/ruvnet/claude-code-flow/docs/swarm-batchtools.md
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
-    console.log('  ✓ Created optimized slash command: /claude-flow-swarm (Batchtools enhanced)');
+
+  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
+  console.log('  ✓ Created optimized slash command: /claude-flow-swarm (Batchtools enhanced)');
 }

package/dist/src/cli/simple-commands/init/claude-commands/optimized-slash-commands.js

@@ -1,67 +1,91 @@
 // optimized-slash-commands.js - Create batchtools-optimized Claude Code slash commands
-import { createOptimizedSparcSlashCommand, createOptimizedMainSparcCommand } from "./optimized-sparc-commands.js";
-import { createOptimizedClaudeFlowCommands } from "./optimized-claude-flow-commands.js";
-import { copyTemplates } from "../template-copier.js";
-import { promises as fs } from "fs";
-import { join } from "path";
+
+import {
+  createOptimizedSparcSlashCommand,
+  createOptimizedMainSparcCommand,
+} from './optimized-sparc-commands.js';
+import { createOptimizedClaudeFlowCommands } from './optimized-claude-flow-commands.js';
+import { copyTemplates } from '../template-copier.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+
 // Create batchtools-optimized Claude Code slash commands for SPARC modes
 export async function createOptimizedClaudeSlashCommands(workingDir, selectedModes = null) {
+  try {
+    console.log('\n🚀 Creating batchtools-optimized Claude Code slash commands...');
+
+    // Use template copier with optimized flag
+    const optimizedOptions = {
+      sparc: true,
+      optimized: true,
+      force: true,
+      dryRun: false,
+      selectedModes: selectedModes,
+    };
+
+    // Check if .roomodes exists for dynamic generation
+    const roomodesPath = `${workingDir}/.roomodes`;
     try {
-        console.log('\n🚀 Creating batchtools-optimized Claude Code slash commands...');
-        // Use template copier with optimized flag
-        const optimizedOptions = {
-            sparc: true,
-            optimized: true,
-            force: true,
-            dryRun: false,
-            selectedModes: selectedModes
-        };
-        // Check if .roomodes exists for dynamic generation
-        const roomodesPath = `${workingDir}/.roomodes`;
-        try {
-            const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
-            const roomodes = JSON.parse(roomodesContent);
-            // Filter modes if selective initialization is requested
-            const modesToCreate = selectedModes ? roomodes.customModes.filter((mode)=>selectedModes.includes(mode.slug)) : roomodes.customModes;
-            console.log(`  📝 Creating optimized commands for ${modesToCreate.length} modes...`);
-            // Create slash commands for each SPARC mode with batchtools optimization
-            const commandPromises = modesToCreate.map(async (mode)=>{
-                const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
-                const commandContent = createOptimizedSparcSlashCommand(mode);
-                await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), {
-                    recursive: true
-                });
-                await fs.writeFile(commandPath, commandContent, 'utf8');
-                console.log(`  ✓ Created optimized slash command: /sparc-${mode.slug} (Batchtools enhanced)`);
-            });
-            // Execute all command creations in parallel
-            await Promise.all(commandPromises);
-            // Create main SPARC command with batchtools optimization
-            const mainSparcCommand = createOptimizedMainSparcCommand(roomodes.customModes);
-            await fs.writeFile(join(workingDir, '.claude', 'commands', 'sparc.md', 'utf8'), mainSparcCommand);
-            console.log('  ✅ Created optimized main slash command: /sparc (Batchtools enhanced)');
-            console.log(`  🎯 Total optimized commands created: ${modesToCreate.length + 5}`);
-        } catch (err) {
-            // Fallback to template copier if .roomodes doesn't exist
-            console.log('  🔄 Using template copier for optimized SPARC commands...');
-            const copyResults = await copyTemplates(workingDir, optimizedOptions);
-            if (!copyResults.success) {
-                console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
-            }
-        }
-        // Create claude-flow-novice specific commands with batchtools optimization
-        await createOptimizedClaudeFlowCommands(workingDir);
-        // Create batchtools-specific commands
-        await createBatchtoolsCommands(workingDir);
-        console.log('  💡 All commands include parallel processing and performance optimizations');
+      const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
+      const roomodes = JSON.parse(roomodesContent);
+
+      // Filter modes if selective initialization is requested
+      const modesToCreate = selectedModes
+        ? roomodes.customModes.filter((mode) => selectedModes.includes(mode.slug))
+        : roomodes.customModes;
+
+      console.log(`  📝 Creating optimized commands for ${modesToCreate.length} modes...`);
+
+      // Create slash commands for each SPARC mode with batchtools optimization
+      const commandPromises = modesToCreate.map(async (mode) => {
+        const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
+        const commandContent = createOptimizedSparcSlashCommand(mode);
+
+        await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), { recursive: true });
+        await fs.writeFile(commandPath, commandContent, 'utf8');
+        console.log(
+          `  ✓ Created optimized slash command: /sparc-${mode.slug} (Batchtools enhanced)`,
+        );
+      });
+
+      // Execute all command creations in parallel
+      await Promise.all(commandPromises);
+
+      // Create main SPARC command with batchtools optimization
+      const mainSparcCommand = createOptimizedMainSparcCommand(roomodes.customModes);
+      await fs.writeFile(
+        join(workingDir, '.claude', 'commands', 'sparc.md', 'utf8'),
+        mainSparcCommand,
+      );
+      console.log('  ✅ Created optimized main slash command: /sparc (Batchtools enhanced)');
+
+      console.log(`  🎯 Total optimized commands created: ${modesToCreate.length + 5}`);
     } catch (err) {
-        console.log(`  ⚠️  Could not create optimized Claude Code slash commands: ${err.message}`);
+      // Fallback to template copier if .roomodes doesn't exist
+      console.log('  🔄 Using template copier for optimized SPARC commands...');
+      const copyResults = await copyTemplates(workingDir, optimizedOptions);
+
+      if (!copyResults.success) {
+        console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
+      }
     }
+
+    // Create claude-flow-novice specific commands with batchtools optimization
+    await createOptimizedClaudeFlowCommands(workingDir);
+
+    // Create batchtools-specific commands
+    await createBatchtoolsCommands(workingDir);
+
+    console.log('  💡 All commands include parallel processing and performance optimizations');
+  } catch (err) {
+    console.log(`  ⚠️  Could not create optimized Claude Code slash commands: ${err.message}`);
+  }
 }
+
 // Create batchtools-specific commands
 async function createBatchtoolsCommands(workingDir) {
-    // Batchtools help command
-    const batchtoolsCommand = `---
+  // Batchtools help command
+  const batchtoolsCommand = `---
 name: batchtools
 description: Execute operations with parallel processing and batch optimization
 ---
@@ -228,10 +252,12 @@ Chain operations with parallel execution at each stage:
 
 For detailed documentation, see: https://github.com/ruvnet/claude-code-flow/docs/batchtools.md
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/batchtools.md`, batchtoolsCommand, 'utf8');
-    console.log('  ✓ Created slash command: /batchtools');
-    // Performance monitoring command
-    const performanceCommand = `---
+
+  await fs.writeFile(`${workingDir}/.claude/commands/batchtools.md`, batchtoolsCommand, 'utf8');
+  console.log('  ✓ Created slash command: /batchtools');
+
+  // Performance monitoring command
+  const performanceCommand = `---
 name: performance
 description: Monitor and optimize system performance with batchtools
 ---
@@ -324,6 +350,7 @@ Real-time performance monitoring and optimization tools for Claude-Flow operatio
 
 For comprehensive performance guides, see: https://github.com/ruvnet/claude-code-flow/docs/performance.md
 `;
-    await fs.writeFile(`${workingDir}/.claude/commands/performance.md`, performanceCommand, 'utf8');
-    console.log('  ✓ Created slash command: /performance');
+
+  await fs.writeFile(`${workingDir}/.claude/commands/performance.md`, performanceCommand, 'utf8');
+  console.log('  ✓ Created slash command: /performance');
 }

package/dist/src/cli/simple-commands/init/claude-commands/optimized-sparc-commands.js

@@ -1,9 +1,14 @@
 // optimized-sparc-commands.js - Batchtools-optimized SPARC-specific slash commands
+
 // Create batchtools-optimized SPARC mode slash command
 export function createOptimizedSparcSlashCommand(mode) {
-    // Extract the full description without truncation
-    const fullDescription = mode.roleDefinition.length > 100 ? `${mode.roleDefinition.substring(0, 97)}...` : mode.roleDefinition;
-    return `---
+  // Extract the full description without truncation
+  const fullDescription =
+    mode.roleDefinition.length > 100
+      ? `${mode.roleDefinition.substring(0, 97)}...`
+      : mode.roleDefinition;
+
+  return `---
 name: sparc-${mode.slug}
 description: ${mode.name} - ${fullDescription} (Batchtools Optimized)
 ---
@@ -31,14 +36,20 @@ ${mode.customInstructions}
 - **Resource Optimization**: Efficient utilization with parallel processing
 
 ## Available Tools (Enhanced)
-${Array.isArray(mode.groups) ? mode.groups.map((g)=>{
-        if (typeof g === 'string') {
+${
+  Array.isArray(mode.groups)
+    ? mode.groups
+        .map((g) => {
+          if (typeof g === 'string') {
             return `- **${g}**: ${getOptimizedToolDescription(g)}`;
-        } else if (Array.isArray(g)) {
+          } else if (Array.isArray(g)) {
             return `- **${g[0]}**: ${g[1]?.description || getOptimizedToolDescription(g[0])} ${g[1]?.fileRegex ? `(Files matching: ${g[1].fileRegex})` : ''} - *Batchtools enabled*`;
-        }
-        return `- ${JSON.stringify(g)}`;
-    }).join('\n') : 'None'}
+          }
+          return `- ${JSON.stringify(g)}`;
+        })
+        .join('\n')
+    : 'None'
+}
 
 ### Batchtools Integration
 - **parallel()**: Execute multiple operations concurrently
@@ -171,133 +182,147 @@ For detailed ${mode.name} documentation and batchtools integration guides, see:
 - Batchtools Integration: https://github.com/ruvnet/claude-code-flow/docs/batchtools-${mode.slug}.md
 `;
 }
+
 // Helper function to get optimized tool descriptions
 function getOptimizedToolDescription(tool) {
-    const toolDescriptions = {
-        read: 'File reading and viewing with parallel processing',
-        edit: 'File modification and creation with batch operations',
-        browser: 'Web browsing capabilities with concurrent requests',
-        mcp: 'Model Context Protocol tools with parallel communication',
-        command: 'Command execution with concurrent processing'
-    };
-    return toolDescriptions[tool] || 'Tool access with batchtools optimization';
+  const toolDescriptions = {
+    read: 'File reading and viewing with parallel processing',
+    edit: 'File modification and creation with batch operations',
+    browser: 'Web browsing capabilities with concurrent requests',
+    mcp: 'Model Context Protocol tools with parallel communication',
+    command: 'Command execution with concurrent processing',
+  };
+  return toolDescriptions[tool] || 'Tool access with batchtools optimization';
 }
+
 // Helper function to get optimized example tasks
 function getOptimizedExampleTask(slug) {
-    const examples = {
-        architect: 'design microservices architecture with parallel component analysis',
-        code: 'implement REST API endpoints with concurrent optimization',
-        tdd: 'create user authentication tests with parallel test generation',
-        debug: 'fix memory leak in service with concurrent analysis',
-        'security-review': 'audit API security with parallel vulnerability assessment',
-        'docs-writer': 'create API documentation with concurrent content generation',
-        integration: 'connect payment service with parallel testing',
-        'post-deployment-monitoring-mode': 'monitor production metrics with real-time parallel analysis',
-        'refinement-optimization-mode': 'optimize database queries with concurrent profiling',
-        devops: 'deploy to AWS Lambda with parallel environment setup',
-        'supabase-admin': 'create user authentication schema with batch operations',
-        'spec-pseudocode': 'define payment flow requirements with concurrent validation',
-        mcp: 'integrate with external API using parallel configuration',
-        swarm: 'build complete feature with parallel testing and documentation',
-        sparc: 'orchestrate authentication system with concurrent coordination',
-        ask: 'help me choose the right mode with parallel analysis',
-        tutorial: 'guide me through SPARC methodology with interactive parallel examples'
-    };
-    return examples[slug] || 'implement feature with batchtools optimization';
+  const examples = {
+    architect: 'design microservices architecture with parallel component analysis',
+    code: 'implement REST API endpoints with concurrent optimization',
+    tdd: 'create user authentication tests with parallel test generation',
+    debug: 'fix memory leak in service with concurrent analysis',
+    'security-review': 'audit API security with parallel vulnerability assessment',
+    'docs-writer': 'create API documentation with concurrent content generation',
+    integration: 'connect payment service with parallel testing',
+    'post-deployment-monitoring-mode':
+      'monitor production metrics with real-time parallel analysis',
+    'refinement-optimization-mode': 'optimize database queries with concurrent profiling',
+    devops: 'deploy to AWS Lambda with parallel environment setup',
+    'supabase-admin': 'create user authentication schema with batch operations',
+    'spec-pseudocode': 'define payment flow requirements with concurrent validation',
+    mcp: 'integrate with external API using parallel configuration',
+    swarm: 'build complete feature with parallel testing and documentation',
+    sparc: 'orchestrate authentication system with concurrent coordination',
+    ask: 'help me choose the right mode with parallel analysis',
+    tutorial: 'guide me through SPARC methodology with interactive parallel examples',
+  };
+  return examples[slug] || 'implement feature with batchtools optimization';
 }
+
 // Helper function to get batchtools best practices for specific modes
 function getBatchtoolsPractices(slug) {
-    const practices = {
-        architect: {
-            parallel: [
-                'Analyzing multiple architectural patterns simultaneously',
-                'Generating component diagrams concurrently',
-                'Validating integration points in parallel',
-                'Creating multiple design alternatives simultaneously'
-            ],
-            optimization: [
-                'Use batch operations for creating multiple architecture documents',
-                'Enable parallel analysis for complex system designs',
-                'Implement concurrent validation for architectural decisions',
-                'Use pipeline processing for multi-stage architecture design'
-            ],
-            performance: [
-                'Monitor resource usage during large architecture analysis',
-                'Use smart batching for related architectural components',
-                'Enable concurrent processing for independent design elements',
-                'Implement parallel validation for architecture consistency'
-            ]
-        },
-        code: {
-            parallel: [
-                'Implementing multiple functions or classes simultaneously',
-                'Analyzing code patterns across multiple files',
-                'Performing concurrent code optimization',
-                'Generating multiple code modules in parallel'
-            ],
-            optimization: [
-                'Use batch operations for creating multiple source files',
-                'Enable parallel code analysis for large codebases',
-                'Implement concurrent optimization for performance improvements',
-                'Use pipeline processing for multi-stage code generation'
-            ],
-            performance: [
-                'Monitor compilation performance during parallel code generation',
-                'Use smart batching for related code modules',
-                'Enable concurrent processing for independent code components',
-                'Implement parallel validation for code quality checks'
-            ]
-        },
-        tdd: {
-            parallel: [
-                'Creating multiple test cases simultaneously',
-                'Running test suites concurrently',
-                'Analyzing test coverage in parallel',
-                'Generating test data and fixtures simultaneously'
-            ],
-            optimization: [
-                'Use batch operations for creating comprehensive test suites',
-                'Enable parallel test execution for faster feedback',
-                'Implement concurrent test analysis for coverage reports',
-                'Use pipeline processing for multi-stage testing workflows'
-            ],
-            performance: [
-                'Monitor test execution performance during parallel runs',
-                'Use smart batching for related test scenarios',
-                'Enable concurrent processing for independent test modules',
-                'Implement parallel validation for test result analysis'
-            ]
-        }
-    };
-    return practices[slug] || {
-        parallel: [
-            'Processing multiple independent components simultaneously',
-            'Analyzing different aspects concurrently',
-            'Generating multiple artifacts in parallel',
-            'Validating multiple criteria simultaneously'
-        ],
-        optimization: [
-            'Use batch operations for related tasks',
-            'Enable parallel processing for independent operations',
-            'Implement concurrent validation and analysis',
-            'Use pipeline processing for complex workflows'
-        ],
-        performance: [
-            'Monitor system resources during parallel operations',
-            'Use smart batching for optimal performance',
-            'Enable concurrent processing based on system capabilities',
-            'Implement parallel validation for comprehensive analysis'
-        ]
-    };
+  const practices = {
+    architect: {
+      parallel: [
+        'Analyzing multiple architectural patterns simultaneously',
+        'Generating component diagrams concurrently',
+        'Validating integration points in parallel',
+        'Creating multiple design alternatives simultaneously',
+      ],
+      optimization: [
+        'Use batch operations for creating multiple architecture documents',
+        'Enable parallel analysis for complex system designs',
+        'Implement concurrent validation for architectural decisions',
+        'Use pipeline processing for multi-stage architecture design',
+      ],
+      performance: [
+        'Monitor resource usage during large architecture analysis',
+        'Use smart batching for related architectural components',
+        'Enable concurrent processing for independent design elements',
+        'Implement parallel validation for architecture consistency',
+      ],
+    },
+    code: {
+      parallel: [
+        'Implementing multiple functions or classes simultaneously',
+        'Analyzing code patterns across multiple files',
+        'Performing concurrent code optimization',
+        'Generating multiple code modules in parallel',
+      ],
+      optimization: [
+        'Use batch operations for creating multiple source files',
+        'Enable parallel code analysis for large codebases',
+        'Implement concurrent optimization for performance improvements',
+        'Use pipeline processing for multi-stage code generation',
+      ],
+      performance: [
+        'Monitor compilation performance during parallel code generation',
+        'Use smart batching for related code modules',
+        'Enable concurrent processing for independent code components',
+        'Implement parallel validation for code quality checks',
+      ],
+    },
+    tdd: {
+      parallel: [
+        'Creating multiple test cases simultaneously',
+        'Running test suites concurrently',
+        'Analyzing test coverage in parallel',
+        'Generating test data and fixtures simultaneously',
+      ],
+      optimization: [
+        'Use batch operations for creating comprehensive test suites',
+        'Enable parallel test execution for faster feedback',
+        'Implement concurrent test analysis for coverage reports',
+        'Use pipeline processing for multi-stage testing workflows',
+      ],
+      performance: [
+        'Monitor test execution performance during parallel runs',
+        'Use smart batching for related test scenarios',
+        'Enable concurrent processing for independent test modules',
+        'Implement parallel validation for test result analysis',
+      ],
+    },
+  };
+
+  return (
+    practices[slug] || {
+      parallel: [
+        'Processing multiple independent components simultaneously',
+        'Analyzing different aspects concurrently',
+        'Generating multiple artifacts in parallel',
+        'Validating multiple criteria simultaneously',
+      ],
+      optimization: [
+        'Use batch operations for related tasks',
+        'Enable parallel processing for independent operations',
+        'Implement concurrent validation and analysis',
+        'Use pipeline processing for complex workflows',
+      ],
+      performance: [
+        'Monitor system resources during parallel operations',
+        'Use smart batching for optimal performance',
+        'Enable concurrent processing based on system capabilities',
+        'Implement parallel validation for comprehensive analysis',
+      ],
+    }
+  );
 }
+
 // Create optimized main SPARC command
 export function createOptimizedMainSparcCommand(modes) {
-    const modeList = modes.map((m)=>`- \`/sparc-${m.slug}\` - ${m.name} (Batchtools optimized)`).join('\n');
-    // Find the sparc orchestrator mode for its full description
-    const sparcMode = modes.find((m)=>m.slug === 'sparc');
-    const sparcDescription = sparcMode ? sparcMode.roleDefinition : 'SPARC orchestrator for complex workflows';
-    const sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
-    return `---
+  const modeList = modes
+    .map((m) => `- \`/sparc-${m.slug}\` - ${m.name} (Batchtools optimized)`)
+    .join('\n');
+
+  // Find the sparc orchestrator mode for its full description
+  const sparcMode = modes.find((m) => m.slug === 'sparc');
+  const sparcDescription = sparcMode
+    ? sparcMode.roleDefinition
+    : 'SPARC orchestrator for complex workflows';
+  const sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
+
+  return `---
 name: sparc
 description: Execute SPARC methodology workflows with Claude-Flow and batchtools optimization
 ---