claude-flow-novice 1.3.2 → 1.3.4

package/src/cli/simple-commands/sparc-modes/security-review.js

@@ -7,9 +7,9 @@ export function getSecurityReviewOrchestration(taskDescription, memoryNamespace)
    - Define audit boundaries for: "${taskDescription}"
    - Query system architecture and sensitive areas:
      \`\`\`bash
-     npx claude-flow memory query ${memoryNamespace}_architecture
-     npx claude-flow memory query ${memoryNamespace}_auth
-     npx claude-flow memory query ${memoryNamespace}_config
+     npx claude-flow-novice memory query ${memoryNamespace}_architecture
+     npx claude-flow-novice memory query ${memoryNamespace}_auth
+     npx claude-flow-novice memory query ${memoryNamespace}_config
      \`\`\`
    - Identify critical assets:
      - User data and PII
@@ -19,7 +19,7 @@ export function getSecurityReviewOrchestration(taskDescription, memoryNamespace)
    - Map data flows and trust boundaries
    - List all external interfaces and integrations
    - Review authentication/authorization points
-   - Store scope: \`npx claude-flow memory store ${memoryNamespace}_security_scope "Audit scope: ${taskDescription}. Critical assets: user PII, JWT tokens, payment data. External interfaces: REST API, webhooks, third-party integrations."\`
+   - Store scope: \`npx claude-flow-novice memory store ${memoryNamespace}_security_scope "Audit scope: ${taskDescription}. Critical assets: user PII, JWT tokens, payment data. External interfaces: REST API, webhooks, third-party integrations."\`
 
 2. **Static Security Analysis** (20 mins)
    - Scan for hardcoded secrets and credentials:
@@ -47,7 +47,7 @@ export function getSecurityReviewOrchestration(taskDescription, memoryNamespace)
      \`\`\`bash
      npm audit
      \`\`\`
-   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_vulnerabilities "Critical: 2 hardcoded API keys found. High: Missing input validation in user-controller. Medium: Outdated JWT library. Low: Verbose error messages expose stack traces."\`
+   - Store findings: \`npx claude-flow-novice memory store ${memoryNamespace}_vulnerabilities "Critical: 2 hardcoded API keys found. High: Missing input validation in user-controller. Medium: Outdated JWT library. Low: Verbose error messages expose stack traces."\`
 
 3. **Dynamic Security Analysis** (10 mins)
    - Test authentication flows:
@@ -61,7 +61,7 @@ export function getSecurityReviewOrchestration(taskDescription, memoryNamespace)
    - Analyze rate limiting and DoS protection
    - Review CORS and CSP policies
    - Test error handling for information leakage
-   - Store dynamic findings: \`npx claude-flow memory store ${memoryNamespace}_dynamic_findings "Auth bypass: None found. Rate limiting: Missing on login endpoint. CORS: Overly permissive. Error handling: Leaks database schema in dev mode."\`
+   - Store dynamic findings: \`npx claude-flow-novice memory store ${memoryNamespace}_dynamic_findings "Auth bypass: None found. Rate limiting: Missing on login endpoint. CORS: Overly permissive. Error handling: Leaks database schema in dev mode."\`
 
 4. **Risk Assessment & Prioritization** (15 mins)
    - Categorize findings by severity (CVSS scores):
@@ -76,7 +76,7 @@ export function getSecurityReviewOrchestration(taskDescription, memoryNamespace)
    - Calculate risk scores (likelihood × impact)
    - Prioritize remediation efforts
    - Document attack vectors and exploit scenarios
-   - Store assessment: \`npx claude-flow memory store ${memoryNamespace}_risk_assessment "Critical risks: 2 (hardcoded secrets, missing auth on admin endpoints). High risks: 3 (outdated deps, missing rate limiting, weak session management). Compliance impact: GDPR violation risk due to logging PII."\`
+   - Store assessment: \`npx claude-flow-novice memory store ${memoryNamespace}_risk_assessment "Critical risks: 2 (hardcoded secrets, missing auth on admin endpoints). High risks: 3 (outdated deps, missing rate limiting, weak session management). Compliance impact: GDPR violation risk due to logging PII."\`
 
 5. **Remediation Plan & Implementation** (10 mins)
    - Create specific fix recommendations:
@@ -93,7 +93,7 @@ export function getSecurityReviewOrchestration(taskDescription, memoryNamespace)
      - Set up security monitoring
    - Create security checklist for future development
    - Implement critical fixes if authorized
-   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_remediation_plan "Immediate: Remove hardcoded secrets, fix auth bypass. Next sprint: Implement rate limiting, update dependencies. Future: Add WAF, implement SIEM integration."\`
+   - Store plan: \`npx claude-flow-novice memory store ${memoryNamespace}_remediation_plan "Immediate: Remove hardcoded secrets, fix auth bypass. Next sprint: Implement rate limiting, update dependencies. Future: Add WAF, implement SIEM integration."\`
 
 ## Deliverables
 - security-audit-report.md:
@@ -124,7 +124,7 @@ export function getSecurityReviewOrchestration(taskDescription, memoryNamespace)
 
 ## Next Steps
 After security review:
-- \`npx claude-flow sparc run code "Implement security remediation plan" --non-interactive\`
-- \`npx claude-flow sparc run tdd "Write security test cases" --non-interactive\`
-- \`npx claude-flow sparc run post-deployment-monitoring-mode "Set up security monitoring and alerts" --non-interactive\``;
+- \`npx claude-flow-novice sparc run code "Implement security remediation plan" --non-interactive\`
+- \`npx claude-flow-novice sparc run tdd "Write security test cases" --non-interactive\`
+- \`npx claude-flow-novice sparc run post-deployment-monitoring-mode "Set up security monitoring and alerts" --non-interactive\``;
 }

