Snapshot of PlanExe commit 773f9ca98123b5751e6b16be192818b572af1aa0

requirements.txt

@@ -5,6 +5,7 @@ aiosignal==1.3.2
 annotated-types==0.7.0
 anyio==4.8.0
 attrs==24.3.0
+audioop-lts==0.2.1
 beautifulsoup4==4.12.3
 certifi==2024.12.14
 charset-normalizer==3.4.1
@@ -14,6 +15,7 @@ dataclasses-json==0.6.7
 Deprecated==1.2.15
 dirtyjson==1.0.8
 distro==1.9.0
+eval_type_backport==0.2.2
 fastapi==0.115.6
 ffmpy==0.5.0
 filelock==3.16.1
@@ -31,6 +33,7 @@ idna==3.10
 Jinja2==3.1.5
 jiter==0.8.2
 joblib==1.4.2
+jsonpath-python==1.0.6
 llama-cloud==0.1.8
 llama-index==0.12.10
 llama-index-agent-openai==0.4.1
@@ -40,6 +43,7 @@ llama-index-embeddings-openai==0.3.1
 llama-index-indices-managed-llama-cloud==0.6.3
 llama-index-llms-groq==0.3.1
 llama-index-llms-lmstudio==0.3.0
+llama-index-llms-mistralai==0.4.0
 llama-index-llms-ollama==0.5.0
 llama-index-llms-openai==0.3.13
 llama-index-llms-openai-like==0.3.3
@@ -53,11 +57,12 @@ llama-index-readers-llama-parse==0.4.0
 llama-parse==0.5.19
 lockfile==0.12.2
 luigi==3.6.0
-Markdown==3.7.0 
+Markdown==3.7
 markdown-it-py==3.0.0
 MarkupSafe==2.1.5
 marshmallow==3.24.2
 mdurl==0.1.2
+mistralai==1.5.2
 multidict==6.1.0
 mypy-extensions==1.0.0
 nest-asyncio==1.6.0

src/assume/shorten_markdown.py

