Snapshot of PlanExe commit d1eee4b3f276c3f079b95539dafb7f1f794abfa4

src/assume/README.md

@@ -1,3 +1,35 @@
 # Assume
 
-Make assumptions about the project
+Make assumptions about the project. Identify what the project *will* and *will not* include.
+
+## 1. Identify Plan Type
+
+- **Digital:** Is this a purely digital project. Can it be executed by agents.
+- **Physical:** Or does this project require physical locations.
+
+## 2. Physical Locations
+
+Where does it take place.
+
+If it's a bridge between 2 countries, then both country A and country B are the physical locations.
+
+## 3. Currency
+
+Decide what currency to use.
+
+If the project takes place in one country, then that country's local currency may be relevant.
+In case the local currency is volatile, then pick a more stable currency.
+
+If it's a global project, then pick a global currency.
+
+## 4. Identify Risks
+
+Understanding potential risks can help you make more informed and realistic assumptions.
+
+## 5. Informed Assumptions
+
+Once you have a preliminary list of risks, you can use them to shape your assumptions.
+
+## 6. Reviewing Assumptions
+
+Bad assumptions impacts the entire plan. Try identify what is wrong about the assumptions found so far. 

src/assume/assumption_orchestrator.py

@@ -1,72 +0,0 @@
-"""
-PROMPT> python -m src.assume.assumption_orchestrator
-"""
-import logging
-from llama_index.core.llms.llm import LLM
-from src.assume.make_assumptions import MakeAssumptions
-from src.assume.distill_assumptions import DistillAssumptions
-from src.format_json_for_use_in_query import format_json_for_use_in_query
-
-logger = logging.getLogger(__name__)
-
-class AssumptionOrchestrator:
-    def __init__(self):
-        self.phase1_post_callback = None
-        self.phase2_post_callback = None
-        self.make_assumptions: MakeAssumptions = None
-        self.distill_assumptions: DistillAssumptions = None
-
-    def execute(self, llm: LLM, query: str) -> None:
-        logger.info("Making assumptions...")
-
-        self.make_assumptions = MakeAssumptions.execute(llm, query)
-        if self.phase1_post_callback:
-            self.phase1_post_callback(self.make_assumptions)
-
-        logger.info(f"Distilling assumptions...")
-
-        assumptions_json_string = format_json_for_use_in_query(self.make_assumptions.assumptions)
-
-        query2 = (
-            f"{query}\n\n"
-            f"assumption.json:\n{assumptions_json_string}"
-        )
-        self.distill_assumptions = DistillAssumptions.execute(llm, query2)
-        if self.phase2_post_callback:
-            self.phase2_post_callback(self.distill_assumptions)
-    
-if __name__ == "__main__":
-    import logging
-    from src.llm_factory import get_llm
-    from src.plan.find_plan_prompt import find_plan_prompt
-    import json
-
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.StreamHandler()
-        ]
-    )
-
-    plan_prompt = find_plan_prompt("4dc34d55-0d0d-4e9d-92f4-23765f49dd29")
-
-    llm = get_llm("ollama-llama3.1")
-    # llm = get_llm("openrouter-paid-gemini-2.0-flash-001")
-    # llm = get_llm("deepseek-chat")
-
-    def phase1_post_callback(make_assumptions: MakeAssumptions) -> None:
-        count = len(make_assumptions.assumptions)
-        d = make_assumptions.to_dict(include_system_prompt=False, include_user_prompt=False)
-        pretty = json.dumps(d, indent=2)
-        print(f"MakeAssumptions: Made {count} assumptions:\n{pretty}")
-
-    def phase2_post_callback(distill_assumptions: DistillAssumptions) -> None:
-        d = distill_assumptions.to_dict(include_system_prompt=False, include_user_prompt=False)
-        pretty = json.dumps(d, indent=2)
-        print(f"DistillAssumptions:\n{pretty}")
-
-    orchestrator = AssumptionOrchestrator()
-    orchestrator.phase1_post_callback = phase1_post_callback
-    orchestrator.phase2_post_callback = phase2_post_callback
-    orchestrator.execute(llm, plan_prompt)

src/assume/currency_strategy.py

