snapshot of PlanExe repo

.env.example

@@ -0,0 +1 @@
+OPENROUTER_API_KEY='sk-or-v1-YOUR_API_KEY'

.gitignore

@@ -0,0 +1,4 @@
+.env
+venv/
+run/
+__pycache__/

llm_config.json

@@ -0,0 +1,60 @@
+{
+    "openrouter-paid-gemini-2.0-flash-001": {
+        "comment": "This is very fast. It's paid, so check the pricing before use.",
+        "class": "OpenRouter",
+        "arguments": {
+            "model": "google/gemini-2.0-flash-001",
+            "api_key": "${OPENROUTER_API_KEY}",
+            "temperature": 0.1,
+            "timeout": 60.0,
+            "is_function_calling_model": false,
+            "is_chat_model": true,
+            "max_tokens": 8192,
+            "max_retries": 5
+        }
+    },
+    "openrouter-paid-openai-gpt-4o-mini": {
+        "comment": "This is medium fast. It's paid, so check the pricing before use.",
+        "class": "OpenRouter",
+        "arguments": {
+            "model": "openai/gpt-4o-mini",
+            "api_key": "${OPENROUTER_API_KEY}",
+            "temperature": 0.1,
+            "timeout": 60.0,
+            "is_function_calling_model": false,
+            "is_chat_model": true,
+            "max_tokens": 8192,
+            "max_retries": 5
+        }
+    },
+    "ollama-llama3.1": {
+        "comment": "This is runs on your own computer. It's free. Requires Ollama to be installed.",
+        "class": "Ollama",
+        "arguments": {
+            "model": "llama3.1:latest",
+            "temperature": 0.5,
+            "request_timeout": 120.0,
+            "is_function_calling_model": false
+        }
+    },
+    "ollama-qwen2.5-coder": {
+        "comment": "This is runs on your own computer. It's free. Requires Ollama to be installed.",
+        "class": "Ollama",
+        "arguments": {
+            "model": "qwen2.5-coder:latest",
+            "temperature": 0.5,
+            "request_timeout": 120.0,
+            "is_function_calling_model": false
+        }
+    },
+    "lmstudio-qwen2.5-7b-instruct-1m": {
+        "comment": "This is runs on your own computer. It's free. Requires LM Studio to be installed. Great for inspecting the request/response.",
+        "class": "LMStudio",
+        "arguments": {
+            "model_name": "qwen2.5-7b-instruct-1m",
+            "temperature": 0.2,
+            "request_timeout": 120.0,
+            "is_function_calling_model": false
+        }
+    }
+}

requirements.txt

@@ -1 +1,114 @@
-huggingface_hub==0.25.2
+aiofiles==23.2.1
+aiohappyeyeballs==2.4.4
+aiohttp==3.11.11
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.8.0
+attrs==24.3.0
+audioop-lts==0.2.1
+beautifulsoup4==4.12.3
+certifi==2024.12.14
+charset-normalizer==3.4.1
+click==8.1.8
+colorlog==6.9.0
+dataclasses-json==0.6.7
+Deprecated==1.2.15
+dirtyjson==1.0.8
+distro==1.9.0
+fastapi==0.115.6
+ffmpy==0.5.0
+filelock==3.16.1
+filetype==1.2.0
+frozenlist==1.5.0
+fsspec==2024.12.0
+gradio==5.12.0
+gradio_client==1.5.4
+greenlet==3.1.1
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.27.2
+huggingface-hub==0.27.1
+idna==3.10
+Jinja2==3.1.5
+jiter==0.8.2
+joblib==1.4.2
+llama-cloud==0.1.8
+llama-index==0.12.10
+llama-index-agent-openai==0.4.1
+llama-index-cli==0.4.0
+llama-index-core==0.12.10.post1
+llama-index-embeddings-openai==0.3.1
+llama-index-indices-managed-llama-cloud==0.6.3
+llama-index-llms-groq==0.3.1
+llama-index-llms-lmstudio==0.3.0
+llama-index-llms-ollama==0.5.0
+llama-index-llms-openai==0.3.13
+llama-index-llms-openai-like==0.3.3
+llama-index-llms-openrouter==0.3.1
+llama-index-llms-together==0.3.1
+llama-index-multi-modal-llms-openai==0.4.2
+llama-index-program-openai==0.3.1
+llama-index-question-gen-openai==0.3.0
+llama-index-readers-file==0.4.2
+llama-index-readers-llama-parse==0.4.0
+llama-parse==0.5.19
+lockfile==0.12.2
+luigi==3.6.0
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.24.2
+mdurl==0.1.2
+multidict==6.1.0
+mypy-extensions==1.0.0
+nest-asyncio==1.6.0
+networkx==3.4.2
+nltk==3.9.1
+numpy==2.2.1
+ollama==0.4.5
+openai==1.59.5
+orjson==3.10.14
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+propcache==0.2.1
+pydantic==2.10.4
+pydantic_core==2.27.2
+pydub==0.25.1
+Pygments==2.19.1
+pypdf==5.1.0
+python-daemon==3.1.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-multipart==0.0.20
+pytz==2024.2
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.3
+rich==13.9.4
+ruff==0.9.2
+safehttpx==0.1.6
+safetensors==0.5.2
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.6
+SQLAlchemy==2.0.36
+starlette==0.41.3
+striprtf==0.0.26
+tenacity==8.5.0
+tiktoken==0.8.0
+tokenizers==0.21.0
+tomlkit==0.13.2
+tornado==6.4.2
+tqdm==4.67.1
+transformers==4.48.1
+typer==0.15.1
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.3.0
+uvicorn==0.34.0
+websockets==14.1
+wrapt==1.17.0
+yarl==1.18.3

src/assume/README.md

@@ -0,0 +1,3 @@
+# Assume
+
+Make assumptions about the project

src/assume/assumption_orchestrator.py

@@ -0,0 +1,72 @@
+"""
+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/distill_assumptions.py

@@ -0,0 +1,250 @@
+"""
+From a list of verbose assumptions, distill the key assumptions, so it can fit within the LLM's token limit.
+
+IDEA: Sometimes the input file has lots of assumptions, but the distilled has none or a few. Important assumptions are getting lost.
+This problem occur with this LLM:
+"openrouter-paid-gemini-2.0-flash-001"
+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?
+"""
+import json
+import time
+from datetime import datetime
+import logging
+from math import ceil
+from uuid import uuid4
+from typing import List, Optional, Any
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from llama_index.core.llms import ChatMessage, MessageRole
+
+logger = logging.getLogger(__name__)
+
+class AssumptionDetails(BaseModel):
+    assumption_list: list[str] = Field(description="List of assumptions")
+
+SYSTEM_PROMPT_1 = """
+You are an intelligent **Planning Assistant** specializing in distilling project assumptions for efficient use by planning tools. Your primary goal is to condense a list of verbose assumptions into a concise list of key assumptions that have a significant strategic impact on planning and execution, while ensuring that all core assumptions are captured.
+
+**Your instructions are:**
+
+1.  **Identify All Core Assumptions with Strategic Impact:** Extract all of the most critical assumptions from the given list, focusing on assumptions that have a significant strategic impact on project planning and execution. Ensure that *all* of these types of assumptions are captured:
+    - Scope and deliverables
+    - Timeline and deadlines
+    - Resources needed
+    - External constraints
+    - Dependencies between tasks
+    - Stakeholders and their roles
+    - Expected outcomes and success criteria
+    - Financial factors (where provided)
+    - Operational factors
+
+2.  **Maintain Core Details:**
+    *   Include crucial numeric values and any specific data points stated in the original assumptions that are strategically important.
+    *   Distill the assumptions to their core details; remove redundant words and ensure the most important aspects are maintained.
+
+3.  **Brevity is Essential:**
+    *   Distill each assumption into a single, short, and clear sentence. Aim for each sentence to be approximately 10-15 words, and do not exceed 17 words.
+    *   Avoid unnecessary phrases, repetition, and filler words.
+    *   Do not add any extra text that is not requested in the output, only return a list of distilled assumptions in JSON.
+
+4.  **JSON Output:**
+    *   Output the distilled assumptions into a list in JSON format.
+    *   The key should be "assumption_list" and its value is a JSON array of strings.
+
+5.  **Ignore:**
+    *   Do not include any information in the response other than the distilled list of assumptions.
+    *   Do not comment on the quality or format of the original assumptions.
+    *   Do not explain your reasoning.
+    *   Do not attempt to add any information that is not provided in the original list of assumptions.
+
+**Example output:**
+{
+  "assumption_list": [
+    "The project will take 3 weeks.",
+    "The team consists of 3 people.",
+    ...
+  ]
+}
+"""
+
+SYSTEM_PROMPT_2 = """
+You are an intelligent **Planning Assistant** specializing in distilling project assumptions for efficient use by planning tools. Your primary goal is to condense a list of verbose assumptions into a concise list of key assumptions that are critical for pre-planning assessment, SWOT analysis, and work breakdown structure (WBS).
+
+**Your instructions are:**
+
+1. **Prioritize Strategic Assumptions:**
+   - Extract only the most significant assumptions that have the highest impact on project planning and execution.
+   - Focus on assumptions that influence multiple downstream tasks and are essential for decision-making.
+   - Emphasize assumptions that, if incorrect, could introduce significant risks or require major project adjustments.
+
+2. **Limit the Number of Assumptions:**
+   - Provide no more than **5 key assumptions**.
+   - Ensure each assumption is unique and adds distinct value to the planning process.
+
+3. **Ensure Direct Relevance to Planning Tools:**
+   - The assumptions should directly support pre-planning assessment, SWOT analysis, and WBS creation.
+   - Consider how each assumption feeds into these specific planning activities and contributes to actionable insights.
+
+4. **Maintain Core Details with Strategic Focus:**
+   - Include crucial numeric values and specific data points from the original assumptions that are strategically important.
+   - Remove redundant or overlapping assumptions to ensure each one is unique and adds distinct value.
+
+5. **Optimize Brevity and Precision:**
+   - Distill each assumption into a single, short, and clear sentence.
+   - Aim for each sentence to be approximately 10-15 words and do not exceed 17 words.
+   - Use precise language to enhance clarity and avoid ambiguity.
+
+6. **JSON Output:**
+   - Output the distilled assumptions into a list in JSON format.
+   - The key should be "assumption_list" and its value is a JSON array of strings.
+
+7. **Ignore:**
+   - Do not include any information in the response other than the distilled list of assumptions.
+   - Do not comment on the quality or format of the original assumptions.
+   - Do not explain your reasoning.
+   - Do not attempt to add any information that is not provided in the original list of assumptions.
+
+**Example output:**
+{
+  "assumption_list": [
+    "The project will take 3 weeks.",
+    "The team consists of 3 people.",
+    ...
+  ]
+}
+"""
+
+SYSTEM_PROMPT = SYSTEM_PROMPT_1
+
+@dataclass
+class DistillAssumptions:
+    system_prompt: Optional[str]
+    user_prompt: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str, **kwargs: Any) -> 'DistillAssumptions':
+        """
+        Invoke LLM with a bunch of assumptions and distill them.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid query.")
+
+        # Obtain the current year as a string, eg. "1984"
+        current_year_int = datetime.now().year
+        current_year = str(current_year_int)
+
+        # Replace the placeholder in the system prompt with the current year
+        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,
+                )
+            )
+        
+        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(AssumptionDetails)
+
+        logger.debug("Starting LLM chat interaction.")
+        start_time = time.perf_counter()
+        chat_response1 = sllm.chat(chat_message_list1)
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response1.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        try:
+            json_response = json.loads(chat_response1.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
+
+        result = DistillAssumptions(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+        )
+        logger.debug("DistillAssumptions instance created successfully.")
+        return result    
+
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        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))
+
+if __name__ == "__main__":
+    import os
+    import logging
+    from src.llm_factory import get_llm
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler()
+        ]
+    )
+
+    path_to_assumptions_file = os.path.join(os.path.dirname(__file__), 'test_data', 'assumptions_solar_farm_in_denmark.json')
+    with open(path_to_assumptions_file, 'r', encoding='utf-8') as f:
+        assumptions_raw_data = f.read()
+
+    plan_prompt = "Establish a solar farm in Denmark."
+    query = (
+        f"{plan_prompt}\n\n"
+        "Today's date:\n2025-Jan-26\n\n"
+        "Project start ASAP\n\n"
+        f"assumption.json:\n{assumptions_raw_data}"
+    )
+
+    llm = get_llm("ollama-llama3.1")
+    # llm = get_llm("deepseek-chat", max_tokens=8192)
+
+    print(f"Query: {query}")
+    result = DistillAssumptions.execute(llm, query)
+
+    print("\n\nResponse:")
+    print(json.dumps(result.to_dict(include_system_prompt=False, include_user_prompt=False), indent=2))

src/assume/make_assumptions.py