@@ -0,0 +1,161 @@
+"""
+Shorten the long consolidated assumptions to a shorter markdown document.
+
+PROMPT> python -m src.assume.shorten_markdown
+"""
+import os
+import json
+import time
+import logging
+from math import ceil
+from typing import Optional
+from dataclasses import dataclass
+from llama_index.core.llms.llm import LLM
+from llama_index.core.llms import ChatMessage, MessageRole
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+from src.markdown_util.fix_bullet_lists import fix_bullet_lists
+from src.markdown_util.remove_bold_formatting import remove_bold_formatting
+
+logger = logging.getLogger(__name__)
+
+SHORTEN_MARKDOWN_SYSTEM_PROMPT = """
+You are a transformer that shortens project planning Markdown documents. Your only task is to convert the input Markdown into a shorter version while preserving all topics and structure. Do not add any extra text or new information.
+
+Output must:
+- Be wrapped exactly in [START_MARKDOWN] and [END_MARKDOWN] (no text before or after).
+- Use only plain Markdown (no bold formatting).
+- Retain headings using only '#' and '##'. Convert any deeper levels to these.
+- Use bullet lists with a hyphen and a space.
+- Condense paragraphs, remove redundancy, and combine similar sections.
+- Preserve key details (assumptions, risks, recommendations) without summarizing or providing commentary.
+"""
+
+@dataclass
+class ShortenMarkdown:
+    system_prompt: Optional[str]
+    user_prompt: str
+    response: str
+    markdown: str
+    metadata: dict
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'ShortenMarkdown':
+        """
+        Invoke LLM with a long markdown document that is to be shortened.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+        
+        user_prompt = user_prompt.strip()
+        user_prompt = remove_bold_formatting(user_prompt)
+
+        system_prompt = SHORTEN_MARKDOWN_SYSTEM_PROMPT.strip()
+        chat_message_list = [
+            ChatMessage(
+                role=MessageRole.SYSTEM,
+                content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
+            )
+        ]
+        
+        logger.debug(f"User Prompt:\n{user_prompt}")
+
+        logger.debug("Starting LLM chat interaction.")
+        start_time = time.perf_counter()
+        chat_response = llm.chat(chat_message_list)
+        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}")
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        response_content = chat_response.message.content
+
+        start_delimiter = "[START_MARKDOWN]"
+        end_delimiter = "[END_MARKDOWN]"
+
+        start_index = response_content.find(start_delimiter)
+        end_index = response_content.find(end_delimiter)
+
+        if start_index != -1 and end_index != -1:
+            markdown_content = response_content[start_index + len(start_delimiter):end_index].strip()
+        else:
+            markdown_content = response_content  # Use the entire content if delimiters are missing
+            logger.warning("Output delimiters not found in LLM response.")
+
+        markdown_content = fix_bullet_lists(markdown_content)
+        markdown_content = remove_bold_formatting(markdown_content)
+
+        json_response = {}
+        json_response['response_content'] = response_content
+        json_response['markdown'] = markdown_content
+
+        result = ShortenMarkdown(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            markdown=markdown_content,
+            metadata=metadata,
+        )
+        logger.debug("ShortenMarkdown instance created successfully.")
+        return result    
+
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        d['markdown'] = self.markdown
+        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 save_raw(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.to_dict(), indent=2))
+
+    def save_markdown(self, file_path: str) -> None:
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.markdown)
+    
+if __name__ == "__main__":
+    from src.llm_factory import get_llm
+
+    # path = os.path.join(os.path.dirname(__file__), 'test_data', 'shorten_markdown1', 'currency_strategy.md')
+    # path = os.path.join(os.path.dirname(__file__), 'test_data', 'shorten_markdown1', 'identify_risks.md')
+    path = os.path.join(os.path.dirname(__file__), 'test_data', 'shorten_markdown1', 'physical_locations.md')
+    with open(path, 'r', encoding='utf-8') as f:
+        the_markdown = f.read()
+
+    model_name = "ollama-llama3.1"
+    # model_name = "ollama-qwen2.5-coder"
+    llm = get_llm(model_name)
+
+    query = the_markdown
+    input_bytes_count = len(query.encode('utf-8'))
+    print(f"Query: {query}")
+    result = ShortenMarkdown.execute(llm, query)
+
+    print("\nResponse:")
+    json_response = result.to_dict(include_system_prompt=False, include_user_prompt=False)
+    print(json.dumps(json_response, indent=2))
+
+    print(f"\n\nMarkdown:\n{result.markdown}")
+
+    output_bytes_count = len(result.markdown.encode('utf-8'))
+    print(f"\n\nInput bytes count: {input_bytes_count}")
+    print(f"Output bytes count: {output_bytes_count}")
+    bytes_saved = input_bytes_count - output_bytes_count
+    print(f"Bytes saved: {bytes_saved}")
+    print(f"Percentage saved: {bytes_saved / input_bytes_count * 100:.2f}%")
+

src/assume/test_data/shorten_markdown1/currency_strategy.md

@@ -0,0 +1,10 @@
+This plan involves money.
+
+## Currencies
+
+- **DKK:** The project is located in Denmark, so Danish Krone will be needed for local expenses, permits, and labor.
+- **EUR:** Denmark is part of Europe, and some transactions or equipment purchases might be denominated in Euros.
+
+**Primary currency:** DKK
+
+**Currency strategy:** Danish Krone will be used for all local transactions. For international transactions, it's advisable to monitor exchange rates between DKK and EUR to minimize currency risks.

src/assume/test_data/shorten_markdown1/identify_risks.md

@@ -0,0 +1,113 @@
+
+## Risk 1 - Regulatory & Permitting
+Delays in obtaining necessary permits and approvals from Danish authorities (e.g., environmental permits, building permits, grid connection permits). This could be due to complex regulations, public opposition, or administrative bottlenecks.
+
+**Impact:** A delay of 3-6 months in project commencement, potentially leading to increased costs due to inflation and contract renegotiations. Could also result in fines or legal challenges.
+
+**Likelihood:** Medium
+
+**Severity:** High
+
+**Action:** Engage with relevant authorities early in the project lifecycle to understand requirements and timelines. Conduct thorough environmental impact assessments. Develop a robust permitting strategy with contingency plans.
+
+## Risk 2 - Technical
+Unexpected technical challenges during installation or grid connection, such as soil instability, unforeseen geological conditions, or incompatibility with existing grid infrastructure. This includes the risk of panel degradation or underperformance due to local climate conditions.
+
+**Impact:** Increased construction costs by 10-20%, delays of 2-4 months, and potential reduction in energy output. Could also lead to equipment failures and increased maintenance costs.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Conduct thorough geotechnical surveys and grid compatibility studies before construction. Select high-quality solar panels suitable for the Danish climate. Implement robust quality control procedures during installation. Secure warranties and maintenance agreements with equipment suppliers.
+
+## Risk 3 - Financial
+Fluctuations in currency exchange rates (DKK/EUR) could increase the cost of imported equipment or services. Unexpected increases in material costs (e.g., solar panels, steel, aluminum) could also impact the project budget. Changes in government subsidies or tax incentives for renewable energy could affect project profitability.
+
+**Impact:** A cost overrun of 5-15% of the total project budget. Reduced return on investment. Project delays due to funding shortfalls.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Hedge currency risks through forward contracts or other financial instruments. Negotiate fixed-price contracts with suppliers. Monitor commodity prices and government policies closely. Secure financing with flexible terms to accommodate potential cost increases.
+
+## Risk 4 - Environmental
+Negative environmental impacts, such as habitat destruction, soil erosion, or water contamination during construction or operation. Public opposition due to concerns about visual impact or noise pollution.
+
+**Impact:** Project delays, increased costs for environmental mitigation measures, reputational damage, and potential legal challenges. Loss of biodiversity.
+
+**Likelihood:** Low
+
+**Severity:** Medium
+
+**Action:** Conduct thorough environmental impact assessments. Implement best practices for erosion control, waste management, and noise reduction. Engage with local communities to address concerns and mitigate visual impacts. Consider biodiversity offsets to compensate for habitat loss.
+
+## Risk 5 - Social
+Local opposition to the project due to concerns about land use, visual impact, or noise pollution. Lack of community support could lead to protests, legal challenges, and project delays.
+
+**Impact:** Project delays of 1-3 months, increased costs for community engagement and mitigation measures, reputational damage.
+
+**Likelihood:** Low
+
+**Severity:** Medium
+
+**Action:** Engage with local communities early in the project lifecycle. Address concerns and incorporate feedback into the project design. Offer community benefits, such as local employment opportunities or funding for community projects.
+
+## Risk 6 - Operational
+Equipment failures, grid outages, or cyberattacks could disrupt energy production and reduce revenue. Difficulty in securing qualified personnel for operation and maintenance.
+
+**Impact:** Reduced energy output, revenue losses, increased maintenance costs, and potential safety hazards.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Implement a robust maintenance program. Invest in cybersecurity measures to protect against cyberattacks. Develop a contingency plan for grid outages. Provide training and development opportunities for operational personnel.
+
+## Risk 7 - Supply Chain
+Disruptions in the supply chain for solar panels or other critical components due to geopolitical events, natural disasters, or manufacturing delays. Increased lead times for equipment delivery.
+
+**Impact:** Project delays of 2-4 months, increased costs for expedited shipping or alternative sourcing, potential equipment shortages.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Diversify suppliers and establish relationships with multiple vendors. Maintain a buffer stock of critical components. Monitor global supply chain conditions closely. Consider sourcing equipment from local or regional suppliers.
+
+## Risk 8 - Security
+Theft of equipment or vandalism could damage the solar farm and disrupt energy production. Physical security breaches could also pose a safety risk.
+
+**Impact:** Increased costs for security measures, project delays, and potential safety hazards.
+
+**Likelihood:** Low
+
+**Severity:** Low
+
+**Action:** Implement physical security measures, such as fencing, security cameras, and alarm systems. Conduct background checks on employees and contractors. Coordinate with local law enforcement agencies.
+
+## Risk 9 - Integration with Existing Infrastructure
+Challenges in integrating the solar farm with the existing power grid, potentially leading to grid instability or curtailment of energy production. Insufficient grid capacity to accommodate the solar farm's output.
+
+**Impact:** Reduced energy output, revenue losses, and potential grid instability.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Conduct thorough grid impact studies. Coordinate with the grid operator to ensure sufficient grid capacity and stability. Invest in grid upgrades if necessary.
+
+## Risk 10 - Long-Term Sustainability
+Uncertainty regarding the long-term performance and degradation of solar panels. Difficulty in decommissioning the solar farm at the end of its lifespan. Lack of a clear plan for recycling or disposal of solar panels.
+
+**Impact:** Reduced energy output over time, increased maintenance costs, and environmental liabilities at the end of the project's lifespan.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Select high-quality solar panels with long-term warranties. Develop a decommissioning plan that includes recycling or disposal of solar panels. Explore options for extending the lifespan of the solar farm through repowering or refurbishment.
+
+## Risk summary
+The most critical risks for this solar farm project in Denmark are related to Regulatory & Permitting, Technical challenges during installation and grid connection, and Financial risks associated with currency fluctuations and material costs. Delays in permitting can significantly impact the project timeline and budget. Technical issues can lead to increased costs and reduced energy output. Financial risks can erode project profitability. Effective mitigation strategies should focus on proactive engagement with authorities, thorough technical assessments, and robust financial planning.

src/assume/test_data/shorten_markdown1/physical_locations.md

@@ -0,0 +1,39 @@
+This plan implies one or more physical locations.
+
+## Requirements for physical locations
+
+- High solar irradiance
+- Flat land
+- Proximity to grid connection
+- Minimal environmental impact
+- Suitable zoning and permits
+
+## Location 1
+Denmark
+
+West Jutland
+
+Near Varde
+
+**Rationale**: West Jutland offers large open areas with relatively high solar irradiance compared to other parts of Denmark. The area near Varde has existing grid infrastructure and relatively flat terrain, making it suitable for a solar farm.
+
+## Location 2
+Denmark
+
+South Jutland
+
+Near Tønder
+
+**Rationale**: South Jutland also has favorable conditions for solar energy production. The area near Tønder has available land and is close to existing high-voltage power lines, which can reduce connection costs.
+
+## Location 3
+Denmark
+
+Zealand
+
+Near Holbæk
+
+**Rationale**: Zealand, particularly the area near Holbæk, offers a balance of available land and proximity to major population centers, potentially reducing transmission losses and increasing the value of the generated electricity. It also benefits from good infrastructure.
+
+## Location Summary
+The suggested locations in West Jutland (near Varde), South Jutland (near Tønder), and Zealand (near Holbæk) are all suitable for establishing a solar farm in Denmark due to their high solar irradiance, availability of flat land, proximity to grid connections, and other favorable conditions.

src/llm_factory.py

@@ -1,10 +1,12 @@
 import logging
 import os
 import json
+from enum import Enum
 from dataclasses import dataclass
 from dotenv import dotenv_values
 from typing import Optional, Any, Dict
 from llama_index.core.llms.llm import LLM
+from llama_index.llms.mistralai import MistralAI
 from llama_index.llms.ollama import Ollama
 from llama_index.llms.openai_like import OpenAILike
 from llama_index.llms.openai import OpenAI
@@ -68,6 +70,13 @@ def substitute_env_vars(config: Dict[str, Any], env_vars: Dict[str, str]) -> Dic
 
     return process_item(config)
 
+class OllamaStatus(str, Enum):
+    no_ollama_models = 'no ollama models in the llm_config.json file'
+    ollama_not_running = 'ollama is NOT running'
+    mixed = 'Mixed. Some ollama models are running, but some are NOT running.'
+    ollama_running = 'Ollama is running'
+
+
 @dataclass
 class LLMConfigItem:
     id: str
@@ -76,7 +85,7 @@ class LLMConfigItem:
 @dataclass
 class LLMInfo:
     llm_config_items: list[LLMConfigItem]
-    is_ollama_running: bool
+    ollama_status: OllamaStatus
     error_message_list: list[str]
 
     @classmethod
@@ -84,16 +93,41 @@ class LLMInfo:
         """
         Returns a list of available LLM names.
         """
+
+        # Probe each Ollama service endpoint just once.
         error_message_list = []
-        ollama_info = OllamaInfo.obtain_info()
-        if ollama_info.is_running == False:
-            print(f"Ollama is not running. Please start the Ollama service, in order to use the models via Ollama.")
-        elif ollama_info.error_message:
-            print(f"Error message: {ollama_info.error_message}")
-            error_message_list.append(ollama_info.error_message)
+        ollama_info_per_host = {}
+        count_running = 0
+        count_not_running = 0
+        for config_id, config in _llm_configs.items():
+            if config.get("class") != "Ollama":
+                continue
+            arguments = config.get("arguments", {})
+            model = arguments.get("model", None)
+            base_url = arguments.get("base_url", None)
 
-        llm_config_items = []
+            if base_url in ollama_info_per_host:
+                # Already got info for this host. No need to get it again.
+                continue
 
+            ollama_info = OllamaInfo.obtain_info(base_url=base_url)
+            ollama_info_per_host[base_url] = ollama_info
+
+            running_on = "localhost" if base_url is None else base_url
+
+            if ollama_info.is_running:
+                count_running += 1
+            else:
+                count_not_running += 1
+
+            if ollama_info.is_running == False:
+                print(f"Ollama is not running on {running_on}. Please start the Ollama service, in order to use the models via Ollama.")
+            elif ollama_info.error_message:
+                print(f"Error message: {ollama_info.error_message}")
+                error_message_list.append(ollama_info.error_message)
+
+        # Get info about the each LLM config item that is using Ollama.
+        llm_config_items = []
         for config_id, config in _llm_configs.items():
             if config.get("class") != "Ollama":
                 item = LLMConfigItem(id=config_id, label=config_id)
@@ -101,6 +135,9 @@ class LLMInfo:
                 continue
             arguments = config.get("arguments", {})
             model = arguments.get("model", None)
+            base_url = arguments.get("base_url", None)
+
+            ollama_info = ollama_info_per_host[base_url]
 
             is_model_available = ollama_info.is_model_available(model)
             if is_model_available:
@@ -115,9 +152,18 @@ class LLMInfo:
             item = LLMConfigItem(id=config_id, label=label)
             llm_config_items.append(item)
 
+        if count_not_running == 0 and count_running > 0:
+            ollama_status = OllamaStatus.ollama_running
+        elif count_not_running > 0 and count_running == 0:
+            ollama_status = OllamaStatus.ollama_not_running
+        elif count_not_running > 0 and count_running > 0:
+            ollama_status = OllamaStatus.mixed
+        else:
+            ollama_status = OllamaStatus.no_ollama_models
+
         return LLMInfo(
             llm_config_items=llm_config_items, 
-            is_ollama_running=ollama_info.is_running,
+            ollama_status=ollama_status,
             error_message_list=error_message_list,
         )
 

src/llm_util/ollama_info.py

@@ -15,20 +15,21 @@ class OllamaInfo:
     error_message: Optional[str] = None
 
     @classmethod
-    def obtain_info(cls) -> 'OllamaInfo':
+    def obtain_info(cls, base_url: Optional[str] = None) -> 'OllamaInfo':
         """Retrieves information about the Ollama service."""
         try:
             # Only import ollama if it's available
-            from ollama import ListResponse, list
-            list_response: ListResponse = list()
+            from ollama import ListResponse, Client
+            client = Client(host=base_url, timeout=5)
+            list_response: ListResponse = client.list()
         except ImportError as e:
-            error_message = f"OllamaInfo. The 'ollama' library was not found: {e}"
+            error_message = f"OllamaInfo base_url={base_url}. The 'ollama' library was not found: {e}"
             return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
         except ConnectionError as e:
-            error_message = f"OllamaInfo. Error connecting to Ollama: {e}"
+            error_message = f"OllamaInfo base_url={base_url}. Error connecting to Ollama: {e}"
             return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
         except Exception as e:
-            error_message = f"OllamaInfo. An unexpected error occurred: {e}"
+            error_message = f"OllamaInfo base_url={base_url}. An unexpected error occurred: {e}"
             return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
 
         model_names = [model.model for model in list_response.models]
@@ -56,7 +57,13 @@ class OllamaInfo:
 
 if __name__ == '__main__':
     find_model = 'qwen2.5-coder:latest'
-    ollama_info = OllamaInfo.obtain_info()
+    base_url = None
+    # base_url = "localhost:11434"
+    # base_url = "example.com:11434"
+
+    print(f"find_model: {find_model}")
+    print(f"base_url: {base_url}")
+    ollama_info = OllamaInfo.obtain_info(base_url=base_url)
     print(f"Error message: {ollama_info.error_message}")
     print(f'Is Ollama running: {ollama_info.is_running}')
     found = ollama_info.is_model_available(find_model)

src/markdown_util/remove_bold_formatting.py

@@ -0,0 +1,11 @@
+import re
+
+def remove_bold_formatting(text: str) -> str:
+    """
+    Remove bold formatting from the text.
+
+    When processing long texts with LLMs, the token count is a limiting factor.
+    This function removes the bold formatting from the text to reduce the token count.
+    """
+    text = re.sub(r'\*\*([^*]+)\*\*', r'\1', text)
+    return re.sub(r'__([^_]+?)__', r'\1', text)

src/markdown_util/tests/test_remove_bold_formatting.py

@@ -0,0 +1,13 @@
+import unittest
+from src.markdown_util.remove_bold_formatting import remove_bold_formatting
+
+class TestRemoveBoldFormatting(unittest.TestCase):
+    def test_remove_bold_formatting1(self):
+        text = "**Hello** __World__"
+        expected = "Hello World"
+        self.assertEqual(remove_bold_formatting(text), expected)
+
+    def test_remove_bold_formatting2(self):
+        text = "**Hello** 123 World**"
+        expected = "Hello 123 World**"
+        self.assertEqual(remove_bold_formatting(text), expected)

src/plan/app_text2plan.py

@@ -15,7 +15,7 @@ import logging
 import json
 from dataclasses import dataclass
 from math import ceil
-from src.llm_factory import LLMInfo
+from src.llm_factory import LLMInfo, OllamaStatus
 from src.plan.generate_run_id import generate_run_id, RUN_ID_PREFIX
 from src.plan.create_zip_archive import create_zip_archive
 from src.plan.filenames import FilenameEnum
@@ -107,7 +107,7 @@ for prompt_item in all_prompts:
     gradio_examples.append([prompt_item.prompt])
 
 llm_info = LLMInfo.obtain_info()
-logger.info(f"LLMInfo.is_ollama_running: {llm_info.is_ollama_running}")
+logger.info(f"LLMInfo.ollama_status: {llm_info.ollama_status.value}")
 logger.info(f"LLMInfo.error_message_list: {llm_info.error_message_list}")
 
 trimmed_llm_config_items = []
@@ -478,8 +478,10 @@ with gr.Blocks(title="PlanExe") as demo_text2plan:
 
     with gr.Tab("Settings"):
         if CONFIG.visible_llm_info:
-            if llm_info.is_ollama_running == False:
+            if llm_info.ollama_status == OllamaStatus.ollama_not_running:
                 gr.Markdown("**Ollama is not running**, so Ollama models are unavailable. Please start Ollama to use them.")
+            elif llm_info.ollama_status == OllamaStatus.mixed:
+                gr.Markdown("**Mixed. Some Ollama models are running, but some are NOT running.**, You may have to start the ones that aren't running.")
 
             if len(llm_info.error_message_list) > 0:
                 gr.Markdown("**Error messages:**")

src/plan/data/simple_plan_prompts.jsonl

@@ -1,3 +1,5 @@
+{"id": "3ca89453-e65b-4828-994f-dff0b679444a", "prompt": "It's 2025 and humanoid robots are entering mainstream society, with China already showcasing robotic athletes in sports events. Plan a 2026 Robot Olympics, outline innovative events, rules, and challenges to test the humanoid robots.", "tags": ["robots", "sport", "olympics"]}
+{"id": "fc0f0be2-125d-42dd-aac3-2e5039fc7938", "prompt": "Make a 64bit x86 OS in Rust. Linux-like but not POSIX-compliant. Monolithic kernel, memory management, process scheduler, shell, utils (ls, cat, rm, mkdir, mv, rmdir, ps). Basic drivers for console, disk, and virtio-net, and include enough network stack do a ping. This is my hobby project for testing LLM coding skills.", "tags": ["OS", "operating system", "linux", "rust"]}
 {"id": "f847a181-c9b8-419f-8aef-552e1a3b662f", "prompt": "Distill Arxiv papers into an objective, hype-free summary that indicates whether improvements are truly significant or just noise. Compare claims with benchmarks, flag inflated gains, and foster a clear, evidence-based understanding of machine learning progress without marketing language. To make the distilled data available with minimal upkeep and maximum longevity, publish these summaries as an open-access dataset on a well-established repository.", "tags": ["Arxiv", "paper", "dataset", "signal", "noise"]}
 {"id": "fdbac6bc-6853-47f3-b7ec-bc0051314952", "prompt": "I'm envisioning a streamlined global language—free of archaic features like gendered terms and excessive suffixes, taking cues from LLM tokenization. Some regions might only choose to adopt certain parts of this modern language. Would humanity ultimately benefit more from preserving many distinct languages, or uniting around a single, optimized one?", "tags": ["language", "tokenization"]}
 {"id": "762b64e2-5ac8-4684-807a-efd3e81d6bc1", "prompt": "Create a detailed report examining the current situation of microplastics within the world's oceans.", "tags": ["ocean", "microplastics", "climate change", "sustainability"]}

src/plan/executive_summary.py

@@ -0,0 +1,226 @@
+"""
+One-pager that summarizes the plan.
+
+https://en.wikipedia.org/wiki/Executive_summary
+
+- The executive summary should always be placed at the beginning of the report.
+- It's designed to be read first. Its purpose is to provide a high-level overview of the report's contents so that readers can quickly understand the key findings and recommendations.
+- It helps readers decide how to engage with the rest of the report. Knowing the key takeaways upfront allows readers to prioritize which sections they need to read in detail.
+- It provides context for the rest of the report. Having a clear understanding of the report's purpose and main findings makes it easier to interpret the details presented in the body of the report.
+
+The primary target audience for the executive summary is senior management, executives, investors, and other key decision-makers. These individuals typically have limited time and need to quickly understand the most important information in the report.
+
+I have removed the "high-level approach" section, because the "executive summary" is generated from all the PlanExe documents.
+It makes no sense to write that it's based on a SWOT analysis and expert interviews, 
+since these documents are already in the PlanExe pipeline. No plan could be created without them.
+
+PROMPT> python -m src.plan.executive_summary
+"""
+import os
+import json
+import time
+import logging
+from math import ceil
+from typing import Optional
+from dataclasses import dataclass
+from llama_index.core.llms.llm import LLM
+from pydantic import BaseModel, Field
+from llama_index.core.llms import ChatMessage, MessageRole
+from src.markdown_util.fix_bullet_lists import fix_bullet_lists
+
+logger = logging.getLogger(__name__)
+
+class DocumentDetails(BaseModel):
+    audience_tailoring: str = Field(
+        description="Adapt the tone and detail based on who will be reading this summary (individual hobbyist, corporate, government, etc.)."
+    )
+    focus_and_context: str = Field(
+        description="A short statement about why this project or plan exists and its overall objectives."
+    )
+    purpose_and_goals: str = Field(
+        description="A crisp statement of the project's main goals and success criteria."
+    )
+    key_deliverables_and_outcomes: str = Field(
+        description="Bulleted summary of the expected end-products or results from the plan."
+    )
+    timeline_and_budget: str = Field(
+        description="A short estimate of time and top-level budget"
+    )
+    risks_and_mitigations: str = Field(
+        description="Identify 1-2 major risks and how you plan to reduce or address them."
+    )
+    action_orientation: str = Field(
+        description="Explain the immediate actions or next steps needed to move forward. Summarize who, what, and when."
+    )
+    overall_takeaway: str = Field(
+        description="A final, concise statement emphasizing the main point or value of the plan (e.g., expected benefits, ROI, key success metric)."
+    )
+    feedback: str = Field(
+        description="Suggestions for how to strengthen the executive summary by adding more evidence or improving persuasiveness."
+    )
+
+EXECUTIVE_SUMMARY_SYSTEM_PROMPT = """
+You are a seasoned expert in crafting concise, high-impact executive summaries for any type of plan—from personal projects (such as weight loss or learning a musical instrument) to large-scale business initiatives. Your task is to generate a complete executive summary as a valid JSON object that strictly adheres to the schema below. Do not include any extra text, markdown formatting, or additional keys.
+
+The JSON object must include exactly the following keys:
+
+{
+  "audience_tailoring": string,
+  "focus_and_context": string,
+  "purpose_and_goals": string,
+  "key_deliverables_and_outcomes": string,
+  "timeline_and_budget": string,
+  "risks_and_mitigations": string,
+  "action_orientation": string,
+  "overall_takeaway": string,
+  "feedback": string
+}
+
+Instructions for each key:
+- audience_tailoring: Describe how the tone and details are tailored for the intended audience (e.g., an individual with personal goals or senior management for a business plan).
+- focus_and_context: Provide a succinct overview of why the plan exists and its overall objectives. Begin with a compelling hook—a visionary statement, provocative question, or striking statistic—to immediately capture the decision-maker's attention.
+- purpose_and_goals: Clearly state the main objectives and success criteria.
+- key_deliverables_and_outcomes: Summarize the primary deliverables, milestones, or outcomes expected.
+- timeline_and_budget: Provide a brief estimate of the timeframe and any associated costs or resource needs. For personal plans, note if costs are minimal or not applicable.
+- risks_and_mitigations: Identify one or two significant risks and outline strategies to mitigate them.
+- action_orientation: Detail the immediate next steps or actions required, including responsibilities and timelines if relevant.
+- overall_takeaway: Conclude with a clear, concise statement emphasizing the plan’s overall value or expected benefits.
+- feedback: Offer multiple constructive suggestions to enhance the summary’s clarity, persuasiveness, or completeness—such as additional data points or more detailed analysis.
+
+Output Requirements:
+- Your entire response must be a valid JSON object conforming exactly to the schema above.
+- Use clear, concise, and professional language appropriate for the context of the plan.
+- Do not include any extra text or formatting outside the JSON structure.
+
+Remember: Your output must be valid JSON and nothing else.
+"""
+
+@dataclass
+class ExecutiveSummary:
+    system_prompt: Optional[str]
+    user_prompt: str
+    response: str
+    markdown: str
+    metadata: dict
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'ExecutiveSummary':
+        """
+        Invoke LLM with a long markdown document that needs an executive summary.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+        
+        system_prompt = EXECUTIVE_SUMMARY_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
+
+        markdown = cls.convert_to_markdown(chat_response.raw)
+
+        result = ExecutiveSummary(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            markdown=markdown,
+            metadata=metadata,
+        )
+        logger.debug("ExecutiveSummary instance created successfully.")
+        return result    
+
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        d['markdown'] = self.markdown
+        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 save_raw(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.to_dict(), indent=2))
+
+    @staticmethod
+    def convert_to_markdown(document_details: DocumentDetails) -> str:
+        """
+        Convert the raw document details to markdown.
+        """
+        rows = []
+        rows.append(f"## Focus and Context\n{document_details.focus_and_context}")
+        rows.append(f"\n## Purpose and Goals\n{document_details.purpose_and_goals}")
+        rows.append(f"\n## Key Deliverables and Outcomes\n{document_details.key_deliverables_and_outcomes}")
+        rows.append(f"\n## Timeline and Budget\n{document_details.timeline_and_budget}")
+        rows.append(f"\n## Risks and Mitigations\n{document_details.risks_and_mitigations}")
+        rows.append(f"\n## Audience Tailoring\n{document_details.audience_tailoring}")
+        rows.append(f"\n## Action Orientation\n{document_details.action_orientation}")
+        rows.append(f"\n## Overall Takeaway\n{document_details.overall_takeaway}")
+        rows.append(f"\n## Feedback\n{document_details.feedback}")
+        markdown = "\n".join(rows)
+        markdown = fix_bullet_lists(markdown)
+        return markdown
+
+    def save_markdown(self, output_file_path: str):
+        with open(output_file_path, 'w', encoding='utf-8') as out_f:
+            out_f.write(self.markdown)
+    
+if __name__ == "__main__":
+    from src.llm_factory import get_llm
+
+    path = os.path.join(os.path.dirname(__file__), 'test_data', 'solarfarm_consolidate_assumptions_short.md')
+    with open(path, 'r', encoding='utf-8') as f:
+        the_markdown = f.read()
+
+    model_name = "ollama-llama3.1"
+    llm = get_llm(model_name)
+
+    query = the_markdown
+    input_bytes_count = len(query.encode('utf-8'))
+    print(f"Query: {query}")
+    result = ExecutiveSummary.execute(llm, query)
+
+    print("\nResponse:")
+    json_response = result.to_dict(include_system_prompt=False, include_user_prompt=False)
+    print(json.dumps(json_response, indent=2))
+
+    print(f"\n\nMarkdown:\n{result.markdown}")
+
+    output_bytes_count = len(result.markdown.encode('utf-8'))
+    print(f"\n\nInput bytes count: {input_bytes_count}")
+    print(f"Output bytes count: {output_bytes_count}")
+    bytes_saved = input_bytes_count - output_bytes_count
+    print(f"Bytes saved: {bytes_saved}")
+    print(f"Percentage saved: {bytes_saved / input_bytes_count * 100:.2f}%")
+