package/src/cli/simple-commands/sparc-modes/sparc-orchestrator.js

@@ -12,22 +12,22 @@ For maximum efficiency, I can orchestrate multiple SPARC modes concurrently usin
 # Full SPARC Workflow with BatchTool (Boomerang Pattern)
 batchtool orchestrate --boomerang --name "${taskDescription}" \\
   --phase1-parallel \\
-    "npx claude-flow sparc run ask 'research requirements for ${taskDescription}' --non-interactive" \\
-    "npx claude-flow sparc run security-review 'identify security needs for ${taskDescription}' --non-interactive" \\
+    "npx claude-flow-novice sparc run ask 'research requirements for ${taskDescription}' --non-interactive" \\
+    "npx claude-flow-novice sparc run security-review 'identify security needs for ${taskDescription}' --non-interactive" \\
   --phase2-sequential \\
-    "npx claude-flow sparc run spec-pseudocode 'create specifications from research' --non-interactive" \\
-    "npx claude-flow sparc run architect 'design system architecture' --non-interactive" \\
+    "npx claude-flow-novice sparc run spec-pseudocode 'create specifications from research' --non-interactive" \\
+    "npx claude-flow-novice sparc run architect 'design system architecture' --non-interactive" \\
   --phase3-parallel \\
-    "npx claude-flow sparc run code 'implement core features' --non-interactive" \\
-    "npx claude-flow sparc run code 'implement authentication' --non-interactive" \\
-    "npx claude-flow sparc run code 'implement data layer' --non-interactive" \\
+    "npx claude-flow-novice sparc run code 'implement core features' --non-interactive" \\
+    "npx claude-flow-novice sparc run code 'implement authentication' --non-interactive" \\
+    "npx claude-flow-novice sparc run code 'implement data layer' --non-interactive" \\
   --phase4-sequential \\
-    "npx claude-flow sparc run integration 'integrate all components' --non-interactive" \\
-    "npx claude-flow sparc run tdd 'comprehensive testing' --non-interactive" \\
+    "npx claude-flow-novice sparc run integration 'integrate all components' --non-interactive" \\
+    "npx claude-flow-novice sparc run tdd 'comprehensive testing' --non-interactive" \\
   --phase5-parallel \\
-    "npx claude-flow sparc run optimization 'performance tuning' --non-interactive" \\
-    "npx claude-flow sparc run docs-writer 'create documentation' --non-interactive" \\
-    "npx claude-flow sparc run devops 'deployment setup' --non-interactive"
+    "npx claude-flow-novice sparc run optimization 'performance tuning' --non-interactive" \\
+    "npx claude-flow-novice sparc run docs-writer 'create documentation' --non-interactive" \\
+    "npx claude-flow-novice sparc run devops 'deployment setup' --non-interactive"
 
 # Monitor all parallel executions
 batchtool monitor --dashboard