@@ -0,0 +1,358 @@
+"""
+Analyze a vague description, generate relevant questions for clarification, make reasonable assumptions where necessary.
+
+PROMPT> python -m src.assume.make_assumptions
+"""
+import json
+import time
+from datetime import datetime
+import logging
+from math import ceil
+from uuid import uuid4
+from typing import List, Optional, Any
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from llama_index.core.llms import ChatMessage, MessageRole
+
+logger = logging.getLogger(__name__)
+
+class QuestionAssumptionItem(BaseModel):
+    item_index: int = Field(description="Index in the list")
+    question: str = Field(description="Question to clarify and refine the user's description")
+    assumptions: str = Field(description="Reasonable assumptions made to fill in the gaps or missing details in the user's description.")
+    assessments: str = Field(description="Detailed information about the assessments, including key findings and recommendations. *max 3 assessments*.")
+
+class ExpertDetails(BaseModel):
+    question_assumption_list: list[QuestionAssumptionItem] = Field(description="Questions and assumptions")
+
+SYSTEM_PROMPT_1 = """
+You are an intelligent **Planning Assistant** designed to help users develop detailed plans from vague or high-level descriptions.
+
+**Your primary tasks are to:**
+
+1. **Identify Potential Questions:**
+   - **Analyze the provided description.**
+   - **List exactly eight relevant questions** that need to be answered to clarify the requirements, scope, and objectives of the project or task.
+   - **Each question must correspond to one of the eight critical areas** to ensure comprehensive and focused planning.
+
+2. **Make Reasonable Assumptions:**
+   - **For any information that is unclear, incomplete, or missing from the description, make logical and reasonable assumptions.**
+   - **Clearly label these as assumptions** to distinguish them from the user's original input.
+   - **Each assumption must directly correspond to its respective question,** providing clear and detailed guidance for planning without unnecessary complexity.
+   - **Ensure all assumptions are realistic and feasible** based on industry standards and practical considerations.
+
+3. **Conduct Assessments:**
+   - **Perform evaluations** based on the identified questions and assumptions.
+   - **Provide insights** into potential risks, feasibility, environmental impact, financial viability, and other relevant factors.
+   - **Ensure exactly eight assessments** are provided, each corresponding to one of the eight critical areas of the project.
+   - **Each assessment must include:**
+     - **Title:** A concise title for the assessment (e.g., Risk Assessment).
+     - **Description:** A brief overview of the assessment focus.
+     - **Details:** Specific insights, including likelihood, impact, and mitigation strategies.
+
+**Guidelines:**
+
+- **Clarity & Precision:** Ensure that all questions, assumptions, and assessments are clear, relevant, and aimed at uncovering essential details that will aid in planning.
+
+- **Comprehensive Coverage:** Address the following eight critical areas:
+  1. **Funding & Budget:** Sources, allocation, and financial planning.
+  2. **Timeline & Milestones:** Project phases, deadlines, and key milestones.
+  3. **Resources & Personnel:** Required materials, technologies, and team members.
+  4. **Governance & Regulations:** Rules, policies, and compliance requirements.
+  5. **Safety & Risk Management:** Potential risks, safety measures, and contingency plans.
+  6. **Environmental Impact:** Sustainability practices and environmental considerations.
+  7. **Stakeholder Involvement:** Key stakeholders, their roles, and communication strategies.
+  8. **Operational Systems:** Essential systems for functionality (e.g., power, water, air).
+
+- **Logical Assumptions:** Base all assumptions on common-sense reasoning, industry benchmarks, and any implicit information present in the description. Avoid introducing unrelated or speculative elements.
+
+- **Realism and Feasibility:** Ensure that all assumptions are grounded in realistic scenarios by referencing industry benchmarks, historical data, and practical constraints. Avoid speculative figures unless explicitly justified by the project context.
+
+- **Alignment:** Ensure each assumption is directly tied to its corresponding question, providing a coherent and logical foundation for planning.
+
+- **Neutral Tone:** Maintain an objective and neutral tone, avoiding any bias or subjective opinions.
+
+- **Conciseness:** Keep questions, assumptions, and assessments concise and to the point, ensuring they are easily understandable while still being sufficiently detailed.
+
+- **Strict Item Limit:** Do not exceed eight items in each section. If the content naturally exceeds this limit, prioritize the most critical aspects and omit less essential details.
+"""
+
+SYSTEM_PROMPT_2 = """
+You are an expert **Planning Assistant** designed to transform vague descriptions into detailed, actionable plans. Your process is rigorous, structured, and ensures comprehensive coverage across all critical project areas.
+
+**Your primary tasks are to perform the following in a strictly ordered sequence:**
+
+1.  **Clarify Requirements with Focused Questions:**
+    -   **Analyze the provided description** to identify its core objectives and constraints.
+    -   **Generate exactly eight (8) targeted questions** designed to elicit essential details necessary for planning.
+    -   **Each question MUST directly address one of the eight (8) critical planning areas** listed below, ensuring no area is overlooked.
+    -   **Questions should be concise, specific, and directly related to the provided description.** Avoid overly generic or broad questions.
+    -   **Output:** Present each question with an `item_index` (e.g., `item_index: 1`). The `item_index` is solely for output formatting and should *not* be used to reference other parts of your response.
+
+2.  **Formulate Specific and Justifiable Assumptions:**
+    -   **For every question posed, formulate a corresponding assumption.** These assumptions should bridge any gaps in the provided description and be directly related to the respective question.
+    -   **Each assumption MUST be realistic, feasible, and based on industry benchmarks or common sense.** Justify each assumption briefly, referencing industry standards or practical considerations where applicable.
+    -   **Label each assumption as "Assumption:"** to clearly distinguish it from user-provided information.
+    -   **Output:** Present each assumption with a matching `item_index` (e.g., `item_index: 1`). The `item_index` is solely for output formatting and should *not* be used to reference other parts of your response.
+
+3.  **Provide Balanced and Actionable Assessments:**
+    -   **For every question and assumption**, conduct a comprehensive evaluation, analyzing its implications, including potential benefits, risks, and opportunities.
+    -   **Provide exactly eight (8) assessments**, each directly linked to one question and assumption, and covering one of the Critical Planning Areas.
+     -   **Each assessment MUST be a single string** containing:
+         - A concise `Title:` (e.g., "Financial Feasibility Assessment").
+         - A brief `Description:` of the assessment's focus.
+         - `Details:` Specific insights into potential risks, impacts, mitigation strategies, potential benefits, and opportunities. Focus on actionable intelligence that can drive planning decisions. Include quantifiable metrics where applicable.
+     -   **Output:** Present each assessment with a matching `item_index` (e.g., `item_index: 1`). The `item_index` is solely for output formatting and should *not* be used to reference other parts of your response.
+
+**Critical Planning Areas (MUST be covered by one question, assumption, and assessment each):**
+
+*   Funding & Budget
+*   Timeline & Milestones
+*   Resources & Personnel
+*   Governance & Regulations
+*   Safety & Risk Management
+*   Environmental Impact
+*   Stakeholder Involvement
+*   Operational Systems
+
+**Guidelines (Strictly Follow):**
+
+*   **Strict Ordering:** Follow the sequence of tasks (questions, assumptions, assessments) and output the results in the same order.
+*   **Strict Item Limit:** Do not exceed eight items in each section. If the content naturally exceeds this limit, prioritize the most critical aspects and omit less essential details.
+*   **Direct Correspondence:** Maintain a one-to-one relationship between each question, assumption, and assessment.
+*   **Realism and Feasibility:** Ensure assumptions are realistic, justifiable, and based on real-world considerations.
+*   **Do not reference any item by index (e.g., "Assumption: 3.2").** The `item_index` is solely for output formatting.
+*   **Balanced Insights:** Assessments should provide a balanced perspective, including potential benefits, opportunities, risks, and actionable mitigation strategies.
+*   **Neutral Tone:** Maintain an objective, unbiased, and professional tone.
+*   **Conciseness:** Be concise and direct. Prioritize the most critical information.
+*   **No Exceeding Item Limit:** Strictly adhere to the 8-item limit for each task.
+*   **Explicit Labeling:** All assumptions must be explicitly labeled with the prefix "Assumption:".
+*   **Quantifiable Metrics:** Include specific numbers, measurements, or metrics in assumptions and assessments whenever possible to enhance precision.
+*   **Justifications:** Briefly justify assumptions using common sense, industry standards, or practical considerations.
+*   **Example of Assessment Output:**
+    ```
+    Title: Financial Feasibility Assessment
+    Description: Evaluation of the project's financial viability.
+    Details: Funding will come from government grants and private investors. The project has a high chance of success.
+    ```
+"""
+
+SYSTEM_PROMPT_3 = """
+You are an expert **Planning Assistant** designed to transform vague descriptions into detailed, actionable plans. Your process is rigorous, structured, and ensures comprehensive coverage across all critical project areas.
+
+**Your primary tasks are to perform the following in a strictly ordered sequence:**
+
+1. **Clarify Requirements with Focused Questions:**
+    - **Analyze the provided description** to identify its core objectives and constraints.
+    - **Generate exactly eight (8) targeted questions** designed to elicit essential details necessary for planning.
+    - **Each question MUST directly address one of the eight (8) Critical Planning Areas** listed below, ensuring no area is overlooked.
+    - **Questions should be concise, specific, and directly related to the provided description.** Avoid overly generic or broad questions.
+    - **Output:** Present each question with an `item_index` (e.g., `item_index: 1`). The `item_index` is solely for output formatting and should *not* be used to reference other parts of your response.
+
+2. **Formulate Specific and Justifiable Assumptions:**
+    - **For every question posed, formulate a corresponding assumption.** These assumptions should bridge any gaps in the provided description and be directly related to the respective question.
+    - **Each assumption MUST be realistic, feasible, and based on industry benchmarks or common sense.** Justify each assumption briefly, referencing industry standards or practical considerations where applicable.
+    - **Label each assumption as "Assumption:"** to clearly distinguish it from user-provided information.
+    - **Output:** Present each assumption with a matching `item_index` (e.g., `item_index: 1`). The `item_index` is solely for output formatting and should *not* be used to reference other parts of your response.
+
+3. **Provide Balanced and Actionable Assessments:**
+    - **For every question and assumption**, conduct a comprehensive evaluation, analyzing its implications, including potential benefits, risks, and opportunities.
+    - **Provide exactly eight (8) assessments**, each directly linked to one question and assumption, and covering one of the Critical Planning Areas.
+    - **Each assessment MUST be a single string** containing:
+        - A concise `Title:` (e.g., "Financial Feasibility Assessment").
+        - A brief `Description:` of the assessment's focus.
+        - `Details:` Specific insights into potential risks, impacts, mitigation strategies, potential benefits, and opportunities. Focus on actionable intelligence that can drive planning decisions. Include quantifiable metrics where applicable.
+    - **Output:** Present each assessment with a matching `item_index` (e.g., `item_index: 1`). The `item_index` is solely for output formatting and should *not* be used to reference other parts of your response.
+
+**Critical Planning Areas (MUST be covered by one question, assumption, and assessment each):**
+
+* Funding & Budget
+* Timeline & Milestones
+* Resources & Personnel
+* Governance & Regulations
+* Safety & Risk Management
+* Environmental Impact
+* Stakeholder Involvement
+* Operational Systems
+
+**Output Format:**
+
+The output must be a JSON object with two keys:
+
+1. `"question_assumption_list"`: An array of exactly eight objects, each containing:
+    - `item_index`: Integer from 1 to 8.
+    - `question`: String.
+    - `assumptions`: String, starting with "Assumption:".
+    - `assessments`: String containing Title, Description, and Details.
+
+2. `"metadata"`: An object containing relevant metadata about the response.
+
+**Example JSON Output:**
+
+{
+  "question_assumption_list": [
+    {
+      "item_index": 1,
+      "question": "What is the size of the square and the yellow ball?",
+      "assumptions": "Assumption: The square has a side length of 500 pixels. The yellow ball has a diameter of 50 pixels.",
+      "assessments": "Title: Collision Detection Assessment\nDescription: Evaluation of collision between the ball and the square.\nDetails: If the ball's center x-coordinate is less than or equal to the square's left edge, or greater than or equal to the square's right edge, the ball will bounce back. Similarly, if the ball's center y-coordinate is less than or equal to the square's top edge, or greater than or equal to the square's bottom edge, the ball will bounce up or down."
+    },
+    // ... seven more items
+  ]
+}
+"""
+
+SYSTEM_PROMPT = SYSTEM_PROMPT_3
+
+@dataclass
+class MakeAssumptions:
+    system_prompt: Optional[str]
+    user_prompt: str
+    response: dict
+    metadata: dict
+    assumptions: list
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str, **kwargs: Any) -> 'MakeAssumptions':
+        """
+        Invoke LLM and make assumptions based on the user prompt.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid query.")
+
+        # Obtain the current year as a string, eg. "1984"
+        current_year_int = datetime.now().year
+        current_year = str(current_year_int)
+
+        # Replace the placeholder in the system prompt with the current year
+        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,
+                )
+            )
+        
+        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)
+        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'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        try:
+            json_response = json.loads(chat_response1.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
+
+        # Cleanup the json response from the LLM model.
+        assumption_list = []
+        for item in json_response['question_assumption_list']:
+            question = item.get('question', '')
+            assumptions = item.get('assumptions', '')
+            assessments = item.get('assessments', '')
+
+            assumption_item = {
+                "question": question,
+                "assumptions": assumptions,
+                "assessments": assessments
+            }
+            assumption_list.append(assumption_item)
+
+        result = MakeAssumptions(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+            assumptions=assumption_list
+        )
+        logger.debug("MakeAssumptions instance created successfully.")
+        return result    
+
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+    def save_raw(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.to_dict(), indent=2))
+
+    def save_assumptions(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.assumptions, indent=2))
+
+if __name__ == "__main__":
+    import logging
+    from src.llm_factory import get_llm
+    from src.plan.find_plan_prompt import find_plan_prompt
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler()
+        ]
+    )
+
+    plan_prompt = find_plan_prompt("4dc34d55-0d0d-4e9d-92f4-23765f49dd29")
+    query = (
+        f"{plan_prompt}\n\n"
+        "Today's date:\n2025-Jan-26\n\n"
+        "Project start ASAP"
+    )
+
+    llm = get_llm("ollama-llama3.1")
+    # llm = get_llm("deepseek-chat", max_tokens=8192)
+
+    print(f"Query: {query}")
+    result = MakeAssumptions.execute(llm, query)
+
+    print("\n\nResponse:")
+    print(json.dumps(result.to_dict(include_system_prompt=False, include_user_prompt=False), indent=2))
+
+    print("\n\nAssumptions:")
+    print(json.dumps(result.assumptions, indent=2))

src/assume/test_data/assumptions_solar_farm_in_denmark.json

@@ -0,0 +1,42 @@
+[
+  {
+    "question": "What is the target capacity of the solar farm in megawatts?",
+    "assumptions": "Assumption: The project will aim for a moderate-sized solar farm with an initial capacity of 50 MW, taking into account Denmark's renewable energy goals and available land.",
+    "assessments": "Title: Financial Feasibility Assessment\nDescription: Evaluation of the financial viability of the solar farm.\nDetails: With an initial investment of approximately DKK 375 million (\u20ac50 million), the project can expect a return on investment of around 7-8% per annum, considering Denmark's feed-in tariffs and tax incentives. However, this may be affected by fluctuations in global panel prices and local labor costs."
+  },
+  {
+    "question": "What is the expected timeline for the solar farm's construction?",
+    "assumptions": "Assumption: The project will adhere to Denmark's renewable energy regulations and guidelines, requiring a minimum of 6 months for environmental impact assessments and permitting.",
+    "assessments": "Title: Timeline & Milestones Assessment\nDescription: Evaluation of the project schedule.\nDetails: With a team of experienced engineers and technicians, construction can be completed within 12-14 months. However, this timeline may be impacted by weather conditions, equipment delivery delays, or unforeseen site-specific challenges."
+  },
+  {
+    "question": "What is the estimated workforce required for the solar farm's construction?",
+    "assumptions": "Assumption: The project will follow industry best practices and hire local labor, taking into account Denmark's high labor costs.",
+    "assessments": "Title: Resources & Personnel Assessment\nDescription: Evaluation of the human resources needed.\nDetails: With an estimated 50-60 workers required for peak construction periods, the project can expect to incur a significant labor cost. To mitigate this, local partnerships and training programs will be explored to ensure a smooth transition of skills."
+  },
+  {
+    "question": "What are the relevant regulations and permits required for the solar farm?",
+    "assumptions": "Assumption: The project will comply with Denmark's Renewable Energy Act (RE-Act) and adhere to EU directives on environmental impact assessments.",
+    "assessments": "Title: Governance & Regulations Assessment\nDescription: Evaluation of regulatory compliance.\nDetails: The project must obtain necessary permits from the Danish Environmental Protection Agency, including a permit for the solar farm's construction and operation. Failure to comply with regulations may result in fines or even project cancellation."
+  },
+  {
+    "question": "What are the potential environmental impacts of the solar farm?",
+    "assumptions": "Assumption: The project will prioritize sustainability and minimize environmental footprint, adhering to Denmark's green energy policies.",
+    "assessments": "Title: Environmental Impact Assessment\nDescription: Evaluation of the solar farm's ecological impact.\nDetails: While the solar farm itself has a minimal carbon footprint, potential environmental concerns include habitat disruption and visual pollution. To mitigate these effects, the project will work with local stakeholders to ensure that any negative impacts are minimized."
+  },
+  {
+    "question": "How will the solar farm be connected to the grid?",
+    "assumptions": "Assumption: The project will utilize Denmark's existing high-voltage transmission infrastructure and adhere to EU directives on grid connection.",
+    "assessments": "Title: Grid Connection Assessment\nDescription: Evaluation of the solar farm's integration with the national grid.\nDetails: With a 50 MW capacity, the solar farm will require a dedicated 132 kV line from the nearest substation. This will be designed and constructed in collaboration with Energinet.dk to ensure seamless integration."
+  },
+  {
+    "question": "What is the expected level of stakeholder engagement?",
+    "assumptions": "Assumption: The project will maintain open communication channels with local communities, ensuring their concerns are addressed.",
+    "assessments": "Title: Stakeholder Involvement Assessment\nDescription: Evaluation of community outreach and engagement.\nDetails: Regular public meetings and information sessions will be held to keep stakeholders informed about the project's progress. This includes partnering with local organizations to address any environmental or social concerns."
+  },
+  {
+    "question": "What are the operational systems required for the solar farm?",
+    "assumptions": "Assumption: The project will utilize industry-standard SCADA systems and adhere to Denmark's energy management guidelines.",
+    "assessments": "Title: Operational Systems Assessment\nDescription: Evaluation of the solar farm's operational infrastructure.\nDetails: With a focus on efficiency and reliability, the project will implement an advanced SCADA system for real-time monitoring and control. This will also enable remote maintenance and troubleshooting."
+  }
+]

src/chunk_dataframe_with_context/chunk_dataframe_with_context.py

@@ -0,0 +1,43 @@
+import pandas as pd
+from typing import Generator, Tuple
+
+def chunk_dataframe_with_context(
+    df: pd.DataFrame, 
+    chunk_size: int = 10, 
+    overlap: int = 3
+) -> Generator[Tuple[pd.DataFrame, pd.DataFrame], None, None]:
+    """
+    Chunk the DataFrame into overlapping segments. For each core chunk,
+    include 'overlap' rows before and after as additional context.
+
+    Yields:
+        (core_df, extended_df):
+            core_df     = The rows we actually want to process in this chunk
+            extended_df = core_df + overlap context before and after
+    """
+    start = 0
+    total_rows = len(df)
+
+    while start < total_rows:
+        # Determine the start/end for the core chunk
+        core_start = start
+        core_end = min(start + chunk_size, total_rows)
+
+        # Determine the start/end for the extended chunk
+        extended_start = max(0, core_start - overlap)
+        extended_end = min(core_end + overlap, total_rows)
+
+        core_df = df.iloc[core_start:core_end]
+        extended_df = df.iloc[extended_start:extended_end]
+
+        yield core_df, extended_df
+
+        start += chunk_size
+
+if __name__ == "__main__":
+    df = pd.DataFrame({
+        "Task ID": range(1, 26),
+        "Description": [f"Task {i}" for i in range(1, 26)]
+    })
+    for i, (core_df, extended_df) in enumerate(chunk_dataframe_with_context(df, chunk_size=5, overlap=2)):
+        print(f"CHUNK {i} - Core:\n{core_df}\n\nContext:\n{extended_df}\n{'-'*40}")

src/chunk_dataframe_with_context/tests/test_chunk_dataframe_with_context.py

@@ -0,0 +1,89 @@
+import unittest
+import pandas as pd
+from ..chunk_dataframe_with_context import chunk_dataframe_with_context
+
+class TestChunkDataFrameWithContext(unittest.TestCase):
+    def test_empty(self):
+        # Arrange
+        df = pd.DataFrame()
+        df["Task ID"] = []
+        df["Description"] = []
+
+        # Act
+        chunk_size = 5
+        overlap = 2
+        results = list(chunk_dataframe_with_context(df, chunk_size=chunk_size, overlap=overlap))
+
+        # Assert
+        # The number of chunks expected = ceil(0 / 5) = 0
+        self.assertEqual(len(results), 0)
+
+    def test_one_chunk_no_overlap(self):
+        # Arrange
+        df = pd.DataFrame({
+            "Task ID": range(1, 4),
+            "Description": [f"Task {i}" for i in range(1, 4)]
+        })
+
+        # Act
+        chunk_size = 5
+        overlap = 2
+        results = list(chunk_dataframe_with_context(df, chunk_size=chunk_size, overlap=overlap))
+
+        # Assert
+        # The number of chunks expected = ceil(3 / 5) = 1
+        self.assertEqual(len(results), 1)
+
+        # Check the only chunk
+        first_core, first_extended = results[0]
+        self.assertEqual(first_core.iloc[0]["Task ID"], 1)
+        self.assertEqual(first_core.iloc[-1]["Task ID"], 3)
+        self.assertEqual(first_extended.iloc[0]["Task ID"], 1)
+        self.assertEqual(first_extended.iloc[-1]["Task ID"], 3)
+
+    def test_multiple_chunks(self):
+        # Arrange
+        # Create a sample DataFrame of 25 rows
+        df = pd.DataFrame({
+            "Task ID": range(1, 26),
+            "Description": [f"Task {i}" for i in range(1, 26)]
+        })
+
+        # Act
+        chunk_size = 5
+        overlap = 2
+        results = list(chunk_dataframe_with_context(df, chunk_size=chunk_size, overlap=overlap))
+
+        # Assert
+        # The number of chunks expected = ceil(25 / 5) = 5
+        self.assertEqual(len(results), 5)
+
+        # Check each chunk
+        for i, (core_df, extended_df) in enumerate(results):
+            # 1) core_df should have at most 5 rows (the chunk_size)
+            self.assertTrue(len(core_df) <= chunk_size)
+
+            # 2) extended_df should be larger or equal to core_df (due to overlap)
+            self.assertTrue(len(extended_df) >= len(core_df))
+
+            # 3) Check that extended_df contains core_df's indices
+            #    (i.e., the extended rows are a superset of the core rows)
+            core_indices = core_df.index.tolist()
+            extended_indices = extended_df.index.tolist()
+
+            for idx in core_indices:
+                self.assertIn(idx, extended_indices)
+
+        # First chunk
+        first_core, first_extended = results[0]
+        self.assertEqual(first_core.iloc[0]["Task ID"], 1)
+        self.assertEqual(first_core.iloc[-1]["Task ID"], 5)
+        self.assertEqual(first_extended.iloc[0]["Task ID"], 1)
+        self.assertEqual(first_extended.iloc[-1]["Task ID"], 7)
+
+        # Last chunk
+        last_core, last_extended = results[-1]
+        self.assertEqual(last_core.iloc[0]["Task ID"], 21)
+        self.assertEqual(last_core.iloc[-1]["Task ID"], 25)
+        self.assertEqual(last_extended.iloc[0]["Task ID"], 19)
+        self.assertEqual(last_extended.iloc[-1]["Task ID"], 25)

src/expert/README.md

@@ -0,0 +1,7 @@
+# Expert
+
+Criticism from experts
+
+- Identify experts that can provide feedback.
+- Ask each expert for feedback.
+

src/expert/expert_criticism.py

@@ -0,0 +1,205 @@
+"""
+PROMPT> python -m src.expert.expert_criticism
+
+Ask a specific expert about something, and get criticism back or constructive feedback.
+"""
+import json
+import time
+from math import ceil
+from typing import Optional
+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
+
+class NegativeFeedbackItem(BaseModel):
+    feedback_index: int = Field(description="Incrementing index, such as 1, 2, 3, 4, 5.")
+    feedback_title: str = Field(description="Constructive criticism. What is the problem?")
+    feedback_verbose: str = Field(description="Elaborate on the criticism. Provide more context and details.")
+    feedback_problem_tags: list[str] = Field(description="Short identifiers that describe the problem.")
+    feedback_mitigation: str = Field(description="Mitigation plan.")
+    feedback_consequence: str = Field(description="Without mitigation what are the consequences.")
+    feedback_root_cause: str = Field(description="Possible root cause.")
+
+class ExpertConsultation(BaseModel):
+    """
+    Status after todays meeting with the client.
+    """
+    negative_feedback_list: list[NegativeFeedbackItem] = Field(description="Your negative feedback.")
+    user_primary_actions: list[str] = Field(description="List of actionable steps the user MUST take.")
+    user_secondary_actions: list[str] = Field(description="List of actionable steps the user should take.")
+    follow_up_consultation: str = Field(description="What to talk about in the next consultation.")
+
+EXPERT_CRITICISM_SYSTEM_PROMPT = f"""
+You are acting as a highly experienced:
+PLACEHOLDER_ROLE
+
+Your areas of deep knowledge include:
+PLACEHOLDER_KNOWLEDGE
+
+You possess the following key skills:
+PLACEHOLDER_SKILLS
+
+From your perspective, please analyze the provided document.
+
+The client may be off track, provide help to get back on track.
+
+The "negative_feedback_list" must contain 3 items.
+
+Provide a detailed list of actions that the client must take to address the issues you identify.
+
+In the "feedback_mitigation" field, provide a mitigation plan for each issue.
+How can this be improved? Who to consult? What to read? What data to provide?
+
+Be brutally direct and provide actionable advice based on your expertise.
+
+Be skeptical. There may be deeper unresolved problems and root causes.
+
+Focus specifically on areas where your expertise can offer unique insights and actionable advice.
+"""
+
+@dataclass
+class ExpertCriticism:
+    """
+    Ask an expert advise about a topic, and get criticism back.
+    """
+    query: str
+    response: dict
+    metadata: dict
+    feedback_list: list[dict]
+    primary_actions: list[str]
+    secondary_actions: list[str]
+    follow_up: str
+
+    @classmethod
+    def format_system(cls, expert: dict) -> str:
+        if not isinstance(expert, dict):
+            raise ValueError("Invalid expert.")
+
+        query = EXPERT_CRITICISM_SYSTEM_PROMPT.strip()
+        role = expert.get('title', 'No role specified')
+        knowledge = expert.get('knowledge', 'No knowledge specified')
+        skills = expert.get('skills', 'No skills specified')
+
+        query = query.replace("PLACEHOLDER_ROLE", role)
+        query = query.replace("PLACEHOLDER_KNOWLEDGE", knowledge)
+        query = query.replace("PLACEHOLDER_SKILLS", skills)
+        return query
+
+    @classmethod
+    def format_query(cls, document_title: str, document_content: str) -> str:
+        if not isinstance(document_title, str):
+            raise ValueError("Invalid document_title.")
+        if not isinstance(document_content, str):
+            raise ValueError("Invalid document_content.")
+
+        query = f"""
+{document_title}:
+{document_content}
+"""
+        return query
+
+    @classmethod
+    def execute(cls, llm: LLM, query: str, system_prompt: Optional[str]) -> 'ExpertCriticism':
+        """
+        Invoke LLM to get advise from the expert.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        chat_message_list = []
+        if system_prompt:
+            chat_message_list.append(
+                ChatMessage(
+                    role=MessageRole.SYSTEM,
+                    content=system_prompt,
+                )
+            )
+        
+        chat_message_user = ChatMessage(
+            role=MessageRole.USER,
+            content=query,
+        )
+        chat_message_list.append(chat_message_user)
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(ExpertConsultation)
+        chat_response = sllm.chat(chat_message_list)
+        json_response = json.loads(chat_response.message.content)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        # Cleanup the json response from the LLM model.
+        result_feedback_list = []
+        for item in json_response['negative_feedback_list']:
+            d = {
+                'title': item.get('feedback_title', ''),
+                'verbose': item.get('feedback_verbose', ''),
+                'tags': item.get('feedback_problem_tags', []),
+                'mitigation': item.get('feedback_mitigation', ''),
+                'consequence': item.get('feedback_consequence', ''),
+                'root_cause': item.get('feedback_root_cause', ''),
+            }
+            result_feedback_list.append(d)
+
+        result = ExpertCriticism(
+            query=query,
+            response=json_response,
+            metadata=metadata,
+            feedback_list=result_feedback_list,
+            primary_actions=json_response.get('user_primary_actions', []),
+            secondary_actions=json_response.get('user_secondary_actions', []),
+            follow_up=json_response.get('follow_up_consultation', '')
+        )
+        return result    
+
+    def to_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        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))
+
+if __name__ == "__main__":
+    from src.llm_factory import get_llm
+    import os
+
+    path1 = os.path.join(os.path.dirname(__file__), 'test_data', 'solarfarm_swot_analysis.md')
+    path2 = os.path.join(os.path.dirname(__file__), 'test_data', 'solarfarm_expert_list.json')
+
+    with open(path1, 'r', encoding='utf-8') as f:
+        swot_markdown = f.read()
+
+    with open(path2, 'r', encoding='utf-8') as f:
+        expert_list_json = json.load(f)
+
+    expert = expert_list_json[5]
+    expert.pop('id')
+    system_prompt = ExpertCriticism.format_system(expert)
+    query = ExpertCriticism.format_query("SWOT Analysis", swot_markdown)
+
+    llm = get_llm("ollama-llama3.1")
+    # llm = get_llm("deepseek-chat")
+
+    print(f"System: {system_prompt}")
+    print(f"\n\nQuery: {query}")
+    result = ExpertCriticism.execute(llm, query, system_prompt)
+
+    print("\n\nResponse:")
+    print(json.dumps(result.to_dict(include_query=False), indent=2))
+
+    print("\n\nFeedback:")
+    print(json.dumps(result.feedback_list, indent=2))

src/expert/expert_finder.py