src/plan/filenames.py

@@ -17,10 +17,14 @@ class FilenameEnum(str, Enum):
     DISTILL_ASSUMPTIONS_MARKDOWN = "003-7-distill_assumptions.md"
     REVIEW_ASSUMPTIONS_RAW = "003-8-review_assumptions_raw.json"
     REVIEW_ASSUMPTIONS_MARKDOWN = "003-9-review_assumptions.md"
-    CONSOLIDATE_ASSUMPTIONS_MARKDOWN = "003-10-consolidate_assumptions.md"
+    CONSOLIDATE_ASSUMPTIONS_FULL_MARKDOWN = "003-10-consolidate_assumptions_full.md"
+    CONSOLIDATE_ASSUMPTIONS_SHORT_MARKDOWN = "003-11-consolidate_assumptions_short.md"
     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"
+    PROJECT_PLAN_RAW = "005-1-project_plan_raw.json"
+    PROJECT_PLAN_MARKDOWN = "005-2-project_plan.md"
+    RELATED_RESOURCES_RAW = "005-3-related_resources_raw.json"
+    RELATED_RESOURCES_MARKDOWN = "005-4-related_resources.md"
     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"
@@ -52,5 +56,9 @@ class FilenameEnum(str, Enum):
     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"
+    REVIEW_PLAN_RAW = "022-1-review_plan_raw.json"
+    REVIEW_PLAN_MARKDOWN = "022-2-review_plan.md"
+    EXECUTIVE_SUMMARY_RAW = "023-1-executive_summary_raw.json"
+    EXECUTIVE_SUMMARY_MARKDOWN = "023-2-executive_summary.md"
+    REPORT = "024-report.html"
     PIPELINE_COMPLETE = "999-pipeline_complete.txt"

src/plan/{create_project_plan.py → project_plan.py}

@@ -1,11 +1,12 @@
 """
-PROMPT> python -m src.plan.create_project_plan
+PROMPT> python -m src.plan.project_plan
 
 Based on a vague description, the creates a rough draft for a project plan.
 """
 import json
 import time
 import logging
+from dataclasses import dataclass
 from math import ceil
 from typing import List, Optional, Any, Type, TypeVar
 from dataclasses import dataclass
@@ -113,7 +114,7 @@ class GoalDefinition(BaseModel):
         description="Ensure compliance with all regulatory and legal requirements, including permits, licenses, and industry-specific standards."
     )
 
-CREATE_PROJECT_PLAN_SYSTEM_PROMPT_1 = """
+PROJECT_PLAN_SYSTEM_PROMPT_1 = """
 You are an expert project planner tasked with creating comprehensive and detailed project plans based on user-provided descriptions. Your output must be a complete JSON object conforming to the provided GoalDefinition schema. Focus on being specific and actionable, generating a plan that is realistic and useful for guiding project development.
 Your plans must include:
 - A clear goal statement adhering to the SMART criteria (Specific, Measurable, Achievable, Relevant, Time-bound). Provide specific metrics and timeframes where possible.
@@ -126,7 +127,7 @@ Your plans must include:
 Prioritize feasibility, practicality, and alignment with the user-provided description. Ensure the plan is actionable, with concrete steps where possible and measurable outcomes.
 """
 
-CREATE_PROJECT_PLAN_SYSTEM_PROMPT_2 = """
+PROJECT_PLAN_SYSTEM_PROMPT_2 = """
 You are an expert project planner tasked with creating comprehensive and detailed project plans based on user-provided descriptions. Your output must be a complete JSON object conforming to the provided GoalDefinition schema. Focus on being specific and actionable, generating a plan that is realistic and useful for guiding project development.
 
 Your plans must include:
@@ -148,7 +149,7 @@ Your plans must include:
 Prioritize feasibility, practicality, and alignment with the user-provided description. Ensure the plan is actionable, with concrete steps where possible and measurable outcomes.
 """
 
-CREATE_PROJECT_PLAN_SYSTEM_PROMPT_3 = """
+PROJECT_PLAN_SYSTEM_PROMPT_3 = """
 You are an expert project planner tasked with creating comprehensive and detailed project plans based on user-provided descriptions. Your output must be a complete JSON object conforming to the provided GoalDefinition schema. Focus on being specific and actionable, generating a plan that is realistic and useful for guiding project development.
 
 Your plans must include:
@@ -196,12 +197,12 @@ Here's an example of the expected output format for a simple project:
 }
 """
 
-CREATE_PROJECT_PLAN_SYSTEM_PROMPT = CREATE_PROJECT_PLAN_SYSTEM_PROMPT_3
+PROJECT_PLAN_SYSTEM_PROMPT = PROJECT_PLAN_SYSTEM_PROMPT_3
 
 T = TypeVar('T', bound=BaseModel)
 
 @dataclass
-class CreateProjectPlan:
+class ProjectPlan:
     """
     Creating a project plan from a vague description.
     """
@@ -209,9 +210,10 @@ class CreateProjectPlan:
     user_prompt: str
     response: dict
     metadata: dict
+    markdown: str
 
     @classmethod
-    def execute(cls, llm: LLM, user_prompt: str) -> 'CreateProjectPlan':
+    def execute(cls, llm: LLM, user_prompt: str) -> 'ProjectPlan':
         """
         Invoke LLM to create project plan from a vague description.
 
@@ -224,7 +226,7 @@ class CreateProjectPlan:
         if not isinstance(user_prompt, str):
             raise ValueError("Invalid user_prompt.")
 
-        system_prompt = CREATE_PROJECT_PLAN_SYSTEM_PROMPT.strip()
+        system_prompt = PROJECT_PLAN_SYSTEM_PROMPT.strip()
         logger.debug(f"System Prompt:\n{system_prompt}")
         logger.debug(f"User Prompt:\n{user_prompt}")
 
@@ -262,11 +264,14 @@ class CreateProjectPlan:
         metadata["duration"] = duration
         metadata["response_byte_count"] = response_byte_count
 