@@ -0,0 +1,343 @@
+"""
+Pick a suitable currency for the project plan. If the description already includes the currency, then there is no need for this step.
+If the currency is not mentioned, then the expert should suggest suitable locations based on the project requirements.
+The project may go across national borders, so picking a currency that is widely accepted is important.
+
+Currency codes
+https://en.wikipedia.org/wiki/ISO_4217
+
+PROMPT> python -m src.assume.currency_strategy
+"""
+import os
+import json
+import time
+import logging
+from math import ceil
+from dataclasses import dataclass
+from typing import Optional
+from pydantic import BaseModel, Field
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.llms.llm import LLM
+
+logger = logging.getLogger(__name__)
+
+class CurrencyItem(BaseModel):
+    currency: str = Field(
+        description="ISO 4217 alphabetic code."
+    )
+    consideration: str = Field(
+        description="Why use this currency."
+    )
+
+class DocumentDetails(BaseModel):
+    money_involved: bool = Field(
+        description="True if the project likely involves any financial transactions (e.g., purchasing equipment, paying for services, travel, lab tests), otherwise False."
+    )
+    currency_list: list[CurrencyItem] = Field(
+        description="List of currencies that are relevant for this project."
+    )
+    primary_currency: Optional[str] = Field(
+        description="The main currency for budgeting and reporting (ISO 4217 alphabetic code).",
+        default=None
+    )
+    currency_strategy: str = Field(
+        description="A short summary of how to handle currency exchange and risk during the project.",
+        default=""
+    )
+
+CURRENCY_STRATEGY_SYSTEM_PROMPT_1 = """
+You are a world-class planning expert specializing in picking the best-suited currency for large, international projects. Currency decisions significantly impact project costs, reporting, and financial risk.
+
+Here's your decision-making process:
+
+1.  **Determine if money is potentially involved:**
+
+    *   Set `money_involved` to `True` if the plan *potentially* requires any financial transactions, *direct or indirect*, such as:
+        *   Buying goods or services (e.g., lab equipment, scientific instruments, sampling containers, software licenses, data sets).
+        *   Paying for services (e.g., laboratory analysis, research assistance, data analysis, travel expenses, shipping samples, transcription services, professional editing, publication fees).
+        *   Paying people (researchers, technicians, consultants, divers, boat crews, etc.) for their time and expertise.
+        *   Renting equipment or facilities (e.g., lab space, boats, diving gear).
+        *   Acquiring data (e.g., purchasing existing datasets, paying for access to databases).
+        *   Travel.
+        *   Maintaining systems.
+
+    *   Set `money_involved` to `False` only if the plan is purely non-financial and has absolutely no potential impact on financial resources.
+
+2.  **Select a primary currency:**
+
+    *   **If a specific currency *can* be determined** based on the project description and location information (e.g., the project is clearly based in the USA):
+        *   Select that currency (ISO 4217 code).
+        *   Explain your reasoning (e.g., "USD is appropriate because the project is based in the USA").
+
+    *   **If a specific currency *cannot* be determined** (e.g., the project is global, theoretical, or lacks clear financial details):
+        *   Suggest USD for all international expenses, such as travel, sample analysis, web hosting, and publication fees.
+        *   Explain your reasoning (e.g., "USD is a widely accepted currency and suitable for international research expenses.").
+
+3.  **Identify additional currencies (if any):**
+
+    *   List any other currencies that might be needed for local expenses or specific transactions.
+    *   Explain why each currency is necessary (e.g., "EUR for travel expenses in Europe").
+
+4.  **Develop a currency management strategy:**
+
+    *   Provide a brief summary of how to manage currency exchange and risk (e.g., "Use forward contracts to hedge against currency fluctuations, especially for travel expenses.").
+
+Here are a few examples of the desired output format:
+
+**Example 1:**
+Project: Constructing a solar power plant in Nevada, USA
+money_involved: True
+Currency List:
+- USD: For all project-related expenses in the USA.
+Primary Currency: USD
+Currency Strategy: Use USD for all budgeting and accounting.
+
+**Example 2:**
+Project: Building a wind farm in the North Sea (offshore UK and Netherlands)
+money_involved: True
+Currency List:
+- EUR: For equipment and services sourced from the Eurozone.
+- GBP: For equipment and services sourced from the Eurozone.
+- DKK: For Danish-based operations and services.
+Primary Currency: EUR
+Currency Strategy: EUR will be the primary currency.  Maintain accounts in GBP and DKK for local expenses.  Hedge against significant currency fluctuations.
+
+**Example 3:**
+Project: Take out the trash
+money_involved: False
+Currency List:
+Primary Currency:
+Currency Strategy:
+
+**Example 4:**
+Project: My daily commute is broken, need an alternative in Amsterdam.
+money_involved: True  # Potential for public transport, taxis, food, etc.
+Currency List:
+- EUR: For transportation and potential expenses in the Netherlands.
+Primary Currency: EUR
+Currency Strategy: Use EUR for all commute-related expenses.
+
+**Example 5:**
+Project: Distill Arxiv papers into an objective, hype-free summary and publish as an open-access dataset.
+money_involved: True # Needs development, hosting, data scraping permission
+Currency List:
+- USD: For potential web hosting and software maintainence
+Primary Currency: USD
+Currency Strategy: Use USD for all web hosting and software maintainence.
+
+**Example 6:**
+Project: I'm envisioning a streamlined global language...
+money_involved: True
+Currency List:
+- USD: Best guess for international expenses
+Primary Currency: USD
+Currency Strategy: Use USD for international expenses
+
+**Example 7:**
+Project: Create a detailed report examining microplastics within the world's oceans.
+money_involved: True # Travel, lab tests, analysis
+Currency List:
+- USD: Best guess for international expenses
+Primary Currency: USD
+Currency Strategy: Use USD for international expenses
+
+Consider the following factors when selecting currencies:
+
+*   Stability: Choose currencies that are relatively stable to minimize the impact of exchange rate fluctuations on the project budget.
+*   Transaction Costs: Minimize the impact of currency conversions to reduce transaction fees.
+*   Economic Influence: Consider the economic influence of the countries involved and the currencies used by major suppliers and contractors.
+*   Reporting Requirements: Think about the reporting needs of stakeholders and investors.
+*   Project Duration: Longer projects are more susceptible to currency risk.
+*   Accounting and Tax Implications: Be aware of the accounting and tax rules regarding currency conversions.
+*   Important Currency Facts: England uses the British Pound (GBP). Denmark uses the Danish Krone (DKK), NOT the Euro.
+
+Given the project description and location information, provide the following:
+
+1.  money_involved (True/False)
+2.  currency_list
+3.  primary_currency
+4.  currency_strategy
+
+Be precise with your reasoning, and avoid making inaccurate statements about which countries use which currencies.
+"""
+
+CURRENCY_STRATEGY_SYSTEM_PROMPT_2 = """
+You are an expert planning assistant focused on selecting the best currency for projects of varying scales, from trivial personal tasks to large, international endeavors. Given a project description and any location details, produce a JSON output with the following structure:
+
+{
+  "money_involved": <Boolean>,
+  "currency_list": [
+      {
+         "currency": "<ISO 4217 Code>",
+         "consideration": "<Brief explanation>"
+      },
+      ...
+  ],
+  "primary_currency": "<ISO 4217 Code>",
+  "currency_strategy": "<Brief explanation of currency management strategy>"
+}
+
+Guidelines:
+
+1. money_involved:
+   - Set to True if the project likely involves financial transactions such as purchasing equipment, paying for services, travel, repairs, lab tests, or any significant expenses requiring budgeting.
+   - Also mark digital, research, or industrial projects as involving money if they require development, data curation, hosting, publication fees, maintenance, or research staff—even if no physical site is needed.
+   - Set to False for trivial or personal tasks with minimal or no financial transactions.
+   - Note: Even for personal tasks, if the issue implies potential expenses (e.g., a broken bike requiring repairs or alternative transportation costs), mark money_involved as True.
+
+2. currency_list:
+   - Provide a list of relevant currencies as objects. Each object should include:
+     - currency: the ISO 4217 code.
+     - consideration: a brief explanation of why this currency is included.
+   - For projects that are clearly local (confined to one country) and not subject to economic instability, list only the local currency.
+   - For projects spanning multiple countries, list the local currencies for the countries involved if relevant.
+   - For projects in regions with multiple European countries, use EUR as the primary currency.
+   - If the project is in a country with known currency instability or hyperinflation, include both the local currency and a stable international currency (e.g., USD) in the list.
+
+3. primary_currency:
+   - If the project description explicitly mentions a specific currency, use that only if it does not conflict with the guidelines below.
+   - For projects that are clearly local in stable economies, use that country's official currency.
+   - For international projects that are not specific to one region, default to "USD".
+   - For projects spanning multiple European countries, select "EUR" as the primary currency.
+   - For significant projects in countries with notable currency instability (such as Venezuela), **do not use the local currency as primary; instead, set the primary currency to "USD"**. The local currency may still be included in the currency_list for local transactions.
+
+4. currency_strategy:
+   - For local projects, simply state that the local currency will be used for all transactions with no additional international risk management needed.
+   - For international projects, provide a brief explanation of how to manage currency risks (e.g., hedging against exchange fluctuations or using cards with no foreign transaction fees).
+   - For projects spanning multiple European countries with "EUR" as the primary currency, note that EUR will be used for consolidated budgeting while local currencies may still be used for local transactions.
+   - For projects in countries with currency instability, explain that a stable international currency (e.g., USD) is recommended for budgeting and reporting to mitigate risks from hyperinflation, and that for significant projects the primary currency must be "USD".
+
+Key Instructions:
+- Evaluate the project's scale, geographic scope, and local economic conditions using the provided project description and location details.
+- Ensure that no field is left empty when significant expenses are expected.
+- Apply the appropriate currency guidelines based on the project's geographic scope, local economic conditions, and scale.
+"""
+
+CURRENCY_STRATEGY_SYSTEM_PROMPT = CURRENCY_STRATEGY_SYSTEM_PROMPT_2
+
+@dataclass
+class CurrencyStrategy:
+    """
+    Take a look at the vague plan description, the physical locations and suggest a currency.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    markdown: str
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'CurrencyStrategy':
+        """
+        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 = CURRENCY_STRATEGY_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 = CurrencyStrategy(
+            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 = []
+
+        if document_details.money_involved:
+            rows.append("This plan involves money.")
+        else:
+            rows.append("This plan **does not** involve money.")
+
+        if len(document_details.currency_list) > 0:
+            rows.append("\n## Currencies\n")
+            for currency_item in document_details.currency_list:
+                rows.append(f"- **{currency_item.currency}:** {currency_item.consideration}")
+        else:
+            rows.append("No currencies identified.")
+
+        rows.append(f"\n**Primary currency:** {document_details.primary_currency}")
+        rows.append(f"\n**Currency strategy:** {document_details.currency_strategy}")        
+        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.utils.concat_files_into_string import concat_files_into_string
+
+    base_path = os.path.join(os.path.dirname(__file__), 'test_data', 'currency_strategy7')
+
+    all_documents_string = concat_files_into_string(base_path)
+    print(all_documents_string)
+
+    llm = get_llm("ollama-llama3.1")
+
+    currency_strategy = CurrencyStrategy.execute(llm, all_documents_string)
+    json_response = currency_strategy.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{currency_strategy.markdown}")

src/assume/distill_assumptions.py

@@ -8,6 +8,14 @@ The llama3.1 has no problems with it.
 
 IDEA: Sometimes it recognizes that the project starts ASAP as an assumption. This is already part of the project description, this is not something new.
 How do I suppress this kind of information from the output?
+
+IDEA: If there is a mismatch between the number of assumptions in the input and the output.
+Then it's likely that one or more assumptions are getting lost or introduced.
+The number of assumptions should be the same in the input and output.
+Ideally track the assumptions in the input with a uuid, that stays the same in the output.
+If one of the input assumptions gets splitted into 2 assumptions, then the source id should be the same for both.
+
+PROMPT> python -m src.assume.distill_assumptions
 """
 import json
 import time
@@ -126,6 +134,7 @@ class DistillAssumptions:
     user_prompt: str
     response: dict
     metadata: dict
+    markdown: str
 
     @classmethod
     def execute(cls, llm: LLM, user_prompt: str, **kwargs: Any) -> 'DistillAssumptions':
@@ -155,9 +164,9 @@ class DistillAssumptions:
         if system_prompt and not isinstance(system_prompt, str):
             raise ValueError("Invalid system prompt.")
 
-        chat_message_list1 = []
+        chat_message_list = []
         if system_prompt:
-            chat_message_list1.append(
+            chat_message_list.append(
                 ChatMessage(
                     role=MessageRole.SYSTEM,
                     content=system_prompt,
@@ -169,16 +178,16 @@ class DistillAssumptions:
             role=MessageRole.USER,
             content=user_prompt,
         )
-        chat_message_list1.append(chat_message_user)
+        chat_message_list.append(chat_message_user)
 
         sllm = llm.as_structured_llm(AssumptionDetails)
 
         logger.debug("Starting LLM chat interaction.")
         start_time = time.perf_counter()
-        chat_response1 = sllm.chat(chat_message_list1)
+        chat_response = sllm.chat(chat_message_list)
         end_time = time.perf_counter()
         duration = int(ceil(end_time - start_time))
-        response_byte_count = len(chat_response1.message.content.encode('utf-8'))
+        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)
@@ -187,16 +196,19 @@ class DistillAssumptions:
         metadata["response_byte_count"] = response_byte_count
 
         try:
-            json_response = json.loads(chat_response1.message.content)
+            json_response = json.loads(chat_response.message.content)
         except json.JSONDecodeError as e:
             logger.error("Failed to parse LLM response as JSON.", exc_info=True)
             raise ValueError("Invalid JSON response from LLM.") from e
 
+        markdown = cls.convert_to_markdown(chat_response.raw)
+
         result = DistillAssumptions(
             system_prompt=system_prompt,
             user_prompt=user_prompt,
             response=json_response,
             metadata=metadata,
+            markdown=markdown
         )
         logger.debug("DistillAssumptions instance created successfully.")
         return result    
@@ -215,6 +227,25 @@ class DistillAssumptions:
         with open(file_path, 'w') as f:
             f.write(json.dumps(self.to_dict(), indent=2))
 
+    @staticmethod
+    def convert_to_markdown(assumption_details: AssumptionDetails) -> str:
+        """
+        Convert the raw document details to markdown.
+        """
+        rows = []
+
+        if len(assumption_details.assumption_list) > 0:
+            for assumption in assumption_details.assumption_list:
+                rows.append(f"- {assumption}")
+        else:
+            rows.append("**No distilled assumptions:** It's unusual that a plan has no assumptions. Please check if the input data is contains assumptions. Please report to the developer of PlanExe.")
+
+        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 os
     import logging
@@ -248,3 +279,5 @@ if __name__ == "__main__":
 
     print("\n\nResponse:")
     print(json.dumps(result.to_dict(include_system_prompt=False, include_user_prompt=False), indent=2))
+
+    print(f"\n\nMarkdown:\n{result.markdown}")

src/assume/identify_plan_type.py

@@ -0,0 +1,290 @@
+"""
+Determine if the plan can be executed digitally without any physical location. Or if the plan requires a physical location.
+
+PROMPT> python -m src.assume.identify_plan_type
+"""
+import os
+import json
+import time
+import logging
+from math import ceil
+from enum import Enum
+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 PlanType(str, Enum):
+    # A plan that can be executed digitally without any physical location.
+    digital = 'digital'
+    # A plan that requires a physical location.
+    physical = 'physical'
+
+class DocumentDetails(BaseModel):
+    explanation: str = Field(
+        description="Providing a high level context."
+    )
+    plan_type: PlanType = Field(
+        description="Classify the type of plan."
+    )
+
+PLAN_TYPE_SYSTEM_PROMPT = """
+You are a world-class planning expert specializing in real-world physical locations. Your *default assumption* should be that a plan *requires* a physical element. You are trying to identify plans that lead to actionable, real-world outcomes. Only classify a plan as "digital" if you are *absolutely certain* it can be executed entirely online *without any benefit* from a physical activity or location.
+
+Use the following guidelines:
+
+## JSON Model
+
+### DocumentDetails
+- **explanation** (string):
+  - A *detailed* explanation of why the plan type was chosen. You must *justify* your choice, especially if you classify a plan as "digital".
+  - If `plan_type` is `digital`, you *must* clearly explain why the plan can be fully automated, has no physical requirements *whatsoever*, and *gains no benefit* from a physical presence.
+
+- **plan_type** (PlanType):
+  - `physical` if the user’s plan *might* involve a physical location, *could benefit* from a physical activity, or *requires* a physical resource. **If there's *any doubt*, classify the plan as `physical`. Examples include: shopping, travel, preparation, setup, construction, repair, in-person meetings, physical testing of products, etc.**
+  - `digital` only if the plan can *exclusively* be completed online with absolutely no benefit from a physical presence.
+
+---
+
+## Recognizing Implied Physical Requirements
+
+Even if a plan *seems* primarily digital or abstract, carefully consider its *implied physical requirements*. These are common, often overlooked actions needed to make the plan happen:
+
+- **Acquiring materials:** Does the plan require buying supplies at a store (e.g., groceries, hardware, art supplies, software)?
+- **Preparation:** Does the plan require physical preparation or setup (e.g., cooking, setting up equipment, cleaning a space, installing software)?
+- **Testing:** Does the plan involve testing a product or service in a real-world environment?
+- **Development:** Does the plan involve physical location for development or meetings?
+- **Transportation:** Does the plan involve traveling to a location, even if the main activity is digital (e.g., working from a coffee shop)?
+- **Location:** Do you want to work in a specific location?
+
+If a plan has *any* of these implied physical requirements, it should be classified as `physical`.
+
+---
+
+## Addressing "Software Development" Plans
+
+Creating software often *seems* purely digital, but it rarely is. Consider these physical elements:
+
+- **Development Environment:** Developers need a physical workspace (home office, co-working space, office).
+- **Physical Hardware:** Developers need a computer, keyboard, monitor, etc.
+- **Collaboration:** Software projects often involve in-person meetings and collaboration.
+- **Testing:** Software often needs to be tested on physical devices (phones, tablets, computers, etc.) in real-world conditions.
+
+**Therefore, plans involving software development should generally be classified as `physical` unless they are extremely simple and can be completed entirely in the cloud with no human interaction.**
+
+---
+
+Example scenarios:
+
+- **Implied Physical Location - Eiffel Tower:**
+  Given "Visit the Eiffel Tower."
+  The correct output is:
+  {
+    "explanation": "The plan *unequivocally requires* a physical presence in Paris, France.",
+    "plan_type": "physical"
+  }
+
+- **Purely Digital / No Physical Location**
+  Given "Print hello world in Python."
+  The correct output is:
+  {
+    "explanation": "This task is *unquestionably* digital. A LLM can generate the python code; no human or physical task is involved.",
+    "plan_type": "digital"
+  }
+
+- **Implied Physical Requirement - Developing a mobile app**
+  Given "The plan involves creating a mobile app."
+  The correct output is:
+  {
+    "explanation": "The plan involves creating a mobile app. This requires developers that requires location for the workspace, as well testing the app in real-world environments.",
+    "plan_type": "physical"
+  }
+
+- **Location - Paris / Requires On-site Research**
+  Given "Write a blog post about Paris, my travel journal with real photos."
+  The correct output is:
+  {
+    "explanation": "Taking high-quality photographs of Paris requires on-site research and physical travel to those locations. This has a *clear* physical element.",
+    "plan_type": "physical"
+  }
+
+- **Location - Paris / Requires No Physical Location**
+  Given "Write a blog post about Paris, listing the top attractions."
+  The correct output is:
+  {
+    "explanation": "While Paris is the subject, the plan *doesn't* require the writer to be in Paris. The content can be created with a LLM.",
+    "plan_type": "digital"
+  }
+
+- **Implied Physical Requirement - Grocery Shopping:**
+  Given "Make spaghetti for dinner."
+  The correct output is:
+  {
+    "explanation": "Making spaghetti *requires* grocery shopping, followed by physical cooking. This *inherently involves* physical components.",
+    "plan_type": "physical"
+  }
+
+- **Implied Physical Requirement - Home Repair:**
+  Given "Fix a leaky faucet."
+  The correct output is:
+  {
+    "explanation": "Fixing a leaky faucet *requires* physically inspecting it, acquiring tools, and performing the repair. This is *clearly* a physical task.",
+    "plan_type": "physical"
+  }
+
+- **INCORRECT - Digital (Grocery Shopping Wrongly Ignored):**
+  Given "Bake a cake for my friend's birthday."
+  The **incorrect** output is:
+  {
+    "explanation": "Baking is a creative activity that can be planned online.",
+    "plan_type": "digital"
+  }
+
+  The **correct** output is:
+  {
+    "explanation": "Baking a cake *unquestionably requires* shopping for ingredients and physical baking. This is *clearly* a physical task.",
+    "plan_type": "physical"
+  }
+
+- **INCORRECT - Digital (Implied Travel Wrongly Ignored):**
+  Given "Work on my presentation at a coffee shop."
+  The **incorrect** output is:
+  {
+    "explanation": "The primary task is working on a digital presentation.",
+    "plan_type": "digital"
+  }
+
+  The **correct** output is:
+  {
+    "explanation": "Working at a coffee shop *requires* traveling to the coffee shop. This *automatically* makes it a physical task.",
+    "plan_type": "physical"
+  }
+"""
+
+@dataclass
+class IdentifyPlanType:
+    """
+    Take a look at the vague plan description and determine:
+    - If it's a plan that can be executed digitally, without any physical location.
+    - Or if the plan requires a physical location.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    markdown: str
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'IdentifyPlanType':
+        """
+        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 = PLAN_TYPE_SYSTEM_PROMPT.strip()
+
+        chat_message_list = [
+            ChatMessage(
+                role=MessageRole.SYSTEM,
+                content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
+            )
+        ]
+
+        sllm = llm.as_structured_llm(DocumentDetails)
+        start_time = time.perf_counter()
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.debug(f"LLM chat interaction failed: {e}")
+            logger.error("LLM chat interaction failed.", exc_info=True)
+            raise ValueError("LLM chat interaction failed.") from e
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        json_response = chat_response.raw.model_dump()
+
+        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 = IdentifyPlanType(
+            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 = []
+
+        if document_details.plan_type == PlanType.digital:
+            rows.append("This plan is purely digital and can be automated. There is no need for any physical locations.")
+        elif document_details.plan_type == PlanType.physical:
+            rows.append("This plan requires one or more physical locations. It cannot be executed digitally.")
+        else:
+            rows.append(f"Invalid plan type. {document_details.plan_type}")
+
+        rows.append(f"\n**Explanation:** {document_details.explanation}")
+        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}")
+
+    identify_plan_type = IdentifyPlanType.execute(llm, query)
+    json_response = identify_plan_type.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{identify_plan_type.markdown}")

src/assume/identify_risks.py

@@ -0,0 +1,231 @@
+"""
+Identify risks in the project plan.
+
+As of 2025-03-03, the result is sensitive to what LLM is being used.
+- Good `openrouter-paid-gemini-2.0-flash-001`.
+- Medium `openrouter-paid-openai-gpt-4o-mini`.
+- Bad `ollama-llama3.1`.
+
+IDEA: assign uuid's to each risk. So later stages of the plan can refer to the risks by their uuid's.
+
+PROMPT> python -m src.assume.identify_risks
+"""
+import os
+import json
+import time
+import logging
+from math import ceil
+from enum import Enum
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+logger = logging.getLogger(__name__)
+
+class LowMediumHigh(str, Enum):
+    low = 'low'
+    medium = 'medium'
+    high = 'high'
+
+class RiskItem(BaseModel):
+    risk_area: str = Field(
+        description="The category or domain of the risk, e.g., Regulatory, Financial, Technical."
+    )
+    risk_description: str = Field(
+        description="A detailed explanation outlining the specific nature of the risk."
+    )
+    potential_impact: str = Field(
+        description="Possible consequences or adverse effects on the project if the risk materializes."
+    )
+    likelihood: LowMediumHigh = Field(
+        description="A qualitative measure (e.g., low, medium, high) indicating the probability that the risk will occur."
+    )
+    severity: LowMediumHigh = Field(
+        description="A qualitative measure (e.g., low, medium, high) describing the extent of the potential negative impact if the risk occurs."
+    )
+    action: str = Field(
+        description="Recommended mitigation strategies or steps to reduce the likelihood or impact of the risk."
+    )
+
+class DocumentDetails(BaseModel):
+    risks: list[RiskItem] = Field(
+        description="A list of identified project risks."
+    )
+    risk_assessment_summary: str = Field(
+        description="Providing a high level context."
+    )
+
+IDENTIFY_RISKS_SYSTEM_PROMPT = """
+You are a world-class planning expert with extensive experience in risk management for a wide range of projects, from small personal tasks to large-scale business ventures. Your objective is to identify potential risks that could jeopardize the success of a project based on its description. When analyzing the project plan, please consider and include the following aspects:
+
+- **Risk Identification & Categorization:**  
+  Analyze the project description thoroughly and identify risks across various domains such as Regulatory & Permitting, Technical, Financial, Environmental, Social, Operational, Supply Chain, and Security. Also consider integration with existing infrastructure, market or competitive risks (if applicable), and long-term sustainability. Be creative and consider even non-obvious factors.
+
+- **Detailed Risk Descriptions:**  
+  For each risk, provide a detailed explanation of what might go wrong and why it is a concern. Include aspects such as integration challenges with existing systems, maintenance difficulties, or long-term sustainability if relevant.
+
+- **Quantification of Potential Impact:**  
+  Where possible, quantify the potential impact. Include estimates of time delays (e.g., “a delay of 2–4 weeks”), financial overruns (e.g., “an extra cost of 5,000–10,000 in the project’s local currency”), and other measurable consequences. Use the appropriate currency or unit based on the project context.
+
+- **Likelihood and Severity Assessments:**  
+  Assess both the probability of occurrence (low, medium, high) and the potential severity of each risk (low, medium, high). Remember that even low-probability risks can have high severity.
+
+- **Actionable Mitigation Strategies:**  
+  For every identified risk, propose clear, actionable mitigation strategies. Explain how these steps can reduce either the likelihood or the impact of the risk.
+
+- **Assumptions and Missing Information:**  
+  If the project description is vague or key details are missing, explicitly note your assumptions and the potential impact of these uncertainties on the risk assessment.
+
+- **Strategic Summary:**  
+  Finally, provide a concise summary that highlights the 2–3 most critical risks that, if not properly managed, could significantly jeopardize the project’s success. Discuss any trade-offs or overlapping mitigation strategies.
+
+Output your findings as a JSON object with the following structure:
+
+{
+  "risks": [
+    {
+      "risk_area": "The category or domain of the risk (e.g., Regulatory & Permitting)",
+      "risk_description": "A detailed explanation outlining the specific nature of the risk.",
+      "potential_impact": "Possible consequences or adverse effects on the project if the risk materializes, with quantifiable details where feasible.",
+      "likelihood": "A qualitative measure (low, medium or high) indicating the probability that the risk will occur.",
+      "severity": "A qualitative measure (low, medium or high) describing the potential negative impact if the risk occurs.",
+      "action": "Recommended mitigation strategies or steps to reduce the likelihood or impact of the risk."
+    },
+    ...
+  ],
+  "risk_assessment_summary": "A concise summary of the overall risk landscape and the most critical risks."
+}
+"""
+
+@dataclass
+class IdentifyRisks:
+    """
+    Take a look at the vague plan description and identify risks.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    markdown: str
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'IdentifyRisks':
+        """
+        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 = IDENTIFY_RISKS_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 = IdentifyRisks(
+            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.
+        """
+        def format_lowmediumhigh(value: LowMediumHigh) -> str:
+            return value.capitalize()
+        
+        rows = []
+
+        if len(document_details.risks) > 0:
+            for risk_index, risk_item in enumerate(document_details.risks, start=1):
+                rows.append(f"\n## Risk {risk_index} - {risk_item.risk_area}")
+                rows.append(risk_item.risk_description)
+                rows.append(f"\n**Impact:** {risk_item.potential_impact}")
+                rows.append(f"\n**Likelihood:** {format_lowmediumhigh(risk_item.likelihood)}")
+                rows.append(f"\n**Severity:** {format_lowmediumhigh(risk_item.severity)}")
+                rows.append(f"\n**Action:** {risk_item.action}")
+        else:
+            rows.append("No risks identified.")
+
+        rows.append(f"\n## Risk summary\n{document_details.risk_assessment_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("4dc34d55-0d0d-4e9d-92f4-23765f49dd29")
+    query = (
+        f"{plan_prompt}\n\n"
+        "Today's date:\n2025-Feb-27\n\n"
+        "Project start ASAP"
+    )
+    print(f"Query: {query}")
+
+    identify_risks = IdentifyRisks.execute(llm, query)
+    json_response = identify_risks.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{identify_risks.markdown}")

src/assume/make_assumptions.py

@@ -212,9 +212,10 @@ class MakeAssumptions:
     response: dict
     metadata: dict
     assumptions: list
+    markdown: str
 
     @classmethod
-    def execute(cls, llm: LLM, user_prompt: str, **kwargs: Any) -> 'MakeAssumptions':
+    def execute(cls, llm: LLM, user_prompt: str) -> 'MakeAssumptions':
         """
         Invoke LLM and make assumptions based on the user prompt.
         """
@@ -231,45 +232,30 @@ class MakeAssumptions:
         system_prompt = SYSTEM_PROMPT.strip()
         system_prompt = system_prompt.replace("CURRENT_YEAR_PLACEHOLDER", current_year)
 
-        default_args = {
-            'system_prompt': system_prompt
-        }
-        default_args.update(kwargs)
-
-        system_prompt = default_args.get('system_prompt')
-        logger.debug(f"System Prompt:\n{system_prompt}")
-        if system_prompt and not isinstance(system_prompt, str):
-            raise ValueError("Invalid system prompt.")
-
-        chat_message_list1 = []
-        if system_prompt:
-            chat_message_list1.append(
-                ChatMessage(
-                    role=MessageRole.SYSTEM,
-                    content=system_prompt,
-                )
+        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}")
-        chat_message_user = ChatMessage(
-            role=MessageRole.USER,
-            content=user_prompt,
-        )
-        chat_message_list1.append(chat_message_user)
+        ]
 
         sllm = llm.as_structured_llm(ExpertDetails)
 
         logger.debug("Starting LLM chat interaction.")
         start_time = time.perf_counter()
         try:
-            chat_response1 = sllm.chat(chat_message_list1)
+            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_response1.message.content.encode('utf-8'))
+        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)
@@ -278,7 +264,7 @@ class MakeAssumptions:
         metadata["response_byte_count"] = response_byte_count
 
         try:
-            json_response = json.loads(chat_response1.message.content)
+            json_response = json.loads(chat_response.message.content)
         except json.JSONDecodeError as e:
             logger.error("Failed to parse LLM response as JSON.", exc_info=True)
             raise ValueError("Invalid JSON response from LLM.") from e
@@ -297,12 +283,15 @@ class MakeAssumptions:
             }
             assumption_list.append(assumption_item)
 
+        markdown = cls.convert_to_markdown(chat_response.raw)
+
         result = MakeAssumptions(
             system_prompt=system_prompt,
             user_prompt=user_prompt,
             response=json_response,
             metadata=metadata,
-            assumptions=assumption_list
+            assumptions=assumption_list,
+            markdown=markdown
         )
         logger.debug("MakeAssumptions instance created successfully.")
         return result    
@@ -325,6 +314,27 @@ class MakeAssumptions:
         with open(file_path, 'w') as f:
             f.write(json.dumps(self.assumptions, indent=2))
 
+    @staticmethod
+    def convert_to_markdown(expert_details: ExpertDetails) -> str:
+        """
+        Convert the raw document details to markdown.
+        """
+        rows = []
+
+        if len(expert_details.question_assumption_list) > 0:
+            for index, item in enumerate(expert_details.question_assumption_list, start=1):
+                rows.append(f"\n## Question {index} - {item.question}")
+                rows.append(f"\n**Assumptions:** {item.assumptions}")
+                rows.append(f"\n**Assessments:** {item.assessments}")
+        else:
+            rows.append("The 'question-assumption-list' is empty. Finding zero questions for a plan is unusual, this is likely a bug. Please report this issue to the developer of PlanExe.")
+
+        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
@@ -356,3 +366,5 @@ if __name__ == "__main__":
 
     print("\n\nAssumptions:")
     print(json.dumps(result.assumptions, indent=2))
+
+    print(f"\n\nMarkdown:\n{result.markdown}")

src/assume/physical_locations.py