@@ -0,0 +1,218 @@
+"""
+PROMPT> python -m src.expert.expert_finder
+
+Find experts that can take a look at the a document, such as a 'SWOT analysis' and provide feedback.
+
+IDEA: Specify a number of experts to be obtained. Currently it's hardcoded 8.
+When it's 4 or less, then there is no need to make a second call to the LLM model.
+When it's 9 or more, then make multiple calls to the LLM model to get more experts.
+"""
+import json
+import time
+import logging
+from math import ceil
+from uuid import uuid4
+from typing import List, Optional, Any
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from llama_index.core.llms import ChatMessage, MessageRole
+
+logger = logging.getLogger(__name__)
+
+class Expert(BaseModel):
+    expert_title: str = Field(description="Job title of the expert.")
+    expert_knowledge: str = Field(description="Industry Knowledge/Specialization, specific industries or subfields where they have focused their career, such as: tech industry for an IT consultant, healthcare sector for a medical expert. **Must be a brief comma separated list**.")
+    expert_why: str = Field(description="Why can this expert be of help. Area of expertise.")
+    expert_what: str = Field(description="Describe what area of this document the role should advise about.")
+    expert_relevant_skills: str = Field(description="Skills that are relevant to the document.")
+    expert_search_query: str = Field(description="What query to use when searching for this expert.")
+
+class ExpertDetails(BaseModel):
+    experts: list[Expert] = Field(description="List of experts.")
+
+EXPERT_FINDER_SYSTEM_PROMPT = """
+Professionals who can offer specialized perspectives and recommendations based on the document.
+
+Ensure that each expert role directly aligns with specific sections or themes within the document.
+This could involve linking particular strengths, weaknesses, opportunities, threats, extra sections, to the expertise required.
+
+Diversity in the types of experts suggested by considering interdisciplinary insights that might not be 
+immediately obvious but could offer unique perspectives on the document.
+
+Account for geographical and contextual relevance, variations in terminology or regional differences that may affect the search outcome.
+
+The "expert_search_query" field is a human readable text for searching in Google/DuckDuckGo/LinkedIn.
+
+Find exactly 4 experts.
+"""
+
+@dataclass
+class ExpertFinder:
+    """
+    Find experts that can advise about the particular domain.
+    """
+    system_prompt: Optional[str]
+    user_prompt: str
+    response: dict
+    metadata: dict
+    expert_list: list[dict]
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str, **kwargs: Any) -> 'ExpertFinder':
+        """
+        Invoke LLM to find the best suited experts that can advise about attached file.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid query.")
+
+        default_args = {
+            'system_prompt': EXPERT_FINDER_SYSTEM_PROMPT.strip()
+        }
+        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,
+                )
+            )
+        
+        logger.debug(f"User Prompt:\n{user_prompt}")
+        chat_message_user1 = ChatMessage(
+            role=MessageRole.USER,
+            content=user_prompt,
+        )
+        chat_message_list1.append(chat_message_user1)
+
+        sllm = llm.as_structured_llm(ExpertDetails)
+
+        logger.debug("Starting LLM chat interaction 1.")
+        start_time = time.perf_counter()
+        chat_response1 = sllm.chat(chat_message_list1)
+        end_time = time.perf_counter()
+        duration1 = int(ceil(end_time - start_time))
+        response_byte_count1 = len(chat_response1.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration1} seconds. Response byte count: {response_byte_count1}")
+
+        # Do a follow up question, for obtaining more experts.
+        chat_message_assistant2 = ChatMessage(
+            role=MessageRole.ASSISTANT,
+            content=chat_response1.message.content,
+        )
+        chat_message_user2 = ChatMessage(
+            role=MessageRole.USER,
+            content="4 more please",
+        )
+        chat_message_list2 = chat_message_list1.copy()
+        chat_message_list2.append(chat_message_assistant2)
+        chat_message_list2.append(chat_message_user2)
+
+        logger.debug("Starting LLM chat interaction 2.")
+        start_time = time.perf_counter()
+        chat_response2 = sllm.chat(chat_message_list2)
+        end_time = time.perf_counter()
+        duration2 = int(ceil(end_time - start_time))
+        response_byte_count2 = len(chat_response2.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration2} seconds. Response byte count: {response_byte_count2}")
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration1"] = duration1
+        metadata["duration2"] = duration2
+        metadata["response_byte_count1"] = response_byte_count1
+        metadata["response_byte_count2"] = response_byte_count2
+
+        json_response1 = json.loads(chat_response1.message.content)
+        json_response2 = json.loads(chat_response2.message.content)
+
+        json_response_merged = {}
+        experts1 = json_response1.get('experts', [])
+        experts2 = json_response2.get('experts', [])
+        json_response_merged['experts'] = experts1 + experts2
+
+        # Cleanup the json response from the LLM model, extract the experts.
+        expert_list = []
+        for expert in json_response_merged['experts']:
+            uuid = str(uuid4())
+            expert_dict = {
+                "id": uuid,
+                "title": expert['expert_title'],
+                "knowledge": expert['expert_knowledge'],
+                "why": expert['expert_why'],
+                "what": expert['expert_what'],
+                "skills": expert['expert_relevant_skills'],
+                "search_query": expert['expert_search_query'],
+            }
+            expert_list.append(expert_dict)
+
+        logger.info(f"Found {len(expert_list)} experts.")
+
+        result = ExpertFinder(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response_merged,
+            metadata=metadata,
+            expert_list=expert_list,
+        )
+        logger.debug("CreateProjectPlan instance created successfully.")
+        return result    
+
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+    def save_raw(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.to_dict(), indent=2))
+
+    def save_cleanedup(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.expert_list, indent=2))
+        
+
+if __name__ == "__main__":
+    import logging
+    from src.llm_factory import get_llm
+    import os
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler()
+        ]
+    )
+
+    path = os.path.join(os.path.dirname(__file__), 'test_data', 'solarfarm_swot_analysis.md')
+    with open(path, 'r', encoding='utf-8') as f:
+        swot_markdown = f.read()
+
+    query = f"SWOT Analysis:\n{swot_markdown}"
+
+    llm = get_llm("ollama-llama3.1")
+    # llm = get_llm("deepseek-chat", max_tokens=8192)
+
+    print(f"Query: {query}")
+    result = ExpertFinder.execute(llm, query)
+
+    print("\n\nResponse:")
+    print(json.dumps(result.to_dict(include_system_prompt=False, include_user_prompt=False), indent=2))
+
+    print("\n\nExperts:")
+    print(json.dumps(result.expert_list, indent=2))

src/expert/expert_orchestrator.py

@@ -0,0 +1,114 @@
+"""
+PROMPT> python -m src.expert.expert_orchestrator
+"""
+import logging
+from llama_index.core.llms.llm import LLM
+from src.expert.expert_finder import ExpertFinder
+from src.expert.expert_criticism import ExpertCriticism
+from src.expert.markdown_with_criticism_from_experts import markdown_rows_with_info_about_one_expert, markdown_rows_with_criticism_from_one_expert
+
+logger = logging.getLogger(__name__)
+
+class ExpertOrchestrator:
+    def __init__(self):
+        self.phase1_post_callback = None
+        self.phase2_post_callback = None
+        self.expert_finder: ExpertFinder = None
+        self.expert_criticism_list: list[ExpertCriticism] = []
+        self.max_expert_count = 2
+
+    def execute(self, llm: LLM, query: str) -> None:
+        logger.info("Finding experts that can provide criticism...")
+
+        self.expert_finder = ExpertFinder.execute(llm, query)
+        if self.phase1_post_callback:
+            self.phase1_post_callback(self.expert_finder)
+
+        expert_finder = self.expert_finder
+        all_expert_list = expert_finder.expert_list
+        all_expert_count = len(all_expert_list)
+
+        expert_list_truncated = all_expert_list[:self.max_expert_count]
+        expert_list_truncated_count = len(expert_list_truncated)
+
+        if all_expert_count != expert_list_truncated_count:
+            logger.info(f"Truncated expert list from {all_expert_count} to {expert_list_truncated_count} experts.")
+
+        logger.info(f"Asking {expert_list_truncated_count} experts for criticism...")
+
+        for expert_index, expert_dict in enumerate(expert_list_truncated):
+            expert_copy = expert_dict.copy()
+            expert_copy.pop('id')
+            expert_title = expert_copy.get('title', 'Missing title')
+            logger.info(f"Getting criticism from expert {expert_index + 1} of {expert_list_truncated_count}. expert_title: {expert_title}")
+            system_prompt = ExpertCriticism.format_system(expert_dict)
+            expert_criticism = ExpertCriticism.execute(llm, query, system_prompt)
+            if self.phase2_post_callback:
+                self.phase2_post_callback(expert_criticism, expert_index)
+            self.expert_criticism_list.append(expert_criticism)
+
+        logger.info(f"Finished collecting criticism from {expert_list_truncated_count} experts.")
+    
+    def to_markdown(self) -> str:
+        rows = []
+        rows.append("# Project Expert Review & Recommendations\n")
+        rows.append("## A Compilation of Professional Feedback for Project Planning and Execution\n\n")
+
+        number_of_experts_with_criticism = len(self.expert_criticism_list)
+        for expert_index, expert_criticism in enumerate(self.expert_criticism_list):
+            section_index = expert_index + 1
+            if expert_index > 0:
+                rows.append("\n---\n")
+            expert_details = self.expert_finder.expert_list[expert_index]
+            rows.extend(markdown_rows_with_info_about_one_expert(section_index, expert_details))
+            rows.extend(markdown_rows_with_criticism_from_one_expert(section_index, expert_criticism.to_dict()))
+
+        if number_of_experts_with_criticism != len(self.expert_finder.expert_list):
+            rows.append("\n---\n")
+            rows.append("# The following experts did not provide feedback:")
+            for expert_index, expert_details in enumerate(self.expert_finder.expert_list):
+                if expert_index < number_of_experts_with_criticism:
+                    continue
+                section_index = expert_index + 1
+                rows.append("")
+                rows.extend(markdown_rows_with_info_about_one_expert(section_index, expert_details))
+        
+        return "\n".join(rows)
+
+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(expert_finder: ExpertFinder) -> None:
+        count = len(expert_finder.expert_list)
+        d = expert_finder.to_dict(include_system_prompt=False, include_user_prompt=False)
+        pretty = json.dumps(d, indent=2)
+        print(f"Found {count} expert:\n{pretty}")
+
+    def phase2_post_callback(expert_criticism: ExpertCriticism, expert_index: int) -> None:
+        d = expert_criticism.to_dict(include_query=False)
+        pretty = json.dumps(d, indent=2)
+        print(f"Expert {expert_index + 1} criticism:\n{pretty}")
+
+    orchestrator = ExpertOrchestrator()
+    orchestrator.phase1_post_callback = phase1_post_callback
+    orchestrator.phase2_post_callback = phase2_post_callback
+    orchestrator.execute(llm, plan_prompt)
+    print("\n\nMarkdown:")
+    print(orchestrator.to_markdown())

src/expert/markdown_with_criticism_from_experts.py

@@ -0,0 +1,97 @@
+def markdown_rows_with_info_about_one_expert(section_index: int, expert_detail_json: dict) -> list[str]:
+    rows = []
+
+    expert_title = expert_detail_json.get('title', 'Missing title')
+    rows.append(f"# {section_index} Expert: {expert_title}")
+
+    expert_knowledge = expert_detail_json.get('knowledge', 'Missing knowledge')
+    rows.append(f"\n**Knowledge**: {expert_knowledge}")
+
+    expert_why = expert_detail_json.get('why', 'Missing why')
+    rows.append(f"\n**Why**: {expert_why}")
+
+    expert_what = expert_detail_json.get('what', 'Missing what')
+    rows.append(f"\n**What**: {expert_what}")
+
+    expert_skills = expert_detail_json.get('skills', 'Missing skills')
+    rows.append(f"\n**Skills**: {expert_skills}")
+
+    expert_search_query = expert_detail_json.get('search_query', 'Missing search_query')
+    rows.append(f"\n**Search**: {expert_search_query}")
+
+    return rows
+
+def markdown_rows_with_criticism_from_one_expert(section_index: int, expert_criticism_json: dict) -> list[str]:
+    rows = []
+
+    rows.append("")
+    user_primary_actions = expert_criticism_json.get('user_primary_actions', None)
+    rows.append(f"## {section_index}.1 Primary Actions\n")
+    if isinstance(user_primary_actions, list) and len(user_primary_actions) > 0:
+        for action in user_primary_actions:
+            rows.append(f"- {action}")
+    else:
+        rows.append("Empty")
+
+    user_secondary_actions = expert_criticism_json.get('user_secondary_actions', None)
+    rows.append(f"\n## {section_index}.2 Secondary Actions\n")
+    if isinstance(user_secondary_actions, list) and len(user_secondary_actions) > 0:
+        for action in user_secondary_actions:
+            rows.append(f"- {action}")
+    else:
+        rows.append("Empty")
+
+    follow_up_consultation = expert_criticism_json.get('follow_up_consultation', None)
+    rows.append(f"\n## {section_index}.3 Follow Up Consultation\n")
+    if follow_up_consultation:
+        rows.append(follow_up_consultation)
+    else:
+        rows.append("Empty")
+
+    start_subsection_index = 4
+    negative_feedback_list = expert_criticism_json.get('negative_feedback_list', [])
+    for feedback_index, feedback_item in enumerate(negative_feedback_list):
+        rows.append("")
+
+        subsection_index = start_subsection_index + feedback_index
+        prefix_a = f"{section_index}.{subsection_index}.A"
+        prefix_b = f"{section_index}.{subsection_index}.B"
+        prefix_c = f"{section_index}.{subsection_index}.C"
+        prefix_d = f"{section_index}.{subsection_index}.D"
+        prefix_e = f"{section_index}.{subsection_index}.E"
+        
+        title = feedback_item.get('feedback_title', 'Missing feedback_title')
+        feedback_verbose = feedback_item.get('feedback_verbose', 'Missing feedback_verbose')
+        rows.append(f"## {prefix_a} Issue - {title}\n")
+        rows.append(feedback_verbose)
+
+        problem_tag_list = feedback_item.get('feedback_problem_tags', None)
+        rows.append(f"\n### {prefix_b} Tags\n")
+        if isinstance(problem_tag_list, list) and len(problem_tag_list) > 0:
+            for tag in problem_tag_list:
+                rows.append(f"- {tag}")
+        else:
+            rows.append("Empty")
+
+        feedback_mitigation = feedback_item.get('feedback_mitigation', None)
+        rows.append(f"\n### {prefix_c} Mitigation\n")
+        if feedback_mitigation:
+            rows.append(feedback_mitigation)
+        else:
+            rows.append("Empty")
+
+        feedback_consequence = feedback_item.get('feedback_consequence', None)
+        rows.append(f"\n### {prefix_d} Consequence\n")
+        if feedback_consequence:
+            rows.append(feedback_consequence)
+        else:
+            rows.append("Empty")
+
+        feedback_root_cause = feedback_item.get('feedback_root_cause', None)
+        rows.append(f"\n### {prefix_e} Root Cause\n")
+        if feedback_root_cause:
+            rows.append(feedback_root_cause)
+        else:
+            rows.append("Empty")
+
+    return rows

src/expert/pre_project_assessment.py

@@ -0,0 +1,404 @@
+"""
+PROMPT> python -m src.expert.pre_project_assessment
+
+Two experts analyze a project plan and provide feedback.
+
+Analysis: Experts assess the plan.
+
+Feedback Generation: Experts create actionable feedback.
+
+Summary & Recommendation: A summary and a "Go/No Go" recommendation is created based on the experts input.
+
+IDEA: Cloud providers often timeouts. 
+If a cloud provider is down, it may take hours to get back up. In that case switch to another cloud provider.
+It would be useful to cycle through multiple cloud providers to get the best results.
+Keeping track of health of each cloud providers would be useful, up/down status, response time, etc.
+
+IDEA: Pool of multiple system prompts. Some of the system prompts yields better results than others.
+Run 3 invocation of the LLM, using different system prompts. Select the best result. Or extract the best parts from each result.
+Example of where it makes sense to have, a pool of multiple system prompts:
+For a simple programming task, one system prompt may focus on the irrelevant things, such as:
+- Procure the Python library 'Pygame' to handle graphics and game logic.
+It makes no sense to procure a Python library for a programming task. It's a simple pip install command.
+- Ensure compatibility with your system architecture (32-bit or 64-bit).
+The year is 2025, I haven't dealt with 32 bit issues for the last 20 years.
+"""
+import json
+import time
+from datetime import datetime
+import logging
+from math import ceil
+from uuid import uuid4
+from typing import List, Optional, Any
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from llama_index.core.llms import ChatMessage, MessageRole
+
+logger = logging.getLogger(__name__)
+
+class FeedbackItem(BaseModel):
+    feedback_index: int = Field(description="The index of the feedback item.")
+    feedback_title: str = Field(description="What is the feedback about?")
+    feedback_description: str = Field(description="Describe the feedback.")
+
+class Expert(BaseModel):
+    expert_title: str = Field(description="Job title of the expert.")
+    expert_full_name: str = Field(description="First name and last name of the expert.")
+    feedback_item_list: List[FeedbackItem] = Field(description="List of feedback items.")
+
+class ExpertDetails(BaseModel):
+    expert1: Expert = Field(description="Perspective from expert 1.")
+    expert2: Expert = Field(description="Perspective from expert 2.")
+    combined_summary: str = Field(description="Summary of the feedback from both experts.")
+    go_no_go_recommendation: str = Field(description="A 'Go' or 'No Go' recommendation, with an explanation.")
+
+# Prompt made with o1mini
+EXPERT_BROAD_SYSTEM_PROMPT_1 = """
+You are a team of 2 experts providing a critical review of a project with a vague description. Depending on the project type, select appropriate expert roles.
+
+**Requirements:**
+
+1. **Feedback Items:**
+   - Each expert must provide exactly **4 feedback items**.
+   - Each feedback item must start with **"You must do this:"** and include **3-4 specific reasons or actions**.
+   - The **"feedback_title"** should capture the essence of the feedback in **around 7 words**.
+   - Use **consistent and professional language** throughout all feedback items.
+   - **Avoid redundancy** between experts; ensure each expert addresses distinct aspects of the project.
+   - Each "feedback_description" should provide clear, step-by-step actions that are specific and measurable.
+   - Avoid vague statements; ensure that each action is actionable and can be directly implemented.
+   
+   **Focus Areas:**
+   - **Expert 1:** Project management, technical feasibility, financial modeling, and stakeholder engagement.
+   - **Expert 2:** Environmental impact, regulatory compliance, community engagement, and risk management.
+   
+2. **Combined Summary and Recommendation:**
+   - **"combined_summary":** Summarize the **3 most critical reasons** why the project cannot start tomorrow.
+   - **"go_no_go_recommendation":** Provide a clear **"Go"** or **"No Go"** recommendation with a brief explanation.
+"""
+
+# Prompt made with gemini
+EXPERT_BROAD_SYSTEM_PROMPT_2 = """
+Pretend that you are a team of 2 experts providing a critical review of a project with a vague description. You must provide specific, actionable recommendations, including why the project cannot begin tomorrow. Each feedback item must be a specific reason why the project cannot begin tomorrow. Each feedback item must start with 'You must do this:'. Each feedback item should then be broken down into 3-4 specific reasons.
+
+The "feedback_title" must capture the essence of the feedback, use around 7 words.
+
+The "feedback_item_list" must contain 4 items per expert. The response must have consistent language throughout all feedback items.
+
+The "expert_full_name" is a fictional name, that might be plausible for the expert.
+
+You must provide a "Go" or "No Go" recommendation. You must also provide the reasons for that recommendation.
+
+The "combined_summary" must include the 3 most important and critical reasons why the project cannot start tomorrow, and the actions you recommend to address these reasons.
+
+The goal of the experts is to assess the readiness and feasibility of the project, and to identify any risks that would make a 'start tomorrow' plan, unfeasible.
+"""
+
+# Prompt made with gemini, by combining the two previous prompts
+EXPERT_BROAD_SYSTEM_PROMPT_3 = """
+You are a team of 2 experts providing a critical review of a task with a vague description. The task is short-term and requires immediate attention.
+
+Your goal is to assess how to complete the task safely and quickly, providing very specific and actionable steps. Select appropriate expert roles.
+
+**Requirements:**
+
+1.  **Expert Roles:**
+  - **Expert 1:** Focus on how to complete the task as quickly and *efficiently* as possible, with very specific, actionable steps.
+  - **Expert 2:** Focus on the safety aspects of the task, with very specific, actionable steps to mitigate safety concerns.
+  - Each expert must have an appropriate title and a fictional full name, relevant to the chosen roles for the task.
+
+2.  **Feedback Items:**
+  - Each expert *MUST* provide exactly **4 feedback items**.
+  - Each feedback item must start with **"To execute the task, you must:"** followed by **3-4 *extremely specific, concrete, actionable steps*.** Avoid vague or high-level steps. Each step should include specific details such as measurements, timings, equipment, or precise actions required. For example instead of "handle hot water carefully" use "Wear oven mitts when handling hot water and pour slowly and steadily".
+  - The **"feedback_title"** should capture the essence of the feedback in around **7 words**, focusing on the immediate actions to be taken. The title should imply very specific actions.
+  - The feedback items MUST NOT be too high level, and MUST be very specific.
+
+3.  **Combined Summary and Recommendation:**
+  - **"combined_summary":** Summarize the **3 most critical actions**, using specific examples from the feedback items, needed immediately to enable the task to begin. The summary must reference the `feedback_index` from the experts for each of these three critical actions. Explain *why* those 3 actions are the most critical actions needed.
+  - **"go_no_go_recommendation":**
+    Provide a clear **"Execute Immediately"** or **"Do Not Execute"** recommendation.
+"""
+
+# Prompt made with deepseek, by combining the 3 previous prompts
+EXPERT_BROAD_SYSTEM_PROMPT_4 = """
+You are a team of 2 experts providing a critical review of a project with a vague description. The project can be short-term, medium-term, or long-term. Your goal is to assess how to complete the project safely, efficiently, and effectively, providing very specific and actionable steps. Select appropriate expert roles based on the project type.
+
+**Requirements:**
+
+1. **Expert Roles:**
+   - **Expert 1:** Focus on how to complete the project as quickly and *efficiently* as possible, with very specific, actionable steps. This includes project management, technical feasibility, resource allocation, and timeline optimization.
+   - **Expert 2:** Focus on the safety, compliance, and risk mitigation aspects of the project, with very specific, actionable steps to address potential hazards, regulatory requirements, and environmental or community impacts.
+   - Each expert must have an appropriate title and a fictional full name, relevant to the chosen roles for the task.
+
+2. **Feedback Items:**
+   - Each expert *MUST* provide exactly **4 feedback items**.
+   - Each feedback item must start with **"To execute the project, you must:"** followed by **3-4 *extremely specific, concrete, actionable steps*.** Avoid vague or high-level steps. Each step should include specific details such as measurements, timings, equipment, or precise actions required. For example, instead of "handle hot water carefully," use "Wear oven mitts when handling hot water and pour slowly and steadily."
+   - The **"feedback_title"** should capture the essence of the feedback in around **7 words**, focusing on immediate actions to be taken. The title should imply very specific actions (e.g., "Assemble Team by [specific date]").
+   - The feedback items MUST NOT be too high-level and MUST be very specific.
+
+3. **Combined Summary and Recommendation:**
+   - **"combined_summary":** Summarize the **3 most critical actions**, using specific examples from the feedback items, needed immediately to enable the project to begin. The summary must reference the `feedback_index` from the experts for each of these three critical actions. Explain *why* those 3 actions are the most critical actions needed.
+   - **"go_no_go_recommendation":** Provide a clear **"Execute Immediately"**, **"Proceed with Caution"**, or **"Do Not Execute"** recommendation, depending on the project's feasibility, risks, and readiness. Include a brief explanation for the recommendation, addressing potential risks and mitigation strategies.
+
+**Focus Areas for Experts:**
+- **Expert 1 (Efficiency and Execution):** Prioritize speed, resource optimization, and technical feasibility. Address logistical challenges, stakeholder coordination, and timeline management.
+- **Expert 2 (Safety and Compliance):** Prioritize risk mitigation, regulatory compliance, and environmental or community impacts. Address safety protocols, hazard prevention, and legal or ethical considerations.
+
+**Adaptability:**
+- For **short-term projects**, emphasize immediate actions, rapid resource allocation, and quick risk assessments.
+- For **medium-term projects**, balance efficiency with thorough planning, including phased execution and contingency planning.
+- For **long-term projects**, focus on sustainability, regulatory approvals, and long-term risk management.
+
+**Language and Tone:**
+- Use **consistent and professional language** throughout all feedback items.
+- Avoid redundancy between experts; ensure each expert addresses distinct aspects of the project.
+- Ensure all steps are **actionable, measurable, and specific**, avoiding vague or generic advice.
+- Use **action-oriented titles** that imply immediate, specific actions (e.g., "Complete Risk Assessment by [specific date]").
+
+**Additional Guidelines:**
+- Include **specific deadlines** (e.g., "by year-month-day") in feedback items to emphasize urgency.
+- Provide **quantifiable details** (e.g., "500 PPE kits," "10m x 10m command center") to ensure clarity and measurability.
+- Highlight **potential risks** and **mitigation strategies** in the combined summary and recommendation.
+- Ensure feedback items are **distinct and non-overlapping** between experts, with clear separation of responsibilities.
+"""
+
+# Prompt made with gemini, by combining the 4 previous prompts
+EXPERT_BROAD_SYSTEM_PROMPT_5 = """
+You are a team of 2 experts providing a critical, actionable review of a project given its vague description. Your goal is to rapidly assess the project's feasibility, identify key risks, and provide a clear path forward. The project can be short-term, medium-term, or long-term.
+
+**Overall Requirements:**
+
+1.  **Action-Oriented:** Focus on providing **immediate, concrete steps** that the project team can take to move forward (or decide not to move forward). Avoid analysis or commentary about why those steps need to be done - just list what to do.
+2.  **Feasibility and Risk-Based:** Analyze the project for feasibility given the vague description, and highlight any safety, logistical, or ethical concerns.
+3.  **Clear Recommendation:** Provide a definitive and clear recommendation on whether the project should proceed *now*, and why.
+
+**Expert Roles:**
+
+   - **Expert 1 (Project Execution & Logistics):** Focus on the **practical steps** required to execute the project efficiently. This includes defining resources, timelines, tasks, and initial goals. Prioritize speed, and assume that no prior work has been done on the project.
+   - **Expert 2 (Safety, Compliance & Risk):** Focus on **identifying and mitigating risks** related to the project. This includes health, safety, legal and ethical issues. Assume that the team will not consider these issues unless prompted.
+
+   - Each expert MUST have an appropriate title and a fictional full name relevant to their expertise.
+
+**Feedback Items (for each expert):**
+
+   - Each expert MUST provide exactly **4 feedback items**.
+   - Each feedback item must start with **"To initiate this project, you must:"**, followed by **3-4 *extremely specific, concrete, actionable steps*.** Each step should include specific details such as measurements, timings, equipment, personnel requirements or precise actions. *DO NOT* use vague, high-level or generalized statements. The goal is to provide a checklist that can be immediately executed. Use action-oriented language. Use quantifiable details (e.g., "10 meters of rope", "5 sterile collection tubes"). For example, instead of: "procure appropriate gear", instead use: "Procure 10 sets of specialized radiation-resistant suits, including lead-lined inner layers, gloves, and boots rated for 100mSv exposure within 48 hours."
+   - The **"feedback_title"** should capture the essence of the feedback in **around 7 words** and should imply very specific actions (e.g., "Procure Safety Gear", "Map the Area"). It should not be a general statement, and it should use an active verb. The 'feedback_title' must NOT include the text 'by Date', as this is unnecessary.
+   - The feedback items MUST NOT be too high level, and MUST be very specific. The aim should be to provide a checklist that can be rapidly assessed by any project team. The items must be directly executable as a checklist. When describing quantities, always use phrases such as "at least X" or "no more than X" unless the exact amount is known. All timeframes MUST include a specific date AND time, and the time must be expressed as a 24 hour clock using HH:MM format. If a specific action is likely to be difficult to achieve in the timeframe, the response MUST include an alternative action to mitigate this risk. *Use a bulleted list for all steps, do not include numbered lists.*
+
+**Combined Summary and Recommendation:**
+
+  - **"combined_summary":** Summarize the **3 most critical, immediate actions**, selected from the feedback items across *both* experts, referencing each feedback item using the expert name and `feedback_index`. Explain *why* these actions are the most immediately essential, and how they mitigate the most important risks.
+  - **"go_no_go_recommendation":** Provide a clear recommendation of **"Execute Immediately"**, **"Proceed with Caution"**, or **"Do Not Execute"**.  Your recommendation must be based on a balanced assessment of the project's potential risks and feasibility, given the limitations of the provided description and the immediate actions outlined by the experts. Do not default to a single recommendation. The response must show that it has actively considered all three options, and show why it is recommending one option over the other two. If you recommend "Proceed with Caution", include the specific actions required for caution. If you recommend "Do Not Execute" be clear about why that's the best option given the risks. The recommendation should be a reflection of the overall safety and operational concerns, given the described project. Provide a brief, *concrete* explanation supporting this recommendation, highlighting the primary risks or critical actions that have influenced the decision.
+
+**Additional Guidelines:**
+
+  - Use **consistent, professional, action-oriented language** throughout.
+  - **Avoid redundancy** between experts; ensure each expert addresses distinct aspects.
+  - Include **specific deadlines** (e.g., "by year-month-day") or timings to emphasize urgency.
+  - Include **quantifiable details** (e.g., "10 meters of rope", "5 sterile collection tubes") to ensure clarity and measurability.
+  - The tone should be that of a professional, who has seen many projects, and therefore immediately recognizes key issues that must be resolved for this project to proceed.
+  - Be aware that some timelines may be impossible. If a timeline is unrealistic, the response should provide an alternative approach to obtain those results, rather than just accepting the unrealistic timeframe as given. Do not propose that a government permit can be obtained in a single day.
+"""
+
+# Prompt made with gemini, by combining the 5 previous prompts
+EXPERT_BROAD_SYSTEM_PROMPT_6 = """
+You are a team of 2 experts providing a critical, actionable review of a project given its vague description. Your goal is to rapidly assess the project's feasibility, identify key risks, and provide a clear path forward. The project can be short-term, medium-term, or long-term. The year is CURRENT_YEAR_PLACEHOLDER.
+
+**Overall Requirements:**
+
+1.  **Action-Oriented:** Focus on providing **immediate, concrete steps** that the project team can take to move forward (or decide not to move forward). Avoid analysis or commentary about why those steps need to be done - just list what to do.
+2.  **Feasibility and Risk-Based:** Analyze the project for feasibility given the vague description, and highlight any safety, logistical, or ethical concerns.
+3.  **Clear Recommendation:** Provide a definitive and clear recommendation on whether the project should proceed *now*, and why.
+
+**Expert Roles:**
+
+   - **Expert 1 (Project Execution & Logistics):** Focus on the **practical steps** required to execute the project efficiently. This includes defining resources, timelines, tasks, and initial goals. Prioritize speed, and assume that no prior work has been done on the project. The feedback *MUST* be specific and derived *ONLY* from the vague description provided. Do *NOT* use generic steps or project management steps. The steps should provide specific details about code, mathematical, and logical details, *if directly implied by the project description*. You MUST explain *why* a specific action is needed.
+   - **Expert 2 (Safety, Compliance & Risk):** Focus on **identifying and mitigating risks** related to the project. This includes health, safety, legal and ethical issues, as well as technical risks within the project. Assume that the team will not consider these issues unless prompted. The feedback *MUST* be specific and derived *ONLY* from the vague description provided. Do *NOT* use generic safety steps or general safety advice. If the task is about software, focus on the specific details of *how* to mitigate a risk, and avoid describing the risk itself. You MUST explain *why* a specific action is needed.
+
+   - Each expert MUST have an appropriate title and a fictional full name relevant to their expertise.
+
+**Feedback Items (for each expert):**
+
+   - Each expert MUST provide exactly **4 feedback items**.
+   - Each feedback item must start with **"To initiate this project, you must:"**, followed by **3-4 *extremely specific, concrete, actionable steps*.** Each step should include specific details such as measurements, timings, equipment, personnel requirements or precise actions. *DO NOT* use vague, high-level or generalized statements. The goal is to provide a checklist that can be immediately executed. Use action-oriented language. Use quantifiable details (e.g., "10 meters of rope", "5 sterile collection tubes"). For example, instead of: "procure appropriate gear", instead use: "Procure 10 sets of specialized radiation-resistant suits, including lead-lined inner layers, gloves, and boots rated for 100mSv exposure within 48 hours." The feedback items must be derived *ONLY* from the vague project description. If the task is about software, *avoid describing generic steps such as "procure a library" or describing general safety risks*. Instead, focus on calculations, algorithms, or implementation details *if they are directly implied by the project description*. The actions for handling the risks MUST be extremely explicit, and describe *how to handle the risk* rather than *what the risk is*. You MUST explain *why* a specific action is needed.
+   - The **"feedback_title"** should capture the essence of the feedback in **around 7 words** and should imply very specific actions (e.g., "Procure Safety Gear", "Map the Area"). It should not be a general statement, and it should use an active verb. The 'feedback_title' must NOT include the text 'by Date', as this is unnecessary.
+   - The feedback items MUST NOT be too high level, and MUST be very specific. The aim should be to provide a checklist that can be rapidly assessed by any project team. The items must be directly executable as a checklist. When describing quantities, always use phrases such as "at least X" or "no more than X" unless the exact amount is known. All timeframes MUST include a specific date AND time, and the time must be expressed as a 24 hour clock using HH:MM format. If a specific action is likely to be difficult to achieve in the timeframe, the response MUST include an alternative action to mitigate this risk. *Use a bulleted list for all steps, do not include numbered lists.*
+
+**Combined Summary and Recommendation:**
+
+  - **"combined_summary":** Summarize the **3 most critical, immediate actions**, selected from the feedback items across *both* experts. Explain *why* these actions are the most immediately essential, and how they mitigate the most important risks. Do *not* reference the feedback item using the expert name and `feedback_index`.
+  - **"go_no_go_recommendation":** Provide a clear recommendation of **"Execute Immediately"**, **"Proceed with Caution"**, or **"Do Not Execute"**. Your recommendation must be based on a balanced assessment of the project's potential risks and feasibility, given the limitations of the provided description and the immediate actions outlined by the experts. Do not default to a single recommendation. The response must show that it has actively considered all three options, and show why it is recommending one option over the other two. If you recommend "Proceed with Caution", include the specific actions required for caution. *If you recommend "Do Not Execute", the response MUST provide a very clear and detailed justification about why it is not feasible to proceed, given the risks and the nature of the project, and if no reasonable mitigation strategy can be proposed. The response must be derived from the vague project description, with clear and obvious reasons why the project cannot be executed immediately. You must use examples directly from the description to justify your recommendation, and you must explain what part of the description is not feasible or creates a contradiction*. The recommendation should be a reflection of the overall safety and operational concerns, given the described project. Provide a brief, *concrete* explanation supporting this recommendation, highlighting the primary risks or critical actions that have influenced the decision.
+
+**Additional Guidelines:**
+
+  - Use **consistent, professional, action-oriented language** throughout.
+  - **Avoid redundancy** between experts; ensure each expert addresses distinct aspects.
+  - Include **specific deadlines** (e.g., "by year-month-day") or timings to emphasize urgency, if necessary.
+  - Include **quantifiable details** (e.g., "10 meters of rope", "5 sterile collection tubes") to ensure clarity and measurability.
+  - The tone should be that of a professional, who has seen many projects, and therefore immediately recognizes key issues that must be resolved for this project to proceed.
+  - Be aware that some timelines may be impossible. If a timeline is unrealistic, the response should provide an alternative approach to obtain those results, rather than just accepting the unrealistic timeframe as given. Do not propose that a government permit can be obtained in a single day.
+"""
+
+EXPERT_BROAD_SYSTEM_PROMPT = EXPERT_BROAD_SYSTEM_PROMPT_6
+
+@dataclass
+class PreProjectAssessment:
+    """
+    Obtain a broad perspective from 2 experts.
+    """
+    system_prompt: Optional[str]
+    user_prompt: str
+    response: dict
+    metadata: dict
+    preproject_assessment: dict
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str, **kwargs: Any) -> 'PreProjectAssessment':
+        """
+        Invoke LLM and have 2 experts take a broad look at the initial plan.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid query.")
+
+        # Obtain the current year as a string, eg. "1984"
+        current_year_int = datetime.now().year
+        current_year = str(current_year_int)
+
+        # Replace the placeholder in the system prompt with the current year
+        system_prompt = EXPERT_BROAD_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,
+                )
+            )
+        
+        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()
+        chat_response1 = sllm.chat(chat_message_list1)
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response1.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        try:
+            json_response = json.loads(chat_response1.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
+
+        # Cleanup the json response from the LLM model.
+        # Discard the name of the experts and the role of the experts, 
+        # these are causing confusion downstream when trying to do project planning.
+        # Having those names and roles causes the LLM to think they are stakeholders in the project, which they are not.
+
+        # Extract just the feedback items
+        flat_feedback_list = []
+        for key in ['expert1', 'expert2']:
+            expert = json_response.get(key)
+            if expert is None:
+                logger.error(f"Expert {key} not found in response.")
+                continue
+
+            for feedback_item in expert.get('feedback_item_list', []):
+                flat_feedback_list.append({
+                    "title": feedback_item.get('feedback_title', 'Empty'),
+                    "description": feedback_item.get('feedback_description', 'Empty')
+                })
+        preproject_assessment = {
+            'go_no_go_recommendation': json_response.get('go_no_go_recommendation', 'Empty'),
+            'combined_summary': json_response.get('combined_summary', 'Empty'),
+            'feedback': flat_feedback_list
+        }
+        logger.info(f"Extracted {len(flat_feedback_list)} feedback items.")
+
+        result = PreProjectAssessment(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata,
+            preproject_assessment=preproject_assessment
+        )
+        logger.debug("CreateProjectPlan instance created successfully.")
+        return result    
+
+    def to_dict(self, include_metadata=True, include_system_prompt=True, include_user_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        return d
+
+    def save_raw(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.to_dict(), indent=2))
+
+    def save_preproject_assessment(self, file_path: str) -> None:
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(self.preproject_assessment, indent=2))
+
+if __name__ == "__main__":
+    import logging
+    from src.llm_factory import get_llm
+    from src.plan.find_plan_prompt import find_plan_prompt
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler()
+        ]
+    )
+
+    plan_prompt = find_plan_prompt("4dc34d55-0d0d-4e9d-92f4-23765f49dd29")
+    query = (
+        f"{plan_prompt}\n\n"
+        "Today's date:\n2025-Jan-26\n\n"
+        "Project start ASAP"
+    )
+
+    llm = get_llm("ollama-llama3.1")
+    # llm = get_llm("deepseek-chat", max_tokens=8192)
+
+    print(f"Query: {query}")
+    result = PreProjectAssessment.execute(llm, query)
+
+    print("\n\nResponse:")
+    print(json.dumps(result.to_dict(include_system_prompt=False, include_user_prompt=False), indent=2))
+
+    print("\n\nPreproject assessment:")
+    print(json.dumps(result.preproject_assessment, indent=2))