-        result = CreateProjectPlan(
+        markdown = cls.convert_to_markdown(chat_response.raw)
+
+        result = ProjectPlan(
             system_prompt=system_prompt,
             user_prompt=user_prompt,
             response=json_response,
-            metadata=metadata
+            metadata=metadata,
+            markdown=markdown
         )
         logger.debug("CreateProjectPlan instance created successfully.")
         return result
@@ -281,11 +286,92 @@ class CreateProjectPlan:
             d['system_prompt'] = self.system_prompt
         return d
 
-    def save(self, file_path: str) -> None:
+    def save_raw(self, file_path: str) -> None:
         d = self.to_dict()
         with open(file_path, 'w') as f:
             f.write(json.dumps(d, indent=2))
 
+    @staticmethod
+    def convert_to_markdown(document_details: GoalDefinition) -> str:
+        """
+        Convert the raw document details to markdown.
+        """
+        rows = []
+
+        rows.append(f"**Goal Statement:** {document_details.goal_statement}")
+
+        rows.append("\n## SMART Criteria\n")
+        rows.append(f"- **Specific:** {document_details.smart_criteria.specific}")
+        rows.append(f"- **Measurable:** {document_details.smart_criteria.measurable}")
+        rows.append(f"- **Achievable:** {document_details.smart_criteria.achievable}")
+        rows.append(f"- **Relevant:** {document_details.smart_criteria.relevant}")
+        rows.append(f"- **Time-bound:** {document_details.smart_criteria.time_bound}")
+
+        rows.append("\n## Dependencies\n")
+        for dep in document_details.dependencies:
+            rows.append(f"- {dep}")
+
+        rows.append("\n## Resources Required\n")
+        for resource in document_details.resources_required:
+            rows.append(f"- {resource}")
+
+        rows.append("\n## Related Goals\n")
+        for goal in document_details.related_goals:
+            rows.append(f"- {goal}")
+
+        rows.append("\n## Tags\n")
+        for tag in document_details.tags:
+            rows.append(f"- {tag}")
+
+        rows.append("\n## Risk Assessment and Mitigation Strategies\n")
+        rows.append("\n### Key Risks\n")
+        for risk in document_details.risk_assessment_and_mitigation_strategies.key_risks:
+            rows.append(f"- {risk}")
+
+        rows.append("\n### Diverse Risks\n")
+        for risk in document_details.risk_assessment_and_mitigation_strategies.diverse_risks:
+            rows.append(f"- {risk}")
+
+        rows.append("\n### Mitigation Plans\n")
+        for plan in document_details.risk_assessment_and_mitigation_strategies.mitigation_plans:
+            rows.append(f"- {plan}")
+
+        rows.append("\n## Stakeholder Analysis\n")
+        rows.append("\n### Primary Stakeholders\n")
+        for stakeholder in document_details.stakeholder_analysis.primary_stakeholders:
+            rows.append(f"- {stakeholder}")
+
+        rows.append("\n### Secondary Stakeholders\n")
+        for stakeholder in document_details.stakeholder_analysis.secondary_stakeholders:
+            rows.append(f"- {stakeholder}")
+
+        rows.append("\n### Engagement Strategies\n")
+        for strategy in document_details.stakeholder_analysis.engagement_strategies:
+            rows.append(f"- {strategy}")
+
+        rows.append("\n## Regulatory and Compliance Requirements\n")
+        rows.append("\n### Permits and Licenses\n")
+        for permit in document_details.regulatory_and_compliance_requirements.permits_and_licenses:
+            rows.append(f"- {permit}")
+
+        rows.append("\n### Compliance Standards\n")
+        for standard in document_details.regulatory_and_compliance_requirements.compliance_standards:
+            rows.append(f"- {standard}")
+
+        rows.append("\n### Regulatory Bodies\n")
+        for body in document_details.regulatory_and_compliance_requirements.regulatory_bodies:
+            rows.append(f"- {body}")
+
+        rows.append("\n### Compliance Actions\n")
+        for action in document_details.regulatory_and_compliance_requirements.compliance_actions:
+            rows.append(f"- {action}")
+
+        return "\n".join(rows)
+
+    def save_markdown(self, output_file_path: str):
+        with open(output_file_path, 'w', encoding='utf-8') as out_f:
+            out_f.write(self.markdown)
+
 if __name__ == "__main__":
     import logging
     from src.llm_factory import get_llm
@@ -306,6 +392,9 @@ if __name__ == "__main__":
     # llm = get_llm("deepseek-chat")
 
     print(f"Query:\n{plan_prompt}\n\n")
-    result = CreateProjectPlan.execute(llm, plan_prompt)
+    result = ProjectPlan.execute(llm, plan_prompt)
     json_response = result.to_dict(include_system_prompt=False, include_user_prompt=False)
+    print("\n\nResponse:")
     print(json.dumps(json_response, indent=2))
+
+    print(f"\n\nMarkdown:\n{result.markdown}")

src/plan/related_resources.py

@@ -0,0 +1,214 @@
+"""
+Suggest similar past or existing projects that can be used as a reference for the current project.
+
+PROMPT> python -m src.plan.related_resources
+"""
+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
+
+logger = logging.getLogger(__name__)
+
+class SuggestionItem(BaseModel):
+    item_index: int = Field(
+        description="Enumeration, starting from 1."
+    )
+    project_name: str = Field(
+        description="The name of the project."
+    )
+    project_description: str = Field(
+        description="A description of the project."
+    )
+    success_metrics: list[str] = Field(
+        description="Indicators of success, challenges encountered, and project outcomes."
+    )
+    risks_and_challenges_faced: list[str] = Field(
+        description="Explain how each project overcame or mitigated these challenges to provide practical guidance."
+    )
+    where_to_find_more_information: list[str] = Field(
+        description="Links to online resources, articles, official documents, or industry reports where more information can be found."
+    )
+    actionable_steps: list[str] = Field(
+        description="Clear instructions on how the user might directly contact key individuals or organizations from those projects, if they desire deeper insights."
+    )
+    rationale_for_suggestion: str = Field(
+        description="Explain why this particular project is suggested."
+    )
+
+class DocumentDetails(BaseModel):
+    suggestion_list: list[SuggestionItem] = Field(
+        description="List of suggestions."
+    )
+    summary: str = Field(
+        description="Providing a high level context."
+    )
+
+RELATED_RESOURCES_SYSTEM_PROMPT = """
+You are an expert project analyst tasked with recommending highly relevant past or existing projects as references for a user's described project.
+
+Your goal is to always provide at least **three detailed and insightful recommendations**, strictly adhering to the following guidelines:
+
+- **Primary Suggestions (at least 2):**
+  - Must be **real and verifiable past or existing projects**—no hypothetical, fictional, or speculative examples.
+  - Include exhaustive detail:
+    - **Project Name:** Clearly state the official name.
+    - **Project Description:** Concise yet comprehensive description of objectives, scale, timeline, industry, location, and outcomes.
+    - **Rationale for Suggestion:** Explicitly highlight similarities in technology, objectives, operational processes, geographical, economic, or cultural aspects.
+    - **Risks and Challenges Faced:** Explicitly list major challenges and clearly explain how each was overcome or mitigated.
+    - **Success Metrics:** Measurable outcomes such as economic impact, production volume, customer satisfaction, timeline adherence, or technology breakthroughs.
+    - **Where to Find More Information:** Direct and authoritative links (official websites, reputable publications, scholarly articles).
+    - **Actionable Steps:** Clearly specify roles, names, and robust communication channels (emails, LinkedIn, organizational contacts).
+
+- **Secondary Suggestions (optional but encouraged, at least 1):**
+  - Must also be real projects but may contain fewer details.
+  - Mark explicitly as secondary suggestions.
+
+**Priority for Relevance:**
+- Emphasize geographical or cultural proximity first, but clearly justify including geographically distant examples if necessary.
+- If geographically or culturally similar projects are limited, explicitly state this in the rationale.
+
+**Important:** Avoid any hypothetical, speculative, or fictional suggestions. Only include real, documented projects.
+
+Your recommendations should collectively provide the user with robust insights, actionable guidance, and practical contacts for successful execution.
+"""
+
+@dataclass
+class RelatedResources:
+    """
+    Identify similar past or existing projects that can be used as a reference for the current project.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    markdown: str
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'RelatedResources':
+        """
+        Invoke LLM with the project description.
+        """
+        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 = RELATED_RESOURCES_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
+
+        markdown = cls.convert_to_markdown(chat_response.raw)
+
+        result = RelatedResources(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+            markdown=markdown
+        )
+        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 save_raw(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.to_dict(), indent=2))
+
+    @staticmethod
+    def convert_to_markdown(document_details: DocumentDetails) -> str:
+        """
+        Convert the raw document details to markdown.
+        """
+        rows = []
+
+        for item_index, suggestion in enumerate(document_details.suggestion_list, start=1):
+            rows.append(f"## Suggestion {item_index} - {suggestion.project_name}\n")
+            rows.append(suggestion.project_description)
+
+            success_metrics = "\n".join(suggestion.success_metrics)
+            rows.append(f"\n### Success Metrics\n\n{success_metrics}")
+
+            risks_and_challenges_faced = "\n".join(suggestion.risks_and_challenges_faced)
+            rows.append(f"\n### Risks and Challenges Faced\n\n{risks_and_challenges_faced}")
+
+            where_to_find_more_information = "\n".join(suggestion.where_to_find_more_information)
+            rows.append(f"\n### Where to Find More Information\n\n{where_to_find_more_information}")
+
+            actionable_steps = "\n".join(suggestion.actionable_steps)
+            rows.append(f"\n### Actionable Steps\n\n{actionable_steps}")
+
+            rows.append(f"\n### Rationale for Suggestion\n\n{suggestion.rationale_for_suggestion}")
+
+        rows.append(f"\n## Summary\n\n{document_details.summary}")
+        return "\n".join(rows)
+
+    def save_markdown(self, output_file_path: str):
+        with open(output_file_path, 'w', encoding='utf-8') as out_f:
+            out_f.write(self.markdown)
+
+if __name__ == "__main__":
+    from src.llm_factory import get_llm
+    from src.plan.find_plan_prompt import find_plan_prompt
+
+    llm = get_llm("ollama-llama3.1")
+
+    plan_prompt = find_plan_prompt("de626417-4871-4acc-899d-2c41fd148807")
+    query = (
+        f"{plan_prompt}\n\n"
+        "Today's date:\n2025-Feb-27\n\n"
+        "Project start ASAP"
+    )
+    print(f"Query: {query}")
+
+    result = RelatedResources.execute(llm, query)
+    json_response = result.to_dict(include_system_prompt=False, include_user_prompt=False)
+    print("\n\nResponse:")
+    print(json.dumps(json_response, indent=2))
+
+    print(f"\n\nMarkdown:\n{result.markdown}")

src/plan/review_plan.py

@@ -0,0 +1,238 @@
+"""
+Ask questions about the almost finished plan.
+
+PROMPT> python -m src.plan.plan_evaluator
+
+IDEA: Executive Summary: Briefly summarizing critical insights from the review.
+"""
+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
+
+logger = logging.getLogger(__name__)
+
+class DocumentDetails(BaseModel):
+    bullet_points: list[str] = Field(
+        description="Answers to the questions in bullet points."
+    )
+
+REVIEW_PLAN_SYSTEM_PROMPT = """
+You are an expert in reviewing plans for projects of all scales. Your goal is to identify the most critical issues that could impact the project's success and provide actionable recommendations to address them.
+
+A good plan is specific, measurable, achievable, relevant, and time-bound (SMART). It addresses potential risks with concrete mitigation strategies, has clear roles and responsibilities, and considers relevant constraints. A strong plan has a detailed financial model, addresses grid connection complexities, and a solid operations and maintenance strategy.
+
+For each question, you MUST provide exactly three concise and distinct bullet points as your answer. Each bullet point must combine all required details for that question into one sentence or clause. **The *very first phrase or a short sentence of each bullet point should act as a concise summary/title for that bullet point, and it MUST BE BOLDED. This first phrase helps the user understand quickly. Make sure the phrase is informative.  Then the rest of the bullet point will contain details, explanation, and actionable recommendations.** Prioritize the *most* critical issues and provide *specific, actionable* recommendations.  For each recommendation, explain *why* it's important and what the potential impact of *not* addressing it would be.**
+
+For example:
+- If a question asks for key dependencies along with their likelihood (e.g., Medium, High, Low) and control (internal or external), then each bullet point must include the dependency name, its likelihood, and whether it is controlled internally or externally—all combined into one sentence.  **Indicate which dependency is the *most* critical and why.**
+- If a question asks for regulatory requirements, each bullet point must state the requirement and briefly explain how it will be met. Do not include any extra header lines or additional bullet points.
+
+If additional details are needed, merge or summarize them so that your final answer always consists of exactly three bullet points.
+
+Your final output must be a JSON object in the following format:
+{
+  "bullet_points": [
+    "Bullet point 1 (including all required details)",
+    "Bullet point 2 (including all required details)",
+    "Bullet point 3 (including all required details)"
+  ]
+}
+
+Do not include any extra bullet points, header lines, or any additional text outside of this JSON structure.
+
+Do not duplicate issues already identified in previous questions of this review.
+"""
+
+@dataclass
+class ReviewPlan:
+    """
+    Take a look at the proposed plan and provide feedback.
+    """
+    system_prompt: str
+    question_answers_list: list[dict]
+    metadata: dict
+    markdown: str
+
+    @classmethod
+    def execute(cls, llm: LLM, document: str) -> 'ReviewPlan':
+        """
+        Invoke LLM with the data to be reviewed.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(document, str):
+            raise ValueError("Invalid document.")
+
+        logger.debug(f"Document:\n{document}")
+
+        system_prompt = REVIEW_PLAN_SYSTEM_PROMPT.strip()
+        system_prompt += "\n\nDocument for review:\n"
+        system_prompt += document
+
+        title_question_list = [
+            ("Critical Issues", "Identify exactly three critical or urgent issues highlighted in the report. For each issue, provide a brief explanation of its quantified significance (e.g., impact in terms of cost, risk, or timing) on the immediate priorities, desired outcomes, or overall effectiveness. Also, explain how these issues might interact with or influence each other, along with a brief, actionable recommendation to address it. Please present your answer in exactly three bullet points."),
+            ("Implementation Consequences", "Identify exactly three significant consequences—both positive and negative—that may result from implementing the plan. For each consequence, provide a brief explanation of its *quantified* impact (e.g., in terms of cost, time, or ROI) on the plan's overall feasibility, outcomes, or long-term success. *Also, explain how these consequences might interact with or influence each other*, *along with a brief, actionable recommendation to address it*. Please present your answer in exactly three bullet points."),
+            ("Recommended Actions", "Identify exactly three specific actions recommended by the report. For each action, briefly quantify its expected impact (e.g., cost savings, risk reduction, time improvements), clearly state its priority level, and provide a brief, actionable recommendation on how it should be implemented. Present your answer in exactly three bullet points. Actions listed here should complement, extend, or provide additional details to recommendations mentioned previously, rather than repeat them directly."),
+            ("Showstopper Risks", "Identify exactly three 'showstopper' risks to the project's success that have not yet been addressed.\nFor each risk:\n- Quantify its potential impact (e.g., in terms of budget increase, timeline delays, ROI reduction).\n- State explicitly its likelihood (High, Medium, Low).\n- Clearly explain how these risks might interact or compound each other.\n- Provide a brief, actionable recommendation to address it.\nPresent your answer in exactly three bullet points, avoiding repetition of previously covered issues or actions. Additionally, for each risk, briefly suggest a contingency measure to be activated if the initial mitigation action proves insufficient."),
+            ("Critical Assumptions", "List exactly three critical assumptions underlying the plan that must hold true for it to succeed. For each assumption, quantify the impact if proven incorrect (e.g., cost increase, ROI decrease, timeline delays), explain clearly how each assumption interacts or compounds with previously identified risks or consequences, and provide a brief, actionable recommendation for validating or adjusting each assumption. Present your answer in exactly three bullet points without repeating previously mentioned risks or issues."),
+            ("Key Performance Indicators", "Identify exactly three Key Performance Indicators (KPIs) essential for measuring the project's long-term success. For each KPI, quantify specific target values or ranges that indicate success or require corrective action. Clearly explain how each KPI interacts with previously identified risks, assumptions, or recommended actions, and provide a brief, actionable recommendation on how to regularly monitor or achieve each KPI. Present your answer in exactly three bullet points without repeating previously mentioned details."),
+            ("Report Objectives", "What exactly are the primary objectives and deliverables of this report? Clearly state the intended audience, the key decisions this report aims to inform, and how Version 2 should differ from Version 1. Present your answer concisely in three bullet points."),
+            ("Data Quality Concerns", "Identify exactly three key areas in the current draft where data accuracy or completeness may be uncertain or insufficient. For each area, briefly explain why the data is critical, quantify the potential consequences of relying on incorrect or incomplete data, and recommend a clear approach for validating or improving data quality before Version 2. Present your answer in exactly three bullet points."),
+            ("Stakeholder Feedback", "List exactly three important pieces of stakeholder feedback or clarification needed before finalizing Version 2 of the report. For each piece of feedback, explain why it's critical, how unresolved stakeholder concerns might impact the project (quantify potential impact), and provide a brief recommendation for obtaining and incorporating this feedback effectively. Present your answer in exactly three bullet points."),
+            ("Changed Assumptions", "Identify exactly three assumptions or conditions from the initial planning stage that might have changed or require re-evaluation since Version 1 was drafted. For each assumption, briefly quantify how changes might affect the report's outcomes (cost, ROI, timeline), explain how these revised assumptions could influence previously identified risks or recommendations, and suggest an actionable approach to reviewing or updating each assumption. Present your answer in exactly three bullet points without repeating previously discussed points."),
+            ("Budget Clarifications", "Provide exactly three critical budget clarifications necessary before finalizing Version 2. For each clarification, quantify its impact on the project's financial planning (e.g., cost adjustments, budget reserves, ROI impact), clearly explain why it's needed, and recommend actionable steps to resolve the uncertainty."),
+            ("Role Definitions", "Identify exactly three key roles or responsibilities that must be explicitly defined or clarified in Version 2. For each role, briefly explain why clarification is essential, quantify potential impacts (e.g., timeline delays, accountability risks) if roles remain unclear, and recommend actionable steps to ensure clear assignment and accountability."),
+            ("Timeline Dependencies", "Identify exactly three timeline dependencies or sequencing concerns that must be clarified before finalizing Version 2. For each dependency, quantify its potential impact if incorrectly sequenced (e.g., timeline delays, increased costs), clearly explain its interaction with previously identified risks or actions, and recommend a concrete action to address the sequencing or dependency concern."),
+            ("Financial Strategy", "Identify exactly three long-term financial strategy questions that must be clarified in Version 2. For each, quantify the financial or strategic impact of leaving it unanswered, explain clearly how each interacts with previously identified assumptions or risks, and recommend actionable steps to clarify or address the question."),
+            ("Motivation Factors", "Identify exactly three factors essential to maintaining motivation and ensuring consistent progress toward the project's goals. For each factor, quantify potential setbacks if motivation falters (e.g., delays, reduced success rates, increased costs), clearly explain how it interacts with previously identified risks or assumptions, and provide a brief, actionable recommendation on maintaining motivation or addressing motivational barriers."),
+            ("Automation Opportunities", "Identify exactly three opportunities within the project where tasks or processes can be automated or streamlined for improved efficiency. For each opportunity, quantify the potential savings (time, resources, or cost), explain how this interacts with previously identified timelines or resource constraints, and recommend a clear, actionable approach for implementing each automation or efficiency improvement."),
+        ]
+
+        chat_message_list = [
+            ChatMessage(
+                role=MessageRole.SYSTEM,
+                content=system_prompt,
+            )
+        ]
+
+        question_answers_list = []
+
+        durations = []
+        response_byte_counts = []
+
+        for index, title_question in enumerate(title_question_list, start=1):
+            title, question = title_question
+            logger.debug(f"Question {index} of {len(title_question_list)}: {question}")
+            chat_message_list.append(ChatMessage(
+                role=MessageRole.USER,
+                content=question,
+            ))
+
+            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"Question {index} of {len(title_question_list)}. LLM chat interaction failed: {e}")
+                logger.error(f"Question {index} of {len(title_question_list)}. 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))
+            durations.append(duration)
+            response_byte_count = len(chat_response.message.content.encode('utf-8'))
+            response_byte_counts.append(response_byte_count)
+            logger.info(f"Question {index} of {len(title_question_list)}. LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+            json_response = chat_response.raw.model_dump()
+            logger.debug(json.dumps(json_response, indent=2))
+
+            question_answers_list.append({
+                "title": title,
+                "question": question,
+                "answers": chat_response.raw.bullet_points,
+            })
+
+            chat_message_list.append(ChatMessage(
+                role=MessageRole.ASSISTANT,
+                content=chat_response.message.content,
+            ))
+
+        response_byte_count_total = sum(response_byte_counts)
+        response_byte_count_average = response_byte_count_total / len(title_question_list)
+        response_byte_count_max = max(response_byte_counts)
+        response_byte_count_min = min(response_byte_counts)
+        duration_total = sum(durations)
+        duration_average = duration_total / len(title_question_list)
+        duration_max = max(durations)
+        duration_min = min(durations)
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration_total"] = duration_total
+        metadata["duration_average"] = duration_average
+        metadata["duration_max"] = duration_max
+        metadata["duration_min"] = duration_min
+        metadata["response_byte_count_total"] = response_byte_count_total
+        metadata["response_byte_count_average"] = response_byte_count_average
+        metadata["response_byte_count_max"] = response_byte_count_max
+        metadata["response_byte_count_min"] = response_byte_count_min
+        markdown = cls.convert_to_markdown(question_answers_list)
+
+        result = ReviewPlan(
+            system_prompt=system_prompt,
+            question_answers_list=question_answers_list,
+            metadata=metadata,
+            markdown=markdown
+        )
+        return result
+    
+    def to_dict(self, include_metadata=True, include_system_prompt=True) -> dict:
+        d = {}
+        d['question_answers_list'] = self.question_answers_list
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        return d
+
+    def save_raw(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.to_dict(), indent=2))
+
+    @staticmethod
+    def convert_to_markdown(question_answers_list: list[dict]) -> str:
+        """
+        Convert the question answers list to markdown.
+        """
+        rows = []
+
+        for question_index, question_answers in enumerate(question_answers_list, start=1):
+            if question_index > 1:
+                rows.append("\n")
+            title = question_answers.get('title', None)
+            if title is None:
+                logger.warning("Title is None.")
+                continue
+            answers = question_answers.get('answers', None)
+            if answers is None:
+                logger.warning("Answers are None.")
+                continue
+            rows.append(f"## Review {question_index}: {title}\n")
+            for answer_index, answer in enumerate(answers, start=1):
+                if answer_index > 1:
+                    rows.append("\n")
+                rows.append(f"{answer_index}. {answer}")
+
+        return "\n".join(rows)
+
+    def save_markdown(self, output_file_path: str):
+        with open(output_file_path, 'w', encoding='utf-8') as out_f:
+            out_f.write(self.markdown)
+
+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', "deadfish_assumptions.md")
+    with open(path, 'r', encoding='utf-8') as f:
+        assumptions_markdown = f.read()
+
+    query = (
+        f"File 'assumptions.md':\n{assumptions_markdown}"
+    )
+    print(f"Query:\n{query}\n\n")
+
+    result = ReviewPlan.execute(llm, query)
+    json_response = result.to_dict(include_system_prompt=False)
+    print("\n\nResponse:")
+    print(json.dumps(json_response, indent=2))
+
+    print(f"\n\nMarkdown:\n{result.markdown}")

src/plan/run_plan_pipeline.py

@@ -23,8 +23,10 @@ from src.assume.identify_risks import IdentifyRisks
 from src.assume.make_assumptions import MakeAssumptions
 from src.assume.distill_assumptions import DistillAssumptions
 from src.assume.review_assumptions import ReviewAssumptions
+from src.assume.shorten_markdown import ShortenMarkdown
 from src.expert.pre_project_assessment import PreProjectAssessment
-from src.plan.create_project_plan import CreateProjectPlan
+from src.plan.project_plan import ProjectPlan
+from src.plan.related_resources import RelatedResources
 from src.swot.swot_analysis import SWOTAnalysis
 from src.expert.expert_finder import ExpertFinder
 from src.expert.expert_criticism import ExpertCriticism
@@ -36,6 +38,8 @@ 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.plan.review_plan import ReviewPlan
+from src.plan.executive_summary import ExecutiveSummary
 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
@@ -499,9 +503,14 @@ class ConsolidateAssumptionsMarkdownTask(PlanTask):
         }
 
     def output(self):