@@ -39,8 +39,8 @@ batchtool monitor --dashboard
    - Analyze the complex objective: "${taskDescription}"
    - Query existing context:
      \`\`\`bash
-     npx claude-flow memory query ${memoryNamespace}
-     npx claude-flow memory list
+     npx claude-flow-novice memory query ${memoryNamespace}
+     npx claude-flow-novice memory list
      \`\`\`
    - Break down into SPARC phases:
      - **S**pecification: Define what needs to be built
@@ -50,79 +50,79 @@ batchtool monitor --dashboard
      - **C**ompletion: Integrate, document, and deploy
    - Identify required specialist modes
    - Create task dependency graph
-   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_sparc_plan "Objective: ${taskDescription}. Phases: 5. Estimated subtasks: 12. Critical path: spec->arch->tdd->integration."\`
+   - Store plan: \`npx claude-flow-novice memory store ${memoryNamespace}_sparc_plan "Objective: ${taskDescription}. Phases: 5. Estimated subtasks: 12. Critical path: spec->arch->tdd->integration."\`
 
 2. **Specification Phase Delegation** (10 mins)
    - Create specification subtasks:
      \`\`\`bash
      # Delegate requirements gathering
-     npx claude-flow sparc run spec-pseudocode "Define detailed requirements for ${taskDescription}" --non-interactive
+     npx claude-flow-novice sparc run spec-pseudocode "Define detailed requirements for ${taskDescription}" --non-interactive
      
      # Store task assignment
-     npx claude-flow memory store ${memoryNamespace}_task_spec "Assigned to: spec-pseudocode mode. Status: In progress. Dependencies: None."
+     npx claude-flow-novice memory store ${memoryNamespace}_task_spec "Assigned to: spec-pseudocode mode. Status: In progress. Dependencies: None."
      \`\`\`
    - Monitor specification progress
    - Review deliverables: requirements.md, pseudocode.md
    - Validate no hardcoded env vars allowed
-   - Store spec results: \`npx claude-flow memory store ${memoryNamespace}_spec_complete "Requirements defined. Pseudocode created. Edge cases identified. Ready for architecture phase."\`
+   - Store spec results: \`npx claude-flow-novice memory store ${memoryNamespace}_spec_complete "Requirements defined. Pseudocode created. Edge cases identified. Ready for architecture phase."\`
 
 3. **Architecture Phase Delegation** (15 mins)
    - Create architecture subtasks:
      \`\`\`bash
      # Delegate system design
-     npx claude-flow sparc run architect "Design scalable architecture for ${taskDescription}" --non-interactive
+     npx claude-flow-novice sparc run architect "Design scalable architecture for ${taskDescription}" --non-interactive
      
      # Store task assignment
-     npx claude-flow memory store ${memoryNamespace}_task_arch "Assigned to: architect mode. Status: In progress. Dependencies: spec_complete."
+     npx claude-flow-novice memory store ${memoryNamespace}_task_arch "Assigned to: architect mode. Status: In progress. Dependencies: spec_complete."
      \`\`\`
    - Ensure modular design (< 500 lines per file)
    - Verify extensible service boundaries
    - Review security architecture
-   - Store arch results: \`npx claude-flow memory store ${memoryNamespace}_arch_complete "Architecture designed. APIs defined. Security boundaries established. Ready for implementation."\`
+   - Store arch results: \`npx claude-flow-novice memory store ${memoryNamespace}_arch_complete "Architecture designed. APIs defined. Security boundaries established. Ready for implementation."\`
 
 4. **Refinement Phase Orchestration** (20 mins)
    - Coordinate parallel implementation tasks:
      \`\`\`bash
      # TDD implementation
-     npx claude-flow sparc run tdd "Implement core functionality with tests" --non-interactive
+     npx claude-flow-novice sparc run tdd "Implement core functionality with tests" --non-interactive
      
      # Main code implementation
-     npx claude-flow sparc run code "Build modular implementation following architecture" --non-interactive
+     npx claude-flow-novice sparc run code "Build modular implementation following architecture" --non-interactive
      
      # Security review
-     npx claude-flow sparc run security-review "Audit implementation for vulnerabilities" --non-interactive
+     npx claude-flow-novice sparc run security-review "Audit implementation for vulnerabilities" --non-interactive
      
      # Debugging support
-     npx claude-flow sparc run debug "Investigate and fix any issues" --non-interactive
+     npx claude-flow-novice sparc run debug "Investigate and fix any issues" --non-interactive
      
      # Store parallel task status
-     npx claude-flow memory store ${memoryNamespace}_refinement_tasks "TDD: 80% complete. Code: 60% complete. Security: Pending. Debug: On standby."\`
+     npx claude-flow-novice memory store ${memoryNamespace}_refinement_tasks "TDD: 80% complete. Code: 60% complete. Security: Pending. Debug: On standby."\`
    - Monitor task progress
    - Resolve dependencies and conflicts
    - Ensure all files < 500 lines
-   - Store refinement status: \`npx claude-flow memory store ${memoryNamespace}_refinement_progress "Core features implemented. Tests passing. Security review in progress."\`
+   - Store refinement status: \`npx claude-flow-novice memory store ${memoryNamespace}_refinement_progress "Core features implemented. Tests passing. Security review in progress."\`
 
 5. **Completion Phase Coordination** (15 mins)
    - Final integration and deployment tasks:
      \`\`\`bash
      # System integration
-     npx claude-flow sparc run integration "Integrate all components" --non-interactive
+     npx claude-flow-novice sparc run integration "Integrate all components" --non-interactive
      
      # Documentation
-     npx claude-flow sparc run docs-writer "Create comprehensive documentation" --non-interactive
+     npx claude-flow-novice sparc run docs-writer "Create comprehensive documentation" --non-interactive
      
      # Optimization
-     npx claude-flow sparc run refinement-optimization-mode "Optimize performance and structure" --non-interactive
+     npx claude-flow-novice sparc run refinement-optimization-mode "Optimize performance and structure" --non-interactive
      
      # DevOps deployment
-     npx claude-flow sparc run devops "Deploy to production" --non-interactive
+     npx claude-flow-novice sparc run devops "Deploy to production" --non-interactive
      
      # Monitoring setup
-     npx claude-flow sparc run post-deployment-monitoring-mode "Configure production monitoring" --non-interactive
+     npx claude-flow-novice sparc run post-deployment-monitoring-mode "Configure production monitoring" --non-interactive
      \`\`\`
    - Validate all deliverables
    - Ensure continuous improvement setup
-   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_sparc_complete "Project delivered. All phases complete. Documentation ready. Deployed to production. Monitoring active."\`
+   - Store completion: \`npx claude-flow-novice memory store ${memoryNamespace}_sparc_complete "Project delivered. All phases complete. Documentation ready. Deployed to production. Monitoring active."\`
 
 ## Task Delegation Strategy
 
@@ -148,16 +148,16 @@ For each subtask, I will:
 ## Orchestration Commands
 \`\`\`bash
 # Check overall progress
-npx claude-flow memory query ${memoryNamespace}_sparc
+npx claude-flow-novice memory query ${memoryNamespace}_sparc
 
 # View specific phase status
-npx claude-flow memory query ${memoryNamespace}_refinement
+npx claude-flow-novice memory query ${memoryNamespace}_refinement
 
 # Check task dependencies
-npx claude-flow memory query ${memoryNamespace}_dependencies
+npx claude-flow-novice memory query ${memoryNamespace}_dependencies
 
 # Monitor active tasks
-npx claude-flow status
+npx claude-flow-novice status
 \`\`\`
 
 ## Next Steps

package/src/cli/simple-commands/sparc-modes/spec-pseudocode.js

@@ -8,21 +8,21 @@ export function getSpecPseudocodeOrchestration(taskDescription, memoryNamespace)
    - Extract functional requirements
    - Identify constraints and edge cases
    - Define success criteria
-   - Store requirements: \`npx claude-flow memory store ${memoryNamespace}_requirements "..."\`
+   - Store requirements: \`npx claude-flow-novice memory store ${memoryNamespace}_requirements "..."\`
 
 2. **Specification Writing** (20 mins)
    - Create detailed specifications
    - Define input/output contracts
    - Document business rules
    - Specify error conditions
-   - Store specs: \`npx claude-flow memory store ${memoryNamespace}_specifications "..."\`
+   - Store specs: \`npx claude-flow-novice memory store ${memoryNamespace}_specifications "..."\`
 
 3. **Pseudocode Development** (20 mins)
    - Write high-level algorithms
    - Define data structures
    - Map process flows
    - Include TDD anchors
-   - Store pseudocode: \`npx claude-flow memory store ${memoryNamespace}_pseudocode "..."\`
+   - Store pseudocode: \`npx claude-flow-novice memory store ${memoryNamespace}_pseudocode "..."\`
 
 4. **Modular Design** (10 mins)
    - Break into logical modules

package/src/cli/simple-commands/sparc-modes/supabase-admin.js

@@ -7,9 +7,9 @@ export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace)
    - Analyze database requirements: "${taskDescription}"
    - Query existing project context:
      \`\`\`bash
-     npx claude-flow memory query ${memoryNamespace}_architecture
-     npx claude-flow memory query ${memoryNamespace}_data_models
-     npx claude-flow memory query ${memoryNamespace}_auth_requirements
+     npx claude-flow-novice memory query ${memoryNamespace}_architecture
+     npx claude-flow-novice memory query ${memoryNamespace}_data_models
+     npx claude-flow-novice memory query ${memoryNamespace}_auth_requirements
      \`\`\`
    - Connect to Supabase via MCP:
      - List organizations: \`list_organizations\`
@@ -18,7 +18,7 @@ export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace)
    - Review cost implications:
      - Use \`get_cost\` before creating resources
      - Confirm costs with user via \`confirm_cost\`
-   - Store analysis: \`npx claude-flow memory store ${memoryNamespace}_supabase_requirements "Requirements: ${taskDescription}. Tables needed: users, profiles, permissions. Auth: Email + OAuth. Storage: user avatars, documents."\`
+   - Store analysis: \`npx claude-flow-novice memory store ${memoryNamespace}_supabase_requirements "Requirements: ${taskDescription}. Tables needed: users, profiles, permissions. Auth: Email + OAuth. Storage: user avatars, documents."\`
 
 2. **Database Schema Design** (15 mins)
    - Design PostgreSQL schemas optimized for Supabase:
@@ -35,7 +35,7 @@ export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace)
      - Composite indexes for queries
    - Design audit/history tables if needed
    - Create modular migration approach (<500 lines per file)
-   - Store design: \`npx claude-flow memory store ${memoryNamespace}_db_design "Tables: users (id, email, created_at), profiles (user_id, full_name, avatar_url), roles (id, name), user_roles (user_id, role_id). Indexes: users_email_idx, profiles_user_id_idx."\`
+   - Store design: \`npx claude-flow-novice memory store ${memoryNamespace}_db_design "Tables: users (id, email, created_at), profiles (user_id, full_name, avatar_url), roles (id, name), user_roles (user_id, role_id). Indexes: users_email_idx, profiles_user_id_idx."\`
 
 3. **Schema Implementation via MCP** (20 mins)
    - Create development branch (if needed):
@@ -59,7 +59,7 @@ export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace)
    - Add performance indexes
    - Create database functions and triggers
    - Set up audit trails
-   - Store migrations: \`npx claude-flow memory store ${memoryNamespace}_migrations "Created: 5 tables, 8 indexes, 3 functions, 2 triggers. Branch: dev-${Date.now()}. Ready for RLS policies."\`
+   - Store migrations: \`npx claude-flow-novice memory store ${memoryNamespace}_migrations "Created: 5 tables, 8 indexes, 3 functions, 2 triggers. Branch: dev-${Date.now()}. Ready for RLS policies."\`
 
 4. **Security & RLS Implementation** (15 mins)
    - Implement Row Level Security policies:
@@ -86,7 +86,7 @@ export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace)
        );
      $$ LANGUAGE SQL SECURITY DEFINER;
      \`\`\`
-   - Store security config: \`npx claude-flow memory store ${memoryNamespace}_security "RLS enabled on all tables. Policies: 15 created (CRUD + special cases). Auth providers: email, google. Custom claims: user_role, organization_id."\`
+   - Store security config: \`npx claude-flow-novice memory store ${memoryNamespace}_security "RLS enabled on all tables. Policies: 15 created (CRUD + special cases). Auth providers: email, google. Custom claims: user_role, organization_id."\`
 
 5. **API & Storage Configuration** (10 mins)
    - Generate TypeScript types:
@@ -102,7 +102,7 @@ export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace)
      - Create API documentation
    - Set up Edge Functions (if needed)
    - Test API access patterns
-   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_supabase_complete "Supabase setup complete. API URL: https://xxx.supabase.co. Types generated. Storage buckets: avatars (public), documents (authenticated). Ready for integration."\`
+   - Store completion: \`npx claude-flow-novice memory store ${memoryNamespace}_supabase_complete "Supabase setup complete. API URL: https://xxx.supabase.co. Types generated. Storage buckets: avatars (public), documents (authenticated). Ready for integration."\`
 
 ## Deliverables
 - migrations/
@@ -143,7 +143,7 @@ export function getSupabaseAdminOrchestration(taskDescription, memoryNamespace)
 
 ## Next Steps
 After Supabase setup:
-- \`npx claude-flow sparc run code "Integrate Supabase client in application" --non-interactive\`
-- \`npx claude-flow sparc run tdd "Write tests for Supabase operations" --non-interactive\`
-- \`npx claude-flow sparc run docs-writer "Create Supabase integration guide" --non-interactive\``;
+- \`npx claude-flow-novice sparc run code "Integrate Supabase client in application" --non-interactive\`
+- \`npx claude-flow-novice sparc run tdd "Write tests for Supabase operations" --non-interactive\`
+- \`npx claude-flow-novice sparc run docs-writer "Create Supabase integration guide" --non-interactive\``;
 }

