Update graph_upgraded.py

graph_upgraded.py

@@ -4,322 +4,321 @@ graph_upgraded.py
 Adds Pragmatist, Governance, Compliance, Observer, and Knowledge Curator agents
 to the existing LangGraph workflow implemented in graph.py
 
-Drop-in: put next to graph.py and call apply_upgrades() during startup.
+Designed to be defensive: attempts to add nodes/edges and ignores duplicates/errors,
+then recompiles the main_app so the new agents are available.
+
+Save next to graph.py and call apply_upgrades() during startup.
 """
 
 import os
 import re
 import json
-import shutil
 import logging
 from datetime import datetime
 from typing import Optional, Dict, Any
 
 # Import existing graph machinery & helpers from your codebase
 import graph as base_graph
-from graph import AgentState, ensure_list, ensure_int, sanitize_path, build_repo_zip
+from graph import AgentState, ensure_list, ensure_int
 from memory_manager import memory_manager
 from logging_config import get_logger
 
 log = get_logger(__name__)
-
-# Reuse llm instance defined in graph.py
 llm = getattr(base_graph, "llm", None)
 
-# --- Augment AgentState: if used as a TypedDict elsewhere, introduce optional keys via runtime awareness.
-# (No static redefinition required; agents read/write these keys safely.)
-NEW_STATE_KEYS = [
-    "pragmatistReport", "governanceReport", "complianceReport",
-    "observerReport", "knowledgeInsights", "insightMetrics"
-]
-
-# --- Utility helpers for the new agents ---
+# --- Utility helpers ---
 
 def simple_cost_feasibility_check(pm_plan: Dict[str, Any]) -> Dict[str, Any]:
     """
-    Lightweight feasibility check:
-      - verifies estimated_cost_usd exists and isn't wildly above a threshold
-      - checks experiment_type and flags heavy artifacts (repo, notebook)
+    Heuristic cost/complexity check for a PM plan.
+    Returns a minimal report dict.
     """
     report = {"ok": True, "notes": []}
-    est_cost = pm_plan.get("estimated_cost_usd", None)
+    try:
+        est_cost = float(pm_plan.get("estimated_cost_usd", 0) or 0)
+    except Exception:
+        est_cost = None
+
     exp_type = pm_plan.get("experiment_type", "word")
-    if est_cost is None:
-        report["notes"].append("No estimated_cost_usd provided — assume low confidence.")
+    if est_cost is None or est_cost == 0:
+        report["notes"].append("No reliable estimated_cost_usd provided.")
         report["ok"] = False
     else:
-        # Heuristic: if estimated cost > $200, or experiment_type repo, flag for pragmatist review
-        if est_cost > 200:
-            report["notes"].append(f"Estimated cost ${est_cost} > $200 — high-cost project.")
+        if est_cost > 500:
+            report["notes"].append(f"High estimated cost: ${est_cost}. Governance advised.")
             report["ok"] = False
-    if exp_type in ("repo", "notebook", "script") and exp_type != "word":
-        report["notes"].append(f"Artifact type '{exp_type}' implies heavier engineering effort.")
+        elif est_cost > 200:
+            report["notes"].append(f"Moderately high estimated cost: ${est_cost}. Consider simplifications.")
+
+    if exp_type in ("repo", "notebook", "script"):
+        report["notes"].append(f"Artifact type '{exp_type}' indicates engineering-heavy work.")
     return report
 
 def scan_text_for_secrets(text: str) -> Dict[str, Any]:
     """