-        return luigi.LocalTarget(str(self.file_path(FilenameEnum.CONSOLIDATE_ASSUMPTIONS_MARKDOWN)))
+        return {
+            'full': luigi.LocalTarget(str(self.file_path(FilenameEnum.CONSOLIDATE_ASSUMPTIONS_FULL_MARKDOWN))),
+            'short': luigi.LocalTarget(str(self.file_path(FilenameEnum.CONSOLIDATE_ASSUMPTIONS_SHORT_MARKDOWN)))
+        }
 
     def run(self):
+        llm = get_llm(self.llm_model)
+
         # Define the list of (title, path) tuples
         title_path_list = [
             ('Plan Type', self.input()['plan_type']['markdown'].path),
@@ -514,27 +523,45 @@ class ConsolidateAssumptionsMarkdownTask(PlanTask):
         ]
 
         # Read the files and handle exceptions
-        markdown_chunks = []
+        full_markdown_chunks = []
+        short_markdown_chunks = []
         for title, path in title_path_list:
             try:
                 with open(path, 'r', encoding='utf-8') as f:
                     markdown_chunk = f.read()
-                markdown_chunks.append(f"# {title}\n\n{markdown_chunk}")
+                full_markdown_chunks.append(f"# {title}\n\n{markdown_chunk}")
             except FileNotFoundError:
                 logger.warning(f"Markdown file not found: {path} (from {title})")
-                markdown_chunks.append(f"**Problem with document:** '{title}'\n\nFile not found.")
+                full_markdown_chunks.append(f"**Problem with document:** '{title}'\n\nFile not found.")
+                short_markdown_chunks.append(f"**Problem with document:** '{title}'\n\nFile not found.")
+                continue
             except Exception as e:
                 logger.error(f"Error reading markdown file {path} (from {title}): {e}")
-                markdown_chunks.append(f"**Problem with document:** '{title}'\n\nError reading markdown file.")
+                full_markdown_chunks.append(f"**Problem with document:** '{title}'\n\nError reading markdown file.")
+                short_markdown_chunks.append(f"**Problem with document:** '{title}'\n\nError reading markdown file.")
+                continue
 
+            try:
+                shorten_markdown = ShortenMarkdown.execute(llm, markdown_chunk)
+                short_markdown_chunks.append(f"# {title}\n{shorten_markdown.markdown}")
+            except Exception as e:
+                logger.error(f"Error shortening markdown file {path} (from {title}): {e}")
+                short_markdown_chunks.append(f"**Problem with document:** '{title}'\n\nError shortening markdown file.")
+                continue
+            
         # Combine the markdown chunks
-        full_markdown = "\n\n".join(markdown_chunks)
+        full_markdown = "\n\n".join(full_markdown_chunks)
+        short_markdown = "\n\n".join(short_markdown_chunks)
 
         # Write the result to disk.
-        output_markdown_path = self.output().path
-        with open(output_markdown_path, "w", encoding="utf-8") as f:
+        output_full_markdown_path = self.output()['full'].path
+        with open(output_full_markdown_path, "w", encoding="utf-8") as f:
             f.write(full_markdown)
 
+        output_short_markdown_path = self.output()['short'].path
+        with open(output_short_markdown_path, "w", encoding="utf-8") as f:
+            f.write(short_markdown)
+
 
 class PreProjectAssessmentTask(PlanTask):
     llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
@@ -558,7 +585,7 @@ class PreProjectAssessmentTask(PlanTask):
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
 
         # Build the query.
@@ -599,7 +626,10 @@ class ProjectPlanTask(PlanTask):
         }
 
     def output(self):
-        return luigi.LocalTarget(str(self.file_path(FilenameEnum.PROJECT_PLAN)))
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.PROJECT_PLAN_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.PROJECT_PLAN_MARKDOWN)))
+        }
 
     def run(self):
         logger.info("Creating plan...")
@@ -610,7 +640,7 @@ class ProjectPlanTask(PlanTask):
             plan_prompt = f.read()
 
         # Load the consolidated assumptions.
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
 
         # Read the pre-project assessment from its file.
@@ -629,12 +659,62 @@ class ProjectPlanTask(PlanTask):
         llm = get_llm(self.llm_model)
 
         # Execute the plan creation.
-        create_project_plan = CreateProjectPlan.execute(llm, query)
-        output_path = self.output().path
-        create_project_plan.save(output_path)
+        project_plan = ProjectPlan.execute(llm, query)
+        
+        # Save raw output
+        project_plan.save_raw(self.output()['raw'].path)
+        
+        # Save markdown output
+        project_plan.save_markdown(self.output()['markdown'].path)
+
+        logger.info("Project plan created and saved")
+
+
+class RelatedResourcesTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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.RELATED_RESOURCES_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.RELATED_RESOURCES_MARKDOWN)))
+        }
+
+    def run(self):
+        # Read inputs from required tasks.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
+        with self.input()['project_plan']['raw'].open("r") as f:
+            project_plan_dict = json.load(f)
 
-        logger.info("Project plan created and saved to %s", output_path)
+        # Build the query.
+        query = (
+            f"File 'initial-plan.txt':\n{plan_prompt}\n\n"
+            f"File 'assumptions.md':\n{consolidate_assumptions_markdown}\n\n"
+            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}"
+        )
 
+        # Create LLM instance.
+        llm = get_llm(self.llm_model)
+
+        # Execute.
+        try:
+            related_resources = RelatedResources.execute(llm, query)
+        except Exception as e:
+            logger.error("SimilarProjects failed: %s", e)
+            raise
+
+        # Save the results.
+        related_resources.save_raw(self.output()['raw'].path)
+        related_resources.save_markdown(self.output()['markdown'].path)
 
 class FindTeamMembersTask(PlanTask):
     llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
@@ -644,7 +724,8 @@ class FindTeamMembersTask(PlanTask):
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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)
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'related_resources': RelatedResourcesTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
         }
 
     def output(self):
@@ -654,32 +735,25 @@ class FindTeamMembersTask(PlanTask):
         }
 
     def run(self):
-        logger.info("FindTeamMembers. Loading files...")
-
-        # Read the plan prompt from SetupTask.
+        # Read inputs from required tasks.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
-
-        # Load the consolidated assumptions.
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
-
-        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
-
-        # Read the project plan from ProjectPlanTask.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
-
-        logger.info("FindTeamMembers. All files are now ready. Brainstorming a team...")
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
 
         # Build the query.
         query = (
             f"File 'initial-plan.txt':\n{plan_prompt}\n\n"
             f"File 'assumptions.md':\n{consolidate_assumptions_markdown}\n\n"
             f"File 'pre-project-assessment.json':\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}"
+            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}"
         )
 
         # Create LLM instance.
@@ -702,8 +776,6 @@ class FindTeamMembersTask(PlanTask):
         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)
 
@@ -713,7 +785,8 @@ class EnrichTeamMembersWithContractTypeTask(PlanTask):
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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)
+            'find_team_members': FindTeamMembersTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'related_resources': RelatedResourcesTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
         }
 
     def output(self):
@@ -723,37 +796,28 @@ class EnrichTeamMembersWithContractTypeTask(PlanTask):
         }
 
     def run(self):
-        logger.info("EnrichTeamMembersWithContractType. Loading files...")
-
-        # Read the plan prompt from SetupTask.
+        # Read inputs from required tasks.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
-
-        # Load the consolidated assumptions.
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
-
-        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
-
-        # Read the project plan from ProjectPlanTask.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
-
-        # 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...")
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
 
         # Build the query.
         query = (
             f"File 'initial-plan.txt':\n{plan_prompt}\n\n"
             f"File 'assumptions.md':\n{consolidate_assumptions_markdown}\n\n"
             f"File 'pre-project-assessment.json':\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}"
-            f"File 'team-members-that-needs-to-be-enriched.json':\n{format_json_for_use_in_query(team_member_list)}"
+            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"File 'team-members-that-needs-to-be-enriched.json':\n{format_json_for_use_in_query(team_member_list)}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}"
         )
 
         # Create LLM instance.
@@ -776,8 +840,6 @@ class EnrichTeamMembersWithContractTypeTask(PlanTask):
         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)
 
@@ -787,7 +849,8 @@ class EnrichTeamMembersWithBackgroundStoryTask(PlanTask):
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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)
+            'enrich_team_members_with_contract_type': EnrichTeamMembersWithContractTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'related_resources': RelatedResourcesTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
         }
 
     def output(self):
@@ -797,37 +860,28 @@ class EnrichTeamMembersWithBackgroundStoryTask(PlanTask):
         }
 
     def run(self):
-        logger.info("EnrichTeamMembersWithBackgroundStoryTask. Loading files...")
-
-        # Read the plan prompt from SetupTask.
+        # Read inputs from required tasks.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
-
-        # Load the consolidated assumptions.
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
-
-        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
-
-        # Read the project plan from ProjectPlanTask.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
-
-        # 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...")
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
 
         # Build the query.
         query = (
             f"File 'initial-plan.txt':\n{plan_prompt}\n\n"
             f"File 'assumptions.md':\n{consolidate_assumptions_markdown}\n\n"
             f"File 'pre-project-assessment.json':\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}"
-            f"File 'team-members-that-needs-to-be-enriched.json':\n{format_json_for_use_in_query(team_member_list)}"
+            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"File 'team-members-that-needs-to-be-enriched.json':\n{format_json_for_use_in_query(team_member_list)}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}"
         )
 
         # Create LLM instance.
@@ -850,8 +904,6 @@ class EnrichTeamMembersWithBackgroundStoryTask(PlanTask):
         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)
 
@@ -861,7 +913,8 @@ class EnrichTeamMembersWithEnvironmentInfoTask(PlanTask):
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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)
+            'enrich_team_members_with_background_story': EnrichTeamMembersWithBackgroundStoryTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'related_resources': RelatedResourcesTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
         }
 
     def output(self):
@@ -871,37 +924,28 @@ class EnrichTeamMembersWithEnvironmentInfoTask(PlanTask):
         }
 
     def run(self):
-        logger.info("EnrichTeamMembersWithEnvironmentInfoTask. Loading files...")
-
-        # Read the plan prompt from SetupTask.
+        # Read inputs from required tasks.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
-
-        # Load the consolidated assumptions.
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
-
-        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
-
-        # Read the project plan from ProjectPlanTask.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
-
-        # 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...")
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
 
         # Build the query.
         query = (
             f"File 'initial-plan.txt':\n{plan_prompt}\n\n"
             f"File 'assumptions.md':\n{consolidate_assumptions_markdown}\n\n"
             f"File 'pre-project-assessment.json':\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}"
-            f"File 'team-members-that-needs-to-be-enriched.json':\n{format_json_for_use_in_query(team_member_list)}"
+            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"File 'team-members-that-needs-to-be-enriched.json':\n{format_json_for_use_in_query(team_member_list)}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}"
         )
 
         # Create LLM instance.
@@ -924,8 +968,6 @@ class EnrichTeamMembersWithEnvironmentInfoTask(PlanTask):
         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)
 
@@ -935,36 +977,27 @@ class ReviewTeamTask(PlanTask):
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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)
+            'enrich_team_members_with_environment_info': EnrichTeamMembersWithEnvironmentInfoTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'related_resources': RelatedResourcesTask(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...")
-
-        # Read the plan prompt from SetupTask.
+        # Read inputs from required tasks.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
-
-        # Load the consolidated assumptions.
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
-
-        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
-
-        # Read the project plan from ProjectPlanTask.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
-
-        # 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...")
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
 
         # Convert the team members to a Markdown document.
         builder = TeamMarkdownDocumentBuilder()
@@ -976,8 +1009,9 @@ class ReviewTeamTask(PlanTask):
             f"File 'initial-plan.txt':\n{plan_prompt}\n\n"
             f"File 'assumptions.md':\n{consolidate_assumptions_markdown}\n\n"
             f"File 'pre-project-assessment.json':\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}"
-            f"File 'team-members.md':\n{team_document_markdown}"
+            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"File 'team-members.md':\n{team_document_markdown}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}"
         )
 
         # Create LLM instance.
@@ -1039,7 +1073,8 @@ class SWOTAnalysisTask(PlanTask):
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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)
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'related_resources': RelatedResourcesTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
         }
 
     def output(self):
@@ -1049,32 +1084,25 @@ class SWOTAnalysisTask(PlanTask):
         }
 
     def run(self):
-        logger.info("SWOTAnalysisTask. Loading files...")
-
-        # Read the plan prompt from SetupTask.
+        # Read inputs from required tasks.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
-
-        # Load the consolidated assumptions.
-        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
             consolidate_assumptions_markdown = f.read()
-
-        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
-
-        # Read the project plan from ProjectPlanTask.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
-
-        logger.info("SWOTAnalysisTask. All files are now ready. Performing analysis...")
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
 
         # Build the query for SWOT analysis.
         query = (
             f"File 'initial-plan.txt':\n{plan_prompt}\n\n"
             f"File 'assumptions.md':\n{consolidate_assumptions_markdown}\n\n"
             f"File 'pre-project-assessment.json':\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}"
+            f"File 'project-plan.json':\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}"
         )
 
         # Create LLM instances for SWOT analysis.
@@ -1100,8 +1128,6 @@ class SWOTAnalysisTask(PlanTask):
         with open(markdown_path, "w", encoding="utf-8") as f:
             f.write(swot_markdown)
 
