/**
 * Role-Based Task Management for Orchestry
 *
 * Manages task assignments based on LLM session roles and expertise
 */
import { DatabaseManager } from '../database-manager.js';
import { Priority } from '../../shared/types.js';
export type LLMRole = 'backend' | 'frontend' | 'fullstack' | 'devops' | 'database' | 'testing' | 'security' | 'ui-ux' | 'architect' | 'product-manager' | 'code-reviewer' | 'documentation';
export declare const ROLE_CAPABILITIES: Record<LLMRole, {
    skills: string[];
    preferredTasks: string[];
    canReview: LLMRole[];
}>;
export declare const PRIORITY_MATRIX: {
    taskTypes: {
        security: string;
        bug: string;
        feature: string;
        enhancement: string;
        documentation: string;
        refactor: string;
    };
    keywords: {
        urgent: string;
        asap: string;
        blocker: string;
        critical: string;
        important: string;
        breaking: string;
        crash: string;
        security: string;
        vulnerability: string;
        optimization: string;
        'nice-to-have': string;
    };
    hasDependents: {
        many: string;
        some: string;
        none: null;
    };
};
export declare class RoleBasedTaskManager {
    private dbManager;
    private sessions;
    constructor(dbManager: DatabaseManager);
    /**
     * Register a new LLM session with a role
     */
    registerSession(sessionId: string, role: LLMRole, expertise?: string[]): {
        sessionId: string;
        role: LLMRole;
        capabilities: {
            skills: string[];
            preferredTasks: string[];
            canReview: LLMRole[];
        };
    };
    /**
     * Automatically assign a task to the best available session
     */
    autoAssignTask(taskTitle: string, taskDescription: string, requiredSkills?: string[]): Promise<{
        assignedTo: string;
        role: LLMRole;
        priority: Priority;
        reason: string;
    }>;
    /**
     * Determine priority based on content analysis
     */
    private determinePriority;
    /**
     * Get recommended next task for a session based on role
     */
    getNextTask(sessionId: string): Promise<{
        task: any;
        reason: string;
    } | null>;
    /**
     * Load balancing - redistribute tasks if a session becomes unavailable
     */
    redistributeTasks(unavailableSessionId: string): Promise<void>;
    /**
     * Get workload distribution across all sessions
     */
    getWorkloadDistribution(): Record<LLMRole, {
        sessions: number;
        totalLoad: number;
        averageLoad: number;
    }>;
}
/**
 * Enhanced collaboration tools with role-based features
 */