@@ -0,0 +1,284 @@
+"""
+Pick suitable physical locations for the project plan. 
+- If the plan is purely digital and can be executed without any physical location, then there is no need to run this step.
+- If the user prompt already includes the physical location, then include that location in the response.
+- If the user prompt does not mention any location, then the expert should suggest suitable locations based on the project requirements.
+- There may be multiple locations, in case a bridge is to be built between two countries.
+
+PROMPT> python -m src.assume.physical_locations
+"""
+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 PhysicalLocationItem(BaseModel):
+    item_index: int = Field(
+        description="Enumeration of the locations, starting from 1."
+    )
+    physical_location_broad: str = Field(
+        description="A broad location for the project, such as a country or region. Use 'Global' if applicable."
+    )
+    physical_location_detailed: str = Field(
+        description="Narrow down the physical location even more, such as a city name."
+    )
+    physical_location_specific: str = Field(
+        description="Narrow down the physical location even more, such as a city name, region, or type of location (e.g., 'Oceanographic Research Centers')."
+    )
+    rationale_for_suggestion: str = Field(
+        description="Explain why this particular physical location is suggested."
+    )
+
+class DocumentDetails(BaseModel):
+    has_location_in_plan: bool = Field(
+        description="Is the location specified in the plan."
+    )
+    requirements_for_the_physical_locations: list[str] = Field(
+        description="List of requirements/constraints for well suited locations."
+    )
+    physical_locations: list[PhysicalLocationItem] = Field(
+        description="List of physical locations."
+    )
+    location_summary: str = Field(
+        description="Providing a high level context."
+    )
+
+PHYSICAL_LOCATIONS_SYSTEM_PROMPT = """
+You are a world-class planning expert specializing in real-world physical locations. Your goal is to generate a JSON response that follows the `DocumentDetails` and `PhysicalLocationItem` models precisely. 
+
+Use the following guidelines:
+
+## JSON Models
+
+### DocumentDetails
+- **has_location_in_plan** (bool):
+  - `true` if the user’s prompt *explicitly mentions or strongly implies* a physical location. This includes named locations (e.g., "Paris", "my office"), specific landmarks (e.g., "Eiffel Tower," "Grand Canyon"), or clear activities that inherently tie the plan to a location (e.g., "build a house", "open a restaurant"). **If the user's plan can *only* occur in a specific geographic area, consider it to have a location in the plan.**
+  - `false` if the user’s prompt does not specify any location.
+
+- **requirements_for_the_physical_locations** (list of strings):
+  - Key criteria or constraints relevant to location selection (e.g., "cheap labor", "near highways", "near harbor", "space for 10-20 people").
+
+- **physical_locations** (list of PhysicalLocationItem):
+  - A list of recommended or confirmed physical sites. 
+  - If the user’s prompt does not require any location, then you **MUST** suggest **three** well-reasoned suggestions.
+  - If the user does require a new site (and has no location in mind), you **MUST** provide **three** well-reasoned suggestions. 
+  - If the user’s prompt already includes a specific location but does not need other suggestions, you may list just that location, or clarify it in one `PhysicalLocationItem` in addition to providing the other **three** well-reasoned suggestions.
+  - When suggesting locations, consider a variety of factors, such as accessibility, cost, zoning regulations, and proximity to relevant resources or amenities.
+
+- **location_summary** (string):
+  - A concise explanation of why the listed sites (if any) are relevant, or—if no location is provided—why no location is necessary (e.g., “All tasks can be done with the user’s current setup; no new site required.”).
+
+### PhysicalLocationItem
+- **item_index** (string):
+  - A unique integer (e.g., 1, 2, 3) for each location.
+- **physical_location_broad** (string):
+  - A country or wide region (e.g., "USA", "Region of North Denmark").
+- **physical_location_detailed** (string):
+  - A more specific subdivision (city, district).
+- **physical_location_specific** (string):
+  - A precise address, if relevant.
+- **rationale_for_suggestion** (string):
+  - Why this location suits the plan (e.g., "near raw materials", "close to highways", "existing infrastructure").
+
+## Additional Instructions
+
+1. **When the User Already Has a Location**  
+   - If `has_location_in_plan = true` and the user explicitly provided a place (e.g., "my home", "my shop"), you can either:
+     - Use a single `PhysicalLocationItem` to confirm or refine that address in addition to the other **three** well-reasoned suggestions, **or**  
+     - Provide **three** location items of suggestions if the user is open to alternatives or further detail within the same area.  
+
+2. **When the User Needs Suggestions**  
+   - If `has_location_in_plan = false`, you **MUST** propose **three** distinct sites that satisfy the user’s requirements.
+
+3. **location_summary** Consistency  
+   - Always provide a summary that matches the `physical_locations` array. 
+   - If multiple locations are provided, summarize how each meets the user’s needs.
+
+---
+
+Example scenarios:
+
+- **Implied Physical Location - Eiffel Tower:**
+  Given "Visit the Eiffel Tower."
+  The correct output is:
+  {
+    "has_location_in_plan": true,
+    "requirements_for_the_physical_locations": [],
+    "physical_locations": [
+      {
+        "item_index": 1,
+        "physical_location_broad": "France",
+        "physical_location_detailed": "Eiffel Tower, Paris",
+        "physical_location_specific": "Champ de Mars, 5 Avenue Anatole France, 75007 Paris, France",
+        "rationale_for_suggestion": "The plan is to visit the Eiffel Tower, which is located in Paris, France."
+      },
+      {
+        "item_index": 2,
+        "physical_location_broad": "France",
+        "physical_location_detailed": "Near Eiffel Tower, Paris",
+        "physical_location_specific": "5 Avenue Anatole France, 75007 Paris, France",
+        "rationale_for_suggestion": "A location near the Eiffel Tower would provide convenient access for individuals who also plan to visit the landmark."
+      },
+      {
+        "item_index": 3,
+        "physical_location_broad": "France",
+        "physical_location_detailed": "Central Paris",
+        "physical_location_specific": "Various locations in Central Paris",
+        "rationale_for_suggestion": "Central Paris offers a vibrant and accessible environment with numerous transportation options."
+      }
+    ],
+    "location_summary": "The plan is to visit the Eiffel Tower, which is located in Paris, France, in addition to a location near the Eiffel Tower and Central Paris."
+  }
+"""
+
+@dataclass
+class PhysicalLocations:
+    """
+    Take a look at the vague plan description and suggest physical locations.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    markdown: str
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'PhysicalLocations':
+        """
+        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 = PHYSICAL_LOCATIONS_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 = PhysicalLocations(
+            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 = []
+
+        if document_details.has_location_in_plan:
+            rows.append("This plan implies one or more physical locations.")
+        else:
+            rows.append("This plan **does not** imply any physical location.")
+
+        if len(document_details.requirements_for_the_physical_locations) > 0:
+            rows.append("\n## Requirements for physical locations\n")
+            for requirement in document_details.requirements_for_the_physical_locations:
+                rows.append(f"- {requirement}")
+        else:
+            rows.append("No requirements for the physical location.")
+        
+        for location_index, location in enumerate(document_details.physical_locations, start=1):
+            rows.append(f"\n## Location {location_index}")
+            physical_location_broad = location.physical_location_broad.strip()
+            physical_location_detailed = location.physical_location_detailed.strip()
+            physical_location_specific = location.physical_location_specific.strip()
+            missing_location = (len(physical_location_broad) + len(physical_location_detailed) + len(physical_location_specific)) == 0
+            if len(physical_location_broad) > 0:
+                rows.append(f"{physical_location_broad}\n")
+            if len(physical_location_detailed) > 0:
+                rows.append(f"{physical_location_detailed}\n")
+            if len(physical_location_specific) > 0:
+                rows.append(f"{physical_location_specific}\n")
+            if missing_location:
+                rows.append("Missing location info.\n")
+            rows.append(f"**Rationale**: {location.rationale_for_suggestion}")
+        
+        rows.append(f"\n## Location Summary\n{document_details.location_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}")
+
+    physical_locations = PhysicalLocations.execute(llm, query)
+    json_response = physical_locations.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{physical_locations.markdown}")

src/assume/review_assumptions.py

@@ -0,0 +1,235 @@
+"""
+Review the assumptions. Are they too low/high? Are they reasonable? Are there any missing assumptions?
+
+PROMPT> python -m src.assume.review_assumptions
+"""
+import os
+import json
+import time
+import logging
+from math import ceil
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+logger = logging.getLogger(__name__)
+
+class ReviewItem(BaseModel):
+    issue: str = Field(
+        description="A brief title or name."
+    )
+    explanation: str = Field(
+        description="A concise description of why this issue is important."
+    )
+    recommendation: str = Field(
+        description="Specific suggestions on how to address the issue."
+    )
+    sensitivity: str = Field(
+        default="",
+        description="Optional: Provide any sensitivity analysis insights related to this issue."
+    )
+
+class DocumentDetails(BaseModel):
+    expert_domain: str = Field(
+        description="The domain of the expert reviewer."
+    )
+    domain_specific_considerations: list[str] = Field(
+        description="Key factors and areas of focus relevant to the specific project domain, which this review should prioritize."
+    )
+    issues: list[ReviewItem] = Field(
+        description="The most significant issues."
+    )
+    conclusion: str = Field(
+        description="Summary of the most important issues."
+    )
+
+REVIEW_ASSUMPTIONS_SYSTEM_PROMPT = """
+You are a world-class planning expert specializing in the success of projects. Your task is to critically review the provided assumptions and identify potential weaknesses, omissions, or unrealistic elements that could significantly impact project success. Your analysis should be tailored to the project’s scale and context, while considering standard project management best practices. Be creative and innovative in your analysis, considering risks and opportunities that might be overlooked by others.
+
+**Crucial Focus: Missing Assumptions and Impact Assessment**
+
+Your primary goal is to identify *critical missing assumptions* that have not been explicitly stated, but are vital for successful project planning and execution. For each missing assumption, estimate its potential impact on the project's key performance indicators (KPIs) such as ROI, timeline, budget, or quality. This impact assessment should be quantitative wherever possible. For instance, if a missing assumption relates to regulatory approval, estimate the potential delay in project completion and the associated cost implications.
+
+**Consider the Following Project Aspects:**
+
+When reviewing the assumptions, actively consider these areas. Look for explicit *or* implicit assumptions that impact these areas.
+
+-   **Financial:** Funding sources, cost estimates (initial and operational), revenue projections, pricing strategy, profitability, economic viability, return on investment (ROI), cost of capital, financial risks (e.g., currency fluctuations, interest rate changes), insurance costs.
+-   **Timeline:** Project duration, key milestones, task dependencies, resource allocation over time, critical path analysis, potential delays (e.g., permitting, supply chain), seasonality effects, weather-related risks.
+-   **Resources:** Human resources (skill availability, labor costs), material resources (supply availability, raw material costs), equipment (availability, maintenance costs), technology (availability, licensing costs), land (acquisition costs, suitability).
+-   **Regulations:** Compliance with local, regional, and national laws, environmental regulations, permitting requirements, zoning ordinances, safety standards, data privacy regulations, industry-specific standards, political risks.
+-   **Infrastructure:** Availability and capacity of transportation, utilities (electricity, water, gas), communication networks, cybersecurity risks.
+-   **Environment:** Potential environmental impacts (e.g., emissions, waste generation, habitat disruption), mitigation strategies, climate change risks, sustainability practices, resource consumption.
+-   **Stakeholders:** Community acceptance, government support, customer needs, supplier relationships, investor expectations, media relations, political influence, key partner dependencies.
+-   **Technology:** Technology selection, innovation, integration, obsolescence, intellectual property rights, data security, scalability, maintenance, licensing.
+-   **Market:** Market demand, competitive landscape, pricing pressure, customer preferences, economic trends, technological disruption, new market entrants, black swan events.
+-   **Risk:** Credit risk, operational risk, strategic risk, compliance risk, political risk, insurance needs, cost of capital, inflation. Examples of risks are: the NLP algorithm has a bug and must be rewritten, funding dries up due to a market crash, etc.
+
+**Your Analysis MUST:**
+
+1.  **Identify Critical Missing Assumptions:** Explicitly state any crucial assumptions that are missing from the provided input. Clearly explain why each missing assumption is critical to the project's success.
+2.  **Highlight Under-Explored Assumptions:** Point out areas where the existing assumptions lack sufficient detail or supporting evidence.
+3.  **Challenge Questionable or Unrealistic Assumptions:** Identify any assumptions that seem unrealistic or based on flawed logic.
+4.  **Discuss Sensitivity Analysis for key variables:** Quantify the potential impact of changes in key variables (e.g., a delay in permitting, a change in energy prices) on the project's overall success. For each issue, consider a plausible range for the key driving variables, and quantify the impact on the project's Return on Investment (ROI) or total project cost. Use percentages or hard numbers! Example of an analysis range of key variables is: The project may experience challenges related to a lack of data privacy considerations. A failure to uphold GDPR principles may result in fines ranging from 5-10% of annual turnover. The cost of a human for the project can be based on a 40/hr for 160 hours and would require a computer, this could be from 6000 to 7000 per month. The variance should not be double the base value.
+5.  **Prioritize Issues:** Focus on the *three most critical* issues, providing detailed and actionable recommendations for addressing them.
+
+**Guidance for identifying missing assumptions:**
+Think about all the things that must be true for this project to succeed. Are all of these things in the existing list of assumptions?
+* Resources: Financial, Human, Data, Time, etc.
+* Pre-Existing Work: Benchmarks, Data Sets, Algorithms, Existing papers, etc.
+* Outside Forces: Community Buy-In, Funding, New laws, weather, etc.
+* Metrics: Clear, measurable success conditions.
+* Technical Considerations: Hardware, Software, Algorithms, Scalability, Data security, etc.
+
+Please limit your output to no more than 800 words.
+
+Return your response as a JSON object with the following structure:
+{
+  "expert_domain": "The area of expertise most relevant for this review",
+  "domain_specific_considerations": ["List", "of", "relevant", "considerations"],
+  "issues": [
+    {
+      "issue": "Title of the issue",
+      "explanation": "Explanation of why this issue is important",
+      "recommendation": "Actionable recommendations to address the issue.  Be specific. Include specific steps, quantifiable targets, or examples of best practices whenever possible.",
+      "sensitivity": "Quantitative sensitivity analysis details. Express the impact as a *range* of values on the project's ROI, total project cost, or project completion date, and include the *baseline* for comparison. Here are examples: *  'A delay in obtaining necessary permits (baseline: 6 months) could increase project costs by \u20ac100,000-200,000, or delay the ROI by 3-6 months.' *  'A 15% increase in the cost of solar panels (baseline: \u20ac1 million) could reduce the project's ROI by 5-7%.' *  'If we underestimate cloud computing costs, the project could be delayed by 3-6 months, or the ROI could be reduced by 10-15%'"
+    },
+    ...
+  ],
+  "conclusion": "Summary of main findings and recommendations"
+}
+"""
+
+@dataclass
+class ReviewAssumptions:
+    """
+    Take a look at the assumptions and provide feedback on potential omissions and improvements.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+    markdown: str
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'ReviewAssumptions':
+        """
+        Invoke LLM with the project description and assumptions to be reviewed.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+
+        logger.debug(f"User Prompt:\n{user_prompt}")
+
+        system_prompt = REVIEW_ASSUMPTIONS_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 = ReviewAssumptions(
+            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 = []
+
+        rows.append(f"## Domain of the expert reviewer\n{document_details.expert_domain}")
+
+        if len(document_details.domain_specific_considerations) > 0:
+            rows.append("\n## Domain-specific considerations\n")
+            for item in document_details.domain_specific_considerations:
+                rows.append(f"- {item}")
+        else:
+            rows.append("\n## Domain-specific considerations - None\n")
+
+        if len(document_details.issues) > 0:
+            for index, item in enumerate(document_details.issues, start=1):
+                rows.append(f"\n## Issue {index} - {item.issue}")
+                rows.append(item.explanation)
+                rows.append(f"\n**Recommendation:** {item.recommendation}")
+                rows.append(f"\n**Sensitivity:** {item.sensitivity}")
+        else:
+            rows.append("## Issues - None. This is unusual. Please report this to the developer of PlanExe.")
+
+        rows.append(f"\n## Review conclusion\n{document_details.conclusion}")
+        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.utils.concat_files_into_string import concat_files_into_string
+
+    llm = get_llm("ollama-llama3.1")
+
+    base_path = os.path.join(os.path.dirname(__file__), 'test_data', 'review_assumptions1')
+
+    all_documents_string = concat_files_into_string(base_path)
+    print(all_documents_string)
+
+    result = ReviewAssumptions.execute(llm, all_documents_string)
+    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/assume/test_data/currency_strategy1/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+Construct a train bridge between Denmark and England.
+
+Today's date:
+2025-Feb-28
+
+Project start ASAP

src/assume/test_data/currency_strategy1/002-physical_locations.json

@@ -0,0 +1,43 @@
+{
+  "physical_location_required": true,
+  "has_location_in_plan": false,
+  "requirements_for_the_locations": [
+    "connects the two countries",
+    "crosses waterways"
+  ],
+  "locations": [
+    {
+      "item_index": 1,
+      "specific_location": "",
+      "suggest_location_broad": "Denmark",
+      "suggest_location_detail": "Region of North Denmark",
+      "suggest_location_address": "between Frederikshavn, Denmark and Esbjerg, Denmark",
+      "rationale_for_suggestion": "nearest Danish point to England"
+    },
+    {
+      "item_index": 2,
+      "specific_location": "",
+      "suggest_location_broad": "England",
+      "suggest_location_detail": "East of England region (Norfolk)",
+      "suggest_location_address": "between Great Yarmouth, Norfolk and King's Lynn, Norfolk",
+      "rationale_for_suggestion": "nearest English point to Denmark"
+    },
+    {
+      "item_index": 3,
+      "specific_location": "",
+      "suggest_location_broad": "Denmark",
+      "suggest_location_detail": "Capital Region of Denmark (Zealand)",
+      "suggest_location_address": "between Copenhagen and Frederikssund, Zealand",
+      "rationale_for_suggestion": "high population density in the area"
+    },
+    {
+      "item_index": 4,
+      "specific_location": "",
+      "suggest_location_broad": "England",
+      "suggest_location_detail": "East of England region (Suffolk)",
+      "suggest_location_address": "between Lowestoft and Southwold, Suffolk",
+      "rationale_for_suggestion": "strategic location near sea routes"
+    }
+  ],
+  "location_summary": "Four potential locations have been suggested for the train bridge connecting Denmark and England: 1) Region of North Denmark (near Frederikshavn), 2) East of England region (Norfolk), 3) Capital Region of Denmark (Zealand, near Copenhagen), and 4) East of England region (Suffolk). These locations are chosen for their proximity to the two countries' borders."
+}

src/assume/test_data/currency_strategy2/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+I need to take out the trash. All the bins is in the kitchen, and the dumpsters are outside, such as: metal, plastics, bio. Where I live, citizens must sort the trash into the correct bins.
+
+Today's date:
+2025-Mar-01
+
+Project start ASAP

src/assume/test_data/currency_strategy2/002-physical_locations.json

@@ -0,0 +1,7 @@
+{
+  "physical_location_required": false,
+  "has_location_in_plan": true,
+  "requirements_for_the_locations": [],
+  "locations": [],
+  "location_summary": "The task involves using existing locations (kitchen, outdoor dumpsters) at the user's residence; no new physical site is required."
+}

src/assume/test_data/currency_strategy3/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+My daily commute from home to work takes 1 hour. My bike is broken and need an alternative plan. I live in Amsterdam, Netherlands.
+
+Today's date:
+2025-Mar-01
+
+Project start ASAP

src/assume/test_data/currency_strategy3/002-physical_locations.json

@@ -0,0 +1,35 @@
+{
+  "physical_location_required": true,
+  "has_location_in_plan": true,
+  "requirements_for_the_locations": [
+    "near work",
+    "alternative commute"
+  ],
+  "locations": [
+    {
+      "item_index": 1,
+      "specific_location": "",
+      "suggest_location_broad": "Netherlands",
+      "suggest_location_detail": "Amsterdam",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": "Existing home and work location in Amsterdam"
+    },
+    {
+      "item_index": 2,
+      "specific_location": "",
+      "suggest_location_broad": "Netherlands",
+      "suggest_location_detail": "Utrecht",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": "Alternative city with good public transportation, relatively close to Amsterdam"
+    },
+    {
+      "item_index": 3,
+      "specific_location": "",
+      "suggest_location_broad": "Netherlands",
+      "suggest_location_detail": "Haarlem",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": "Neighboring city with good public transportation, close to Amsterdam"
+    }
+  ],
+  "location_summary": "Alternative commute options from home to work in Amsterdam and nearby cities."
+}

src/assume/test_data/currency_strategy4/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+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.
+
+Today's date:
+2025-Mar-01
+
+Project start ASAP

src/assume/test_data/currency_strategy4/002-physical_locations.json

@@ -0,0 +1,10 @@
+{
+  "physical_location_required": false,
+  "has_location_in_plan": false,
+  "requirements_for_the_locations": [
+    "research institution",
+    "data repository"
+  ],
+  "locations": [],
+  "location_summary": "This project will be conducted in a digital environment, leveraging existing research institutions and data repositories to minimize physical site requirements."
+}

src/assume/test_data/currency_strategy5/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+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?
+
+Today's date:
+2025-Mar-01
+
+Project start ASAP

src/assume/test_data/currency_strategy5/002-physical_locations.json

@@ -0,0 +1,35 @@
+{
+  "physical_location_required": true,
+  "has_location_in_plan": false,
+  "requirements_for_the_locations": [
+    "global",
+    "language center"
+  ],
+  "locations": [
+    {
+      "item_index": 1,
+      "specific_location": "",
+      "suggest_location_broad": "Global",
+      "suggest_location_detail": "",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": ""
+    },
+    {
+      "item_index": 2,
+      "specific_location": "",
+      "suggest_location_broad": "Global Headquarters of a major Language Institution",
+      "suggest_location_detail": "e.g., UNESCO, British Council",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": ""
+    },
+    {
+      "item_index": 3,
+      "specific_location": "",
+      "suggest_location_broad": "A hub city with strong linguistic diversity and cultural significance",
+      "suggest_location_detail": "e.g., Paris, Tokyo, New York",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": ""
+    }
+  ],
+  "location_summary": "This project requires a global approach to develop a unified language. The suggested locations are hubs for linguistic diversity and cultural significance."
+}

src/assume/test_data/currency_strategy6/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+Create a detailed report examining the current situation of microplastics within the world's oceans.
+
+Today's date:
+2025-Mar-01
+
+Project start ASAP

src/assume/test_data/currency_strategy6/002-physical_locations.json

@@ -0,0 +1,27 @@
+{
+  "physical_location_required": true,
+  "has_location_in_plan": false,
+  "requirements_for_the_locations": [
+    "near research institutions",
+    "with access to oceanic sampling equipment"
+  ],
+  "locations": [
+    {
+      "item_index": 1,
+      "specific_location": "",
+      "suggest_location_broad": "Global Oceans",
+      "suggest_location_detail": "Various marine ecosystems",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": "To gather diverse ocean samples and collaborate with local researchers"
+    },
+    {
+      "item_index": 2,
+      "specific_location": "",
+      "suggest_location_broad": "Major coastal cities",
+      "suggest_location_detail": "Port locations",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": "For easy access to sampling equipment and research institutions"
+    }
+  ],
+  "location_summary": "The study requires accessing various oceanic ecosystems globally for diverse sampling. Suggested sites are near major coastal cities with access to relevant research facilities."
+}

src/assume/test_data/currency_strategy7/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+Establish a humanoid robot factory in Caracas, Venezuela.
+
+Today's date:
+2025-Mar-01
+
+Project start ASAP

src/assume/test_data/currency_strategy7/002-physical_locations.json

@@ -0,0 +1,19 @@
+{
+  "physical_location_required": true,
+  "has_location_in_plan": false,
+  "requirements_for_the_locations": [
+    "cheap labor",
+    "government incentives for robotics industry"
+  ],
+  "locations": [
+    {
+      "item_index": 1,
+      "specific_location": "",
+      "suggest_location_broad": "Venezuela",
+      "suggest_location_detail": "Caracas",
+      "suggest_location_address": "",
+      "rationale_for_suggestion": "Existing infrastructure and access to cheap labor in Caracas make it an ideal location for a humanoid robot factory."
+    }
+  ],
+  "location_summary": "A humanoid robot factory should be set up in Caracas, Venezuela, due to the availability of cheap labor and government incentives for the robotics industry. This will allow us to keep costs low and take advantage of local resources."
+}

src/assume/test_data/review_assumptions1/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+Establish a solar farm in Denmark.
+
+Today's date:
+2025-Feb-26
+
+Project start ASAP

src/assume/test_data/review_assumptions1/002-make_assumptions.json

@@ -0,0 +1,42 @@
+[
+  {
+    "question": "What are the funding and budget requirements for establishing the solar farm?",
+    "assumptions": "Assumption: The initial investment includes land acquisition, installation of solar panels, infrastructure (roads, fencing), and permits. Based on industry standards in Denmark, this could range from \u20ac2-4 million, including contingency.",
+    "assessments": "Title: Financial Feasibility Assessment\nDescription: Evaluation of the financial viability considering initial costs and potential returns.\nDetails: The estimated cost is \u20ac3 million. Expected return on investment (ROI) is 5-7 years with current technology advances and government incentives. Risks include fluctuating energy prices and regulatory changes. Mitigation strategies involve securing long-term power purchase agreements (PPAs) and diversifying renewable energy portfolio."
+  },
+  {
+    "question": "What is the projected timeline for development, including key milestones?",
+    "assumptions": "Assumption: The project follows a phased approach starting with site selection, followed by permits, construction, and finally commissioning. Assuming an average pace of work, this process could take 18-24 months.",
+    "assessments": "Title: Timeline & Milestones Assessment\nDescription: Structuring the project timeline for efficient execution.\nDetails: Key milestones include site selection (Month 1), permit acquisition (Months 2-6), start of construction (Month 7), completion and testing (Months 12-18), with full operational capacity by Month 24. Delays in permits could extend timelines; regular updates and stakeholder communication are crucial for maintaining momentum."
+  },
+  {
+    "question": "What resources and personnel are required to execute the project?",
+    "assumptions": "Assumption: The team includes engineers, environmental specialists, procurement managers, construction workers, and administrative staff. Given the scale, a core team of around 20-30 people is necessary, supplemented by contractors during peak construction phases.",
+    "assessments": "Title: Resource & Personnel Assessment\nDescription: Ensuring adequate human capital and material resources.\nDetails: A skilled team with diverse expertise will be essential for successful execution. Risks include talent shortages; mitigating this involves early recruitment and fostering partnerships with local educational institutions for training programs."
+  },
+  {
+    "question": "What are the governance and regulatory considerations?",
+    "assumptions": "Assumption: The project must comply with Danish renewable energy laws, environmental regulations, and local zoning ordinances. Engaging early with relevant authorities is critical.",
+    "assessments": "Title: Governance & Regulations Assessment\nDescription: Ensuring adherence to legal requirements.\nDetails: Permits are required from the Danish Energy Agency and local municipalities. Potential risks include regulatory changes; mitigation involves maintaining active dialogue with regulators and being prepared for revisions through flexible planning."
+  },
+  {
+    "question": "What are the safety and risk management protocols?",
+    "assumptions": "Assumption: Comprehensive safety measures must be in place, including training for workers on solar panel handling and use of heavy machinery. Risk assessments will identify potential hazards such as electrical risks and working at heights.",
+    "assessments": "Title: Safety & Risk Management Assessment\nDescription: Minimizing potential hazards to personnel and the environment.\nDetails: A detailed risk management plan is required, including safety training programs, emergency protocols, and regular audits. Potential risks include worker injury; mitigation strategies involve thorough site inspections, regular safety drills, and adherence to all regulatory safety standards."
+  },
+  {
+    "question": "What are the environmental impacts and mitigations?",
+    "assumptions": "Assumption: The project will have minimal impact on local ecosystems; however, potential effects include habitat alteration and water usage. Mitigation strategies involve preserving existing vegetation during construction and implementing efficient irrigation systems.",
+    "assessments": "Title: Environmental Impact Assessment\nDescription: Evaluating ecological impacts and implementing mitigation measures.\nDetails: A detailed environmental assessment will be conducted to identify potential impacts. Mitigations include reforestation plans, wildlife corridors, and using rainwater harvesting systems. Monitoring programs post-completion are necessary to ensure long-term sustainability."
+  },
+  {
+    "question": "How can stakeholder involvement be maximized?",
+    "assumptions": "Assumption: Engaging local communities, government bodies, and industry stakeholders early in the process is crucial for project success and social acceptance.",
+    "assessments": "Title: Stakeholder Involvement Assessment\nDescription: Securing buy-in from all relevant parties.\nDetails: A robust stakeholder engagement plan will be developed, including regular updates, public forums, and feedback mechanisms. Risks include resistance or lack of interest; mitigations involve transparent communication and addressing community concerns proactively."
+  },
+  {
+    "question": "What operational systems and technologies are essential for the solar farm?",
+    "assumptions": "Assumption: Advanced monitoring systems, energy storage solutions (like batteries), and smart grid integration will be key to optimizing performance and reliability.",
+    "assessments": "Title: Operational Systems Assessment\nDescription: Establishing efficient and sustainable operational frameworks.\nDetails: Investment in cutting-edge technology is crucial for maximizing energy yield. Risks include technological obsolescence; mitigation strategies involve regular system upgrades and fostering partnerships with tech innovators to stay ahead."
+  }
+]

src/assume/test_data/review_assumptions1/003-distill_assumptions.json

@@ -0,0 +1,12 @@
+{
+  "assumption_list": [
+    "Project takes 18-24 months.",
+    "Investment \u20ac3m, ROI 5-7 years.",
+    "Team of 20-30 people.",
+    "Compliance with Danish renewable laws.",
+    "Active regulator dialogue.",
+    "Safety protocols and risk assessments.",
+    "Minimal environmental impact; mitigation plans.",
+    "Stakeholder engagement plan."
+  ]
+}

src/assume/test_data/review_assumptions2/001-plan.txt

@@ -0,0 +1,7 @@
+Plan:
+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.
+
+Today's date:
+2025-Feb-10
+
+Project start ASAP

src/assume/test_data/review_assumptions2/002-make_assumptions.json

@@ -0,0 +1,42 @@
+[
+  {
+    "question": "What is the estimated budget allocated for personnel, computational resources, and data storage for this project?",
+    "assumptions": "Assumption: A budget of $10,000 is allocated for the initial phase, covering personnel costs (part-time researcher), cloud computing for paper processing, and data storage on a public repository. This is based on typical costs for similar academic projects.",
+    "assessments": "Title: Financial Feasibility Assessment\nDescription: Evaluation of the project's financial viability based on the allocated budget.\nDetails: The $10,000 budget is tight but feasible for a small-scale initial phase. Risks include potential cost overruns for cloud computing if the volume of papers is high. Mitigation: Implement strict budget controls, optimize cloud resource usage, and explore free or discounted academic resources. Opportunity: Securing grants or sponsorships could expand the project's scope and impact."
+  },
+  {
+    "question": "What is the target completion date for the initial dataset release, and what are the key milestones leading up to it?",
+    "assumptions": "Assumption: The initial dataset release is targeted for 2025-May-10, with milestones including literature review (2 weeks), summary template design (1 week), initial paper distillation (6 weeks), and dataset formatting/publication (2 weeks). This timeline is based on the complexity of the task and available resources.",
+    "assessments": "Title: Timeline & Milestones Assessment\nDescription: Evaluation of the project's timeline and the feasibility of meeting the set milestones.\nDetails: The timeline is aggressive but achievable with focused effort. Risks include delays in paper distillation due to unforeseen complexities. Mitigation: Prioritize papers based on impact and relevance, and allocate sufficient time for quality control. Opportunity: Streamlining the distillation process could accelerate the timeline and allow for more papers to be included in the initial release."
+  },
+  {
+    "question": "What specific roles and expertise are required for this project (e.g., machine learning researchers, data scientists, curators)?",
+    "assumptions": "Assumption: The project requires one part-time machine learning researcher with experience in natural language processing and benchmark analysis, and access to a data curator for dataset formatting and publication. This is based on the skills needed for paper analysis and data management.",
+    "assessments": "Title: Resources & Personnel Assessment\nDescription: Evaluation of the adequacy of the project's human resources and expertise.\nDetails: Having a part-time ML researcher is sufficient for the initial phase. Risks include potential bottlenecks if the researcher is overloaded. Mitigation: Clearly define roles and responsibilities, and consider outsourcing data curation tasks. Opportunity: Collaborating with other researchers or institutions could provide access to additional expertise and resources."
+  },
+  {
+    "question": "What are the guidelines for ensuring objectivity and avoiding bias in the paper summaries, and how will these be enforced?",
+    "assumptions": "Assumption: Objectivity will be ensured through a standardized summary template, peer review of summaries, and adherence to a pre-defined set of criteria for evaluating significance. This is based on best practices for scientific reporting.",
+    "assessments": "Title: Governance & Regulations Assessment\nDescription: Evaluation of the project's governance structure and adherence to ethical guidelines.\nDetails: The proposed guidelines are a good starting point. Risks include unintentional bias creeping into the summaries. Mitigation: Implement a blind review process and regularly audit summaries for potential biases. Opportunity: Establishing an advisory board of experts could provide oversight and ensure the project's integrity."
+  },
+  {
+    "question": "What measures will be taken to ensure the accuracy and reliability of the distilled information, and to mitigate the risk of misinterpreting research findings?",
+    "assumptions": "Assumption: Accuracy will be ensured through cross-validation of summaries by multiple reviewers, verification of claims against original papers and benchmarks, and clear documentation of the distillation process. This is based on standard practices for data validation.",
+    "assessments": "Title: Safety & Risk Management Assessment\nDescription: Evaluation of the project's risk management strategies, focusing on data accuracy and reliability.\nDetails: The proposed measures are crucial for maintaining data integrity. Risks include errors in the distillation process leading to inaccurate summaries. Mitigation: Implement a robust quality control process with multiple layers of review and validation. Opportunity: Developing automated tools for claim verification could improve efficiency and accuracy."
+  },
+  {
+    "question": "How will the project minimize its environmental impact, particularly regarding computational resources used for processing and storing the data?",
+    "assumptions": "Assumption: The project will minimize its environmental impact by using energy-efficient cloud computing resources, optimizing code for performance, and storing data in a compressed format. This is based on best practices for sustainable computing.",
+    "assessments": "Title: Environmental Impact Assessment\nDescription: Evaluation of the project's environmental footprint and strategies for minimizing it.\nDetails: Using cloud computing is generally more efficient than on-premise solutions. Risks include high energy consumption if cloud resources are not optimized. Mitigation: Select cloud providers with renewable energy sources, and optimize code for efficiency. Opportunity: Exploring federated learning or other distributed computing approaches could further reduce the environmental impact."
+  },
+  {
+    "question": "How will the project engage with the machine learning community to gather feedback, promote adoption of the dataset, and ensure its long-term relevance?",
+    "assumptions": "Assumption: The project will engage with the community through open-source code, public forums, conference presentations, and collaborations with other researchers. This is based on standard practices for open science.",
+    "assessments": "Title: Stakeholder Involvement Assessment\nDescription: Evaluation of the project's engagement with stakeholders and strategies for promoting adoption.\nDetails: Community engagement is crucial for the project's success. Risks include lack of adoption if the dataset is not perceived as valuable. Mitigation: Actively solicit feedback from the community and incorporate it into the dataset. Opportunity: Partnering with influential researchers or organizations could increase visibility and adoption."
+  },
+  {
+    "question": "What platform will be used to host the open-access dataset, and what measures will be taken to ensure its long-term accessibility and maintainability?",
+    "assumptions": "Assumption: The dataset will be hosted on a well-established repository like Hugging Face Datasets or Zenodo, with clear documentation, version control, and a stable API. This is based on best practices for data archiving.",
+    "assessments": "Title: Operational Systems Assessment\nDescription: Evaluation of the project's operational infrastructure and strategies for ensuring long-term sustainability.\nDetails: Choosing a reputable repository is essential for long-term accessibility. Risks include data loss or corruption if the repository is not properly maintained. Mitigation: Regularly back up the dataset and monitor the repository for any issues. Opportunity: Developing automated tools for dataset updates and maintenance could reduce the long-term operational burden."
+  }
+]

src/assume/test_data/review_assumptions2/003-distill_assumptions.json

@@ -0,0 +1,12 @@
+{
+  "assumption_list": [
+    "The initial phase budget is $10,000 for personnel, cloud computing, and storage.",
+    "Initial dataset release is targeted for 2025-May-10, including key milestones.",
+    "The project requires one part-time ML researcher and access to a data curator.",
+    "Objectivity is ensured via a template, peer review, and pre-defined criteria.",
+    "Accuracy is ensured through cross-validation, verification, and clear documentation.",
+    "The project will minimize environmental impact by using efficient cloud resources.",
+    "The project will engage the community through open-source code and collaborations.",
+    "Dataset hosted on Hugging Face or Zenodo with documentation, version control, and API."
+  ]
+}

src/expert/pre_project_assessment.py

@@ -1,6 +1,8 @@
 """
 PROMPT> python -m src.expert.pre_project_assessment
 
+IDEA: markdown document, that goes into the final report.
+
 Two experts analyze a project plan and provide feedback.
 
 Analysis: Experts assess the plan.

src/llm_util/ollama_info.py

@@ -1,46 +1,63 @@
-"""
-PROMPT> python -m src.llm_util.ollama_info
-"""
-from dataclasses import dataclass
-
-@dataclass
-class OllamaInfo:
-    """
-    Details about the Ollama service, including a list of available model names,
-    a flag indicating whether the service is running, and an optional error message.
-    """
-    model_names: list[str]
-    is_running: bool
-    error_message: str = None
-
-    @classmethod
-    def obtain_info(cls) -> 'OllamaInfo':
-        """Retrieves information about the Ollama service."""
-        try:
-            # Only import ollama if it's available
-            from ollama import ListResponse, list
-            list_response: ListResponse = list()
-        except ImportError as e:
-            error_message = f"OllamaInfo. 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}"
-            return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
-        except Exception as e:
-            error_message = f"OllamaInfo. 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]
-        return OllamaInfo(model_names=model_names, is_running=True, error_message=None)
-    
-    def is_model_available(self, find_model: str) -> bool:
-        """Checks if a specific model is available in the list of model names."""
-        return find_model in self.model_names
-
-if __name__ == '__main__':
-    find_model = 'qwen2.5-coder:latest'
-    ollama_info = OllamaInfo.obtain_info()
-    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)
-    print(f'Has model {find_model}: {found}')
+"""
+PROMPT> python -m src.llm_util.ollama_info
+"""
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class OllamaInfo:
+    """
+    Details about the Ollama service, including a list of available model names,
+    a flag indicating whether the service is running, and an optional error message.
+    """
+    model_names: list[str]
+    is_running: bool
+    error_message: Optional[str] = None
+
+    @classmethod
+    def obtain_info(cls) -> 'OllamaInfo':
+        """Retrieves information about the Ollama service."""
+        try:
+            # Only import ollama if it's available
+            from ollama import ListResponse, list
+            list_response: ListResponse = list()
+        except ImportError as e:
+            error_message = f"OllamaInfo. 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}"
+            return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
+        except Exception as e:
+            error_message = f"OllamaInfo. 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]
+        return OllamaInfo(model_names=model_names, is_running=True, error_message=None)
+    
+    def is_model_available(self, find_model: str) -> bool:
+        """
+        Checks if a specific model is available.
+        
+        Args:
+            find_model: Name of the model to check. Can be either a local Ollama model
+                       or a HuggingFace GGUF model (prefixed with 'hf.co/').
+
+        Returns:
+            bool: True if the model is available or is a valid GGUF model path.
+        """
+        if not find_model:
+            return False
+            
+        # Support direct use of GGUF models from HuggingFace
+        if find_model.startswith("hf.co/"):
+            return True
+            
+        return find_model in self.model_names
+
+if __name__ == '__main__':
+    find_model = 'qwen2.5-coder:latest'
+    ollama_info = OllamaInfo.obtain_info()
+    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)
+    print(f'Has model {find_model}: {found}')

src/pitch/convert_pitch_to_markdown.py

@@ -107,7 +107,7 @@ class ConvertPitchToMarkdown:
             markdown_content = response_content  # Use the entire content if delimiters are missing
             logger.warning("Output delimiters not found in LLM response.")
 
-        # The bullet lists are supposed to be preceeded by 2 newlines. 
+        # The bullet lists are supposed to be preceded by 2 newlines. 
         # However often there is just 1 newline. 
         # This fix makes sure there are 2 newlines before bullet lists.
         markdown_content = fix_bullet_lists(markdown_content)

src/plan/app_text2plan.py

@@ -203,6 +203,13 @@ def initialize_browser_settings(browser_state, session_state: SessionState):
     openrouter_api_key = settings.get("openrouter_api_key_text", "")
     model = settings.get("model_radio", default_model_value)
     speedvsdetail = settings.get("speedvsdetail_radio", SpeedVsDetailEnum.ALL_DETAILS_BUT_SLOW)
+
+    # When making changes to the llm_config.json, it may happen that the selected model is no longer among the available_model_names.
+    # In that case, set the model to the default_model_value.
+    if model not in [item[1] for item in available_model_names]:
+        logger.info(f"initialize_browser_settings: model '{model}' is not in available_model_names. Setting to default_model_value: {default_model_value}")
+        model = default_model_value
+
     session_state.openrouter_api_key = openrouter_api_key
     session_state.llm_model = model
     session_state.speedvsdetail = speedvsdetail

src/plan/data/simple_plan_prompts.jsonl

@@ -3,6 +3,7 @@
 {"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"]}
 {"id": "930c2abc-faa7-4c21-8ae1-f0323cbcd120", "prompt": "Open the first space elevator terminal in Berlin, Germany, connecting Earths surface to orbit.", "tags": ["space", "exploration", "berlin", "germany"]}
 {"id": "45763178-8ba8-4a86-adcd-63ed19d4d47b", "prompt": "Establish a humanoid robot factory in Paris, France.", "tags": ["paris", "france", "robots"]}
+{"id": "de626417-4871-4acc-899d-2c41fd148807", "prompt": "Establish a humanoid robot factory in Caracas, Venezuela.", "tags": ["caracas", "venezuela", "robots"]}
 {"id": "67c461a9-3364-42a4-bf8f-643315abfcf6", "prompt": "When I die, I want to become a skeleton, skull and bones. I love zombies.", "tags": ["death", "bones", "post-mortem", "zoombie"]}
 {"id": "d70ced0b-d5c7-4b84-88d7-18a5ada2cfee", "prompt": "Construct a new metro line under the city center of Copenhagen, Denmark.", "tags": ["denmark", "copenhagen", "metro"]}
 {"id": "f24a6ba9-20ce-40bb-866a-263b87b5ddcc", "prompt": "I want to make a restaurant for puzzle solving happy people. An important part is that humans are solving puzzles with each other. While having something to drink and eat.", "tags": ["restaurant", "puzzle", "food"]}
@@ -21,8 +22,10 @@
 {"id": "d3e10877-446f-4eb0-8027-864e923973b0", "prompt": "Construct a train bridge between Denmark and England.", "tags": ["denmark", "england", "bridge"]}
 {"id": "9fbb7ff9-5dc3-44f4-9823-dba3f31d3661", "prompt": "Write a Python script for a bouncing yellow ball within a square. Make sure to handle collision detection. Make the square slightly rotate. Implement it in Python. Make sure the ball stays within the square.", "tags": ["programming", "python", "collision detection"]}
 {"id": "676cbca8-5d49-42a0-8826-398318004703", "prompt": "Write a Python script for a snake shape keep bouncing within a pentagon. Make sure to handle collision detection properly. Make the pentagon slowly rotate.", "tags": ["programming", "python", "collision detection"]}
+{"id": "5719d9d2-da23-410e-beac-af8fe65d5482", "prompt": "Write a blog post about Paris, listing the top attractions.", "tags": ["blog", "paris", "tourism"]}
 {"id": "a9113924-6148-4a0c-b72a-eecdb856e1e2", "prompt": "Investigate outbreak of a deadly new disease in the jungle.", "tags": ["outbreak", "jungle", "emergency"]}
-{"id": "d68da41f-9341-40c0-85ee-7fc9181271d1", "prompt": "Eradication of Oak Processionary Caterpillars. It was discovered in Denmark for the first time just under three weeks ago, with around 800 nests found in trees in southeastern Odense. You suffocate from the caterpillar’s toxic hairs. Limit the outbreak as quick as possible.", "tags": ["outbreak", "toxic", "caterpillar", "emergency"]}
+{"id": "d68da41f-9341-40c0-85ee-7fc9181271d1", "prompt": "Eradication of Oak Processionary Caterpillars. It was discovered in Denmark for the first time just under three weeks ago, with around 800 nests found in trees in southeastern Odense. You suffocate from the caterpillar’s toxic hairs. Limit the outbreak as quick as possible.", "tags": ["denmark", "outbreak", "toxic", "caterpillar", "emergency"]}
+{"id": "87cbb86d-8ee1-4477-a71d-5e702bf6a887", "prompt": "Launch a pollution monitoring program for Roskilde Fjord in Roskilde, Denmark, in response to alarming fish die-offs. Track oxygen levels, nutrients, microplastics, pH, nitrates, and phosphates in real time.", "tags": ["denmark", "roskilde", "pollution", "fish"]}
 {"id": "4dc34d55-0d0d-4e9d-92f4-23765f49dd29", "prompt": "Establish a solar farm in Denmark.", "tags": ["denmark", "energy", "sun"]}
 {"id": "0bb4a7d3-c16b-4b21-8a9b-20e1cd4002d4", "prompt": "Develop a sustainable solution for extreme poverty in regions where people live on less than 2 USD per day. Focus on improving access to basic necessities like food, shelter, and clean water, and explain how you would allocate investments given that sectors like infrastructure may require higher per capita funding. Indicate whether your approach leverages existing systems or builds new capacity. Assume this initiative will impact 5 million people over 5 years with a total budget of 500 million USD.", "tags": ["poverty", "sustainability", "development"]}
 {"id": "307f7e0c-a160-4b7a-9e3c-76577164497e", "prompt": "Create a comprehensive plan to address hunger and malnutrition in impoverished communities by enhancing food security and nutritional education. Provide a detailed cost breakdown and clarify which components might need additional per capita investment. State whether you will leverage existing food distribution networks or develop new infrastructure. Assume the plan targets 3 million individuals across 10 countries with a total budget of 300 million USD over 4 years.", "tags": ["hunger", "malnutrition", "nutrition"]}
@@ -34,3 +37,4 @@
 {"id": "a9f410c0-120e-45d6-b042-e88ca47b39bb", "prompt": "Formulate a housing security plan that addresses overcrowding, unsafe living conditions, and homelessness by promoting secure and dignified housing. Clarify whether the initiative involves new construction, rehabilitation of existing structures, or a combination of both, and outline a phased investment strategy given the higher costs typically associated with housing projects. Assume the plan will provide housing for 200,000 individuals over 4 years with a total budget of 250 million USD.", "tags": ["housing", "security", "urban development"]}
 {"id": "cdf7f29d-bbcb-478d-8b5a-e82e74ed8626", "prompt": "Propose comprehensive peace initiatives and conflict resolution strategies for areas experiencing high rates of violence and political instability. Detail how your approach will protect vulnerable populations, including mechanisms for community engagement, reconciliation, and rebuilding. Assume the intervention will affect 1 million people in conflict zones over 3 years with a total budget of 150 million USD.", "tags": ["conflict", "peace", "stability"]}
 {"id": "79ef9ebf-3173-4b33-81f9-abbd3da7da6d", "prompt": "Design robust adaptation and resilience programs for communities facing environmental degradation and the effects of climate change, especially in disaster-prone regions. Include both short-term relief measures and long-term sustainability strategies, and provide details on how funds will be allocated between immediate response and infrastructure improvements. Assume the initiative will aid 1.2 million people in the 10 most affected countries over 5 years with a total budget of 180 million USD.", "tags": ["environment", "climate change", "resilience"]}
+{"id": "fe853807-5bfe-4e5b-8071-d6db3c360279", "prompt": "My daily commute from home to work takes 1 hour. My bike is broken and need an alternative plan. I live in Amsterdam, Netherlands.", "tags": ["bike", "traffic", "amsterdam", "netherlands"]}

src/plan/filenames.py

@@ -2,9 +2,22 @@ from enum import Enum
 
 class FilenameEnum(str, Enum):
     INITIAL_PLAN = "001-plan.txt"
-    MAKE_ASSUMPTIONS_RAW = "002-1-make_assumptions_raw.json"
-    MAKE_ASSUMPTIONS = "002-2-make_assumptions.json"
-    DISTILL_ASSUMPTIONS_RAW = "003-distill_assumptions.json"
+    PLAN_TYPE_RAW = "002-1-plan_type_raw.json"
+    PLAN_TYPE_MARKDOWN = "002-2-plan_type.md"
+    PHYSICAL_LOCATIONS_RAW = "002-3-physical_locations_raw.json"
+    PHYSICAL_LOCATIONS_MARKDOWN = "002-4-physical_locations.md"
+    CURRENCY_STRATEGY_RAW = "002-5-currency_strategy_raw.json"
+    CURRENCY_STRATEGY_MARKDOWN = "002-6-currency_strategy.md"
+    IDENTIFY_RISKS_RAW = "003-1-identify_risks_raw.json"
+    IDENTIFY_RISKS_MARKDOWN = "003-2-identify_risks.md"
+    MAKE_ASSUMPTIONS_RAW = "003-3-make_assumptions_raw.json"
+    MAKE_ASSUMPTIONS_CLEAN = "003-4-make_assumptions.json"
+    MAKE_ASSUMPTIONS_MARKDOWN = "003-5-make_assumptions.md"
+    DISTILL_ASSUMPTIONS_RAW = "003-6-distill_assumptions_raw.json"
+    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"
     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"

src/plan/run_plan_pipeline.py

@@ -16,8 +16,13 @@ from src.plan.filenames import FilenameEnum
 from src.plan.speedvsdetail import SpeedVsDetailEnum
 from src.plan.plan_file import PlanFile
 from src.plan.find_plan_prompt import find_plan_prompt
+from src.assume.identify_plan_type import IdentifyPlanType
+from src.assume.physical_locations import PhysicalLocations
+from src.assume.currency_strategy import CurrencyStrategy
+from src.assume.identify_risks import IdentifyRisks
 from src.assume.make_assumptions import MakeAssumptions
-from src.assume.assumption_orchestrator import AssumptionOrchestrator
+from src.assume.distill_assumptions import DistillAssumptions
+from src.assume.review_assumptions import ReviewAssumptions
 from src.expert.pre_project_assessment import PreProjectAssessment
 from src.plan.create_project_plan import CreateProjectPlan
 from src.swot.swot_analysis import SWOTAnalysis
@@ -76,9 +81,9 @@ class SetupTask(PlanTask):
         plan_file = PlanFile.create(plan_prompt)
         plan_file.save(self.output().path)
 
-class AssumptionsTask(PlanTask):
+class PlanTypeTask(PlanTask):
     """
-    Make assumptions about the plan.
+    Determine if the plan is purely digital or requires physical locations.
     Depends on:
       - SetupTask (for the initial plan)
     """
@@ -88,47 +93,457 @@ class AssumptionsTask(PlanTask):
         return SetupTask(run_id=self.run_id)
 
     def output(self):
-        return luigi.LocalTarget(str(self.file_path(FilenameEnum.DISTILL_ASSUMPTIONS_RAW)))
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.PLAN_TYPE_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.PLAN_TYPE_MARKDOWN)))
+        }
 
     def run(self):
-        logger.info("Making assumptions about the plan...")
+        logger.info("Identifying PlanType of the plan...")
 
         # Read inputs from required tasks.
         with self.input().open("r") as f:
             plan_prompt = f.read()
 
-        # I'm currently debugging the speedvsdetail parameter. When I'm done I can remove it.
-        # Verifying that the speedvsdetail parameter is set correctly.
-        logger.info(f"AssumptionsTask.speedvsdetail: {self.speedvsdetail}")
-        if self.speedvsdetail == SpeedVsDetailEnum.FAST_BUT_SKIP_DETAILS:
-            logger.info("AssumptionsTask: We are in FAST_BUT_SKIP_DETAILS mode.")
+        llm = get_llm(self.llm_model)
+
+        identify_plan_type = IdentifyPlanType.execute(llm, plan_prompt)
+
+        # Write the result to disk.
+        output_raw_path = self.output()['raw'].path
+        identify_plan_type.save_raw(str(output_raw_path))
+        output_markdown_path = self.output()['markdown'].path
+        identify_plan_type.save_markdown(str(output_markdown_path))
+
+
+class PhysicalLocationsTask(PlanTask):
+    """
+    Identify/suggest physical locations for the plan.
+    Depends on:
+      - SetupTask (for the initial plan)
+      - PlanTypeTask (for the plan type)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'plan_type': PlanTypeTask(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.PHYSICAL_LOCATIONS_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.PHYSICAL_LOCATIONS_MARKDOWN)))
+        }
+
+    def run(self):
+        logger.info("Identify/suggest physical locations for the plan...")
+
+        # Read inputs from required tasks.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        with self.input()['plan_type']['raw'].open("r") as f:
+            plan_type_dict = json.load(f)
+
+        output_raw_path = self.output()['raw'].path
+        output_markdown_path = self.output()['markdown'].path
+
+        llm = get_llm(self.llm_model)
+
+        plan_type = plan_type_dict.get("plan_type")
+        if plan_type == "physical":
+            query = (
+                f"File 'plan.txt':\n{plan_prompt}\n\n"
+                f"File 'plan_type.json':\n{format_json_for_use_in_query(plan_type_dict)}"
+            )
+
+            physical_locations = PhysicalLocations.execute(llm, query)
+
+            # Write the physical locations to disk.
+            physical_locations.save_raw(str(output_raw_path))
+            physical_locations.save_markdown(str(output_markdown_path))
         else:
-            logger.info("AssumptionsTask: We are in another mode")
+            # Write an empty file to indicate that there are no physical locations.
+            data = {
+                "comment": "The plan is purely digital, without any physical locations."
+            }
+            with open(output_raw_path, "w") as f:
+                json.dump(data, f, indent=2)
+            
+            with open(output_markdown_path, "w", encoding='utf-8') as f:
+                f.write("The plan is purely digital, without any physical locations.")
+
+class CurrencyStrategyTask(PlanTask):
+    """
+    Identify/suggest what currency to use for the plan, depending on the physical locations.
+    Depends on:
+      - SetupTask (for the initial plan)
+      - PlanTypeTask (for the plan type)
+      - PhysicalLocationsTask (for the physical locations)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'plan_type': PlanTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'physical_locations': PhysicalLocationsTask(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.CURRENCY_STRATEGY_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.CURRENCY_STRATEGY_MARKDOWN)))
+        }
+
+    def run(self):
+        logger.info("Currency strategy for the plan...")
+
+        # Read inputs from required tasks.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        with self.input()['plan_type']['raw'].open("r") as f:
+            plan_type_dict = json.load(f)
+
+        with self.input()['physical_locations']['raw'].open("r") as f:
+            physical_locations_dict = json.load(f)
+
+        query = (
+            f"File 'plan.txt':\n{plan_prompt}\n\n"
+            f"File 'plan_type.json':\n{format_json_for_use_in_query(plan_type_dict)}\n\n"
+            f"File 'physical_locations.json':\n{format_json_for_use_in_query(physical_locations_dict)}"
+        )
 
         llm = get_llm(self.llm_model)
 
-        # Define callback functions.
-        def phase1_post_callback(make_assumptions: MakeAssumptions) -> None:
-            raw_path = self.run_dir / FilenameEnum.MAKE_ASSUMPTIONS_RAW.value
-            cleaned_path = self.run_dir / FilenameEnum.MAKE_ASSUMPTIONS.value
-            make_assumptions.save_raw(str(raw_path))
-            make_assumptions.save_assumptions(str(cleaned_path))
+        currency_strategy = CurrencyStrategy.execute(llm, query)
+
+        # Write the result to disk.
+        output_raw_path = self.output()['raw'].path
+        currency_strategy.save_raw(str(output_raw_path))
+        output_markdown_path = self.output()['markdown'].path
+        currency_strategy.save_markdown(str(output_markdown_path))
+
+
+class IdentifyRisksTask(PlanTask):
+    """
+    Identify risks for the plan, depending on the physical locations.
+    Depends on:
+      - SetupTask (for the initial plan)
+      - PlanTypeTask (for the plan type)
+      - PhysicalLocationsTask (for the physical locations)
+      - CurrencyStrategy (for the currency strategy)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'plan_type': PlanTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'physical_locations': PhysicalLocationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'currency_strategy': CurrencyStrategyTask(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.IDENTIFY_RISKS_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.IDENTIFY_RISKS_MARKDOWN)))
+        }
 
