- fix step 2

- fix calculate mandays

Project.py

@@ -519,12 +519,6 @@ class Project:
                     yield f"Error in {function_name}: {str(e)}", results
                     continue
 
-            # Add the revised_mvp_estimates to the results
-            results.append({
-                "function_name": "revised_mandays_estimates",
-                "result": revised_mvp_estimates
-            })
-
             yield "Components analysis completed!", results
             
         except Exception as e:
@@ -569,7 +563,7 @@ class Project:
                     input_vars = {}
                     prompt_config = PROMPTS[function_name]
                     for input_name in prompt_config.inputs:
-                        for prev_result in state.generation_results.get('step_2_c', [])[-1]:
+                        for prev_result in state.generation_results.get('step_2_b', [])[-1]:
                             if prev_result['function_name'] == input_name:
                                 ui_config = PROMPTS[input_name].ui
                                 dataframe_output_key = next(
@@ -594,46 +588,45 @@ class Project:
                     
                     yield f"Successfully completed {function_name}", results
                     
-                    
                 except Exception as e:
                     print(f"Error executing {function_name}: {str(e)}")
                     yield f"Error in {function_name}: {str(e)}", results
                     continue
                 
-            yield "MVP Mandays generation completed!", results
+            yield "MVP Mandays recalculation completed!", results
             
         except Exception as e:
-            print(f"Error in generating MVP mandays: {str(e)}")
-            yield f"Error in generating MVP mandays: {str(e)}", []
+            print(f"Error in recalculating MVP mandays: {str(e)}")
+            yield f"Error in recalculating MVP mandays: {str(e)}", []
             
     def generate_mvp_mandays(self, progress=gr.Progress()):
         """Generate MVP Mandays"""
         results = []
         
-        yield "Generating MVP Mandays...", results , None
+        yield "Generating MVP Mandays...", results, None
         
         try:
             if not hasattr(self, 'config'):
-                yield "Configuration not found.", [] , None
+                yield "Configuration not found.", [], None
                 return
             
             config = self.config
             configuration_type = config[0]["configuration_type"]
             
-            yield f"Configuration type detected: {configuration_type}", [] , None
+            yield f"Configuration type detected: {configuration_type}", [], None
             
             # Map configuration type to enum
             try:
                 config_enum = ConfigurationType(configuration_type)
             except ValueError:
-                yield f"Unsupported configuration type: {configuration_type}", [] , None
+                yield f"Unsupported configuration type: {configuration_type}", [], None
                 return
 
             # Get functions to execute based on configuration type
             functions_to_execute = GENERATE_MVP_MANDAYS_FUNCTIONS.get(config_enum, [])
             
             if not functions_to_execute:
-                yield f"No functions defined for configuration type: {configuration_type}", [] , None
+                yield f"No functions defined for configuration type: {configuration_type}", [], None
                 return
 
             for function_name in functions_to_execute:
@@ -643,42 +636,48 @@ class Project:
                     # Get the required input variables from the previous generation results
                     input_vars = {}
                     prompt_config = PROMPTS[function_name]
+                    
                     for input_name in prompt_config.inputs:
-                        for prev_result in state.generation_results.get('step_2_b', [])[-1]:
-                            if prev_result['function_name'] == input_name:
-                                ui_config = PROMPTS[input_name].ui
-                                dataframe_output_key = next(
-                                    (key for key in ui_config if key.endswith('_dataframe')),
-                                    None
-                                )
-                                if dataframe_output_key:
-                                    input_vars[input_name] = prev_result['result'][dataframe_output_key]
-                                else:
-                                    input_vars[input_name] = prev_result['result']
-                                break
+                            for prev_result in state.generation_results.get('step_2_c', [])[-1]:
+                                if prev_result['function_name'] == input_name:
+                                    ui_config = PROMPTS[input_name].ui
+                                    text_output_key = next(
+                                        (key for key in ui_config if key.endswith('_text')),
+                                        None
+                                    )
+                                    if text_output_key:
+                                        input_vars[input_name] = prev_result['result'][text_output_key]
+                                    else:
+                                        input_vars[input_name] = prev_result['result']
+                                    break
                     
                     # Execute the prompt with gathered input variables
                     result = self.execute_prompt(function_name, input_vars)
                     
+                    # Clean up the result by removing CSV markers and any other formatting
+                    result = (result.replace("```csv", "")
+                               .replace("```", "")
+                               .strip())
+                    
                     # Process CSV sections
                     sections = result.split("---SECTION BREAK---")
                     processed_result = {}
                     
                     if len(sections) >= 2:  
                         plan_test_csv = StringIO(sections[0].strip())
-                        plan_test_df = pd.read_csv(plan_test_csv)
-                        processed_result['mvp_plan_test_dataframe'] = plan_test_df
+                        plan_test_df = pd.read_csv(plan_test_csv, keep_default_na=False) 
+                        processed_result['mvp_plan_test_dataframe'] = plan_test_df.to_dict('records')
                         
-                        # Process Development Components
+                        # Process Development Components - ensure all columns are preserved
                         dev_csv = StringIO(sections[1].strip())
-                        dev_df = pd.read_csv(dev_csv)
-                        processed_result['mvp_dev_dataframe'] = dev_df
+                        dev_df = pd.read_csv(dev_csv, keep_default_na=False)  
+                        processed_result['mvp_dev_dataframe'] = dev_df.to_dict('records')
                         
                         if len(sections) >= 3 and 'generate_engage_MVP_mandays' in function_name:
                             # Process MVP Intents for Engage projects
                             intents_csv = StringIO(sections[2].strip())
-                            intents_df = pd.read_csv(intents_csv)
-                            processed_result['mvp_intents_dataframe'] = intents_df
+                            intents_df = pd.read_csv(intents_csv, keep_default_na=False)  
+                            processed_result['mvp_intents_dataframe'] = intents_df.to_dict('records')
                     
                     # Format and store results
                     formatted_result = {
@@ -687,28 +686,32 @@ class Project:
                     }
                     results.append(formatted_result)
                     
-                    yield f"Successfully completed {function_name}", results , None
+                    yield f"Successfully completed {function_name}", results, None
+                    
+                    # Calculate MVP Mandays
+                    total_mvp_mandays, total_mvp_cost, estimated_mvp_months = calculate_mvp_mandays_and_costs(results)
+                    mvp_cost_summary = f"""MVP Estimate:
+                    Total Mandays: {total_mvp_mandays:.2f} 
+                    Total Cost: ${total_mvp_cost:,.2f}
+                    ({estimated_mvp_months:.2f} months)"""
+                    
+                    # Initialize combined_cost_summary if general_cost_summary doesn't exist
+                    if hasattr(self, 'general_cost_summary'):
+                        self.combined_cost_summary = f"""{self.general_cost_summary}
+                        {mvp_cost_summary}"""
+                    else:
+                        self.combined_cost_summary = mvp_cost_summary
                     
                 except Exception as e:
                     print(f"Error executing {function_name}: {str(e)}")
-                    yield f"Error in {function_name}: {str(e)}", results , None
+                    yield f"Error in {function_name}: {str(e)}", results, None
                     continue
-                
-                # Calculate MVP Mandays
-                total_mvp_mandays, total_mvp_cost, estimated_mvp_months = calculate_mvp_mandays_and_costs(results)
-                mvp_cost_summary = f"""Original Estimate:
-                Total Mandays: {total_mvp_mandays:.2f} 
-                Total Cost: ${total_mvp_cost:,.2f}
-                ({estimated_mvp_months:.2f} months)"""
-                
-                combined_cost_summary = f"""{self.general_cost_summary}
-                {mvp_cost_summary}"""
-                
-            yield "MVP Mandays generation completed!", results , combined_cost_summary
+            
+            yield "MVP Mandays generation completed!", results, self.combined_cost_summary
             
         except Exception as e:
             print(f"Error in generating MVP mandays: {str(e)}")
-            yield f"Error in generating MVP mandays: {str(e)}", [] , None
+            yield f"Error in generating MVP mandays: {str(e)}", [], None
             
     ## Generate Final Documentation ##        
     def generate_final_documentation(self, progress=gr.Progress()):
@@ -717,7 +720,7 @@ class Project:
         
         try:
             if not hasattr(self, 'config'):
-                yield "Configuration not found. Please run 'generate_prd_and_components' first.", []
+                yield "Configuration not found.", []
                 return
             
             config = self.config
@@ -746,16 +749,34 @@ class Project:
                     # Get the required input variables from the previous generation results
                     input_vars = {}
                     prompt_config = PROMPTS[function_name]
+                    if hasattr(self, 'combined_cost_summary'):
+                        input_vars['quotation_cost'] = self.combined_cost_summary
+                    else:
+                        input_vars['quotation_cost'] = None
+                        
+                    for prev_result in state.generation_results.get('step_2_d', [])[-1]:
+                        if prev_result['function_name'] == input_name:
+                            ui_config = PROMPTS[input_name].ui
+                            dataframe_output_key = next(
+                                (key for key in ui_config if key.endswith('_dataframe')),
+                                None
+                            )
+                            if dataframe_output_key:
+                                input_vars[input_name] = prev_result['result'][dataframe_output_key]
+                            else:
+                                input_vars[input_name] = prev_result['result']
+                            break
+                            
                     for input_name in prompt_config.inputs:
-                        for prev_result in state.generation_results.get('step_2_c', [])[-1]:
+                        for prev_result in state.generation_results.get('step_1', [])[-1]:
                             if prev_result['function_name'] == input_name:
                                 ui_config = PROMPTS[input_name].ui
-                                dataframe_output_key = next(
-                                    (key for key in ui_config if key.endswith('_dataframe')),
+                                text_output_key = next(
+                                    (key for key in ui_config if key.endswith('_text')),
                                     None
                                 )
-                                if dataframe_output_key:
-                                    input_vars[input_name] = prev_result['result'][dataframe_output_key]
+                                if text_output_key:
+                                    input_vars[input_name] = prev_result['result'][text_output_key]
                                 else:
                                     input_vars[input_name] = prev_result['result']
                                 break
@@ -778,11 +799,11 @@ class Project:
                     yield f"Error in {function_name}: {str(e)}", results
                     continue
             
-            yield "MVP Mandays generation completed!", results
+            yield "Final Documentation Generation completed!", results
             
         except Exception as e:
-            print(f"Error in generating MVP mandays: {str(e)}")
-            yield f"Error in generating MVP mandays: {str(e)}", []
+            print(f"Error in generating Final Documentation: {str(e)}")
+            yield f"Error in generating Final Documentation: {str(e)}", []
         
         
         

common_functions_v4.py

@@ -206,44 +206,43 @@ def calculate_mandays_and_costs(generated_results=None):
         print(f"Error calculating mandays and costs: {str(e)}")
         return tuple([None] * 3)
 
-def calculate_mvp_mandays_and_costs(generated_results=None):
+def calculate_mvp_mandays_and_costs(generated_mvp_results):
     try:
         total_mvp_mandays = 0
-        if generated_results:
-            for result in generated_results:
-                if 'result' in result:
-                    result_content = result['result']
-                    # Check if result is a CSV string
-                    if isinstance(result_content, str):
+        
+        # Process results from each function
+        for result in generated_mvp_results:
+            if not result.get('result'):
+                continue
+                
+            # Process all dataframes in the result that end with '_dataframe'
+            for key, data in result['result'].items():
+                if not key.endswith('_dataframe') or not isinstance(data, list):
+                    continue
+                    
+                # Sum mandays from each item in the dataframe
+                for item in data:
+                    manday_key = next((k for k in item.keys() 
+                                     if 'manday' in k.lower()), None)
+                    if manday_key:
                         try:
-                            # Convert the CSV string to a dataframe
-                            df = pd.read_csv(StringIO(result_content))
-                            
-                            # Check if 'mandays' column exists (case-insensitive)
-                            mandays_col = next((col for col in df.columns if col.lower() == 'mandays'), None)
-                            if mandays_col:
-                                total_mvp_mandays += df[mandays_col].astype(float).sum()
-                                print(f"Added {df[mandays_col].sum()} mandays from {result.get('function_name', 'unknown')}")
-                            
-                        except Exception as e:
-                            print(f"Error parsing CSV: {str(e)}")
-                            continue
-                    # Handle dictionary format (keeping for backward compatibility)
-                    elif isinstance(result_content, dict) and 'mandays' in result_content:
-                        total_mvp_mandays += float(result_content['mandays'])
+                            total_mvp_mandays += float(item[manday_key])
+                        except (ValueError, TypeError):
+                            print(f"Warning: Invalid mandays value: {item[manday_key]}")
         
         # Calculate costs based on total mandays
         total_mvp_cost = 1500 * total_mvp_mandays
-        estimated_mvp_months = total_mvp_mandays/30
+        estimated_mvp_months = total_mvp_mandays / 30
 
         return (
             total_mvp_mandays, 
             total_mvp_cost, 
             estimated_mvp_months
         )
+        
     except Exception as e:
-        print(f"Error calculating mandays and costs: {str(e)}")
-        return tuple([None] * 3)
+        print(f"Error calculating MVP mandays and costs: {str(e)}")
+        return 0, 0, 0
 
 def create_new_session():
     """Create a new session in the database and return the session_id"""

event_handler.py

@@ -75,21 +75,21 @@ def generate_step_2_c(progress=gr.Progress()) -> Generator[Tuple[str, list], Any
         print(f"Error during generation: {str(e)}")
         yield f"Error during generation: {str(e)}", []
         
-def generate_step_2_d(progress=gr.Progress()) -> Generator[Tuple[str, list], Any, None]:
+def generate_step_2_d(progress=gr.Progress()) -> Generator[Tuple[str, list, str], Any, None]:
     """Generate content using the Project instance"""
     try:
         # Initialize results for this step
         step_results = []
 
         # Generate mandays estimate, yielding results as they're generated
-        for status_msg, result in state.quotation_project.generate_mandays_estimate(progress):
+        for status_msg, result , quotation_cost in state.quotation_project.generate_mvp_mandays(progress):
             step_results.append(result)
             state.generation_results['step_2_d'] = step_results
-            yield status_msg, step_results
+            yield status_msg, step_results , quotation_cost
 
     except Exception as e:
         print(f"Error during generation: {str(e)}")
-        yield f"Error during generation: {str(e)}", []
+        yield f"Error during generation: {str(e)}", [] , None
         
 def generate_step_3(progress=gr.Progress()) -> Generator[Tuple[str, list], Any, None]:
     """Generate content using the Project instance"""
@@ -204,7 +204,6 @@ def upload_to_gdrive(folder_name, generation_result, progress=gr.Progress()):
         return f"Failed to upload files. Error: {e}"
 
 
-
 def setup_all_handlers(step_buttons, all_components, progress_update, quotation_cost=None, recalc_btn=None, upload_drive_btn=None, upload_notion_btn=None, project_name=None, generation_results=None):
     """Set up all step handlers with the provided UI components"""
     # Modified button click chain
@@ -235,6 +234,12 @@ def setup_all_handlers(step_buttons, all_components, progress_update, quotation_
     
     step_buttons['Step 2.4 : Generate MVP Mandays'].click(
         fn=generate_step_2_d,
+        outputs=[progress_update, generation_results , quotation_cost],
+        queue=True
+    )
+    
+    step_buttons['Step 3 : Final Documentation'].click(
+        fn=generate_step_3,
         outputs=[progress_update, generation_results],
         queue=True
     )
@@ -267,8 +272,8 @@ def create_render_results(step, generation_results):
         step_to_state_key = {
             "Step 2.1 : Generate Mandays": "step_2_a",
             "Step 2.2 : Analyze MVP Components": "step_2_b",
-            "Step 2.3 : Generate MVP Mandays": "step_2_c",
-            "Step 2.4 : Recalculate MVP Mandays": "step_2_d",
+            "Step 2.3 : Recalculate MVP Mandays": "step_2_c",
+            "Step 2.4 : Generate MVP Mandays": "step_2_d",
         }
         
         # Get the relevant results based on the step
@@ -313,10 +318,21 @@ def create_render_results(step, generation_results):
                 
                 # Special handling for Step 2 results
                 if step.startswith("Step 2"):
-                    with gr.Accordion(f"{description}", open=True):
-                        if isinstance(result, str):
+                    with gr.Accordion(f"{description}", open=False):
+                        if isinstance(result, dict) and any(key.endswith('_dataframe') for key in result.keys()):
+                            # Handle multiple dataframes
+                            for key, data in result.items():
+                                if key.endswith('_dataframe'):
+                                    df = pd.DataFrame(data)
+                                    result_components.append(
+                                        gr.Dataframe(
+                                            value=df,
+                                            label=key.replace('_dataframe', '').replace('_', ' ').title(),
+                                            interactive=False
+                                        )
+                                    )
+                        elif isinstance(result, str):
                             try:
-                                # Convert markdown table to dataframe
                                 df = pd.read_csv(
                                     StringIO(result.replace('|', ',').replace('\n\n', '\n')), 
                                     sep=',', 

prompt_configs.py

@@ -1124,867 +1124,790 @@ PROMPTS = {
             )
         }
     ),
-    
-    "generate_page_MVP_prd": PromptConfig(
+        
+    "analyze_planning_testing_mandays": PromptConfig(
         prompt=
         """
-        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
-        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
-        2. **Revised Mandays Estimates**: Incorporate the specific MVP components, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
+        You are an experienced project manager tasked with analyzing the provided planning and testing mandays estimates. Your goal is to identify the highest priority components that must be completed to build the MVP. Focus on components that deliver **immediate value to users** and are **critical for the core functionality** of the product.
         
-        Follow these instructions:
-        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
-        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
-        - Do not add any context or assumptions beyond the provided inputs.
-        - Do not exclude any details from the inputs.
-        - Structure the document to ensure clarity, logical flow, and readability and use tabular format whenever possible.
-        - Use the title "Project Requirements" for the document.
+        Objective:
+        Identify the highest priority planning and testing components that are critical for the MVP's core functionality and deliver immediate value to the business. Exclude all non-critical components that do not directly contribute to the MVP's primary functionality.
         
-        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
+        Key Guidelines:
+        - Focus on Core Functionality: Only include components that are essential for the MVP to function and deliver immediate value to users.
+        - Exclude Non-Critical Components: Do not include components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is not absolutely necessary for the MVP.
+        - Prioritize Business Value: Ensure the selected components align with the business's core objectives and deliver measurable value.
+        - Minimalistic Approach: Focus on the least effort required to deliver the most value.
+        
+        Output Format Requirements:
+        - Generate a CSV with EXACTLY these column headers: "component,mandays,description"
+        - Each row must have all three columns filled
+        - Numeric values should not be quoted
+        - Text values must be enclosed in double quotes
+        - No empty rows or missing values
+        
+        Return only the CSV content, no code blocks or additional text.
         """,
-        inputs=["generated_prd" , "revised_mandays_estimates"],
-        outputs=["generated_mvp_prd"],
+        inputs=["generated_plan_test_mandays"],
+        outputs=["identified_planning_testing_components"],
         model=ModelType.O1_MINI,
-        description="Step 3.1 : Generate MVP PRD",
-        step="Step 3 : Final Documentation",
+        description="Step 2.2 : MVP Plan_Test Analysis",
+        step='Step 2 : Mandays & Quotation',
+        sub_step="Step 2.2 : Analyze MVP Components",
         ui={
-            "mvp_prd_prompt_editor": UIConfig(
+            "mvp_planning_testing_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD System Prompt",
+                label="MVP Plan_Test Analysis Prompt",
                 lines=20,
                 interactive=True
             ),
-            "generated_mvp_prd_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD Output",
+            "mvp_planning_testing_dataframe": UIConfig(
+                component_type=UIComponentType.DATAFRAME,
+                label="MVP Plan_Test Analysis Components",
                 lines=20,
-                visible=True
-            ),
-            "generated_mvp_prd_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="MVP PRD Output",
-                visible=True,
-                show_copy_button=True
+                interactive=True
             )
         }
     ),
     
-    "generate_engage_MVP_prd": PromptConfig(
+    "analyze_development_mandays": PromptConfig(
         prompt=
         """
-        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
-        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
-        2. **Revised Mandays Estimates**: Incorporate the specific MVP components & intents, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
+        You are an experienced project manager tasked with analyzing the provided development mandays estimates. Your goal is to assign a priority level to each development component based on its importance to the MVP's core functionality and business value. Focus exclusively on components that deliver immediate value to users and are critical for the core functionality of the product.
         
-        Follow these instructions:
-        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
-        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
-        - Do not add any context or assumptions beyond the provided inputs.
-        - Do not exclude any details from the inputs.
-        - Structure the document to ensure clarity, logical flow, and readability and structure tabular format if necessary.
-        - Use the title "Project Requirements" for the document.
+        Key Guidelines:
+        - **Focus on Core Functionality:** Assign priority levels based on how essential each component is for the MVP to function and deliver immediate value to users.
+        - **Exclude Non-Critical Considerations:** Do not label components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
+        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
+        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
+        - **Assign Priority Levels:** Label each development component as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
         
-        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
+        Objective:
+        Assign a priority level ("high," "medium," or "low") to each development component, ensuring the output reflects the importance of each component to the MVP's core functionality and business value. Retain all original components in the list.
+        
+        Important Notes:
+        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
+        - Do not exclude any components from the list, even if they are low priority.
+        - Only assign "high" priority to components that are absolutely necessary for the MVP to function.
+
+        Output Format Requirements:
+        Convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "component","subcomponent","mandays","description". Follow these rules:
+        
+        Enclose all text values, including the column headers, in double quotes ("").
+        Retain numeric values as-is, without any quotes.
+        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
+        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
         """,
-        inputs=["generated_prd" , "revised_mandays_estimates"],
-        outputs=["generated_mvp_prd"],
+        inputs=["generated_dev_mandays"],
+        outputs=["identified_development_components"],
         model=ModelType.O1_MINI,
-        description="Step 3.1 : Generate MVP PRD",
-        step="Step 3 : Final Documentation",
+        description="Step 2.2 : MVP Development Analysis",
+        step="Step 2 : Mandays & Quotation",
+        sub_step="Step 2.2 : Analyze MVP Components",
         ui={
-            "mvp_prd_prompt_editor": UIConfig(
+            "mvp_development_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD System Prompt",
+                label="MVP Development Analysis Prompt",
                 lines=20,
                 interactive=True
             ),
-            "generated_mvp_prd_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="MVP PRD Output",
+            "mvp_development_dataframe": UIConfig(
+                component_type=UIComponentType.DATAFRAME,
+                label="MVP Development Analysis Components",
                 lines=20,
-                visible=True
-            ),
-            "generated_mvp_prd_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="MVP PRD Output",
-                visible=True,
-                show_copy_button=True
+                interactive=True
             )
         }
     ),
-
-    "generate_page_BD_SOW": PromptConfig(
+        
+    "analyze_MVP_intents": PromptConfig(
         prompt=
         """
-        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
-        
-        ### **Scope of Work (SOW)**
-        
-        #### **1. Project Background**
-        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
-        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
-        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentences.
-        
-        #### **2. Project Objective**
-        - Clearly define the project's primary goals and what constitutes success, using the following structure:
-        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
-        - Outcomes: Describe tangible deliverables and metrics for success.
-        
-        #### **3. Project Buyers & Stakeholders**
-        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
-        - Identify their name and roles in the project, using a table.
-        
-        #### **4. System Flow**
-        - Provide description of how the system components interact, describing what each module does and how it works.
-        - Use one of the following:
-        - Visual Representation: Diagram illustrating workflows or data flows between modules.
-        - Textual Description: Detailed explanation of the processes and transitions
-        - Use bullet point, ensure simplicity and avoid overly technical language.
-        
-        #### **5. Modules and Functional Requirements Breakdown**
-        - LEAVE THIS BLANK
-        
-        #### **6. Acceptance Criteria**
-        - Define conditions to be met, including specific, measurable criteria for project completion:
-        - Link each deliverable/module to its validation or testing process (e.g., UAT).
-        - Table format with the following column:
-        - Deliverable (e.g. Field Matching Automation module)
-        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status accordingly)
-        
-        #### **7. Assumptions and Pre-requisites**
-        - List all planning-phase assumptions and pre-requisites, grouped into:
-        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
-        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
-        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
-        - Be written in clear, concise language.
-        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
-        - Be specific and actionable.
-        - Reference who is responsible and what needs to be done.
+        You are an experienced project manager tasked with analyzing the provided intents mandays estimates. Your goal is to assign a priority level to each intents based on its importance to the MVP's core functionality and business value. Focus exclusively on intents that deliver immediate value to users and are critical for the core functionality of the product.
         
-        #### **8. Proposed Timeline**
-        - Provide a project timeline, including:
-        - Milestone
-        - Expected Date/Duration
-        - Outcome/Deliverable
-        - Use a Gantt chart or table to visualize the timeline.
-        - Ensure the output are clean, organized, and easy to read.
+        Key Guidelines:
+        - **Focus on Core Functionality:** Assign priority levels based on how essential each intents is for the MVP to function and deliver immediate value to users.
+        - **Exclude Non-Critical Considerations:** Do not label intents related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
+        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
+        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
+        - **Assign Priority Levels:** Label each development intents as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
         
-        #### **9. Commercial**
-        Summarize the project's commercial details in the following subsections:
-        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
-        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
-        - Payment Terms: Include a text description of payment terms:
-        - Milestones: Specify at which stages payments are due
-        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
-        - Other Terms: Mention late payment fees or additional terms, if applicable
-        - Output Format for tables: {Service}, {Fee} (leave amount blank)
+        Objective:
+        Assign a priority level ("high," "medium," or "low") to each development intents , ensuring the output reflects the importance to the MVP's core functionality and business value. Retain all original components in the list.
         
-        #### **10. Sign-Off**
-        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
-        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
-        - Provide placeholder for each party (Company):
-        - Signature
-        - Name
-        - Position
-        - Date
+        Important Notes:
+        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
+        - Do not exclude any intents rom the list, even if they are low priority.
+        - Only assign "high" priority to intents that are absolutely necessary for the MVP to function.
         
-        #### **Guidelines**
-        - Use bullet points for clarity.
-        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
-        - Maintain structured sections and tables for readability.
+        Output Format Requirements:
+        Convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "intent_type", "intent", and "workflow". Follow these rules:
         
-        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
+        Enclose all text values, including the column headers, in double quotes ("").
+        Retain numeric values as-is, without any quotes.
+        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
+        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
         """,
-        inputs=[
-            "generated_prd",
-            "generated_plan_test_components",
-            "reformatted_dev_components",
-            "quotation_cost" 
-        ],
-        outputs=["generated_BD_SOW"],
+        inputs=["generated_intent_list"],
+        outputs=["identified_mvp_intents"],
         model=ModelType.O1_MINI,
-        description="Step 3.2 : Generate Business Development SOW",
-        step="Step 3 : Final Documentation",
+        description="Step 2.2 : MVP Intent Analysis",
+        step='Step 2 : Mandays & Quotation',
+        sub_step="Step 2.2 : Analyze MVP Components",
         ui={
-            "BD_SOW_prompt_editor": UIConfig(
+            "mvp_intents_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="BD SOW Generator Prompt",
+                label="MVP Intent Analysis Prompt",
                 lines=20,
                 interactive=True
             ),
-            "generated_BD_SOW_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="BD SOW",
+            "mvp_intents_dataframe": UIConfig(
+                component_type=UIComponentType.DATAFRAME,
+                label="MVP Intent Analysis Components",
                 lines=20,
-                visible=True
-            ),
-            "generated_BD_SOW_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="BD SOW",
-                visible=True,
-                show_copy_button=True
+                interactive=True
             )
         }
     ),
     
-    "generate_engage_BD_SOW": PromptConfig(
+    "recalculate_page_MVP_mandays": PromptConfig(
         prompt=
         """
-        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
+        Based on the identified priority components from the previous analysis, your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
         
-        ### **Scope of Work (SOW)**
+        Objective:
+        Reread the entire PRD to identify the timelimit of the MVP, then Recalculate the manday estimates for the identified priority development components to ensure they fit within the timeline specified in the Project Requirement Document (PRD) to build the MVP. Adjust development mandays while maintaining feasibility and ensuring core functionality delivery.
         
-        #### **1. Project Background**
-        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
-        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
-        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentences.
-        
-        #### **2. Project Objective**
-        - Clearly define the project's primary goals and what constitutes success, using the following structure:
-        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
-        - Outcomes: Describe tangible deliverables and metrics for success.
-        
-        #### **3. Project Buyers & Stakeholders**
-        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
-        - Identify their name and roles in the project, using a table.
-        
-        #### **4. System Flow**
-        - Provide description of how the system components interact, describing what each module does and how it works.
-        - Use one of the following:
-        - Visual Representation: Diagram illustrating workflows or data flows between modules.
-        - Textual Description: Detailed explanation of the processes and transitions
-        - Use bullet point, ensure simplicity and avoid overly technical language.
-        
-        #### **5. Modules and Functional Requirements Breakdown**
-        - LEAVE THIS BLANK
-        
-        #### **6. Acceptance Criteria**
-        - Define conditions to be met, including specific, measurable criteria for project completion:
-        - Link each deliverable/module to its validation or testing process (e.g., UAT).
-        - Table format with the following column:
-        - Deliverable (e.g. Field Matching Automation module)
-        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status accordingly)
-        
-        #### **7. Assumptions and Pre-requisites**
-        - List all planning-phase assumptions and pre-requisites, grouped into:
-        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
-        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
-        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
-        - Be written in clear, concise language.
-        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
-        - Be specific and actionable.
-        - Reference who is responsible and what needs to be done.
-        
-        #### **8. Proposed Timeline**
-        - Provide a project timeline, including:
-        - Milestone
-        - Expected Date/Duration
-        - Outcome/Deliverable
-        - Use a Gantt chart or table to visualize the timeline.
-        - Ensure the output are clean, organized, and easy to read.
-        
-        #### **9. Commercial**
-        Summarize the project's commercial details in the following subsections:
-        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
-        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
-        - Payment Terms: Include a text description of payment terms:
-        - Milestones: Specify at which stages payments are due
-        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
-        - Other Terms: Mention late payment fees or additional terms, if applicable
-        - Output Format for tables: {Service}, {Fee} (leave amount blank)
-        
-        #### **10. Sign-Off**
-        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
-        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
-        - Provide placeholder for each party (Company):
-        - Signature
-        - Name
-        - Position
-        - Date
+        Key Guidelines:
+        1. Convert Time Estimates: Convert all time estimates into raw mandays:
+        - 1 week = 7 mandays
+        - 1 month = 28-31 mandays
+        - If input is in days, use as is.
+        - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
+        2. **Preserve All Components:** Do not remove any components from the list, even if they are low priority.
+        3. **Adjust Mandays Based on Priority:**
+        - For **high priority components**, allocate the majority of mandays (eg: 1-3) to ensure critical functionalities are minimally viable. However , components such as authentication , security , etc. can be set to 0.
+        - For **medium priority components**, allocate minimal mandays (eg: 1-2) or set them to 0, as these can be deferred without impacting core functionalities.
+        - For **low priority components**, set mandays to 0, as these are not essential for the MVP.
+        4.  Retain Planning/Testing Components: All identified planning and testing components must be retained in the list but have their mandays set to 0. Do not remove them.
+        5. **Iterative Adjustment:** If the total mandays for the development components still exceed the MVP timeline after the first adjustment, further reduce or set the mandays to 0 on high and medium priority components if necessary until the total fits within the timeline.
+        - **MVP Timeline Constraint:** Ensure the final total mandays do not exceed the MVP timeline.
+        6. Justify Adjustments: Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
         
-        #### **Guidelines**
-        - Use bullet points for clarity.
-        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
-        - Maintain structured sections and tables for readability.
+        Output Format Requirements:
+        - Provide a revised list of development components with updated mandays estimates.
+        - Include the "Priority" column for reference.
+        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
+        - Ensure the output is concise and actionable.
         
-        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
+        Important Notes:
+        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components while keeping high priority components as intact as possible.
+        - Do not remove any components from the list, even if their mandays are reduced to 0.
         """,
-        inputs=[
-            "generated_prd",
-            "generated_plan_test_components",
-            "reformatted_dev_components",
-            "generated_intent_list",
-            "quotation_cost" 
-        ],
-        outputs=["generated_BD_SOW"],
+        inputs=["identified_planning_testing_components", "identified_development_components" , "generated_prd"],
+        outputs=["revised_mandays_estimates"],
         model=ModelType.O1_MINI,
-        description="Step 3.2 : Generate Business Development SOW",
-        step="Step 3 : Final Documentation",
+        description="Step 2.3 : MVP Mandays Recalculation",
+        step="Step 2 : Mandays & Quotation",
+        sub_step="Step 2.3 : Recalculate MVP Mandays",
         ui={
-            "BD_SOW_prompt_editor": UIConfig(
+            "mandays_recalculation_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="BD SOW Generator Prompt",
+                label="MVP Mandays Recalculation Prompt",
                 lines=20,
                 interactive=True
             ),
-            "generated_BD_SOW_text": UIConfig(
+            "page_mandays_recalculation_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="BD SOW",
-                lines=20,
+                label="MVP Mandays Recalculation",
+                interactive=True,
                 visible=True
             ),
-            "generated_BD_SOW_markdown": UIConfig(
+            "page_mandays_recalculation_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
-                label="BD SOW",
-                visible=True,
-                show_copy_button=True
-            )
-        }
-    ),
-
-    "generate_Tech_SOW": PromptConfig(
-        prompt=
-        """
-        As an experienced project manager with over 20 years of expertise, you are tasked to create a detailed Scope of Work (SOW) document in JSON format. The JSON output should contain markdown-formatted strings as values for each section of the SOW. Analyze the provided project component list and scope document to generate the following sections:
-        
-        ### **Scope of Work (SOW)**
-        
-        #### **1. Scope Summary**
-        - Provide a concise, high-level overview of the project scope. Divide it into three subsections:
-        - In Scope:
-        - List all deliverables, functionalities, and modules included in the project.
-        - Be specific about what will be developed, implemented, or delivered.
-        - Include MVP components (e.g., basic features, functionality, UI, document processing).
-        - Assumptions:
-        - Highlight key project-specific assumptions that the project relies on.
-        - Dependencies:
-        - List all internal and external dependencies required for the project's success.
-        - Include any third-party integrations, resources, or timelines that the project depends on.
-        
-        #### **2. Modules and Functional Requirements Breakdown**
-        - Break down the project into modules or components.
-        - Prsent the details in a succinct and client-friendly table with the following column:
-        - Module
-        ii. Functionalities/Features
-        iii. Notes for any special considerations or constraints (e.g., 'Supports files up to 100MB').
-        - Use clear, concise, non-technical language. (e.g., 'Drag-and-drop support for PDFs, Excel, CSV; progress indicators'). Avoid excessive detail.
-        - Include MVP components as part of the breakdown and provide clear functionalities related to those (e.g., basic document upload, UI features, data processing).
-        
-        #### **3. Out of Scope**
-        - Explicitly define what is excluded from the project's scope. This may include any functionalities, tasks, or deliverables.
-        - Ensure clarity to prevent future misunderstandings.
-        
-        #### **4. System Flow**
-        - Provide a detailed, step-by-step description of how the system components interact.
-        - For each component or module:
-        - Describe what it does and how it works, including both success and unsuccessful scenarios
-        - Explain how it interacts with other components
-        - Include MVP-related components in the system flow, describing their function and interaction within the MVP's framework.
-        
-        Output Requirements:
-        Just return the json object and nothing else, omit code guards ```, where each key represents a section of the SOW, and the value is a markdown-formatted string for that section.
-        Use clear, concise, and client-friendly language. Avoid excessive technical jargon unless necessary.
-        Example JSON Output:
-        {
-        "scope_summary": <markdown content>,
-        "modules_and_functional_requirements": <markdown content>,
-        "out_of_scope": <markdown content>,
-        "system_flow": <markdown content>
-        }
-        """,
-        inputs=["generated_plan_test_components","reformatted_dev_components","revised_mandays_estimates"],
-        outputs=["generated_Tech_SOW"],
-        model=ModelType.O1_MINI,
-        description="Step 3.3 : Generate Technical SOW",
-        step="Step 3 : Final Documentation",
-        ui={
-            "Tech_SOW_prompt_editor": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW Generator Prompt",
-                lines=20,
-                interactive=True
-            ),
-            "generated_Tech_SOW_text": UIConfig(
-                component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW",
-                lines=20,
+                label="MVP Mandays Recalculation",
+                interactive=True,
                 visible=True
-            ),
-            "generated_Tech_SOW_markdown": UIConfig(
-                component_type=UIComponentType.MARKDOWN,
-                label="Technical SOW",
-                visible=True,
-                show_copy_button=True
             )
         }
     ),
     
-    "generate_engage_Tech_SOW": PromptConfig(
+    "recalculate_engage_MVP_mandays": PromptConfig(
         prompt=
         """
-        As an experienced project manager with over 20 years of expertise, you are tasked to create a detailed Scope of Work (SOW) document in JSON format. The JSON output should contain markdown-formatted strings as values for each section of the SOW. Analyze the provided project component list and scope document to generate the following sections:
-        
-        ### **Scope of Work (SOW)**
-        
-        #### **1. Scope Summary**
-        - Provide a concise, high-level overview of the project scope. Divide it into three subsections:
-        - In Scope:
-        - List all deliverables, functionalities, and modules included in the project.
-        - Be specific about what will be developed, implemented, or delivered.
-        - Include MVP components (e.g., basic features, functionality, UI, document processing).
-        - Assumptions:
-        - Highlight key project-specific assumptions that the project relies on.
-        - Dependencies:
-        - List all internal and external dependencies required for the project's success.
-        - Include any third-party integrations, resources, or timelines that the project depends on.
+        Based on the identified priority components and the identified priority intent list from the previous analysis , your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
         
-        #### **2. Modules and Functional Requirements Breakdown**
-        - Break down the project into modules or components.
-        - Prsent the details in a succinct and client-friendly table with the following column:
-        - Module
-        ii. Functionalities/Features
-        iii. Notes for any special considerations or constraints (e.g., 'Supports files up to 100MB').
-        - Use clear, concise, non-technical language. (e.g., 'Drag-and-drop support for PDFs, Excel, CSV; progress indicators'). Avoid excessive detail.
-        - Include MVP components as part of the breakdown and provide clear functionalities related to those (e.g., basic document upload, UI features, data processing).
+        Objective:
+        Read the entire PRD and identify the time constraint ; Recalculate the manday estimates for both development components and intents to ensure the total combined mandays fit within the MVP timeline specified in the Project Requirement Document (PRD). Adjust mandays while maintaining feasibility and ensuring core functionality delivery. Retain all components and intents in the list, even if their mandays are set to 0.
         
-        #### **3. Out of Scope**
-        - Explicitly define what is excluded from the project's scope. This may include any functionalities, tasks, or deliverables.
-        - Ensure clarity to prevent future misunderstandings.
+        Key Guidelines:
+        1. Total Combined Mandays Constraint:
+        The combined total mandays for development components and intents must not exceed MVP timeline.
+        Ensure the total is calculated as:
+        Total Combined Mandays = Development Components Mandays + Intents Mandays ≤ MVP timeline.
+        Convert Time Estimates:
+        Convert all time estimates into raw mandays:
+        - 1 week = 7 mandays
+        - 1 month = 28-31 mandays
+        - If input is in days, use as is.
+        - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
+        2. Preserve All Components and Intents:
+        3. Do not remove any components or intents from the list, even if their mandays are set to 0.
+        4. Retain all planning and testing components but set their mandays to 0.
+        5. Adjust Mandays Based on Priority:
+        - For high priority, allocate the majority of mandays to ensure critical functionalities are minimally viable. Significant reductions may be necessary for non-core features (e.g., authentication, security).
+        - For medium priority, allocate minimal mandays or set them to 0, as these can be deferred without impacting core functionalities.
+        - For low priority, set mandays to 0, as these are not essential for the MVP.
+        6. Iterative Adjustment:
+        - If the total combined mandays still exceed the MVP timeline after the first adjustment, further reduce mandays for both high and medium priority components and intents until the total fits within the timeline.
+        - Set mandays to 0 for non-essential components and intents if necessary, but do not remove them from the list.
+        7. Strict Calculation for Intents:
+        Properly calculate the total mandays for development components and MVP intents. Ensure the total combined mandays for both development components and MVP intents DO NOT exceed the MVP timeline.
+        8. Justify Adjustments:
+        - Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
         
-        #### **4. System Flow**
-        - Provide a detailed, step-by-step description of how the system components interact.
-        - For each component or module:
-        - Describe what it does and how it works, including both success and unsuccessful scenarios
-        - Explain how it interacts with other components
-        - Include MVP-related components in the system flow, describing their function and interaction within the MVP's framework.
+        Output Format Requirements:
+        - Provide a revised list of development components and intents with updated mandays estimates.
+        - Include the "Priority" column for reference.
+        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
+        - Retain all components and intents in the list, even if their mandays are set to 0.
+        - Ensure the output is concise and actionable.
         
-        Output Requirements:
-        Just return the json object and nothing else, omit code guards ```, where each key represents a section of the SOW, and the value is a markdown-formatted string for that section.
-        Use clear, concise, and client-friendly language. Avoid excessive technical jargon unless necessary.
-        Example JSON Output:
-        {
-        "scope_summary": <markdown content>,
-        "modules_and_functional_requirements": <markdown content>,
-        "out_of_scope": <markdown content>,
-        "system_flow": <markdown content>
-        }
+        Important Notes:
+        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components and intents while keeping high priority components as intact as possible.
+        - Do not remove any components or intents from the list, even if their mandays are reduced to 0.
         """,
-        inputs=["generated_plan_test_components","reformatted_dev_components","generated_intent_list","mvp_components"],
-        outputs=["generated_Tech_SOW"],
+        inputs=["identified_planning_testing_components", "identified_development_components", "identified_mvp_intents", "generated_prd"],
+        outputs=["revised_mandays_estimates"],
         model=ModelType.O1_MINI,
-        description="Step 3.3 : Generate Technical SOW",
-        step="Step 3 : Final Documentation",
+        description="Step 2.3 : MVP Mandays Recalculation",
+        step="Step 2 : Mandays & Quotation",
+        sub_step="Step 2.3 : Recalculate MVP Mandays",
         ui={
-            "Tech_SOW_prompt_editor": UIConfig(
+            "mandays_recalculation_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW Generator Prompt",
+                label="MVP Mandays Recalculation Prompt",
                 lines=20,
                 interactive=True
             ),
-            "generated_Tech_SOW_text": UIConfig(
+            "engage_mandays_recalculation_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Technical SOW",
-                lines=20,
+                label="MVP Mandays Recalculation",
+                interactive=True,
                 visible=True
             ),
-            "generated_Tech_SOW_markdown": UIConfig(
+            "engage_mandays_recalculation_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
-                label="Technical SOW",
-                visible=True,
-                show_copy_button=True
+                label="MVP Mandays Recalculation",
+                interactive=True,
+                visible=True
             )
         }
     ),
     
-    "analyze_planning_testing_mandays": PromptConfig(
+    "generate_page_MVP_mandays": PromptConfig(
         prompt=
         """
-        You are an experienced project manager tasked with analyzing the provided planning and testing mandays estimates. Your goal is to identify the highest priority components that must be completed to build the MVP. Focus on components that deliver **immediate value to users** and are **critical for the core functionality** of the product.
+        Using the revised mandays estimates from the previous step, format the output into two clearly separated CSV sections: one for Planning/Testing  Components and another for Development  Components.
         
         Objective:
-        Identify the highest priority planning and testing components that are critical for the MVP's core functionality and deliver immediate value to the business. Exclude all non-critical components that do not directly contribute to the MVP's primary functionality.
-        
-        Key Guidelines:
-        - Focus on Core Functionality: Only include components that are essential for the MVP to function and deliver immediate value to users.
-        - Exclude Non-Critical Components: Do not include components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is not absolutely necessary for the MVP.
-        - Prioritize Business Value: Ensure the selected components align with the business's core objectives and deliver measurable value.
-        - Minimalistic Approach: Focus on the least effort required to deliver the most value.
+        Structure the output to clearly delineate the two sections while maintaining the original column structure.
         
         Output Format Requirements:
-        - Generate a CSV with EXACTLY these column headers: "component,mandays,description"
-        - Each row must have all three columns filled
-        - Numeric values should not be quoted
-        - Text values must be enclosed in double quotes
-        - No empty rows or missing values
+        - First Section - Planning & Testing Components:
+        component,mandays,description
+        "Requirements Analysis",0,"Critical user requirements and system specifications"
         
-        Return only the CSV content, no code blocks or additional text.
+        - Second Section - Development Components:
+        component,subcomponent,mandays,description
+        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
+        
+        Important:
+        - Each section must maintain its original column structure.
+        - Sections MUST be separated by the marker: "---SECTION BREAK---".
+        - Include ALL components and NOT change anything.
+        - No empty rows or missing values.
+        - Text values must be in double quotes.
+        - Numbers must not be in quotes.
+        
+        Return only the CSV content with the section break, no additional text or explanations.
         """,
-        inputs=["generated_plan_test_mandays"],
-        outputs=["identified_planning_testing_components"],
+        inputs=["revised_mandays_estimates"],
+        outputs=["generated_MVP_mandays"],
         model=ModelType.O1_MINI,
-        description="Step 2.2 : MVP Plan_Test Analysis",
-        step='Step 2 : Mandays & Quotation',
-        sub_step="Step 2.2 : Analyze MVP Components",
+        description="Step 2.4 : Generate MVP Mandays",
+        step="Step 2 : Mandays & Quotation",
+        sub_step="Step 2.4 : Generate MVP Mandays",
         ui={
-            "mvp_planning_testing_prompt_editor": UIConfig(
+            "generated_MVP_mandays_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Plan_Test Analysis Prompt",
+                label="MVP Mandays Formatting System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "mvp_planning_testing_dataframe": UIConfig(
+            "generated_MVP_mandays_dataframe": UIConfig(
                 component_type=UIComponentType.DATAFRAME,
-                label="MVP Plan_Test Analysis Components",
-                lines=20,
-                interactive=True
+                label="Formatted MVP Mandays",
+                interactive=True,
             )
         }
     ),
-    
-    "analyze_development_mandays": PromptConfig(
+
+    "generate_engage_MVP_mandays": PromptConfig(
         prompt=
         """
-        You are an experienced project manager tasked with analyzing the provided development mandays estimates. Your goal is to assign a priority level to each development component based on its importance to the MVP's core functionality and business value. Focus exclusively on components that deliver immediate value to users and are critical for the core functionality of the product.
-        
-        Key Guidelines:
-        - **Focus on Core Functionality:** Assign priority levels based on how essential each component is for the MVP to function and deliver immediate value to users.
-        - **Exclude Non-Critical Considerations:** Do not label components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
-        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
-        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
-        - **Assign Priority Levels:** Label each development component as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
+        Using the revised mandays estimates from the previous step, format the output into three clearly separated CSV sections: one for Planning/Testing Components, one for Development Components, and another for MVP Intents.
         
         Objective:
-        Assign a priority level ("high," "medium," or "low") to each development component, ensuring the output reflects the importance of each component to the MVP's core functionality and business value. Retain all original components in the list.
+        Structure the output to clearly delineate the three sections while maintaining the original column structure.
         
-        Important Notes:
-        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
-        - Do not exclude any components from the list, even if they are low priority.
-        - Only assign "high" priority to components that are absolutely necessary for the MVP to function.
-
         Output Format Requirements:
-        Convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "component","subcomponent","mandays","description". Follow these rules:
+        - First Section - Planning & Testing Components:
+        component,mandays,description
+        "Requirements Analysis",0,"Critical user requirements and system specifications"
         
-        Enclose all text values, including the column headers, in double quotes ("").
-        Retain numeric values as-is, without any quotes.
-        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
-        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
+        - Second Section - Development Components:
+        component,subcomponent,mandays,description
+        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
+        
+        - Third Section - MVP Intents:
+        intent_type,intent,workflow,mandays
+        "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details from user input → 3. Save order to database → 4. Confirm creation to user",0.3
+        
+        Important:
+        - Each section must maintain its original column structure.
+        - Sections MUST be separated by the marker: "---SECTION BREAK---".
+        - Include ALL the components and intents.
+        - No empty rows or missing values.
+        - Text values must be in double quotes.
+        - Numbers must not be in quotes.
+        
+        Return only the CSV content with the section break, no additional text or explanations.
         """,
-        inputs=["generated_dev_mandays"],
-        outputs=["identified_development_components"],
+        inputs=["revised_mandays_estimates"],
+        outputs=["generated_MVP_mandays"],
         model=ModelType.O1_MINI,
-        description="Step 2.2 : MVP Development Analysis",
+        description="Step 2.4 : Generate MVP Mandays",
         step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.2 : Analyze MVP Components",
+        sub_step="Step 2.4 : Generate MVP Mandays",
         ui={
-            "mvp_development_prompt_editor": UIConfig(
+            "generated_MVP_mandays_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Development Analysis Prompt",
+                label="MVP Mandays Formatting System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "mvp_development_dataframe": UIConfig(
+            "mvp_plan_test_dataframe": UIConfig(
+                component_type=UIComponentType.DATAFRAME,
+                label="MVP Planning & Testing Components",
+                interactive=True,
+                visible=True
+            ),
+            "mvp_dev_dataframe": UIConfig(
+                component_type=UIComponentType.DATAFRAME,
+                label="MVP Development Components",
+                interactive=True,
+                visible=True
+            ),
+            "mvp_intents_dataframe": UIConfig(
                 component_type=UIComponentType.DATAFRAME,
-                label="MVP Development Analysis Components",
-                lines=20,
-                interactive=True
+                label="MVP Intents",
+                interactive=True,
+                visible=True
             )
         }
     ),
-        
-    "analyze_MVP_intents": PromptConfig(
+    
+    "generate_page_MVP_prd": PromptConfig(
         prompt=
         """
-        You are an experienced project manager tasked with analyzing the provided intents mandays estimates. Your goal is to assign a priority level to each intents based on its importance to the MVP's core functionality and business value. Focus exclusively on intents that deliver immediate value to users and are critical for the core functionality of the product.
-        
-        Key Guidelines:
-        - **Focus on Core Functionality:** Assign priority levels based on how essential each intents is for the MVP to function and deliver immediate value to users.
-        - **Exclude Non-Critical Considerations:** Do not label intents related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
-        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
-        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
-        - **Assign Priority Levels:** Label each development intents as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
-        
-        Objective:
-        Assign a priority level ("high," "medium," or "low") to each development intents , ensuring the output reflects the importance to the MVP's core functionality and business value. Retain all original components in the list.
-        
-        Important Notes:
-        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
-        - Do not exclude any intents rom the list, even if they are low priority.
-        - Only assign "high" priority to intents that are absolutely necessary for the MVP to function.
+        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
+        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
+        2. **Revised Mandays Estimates**: Incorporate the specific MVP components, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
         
-        Output Format Requirements:
-        Convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "intent_type", "intent", and "workflow". Follow these rules:
+        Follow these instructions:
+        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
+        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
+        - Do not add any context or assumptions beyond the provided inputs.
+        - Do not exclude any details from the inputs.
+        - Structure the document to ensure clarity, logical flow, and readability and use tabular format whenever possible.
+        - Use the title "Project Requirements" for the document.
         
-        Enclose all text values, including the column headers, in double quotes ("").
-        Retain numeric values as-is, without any quotes.
-        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
-        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
+        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
         """,
-        inputs=["generated_intent_list"],
-        outputs=["identified_mvp_intents"],
+        inputs=["generated_prd" , "generated_MVP_mandays"],
+        outputs=["generated_mvp_prd"],
         model=ModelType.O1_MINI,
-        description="Step 2.2 : MVP Intent Analysis",
-        step='Step 2 : Mandays & Quotation',
-        sub_step="Step 2.2 : Analyze MVP Components",
+        description="Step 3.1 : Generate MVP PRD",
+        step="Step 3 : Final Documentation",
         ui={
-            "mvp_intents_prompt_editor": UIConfig(
+            "mvp_prd_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Intent Analysis Prompt",
+                label="MVP PRD System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "mvp_intents_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="MVP Intent Analysis Components",
+            "generated_mvp_prd_text": UIConfig(
+                component_type=UIComponentType.TEXTBOX,
+                label="MVP PRD Output",
                 lines=20,
-                interactive=True
+                visible=True
+            ),
+            "generated_mvp_prd_markdown": UIConfig(
+                component_type=UIComponentType.MARKDOWN,
+                label="MVP PRD Output",
+                visible=True,
+                show_copy_button=True
             )
         }
     ),
     
-    "recalculate_page_MVP_mandays": PromptConfig(
+    "generate_engage_MVP_prd": PromptConfig(
         prompt=
         """
-        Based on the identified priority components from the previous analysis, your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
-        
-        Objective:
-        Reread the entire PRD to identify the timelimit of the MVP, then Recalculate the manday estimates for the identified priority development components to ensure they fit within the timeline specified in the Project Requirement Document (PRD) to build the MVP. Adjust development mandays while maintaining feasibility and ensuring core functionality delivery.
-        
-        Key Guidelines:
-        1. Convert Time Estimates: Convert all time estimates into raw mandays:
-        - 1 week = 7 mandays
-        - 1 month = 28-31 mandays
-        - If input is in days, use as is.
-        - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
-        2. **Preserve All Components:** Do not remove any components from the list, even if they are low priority.
-        3. **Adjust Mandays Based on Priority:**
-        - For **high priority components**, allocate the majority of mandays (eg: 1-3) to ensure critical functionalities are minimally viable. However , components such as authentication , security , etc. can be set to 0.
-        - For **medium priority components**, allocate minimal mandays (eg: 1-2) or set them to 0, as these can be deferred without impacting core functionalities.
-        - For **low priority components**, set mandays to 0, as these are not essential for the MVP.
-        4.  Retain Planning/Testing Components: All identified planning and testing components must be retained in the list but have their mandays set to 0. Do not remove them.
-        5. **Iterative Adjustment:** If the total mandays for the development components still exceed the MVP timeline after the first adjustment, further reduce or set the mandays to 0 on high and medium priority components if necessary until the total fits within the timeline.
-        - **MVP Timeline Constraint:** Ensure the final total mandays do not exceed the MVP timeline.
-        6. Justify Adjustments: Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
+        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
+        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
+        2. **Revised Mandays Estimates**: Incorporate the specific MVP components & intents, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
         
-        Output Format Requirements:
-        - Provide a revised list of development components with updated mandays estimates.
-        - Include the "Priority" column for reference.
-        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
-        - Ensure the output is concise and actionable.
+        Follow these instructions:
+        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
+        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
+        - Do not add any context or assumptions beyond the provided inputs.
+        - Do not exclude any details from the inputs.
+        - Structure the document to ensure clarity, logical flow, and readability and structure tabular format if necessary.
+        - Use the title "Project Requirements" for the document.
         
-        Important Notes:
-        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components while keeping high priority components as intact as possible.
-        - Do not remove any components from the list, even if their mandays are reduced to 0.
+        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
         """,
-        inputs=["identified_planning_testing_components", "identified_development_components" , "generated_prd"],
-        outputs=["revised_mandays_estimates"],
+        inputs=["generated_prd" , "generated_MVP_mandays"],
+        outputs=["generated_mvp_prd"],
         model=ModelType.O1_MINI,
-        description="Step 2.3 : MVP Mandays Recalculation Prompt",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.3 : Recalculate MVP Mandays",
+        description="Step 3.1 : Generate MVP PRD",
+        step="Step 3 : Final Documentation",
         ui={
-            "mandays_recalculation_prompt_editor": UIConfig(
+            "mvp_prd_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Recalculation Prompt",
+                label="MVP PRD System Prompt",
                 lines=20,
                 interactive=True
             ),
-            "page_mandays_recalculation_text": UIConfig(
+            "generated_mvp_prd_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Recalculation",
-                interactive=True,
+                label="MVP PRD Output",
+                lines=20,
                 visible=True
             ),
-            "page_mandays_recalculation_markdown": UIConfig(
+            "generated_mvp_prd_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
-                label="MVP Mandays Recalculation",
-                interactive=True,
-                visible=True
+                label="MVP PRD Output",
+                visible=True,
+                show_copy_button=True
             )
         }
     ),
-    
-    "recalculate_engage_MVP_mandays": PromptConfig(
+
+    "generate_page_BD_SOW": PromptConfig(
         prompt=
         """
-        Based on the identified priority components and the identified priority intent list from the previous analysis , your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
+        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
         
-        Objective:
-        Read the entire PRD and identify the time constraint ; Recalculate the manday estimates for both development components and intents to ensure the total combined mandays fit within the MVP timeline specified in the Project Requirement Document (PRD). Adjust mandays while maintaining feasibility and ensuring core functionality delivery. Retain all components and intents in the list, even if their mandays are set to 0.
+        ### **Scope of Work (SOW)**
         
-        Key Guidelines:
-        1. Total Combined Mandays Constraint:
-        The combined total mandays for development components and intents must not exceed MVP timeline.
-        Ensure the total is calculated as:
-        Total Combined Mandays = Development Components Mandays + Intents Mandays ≤ MVP timeline.
-        Convert Time Estimates:
-        Convert all time estimates into raw mandays:
-        - 1 week = 7 mandays
-        - 1 month = 28-31 mandays
-        - If input is in days, use as is.
-        - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
-        2. Preserve All Components and Intents:
-        3. Do not remove any components or intents from the list, even if their mandays are set to 0.
-        4. Retain all planning and testing components but set their mandays to 0.
-        5. Adjust Mandays Based on Priority:
-        - For high priority, allocate the majority of mandays to ensure critical functionalities are minimally viable. Significant reductions may be necessary for non-core features (e.g., authentication, security).
-        - For medium priority, allocate minimal mandays or set them to 0, as these can be deferred without impacting core functionalities.
-        - For low priority, set mandays to 0, as these are not essential for the MVP.
-        6. Iterative Adjustment:
-        - If the total combined mandays still exceed the MVP timeline after the first adjustment, further reduce mandays for both high and medium priority components and intents until the total fits within the timeline.
-        - Set mandays to 0 for non-essential components and intents if necessary, but do not remove them from the list.
-        7. Strict Calculation for Intents:
-        Properly calculate the total mandays for development components and MVP intents. Ensure the total combined mandays for both development components and MVP intents DO NOT exceed the MVP timeline.
-        8. Justify Adjustments:
-        - Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
+        #### **1. Project Background**
+        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
+        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
+        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentences.
         
-        Output Format Requirements:
-        - Provide a revised list of development components and intents with updated mandays estimates.
-        - Include the "Priority" column for reference.
-        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
-        - Retain all components and intents in the list, even if their mandays are set to 0.
-        - Ensure the output is concise and actionable.
+        #### **2. Project Objective**
+        - Clearly define the project's primary goals and what constitutes success, using the following structure:
+        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
+        - Outcomes: Describe tangible deliverables and metrics for success.
         
-        Important Notes:
-        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components and intents while keeping high priority components as intact as possible.
-        - Do not remove any components or intents from the list, even if their mandays are reduced to 0.
-        """,
-        inputs=["identified_planning_testing_components", "identified_development_components", "identified_mvp_intents", "generated_prd"],
-        outputs=["revised_mandays_estimates"],
+        #### **3. Project Buyers & Stakeholders**
+        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
+        - Identify their name and roles in the project, using a table.
+        
+        #### **4. System Flow**
+        - Provide description of how the system components interact, describing what each module does and how it works.
+        - Use one of the following:
+        - Visual Representation: Diagram illustrating workflows or data flows between modules.
+        - Textual Description: Detailed explanation of the processes and transitions
+        - Use bullet point, ensure simplicity and avoid overly technical language.
+        
+        #### **5. Modules and Functional Requirements Breakdown**
+        - LEAVE THIS BLANK
+        
+        #### **6. Acceptance Criteria**
+        - Define conditions to be met, including specific, measurable criteria for project completion:
+        - Link each deliverable/module to its validation or testing process (e.g., UAT).
+        - Table format with the following column:
+        - Deliverable (e.g. Field Matching Automation module)
+        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status accordingly)
+        
+        #### **7. Assumptions and Pre-requisites**
+        - List all planning-phase assumptions and pre-requisites, grouped into:
+        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
+        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
+        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
+        - Be written in clear, concise language.
+        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
+        - Be specific and actionable.
+        - Reference who is responsible and what needs to be done.
+        
+        #### **8. Proposed Timeline**
+        - Provide a project timeline, including:
+        - Milestone
+        - Expected Date/Duration
+        - Outcome/Deliverable
+        - Use a Gantt chart or table to visualize the timeline.
+        - Ensure the output are clean, organized, and easy to read.
+        
+        #### **9. Commercial**
+        Summarize the project's commercial details in the following subsections:
+        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
+        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
+        - Payment Terms: Include a text description of payment terms:
+        - Milestones: Specify at which stages payments are due
+        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
+        - Other Terms: Mention late payment fees or additional terms, if applicable
+        - Output Format for tables: {Service}, {Fee} (leave amount blank)
+        
+        #### **10. Sign-Off**
+        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
+        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
+        - Provide placeholder for each party (Company):
+        - Signature
+        - Name
+        - Position
+        - Date
+        
+        #### **Guidelines**
+        - Use bullet points for clarity.
+        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
+        - Maintain structured sections and tables for readability.
+        
+        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
+        """,
+        inputs=[
+            "generated_prd",
+            "generated_plan_test_components",
+            "reformatted_dev_components",
+            "quotation_cost" 
+        ],
+        outputs=["generated_BD_SOW"],
         model=ModelType.O1_MINI,
-        description="Step 2.3 : MVP Mandays Recalculation Prompt",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.3 : Recalculate MVP Mandays",
+        description="Step 3.2 : Generate Business Development SOW",
+        step="Step 3 : Final Documentation",
         ui={
-            "mandays_recalculation_prompt_editor": UIConfig(
+            "BD_SOW_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Recalculation Prompt",
+                label="BD SOW Generator Prompt",
                 lines=20,
                 interactive=True
             ),
-            "engage_mandays_recalculation_text": UIConfig(
+            "generated_BD_SOW_text": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Recalculation",
-                interactive=True,
+                label="BD SOW",
+                lines=20,
                 visible=True
             ),
-            "engage_mandays_recalculation_markdown": UIConfig(
+            "generated_BD_SOW_markdown": UIConfig(
                 component_type=UIComponentType.MARKDOWN,
-                label="MVP Mandays Recalculation",
-                interactive=True,
-                visible=True
+                label="BD SOW",
+                visible=True,
+                show_copy_button=True
             )
         }
     ),
     
-    "generate_page_MVP_mandays": PromptConfig(
+    "generate_engage_BD_SOW": PromptConfig(
         prompt=
         """
-        Using the revised mandays estimates from the previous step, format the output into two clearly separated CSV sections: one for Planning/Testing  Components and another for Development  Components.
+        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
         
-        Objective:
-        Structure the output to clearly delineate the two sections while maintaining the original column structure.
+        ### **Scope of Work (SOW)**
         
-        Output Format Requirements:
-        - First Section - Planning & Testing Components:
-        component,mandays,description
-        "Requirements Analysis",0,"Critical user requirements and system specifications"
+        #### **1. Project Background**
+        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
+        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
+        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentences.
         
-        - Second Section - Development Components:
-        component,subcomponent,mandays,description
-        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
+        #### **2. Project Objective**
+        - Clearly define the project's primary goals and what constitutes success, using the following structure:
+        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
+        - Outcomes: Describe tangible deliverables and metrics for success.
         
-        Important:
-        - Each section must maintain its original column structure.
-        - Sections MUST be separated by the marker: "---SECTION BREAK---".
-        - Include ALL components and NOT change anything.
-        - No empty rows or missing values.
-        - Text values must be in double quotes.
-        - Numbers must not be in quotes.
+        #### **3. Project Buyers & Stakeholders**
+        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
+        - Identify their name and roles in the project, using a table.
         
-        Return only the CSV content with the section break, no additional text or explanations.
+        #### **4. System Flow**
+        - Provide description of how the system components interact, describing what each module does and how it works.
+        - Use one of the following:
+        - Visual Representation: Diagram illustrating workflows or data flows between modules.
+        - Textual Description: Detailed explanation of the processes and transitions
+        - Use bullet point, ensure simplicity and avoid overly technical language.
+        
+        #### **5. Modules and Functional Requirements Breakdown**
+        - LEAVE THIS BLANK
+        
+        #### **6. Acceptance Criteria**
+        - Define conditions to be met, including specific, measurable criteria for project completion:
+        - Link each deliverable/module to its validation or testing process (e.g., UAT).
+        - Table format with the following column:
+        - Deliverable (e.g. Field Matching Automation module)
+        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status accordingly)
+        
+        #### **7. Assumptions and Pre-requisites**
+        - List all planning-phase assumptions and pre-requisites, grouped into:
+        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
+        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
+        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
+        - Be written in clear, concise language.
+        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
+        - Be specific and actionable.
+        - Reference who is responsible and what needs to be done.
+        
+        #### **8. Proposed Timeline**
+        - Provide a project timeline, including:
+        - Milestone
+        - Expected Date/Duration
+        - Outcome/Deliverable
+        - Use a Gantt chart or table to visualize the timeline.
+        - Ensure the output are clean, organized, and easy to read.
+        
+        #### **9. Commercial**
+        Summarize the project's commercial details in the following subsections:
+        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
+        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
+        - Payment Terms: Include a text description of payment terms:
+        - Milestones: Specify at which stages payments are due
+        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
+        - Other Terms: Mention late payment fees or additional terms, if applicable
+        - Output Format for tables: {Service}, {Fee} (leave amount blank)
+        
+        #### **10. Sign-Off**
+        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
+        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
+        - Provide placeholder for each party (Company):
+        - Signature
+        - Name
+        - Position
+        - Date
+        
+        #### **Guidelines**
+        - Use bullet points for clarity.
+        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
+        - Maintain structured sections and tables for readability.
+        
+        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
         """,
-        inputs=["revised_mandays_estimates"],
-        outputs=["generated_MVP_mandays"],
+        inputs=[
+            "generated_prd",
+            "generated_plan_test_components",
+            "reformatted_dev_components",
+            "generated_intent_list",
+            "quotation_cost" 
+        ],
+        outputs=["generated_BD_SOW"],
         model=ModelType.O1_MINI,
-        description="Step 2.4 : Generate MVP Mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.4 : Generate MVP Mandays",
+        description="Step 3.2 : Generate Business Development SOW",
+        step="Step 3 : Final Documentation",
         ui={
-            "generated_MVP_mandays_prompt_editor": UIConfig(
+            "BD_SOW_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Formatting System Prompt",
+                label="BD SOW Generator Prompt",
                 lines=20,
                 interactive=True
             ),
-            "generated_MVP_mandays_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="Formatted MVP Mandays",
-                interactive=True,
+            "generated_BD_SOW_text": UIConfig(
+                component_type=UIComponentType.TEXTBOX,
+                label="BD SOW",
+                lines=20,
+                visible=True
+            ),
+            "generated_BD_SOW_markdown": UIConfig(
+                component_type=UIComponentType.MARKDOWN,
+                label="BD SOW",
+                visible=True,
+                show_copy_button=True
             )
         }
     ),
 
-    "generate_engage_MVP_mandays": PromptConfig(
+    "generate_Tech_SOW": PromptConfig(
         prompt=
         """
-        Using the revised mandays estimates from the previous step, format the output into three clearly separated CSV sections: one for Planning/Testing Components, one for Development Components, and another for MVP Intents.
+        As an experienced project manager with over 20 years of expertise, you are tasked to create a detailed Scope of Work (SOW) document in JSON format. The JSON output should contain markdown-formatted strings as values for each section of the SOW. Analyze the provided project component list and scope document to generate the following sections:
         
-        Objective:
-        Structure the output to clearly delineate the three sections while maintaining the original column structure.
+        ### **Scope of Work (SOW)**
         
-        Output Format Requirements:
-        - First Section - Planning & Testing Components:
-        component,mandays,description
-        "Requirements Analysis",0,"Critical user requirements and system specifications"
+        #### **1. Scope Summary**
+        - Provide a concise, high-level overview of the project scope. Divide it into three subsections:
+        - In Scope:
+        - List all deliverables, functionalities, and modules included in the project.
+        - Be specific about what will be developed, implemented, or delivered.
+        - Include MVP components (e.g., basic features, functionality, UI, document processing).
+        - Assumptions:
+        - Highlight key project-specific assumptions that the project relies on.
+        - Dependencies:
+        - List all internal and external dependencies required for the project's success.
+        - Include any third-party integrations, resources, or timelines that the project depends on.
         
-        - Second Section - Development Components:
-        component,subcomponent,mandays,description
-        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
+        #### **2. Modules and Functional Requirements Breakdown**
+        - Break down the project into modules or components.
+        - Prsent the details in a succinct and client-friendly table with the following column:
+        - Module
+        ii. Functionalities/Features
+        iii. Notes for any special considerations or constraints (e.g., 'Supports files up to 100MB').
+        - Use clear, concise, non-technical language. (e.g., 'Drag-and-drop support for PDFs, Excel, CSV; progress indicators'). Avoid excessive detail.
+        - Include MVP components as part of the breakdown and provide clear functionalities related to those (e.g., basic document upload, UI features, data processing).
         
-        - Third Section - MVP Intents:
-        intent_type,intent,workflow,mandays
-        "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details from user input → 3. Save order to database → 4. Confirm creation to user",0.3
+        #### **3. Out of Scope**
+        - Explicitly define what is excluded from the project's scope. This may include any functionalities, tasks, or deliverables.
+        - Ensure clarity to prevent future misunderstandings.
         
-        Important:
-        - Each section must maintain its original column structure.
-        - Sections MUST be separated by the marker: "---SECTION BREAK---".
-        - Include ALL the components and intents.
-        - No empty rows or missing values.
-        - Text values must be in double quotes.
-        - Numbers must not be in quotes.
+        #### **4. System Flow**
+        - Provide a detailed, step-by-step description of how the system components interact.
+        - For each component or module:
+        - Describe what it does and how it works, including both success and unsuccessful scenarios
+        - Explain how it interacts with other components
+        - Include MVP-related components in the system flow, describing their function and interaction within the MVP's framework.
         
-        Return only the CSV content with the section break, no additional text or explanations.
+        Output Requirements:
+        Just return the json object and nothing else, omit code guards ```, where each key represents a section of the SOW, and the value is a markdown-formatted string for that section.
+        Use clear, concise, and client-friendly language. Avoid excessive technical jargon unless necessary.
+        Example JSON Output:
+        {
+        "scope_summary": <markdown content>,
+        "modules_and_functional_requirements": <markdown content>,
+        "out_of_scope": <markdown content>,
+        "system_flow": <markdown content>
+        }
         """,
-        inputs=["revised_mandays_estimates"],
-        outputs=["generated_MVP_mandays"],
+        inputs=["generated_plan_test_components","reformatted_dev_components","generated_MVP_mandays"],
+        outputs=["generated_Tech_SOW"],
         model=ModelType.O1_MINI,
-        description="Step 2.4 : Generate MVP Mandays",
-        step="Step 2 : Mandays & Quotation",
-        sub_step="Step 2.4 : Generate MVP Mandays",
+        description="Step 3.3 : Generate Technical SOW",
+        step="Step 3 : Final Documentation",
         ui={
-            "generated_MVP_mandays_prompt_editor": UIConfig(
+            "Tech_SOW_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="MVP Mandays Formatting System Prompt",
+                label="Technical SOW Generator Prompt",
                 lines=20,
                 interactive=True
             ),
-            "mvp_plan_test_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="MVP Planning & Testing Components",
-                interactive=True,
-                visible=True
-            ),
-            "mvp_dev_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="MVP Development Components",
-                interactive=True,
+            "generated_Tech_SOW_text": UIConfig(
+                component_type=UIComponentType.TEXTBOX,
+                label="Technical SOW",
+                lines=20,
                 visible=True
             ),
-            "mvp_intents_dataframe": UIConfig(
-                component_type=UIComponentType.DATAFRAME,
-                label="MVP Intents",
-                interactive=True,
-                visible=True
+            "generated_Tech_SOW_markdown": UIConfig(
+                component_type=UIComponentType.MARKDOWN,
+                label="Technical SOW",
+                visible=True,
+                show_copy_button=True
             )
         }
     ),

sample_permutations.py

@@ -66,14 +66,17 @@ GENERATE_MVP_MANDAYS_FUNCTIONS = {
 
 GENERATE_FINAL_DOCUMENT_FUNCTIONS = {
     ConfigurationType.CHATBOT: [
+        "generate_engage_MVP_prd",
         "generate_engage_BD_SOW",
         "generate_Tech_SOW"
     ],
     ConfigurationType.DOCUMENT_EXTRACTION: [
+        "generate_page_MVP_prd",
         "generate_page_BD_SOW",
         "generate_Tech_SOW"
     ],
     ConfigurationType.CHATBOT_AND_DOC: [
+        "generate_engage_MVP_prd",
         "generate_engage_BD_SOW",
         "generate_Tech_SOW"
     ]