Update graph.py

graph.py

@@ -1,4 +1,4 @@
-# graph.py (patched, OUT_DIR-enabled)
+# graph.py (Enhanced with better context passing)
 import json
 import re
 import math
@@ -22,17 +22,14 @@ from docx import Document
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
 from reportlab.lib.styles import getSampleStyleSheet
 
-# --- Configurable output directory (change via ENV if needed) ---
+# --- Configurable output directory ---
 OUT_DIR = os.environ.get("OUT_DIR", "/tmp")
-# Ensure output directory exists
 os.makedirs(OUT_DIR, exist_ok=True)
-# Also ensure a subdir for exported outputs (keeps things organized)
 EXPORTS_DIR = os.path.join(OUT_DIR, "exports")
 os.makedirs(EXPORTS_DIR, exist_ok=True)
 
 # --- Helpers ---
 def ensure_list(state, key):
-    """Return a list from state[key], default [] if missing/None/not-list."""
     v = state.get(key) if state else None
     if v is None:
         return []
@@ -43,7 +40,6 @@ def ensure_list(state, key):
     return [v]
 
 def ensure_int(state, key, default=0):
-    """Return an int from state[key], default if missing/invalid."""
     try:
         v = state.get(key) if state else None
         if v is None:
@@ -53,7 +49,6 @@ def ensure_int(state, key, default=0):
         return default
 
 def sanitize_path(path: str) -> str:
-    """Sanitize/normalize output path for return to UI."""
     return os.path.abspath(path)
 
 # --- Setup & constants ---
@@ -76,7 +71,6 @@ class AgentState(TypedDict):
     draftResponse: str
     qaFeedback: Optional[str]
     approved: bool
-    # Annotate execution_path so Langgraph will treat it as an accumulating field
     execution_path: Annotated[List[str], operator.add]
     rework_cycles: int
     max_loops: int
@@ -86,7 +80,6 @@ class AgentState(TypedDict):
 llm = ChatOpenAI(model="gpt-4o", temperature=0.1, max_retries=3, request_timeout=60)
 
 def parse_json_from_llm(llm_output: str) -> Optional[dict]:
-    """Robustly try to extract JSON object from LLM text."""
     try:
         if not llm_output:
             return None
@@ -108,7 +101,6 @@ def parse_json_from_llm(llm_output: str) -> Optional[dict]:
 KNOWN_ARTIFACT_TYPES = {"notebook","excel","word","pdf","image","repo","script"}
 
 def detect_requested_output_types(text: str) -> Dict:
-    """Heuristic detect requested artifact type from text."""
     if not text:
         return {"requires_artifact": False, "artifact_type": None, "artifact_hint": None}
     t = text.lower()
@@ -129,15 +121,12 @@ def detect_requested_output_types(text: str) -> Dict:
     return {"requires_artifact": False, "artifact_type": None, "artifact_hint": None}
 
 def normalize_experiment_type(exp_type: Optional[str], goal_text: str) -> str:
-    """Map arbitrary LLM returned experiment_type into known set or infer from goal_text."""
     if not exp_type:
         detection = detect_requested_output_types(goal_text or "")
-        return detection.get("artifact_type") or "docx"
+        return detection.get("artifact_type") or "word"
     s = exp_type.strip().lower()
-    # direct mapping heuristics
     if s in KNOWN_ARTIFACT_TYPES:
         return s
-    # common synonyms
     if "notebook" in s or "ipynb" in s:
         return "notebook"
     if "excel" in s or "xlsx" in s or "spreadsheet" in s:
@@ -150,11 +139,10 @@ def normalize_experiment_type(exp_type: Optional[str], goal_text: str) -> str:
         return "repo"
     if "script" in s or "python" in s or ".py" in s:
         return "script"
-    # fallback to detection from goal
     detection = detect_requested_output_types(goal_text or "")
-    return detection.get("artifact_type") or "docx"
+    return detection.get("artifact_type") or "word"
 