export declare class EnhancedCollaborationTools {
    private dbManager;
    private taskManager;
    constructor(dbManager: DatabaseManager);
    getEnhancedTools(): ({
        name: string;
        description: string;
        inputSchema: {
            type: string;
            properties: {
                role: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                expertise: {
                    type: string;
                    items: {
                        type: string;
                    };
                    description: string;
                };
                sessionName: {
                    type: string;
                    description: string;
                };
                title?: undefined;
                description?: undefined;
                requiredSkills?: undefined;
                explicitPriority?: undefined;
                preferredRole?: undefined;
                dependencies?: undefined;
                estimatedHours?: undefined;
                taskType?: undefined;
                taskId?: undefined;
                assignTo?: undefined;
                priority?: undefined;
                reason?: undefined;
                targetRole?: undefined;
                issue?: undefined;
                context?: undefined;
                newPriority?: undefined;
                escalateToRole?: undefined;
            };
            required: string[];
        };
    } | {
        name: string;
        description: string;
        inputSchema: {
            type: string;
            properties: {
                title: {
                    type: string;
                    description: string;
                };
                description: {
                    type: string;
                    description: string;
                };
                requiredSkills: {
                    type: string;
                    items: {
                        type: string;
                    };
                    description: string;
                };
                explicitPriority: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                preferredRole: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                dependencies: {
                    type: string;
                    items: {
                        type: string;
                    };
                    description: string;
                };
                estimatedHours: {
                    type: string;
                    description: string;
                };
                role?: undefined;
                expertise?: undefined;
                sessionName?: undefined;
                taskType?: undefined;
                taskId?: undefined;
                assignTo?: undefined;
                priority?: undefined;
                reason?: undefined;
                targetRole?: undefined;
                issue?: undefined;
                context?: undefined;
                newPriority?: undefined;
                escalateToRole?: undefined;
            };
            required: string[];
        };
    } | {
        name: string;
        description: string;
        inputSchema: {
            type: string;
            properties: {
                taskType: {
                    type: string;
                    description: string;
                };
                role?: undefined;
                expertise?: undefined;
                sessionName?: undefined;
                title?: undefined;
                description?: undefined;
                requiredSkills?: undefined;
                explicitPriority?: undefined;
                preferredRole?: undefined;
                dependencies?: undefined;
                estimatedHours?: undefined;
                taskId?: undefined;
                assignTo?: undefined;
                priority?: undefined;
                reason?: undefined;
                targetRole?: undefined;
                issue?: undefined;
                context?: undefined;
                newPriority?: undefined;
                escalateToRole?: undefined;
            };
            required?: undefined;
        };
    } | {
        name: string;
        description: string;
        inputSchema: {
            type: string;
            properties: {
                taskId: {
                    type: string;
                    description: string;
                };
                assignTo: {
                    type: string;
                    description: string;
                };
                priority: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                reason: {
                    type: string;
                    description: string;
                };
                role?: undefined;
                expertise?: undefined;
                sessionName?: undefined;
                title?: undefined;
                description?: undefined;
                requiredSkills?: undefined;
                explicitPriority?: undefined;
                preferredRole?: undefined;
                dependencies?: undefined;
                estimatedHours?: undefined;
                taskType?: undefined;
                targetRole?: undefined;
                issue?: undefined;
                context?: undefined;
                newPriority?: undefined;
                escalateToRole?: undefined;
            };
            required: string[];
        };
    } | {
        name: string;
        description: string;
        inputSchema: {
            type: string;
            properties: {
                role?: undefined;
                expertise?: undefined;
                sessionName?: undefined;
                title?: undefined;
                description?: undefined;
                requiredSkills?: undefined;
                explicitPriority?: undefined;
                preferredRole?: undefined;
                dependencies?: undefined;
                estimatedHours?: undefined;
                taskType?: undefined;
                taskId?: undefined;
                assignTo?: undefined;
                priority?: undefined;
                reason?: undefined;
                targetRole?: undefined;
                issue?: undefined;
                context?: undefined;
                newPriority?: undefined;
                escalateToRole?: undefined;
            };
            required?: undefined;
        };
    } | {
        name: string;
        description: string;
        inputSchema: {
            type: string;
            properties: {
                targetRole: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                issue: {
                    type: string;
                    description: string;
                };
                context: {
                    type: string;
                    description: string;
                };
                priority: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                role?: undefined;
                expertise?: undefined;
                sessionName?: undefined;
                title?: undefined;
                description?: undefined;
                requiredSkills?: undefined;
                explicitPriority?: undefined;
                preferredRole?: undefined;
                dependencies?: undefined;
                estimatedHours?: undefined;
                taskType?: undefined;
                taskId?: undefined;
                assignTo?: undefined;
                reason?: undefined;
                newPriority?: undefined;
                escalateToRole?: undefined;
            };
            required: string[];
        };
    } | {
        name: string;
        description: string;
        inputSchema: {
            type: string;
            properties: {
                taskId: {
                    type: string;
                    description: string;
                };
                newPriority: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                escalateToRole: {
                    type: string;
                    enum: string[];
                    description: string;
                };
                reason: {
                    type: string;
                    description: string;
                };
                role?: undefined;
                expertise?: undefined;
                sessionName?: undefined;
                title?: undefined;
                description?: undefined;
                requiredSkills?: undefined;
                explicitPriority?: undefined;
                preferredRole?: undefined;
                dependencies?: undefined;
                estimatedHours?: undefined;
                taskType?: undefined;
                assignTo?: undefined;
                priority?: undefined;
                targetRole?: undefined;
                issue?: undefined;
                context?: undefined;
            };
            required: string[];
        };
    })[];
}
/**
 * Priority queue for task management
 */
export declare class TaskPriorityQueue {
    private queues;
    addTask(task: any, priority: Priority): void;
    getNextTask(): any | null;
    getQueueStatus(): Record<Priority, number>;
}
//# sourceMappingURL=role-based-collaboration.d.ts.map