-        # Execute
-        orchestrator = AssumptionOrchestrator()
-        orchestrator.phase1_post_callback = phase1_post_callback
-        orchestrator.execute(llm, plan_prompt)
+    def run(self):
+        logger.info("Identifying risks for the plan...")
+
+        # Read inputs from required tasks.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        with self.input()['plan_type']['raw'].open("r") as f:
+            plan_type_dict = json.load(f)
+
+        with self.input()['physical_locations']['raw'].open("r") as f:
+            physical_locations_dict = json.load(f)
+
+        with self.input()['currency_strategy']['raw'].open("r") as f:
+            currency_strategy_dict = json.load(f)
+
+        query = (
+            f"File 'plan.txt':\n{plan_prompt}\n\n"
+            f"File 'plan_type.json':\n{format_json_for_use_in_query(plan_type_dict)}\n\n"
+            f"File 'physical_locations.json':\n{format_json_for_use_in_query(physical_locations_dict)}\n\n"
+            f"File 'currency_strategy.json':\n{format_json_for_use_in_query(currency_strategy_dict)}"
+        )
+
+        llm = get_llm(self.llm_model)
+
+        identify_risks = IdentifyRisks.execute(llm, query)
 
-        # Write the assumptions to the output file.
-        file_path = self.run_dir / FilenameEnum.DISTILL_ASSUMPTIONS_RAW.value
-        orchestrator.distill_assumptions.save_raw(str(file_path))
+        # Write the result to disk.
+        output_raw_path = self.output()['raw'].path
+        identify_risks.save_raw(str(output_raw_path))
+        output_markdown_path = self.output()['markdown'].path
+        identify_risks.save_markdown(str(output_markdown_path))
+
+
+class MakeAssumptionsTask(PlanTask):
+    """
+    Make assumptions about the plan.
+    Depends on:
+      - SetupTask (for the initial plan)
+      - PlanTypeTask (for the plan type)
+      - PhysicalLocationsTask (for the physical locations)
+      - CurrencyStrategy (for the currency strategy)
+      - IdentifyRisksTask (for the identified risks)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'plan_type': PlanTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'physical_locations': PhysicalLocationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'currency_strategy': CurrencyStrategyTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'identify_risks': IdentifyRisksTask(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.MAKE_ASSUMPTIONS_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.MAKE_ASSUMPTIONS_CLEAN))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.MAKE_ASSUMPTIONS_MARKDOWN)))
+        }
+
+    def run(self):
+        logger.info("Making assumptions about the plan...")
+
+        # Read inputs from required tasks.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        with self.input()['plan_type']['raw'].open("r") as f:
+            plan_type_dict = json.load(f)
+
+        with self.input()['physical_locations']['raw'].open("r") as f:
+            physical_locations_dict = json.load(f)
+
+        with self.input()['currency_strategy']['raw'].open("r") as f:
+            currency_strategy_dict = json.load(f)
+
+        with self.input()['identify_risks']['raw'].open("r") as f:
+            identify_risks_dict = json.load(f)
+
+        query = (
+            f"File 'plan.txt':\n{plan_prompt}\n\n"
+            f"File 'plan_type.json':\n{format_json_for_use_in_query(plan_type_dict)}\n\n"
+            f"File 'physical_locations.json':\n{format_json_for_use_in_query(physical_locations_dict)}\n\n"
+            f"File 'currency_strategy.json':\n{format_json_for_use_in_query(currency_strategy_dict)}\n\n"
+            f"File 'identify_risks.json':\n{format_json_for_use_in_query(identify_risks_dict)}"
+        )
+
+        llm = get_llm(self.llm_model)
+
+        make_assumptions = MakeAssumptions.execute(llm, query)
+
+        # Write the result to disk.
+        output_raw_path = self.output()['raw'].path
+        make_assumptions.save_raw(str(output_raw_path))
+        output_clean_path = self.output()['clean'].path
+        make_assumptions.save_assumptions(str(output_clean_path))
+        output_markdown_path = self.output()['markdown'].path
+        make_assumptions.save_markdown(str(output_markdown_path))
+
+
+class DistillAssumptionsTask(PlanTask):
+    """
+    Distill raw assumption data.
+    Depends on:
+      - SetupTask (for the initial plan)
+      - MakeAssumptionsTask (for the draft assumptions)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'make_assumptions': MakeAssumptionsTask(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.DISTILL_ASSUMPTIONS_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.DISTILL_ASSUMPTIONS_MARKDOWN)))
+        }
+
+    def run(self):
+        logger.info("Distilling assumptions...")
+
+        # Read the plan prompt from SetupTask's output.
+        setup_target = self.input()['setup']
+        with setup_target.open("r") as f:
+            plan_prompt = f.read()
+
+        # Read the assumptions from MakeAssumptionsTask's output.
+        make_assumptions_target = self.input()['make_assumptions']['clean']
+        with make_assumptions_target.open("r") as f:
+            assumptions_raw_data = json.load(f)
+
+        llm = get_llm(self.llm_model)
+
+        query = (
+            f"{plan_prompt}\n\n"
+            f"assumption.json:\n{assumptions_raw_data}"
+        )
+
+        distill_assumptions = DistillAssumptions.execute(llm, query)
+
+        # Write the result to disk.
+        output_raw_path = self.output()['raw'].path
+        distill_assumptions.save_raw(str(output_raw_path))
+        output_markdown_path = self.output()['markdown'].path
+        distill_assumptions.save_markdown(str(output_markdown_path))
+
+
+class ReviewAssumptionsTask(PlanTask):
+    """
+    Find issues with the assumptions.
+    Depends on:
+      - PlanTypeTask
+      - PhysicalLocationsTask
+      - CurrencyStrategyTask
+      - IdentifyRisksTask
+      - MakeAssumptionsTask
+      - DistillAssumptionsTask
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'plan_type': PlanTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'physical_locations': PhysicalLocationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'currency_strategy': CurrencyStrategyTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'identify_risks': IdentifyRisksTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'make_assumptions': MakeAssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'distill_assumptions': DistillAssumptionsTask(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.REVIEW_ASSUMPTIONS_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.REVIEW_ASSUMPTIONS_MARKDOWN)))
+        }
+
+    def run(self):
+        # Define the list of (title, path) tuples
+        title_path_list = [
+            ('Plan Type', self.input()['plan_type']['markdown'].path),
+            ('Physical Locations', self.input()['physical_locations']['markdown'].path),
+            ('Currency Strategy', self.input()['currency_strategy']['markdown'].path),
+            ('Identify Risks', self.input()['identify_risks']['markdown'].path),
+            ('Make Assumptions', self.input()['make_assumptions']['markdown'].path),
+            ('Distill Assumptions', self.input()['distill_assumptions']['markdown'].path)
+        ]
+
+        # Read the files and handle exceptions
+        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}")
+            except FileNotFoundError:
+                logger.warning(f"Markdown file not found: {path} (from {title})")
+                markdown_chunks.append(f"**Problem with document:** '{title}'\n\nFile not found.")
+            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.")
+
+        # Combine the markdown chunks
+        full_markdown = "\n\n".join(markdown_chunks)
+
+        llm = get_llm(self.llm_model)
+
+        review_assumptions = ReviewAssumptions.execute(llm, full_markdown)
+
+        # Write the result to disk.
+        output_raw_path = self.output()['raw'].path
+        review_assumptions.save_raw(str(output_raw_path))
+        output_markdown_path = self.output()['markdown'].path
+        review_assumptions.save_markdown(str(output_markdown_path))
+
+
+class ConsolidateAssumptionsMarkdownTask(PlanTask):
+    """
+    Combines multiple small markdown documents into a single big document.
+    Depends on:
+      - PlanTypeTask
+      - PhysicalLocationsTask
+      - CurrencyStrategyTask
+      - IdentifyRisksTask
+      - MakeAssumptionsTask
+      - DistillAssumptionsTask
+      - ReviewAssumptionsTask
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'plan_type': PlanTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'physical_locations': PhysicalLocationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'currency_strategy': CurrencyStrategyTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'identify_risks': IdentifyRisksTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'make_assumptions': MakeAssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'distill_assumptions': DistillAssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'review_assumptions': ReviewAssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.CONSOLIDATE_ASSUMPTIONS_MARKDOWN)))
+
+    def run(self):
+        # Define the list of (title, path) tuples
+        title_path_list = [
+            ('Plan Type', self.input()['plan_type']['markdown'].path),
+            ('Physical Locations', self.input()['physical_locations']['markdown'].path),
+            ('Currency Strategy', self.input()['currency_strategy']['markdown'].path),
+            ('Identify Risks', self.input()['identify_risks']['markdown'].path),
+            ('Make Assumptions', self.input()['make_assumptions']['markdown'].path),
+            ('Distill Assumptions', self.input()['distill_assumptions']['markdown'].path),
+            ('Review Assumptions', self.input()['review_assumptions']['markdown'].path)
+        ]
+
+        # Read the files and handle exceptions
+        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}")
+            except FileNotFoundError:
+                logger.warning(f"Markdown file not found: {path} (from {title})")
+                markdown_chunks.append(f"**Problem with document:** '{title}'\n\nFile not found.")
+            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.")
+
+        # Combine the markdown chunks
+        full_markdown = "\n\n".join(markdown_chunks)
+
+        # Write the result to disk.
+        output_markdown_path = self.output().path
+        with open(output_markdown_path, "w", encoding="utf-8") as f:
+            f.write(full_markdown)
 
 
 class PreProjectAssessmentTask(PlanTask):
     llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
 
     def requires(self):