-# --- Notebook & artifact builders (use OUT_DIR when out_dir is None) ---
+# --- Notebook & artifact builders ---
 def write_notebook_from_text(llm_text: str, out_dir: Optional[str]=None) -> str:
     out_dir = out_dir or OUT_DIR
     os.makedirs(out_dir, exist_ok=True)
@@ -280,7 +268,7 @@ def build_repo_zip(files_map: Dict[str,str], repo_name: str="generated_app", out
 
 # --- Node functions ---
 def run_triage_agent(state: AgentState):
-    log.info("---  triage ---")
+    log.info("--- TRIAGE ---")
     prompt = f"Analyze the user input. Is it a simple conversational greeting or a task? Respond with 'greeting' or 'task'.\n\nUser Input: \"{state.get('userInput','')}\""
     response = llm.invoke(prompt)
     content = getattr(response, "content", "") or ""
@@ -292,7 +280,7 @@ def run_triage_agent(state: AgentState):
         return {"execution_path": ["Triage Agent"], "status_update": "Request requires a plan. Proceeding..."}
 
 def run_planner_agent(state: AgentState):
-    log.info("--- ✈️ Running Planner Agent ---")
+    log.info("--- PLANNER AGENT ---")
     path = ensure_list(state, 'execution_path') + ["Planner Agent"]
     prompt = (
         f"Analyze the user's request. Provide a high-level plan and estimate the number of LLM calls for one loop. "
@@ -317,7 +305,7 @@ def run_planner_agent(state: AgentState):
     return {"pmPlan": plan_data, "execution_path": path, "status_update": "Plan and cost estimate created. Awaiting approval."}
 
 def run_memory_retrieval(state: AgentState):
-    log.info("--- 🧠 Accessing Long-Term Memory ---")
+    log.info("--- MEMORY RETRIEVAL ---")
     path = ensure_list(state, 'execution_path') + ["Memory Retriever"]
     relevant_mems = memory_manager.retrieve_relevant_memories(state.get('userInput',''))
     if relevant_mems:
@@ -329,7 +317,7 @@ def run_memory_retrieval(state: AgentState):
     return {"retrievedMemory": context, "execution_path": path, "status_update": "Searching for relevant past information..."}
 
 def run_intent_agent(state: AgentState):
-    log.info("--- 🎯 Running Intent Agent ---")
+    log.info("--- INTENT AGENT ---")
     path = ensure_list(state, 'execution_path') + ["Intent Agent"]
     prompt = (f"Refine the user's request into a clear, actionable 'core objective prompt'.\n\nRelevant Memory:\n{state.get('retrievedMemory')}\n\nUser Request: \"{state.get('userInput','')}\"\n\nCore Objective:")
     response = llm.invoke(prompt)
@@ -341,34 +329,97 @@ def run_intent_agent(state: AgentState):
     return {"coreObjectivePrompt": core_obj, **extras, "execution_path": path, "status_update": "Clarifying the main objective..."}
 
 def run_pm_agent(state: AgentState):
-    log.info("--- 👷 Running PM Agent ---")
+    log.info("--- PM AGENT ---")
     current_cycles = ensure_int(state, 'rework_cycles', 0) + 1
     max_loops_val = ensure_int(state, 'max_loops', 0)
     log.info(f"Starting work cycle {current_cycles}/{max_loops_val + 1}")
     path = ensure_list(state, 'execution_path') + ["PM Agent"]
-    feedback = f"QA Feedback (must be addressed): {state.get('qaFeedback')}" if state.get('qaFeedback') else ""
-    prompt = (
-        f"Decompose the core objective into a plan. Determine if code execution or artifact generation is needed and define the goal.\n\n"
-        f"Core Objective: {state.get('coreObjectivePrompt')}\n\n{feedback}\n\n"
-        f"Respond in JSON with keys: 'plan_steps' (list), 'experiment_needed' (bool), 'experiment_type' (optional string), and 'experiment_goal' (str if needed)."
-    )
+    
+    # BUILD COMPREHENSIVE CONTEXT
+    context_parts = [
+        f"=== USER'S ORIGINAL REQUEST ===",
+        f"{state.get('userInput', '')}",
+        f"\n=== CORE OBJECTIVE ===",
+        f"{state.get('coreObjectivePrompt', '')}",
+        f"\n=== RELEVANT MEMORY ===",
+        f"{state.get('retrievedMemory', 'None')}",
+    ]
+    
+    if state.get('qaFeedback'):
+        context_parts.append(f"\n=== QA FEEDBACK (MUST ADDRESS) ===")
+        context_parts.append(f"{state.get('qaFeedback')}")
+        context_parts.append(f"\n=== PREVIOUS PLAN ===")
+        context_parts.append(f"{json.dumps(state.get('pmPlan', {}).get('plan_steps', []), indent=2)}")
+    
+    full_context = "\n".join(context_parts)
+    
+    # ENHANCED PM PROMPT
+    prompt = f"""You are a Project Manager creating a DETAILED, EXECUTABLE plan.
+
+{full_context}
+
+Your task is to create a plan where each step is SPECIFIC and ACTIONABLE:
+- State EXACTLY what will be created/analyzed
+- Specify WHAT information/data will be used
+- Define WHAT approach/method will be applied
+
+Respond in JSON format:
+{{
+    "plan_steps": [
+        "Specific executable step 1 with clear deliverable...",
+        "Specific executable step 2 with clear action...",
+        "..."
+    ],
+    "experiment_needed": true/false,
+    "experiment_type": "notebook|script|excel|word|pdf|repo",
+    "experiment_goal": "Detailed description of artifact content and purpose",
+    "experiment_language": "python|r|java|javascript" (if script),
+    "key_requirements": ["Critical requirements that MUST be met"]
+}}
+
+CRITICAL: Be specific about:
+- Analysis tasks: WHAT to analyze and HOW
+- Code tasks: WHAT functionality to implement
+- Document tasks: WHAT sections/content to include
+- Using any uploaded files or user-provided data
+"""
+    
     response = llm.invoke(prompt)
     plan = parse_json_from_llm(getattr(response, "content", "") or "")
+    
     if not plan:
-        log.warning("PM Agent did not produce JSON — applying heuristic fallback.")
-        plan = {"plan_steps": ["Analyze files", "Create notebook if requested", "Synthesize answers"], "experiment_needed": False}
-    # normalize experiment type
+        log.warning("PM Agent did not produce JSON – applying fallback.")
+        detection = detect_requested_output_types(state.get('userInput', ''))
+        plan = {
+            "plan_steps": [
+                f"Analyze request: {state.get('userInput', '')[:100]}...",
+                "Process relevant information",
+                "Create deliverable with specific details",
+                "Review output quality"
+            ],
+            "experiment_needed": detection.get('requires_artifact', False),
+            "experiment_type": detection.get('artifact_type', 'word'),
+            "experiment_goal": state.get('coreObjectivePrompt', state.get('userInput', ''))
+        }
+    
     exp_type_raw = plan.get('experiment_type') or ""
     plan_goal = plan.get('experiment_goal') or state.get('userInput','') or state.get('coreObjectivePrompt','')
     normalized = normalize_experiment_type(exp_type_raw, plan_goal)
     plan['experiment_type'] = normalized
+    
     if plan.get('experiment_needed') and not plan.get('experiment_goal'):
         plan['experiment_goal'] = plan_goal
-    log.info(f"Generated Plan: Experiment Needed = {plan.get('experiment_needed', False)}, Type = {plan.get('experiment_type')}")
-    return {"pmPlan": plan, "execution_path": path, "rework_cycles": current_cycles, "status_update": "Breaking down the objective into a detailed plan..."}
+    
+    log.info(f"Plan: Steps={len(plan.get('plan_steps', []))}, Experiment={plan.get('experiment_needed')}, Type={plan.get('experiment_type')}")
+    
+    return {
+        "pmPlan": plan, 
+        "execution_path": path, 
+        "rework_cycles": current_cycles, 
+        "status_update": f"Detailed plan created ({len(plan.get('plan_steps', []))} steps)"
+    }
 
 def _extract_code_blocks(text: str, lang_hint: Optional[str]=None) -> List[str]:
-    # prefer specific language fences, fallback to generic fenced blocks
     if lang_hint and "python" in (lang_hint or "").lower():
         blocks = re.findall(r"```python\s*(.*?)\s*```", text, re.DOTALL)
         if blocks:
@@ -377,53 +428,140 @@ def _extract_code_blocks(text: str, lang_hint: Optional[str]=None) -> List[str]:
     return blocks
 
 def run_experimenter_agent(state: AgentState):
-    log.info("--- 🔬 Running Experimenter Agent ---")
+    log.info("--- EXPERIMENTER AGENT ---")
     path = ensure_list(state, 'execution_path') + ["Experimenter Agent"]
     pm = state.get('pmPlan', {}) or {}
+    
     if not pm.get('experiment_needed'):
-        return {"experimentCode": None, "experimentResults": None, "execution_path": path, "status_update": "Proceeding without a code experiment."}
+        return {
+            "experimentCode": None, 
+            "experimentResults": None, 
+            "execution_path": path, 
+            "status_update": "No experiment needed."
+        }
+    
     exp_type = normalize_experiment_type(pm.get('experiment_type'), pm.get('experiment_goal',''))
     goal = pm.get('experiment_goal', 'No goal specified.')
-    response = llm.invoke(
-        f"Produce content for artifact type '{exp_type}' to achieve: {goal}\n"
-        "Return runnable code in fenced code blocks where appropriate, and explanatory text otherwise."
-    )
+    
+    # BUILD COMPREHENSIVE CONTEXT FOR EXPERIMENTER
+    context_parts = [
+        f"=== USER'S ORIGINAL REQUEST ===",
+        f"{state.get('userInput', '')}",
+        f"\n=== CORE OBJECTIVE ===",
+        f"{state.get('coreObjectivePrompt', '')}",
+        f"\n=== EXECUTION PLAN ===",
+        f"{json.dumps(pm.get('plan_steps', []), indent=2)}",
+        f"\n=== KEY REQUIREMENTS ===",
+        f"{json.dumps(pm.get('key_requirements', []), indent=2)}",
+    ]
+    
+    if state.get('retrievedMemory'):
+        context_parts.append(f"\n=== RELEVANT PAST CONTEXT ===")
+        context_parts.append(f"{state.get('retrievedMemory', '')}")
+    
+    if state.get('qaFeedback'):
+        context_parts.append(f"\n=== FEEDBACK TO ADDRESS ===")
+        context_parts.append(f"{state.get('qaFeedback', '')}")
+    
+    full_context = "\n".join(context_parts)
+    
+    # ENHANCED EXPERIMENTER PROMPT
+    enhanced_prompt = f"""You are creating a HIGH-QUALITY {exp_type} artifact.
+
+{full_context}
+
+ARTIFACT GOAL: {goal}
+
+QUALITY REQUIREMENTS:
+1. Use ALL specific details from the user's request
+2. Create PRODUCTION-READY, COMPLETE content (NO templates or placeholders)
+3. Include ACTUAL data, REALISTIC examples, and WORKING implementations
+4. For notebooks: Include markdown explanations, executable code, and visualizations
+5. For scripts: Include error handling, documentation, and real logic
+6. For documents: Provide substantive, detailed content based on context
+7. For analysis: Use specific methodologies and provide concrete insights
+
+Generate complete, high-quality content for '{exp_type}'.
+Use fenced code blocks with language identifiers where appropriate.
+"""
+    
+    response = llm.invoke(enhanced_prompt)
     llm_text = getattr(response, "content", "") or ""
     out_dir = OUT_DIR
-    results = {"success": False, "paths": {}, "stderr": "", "stdout": ""}
+    results = {"success": False, "paths": {}, "stderr": "", "stdout": "", "context_used": len(full_context)}
+    
     try:
         if exp_type == 'notebook':
             nb_path = write_notebook_from_text(llm_text, out_dir=out_dir)
             results.update({"success": True, "paths": {"notebook": sanitize_path(nb_path)}})
-            return {"experimentCode": None, "experimentResults": results, "execution_path": path, "status_update": f"Notebook generated at {nb_path}"}
+            return {
+                "experimentCode": None, 
+                "experimentResults": results, 
+                "execution_path": path, 
+                "status_update": f"Notebook generated ({len(full_context)} chars context)"
+            }
+            
         elif exp_type == 'excel':
             excel_path = write_excel_from_tables(llm_text, out_dir=out_dir)
             results.update({"success": True, "paths": {"excel": sanitize_path(excel_path)}})
-            return {"experimentCode": None, "experimentResults": results, "execution_path": path, "status_update": f"Excel generated at {excel_path}"}
+            return {
+                "experimentCode": None, 
+                "experimentResults": results, 
+                "execution_path": path, 
+                "status_update": f"Excel generated"
+            }
+            
         elif exp_type == 'word':
             docx_path = write_docx_from_text(llm_text, out_dir=out_dir)
             results.update({"success": True, "paths": {"docx": sanitize_path(docx_path)}})
-            return {"experimentCode": None, "experimentResults": results, "execution_path": path, "status_update": f"DOCX generated at {docx_path}"}
+            return {
+                "experimentCode": None, 
+                "experimentResults": results, 
+                "execution_path": path, 
+                "status_update": f"DOCX generated"
+            }
+            
         elif exp_type == 'pdf':
             pdf_path = write_pdf_from_text(llm_text, out_dir=out_dir)
             results.update({"success": True, "paths": {"pdf": sanitize_path(pdf_path)}})
-            return {"experimentCode": None, "experimentResults": results, "execution_path": path, "status_update": f"PDF generated at {pdf_path}"}
+            return {
+                "experimentCode": None, 
+                "experimentResults": results, 
+                "execution_path": path, 
+                "status_update": f"PDF generated"
+            }
+            
         elif exp_type == 'script':
             lang_hint = pm.get('experiment_language') or ("python" if ".py" in goal.lower() else None)
             code_blocks = _extract_code_blocks(llm_text, lang_hint)
+            
             if not code_blocks:
                 code_text = llm_text
             else:
                 code_text = "\n\n# === BLOCK ===\n\n".join(code_blocks)
+            
             script_path = write_script(code_text, language_hint=lang_hint, out_dir=out_dir)
             exec_results = {}
+            
             if script_path.endswith(".py"):
                 try:
-                    exec_results = execute_python_code(open(script_path,"r",encoding="utf-8").read())
+                    exec_results = execute_python_code(code_text)
                 except Exception as e:
                     exec_results = {"stdout":"","stderr":str(e),"success":False}
-            results.update({"success": True, "paths": {"script": sanitize_path(script_path)}, "stdout": exec_results.get("stdout",""), "stderr": exec_results.get("stderr","")})
-            return {"experimentCode": code_text, "experimentResults": results, "execution_path": path, "status_update": f"Script generated at {script_path}"}
+            
+            results.update({
+                "success": True, 
+                "paths": {"script": sanitize_path(script_path)}, 
+                "stdout": exec_results.get("stdout",""), 
+                "stderr": exec_results.get("stderr","")
+            })
+            return {
+                "experimentCode": code_text, 
+                "experimentResults": results, 
+                "execution_path": path, 
+                "status_update": f"Script generated"
+            }
+            
         elif exp_type == 'repo':
             repo_files = {}
             readme = (llm_text[:1000] + "\n\n") if llm_text else "Generated repo"
@@ -434,131 +572,22 @@ def run_experimenter_agent(state: AgentState):
             repo_files["requirements.txt"] = reqs
             zip_path = build_repo_zip(repo_files, repo_name="generated_app", out_dir=out_dir)
             results.update({"success": True, "paths": {"repo_zip": sanitize_path(zip_path)}})
-            return {"experimentCode": None, "experimentResults": results, "execution_path": path, "status_update": f"Repository ZIP created at {zip_path}"}
+            return {
+                "experimentCode": None, 
+                "experimentResults": results, 
+                "execution_path": path, 
+                "status_update": f"Repository ZIP created"
+            }
+            
         else:
-            # safe fallback: write docx
             fallback = write_docx_from_text(llm_text, out_dir=out_dir)
             results.update({"success": True, "paths": {"docx": sanitize_path(fallback)}})
-            return {"experimentCode": None, "experimentResults": results, "execution_path": path, "status_update": f"Fallback DOCX generated at {fallback}"}
-    except Exception as e:
-        log.error(f"Experimenter failed: {e}")
-        results.update({"success": False, "stderr": str(e)})
-        return {"experimentCode": None, "experimentResults": results, "execution_path": path, "status_update": "Error: Experimenter failed."}
-
-def run_synthesis_agent(state: AgentState):
-    log.info("--- ✍️ Running Synthesis Agent ---")
-    
-    # FIX: Defensively ensure state is a dictionary-like object to prevent AttributeError if state is None
-    _state = state or {} 
-    
-    path = ensure_list(_state, 'execution_path') + ["Synthesis Agent"]
-    exp_results = _state.get('experimentResults')
-    results_summary = "No experiment was conducted."
-    artifact_message = ""
-    
-    if exp_results and isinstance(exp_results, dict):
-        paths = exp_results.get("paths") or {}
-        if paths:
-            artifact_lines = []
-            for k,v in paths.items():
-                artifact_lines.append(f"- {k}: `{v}`")
-            artifact_message = "\n\n**Artifacts produced:**\n" + "\n".join(artifact_lines)
-            results_summary = f"Artifacts produced: {list(paths.keys())}"
-        else:
-            results_summary = f"Experiment Output Stdout: {exp_results.get('stdout','')}\nStderr: {exp_results.get('stderr','')}"
+            return {
+                "experimentCode": None, 
+                "experimentResults": results, 
+                "execution_path": path, 
+                "status_update": f"Fallback DOCX generated"
+            }
             
-    prompt = (
-        f"Synthesize all information into a final response.\n\nCore Objective: {_state.get('coreObjectivePrompt', '')}\n\n"
-        f"Plan: {_state.get('pmPlan', {}).get('plan_steps')}\n\n{results_summary}\n\nFinal Response:"
-    )
-    
-    response = llm.invoke(prompt)
-    final_text = getattr(response, "content", "") or ""
-    if artifact_message:
-        final_text = final_text + "\n\n" + artifact_message
-        
-    return {"draftResponse": final_text, "execution_path": path, "status_update": "Putting together the final response..."}
-
-def run_qa_agent(state: AgentState):
-    log.info("--- ✅ Running QA Agent ---")
-    path = ensure_list(state, 'execution_path') + ["QA Agent"]
-    prompt = (f"Review the draft response based on the core objective. Respond ONLY with 'APPROVED' or provide concise feedback for rework.\n\n"
-              f"Core Objective: {state.get('coreObjectivePrompt')}\n\nDraft: {state.get('draftResponse')}")
-    response = llm.invoke(prompt)
-    content = getattr(response, "content", "") or ""
-    if "APPROVED" in content.upper():
-        return {"approved": True, "qaFeedback": None, "execution_path": path, "status_update": "Response approved!"}
-    else:
-        return {"approved": False, "qaFeedback": content or "No specific feedback.", "execution_path": path, "status_update": "Response needs improvement. Reworking..."}
-
-def run_archivist_agent(state: AgentState):
-    log.info("--- 💾 Running Archivist Agent ---")
-    path = ensure_list(state, 'execution_path') + ["Archivist Agent"]
-    summary_prompt = (f"Create a concise summary of this successful task for long-term memory.\n\n"
-                      f"Core Objective: {state.get('coreObjectivePrompt')}\n\nFinal Response: {state.get('draftResponse')}\n\nMemory Summary:")
-    response = llm.invoke(summary_prompt)
-    memory_manager.add_to_memory(getattr(response,"content",""), {"objective": state.get('coreObjectivePrompt')})
-    return {"execution_path": path, "status_update": "Saving key learnings for future reference..."}
-
-def run_disclaimer_agent(state: AgentState):
-    log.warning("--- ⚠️ Running Disclaimer Agent ---")
-    path = ensure_list(state, 'execution_path') + ["Disclaimer Agent"]
-    disclaimer = ("**DISCLAIMER: The process was stopped after exhausting the budget. The following response is the best available draft and may be incomplete.**\n\n---\n\n")
-    final_response = disclaimer + state.get('draftResponse', "No response was generated.")
-    return {"draftResponse": final_response, "execution_path": path, "status_update": "Budget limit reached. Preparing final draft..."}
-
-# --- Decision & Graph ---
-def should_continue(state: AgentState):
-    log.info("--- 🤔 Decision: Is the response QA approved? ---")
-    if state.get("approved"):
-        log.info("Routing to: Archivist (Success Path)")
-        return "archivist_agent"
-    if ensure_int(state, "rework_cycles", 0) > ensure_int(state, "max_loops", 0):
-        log.error(f"BUDGET LIMIT REACHED after {ensure_int(state, 'rework_cycles', 0)-1} cycles.")
-        return "disclaimer_agent"
-    else:
-        log.info("Routing to: PM Agent for rework")
-        return "pm_agent"
-
-def should_run_experiment(state: AgentState):
-    pm = state.get('pmPlan', {}) or {}
-    return "experimenter_agent" if pm.get('experiment_needed') else "synthesis_agent"
-
-# --- Build graphs ---
-triage_workflow = StateGraph(AgentState)
-triage_workflow.add_node("triage", run_triage_agent)
-triage_workflow.set_entry_point("triage")
-triage_workflow.add_edge("triage", END)
-triage_app = triage_workflow.compile()
-
-planner_workflow = StateGraph(AgentState)
-planner_workflow.add_node("planner", run_planner_agent)
-planner_workflow.set_entry_point("planner")
-planner_workflow.add_edge("planner", END)
-planner_app = planner_workflow.compile()
-
-main_workflow = StateGraph(AgentState)
-main_workflow.add_node("memory_retriever", run_memory_retrieval)
-main_workflow.add_node("intent_agent", run_intent_agent)
-main_workflow.add_node("pm_agent", run_pm_agent)
-main_workflow.add_node("experimenter_agent", run_experimenter_agent)
-main_workflow.add_node("synthesis_agent", run_synthesis_agent)
-main_workflow.add_node("qa_agent", run_qa_agent)
-main_workflow.add_node("archivist_agent", run_archivist_agent)
-main_workflow.add_node("disclaimer_agent", run_disclaimer_agent)
-
-main_workflow.set_entry_point("memory_retriever")
-main_workflow.add_edge("memory_retriever", "intent_agent")
-main_workflow.add_edge("intent_agent", "pm_agent")
-main_workflow.add_edge("experimenter_agent", "synthesis_agent")
-main_workflow.add_edge("synthesis_agent", "qa_agent")
-main_workflow.add_edge("archivist_agent", END)
-main_workflow.add_edge("disclaimer_agent", END)
-
-main_workflow.add_conditional_edges("pm_agent", should_run_experiment)
-main_workflow.add_conditional_edges("qa_agent", should_continue, {
-    "archivist_agent": "archivist_agent",
-    "pm_agent": "pm_agent",
-    "disclaimer_agent": "disclaimer_agent"
-})
-main_app = main_workflow.compile()
+    except Exception as e:
+        log.error(f"Experimenter failed: {e}")