Snapshot of PlanExe commit 5012c8a07355571673d80b3e1f60b5fc0fc1a715

src/plan/data/simple_plan_prompts.jsonl

@@ -23,3 +23,13 @@
 {"id": "676cbca8-5d49-42a0-8826-398318004703", "prompt": "Write a Python script for a snake shape keep bouncing within a pentagon. Make sure to handle collision detection properly. Make the pentagon slowly rotate.", "tags": ["programming", "python", "collision detection"]}
 {"id": "a9113924-6148-4a0c-b72a-eecdb856e1e2", "prompt": "Investigate outbreak of a deadly new disease in the jungle.", "tags": ["outbreak", "jungle"]}
 {"id": "4dc34d55-0d0d-4e9d-92f4-23765f49dd29", "prompt": "Establish a solar farm in Denmark.", "tags": ["denmark", "energy", "sun"]}
+{"id": "0bb4a7d3-c16b-4b21-8a9b-20e1cd4002d4", "prompt": "Develop a sustainable solution for extreme poverty in regions where people live on less than 2 USD per day. Focus on improving access to basic necessities like food, shelter, and clean water, and explain how you would allocate investments given that sectors like infrastructure may require higher per capita funding. Indicate whether your approach leverages existing systems or builds new capacity. Assume this initiative will impact 5 million people over 5 years with a total budget of 500 million USD.", "tags": ["poverty", "sustainability", "development"]}
+{"id": "307f7e0c-a160-4b7a-9e3c-76577164497e", "prompt": "Create a comprehensive plan to address hunger and malnutrition in impoverished communities by enhancing food security and nutritional education. Provide a detailed cost breakdown and clarify which components might need additional per capita investment. State whether you will leverage existing food distribution networks or develop new infrastructure. Assume the plan targets 3 million individuals across 10 countries with a total budget of 300 million USD over 4 years.", "tags": ["hunger", "malnutrition", "nutrition"]}
+{"id": "1ea5076a-95b5-47fe-aff5-f03c8ef00cd7", "prompt": "Implement a comprehensive strategy for providing clean water to areas where it is currently unavailable. Your solution should include infrastructure development for water purification, distribution, and ongoing maintenance, and clarify if you are upgrading existing systems or building new ones from scratch. Assume this project will serve 2 million people in rural areas over 3 years with a total budget of 200 million USD.", "tags": ["water", "sanitation", "infrastructure"]}
+{"id": "08505146-b6ad-4d7c-b6b6-85c2868e707d", "prompt": "Design an initiative to improve sanitation in both slums and rural areas to reduce disease spread and enhance living conditions. Provide a detailed allocation plan that accounts for the varying needs of urban versus rural contexts, and note that phased investments may be necessary for sustainable infrastructure. Assume the initiative will reach 1.5 million people in 50 different locations over 5 years with a total budget of 150 million USD.", "tags": ["sanitation", "health", "slums"]}
+{"id": "0bb00fe6-711c-4612-8f83-a9a88e5c7958", "prompt": "Establish accessible healthcare systems in regions where medical facilities are scarce, focusing on both preventive care and emergency services. Clarify whether your approach involves upgrading existing facilities or constructing new ones, and account for the typically higher per capita costs in healthcare infrastructure. Assume the program will cover 4 million people in 20 countries over 6 years with a total budget of 400 million USD.", "tags": ["healthcare", "accessibility", "medicine"]}
+{"id": "79b62957-cae7-4727-8450-4f5f29d4ddda", "prompt": "Create a detailed plan to increase educational opportunities in poverty-stricken areas. This plan should include building or improving schools, teacher training, and scholarship programs, with a clear breakdown of resource allocation among these components. Recognize that educational initiatives may require higher per capita investments for infrastructure compared to service-based interventions. Assume the plan will support 1 million students over 7 years with a total budget of 350 million USD.", "tags": ["education", "literacy", "development"]}
+{"id": "6f7a8b9c-0d1e-2f3a-4b5c-6d7e8f90a1b2", "prompt": "Develop comprehensive policies and programs to eradicate child labor by ensuring children have access to education and protection from exploitation. Include details on scaling the initiative and allocating funds among enforcement, educational support, and social services. Assume this effort will benefit 500,000 children in 15 countries over 5 years with a total budget of 100 million USD.", "tags": ["child labor", "education", "protection"]}
+{"id": "a9f410c0-120e-45d6-b042-e88ca47b39bb", "prompt": "Formulate a housing security plan that addresses overcrowding, unsafe living conditions, and homelessness by promoting secure and dignified housing. Clarify whether the initiative involves new construction, rehabilitation of existing structures, or a combination of both, and outline a phased investment strategy given the higher costs typically associated with housing projects. Assume the plan will provide housing for 200,000 individuals over 4 years with a total budget of 250 million USD.", "tags": ["housing", "security", "urban development"]}
+{"id": "cdf7f29d-bbcb-478d-8b5a-e82e74ed8626", "prompt": "Propose comprehensive peace initiatives and conflict resolution strategies for areas experiencing high rates of violence and political instability. Detail how your approach will protect vulnerable populations, including mechanisms for community engagement, reconciliation, and rebuilding. Assume the intervention will affect 1 million people in conflict zones over 3 years with a total budget of 150 million USD.", "tags": ["conflict", "peace", "stability"]}
+{"id": "79ef9ebf-3173-4b33-81f9-abbd3da7da6d", "prompt": "Design robust adaptation and resilience programs for communities facing environmental degradation and the effects of climate change, especially in disaster-prone regions. Include both short-term relief measures and long-term sustainability strategies, and provide details on how funds will be allocated between immediate response and infrastructure improvements. Assume the initiative will aid 1.2 million people in the 10 most affected countries over 5 years with a total budget of 180 million USD.", "tags": ["environment", "climate change", "resilience"]}

src/plan/filenames.py

@@ -8,26 +8,36 @@ class FilenameEnum(str, Enum):
     PRE_PROJECT_ASSESSMENT_RAW = "004-1-pre_project_assessment_raw.json"
     PRE_PROJECT_ASSESSMENT = "004-2-pre_project_assessment.json"
     PROJECT_PLAN = "005-project_plan.json"
-    SWOT_RAW = "006-1-swot_analysis_raw.json"
-    SWOT_MARKDOWN = "006-2-swot_analysis.md"
-    EXPERTS_RAW = "007-1-experts_raw.json"
-    EXPERTS_CLEAN = "007-2-experts.json"
-    EXPERT_CRITICISM_RAW_TEMPLATE = "008-1-{}-expert_criticism_raw.json"
-    EXPERT_CRITICISM_MARKDOWN = "008-2-expert_criticism.md"
-    WBS_LEVEL1_RAW = "009-1-wbs_level1_raw.json"
-    WBS_LEVEL1 = "009-2-wbs_level1.json"
-    WBS_LEVEL2_RAW = "010-1-wbs_level2_raw.json"
-    WBS_LEVEL2 = "010-2-wbs_level2.json"
-    WBS_PROJECT_LEVEL1_AND_LEVEL2 = "011-wbs_project_level1_and_level2.json"
-    PITCH_RAW = "012-1-pitch_raw.json"
-    PITCH_CONVERT_TO_MARKDOWN_RAW = "012-2-pitch_to_markdown_raw.json"
-    PITCH_MARKDOWN = "012-3-pitch.md"
-    TASK_DEPENDENCIES_RAW = "013-task_dependencies_raw.json"
-    TASK_DURATIONS_RAW_TEMPLATE = "014-1-{}-task_durations_raw.json"
-    TASK_DURATIONS = "014-2-task_durations.json"
-    WBS_LEVEL3_RAW_TEMPLATE = "015-1-{}-wbs_level3_raw.json"
-    WBS_LEVEL3 = "015-2-wbs_level3.json"
-    WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_FULL = "015-3-wbs_project_level1_and_level2_and_level3.json"
-    WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_CSV = "015-4-wbs_project_level1_and_level2_and_level3.csv"
-    REPORT = "016-report.html"
+    FIND_TEAM_MEMBERS_RAW = "006-1-find_team_members_raw.json"
+    FIND_TEAM_MEMBERS_CLEAN = "006-2-find_team_members.json"
+    ENRICH_TEAM_MEMBERS_CONTRACT_TYPE_RAW = "007-1-enrich_team_members_contract_type_raw.json"
+    ENRICH_TEAM_MEMBERS_CONTRACT_TYPE_CLEAN = "007-2-enrich_team_members_contract_type.json"
+    ENRICH_TEAM_MEMBERS_BACKGROUND_STORY_RAW = "008-1-enrich_team_members_background_story_raw.json"
+    ENRICH_TEAM_MEMBERS_BACKGROUND_STORY_CLEAN = "008-2-enrich_team_members_background_story.json"
+    ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_RAW = "009-1-enrich_team_members_environment_info_raw.json"
+    ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_CLEAN = "009-2-enrich_team_members_environment_info.json"
+    REVIEW_TEAM_RAW = "010-review_team_raw.json"
+    TEAM_MARKDOWN = "011-team.md"
+    SWOT_RAW = "012-1-swot_analysis_raw.json"
+    SWOT_MARKDOWN = "012-2-swot_analysis.md"
+    EXPERTS_RAW = "013-1-experts_raw.json"
+    EXPERTS_CLEAN = "013-2-experts.json"
+    EXPERT_CRITICISM_RAW_TEMPLATE = "014-1-{}-expert_criticism_raw.json"
+    EXPERT_CRITICISM_MARKDOWN = "014-2-expert_criticism.md"
+    WBS_LEVEL1_RAW = "015-1-wbs_level1_raw.json"
+    WBS_LEVEL1 = "015-2-wbs_level1.json"
+    WBS_LEVEL2_RAW = "016-1-wbs_level2_raw.json"
+    WBS_LEVEL2 = "016-2-wbs_level2.json"
+    WBS_PROJECT_LEVEL1_AND_LEVEL2 = "017-wbs_project_level1_and_level2.json"
+    PITCH_RAW = "018-1-pitch_raw.json"
+    PITCH_CONVERT_TO_MARKDOWN_RAW = "018-2-pitch_to_markdown_raw.json"
+    PITCH_MARKDOWN = "018-3-pitch.md"
+    TASK_DEPENDENCIES_RAW = "019-task_dependencies_raw.json"
+    TASK_DURATIONS_RAW_TEMPLATE = "020-1-{}-task_durations_raw.json"
+    TASK_DURATIONS = "020-2-task_durations.json"
+    WBS_LEVEL3_RAW_TEMPLATE = "021-1-{}-wbs_level3_raw.json"
+    WBS_LEVEL3 = "021-2-wbs_level3.json"
+    WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_FULL = "021-3-wbs_project_level1_and_level2_and_level3.json"
+    WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_CSV = "021-4-wbs_project_level1_and_level2_and_level3.csv"
+    REPORT = "022-report.html"
     PIPELINE_COMPLETE = "999-pipeline_complete.txt"

src/plan/run_plan_pipeline.py

@@ -31,6 +31,12 @@ from src.pitch.create_pitch import CreatePitch
 from src.pitch.convert_pitch_to_markdown import ConvertPitchToMarkdown
 from src.plan.identify_wbs_task_dependencies import IdentifyWBSTaskDependencies
 from src.plan.estimate_wbs_task_durations import EstimateWBSTaskDurations
+from src.team.find_team_members import FindTeamMembers
+from src.team.enrich_team_members_with_contract_type import EnrichTeamMembersWithContractType
+from src.team.enrich_team_members_with_background_story import EnrichTeamMembersWithBackgroundStory
+from src.team.enrich_team_members_with_environment_info import EnrichTeamMembersWithEnvironmentInfo
+from src.team.team_markdown_document import TeamMarkdownDocumentBuilder
+from src.team.review_team import ReviewTeam
 from src.wbs.wbs_task import WBSTask, WBSProject
 from src.wbs.wbs_populate import WBSPopulate
 from src.llm_factory import get_llm
@@ -210,6 +216,401 @@ class ProjectPlanTask(PlanTask):
         logger.info("Project plan created and saved to %s", output_path)
 
 