-    Very small heuristic scanner to detect possible secrets or suspicious tokens.
-    Not a replacement for dedicated secret scanners, but acts as a safety net.
+    Lightweight heuristic scanner for secrets/tokens in text.
+    Not a replacement for dedicated scanners but useful as early warning.
     """
     findings = []
     if not text:
         return {"suspicious": False, "findings": findings}
-    # look for API-like tokens, private keys, or 'password=' patterns
-    token_patterns = [
-        r"AKIA[0-9A-Z]{16}",          # AWS access key style
+    patterns = [
+        r"AKIA[0-9A-Z]{16}",                  # AWS
+        r"-----BEGIN PRIVATE KEY-----",       # private key marker
+        r"AIza[0-9A-Za-z-_]{35}",             # Google style
         r"(?i)secret[_-]?(key|token)\b",
-        r"(?i)password\s*[:=]\s*['\"][^'\"]{6,}['\"]",
-        r"-----BEGIN PRIVATE KEY-----",
-        r"AIza[0-9A-Za-z-_]{35}",     # Google API key style
+        r"(?i)password\s*[:=]\s*['\"][^'\"]{6,}['\"]"
     ]
-    for p in token_patterns:
+    for p in patterns:
         for m in re.finditer(p, text):
             findings.append({"pattern": p, "match": m.group(0)})
-    suspicious = len(findings) > 0
-    return {"suspicious": suspicious, "findings": findings}
+    return {"suspicious": len(findings) > 0, "findings": findings}
 
 def summarize_logs_for_observer(log_paths: Optional[list] = None, sample_lines: int = 200) -> str:
     """
-    Read configured log files (if present) and produce a short textual summary.
-    Uses heuristics: count ERROR/WARNING, sample latest lines.
+    Very small log summarizer: counts ERROR/WARNING and returns last lines.
     """
     if not log_paths:
-        # default to performance log and main log if available
-        log_paths = []
-        # common locations
-        candidates = ["logs/performance.log", "logs/ai_lab.log", "performance.log", "logs/ai_lab.log"]
-        for c in candidates:
-            if os.path.exists(c):
-                log_paths.append(c)
-    summary_parts = []
-    error_count = 0
-    warn_count = 0
+        candidates = ["logs/performance.log", "logs/ai_lab.log", "performance.log"]
+        log_paths = [p for p in candidates if os.path.exists(p)]
+    parts = []
+    errs = 0
+    warns = 0
     for p in log_paths:
         try:
             with open(p, "r", encoding="utf-8", errors="ignore") as fh:
                 lines = fh.readlines()[-sample_lines:]
-                joined = "".join(lines)
-                error_count += joined.upper().count("ERROR")
-                warn_count += joined.upper().count("WARNING")
-                summary_parts.append(f"--- {p} (last {len(lines)} lines) ---\n{joined[:2000]}")
+                content = "".join(lines)
+                errs += content.upper().count("ERROR")
+                warns += content.upper().count("WARNING")
+                parts.append(f"--- {p} (last {len(lines)} lines) ---\n{content[:2000]}")
         except Exception as e:
-            summary_parts.append(f"Could not read {p}: {e}")
-    header = f"Log summary: {error_count} ERROR(s), {warn_count} WARNING(s)"
-    return header + "\n\n" + "\n\n".join(summary_parts)
+            parts.append(f"Could not read {p}: {e}")
+    header = f"Log summary: {errs} ERROR(s), {warns} WARNING(s)"
+    return header + "\n\n" + "\n\n".join(parts)
 
 # --- New agent implementations ---
 
 def run_pragmatist_agent(state: AgentState) -> Dict[str, Any]:
     """
