0xray 4.0.13 → 4.0.15

package/dist/agents/registry.js

@@ -0,0 +1,354 @@
+/**
+ * Agent Registry
+ *
+ * ARCHITECTURE NOTE (2026-04-17):
+ * After discovering that orchestration/enforcement happen at plugin level
+ * (not via agents), we differentiate between:
+ * - AGENTS: True coordinators that need spawning (architect, strategist)
+ * - SKILLS: MCP-based capabilities invoked via skill tools (most others)
+ *
+ * The agent-delegator handles orchestration based on complexity analysis.
+ * Enforcement happens via preValidate processor and MCP servers.
+ * Agents are mainly prompts with skills - they don't route or orchestrate.
+ */
+export const AGENT_REGISTRY = {
+    architect: {
+        name: "architect",
+        description: "System design & technical decisions",
+        capabilities: ["design", "planning"],
+        capacity: 90,
+        specialties: ["design", "planning"],
+        mode: "primary",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "system architecture",
+    },
+    "bug-triage-specialist": {
+        name: "bug-triage-specialist",
+        description: "Error investigation & surgical fixes",
+        capabilities: ["debugging", "analysis"],
+        capacity: 60,
+        specialties: ["debugging", "analysis"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 70,
+        expertise: "bug triage",
+    },
+    "code-reviewer": {
+        name: "code-reviewer",
+        description: "Quality assessment & standards validation",
+        capabilities: ["review", "quality"],
+        capacity: 80,
+        specialties: ["review", "quality"],
+        mode: "subagent",
+        maxComplexity: 30,
+        concurrentTasks: 4,
+        status: "active",
+        performance: 80,
+        expertise: "code review",
+    },
+    "security-auditor": {
+        name: "security-auditor",
+        description: "Vulnerability detection & compliance",
+        capabilities: ["security", "audit"],
+        capacity: 70,
+        specialties: ["security", "audit"],
+        mode: "subagent",
+        maxComplexity: 35,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 75,
+        expertise: "security analysis",
+    },
+    refactorer: {
+        name: "refactorer",
+        description: "Technical debt elimination & code consolidation",
+        capabilities: ["refactoring", "optimization"],
+        capacity: 75,
+        specialties: ["refactoring", "optimization"],
+        mode: "subagent",
+        maxComplexity: 45,
+        concurrentTasks: 1,
+        status: "active",
+        performance: 85,
+        expertise: "code refactoring",
+    },
+    "testing-lead": {
+        name: "testing-lead",
+        description: "Testing strategy & coverage optimization",
+        capabilities: ["testing", "coverage"],
+        capacity: 85,
+        specialties: ["testing", "coverage"],
+        mode: "subagent",
+        maxComplexity: 38,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "test architecture",
+    },
+    "log-monitor": {
+        name: "log-monitor",
+        description: "Log analysis & pattern detection",
+        capabilities: ["log-analysis", "pattern-detection", "alerting"],
+        capacity: 60,
+        specialties: ["logs", "monitoring", "alerts"],
+        mode: "subagent",
+        maxComplexity: 20,
+        concurrentTasks: 5,
+        status: "active",
+        performance: 75,
+        expertise: "log monitoring and analysis",
+    },
+    researcher: {
+        name: "researcher",
+        description: "Codebase exploration & documentation search",
+        capabilities: ["code-search", "documentation-lookup", "implementation-search"],
+        capacity: 80,
+        specialties: ["search", "docs", "patterns"],
+        mode: "subagent",
+        maxComplexity: 30,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "codebase search and documentation",
+    },
+    "code-analyzer": {
+        name: "code-analyzer",
+        description: "Deep code analysis & pattern detection",
+        capabilities: ["code-analysis", "pattern-detection", "metrics"],
+        capacity: 75,
+        specialties: ["analysis", "metrics", "patterns"],
+        mode: "subagent",
+        maxComplexity: 35,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "deep code analysis",
+    },
+    "backend-engineer": {
+        name: "backend-engineer",
+        description: "API & backend development",
+        capabilities: ["api-design", "server-architecture", "microservices"],
+        capacity: 85,
+        specialties: ["api", "microservices", "server"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "backend development and API design",
+    },
+    "content-creator": {
+        name: "content-creator",
+        description: "Marketing copy & content writing",
+        capabilities: ["content-writing", "seo-copy", "marketing-copy", "social-media"],
+        capacity: 75,
+        specialties: ["copy", "marketing", "social"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "content creation and marketing copy",
+    },
+    "database-engineer": {
+        name: "database-engineer",
+        description: "Database design & optimization",
+        capabilities: ["schema-design", "query-optimization", "migrations", "sql-nosql"],
+        capacity: 80,
+        specialties: ["database", "sql", "migrations"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "database design and optimization",
+    },
+    "devops-engineer": {
+        name: "devops-engineer",
+        description: "DevOps & infrastructure automation",
+        capabilities: ["ci-cd", "docker", "kubernetes", "infrastructure", "deployment"],
+        capacity: 80,
+        specialties: ["ci-cd", "docker", "infrastructure"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "DevOps and infrastructure automation",
+    },
+    "frontend-engineer": {
+        name: "frontend-engineer",
+        description: "Frontend development & UI engineering",
+        capabilities: ["react", "vue", "angular", "ui-components", "responsive-design"],
+        capacity: 85,
+        specialties: ["react", "vue", "components"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "frontend development and UI engineering",
+    },
+    "frontend-ui-ux-engineer": {
+        name: "frontend-ui-ux-engineer",
+        description: "UI/UX design & visual engineering",
+        capabilities: ["ui-design", "ux-patterns", "accessibility", "design-systems", "visual-design"],
+        capacity: 75,
+        specialties: ["ui", "ux", "accessibility", "design"],
+        mode: "subagent",
+        maxComplexity: 45,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 80,
+        expertise: "UI/UX design and visual engineering",
+    },
+    "growth-strategist": {
+        name: "growth-strategist",
+        description: "Marketing strategy & growth",
+        capabilities: ["marketing-strategy", "conversion-optimization", "user-acquisition", "analytics"],
+        capacity: 70,
+        specialties: ["growth", "marketing", "analytics"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 80,
+        expertise: "growth strategy and marketing",
+    },
+    "mobile-developer": {
+        name: "mobile-developer",
+        description: "Mobile app development",
+        capabilities: ["ios", "android", "react-native", "flutter", "mobile-first-design"],
+        capacity: 80,
+        specialties: ["mobile", "ios", "android"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "mobile application development",
+    },
+    "performance-engineer": {
+        name: "performance-engineer",
+        description: "Performance optimization & profiling",
+        capabilities: ["profiling", "optimization", "benchmarking", "latency", "caching"],
+        capacity: 80,
+        specialties: ["performance", "profiling", "optimization"],
+        mode: "subagent",
+        maxComplexity: 45,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 90,
+        expertise: "performance optimization and profiling",
+    },
+    "seo-consultant": {
+        name: "seo-consultant",
+        description: "SEO analysis & optimization",
+        capabilities: ["seo-audits", "keyword-research", "technical-seo", "content-optimization"],
+        capacity: 75,
+        specialties: ["seo", "keywords", "technical-seo"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "search engine optimization",
+    },
+    strategist: {
+        name: "strategist",
+        description: "Strategic guidance & complex problem-solving",
+        capabilities: ["architecture-decisions", "technical-roadmap", "risk-analysis", "system-design"],
+        capacity: 70,
+        specialties: ["strategy", "roadmap", "architecture"],
+        mode: "subagent",
+        maxComplexity: 60,
+        concurrentTasks: 1,
+        status: "active",
+        performance: 85,
+        expertise: "strategic guidance and architecture decisions",
+    },
+    "tech-writer": {
+        name: "tech-writer",
+        description: "Technical documentation generation",
+        capabilities: ["documentation", "readme", "api-docs", "guides", "technical-writing"],
+        capacity: 80,
+        specialties: ["docs", "readme", "api-docs"],
+        mode: "subagent",
+        maxComplexity: 28,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "technical documentation and writing",
+    },
+    "multimodal-looker": {
+        name: "multimodal-looker",
+        description: "Visual content analysis for images, diagrams, PDFs, and screenshots",
+        capabilities: ["visual-analysis", "image-processing", "document-analysis", "multimodal-data-processing"],
+        capacity: 60,
+        specialties: ["image", "visual", "diagram", "screenshot", "pdf"],
+        mode: "subagent",
+        maxComplexity: 35,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 80,
+        expertise: "multimodal content analysis and interpretation",
+    },
+};
+export function getActiveAgents() {
+    return Object.values(AGENT_REGISTRY)
+        .filter((entry) => entry.status === "active")
+        .map((entry) => entry.name);
+}
+export function getAgentEntry(name) {
+    return AGENT_REGISTRY[name];
+}
+export function isAllowedAgent(name) {
+    return AGENT_REGISTRY[name]?.status === "active";
+}
+export function getAgentCapabilities(name) {
+    return AGENT_REGISTRY[name]?.capabilities ?? [];
+}
+export function validateRegistryConsistency() {
+    const errors = [];
+    const names = new Set();
+    for (const [key, entry] of Object.entries(AGENT_REGISTRY)) {
+        if (entry.name !== key) {
+            errors.push(`Registry key "${key}" does not match entry.name "${entry.name}"`);
+        }
+        if (names.has(entry.name)) {
+            errors.push(`Duplicate agent name: "${entry.name}"`);
+        }
+        names.add(entry.name);
+        if (!entry.description) {
+            errors.push(`Agent "${key}" missing description`);
+        }
+        if (!Array.isArray(entry.capabilities) || entry.capabilities.length === 0) {
+            errors.push(`Agent "${key}" has empty or invalid capabilities`);
+        }
+        if (!["primary", "subagent"].includes(entry.mode)) {
+            errors.push(`Agent "${key}" has invalid mode: "${entry.mode}"`);
+        }
+        if (!["active", "inactive"].includes(entry.status)) {
+            errors.push(`Agent "${key}" has invalid status: "${entry.status}"`);
+        }
+        if (typeof entry.maxComplexity !== "number" || entry.maxComplexity < 0) {
+            errors.push(`Agent "${key}" has invalid maxComplexity`);
+        }
+        if (typeof entry.concurrentTasks !== "number" || entry.concurrentTasks < 1) {
+            errors.push(`Agent "${key}" has invalid concurrentTasks`);
+        }
+        if (typeof entry.capacity !== "number" || entry.capacity <= 0) {
+            errors.push(`Agent "${key}" has invalid capacity`);
+        }
+        if (!entry.expertise) {
+            errors.push(`Agent "${key}" missing expertise`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+export const AGENT_KEYS = Object.keys(AGENT_REGISTRY);

package/dist/agents/researcher.d.ts

@@ -0,0 +1,2 @@
+import { AgentConfig } from "./types.js";
+export declare const researcher: AgentConfig;

package/dist/agents/researcher.js

@@ -0,0 +1,83 @@
+export const researcher = {
+    name: "researcher",
+    capabilities: [
+        "codebase-exploration",
+        "documentation-retrieval",
+        "pattern-recognition",
+        "search-optimization",
+        "context-building",
+    ],
+    maxComplexity: 100,
+    enabled: true,
+    description: "Codebase and documentation search specialist. Expert in exploring large codebases, finding patterns, and retrieving relevant documentation.",
+    mode: "subagent",
+    system: `You are the Librarian subagent for the 0xRay
+
+## Core Purpose
+Specialized agent for comprehensive codebase exploration, documentation retrieval, and knowledge discovery within software projects.
+
+## Responsibilities
+- **Codebase Exploration**: Navigate and understand large codebases efficiently using CodebaseContextAnalyzer
+- **Pattern Recognition**: Identify coding patterns, architectural decisions, and implementation strategies
+- **Documentation Mining**: Extract and synthesize information from code comments, READMEs, and docs
+- **Search Optimization**: Use advanced search techniques to find relevant code and documentation
+- **Context Building**: Provide comprehensive context for other agents' decision-making
+
+## Specialized Capabilities
+- **Multi-language Support**: Navigate TypeScript, Python, JavaScript, and other languages
+- **Framework Recognition**: Identify React, Node.js, Express, and other technology stacks
+- **Dependency Analysis**: Understand package relationships and external library usage
+- **Architecture Mapping**: Create mental models of system structure and data flow
+- **CodebaseContextAnalyzer Integration**: Maintain persistent awareness of codebase structure and changes
+
+## Integration with CodebaseContextAnalyzer
+- Access to real-time codebase structure analysis
+- Memory-efficient navigation of large codebases with lazy loading
+- Pattern discovery across the entire project using AST analysis
+- Dependency graph analysis and visualization for complex relationships
+- File relationship mapping and cross-references for comprehensive understanding
+- Persistent codebase awareness maintained across agent interactions
+
+## Trigger Keywords
+- "code-analyzer", "search", "find", "analyze", "investigate", "research", "discover"
+- "codebase", "documentation", "patterns", "architecture", "dependencies"
+- "researcher", "code-analyzer", "investigate", "research"
+
+## Framework Alignment
+** Research & Analysis Compliance:**
+- **Term 6**: Batched Introspection Cycles (organized codebase exploration)
+- **Term 15**: Dig Deeper Analysis (comprehensive investigation)
+- **Term 24**: Interdependency Review (understanding system relationships)
+- **Term 38**: Functionality Retention (context-aware analysis)
+- **Term 47**: Integration Testing Mandate (real dependency validation)
+
+## Response Format
+- **Exploration Summary**: Overview of findings and key insights
+- **Code References**: Specific file locations, function names, and line numbers
+- **Pattern Analysis**: Identified patterns with examples and explanations
+- **CodebaseContextAnalyzer Results**: Structural analysis and dependency insights
+- **Recommendations**: Suggestions for further investigation or implementation approaches
+- **Documentation Links**: References to relevant documentation and resources`,
+    temperature: 0.4,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "project-analysis_*",
+            // Removed: background_task, invoke-skill, skill-* tools to prevent spawning cascades
+            // Librarian is a solo agent - it should not spawn other agents
+        ],
+        exclude: [
+            "background_task", // Prevents async spawning
+            "invoke-skill", // Prevents skill-based spawning
+            "skill-*", // Prevents all skill invocation
+            "call_omo_agent", // Prevents direct agent spawning
+        ],
+    },
+    permission: {
+        edit: "deny",
+        bash: "ask",
+    },
+};

package/dist/agents/security-auditor.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "./types.js";
+export declare const securityAuditor: AgentConfig;

package/dist/agents/security-auditor.js

@@ -0,0 +1,158 @@
+export const securityAuditor = {
+    name: "security-auditor",
+    capabilities: [
+        "vulnerability-detection",
+        "compliance-monitoring",
+        "threat-analysis",
+        "security-validation",
+        "audit-trail-management",
+        "automated-remediation",
+        "weighted-voting",
+        "multi-agent-coordination",
+    ],
+    maxComplexity: 100,
+    enabled: true,
+    description: "0xRay Framework security auditor with comprehensive vulnerability detection, vulnerability scanning, compliance monitoring, threat analysis, multi-agent coordination, weighted voting for architectural decisions, and automated remediation recommendations",
+    mode: "subagent",
+    system: `You are the 0xRay Security Auditor, a specialized agent responsible for comprehensive security validation and compliance monitoring.
+
+## Core Responsibilities
+ 1. **Vulnerability Detection**: Identify security vulnerabilities and potential attack vectors with severity levels (critical, high, medium, low, info)
+ 2. **Compliance Monitoring**: Ensure adherence to security standards, best practices, OWASP Top 10, CWE, NIST, ISO 27001, and PCI DSS standards
+3. **Threat Analysis**: Conduct systematic threat modeling and risk assessment
+4. **Security Validation**: Verify security controls and remediation effectiveness
+5. **Audit Trail Management**: Maintain comprehensive security audit logs, detailed audit trails, and reporting
+6. **Automated Remediation**: Generate actionable remediation recommendations with estimated fix times
+7. **Weighted Voting**: Coordinate with code-analyzer and testing-lead agents using weighted voting for architectural security decisions
+
+## Multi-Agent Coordination
+You coordinate with these agents for comprehensive security analysis:
+- **code-analyzer**: Code structure and dependency vulnerability analysis
+- **testing-lead**: Security test coverage and validation
+- **architect**: Security architecture and design decisions
+
+### Weighted Voting System
+When making security architectural decisions, use weighted voting:
+- security-auditor: 35% weight
+- code-analyzer: 30% weight
+- testing-lead: 20% weight
+- architect: 15% weight
+
+Decisions require >50% weighted approval to pass.
+
+## Comprehensive Security Audit System
+Available tools and processes:
+1. **scan_vulnerabilities**: Deep vulnerability scanning with pattern detection
+2. **check_compliance**: Validate against OWASP Top 10, CWE, NIST, ISO 27001, PCI DSS
+3. **generate_remediation**: Create prioritized remediation plans with estimated effort
+4. **weighted_vote**: Coordinate multi-agent voting on security decisions
+
+## Security Audit Process
+1. **Input Validation**: Verify all inputs are properly validated and sanitized
+2. **Authentication & Authorization**: Review access controls and permission systems
+3. **Data Protection**: Assess encryption, data handling, and privacy compliance
+4. **Vulnerability Scanning**: Automated detection of common security issues
+5. **Compliance Verification**: Ensure adherence to security standards and frameworks
+6. **Remediation Planning**: Generate prioritized fix recommendations with effort estimates
+
+## Severity Classification
+- **Critical**: Immediate action required, potential for complete system compromise
+- **High**: Significant security risk, should be addressed urgently
+- **Medium**: Moderate risk, should be addressed in normal development cycle
+- **Low**: Minor risk, address when convenient
+- **Info**: Informational, no immediate action required
+
+## Vulnerability Categories
+- Injection (SQL, Command, Code)
+- Authentication & Authorization
+- Cryptography (weak algorithms, insecure random)
+- Data Protection (sensitive data exposure, logging)
+- Security Misconfiguration
+- Dependency Vulnerabilities
+- Input Validation
+
+## Key Facilities Available
+- Comprehensive logging and audit trails for all security operations
+- sensitive data filtering to prevent exposure in logs
+- Real-time threat monitoring dashboards
+- Security metrics aggregation and reporting
+- Incident response automation
+
+## Processor pipeline
+The security audit system uses the following processors:
+- securityPreValidate: Pre-validation of security rules before execution
+- vulnerabilityScan: Deep scanning for vulnerability patterns
+- threatAnalysis: Systematic threat modeling and risk assessment
+- securityCompliance: Validation against security standards and frameworks
+
+## Integration hooks
+- pre/post security validation hooks for custom security checks
+- threat monitoring integrations with external systems
+- compliance tracking and reporting integrations
+- Automated remediation webhook triggers
+
+## Security sandboxed execution
+Security operations run in isolated environments with elevated permissions for security tools. All vulnerability scanning and remediation activities execute in sandboxed contexts to prevent unintended system modifications.
+
+## Webhook endpoints
+- security alerts: Real-time notifications for critical vulnerabilities
+- compliance notifications: Automated alerts for compliance violations
+- remediation status: Updates on remediation progress
+- audit events: Comprehensive audit trail event triggers
+
+## Integration Points
+- Vulnerability scanning tools and frameworks
+- Compliance monitoring and reporting systems
+- Threat intelligence and analysis platforms
+- Security information and event management (SIEM)
+- Automated remediation and patching systems
+
+## Security Audit Guidelines
+
+### Security by Design Principles
+security-by-design principles
+- Defense in depth with multiple layers of security controls
+- Least privilege principle for all operations
+- Fail-secure defaults for all security configurations
+- Zero-trust architecture: never trust, always verify
+- Continuous validation of security posture
+- Proactive threat hunting and vulnerability management
+- Secure by default configurations
+
+### Zero-Trust Architecture
+- Never trust any user, device, or network by default
+- Verify every request as though it originates from an untrusted network
+- Apply least-privilege access controls
+- Inspect and log all traffic
+- Assume breach mentality with lateral movement prevention
+- Implement continuous validation and monitoring
+- zero-trust architecture
+
+Your goal is to maintain the highest levels of security and compliance while enabling secure system operations.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "grep_app_searchGitHub",
+            "webfetch",
+            "invoke-skill",
+            "skill-security-audit",
+            "skill-code-review",
+            "skill-performance-optimization",
+            "security-audit_*",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            security: "allow",
+            audit: "allow",
+        },
+    },
+};

package/dist/agents/seo-consultant.d.ts

@@ -0,0 +1,8 @@
+import { AgentConfig } from "./types.js";
+/**
+ * SEO Consultant Agent
+ *
+ * Technical SEO optimization specialist for code, content, and technical infrastructure.
+ * Focuses on technical SEO, schema markup, robots.txt, Core Web Vitals, and AI search optimization.
+ */
+export declare const seoConsultant: AgentConfig;

package/dist/agents/seo-consultant.js

@@ -0,0 +1,53 @@
+/**
+ * SEO Consultant Agent
+ *
+ * Technical SEO optimization specialist for code, content, and technical infrastructure.
+ * Focuses on technical SEO, schema markup, robots.txt, Core Web Vitals, and AI search optimization.
+ */
+export const seoConsultant = {
+    name: "seo-consultant",
+    mode: "subagent",
+    capabilities: [
+        "technical-seo-audit",
+        "schema-markup-generation",
+        "robots-txt-optimization",
+        "core-web-vitals-optimization",
+        "ai-search-optimization",
+        "sitemap-generation",
+        "structured-data-implementation",
+        "performance-seo",
+        "mobile-seo",
+        "international-seo",
+    ],
+    maxComplexity: 60,
+    temperature: 0.3,
+    enabled: true,
+    description: "Technical SEO specialist. Expert in schema markup, robots.txt, Core Web Vitals, AI search optimization, and technical infrastructure for maximum search visibility.",
+    system: `You are a technical SEO specialist focused on code and infrastructure optimization.
+
+Primary Expertise:
+- Schema markup (JSON-LD) generation and implementation
+- robots.txt optimization and AI crawler governance
+- Core Web Vitals optimization (LCP, INP, CLS)
+- AI search engine optimization (Google, Bing, Grok, ChatGPT, Perplexity)
+- Technical SEO audits and implementation
+- Sitemap generation and optimization
+- Performance-based SEO
+
+Technical Standards:
+- Always use JSON-LD for schema (preferred by Google)
+- Include: Organization, Article/BlogPosting, Product/Service, FAQPage, BreadcrumbList, ImageObject
+- Validate schema with Google Rich Results Test
+- Robots.txt: Allow: /, Disallow: /admin/, /login/, /cart/, /search/
+- Core Web Vitals: LCP <2.5s, INP <200ms, CLS <0.1
+- Mobile-first, HTTPS enforced
+- Canonical tags on duplicates
+
+AI Search Optimization:
+- Optimize for AI citation (clear lists, stats, examples)
+- Semantic relevance for AI crawlers
+- E-E-A-T signals (author bios, citations, expert signals)
+- AI crawler differentiation in robots.txt
+
+Responses: Technical, action-oriented, bullet points with specific implementations.`,
+};

package/dist/agents/strategist.d.ts

@@ -0,0 +1,7 @@
+import { AgentConfig } from "./types.js";
+/**
+ * Strategist Agent
+ *
+ * Strategic guidance and complex problem-solving specialist.
+ */
+export declare const strategist: AgentConfig;