+class FindTeamMembersTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'preproject': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.FIND_TEAM_MEMBERS_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.FIND_TEAM_MEMBERS_CLEAN)))
+        }
+
+    def run(self):
+        logger.info("FindTeamMembers. Loading files...")
+
+        # 1. Read the plan prompt from SetupTask.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        # 2. Read the distilled assumptions from AssumptionsTask.
+        with self.input()['assumptions'].open("r") as f:
+            assumption_list = json.load(f)
+
+        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        with self.input()['preproject']['clean'].open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+
+        # 4. Read the project plan from ProjectPlanTask.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+
+        logger.info("FindTeamMembers. All files are now ready. Brainstorming a team...")
+
+        # Build the query.
+        query = (
+            f"Initial plan: {plan_prompt}\n\n"
+            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
+            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
+            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}"
+        )
+
+        # Create LLM instance.
+        llm = get_llm(self.llm_model)
+
+        # Execute.
+        try:
+            find_team_members = FindTeamMembers.execute(llm, query)
+        except Exception as e:
+            logger.error("FindTeamMembers failed: %s", e)
+            raise
+
+        # Save the raw output.
+        raw_dict = find_team_members.to_dict()
+        with self.output()['raw'].open("w") as f:
+            json.dump(raw_dict, f, indent=2)
+
+        # Save the cleaned up result.
+        team_member_list = find_team_members.team_member_list
+        with self.output()['clean'].open("w") as f:
+            json.dump(team_member_list, f, indent=2)
+
+        logger.info("FindTeamMembers complete.")
+
+class EnrichTeamMembersWithContractTypeTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'preproject': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'find_team_members': FindTeamMembersTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.ENRICH_TEAM_MEMBERS_CONTRACT_TYPE_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.ENRICH_TEAM_MEMBERS_CONTRACT_TYPE_CLEAN)))
+        }
+
+    def run(self):
+        logger.info("EnrichTeamMembersWithContractType. Loading files...")
+
+        # 1. Read the plan prompt from SetupTask.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        # 2. Read the distilled assumptions from AssumptionsTask.
+        with self.input()['assumptions'].open("r") as f:
+            assumption_list = json.load(f)
+
+        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        with self.input()['preproject']['clean'].open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+
+        # 4. Read the project plan from ProjectPlanTask.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+
+        # 5. Read the team_member_list from FindTeamMembersTask.
+        with self.input()['find_team_members']['clean'].open("r") as f:
+            team_member_list = json.load(f)
+
+        logger.info("EnrichTeamMembersWithContractType. All files are now ready. Processing...")
+
+        # Build the query.
+        query = (
+            f"Initial plan: {plan_prompt}\n\n"
+            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
+            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
+            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+        )
+
+        # Create LLM instance.
+        llm = get_llm(self.llm_model)
+
+        # Execute.
+        try:
+            enrich_team_members_with_contract_type = EnrichTeamMembersWithContractType.execute(llm, query, team_member_list)
+        except Exception as e:
+            logger.error("EnrichTeamMembersWithContractType failed: %s", e)
+            raise
+
+        # Save the raw output.
+        raw_dict = enrich_team_members_with_contract_type.to_dict()
+        with self.output()['raw'].open("w") as f:
+            json.dump(raw_dict, f, indent=2)
+
+        # Save the cleaned up result.
+        team_member_list = enrich_team_members_with_contract_type.team_member_list
+        with self.output()['clean'].open("w") as f:
+            json.dump(team_member_list, f, indent=2)
+
+        logger.info("EnrichTeamMembersWithContractType complete.")
+
+class EnrichTeamMembersWithBackgroundStoryTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'preproject': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'enrich_team_members_with_contract_type': EnrichTeamMembersWithContractTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.ENRICH_TEAM_MEMBERS_BACKGROUND_STORY_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.ENRICH_TEAM_MEMBERS_BACKGROUND_STORY_CLEAN)))
+        }
+
+    def run(self):
+        logger.info("EnrichTeamMembersWithBackgroundStoryTask. Loading files...")
+
+        # 1. Read the plan prompt from SetupTask.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        # 2. Read the distilled assumptions from AssumptionsTask.
+        with self.input()['assumptions'].open("r") as f:
+            assumption_list = json.load(f)
+
+        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        with self.input()['preproject']['clean'].open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+
+        # 4. Read the project plan from ProjectPlanTask.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+
+        # 5. Read the team_member_list from EnrichTeamMembersWithContractTypeTask.
+        with self.input()['enrich_team_members_with_contract_type']['clean'].open("r") as f:
+            team_member_list = json.load(f)
+
+        logger.info("EnrichTeamMembersWithBackgroundStoryTask. All files are now ready. Processing...")
+
+        # Build the query.
+        query = (
+            f"Initial plan: {plan_prompt}\n\n"
+            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
+            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
+            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+        )
+
+        # Create LLM instance.
+        llm = get_llm(self.llm_model)
+
+        # Execute.
+        try:
+            enrich_team_members_with_background_story = EnrichTeamMembersWithBackgroundStory.execute(llm, query, team_member_list)
+        except Exception as e:
+            logger.error("EnrichTeamMembersWithBackgroundStory failed: %s", e)
+            raise
+
+        # Save the raw output.
+        raw_dict = enrich_team_members_with_background_story.to_dict()
+        with self.output()['raw'].open("w") as f:
+            json.dump(raw_dict, f, indent=2)
+
+        # Save the cleaned up result.
+        team_member_list = enrich_team_members_with_background_story.team_member_list
+        with self.output()['clean'].open("w") as f:
+            json.dump(team_member_list, f, indent=2)
+
+        logger.info("EnrichTeamMembersWithBackgroundStoryTask complete.")
+
+class EnrichTeamMembersWithEnvironmentInfoTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'preproject': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'enrich_team_members_with_background_story': EnrichTeamMembersWithBackgroundStoryTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_CLEAN)))
+        }
+
+    def run(self):
+        logger.info("EnrichTeamMembersWithEnvironmentInfoTask. Loading files...")
+
+        # 1. Read the plan prompt from SetupTask.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        # 2. Read the distilled assumptions from AssumptionsTask.
+        with self.input()['assumptions'].open("r") as f:
+            assumption_list = json.load(f)
+
+        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        with self.input()['preproject']['clean'].open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+
+        # 4. Read the project plan from ProjectPlanTask.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+
+        # 5. Read the team_member_list from EnrichTeamMembersWithBackgroundStoryTask.
+        with self.input()['enrich_team_members_with_background_story']['clean'].open("r") as f:
+            team_member_list = json.load(f)
+
+        logger.info("EnrichTeamMembersWithEnvironmentInfoTask. All files are now ready. Processing...")
+
+        # Build the query.
+        query = (
+            f"Initial plan: {plan_prompt}\n\n"
+            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
+            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
+            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+        )
+
+        # Create LLM instance.
+        llm = get_llm(self.llm_model)
+
+        # Execute.
+        try:
+            enrich_team_members_with_background_story = EnrichTeamMembersWithEnvironmentInfo.execute(llm, query, team_member_list)
+        except Exception as e:
+            logger.error("EnrichTeamMembersWithEnvironmentInfo failed: %s", e)
+            raise
+
+        # Save the raw output.
+        raw_dict = enrich_team_members_with_background_story.to_dict()
+        with self.output()['raw'].open("w") as f:
+            json.dump(raw_dict, f, indent=2)
+
+        # Save the cleaned up result.
+        team_member_list = enrich_team_members_with_background_story.team_member_list
+        with self.output()['clean'].open("w") as f:
+            json.dump(team_member_list, f, indent=2)
+
+        logger.info("EnrichTeamMembersWithEnvironmentInfoTask complete.")
+
+class ReviewTeamTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'preproject': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'enrich_team_members_with_environment_info': EnrichTeamMembersWithEnvironmentInfoTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.REVIEW_TEAM_RAW)))
+
+    def run(self):
+        logger.info("ReviewTeamTask. Loading files...")
+
+        # 1. Read the plan prompt from SetupTask.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        # 2. Read the distilled assumptions from AssumptionsTask.
+        with self.input()['assumptions'].open("r") as f:
+            assumption_list = json.load(f)
+
+        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        with self.input()['preproject']['clean'].open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+
+        # 4. Read the project plan from ProjectPlanTask.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+
+        # 5. Read the team_member_list from EnrichTeamMembersWithEnvironmentInfoTask.
+        with self.input()['enrich_team_members_with_environment_info']['clean'].open("r") as f:
+            team_member_list = json.load(f)
+
+        logger.info("ReviewTeamTask. All files are now ready. Processing...")
+
+        # Convert the team members to a Markdown document.
+        builder = TeamMarkdownDocumentBuilder()
+        builder.append_roles(team_member_list, title=None)
+        team_document_markdown = builder.to_string()
+
+        # Build the query.
+        query = (
+            f"Initial plan: {plan_prompt}\n\n"
+            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
+            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
+            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"Document with team members:\n{team_document_markdown}"
+        )
+
+        # Create LLM instance.
+        llm = get_llm(self.llm_model)
+
+        # Execute.
+        try:
+            review_team = ReviewTeam.execute(llm, query)
+        except Exception as e:
+            logger.error("ReviewTeam failed: %s", e)
+            raise
+
+        # Save the raw output.
+        raw_dict = review_team.to_dict()
+        with self.output().open("w") as f:
+            json.dump(raw_dict, f, indent=2)
+
+        logger.info("ReviewTeamTask complete.")
+
+class TeamMarkdownTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'enrich_team_members_with_environment_info': EnrichTeamMembersWithEnvironmentInfoTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'review_team': ReviewTeamTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.TEAM_MARKDOWN)))
+
+    def run(self):
+        logger.info("TeamMarkdownTask. Loading files...")
+
+        # 1. Read the team_member_list from EnrichTeamMembersWithEnvironmentInfoTask.
+        with self.input()['enrich_team_members_with_environment_info']['clean'].open("r") as f:
+            team_member_list = json.load(f)
+
+        # 2. Read the json from ReviewTeamTask.
+        with self.input()['review_team'].open("r") as f:
+            review_team_json = json.load(f)
+
+        logger.info("TeamMarkdownTask. All files are now ready. Processing...")
+
+        # Combine the team members and the review into a Markdown document.
+        builder = TeamMarkdownDocumentBuilder()
+        builder.append_roles(team_member_list)
+        builder.append_separator()
+        builder.append_full_review(review_team_json)
+        builder.write_to_file(self.output().path)
+
+        logger.info("TeamMarkdownTask complete.")
+
 class SWOTAnalysisTask(PlanTask):
     llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
 