-        logger.info("SWOT analysis complete.")
-
 class ExpertReviewTask(PlanTask):
     """
     Finds experts to review the SWOT analysis and have them provide criticism.
@@ -1137,7 +1163,7 @@ class ExpertReviewTask(PlanTask):
             plan_prompt = f.read()
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
         swot_markdown_path = self.input()['swot_analysis']['markdown'].path
         with open(swot_markdown_path, "r", encoding="utf-8") as f:
@@ -1202,7 +1228,7 @@ class CreateWBSLevel1Task(PlanTask):
         logger.info("Creating Work Breakdown Structure (WBS) Level 1...")
         
         # Read the project plan JSON from the dependency.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
         
         # Build the query using the project plan.
@@ -1254,7 +1280,7 @@ class CreateWBSLevel2Task(PlanTask):
         logger.info("Creating Work Breakdown Structure (WBS) Level 2...")
         
         # Read the project plan from the ProjectPlanTask output.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
         
         # Read the cleaned WBS Level 1 result from the CreateWBSLevel1Task output.
@@ -1330,25 +1356,29 @@ class CreatePitchTask(PlanTask):
         return {
             'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'wbs_project': WBSProjectLevel1AndLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'related_resources': RelatedResourcesTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
         }
     
     def run(self):
         logger.info("Creating pitch...")
         
         # Read the project plan JSON.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
         
-        wbs_project_path = self.input()['wbs_project'].path
-        with open(wbs_project_path, "r") as f:
+        with self.input()['wbs_project'].open("r") as f:
             wbs_project_dict = json.load(f)
         wbs_project = WBSProject.from_dict(wbs_project_dict)
         wbs_project_json = wbs_project.to_dict()
+
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
         
         # Build the query
         query = (
             f"The project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
-            f"Work Breakdown Structure:\n{format_json_for_use_in_query(wbs_project_json)}"
+            f"Work Breakdown Structure:\n{format_json_for_use_in_query(wbs_project_json)}\n\n"
+            f"Similar projects:\n{format_json_for_use_in_query(related_resources_dict)}"
         )
         
         # Get the LLM instance.
@@ -1433,7 +1463,7 @@ class IdentifyTaskDependenciesTask(PlanTask):
         logger.info("Identifying task dependencies...")
         
         # Read the project plan JSON.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
         
         # Read the major phases with subtasks from WBS Level 2 output.
@@ -1487,7 +1517,7 @@ class EstimateTaskDurationsTask(PlanTask):
         logger.info("Estimating task durations...")
         
         # Load the project plan JSON.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
 
         with self.input()['wbs_project'].open("r") as f:
@@ -1579,7 +1609,7 @@ class CreateWBSLevel3Task(PlanTask):
         logger.info("Creating Work Breakdown Structure (WBS) Level 3...")
         
         # Load the project plan JSON.
-        with self.input()['project_plan'].open("r") as f:
+        with self.input()['project_plan']['raw'].open("r") as f:
             project_plan_dict = json.load(f)
         
         with self.input()['wbs_project'].open("r") as f:
@@ -1692,6 +1722,167 @@ class WBSProjectLevel1AndLevel2AndLevel3Task(PlanTask):
         with self.output()['csv'].open("w") as f:
             f.write(csv_representation)
 
+class ReviewPlanTask(PlanTask):
+    """
+    Ask questions about the almost finished plan.
+    
+    It depends on:
+      - ConsolidateAssumptionsMarkdownTask: provides the assumptions as Markdown.
+      - ProjectPlanTask: provides the project plan as Markdown.
+      - SWOTAnalysisTask: provides the SWOT analysis as Markdown.
+      - TeamMarkdownTask: provides the team as Markdown.
+      - ConvertPitchToMarkdownTask: provides the pitch as Markdown.
+      - ExpertReviewTask: provides the expert criticism as Markdown.
+      - WBSProjectLevel1AndLevel2AndLevel3Task: provides the table csv file.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.REVIEW_PLAN_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.REVIEW_PLAN_MARKDOWN)))
+        }
+    
+    def requires(self):
+        return {
+            'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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),
+            'related_resources': RelatedResourcesTask(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),
+            'team_markdown': TeamMarkdownTask(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),
+            'expert_review': ExpertReviewTask(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)
+        }
+    
+    def run(self):
+        # Read inputs from required tasks.
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
+            assumptions_markdown = f.read()
+        with self.input()['project_plan']['markdown'].open("r") as f:
+            project_plan_markdown = f.read()
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
+        with self.input()['swot_analysis']['markdown'].open("r") as f:
+            swot_analysis_markdown = f.read()
+        with self.input()['team_markdown'].open("r") as f:
+            team_markdown = f.read()
+        with self.input()['pitch_markdown']['markdown'].open("r") as f:
+            pitch_markdown = f.read()
+        with self.input()['expert_review'].open("r") as f:
+            expert_review = f.read()
+        with self.input()['wbs_project123']['csv'].open("r") as f:
+            wbs_project_csv = f.read()
+
+        # Build the query.
+        query = (
+            f"File 'assumptions.md':\n{assumptions_markdown}\n\n"
+            f"File 'project-plan.md':\n{project_plan_markdown}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}\n\n"
+            f"File 'swot-analysis.md':\n{swot_analysis_markdown}\n\n"
+            f"File 'team.md':\n{team_markdown}\n\n"
+            f"File 'pitch.md':\n{pitch_markdown}\n\n"
+            f"File 'expert-review.md':\n{expert_review}\n\n"
+            f"File 'work-breakdown-structure.csv':\n{wbs_project_csv}"
+        )
+
+        llm = get_llm(self.llm_model)
+
+        # Perform the review.
+        review_plan = ReviewPlan.execute(llm, query)
+
+        # Save the results.
+        json_path = self.output()['raw'].path
+        review_plan.save_raw(json_path)
+        markdown_path = self.output()['markdown'].path
+        review_plan.save_markdown(markdown_path)
+
+        logger.info("Reviewed the plan.")
+
+
+class ExecutiveSummaryTask(PlanTask):
+    """
+    Create an executive summary of the plan.
+    
+    It depends on:
+      - ConsolidateAssumptionsMarkdownTask: provides the assumptions as Markdown.
+      - ProjectPlanTask: provides the project plan as Markdown.
+      - SWOTAnalysisTask: provides the SWOT analysis as Markdown.
+      - TeamMarkdownTask: provides the team as Markdown.
+      - ConvertPitchToMarkdownTask: provides the pitch as Markdown.
+      - ExpertReviewTask: provides the expert criticism as Markdown.
+      - WBSProjectLevel1AndLevel2AndLevel3Task: provides the table csv file.
+      - ReviewPlanTask: provides the reviewed plan as Markdown.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.EXECUTIVE_SUMMARY_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.EXECUTIVE_SUMMARY_MARKDOWN)))
+        }
+    
+    def requires(self):
+        return {
+            'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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),
+            'related_resources': RelatedResourcesTask(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),
+            'team_markdown': TeamMarkdownTask(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),
+            'expert_review': ExpertReviewTask(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),
+            'review_plan': ReviewPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+    
+    def run(self):
+        # Read inputs from required tasks.
+        with self.input()['consolidate_assumptions_markdown']['short'].open("r") as f:
+            assumptions_markdown = f.read()
+        with self.input()['project_plan']['markdown'].open("r") as f:
+            project_plan_markdown = f.read()
+        with self.input()['related_resources']['raw'].open("r") as f:
+            related_resources_dict = json.load(f)
+        with self.input()['swot_analysis']['markdown'].open("r") as f:
+            swot_analysis_markdown = f.read()
+        with self.input()['team_markdown'].open("r") as f:
+            team_markdown = f.read()
+        with self.input()['pitch_markdown']['markdown'].open("r") as f:
+            pitch_markdown = f.read()
+        with self.input()['expert_review'].open("r") as f:
+            expert_review = f.read()
+        with self.input()['wbs_project123']['csv'].open("r") as f:
+            wbs_project_csv = f.read()
+        with self.input()['review_plan']['markdown'].open("r") as f:
+            review_plan_markdown = f.read()
+
+        # Build the query.
+        query = (
+            f"File 'assumptions.md':\n{assumptions_markdown}\n\n"
+            f"File 'project-plan.md':\n{project_plan_markdown}\n\n"
+            f"File 'related-resources.json':\n{format_json_for_use_in_query(related_resources_dict)}\n\n"
+            f"File 'swot-analysis.md':\n{swot_analysis_markdown}\n\n"
+            f"File 'team.md':\n{team_markdown}\n\n"
+            f"File 'pitch.md':\n{pitch_markdown}\n\n"
+            f"File 'expert-review.md':\n{expert_review}\n\n"
+            f"File 'work-breakdown-structure.csv':\n{wbs_project_csv}\n\n"
+            f"File 'review-plan.md':\n{review_plan_markdown}"
+        )
+
+        llm = get_llm(self.llm_model)
+
+        # Create the executive summary.
+        executive_summary = ExecutiveSummary.execute(llm, query)
+
+        # Save the results.
+        json_path = self.output()['raw'].path
+        executive_summary.save_raw(json_path)
+        markdown_path = self.output()['markdown'].path
+        executive_summary.save_markdown(markdown_path)
+
+        logger.info("Created executive summary.")
+
+
 class ReportTask(PlanTask):
     """
     Generate a report html document.
@@ -1701,6 +1892,9 @@ class ReportTask(PlanTask):
       - ConvertPitchToMarkdownTask: provides the pitch as Markdown.
       - WBSProjectLevel1AndLevel2AndLevel3Task: provides the table csv file.
       - ExpertReviewTask: provides the expert criticism as Markdown.