src/expert/test_data/solarfarm_expert_list.json

@@ -0,0 +1,74 @@
+[
+  {
+    "id": "a0f6dfa3-45f6-4126-9843-79995b9ea935",
+    "title": "Renewable Energy Policy Specialist",
+    "knowledge": "Danish renewable energy policies, government incentives, and regulatory frameworks.",
+    "why": "To provide insights on the current policy landscape and potential future changes that may impact the solar farm project.",
+    "what": "Assessing the likelihood of continued government support for renewable energy projects and identifying potential risks associated with relying on subsidies and incentives.",
+    "skills": "Analyzing policy documents, understanding regulatory frameworks, and communicating complex information to stakeholders.",
+    "search_query": "Renewable Energy Policy Specialist in Denmark"
+  },
+  {
+    "id": "208da91f-97cb-4915-b1f8-265ce759d13f",
+    "title": "Community Engagement Expert",
+    "knowledge": "Effective community engagement strategies, local attitudes towards solar farms, and social impact assessments.",
+    "why": "To provide guidance on how to engage with the local community, address concerns, and gain support for the project.",
+    "what": "Developing a comprehensive community engagement plan, assessing local attitudes towards solar farms, and identifying potential risks associated with negative public perception.",
+    "skills": "Community outreach, stakeholder analysis, and conflict resolution.",
+    "search_query": "Community Engagement Expert in Denmark"
+  },
+  {
+    "id": "bb34f731-0162-4e09-a1bc-6c62a811ef71",
+    "title": "Energy Storage Specialist",
+    "knowledge": "Energy storage solutions, their feasibility, and potential for mitigating intermittency.",
+    "why": "To provide expertise on the development of an energy storage solution plan and its integration with the solar farm project.",
+    "what": "Assessing different energy storage solutions, evaluating their feasibility, and identifying potential risks associated with technological disruptions.",
+    "skills": "Energy storage system design, feasibility studies, and technical writing.",
+    "search_query": "Energy Storage Specialist in Denmark"
+  },
+  {
+    "id": "fa98fa94-386d-4ed3-b216-d079ffaa276a",
+    "title": "Cybersecurity Expert",
+    "knowledge": "Solar farm control systems security, potential cybersecurity threats, and mitigation strategies.",
+    "why": "To provide guidance on implementing a robust cybersecurity plan to protect the solar farm's control systems.",
+    "what": "Developing a comprehensive cybersecurity plan, identifying potential risks associated with cybersecurity threats, and evaluating the effectiveness of mitigation strategies.",
+    "skills": "Cybersecurity risk assessment, threat analysis, and incident response planning.",
+    "search_query": "Cybersecurity Expert in Denmark"
+  },
+  {
+    "id": "1325be99-ba08-4283-9297-ab8098589d51",
+    "title": "Grid Infrastructure Specialist",
+    "knowledge": "Danish grid infrastructure capacity, energy distribution optimization, and integration of renewable energy sources.",
+    "why": "To provide insights on the grid infrastructure's ability to handle the solar farm's output and identify potential risks associated with integrating the solar farm into the grid.",
+    "what": "Assessing the grid infrastructure's capacity to handle the solar farm's output, evaluating the feasibility of smart grid technologies, and identifying potential risks associated with energy distribution disruptions.",
+    "skills": "Grid system analysis, energy distribution optimization, and technical writing.",
+    "search_query": "Grid Infrastructure Specialist in Denmark"
+  },
+  {
+    "id": "d019beb2-f900-4e43-8ca6-920a24bc7fda",
+    "title": "Agrivoltaics Expert",
+    "knowledge": "Agricultural applications of solar farms, agrivoltaic systems design, and integration with other sectors (e.g., agriculture, electric vehicle charging infrastructure).",
+    "why": "To provide expertise on the development of a 'killer application' by integrating the solar farm with agricultural activities.",
+    "what": "Evaluating the feasibility of agrivoltaics, assessing potential revenue streams, and identifying potential risks associated with integrating the solar farm with other sectors.",
+    "skills": "Agrivoltaic system design, agricultural applications of solar energy, and business development.",
+    "search_query": "Agrivoltaics Expert in Denmark"
+  },
+  {
+    "id": "b8f51b0f-0875-4601-9871-ad94446f11c9",
+    "title": "Data Analytics and AI Specialist",
+    "knowledge": "Solar farm performance optimization using data analytics and AI, predictive maintenance strategies, and energy storage solution integration.",
+    "why": "To provide insights on how to optimize the solar farm's performance using data analytics and AI, and identify potential risks associated with relying on these technologies.",
+    "what": "Developing a comprehensive data analytics and AI plan, evaluating the feasibility of predictive maintenance strategies, and identifying potential risks associated with technological disruptions.",
+    "skills": "Data analysis, machine learning, and technical writing.",
+    "search_query": "Data Analytics and AI Specialist in Denmark"
+  },
+  {
+    "id": "54b7837f-92d1-4e3d-ac54-0228f014a582",
+    "title": "Economic Development Expert",
+    "knowledge": "Renewable energy project economic viability, cost-benefit analysis of different energy storage solutions, and potential risks associated with market fluctuations.",
+    "why": "To provide expertise on the economic feasibility of the solar farm project and identify potential risks associated with market fluctuations.",
+    "what": "Conducting a comprehensive cost-benefit analysis, evaluating the economic viability of the solar farm project, and identifying potential risks associated with market disruptions.",
+    "skills": "Cost-benefit analysis, market research, and financial modeling.",
+    "search_query": "Economic Development Expert in Denmark"
+  }
+]

src/expert/test_data/solarfarm_swot_analysis.md

@@ -0,0 +1,77 @@
+# SWOT Analysis
+
+## Topic
+Solar farm in Denmark
+
+## Type
+business
+
+## Type detailed
+Strategic Planning
+
+## Strengths 👍💪🦾
+- Denmark's strong commitment to renewable energy and sustainability.
+- Availability of skilled workforce (engineers, technicians) in the renewable energy sector.
+- Established regulatory framework for renewable energy projects.
+- Potential for government subsidies and incentives for renewable energy projects.
+- Access to advanced technology and equipment for solar farm construction.
+- Strong grid infrastructure capable of integrating renewable energy sources.
+
+## Weaknesses 👎😱🪫⚠️
+- High initial capital investment required.
+- Dependence on weather conditions for energy generation.
+- Potential land use conflicts and environmental concerns.
+- Complexity of navigating Danish regulatory and permitting processes.
+- Fluctuations in solar panel prices and supply chain vulnerabilities.
+- Lack of a 'killer app' or unique selling proposition to differentiate from other solar farms.
+
+## Opportunities 🌈🌐
+- Development of energy storage solutions to mitigate intermittency.
+- Integration of smart grid technologies to optimize energy distribution.
+- Collaboration with local communities to gain social acceptance and support.
+- Expansion of solar farm capacity to meet growing energy demand.
+- Creation of a 'killer application' by integrating the solar farm with other sectors, such as agriculture (agrivoltaics) or electric vehicle charging infrastructure, offering a unique value proposition.
+- Leveraging data analytics and AI to optimize solar farm performance and predictive maintenance.
+
+## Threats ☠️🛑🚨☢︎💩☣︎
+- Changes in government policies and regulations regarding renewable energy.
+- Increased competition from other renewable energy sources (e.g., wind, biomass).
+- Potential for technological disruptions that could render existing solar technology obsolete.
+- Negative public perception due to environmental concerns or visual impact.
+- Economic downturns that could impact investment in renewable energy projects.
+- Cybersecurity threats to the solar farm's control systems.
+
+## Recommendations 💡✅
+- Within 3 months, conduct a comprehensive market analysis to identify potential 'killer applications' such as agrivoltaics or integrated EV charging, led by the Business Development team.
+- Within 6 months, establish partnerships with local communities and environmental organizations to address concerns and gain support, managed by the Stakeholder Relations Manager.
+- Within 12 months, develop a detailed plan for integrating energy storage solutions to mitigate intermittency, overseen by the Engineering Manager.
+- Continuously monitor and adapt to changes in government policies and regulations, with the Legal and Compliance Officer providing monthly updates.
+- Within 18 months, implement a robust cybersecurity plan to protect the solar farm's control systems, led by the IT Security team.
+
+## Strategic Objectives 🎯🔭⛳🏅
+- Achieve 50 MW solar farm operational capacity within 24 months, measured by energy output and grid integration success.
+- Secure all necessary permits and regulatory approvals within 12 months, demonstrated by obtaining required documentation from Danish authorities.
+- Establish positive relationships with local communities, achieving a satisfaction rating of 80% based on community surveys within 18 months.
+- Develop and implement an energy storage solution plan within 12 months, measured by the plan's feasibility and potential for mitigating intermittency.
+- Identify and develop a 'killer application' (e.g., agrivoltaics) within 6 months, measured by the potential for increased revenue and market differentiation.
+
+## Assumptions 🤔🧠🔍
+- The Danish government will continue to support renewable energy projects through subsidies and incentives.
+- The cost of solar panel technology will remain competitive compared to other energy sources.
+- The local community will be receptive to the solar farm project with proper engagement and mitigation of concerns.
+- The grid infrastructure will be capable of handling the additional energy generated by the solar farm.
+- No major technological disruptions will render the planned solar technology obsolete within the project timeline.
+
+## Missing Information 🧩🤷‍♂️🤷‍♀️
+- Detailed analysis of potential 'killer application' opportunities and their market viability.
+- Specific data on community attitudes towards solar farms in the proposed location.
+- Comprehensive assessment of the grid infrastructure's capacity to handle the solar farm's output.
+- Detailed cost-benefit analysis of different energy storage solutions.
+- Up-to-date information on potential changes in Danish renewable energy policies and regulations.
+
+## Questions 🙋❓💬📌
+- What are the most promising 'killer application' opportunities for this solar farm, and what resources are needed to develop them?
+- How can we effectively engage with the local community to address their concerns and gain their support for the project?
+- What are the potential risks associated with relying on government subsidies and incentives, and how can we mitigate them?
+- How can we ensure that the solar farm's technology remains competitive and relevant in the face of potential technological disruptions?
+- What are the most effective strategies for mitigating the environmental impact of the solar farm and ensuring its long-term sustainability?

src/fiction/data/simple_fiction_prompts.jsonl

@@ -0,0 +1,7 @@
+{"id": "6448bd67-2e67-4324-a7c6-b59960443e36", "prompt": "The Unified Energy Civilization Grid\n\nGoal: Provide unlimited energy for all humanity.\nConstruct a Dyson Swarm\u2014a system of trillions of solar-collecting satellites orbiting the Sun\u2014to harness nearly all its energy output and beam it to Earth and other planets wirelessly. This would ensure a post-scarcity energy society.\n", "tags": ["space", "dyson swarm", "solar"]}
+{"id": "65974e78-3643-4f84-b323-f71316c2a8b8", "prompt": "What is a project? Work breakdown structure and estimating costs.", "tags": ["project", "WBS", "cost"]}
+{"id": "03d3a59a-2962-4ed9-9e57-7a7e3a989bbd", "prompt": "I have received a SWOT analysis. What should I pay attention to? A guide for project managers.", "tags": ["swot", "guide", "project manager"]}
+{"id": "6957d9c3-f188-4f31-bdd7-ed3ec0f153db", "prompt": "SWOT analysis. Show 20 detailed examples. Business/personal. University education level.", "tags": ["swot", "education"]}
+{"id": "eae2d3c9-aa6d-4e61-a671-3723dcebb50e", "prompt": "out-of-distribution, how to find any anomaly", "tags": ["anomaly", "outlier", "OOD"]}
+{"id": "0e8e9b9d-95dd-4632-b47c-dcc4625a556d", "prompt": "Daily life in a lunar colony", "tags": ["moon", "space"]}
+{"id": "4a2f93db-db24-403a-bad5-5b0ccbea8d58", "prompt": "Planning poker. A guide for project managers.", "tags": ["planning", "project manager", "guide"]}

src/fiction/fiction_writer.py

