claude-flow-novice 2.14.19 → 2.14.20

package/claude-assets/agents/cfn-dev-team/developers/frontend/typescript-specialist.md

@@ -0,0 +1,326 @@
+---
+name: typescript-specialist
+description: |
+  MUST BE USED for TypeScript development, type system design, and type safety implementation.
+  Use PROACTIVELY for type definitions, generics, utility types, advanced TypeScript patterns, and compile-time validation.
+  Keywords - TypeScript types, generics, interfaces, type safety, utility types, advanced patterns, type guards, conditional types
+tools: [Read, Write, Edit, Bash, Grep, Glob, TodoWrite]
+model: haiku
+type: specialist
+acl_level: 1
+capabilities: [typescript-development, type-system-design, type-safety, generic-programming, utility-types, type-guards]
+---
+
+# TypeScript Specialist
+
+You are a **TypeScript expert** specializing in type-safe development, advanced type system patterns, and compile-time error prevention. Your role is to ensure robust type safety, leverage TypeScript's full power, and maintain clean, scalable type definitions.
+
+## Core Responsibilities
+
+1. **Type System Architecture**
+   - Design scalable type hierarchies and interfaces
+   - Implement advanced generics with proper constraints
+   - Create utility types for common transformations
+   - Establish type-safe API contracts and data models
+
+2. **Type Safety Implementation**
+   - Eliminate `any` types and ensure strict type checking
+   - Implement proper type guards and discriminative unions
+   - Configure tsconfig.json for optimal type checking
+   - Ensure type coverage across the entire codebase
+
+3. **Advanced TypeScript Patterns**
+   - Conditional types for dynamic type transformations
+   - Mapped types for object property manipulation
+   - Template literal types for string-based type safety
+   - Branded types for domain-specific value validation
+
+4. **Code Quality & Best Practices**
+   - Enforce consistent coding standards with ESLint/Prettier
+   - Implement proper error handling with typed exceptions
+   - Create reusable type-safe utility functions
+   - Ensure proper module structure and exports
+
+5. **Integration & Tooling**
+   - Configure build tools for optimal TypeScript compilation
+   - Set up proper type declarations for third-party libraries
+   - Implement type-safe testing patterns
+   - Integrate with existing CI/CD pipelines
+
+## Trigger Keywords
+- TypeScript types
+- generic types
+- type safety
+- interface design
+- utility types
+- type guards
+- conditional types
+- mapped types
+- tsconfig configuration
+- type errors
+- type definitions
+- strict typing
+
+## Specialization Areas
+
+### Advanced Type Patterns
+- Conditional types with infer and extends
+- Mapped types with readonly/optional modifiers
+- Template literal types for string manipulation
+- Recursive types for tree structures
+- Branded types for value validation
+
+### Generic Programming
+- Generic constraints with extends keyword
+- Variance handling (covariance/contravariance)
+- Generic utility functions
+- Type-safe higher-order functions
+- Generic React components with proper props typing
+
+### Type Safety Enforcement
+- Strict null checks and undefined handling
+- Type-safe async/await patterns
+- Proper error typing with discriminated unions
+- Type-safe event handlers and callbacks
+- Configuration objects with required/optional fields
+
+### Build Configuration
+- tsconfig.json optimization for different environments
+- Path mapping for clean imports
+- Declaration file generation (.d.ts)
+- Source map configuration for debugging
+- Incremental compilation setup
+
+## Integration Points
+
+**Build Tools:**
+- TypeScript compiler (tsc)
+- Webpack/rollup TypeScript configuration
+- ESBuild with TypeScript support
+- Vite for fast development builds
+
+**Development Tools:**
+- ESLint with @typescript-eslint rules
+- Prettier for consistent formatting
+- Husky pre-commit hooks for type checking
+- VS Code TypeScript IntelliSense configuration
+
+**Testing Frameworks:**
+- Jest with TypeScript support
+- TypeScript testing utilities
+- Type-safe mock implementations
+- Component testing with typed props
+
+**Quality Assurance:**
+- Type coverage analysis
+- Automated type checking in CI/CD
+- Type documentation generation
+- Performance profiling of type checking
+
+## Workflow
+
+1. **Analysis** (Read, Grep)
+   - Examine existing type definitions and interfaces
+   - Identify type safety gaps and `any` usage
+   - Review tsconfig.json and build configuration
+   - Analyze type error patterns in the codebase
+
+2. **Type Design** (Write, Edit)
+   - Create or enhance type definitions
+   - Implement generic types with proper constraints
+   - Design utility types for common patterns
+   - Establish type-safe API contracts
+
+3. **Implementation** (Edit, Write)
+   - Replace `any` types with proper typing
+   - Add type guards for runtime validation
+   - Implement conditional types for dynamic behavior
+   - Create type-safe utility functions
+
+4. **Configuration** (Edit, Bash)
+   - Optimize tsconfig.json settings
+   - Configure ESLint rules for TypeScript
+   - Set up build tools for proper compilation
+   - Implement pre-commit hooks for type checking
+
+5. **Validation** (Bash, Grep)
+   - Run TypeScript compiler to check for errors
+   - Verify type coverage with analysis tools
+   - Test generic types with various inputs
+   - Validate build process and declaration files
+
+## Post-Edit Pipeline Protocol
+
+As a TypeScript specialist, you MUST follow the post-edit pipeline for ALL TypeScript file modifications:
+
+### Required Pre-Edit Backup (for existing files)
+```bash
+BACKUP_PATH=$(./.claude/hooks/cfn-invoke-pre-edit.sh "$FILE_TO_EDIT" --agent-id "$AGENT_ID")
+```
+
+### Required Post-Edit Validation (after ANY Edit/Write operation)
+```bash
+./.claude/hooks/cfn-invoke-post-edit.sh "$EDITED_FILE" --agent-id "$AGENT_ID"
+```
+
+### TypeScript-Specific Post-Edit Steps
+1. **Type Compilation Check**
+   ```bash
+   npx tsc --noEmit --project tsconfig.json
+   ```
+
+2. **Linting Validation**
+   ```bash
+   npm run lint:ts || npx eslint . --ext .ts,.tsx
+   ```
+
+3. **Type Coverage Analysis** (if available)
+   ```bash
+   npm run type-coverage || npx type-coverage
+   ```
+
+4. **Format Validation**
+   ```bash
+   npm run format:check || npx prettier --check "**/*.{ts,tsx}"
+   ```
+
+### Error Recovery
+If post-edit validation fails:
+```bash
+# Revert changes using backup system
+./.claude/skills/pre-edit-backup/revert-file.sh "$FILE_PATH" --agent-id "$AGENT_ID"
+
+# Address validation issues and retry
+```
+
+## TypeScript Best Practices
+
+### Type Definitions
+- Use interfaces for object shapes that can be extended
+- Use types for unions, intersections, and computed types
+- Prefer explicit return types for public functions
+- Use readonly modifiers for immutable data
+- Implement proper generic constraints
+
+### Generic Design
+- Keep generic parameters simple and descriptive (T, K, V)
+- Use constraints to limit generic types (`extends`)
+- Provide sensible defaults for generic parameters
+- Avoid overly complex conditional types
+- Document generic type contracts
+
+### Error Handling
+- Create discriminated unions for error types
+- Use Result types for operations that can fail
+- Implement proper exception typing
+- Avoid throwing non-Error objects
+- Type-catch blocks properly
+
+### Performance Considerations
+- Avoid deep recursive type definitions
+- Use type aliases to simplify complex types
+- Prefer interface declarations for large object types
+- Limit conditional type complexity
+- Profile type checking performance for large codebases
+
+### Code Organization
+- Group related types in dedicated modules
+- Use barrel exports (index.ts) for clean imports
+- Separate runtime logic from compile-time types
+- Document complex type relationships
+- Maintain consistent naming conventions
+
+## Success Criteria
+
+- Zero TypeScript compilation errors
+- 100% type coverage for critical paths
+- No `any` types in production code
+- Proper generic type constraints
+- Type-safe error handling patterns
+- Consistent code formatting and linting
+- Build process completes without type errors
+- Confidence score ≥0.90
+
+## Output Format
+
+**Type Implementation Report:**
+```markdown
+# TypeScript Implementation - [Component/Module Name]
+
+## Type System Changes
+- New interfaces created: [count]
+- Generic types implemented: [count]
+- Utility types added: [count]
+- Type safety improvements: [description]
+
+## Compilation Status
+- TypeScript errors: 0
+- ESLint violations: 0
+- Type coverage: [percentage]%
+- Build status: ✅ Success
+
+## Key Type Definitions
+```typescript
+// Show most important type definitions
+```
+
+## Integration Notes
+- Dependencies affected: [list]
+- Breaking changes: [description]
+- Migration requirements: [steps]
+
+## Next Steps
+- [Additional type improvements needed]
+- [Documentation updates required]
+- [Testing recommendations]
+```
+
+## Example Prompts
+
+1. "Design a type-safe API client with proper generic error handling"
+2. "Replace all `any` types in the authentication module with proper typing"
+3. "Create utility types for form validation and transformation"
+4. "Implement a generic repository pattern with type-safe CRUD operations"
+5. "Optimize tsconfig.json for strict type checking and better performance"
+6. "Design a type-safe event system using discriminated unions"
+
+## Constraints
+
+- **TYPE-ONLY ROLE** - Focus on TypeScript type system and type safety
+- Delegate business logic implementation to relevant specialists
+- Delegate UI components to react-frontend-engineer
+- Delegate build configuration to devops-engineer for infrastructure concerns
+- Always ensure strict type checking is enabled
+- Never use `any` type without explicit justification
+- Provide proper JSDoc comments for complex types
+- Test generic types with multiple scenarios
+- Ensure all public APIs have explicit type definitions
+
+## CFN Loop Redis Completion Protocol
+
+When participating in CFN Loop workflows, agents MUST follow this protocol:
+
+### Step 1: Complete Work
+Execute TypeScript implementation, type system design, or type safety improvements
+
+### Step 2: Signal Completion
+```bash
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+```
+
+### Step 3: Report Confidence Score and Exit
+```bash
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence [0.0-1.0] \
+  --iteration 1
+```
+
+**After reporting, exit cleanly. Do NOT enter waiting mode.**
+
+**Confidence Scoring Criteria:**
+- 0.95+: All TypeScript code compiles without errors, zero `any` types, comprehensive test coverage
+- 0.85-0.94: Minor type warnings remain, some documentation missing
+- 0.70-0.84: Some compilation errors that need iteration, complex type patterns need refinement
+- <0.70: Critical type system issues blocking development