+      - ProjectPlanTask: provides the project plan as Markdown.
+      - ReviewPlanTask: provides the reviewed plan as Markdown.
+      - ExecutiveSummaryTask: provides the executive summary as Markdown.
     """
     llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
 
@@ -1711,20 +1905,28 @@ class ReportTask(PlanTask):
         return {
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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),
+            'related_resources': RelatedResourcesTask(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),
-            'expert_review': ExpertReviewTask(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),
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'review_plan': ReviewPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'executive_summary': ExecutiveSummaryTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
         }
     
     def run(self):
         rg = ReportGenerator()
-        rg.append_assumptions_markdown(self.input()['consolidate_assumptions_markdown'].path)
-        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.append_markdown('Executive Summary', self.input()['executive_summary']['markdown'].path)
+        rg.append_markdown('Pitch', self.input()['pitch_markdown']['markdown'].path)
+        rg.append_markdown('Project Plan', self.input()['project_plan']['markdown'].path)
+        rg.append_markdown('Assumptions', self.input()['consolidate_assumptions_markdown']['full'].path)
+        rg.append_markdown('Related Resources', self.input()['related_resources']['markdown'].path)
+        rg.append_markdown('SWOT Analysis', self.input()['swot_analysis']['markdown'].path)
+        rg.append_markdown('Team', self.input()['team_markdown'].path)
+        rg.append_markdown('Expert Criticism', self.input()['expert_review'].path)
+        rg.append_csv('Work Breakdown Structure', self.input()['wbs_project123']['csv'].path)
+        rg.append_markdown('Review Plan', self.input()['review_plan']['markdown'].path)
         rg.save_report(self.output().path)
 
 class FullPlanPipeline(PlanTask):
@@ -1743,6 +1945,7 @@ class FullPlanPipeline(PlanTask):
             'consolidate_assumptions_markdown': ConsolidateAssumptionsMarkdownTask(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),
+            'related_resources': RelatedResourcesTask(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),
@@ -1760,6 +1963,8 @@ class FullPlanPipeline(PlanTask):
             'durations': EstimateTaskDurationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'wbs_level3': CreateWBSLevel3Task(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),
+            'plan_evaluator': ReviewPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'executive_summary': ExecutiveSummaryTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
             'report': ReportTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
         }
 
@@ -1811,7 +2016,7 @@ if __name__ == '__main__':
     # Capture logs messages to 'run/yyyymmdd_hhmmss/log.txt'
     file_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
     log_file = os.path.join(run_dir, "log.txt")
-    file_handler = logging.FileHandler(log_file, mode='w')
+    file_handler = logging.FileHandler(log_file, mode='a')
     file_handler.setLevel(logging.DEBUG)
     file_handler.setFormatter(file_formatter)
     logger.addHandler(file_handler)

src/plan/test_data/deadfish_assumptions.md

@@ -0,0 +1,267 @@
+# Plan Type
+
+This plan requires one or more physical locations. It cannot be executed digitally.
+
+**Explanation:** Launching a pollution monitoring program *requires* physical deployment of sensors in Roskilde Fjord, regular physical sample collection, and on-site analysis. This is *unequivocally* a physical endeavor.
+
+# Physical Locations
+
+This plan implies one or more physical locations.
+
+## Requirements for physical locations
+
+- Accessibility to Roskilde Fjord
+- Suitable for deploying monitoring sensors
+- Access to laboratory facilities for sample analysis
+- Proximity to research institutions or environmental agencies
+
+## Location 1
+Denmark
+
+Roskilde Fjord, Roskilde
+
+Various locations within Roskilde Fjord
+
+**Rationale**: The program specifically targets Roskilde Fjord for pollution monitoring.
+
+## Location 2
+Denmark
+
+Roskilde
+
+Roskilde University
+
+**Rationale**: Roskilde University has environmental science programs and research facilities that could support the monitoring program.
+
+## Location 3
+Denmark
+
+Copenhagen
+
+Danish Environmental Protection Agency
+
+**Rationale**: The Danish EPA could provide expertise, resources, and regulatory oversight for the pollution monitoring program.
+
+## Location Summary
+The primary location is Roskilde Fjord, supplemented by Roskilde University for research support and the Danish Environmental Protection Agency in Copenhagen for expertise and oversight.
+
+# Currency Strategy
+
+This plan involves money.
+
+## Currencies
+
+- **DKK:** Local currency for expenses related to the monitoring program in Denmark, including equipment, personnel, and laboratory services.
+
+**Primary currency:** DKK
+
+**Currency strategy:** The Danish Krone (DKK) will be used for all transactions. No additional international risk management is needed.
+
+# Identify Risks
+
+
+## Risk 1 - Regulatory & Permitting
+Deployment of sensors and sample collection within Roskilde Fjord may require permits from local or national environmental agencies. Delays in obtaining these permits could postpone the project start.
+
+**Impact:** A delay of 1-3 months in project commencement. Potential fines if work begins without proper authorization.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Initiate the permitting process immediately. Engage with relevant authorities (e.g., Roskilde Municipality, Danish EPA) to understand requirements and timelines. Prepare all necessary documentation proactively.
+
+## Risk 2 - Technical
+Sensor malfunction or data transmission errors could lead to inaccurate or incomplete data, compromising the program's effectiveness. The real-time aspect adds complexity.
+
+**Impact:** Compromised data quality, requiring re-calibration or replacement of sensors. Potential delays in identifying pollution sources. Could lead to a 10-20% budget increase for sensor maintenance and replacement.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Select robust and reliable sensors with proven performance in marine environments. Implement a rigorous sensor calibration and maintenance schedule. Establish redundant data transmission pathways. Conduct regular data quality checks.
+
+## Risk 3 - Environmental
+The deployment and maintenance of sensors could inadvertently cause localized environmental damage (e.g., disturbance to benthic habitats, introduction of pollutants from sensor materials).
+
+**Impact:** Localized habitat damage, potentially triggering further environmental concerns and negative public perception. Fines from environmental agencies.
+
+**Likelihood:** Low
+
+**Severity:** Medium
+
+**Action:** Conduct an environmental impact assessment prior to deployment. Select sensor materials that are environmentally benign. Implement best practices for sensor deployment and maintenance to minimize disturbance. Monitor the deployment sites for any signs of environmental damage.
+
+## Risk 4 - Operational
+Adverse weather conditions (e.g., storms, ice) could hinder sensor deployment, sample collection, and maintenance activities. This is particularly relevant in a fjord environment.
+
+**Impact:** Delays in data collection, potentially leading to gaps in the monitoring record. Increased operational costs due to weather-related disruptions. A delay of 2-4 weeks is possible.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Develop a weather contingency plan. Schedule fieldwork during periods of historically favorable weather. Utilize weather forecasting services to anticipate and avoid adverse conditions. Invest in equipment suitable for a range of weather conditions.
+
+## Risk 5 - Supply Chain
+Delays in the delivery of sensors, laboratory equipment, or other essential supplies could postpone the project start or disrupt ongoing operations.
+
+**Impact:** Project delays, increased costs due to expedited shipping or alternative sourcing. A delay of 1-2 months is possible.
+
+**Likelihood:** Low
+
+**Severity:** Medium
+
+**Action:** Establish relationships with multiple suppliers. Maintain a buffer stock of critical supplies. Closely monitor supplier performance and delivery schedules. Consider local suppliers to reduce lead times.
+
+## Risk 6 - Financial
+Unexpected cost overruns (e.g., due to sensor failures, permitting delays, or increased labor costs) could strain the project budget.
+
+**Impact:** Reduced scope of the monitoring program, delays in data analysis, or project termination. An extra cost of 5,000-10,000 DKK is possible.
+
+**Likelihood:** Medium
+
+**Severity:** Medium
+
+**Action:** Develop a detailed budget with contingency funds. Closely monitor project expenditures. Implement cost control measures. Secure additional funding sources if possible.
+
+## Risk 7 - Social
+Lack of public awareness or support for the monitoring program could hinder its effectiveness. Concerns about data privacy or potential impacts on fishing activities could lead to opposition.
+
+**Impact:** Difficulty obtaining access to sampling locations, resistance to sensor deployment, or negative media coverage. Reduced public trust in the program's findings.
+
+**Likelihood:** Low
+
+**Severity:** Medium
+
+**Action:** Develop a public outreach and engagement plan. Communicate the program's goals and benefits clearly and transparently. Address public concerns proactively. Involve local stakeholders in the monitoring process.
+
+## Risk 8 - Security
+Vandalism or theft of sensors could disrupt the monitoring program and require costly replacements.
+
+**Impact:** Data loss, project delays, and increased costs for sensor replacement. A delay of 1-2 weeks is possible.
+
+**Likelihood:** Low
+
+**Severity:** Low
+
+**Action:** Deploy sensors in secure locations. Implement security measures (e.g., GPS tracking, tamper alarms). Establish relationships with local law enforcement.
+
+## Risk summary
+The most critical risks are related to regulatory permitting, technical sensor reliability, and potential environmental impacts from sensor deployment. Obtaining permits promptly is crucial to avoid delays. Selecting robust sensors and implementing a rigorous maintenance schedule will minimize data loss. A proactive environmental impact assessment and careful deployment practices will mitigate potential harm to the fjord ecosystem. These three areas require the most attention to ensure the program's success.
+
+# Make Assumptions
+
+
+## Question 1 - What is the total budget allocated for the pollution monitoring program, and what are the specific funding sources?
+
+**Assumptions:** Assumption: The initial budget for the program is 500,000 DKK, sourced from a combination of government grants (70%) and private donations (30%). This is a reasonable starting point for a localized environmental monitoring program, based on similar initiatives in the region.
+
+**Assessments:** Title: Financial Feasibility Assessment
+Description: Evaluation of the program's financial viability based on the allocated budget and funding sources.
+Details: A 500,000 DKK budget may be sufficient for initial setup and operation for one year. Risks include potential cost overruns (identified in 'identify_risks.json'). Mitigation strategies include securing additional funding sources and implementing strict cost control measures. Opportunity: Explore partnerships with local businesses for in-kind contributions or sponsorships.
+
+## Question 2 - What is the planned duration of the monitoring program, and what are the key milestones for sensor deployment, data collection, and analysis?
+
+**Assumptions:** Assumption: The monitoring program is planned for a duration of three years, with key milestones including sensor deployment within the first three months, quarterly data collection and analysis reports, and an annual comprehensive report. This timeline allows for sufficient data collection to identify trends and assess the effectiveness of any remediation efforts.
+
+**Assessments:** Title: Timeline Adherence Assessment
+Description: Analysis of the project timeline and its feasibility, considering potential delays and dependencies.
+Details: The three-year duration is adequate for long-term trend analysis. Risk: Delays in permitting (identified in 'identify_risks.json') could impact the sensor deployment milestone. Mitigation: Proactive engagement with regulatory bodies. Opportunity: Phased sensor deployment to accelerate initial data collection.
+
+## Question 3 - What specific personnel and equipment are required for the program, including expertise in sensor technology, data analysis, and field operations?
+
+**Assumptions:** Assumption: The program requires a team of three environmental scientists, two field technicians, and access to a fully equipped environmental laboratory. This is based on the scope of the monitoring program and the need for both field data collection and laboratory analysis.
+
+**Assessments:** Title: Resource Allocation Assessment
+Description: Evaluation of the adequacy of personnel and equipment resources for the program's objectives.
+Details: Three scientists and two technicians are likely sufficient. Risk: Technical sensor issues (identified in 'identify_risks.json') may require additional expertise. Mitigation: Contract with external sensor specialists. Opportunity: Collaboration with Roskilde University to leverage student researchers.
+
+## Question 4 - What specific regulatory approvals and permits are required for sensor deployment and data collection in Roskilde Fjord?
+
+**Assumptions:** Assumption: Permits are required from Roskilde Municipality and the Danish Environmental Protection Agency for sensor deployment and water sampling. This is based on standard environmental regulations in Denmark.
+
+**Assessments:** Title: Regulatory Compliance Assessment
+Description: Evaluation of the program's adherence to relevant environmental regulations and permitting requirements.
+Details: Permitting delays are a significant risk (identified in 'identify_risks.json'). Mitigation: Early and proactive engagement with regulatory bodies. Opportunity: Establish a strong working relationship with regulators to streamline future monitoring efforts.
+
+## Question 5 - What safety protocols will be implemented to protect personnel during field operations, particularly considering the fjord environment and potential weather hazards?
+
+**Assumptions:** Assumption: Standard maritime safety protocols will be followed, including the use of personal flotation devices, weather monitoring, and emergency communication equipment. This is based on standard safety practices for working in marine environments.
+
+**Assessments:** Title: Safety and Risk Management Assessment
+Description: Evaluation of safety protocols and risk mitigation strategies for field operations.
+Details: Adverse weather is a significant risk (identified in 'identify_risks.json'). Mitigation: Weather contingency plan and appropriate equipment. Opportunity: Implement a comprehensive safety training program for all personnel.
+
+## Question 6 - What measures will be taken to minimize the environmental impact of sensor deployment and maintenance activities in Roskilde Fjord?
+
+**Assumptions:** Assumption: Environmentally benign sensor materials will be used, and deployment will be conducted to minimize disturbance to benthic habitats. This is based on best practices for environmental monitoring.
+
+**Assessments:** Title: Environmental Impact Assessment
+Description: Evaluation of the program's potential environmental impact and mitigation strategies.
+Details: Sensor deployment could cause localized damage (identified in 'identify_risks.json'). Mitigation: Environmental impact assessment and careful deployment practices. Opportunity: Use of biodegradable sensor components where feasible.
+
+## Question 7 - How will local stakeholders, including fishermen, residents, and environmental groups, be involved in the monitoring program?
+
+**Assumptions:** Assumption: A public outreach program will be implemented to inform stakeholders about the program's goals and benefits, and to solicit their feedback. This is based on the importance of public support for environmental monitoring initiatives.
+
+**Assessments:** Title: Stakeholder Engagement Assessment
+Description: Evaluation of the program's engagement with local stakeholders and its impact on public perception.
+Details: Lack of public support is a potential risk (identified in 'identify_risks.json'). Mitigation: Public outreach and engagement plan. Opportunity: Involve stakeholders in data interpretation and dissemination.
+
+## Question 8 - What specific data management and analysis systems will be used to process and interpret the real-time data collected from the sensors?
+
+**Assumptions:** Assumption: A cloud-based data management system will be used to store and analyze the data, with automated alerts triggered when pollution levels exceed pre-defined thresholds. This is based on the need for real-time data analysis and efficient data management.
+
+**Assessments:** Title: Operational Systems Assessment
+Description: Evaluation of the data management and analysis systems used in the program.
+Details: Sensor malfunction and data errors are a risk (identified in 'identify_risks.json'). Mitigation: Robust sensor calibration and redundant data transmission. Opportunity: Develop a publicly accessible data dashboard to enhance transparency.
+
+# Distill Assumptions
+
+- The initial budget is 500,000 DKK, with 70% from grants and 30% donations.
+- The monitoring program will last three years, with quarterly data reports.
+- The program requires three environmental scientists and two field technicians.
+- Permits are required from Roskilde Municipality and the Danish Environmental Protection Agency.
+- Standard maritime safety protocols will be followed during field operations.
+- Environmentally benign sensor materials will be used to minimize habitat disturbance.
+- A public outreach program will inform stakeholders and solicit their feedback.
+- A cloud system will store data, with alerts for pollution levels exceeding thresholds.
+
+# Review Assumptions
+
+## Domain of the expert reviewer
+Environmental Project Management and Risk Assessment
+
+## Domain-specific considerations
+
+- Environmental regulations and compliance
+- Stakeholder engagement and community relations
+- Data quality and reliability
+- Long-term sustainability of the monitoring program
+- Specifics of fjord environments
+
+## Issue 1 - Long-Term Funding Sustainability
+The assumption of a 500,000 DKK budget with 70% from grants and 30% from donations is a good starting point, but it lacks detail regarding the *long-term sustainability* of funding. Grant funding is often project-specific and may not be renewable. Reliance on donations can be unpredictable. A lack of a long-term funding strategy could lead to premature termination of the monitoring program, undermining its long-term value and ROI.
+
+**Recommendation:** Develop a comprehensive long-term funding strategy that includes: (1) Identifying potential recurring grant opportunities (e.g., EU environmental funds, national research grants). (2) Diversifying funding sources to include corporate sponsorships, philanthropic foundations, and citizen science initiatives. (3) Creating a detailed financial model that projects costs and revenues over the three-year period and beyond, including sensitivity analyses for different funding scenarios. (4) Exploring opportunities for revenue generation, such as offering data analysis services to local businesses or government agencies.
+
+**Sensitivity:** If long-term funding is not secured, the project may need to be scaled down or terminated after the initial funding period. A reduction in funding by 20% (100,000 DKK) could lead to a 15-20% reduction in the scope of the monitoring program (e.g., fewer sampling locations, less frequent data collection), reducing the ROI by 10-15%. Complete loss of grant funding after year 1 would result in project termination and a 100% loss of ROI after year 1. The baseline ROI is based on the assumption that the project will run for 3 years as planned.
+
+## Issue 2 - Data Security and Integrity
+While the assumption mentions a cloud-based data management system with automated alerts, it lacks detail regarding *data security and integrity*. Environmental data is often sensitive and could be targeted by malicious actors. A breach of data security could compromise the program's credibility, lead to regulatory penalties, and damage stakeholder trust. The real-time aspect adds complexity.
+
+**Recommendation:** Implement a robust data security plan that includes: (1) Employing encryption for data storage and transmission. (2) Implementing access controls to restrict data access to authorized personnel only. (3) Conducting regular security audits and penetration testing. (4) Establishing a data backup and recovery plan to ensure data availability in the event of a system failure or cyberattack. (5) Ensuring compliance with relevant data privacy regulations (e.g., GDPR).
+
+**Sensitivity:** A data breach could result in fines ranging from 2-4% of annual turnover under GDPR, potentially costing 10,000-20,000 DKK. Loss of public trust could reduce stakeholder engagement by 30-50%, impacting the program's effectiveness and ROI by 5-10%. The baseline ROI is based on the assumption that the data collected is secure and reliable.
+
+## Issue 3 - Community and Stakeholder Engagement Depth
+The assumption of a public outreach program is a good start, but it lacks detail regarding the *depth and breadth* of community and stakeholder engagement. Simply informing stakeholders is not enough; active involvement and co-creation are crucial for building trust and ensuring the program's long-term success. A lack of meaningful engagement could lead to resistance to sensor deployment, skepticism about the program's findings, and ultimately, a failure to achieve its objectives.
+
+**Recommendation:** Develop a comprehensive stakeholder engagement plan that includes: (1) Conducting stakeholder mapping to identify key stakeholders and their interests. (2) Establishing a stakeholder advisory group to provide ongoing feedback and guidance. (3) Organizing public forums and workshops to discuss the program's goals, methods, and findings. (4) Involving local stakeholders in data collection and analysis (e.g., citizen science initiatives). (5) Communicating the program's findings in a clear and accessible manner to the public.
+
+**Sensitivity:** If the community opposes the project, the project could be delayed by 2-4 months, and the cost could increase by 5-10% due to the need for additional consultations and mitigation measures. A lack of stakeholder buy-in could reduce the program's effectiveness by 10-20%, impacting the ROI by 5-10%. The baseline ROI is based on the assumption that the community supports the project.
+
+## Review conclusion
+The pollution monitoring program in Roskilde Fjord has a solid foundation, but it needs to address the long-term sustainability of funding, data security and integrity, and the depth of community and stakeholder engagement. By developing comprehensive strategies in these areas, the program can increase its chances of success and maximize its impact on the environment and the community.

src/plan/test_data/solarfarm_consolidate_assumptions_short.md

@@ -0,0 +1,306 @@
+# Plan Type
+- Requires physical locations.
+- Cannot be executed digitally.
+
+## Explanation
+
+- Solar farm requires physical location, construction, installation, and maintenance.
+- Inherently a physical project.
+
+
+# Physical Locations
+This plan implies one or more physical locations.
+
+## Requirements for physical locations
+
+- High solar irradiance
+- Available land area
+- Proximity to grid infrastructure
+- Favorable zoning regulations
+
+## Location 1
+Denmark, West Jutland, Near Varde
+
+Rationale: Flat terrain, good grid access, available land, favorable conditions.
+
+## Location 2
+Denmark, South Jutland, Near Tønder
+
+Rationale: Ample open space, significant sunlight, proximity to German border for potential energy export.
+
+## Location 3
+Denmark, Zealand, Near Holbæk
+
+Rationale: Balance of available land and proximity to major population centers, reducing transmission losses. Existing infrastructure.
+
+## Location Summary
+Locations in West Jutland (near Varde), South Jutland (near Tønder), and Zealand (near Holbæk) offer suitable land area, high solar irradiance, proximity to grid infrastructure, and favorable zoning regulations.
+
+# Currency Strategy
+## Currencies
+
+- DKK: Project in Denmark, needed for local expenses.
+- EUR: Denmark is part of the EU, simplifies transactions.
+
+Primary currency: DKK
+
+Currency strategy: DKK for local transactions. Hedge against exchange rate fluctuations between DKK and EUR/USD for international transactions.
+
+# Identify Risks
+# Risk 1 - Regulatory & Permitting
+Delays in permits/approvals from Danish authorities. Changes in regulations.
+
+- Impact: 6-12 month delays, 5-10% cost increase, or cancellation.
+- Likelihood: Medium
+- Severity: High
+- Action: Engage regulators early. Conduct impact assessments. Secure legal counsel. Develop contingency plans.
+
+# Risk 2 - Technical
+Technical challenges during construction/operation. Suboptimal performance.
+
+- Impact: 5-15% reduced output, 20-50k DKK increased costs, 1-2 weeks downtime.
+- Likelihood: Medium
+- Severity: Medium
+- Action: Conduct site assessments. Select proven tech. Implement monitoring. Secure warranties. Plan for redundancy.
+
+# Risk 3 - Financial
+Cost overruns. Difficulty securing financing. Lower energy prices.
+
+- Impact: 10-20% budget increase, reduced ROI, or abandonment.
+- Likelihood: Medium
+- Severity: High
+- Action: Develop realistic budget with 10-15% contingency. Secure financing early. Implement cost controls. Hedge currency. Forecast energy prices.
+
+# Risk 4 - Environmental
+Negative environmental impacts. Public opposition.
+
+- Impact: Project delays, 10-30k DKK mitigation costs, reputational damage, or cancellation.
+- Likelihood: Low
+- Severity: Medium
+- Action: Conduct impact assessments. Implement best practices. Engage communities. Develop management plan.
+
+# Risk 5 - Social
+Public opposition. Lack of community support.
+
+- Impact: Project delays, increased costs, or reputational damage.
+- Likelihood: Low
+- Severity: Medium
+- Action: Engage communities early. Address concerns. Offer community benefits.
+
+# Risk 6 - Operational
+Difficulties in operating/maintaining the farm.
+
+- Impact: Reduced output, increased costs, or downtime.
+- Likelihood: Medium
+- Severity: Medium
+- Action: Develop maintenance plan. Train personnel. Implement cybersecurity. Secure service agreements.
+
+# Risk 7 - Supply Chain
+Disruptions in supply chain.
+
+- Impact: 3-6 month delays, 5-10% increased costs, or difficulty completing project.
+- Likelihood: Medium
+- Severity: Medium
+- Action: Diversify suppliers. Maintain buffer stocks. Monitor supply chain. Secure supply agreements.
+
+# Risk 8 - Security
+Theft, vandalism, or sabotage.
+
+- Impact: Project delays, increased security costs, or damage.
+- Likelihood: Low
+- Severity: Medium
+- Action: Implement security measures. Hire personnel. Conduct background checks. Establish relationships with law enforcement.
+
+# Risk 9 - Grid Integration
+Challenges in connecting to the grid.
+
+- Impact: 2-4 week delays, reduced output, or increased grid upgrade costs.
+- Likelihood: Medium
+- Severity: Medium
+- Action: Engage grid operator early. Conduct impact studies. Secure agreements. Invest in upgrades.
+
+# Risk 10 - Market & Competitive
+Changes in electricity market dynamics.
+
+- Impact: Reduced prices, lower profitability, or difficulty competing.
+- Likelihood: Low
+- Severity: Medium
+- Action: Conduct market analysis. Secure PPAs. Advocate for renewable policies.
+
+# Risk 11 - Long-Term Sustainability
+Degradation of panel performance. End-of-life disposal.
+
+- Impact: Reduced output, increased costs, or environmental liabilities.
+- Likelihood: Medium
+- Severity: Medium
+- Action: Select high-quality panels. Develop disposal plan. Explore recycling.
+
+# Risk summary
+Critical risks: Regulatory & Permitting, Financial, and Technical. Mitigation: early engagement, securing financing, proven technologies, site assessments, monitoring, and supplier diversification.
+
+# Make Assumptions
+# Question 1 - Estimated Total Budget
+
+- Assumption: 50 million DKK, including 15% contingency.
+
+## Assessments
+
+- Title: Financial Feasibility Assessment
+- Description: Evaluation of financial viability.
+- Details: Requires significant funding. Risks: cost overruns, lower energy prices. Mitigation: long-term PPAs, cost control. Benefits: strong ROI. Opportunity: government subsidies.
+
+# Question 2 - Projected Timeline
+
+- Assumption: 24 months (6 planning/permitting, 12 construction, 6 grid connection/commissioning).
+
+## Assessments
+
+- Title: Timeline and Milestone Assessment
+- Description: Analysis of timeline.
+- Details: Aggressive timeline. Risks: permitting delays, construction challenges. Mitigation: early engagement, risk management. Benefits: early revenue. Opportunity: streamline processes.
+
+# Question 3 - Personnel and Resources
+
+- Assumption: 5 engineers, 2 project managers, 50 construction workers, specialized equipment.
+
+## Assessments
+
+- Title: Resource and Personnel Assessment
+- Description: Evaluation of resources.
+- Details: Securing personnel/equipment is crucial. Risks: labor shortages, equipment malfunctions. Mitigation: recruitment, maintenance. Benefits: efficient execution. Opportunity: partner with training institutions.
+
+# Question 4 - Regulations and Governance
+
+- Assumption: Governed by Danish energy regulations, EIA, grid connection agreements.
+
+## Assessments
+
+- Title: Governance and Regulations Assessment
+- Description: Analysis of regulatory framework.
+- Details: Compliance is essential. Risks: permitting delays, regulatory changes. Mitigation: early engagement, legal counsel. Benefits: smooth permitting. Opportunity: advocate for policies.
+
+# Question 5 - Safety Protocols and Risk Management
+
+- Assumption: Mandatory safety training, inspections, emergency response plans.
+
+## Assessments
+
+- Title: Safety and Risk Management Assessment
+- Description: Evaluation of safety protocols.
+- Details: Prioritizing safety is paramount. Risks: accidents, injuries. Mitigation: training, inspections. Benefits: safe environment, reduced liability. Opportunity: implement safety technologies.
+
+# Question 6 - Environmental Impact
+
+- Assumption: EIA, mitigation measures, habitat restoration, erosion control, waste management.
+
+## Assessments
+
+- Title: Environmental Impact Assessment
+- Description: Analysis of environmental impact.
+- Details: Minimizing impact is crucial. Risks: habitat disruption, water contamination. Mitigation: EIAs, best practices. Benefits: positive image. Opportunity: biodiversity enhancement.
+
+# Question 7 - Stakeholder Involvement
+
+- Assumption: Public consultations, community meetings, feedback mechanisms.
+
+## Assessments
+
+- Title: Stakeholder Involvement Assessment
+- Description: Evaluation of stakeholder engagement.
+- Details: Community support is essential. Risks: public opposition. Mitigation: proactive engagement. Benefits: positive relationship. Opportunity: community benefits.
+
+# Question 8 - Operational Systems
+
+- Assumption: SCADA, CMMS, security systems.
+
+## Assessments
+
+- Title: Operational Systems Assessment
+- Description: Analysis of operational systems.
+- Details: Efficient operation is crucial. Risks: equipment failures, security breaches. Mitigation: monitoring, maintenance. Benefits: optimized production. Opportunity: predictive maintenance.
+
+
+# Distill Assumptions
+# Project Overview
+
+- Budget: 50 million DKK (15% contingency)
+- Timeline: 24 months (6 planning, 12 construction, 6 grid)
+- Resources: 5 engineers, 2 project managers, 50 construction workers, specialized equipment
+
+## Regulatory Compliance
+
+- Governed by Danish energy regulations: Electricity Supply Act, Renewable Energy Act, EIA, Energinet
+
+## Safety and Environment
+
+- Implement safety training, inspections, emergency plans (Danish standards)
+- EIA: habitat restoration, erosion control, waste management
+
+## Stakeholder Engagement
+
+- Consultations and feedback to address concerns
+
+## Technology
+
+- SCADA for energy monitoring
+- CMMS for maintenance
+- Security systems
+
+
+# Review Assumptions
+# Domain of the expert reviewer
+Renewable Energy Project Finance and Risk Management
+
+## Domain-specific considerations
+
+- Energy market dynamics in Denmark and neighboring countries
+- Grid connection costs and capacity constraints
+- Long-term power purchase agreement (PPA) terms
+- Technological advancements in solar panel efficiency and energy storage
+- Political and regulatory landscape for renewable energy in Denmark
+
+## Issue 1 - Incomplete Financial Model and Revenue Projections
+The budget assumption lacks granularity. A detailed financial model is missing, including revenue projections based on realistic energy prices, PPA terms, and potential for ancillary services. Without this, the project's ROI and financial viability are uncertain. The plan does not address energy price volatility.
+
+Recommendation:
+
+- Develop a comprehensive financial model with detailed cost breakdowns and revenue projections based on various energy price scenarios and PPA terms.
+- Conduct a sensitivity analysis to assess the impact of key variables on the project's ROI.
+- Secure a PPA with a reputable off-taker to provide revenue certainty.
+
+Sensitivity:
+
+- A 10% decrease in energy prices could reduce the project's ROI by 8-12%.
+- A 2% increase in interest rates could increase the total project cost by 3-5% and delay the ROI by 1-2 years.
+
+## Issue 2 - Lack of Specificity Regarding Grid Connection and Capacity
+The plan lacks specific details about the available grid capacity and associated costs for grid connection upgrades. Insufficient grid capacity or high connection costs could significantly impact the project's timeline and budget. The plan does not address the potential for curtailment.
+
+Recommendation:
+
+- Conduct a detailed grid impact study for each proposed location.
+- Obtain firm cost estimates for grid connection.
+- Negotiate grid connection agreements that address potential curtailment issues.
+- Explore options for on-site energy storage.
+
+Sensitivity:
+
+- Required grid connection upgrades could increase the total project cost by 10-15% and delay the project completion date by 3-6 months.
+- Curtailment occurring 5% of the time could reduce the project's annual revenue by 3-5%.
+
+## Issue 3 - Insufficient Consideration of Long-Term Operational Costs and Panel Degradation
+The plan lacks a detailed assessment of long-term operational costs and does not explicitly address the impact of panel degradation on energy output and revenue.
+
+Recommendation:
+
+- Develop a detailed O&M budget with realistic estimates for all operational costs.
+- Incorporate panel degradation rates into the financial model.
+- Consider investing in higher-quality panels with lower degradation rates.
+
+Sensitivity:
+
+- A 0.2% increase in the annual panel degradation rate could reduce the project's cumulative energy output by 5-7% over 25 years and decrease the ROI by 3-5%.
+- A 20% increase in annual O&M costs could reduce the project's ROI by 2-3%.
+
+## Review conclusion
+The solar farm project has potential but requires a more detailed plan addressing gaps in financial modeling, grid connection, and long-term operational costs. By conducting thorough assessments, securing firm commitments, and implementing robust risk management strategies, the project can maximize its ROI.

src/report/report_generator.py

@@ -9,6 +9,7 @@ import re
 import json
 import logging
 import pandas as pd
+from dataclasses import dataclass
 from pathlib import Path
 from datetime import datetime
 import markdown
@@ -16,9 +17,14 @@ from typing import Dict, Any, Optional
 
 logger = logging.getLogger(__name__)
 
+@dataclass
+class ReportDocumentItem:
+    document_title: str
+    document_html_content: str
+
 class ReportGenerator:
     def __init__(self):
-        self.report_data = {}
+        self.report_item_list: list[ReportDocumentItem] = []
         
     def read_json_file(self, file_path: Path) -> Optional[Dict[str, Any]]:
         """Read a JSON file and return its contents."""
@@ -81,44 +87,26 @@ class ReportGenerator:
             logging.error(f"Error reading CSV file {file_path}: {str(e)}")
             return None
 
-    def append_assumptions_markdown(self, file_path: Path):
-        """Append the assumptions markdown to the report."""
-        markdown = self.read_markdown_file(file_path)
-        if markdown:
-            self.report_data['assumptions'] = markdown
-    
-    def append_pitch_markdown(self, file_path: Path):
-        """Append the pitch markdown to the report."""
-        markdown = self.read_markdown_file(file_path)
-        if markdown:
-            self.report_data['pitch'] = markdown
-    
-    def append_swot_analysis_markdown(self, file_path: Path):
-        """Append the SWOT markdown to the report."""
-        markdown = self.read_markdown_file(file_path)
-        if markdown:
-            self.report_data['swot'] = markdown
-    
-    def append_team_markdown(self, file_path: Path):
-        """Append the team markdown to the report."""
-        markdown = self.read_markdown_file(file_path)
-        if markdown:
-            self.report_data['team'] = markdown
-    
-    def append_expert_criticism_markdown(self, file_path: Path):
-        """Append the expert criticism markdown to the report."""
-        markdown = self.read_markdown_file(file_path)
-        if markdown:
-            self.report_data['expert_criticism'] = markdown
+    def append_markdown(self, document_title: str, file_path: Path):
+        """Append a markdown document to the report."""
+        md_data = self.read_markdown_file(file_path)
+        if md_data is None:
+            logging.warning(f"Document: '{document_title}'. Could not read markdown file: {file_path}")
+            return
+        html = markdown.markdown(md_data)
+        self.report_item_list.append(ReportDocumentItem(document_title, html))
     
-    def append_project_plan_csv(self, file_path: Path):
-        """Append the project plan CSV to the report."""
-        plan_df = self.read_csv_file(file_path)
-        if plan_df is not None:
-            # Clean up the dataframe
-            # Remove any completely empty rows or columns
-            plan_df = plan_df.dropna(how='all', axis=0).dropna(how='all', axis=1)
-            self.report_data['project_plan'] = plan_df
+    def append_csv(self, document_title: str, file_path: Path):
+        """Append a CSV to the report."""
+        df_data = self.read_csv_file(file_path)
+        if df_data is None:
+            logging.warning(f"Document: '{document_title}'. Could not read CSV file: {file_path}")
+            return
+        # Clean up the dataframe
+        # Remove any completely empty rows or columns
+        df = df_data.dropna(how='all', axis=0).dropna(how='all', axis=1)
+        html = df.to_html(classes='dataframe', index=False, na_rep='')
+        self.report_item_list.append(ReportDocumentItem(document_title, html))
 
     def generate_html_report(self) -> str:
         """Generate an HTML report from the gathered data."""
@@ -144,25 +132,8 @@ class ReportGenerator:
             </div>
             """)
 