@@ -0,0 +1,133 @@
+"""
+Based on short description, make a longer description.
+
+PROMPT> python -m src.fiction.fiction_writer
+"""
+import json
+import time
+import logging
+from math import ceil
+from typing import Optional
+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 BookDraft(BaseModel):
+    book_title: str = Field(description="Human readable title.")
+    overview: str = Field(description="What is this about?")
+    elaborate: str = Field(description="Details")
+    background_story: str = Field(description="What is the background story.")
+    blurb: str = Field(description="The back cover of the book. Immediately capture the readers attention.")
+    goal: str = Field(description="What is the goal.")
+    main_characters: list[str] = Field(description="List of characters in the story and their background story.")
+    character_flaws: list[str] = Field(description="Character flaws relevant to the story.")
+    plot_devices: list[str] = Field(description="Items that appear in the story.")
+    possible_plot_ideas: list[str] = Field(description="List of story directions.")
+    challenges: list[str] = Field(description="Things that could go wrong or be difficult.")
+    chapter_title_list: list[str] = Field(description="Name of each chapter.")
+    final_story: str = Field(description="Based on the above, what is the final story.")
+
+@dataclass
+class FictionWriter:
+    """
+    Given a short text, elaborate on it.
+    """
+    query: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def execute(cls, llm: LLM, query: str, system_prompt: Optional[str]) -> 'FictionWriter':
+        """
+        Invoke LLM to write a fiction based on the query.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        chat_message_list = []
+        if system_prompt:
+            chat_message_list.append(
+                ChatMessage(
+                    role=MessageRole.SYSTEM,
+                    content=system_prompt,
+                )
+            )
+        
+        chat_message_list.append(ChatMessage(
+            role=MessageRole.USER,
+            content=query
+        ))
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(BookDraft)
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.error(f"FictionWriter failed to chat with LLM: {e}")
+            raise ValueError(f"Failed to chat with LLM: {e}")
+        json_response = json.loads(chat_response.message.content)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        result = FictionWriter(
+            query=query,
+            response=json_response,
+            metadata=metadata
+        )
+        return result    
+
+    def raw_response_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        return d
+
+if __name__ == "__main__":
+    from src.llm_factory import get_llm
+    from src.prompt.prompt_catalog import PromptCatalog
+    import os
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler()
+        ]
+    )
+
+    system_prompt = "You are a fiction writer that has been given a short description to elaborate on."
+    system_prompt = "You are a non-fiction writer that has been given a short description to elaborate on."
+
+    prompt_catalog = PromptCatalog()
+    prompt_catalog.load(os.path.join(os.path.dirname(__file__), 'data', 'simple_fiction_prompts.jsonl'))
+    prompt_item = prompt_catalog.find("0e8e9b9d-95dd-4632-b47c-dcc4625a556d")
+
+    if not prompt_item:
+        raise ValueError("Prompt item not found.")
+    query = prompt_item.prompt
+
+    llm = get_llm("ollama-llama3.1") # works
+    # llm = get_llm("openrouter-paid-gemini-2.0-flash-001") # works
+    # llm = get_llm("ollama-qwen")
+    # llm = get_llm("ollama-phi")
+    # llm = get_llm("deepseek-chat")
+
+    print(f"System: {system_prompt}")
+    print(f"\n\nQuery: {query}")
+    result = FictionWriter.execute(llm, query, system_prompt)
+
+    print("\n\nResponse:")
+    print(json.dumps(result.raw_response_dict(include_query=False), indent=2))

src/format_json_for_use_in_query.py

@@ -0,0 +1,46 @@
+import json
+from typing import Union, Dict, List, Any
+
+# Define a type alias for JSON data that can be either a dict or a list
+JSONType = Union[Dict[str, Any], List[Any]]
+
+def format_json_for_use_in_query(d: JSONType) -> str:
+    """
+    Format a dictionary or list as a JSON string for use in a query.
+    We are not interested in the several unwanted fields if it's a dictionary.
+    """
+    if isinstance(d, dict):
+        # Make a copy to avoid mutating the original data
+        result_dict = d.copy()
+        # Remove unwanted keys if they exist
+        result_dict.pop('metadata', None)
+        result_dict.pop('query', None)
+        result_dict.pop('user_prompt', None)
+        result_dict.pop('system_prompt', None)
+        return json.dumps(result_dict, separators=(',', ':'))
+    elif isinstance(d, list):
+        # If it's a list, simply convert it to a JSON string
+        return json.dumps(d, separators=(',', ':'))
+    else:
+        raise TypeError("Input must be a dictionary or a list")
+
+if __name__ == "__main__":
+    data_dict = {
+        'key1': 'value1',
+        'key2': 'value2',
+        'query': 'long text input from the user',
+        'metadata': {
+            'duration': 42,
+        }
+    }
+    expected_dict = '{"key1":"value1","key2":"value2"}'
+    assert format_json_for_use_in_query(data_dict) == expected_dict
+
+    data_list = [
+        'item1',
+        'item2',
+        'item3',
+    ]
+    expected_list = '["item1","item2","item3"]'
+    assert format_json_for_use_in_query(data_list) == expected_list
+    print('PASSED')

src/llm_factory.py

@@ -0,0 +1,107 @@
+import os
+import json
+from dotenv import dotenv_values
+from typing import Optional, Any, Dict
+from llama_index.core.llms.llm import LLM
+from llama_index.llms.ollama import Ollama
+from llama_index.llms.openai_like import OpenAILike
+from llama_index.llms.together import TogetherLLM
+from llama_index.llms.groq import Groq
+from llama_index.llms.lmstudio import LMStudio
+from llama_index.llms.openrouter import OpenRouter
+
+__all__ = ["get_llm", "get_available_llms"]
+
+# Define paths and load environment variables and config
+_dotenv_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".env"))
+_dotenv_dict = dotenv_values(dotenv_path=_dotenv_path)
+_config_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "llm_config.json"))
+
+
+def load_config(config_path: str) -> Dict[str, Any]:
+    """Loads the configuration from a JSON file."""
+    try:
+        with open(config_path, "r") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"Warning: config.json not found at {config_path}. Using default settings.")
+        return {}
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Error decoding JSON from {config_path}: {e}")
+
+
+_llm_configs = load_config(_config_path)
+
+
+def substitute_env_vars(config: Dict[str, Any], env_vars: Dict[str, str]) -> Dict[str, Any]:
+    """Recursively substitutes environment variables in the configuration."""
+
+    def replace_value(value: Any) -> Any:
+        if isinstance(value, str) and value.startswith("${") and value.endswith("}"):
+            var_name = value[2:-1]  # Extract variable name
+            if var_name in env_vars:
+                return env_vars[var_name]
+            else:
+                print(f"Warning: Environment variable '{var_name}' not found.")
+                return value  # Or raise an error if you prefer strict enforcement
+        return value
+
+    def process_item(item):
+        if isinstance(item, dict):
+            return {k: process_item(v) for k, v in item.items()}
+        elif isinstance(item, list):
+            return [process_item(i) for i in item]
+        else:
+            return replace_value(item)
+
+    return process_item(config)
+
+def get_available_llms() -> list[str]:
+    """
+    Returns a list of available LLM names.
+    """
+    return list(_llm_configs.keys())
+
+def get_llm(llm_name: Optional[str] = None, **kwargs: Any) -> LLM:
+    """
+    Returns an LLM instance based on the config.json file or a fallback default.
+
+    :param llm_name: The name/key of the LLM to instantiate.
+                     If None, falls back to DEFAULT_LLM in .env (or 'ollama-llama3.1').
+    :param kwargs: Additional keyword arguments to override default model parameters.
+    :return: An instance of a LlamaIndex LLM class.
+    """
+    if not llm_name:
+        llm_name = _dotenv_dict.get("DEFAULT_LLM", "ollama-llama3.1")
+
+    if llm_name not in _llm_configs:
+        # If llm_name doesn't exits in _llm_configs, then we go through default settings
+        print(f"Warning: LLM '{llm_name}' not found in config.json. Falling back to hardcoded defaults.")
+        raise ValueError(f"Unsupported LLM name: {llm_name}")
+
+    config = _llm_configs[llm_name]
+    class_name = config.get("class")
+    arguments = config.get("arguments", {})
+
+    # Substitute environment variables
+    arguments = substitute_env_vars(arguments, _dotenv_dict)
+
+    # Override with any kwargs passed to get_llm()
+    arguments.update(kwargs)
+
+    # Dynamically instantiate the class
+    try:
+        llm_class = globals()[class_name]  # Get class from global scope
+        return llm_class(**arguments)
+    except KeyError:
+        raise ValueError(f"Invalid LLM class name in config.json: {class_name}")
+    except TypeError as e:
+        raise ValueError(f"Error instantiating {class_name} with arguments: {e}")
+
+if __name__ == '__main__':
+    try:
+        llm = get_llm(llm_name="ollama-llama3.1")
+        print(f"Successfully loaded LLM: {llm.__class__.__name__}")
+        print(llm.complete("Hello, how are you?"))
+    except ValueError as e:
+        print(f"Error: {e}")

src/plan/README.md

@@ -0,0 +1,4 @@
+# Plan
+
+From a project description, create a project plan.
+

src/plan/app_text2plan.py

@@ -0,0 +1,332 @@
+"""
+PROMPT> python -m src.plan.app_text2plan
+"""
+import gradio as gr
+import os
+import subprocess
+import time
+import sys
+import threading
+from datetime import datetime
+from math import ceil
+from src.llm_factory import get_available_llms
+from src.plan.filenames import FilenameEnum
+from src.plan.plan_file import PlanFile
+from src.plan.speedvsdetail import SpeedVsDetailEnum
+from src.prompt.prompt_catalog import PromptCatalog
+from src.utils.get_env_as_string import get_env_as_string
+from src.utils.time_since_last_modification import time_since_last_modification
+    
+# Global variables
+active_proc = None
+stop_event = threading.Event()
+latest_run_id = None
+latest_run_dir = None
+
+MODULE_PATH_PIPELINE = "src.plan.run_plan_pipeline"
+DEFAULT_PROMPT_UUID = "4dc34d55-0d0d-4e9d-92f4-23765f49dd29"
+
+# The pipeline outputs are stored in a log.txt file in the run directory.
+# So we don't need to relay the process output to the console.
+# Except for debugging purposes, you can set this to True.
+RELAY_PROCESS_OUTPUT = False
+
+prompt_catalog = PromptCatalog()
+prompt_catalog.load(os.path.join(os.path.dirname(__file__), 'data', 'simple_plan_prompts.jsonl'))
+
+# Prefill the input box with the default prompt
+default_prompt_item = prompt_catalog.find(DEFAULT_PROMPT_UUID)
+if default_prompt_item:
+    gradio_default_example = default_prompt_item.prompt
+else:
+    raise ValueError("DEFAULT_PROMPT_UUID prompt not found.")
+
+# Show all prompts in the catalog as examples
+all_prompts = prompt_catalog.all()
+gradio_examples = []
+for prompt_item in all_prompts:
+    gradio_examples.append([prompt_item.prompt])
+
+available_models = get_available_llms()
+available_model_names = [model for model in available_models]
+
+def has_pipeline_complete_file(path_dir: str):
+    """
+    Checks if the pipeline has completed by looking for the completion file.
+    """
+    files = os.listdir(path_dir)
+    return FilenameEnum.PIPELINE_COMPLETE.value in files
+
+class MarkdownBuilder:
+    """
+    Helper class to build Markdown-formatted strings.
+    """
+    def __init__(self):
+        self.rows = []
+
+    def add_line(self, line: str):
+        self.rows.append(line)
+
+    def add_code_block(self, code: str):
+        self.rows.append("```\n" + code + "\n```")
+
+    def status(self, status_message: str):
+        self.add_line(f"### Status")
+        self.add_line(status_message)
+
+    def path_to_run_dir(self, absolute_path_to_run_dir: str):
+        self.add_line(f"### Output dir")
+        self.add_code_block(absolute_path_to_run_dir)
+
+    def list_files(self, path_dir: str):
+        self.add_line(f"### Output files")
+        files = os.listdir(path_dir)
+        files.sort()
+        filenames = "\n".join(files)
+        self.add_code_block(filenames)
+
+    def to_markdown(self):
+        return "\n".join(self.rows)
+    
+def run_planner(submit_or_retry_button: str, plan_prompt: str, llm_model: str, speedvsdetail: str):
+    """
+    This generator function:
+    
+    1. Prepare the run directory.
+    2. Updates environment with RUN_ID and LLM_MODEL.
+    3. Launches the Python pipeline script.
+    5. Polls the output dir (every second) to yield a Markdown-formatted file listing.
+       If a stop is requested or if the pipeline-complete file is detected, it exits.
+    """
+    global active_proc, stop_event, latest_run_dir, latest_run_id
+
+    # Clear any previous stop signal.
+    stop_event.clear()
+
+    submit_or_retry = submit_or_retry_button.lower()
+
+    if submit_or_retry == "retry":
+        if latest_run_id is None:
+            raise ValueError("No previous run to retry. Please submit a plan first.")
+
+        run_id = latest_run_id
+        run_path = os.path.join("run", run_id)
+        absolute_path_to_run_dir = latest_run_dir
+
+        print(f"Retrying the run with ID: {run_id}")
+
+        if not os.path.exists(run_path):
+            raise Exception(f"The run path is supposed to exist from an earlier run. However the no run path exists: {run_path}")
+        
+    elif submit_or_retry == "submit":
+        run_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+        run_path = os.path.join("run", run_id)
+        absolute_path_to_run_dir = os.path.abspath(run_path)
+
+        print(f"Submitting a new run with ID: {run_id}")
+
+        # Update the global variables.
+        latest_run_id = run_id
+        latest_run_dir = absolute_path_to_run_dir
+
+        # Prepare a new run directory.
+        if os.path.exists(run_path):
+            raise Exception(f"The run path is not supposed to exist at this point. However the run path already exists: {run_path}")
+        os.makedirs(run_path)
+
+        # Create the initial plan file.
+        plan_file = PlanFile.create(plan_prompt)
+        plan_file.save(os.path.join(run_path, FilenameEnum.INITIAL_PLAN.value))
+
+    # Set the prompt in the environment so the pipeline can use it.
+    env = os.environ.copy()
+    env["RUN_ID"] = run_id
+    env["LLM_MODEL"] = llm_model
+    env["SPEED_VS_DETAIL"] = speedvsdetail
+
+    start_time = time.perf_counter()
+
+    # Launch the pipeline as a separate Python process.
+    command = [sys.executable, "-m", MODULE_PATH_PIPELINE]
+    print(f"Executing command: {' '.join(command)}")
+    # Spawn threads to print process output to the console.
+    if RELAY_PROCESS_OUTPUT:
+        active_proc = subprocess.Popen(
+            command,
+            cwd=".",
+            env=env,
+            stdout=None,
+            stderr=None
+        )
+    else:
+        active_proc = subprocess.Popen(
+            command,
+            cwd=".",
+            env=env,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+
+    # Obtain process id
+    child_process_id = active_proc.pid
+    print(f"Process started. Process ID: {child_process_id}")
+
+    # Poll the output directory every second.
+    while True:
+        # Check if the process has ended.
+        if active_proc.poll() is not None:
+            break
+
+        # print("running...")
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        # Check if a stop was requested.
+        if stop_event.is_set():
+            try:
+                active_proc.terminate()
+            except Exception as e:
+                print("Error terminating process:", e)
+
+            markdown_builder = MarkdownBuilder()
+            markdown_builder.status("Process terminated by user.")
+            markdown_builder.path_to_run_dir(absolute_path_to_run_dir)
+            markdown_builder.list_files(run_path)
+            yield markdown_builder.to_markdown()
+            break
+
+        last_update = ceil(time_since_last_modification(run_path))
+        markdown_builder = MarkdownBuilder()
+        markdown_builder.status(f"Working. {duration} seconds elapsed. Last output update was {last_update} seconds ago.")
+        markdown_builder.path_to_run_dir(absolute_path_to_run_dir)
+        markdown_builder.list_files(run_path)
+        yield markdown_builder.to_markdown()
+
+        # If the pipeline complete file is found, finish streaming.
+        if has_pipeline_complete_file(run_path):
+            break
+
+        time.sleep(1)
+
+    # Wait for the process to end (if it hasn't already) and clear our global.
+    returncode = 'NOT SET'
+    if active_proc is not None:
+        active_proc.wait()
+        returncode = active_proc.returncode
+        active_proc = None
+
+    # Process has completed.
+    end_time = time.perf_counter()
+    duration = int(ceil(end_time - start_time))
+    print(f"Process ended. returncode: {returncode}. Process ID: {child_process_id}. Duration: {duration} seconds.")
+
+    if has_pipeline_complete_file(run_path):
+        status_message = "Completed."
+    else:
+        status_message = "Stopped prematurely, the output may be incomplete."
+
+    # Final file listing update.
+    markdown_builder = MarkdownBuilder()
+    markdown_builder.status(f"{status_message} {duration} seconds elapsed.")
+    markdown_builder.path_to_run_dir(absolute_path_to_run_dir)
+    markdown_builder.list_files(run_path)
+    yield markdown_builder.to_markdown()
+
+def stop_planner():
+    """
+    Sets a global stop flag and, if there is an active process, attempts to terminate it.
+    Returns a status message.
+    """
+    global active_proc, stop_event
+    stop_event.set()
+    if active_proc is not None:
+        try:
+            if active_proc.poll() is None:  # Process is still running.
+                active_proc.terminate()
+            return "Stop signal sent. Process termination requested."
+        except Exception as e:
+            return f"Error terminating process: {e}"
+    else:
+        return "No active process to stop."
+
+def open_output_dir():
+    """
+    Opens the latest output directory in the native file explorer.
+    """
+    if not latest_run_dir or not os.path.exists(latest_run_dir):
+        return "No output directory available."
+    
+    try:
+        if sys.platform == "darwin":  # macOS
+            subprocess.Popen(["open", latest_run_dir])
+        elif sys.platform == "win32":  # Windows
+            subprocess.Popen(["explorer", latest_run_dir])
+        else:  # Assume Linux or other unix-like OS
+            subprocess.Popen(["xdg-open", latest_run_dir])
+        return f"Opened the directory: {latest_run_dir}"
+    except Exception as e:
+        return f"Failed to open directory: {e}"
+
+# Build the Gradio UI using Blocks.
+with gr.Blocks(title="PlanExe") as demo:
+    gr.Markdown("# PlanExe: crack open pandora’s box of ideas")
+    with gr.Tab("Main"):
+        with gr.Row():
+            with gr.Column(scale=2, min_width=300):
+                prompt_input = gr.Textbox(
+                    label="Plan Description",
+                    lines=5,
+                    placeholder="Enter a description of your plan...",
+                    value=gradio_default_example
+                )
+                with gr.Row():
+                    submit_btn = gr.Button("Submit", variant='primary')
+                    stop_btn = gr.Button("Stop")
+                    retry_btn = gr.Button("Retry")
+                    open_dir_btn = gr.Button("Open Output Dir")
+
+                output_markdown = gr.Markdown("Output will appear here...")
+                status_markdown = gr.Markdown("Status messages will appear here...")
+
+            with gr.Column(scale=1, min_width=300):
+                examples = gr.Examples(
+                    examples=gradio_examples,
+                    inputs=[prompt_input],
+                )
+
+    with gr.Tab("Settings"):
+        model_radio = gr.Radio(
+            available_model_names,
+            value=available_model_names[0],
+            label="Model",
+            interactive=True 
+        )
+
+        speedvsdetail_items = [
+            ("All details, but slow", SpeedVsDetailEnum.ALL_DETAILS_BUT_SLOW),
+            ("Fast, but few details", SpeedVsDetailEnum.FAST_BUT_SKIP_DETAILS),
+        ]
+        speedvsdetail_radio = gr.Radio(
+            speedvsdetail_items,
+            value=SpeedVsDetailEnum.ALL_DETAILS_BUT_SLOW,
+            label="Speed vs Detail",
+            interactive=True 
+        )
+
+    with gr.Tab("Join the community"):
+        gr.Markdown("""
+- [GitHub](https://github.com/neoneye/PlanExe) the source code.
+- [Discord](https://neoneye.github.io/PlanExe-web/discord) join the community. Suggestions, feedback, and questions are welcome.
+""")
+
+    # Start the planning assistant with streaming updates.
+    submit_btn.click(fn=run_planner, inputs=[submit_btn, prompt_input, model_radio, speedvsdetail_radio], outputs=output_markdown)
+    # The stop button simply calls stop_planner and displays its status message.
+    stop_btn.click(fn=stop_planner, outputs=status_markdown)
+    retry_btn.click(fn=run_planner, inputs=[retry_btn, prompt_input, model_radio, speedvsdetail_radio], outputs=output_markdown)
+    open_dir_btn.click(fn=open_output_dir, outputs=status_markdown)
+
+# print("Environment variables Gradio:\n" + get_env_as_string() + "\n\n\n")
+
+print("Press Ctrl+C to exit.")
+demo.launch()

src/plan/create_pitch.py

@@ -0,0 +1,151 @@
+"""
+Create a pitch for this project.
+"""
+import os
+import json
+import time
+from math import ceil
+from typing import List, Optional
+from uuid import uuid4
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+class ProjectPitch(BaseModel):
+    pitch: str = Field(
+        description="A compelling pitch for this project."
+    )
+    why_this_pitch_works: str = Field(
+        description="Explanation why this pitch works."
+    )
+    target_audience: str = Field(
+        description="Who this pitch is aimed at, such as investors, stakeholders, or the general public."
+    )
+    call_to_action: str = Field(
+        description="A clear next step for the audience to engage with the project."
+    )
+    risks_and_mitigation: str = Field(
+        description="Address potential challenges and demonstrate readiness to handle them."
+    )
+    metrics_for_success: str = Field(
+        description="Define how the success of the project will be measured beyond its goals."
+    )
+    stakeholder_benefits: str = Field(
+        description="Explicitly state what stakeholders gain from supporting or being involved in the project."
+    )
+    ethical_considerations: str = Field(
+        description="Build trust by showing a commitment to ethical practices."
+    )
+    collaboration_opportunities: str = Field(
+        description="Highlight ways other organizations or individuals can partner with the project."
+    )
+    long_term_vision: str = Field(
+        description="Show the broader impact and sustainability of the project."
+    )
+
+QUERY_PREAMBLE = f"""
+Craft a compelling pitch for this project that starts with an attention-grabbing hook, 
+presents its purpose clearly, and highlights the benefits or value it brings. Use a tone 
+that conveys enthusiasm and aligns with the goals and values of the intended audience, 
+emphasizing why this project matters and how it stands out.
+
+"""
+
+@dataclass
+class CreatePitch:
+    query: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def format_query(cls, plan_json: dict, wbs_level1_json: dict, wbs_level2_json: list) -> str:
+        """
+        Format the query for creating project pitch.
+        """
+        if not isinstance(plan_json, dict):
+            raise ValueError("Invalid plan_json.")
+        if not isinstance(wbs_level1_json, dict):
+            raise ValueError("Invalid wbs_level1_json.")
+        if not isinstance(wbs_level2_json, list):
+            raise ValueError("Invalid wbs_level2_json.")
+
+        query = f"""
+The project plan:
+{format_json_for_use_in_query(plan_json)}
+
+WBS Level 1:
+{format_json_for_use_in_query(wbs_level1_json)}
+
+WBS Level 2:
+{format_json_for_use_in_query(wbs_level2_json)}
+"""
+        return query
+    
+    @classmethod
+    def execute(cls, llm: LLM, query: str) -> 'CreatePitch':
+        """
+        Invoke LLM to create a project pitch.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(ProjectPitch)
+        response = sllm.complete(QUERY_PREAMBLE + query)
+        json_response = json.loads(response.text)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        result = CreatePitch(
+            query=query,
+            response=json_response,
+            metadata=metadata,
+        )
+        return result
+
+    def raw_response_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        return d
+
+if __name__ == "__main__":
+    from llama_index.llms.ollama import Ollama
+
+    # TODO: Eliminate hardcoded paths
+    basepath = '/Users/neoneye/Desktop/planexe_data'
+
+    def load_json(relative_path: str) -> dict:
+        path = os.path.join(basepath, relative_path)
+        print(f"loading file: {path}")
+        with open(path, 'r', encoding='utf-8') as f:
+            the_json = json.load(f)
+        return the_json
+
+    plan_json = load_json('002-project_plan.json')
+    wbs_level1_json = load_json('004-wbs_level1.json')
+    wbs_level2_json = load_json('005-wbs_level2.json')
+
+    model_name = "llama3.1:latest"
+    # model_name = "qwen2.5-coder:latest"
+    # model_name = "phi4:latest"
+    llm = Ollama(model=model_name, request_timeout=120.0, temperature=0.5, is_function_calling_model=False)
+
+    query = CreatePitch.format_query(plan_json, wbs_level1_json, wbs_level2_json)
+    print(f"Query: {query}")
+    result = CreatePitch.execute(llm, query)
+
+    print("\nResponse:")
+    json_response = result.raw_response_dict(include_query=False)
+    print(json.dumps(json_response, indent=2))

src/plan/create_project_plan.py

@@ -0,0 +1,311 @@
+"""
+PROMPT> python -m src.plan.create_project_plan
+
+Based on a vague description, the creates a rough draft for a project plan.
+"""
+import json
+import time
+import logging
+from math import ceil
+from typing import List, Optional, Any, Type, TypeVar
+from dataclasses import dataclass
+from pydantic import BaseModel, Field, ValidationError
+from llama_index.core.llms.llm import LLM
+from llama_index.core.llms import ChatMessage, MessageRole
+
+logger = logging.getLogger(__name__)
+
+class SMARTCriteria(BaseModel):
+    specific: str = Field(
+        description="Clearly defines what is to be accomplished. Provides context and purpose behind the goal. Avoid vagueness, unrealistic targets, broad statements that lack direction."
+    )
+    measurable: str = Field(
+        description="Establish how you will measure success. This could be quantitative (e.g., numbers, percentages) or qualitative (e.g., satisfaction levels). Without clear metrics, it’s difficult to track progress or determine success."
+    )
+    achievable: str = Field(
+        description="Realism: Ensures the goal is attainable with the available resources and within constraints. Feasibility: Considers practical aspects such as time, budget, and expertise."
+    )
+    relevant: str = Field(
+        description="Alignment: Connects the goal to broader objectives or missions. Importance: Highlights the significance and impact of achieving the goal."
+    )
+    time_bound: str = Field(
+        description="Deadline: Specifies a clear timeframe for goal completion. Milestones: Breaks down the timeline into smaller, manageable phases if necessary."
+    )
+
+class RiskAssessmentAndMitigationStrategies(BaseModel):
+    """
+    By systematically identifying, analyzing, and addressing risks, you enhance the project 
+    resilience and increase the likelihood of achieving sustainable and long-term success.
+    """
+    key_risks: list[str] = Field(
+        description="Things that can negatively impact the project, such as regulatory changes, financial uncertainties, technological failures, supply chain disruptions and environmental challenges."
+    )
+    diverse_risks: list[str] = Field(
+        description="Things that can negatively impact the project, such as operational risks, systematic risks, business risks."
+    )
+    mitigation_plans: list[str] = Field(
+        description="Develop strategies to minimize or manage these risks, ensuring the project remains on track despite unforeseen obstacles."
+    )
+
+class StakeholderAnalysis(BaseModel):
+    """
+    Understanding the interests, expectations, and concerns of stakeholders is essential for building
+    strong relationships, securing support, and ensuring project success.
+    """
+    primary_stakeholders: list[str] = Field(
+        description="List all key stakeholders, including government agencies, local communities, investors, suppliers, and end-users."
+    )
+    secondary_stakeholders: list[str] = Field(
+        description="List all secondary stakeholders, such as regulatory bodies, environmental groups, and suppliers."
+    )
+    engagement_strategies: list[str] = Field(
+        description="Outline how each stakeholder group will be engaged, their roles, and how their interests will be addressed to secure support and collaboration."
+    )
+
+class RegulatoryAndComplianceRequirements(BaseModel):
+    """
+    Detailed overview of the regulatory and compliance requirements necessary for the project.
+    Ensures the project operates within legal frameworks and adheres to all necessary standards.
+    """
+    permits_and_licenses: list[str] = Field(
+        description="List of permits and licenses required at local, regional, and national levels. Such as Building Permit, Cave Exploration Permit, Hazardous Materials Handling Permit."
+    )
+    compliance_standards: list[str] = Field(
+        description="Ensure adherence to environmental, safety, and industry-specific standards and regulations."
+    )
+    regulatory_bodies: list[str] = Field(
+        description="List of regulatory bodies and their roles in the project's compliance landscape. Such as International Energy Agency, International Maritime Organization, World Health Organization."
+    )
+    compliance_actions: list[str] = Field(
+        description="List with actions and steps taken to ensure compliance with all relevant regulations and standards. Example: ['Building and Electrical Codes', 'Wildlife Protection', 'Fire safety measures', 'Biosafety Regulations', 'Radiation Safety']."
+    )
+    
+class GoalDefinition(BaseModel):
+    """
+    A clear, specific, and actionable statement that outlines what you aim to achieve.
+    A well-defined goal serves as a foundation for effective planning, problem decomposition, and team assembly.
+    """
+    goal_statement: str = Field(
+        description="Adhering to the SMART criteria (Specific, Measurable, Achievable, Relevant, Time-bound)"
+    )
+    smart_criteria: SMARTCriteria = Field(
+        description="Details of the SMART criteria."
+    )
+    dependencies: list[str] = Field(
+        description="Other goals or tasks that must be completed before this goal can be achieved. Example: ['Securing funding for equipment and personnel', 'Obtaining necessary permits for cave exploration']."
+    )
+    resources_required: list[str] = Field(
+        description="Resources necessary to achieve the goal. Example: ['Cave exploration gear', 'Biological sampling tools']."
+    )
+    related_goals: list[str] = Field(
+        description="Other goals that are related or interconnected. Facilitates understanding of goal interdependencies and broader objectives."
+    )
+    tags: list[str] = Field(
+        description="Keywords or labels associated with the goal. Enhances searchability and categorization, making it easier to filter and find goals based on keywords. Example: ['Extremophiles', 'DNA Sequencing', 'Microbial Life']."
+    )
+    risk_assessment_and_mitigation_strategies: RiskAssessmentAndMitigationStrategies = Field(
+        description="Identify potential risks and develop strategies to mitigate them, ensuring the goal remains achievable despite unforeseen challenges."
+    )
+    stakeholder_analysis: StakeholderAnalysis = Field(
+        description="Analyze key stakeholders, their interests, and engagement strategies to secure support and collaboration for goal achievement."
+    )
+    regulatory_and_compliance_requirements: RegulatoryAndComplianceRequirements = Field(
+        description="Ensure compliance with all regulatory and legal requirements, including permits, licenses, and industry-specific standards."
+    )
+
+CREATE_PROJECT_PLAN_SYSTEM_PROMPT_1 = """
+You are an expert project planner tasked with creating comprehensive and detailed project plans based on user-provided descriptions. Your output must be a complete JSON object conforming to the provided GoalDefinition schema. Focus on being specific and actionable, generating a plan that is realistic and useful for guiding project development.
+Your plans must include:
+- A clear goal statement adhering to the SMART criteria (Specific, Measurable, Achievable, Relevant, Time-bound). Provide specific metrics and timeframes where possible.
+- A breakdown of dependencies and required resources for the project.
+- A clear identification of related goals and future applications.
+- A detailed risk assessment with specific mitigation strategies. Focus on actionable items to mitigate the risks you have identified.
+- A comprehensive stakeholder analysis, identifying primary and secondary stakeholders, and outlining engagement strategies.
+- A detailed overview of regulatory and compliance requirements, such as permits and licenses, and how compliance actions are planned.
+- Tags or keywords that allow users to easily find and categorize the project.
+Prioritize feasibility, practicality, and alignment with the user-provided description. Ensure the plan is actionable, with concrete steps where possible and measurable outcomes.
+"""
+
+CREATE_PROJECT_PLAN_SYSTEM_PROMPT_2 = """
+You are an expert project planner tasked with creating comprehensive and detailed project plans based on user-provided descriptions. Your output must be a complete JSON object conforming to the provided GoalDefinition schema. Focus on being specific and actionable, generating a plan that is realistic and useful for guiding project development.
+
+Your plans must include:
+- A clear goal statement adhering to the SMART criteria (Specific, Measurable, Achievable, Relevant, Time-bound). Provide specific metrics and timeframes where possible.
+- A breakdown of dependencies and required resources for the project. Break down dependencies into actionable sub-tasks where applicable.
+- A clear identification of related goals and future applications.
+- A detailed risk assessment with specific mitigation strategies. Focus on actionable items to mitigate the risks you have identified, ensuring they are tailored to the project's context.
+- A comprehensive stakeholder analysis, identifying primary and secondary stakeholders, and outlining engagement strategies.
+  - **Primary Stakeholders:** Identify key roles or individuals directly responsible for executing the project. For small-scale or personal projects, this may simply be the person performing the task (e.g., "Coffee Brewer"). For large-scale projects, identify domain-specific roles (e.g., "Construction Manager," "Life Support Systems Engineer").
+  - **Secondary Stakeholders:** Identify external parties or collaborators relevant to the project. For small-scale projects, this may include suppliers or individuals indirectly affected by the project (e.g., "Coffee Supplier," "Household Members"). For large-scale projects, include regulatory bodies, material suppliers, or other external entities.
+  - **Note:** Do not assume the availability or involvement of any specific individuals unless explicitly stated in the user-provided description.
+- A detailed overview of regulatory and compliance requirements, such as permits and licenses, and how compliance actions are planned.
+- Tags or keywords that allow users to easily find and categorize the project.
+
+**Adaptive Behavior:**
+- Automatically adjust the level of detail and formality based on the scale and complexity of the project. For small-scale or personal projects, keep the plan simple and practical. For large-scale or complex projects, include more detailed and formal elements.
+- Infer the appropriate stakeholders, risks, and resources based on the project's domain and context. Avoid overly formal or mismatched roles unless explicitly required by the project's context.
+
+Prioritize feasibility, practicality, and alignment with the user-provided description. Ensure the plan is actionable, with concrete steps where possible and measurable outcomes.
+"""
+
+CREATE_PROJECT_PLAN_SYSTEM_PROMPT_3 = """
+You are an expert project planner tasked with creating comprehensive and detailed project plans based on user-provided descriptions. Your output must be a complete JSON object conforming to the provided GoalDefinition schema. Focus on being specific and actionable, generating a plan that is realistic and useful for guiding project development.
+
+Your plans must include:
+- A clear goal statement adhering to the SMART criteria (Specific, Measurable, Achievable, Relevant, Time-bound). Provide specific metrics and timeframes where possible. For the time-bound, only use "Today" for simple, short duration tasks.
+    -Ensure the SMART criteria is high-level, and based directly on the goal statement, and the user description.
+        - The **Specific** criteria should clarify what is to be achieved with the goal, and must directly reflect the goal statement, and must not imply any specific actions or processes.
+        - The **Measurable** criteria should define how you will know if the goal has been achieved. It should be a metric or some other way of validating that the goal is complete, and must not include implied actions or steps.
+        - The **Achievable** criteria should explain why the goal is achievable given the information provided by the user. It should specify any limitations or benefits.
+        - The **Relevant** criteria should specify why this goal is necessary, or what value it provides.
+        - The **Time-bound** criteria must specify when the goal must be achieved. For small tasks, this will be "Today". For larger tasks, the time-bound should be a general time estimate, and should not specify a specific date or time unless it has been specified by the user.
+- A breakdown of dependencies and required resources for the project. Break down dependencies into actionable sub-tasks where applicable. Dependencies should be high-level, and not overly prescriptive, nor should they imply specific actions. Only include dependencies that are explicitly mentioned in the user description or directly implied from it. Do not include any specific timestamps, volumes, quantities or implied resources in the dependencies section, and do not include inferred actions.
+- A clear identification of related goals and future applications.
+- A detailed risk assessment with specific mitigation strategies. Focus on actionable items to mitigate the risks you have identified, ensuring they are tailored to the project's context.
+    - When identifying risks, consider common issues specific to the project's domain (e.g., construction delays, equipment failures, safety hazards, financial issues, security breaches, data losses). For each identified risk, generate a realistic and specific mitigation strategy that is actionable within the project's context. Try to extract risks based on user descriptions. Avoid being too specific, and avoid adding unrealistic risks and mitigation actions. Only include mitigation plans that are explicitly derived from the user description, or are implied from it.
+- A comprehensive stakeholder analysis, identifying primary and secondary stakeholders, and outlining engagement strategies.
+  - **Primary Stakeholders:** Identify key roles or individuals directly responsible for executing the project. For small-scale or personal projects, this may simply be the person performing the task (e.g., "Coffee Brewer"). For large-scale projects, identify domain-specific roles (e.g., "Construction Manager," "Life Support Systems Engineer").
+  - **Secondary Stakeholders:** Identify external parties or collaborators relevant to the project. For small-scale projects, this may include suppliers or individuals indirectly affected by the project (e.g., "Coffee Supplier," "Household Members"). For large-scale projects, include regulatory bodies, material suppliers, or other external entities.
+    - When outlining engagement strategies for stakeholders, consider the nature of the project and their roles. Primary stakeholders should have regular updates and progress reports, and requests for information should be answered promptly. Secondary stakeholders may require updates on key milestones, reports for compliance, or timely notification of significant changes to project scope or timeline. For smaller projects, the engagement strategy and stakeholders can be omitted if they are not explicitly mentioned in the user description, or implied from it.
+  - **Note:** Do not assume the availability or involvement of any specific individuals beyond those directly mentioned in the user-provided project description. Generate all information independently from the provided description, and do not rely on any previous data or information from prior runs of this tool. Do not include any default information unless explicitly stated.
+- A detailed overview of regulatory and compliance requirements, such as permits and licenses, and how compliance actions are planned.
+    - When considering regulatory and compliance requirements, identify any specific licenses or permits needed, and include compliance actions in the plan, such as "Apply for permit X", "Schedule compliance audit" and "Implement compliance plan for Y", and ensure compliance actions are included in the project timeline. For smaller projects, the regulatory compliance section can be omitted.
+- Tags or keywords that allow users to easily find and categorize the project.
+Adaptive Behavior:
+- Automatically adjust the level of detail and formality based on the scale and complexity of the project. For small-scale or personal projects, keep the plan simple and avoid formal elements. For massive or complex projects, ensure plans include more formal elements, such as project charters or work breakdown structures, and provide detailed actions for project execution.
+- Infer the appropriate stakeholders, risks, and resources based on the project's domain and context. Avoid overly formal or mismatched roles unless explicitly required by the project's context.
+- For smaller tasks, only include resources that need to be purchased or otherwise explicitly acquired. Only include resources that are mentioned in the user description, or implied from it. Do not include personnel or stakeholders as a resource.
+- Only include dependencies that are explicitly mentioned in the user description, or directly implied from it.
+Prioritize feasibility, practicality, and alignment with the user-provided description. Ensure the plan is actionable, with concrete steps where possible and measurable outcomes.
+When breaking down dependencies into sub-tasks, specify concrete actions (e.g., "Procure X", "Design Y", "Test Z"), and if possible, include resource requirements (e.g., "Procure 100 Units of X") and estimated timeframes where appropriate. However, for very small, simple tasks, the dependencies do not need a time element, and do not have to be overly specific.
+
+Here's an example of the expected output format for a simple project:
+{
+  "goal_statement": "Make a cup of coffee.",
+  "smart_criteria": {
+    "specific": "Prepare a cup of instant coffee, with milk and sugar if available.",
+    "measurable": "The completion of the task can be measured by the existence of a prepared cup of coffee.",
+    "achievable": "The task is achievable in the user's kitchen.",
+    "relevant": "The task will provide the user with a warm drink.",
+    "time_bound": "The task should be completed in 5 minutes."
+  },
+  "dependencies": [],
+  "resources_required": [ "instant coffee" ],
+  "related_goals": [ "satisfy hunger", "enjoy a drink" ],
+  "tags": [ "drink", "coffee", "simple" ]
+}
+"""
+
+CREATE_PROJECT_PLAN_SYSTEM_PROMPT = CREATE_PROJECT_PLAN_SYSTEM_PROMPT_3
+
+T = TypeVar('T', bound=BaseModel)
+
+@dataclass
+class CreateProjectPlan:
+    """
+    Creating a project plan from a vague description.
+    """
+    system_prompt: str
+    user_prompt: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def execute(cls, llm: LLM, user_prompt: str) -> 'CreateProjectPlan':
+        """
+        Invoke LLM to create project plan from a vague description.
+
+        :param llm: An instance of LLM.
+        :param user_prompt: A vague description of the project.
+        :return: An instance of CreateProjectPlan.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(user_prompt, str):
+            raise ValueError("Invalid user_prompt.")
+
+        system_prompt = CREATE_PROJECT_PLAN_SYSTEM_PROMPT.strip()
+        logger.debug(f"System Prompt:\n{system_prompt}")
+        logger.debug(f"User Prompt:\n{user_prompt}")
+
+        chat_message_list = [
+            ChatMessage(
+                role=MessageRole.SYSTEM,
+                content=system_prompt,
+            ),
+            ChatMessage(
+                role=MessageRole.USER,
+                content=user_prompt,
+            )
+        ]
+        
+        sllm = llm.as_structured_llm(GoalDefinition)
+
+        logger.debug("Starting LLM chat interaction.")
+        start_time = time.perf_counter()
+        try:
+            chat_response = sllm.chat(chat_message_list)
+        except Exception as e:
+            logger.debug(f"LLM chat interaction failed: {e}")
+            logger.error("LLM chat interaction failed.", exc_info=True)
+            raise ValueError("LLM chat interaction failed.") from e
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+        response_byte_count = len(chat_response.message.content.encode('utf-8'))
+        logger.info(f"LLM chat interaction completed in {duration} seconds. Response byte count: {response_byte_count}")
+
+        json_response = chat_response.raw.model_dump()
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["response_byte_count"] = response_byte_count
+
+        result = CreateProjectPlan(
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            response=json_response,
+            metadata=metadata
+        )
+        logger.debug("CreateProjectPlan instance created successfully.")
+        return result
+        
+    def to_dict(self, include_metadata=True, include_user_prompt=True, include_system_prompt=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_user_prompt:
+            d['user_prompt'] = self.user_prompt
+        if include_system_prompt:
+            d['system_prompt'] = self.system_prompt
+        return d
+
+    def save(self, file_path: str) -> None:
+        d = self.to_dict()
+        with open(file_path, 'w') as f:
+            f.write(json.dumps(d, indent=2))
+
+if __name__ == "__main__":
+    import logging
+    from src.llm_factory import get_llm
+    from src.plan.find_plan_prompt import find_plan_prompt
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        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")
+
+    print(f"Query:\n{plan_prompt}\n\n")
+    result = CreateProjectPlan.execute(llm, plan_prompt)
+    json_response = result.to_dict(include_system_prompt=False, include_user_prompt=False)
+    print(json.dumps(json_response, indent=2))

src/plan/create_wbs_level1.py

@@ -0,0 +1,120 @@
+"""
+WBS Level 1: Create a Work Breakdown Structure (WBS) from a project plan.
+
+https://en.wikipedia.org/wiki/Work_breakdown_structure
+"""
+import os
+import json
+import time
+from math import ceil
+from typing import List, Optional
+from uuid import uuid4
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+
+class WBSLevel1(BaseModel):
+    """
+    Represents the top-level details of a Work Breakdown Structure (WBS)
+    """
+    project_title: str = Field(
+        description="A clear, overarching title that conveys the primary objective of the project. Serves as the projects strategic anchor, guiding all subsequent tasks and deliverables."
+    )
+    final_deliverable: str = Field(
+        description="A detailed description of the projects ultimate outcome or product upon completion. Clearly states the final state or result that the team aims to achieve."
+    )
+
+QUERY_PREAMBLE = f"""
+The task here:
+Create a work breakdown structure level 1 for this project.
+
+Focus on providing the following:
+- 'project_title': A 1- to 3-word name, extremely concise.
+- 'final_deliverable': A 1- to 3-word result, extremely concise.
+
+The project plan:
+"""
+
+
+@dataclass
+class CreateWBSLevel1:
+    """
+    WBS Level 1: Creating a Work Breakdown Structure (WBS) from a project plan.
+    """
+    query: str
+    response: dict
+    metadata: dict
+    id: str
+    project_title: str
+    final_deliverable: str
+
+    @classmethod
+    def execute(cls, llm: LLM, query: str) -> 'CreateWBSLevel1':
+        """
+        Invoke LLM to create a Work Breakdown Structure (WBS) from a json representation of a project plan.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(WBSLevel1)
+        response = sllm.complete(QUERY_PREAMBLE + query)
+        json_response = json.loads(response.text)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+        metadata["query"] = query
+
+        project_id = str(uuid4())
+        result = CreateWBSLevel1(
+            query=query,
+            response=json_response,
+            metadata=metadata,
+            id=project_id,
+            project_title=json_response['project_title'],
+            final_deliverable=json_response['final_deliverable']
+        )
+        return result
+    
+    def raw_response_dict(self, include_metadata=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        return d
+    
+    def cleanedup_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "project_title": self.project_title,
+            "final_deliverable": self.final_deliverable
+        }
+
+if __name__ == "__main__":
+    from llama_index.llms.ollama import Ollama
+    # TODO: Eliminate hardcoded paths
+    path = '/Users/neoneye/Desktop/planexe_data/plan.json'
+
+    print(f"file: {path}")
+    with open(path, 'r', encoding='utf-8') as f:
+        plan_json = json.load(f)
+
+    if 'metadata' in plan_json:
+        del plan_json['metadata']
+
+    model_name = "llama3.1:latest"
+    # model_name = "qwen2.5-coder:latest"
+    # model_name = "phi4:latest"
+    llm = Ollama(model=model_name, request_timeout=120.0, temperature=0.5, is_function_calling_model=False)
+
+    query = json.dumps(plan_json, indent=2)
+    print(f"\nQuery: {query}")
+    result = CreateWBSLevel1.execute(llm, query)
+    print("\n\nResult:")
+    print(json.dumps(result.raw_response_dict(), indent=2))

src/plan/create_wbs_level2.py

@@ -0,0 +1,192 @@
+"""
+WBS Level 2: Create a Work Breakdown Structure (WBS) from a project plan.
+
+https://en.wikipedia.org/wiki/Work_breakdown_structure
+
+Focus is on the "Process style". 
+Focus is not on the "product style".
+"""
+import os
+import json
+import time
+from math import ceil
+from typing import List, Optional
+from uuid import uuid4
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+class SubtaskDetails(BaseModel):
+    subtask_wbs_number: str = Field(
+        description="The unique identifier assigned to each subtask. Example: ['1.', '2.', '3.', '6.2.2', '6.2.3', '6.2.4', 'Subtask 5:', 'Subtask 6:', 'S3.', 'S4.']."
+    )
+    subtask_title: str = Field(
+        description="Start with a verb to clearly indicate the action required. Example: ['Secure funding', 'Obtain construction permits', 'Electrical installation', 'Commissioning and handover']."
+    )
+
+class MajorPhaseDetails(BaseModel):
+    """
+    A major phase in the project decomposed into smaller tasks.
+    """
+    major_phase_wbs_number: str = Field(
+        description="The unique identifier assigned to each major phase. Example: ['1.', '2.', '3.', 'Phase 1:', 'Phase 2:', 'P1.', 'P2.']."
+    )
+    major_phase_title: str = Field(
+        description="Action-oriented title of this primary phase of the project. Example: ['Project Initiation', 'Procurement', 'Construction', 'Operation and Maintenance']."
+    )
+    subtasks: list[SubtaskDetails] = Field(
+        description="List of the subtasks or activities."
+    )
+
+class WorkBreakdownStructure(BaseModel):
+    """
+    The Work Breakdown Structure (WBS) is a hierarchical decomposition of the total scope of work to accomplish project objectives.
+    It organizes the project into smaller, more manageable components.
+    """
+    major_phase_details: list[MajorPhaseDetails] = Field(
+        description="List with each major phase broken down into subtasks or activities."
+    )
+
+QUERY_PREAMBLE = f"""
+Create a work breakdown structure level 2 for this project.
+
+A task can always be broken down into smaller, more manageable subtasks.
+
+"""
+
+@dataclass
+class CreateWBSLevel2:
+    """
+    WBS Level 2: Creating a Work Breakdown Structure (WBS) from a project plan.
+    """
+    query: str
+    response: dict
+    metadata: dict
+    major_phases_with_subtasks: list[dict]
+    major_phases_uuids: list[str]
+    task_uuids: list[str]
+
+    @classmethod
+    def format_query(cls, plan_json: dict, wbs_level1_json: dict) -> str:
+        """
+        Format the query for creating a Work Breakdown Structure (WBS) level 2.
+        """
+        if not isinstance(plan_json, dict):
+            raise ValueError("Invalid plan_json.")
+        if not isinstance(wbs_level1_json, dict):
+            raise ValueError("Invalid wbs_level1_json.")
+        
+        # Having a uuid in the WBS Level 1 data trend to confuse the LLM, causing the LLM to attempt to insert all kinds of ids in the response.
+        # Removing the id from the WBS Level 1 data, and there is less confusion about what the LLM should do.
+        wbs_level1_json_without_id = wbs_level1_json.copy()
+        wbs_level1_json_without_id.pop("id", None)
+
+        query = f"""
+The project plan:
+{format_json_for_use_in_query(plan_json)}
+
+WBS Level 1:
+{format_json_for_use_in_query(wbs_level1_json_without_id)}
+"""
+        return query
+    
+    @classmethod
+    def execute(cls, llm: LLM, query: str) -> 'CreateWBSLevel2':
+        """
+        Invoke LLM to create a Work Breakdown Structure (WBS) from a json representation of a project plan.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(WorkBreakdownStructure)
+        response = sllm.complete(QUERY_PREAMBLE + query)
+        json_response = json.loads(response.text)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        # Cleanup the json response from the LLM model, assign unique ids to each activity.
+        result_major_phases_with_subtasks = []
+        result_major_phases_uuids = []
+        result_task_uuids = []
+        for major_phase_detail in json_response['major_phase_details']:
+            subtask_list = []
+            for subtask in major_phase_detail['subtasks']:
+                subtask_title = subtask['subtask_title']
+                uuid = str(uuid4())
+                subtask_item = {
+                    "id": uuid,
+                    "description": subtask_title,
+                }
+                subtask_list.append(subtask_item)
+                result_task_uuids.append(uuid)
+
+            uuid = str(uuid4())
+            major_phase_item = {
+                "id": uuid,
+                "major_phase_title": major_phase_detail['major_phase_title'],
+                "subtasks": subtask_list,
+            }
+            result_major_phases_with_subtasks.append(major_phase_item)
+            result_major_phases_uuids.append(uuid)
+
+        result = CreateWBSLevel2(
+            query=query,
+            response=json_response,
+            metadata=metadata,
+            major_phases_with_subtasks=result_major_phases_with_subtasks,
+            major_phases_uuids=result_major_phases_uuids,
+            task_uuids=result_task_uuids
+        )
+        return result
+
+    def raw_response_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        return d
+    
+if __name__ == "__main__":
+    from llama_index.llms.ollama import Ollama
+
+    # TODO: Eliminate hardcoded paths
+    path = '/Users/neoneye/Desktop/planexe_data/plan.json'
+
+    wbs_level1_json = {
+        "id": "d0169227-bf29-4a54-a898-67d6ff4d1193",
+        "project_title": "Establish a solar farm in Denmark",
+        "final_deliverable": "Solar farm operational",
+    }
+
+    print(f"file: {path}")
+    with open(path, 'r', encoding='utf-8') as f:
+        plan_json = json.load(f)
+
+    query = CreateWBSLevel2.format_query(plan_json, wbs_level1_json)
+
+    model_name = "llama3.1:latest"
+    # model_name = "qwen2.5-coder:latest"
+    # model_name = "phi4:latest"
+    llm = Ollama(model=model_name, request_timeout=120.0, temperature=0.5, is_function_calling_model=False)
+
+    print(f"Query: {query}")
+    result = CreateWBSLevel2.execute(llm, query)
+
+    print("Response:")
+    response_dict = result.raw_response_dict(include_query=False)
+    print(json.dumps(response_dict, indent=2))
+
+    print("\n\nExtracted result:")
+    print(json.dumps(result.major_phases_with_subtasks, indent=2))
+

src/plan/create_wbs_level3.py

@@ -0,0 +1,192 @@
+"""
+WBS Level 3: Create a Work Breakdown Structure (WBS) from a project plan.
+
+https://en.wikipedia.org/wiki/Work_breakdown_structure
+
+The "progressive elaboration" technique is used to decompose big tasks into smaller, more manageable subtasks.
+"""
+import os
+import json
+import time
+from dataclasses import dataclass
+from math import ceil
+from typing import List, Optional
+from uuid import uuid4
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+class WBSSubtask(BaseModel):
+    """
+    A subtask.
+    """
+    name: str = Field(
+        description="Short name of the subtask, such as: Prepare necessary documentation for permits, Conduct interviews with potential contractors, Secure final approval of funds."
+    )
+    description: str = Field(
+        description="Longer text that describes the subtask in more detail, such as: Objective, Scope, Steps, Deliverables."
+    )
+    resources_needed: list[str] = Field(
+        description="List of resources needed to complete the subtask. Example: ['Project manager', 'Architect', 'Engineer', 'Construction crew']."
+    )
+
+class WBSTaskDetails(BaseModel):
+    """
+    A big task in the project decomposed into a few smaller tasks.
+    """
+    subtasks: list[WBSSubtask] = Field(
+        description="List of subtasks."
+    )
+
+QUERY_PREAMBLE = f"""
+Decompose a big task into smaller, more manageable subtasks.
+
+Split the task into 3 to 5 subtasks.
+
+Pick a subtask name that is short, max 7 words or max 60 characters.
+
+Don't enumerate the subtasks with integers or letters.
+
+Don't assign a uuid to the subtask.
+
+"""
+
+@dataclass
+class CreateWBSLevel3:
+    """
+    WBS Level 3: Creating a Work Breakdown Structure (WBS) from a project plan.
+    """
+    query: str
+    response: dict
+    metadata: dict
+    tasks: list[dict]
+    task_uuids: list[str]
+
+    @classmethod
+    def format_query(cls, plan_json: dict, wbs_level1_json: dict, wbs_level2_json: list, wbs_level2_task_durations_json: dict, decompose_task_id: str) -> str:
+        if not isinstance(plan_json, dict):
+            raise ValueError("Invalid plan_json.")
+        if not isinstance(wbs_level1_json, dict):
+            raise ValueError("Invalid wbs_level1_json.")
+        if not isinstance(wbs_level2_json, list):
+            raise ValueError("Invalid wbs_level1_json.")
+        if not isinstance(wbs_level2_task_durations_json, list):
+            raise ValueError("Invalid wbs_level2_task_durations_json.")
+        if not isinstance(decompose_task_id, str):
+            raise ValueError("Invalid decompose_task_id.")
+
+        query = f"""
+The project plan:
+{format_json_for_use_in_query(plan_json)}
+
+WBS Level 1:
+{format_json_for_use_in_query(wbs_level1_json)}
+
+WBS Level 2:
+{format_json_for_use_in_query(wbs_level2_json)}
+
+WBS Level 2 time estimates:
+{format_json_for_use_in_query(wbs_level2_task_durations_json)}
+
+Only decompose this task:
+"{decompose_task_id}"
+"""
+        return query
+
+    @classmethod
+    def execute(cls, llm: LLM, query: str, decompose_task_id: str) -> 'CreateWBSLevel3':
+        """
+        Invoke LLM to decompose a big WBS level 2 task into smaller tasks.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+        if not isinstance(decompose_task_id, str):
+            raise ValueError("Invalid decompose_task_id.")
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(WBSTaskDetails)
+        response = sllm.complete(QUERY_PREAMBLE + query)
+        json_response = json.loads(response.text)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        # Cleanup the json response from the LLM model, assign unique ids to each subtask.
+        parent_task_id = decompose_task_id
+        result_tasks = []
+        result_task_uuids = []
+        for subtask in json_response['subtasks']:
+            name = subtask['name']
+            description = subtask['description']
+            resources_needed = subtask['resources_needed']
+            uuid = str(uuid4())
+            subtask_item = {
+                "id": uuid,
+                "name": name,
+                "description": description,
+                "resources_needed": resources_needed,
+                "parent_id": parent_task_id
+            }
+            result_tasks.append(subtask_item)
+            result_task_uuids.append(uuid)
+
+        result = CreateWBSLevel3(
+            query=query,
+            response=json_response,
+            metadata=metadata,
+            tasks=result_tasks,
+            task_uuids=result_task_uuids
+        )
+        return result    
+
+    def raw_response_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        return d
+
+if __name__ == "__main__":
+    from llama_index.llms.ollama import Ollama
+
+    # TODO: Eliminate hardcoded paths
+    basepath = '/Users/neoneye/Desktop/planexe_data'
+
+    def load_json(relative_path: str) -> dict:
+        path = os.path.join(basepath, relative_path)
+        print(f"loading file: {path}")
+        with open(path, 'r', encoding='utf-8') as f:
+            the_json = json.load(f)
+        return the_json
+
+    plan_json = load_json('002-project_plan.json')
+    wbs_level1_json = load_json('006-wbs_level1.json')
+    wbs_level2_json = load_json('008-wbs_level2.json')
+    wbs_level2_task_durations_json = load_json('012-task_durations.json')
+    decompose_task_id = "1c690f4a-ae8e-493d-9e47-6da58ef5b24c"
+
+    query = CreateWBSLevel3.format_query(plan_json, wbs_level1_json, wbs_level2_json, wbs_level2_task_durations_json, decompose_task_id)
+
+    model_name = "llama3.1:latest"
+    # model_name = "qwen2.5-coder:latest"
+    # model_name = "phi4:latest"
+    llm = Ollama(model=model_name, request_timeout=120.0, temperature=0.5, is_function_calling_model=False)
+
+    print(f"Query: {query}")
+    result = CreateWBSLevel3.execute(llm, query, decompose_task_id)
+
+    print("\n\nResponse:")
+    print(json.dumps(result.raw_response_dict(include_query=False), indent=2))
+
+    print("\n\nExtracted tasks:")
+    print(json.dumps(result.tasks, indent=2))
+

src/plan/data/simple_plan_prompts.jsonl

@@ -0,0 +1,23 @@
+{"id": "fdbac6bc-6853-47f3-b7ec-bc0051314952", "prompt": "I'm envisioning a streamlined global language—free of archaic features like gendered terms and excessive suffixes, taking cues from LLM tokenization. Some regions might only choose to adopt certain parts of this modern language. Would humanity ultimately benefit more from preserving many distinct languages, or uniting around a single, optimized one?", "tags": ["language", "tokenization"]}
+{"id": "762b64e2-5ac8-4684-807a-efd3e81d6bc1", "prompt": "Create a detailed report examining the current situation of microplastics within the world's oceans.", "tags": ["ocean", "microplastics", "climate change", "sustainability"]}
+{"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": "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"]}
+{"id": "da8da7a6-954c-4f88-91c9-53f98a934868", "prompt": "I want a cup of coffee. I have instant coffee and a cup and water. I don't use sugar, milk. I have done it many times before.", "tags": ["small task", "trivial", "coffee"]}
+{"id": "9d008681-8710-431c-bae4-0fc27ce3cc36", "prompt": "I want to find the TV remote. It's probably in the fridge again. I had it last night when I watched TV.", "tags": ["small task", "trivial", "lost item"]}
+{"id": "3deda46b-9c9d-4078-a72c-15299b70d915", "prompt": "I need to water my houseplants. I have a watering can and access to water. The plants are in the living room and bedroom. There are 5 plants in total. They need to be watered once a week.", "tags": ["small task", "trivial", "plants"]}
+{"id": "0a61aae5-472d-4e63-8a4e-cf976cb5064b", "prompt": "I need to set an alarm for tomorrow morning. I have a smartphone and know the time I want to wake up.", "tags": ["small task", "trivial", "sleep"]}
+{"id": "2eaa697a-0657-4de2-aadc-a6f314e88e98", "prompt": "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.", "tags": ["small task", "trivial", "trash"]}
+{"id": "9040f467-cce5-4e68-8686-48d4464c4d02", "prompt": "I want to go on a 14 days vacation trip to Paris. Book a cheap flight. Identify a cheap hotel. I want to visit the Eiffel tower. What other tourist attractions are a must.", "tags": ["travel", "paris", "eiffel tower", "hotel"]}
+{"id": "faca8cec-28bb-4499-b9e9-1efc00c4aa2b", "prompt": "Construct a pyramid of modern day, year 2025, built following the same principles as the old pyramids (2000 BC), no use of modern tools.", "tags": ["historical", "replica", "pyramid"]}
+{"id": "98a8c63e-4770-4ee1-aef8-693800deec0e", "prompt": "Construct a replica of Stonehenge using only the tools and methods available in 2500 BC, at a site in rural England.", "tags": ["historical", "replica", "stonehenge"]}
+{"id": "39bc819c-ee86-44c8-b1d4-d6bf3117cb0e", "prompt": "Create a fully functional, medieval-style castle using only materials and techniques from the 12th century, located in Scotland.", "tags": ["historical", "replica", "castle"]}
+{"id": "6860b2ae-39f0-4517-b827-95befbf142ac", "prompt": "Manned moon mission, for establishing a permanent base.", "tags": ["moon", "space", "exploration"]}
+{"id": "b37da5bf-1e67-43b6-8c76-8d735f89ef6b", "prompt": "Construct a massive, multi-level underground complex designed to sustain thousands of people indefinitely. This silo would feature self-contained ecosystems, including residential areas, agricultural zones, and industrial facilities spread across 144 floors. The structure would maintain stringent rules to keep order and control information about the outside world, believed to be toxic. Advanced surveillance and security systems would enforce these rules. The silo would be a complete, self-sustaining society, with its own power generation, water recycling, and air filtration systems, embodying a dystopian, controlled environment. Funding for this project comes from a mix of government allocations and private investments from elite stakeholders.", "tags": ["silo", "exploration", "dystopian"]}
+{"id": "c2c45867-be60-4690-aac1-530627fc0818", "prompt": "Deep cave exploration to find new lifeforms in extreme conditions, in the newly found highly radiative cave near Copenhagen, Denmark.", "tags": ["denmark", "copenhagen", "cave", "radioactive"]}
+{"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": "a9113924-6148-4a0c-b72a-eecdb856e1e2", "prompt": "Investigate outbreak of a deadly new disease in the jungle.", "tags": ["outbreak", "jungle"]}
+{"id": "4dc34d55-0d0d-4e9d-92f4-23765f49dd29", "prompt": "Establish a solar farm in Denmark.", "tags": ["denmark", "energy", "sun"]}

src/plan/estimate_wbs_task_durations.py

@@ -0,0 +1,174 @@
+"""
+https://en.wikipedia.org/wiki/Work_breakdown_structure
+"""
+import os
+import json
+import time
+from math import ceil
+from typing import List, Optional
+from uuid import uuid4
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+class TaskTimeEstimateDetail(BaseModel):
+    """
+    Details about a task duration, lower/upper bounds. Potential risks impacting the duration. 
+    """
+    task_id: str = Field(
+        description="UUID that uniquely identifies the task."
+    )
+    delay_risks: str = Field(
+        description="Possible issues that may delay the task. Example: ['Weather-related disruptions', 'Third-party vendors might fail to deliver on time', 'Key team members might be unavailable']. **This field MUST be filled with a meaningful description. Do not leave it empty.**"
+    )
+    mitigation_strategy: str = Field(
+        description="Actions or strategies to minimize the risk of delays. Example: ['Engage backup vendors', 'Schedule regular progress reviews', 'Establish clear communication channels']. **This field MUST be filled with a meaningful and specific strategy. Do not leave it empty.**"
+    )
+    days_min: int = Field(
+        description="Number of days, the best case scenario. If not applicable use minus 1."
+    )
+    days_max: int = Field(
+        description="Number of days, the worst case scenario. If not applicable use minus 1."
+    )
+    days_realistic: int = Field(
+        description="Number of days, in the realistic scenario. If not applicable use minus 1."
+    )
+
+class TimeEstimates(BaseModel):
+    """
+    Estimating realistic durations for each task and appropriately assigning resources 
+    ensures that the project stays on schedule and within budget.
+    """
+    task_details: list[TaskTimeEstimateDetail] = Field(
+        description="List with tasks with time estimates."
+    )
+
+QUERY_PREAMBLE = f"""
+Assign estimated durations for each task and subtask.
+Ensure a consistent voice and phrasing across tasks.
+
+**For each task, you MUST provide a meaningful description for both 'delay_risks' and 'mitigation_strategy'. Do not leave these fields as empty strings.**
+
+**Example of good 'delay_risks' and 'mitigation_strategy':**
+For the task of "Define project scope and objectives":
+- delay_risks: "Lack of clear initial requirements from stakeholders, potential for scope creep later in the project."
+- mitigation_strategy: "Conduct thorough initial meetings with all key stakeholders to gather requirements, establish a clear change management process."
+
+"""
+
+@dataclass
+class EstimateWBSTaskDurations:
+    """
+    Enrich an existing Work Breakdown Structure (WBS) with task duration estimates.
+    """
+    query: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def format_query(cls, plan_json: dict, wbs_level2_json: list, task_ids: list[str]) -> str:
+        if not isinstance(plan_json, dict):
+            raise ValueError("Invalid plan_json.")
+        if not isinstance(wbs_level2_json, list):
+            raise ValueError("Invalid wbs_level1_json.")
+        if not isinstance(task_ids, list):
+            raise ValueError("Invalid task_ids.")
+
+        """
+        Wrap the task ids in quotes, so it looks like this:
+        "0ca58751-3abd-44d0-b24b-ebcf14c794e7"
+        "86f0ed30-ba23-46e4-83d9-ef53d95ff054"
+        "58d5dcc3-7385-4919-adc1-e1f84727e9d2"
+        """
+        task_ids_in_quotes = [f'"{task_id}"' for task_id in task_ids]
+        task_id_strings = "\n".join(task_ids_in_quotes)
+
+        query = f"""
+The project plan:
+{format_json_for_use_in_query(plan_json)}
+
+The Work Breakdown Structure (WBS):
+{format_json_for_use_in_query(wbs_level2_json)}
+
+Only estimate these {len(task_ids)} tasks:
+{task_id_strings}
+"""
+        return query
+    
+    @classmethod
+    def execute(cls, llm: LLM, query: str) -> 'EstimateWBSTaskDurations':
+        """
+        Invoke LLM to estimate task durations from a json representation of a project plan and Work Breakdown Structure (WBS).
+
+        Executing with too many task_ids may result in a timeout, where the LLM cannot complete the task within a reasonable time.
+        Split the task_ids into smaller chunks of around 3 task_ids each, and process them one at a time.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(TimeEstimates)
+        response = sllm.complete(QUERY_PREAMBLE + query)
+        json_response = json.loads(response.text)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        result = EstimateWBSTaskDurations(
+            query=query,
+            response=json_response,
+            metadata=metadata,
+        )
+        return result
+    
+    def raw_response_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        return d
+
+if __name__ == "__main__":
+    from llama_index.llms.ollama import Ollama
+
+    # TODO: Eliminate hardcoded paths
+    basepath = '/Users/neoneye/Desktop/planexe_data'
+
+    def load_json(relative_path: str) -> dict:
+        path = os.path.join(basepath, relative_path)
+        print(f"loading file: {path}")
+        with open(path, 'r', encoding='utf-8') as f:
+            the_json = json.load(f)
+        return the_json
+
+    plan_json = load_json('002-project_plan.json')
+    wbs_level2_json = load_json('006-wbs_level2.json')
+
+    task_ids = [
+        "c6a249af-b8d3-4d4c-b3ef-8a5caa8793d4",
+        "622fa6f1-6252-445e-8b5a-2a5c75683a80",
+        "fdaa706e-3d3b-4166-9730-7ea3e238d0cf"
+    ]
+
+    query = EstimateWBSTaskDurations.format_query(plan_json, wbs_level2_json, task_ids)
+
+    model_name = "llama3.1:latest"
+    # model_name = "qwen2.5-coder:latest"
+    # model_name = "phi4:latest"
+    llm = Ollama(model=model_name, request_timeout=120.0, temperature=0.5, is_function_calling_model=False)
+
+    print(f"Query: {query}")
+    result = EstimateWBSTaskDurations.execute(llm, query)
+
+    print("\n\nResponse:")
+    response_dict = result.raw_response_dict(include_query=False)
+    print(json.dumps(response_dict, indent=2))

src/plan/expert_cost.py

@@ -0,0 +1,320 @@
+"""
+Ask a specific expert about estimating cost.
+"""
+import json
+import time
+from math import ceil
+from typing import Optional
+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
+
+class CostUnit(str, Enum):
+    # An hour is 60 minutes.
+    hour = 'hour'
+
+    # A day is 24 hours.
+    day = 'day'
+
+    # A single upfront fee that covers the entire cost of a project.
+    lumpsum = 'lumpsum'
+
+    # A single discrete unit or piece of equipment.
+    item = 'item'
+
+    # When no other enum value is applicable.
+    other = 'other'
+
+class CostComponent(BaseModel):
+    name: str = Field(description="Human-readable name of the cost component.")
+    unit: CostUnit = Field(description="Indicates how costs are measured.")
+    quantity: float = Field(description="Number of units, if applicable.")
+    currency: str = Field(description="What currency used in this cost component, such as: USD, EUR.")
+    unit_cost: float = Field(description="Cost per unit, if applicable.")
+    labor_cost: float = Field(description="Cost related to labor.")
+    material_cost: float = Field(description="Cost related to materials.")
+    equipment_cost: float = Field(description="Cost related to equipment.")
+    overhead_cost: float = Field(description="Indirect or overhead costs.")
+    contingency_rate: float = Field(description="Higher contingency rates for riskier tasks.")
+
+class CostEstimateItem(BaseModel):
+    task_id: str = Field(description="Unique identifier for the task.")
+    task_name: str = Field(description="Name of the task.")
+    cost_component_list: list[CostComponent] = Field(description="Multiple cost components.")
+    min_cost: int = Field(description="Minimum estimated cost.")
+    max_cost: int = Field(description="Maximum estimated cost.")
+    realistic_cost: int = Field(description="Most likely cost estimate.")
+    assumptions: list[str] = Field(description="Assumptions made during estimation.")
+    high_risks: list[str] = Field(description="Potential risks affecting cost. High risk level.")
+    medium_risks: list[str] = Field(description="Potential risks affecting cost. Medium risk level.")
+    low_risks: list[str] = Field(description="Potential risks affecting cost. Low risk level.")
+    dependencies_impact: str = Field(description="Impact of task dependencies on cost.")
+
+class ExpertCostEstimationResponse(BaseModel):
+    cost_estimates: list[CostEstimateItem] = Field(description="List of cost estimates for tasks.")
+    primary_actions: list[str] = Field(description="Actionable steps to refine cost estimates.")
+    secondary_actions: list[str] = Field(description="Additional suggestions for cost management.")
+    follow_up_consultation: str = Field(description="Topics for the next consultation.")
+
+@dataclass
+class Document:
+    name: str
+    content: str
+
+QUERY_PREAMBLE = f"""
+Provide detailed and accurate cost estimates for the provided tasks.
+
+Use the following guidelines:
+- Provide minimum, maximum, and realistic cost estimates.
+- Break down costs into components such as labor, materials, equipment, subcontractors, overhead, and miscellaneous.
+- State any assumptions made during estimation.
+- Highlight potential risks that could affect costs.
+- Explain how task dependencies impact the cost.
+
+Ensure that your estimates are actionable and based on best practices in cost estimation.
+
+Please provide a detailed cost estimate for each task, including minimum, maximum, and realistic costs, 
+along with a breakdown of cost components and any relevant assumptions or risks.
+
+Cost components with smaller quantities
+Round up the partial-hour rates to the nearest whole hour. 
+If a meeting is 15 minutes, the bill might be 1-hour. Better to overestimate than underestimate.
+
+Here are the details of the project tasks for cost estimation:
+
+"""
+
+@dataclass
+class ExpertCost:
+    """
+    Ask an expert advise about estimating cost.
+    """
+    query: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def format_system(cls, expert: dict) -> str:
+        if not isinstance(expert, dict):
+            raise ValueError("Invalid expert.")
+
+        role = expert.get('title', 'Cost Estimation Expert')
+        knowledge = expert.get('knowledge', 'Cost estimation methodologies, project budgeting, financial analysis.')
+        skills = expert.get('skills', 'Analytical skills, attention to detail, proficiency in budgeting tools.')
+
+        query = f"""
+You are acting as a highly experienced {role}.
+
+Your areas of deep knowledge include:
+{knowledge}
+
+You possess the following key skills:
+{skills}
+
+"""
+        return query
+
+    @classmethod
+    def format_query(cls, currency: str, location: str, task_ids_to_process: list[str], documents: list[Document]) -> str:
+        if not isinstance(currency, str):
+            raise ValueError("Invalid currency.")
+        if not isinstance(location, str):
+            raise ValueError("Invalid location.")
+        if not isinstance(task_ids_to_process, list):
+            raise ValueError("Invalid task_ids_to_process.")
+        if not isinstance(documents, list):
+            raise ValueError("Invalid documents.")
+
+        task_ids_in_quotes = [f'"{task_id}"' for task_id in task_ids_to_process]
+        task_id_strings = "\n".join(task_ids_in_quotes)
+        task_id_count = len(task_ids_to_process)
+
+        document_items = []
+        for document_index, document in enumerate(documents, start=1):
+            document_items.append(f"File {document_index}, {document.name}:\n{document.content}")
+
+        document_content = "\n\n".join(document_items)
+        query = f"""
+{document_content}
+
+Extra information:
+- All cost estimates should be in {currency}.
+- The project is located in {location}; consider local market rates and economic factors.
+
+Please provide exactly one cost estimate for each of the following {task_id_count} tasks and no others:
+{task_id_strings}
+**Do not** include cost estimates for tasks not in this list.
+"""
+        return query
+
+    @classmethod
+    def execute(cls, llm: LLM, query: str, system_prompt: Optional[str]) -> 'ExpertCost':
+        """
+        Invoke LLM to get cost estimation advice from the expert.
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        chat_message_list = []
+        if system_prompt:
+            chat_message_list.append(
+                ChatMessage(
+                    role=MessageRole.SYSTEM,
+                    content=system_prompt,
+                )
+            )
+        
+        chat_message_user = ChatMessage(
+            role=MessageRole.USER,
+            content=query,
+        )
+        chat_message_list.append(chat_message_user)
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(ExpertCostEstimationResponse)
+        chat_response = sllm.chat(chat_message_list)
+        json_response = json.loads(chat_response.message.content)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        result = ExpertCost(
+            query=query,
+            response=json_response,
+            metadata=metadata,
+        )
+        return result    
+
+    def raw_response_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        return d
+
+if __name__ == "__main__":
+    from llama_index.llms.ollama import Ollama
+    from llama_index.llms.openai_like import OpenAILike
+    from dotenv import dotenv_values
+    import os
+    from wbs_table_for_cost_estimation.wbs_table_for_cost_estimation import WBSTableForCostEstimation
+    from chunk_dataframe_with_context.chunk_dataframe_with_context import chunk_dataframe_with_context
+    import pandas as pd
+    from pandas import DataFrame
+
+    dotenv_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '.env'))
+    dotenv_dict = dotenv_values(dotenv_path=dotenv_path)
+
+    if True:
+        model_name = "llama3.1:latest"
+        # model_name = "qwen2.5-coder:latest"
+        # model_name = "phi4:latest"
+        llm = Ollama(model=model_name, request_timeout=120.0, temperature=0.5, is_function_calling_model=False)
+    else:
+        llm = OpenAILike(
+            api_base="https://api.deepseek.com/v1",
+            api_key=dotenv_dict['DEEPSEEK_API_KEY'],
+            model="deepseek-chat",
+            is_chat_model=True,
+            is_function_calling_model=True,
+            max_retries=1,
+        )
+    
+
+    # TODO: Eliminate hardcoded paths
+    basepath = '/Users/neoneye/Desktop/planexe_data'
+
+    def load_json(relative_path: str) -> dict:
+        path = os.path.join(basepath, relative_path)
+        print(f"loading file: {path}")
+        with open(path, 'r', encoding='utf-8') as f:
+            the_json = json.load(f)
+        return the_json
+
+    def load_text(relative_path: str) -> dict:
+        path = os.path.join(basepath, relative_path)
+        print(f"loading file: {path}")
+        with open(path, 'r', encoding='utf-8') as f:
+            the_text = f.read()
+        return the_text
+
+    plan_txt = load_text('001-plan.txt')
+    document_plan = Document(name="vague_plan_description.txt", content=plan_txt)
+
+    project_plan_json = load_json('002-project_plan.json')
+    project_plan = format_json_for_use_in_query(project_plan_json)
+    document_project_plan = Document(name="project_plan.json", content=project_plan)
+
+    swot_analysis_md = load_text('004-swot_analysis.md')
+    document_swot_analysis = Document(name="swot_analysis.md", content=swot_analysis_md)
+
+    expert_list_json = load_json('006-experts.json')
+
+    path_wbs_table_csv = os.path.join(basepath, '016-wbs_table.csv')
+    path_wbs_project_json = os.path.join(basepath, '016-wbs_project.json')
+    wbs_table = WBSTableForCostEstimation.create(path_wbs_table_csv, path_wbs_project_json)
+    wbs_df = wbs_table.wbs_table_df.copy()
+
+    expert = expert_list_json[5]
+    expert.pop('id')
+    system_prompt = ExpertCost.format_system(expert)
+    print(f"System: {system_prompt}")
+
+    currency = "DKK"
+    location = "Kolonihave at Kongelundsvej, Copenhagen, Denmark"
+
+    # The LLM cannot handle the entire WBS hierarchy at once, usually more than 100 rows.
+    # Instead process the CSV in chunks of N rows.
+    chunk_size=3
+    overlap=4
+
+    # Collect all chunks in a list to know how many there are
+    all_chunks = list(chunk_dataframe_with_context(wbs_df, chunk_size, overlap))
+    # truncate to 5 chunks
+    all_chunks = all_chunks[:5]
+
+    # Print out the total number of chunks (iterations) that will be processed
+    number_of_chunks = len(all_chunks)
+    print(f"There will be {number_of_chunks} iterations.")
+
+    documents_static = [document_plan, document_project_plan, document_swot_analysis]
+
+    # Then iterate over them as usual
+    for chunk_index, (core_df, extended_df) in enumerate(all_chunks, start=1):
+        print(f"Processing chunk {chunk_index} of {number_of_chunks} ...")
+
+        # Convert extended_df to CSV for the LLM prompt
+        extended_csv = extended_df.to_csv(sep=';', index=False)
+        document_wbs_chunk = Document(name="work_breakdown_structure.csv", content=extended_csv)
+        
+        # The tasks we want cost-estimated in this chunk (core tasks only)
+        task_ids_to_process = core_df['Task ID'].tolist()
+        
+        # Format the query with extended context as the content,
+        # but instruct the LLM to only produce estimates for the 
+        # `task_ids_to_process`.
+        query = ExpertCost.format_query(
+            currency=currency,
+            location=location,
+            task_ids_to_process=task_ids_to_process,
+            documents=documents_static + [document_wbs_chunk],
+        )
+        
+        # Make the LLM call
+        print(f"\n\nChunk {chunk_index} Query (len={len(query)}): {query}")
+        # print(f"\n\nChunk {chunk_index} Execute. len(query)={len(query)}")
+        result = ExpertCost.execute(llm, query, system_prompt)
+
+        print(f"\n\nChunk {chunk_index} Response:")
+        print(json.dumps(result.raw_response_dict(include_query=False), indent=2))