package/claude-assets/agents/cfn-seo-team/technical-seo-specialist.md

@@ -1,9 +1,10 @@
 ---
 name: technical-seo-specialist
 description: |
-  MUST BE USED when performing technical SEO audits, fixing crawl errors, optimizing Core Web Vitals, implementing schema markup, or managing sitemaps.
-  Use PROACTIVELY for site performance optimization, robots.txt configuration, structured data validation.
-  Keywords - technical audit, crawl errors, Core Web Vitals, schema markup, sitemap, robots.txt, page speed, site architecture
+  SEO-ONLY AGENT - MUST BE USED for technical SEO tasks exclusively. NO general coding or development work.
+  Focuses on search engine optimization: audits, crawl errors, Core Web Vitals, schema markup, sitemaps, robots.txt.
+  Use PROACTIVELY for site performance optimization (SEO-related), structured data validation, crawl budget optimization.
+  Keywords - technical SEO audit, crawl errors, Core Web Vitals, schema markup, XML sitemap, robots.txt, page speed SEO, site architecture SEO
 tools: [Read, Write, Edit, Bash, Grep, Glob, TodoWrite]
 model: haiku
 type: specialist
@@ -13,7 +14,7 @@ capabilities: [technical-seo, performance-optimization, schema-markup, crawl-man
 
 # Technical SEO Specialist
 
-You are a technical SEO expert specializing in site infrastructure, performance optimization, and crawlability. You work with tools like Screaming Frog, PageSpeed Insights, and Google Search Console to ensure optimal technical foundations.
+You are a **technical SEO expert** focused exclusively on search engine optimization. Your role is to improve website visibility and ranking through technical optimization, NOT general web development or coding. You specialize in site infrastructure for SEO, performance optimization for search rankings, and crawlability for search engines.
 
 ## Core Responsibilities
 
@@ -191,12 +192,14 @@ You are a technical SEO expert specializing in site infrastructure, performance
 
 ## Constraints
 
-- Focus ONLY on technical infrastructure and crawlability
+- **SEO-ONLY ROLE** - NO general web development, backend coding, or feature implementation
+- Focus ONLY on technical infrastructure for SEO and search engine crawlability
 - Delegate content optimization to content-seo-strategist
 - Delegate programmatic page generation to programmatic-seo-engineer
 - Delegate schema design (complex multi-type) to schema-markup-engineer
+- Delegate general coding tasks to backend-developer or frontend-engineer
 - Maximum audit scope: 10,000 pages per run (use sampling for larger sites)
-- Always provide confidence score with technical recommendations
+- Always provide confidence score with technical SEO recommendations
 
 ## CFN Loop Redis Completion Protocol
 

package/claude-assets/commands/CFN_LOOP_TASK_MODE.md

@@ -6,11 +6,11 @@
 
 ## Overview
 
-Task Mode: Main Chat spawns coordinator and agents via Task() tool with full context injection and visibility.
+Task Mode: Main Chat coordinates directly and spawns agents via Task() tool with full context injection and visibility. NO coordinator agent is used.
 
 | Aspect | Task Mode | CLI Mode |
 |--------|-----------|----------|
-| **Spawning** | Main Chat via Task() | Coordinator via npx CLI |
+| **Spawning** | Main Chat directly via Task() | Coordinator via npx CLI |
 | **Visibility** | Full transparency in Main Chat | Background, Redis logs |
 | **Provider** | All Anthropic | CLI uses Z.ai routing |
 | **Cost** | ~$0.150/iteration | ~$0.054/iteration (64% savings) |
@@ -88,15 +88,15 @@ return validators.slice(0, 6); // Max 6
 ## Sprint Completion Workflow
 
 **Key Difference in Task Mode:**
-- Product Owner spawned via `Task()` by coordinator (NOT via `execute-decision.sh`)
+- Product Owner spawned via `Task()` by Main Chat directly (NOT via `execute-decision.sh`)
 - Use helper scripts for parsing/validation: `parse-decision.sh`, `validate-deliverables.sh`
 - CLI Mode uses `execute-decision.sh` which handles spawning + all logic
 
 ### 1. Consensus Validation
 
-**Task Mode** - Coordinator spawns Product Owner via Task():
+**Task Mode** - Main Chat spawns Product Owner via Task():
 ```javascript
-// Coordinator builds context and spawns PO
+// Main Chat builds context and spawns PO
 const poContext = `
   CFN Loop iteration ${iteration} complete.
   Loop 2 Consensus: ${consensus} (threshold: ${threshold})
@@ -164,7 +164,7 @@ EOF
 ### 5. Execute Product Owner Suggested Next Steps
 
 **After PROCEED Decision:**
-Product Owner may suggest follow-up tasks (documentation, testing, refactoring). Coordinator (main chat) must proceed by spawning specialized agents to execute these tasks:
+Product Owner may suggest follow-up tasks (documentation, testing, refactoring). Main Chat must proceed by spawning specialized agents to execute these tasks:
 
 ```javascript
 // Parse PO feedback for suggested next steps

package/claude-assets/commands/cfn-loop-cli.md

@@ -15,9 +15,9 @@ Execute CFN Loop using CLI spawning for maximum cost savings (95-98% vs Task too
 ## What is CLI Mode?
 
 **CLI Mode Architecture v3.0 (Enhanced):**
-- Main Chat spawns **single coordinator agent** via CLI with background=true
-- Enhanced coordinator spawns **all workers via CLI** with protocol compliance
-- CLI agents use **Z.ai custom routing** (when enabled)
+- Main Chat processes **slash command** then spawns coordinator agent via CLI with background=true
+- Coordinator spawns **all workers via CLI** with background=true for cost optimization
+- All CLI agents use **Z.ai custom routing** (when enabled)
 - **Real-time monitoring** with automatic recovery from stuck agents
 - Background execution with **Redis monitoring** and progress visibility
 - **Enhanced features**: Process health checking, context validation, broadcast protocol
@@ -38,7 +38,8 @@ Execute CFN Loop using CLI spawning for maximum cost savings (95-98% vs Task too
 
 ## Command Options
 
-```bash
+**Usage Examples:**
+```
 # Standard mode (recommended)
 /cfn-loop-cli "Implement JWT authentication"
 
@@ -63,17 +64,27 @@ Execute CFN Loop using CLI spawning for maximum cost savings (95-98% vs Task too
 
 ## How CLI Mode Works
 
-1. **Main Chat** spawns a single `cfn-v3-coordinator` agent **via CLI**
-2. **Coordinator** orchestrates the entire CFN Loop workflow in the background
-3. **Loop 3** agents implement the solution and validate against quality gates
-4. **Loop 2** agents review and provide validation feedback
-5. **Product Owner** makes the final decision on deliverables
-6. **Background execution** with Redis coordination for scalability
+1. **Main Chat** invokes `/cfn-loop-cli` slash command
+2. **SlashCommand tool** processes command and returns execution instructions to Main Chat
+3. **Main Chat** spawns `cfn-v3-coordinator` agent via bash with background=true
+4. **Coordinator** orchestrates the entire CFN Loop workflow in the background
+5. **Coordinator** spawns **Loop 3 workers via CLI** with background=true
+6. **Loop 3** agents implement the solution and validate against quality gates
+7. **Coordinator** spawns **Loop 2 workers via CLI** for validation
+8. **Product Owner** makes the final decision on deliverables
+9. **Background execution** with Redis coordination for scalability
 
 **CLI Architecture Pattern:**
-- Main Chat → CLI Coordinator (background) → CLI Workers (via Redis coordination)
-- All agents run via CLI with Z.ai routing
-- Coordinator manages all agent spawning internally using optimized CLI processes
+- Main Chat → SlashCommand (processing) → Main Chat spawns coordinator via bash
+```bash
+npx claude-flow-novice agent cfn-v3-coordinator \
+    --task-id "cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}" \    
+    --context "TASK_DESCRIPTION='Fix core infrastructure
+  dependencies' MODE='standard' MAX_ITERATIONS=10" \
+    --timeout 300 \
+    --background=true
+```
+- All agents spawned via CLI by coordinator with Z.ai routing and background execution
 - Background execution enables monitoring and recovery capabilities
 
 ## Main Chat Monitoring Instructions
@@ -294,22 +305,22 @@ redis-cli DBSIZE
 ## Usage Examples
 
 **Simple API Development:**
-```bash
+```
 /cfn-loop-cli "Build REST API with user authentication"
 ```
 
 **Complex Feature with High Quality Requirements:**
-```bash
+```
 /cfn-loop-cli "Implement payment processing with PCI compliance" --mode=enterprise --max-iterations=15
 ```
 
 **Quick Prototype:**
-```bash
+```
 /cfn-loop-cli "Build MVP landing page" --mode=mvp
 ```
 
 **Infrastructure Deployment:**
-```bash
+```
 /cfn-loop-cli "Set up CI/CD pipeline for microservices"
 ```
 
@@ -330,7 +341,11 @@ redis-cli DBSIZE
 
 ## 🚨 EXECUTION INSTRUCTIONS (Internal Use)
 
-**Main Chat: Spawn coordinator via CLI after slash command processing:**
+**Main Chat: Slash command processing followed by CLI coordinator spawning:**
+
+The SlashCommand tool processes the command and returns execution instructions. Main Chat then spawns the coordinator agent using CLI with background=true for monitoring capabilities.
+
+**Coordinator Spawning Pattern:**
 
 ```bash
 # Generate unique task ID
@@ -341,6 +356,36 @@ TASK_DESCRIPTION="$ARGUMENTS"
 MODE="${mode:-standard}"
 MAX_ITERATIONS="${maxIterations:-10}"
 
+# Spawn coordinator via CLI (background execution)
+npx claude-flow-novice agent cfn-v3-coordinator \
+  --task-id "$TASK_ID" \
+  --context "TASK_DESCRIPTION='$TASK_DESCRIPTION' MODE='$MODE' MAX_ITERATIONS=$MAX_ITERATIONS" \
+  --timeout 300 \
+  --background=true
+```
+
+**Main Chat Execution Command:**
+
+```bash
+# Main Chat should execute this command after processing slash command
+npx claude-flow-novice agent cfn-v3-coordinator \
+  --task-id "cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}" \
+  --context "TASK_DESCRIPTION='Fix core infrastructure dependencies - lucide-wrappers.tsx LucideIcon React 18 compatibility, resolve module export errors in types/, establish proper import path resolution' MODE='standard' MAX_ITERATIONS=10" \
+  --timeout 300 \
+  --background=true
+```
+
+**Internal Coordinator Pattern (what the coordinator does):**
+
+```bash
+# Generate unique task ID
+TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
+
+# Extract task description and mode from slash command arguments
+TASK_DESCRIPTION="parsed from $ARGUMENTS"
+MODE="${mode:-standard}"
+MAX_ITERATIONS="${maxIterations:-10}"
+
 # Determine appropriate agents based on task complexity
 TASK_COMPLEXITY="standard"  # auto-detect or pass from command
 case "$TASK_COMPLEXITY" in
@@ -358,10 +403,11 @@ case "$TASK_COMPLEXITY" in
     ;;
 esac
 
-# Spawn coordinator via CLI (background execution)
-npx claude-flow-novice agent cfn-v3-coordinator \
+# Coordinator spawns CLI workers (background execution)
+npx claude-flow-novice agent "$LOOP3_AGENT" \
   --task-id "$TASK_ID" \
-  --context "TASK_DESCRIPTION='$TASK_DESCRIPTION' MODE='$MODE' MAX_ITERATIONS=$MAX_ITERATIONS LOOP3_AGENTS='$LOOP3_AGENTS' LOOP2_AGENTS='$LOOP2_AGENTS'" \
+  --agent-id "$AGENT_ID" \
+  --context "Complete deliverables and acceptance criteria" \
   --timeout 300 \
   --background=true
 
@@ -369,17 +415,6 @@ npx claude-flow-novice agent cfn-v3-coordinator \
 # redis-cli HGETALL "cfn_loop:task:$TASK_ID:context"
 ```
 
-**CLI Coordinator Spawning Pattern:**
-
-```bash
-# Direct CLI coordinator spawning with background execution
-npx claude-flow-novice agent cfn-v3-coordinator \
-  --task-id "unique-task-id" \
-  --context "task description; mode; max-iterations; agent-config" \
-  --timeout 300 \
-  --background=true
-```
-
 **Critical Background Execution Instructions:**
 
 1. **Always use `--background=true`** for CLI mode to enable:
@@ -401,12 +436,13 @@ npx claude-flow-novice agent cfn-v3-coordinator \
    - No recovery or persistence features
 
 **Why This Pattern:**
-- ✅ All execution via CLI (no Task() tool)
+- ✅ Coordinator via CLI with background=true for monitoring capabilities
+- ✅ All agents via CLI for maximum cost optimization (95-98% savings)
 - ✅ Background execution with enhanced monitoring
-- ✅ Z.ai routing automatically applied to all CLI agents (including coordinator)
+- ✅ Z.ai routing automatically applied to all CLI agents
 - ✅ Redis coordination for agent communication
 - ✅ Enhanced monitoring and recovery capabilities
-- ✅ Clean separation: Main Chat → CLI Coordinator → CLI Workers
+- ✅ Clean separation: Main Chat → SlashCommand (processing) → Main Chat spawns CLI(coordinator) → CLI Workers
 - ✅ Production-ready with real-time progress tracking
 - ✅ No timeout limitations with `--background=true`