@@ -888,6 +1289,7 @@ class ReportTask(PlanTask):
     
     def requires(self):
         return {
+            'team_markdown': TeamMarkdownTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'swot_analysis': SWOTAnalysisTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'pitch_markdown': ConvertPitchToMarkdownTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'wbs_project123': WBSProjectLevel1AndLevel2AndLevel3Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
@@ -898,6 +1300,7 @@ class ReportTask(PlanTask):
         rg = ReportGenerator()
         rg.append_pitch_markdown(self.input()['pitch_markdown']['markdown'].path)
         rg.append_swot_analysis_markdown(self.input()['swot_analysis']['markdown'].path)
+        rg.append_team_markdown(self.input()['team_markdown'].path)
         rg.append_project_plan_csv(self.input()['wbs_project123']['csv'].path)
         rg.append_expert_criticism_markdown(self.input()['expert_review'].path)
         rg.save_report(self.output().path)
@@ -911,6 +1314,12 @@ class FullPlanPipeline(PlanTask):
             'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'pre_project_assessment': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'find_team_members': FindTeamMembersTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'enrich_team_members_with_contract_type': EnrichTeamMembersWithContractTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'enrich_team_members_with_background_story': EnrichTeamMembersWithBackgroundStoryTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'enrich_team_members_with_environment_info': EnrichTeamMembersWithEnvironmentInfoTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'review_team': ReviewTeamTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'team_markdown': TeamMarkdownTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'swot_analysis': SWOTAnalysisTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'expert_review': ExpertReviewTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'wbs_level1': CreateWBSLevel1Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),

src/report/report_generator.py

@@ -92,6 +92,12 @@ class ReportGenerator:
         if swot_md:
             self.report_data['swot'] = swot_md
     
+    def append_team_markdown(self, file_path: Path):
+        """Append the team markdown to the report."""
+        swot_md = self.read_markdown_file(file_path)
+        if swot_md:
+            self.report_data['team'] = swot_md
+    
     def append_expert_criticism_markdown(self, file_path: Path):
         """Append the expert criticism markdown to the report."""
         expert_md = self.read_markdown_file(file_path)
@@ -210,6 +216,15 @@ class ReportGenerator:
             html_parts.append(markdown.markdown(self.report_data['swot']))
             html_parts.append("</div>")
 
+        # Team
+        if 'team' in self.report_data:
+            html_parts.append("""
+            <div class="section">
+                <h2>Team</h2>
+            """)
+            html_parts.append(markdown.markdown(self.report_data['team']))
+            html_parts.append("</div>")
+
         # Expert Criticism
         if 'expert_criticism' in self.report_data:
             html_parts.append("""
@@ -276,6 +291,7 @@ def main():
     report_generator = ReportGenerator()
     report_generator.append_pitch_markdown(input_path / FilenameEnum.PITCH_MARKDOWN.value)
     report_generator.append_swot_analysis_markdown(input_path / FilenameEnum.SWOT_MARKDOWN.value)
+    report_generator.append_team_markdown(input_path / FilenameEnum.TEAM_MARKDOWN.value)
     report_generator.append_expert_criticism_markdown(input_path / FilenameEnum.EXPERT_CRITICISM_MARKDOWN.value)
     report_generator.append_project_plan_csv(input_path / FilenameEnum.WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_CSV.value)
     report_generator.save_report(output_path)

src/team/create_markdown_document.py

@@ -1,71 +0,0 @@
-import json
-
-def create_markdown_document(plan_prompt: str, team_member_list_json_file_path: str, output_file_path: str):
-    """
-    Reads text content and JSON data, then writes a Markdown document.
-    
-    :param text_content: str, the main topic text to include in the Markdown
-    :param json_file_path: str, path to the JSON file
-    :param output_file_path: str, path to output the generated Markdown file
-    """
-    # Load JSON data
-    with open(team_member_list_json_file_path, 'r', encoding='utf-8') as f:
-        roles_data = json.load(f)
-    
-    # Begin constructing the Markdown content
-    rows = []
-    
-    # 1. Add the main text content as a top-level section
-    rows.append("# The plan")
-    rows.append("")
-    rows.append(plan_prompt.strip())
-    rows.append("")
-    rows.append("---")
-    rows.append("")
-    
-    # 2. Loop through each entry in the JSON and format as Markdown
-    for entry in roles_data:
-        # Each entry will be displayed under a subsection
-        rows.append(f"## Role {entry['id']} - {entry['category']}")
-        if 'explanation' in entry:
-            rows.append("")
-            rows.append(f"**Explanation**:\n{entry['explanation']}")
-        if 'count' in entry:
-            rows.append("")
-            rows.append(f"**People Count**:\n{entry['count']}")
-        if 'typical_job_activities' in entry:
-            rows.append("")
-            rows.append(f"**Typical Activities**:\n{entry['typical_job_activities']}")
-        if 'background_story' in entry:
-            rows.append("")
-            rows.append(f"**Background Story**:\n{entry['background_story']}")
-        if 'equipment_needs' in entry:
-            rows.append("")
-            rows.append(f"**Equipment Needs**:\n{entry['equipment_needs']}")
-        if 'facility_needs' in entry:
-            rows.append("")
-            rows.append(f"**Facility Needs**:\n{entry['facility_needs']}")
-        rows.append("")
-        rows.append("---")
-        rows.append("")
-    
-    # Write everything to the output markdown file
-    with open(output_file_path, 'w', encoding='utf-8') as out_f:
-        out_f.write("\n".join(rows))
-    
-    print(f"Markdown document has been created at: {output_file_path}")
-
-
-if __name__ == "__main__":
-    # Your text snippet
-    plan_prompt = "Deep cave exploration to find new lifeforms in extreme conditions."
-    
-    # Path to your JSON file
-    # TODO: Eliminate hardcoded paths
-    json_path = "/Users/neoneye/Desktop/planexe_data/005-enriched_team_members_list.json"
-    
-    # Output Markdown file path
-    output_path = "output.md"
-    
-    # Create the markdown document
-    create_markdown_document(plan_prompt, json_path, output_path)

src/team/{enrich_team_members.py → enrich_team_members_with_background_story.py}

@@ -1,14 +1,20 @@
 """
 Enrich each team member with a fictional background story and typical job activities.
+
+PROMPT> python -m src.team.enrich_team_members_with_background_story
 """
-import os
 import json
 import time
+import logging
 from math import ceil
+from dataclasses import dataclass
 from typing import List, Optional
 from pydantic import BaseModel, Field
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+logger = logging.getLogger(__name__)
 
 class TeamMember(BaseModel):
     """A human with domain knowledge."""
@@ -28,6 +34,8 @@ class TeamDetails(BaseModel):
     )
 
 ENRICH_TEAM_MEMBERS_SYSTEM_PROMPT = """
+For each team member provided, enrich them with a fictional background story and typical job activities.
+
 Write a fictional background story about the person. It must be one paragraph that covers: 
 - First name and last name.
 - Location.
@@ -38,58 +46,113 @@ Write a fictional background story about the person. It must be one paragraph th
 The typical_job_activities describes relevant skills needed for this project.
 """
 
-def enrich_team_members(llm: LLM, job_description: str, team_member_list: list, system_prompt: Optional[str]) -> dict:
-    compact_json = json.dumps(team_member_list, separators=(',', ':'))
+@dataclass
+class EnrichTeamMembersWithBackgroundStory:
+    """
+    Enrich each team member with a fictional background story and typical job activities.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    team_member_list: list[dict]
+
+    @classmethod
+    def format_query(cls, job_description: str, team_member_list: list[dict]) -> str:
+        if not isinstance(job_description, str):
+            raise ValueError("Invalid job_description.")
+        if not isinstance(team_member_list, list):
+            raise ValueError("Invalid team_member_list.")
+
+        query = (
+            f"Project description:\n{job_description}\n\n"
+            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+        )
+        return query
 
-    user_prompt = f"""Project description:
-{job_description}
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str, team_member_list: list[dict]) -> 'EnrichTeamMembersWithBackgroundStory':
+        """
+        Invoke LLM with each team member.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+        if not isinstance(team_member_list, list):
+            raise ValueError("Invalid team_member_list.")
 
-Here is the list of team members that needs to be enriched:
-{compact_json}
-"""
-    # print(user_prompt)
+        logger.debug(f"User Prompt:\n{user_prompt}")
 
-    chat_message_list = []
-    if system_prompt:
-        chat_message_list.append(
+        system_prompt = ENRICH_TEAM_MEMBERS_SYSTEM_PROMPT.strip()
+
+        chat_message_list = [
             ChatMessage(
                 role=MessageRole.SYSTEM,
                 content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
             )
+        ]
+
+        sllm = llm.as_structured_llm(TeamDetails)
+        start_time = time.perf_counter()
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.debug(f"LLM chat interaction failed: {e}")
+            logger.error("LLM chat interaction failed.", exc_info=True)
+            raise ValueError("LLM chat interaction failed.") from e
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        json_response = chat_response.raw.model_dump()
+
+        team_member_list_enriched = cls.cleanup_enriched_team_members_and_merge_with_team_members(chat_response.raw, team_member_list)
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        result = EnrichTeamMembersWithBackgroundStory(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+            team_member_list=team_member_list_enriched,
         )
+        return result
     
-    chat_message_user = ChatMessage(
-        role=MessageRole.USER,
-        content=user_prompt,
-    )
-    chat_message_list.append(chat_message_user)
-
-    sllm = llm.as_structured_llm(TeamDetails)
-
-    start_time = time.perf_counter()
-    chat_response = sllm.chat(chat_message_list)
-    end_time = time.perf_counter()
-    duration = int(ceil(end_time - start_time))
-
-    json_response = json.loads(chat_response.message.content)
-
-    metadata = {
-        "duration_warmup": duration,
-    }
-    json_response['metadata'] = metadata
-    return json_response
-
-def cleanup_enriched_team_members_and_merge_with_team_members(raw_enriched_team_member_dict: dict, team_member_list: list) -> list:
-    result_team_member_list = team_member_list.copy()
-    enriched_team_member_list = raw_enriched_team_member_dict['team_members']
-    id_to_enriched_team_member = {item['id']: item for item in enriched_team_member_list}
-    for team_member in result_team_member_list:
-        id = team_member['id']
-        enriched_team_member = id_to_enriched_team_member.get(id)
-        if enriched_team_member:
-            team_member['typical_job_activities'] = enriched_team_member['typical_job_activities']
-            team_member['background_story'] = enriched_team_member['job_background_story_of_employee']
-    return result_team_member_list
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+    def cleanup_enriched_team_members_and_merge_with_team_members(team_details: TeamDetails, team_member_list: list[dict]) -> list[dict]:
+        result_team_member_list = team_member_list.copy()
+        enriched_team_member_list = team_details.team_members
+        id_to_enriched_team_member = {item.id: item for item in enriched_team_member_list}
+        for team_member_index, team_member in enumerate(result_team_member_list):
+            if not 'id' in team_member:
+                logger.warning(f"Team member #{team_member_index} does not have an id")
+                continue
+            id = team_member['id']
+            enriched_team_member = id_to_enriched_team_member.get(id)
+            if enriched_team_member:
+                team_member['typical_job_activities'] = enriched_team_member.typical_job_activities
+                team_member['background_story'] = enriched_team_member.job_background_story_of_employee
+        return result_team_member_list
 
 if __name__ == "__main__":
     from src.llm_factory import get_llm
@@ -122,5 +185,13 @@ if __name__ == "__main__":
         }
     ]
 
-    json_response = enrich_team_members(llm, job_description, team_member_list, ENRICH_TEAM_MEMBERS_SYSTEM_PROMPT)
+    query = EnrichTeamMembersWithBackgroundStory.format_query(job_description, team_member_list)
+    print(f"Query:\n{query}\n\n")
+
+    enrich_team_members_with_background_story = EnrichTeamMembersWithBackgroundStory.execute(llm, query, team_member_list)
+    json_response = enrich_team_members_with_background_story.to_dict(include_system_prompt=False, include_user_prompt=False)
     print(json.dumps(json_response, indent=2))
+
+    print("\n\nTeam members with extra details:")
+    enriched_json = enrich_team_members_with_background_story.team_member_list
+    print(json.dumps(enriched_json, indent=2))

src/team/enrich_team_members_with_contract_type.py

@@ -0,0 +1,214 @@
+"""
+Enrich the team members with what kind of contract type they have.
+
+PROMPT> python -m src.team.enrich_team_members_with_contract_type
+"""
+import os
+import json
+import time
+import logging
+from enum import Enum
+from math import ceil
+from dataclasses import dataclass
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+logger = logging.getLogger(__name__)
+
+class ContractType(str, Enum):
+    # Full-Time Employee. The individual is a permanent member of the organization.
+    full_time_employee = 'full_time_employee'
+    # Part-Time Employee. Similar to a full-time employee, but they work fewer hours per week.
+    part_time_employee = 'part_time_employee'
+    # Independent Contractor / Consultant. A self-employed individual or business that provides services to your company on a contractual basis.
+    independent_contractor = 'independent_contractor'
+    # Temporary Employee through an Agency. The individual is employed by a staffing agency, who then assigns them to work at your company for a set period.
+    agency_temp = 'agency_temp'
+    # Other. When the contract type does not fit into the above categories.
+    other = 'other'
+
+class TeamMember(BaseModel):
+    """A human with domain knowledge."""
+    id: int = Field(
+        description="A unique id for the job_category."
+    )
+    contract_type: ContractType = Field(
+        description="The legal and financial agreement."
+    )
+    justification: str = Field(
+        description="Brief explanation for why that contract type was chosen. Helps justify decisions and allows for easy review."
+    )
+
+class DocumentDetails(BaseModel):
+    team_members: list[TeamMember] = Field(
+        description="The experts with domain knowledge about the problem."
+    )
+
+ENRICH_TEAM_MEMBERS_CONTRACT_TYPE_SYSTEM_PROMPT = """
+You are an expert at determining what contract type are needed for different job roles given a project description.
+
+"Contract Type" refers to the legal and financial agreement you have with each individual working on the project. 
+It dictates their employment status, compensation, benefits, and overall relationship with your organization (or the project). 
+
+The "contract_type" for each team member is crucial for the following reasons:
+- Drives Cost Calculations: The type of employment agreement dictates a huge portion of project labor costs. Whether you're paying salary + benefits, or a fixed project fee, this is foundational information.
+- Impacts Availability and Control: The contract type determines how much control you have over the person and how readily available they will be.
+- Informs Resource Planning: It influences long-term versus short-term resource commitments.
+
+Allowed values: "full_time_employee", "part_time_employee", "independent_contractor", "agency_temp"
+
+For each team member provided, identify the contract_type considering the given project description. Provide concise but descriptive answers.
+"""
+
+@dataclass
+class EnrichTeamMembersWithContractType:
+    """
+    Enrich each team member with more info.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    team_member_list: list[dict]
+
+    @classmethod
+    def format_query(cls, job_description: str, team_member_list: list[dict]) -> str:
+        if not isinstance(job_description, str):
+            raise ValueError("Invalid job_description.")
+        if not isinstance(team_member_list, list):
+            raise ValueError("Invalid team_member_list.")
+
+        query = (
+            f"Project description:\n{job_description}\n\n"
+            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+        )
+        return query
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str, team_member_list: list[dict]) -> 'EnrichTeamMembersWithContractType':
+        """
+        Invoke LLM with each team member.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+        if not isinstance(team_member_list, list):
+            raise ValueError("Invalid team_member_list.")
+
+        logger.debug(f"User Prompt:\n{user_prompt}")
+
+        system_prompt = ENRICH_TEAM_MEMBERS_CONTRACT_TYPE_SYSTEM_PROMPT.strip()
+
+        chat_message_list = [
+            ChatMessage(
+                role=MessageRole.SYSTEM,
+                content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
+            )
+        ]
+
+        sllm = llm.as_structured_llm(DocumentDetails)
+        start_time = time.perf_counter()
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.debug(f"LLM chat interaction failed: {e}")
+            logger.error("LLM chat interaction failed.", exc_info=True)
+            raise ValueError("LLM chat interaction failed.") from e
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        json_response = chat_response.raw.model_dump()
+
+        team_member_list_enriched = cls.cleanup_and_merge_with_team_members(chat_response.raw, team_member_list)
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        result = EnrichTeamMembersWithContractType(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+            team_member_list=team_member_list_enriched,
+        )
+        return result
+    
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+    def cleanup_and_merge_with_team_members(document_details: DocumentDetails, team_member_list: list[dict]) -> list:
+        result_team_member_list = team_member_list.copy()
+        enriched_team_member_list = document_details.team_members
+        id_to_enriched_team_member = {item.id: item for item in enriched_team_member_list}
+        for team_member_index, team_member in enumerate(result_team_member_list):
+            if not 'id' in team_member:
+                logger.warning(f"Team member #{team_member_index} does not have an id")
+                continue
+            id = team_member['id']
+            enriched_team_member = id_to_enriched_team_member.get(id)
+            if enriched_team_member:
+                team_member['contract_type'] = enriched_team_member.contract_type.value
+                team_member['contract_type_justification'] = enriched_team_member.justification
+        return result_team_member_list
+
+if __name__ == "__main__":
+    from src.llm_factory import get_llm
+
+    llm = get_llm("ollama-llama3.1")
+    # llm = get_llm("deepseek-chat")
+
+    job_description = "Establish a new police station in a high crime area."
+
+    team_member_list = [
+        {
+            "id": 1,
+            "category": "Law Enforcement",
+            "explanation": "Police officers and detectives are essential for patrolling, investigation, and maintaining public safety."
+        },
+        {
+            "id": 2,
+            "category": "Administration",
+            "explanation": "Administrative staff manage paperwork, scheduling, and coordination of police activities."
+        },
+        {
+            "id": 3,
+            "category": "Forensics",
+            "explanation": "Forensic experts analyze crime scene evidence to support investigations."
+        },
+        {
+            "id": 4,
+            "category": "Community Relations",
+            "explanation": "Officers or liaisons engage with the community to build trust and cooperation."
+        }
+    ]
+
+    query = EnrichTeamMembersWithContractType.format_query(job_description, team_member_list)
+    print(f"Query:\n{query}\n\n")
+
+    enrich_team_members_with_environment_info = EnrichTeamMembersWithContractType.execute(llm, query, team_member_list)
+    json_response = enrich_team_members_with_environment_info.to_dict(include_system_prompt=False, include_user_prompt=False)
+    print(json.dumps(json_response, indent=2))
+
+    print("\n\nTeam members:")
+    json_team = enrich_team_members_with_environment_info.team_member_list
+    print(json.dumps(json_team, indent=2))

src/team/enrich_team_members_with_environment_info.py

@@ -1,14 +1,21 @@
 """
 Enrich the team members with what kind of equipment and facilities they need for the task.
+
+PROMPT> python -m src.team.enrich_team_members_with_environment_info
 """
 import os
 import json
 import time
+import logging
 from math import ceil
+from dataclasses import dataclass
 from typing import List, Optional
 from pydantic import BaseModel, Field
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+logger = logging.getLogger(__name__)
 
 class TeamMember(BaseModel):
     """A human with domain knowledge."""
@@ -28,60 +35,118 @@ class DocumentDetails(BaseModel):
     )
 
 ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_SYSTEM_PROMPT = """
-Identify what kind of equipment and facilities are needed for the daily job of each team member.
+You are an expert at determining what equipment and facilities are needed for different job roles given a project description.
+
+For each team member provided, identify the specific equipment and facilities they require to effectively perform their daily tasks within the context of the given project description. Provide concise but descriptive answers.
 """
 
-def enrich_team_members_with_environment_info(llm: LLM, job_description: str, team_member_list: list, system_prompt: Optional[str]) -> dict:
-    compact_json = json.dumps(team_member_list, separators=(',', ':'))
+@dataclass
+class EnrichTeamMembersWithEnvironmentInfo:
+    """
+    Enrich each team member with more info.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    team_member_list: list[dict]
+
+    @classmethod
+    def format_query(cls, job_description: str, team_member_list: list[dict]) -> str:
+        if not isinstance(job_description, str):
+            raise ValueError("Invalid job_description.")
+        if not isinstance(team_member_list, list):
+            raise ValueError("Invalid team_member_list.")
+
+        query = (
+            f"Project description:\n{job_description}\n\n"
+            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+        )
+        return query
 
-    user_prompt = f"""Project description:
-{job_description}
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str, team_member_list: list[dict]) -> 'EnrichTeamMembersWithEnvironmentInfo':
+        """
+        Invoke LLM with each team member.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+        if not isinstance(team_member_list, list):
+            raise ValueError("Invalid team_member_list.")
 
-Here is the list of team members that needs to be enriched:
-{compact_json}
-"""
-    chat_message_list = []
-    if system_prompt:
-        chat_message_list.append(
+        logger.debug(f"User Prompt:\n{user_prompt}")
+
+        system_prompt = ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_SYSTEM_PROMPT.strip()
+
+        chat_message_list = [
             ChatMessage(
                 role=MessageRole.SYSTEM,
                 content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
             )
+        ]
+
+        sllm = llm.as_structured_llm(DocumentDetails)
+        start_time = time.perf_counter()
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.debug(f"LLM chat interaction failed: {e}")
+            logger.error("LLM chat interaction failed.", exc_info=True)
+            raise ValueError("LLM chat interaction failed.") from e
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        json_response = chat_response.raw.model_dump()
+
+        team_member_list_enriched = cls.cleanup_enriched_team_members_with_environment_info_and_merge_with_team_members(chat_response.raw, team_member_list)
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        result = EnrichTeamMembersWithEnvironmentInfo(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+            team_member_list=team_member_list_enriched,
         )
+        return result
     
-    chat_message_user = ChatMessage(
-        role=MessageRole.USER,
-        content=user_prompt,
-    )
-    chat_message_list.append(chat_message_user)
-
-    sllm = llm.as_structured_llm(DocumentDetails)
-
-    start_time = time.perf_counter()
-    chat_response = sllm.chat(chat_message_list)
-    end_time = time.perf_counter()
-
-    json_response = json.loads(chat_response.message.content)
-
-    duration = int(ceil(end_time - start_time))
-
-    metadata = {
-        "duration": duration,
-    }
-    json_response['metadata'] = metadata
-    return json_response
-
-def cleanup_enriched_team_members_with_environment_info_and_merge_with_team_members(raw_enriched_team_member_dict: dict, team_member_list: list) -> list:
-    result_team_member_list = team_member_list.copy()
-    enriched_team_member_list = raw_enriched_team_member_dict['team_members']
-    id_to_enriched_team_member = {item['id']: item for item in enriched_team_member_list}
-    for team_member in result_team_member_list:
-        id = team_member['id']
-        enriched_team_member = id_to_enriched_team_member.get(id)
-        if enriched_team_member:
-            team_member['equipment_needs'] = enriched_team_member['equipment_needs']
-            team_member['facility_needs'] = enriched_team_member['facility_needs']
-    return result_team_member_list
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+    def cleanup_enriched_team_members_with_environment_info_and_merge_with_team_members(document_details: DocumentDetails, team_member_list: list[dict]) -> list:
+        result_team_member_list = team_member_list.copy()
+        enriched_team_member_list = document_details.team_members
+        id_to_enriched_team_member = {item.id: item for item in enriched_team_member_list}
+        for team_member_index, team_member in enumerate(result_team_member_list):
+            if not 'id' in team_member:
+                logger.warning(f"Team member #{team_member_index} does not have an id")
+                continue
+            id = team_member['id']
+            enriched_team_member = id_to_enriched_team_member.get(id)
+            if enriched_team_member:
+                team_member['equipment_needs'] = enriched_team_member.equipment_needs
+                team_member['facility_needs'] = enriched_team_member.facility_needs
+        return result_team_member_list
 
 if __name__ == "__main__":
     from src.llm_factory import get_llm
@@ -114,5 +179,13 @@ if __name__ == "__main__":
         }
     ]
 
-    json_response = enrich_team_members_with_environment_info(llm, job_description, team_member_list, ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_SYSTEM_PROMPT)
+    query = EnrichTeamMembersWithEnvironmentInfo.format_query(job_description, team_member_list)
+    print(f"Query:\n{query}\n\n")
+
+    enrich_team_members_with_environment_info = EnrichTeamMembersWithEnvironmentInfo.execute(llm, query, team_member_list)
+    json_response = enrich_team_members_with_environment_info.to_dict(include_system_prompt=False, include_user_prompt=False)
     print(json.dumps(json_response, indent=2))
+
+    print("\n\nTeam members:")
+    json_team = enrich_team_members_with_environment_info.team_member_list
+    print(json.dumps(json_team, indent=2))

src/team/find_team_members.py

@@ -6,12 +6,16 @@ PROMPT> python -m src.team.find_team_members
 import os
 import json
 import time
+import logging
 from math import ceil
+from dataclasses import dataclass
 from typing import List, Optional
 from pydantic import BaseModel, Field
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.llms.llm import LLM
 
+logger = logging.getLogger(__name__)
+
 class TeamMember(BaseModel):
     job_category_title: str = Field(
         description="Human readable title"
@@ -22,6 +26,9 @@ class TeamMember(BaseModel):
     people_needed: str = Field(
         description="Number of people needed."
     )
+    consequences_of_not_having_this_role: str = Field(
+        description="Consequences of not having this role."
+    )
 
 class DocumentDetails(BaseModel):
     brainstorm_of_needed_team_members: list[TeamMember] = Field(
@@ -29,68 +36,147 @@ class DocumentDetails(BaseModel):
     )
 
 FIND_TEAM_MEMBERS_SYSTEM_PROMPT = """
-Pick a good team of humans for solving the task.
+You are a versatile project planning assistant and team architect. Your goal is to analyze the user's project description and decompose it into a comprehensive plan with a focus on human roles and resource allocation—**do not generate any code or technical implementation details.**
+
+If the project description involves programming tasks or includes requests for code, treat it as a planning challenge. Instead of writing a script or providing code, break down the project into essential phases and identify the key human roles needed to successfully complete the project.
+
+Based on the user's project description, brainstorm a team of potential human support roles that cover all crucial aspects of the project, including planning & preparation, execution, monitoring & adjustment, and maintenance & sustainability.
+
+**Output Requirements:**
+
+1. **Team Size:**  
+   Your output **must include exactly 8 candidate roles**.  
+   - If your initial analysis identifies fewer than 8 distinct roles, create additional meaningful roles to reach exactly 8.  
+   - If your analysis results in more than 8 roles, consolidate or combine roles so that the final output contains exactly 8 candidates.
+
+2. **Role Titles:**  
+   Provide a clear and concise `job_category_title` that accurately describes the role's primary contribution.
+
+3. **Role Explanations:**  
+   Briefly explain each role’s purpose, key responsibilities, and how it contributes actively throughout the project.
 
-Ensure that the team consists of at least 5 members.
+4. **Consequences:**  
+   For each role, note potential risks or consequences of omitting that role.
 
-The "job_category_title" field must be a brief the title that captures what the role is about.
-Such as area of expertise, group, subject, topic or domain.
+5. **People Count / Resource Level:** 
+   Use the `people_needed` field to indicate the number of people required for each role. **Do not simply default to "1" for every role.** Instead, evaluate the complexity and workload of the role relative to the project's scale:
+   - **Single Resource:** If one person is clearly sufficient, use "1".
+   - **Fixed Level:** If the role consistently requires a specific number of people (e.g., "2" or "3"), use that fixed number.
+   - **Variable Level:** If the required support may vary based on factors like project scale, workload, or budget, specify a range. For example, instead of "1", you might write "min 1, max 3, depending on project scale and workload." Be sure to justify why the role may require more than one person.
 
-Estimate how many people are needed for each role.
-What is the minimum of people needed for the role.
-What is the maximum of people needed for the role.
-Use the people_needed field to specify the number of people needed for each role: 
-- if only one person is needed, use "1".
-- if two people are needed, use "2".
-- When it can vary, use "min 5,max 10,depending on capacity".
+6. **Project Phases / Support Stages:**  
+   Ensure the roles collectively address the following phases:
+    - **Planning & Preparation**
+    - **Execution**
+    - **Monitoring & Adjustment**
+    - **Maintenance & Sustainability**
 
-Provide a short explanation of why that team member is relevant for the project.
+**Essential Considerations for EVERY Role:**
+
+- **Specific Expertise**
+- **Key Responsibilities**
+- **Direct Impact (if applicable)**
+- **Project Dependencies**
+- **Relevant Skills**
+- **Role Priority**
+
+**Important:** 
+- Do not provide any code or implementation details—even if the prompt is programming-related. Focus solely on planning, decomposing the work, and identifying the essential human roles.
+- **For personal, trivial, or non-commercial projects, avoid suggesting overly formal or business-oriented roles (e.g., Marketing Specialist, Legal Advisor, Technical Support Specialist) unless they are absolutely necessary.** In such cases, prefer roles that can be integrated or scaled down to suit the project's nature.
 """
 
-def find_team_members(llm: LLM, query: str, system_prompt: Optional[str]) -> dict:
-    chat_message_list = []
-    if system_prompt:
-        chat_message_list.append(
+@dataclass
+class FindTeamMembers:
+    """
+    From a project description, find a team for solving the job.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    team_member_list: list[dict]
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'FindTeamMembers':
+        """
+        Invoke LLM to find a team.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+
+        logger.debug(f"User Prompt:\n{user_prompt}")
+
+        system_prompt = FIND_TEAM_MEMBERS_SYSTEM_PROMPT.strip()
+
+        chat_message_list = [
             ChatMessage(
                 role=MessageRole.SYSTEM,
                 content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
             )
+        ]
+
+        sllm = llm.as_structured_llm(DocumentDetails)
+        start_time = time.perf_counter()
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.debug(f"LLM chat interaction failed: {e}")
+            logger.error("LLM chat interaction failed.", exc_info=True)
+            raise ValueError("LLM chat interaction failed.") from e
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        json_response = chat_response.raw.model_dump()
+
+        team_member_list = cls.cleanup_team_members_and_assign_id(chat_response.raw)
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        result = FindTeamMembers(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+            team_member_list=team_member_list,
         )
+        return result
+    
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+    def cleanup_team_members_and_assign_id(document_details: DocumentDetails) -> list:
+        result_list = []
+        team_members = document_details.brainstorm_of_needed_team_members
+        for i, team_member in enumerate(team_members, start=1):
+            item = {
+                "id": i,
+                "category": team_member.job_category_title,
+                "explanation": team_member.short_explanation,
+                "consequences": team_member.consequences_of_not_having_this_role,
+                "count": team_member.people_needed,
+            }
+            result_list.append(item)
+        return result_list
     
-    chat_message_user = ChatMessage(
-        role=MessageRole.USER,
-        content=query,
-    )
-    chat_message_list.append(chat_message_user)
-
-    sllm = llm.as_structured_llm(DocumentDetails)
-
-    start_time = time.perf_counter()
-    chat_response = sllm.chat(chat_message_list)
-    end_time = time.perf_counter()
-    duration = int(ceil(end_time - start_time))
-
-    json_response = json.loads(chat_response.message.content)
-
-    metadata = {
-        "duration": duration,
-    }
-    json_response['metadata'] = metadata
-    return json_response
-
-def cleanup_team_members_and_assign_id(team_member_dict: dict) -> list:
-    result_list = []
-    team_members = team_member_dict['brainstorm_of_needed_team_members']
-    for i, team_member in enumerate(team_members, start=1):
-        item = {
-            "id": i,
-            "category": team_member['job_category_title'],
-            "explanation": team_member['short_explanation'],
-            "count": team_member['people_needed'],
-        }
-        result_list.append(item)
-    return result_list
-
 if __name__ == "__main__":
     from src.llm_factory import get_llm
     from src.plan.find_plan_prompt import find_plan_prompt
@@ -99,5 +185,10 @@ if __name__ == "__main__":
     plan_prompt = find_plan_prompt("4dc34d55-0d0d-4e9d-92f4-23765f49dd29")
 
     print(f"Query:\n{plan_prompt}\n\n")
-    json_response = find_team_members(llm, plan_prompt, FIND_TEAM_MEMBERS_SYSTEM_PROMPT)
+    result = FindTeamMembers.execute(llm, plan_prompt)
+    json_response = result.to_dict(include_system_prompt=False, include_user_prompt=False)
     print(json.dumps(json_response, indent=2))
+
+    print("\n\nTeam members:")
+    json_team = result.team_member_list
+    print(json.dumps(json_team, indent=2))

src/team/review_team.py

@@ -0,0 +1,170 @@
+"""
+Review the team.
+
+PROMPT> python -m src.team.review_team
+"""
+import os
+import json
+import time
+import logging
+from math import ceil
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+logger = logging.getLogger(__name__)
+
+class ReviewItem(BaseModel):
+    issue: str = Field(
+        description="A brief title or name for the omission/improvement."
+    )
+    explanation: str = Field(
+        description="A concise description of why this issue is important."
+    )
+    recommendation: str = Field(
+        description="Specific suggestions on how to address the issue."
+    )
+
+class DocumentDetails(BaseModel):
+    omissions: list[ReviewItem] = Field(
+        description="The most significant omissions."
+    )
+    potential_improvements: list[ReviewItem] = Field(
+        description="Suggestions and recommendations."
+    )
+
+REVIEW_TEAM_SYSTEM_PROMPT = """
+You are an expert in designing and evaluating team structures for projects of all scales—from personal or trivial endeavors to large, complex initiatives. Your task is to review a team document that includes a project plan, detailed team roles, and sections on omissions and potential improvements.
+
+In your analysis, please:
+
+1. **Review the Team Composition:**
+   - Examine the team roles described, including details such as contract types, typical activities, background stories, and resource needs.
+   - Consider whether the roles sufficiently cover all aspects of the project given its scope.
+
+2. **Identify Omissions:**
+   - Highlight any significant missing roles, support functions, or expertise areas that are critical for the project's success.
+   - **Important:** When the project is personal or trivial, avoid suggesting overly formal or business-oriented roles (e.g., Marketing Specialist, Legal Advisor, Technical Support Specialist). Instead, suggest simpler or integrative adjustments suitable for a personal context.
+
+3. **Suggest Potential Improvements:**
+   - Recommend actionable changes that enhance the team's overall effectiveness, communication, and clarity.
+   - Focus on clarifying responsibilities and reducing overlap.
+   - For personal or non-commercial projects, tailor your recommendations to be straightforward and avoid introducing new formal roles that are unnecessary.
+
+4. **Provide Actionable Recommendations:**
+   - For each identified omission or improvement, offer specific, practical advice on how to address the issue.
+   - Ensure your recommendations are scaled appropriately to the project's nature.
+
+Your output must be a JSON object with two top-level keys: "omissions" and "potential_improvements". Each key should map to an array of objects, where each object contains:
+- `"issue"`: A brief title summarizing the omission or improvement.
+- `"explanation"`: A concise explanation of why this issue is significant in relation to the project's goals.
+- `"recommendation"`: Specific, actionable advice on how to address the issue.
+
+Ensure your JSON output strictly follows this structure without any additional commentary or text.
+"""
+
+@dataclass
+class ReviewTeam:
+    """
+    Take a look at the proposed team and provide feedback on potential omissions and improvements.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def format_query(cls, job_description: str, team_document_markdown: str) -> str:
+        if not isinstance(job_description, str):
+            raise ValueError("Invalid job_description.")
+        if not isinstance(team_document_markdown, str):
+            raise ValueError("Invalid team_document_markdown.")
+
+        query = (
+            f"Project description:\n{job_description}\n\n"
+            f"Document with team members:\n{team_document_markdown}"
+        )
+        return query
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'ReviewTeam':
+        """
+        Invoke LLM with the project description and team document to be reviewed.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+
+        logger.debug(f"User Prompt:\n{user_prompt}")
+
+        system_prompt = REVIEW_TEAM_SYSTEM_PROMPT.strip()
+
+        chat_message_list = [
+            ChatMessage(
+                role=MessageRole.SYSTEM,
+                content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
+            )
+        ]
+
+        sllm = llm.as_structured_llm(DocumentDetails)
+        start_time = time.perf_counter()
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.debug(f"LLM chat interaction failed: {e}")
+            logger.error("LLM chat interaction failed.", exc_info=True)
+            raise ValueError("LLM chat interaction failed.") from e
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        json_response = chat_response.raw.model_dump()
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        result = ReviewTeam(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+        )
+        return result
+    
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+if __name__ == "__main__":
+    from src.llm_factory import get_llm
+
+    llm = get_llm("ollama-llama3.1")
+
+    path = os.path.join(os.path.dirname(__file__), 'test_data', "solarfarm_team_without_review.md")
+    with open(path, 'r', encoding='utf-8') as f:
+        team_document_markdown = f.read()
+    job_description = "Establish a solar farm in Denmark."
+
+    query = ReviewTeam.format_query(job_description, team_document_markdown)
+    print(f"Query:\n{query}\n\n")
+
+    review_team = ReviewTeam.execute(llm, query)
+    json_response = review_team.to_dict(include_system_prompt=False, include_user_prompt=False)
+    print(json.dumps(json_response, indent=2))

src/team/run_hire_team.py

@@ -4,16 +4,18 @@ PROMPT> python -m src.team.run_hire_team
 from datetime import datetime
 import os
 import json
-from src.team.find_team_members import FIND_TEAM_MEMBERS_SYSTEM_PROMPT, find_team_members, cleanup_team_members_and_assign_id
-from src.team.enrich_team_members import ENRICH_TEAM_MEMBERS_SYSTEM_PROMPT, enrich_team_members, cleanup_enriched_team_members_and_merge_with_team_members
-from src.team.enrich_team_members_with_environment_info import ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_SYSTEM_PROMPT, enrich_team_members_with_environment_info, cleanup_enriched_team_members_with_environment_info_and_merge_with_team_members
-from src.team.create_markdown_document import create_markdown_document
+from src.team.find_team_members import FindTeamMembers
+from src.team.enrich_team_members_with_contract_type import EnrichTeamMembersWithContractType
+from src.team.enrich_team_members_with_background_story import EnrichTeamMembersWithBackgroundStory
+from src.team.enrich_team_members_with_environment_info import EnrichTeamMembersWithEnvironmentInfo
+from src.team.team_markdown_document import TeamMarkdownDocumentBuilder
+from src.team.review_team import ReviewTeam
 from src.plan.find_plan_prompt import find_plan_prompt
 from src.llm_factory import get_llm
 
 llm = get_llm("ollama-llama3.1")
 # llm = get_llm("openrouter-paid-gemini-2.0-flash-001")
-# llm = get_llm("deepseek-chat", max_tokens=8192)
+# llm = get_llm("openrouter-paid-openai-gpt-4o-mini")
 
 plan_prompt = find_plan_prompt("4dc34d55-0d0d-4e9d-92f4-23765f49dd29")
 
@@ -31,12 +33,12 @@ with open(plan_prompt_file, 'w') as f:
     f.write(plan_prompt)
 
 print("Finding team members for this task...")
-team_members_raw_dict = find_team_members(llm, plan_prompt, FIND_TEAM_MEMBERS_SYSTEM_PROMPT)
+find_team_members = FindTeamMembers.execute(llm, plan_prompt)
 team_members_raw_file = f'{run_dir}/002-team_members_raw.json'
 with open(team_members_raw_file, 'w') as f:
-    f.write(json.dumps(team_members_raw_dict, indent=2))
+    f.write(json.dumps(find_team_members.to_dict(), indent=2))
 
-team_members_list = cleanup_team_members_and_assign_id(team_members_raw_dict)
+team_members_list = find_team_members.team_member_list
 team_members_list_file = f'{run_dir}/003-team_members_list.json'
 with open(team_members_list_file, 'w') as f:
     f.write(json.dumps(team_members_list, indent=2))
@@ -45,31 +47,66 @@ print(f"Number of team members: {len(team_members_list)}")
 team_member_category_list = [item['category'] for item in team_members_list]
 print(f"Team member categories: {team_member_category_list}")
 
-print("Step A: Enriching team members...")
-enrich_team_members_raw_dict = enrich_team_members(llm, plan_prompt, team_members_list, ENRICH_TEAM_MEMBERS_SYSTEM_PROMPT)
-enrich_team_members_raw_file = f'{run_dir}/004-enrich_team_members_raw.json'
-with open(enrich_team_members_raw_file, 'w') as f:
-    f.write(json.dumps(enrich_team_members_raw_dict, indent=2))
+print("Step A: Enriching team members with contract type...")
+enrich_team_members_with_contract_type_query = EnrichTeamMembersWithContractType.format_query(plan_prompt, team_members_list)
+enrich_team_members_with_contract_type = EnrichTeamMembersWithContractType.execute(llm, enrich_team_members_with_contract_type_query, team_members_list)
+enrich_team_members_with_contract_type_raw_dict = enrich_team_members_with_contract_type.to_dict()
+enrich_team_members_with_contract_type_raw_file = f'{run_dir}/004-enrich_team_members_with_contract_type_raw.json'
+with open(enrich_team_members_with_contract_type_raw_file, 'w') as f:
+    f.write(json.dumps(enrich_team_members_with_contract_type_raw_dict, indent=2))
 
-enrich_team_members_list = cleanup_enriched_team_members_and_merge_with_team_members(enrich_team_members_raw_dict, team_members_list)
-enrich_team_members_list_file = f'{run_dir}/005-enriched_team_members_list.json'
-with open(enrich_team_members_list_file, 'w') as f:
-    f.write(json.dumps(enrich_team_members_list, indent=2))
+enrich_team_members_with_contract_type_list = enrich_team_members_with_contract_type.team_member_list
+enrich_team_members_with_contract_type_list_file = f'{run_dir}/005-enrich_team_members_with_contract_type_list.json'
+with open(enrich_team_members_with_contract_type_list_file, 'w') as f:
+    f.write(json.dumps(enrich_team_members_with_contract_type_list, indent=2))
 print("Step A: Done enriching team members.")
 
-print("Step B: Enriching team members with environment info...")
-enrich_team_members_with_environment_info_raw_dict = enrich_team_members_with_environment_info(llm, plan_prompt, enrich_team_members_list, ENRICH_TEAM_MEMBERS_ENVIRONMENT_INFO_SYSTEM_PROMPT)
-enrich_team_members_with_environment_info_raw_file = f'{run_dir}/006-enrich_team_members_with_environment_info_raw.json'
+print("Step B: Enriching team members with background story...")
+enrich_team_members_with_background_story_query = EnrichTeamMembersWithBackgroundStory.format_query(plan_prompt, enrich_team_members_with_contract_type_list)
+enrich_team_members_with_background_story = EnrichTeamMembersWithBackgroundStory.execute(llm, enrich_team_members_with_background_story_query, enrich_team_members_with_contract_type_list)
+enrich_team_members_with_background_story_raw_dict = enrich_team_members_with_background_story.to_dict()
+enrich_team_members_with_background_story_raw_file = f'{run_dir}/006-enriched_team_members_with_background_story_raw.json'
+with open(enrich_team_members_with_background_story_raw_file, 'w') as f:
+    f.write(json.dumps(enrich_team_members_with_background_story_raw_dict, indent=2))
+
+enrich_team_members_with_background_story_list = enrich_team_members_with_background_story.team_member_list
+enrich_team_members_with_background_story_list_file = f'{run_dir}/007-enrich_team_members_with_background_story_list.json'
+with open(enrich_team_members_with_background_story_list_file, 'w') as f:
+    f.write(json.dumps(enrich_team_members_with_background_story_list, indent=2))
+print("Step B: Done enriching team members.")
+
+print("Step C: Enriching team members with environment info...")
+enrich_team_members_with_environment_info_query = EnrichTeamMembersWithEnvironmentInfo.format_query(plan_prompt, enrich_team_members_with_background_story_list)
+enrich_team_members_with_environment_info = EnrichTeamMembersWithEnvironmentInfo.execute(llm, enrich_team_members_with_environment_info_query, enrich_team_members_with_background_story_list)
+enrich_team_members_with_environment_info_raw_dict = enrich_team_members_with_environment_info.to_dict()
+enrich_team_members_with_environment_info_raw_file = f'{run_dir}/008-enrich_team_members_with_environment_info_raw.json'
 with open(enrich_team_members_with_environment_info_raw_file, 'w') as f:
     f.write(json.dumps(enrich_team_members_with_environment_info_raw_dict, indent=2))
 
-enrich_team_members_with_environment_info_list = cleanup_enriched_team_members_with_environment_info_and_merge_with_team_members(enrich_team_members_with_environment_info_raw_dict, enrich_team_members_list)
-enrich_team_members_with_environment_info_list_file = f'{run_dir}/007-enriched_team_members_with_environment_info_list.json'
+enrich_team_members_with_environment_info_list = enrich_team_members_with_environment_info.team_member_list
+enrich_team_members_with_environment_info_list_file = f'{run_dir}/009-enrich_team_members_with_environment_info_list.json'
 with open(enrich_team_members_with_environment_info_list_file, 'w') as f:
     f.write(json.dumps(enrich_team_members_with_environment_info_list, indent=2))
-print("Step B: Done enriching team members.")
+print("Step C: Done enriching team members.")
+
+print("Step D: Reviewing team...")
+builder1 = TeamMarkdownDocumentBuilder()
+builder1.append_roles(enrich_team_members_with_environment_info_list, title=None)
+review_team_query = ReviewTeam.format_query(plan_prompt, builder1.to_string())
+review_team = ReviewTeam.execute(llm, review_team_query)
+review_team_raw_dict = review_team.to_dict()
+review_team_raw_file = f'{run_dir}/010-review_team_raw.json'
+with open(review_team_raw_file, 'w') as f:
+    f.write(json.dumps(review_team_raw_dict, indent=2))
+print("Step D: Reviewing team.")
 
 print("Creating Markdown document...")
-output_file = f'{run_dir}/008-team.md'
-create_markdown_document(plan_prompt, enrich_team_members_with_environment_info_list_file, output_file)
+builder2 = TeamMarkdownDocumentBuilder()
+builder2.append_plan_prompt(plan_prompt)
+builder2.append_separator()
+builder2.append_roles(enrich_team_members_with_environment_info_list)
+builder2.append_separator()
+builder2.append_full_review(review_team.response)
+output_file = f'{run_dir}/011-team.md'
+builder2.write_to_file(output_file)
 print("Done creating Markdown document.")

src/team/team_markdown_document.py

@@ -0,0 +1,100 @@
+"""
+Create a Markdown document containing details about the team.
+
+PROMPT> python -m src.team.team_markdown_document
+"""
+import json
+from typing import Optional
+
+class TeamMarkdownDocumentBuilder:
+    """
+    A class to build a Markdown document containing details about the team.
+    """
+    def __init__(self):
+        self.rows = []
+
+    def append_separator(self):
+        self.rows.append("\n---\n")
+    
+    def append_plan_prompt(self, plan_prompt: str):
+        """The main topic text to include in the Markdown"""
+        self.rows.append("# The plan\n")
+        self.rows.append(plan_prompt.strip())
+
+    def append_role(self, entry: dict, role_index: int):
+        self.rows.append(f"\n## {role_index}. {entry['category']}")
+        if 'contract_type' in entry:
+            self.rows.append(f"\n**Contract Type**: `{entry['contract_type']}`")
+        if 'contract_type_justification' in entry:
+            self.rows.append(f"\n**Contract Type Justification**: {entry['contract_type_justification']}")
+        if 'explanation' in entry:
+            self.rows.append(f"\n**Explanation**:\n{entry['explanation']}")
+        if 'consequences' in entry:
+            self.rows.append(f"\n**Consequences**:\n{entry['consequences']}")
+        if 'count' in entry:
+            self.rows.append(f"\n**People Count**:\n{entry['count']}")
+        if 'typical_job_activities' in entry:
+            self.rows.append(f"\n**Typical Activities**:\n{entry['typical_job_activities']}")
+        if 'background_story' in entry:
+            self.rows.append(f"\n**Background Story**:\n{entry['background_story']}")
+        if 'equipment_needs' in entry:
+            self.rows.append(f"\n**Equipment Needs**:\n{entry['equipment_needs']}")
+        if 'facility_needs' in entry:
+            self.rows.append(f"\n**Facility Needs**:\n{entry['facility_needs']}")
+    
+    def append_roles(self, roles_list: list[dict], title: Optional[str] = "Roles"):
+        if isinstance(title, str):
+            self.rows.append(f"# {title}")
+        for entry_index, entry in enumerate(roles_list, start=1):
+            self.append_role(entry, entry_index)
+
+    def append_review_item(self, review_item: dict, review_index: int):
+        issue = review_item.get('issue', "Missing Review Issue")
+        self.rows.append(f"\n## {review_index}. {issue}")
+        if 'explanation' in review_item:
+            self.rows.append(f"\n{review_item['explanation']}")
+        if 'recommendation' in review_item:
+            self.rows.append(f"\n**Recommendation**:\n{review_item['recommendation']}")
+    
+    def append_review_items(self, review_items: list[dict], title: Optional[str] = "Review Items"):
+        if isinstance(title, str):
+            self.rows.append(f"# {title}")
+        for review_index, review_item in enumerate(review_items, start=1):
+            self.append_review_item(review_item, review_index)
+
+    def append_full_review(self, review: dict):
+        review_omissions = review.get('omissions', [])
+        self.append_review_items(review_omissions, title="Omissions")
+        self.append_separator()
+        review_potential_improvements = review.get('potential_improvements', [])
+        self.append_review_items(review_potential_improvements, title="Potential Improvements")
+
+    def to_string(self) -> str:
+        return "\n".join(self.rows)
+
+    def write_to_file(self, output_file_path: str):
+        markdown_representation = self.to_string()
+        with open(output_file_path, 'w', encoding='utf-8') as out_f:
+            out_f.write(markdown_representation)
+
+if __name__ == "__main__":
+    import os
+
+    plan_prompt = "Establish a solar farm in Denmark."
+
+    path1 = os.path.join(os.path.dirname(__file__), 'test_data', "solarfarm_roles_list.json")
+    with open(path1, 'r', encoding='utf-8') as f:
+        roles_list = json.load(f)
+
+    path2 = os.path.join(os.path.dirname(__file__), 'test_data', "solarfarm_team_review.json")
+    with open(path2, 'r', encoding='utf-8') as f:
+        team_review = json.load(f)
+
+    builder2 = TeamMarkdownDocumentBuilder()
+    builder2.append_plan_prompt(plan_prompt)
+    builder2.append_separator()
+    builder2.append_roles(roles_list)
+    builder2.append_separator()
+    builder2.append_full_review(team_review)
+
+    print(builder2.to_string())

src/team/test_data/solarfarm_roles_list.json

@@ -0,0 +1,106 @@
+[
+  {
+    "id": 1,
+    "category": "Project Manager",
+    "explanation": "Oversees the entire project, ensuring it stays on schedule and within budget.",
+    "consequences": "Without a project manager, the project may lack direction, leading to delays and budget overruns.",
+    "count": "1",
+    "contract_type": "full_time_employee",
+    "contract_type_justification": "The Project Manager needs to be fully integrated into the project to ensure consistent oversight and decision-making throughout the project's duration.",
+    "typical_job_activities": "Coordinate project schedules, manage budgets, liaise with stakeholders, oversee project execution, and ensure compliance with regulations.",
+    "background_story": "Lars Jensen, a seasoned project manager based in Aarhus, Denmark, graduated with a Master's degree in Project Management from the University of Aarhus. With over 10 years of experience in managing renewable energy projects, Lars has successfully overseen the construction of multiple wind and solar farms across Scandinavia. His strong leadership skills and ability to navigate complex regulatory environments make him an invaluable asset to the team. Lars is well-versed in the intricacies of project timelines and budgets, ensuring that the solar farm project remains on track and within financial constraints.",
+    "equipment_needs": "Laptop with project management software, communication tools, and access to project documentation.",
+    "facility_needs": "Office space for meetings and collaboration with team members and stakeholders."
+  },
+  {
+    "id": 2,
+    "category": "Site Engineer",
+    "explanation": "Responsible for the technical aspects of the solar farm's construction and installation.",
+    "consequences": "Absence of a site engineer can result in construction errors and safety issues, jeopardizing the project.",
+    "count": "2",
+    "contract_type": "full_time_employee",
+    "contract_type_justification": "The Site Engineer is essential for the technical execution of the project and requires full-time commitment to address ongoing construction challenges.",
+    "typical_job_activities": "Oversee construction activities, ensure compliance with engineering specifications, conduct site inspections, and collaborate with contractors.",
+    "background_story": "Sophie Madsen, a site engineer from Odense, Denmark, holds a Bachelor's degree in Civil Engineering from the Technical University of Denmark. With five years of hands-on experience in solar farm construction, Sophie has developed a keen eye for detail and a strong understanding of the technical requirements involved in such projects. Her familiarity with construction processes and safety regulations makes her a critical member of the team, ensuring that the solar farm is built to the highest standards.",
+    "equipment_needs": "Construction tools, safety gear, surveying equipment, and a laptop with engineering software.",
+    "facility_needs": "Access to the construction site and a temporary office or trailer for on-site coordination."
+  },
+  {
+    "id": 3,
+    "category": "Environmental Consultant",
+    "explanation": "Assesses the environmental impact of the solar farm and ensures compliance with regulations.",
+    "consequences": "Failure to address environmental concerns can lead to legal issues and project delays.",
+    "count": "1",
+    "contract_type": "independent_contractor",
+    "contract_type_justification": "The Environmental Consultant can be engaged on a project basis, providing expertise as needed without the requirement for full-time employment.",
+    "typical_job_activities": "Conduct environmental impact assessments, prepare reports, liaise with regulatory bodies, and recommend mitigation strategies.",
+    "background_story": "Freja S\u00f8rensen, an environmental consultant based in Copenhagen, Denmark, earned her Master's degree in Environmental Science from the University of Copenhagen. With over eight years of experience in environmental assessments for renewable energy projects, Freja is adept at identifying potential ecological impacts and ensuring compliance with local regulations. Her expertise is crucial for the solar farm project, as she will help navigate environmental challenges and secure necessary permits.",
+    "equipment_needs": "Laptop with environmental assessment software, access to environmental databases, and reporting tools.",
+    "facility_needs": "Office space for conducting assessments and meetings with regulatory bodies."
+  },
+  {
+    "id": 4,
+    "category": "Financial Analyst",
+    "explanation": "Evaluates the financial feasibility of the project and manages funding and budgeting.",
+    "consequences": "Without financial oversight, the project may face funding shortages or misallocation of resources.",
+    "count": "1",
+    "contract_type": "full_time_employee",
+    "contract_type_justification": "The Financial Analyst plays a critical role in managing the project's finances and requires continuous involvement to ensure financial health.",
+    "typical_job_activities": "Evaluate financial models, manage budgets, analyze funding options, and prepare financial reports.",
+    "background_story": "Mikkel Thomsen, a financial analyst from Aalborg, Denmark, graduated with a degree in Finance from Aalborg University. With a background in renewable energy financing, Mikkel has spent the last six years analyzing project feasibility and managing budgets for various energy initiatives. His analytical skills and financial acumen are essential for ensuring that the solar farm project remains financially viable and well-funded.",
+    "equipment_needs": "Laptop with financial modeling software, access to financial databases, and reporting tools.",
+    "facility_needs": "Office space for financial analysis and meetings with project stakeholders."
+  },
+  {
+    "id": 5,
+    "category": "Procurement Specialist",
+    "explanation": "Handles the sourcing and purchasing of materials and equipment needed for the solar farm.",
+    "consequences": "Lack of procurement expertise can lead to delays in acquiring necessary materials, affecting the project timeline.",
+    "count": "1",
+    "contract_type": "independent_contractor",
+    "contract_type_justification": "The Procurement Specialist can be contracted for specific phases of the project, focusing on sourcing materials without needing a full-time position.",
+    "typical_job_activities": "Source and negotiate with suppliers, manage purchase orders, track inventory, and ensure timely delivery of materials.",
+    "background_story": "Clara Nielsen, a procurement specialist located in Esbjerg, Denmark, has a degree in Supply Chain Management from the University of Southern Denmark. With over seven years of experience in sourcing materials for construction projects, Clara has developed strong negotiation skills and a vast network of suppliers. Her role is vital for ensuring that the solar farm has all necessary materials and equipment on time and within budget.",
+    "equipment_needs": "Laptop with procurement management software, access to supplier databases, and communication tools.",
+    "facility_needs": "Office space for sourcing materials and negotiating with suppliers."
+  },
+  {
+    "id": 6,
+    "category": "Construction Crew",
+    "explanation": "A team of workers responsible for the physical construction of the solar farm.",
+    "consequences": "Insufficient workforce can slow down construction progress and lead to missed deadlines.",
+    "count": "min 5, max 10, depending on project scale",
+    "contract_type": "agency_temp",
+    "contract_type_justification": "The Construction Crew can be sourced through an agency to provide flexibility in workforce size based on project demands and timelines.",
+    "typical_job_activities": "Install solar panels, perform site preparation, conduct safety checks, and collaborate with site engineers.",
+    "background_story": "The construction crew, led by foreman Jakob Larsen, is a diverse team of skilled workers from various backgrounds in construction and renewable energy. Based in different regions of Denmark, the crew members have undergone specialized training in solar panel installation and safety protocols. Their collective experience and teamwork are essential for the successful physical construction of the solar farm, ensuring that all tasks are completed efficiently and safely.",
+    "equipment_needs": "Construction tools, safety gear, and equipment for solar panel installation.",
+    "facility_needs": "Access to the construction site and temporary facilities for the crew."
+  },
+  {
+    "id": 7,
+    "category": "Quality Assurance Specialist",
+    "explanation": "Ensures that all work meets the required standards and specifications.",
+    "consequences": "Without quality assurance, the project may face issues with system performance and reliability.",
+    "count": "1",
+    "contract_type": "part_time_employee",
+    "contract_type_justification": "The Quality Assurance Specialist may not need to be full-time, as their role can be fulfilled on a part-time basis during critical phases of construction.",
+    "typical_job_activities": "Conduct quality inspections, develop quality assurance protocols, document findings, and collaborate with construction teams.",
+    "background_story": "Anna Pedersen, a quality assurance specialist from Randers, Denmark, holds a degree in Quality Management from the University of Aarhus. With over four years of experience in quality control within the renewable energy sector, Anna is skilled in developing and implementing quality assurance protocols. Her attention to detail and commitment to excellence are crucial for ensuring that the solar farm meets all required standards and specifications.",
+    "equipment_needs": "Laptop with quality management software, inspection tools, and documentation materials.",
+    "facility_needs": "Office space for conducting quality inspections and meetings with construction teams."
+  },
+  {
+    "id": 8,
+    "category": "Maintenance Technician",
+    "explanation": "Responsible for the ongoing maintenance and troubleshooting of the solar farm post-construction.",
+    "consequences": "Lack of maintenance can lead to system failures and decreased efficiency over time.",
+    "count": "min 1, max 3, depending on project scale and operational needs",
+    "contract_type": "independent_contractor",
+    "contract_type_justification": "The Maintenance Technician can be contracted as needed post-construction, allowing for flexibility in scheduling maintenance activities.",
+    "typical_job_activities": "Perform routine maintenance, troubleshoot system issues, conduct performance assessments, and coordinate with the project team for repairs.",
+    "background_story": "Oliver Kristensen, a maintenance technician based in Kolding, Denmark, has a background in electrical engineering from the University of Southern Denmark. With three years of experience in maintaining solar energy systems, Oliver is adept at troubleshooting and performing routine maintenance to ensure optimal performance. His role post-construction is vital for the long-term efficiency and reliability of the solar farm.",
+    "equipment_needs": "Maintenance tools, diagnostic equipment, and a laptop for performance assessments.",
+    "facility_needs": "Access to the solar farm for maintenance activities and a workshop for repairs."
+  }
+]

src/team/test_data/solarfarm_team_review.json

@@ -0,0 +1,49 @@
+{
+  "omissions": [
+    {
+      "issue": "Community Engagement Coordinator",
+      "explanation": "Engaging with the local community is crucial for gaining support and addressing concerns related to the solar farm project.",
+      "recommendation": "Consider appointing a Community Engagement Coordinator to facilitate communication with local residents, address their concerns, and promote the benefits of the solar farm."
+    },
+    {
+      "issue": "Health and Safety Officer",
+      "explanation": "A dedicated Health and Safety Officer is essential to ensure compliance with safety regulations and to promote a safe working environment on-site.",
+      "recommendation": "Introduce a Health and Safety Officer role to oversee safety protocols, conduct training, and ensure that all safety measures are adhered to during construction."
+    },
+    {
+      "issue": "Legal Advisor",
+      "explanation": "Legal expertise is necessary to navigate contracts, permits, and compliance with local laws and regulations.",
+      "recommendation": "Engage a Legal Advisor on a consulting basis to review contracts, assist with regulatory compliance, and address any legal issues that may arise during the project."
+    }
+  ],
+  "potential_improvements": [
+    {
+      "issue": "Clarification of Roles",
+      "explanation": "Some roles may have overlapping responsibilities, which can lead to confusion and inefficiencies.",
+      "recommendation": "Clearly define the responsibilities of each team member, particularly between the Site Engineer and the Quality Assurance Specialist, to ensure accountability and streamline processes."
+    },
+    {
+      "issue": "Regular Team Meetings",
+      "explanation": "Frequent communication among team members is vital for project alignment and addressing issues promptly.",
+      "recommendation": "Implement regular team meetings to discuss progress, challenges, and updates, ensuring that all team members are informed and engaged."
+    },
+    {
+      "issue": "Documentation and Reporting",
+      "explanation": "Proper documentation is essential for tracking progress and ensuring compliance with regulations.",
+      "recommendation": "Establish a centralized documentation system where all team members can access and update project-related documents, ensuring transparency and accountability."
+    }
+  ],
+  "metadata": {
+    "context_window": 3900,
+    "num_output": 8192,
+    "is_chat_model": true,
+    "is_function_calling_model": false,
+    "model_name": "openai/gpt-4o-mini",
+    "system_role": "system",
+    "llm_classname": "OpenRouter_LLM",
+    "duration": 10,
+    "response_byte_count": 2130
+  },
+  "system_prompt": "You are an expert in designing and evaluating team structures for projects of all scales\u2014from personal or trivial endeavors to large, complex initiatives. Your task is to review a team document that includes a project plan, detailed team roles, and sections on omissions and potential improvements.\n\nIn your analysis, please:\n\n1. **Review the Team Composition:**\n   - Examine the team roles described, including details such as contract types, typical activities, background stories, and resource needs.\n   - Consider whether the roles sufficiently cover all aspects of the project given its scope.\n\n2. **Identify Omissions:**\n   - Highlight any significant missing roles, support functions, or expertise areas that are critical for the project's success.\n   - **Important:** When the project is personal or trivial, avoid suggesting overly formal or business-oriented roles (e.g., Marketing Specialist, Legal Advisor, Technical Support Specialist). Instead, suggest simpler or integrative adjustments suitable for a personal context.\n\n3. **Suggest Potential Improvements:**\n   - Recommend actionable changes that enhance the team's overall effectiveness, communication, and clarity.\n   - Focus on clarifying responsibilities and reducing overlap.\n   - For personal or non-commercial projects, tailor your recommendations to be straightforward and avoid introducing new formal roles that are unnecessary.\n\n4. **Provide Actionable Recommendations:**\n   - For each identified omission or improvement, offer specific, practical advice on how to address the issue.\n   - Ensure your recommendations are scaled appropriately to the project's nature.\n\nYour output must be a JSON object with two top-level keys: \"omissions\" and \"potential_improvements\". Each key should map to an array of objects, where each object contains:\n- `\"issue\"`: A brief title summarizing the omission or improvement.\n- `\"explanation\"`: A concise explanation of why this issue is significant in relation to the project's goals.\n- `\"recommendation\"`: Specific, actionable advice on how to address the issue.\n\nEnsure your JSON output strictly follows this structure without any additional commentary or text.",
+  "user_prompt": "Project description:\nEstablish a solar farm in Denmark.\n\nDocument with team members:\n\n## 1. Project Manager\n\n**Contract Type**: `full_time_employee`\n\n**Contract Type Justification**: The Project Manager needs to be fully integrated into the project to ensure consistent oversight and decision-making throughout the project's duration.\n\n**Explanation**:\nOversees the entire project, ensuring it stays on schedule and within budget.\n\n**Consequences**:\nWithout a project manager, the project may lack direction, leading to delays and budget overruns.\n\n**People Count**:\n1\n\n**Typical Activities**:\nCoordinate project schedules, manage budgets, liaise with stakeholders, oversee project execution, and ensure compliance with regulations.\n\n**Background Story**:\nLars Jensen, a seasoned project manager based in Aarhus, Denmark, graduated with a Master's degree in Project Management from the University of Aarhus. With over 10 years of experience in managing renewable energy projects, Lars has successfully overseen the construction of multiple wind and solar farms across Scandinavia. His strong leadership skills and ability to navigate complex regulatory environments make him an invaluable asset to the team. Lars is well-versed in the intricacies of project timelines and budgets, ensuring that the solar farm project remains on track and within financial constraints.\n\n**Equipment Needs**:\nLaptop with project management software, communication tools, and access to project documentation.\n\n**Facility Needs**:\nOffice space for meetings and collaboration with team members and stakeholders.\n\n## 2. Site Engineer\n\n**Contract Type**: `full_time_employee`\n\n**Contract Type Justification**: The Site Engineer is essential for the technical execution of the project and requires full-time commitment to address ongoing construction challenges.\n\n**Explanation**:\nResponsible for the technical aspects of the solar farm's construction and installation.\n\n**Consequences**:\nAbsence of a site engineer can result in construction errors and safety issues, jeopardizing the project.\n\n**People Count**:\n2\n\n**Typical Activities**:\nOversee construction activities, ensure compliance with engineering specifications, conduct site inspections, and collaborate with contractors.\n\n**Background Story**:\nSophie Madsen, a site engineer from Odense, Denmark, holds a Bachelor's degree in Civil Engineering from the Technical University of Denmark. With five years of hands-on experience in solar farm construction, Sophie has developed a keen eye for detail and a strong understanding of the technical requirements involved in such projects. Her familiarity with construction processes and safety regulations makes her a critical member of the team, ensuring that the solar farm is built to the highest standards.\n\n**Equipment Needs**:\nConstruction tools, safety gear, surveying equipment, and a laptop with engineering software.\n\n**Facility Needs**:\nAccess to the construction site and a temporary office or trailer for on-site coordination.\n\n## 3. Environmental Consultant\n\n**Contract Type**: `independent_contractor`\n\n**Contract Type Justification**: The Environmental Consultant can be engaged on a project basis, providing expertise as needed without the requirement for full-time employment.\n\n**Explanation**:\nAssesses the environmental impact of the solar farm and ensures compliance with regulations.\n\n**Consequences**:\nFailure to address environmental concerns can lead to legal issues and project delays.\n\n**People Count**:\n1\n\n**Typical Activities**:\nConduct environmental impact assessments, prepare reports, liaise with regulatory bodies, and recommend mitigation strategies.\n\n**Background Story**:\nFreja S\u00f8rensen, an environmental consultant based in Copenhagen, Denmark, earned her Master's degree in Environmental Science from the University of Copenhagen. With over eight years of experience in environmental assessments for renewable energy projects, Freja is adept at identifying potential ecological impacts and ensuring compliance with local regulations. Her expertise is crucial for the solar farm project, as she will help navigate environmental challenges and secure necessary permits.\n\n**Equipment Needs**:\nLaptop with environmental assessment software, access to environmental databases, and reporting tools.\n\n**Facility Needs**:\nOffice space for conducting assessments and meetings with regulatory bodies.\n\n## 4. Financial Analyst\n\n**Contract Type**: `full_time_employee`\n\n**Contract Type Justification**: The Financial Analyst plays a critical role in managing the project's finances and requires continuous involvement to ensure financial health.\n\n**Explanation**:\nEvaluates the financial feasibility of the project and manages funding and budgeting.\n\n**Consequences**:\nWithout financial oversight, the project may face funding shortages or misallocation of resources.\n\n**People Count**:\n1\n\n**Typical Activities**:\nEvaluate financial models, manage budgets, analyze funding options, and prepare financial reports.\n\n**Background Story**:\nMikkel Thomsen, a financial analyst from Aalborg, Denmark, graduated with a degree in Finance from Aalborg University. With a background in renewable energy financing, Mikkel has spent the last six years analyzing project feasibility and managing budgets for various energy initiatives. His analytical skills and financial acumen are essential for ensuring that the solar farm project remains financially viable and well-funded.\n\n**Equipment Needs**:\nLaptop with financial modeling software, access to financial databases, and reporting tools.\n\n**Facility Needs**:\nOffice space for financial analysis and meetings with project stakeholders.\n\n## 5. Procurement Specialist\n\n**Contract Type**: `independent_contractor`\n\n**Contract Type Justification**: The Procurement Specialist can be contracted for specific phases of the project, focusing on sourcing materials without needing a full-time position.\n\n**Explanation**:\nHandles the sourcing and purchasing of materials and equipment needed for the solar farm.\n\n**Consequences**:\nLack of procurement expertise can lead to delays in acquiring necessary materials, affecting the project timeline.\n\n**People Count**:\n1\n\n**Typical Activities**:\nSource and negotiate with suppliers, manage purchase orders, track inventory, and ensure timely delivery of materials.\n\n**Background Story**:\nClara Nielsen, a procurement specialist located in Esbjerg, Denmark, has a degree in Supply Chain Management from the University of Southern Denmark. With over seven years of experience in sourcing materials for construction projects, Clara has developed strong negotiation skills and a vast network of suppliers. Her role is vital for ensuring that the solar farm has all necessary materials and equipment on time and within budget.\n\n**Equipment Needs**:\nLaptop with procurement management software, access to supplier databases, and communication tools.\n\n**Facility Needs**:\nOffice space for sourcing materials and negotiating with suppliers.\n\n## 6. Construction Crew\n\n**Contract Type**: `agency_temp`\n\n**Contract Type Justification**: The Construction Crew can be sourced through an agency to provide flexibility in workforce size based on project demands and timelines.\n\n**Explanation**:\nA team of workers responsible for the physical construction of the solar farm.\n\n**Consequences**:\nInsufficient workforce can slow down construction progress and lead to missed deadlines.\n\n**People Count**:\nmin 5, max 10, depending on project scale\n\n**Typical Activities**:\nInstall solar panels, perform site preparation, conduct safety checks, and collaborate with site engineers.\n\n**Background Story**:\nThe construction crew, led by foreman Jakob Larsen, is a diverse team of skilled workers from various backgrounds in construction and renewable energy. Based in different regions of Denmark, the crew members have undergone specialized training in solar panel installation and safety protocols. Their collective experience and teamwork are essential for the successful physical construction of the solar farm, ensuring that all tasks are completed efficiently and safely.\n\n**Equipment Needs**:\nConstruction tools, safety gear, and equipment for solar panel installation.\n\n**Facility Needs**:\nAccess to the construction site and temporary facilities for the crew.\n\n## 7. Quality Assurance Specialist\n\n**Contract Type**: `part_time_employee`\n\n**Contract Type Justification**: The Quality Assurance Specialist may not need to be full-time, as their role can be fulfilled on a part-time basis during critical phases of construction.\n\n**Explanation**:\nEnsures that all work meets the required standards and specifications.\n\n**Consequences**:\nWithout quality assurance, the project may face issues with system performance and reliability.\n\n**People Count**:\n1\n\n**Typical Activities**:\nConduct quality inspections, develop quality assurance protocols, document findings, and collaborate with construction teams.\n\n**Background Story**:\nAnna Pedersen, a quality assurance specialist from Randers, Denmark, holds a degree in Quality Management from the University of Aarhus. With over four years of experience in quality control within the renewable energy sector, Anna is skilled in developing and implementing quality assurance protocols. Her attention to detail and commitment to excellence are crucial for ensuring that the solar farm meets all required standards and specifications.\n\n**Equipment Needs**:\nLaptop with quality management software, inspection tools, and documentation materials.\n\n**Facility Needs**:\nOffice space for conducting quality inspections and meetings with construction teams.\n\n## 8. Maintenance Technician\n\n**Contract Type**: `independent_contractor`\n\n**Contract Type Justification**: The Maintenance Technician can be contracted as needed post-construction, allowing for flexibility in scheduling maintenance activities.\n\n**Explanation**:\nResponsible for the ongoing maintenance and troubleshooting of the solar farm post-construction.\n\n**Consequences**:\nLack of maintenance can lead to system failures and decreased efficiency over time.\n\n**People Count**:\nmin 1, max 3, depending on project scale and operational needs\n\n**Typical Activities**:\nPerform routine maintenance, troubleshoot system issues, conduct performance assessments, and coordinate with the project team for repairs.\n\n**Background Story**:\nOliver Kristensen, a maintenance technician based in Kolding, Denmark, has a background in electrical engineering from the University of Southern Denmark. With three years of experience in maintaining solar energy systems, Oliver is adept at troubleshooting and performing routine maintenance to ensure optimal performance. His role post-construction is vital for the long-term efficiency and reliability of the solar farm.\n\n**Equipment Needs**:\nMaintenance tools, diagnostic equipment, and a laptop for performance assessments.\n\n**Facility Needs**:\nAccess to the solar farm for maintenance activities and a workshop for repairs."
+}

src/team/test_data/solarfarm_team_without_review.md

@@ -0,0 +1,229 @@
+## Role 1 - Project Manager
+
+**Contract Type**: full_time_employee
+
+**Contract Type Justification**: The Project Manager requires consistent involvement and oversight throughout the project lifecycle, making a full-time employee the most suitable option.
+
+**Explanation**:
+Oversees all aspects of the solar farm project, ensuring it stays on schedule and within budget. Manages communication between different teams and stakeholders.
+
+**Consequences**:
+Project delays, cost overruns, and miscommunication between teams.
+
+**People Count**:
+1
+
+**Typical Activities**:
+Developing project plans, managing budgets, coordinating teams, communicating with stakeholders, and ensuring project milestones are met on time and within budget.
+
+**Background Story**:
+Astrid Nielsen, a seasoned project manager from Copenhagen, has a proven track record of successfully delivering large-scale infrastructure projects across Denmark. With a Master's degree in Engineering Management from the Technical University of Denmark and over 15 years of experience in the construction and renewable energy sectors, Astrid possesses a comprehensive understanding of project lifecycles, risk management, and stakeholder communication. She has previously managed the construction of a large wind farm in Jutland, giving her direct experience with the challenges and opportunities of renewable energy projects in the Danish landscape. Astrid's meticulous planning, proactive problem-solving skills, and ability to foster collaboration make her the ideal candidate to lead the solar farm project.
+
+**Equipment Needs**:
+Laptop, project management software, communication tools (phone, video conferencing).
+
+**Facility Needs**:
+Office space, meeting rooms.
+
+---
+
+## Role 2 - Solar Energy Engineer
+
+**Contract Type**: full_time_employee
+
+**Contract Type Justification**: The Solar Energy Engineer's role is critical for the entire project and requires in-depth knowledge of the project specifics. A full-time employee ensures consistent involvement and expertise.
+
+**Explanation**:
+Designs the solar farm layout, selects appropriate solar panel technology, and optimizes energy production based on the Danish climate and grid infrastructure.
+
+**Consequences**:
+Inefficient energy production, suboptimal panel selection, and potential grid integration issues.
+
+**People Count**:
+1
+
+**Typical Activities**:
+Designing solar farm layouts, selecting solar panel technology, optimizing energy production, conducting energy yield assessments, and ensuring grid integration compliance.
+
+**Background Story**:
+Erik Hansen, a highly skilled Solar Energy Engineer hailing from Aarhus, possesses a deep understanding of photovoltaic systems and renewable energy technologies. He holds a PhD in Solar Energy Engineering from Aarhus University and has spent the last decade designing and optimizing solar energy systems for various applications, including residential, commercial, and utility-scale projects. Erik's expertise lies in solar panel technology selection, energy yield modeling, and grid integration strategies. He is intimately familiar with the Danish climate and grid infrastructure, having previously worked on several solar energy projects in the region. Erik's analytical skills, technical expertise, and passion for renewable energy make him an invaluable asset to the solar farm project.
+
+**Equipment Needs**:
+High-performance computer, specialized solar design software (e.g., PVsyst, Helioscope), data analysis tools.
+
+**Facility Needs**:
+Office space, access to meteorological data and grid information.
+
+---
+
+## Role 3 - Environmental Impact Assessor
+
+**Contract Type**: independent_contractor
+
+**Contract Type Justification**: The Environmental Impact Assessor's role is project-specific and requires specialized expertise. An independent contractor can provide this expertise on a project basis.
+
+**Explanation**:
+Conducts a thorough environmental impact assessment to identify and mitigate potential negative effects on the local ecosystem, ensuring compliance with Danish environmental regulations.
+
+**Consequences**:
+Regulatory delays, potential environmental damage, and negative public perception.
+
+**People Count**:
+1
+
+**Typical Activities**:
+Conducting environmental impact assessments, identifying potential environmental impacts, developing mitigation strategies, preparing environmental reports, and ensuring compliance with environmental regulations.
+
+**Background Story**:
+Birgitte Christensen, an independent Environmental Impact Assessor based in Odense, has extensive experience in evaluating the environmental consequences of development projects in Denmark. With a Master's degree in Environmental Science from the University of Southern Denmark and over 8 years of experience in environmental consulting, Birgitte has conducted numerous environmental impact assessments for a wide range of projects, including wind farms, infrastructure developments, and industrial facilities. She is intimately familiar with Danish environmental regulations and best practices for mitigating environmental impacts. Birgitte's thoroughness, attention to detail, and commitment to environmental sustainability make her the perfect choice to assess the environmental impact of the solar farm project.
+
+**Equipment Needs**:
+Field equipment for environmental sampling and monitoring, data analysis software, report writing software.
+
+**Facility Needs**:
+Access to environmental databases, laboratory access (if required for sample analysis), transportation to site.
+
+---
+
+## Role 4 - Land Acquisition Specialist
+
+**Contract Type**: independent_contractor
+
+**Contract Type Justification**: The Land Acquisition Specialist's role is specific to the initial phase of the project. An independent contractor with local expertise is well-suited for this task.
+
+**Explanation**:
+Identifies and secures suitable land for the solar farm, negotiating purchase or lease agreements with landowners, and navigating Danish land use regulations.
+
+**Consequences**:
+Difficulty finding suitable land, delays in project commencement, and increased project costs.
+
+**People Count**:
+1
+
+**Typical Activities**:
+Identifying suitable land for the solar farm, negotiating purchase or lease agreements with landowners, conducting due diligence on land parcels, and navigating Danish land use regulations.
+
+**Background Story**:
+Jens Petersen, a seasoned Land Acquisition Specialist from Aalborg, has a proven track record of successfully securing land for development projects across Denmark. With over 12 years of experience in real estate and land acquisition, Jens possesses a deep understanding of Danish land use regulations, property valuation, and negotiation strategies. He has previously worked on several renewable energy projects, including wind farms and biomass plants, giving him direct experience with the challenges and opportunities of land acquisition in the renewable energy sector. Jens's local knowledge, negotiation skills, and ability to build relationships with landowners make him the ideal candidate to secure suitable land for the solar farm project.
+
+**Equipment Needs**:
+Transportation, access to land registry databases, GIS software, negotiation tools.
+
+**Facility Needs**:
+Office space (potentially remote), access to legal resources.
+
+---
+
+## Role 5 - Grid Connection Specialist
+
+**Contract Type**: independent_contractor
+
+**Contract Type Justification**: The Grid Connection Specialist requires specialized knowledge of the Danish power grid and regulations. An independent contractor with relevant experience is a good fit.
+
+**Explanation**:
+Manages the interconnection of the solar farm to the Danish power grid, ensuring compliance with grid operator requirements and optimizing energy delivery.
+
+**Consequences**:
+Delays in grid connection, potential energy losses, and non-compliance with grid regulations.
+
+**People Count**:
+1
+
+**Typical Activities**:
+Managing the interconnection of the solar farm to the Danish power grid, ensuring compliance with grid operator requirements, optimizing energy delivery, and conducting power system studies.
+
+**Background Story**:
+Lars Jensen, an independent Grid Connection Specialist based in Esbjerg, has extensive experience in managing the interconnection of renewable energy projects to the Danish power grid. With a Master's degree in Electrical Engineering from the University of Aalborg and over 10 years of experience in the power industry, Lars possesses a deep understanding of grid operator requirements, grid connection procedures, and power system analysis. He has previously worked on several large-scale renewable energy projects, including wind farms and solar power plants, giving him direct experience with the challenges and opportunities of grid integration in Denmark. Lars's technical expertise, problem-solving skills, and ability to navigate complex grid regulations make him an invaluable asset to the solar farm project.
+
+**Equipment Needs**:
+Specialized software for power system studies (e.g., PSS/E, DigSilent), communication equipment for liaising with grid operators.
+
+**Facility Needs**:
+Office space, access to grid connection standards and regulations.
+
+---
+
+## Role 6 - Construction Supervisor
+
+**Contract Type**: full_time_employee
+
+**Contract Type Justification**: The Construction Supervisor needs to be on-site throughout the construction phase, ensuring quality and safety. A full-time employee provides consistent oversight.
+
+**Explanation**:
+Oversees the physical construction of the solar farm, ensuring adherence to engineering specifications, safety regulations, and quality standards.
+
+**Consequences**:
+Poor construction quality, safety hazards, and potential structural failures.
+
+**People Count**:
+1
+
+**Typical Activities**:
+Overseeing the physical construction of the solar farm, ensuring adherence to engineering specifications, enforcing safety regulations, and maintaining quality standards.
+
+**Background Story**:
+Helle Mortensen, a highly experienced Construction Supervisor from Roskilde, has a proven track record of successfully overseeing the construction of large-scale infrastructure projects across Denmark. With a Bachelor's degree in Civil Engineering from the Technical University of Denmark and over 18 years of experience in the construction industry, Helle possesses a comprehensive understanding of construction methods, safety regulations, and quality control procedures. She has previously supervised the construction of several renewable energy projects, including wind farms and solar power plants, giving her direct experience with the challenges and opportunities of construction in the renewable energy sector. Helle's leadership skills, attention to detail, and commitment to safety make her the ideal candidate to oversee the construction of the solar farm.
+
+**Equipment Needs**:
+Personal Protective Equipment (PPE), communication devices (radio, phone), inspection tools, access to engineering drawings and specifications.
+
+**Facility Needs**:
+On-site office/trailer, access to construction site, safety equipment storage.
+
+---
+
+## Role 7 - Legal Counsel (Danish Law)
+
+**Contract Type**: independent_contractor
+
+**Contract Type Justification**: Legal Counsel is needed for specific legal tasks and advice. An independent contractor specializing in Danish law can provide this expertise as needed.
+
+**Explanation**:
+Provides legal expertise on Danish regulations related to renewable energy, land use, environmental compliance, and grid connection agreements.
+
+**Consequences**:
+Legal challenges, regulatory fines, and project delays due to non-compliance.
+
+**People Count**:
+min 1, max 2, depending on the complexity of the legal and regulatory landscape. This is measured by the number of unique legal challenges encountered during the project.
+
+**Typical Activities**:
+Providing legal expertise on Danish regulations related to renewable energy, land use, environmental compliance, and grid connection agreements, drafting and reviewing legal documents, and representing the project in legal proceedings.
+
+**Background Story**:
+Peter Olsen, a highly regarded Legal Counsel specializing in Danish law, operates his independent practice from Copenhagen. With a Juris Doctor degree from the University of Copenhagen and over 15 years of experience in legal practice, Peter possesses a deep understanding of Danish regulations related to renewable energy, land use, environmental compliance, and grid connection agreements. He has advised numerous clients on renewable energy projects, providing legal expertise on a wide range of issues, including permitting, financing, and contract negotiation. Peter's legal acumen, attention to detail, and commitment to client service make him the perfect choice to provide legal counsel on the solar farm project.
+
+**Equipment Needs**:
+Legal research databases, document drafting software, communication tools.
+
+**Facility Needs**:
+Office space, access to legal library/resources.
+
+---
+
+## Role 8 - Financial Analyst
+
+**Contract Type**: full_time_employee
+
+**Contract Type Justification**: The Financial Analyst needs to be involved throughout the project lifecycle, managing finances and securing funding. A full-time employee ensures consistent financial oversight.
+
+**Explanation**:
+Develops and manages the project's financial model, secures funding, and monitors financial performance throughout the project lifecycle.
+
+**Consequences**:
+Difficulty securing funding, cost overruns, and potential financial losses.
+
+**People Count**:
+min 1, max 2, depending on the size of the solar farm and the complexity of the financing structure. This is measured by the total capital expenditure of the project.
+
+**Typical Activities**:
+Developing and managing the project's financial model, securing funding, monitoring financial performance, and preparing financial reports.
+
+**Background Story**:
+Rasmus Christensen, a seasoned Financial Analyst from Odense, has a proven track record of successfully managing the financial aspects of large-scale infrastructure projects across Denmark. With a Master's degree in Finance from Copenhagen Business School and over 12 years of experience in the financial industry, Rasmus possesses a comprehensive understanding of financial modeling, project finance, and investment analysis. He has previously worked on several renewable energy projects, including wind farms and solar power plants, giving him direct experience with the challenges and opportunities of financing renewable energy projects in Denmark. Rasmus's analytical skills, financial expertise, and ability to secure funding make him an invaluable asset to the solar farm project.
+
+**Equipment Needs**:
+Financial modeling software, data analysis tools, communication tools for investor relations.
+
+**Facility Needs**:
+Office space, access to financial databases.