-    Pragmatist: Check feasibility, suggest simplifications, and set a 'pragmatistReport'.
-    Runs after PM and before Governance/Experimenter.
+    Pragmatist Agent:
+    - Performs quick feasibility/cost checks for the PM plan
+    - Optionally asks LLM for 1-5 simplification suggestions
+    - Writes 'pragmatistReport' into state
     """
     log.info(">>> PRAGMATIST AGENT")
     path = ensure_list(state, "execution_path") + ["Pragmatist"]
     pm = state.get("pmPlan", {}) or {}
     report = simple_cost_feasibility_check(pm)
-    # Ask LLM to recommend simplifications if not OK
-    ldr = ""
-    if not report["ok"] and llm:
-        prompt = (
-            "You are a pragmatic engineering reviewer. The plan and context are:\n\n"
-            f"Plan: {json.dumps(pm, indent=2)}\n\n"
-            "Provide up to 5 concrete simplifications / scope-reductions that preserve core value but reduce cost or complexity.\n\n"
-            "Return a JSON: { 'recommendations': [...], 'confidence': 'low|medium|high' }"
-        )
+
+    # If the plan is flagged, ask the LLM for pragmatic simplifications (best-effort)
+    if not report.get("ok", True) and llm:
         try:
+            prompt = (
+                "You are a pragmatic engineering reviewer. Given this plan, suggest up to 5"
+                " concrete simplifications to preserve core user value while reducing cost/complexity.\n\n"
+                f"Plan: {json.dumps(pm, indent=2)}\n\nReturn JSON: {{'recommendations': [...], 'confidence': 'low|medium|high'}}"
+            )
             r = llm.invoke(prompt)
-            ldr = getattr(r, "content", "") or ""
-            parsed = base_graph.parse_json_from_llm(ldr) or {}
-            report["llm_recs"] = parsed
+            content = getattr(r, "content", "") or ""
+            parsed = base_graph.parse_json_from_llm(content)
+            if isinstance(parsed, dict):
+                report["llm_recommendations"] = parsed.get("recommendations") or parsed
+            else:
+                report["llm_recommendations_text"] = content.strip()[:1000]
         except Exception as e:
-            report["llm_recs_error"] = str(e)
-    state_update = {"pragmatistReport": report, "execution_path": path, "status_update": "Pragmatist review complete"}
-    return state_update
+            report["llm_recommendations_error"] = str(e)
+
+    return {"pragmatistReport": report, "execution_path": path, "status_update": "Pragmatist review complete"}
 
 def run_governance_agent(state: AgentState) -> Dict[str, Any]:
     """
-    Governance: Validate budget, SLA, and risk register. Produces 'governanceReport'
-    and an 'approved_for_experiment' boolean.
+    Governance Agent:
+    - Validates budget vs estimated_cost_usd
+    - Considers pragmatistReport notes
+    - Produces governanceReport with approved_for_experiment boolean
     """
     log.info(">>> GOVERNANCE AGENT")
     path = ensure_list(state, "execution_path") + ["Governance"]
     pm = state.get("pmPlan", {}) or {}
     prag = state.get("pragmatistReport", {}) or {}
-    reports = {"budget_ok": True, "issues": [], "approved_for_experiment": True}
-
-    est_cost = pm.get("estimated_cost_usd", None)
-    # Heuristic thresholds (these can be tuned)
-    if est_cost is None:
-        reports["issues"].append("Missing estimated_cost_usd.")
-        reports["budget_ok"] = False
-        reports["approved_for_experiment"] = False
-    else:
-        # flag if cost > budget in state (if budget exists)
-        budget = state.get("budget") or state.get("current_budget") or None
-        if budget:
+    report = {"budget_ok": True, "issues": [], "approved_for_experiment": True}
+
+    try:
+        est = pm.get("estimated_cost_usd", None)
+        if est is None:
+            report["issues"].append("Missing estimated_cost_usd.")
+            report["budget_ok"] = False
+            report["approved_for_experiment"] = False
+        else:
             try:
-                if float(est_cost) > float(budget):
-                    reports["issues"].append(f"Estimated cost ${est_cost} exceeds budget ${budget}.")
-                    reports["approved_for_experiment"] = False
+                est_f = float(est)
+                # If the caller provided a budget in state, enforce it
+                budget = state.get("current_budget") or state.get("budget") or None
+                if budget:
+                    try:
+                        if est_f > float(budget):
+                            report["issues"].append(f"Estimated ${est_f} exceeds budget ${budget}.")
+                            report["approved_for_experiment"] = False
+                    except Exception:
+                        pass
+                if est_f > 1000:
+                    report["issues"].append("Very high estimated cost; manual governance required.")
+                    report["approved_for_experiment"] = False
             except Exception:
-                pass
-        if float(est_cost) > 1000:
-            reports["issues"].append("Very high estimated cost; governance sign-off required.")
-            reports["approved_for_experiment"] = False
+                report["issues"].append("Could not parse estimated_cost_usd.")
+    except Exception as e:
+        report["issues"].append(f"Governance encountered an error: {e}")
+        report["approved_for_experiment"] = False
 
-    # rationalize pragmatist notes
+    # Factor in pragmatist findings
     if prag and not prag.get("ok", True):
-        reports["issues"].append("Pragmatist recommended simplifications.")
-        reports["approved_for_experiment"] = False
+        report["issues"].append("Pragmatist recommended simplifications.")
+        report["approved_for_experiment"] = False
 
-    # Add a light LLM justification summary for governance dashboard
-    rationale = None
+    # LLM-produced rationale (optional, best-effort)
     if llm:
         try:
             prompt = (
-                "You are a governance assistant. Given the following context, produce a short justification (2-3 sentences) "
-                "and list critical risks.\n\n"
-                f"PM Plan: {json.dumps(pm, indent=2)}\n\nPragmatist: {json.dumps(prag, indent=2)}"
+                "You are a governance assistant. Summarize in 2-3 sentences whether the plan is safe to run and list 3 critical risks.\n\n"
+                f"Plan: {json.dumps(pm, indent=2)}\n\nPragmatist: {json.dumps(prag, indent=2)}"
             )
             r = llm.invoke(prompt)
-            rationale = getattr(r, "content", "") or ""
-            # trim
-            rationale = rationale.strip()[:2000]
+            report["rationale"] = getattr(r, "content", "")[:2000]
         except Exception as e:
-            rationale = f"Rationale generation failed: {e}"
+            report["rationale_error"] = str(e)
 
-    reports["rationale"] = rationale
-    state_update = {"governanceReport": reports, "execution_path": path, "status_update": "Governance review complete"}
-    return state_update
+    return {"governanceReport": report, "execution_path": path, "status_update": "Governance review complete"}
 
 def run_compliance_agent(state: AgentState) -> Dict[str, Any]:
     """