src/plan/filenames.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+class FilenameEnum(str, Enum):
+    INITIAL_PLAN = "001-plan.txt"
+    MAKE_ASSUMPTIONS_RAW = "002-make_assumptions_raw.json"
+    MAKE_ASSUMPTIONS = "003-make_assumptions.json"
+    DISTILL_ASSUMPTIONS_RAW = "004-distill_assumptions.json"
+    PRE_PROJECT_ASSESSMENT_RAW = "005-pre_project_assessment_raw.json"
+    PRE_PROJECT_ASSESSMENT = "006-pre_project_assessment.json"
+    PROJECT_PLAN = "007-project_plan.json"
+    SWOT_RAW = "008-swot_analysis_raw.json"
+    SWOT_MARKDOWN = "009-swot_analysis.md"
+    EXPERTS_RAW = "010-experts_raw.json"
+    EXPERTS_CLEAN = "011-experts.json"
+    EXPERT_CRITICISM_RAW_TEMPLATE = "012-{}-expert_criticism_raw.json"
+    EXPERT_CRITICISM_MARKDOWN = "013-expert_criticism.md"
+    WBS_LEVEL1_RAW = "014-wbs_level1_raw.json"
+    WBS_LEVEL1 = "015-wbs_level1.json"
+    WBS_LEVEL2_RAW = "016-wbs_level2_raw.json"
+    WBS_LEVEL2 = "017-wbs_level2.json"
+    WBS_PROJECT_LEVEL1_AND_LEVEL2 = "018-wbs_project_level1_and_level2.json"
+    PITCH = "019-pitch.json"
+    TASK_DEPENDENCIES_RAW = "020-task_dependencies_raw.json"
+    TASK_DURATIONS_RAW_TEMPLATE = "021-{}-task_durations_raw.json"
+    TASK_DURATIONS = "022-task_durations.json"
+    WBS_LEVEL3_RAW_TEMPLATE = "023-{}-wbs_level3_raw.json"
+    WBS_LEVEL3 = "024-wbs_level3.json"
+    WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_FULL = "025-wbs_project_level1_and_level2_and_level3.json"
+    WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_CSV = "026-wbs_project_level1_and_level2_and_level3.csv"
+    PIPELINE_COMPLETE = "999-pipeline_complete.txt"

