import type { AgentRole, ModelTier } from './multi-agent.js';
/** Complete distribution plan for a team of Claude Code agents. */
export interface TeamDistributionPlan {
    /** Human-readable team name. */
    teamName: string;
    /** Total number of teammates in the team. */
    teamSize: number;
    /** Per-teammate assignment details. */
    teammates: TeammateAssignment[];
    /** Ordered execution phases (parallel within each phase). */
    executionOrder: TeamExecutionPhase[];
    /** Estimated wall-clock duration for the full team run. */
    estimatedDuration: string;
    /** Warnings about potential issues (e.g. file conflicts, large specs). */
    warnings: string[];
}
/** Assignment details for a single teammate in the team. */
export interface TeammateAssignment {
    /** Unique teammate name (e.g. "spec-042-impl"). */
    name: string;
    /** Role this teammate fulfils. */
    role: AgentRole;
    /** Model tier assigned to this teammate. */
    model: ModelTier;
    /** Spec IDs this teammate is responsible for. */
    specs: string[];
    /** Files this teammate has exclusive write access to. */
    ownedFiles: string[];
    /** Generated prompt to send to this teammate. */
    prompt: string;
}
/** A phase of execution where all listed teammates run in parallel. */
export interface TeamExecutionPhase {
    /** Phase number (1-based). */
    phase: number;
    /** Teammate names that run in parallel during this phase. */
    teammates: string[];
    /** Reason these teammates are grouped together (or separated). */
    reason: string;
}
/** Predefined team composition template. */
export interface TeamTemplate {
    /** Unique template identifier. */
    id: string;
    /** Human-readable template name. */
    name: string;
    /** Short description of the template strategy. */
    description: string;
    /** Pattern category for matching. */
    pattern: string;
    /** Role composition for the team. */
    roles: TeamTemplateRole[];
}
/** A role slot within a TeamTemplate. */
export interface TeamTemplateRole {
    /** Agent role for this slot. */
    role: AgentRole;
    /** Model tier for agents in this slot. */
    model: ModelTier;
    /** Fixed count or "per-spec" for dynamic sizing. */
    count: number | 'per-spec';
}
/** Recommendation on whether to use Agent Teams for a set of specs. */
export interface TeamSuggestion {
    /** Whether Agent Teams are recommended for this workload. */
    recommended: boolean;
    /** Explanation of the recommendation. */
    reason: string;
    /** Suggested template ID. */
    templateId: string;
    /** Recommended team size. */
    teamSize: number;
    /** Spec IDs included in the recommendation. */
    specs: string[];
    /** Exact tool call suggestions for the LLM to execute. */
    toolCalls: string[];
}
/** Context provided to the prompt builder for a single teammate. */
export interface TeammatePromptContext {
    /** Primary language of the project (e.g. "typescript", "python"). */
    projectLanguage: string;
    /** Primary framework if detected (e.g. "next.js", "django"). */
    projectFramework: string | null;
    /** Architecture pattern (e.g. "hexagonal", "layered"). */
    architecture: string;
    /** Project conventions extracted from constitution/config. */
    conventions: Record<string, unknown>;
    /** Spec details for this teammate's assignment. */
    specDetails: {
        id: string;
        title: string;
        criteria: string[];
    };
    /** Files this teammate owns (exclusive write access). */
    ownedFiles: string[];
    /** Files this teammate must NOT modify. */
    forbiddenFiles: string[];
    /** Quality rules from the project constitution. */
    qualityRules: string[];
    /** Testing requirements (coverage thresholds, runner commands). */
    testingRequirements: string[];
    /** Git conventions (branch naming, commit format). */
    gitConventions: string[];
    /** Commands to run for validation before reporting done. */
    validationCommands: string[];
}
/** Result of validating team outputs after all teammates complete. */
export interface TeamValidationResult {
    /** Whether the overall validation passed. */
    passed: boolean;
    /** Whether TypeScript type-checking passed. */
    typecheckPassed: boolean;
    /** Whether linting passed. */
    lintPassed: boolean;
    /** Whether tests passed. */
    testsPassed: boolean;
    /** Whether coverage thresholds were met. */
    coveragePassed: boolean;
    /** Files modified by more than one teammate (violations). */
    fileConflicts: {
        file: string;
        teammates: string[];
    }[];
    /** Per-spec criteria coverage report. */
    criteriaReport: {
        specId: string;
        covered: number;
        total: number;
    }[];
    /** Recommended order for merging teammate branches. */
    mergeOrder: string[];
    /** Human-readable summary of validation results. */
    summary: string;
}
/** Minimal spec-like input for the distribution planner. */
export interface TeamPlannerSpecInput {
    id: string;
    title: string;
    criteria?: string[];
}
/** Minimal reference to a team template. */
export interface TeamTemplateRef {
    id: string;
    name: string;
}
/** Output produced by a teammate, used for validation. */
export interface TeammateOutput {
    name: string;
    modifiedFiles: string[];
    coveredCriteria: string[];
}
/** Input for the plan_team_distribution tool. */
export interface PlanTeamDistributionInput {
    /** Project identifier. */
    projectId: string;
    /** Spec IDs to distribute across the team. */
    specIds: string[];
    /** Optional template ID to use for team composition. */
    template?: string;
}
/** Input for the generate_teammate_prompt tool. */
export interface GenerateTeammatePromptInput {
    /** Project identifier. */
    projectId: string;
    /** Spec ID assigned to this teammate. */
    specId: string;
    /** Name for this teammate. */
    teammateName: string;
    /** Files assigned to this teammate (optional — defaults to []). */
    assignedFiles?: string[];
    /** Role for this teammate. */
    role: AgentRole;
}
/** Input for the validate_team_results tool. */
export interface ValidateTeamResultsInput {
    /** Project identifier. */
    projectId: string;
    /** Spec IDs that were distributed. */
    specIds: string[];
    /** Names of teammates whose results to validate. */
    teammateNames: string[];
}
export interface WriterReviewerConfig {
    specId: string;
    modifiedFiles: string[];
    acceptanceCriteria: string[];
    projectPath: string;
}
export interface ReviewerPrompt {
    /** Full session instructions ready to paste into a new Claude session. */
    sessionInstructions: string;
    /** File references formatted as "@file1.ts @file2.ts ..." */
    fileReferences: string;
    /** Checklist of acceptance criteria to verify. */
    reviewChecklist: string[];
    /** Command to start the reviewer session. */
    startCommand: string;
    /** Review dimensions the reviewer should address. */
    dimensions: string[];
}
//# sourceMappingURL=team-planner.d.ts.map