package/src/cli/simple-commands/sparc-modes/swarm.js

@@ -115,19 +115,19 @@ You have access to the advanced Claude-Flow swarm system with the following capa
 ### Basic Swarm Execution:
 \`\`\`bash
 # Start a development swarm for complex implementation
-npx claude-flow swarm "Build a complete REST API with authentication" --strategy development --monitor
+npx claude-flow-novice swarm "Build a complete REST API with authentication" --strategy development --monitor
 
 # Research swarm with distributed coordination
-npx claude-flow swarm "Research and analyze blockchain technologies" --strategy research --distributed --ui
+npx claude-flow-novice swarm "Research and analyze blockchain technologies" --strategy research --distributed --ui
 
 # Background optimization swarm (for long-running tasks)
-npx claude-flow swarm "Optimize application performance across all modules" --strategy optimization --background --monitor
+npx claude-flow-novice swarm "Optimize application performance across all modules" --strategy optimization --background --monitor
 \`\`\`
 
 ### Advanced Swarm Configuration:
 \`\`\`bash
 # Full-featured swarm with all enterprise features
-npx claude-flow swarm "Complex enterprise application development" \\
+npx claude-flow-novice swarm "Complex enterprise application development" \\
   --strategy development \\
   --mode distributed \\
   --max-agents 10 \\
@@ -139,20 +139,20 @@ npx claude-flow swarm "Complex enterprise application development" \\
   --verbose
 
 # Dry run to see configuration before execution
-npx claude-flow swarm "Your complex task" --dry-run --strategy development
+npx claude-flow-novice swarm "Your complex task" --dry-run --strategy development
 \`\`\`
 
 ### 🔍 Monitoring and Management:
 \`\`\`bash
 # Real-time swarm monitoring
-npx claude-flow monitor
+npx claude-flow-novice monitor
 
 # Check swarm status
-npx claude-flow status
+npx claude-flow-novice status
 
 # Memory operations for cross-agent sharing
-npx claude-flow memory store "key" "value" --namespace swarm
-npx claude-flow memory query "search-term" --namespace swarm
+npx claude-flow-novice memory store "key" "value" --namespace swarm
+npx claude-flow-novice memory query "search-term" --namespace swarm
 \`\`\`
 
 ## 🎯 SWARM METHODOLOGY
@@ -191,7 +191,7 @@ The swarm system is specifically designed to handle complex, long-running tasks
 ### 🌙 Background Execution:
 - Use \`--background\` flag for tasks that might take over 60 minutes
 - Background swarms run independently and save results
-- Monitor progress with \`npx claude-flow status\`
+- Monitor progress with \`npx claude-flow-novice status\`
 
 ### 🔄 Task Splitting:
 - Large tasks are automatically decomposed into smaller chunks
@@ -208,40 +208,40 @@ The swarm system is specifically designed to handle complex, long-running tasks
 ### Complex Development Project:
 \`\`\`bash
 # 1. Start comprehensive development swarm
-npx claude-flow swarm "Build microservices e-commerce platform" \\
+npx claude-flow-novice swarm "Build microservices e-commerce platform" \\
   --strategy development --parallel --monitor --review --testing
 
 # 2. Monitor progress in real-time
-npx claude-flow monitor
+npx claude-flow-novice monitor
 
 # 3. Check specific swarm status
-npx claude-flow status
+npx claude-flow-novice status
 \`\`\`
 
 ### Research and Analysis:
 \`\`\`bash
 # 1. Launch research swarm with UI
-npx claude-flow swarm "Comprehensive AI/ML market analysis" \\
+npx claude-flow-novice swarm "Comprehensive AI/ML market analysis" \\
   --strategy research --distributed --ui --verbose
 
 # 2. Store findings for cross-agent access
-npx claude-flow memory store "research-findings" "key insights" --namespace swarm
+npx claude-flow-novice memory store "research-findings" "key insights" --namespace swarm
 \`\`\`
 
 ### Long-Running Optimization:
 \`\`\`bash
 # 1. Background optimization swarm
-npx claude-flow swarm "Optimize entire codebase performance" \\
+npx claude-flow-novice swarm "Optimize entire codebase performance" \\
   --strategy optimization --background --testing --encryption
 
 # 2. Check background progress
-npx claude-flow status
+npx claude-flow-novice status
 \`\`\`
 
 ## 🔧 TROUBLESHOOTING
 
 ### Common Issues:
-1. **Swarm fails to start**: Check if Claude-Flow is initialized with \`npx claude-flow init --sparc\`
+1. **Swarm fails to start**: Check if Claude-Flow is initialized with \`npx claude-flow-novice init --sparc\`
 2. **Agents not coordinating**: Ensure memory namespace is consistent
 3. **Timeout concerns**: Use \`--background\` flag for long tasks
 4. **Performance issues**: Reduce \`--max-agents\` or use \`--monitor\` for insights
@@ -305,16 +305,16 @@ export function getSwarmOrchestration(taskDescription, memoryNamespace) {
 4. **Environment Preparation**
    \`\`\`bash
    # Ensure Claude-Flow is properly initialized
-   npx claude-flow status
+   npx claude-flow-novice status
    
    # Check memory system
-   npx claude-flow memory stats
+   npx claude-flow-novice memory stats
    \`\`\`
 
 5. **Dry Run Validation**
    \`\`\`bash
    # Test swarm configuration before execution
-   npx claude-flow swarm "${taskDescription}" --dry-run --strategy <selected-strategy>
+   npx claude-flow-novice swarm "${taskDescription}" --dry-run --strategy <selected-strategy>
    \`\`\`
 
 ### Phase 3: Swarm Execution (Variable)
@@ -323,22 +323,22 @@ export function getSwarmOrchestration(taskDescription, memoryNamespace) {
 
    **For Standard Tasks (< 30 minutes):**
    \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" --strategy <strategy> --monitor --verbose
+   npx claude-flow-novice swarm "${taskDescription}" --strategy <strategy> --monitor --verbose
    \`\`\`
 
    **For Complex Tasks (30-60 minutes):**
    \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" --strategy <strategy> --parallel --monitor --review
+   npx claude-flow-novice swarm "${taskDescription}" --strategy <strategy> --parallel --monitor --review
    \`\`\`
 
    **For Long-Running Tasks (> 60 minutes):**
    \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" --strategy <strategy> --background --monitor --testing
+   npx claude-flow-novice swarm "${taskDescription}" --strategy <strategy> --background --monitor --testing
    \`\`\`
 
    **For Enterprise Tasks (Multiple hours):**
    \`\`\`bash
-   npx claude-flow swarm "${taskDescription}" \\
+   npx claude-flow-novice swarm "${taskDescription}" \\
      --strategy <strategy> \\
      --mode distributed \\
      --max-agents 10 \\
@@ -355,28 +355,28 @@ export function getSwarmOrchestration(taskDescription, memoryNamespace) {
 7. **Real-Time Monitoring**
    \`\`\`bash
    # Monitor swarm progress
-   npx claude-flow monitor
+   npx claude-flow-novice monitor
    
    # Check specific swarm status
-   npx claude-flow status
+   npx claude-flow-novice status
    
    # View agent activities
-   npx claude-flow agent list
+   npx claude-flow-novice agent list
    \`\`\`
 
 8. **Cross-Agent Memory Sharing**
    \`\`\`bash
    # Store important findings for all agents
-   npx claude-flow memory store "${memoryNamespace}_findings" "key insights and decisions"
+   npx claude-flow-novice memory store "${memoryNamespace}_findings" "key insights and decisions"
    
    # Store progress updates
-   npx claude-flow memory store "${memoryNamespace}_progress" "current completion status"
+   npx claude-flow-novice memory store "${memoryNamespace}_progress" "current completion status"
    
    # Store blockers or issues
-   npx claude-flow memory store "${memoryNamespace}_blockers" "any impediments or questions"
+   npx claude-flow-novice memory store "${memoryNamespace}_blockers" "any impediments or questions"
    
    # Query shared knowledge
-   npx claude-flow memory query "${memoryNamespace}" --limit 10
+   npx claude-flow-novice memory query "${memoryNamespace}" --limit 10
    \`\`\`
 
 ### Phase 5: Results Integration (5-15 minutes)
@@ -389,10 +389,10 @@ export function getSwarmOrchestration(taskDescription, memoryNamespace) {
 10. **Memory Documentation**
     \`\`\`bash
     # Store final results
-    npx claude-flow memory store "${memoryNamespace}_final" "completed task summary and results"
+    npx claude-flow-novice memory store "${memoryNamespace}_final" "completed task summary and results"
     
     # Store lessons learned
-    npx claude-flow memory store "${memoryNamespace}_lessons" "insights for future similar tasks"
+    npx claude-flow-novice memory store "${memoryNamespace}_lessons" "insights for future similar tasks"
     \`\`\`
 
 ## 🎯 SWARM SUCCESS CRITERIA

package/src/cli/simple-commands/sparc-modes/tdd.js

@@ -7,14 +7,14 @@ export function getTddOrchestration(taskDescription, memoryNamespace) {
    - Analyze requirements: "${taskDescription}"
    - Query existing code and architecture:
      \\\`\\\`\\\`bash
-     npx claude-flow memory query ${memoryNamespace}_architecture
-     npx claude-flow memory query ${memoryNamespace}_implementation
-     npx claude-flow memory query ${memoryNamespace}_tech_specs
+     npx claude-flow-novice memory query ${memoryNamespace}_architecture
+     npx claude-flow-novice memory query ${memoryNamespace}_implementation
+     npx claude-flow-novice memory query ${memoryNamespace}_tech_specs
      \\\`\\\`\\\`
    - Define test boundaries and acceptance criteria
    - Plan test structure (unit, integration, e2e)
    - Identify test doubles needed (mocks, stubs, spies)
-   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_test_plan "Test strategy: Unit tests for domain logic, integration for APIs, e2e for workflows. Mocking: External services, database. Coverage target: 95%."\`
+   - Store plan: \`npx claude-flow-novice memory store ${memoryNamespace}_test_plan "Test strategy: Unit tests for domain logic, integration for APIs, e2e for workflows. Mocking: External services, database. Coverage target: 95%."\`
 
 2. **Red Phase - Write Failing Tests** (20 mins)
    - Create comprehensive test structure:
@@ -32,7 +32,7 @@ export function getTddOrchestration(taskDescription, memoryNamespace) {
    - Ensure NO hardcoded values in tests
    - Create parameterized tests for edge cases
    - Verify all tests fail with meaningful messages
-   - Store status: \`npx claude-flow memory store ${memoryNamespace}_red_phase "Written: 25 unit tests (all failing), 10 integration tests (all failing), 5 e2e tests (all failing). Coverage: 0%."\`
+   - Store status: \`npx claude-flow-novice memory store ${memoryNamespace}_red_phase "Written: 25 unit tests (all failing), 10 integration tests (all failing), 5 e2e tests (all failing). Coverage: 0%."\`
 
 3. **Green Phase - Minimal Implementation** (20 mins)
    - Implement ONLY enough code to pass tests:
@@ -43,7 +43,7 @@ export function getTddOrchestration(taskDescription, memoryNamespace) {
    - Use dependency injection for testability
    - Implement proper error handling
    - Track coverage as you progress
-   - Store progress: \`npx claude-flow memory store ${memoryNamespace}_green_phase "Progress: 20/25 unit tests passing, 8/10 integration tests passing. Current coverage: 75%. Remaining: Complex edge cases."\`
+   - Store progress: \`npx claude-flow-novice memory store ${memoryNamespace}_green_phase "Progress: 20/25 unit tests passing, 8/10 integration tests passing. Current coverage: 75%. Remaining: Complex edge cases."\`
 
 4. **Refactor Phase - Optimize & Clean** (15 mins)
    - Refactor while keeping tests green:
@@ -55,7 +55,7 @@ export function getTddOrchestration(taskDescription, memoryNamespace) {
    - Add performance tests if needed
    - Improve test maintainability
    - Document complex test scenarios
-   - Store refactoring: \`npx claude-flow memory store ${memoryNamespace}_refactor "Extracted 3 common utilities, optimized database queries, improved test readability. All tests green. Coverage: 95%."\`
+   - Store refactoring: \`npx claude-flow-novice memory store ${memoryNamespace}_refactor "Extracted 3 common utilities, optimized database queries, improved test readability. All tests green. Coverage: 95%."\`
 
 5. **Test Documentation & Validation** (10 mins)
    - Generate coverage reports
@@ -63,7 +63,7 @@ export function getTddOrchestration(taskDescription, memoryNamespace) {
    - Create test execution guide
    - Set up CI/CD test configuration
    - Validate against acceptance criteria
-   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_tdd_complete "TDD cycle complete. Coverage: 95%. All acceptance criteria met. Tests documented. CI/CD ready."\`
+   - Store completion: \`npx claude-flow-novice memory store ${memoryNamespace}_tdd_complete "TDD cycle complete. Coverage: 95%. All acceptance criteria met. Tests documented. CI/CD ready."\`
 
 ## Directory Safety
 - **IMPORTANT**: All test files should be created in the current working directory
@@ -106,7 +106,7 @@ export function getTddOrchestration(taskDescription, memoryNamespace) {
 
 ## Next Steps
 After TDD cycle completes:
-- \`npx claude-flow sparc run debug "Investigate any failing edge cases" --non-interactive\`
-- \`npx claude-flow sparc run refinement-optimization-mode "Optimize performance bottlenecks" --non-interactive\`
-- \`npx claude-flow sparc run docs-writer "Create user documentation" --non-interactive\``;
+- \`npx claude-flow-novice sparc run debug "Investigate any failing edge cases" --non-interactive\`
+- \`npx claude-flow-novice sparc run refinement-optimization-mode "Optimize performance bottlenecks" --non-interactive\`
+- \`npx claude-flow-novice sparc run docs-writer "Create user documentation" --non-interactive\``;
 }