-        return SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail)
+        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)
+        }
 
     def output(self):
         return {
@@ -140,11 +555,17 @@ class PreProjectAssessmentTask(PlanTask):
         logger.info("Conducting pre-project assessment...")
 
         # Read the plan prompt from the SetupTask's output.
-        with self.input().open("r") as f:
+        with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
+
         # Build the query.
-        query = f"Initial plan: {plan_prompt}\n\n"
+        query = (
+            f"File 'plan.txt':\n{plan_prompt}\n\n"
+            f"File 'assumptions.md':\n{consolidate_assumptions_markdown}"
+        )
 
         # Get an instance of your LLM.
         llm = get_llm(self.llm_model)
@@ -167,13 +588,13 @@ class ProjectPlanTask(PlanTask):
     def requires(self):
         """
         This task depends on:
-          - SetupTask: produces the plan prompt (001-plan.txt)
-          - AssumptionsTask: produces the distilled assumptions (003-distill_assumptions.json)
+          - SetupTask: produces the plan prompt
+          - ConsolidateAssumptionsMarkdownTask: the assumptions and scope.
           - PreProjectAssessmentTask: produces the pre‑project assessment files
         """
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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)
         }
 
@@ -188,10 +609,9 @@ class ProjectPlanTask(PlanTask):
         with setup_target.open("r") as f:
             plan_prompt = f.read()
 
-        # Read assumptions from the distilled assumptions output.
-        assumptions_file = self.input()['assumptions']
-        with assumptions_file.open("r") as f:
-            assumption_list = json.load(f)
+        # Load the consolidated assumptions.
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
 
         # Read the pre-project assessment from its file.
         pre_project_assessment_file = self.input()['preproject']['clean']
@@ -200,9 +620,9 @@ class ProjectPlanTask(PlanTask):
 
         # Build the query.
         query = (
-            f"Initial plan: {plan_prompt}\n\n"
-            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
-            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}"
+            f"File '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)}"
         )
 
         # Get an LLM instance.
@@ -222,7 +642,7 @@ class FindTeamMembersTask(PlanTask):
     def requires(self):
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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)
         }
@@ -236,19 +656,19 @@ class FindTeamMembersTask(PlanTask):
     def run(self):
         logger.info("FindTeamMembers. Loading files...")
 
-        # 1. Read the plan prompt from SetupTask.
+        # Read the plan prompt from SetupTask.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
-        # 2. Read the distilled assumptions from AssumptionsTask.
-        with self.input()['assumptions'].open("r") as f:
-            assumption_list = json.load(f)
+        # Load the consolidated assumptions.
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
 
-        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
 
-        # 4. Read the project plan from ProjectPlanTask.
+        # Read the project plan from ProjectPlanTask.
         with self.input()['project_plan'].open("r") as f:
             project_plan_dict = json.load(f)
 
@@ -256,10 +676,10 @@ class FindTeamMembersTask(PlanTask):
 
         # Build the query.
         query = (
-            f"Initial plan: {plan_prompt}\n\n"
-            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
-            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}"
+            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)}"
         )
 
         # Create LLM instance.
@@ -290,7 +710,7 @@ class EnrichTeamMembersWithContractTypeTask(PlanTask):
     def requires(self):
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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)
@@ -305,23 +725,23 @@ class EnrichTeamMembersWithContractTypeTask(PlanTask):
     def run(self):
         logger.info("EnrichTeamMembersWithContractType. Loading files...")
 
-        # 1. Read the plan prompt from SetupTask.
+        # Read the plan prompt from SetupTask.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
-        # 2. Read the distilled assumptions from AssumptionsTask.
-        with self.input()['assumptions'].open("r") as f:
-            assumption_list = json.load(f)
+        # Load the consolidated assumptions.
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
 
-        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
 
-        # 4. Read the project plan from ProjectPlanTask.
+        # Read the project plan from ProjectPlanTask.
         with self.input()['project_plan'].open("r") as f:
             project_plan_dict = json.load(f)
 
-        # 5. Read the team_member_list from FindTeamMembersTask.
+        # Read the team_member_list from FindTeamMembersTask.
         with self.input()['find_team_members']['clean'].open("r") as f:
             team_member_list = json.load(f)
 
@@ -329,11 +749,11 @@ class EnrichTeamMembersWithContractTypeTask(PlanTask):
 
         # Build the query.
         query = (
-            f"Initial plan: {plan_prompt}\n\n"
-            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
-            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
-            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+            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)}"
         )
 
         # Create LLM instance.
@@ -364,7 +784,7 @@ class EnrichTeamMembersWithBackgroundStoryTask(PlanTask):
     def requires(self):
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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)
@@ -379,23 +799,23 @@ class EnrichTeamMembersWithBackgroundStoryTask(PlanTask):
     def run(self):
         logger.info("EnrichTeamMembersWithBackgroundStoryTask. Loading files...")
 
-        # 1. Read the plan prompt from SetupTask.
+        # Read the plan prompt from SetupTask.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
-        # 2. Read the distilled assumptions from AssumptionsTask.
-        with self.input()['assumptions'].open("r") as f:
-            assumption_list = json.load(f)
+        # Load the consolidated assumptions.
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
 
-        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
 
-        # 4. Read the project plan from ProjectPlanTask.
+        # Read the project plan from ProjectPlanTask.
         with self.input()['project_plan'].open("r") as f:
             project_plan_dict = json.load(f)
 
-        # 5. Read the team_member_list from EnrichTeamMembersWithContractTypeTask.
+        # 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)
 
@@ -403,11 +823,11 @@ class EnrichTeamMembersWithBackgroundStoryTask(PlanTask):
 
         # Build the query.
         query = (
-            f"Initial plan: {plan_prompt}\n\n"
-            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
-            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
-            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+            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)}"
         )
 
         # Create LLM instance.
