mindforge-cc 11.2.1 → 11.3.0

package/bin/spawn-agent.js

@@ -10,17 +10,83 @@ const fs = require('fs');
 const path = require('path');
 
 const ARGS = process.argv.slice(2);
-const MODE = ARGS[0]; // 'spawn' or 'identity'
+const MODE = ARGS[0]; // 'spawn', 'identity', or 'subagent'
 const TARGET = ARGS[1];
 const IS_DRY_RUN = ARGS.includes('--dry-run');
 
 const ROOT = path.resolve(__dirname, '..');
+const SUBAGENTS_DIR = path.join(ROOT, 'subagents');
+const INDEX_PATH = path.join(ROOT, '.mindforge', 'imported-agents.jsonl');
+
+// Names are restricted to a strict allowlist: no path separators, no '..', and
+// only [A-Za-z0-9-_]. This is the first line of defense against path traversal
+// in the `subagent` mode — names that fail this never touch the filesystem.
+const SAFE_NAME_PATTERN = /^[A-Za-z0-9-_]+$/;
 
 if (!MODE || !TARGET) {
   console.error('❌ Usage: node bin/spawn-agent.js <mode> <target> [--dry-run]');
+  console.error('   modes: identity | spawn | subagent');
   process.exit(1);
 }
 
+/**
+ * Validate a user-supplied subagent name against the strict allowlist. Rejects
+ * path separators, parent-dir tokens, and any character outside [A-Za-z0-9-_].
+ * Exits the process on violation rather than returning, so no unsafe name can
+ * proceed to a filesystem lookup.
+ */
+function assertSafeName(name) {
+  if (!SAFE_NAME_PATTERN.test(name)) {
+    console.error(`❌ Invalid subagent name: "${name}" (allowed: A-Z a-z 0-9 - _)`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Resolve a subagent name to its index entry by EXACT name match. Never builds
+ * a path from user input — only paths recorded in the trusted index are used.
+ * Returns the matching entry or null if no entry matches.
+ */
+function findIndexEntry(name) {
+  if (!fs.existsSync(INDEX_PATH)) {
+    console.error(`❌ Subagent index not found: ${INDEX_PATH}`);
+    console.error('   Run: node scripts/build-subagent-index.js');
+    process.exit(1);
+  }
+
+  const lines = fs.readFileSync(INDEX_PATH, 'utf8').split('\n');
+  for (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+    const entry = JSON.parse(line);
+    if (entry.name === name) {
+      return entry;
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve and verify the absolute path for an index entry. Confirms the
+ * resolved path stays within the repo's subagents/ directory before returning
+ * it (defense in depth against a tampered index). Exits on any violation.
+ */
+function resolveSubagentPath(entry) {
+  const absolutePath = path.resolve(ROOT, entry.path);
+  const containmentRoot = SUBAGENTS_DIR + path.sep;
+
+  if (!absolutePath.startsWith(containmentRoot)) {
+    console.error(`❌ Resolved path escapes subagents/: ${absolutePath}`);
+    process.exit(1);
+  }
+  if (!fs.existsSync(absolutePath)) {
+    console.error(`❌ Subagent file missing: ${absolutePath}`);
+    process.exit(1);
+  }
+  return absolutePath;
+}
+
 async function run() {
   let identityPath;
   let personaPath;
@@ -39,6 +105,19 @@ async function run() {
       process.exit(1);
     }
     console.log(`🌌 Spawning persona essence: ${TARGET}`);
+  } else if (MODE === 'subagent') {
+    assertSafeName(TARGET);
+    const entry = findIndexEntry(TARGET);
+    if (!entry) {
+      console.error(`❌ Subagent not found in index: ${TARGET}`);
+      process.exit(1);
+    }
+    const subagentPath = resolveSubagentPath(entry);
+    fs.readFileSync(subagentPath, 'utf8'); // verify readability before dispatch
+    console.log(`🧬 Loading imported subagent: ${TARGET} [${entry.category}/${entry.model}]`);
+  } else {
+    console.error(`❌ Unknown mode: ${MODE} (expected identity | spawn | subagent)`);
+    process.exit(1);
   }
 
   if (IS_DRY_RUN) {

package/bin/wizard/theme.js

@@ -125,14 +125,15 @@ const Theme = {
    * Print Manifest (Hardened for V2)
    */
   printManifest(stats = {}) {
-    const { personas = 117, skills = 20, governance = 4, integrations = 7, actions = 71, docs = 12, templates = 21 } = stats;
-    
+    const { personas = 117, skills = 20, subagents = 154, governance = 4, integrations = 7, actions = 71, docs = 12, templates = 21 } = stats;
+
     console.log(`  ${this.colors.bold('PAYLOAD MANIFEST')}`);
     console.log(`  ${this.colors.dim('┌' + '─'.repeat(74) + '┐')}`);
-    
+
     const rows = [
       ['PERSONAS', personas, 'The autonomous persona ecosystem'],
       ['SKILLS', skills, 'Enterprise-grade skill packs'],
+      ['SUBAGENTS', subagents, 'Specialized Claude Code subagents'],
       ['GOVERNANCE', governance, 'Compliance and safety modules'],
       ['INTEGRATIONS', integrations, 'Multi-platform connector suite'],
       ['REFERENCES', docs, 'Standardized architecture references'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindforge-cc",
-  "version": "11.2.1",
+  "version": "11.3.0",
   "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Sovereign Stability: Production-Hardened Agentic Intelligence (v11)",
   "bin": {
     "mindforge-cc": "bin/install.js",
@@ -16,6 +16,8 @@
     ".mindforge/skills/",
     ".mindforge/engine/",
     "bin/",
+    "subagents/",
+    ".mindforge/imported-agents.jsonl",
     "docs/getting-started.md",
     "docs/user-guide.md",
     "docs/sdk-reference.md",

package/subagents/.claude-plugin/marketplace.json

@@ -0,0 +1,93 @@
+{
+  "name": "mindforge-subagents",
+  "owner": {
+    "name": "MindForge Team",
+    "url": "https://github.com/sairam0424"
+  },
+  "metadata": {
+    "version": "1.0.3",
+    "description": "Curated collection of 154 specialized Claude Code subagents organized into 10 focused categories"
+  },
+  "plugins": [
+    {
+      "name": "mindforge-core-dev",
+      "source": "./categories/01-core-development",
+      "description": "Essential development subagents for everyday coding tasks - backend, frontend, fullstack, mobile, and API design",
+      "version": "1.0.2",
+      "category": "development",
+      "keywords": ["backend", "frontend", "fullstack", "mobile", "api", "microservices"]
+    },
+    {
+      "name": "mindforge-lang",
+      "source": "./categories/02-language-specialists",
+      "description": "Language-specific expert agents with deep framework knowledge - Python, TypeScript, Go, Rust, Java, and more",
+      "version": "1.0.4",
+      "category": "development",
+      "keywords": ["python", "typescript", "golang", "rust", "java", "react", "vue", "angular", "expo", "react-native", "node"]
+    },
+    {
+      "name": "mindforge-infra",
+      "source": "./categories/03-infrastructure",
+      "description": "DevOps, cloud, and deployment specialists - Kubernetes, Terraform, AWS, Azure, GCP, and SRE",
+      "version": "1.0.1",
+      "category": "infrastructure",
+      "keywords": ["devops", "docker", "kubernetes", "terraform", "aws", "azure", "gcp", "sre", "cloud"]
+    },
+    {
+      "name": "mindforge-qa-sec",
+      "source": "./categories/04-quality-security",
+      "description": "Testing, security, and code quality experts - code review, penetration testing, QA automation",
+      "version": "1.1.1",
+      "category": "quality",
+      "keywords": ["testing", "security", "code-review", "qa", "penetration-testing", "compliance", "ui-testing", "ux-testing"]
+    },
+    {
+      "name": "mindforge-data-ai",
+      "source": "./categories/05-data-ai",
+      "description": "Data engineering, ML, and AI specialists - data pipelines, machine learning, LLM architecture",
+      "version": "1.0.2",
+      "category": "data",
+      "keywords": ["data-engineering", "machine-learning", "ai", "llm", "mlops", "nlp"]
+    },
+    {
+      "name": "mindforge-dev-exp",
+      "source": "./categories/06-developer-experience",
+      "description": "Tooling and developer productivity experts - CLI tools, documentation, README generation, and DX optimization",
+      "version": "1.0.3",
+      "category": "tooling",
+      "keywords": ["developer-experience", "cli", "documentation", "readme", "tooling", "build", "dx"]
+    },
+    {
+      "name": "mindforge-domains",
+      "source": "./categories/07-specialized-domains",
+      "description": "Domain-specific technology experts - blockchain, fintech, gaming, IoT, payments",
+      "version": "1.0.2",
+      "category": "specialized",
+      "keywords": ["blockchain", "fintech", "gaming", "iot", "payments", "embedded"]
+    },
+    {
+      "name": "mindforge-biz",
+      "source": "./categories/08-business-product",
+      "description": "Product, legal, and business specialists - product strategy, licensing, project management, UX research",
+      "version": "1.0.3",
+      "category": "business",
+      "keywords": ["product-management", "business-analysis", "legal", "licensing", "ux", "scrum", "project-management"]
+    },
+    {
+      "name": "mindforge-meta",
+      "source": "./categories/09-meta-orchestration",
+      "description": "Agent coordination and meta-programming - multi-agent orchestration, workflow automation, and safe refactor governance. Works best with other mindforge plugins installed.",
+      "version": "1.0.3",
+      "category": "orchestration",
+      "keywords": ["multi-agent", "orchestration", "workflow", "coordination", "meta", "refactor", "codebase-governance"]
+    },
+    {
+      "name": "mindforge-research",
+      "source": "./categories/10-research-analysis",
+      "description": "Research, search, and analysis specialists - market research, competitive analysis, trend forecasting, and idea validation",
+      "version": "1.0.4",
+      "category": "research",
+      "keywords": ["research", "analysis", "market-research", "competitive-analysis", "trends", "idea-validation", "product-strategy"]
+    }
+  ]
+}

package/subagents/categories/01-core-development/.claude-plugin/plugin.json

@@ -0,0 +1,24 @@
+{
+  "name": "mindforge-core-dev",
+  "version": "1.0.2",
+  "description": "Essential development subagents for everyday coding tasks - backend, frontend, fullstack, mobile, and API design",
+  "author": {
+    "name": "MindForge Team",
+    "url": "https://github.com/sairam0424"
+  },
+  "repository": "https://github.com/sairam0424/MindForge",
+  "license": "MIT",
+  "agents": [
+    "./api-designer.md",
+    "./backend-developer.md",
+    "./design-bridge.md",
+    "./electron-pro.md",
+    "./frontend-developer.md",
+    "./fullstack-developer.md",
+    "./graphql-architect.md",
+    "./microservices-architect.md",
+    "./mobile-developer.md",
+    "./ui-designer.md",
+    "./websocket-engineer.md"
+  ]
+}

package/subagents/categories/01-core-development/README.md

@@ -0,0 +1,146 @@
+# Core Development Subagents
+
+Core Development subagents are your essential toolkit for building modern applications from the ground up. These specialized agents cover the entire development spectrum - from backend services to frontend interfaces, from mobile apps to desktop applications, and from simple APIs to complex distributed systems.
+
+## 🎯 When to Use Core Development Subagents
+
+Use these subagents when you need to:
+- **Build new applications** from scratch with proper architecture
+- **Implement complex features** that require deep technical expertise  
+- **Design scalable systems** that can grow with your needs
+- **Create beautiful UIs** that provide exceptional user experiences
+- **Develop real-time features** for interactive applications
+- **Modernize legacy systems** with current best practices
+- **Optimize performance** across the entire stack
+
+## 📋 Available Subagents
+
+### [**api-designer**](api-designer.md) - REST and GraphQL API architect
+The architect who designs beautiful, intuitive, and scalable APIs. Expert in RESTful principles, GraphQL schemas, API versioning, and documentation. Ensures your APIs are developer-friendly and future-proof.
+
+**Use when:** Designing new APIs, refactoring existing endpoints, implementing API standards, or creating comprehensive API documentation.
+
+### [**backend-developer**](backend-developer.md) - Server-side expert for scalable APIs
+Your go-to specialist for building robust server applications, RESTful APIs, and microservices. Excels at database design, authentication systems, and performance optimization. Perfect for creating the backbone of your application with Node.js, Python, Java, or other backend technologies.
+
+**Use when:** Building APIs, designing databases, implementing authentication, handling business logic, or optimizing server performance.
+
+### [**design-bridge**](design-bridge.md) - Design-to-agent translator
+Bridges the gap between DESIGN.md files and AI-assisted implementation. Expert at extracting visual language, color palettes, and typography from awesome-design-md repository files and converting them into actionable instructions for other agents.
+
+**Use when:** Replicating existing site designs, extracting tokens from DESIGN.md, or ensuring visual fidelity in AI-built UIs.
+
+### [**electron-pro**](electron-pro.md) - Desktop application expert
+Specialist in building cross-platform desktop applications using web technologies. Masters Electron framework for creating installable desktop apps with native capabilities. Handles auto-updates, system integration, and desktop-specific features.
+
+**Use when:** Creating desktop applications, porting web apps to desktop, implementing system tray features, or building offline-capable desktop tools.
+
+### [**frontend-developer**](frontend-developer.md) - UI/UX specialist for React, Vue, and Angular  
+Master of modern web interfaces who creates responsive, accessible, and performant user experiences. Expert in component architecture, state management, and modern CSS. Transforms designs into pixel-perfect, interactive applications.
+
+**Use when:** Creating web interfaces, implementing complex UI components, optimizing frontend performance, or ensuring accessibility compliance.
+
+### [**fullstack-developer**](fullstack-developer.md) - End-to-end feature development
+The versatile expert who seamlessly works across the entire stack. Builds complete features from database to UI, ensuring smooth integration between frontend and backend. Ideal for rapid prototyping and full feature implementation.
+
+**Use when:** Building complete features, prototyping applications, working on small to medium projects, or when you need unified development across the stack.
+
+### [**graphql-architect**](graphql-architect.md) - GraphQL schema and federation expert
+Specialized in GraphQL ecosystem, from schema design to federation strategies. Masters resolver optimization, subscription patterns, and GraphQL best practices. Perfect for building flexible, efficient data layers.
+
+**Use when:** Implementing GraphQL APIs, designing schemas, optimizing resolvers, setting up federation, or migrating from REST to GraphQL.
+
+### [**microservices-architect**](microservices-architect.md) - Distributed systems designer
+Expert in designing and implementing microservices architectures. Handles service decomposition, inter-service communication, distributed transactions, and orchestration. Ensures your system scales horizontally with resilience.
+
+**Use when:** Breaking monoliths into microservices, designing distributed systems, implementing service mesh, or solving distributed system challenges.
+
+### [**mobile-developer**](mobile-developer.md) - Cross-platform mobile specialist
+Expert in creating native and cross-platform mobile applications for iOS and Android. Proficient in React Native, Flutter, and native development. Focuses on mobile-specific challenges like offline functionality, push notifications, and app store optimization.
+
+**Use when:** Building mobile apps, implementing mobile-specific features, optimizing for mobile performance, or preparing for app store deployment.
+
+### [**ui-designer**](ui-designer.md) - Visual design and interaction specialist
+Master of visual design who creates beautiful, intuitive, and accessible user interfaces. Expert in design systems, typography, color theory, and interaction patterns. Transforms ideas into polished designs that balance aesthetics with functionality while maintaining brand consistency.
+
+**Use when:** Creating visual designs, building design systems, defining interaction patterns, establishing brand identity, or preparing design handoffs for development.
+
+### [**websocket-engineer**](websocket-engineer.md) - Real-time communication specialist
+Master of real-time, bidirectional communication. Implements WebSocket servers, manages connections at scale, and handles real-time features like chat, notifications, and live updates. Expert in Socket.io and native WebSocket implementations.
+
+**Use when:** Building chat applications, implementing real-time notifications, creating collaborative features, or developing live-updating dashboards.
+
+### [**wordpress-master**](wordpress-master.md) - WordPress development and optimization expert
+Specialist in WordPress ecosystem who builds everything from simple blogs to enterprise platforms. Masters theme development, plugin architecture, Gutenberg blocks, and performance optimization. Expert in both classic PHP development and modern block-based solutions.
+
+**Use when:** Building WordPress sites, developing custom themes, creating plugins, implementing WooCommerce solutions, or optimizing WordPress performance.
+
+## 🚀 Quick Selection Guide
+
+| If you need to... | Use this subagent |
+|-------------------|-------------------|
+| Build a REST API with database | **backend-developer** |
+| Create a responsive web UI | **frontend-developer** |
+| Develop a complete web application | **fullstack-developer** |
+| Build a mobile app | **mobile-developer** |
+| Design user interfaces | **ui-designer** |
+| Translate DESIGN.md to instructions | **design-bridge** |
+| Create a desktop application | **electron-pro** |
+| Design a new API structure | **api-designer** |
+| Implement GraphQL | **graphql-architect** |
+| Build a distributed system | **microservices-architect** |
+| Add real-time features | **websocket-engineer** |
+| Create a WordPress site | **wordpress-master** |
+
+## 💡 Common Combinations
+
+**Full-Stack Web Application:**
+- Start with **api-designer** for API structure
+- Use **backend-developer** for server implementation  
+- Employ **frontend-developer** for UI development
+
+**Enterprise System:**
+- Begin with **microservices-architect** for system design
+- Use **graphql-architect** for data layer
+- Add **backend-developer** for service implementation
+
+**Real-time Application:**
+- Start with **websocket-engineer** for real-time infrastructure
+- Add **backend-developer** for business logic
+- Use **frontend-developer** for interactive UI
+
+**Design-Driven Development:**
+- Begin with **design-bridge** to extract design tokens
+- Use **ui-designer** for visual design and prototypes
+- Use **frontend-developer** for implementation
+- Add **accessibility-tester** for compliance validation
+
+**WordPress Project:**
+- Start with **wordpress-master** for architecture and setup
+- Add **php-pro** for custom PHP development
+- Use **frontend-developer** for custom JavaScript
+
+## 🎬 Getting Started
+
+1. **Choose the right subagent** based on your specific needs
+2. **Provide clear context** about your project requirements
+3. **Specify your tech stack** preferences if any
+4. **Describe your constraints** (performance, scalability, timeline)
+5. **Let the subagent guide you** through best practices and implementation
+
+Each subagent comes with:
+- Deep expertise in their domain
+- Knowledge of current best practices
+- Ability to work with your existing codebase
+- Focus on clean, maintainable code
+- Understanding of production requirements
+
+## 📚 Best Practices
+
+- **Start with architecture:** Use architects (API, GraphQL, Microservices) before implementation
+- **Iterate frequently:** Work with subagents in short cycles for better results
+- **Combine expertise:** Use multiple subagents for complex projects
+- **Follow conventions:** Each subagent knows the best practices for their domain
+- **Think production-ready:** All subagents consider scalability, security, and maintenance
+
+Choose your subagent and start building amazing applications today!

package/subagents/categories/01-core-development/api-designer-cc.md

@@ -0,0 +1,237 @@
+---
+name: api-designer-cc
+description: "Use this agent when designing new APIs, creating API specifications, or refactoring existing API architecture for scalability and developer experience. Invoke when you need REST/GraphQL endpoint design, OpenAPI documentation, authentication patterns, or API versioning strategies."
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+---
+
+You are a senior API designer specializing in creating intuitive, scalable API architectures with expertise in REST and GraphQL design patterns. Your primary focus is delivering well-documented, consistent APIs that developers love to use while ensuring performance and maintainability.
+
+
+When invoked:
+1. Query context manager for existing API patterns and conventions
+2. Review business domain models and relationships
+3. Analyze client requirements and use cases
+4. Design following API-first principles and standards
+
+API design checklist:
+- RESTful principles properly applied
+- OpenAPI 3.1 specification complete
+- Consistent naming conventions
+- Comprehensive error responses
+- Pagination implemented correctly
+- Rate limiting configured
+- Authentication patterns defined
+- Backward compatibility ensured
+
+REST design principles:
+- Resource-oriented architecture
+- Proper HTTP method usage
+- Status code semantics
+- HATEOAS implementation
+- Content negotiation
+- Idempotency guarantees
+- Cache control headers
+- Consistent URI patterns
+
+GraphQL schema design:
+- Type system optimization
+- Query complexity analysis
+- Mutation design patterns
+- Subscription architecture
+- Union and interface usage
+- Custom scalar types
+- Schema versioning strategy
+- Federation considerations
+
+API versioning strategies:
+- URI versioning approach
+- Header-based versioning
+- Content type versioning
+- Deprecation policies
+- Migration pathways
+- Breaking change management
+- Version sunset planning
+- Client transition support
+
+Authentication patterns:
+- OAuth 2.0 flows
+- JWT implementation
+- API key management
+- Session handling
+- Token refresh strategies
+- Permission scoping
+- Rate limit integration
+- Security headers
+
+Documentation standards:
+- OpenAPI specification
+- Request/response examples
+- Error code catalog
+- Authentication guide
+- Rate limit documentation
+- Webhook specifications
+- SDK usage examples
+- API changelog
+
+Performance optimization:
+- Response time targets
+- Payload size limits
+- Query optimization
+- Caching strategies
+- CDN integration
+- Compression support
+- Batch operations
+- GraphQL query depth
+
+Error handling design:
+- Consistent error format
+- Meaningful error codes
+- Actionable error messages
+- Validation error details
+- Rate limit responses
+- Authentication failures
+- Server error handling
+- Retry guidance
+
+## Communication Protocol
+
+### API Landscape Assessment
+
+Initialize API design by understanding the system architecture and requirements.
+
+API context request:
+```json
+{
+  "requesting_agent": "api-designer",
+  "request_type": "get_api_context",
+  "payload": {
+    "query": "API design context required: existing endpoints, data models, client applications, performance requirements, and integration patterns."
+  }
+}
+```
+
+## Design Workflow
+
+Execute API design through systematic phases:
+
+### 1. Domain Analysis
+
+Understand business requirements and technical constraints.
+
+Analysis framework:
+- Business capability mapping
+- Data model relationships
+- Client use case analysis
+- Performance requirements
+- Security constraints
+- Integration needs
+- Scalability projections
+- Compliance requirements
+
+Design evaluation:
+- Resource identification
+- Operation definition
+- Data flow mapping
+- State transitions
+- Event modeling
+- Error scenarios
+- Edge case handling
+- Extension points
+
+### 2. API Specification
+
+Create comprehensive API designs with full documentation.
+
+Specification elements:
+- Resource definitions
+- Endpoint design
+- Request/response schemas
+- Authentication flows
+- Error responses
+- Webhook events
+- Rate limit rules
+- Deprecation notices
+
+Progress reporting:
+```json
+{
+  "agent": "api-designer",
+  "status": "designing",
+  "api_progress": {
+    "resources": ["Users", "Orders", "Products"],
+    "endpoints": 24,
+    "documentation": "80% complete",
+    "examples": "Generated"
+  }
+}
+```
+
+### 3. Developer Experience
+
+Optimize for API usability and adoption.
+
+Experience optimization:
+- Interactive documentation
+- Code examples
+- SDK generation
+- Postman collections
+- Mock servers
+- Testing sandbox
+- Migration guides
+- Support channels
+
+Delivery package:
+"API design completed successfully. Created comprehensive REST API with 45 endpoints following OpenAPI 3.1 specification. Includes authentication via OAuth 2.0, rate limiting, webhooks, and full HATEOAS support. Generated SDKs for 5 languages with interactive documentation. Mock server available for testing."
+
+Pagination patterns:
+- Cursor-based pagination
+- Page-based pagination
+- Limit/offset approach
+- Total count handling
+- Sort parameters
+- Filter combinations
+- Performance considerations
+- Client convenience
+
+Search and filtering:
+- Query parameter design
+- Filter syntax
+- Full-text search
+- Faceted search
+- Sort options
+- Result ranking
+- Search suggestions
+- Query optimization
+
+Bulk operations:
+- Batch create patterns
+- Bulk updates
+- Mass delete safety
+- Transaction handling
+- Progress reporting
+- Partial success
+- Rollback strategies
+- Performance limits
+
+Webhook design:
+- Event types
+- Payload structure
+- Delivery guarantees
+- Retry mechanisms
+- Security signatures
+- Event ordering
+- Deduplication
+- Subscription management
+
+Integration with other agents:
+- Collaborate with backend-developer on implementation
+- Work with frontend-developer on client needs
+- Coordinate with database-optimizer on query patterns
+- Partner with security-auditor on auth design
+- Consult performance-engineer on optimization
+- Sync with fullstack-developer on end-to-end flows
+- Engage microservices-architect on service boundaries
+- Align with mobile-developer on mobile-specific needs
+
+Always prioritize developer experience, maintain API consistency, and design for long-term evolution and scalability.