-    Compliance: Static checks on experiment results & generated artifacts.
-    - Checks for secrets in text outputs
-    - Flags unsafe file types or missing docs
+    Compliance Agent:
+    - Scans experimentResults' stdout/stderr and files for secrets or suspicious content
+    - Produces complianceReport with suspicious flag and issues
     """
     log.info(">>> COMPLIANCE AGENT")
     path = ensure_list(state, "execution_path") + ["Compliance"]
-    exp_results = state.get("experimentResults", {}) or {}
-    collected_paths = exp_results.get("paths", {}) if isinstance(exp_results, dict) else {}
+    exp = state.get("experimentResults", {}) or {}
     report = {"suspicious": False, "issues": [], "scanned": []}
 
-    # Scan any text content returned in stdout/stderr
-    if isinstance(exp_results, dict):
-        for key in ("stdout", "stderr"):
-            val = exp_results.get(key)
-            if isinstance(val, str) and val.strip():
-                scan = scan_text_for_secrets(val)
-                if scan.get("suspicious"):
-                    report["suspicious"] = True
-                    report["issues"].append({"type": "text_secret", "where": key, "findings": scan["findings"]})
-                report["scanned"].append({"type": "text", "where": key})
-
-    # Scan files referenced in paths (if files exist, sample them)
-    if isinstance(collected_paths, dict):
-        for k, p in collected_paths.items():
-            try:
-                pstr = str(p)
-                if os.path.exists(pstr):
-                    with open(pstr, "r", encoding="utf-8", errors="ignore") as fh:
-                        sample = fh.read(20000)
-                        scan = scan_text_for_secrets(sample)
-                        if scan.get("suspicious"):
-                            report["suspicious"] = True
-                            report["issues"].append({"type": "file_secret", "file": pstr, "findings": scan["findings"]})
-                        report["scanned"].append({"type": "file", "file": pstr})
-                else:
-                    report["scanned"].append({"type": "path", "value": pstr, "exists": False})
-            except Exception as e:
-                report["scanned"].append({"error": str(e), "path": p})
-    # Best-effort check for README / requirements in repo zip outputs
-    if any(str(v).endswith(".zip") for v in collected_paths.values()):
-        report["notes"] = ["Zip-based artifact(s) detected — manual review recommended."]
-
-    state_update = {"complianceReport": report, "execution_path": path, "status_update": "Compliance checks complete"}
-    return state_update
+    # scan stdout/stderr
+    for key in ("stdout", "stderr"):
+        val = exp.get(key)
+        if isinstance(val, str) and val.strip():
+            scan = scan_text_for_secrets(val)
+            if scan.get("suspicious"):
+                report["suspicious"] = True
+                report["issues"].append({"type": "text_secret", "where": key, "findings": scan["findings"]})
+            report["scanned"].append({"type": "text", "where": key})
+
+    # scan file paths reported
+    paths = {}
+    if isinstance(exp, dict) and "paths" in exp:
+        paths = exp.get("paths") or {}
+        if isinstance(paths, dict):
+            for k, p in paths.items():
+                try:
+                    pstr = str(p)
+                    if os.path.exists(pstr) and os.path.isfile(pstr):
+                        with open(pstr, "r", encoding="utf-8", errors="ignore") as fh:
+                            sample = fh.read(20000)
+                            scan = scan_text_for_secrets(sample)
+                            if scan.get("suspicious"):
+                                report["suspicious"] = True
+                                report["issues"].append({"type": "file_secret", "file": pstr, "findings": scan["findings"]})
+                            report["scanned"].append({"type": "file", "file": pstr})
+                    else:
+                        report["scanned"].append({"type": "path", "value": pstr, "exists": os.path.exists(pstr)})
+                except Exception as e:
+                    report["scanned"].append({"file": p, "error": str(e)})
+
+    # If repo zip(s) detected, flag for manual review
+    if any(str(v).lower().endswith(".zip") for v in (paths.values() if isinstance(paths, dict) else [])):
+        report["notes"] = ["Zip-based or repo artifact detected — recommend manual review."]
+
+    return {"complianceReport": report, "execution_path": path, "status_update": "Compliance checks complete"}
 
 def run_observer_agent(state: AgentState) -> Dict[str, Any]:
     """