src/plan/find_plan_prompt.py

@@ -0,0 +1,10 @@
+from src.prompt.prompt_catalog import PromptCatalog
+import os
+
+def find_plan_prompt(prompt_id: str) -> str:
+    prompt_catalog = PromptCatalog()
+    prompt_catalog.load(os.path.join(os.path.dirname(__file__), 'data', 'simple_plan_prompts.jsonl'))
+    prompt_item = prompt_catalog.find(prompt_id)
+    if not prompt_item:
+        raise ValueError(f"Prompt ID '{prompt_id}' not found.")
+    return prompt_item.prompt

src/plan/identify_wbs_task_dependencies.py

@@ -0,0 +1,167 @@
+"""
+Identified dependencies, that serves as a foundation for task sequencing.
+https://en.wikipedia.org/wiki/Work_breakdown_structure
+
+IDEA: I'm not happy about have two separate arrays for the task_ids and the explanations.
+There should be 1 task id and 1 explanation per dependency.
+Currently there can be N task ids and M explanations, where N != M. This is not good.
+
+IDEA: Label each dependency with its type (FS, SS, FF, SF).
+- Finish-to-Start (FS): Task B cannot start until Task A is finished (most common).
+- Start-to-Start (SS): Task B cannot start until Task A starts.
+- Finish-to-Finish (FF): Task B cannot finish until Task A is finished.
+- Start-to-Finish (SF): Task B cannot finish until Task A starts (least common).
+
+IDEA: Missing Dependencies.
+I asked Gemini to check the json file containing the dependencies, and it did spot some missing dependencies.
+So I need an extra LLM that can go identify if there are more missing dependencies.
+"""
+import os
+import json
+import time
+from math import ceil
+from typing import List, Optional
+from uuid import uuid4
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from llama_index.core.llms.llm import LLM
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+
+class TaskDependencyDetail(BaseModel):
+    """
+    Details about the prerequisites for a task.
+    """
+    dependent_task_id: str = Field(
+        description="UUID that uniquely identifies a major phase or a subtask."
+    )
+
+    depends_on_task_id_list: list[str] = Field(
+        description="List of UUIDs that are prerequisites for this task."
+    )
+
+    depends_on_task_explanation_list: list[str] = Field(
+        description="List of explanations why these tasks must be completed before this task."
+    )
+
+class DependencyMapping(BaseModel):
+    """
+    Understanding the dependencies between tasks is crucial for effective project scheduling and 
+    ensuring that prerequisites are met before commencing subsequent activities.
+    """
+    task_dependency_details: list[TaskDependencyDetail] = Field(
+        description="List with dependency mappings between tasks."
+    )
+
+QUERY_PREAMBLE = f"""
+Find the 10 most critical important task dependencies. Don't attempt making an exhaustive list.
+
+Understanding how tasks relate to each other is crucial for accurate timeline planning. 
+Dependencies determine the sequence in which tasks must be completed.
+
+Types of Dependencies:
+    •	Finish-to-Start (FS): Task B cannot start until Task A is finished.
+    •	Start-to-Start (SS): Task B cannot start until Task A starts.
+    •	Finish-to-Finish (FF): Task B cannot finish until Task A finishes.
+    •	Start-to-Finish (SF): Task B cannot finish until Task A starts (rarely used).
+
+Example Dependencies:
+    •	Land Acquisition must be completed before Permitting and Approvals can begin.
+    •	Permitting and Approvals must be completed before Design and Engineering starts.
+    •	Procurement of materials can begin once Design and Engineering is underway.
+
+"""
+
+@dataclass
+class IdentifyWBSTaskDependencies:
+    """
+    Enrich an existing Work Breakdown Structure (WBS) with details about dependencies between tasks.
+    """
+    query: str
+    response: dict
+    metadata: dict
+
+    @classmethod
+    def format_query(cls, plan_json: dict, wbs_level2_json: list) -> str:
+        """
+        Format the query for creating a Work Breakdown Structure (WBS) level 2.
+        """
+        if not isinstance(plan_json, dict):
+            raise ValueError("Invalid plan_json.")
+        if not isinstance(wbs_level2_json, list):
+            raise ValueError("Invalid wbs_list.")
+
+        query = f"""
+The project plan:
+{format_json_for_use_in_query(plan_json)}
+
+The Work Breakdown Structure (WBS):
+{format_json_for_use_in_query(wbs_level2_json)}
+"""
+        return query
+
+    @classmethod
+    def execute(cls, llm: LLM, query: str) -> 'IdentifyWBSTaskDependencies':
+        """
+        Invoke LLM to identify task dependencies from a json representation of a project plan and Work Breakdown Structure (WBS).
+        """
+        if not isinstance(llm, LLM):
+            raise ValueError("Invalid LLM instance.")
+        if not isinstance(query, str):
+            raise ValueError("Invalid query.")
+
+        start_time = time.perf_counter()
+
+        sllm = llm.as_structured_llm(DependencyMapping)
+        response = sllm.complete(QUERY_PREAMBLE + query)
+        json_response = json.loads(response.text)
+
+        end_time = time.perf_counter()
+        duration = int(ceil(end_time - start_time))
+
+        metadata = dict(llm.metadata)
+        metadata["llm_classname"] = llm.class_name()
+        metadata["duration"] = duration
+
+        result = IdentifyWBSTaskDependencies(
+            query=query,
+            response=json_response,
+            metadata=metadata
+        )
+        return result
+    
+    def raw_response_dict(self, include_metadata=True, include_query=True) -> dict:
+        d = self.response.copy()
+        if include_metadata:
+            d['metadata'] = self.metadata
+        if include_query:
+            d['query'] = self.query
+        return d
+
+if __name__ == "__main__":
+    from llama_index.llms.ollama import Ollama
+    # TODO: Eliminate hardcoded paths
+    basepath = '/Users/neoneye/Desktop/planexe_data'
+
+    def load_json(relative_path: str) -> dict:
+        path = os.path.join(basepath, relative_path)
+        print(f"loading file: {path}")
+        with open(path, 'r', encoding='utf-8') as f:
+            the_json = json.load(f)
+        return the_json
+
+    plan_json = load_json('002-project_plan.json')
+    wbs_json = load_json('005-wbs_level2.json')
+
+    query = IdentifyWBSTaskDependencies.format_query(plan_json, wbs_json)
+
+    model_name = "llama3.1:latest"
+    # model_name = "qwen2.5-coder:latest"
+    # model_name = "phi4:latest"
+    llm = Ollama(model=model_name, request_timeout=120.0, temperature=0.5, is_function_calling_model=False)
+
+    print(f"Query: {query}")
+    result = IdentifyWBSTaskDependencies.execute(llm, query)
+
+    print("Response:")
+    response_dict = result.raw_response_dict(include_query=False)
+    print(json.dumps(response_dict, indent=2))

src/plan/plan_file.py

@@ -0,0 +1,28 @@
+"""
+PROMPT> python -m src.plan.plan_file
+"""
+from datetime import datetime
+from dataclasses import dataclass
+
+@dataclass
+class PlanFile:
+    content: str
+
+    @classmethod
+    def create(cls, vague_plan_description: str) -> "PlanFile":
+        run_date = datetime.now()
+        pretty_date = run_date.strftime("%Y-%b-%d")
+        plan_prompt = (
+            f"Plan:\n{vague_plan_description}\n\n"
+            f"Today's date:\n{pretty_date}\n\n"
+            "Project start ASAP"
+        )
+        return cls(plan_prompt)
+
+    def save(self, file_path: str) -> None:
+        with open(file_path, "w") as f:
+            f.write(self.content)
+
+if __name__ == "__main__":
+    plan = PlanFile.create("My plan is here!")
+    print(plan.content)

src/plan/run_plan_pipeline.py