@@ -438,7 +858,7 @@ class EnrichTeamMembersWithEnvironmentInfoTask(PlanTask):
     def requires(self):
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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)
@@ -453,23 +873,23 @@ class EnrichTeamMembersWithEnvironmentInfoTask(PlanTask):
     def run(self):
         logger.info("EnrichTeamMembersWithEnvironmentInfoTask. Loading files...")
 
-        # 1. Read the plan prompt from SetupTask.
+        # Read the plan prompt from SetupTask.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
-        # 2. Read the distilled assumptions from AssumptionsTask.
-        with self.input()['assumptions'].open("r") as f:
-            assumption_list = json.load(f)
+        # Load the consolidated assumptions.
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
 
-        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
 
-        # 4. Read the project plan from ProjectPlanTask.
+        # Read the project plan from ProjectPlanTask.
         with self.input()['project_plan'].open("r") as f:
             project_plan_dict = json.load(f)
 
-        # 5. Read the team_member_list from EnrichTeamMembersWithBackgroundStoryTask.
+        # 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)
 
@@ -477,11 +897,11 @@ class EnrichTeamMembersWithEnvironmentInfoTask(PlanTask):
 
         # Build the query.
         query = (
-            f"Initial plan: {plan_prompt}\n\n"
-            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
-            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
-            f"Here is the list of team members that needs to be enriched:\n{format_json_for_use_in_query(team_member_list)}"
+            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)}"
         )
 
         # Create LLM instance.
@@ -512,7 +932,7 @@ class ReviewTeamTask(PlanTask):
     def requires(self):
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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)
@@ -524,23 +944,23 @@ class ReviewTeamTask(PlanTask):
     def run(self):
         logger.info("ReviewTeamTask. Loading files...")
 
-        # 1. Read the plan prompt from SetupTask.
+        # Read the plan prompt from SetupTask.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
-        # 2. Read the distilled assumptions from AssumptionsTask.
-        with self.input()['assumptions'].open("r") as f:
-            assumption_list = json.load(f)
+        # Load the consolidated assumptions.
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
 
-        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
 
-        # 4. Read the project plan from ProjectPlanTask.
+        # Read the project plan from ProjectPlanTask.
         with self.input()['project_plan'].open("r") as f:
             project_plan_dict = json.load(f)
 
-        # 5. Read the team_member_list from EnrichTeamMembersWithEnvironmentInfoTask.
+        # 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)
 
@@ -553,11 +973,11 @@ class ReviewTeamTask(PlanTask):
 
         # Build the query.
         query = (
-            f"Initial plan: {plan_prompt}\n\n"
-            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
-            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
-            f"Document with team members:\n{team_document_markdown}"
+            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}"
         )
 
         # Create LLM instance.
@@ -617,7 +1037,7 @@ class SWOTAnalysisTask(PlanTask):
     def requires(self):
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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)
         }
@@ -631,19 +1051,19 @@ class SWOTAnalysisTask(PlanTask):
     def run(self):
         logger.info("SWOTAnalysisTask. Loading files...")
 
-        # 1. Read the plan prompt from SetupTask.
+        # Read the plan prompt from SetupTask.
         with self.input()['setup'].open("r") as f:
             plan_prompt = f.read()
 
-        # 2. Read the distilled assumptions from AssumptionsTask.
-        with self.input()['assumptions'].open("r") as f:
-            assumption_list = json.load(f)
+        # Load the consolidated assumptions.
+        with self.input()['consolidate_assumptions_markdown'].open("r") as f:
+            consolidate_assumptions_markdown = f.read()
 
-        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        # Read the pre-project assessment from PreProjectAssessmentTask.
         with self.input()['preproject']['clean'].open("r") as f:
             pre_project_assessment_dict = json.load(f)
 
-        # 4. Read the project plan from ProjectPlanTask.
+        # Read the project plan from ProjectPlanTask.
         with self.input()['project_plan'].open("r") as f:
             project_plan_dict = json.load(f)
 
@@ -651,10 +1071,10 @@ class SWOTAnalysisTask(PlanTask):
 
         # Build the query for SWOT analysis.
         query = (
-            f"Initial plan: {plan_prompt}\n\n"
-            f"Assumptions:\n{format_json_for_use_in_query(assumption_list)}\n\n"
-            f"Pre-project assessment:\n{format_json_for_use_in_query(pre_project_assessment_dict)}\n\n"
-            f"Project plan:\n{format_json_for_use_in_query(project_plan_dict)}"
+            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)}"
         )
 
         # Create LLM instances for SWOT analysis.
@@ -1289,6 +1709,7 @@ class ReportTask(PlanTask):
     
     def requires(self):
         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),
             '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),
@@ -1298,6 +1719,7 @@ class ReportTask(PlanTask):
     
     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)
@@ -1311,7 +1733,14 @@ class FullPlanPipeline(PlanTask):
     def requires(self):
         return {
             'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
-            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'plan_type': PlanTypeTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'physical_locations': PhysicalLocationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'currency_strategy': CurrencyStrategyTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'identify_risks': IdentifyRisksTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'make_assumptions': MakeAssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'assumptions': DistillAssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'review_assumptions': ReviewAssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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),
             'find_team_members': FindTeamMembersTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),

src/report/report_generator.py

@@ -5,6 +5,7 @@ PROMPT> python -m src.report.report_generator /path/to/PlanExe_20250216_dir
 This generates the report without opening the browser.
 PROMPT> python -m src.report.report_generator /path/to/PlanExe_20250216_dir --no-browser
 """
+import re
 import json
 import logging
 import pandas as pd
@@ -80,29 +81,35 @@ 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."""
-        pitch_md = self.read_markdown_file(file_path)
-        if pitch_md:
-            self.report_data['pitch'] = pitch_md
+        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."""
-        swot_md = self.read_markdown_file(file_path)
-        if swot_md:
-            self.report_data['swot'] = swot_md
+        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."""
-        swot_md = self.read_markdown_file(file_path)
-        if swot_md:
-            self.report_data['team'] = swot_md
+        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."""
-        expert_md = self.read_markdown_file(file_path)
-        if expert_md:
-            self.report_data['expert_criticism'] = expert_md
+        markdown = self.read_markdown_file(file_path)
+        if markdown:
+            self.report_data['expert_criticism'] = markdown
     
     def append_project_plan_csv(self, file_path: Path):
         """Append the project plan CSV to the report."""
@@ -115,142 +122,59 @@ class ReportGenerator:
 
     def generate_html_report(self) -> str:
         """Generate an HTML report from the gathered data."""
-        html_parts = []
-        
-        # Header with improved styling
-        html_parts.append("""
-        <html>
-        <head>
-            <title>PlanExe Project Report</title>
-            <style>
-                body { 
-                    font-family: Arial, sans-serif; 
-                    margin: 40px;
-                    line-height: 1.6;
-                    color: #333;
-                    max-width: 1200px;
-                    margin: 0 auto;
-                    padding: 20px;
-                }
-                h1 { 
-                    color: #2c3e50;
-                    border-bottom: 2px solid #eee;
-                    padding-bottom: 10px;
-                }
-                h2 { 
-                    color: #34495e;
-                    margin-top: 30px;
-                    border-bottom: 1px solid #eee;
-                    padding-bottom: 5px;
-                }
-                .section { 
-                    margin: 20px 0;
-                    padding: 20px;
-                    border: 1px solid #eee;
-                    border-radius: 5px;
-                    background-color: #fff;
-                    box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-                }
-                table { 
-                    border-collapse: collapse;
-                    width: 100%;
-                    margin: 20px 0;
-                    font-size: 14px;
-                }
-                th, td { 
-                    border: 1px solid #ddd;
-                    padding: 12px 8px;
-                    text-align: left;
-                }
-                th { 
-                    background-color: #f5f5f5;
-                    font-weight: bold;
-                }
-                tr:nth-child(even) { 
-                    background-color: #f9f9f9;
-                }
-                tr:hover {
-                    background-color: #f5f5f5;
-                }
-                .timestamp { 
-                    color: #666;
-                    font-size: 0.9em;
-                    margin-bottom: 30px;
-                }
-                .dataframe {
-                    overflow-x: auto;
-                    display: block;
-                }
-                .source-info {
-                    color: #666;
-                    font-size: 0.9em;
-                    margin-top: 10px;
-                    font-style: italic;
-                }
-            </style>
-        </head>
-        <body>
-        """)
 
+        path_to_template = Path(__file__).parent / 'report_template.html'
+        with open(path_to_template, 'r') as f:
+            html_template = f.read()
+        
+        html_parts = []
         # Title and Timestamp
         html_parts.append(f"""
         <h1>PlanExe Project Report</h1>
         <p class="timestamp">Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
         """)
 
-        # Project Pitch
-        if 'pitch' in self.report_data:
-            html_parts.append("""
+        def add_section(title: str, content: str):
+            html_parts.append(f"""
             <div class="section">
-                <h2>Project Pitch</h2>
+                <button class="collapsible">{title}</button>
+                <div class="content">        
+                    {content}
+                </div>
+            </div>
             """)
-            html_parts.append(markdown.markdown(self.report_data['pitch']))
-            html_parts.append("</div>")
 
-        # SWOT Analysis
+        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:
-            html_parts.append("""
-            <div class="section">
-                <h2>SWOT Analysis</h2>
-            """)
-            html_parts.append(markdown.markdown(self.report_data['swot']))
-            html_parts.append("</div>")
+            add_section('SWOT Analysis', markdown.markdown(self.report_data['swot']))
 
-        # Team
         if 'team' in self.report_data:
-            html_parts.append("""
-            <div class="section">
-                <h2>Team</h2>
-            """)
-            html_parts.append(markdown.markdown(self.report_data['team']))
-            html_parts.append("</div>")
+            add_section('Team', markdown.markdown(self.report_data['team']))
 
-        # Expert Criticism
         if 'expert_criticism' in self.report_data:
-            html_parts.append("""
-            <div class="section">
-                <h2>Expert Criticism</h2>
-            """)
-            html_parts.append(markdown.markdown(self.report_data['expert_criticism']))
-            html_parts.append("</div>")
+            add_section('Expert Criticism', markdown.markdown(self.report_data['expert_criticism']))
 
-        # Project Plan
         if 'project_plan' in self.report_data:
-            html_parts.append("""
-            <div class="section">
-                <h2>Project Plan</h2>
-            """)
             df = self.report_data['project_plan']
-            html_parts.append(df.to_html(classes='dataframe', index=False, na_rep=''))
-            html_parts.append("</div>")
+            table_html = df.to_html(classes='dataframe', index=False, na_rep='')
+            add_section('Project Plan', table_html)
 
-        # Footer
-        html_parts.append("""
-        </body>
-        </html>
-        """)
+        html_content = '\n'.join(html_parts)
+
+        # Replace the content between <!--CONTENT-START--> and <!--CONTENT-END--> with html_content
+        pattern = re.compile(r'<!--CONTENT-START-->.*<!--CONTENT-END-->', re.DOTALL)
+        html = re.sub(
+            pattern,
+            f'<!--CONTENT-START-->\n{html_content}\n<!--CONTENT-END-->',
+            html_template
+        )
 
-        return '\n'.join(html_parts)
+        return html
 
     def save_report(self, output_path: Path) -> None:
         """Generate and save the report."""
@@ -290,6 +214,7 @@ def main():
     
     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)

src/report/report_template.html

@@ -0,0 +1,143 @@
+<html>
+<head>
+    <title>PlanExe Project Report</title>
+    <style>
+        body { 
+            font-family: Arial, sans-serif; 
+            margin: 40px;
+            line-height: 1.6;
+            color: #333;
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        h1 { 
+            color: #2c3e50;
+            border-bottom: 2px solid #eee;
+            padding-bottom: 10px;
+        }
+        h2 { 
+            color: #34495e;
+            margin-top: 30px;
+            border-bottom: 1px solid #eee;
+            padding-bottom: 5px;
+        }
+        .section { 
+            margin: 20px 0;
+            border: 1px solid #eee;
+            border-radius: 5px;
+            background-color: #fff;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        }
+        table { 
+            border-collapse: collapse;
+            width: 100%;
+            margin: 20px 0;
+            font-size: 14px;
+        }
+        th, td { 
+            border: 1px solid #ddd;
+            padding: 12px 8px;
+            text-align: left;
+        }
+        th { 
+            background-color: #f5f5f5;
+            font-weight: bold;
+        }
+        tr:nth-child(even) { 
+            background-color: #f9f9f9;
+        }
+        tr:hover {
+            background-color: #f5f5f5;
+        }
+        .timestamp { 
+            color: #666;
+            font-size: 0.9em;
+            margin-bottom: 30px;
+        }
+        .dataframe {
+            overflow-x: auto;
+            display: block;
+        }
+        .source-info {
+            color: #666;
+            font-size: 0.9em;
+            margin-top: 10px;
+            font-style: italic;
+        }
+        .collapsible {
+            background-color: #3498db;
+            color: white;
+            cursor: pointer;
+            padding: 18px;
+            width: 100%;
+            border: none;
+            border-radius: 5px;
+            text-align: left;
+            outline: none;
+            font-size: 18px;
+            font-weight: bold;
+            transition: background-color 0.3s ease, box-shadow 0.3s ease;
+            position: relative;
+        }
+        .collapsible:hover {
+            background-color: #2980b9;
+            box-shadow: 0 4px 8px rgba(0,0,0,0.4);
+        }
+        .collapsible:after {
+            content: '+';
+            position: absolute;
+            right: 20px;
+            top: 50%;
+            transform: translateY(-50%);
+            transition: transform 0.3s ease;
+        }
+        .active:after {
+            content: "−";
+        }
+        .content {
+            padding: 0 20px;
+            max-height: 0;
+            overflow: hidden;
+            transition: max-height 0.2s ease-out;
+        }
+    </style>
+</head>
+<body>
+    <!--CONTENT-START-->
+    <h1>PlanExe Project Report</h1>
+    <p class="timestamp">Generated on: 1984-12-31 23:59:59</p>
+
+    <div class="section">
+        <button class="collapsible">Project Pitch</button>
+        <div class="content">        
+            <p>Lorem ipsum</p>
+        </div>
+    </div>
+
+    <div class="section">
+        <button class="collapsible">SWOT Analysis</button>
+        <div class="content">        
+            <p>Lorem ipsum</p>
+        </div>
+    </div>
+    <!--CONTENT-END-->
+
+    <script>
+        var coll = document.getElementsByClassName("collapsible");
+        var i;
+
+        for (i = 0; i < coll.length; i++) {
+            coll[i].addEventListener("click", function() {
+                this.classList.toggle("active");
+                var content = this.nextElementSibling;
+                if (content.style.maxHeight){
+                    content.style.maxHeight = null;
+                } else {
+                    content.style.maxHeight = content.scrollHeight + "px";
+                }
+            });
+        }
+    </script>
+</body>
+</html>

src/utils/concat_files_into_string.py

@@ -0,0 +1,20 @@
+import os
+
+def concat_files_into_string(base_path: str, prefix: str="File: '", suffix: str="'\n", document_separator: str="\n\n") -> str:
+    """
+    Read the files, and concat their data into a single string
+    """
+    # Obtain files
+    files = os.listdir(base_path)
+    files = [f for f in files if not f.startswith('.')]
+    files.sort()
+
+    # Read the files, and concat their data into a single string
+    documents = []
+    for file in files:
+        s = f"{prefix}{file}{suffix}"
+        with open(os.path.join(base_path, file), 'r', encoding='utf-8') as f:
+            s += f.read()
+        documents.append(s)
+    all_documents_string = document_separator.join(documents)
+    return all_documents_string