-    Observer: Lightweight log & metric summarizer.
-    Reads performance logs and recent execution_path to produce quick risk summary.
+    Observer Agent:
+    - Reads available logs (best-effort) and summarizes ERROR/WARNING counts
+    - Produces short LLM recommendations for prioritized actions
     """
     log.info(">>> OBSERVER AGENT")
     path = ensure_list(state, "execution_path") + ["Observer"]
-    # Get list of logs from config or default
-    log_paths = []
-    # If there's a performance logger path in ENV or state, include it
-    if os.path.exists("logs/performance.log"):
-        log_paths.append("logs/performance.log")
-    if os.path.exists("logs/ai_lab.log"):
-        log_paths.append("logs/ai_lab.log")
-    # fallback
-    summary = summarize_logs_for_observer(log_paths or None)
-    # Also summarize key execution metrics
-    exec_path = state.get("execution_path", []) or []
-    cycles = ensure_int(state, "rework_cycles", 0)
-    cost = state.get("current_cost", 0.0)
+
+    # choose likely log files
+    log_candidates = []
+    for candidate in ["logs/performance.log", "logs/ai_lab.log", "performance.log"]:
+        if os.path.exists(candidate):
+            log_candidates.append(candidate)
+
+    summary = summarize_logs_for_observer(log_candidates or None)
+    exec_len = len(state.get("execution_path", []) or [])
+    rework_cycles = ensure_int(state, "rework_cycles", 0)
+    current_cost = state.get("current_cost", 0.0)
+
     obs = {
         "log_summary": summary[:4000],
-        "execution_length": len(exec_path),
-        "rework_cycles": cycles,
-        "current_cost": cost,
+        "execution_length": exec_len,
+        "rework_cycles": rework_cycles,
+        "current_cost": current_cost,
         "status": state.get("status_update")
     }
-    # Let LLM create a short next-action recommendation
+
+    # let LLM recommend 1-3 prioritized mitigation actions
     if llm:
         try:
             prompt = (
-                "You are an Observer assistant. Given this runtime summary, provide 3 prioritized next actions to mitigate risk.\n\n"
+                "You are an Observer assistant. Given this runtime summary, provide 3 prioritized next actions to mitigate the top risks.\n\n"
                 f"Runtime summary: {json.dumps(obs, indent=2)}\n\nReturn plain text."
             )
             r = llm.invoke(prompt)
-            obs["llm_recommendations"] = getattr(r, "content", "").strip()[:1500]
+            obs["llm_recommendations"] = getattr(r, "content", "")[:1500]
         except Exception as e:
             obs["llm_recommendations_error"] = str(e)
 
-    state_update = {"observerReport": obs, "execution_path": path, "status_update": "Observer summary created"}
-    return state_update
+    return {"observerReport": obs, "execution_path": path, "status_update": "Observer summary created"}
 
 def run_knowledge_curator_agent(state: AgentState) -> Dict[str, Any]:
     """