@@ -0,0 +1,934 @@
+"""
+PROMPT> python -m src.plan.run_plan_pipeline
+"""
+from datetime import datetime
+import logging
+import json
+import luigi
+from pathlib import Path
+
+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.make_assumptions import MakeAssumptions
+from src.assume.assumption_orchestrator import AssumptionOrchestrator
+from src.expert.pre_project_assessment import PreProjectAssessment
+from src.plan.create_project_plan import CreateProjectPlan
+from src.swot.swot_analysis import SWOTAnalysis
+from src.expert.expert_finder import ExpertFinder
+from src.expert.expert_criticism import ExpertCriticism
+from src.expert.expert_orchestrator import ExpertOrchestrator
+from src.plan.create_wbs_level1 import CreateWBSLevel1
+from src.plan.create_wbs_level2 import CreateWBSLevel2
+from src.plan.create_wbs_level3 import CreateWBSLevel3
+from src.plan.create_pitch import CreatePitch
+from src.plan.identify_wbs_task_dependencies import IdentifyWBSTaskDependencies
+from src.plan.estimate_wbs_task_durations import EstimateWBSTaskDurations
+from src.wbs.wbs_task import WBSTask, WBSProject
+from src.wbs.wbs_populate import WBSPopulate
+from src.llm_factory import get_llm
+from src.format_json_for_use_in_query import format_json_for_use_in_query
+from src.utils.get_env_as_string import get_env_as_string
+
+logger = logging.getLogger(__name__)
+DEFAULT_LLM_MODEL = "ollama-llama3.1"
+
+class PlanTask(luigi.Task):
+    # Default it to the current timestamp, eg. 19841231_235959
+    run_id = luigi.Parameter(default=datetime.now().strftime("%Y%m%d_%H%M%S"))
+
+    # By default, run everything but it's slow.
+    # This can be overridden in developer mode, where a quick turnaround is needed, and the details are not important.
+    speedvsdetail = luigi.EnumParameter(enum=SpeedVsDetailEnum, default=SpeedVsDetailEnum.ALL_DETAILS_BUT_SLOW)
+
+    @property
+    def run_dir(self) -> Path:
+        return Path('run') / self.run_id
+
+    def file_path(self, filename: FilenameEnum) -> Path:
+        return self.run_dir / filename.value
+
+
+class SetupTask(PlanTask):
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.INITIAL_PLAN)))
+
+    def run(self):
+        # Ensure the run directory exists.
+        self.run_dir.mkdir(parents=True, exist_ok=True)
+
+        # Pick a random prompt.
+        plan_prompt = find_plan_prompt("4dc34d55-0d0d-4e9d-92f4-23765f49dd29")
+        plan_file = PlanFile.create(plan_prompt)
+        plan_file.save(self.output().path)
+
+class AssumptionsTask(PlanTask):
+    """
+    Make assumptions about the plan.
+    Depends on:
+      - SetupTask (for the initial plan)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return SetupTask(run_id=self.run_id)
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.DISTILL_ASSUMPTIONS_RAW)))
+
+    def run(self):
+        logger.info("Making assumptions about 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.")
+        else:
+            logger.info("AssumptionsTask: We are in another mode")
+
+        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))
+
+        # Execute
+        orchestrator = AssumptionOrchestrator()
+        orchestrator.phase1_post_callback = phase1_post_callback
+        orchestrator.execute(llm, plan_prompt)
+
+        # 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))
+
+
+class PreProjectAssessmentTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail)
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.PRE_PROJECT_ASSESSMENT_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.PRE_PROJECT_ASSESSMENT)))
+        }
+
+    def run(self):
+        logger.info("Conducting pre-project assessment...")
+
+        # Read the plan prompt from the SetupTask's output.
+        with self.input().open("r") as f:
+            plan_prompt = f.read()
+
+        # Build the query.
+        query = f"Initial plan: {plan_prompt}\n\n"
+
+        # Get an instance of your LLM.
+        llm = get_llm(self.llm_model)
+
+        # Execute the pre-project assessment.
+        pre_project_assessment = PreProjectAssessment.execute(llm, query)
+
+        # Save raw output.
+        raw_path = self.file_path(FilenameEnum.PRE_PROJECT_ASSESSMENT_RAW)
+        pre_project_assessment.save_raw(str(raw_path))
+
+        # Save cleaned pre-project assessment.
+        clean_path = self.file_path(FilenameEnum.PRE_PROJECT_ASSESSMENT)
+        pre_project_assessment.save_preproject_assessment(str(clean_path))
+
+
+class ProjectPlanTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        """
+        This task depends on:
+          - SetupTask: produces the plan prompt (001-plan.txt)
+          - AssumptionsTask: produces the distilled assumptions (003-distill_assumptions.json)
+          - 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),
+            'preproject': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.PROJECT_PLAN)))
+
+    def run(self):
+        logger.info("Creating plan...")
+
+        # 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 assumptions from the distilled assumptions output.
+        assumptions_file = self.input()['assumptions']
+        with assumptions_file.open("r") as f:
+            assumption_list = json.load(f)
+
+        # Read the pre-project assessment from its file.
+        pre_project_assessment_file = self.input()['preproject']['clean']
+        with pre_project_assessment_file.open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+
+        # 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)}"
+        )
+
+        # Get an LLM instance.
+        llm = get_llm(self.llm_model)
+
+        # Execute the plan creation.
+        create_project_plan = CreateProjectPlan.execute(llm, query)
+        output_path = self.output().path
+        create_project_plan.save(output_path)
+
+        logger.info("Project plan created and saved to %s", output_path)
+
+
+class SWOTAnalysisTask(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'preproject': PreProjectAssessmentTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.SWOT_RAW))),
+            'markdown': luigi.LocalTarget(str(self.file_path(FilenameEnum.SWOT_MARKDOWN)))
+        }
+
+    def run(self):
+        logger.info("SWOTAnalysisTask. Loading files...")
+
+        # 1. Read the plan prompt from SetupTask.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+
+        # 2. Read the distilled assumptions from AssumptionsTask.
+        with self.input()['assumptions'].open("r") as f:
+            assumption_list = json.load(f)
+
+        # 3. Read the pre-project assessment from PreProjectAssessmentTask.
+        with self.input()['preproject']['clean'].open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+
+        # 4. Read the project plan from ProjectPlanTask.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+
+        logger.info("SWOTAnalysisTask. All files are now ready. Performing analysis...")
+
+        # 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)}"
+        )
+
+        # Create LLM instances for SWOT analysis.
+        llm = get_llm(self.llm_model)
+
+        # Execute the SWOT analysis.
+        try:
+            swot_analysis = SWOTAnalysis.execute(llm, query)
+        except Exception as e:
+            logger.error("SWOT analysis failed: %s", e)
+            raise
+
+        # Convert the SWOT analysis to a dict and markdown.
+        swot_raw_dict = swot_analysis.to_dict()
+        swot_markdown = swot_analysis.to_markdown(include_metadata=False)
+
+        # Write the raw SWOT JSON.
+        with self.output()['raw'].open("w") as f:
+            json.dump(swot_raw_dict, f, indent=2)
+
+        # Write the SWOT analysis as Markdown.
+        with self.output()['markdown'].open("w") as f:
+            f.write(swot_markdown)
+
+        logger.info("SWOT analysis complete.")
+
+class ExpertReviewTask(PlanTask):
+    """
+    Finds experts to review the SWOT analysis and have them provide criticism.
+    Depends on:
+      - SetupTask (for the initial plan)
+      - PreProjectAssessmentTask (for the pre‑project assessment)
+      - ProjectPlanTask (for the project plan)
+      - SWOTAnalysisTask (for the SWOT analysis)
+    Produces:
+      - Raw experts file (006-experts_raw.json)
+      - Cleaned experts file (007-experts.json)
+      - For each expert, a raw expert criticism file (008-XX-expert_criticism_raw.json) [side effects via callbacks]
+      - Final expert criticism markdown (009-expert_criticism.md)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            '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),
+            'swot_analysis': SWOTAnalysisTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.EXPERT_CRITICISM_MARKDOWN)))
+
+    def run(self):
+        logger.info("Finding experts to review the SWOT analysis, and having them provide criticism...")
+
+        # Read inputs from required tasks.
+        with self.input()['setup'].open("r") as f:
+            plan_prompt = f.read()
+        with self.input()['preproject']['clean'].open("r") as f:
+            pre_project_assessment_dict = json.load(f)
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+        with self.input()['swot_analysis']['markdown'].open("r") as f:
+            swot_markdown = f.read()
+
+        # Build the query.
+        query = (
+            f"Initial plan: {plan_prompt}\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"SWOT Analysis:\n{swot_markdown}"
+        )
+
+        llm = get_llm(self.llm_model)
+
+        # Define callback functions.
+        def phase1_post_callback(expert_finder: ExpertFinder) -> None:
+            raw_path = self.run_dir / FilenameEnum.EXPERTS_RAW.value
+            cleaned_path = self.run_dir / FilenameEnum.EXPERTS_CLEAN.value
+            expert_finder.save_raw(str(raw_path))
+            expert_finder.save_cleanedup(str(cleaned_path))
+
+        def phase2_post_callback(expert_criticism: ExpertCriticism, expert_index: int) -> None:
+            file_path = self.run_dir / FilenameEnum.EXPERT_CRITICISM_RAW_TEMPLATE.format(expert_index + 1)
+            expert_criticism.save_raw(str(file_path))
+
+        # Execute the expert orchestration.
+        expert_orchestrator = ExpertOrchestrator()
+        # IDEA: max_expert_count. don't truncate to 2 experts. Interview them all in production mode.
+        expert_orchestrator.phase1_post_callback = phase1_post_callback
+        expert_orchestrator.phase2_post_callback = phase2_post_callback
+        expert_orchestrator.execute(llm, query)
+
+        # Write final expert criticism markdown.
+        expert_criticism_markdown_file = self.file_path(FilenameEnum.EXPERT_CRITICISM_MARKDOWN)
+        with expert_criticism_markdown_file.open("w") as f:
+            f.write(expert_orchestrator.to_markdown())
+
+class CreateWBSLevel1Task(PlanTask):
+    """
+    Creates the Work Breakdown Structure (WBS) Level 1.
+    Depends on:
+      - ProjectPlanTask: provides the project plan as JSON.
+    Produces:
+      - Raw WBS Level 1 output file (xxx-wbs_level1_raw.json)
+      - Cleaned up WBS Level 1 file (xxx-wbs_level1.json)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_LEVEL1_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_LEVEL1)))
+        }
+
+    def run(self):
+        logger.info("Creating Work Breakdown Structure (WBS) Level 1...")
+        
+        # Read the project plan JSON from the dependency.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+        
+        # Build the query using the project plan.
+        query = format_json_for_use_in_query(project_plan_dict)
+        
+        # Get an LLM instance.
+        llm = get_llm(self.llm_model)
+        
+        # Execute the WBS Level 1 creation.
+        create_wbs_level1 = CreateWBSLevel1.execute(llm, query)
+        
+        # Save the raw output.
+        wbs_level1_raw_dict = create_wbs_level1.raw_response_dict()
+        with self.output()['raw'].open("w") as f:
+            json.dump(wbs_level1_raw_dict, f, indent=2)
+        
+        # Save the cleaned up result.
+        wbs_level1_result_json = create_wbs_level1.cleanedup_dict()
+        with self.output()['clean'].open("w") as f:
+            json.dump(wbs_level1_result_json, f, indent=2)
+        
+        logger.info("WBS Level 1 created successfully.")
+
+class CreateWBSLevel2Task(PlanTask):
+    """
+    Creates the Work Breakdown Structure (WBS) Level 2.
+    Depends on:
+      - ProjectPlanTask: provides the project plan as JSON.
+      - CreateWBSLevel1Task: provides the cleaned WBS Level 1 result.
+    Produces:
+      - Raw WBS Level 2 output (007-wbs_level2_raw.json)
+      - Cleaned WBS Level 2 output (008-wbs_level2.json)
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_level1': CreateWBSLevel1Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+
+    def output(self):
+        return {
+            'raw': luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_LEVEL2_RAW))),
+            'clean': luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_LEVEL2)))
+        }
+
+    def run(self):
+        logger.info("Creating Work Breakdown Structure (WBS) Level 2...")
+        
+        # Read the project plan from the ProjectPlanTask output.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+        
+        # Read the cleaned WBS Level 1 result from the CreateWBSLevel1Task output.
+        # Here we assume the cleaned output is under the 'clean' key.
+        with self.input()['wbs_level1']['clean'].open("r") as f:
+            wbs_level1_result_json = json.load(f)
+        
+        # Build the query using CreateWBSLevel2's format_query method.
+        query = CreateWBSLevel2.format_query(project_plan_dict, wbs_level1_result_json)
+        
+        # Get an LLM instance.
+        llm = get_llm(self.llm_model)
+        
+        # Execute the WBS Level 2 creation.
+        create_wbs_level2 = CreateWBSLevel2.execute(llm, query)
+        
+        # Retrieve and write the raw output.
+        wbs_level2_raw_dict = create_wbs_level2.raw_response_dict()
+        with self.output()['raw'].open("w") as f:
+            json.dump(wbs_level2_raw_dict, f, indent=2)
+        
+        # Retrieve and write the cleaned output (e.g. major phases with subtasks).
+        with self.output()['clean'].open("w") as f:
+            json.dump(create_wbs_level2.major_phases_with_subtasks, f, indent=2)
+        
+        logger.info("WBS Level 2 created successfully.")
+
+class WBSProjectLevel1AndLevel2Task(PlanTask):
+    """
+    Create a WBS project from the WBS Level 1 and Level 2 JSON files.
+    
+    It depends on:
+      - CreateWBSLevel1Task: providing the cleaned WBS Level 1 JSON.
+      - CreateWBSLevel2Task: providing the major phases with subtasks and the task UUIDs.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_PROJECT_LEVEL1_AND_LEVEL2)))
+    
+    def requires(self):
+        return {
+            'wbs_level1': CreateWBSLevel1Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_level2': CreateWBSLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+        }
+    
+    def run(self):
+        wbs_level1_path = self.input()['wbs_level1']['clean'].path
+        wbs_level2_path = self.input()['wbs_level2']['clean'].path
+        wbs_project = WBSPopulate.project_from_level1_json(wbs_level1_path)
+        WBSPopulate.extend_project_with_level2_json(wbs_project, wbs_level2_path)
+
+        json_representation = json.dumps(wbs_project.to_dict(), indent=2)
+        with self.output().open("w") as f:
+            f.write(json_representation)
+
+class CreatePitchTask(PlanTask):
+    """
+    Create a the pitch that explains the project plan, from multiple perspectives.
+    
+    This task depends on:
+      - ProjectPlanTask: provides the project plan JSON.
+      - WBSProjectLevel1AndLevel2Task: containing the top level of the project plan.
+    
+    The resulting pitch JSON is written to the file specified by FilenameEnum.PITCH.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+    
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.PITCH)))
+    
+    def requires(self):
+        return {
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_project': WBSProjectLevel1AndLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+        }
+    
+    def run(self):
+        logger.info("Creating pitch...")
+        
+        # Read the project plan JSON.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+        
+        wbs_project_path = self.input()['wbs_project'].path
+        with open(wbs_project_path, "r") as f:
+            wbs_project_dict = json.load(f)
+        wbs_project = WBSProject.from_dict(wbs_project_dict)
+        wbs_project_json = wbs_project.to_dict()
+        
+        # Build the query
+        query = (
+            f"The project plan:\n{format_json_for_use_in_query(project_plan_dict)}\n\n"
+            f"Work Breakdown Structure:\n{format_json_for_use_in_query(wbs_project_json)}"
+        )
+        
+        # Get the LLM instance.
+        llm = get_llm(self.llm_model)
+        
+        # Execute the pitch creation.
+        create_pitch = CreatePitch.execute(llm, query)
+        pitch_dict = create_pitch.raw_response_dict()
+        
+        # Write the resulting pitch JSON to the output file.
+        with self.output().open("w") as f:
+            json.dump(pitch_dict, f, indent=2)
+        
+        logger.info("Pitch created and written to %s", self.output().path)
+
+class IdentifyTaskDependenciesTask(PlanTask):
+    """
+    This task identifies the dependencies between WBS tasks.
+    
+    It depends on:
+      - ProjectPlanTask: provides the project plan JSON.
+      - CreateWBSLevel2Task: provides the major phases with subtasks.
+    
+    The raw JSON response is written to the file specified by FilenameEnum.TASK_DEPENDENCIES_RAW.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+    
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.TASK_DEPENDENCIES_RAW)))
+    
+    def requires(self):
+        return {
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_level2': CreateWBSLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+    
+    def run(self):
+        logger.info("Identifying task dependencies...")
+        
+        # Read the project plan JSON.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+        
+        # Read the major phases with subtasks from WBS Level 2 output.
+        with self.input()['wbs_level2']['clean'].open("r") as f:
+            major_phases_with_subtasks = json.load(f)
+        
+        # Build the query using the provided format method.
+        query = IdentifyWBSTaskDependencies.format_query(project_plan_dict, major_phases_with_subtasks)
+        
+        # Get the LLM instance.
+        llm = get_llm(self.llm_model)
+        
+        # Execute the dependency identification.
+        identify_dependencies = IdentifyWBSTaskDependencies.execute(llm, query)
+        dependencies_raw_dict = identify_dependencies.raw_response_dict()
+        
+        # Write the raw dependencies JSON to the output file.
+        with self.output().open("w") as f:
+            json.dump(dependencies_raw_dict, f, indent=2)
+        
+        logger.info("Task dependencies identified and written to %s", self.output().path)
+
+class EstimateTaskDurationsTask(PlanTask):
+    """
+    This task estimates durations for WBS tasks in chunks.
+    
+    It depends on:
+      - ProjectPlanTask: providing the project plan JSON.
+      - WBSProjectLevel1AndLevel2Task: providing the major phases with subtasks and the task UUIDs.
+    
+    For each chunk of 3 task IDs, a raw JSON file (e.g. "011-1-task_durations_raw.json") is written,
+    and an aggregated JSON file (defined by FilenameEnum.TASK_DURATIONS) is produced.
+
+    IDEA: 1st estimate the Tasks that have zero children.
+    2nd estimate tasks that have children where all children have been estimated.
+    repeat until all tasks have been estimated.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+    
+    def output(self):
+        # The primary output is the aggregated task durations JSON.
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.TASK_DURATIONS)))
+    
+    def requires(self):
+        return {
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_project': WBSProjectLevel1AndLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+        }
+    
+    def run(self):
+        logger.info("Estimating task durations...")
+        
+        # Load the project plan JSON.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+
+        with self.input()['wbs_project'].open("r") as f:
+            wbs_project_dict = json.load(f)
+        wbs_project = WBSProject.from_dict(wbs_project_dict)
+
+        # json'ish representation of the major phases in the WBS, and their subtasks.
+        root_task = wbs_project.root_task
+        major_tasks = [child.to_dict() for child in root_task.task_children]
+        major_phases_with_subtasks = major_tasks
+
+        # Don't include uuid of the root task. It's the child tasks that are of interest to estimate.
+        decompose_task_id_list = []
+        for task in wbs_project.root_task.task_children:
+            decompose_task_id_list.extend(task.task_ids())
+
+        logger.info(f"There are {len(decompose_task_id_list)} tasks to be estimated.")
+        
+        # Split the task IDs into chunks of 3.
+        task_ids_chunks = [decompose_task_id_list[i:i + 3] for i in range(0, len(decompose_task_id_list), 3)]
+        
+        # In production mode, all chunks are processed.
+        # In developer mode, truncate to only 2 chunks for fast turnaround cycle. Otherwise LOTS of tasks are to be estimated.
+        logger.info(f"EstimateTaskDurationsTask.speedvsdetail: {self.speedvsdetail}")
+        if self.speedvsdetail == SpeedVsDetailEnum.FAST_BUT_SKIP_DETAILS:
+            logger.info("FAST_BUT_SKIP_DETAILS mode, truncating to 2 chunks for testing.")
+            task_ids_chunks = task_ids_chunks[:2]
+        else:
+            logger.info("Processing all chunks.")
+
+        # Get the LLM instance.
+        llm = get_llm(self.llm_model)
+        
+        # Process each chunk.
+        accumulated_task_duration_list = []
+        for index, task_ids_chunk in enumerate(task_ids_chunks, start=1):
+            logger.info("Processing chunk %d of %d", index, len(task_ids_chunks))
+            
+            query = EstimateWBSTaskDurations.format_query(
+                project_plan_dict,
+                major_phases_with_subtasks,
+                task_ids_chunk
+            )
+            
+            estimate_durations = EstimateWBSTaskDurations.execute(llm, query)
+            durations_raw_dict = estimate_durations.raw_response_dict()
+            
+            # Write the raw JSON for this chunk.
+            filename = FilenameEnum.TASK_DURATIONS_RAW_TEMPLATE.format(index)
+            raw_chunk_path = self.run_dir / filename
+            with open(raw_chunk_path, "w") as f:
+                json.dump(durations_raw_dict, f, indent=2)
+            
+            accumulated_task_duration_list.extend(durations_raw_dict.get('task_details', []))
+        
+        # Write the aggregated task durations.
+        aggregated_path = self.file_path(FilenameEnum.TASK_DURATIONS)
+        with open(aggregated_path, "w") as f:
+            json.dump(accumulated_task_duration_list, f, indent=2)
+        
+        logger.info("Task durations estimated and aggregated results written to %s", aggregated_path)
+
+class CreateWBSLevel3Task(PlanTask):
+    """
+    This task creates the Work Breakdown Structure (WBS) Level 3, by decomposing tasks from Level 2 into subtasks.
+    
+    It depends on:
+      - ProjectPlanTask: provides the project plan JSON.
+      - WBSProjectLevel1AndLevel2Task: provides the major phases with subtasks and the task UUIDs.
+      - EstimateTaskDurationsTask: provides the aggregated task durations (task_duration_list).
+    
+    For each task without any subtasks, a query is built and executed using the LLM. 
+    The raw JSON result for each task is written to a file using the template from FilenameEnum. 
+    Finally, all individual results are accumulated and written as an aggregated JSON file.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+    
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_LEVEL3)))
+    
+    def requires(self):
+        return {
+            'project_plan': ProjectPlanTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_project': WBSProjectLevel1AndLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'task_durations': EstimateTaskDurationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model)
+        }
+    
+    def run(self):
+        logger.info("Creating Work Breakdown Structure (WBS) Level 3...")
+        
+        # Load the project plan JSON.
+        with self.input()['project_plan'].open("r") as f:
+            project_plan_dict = json.load(f)
+        
+        with self.input()['wbs_project'].open("r") as f:
+            wbs_project_dict = json.load(f)
+        wbs_project = WBSProject.from_dict(wbs_project_dict)
+
+        # Load the estimated task durations.
+        task_duration_list_path = self.input()['task_durations'].path
+        WBSPopulate.extend_project_with_durations_json(wbs_project, task_duration_list_path)
+
+        # for each task in the wbs_project, find the task that has no children
+        tasks_with_no_children = []
+        def visit_task(task):
+            if len(task.task_children) == 0:
+                tasks_with_no_children.append(task)
+            else:
+                for child in task.task_children:
+                    visit_task(child)
+        visit_task(wbs_project.root_task)
+
+        # for each task with no children, extract the task_id
+        decompose_task_id_list = []
+        for task in tasks_with_no_children:
+            decompose_task_id_list.append(task.id)
+        
+        logger.info("There are %d tasks to be decomposed.", len(decompose_task_id_list))
+
+        # In production mode, all chunks are processed.
+        # In developer mode, truncate to only 2 chunks for fast turnaround cycle. Otherwise LOTS of tasks are to be decomposed.
+        logger.info(f"CreateWBSLevel3Task.speedvsdetail: {self.speedvsdetail}")
+        if self.speedvsdetail == SpeedVsDetailEnum.FAST_BUT_SKIP_DETAILS:
+            logger.info("FAST_BUT_SKIP_DETAILS mode, truncating to 2 chunks for testing.")
+            decompose_task_id_list = decompose_task_id_list[:2]
+        else:
+            logger.info("Processing all chunks.")
+        
+        # Get an LLM instance.
+        llm = get_llm(self.llm_model)
+        
+        project_plan_str = format_json_for_use_in_query(project_plan_dict)
+        wbs_project_str = format_json_for_use_in_query(wbs_project.to_dict())
+
+        # Loop over each task ID.
+        wbs_level3_result_accumulated = []
+        total_tasks = len(decompose_task_id_list)
+        for index, task_id in enumerate(decompose_task_id_list, start=1):
+            logger.info("Decomposing task %d of %d", index, total_tasks)
+            
+            query = (
+                f"The project plan:\n{project_plan_str}\n\n"
+                f"Work breakdown structure:\n{wbs_project_str}\n\n"
+                f"Only decompose this task:\n\"{task_id}\""
+            )
+
+            create_wbs_level3 = CreateWBSLevel3.execute(llm, query, task_id)
+            wbs_level3_raw_dict = create_wbs_level3.raw_response_dict()
+            
+            # Write the raw JSON for this task using the FilenameEnum template.
+            raw_filename = FilenameEnum.WBS_LEVEL3_RAW_TEMPLATE.value.format(index)
+            raw_chunk_path = self.run_dir / raw_filename
+            with open(raw_chunk_path, 'w') as f:
+                json.dump(wbs_level3_raw_dict, f, indent=2)
+            
+            # Accumulate the decomposed tasks.
+            wbs_level3_result_accumulated.extend(create_wbs_level3.tasks)
+        
+        # Write the aggregated WBS Level 3 result.
+        aggregated_path = self.file_path(FilenameEnum.WBS_LEVEL3)
+        with open(aggregated_path, 'w') as f:
+            json.dump(wbs_level3_result_accumulated, f, indent=2)
+        
+        logger.info("WBS Level 3 created and aggregated results written to %s", aggregated_path)
+
+class WBSProjectLevel1AndLevel2AndLevel3Task(PlanTask):
+    """
+    Create a WBS project from the WBS Level 1 and Level 2 and Level 3 JSON files.
+    
+    It depends on:
+      - WBSProjectLevel1AndLevel2Task: providing the major phases with subtasks and the task UUIDs.
+      - CreateWBSLevel3Task: providing the decomposed tasks.
+    """
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def output(self):
+        return {
+            'full': luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_FULL))),
+            'csv': luigi.LocalTarget(str(self.file_path(FilenameEnum.WBS_PROJECT_LEVEL1_AND_LEVEL2_AND_LEVEL3_CSV)))
+        }
+    
+    def requires(self):
+        return {
+            'wbs_project12': WBSProjectLevel1AndLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_level3': CreateWBSLevel3Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+        }
+    
+    def run(self):
+        wbs_project_path = self.input()['wbs_project12'].path
+        with open(wbs_project_path, "r") as f:
+            wbs_project_dict = json.load(f)
+        wbs_project = WBSProject.from_dict(wbs_project_dict)
+
+        wbs_level3_path = self.input()['wbs_level3'].path
+        WBSPopulate.extend_project_with_decomposed_tasks_json(wbs_project, wbs_level3_path)
+
+        json_representation = json.dumps(wbs_project.to_dict(), indent=2)
+        with self.output()['full'].open("w") as f:
+            f.write(json_representation)
+        
+        csv_representation = wbs_project.to_csv_string()
+        with self.output()['csv'].open("w") as f:
+            f.write(csv_representation)
+
+class FullPlanPipeline(PlanTask):
+    llm_model = luigi.Parameter(default=DEFAULT_LLM_MODEL)
+
+    def requires(self):
+        return {
+            'setup': SetupTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail),
+            'assumptions': AssumptionsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            '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),
+            'swot_analysis': SWOTAnalysisTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'expert_review': ExpertReviewTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_level1': CreateWBSLevel1Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_level2': CreateWBSLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_project12': WBSProjectLevel1AndLevel2Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'pitch': CreatePitchTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'dependencies': IdentifyTaskDependenciesTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'durations': EstimateTaskDurationsTask(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_level3': CreateWBSLevel3Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+            'wbs_project123': WBSProjectLevel1AndLevel2AndLevel3Task(run_id=self.run_id, speedvsdetail=self.speedvsdetail, llm_model=self.llm_model),
+        }
+
+    def output(self):
+        return luigi.LocalTarget(str(self.file_path(FilenameEnum.PIPELINE_COMPLETE)))
+
+    def run(self):
+        with self.output().open("w") as f:
+            f.write("Full pipeline executed successfully.\n")
+
+
+if __name__ == '__main__':
+    import colorlog
+    import sys
+    import os
+
+    run_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    # specify a hardcoded, and it will resume work on that directory
+    # run_id = "20250205_141025"
+
+    # if env contains "RUN_ID" then use that as the run_id
+    if "RUN_ID" in os.environ:
+        run_id = os.environ["RUN_ID"]
+
+    run_dir = os.path.join("run", run_id)
+    os.makedirs(run_dir, exist_ok=True)
+
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+
+    # Log messages on the console
+    colored_formatter = colorlog.ColoredFormatter(
+        "%(log_color)s%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt='%Y-%m-%d %H:%M:%S',
+        log_colors={
+            'DEBUG':    'cyan',
+            'INFO':     'green',
+            'WARNING':  'yellow',
+            'ERROR':    'red',
+            'CRITICAL': 'red,bg_white',
+        }
+    )
+    stdout_handler = colorlog.StreamHandler(stream=sys.stdout)
+    stdout_handler.setFormatter(colored_formatter)
+    stdout_handler.setLevel(logging.DEBUG)
+    logger.addHandler(stdout_handler)
+
+    # Capture logs messages to 'run/yyyymmdd_hhmmss/log.txt'
+    file_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    log_file = os.path.join(run_dir, "log.txt")
+    file_handler = logging.FileHandler(log_file, mode='w')
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(file_formatter)
+    logger.addHandler(file_handler)
+
+    logger.info(f"run_id: {run_id}")
+
+    # Example logging messages
+    if False:
+        logger.debug("This is a debug message.")
+        logger.info("This is an info message.")
+        logger.warning("This is a warning message.")
+        logger.error("This is an error message.")
+        logger.critical("This is a critical message.")
+
+    model = DEFAULT_LLM_MODEL # works
+    model = "openrouter-paid-gemini-2.0-flash-001" # works
+    # model = "openrouter-paid-openai-gpt-4o-mini" # often fails, I think it's not good at structured output
+
+    if "LLM_MODEL" in os.environ:
+        model = os.environ["LLM_MODEL"]
+
+    logger.info(f"LLM model: {model}")
+
+    speedvsdetail = SpeedVsDetailEnum.ALL_DETAILS_BUT_SLOW
+    if "SPEED_VS_DETAIL" in os.environ:
+        speedvsdetail_value = os.environ["SPEED_VS_DETAIL"]
+        found = False
+        for e in SpeedVsDetailEnum:
+            if e.value == speedvsdetail_value:
+                speedvsdetail = e
+                found = True
+                logger.info(f"Setting Speed vs Detail: {speedvsdetail}")
+                break
+        if not found:
+            logger.error(f"Invalid value for SPEED_VS_DETAIL: {speedvsdetail_value}")
+    logger.info(f"Speed vs Detail: {speedvsdetail}")
+
+    task = FullPlanPipeline(speedvsdetail=speedvsdetail, llm_model=model)
+    if run_id is not None:
+        task.run_id = run_id
+
+    # logger.info("Environment variables Luigi:\n" + get_env_as_string() + "\n\n\n")
+
+    luigi.build([task], local_scheduler=True, workers=1)

src/plan/speedvsdetail.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class SpeedVsDetailEnum(str, Enum):
+    # Production mode.
+    ALL_DETAILS_BUT_SLOW = "all_details_but_slow"
+
+    # Developer mode that does a quick check if the pipeline runs. The accuracy is not a priority.
+    FAST_BUT_SKIP_DETAILS = "fast_but_skip_details"

src/prompt/prompt_catalog.py

@@ -0,0 +1,83 @@
+import json
+import logging
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+from src.uuid_util.is_valid_uuid import is_valid_uuid
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class PromptItem:
+    """Dataclass to hold a single prompt with tags, UUID, and any extra fields."""
+    id: str
+    prompt: str
+    tags: List[str] = field(default_factory=list)
+    extras: Dict[str, Any] = field(default_factory=dict)
+
+class PromptCatalog:
+    """
+    A catalog of PromptItem objects, keyed by UUID.
+    Supports loading from one or more JSONL files, each containing
+    one JSON object per line.
+    """
+    def __init__(self):
+        self._catalog: Dict[str, PromptItem] = {}
+
+    def load(self, filepath: str) -> None:
+        """
+        Load prompts from a JSONL file. Each line is expected to have
+        fields like 'id', 'prompt', 'tags', etc.
+        Logs an error if 'id' or 'prompt' is missing/empty, then skips that row.
+        """
+        with open(filepath, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, start=1):
+                line = line.strip()
+                if not line:
+                    continue
+
+                try:
+                    data = json.loads(line)
+                except json.JSONDecodeError as e:
+                    logger.error(f"JSON decode error in {filepath} at line {line_num}: {e}")
+                    continue
+
+                pid = data.get('id')
+                prompt_text = data.get('prompt')
+
+                if not pid:
+                    logger.error(f"Missing 'id' field in {filepath} at line {line_num}. Skipping row.")
+                    continue
+                if not prompt_text:
+                    logger.error(f"Missing or empty 'prompt' for ID '{pid}' in {filepath} at line {line_num}. Skipping row.")
+                    continue
+
+                if not is_valid_uuid(pid):
+                    logger.error(f"Invalid UUID in {filepath} at line {line_num}: {pid}. Skipping row.")
+                    continue
+
+                tags = data.get('tags', [])
+                extras = {k: v for k, v in data.items() if k not in ('id', 'prompt', 'tags')}
+
+                if self._catalog.get(pid):
+                    logger.error(f"Duplicate UUID found in {filepath} at line {line_num}: {pid}. Skipping row.")
+                    continue
+
+                item = PromptItem(id=pid, prompt=prompt_text, tags=tags, extras=extras)
+                self._catalog[pid] = item
+
+    def find(self, prompt_id: str) -> Optional[PromptItem]:
+        """Retrieve a PromptItem by its ID (UUID). Returns None if not found."""
+        if not is_valid_uuid(prompt_id):
+            raise ValueError(f"Invalid UUID: {prompt_id}")
+        return self._catalog.get(prompt_id)
+
+    def find_by_tag(self, tag: str) -> List[PromptItem]:
+        """
+        Return a list of all PromptItems that contain the given tag
+        (case-sensitive match).
+        """
+        return [item for item in self._catalog.values() if tag in item.tags]
+
+    def all(self) -> List[PromptItem]:
+        """Return a list of all PromptItems in the order they were inserted."""
+        return list(self._catalog.values())

src/prompt/test_data/prompts_simple.jsonl

@@ -0,0 +1,2 @@
+{"id":"cfd7aaf3-b521-42c6-ae50-6f0ecbc0c6ca","prompt":"I'm a prompt with 3 tags","tags":["tag1","tag2","tag3"]}
+{"id":"25bd2b32-ac7c-4b71-ba55-a7c6e29d08c5","prompt":"I'm a prompt with an extra field named 'comment'","tags":["I'm a tag"],"comment":"I'm a comment"}