-        if 'pitch' in self.report_data:
-            add_section('Project Pitch', markdown.markdown(self.report_data['pitch']))
-        
-        if 'assumptions' in self.report_data:
-            add_section('Assumptions', markdown.markdown(self.report_data['assumptions']))
-
-        if 'swot' in self.report_data:
-            add_section('SWOT Analysis', markdown.markdown(self.report_data['swot']))
-
-        if 'team' in self.report_data:
-            add_section('Team', markdown.markdown(self.report_data['team']))
-
-        if 'expert_criticism' in self.report_data:
-            add_section('Expert Criticism', markdown.markdown(self.report_data['expert_criticism']))
-
-        if 'project_plan' in self.report_data:
-            df = self.report_data['project_plan']
-            table_html = df.to_html(classes='dataframe', index=False, na_rep='')
-            add_section('Project Plan', table_html)
+        for item in self.report_item_list:
+            add_section(item.document_title, item.document_html_content)
 
         html_content = '\n'.join(html_parts)
 
@@ -213,12 +184,12 @@ def main():
     output_path = input_path / FilenameEnum.REPORT.value
     
     report_generator = ReportGenerator()
-    report_generator.append_pitch_markdown(input_path / FilenameEnum.PITCH_MARKDOWN.value)
-    report_generator.append_assumptions_markdown(input_path / FilenameEnum.CONSOLIDATE_ASSUMPTIONS_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.append_markdown('Pitch', input_path / FilenameEnum.PITCH_MARKDOWN.value)
+    report_generator.append_markdown('Assumptions', input_path / FilenameEnum.CONSOLIDATE_ASSUMPTIONS_FULL_MARKDOWN.value)
+    report_generator.append_markdown('SWOT Analysis', input_path / FilenameEnum.SWOT_MARKDOWN.value)
+    report_generator.append_markdown('Team', input_path / FilenameEnum.TEAM_MARKDOWN.value)
+    report_generator.append_markdown('Expert Criticism', input_path / FilenameEnum.EXPERT_CRITICISM_MARKDOWN.value)
+    report_generator.append_csv('Work Breakdown Structure', input_path / FilenameEnum.WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_CSV.value)
     report_generator.save_report(output_path)
         
     if not args.no_browser:

src/swot/app_swot_analysis.py

@@ -31,7 +31,7 @@ for prompt_item in all_prompts:
     gradio_examples.append([prompt_item.prompt])
 
 llm_info = LLMInfo.obtain_info()
-logger.info(f"LLMInfo.is_ollama_running: {llm_info.is_ollama_running}")
+logger.info(f"LLMInfo.ollama_status: {llm_info.ollama_status.value}")
 logger.info(f"LLMInfo.error_message_list: {llm_info.error_message_list}")
 
 # Create tupples for the Gradio Radio buttons.

src/swot/swot_analysis.py

@@ -93,8 +93,6 @@ class SWOTAnalysis:
 
     def to_markdown(self, include_metadata=True) -> str:
         rows = []
-        rows.append(f"# SWOT Analysis")
-
         rows.append(f"\n## Topic")
         rows.append(f"{self.topic}")
 

src/swot/swot_phase1_determine_type.py

@@ -1,5 +1,8 @@
 """
 Determine what kind of SWOT analysis is to be conducted.
+- **Business:** Profit-Driven, aimed at generating profit.
+- **Personal:** Personal stuff, not aimed at generating profit.
+- **Other:** Doesn't fit into the above categories.
 
 PROMPT> python -m src.swot.swot_phase1_determine_type
 """