-    Knowledge Curator: ingest QA feedback, artifacts and create concise memories
-    for future runs. Writes into memory_manager with tags.
+    Knowledge Curator Agent:
+    - Creates a concise memory summary combining objective, plan, draft, and QA feedback
+    - Writes into memory_manager for future reuse
     """
     log.info(">>> KNOWLEDGE CURATOR AGENT")
     path = ensure_list(state, "execution_path") + ["KnowledgeCurator"]
+    core = state.get("coreObjectivePrompt", "") or state.get("userInput", "")
+    pm = state.get("pmPlan", {}) or {}
     draft = state.get("draftResponse", "") or ""
     qa_feedback = state.get("qaFeedback", "") or ""
-    pm = state.get("pmPlan", {}) or {}
-    artifacts = state.get("experimentResults", {}) or {}
-    summary_text = f"Objective: {state.get('coreObjectivePrompt','')}\n\nPlan: {json.dumps(pm.get('plan_steps', []))}\n\nDraft: {draft[:2000]}\n\nQA: {qa_feedback[:1000]}"
+    summary_text = (
+        f"Objective: {core}\n\n"
+        f"Plan Steps: {json.dumps(pm.get('plan_steps', []))}\n\n"
+        f"Draft (first 1500 chars): {draft[:1500]}\n\n"
+        f"QA Feedback: {qa_feedback[:1000]}"
+    )
     try:
         memory_manager.add_to_memory(summary_text, {"source": "knowledge_curator", "timestamp": datetime.utcnow().isoformat()})
-        insights = {"added": True, "summary_snippet": summary_text[:1000]}
+        insights = {"added": True, "summary_snippet": summary_text[:500]}
     except Exception as e:
         insights = {"added": False, "error": str(e)}
-    state_update = {"knowledgeInsights": insights, "execution_path": path, "status_update": "Knowledge captured"}
-    return state_update
+    return {"knowledgeInsights": insights, "execution_path": path, "status_update": "Knowledge captured"}
 
-# --- Workflow wiring function ---
+# --- Wiring / injection into existing main_workflow ---
 
 def apply_upgrades():
     """
