0xray 4.0.12 → 4.0.13

package/dist/agents/registry.js

@@ -1,354 +0,0 @@
-/**
- * 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

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

package/dist/agents/researcher.js

@@ -1,83 +0,0 @@
-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

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

package/dist/agents/security-auditor.js

@@ -1,158 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,53 +0,0 @@
-/**
- * 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

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