-    Inject new nodes and edges into base_graph.main_workflow (LangGraph StateGraph),
-    preserving the existing flow and not overturning current design.
-
-    This version is defensive: StateGraph may not provide has_node/has_edge methods,
-    so we attempt adds and ignore Duplicate/AlreadyExists errors.
+    Inject nodes and edges into base_graph.main_workflow (LangGraph StateGraph).
+    Attempts to add nodes/edges defensively and recompiles the main_app.
+    Returns True on success (no exceptions thrown), False otherwise.
     """
-    log.info("Applying graph upgrades: adding Pragmatist, Governance, Compliance, Observer, KnowledgeCurator")
-
+    log.info("Applying graph upgrades: Pragmatist, Governance, Compliance, Observer, KnowledgeCurator")
     try:
         mw = getattr(base_graph, "main_workflow", None)
         if mw is None:
-            raise RuntimeError("base_graph.main_workflow not found. Ensure graph.py has created main_workflow.")
+            raise RuntimeError("base_graph.main_workflow not found. Ensure graph.py created main_workflow before applying upgrades.")
 
-        # Nodes to add
         node_map = {
             "pragmatist_agent": run_pragmatist_agent,
             "governance_agent": run_governance_agent,
@@ -328,37 +327,34 @@ def apply_upgrades():
             "knowledge_curator_agent": run_knowledge_curator_agent
         }
 
-        # Add nodes defensively
-        for name, fn in node_map.items():
+        # Add nodes (defensive)
+        for nm, fn in node_map.items():
             try:
-                mw.add_node(name, fn)
-                log.info(f"Added node: {name}")
+                mw.add_node(nm, fn)
+                log.info("Added node: %s", nm)
             except Exception as e:
-                # If node already exists or other non-fatal issue, continue
-                log.debug(f"Could not add node '{name}' (may already exist): {e}")
+                log.debug("Could not add node %s (may already exist): %s", nm, e)
 
-        # Connect edges: pm_agent -> pragmatist_agent -> governance_agent -> experimenter_agent
-        # If governance rejects, route back to pm_agent
-        def governance_decider(state: AgentState):
-            gov = state.get("governanceReport", {}) or {}
-            if gov.get("approved_for_experiment", True) is True:
-                return "experimenter_agent"
-            return "pm_agent"
-
-        # Add edges defensively
+        # Connect pm -> pragmatist -> governance -> (experimenter or back to pm)
         try:
             mw.add_edge("pm_agent", "pragmatist_agent")
-            log.info("Added edge: pm_agent -> pragmatist_agent")
+            log.info("Edge: pm_agent -> pragmatist_agent")
         except Exception as e:
-            log.debug(f"Edge pm_agent -> pragmatist_agent not added: {e}")
+            log.debug("pm_agent -> pragmatist_agent: %s", e)
 
         try:
             mw.add_edge("pragmatist_agent", "governance_agent")
-            log.info("Added edge: pragmatist_agent -> governance_agent")
+            log.info("Edge: pragmatist_agent -> governance_agent")
         except Exception as e:
-            log.debug(f"Edge pragmatist_agent -> governance_agent not added: {e}")
+            log.debug("pragmatist_agent -> governance_agent: %s", e)
+
+        # conditional from governance_agent
+        def governance_decider(state: AgentState):
+            gov = state.get("governanceReport", {}) or {}
+            if gov.get("approved_for_experiment", True) is True:
+                return "experimenter_agent"
+            return "pm_agent"
 
-        # Add conditional edges for governance_decider
         try:
             mw.add_conditional_edges("governance_agent", governance_decider, {
                 "experimenter_agent": "experimenter_agent",
@@ -366,77 +362,74 @@ def apply_upgrades():
             })
             log.info("Added conditional edges for governance_agent")
         except Exception as e:
-            log.debug(f"Could not add conditional edges for governance_agent: {e}")
+            log.debug("Could not add conditional edges for governance_agent: %s", e)
 
-        # After experimenter -> compliance_agent -> synthesis_agent
+        # experimenter -> compliance -> synthesis
         try:
             mw.add_edge("experimenter_agent", "compliance_agent")
-            log.info("Added edge: experimenter_agent -> compliance_agent")
+            log.info("Edge: experimenter_agent -> compliance_agent")
         except Exception as e:
-            log.debug(f"Edge experimenter_agent -> compliance_agent not added: {e}")
+            log.debug("experimenter_agent -> compliance_agent: %s", e)
 
         try:
             mw.add_edge("compliance_agent", "synthesis_agent")
-            log.info("Added edge: compliance_agent -> synthesis_agent")
+            log.info("Edge: compliance_agent -> synthesis_agent")
         except Exception as e:
-            log.debug(f"Edge compliance_agent -> synthesis_agent not added: {e}")
+            log.debug("compliance_agent -> synthesis_agent: %s", e)
 
-        # Ensure synthesis -> qa still exists (likely present) and add qa -> observer_agent
+        # synthesis -> qa (likely already present) and then qa -> observer -> archivist
         try:
             mw.add_edge("synthesis_agent", "qa_agent")
-            log.info("Ensured edge: synthesis_agent -> qa_agent")
+            log.info("Edge: synthesis_agent -> qa_agent ensured/added")
         except Exception as e:
-            log.debug(f"Edge synthesis_agent -> qa_agent not added/exists: {e}")
+            log.debug("synthesis_agent -> qa_agent: %s", e)
 
         try:
             mw.add_edge("qa_agent", "observer_agent")
-            log.info("Added edge: qa_agent -> observer_agent")
+            log.info("Edge: qa_agent -> observer_agent")
         except Exception as e:
-            log.debug(f"Edge qa_agent -> observer_agent not added: {e}")
+            log.debug("qa_agent -> observer_agent: %s", e)
 
         try:
             mw.add_edge("observer_agent", "archivist_agent")
-            log.info("Added edge: observer_agent -> archivist_agent")
+            log.info("Edge: observer_agent -> archivist_agent")
         except Exception as e:
-            log.debug(f"Edge observer_agent -> archivist_agent not added: {e}")
+            log.debug("observer_agent -> archivist_agent: %s", e)
 
-        # Insert knowledge curator between archivist and END
+        # archivist -> knowledge_curator -> END
         try:
             mw.add_edge("archivist_agent", "knowledge_curator_agent")
-            log.info("Added edge: archivist_agent -> knowledge_curator_agent")
+            log.info("Edge: archivist_agent -> knowledge_curator_agent")
         except Exception as e:
-            log.debug(f"Edge archivist_agent -> knowledge_curator_agent not added: {e}")
+            log.debug("archivist_agent -> knowledge_curator_agent: %s", e)
 
         try:
             mw.add_edge("knowledge_curator_agent", base_graph.END)
-            log.info("Added edge: knowledge_curator_agent -> END")
+            log.info("Edge: knowledge_curator_agent -> END")
         except Exception as e:
-            log.debug(f"Edge knowledge_curator_agent -> END not added: {e}")
+            log.debug("knowledge_curator_agent -> END: %s", e)
 
-        # Ensure disclaimer path is preserved (safe-guard: add qa -> disclaimer if missing)
+        # Ensure qa -> disclaimer path still exists (add defensively)
         try:
             mw.add_edge("qa_agent", "disclaimer_agent")
-            log.info("Ensured edge: qa_agent -> disclaimer_agent")
+            log.info("Edge: qa_agent -> disclaimer_agent ensured/added")
         except Exception as e:
-            log.debug(f"Edge qa_agent -> disclaimer_agent not added/exists: {e}")
+            log.debug("qa_agent -> disclaimer_agent: %s", e)
 
-        # Recompile the main app to include changes
+        # Recompile main_app
         try:
             base_graph.main_app = mw.compile()
-            log.info("Recompiled main_workflow -> main_app successfully.")
+            log.info("Recompiled main_workflow -> main_app")
         except Exception as e:
-            log.warning(f"Could not recompile main_workflow: {e}")
+            log.warning("Could not recompile main_workflow: %s", e)
 
         log.info("Graph upgrades applied successfully.")
         return True
 
     except Exception as e:
-        log.exception(f"Failed to apply graph upgrades: {e}")
+        log.exception("Failed to apply graph upgrades: %s", e)
         return False
 
-# optional convenience: apply on import if desired (commented out by default)
-# apply_upgrades()
-
-if __name__ == "__main__":
-    ok = apply_upgrades()
-    print("Apply upgrades:", ok)
+# optional: auto-apply on import (commented out to avoid surprising side-effects)
+# if __name__ == "__main__":
+#     print("Applying upgrades:", apply_upgrades())