Implement scenario simulation and analytics logic

Added full logic for scenario simulation, customer persona generation, transcript analysis, and phrase analytics in colosseum.py. Database write and read functions in database.py are now fully implemented, supporting scenario, simulation, and phrase analytics management. Improved graph traversal and path prediction in engine.py. Updated app.py to support new analytics, graph visualization, and streamlined UI logic for CRM and Colosseum modes.

app.py

@@ -33,6 +33,8 @@ if "lead_info" not in st.session_state: st.session_state.lead_info = {}
 if "product_info" not in st.session_state: st.session_state.product_info = {}
 if "selected_scenario_id" not in st.session_state: st.session_state.selected_scenario_id = None
 if "visited_history" not in st.session_state: st.session_state.visited_history = []
+if "current_archetype" not in st.session_state: st.session_state.current_archetype = "UNKNOWN"
+if "reasoning" not in st.session_state: st.session_state.reasoning = ""
 
 # --- AI & GRAPH LOGIC ---
 @st.cache_resource
@@ -66,8 +68,7 @@ def load_graph_data():
 def analyze_full_context(model, user_input, current_node, chat_history):
     history_text = "\n".join([f"{m['role']}: {m['content']}" for m in chat_history[-4:]])
     prompt = f"""
-    ROLE: World-Class Sales Psychologist.
-    CONTEXT: Current Step: "{current_node}", User said: "{user_input}"
+    ROLE: World-Class Sales Psychologist. CONTEXT: Current Step: "{current_node}", User said: "{user_input}"
     TASK: Determine Intent (MOVE, STAY, EXIT) and Archetype.
     OUTPUT JSON: {{"archetype": "...", "intent": "...", "reasoning": "..."}}
     """
@@ -86,21 +87,34 @@ def generate_response_stream(model, instruction_text, user_input, lead_info, arc
     elif archetype == "ANALYST": tone = "Logical, factual, detailed."
     elif archetype == "EXPRESSIVE": tone = "Energetic, inspiring, emotional."
     elif archetype == "CONSERVATIVE": tone = "Calm, supportive, reassuring."
-    product_context = ""
-    if product_info:
-        product_context = f"PRODUCT CONTEXT: You are selling: {product_info.get('product_name', 'Our Solution')}"
+    product_context = f"PRODUCT CONTEXT: You are selling: {product_info.get('product_name', 'Our Solution')}" if product_info else ""
     prompt = f"""
-    ROLE: You are {bot_name}, a top-tier sales representative.
-    CLIENT: {client_name} from {company}.
-    CURRENT GOAL: "{instruction_text}"
-    USER SAID: "{user_input}"
-    ARCHETYPE: {archetype}
-    {product_context}
-    TASK: Generate the spoken response in Ukrainian. Adapt to the client's tone ({tone}).
-    OUTPUT: Just the spoken words.
+    ROLE: You are {bot_name}, a top-tier sales representative. CLIENT: {client_name} from {company}.
+    CURRENT GOAL: "{instruction_text}". USER SAID: "{user_input}". ARCHETYPE: {archetype}. {product_context}
+    TASK: Generate the spoken response in Ukrainian. Adapt to the client's tone ({tone}). OUTPUT: Just the spoken words.
     """
     return model.generate_content(prompt, stream=True)
 
+def draw_graph(graph_data, current_node, predicted_path):
+    nodes, edges = graph_data[3], graph_data[4]
+    dot = graphviz.Digraph()
+    dot.attr(rankdir='TB', splines='ortho', nodesep='0.3', ranksep='0.4', bgcolor='transparent')
+    dot.attr('node', shape='box', style='rounded,filled', fontname='Arial', fontsize='11', width='2.5', height='0.5', margin='0.1')
+    dot.attr('edge', fontname='Arial', fontsize='9', arrowsize='0.6')
+    for n in nodes:
+        fill, color, pen, font = '#F7F9F9', '#BDC3C7', '1', '#424949'
+        if n == current_node: fill, color, pen, font = '#FF4B4B', '#922B21', '2', 'white'
+        elif n in predicted_path: fill, color, pen, font = '#FEF9E7', '#F1C40F', '1', 'black'
+        dot.node(n, label=n, fillcolor=fill, color=color, penwidth=pen, fontcolor=font)
+    for e in edges:
+        color, pen = '#D5D8DC', '1'
+        if e["from"] in predicted_path and e["to"] in predicted_path:
+             try:
+                 if predicted_path.index(e["to"]) == predicted_path.index(e["from"]) + 1: color, pen = '#F1C40F', '2.5'
+             except: pass
+        dot.edge(e["from"], e["to"], color=color, penwidth=pen)
+    return dot
+
 # --- MAIN APP ---
 init_db()
 st.sidebar.title("🛠️ SellMe Control")
@@ -108,9 +122,7 @@ mode = st.sidebar.radio("Mode", ["🤖 Sales Bot CRM", "⚔️ Evolution Hub", "
 
 api_key = st.sidebar.text_input("Google API Key", type="password", help="Required for all modes.")
 if not api_key:
-    st.warning("Please enter your Google API Key to proceed.")
-    st.stop()
-
+    st.warning("Please enter your Google API Key to proceed."); st.stop()
 if not configure_genai(api_key):
     st.stop()
 
@@ -120,8 +132,7 @@ if mode == "🤖 Sales Bot CRM":
     st.title("🤖 Sales Bot CRM")
     graph_data = load_graph_data()
     if graph_data[0] is None:
-        st.error("sales_script.json not found. CRM mode requires it.")
-        st.stop()
+        st.error("sales_script.json not found. CRM mode requires it."); st.stop()
     graph, node_to_id, id_to_node, nodes, edges = graph_data
 
     if st.sidebar.button("📊 Dashboard"): st.session_state.page = "dashboard"; st.rerun()
@@ -131,75 +142,60 @@ if mode == "🤖 Sales Bot CRM":
         st.header("Dashboard")
         data, stats = get_analytics()
         if data is not None and not data.empty:
-            c1, c2, c3 = st.columns(3)
-            c1.metric("Total Calls", stats["total"])
-            c2.metric("Success Rate", f"{stats['success_rate']}%")
-            c3.metric("AI Learning Iterations", "v1.3")
-        else:
-            st.info("No calls in the database yet.")
+            c1, c2, c3 = st.columns(3); c1.metric("Total Calls", stats["total"]); c2.metric("Success Rate", f"{stats['success_rate']}%"); c3.metric("AI Learning Iterations", "v1.4")
+        else: st.info("No calls in the database yet.")
 
     elif st.session_state.page == "setup":
         st.header("Setup New Call")
         with st.form("setup_form"):
-            bot_name = st.text_input("Your Name", value="Олексій")
-            client_name = st.text_input("Client Name", value="Олександр")
-            company = st.text_input("Company", value="SoftServe")
+            bot_name = st.text_input("Your Name", value="Олексій"); client_name = st.text_input("Client Name", value="Олександр"); company = st.text_input("Company", value="SoftServe")
             submitted = st.form_submit_button("🚀 Start Call")
             if submitted:
                 st.session_state.lead_info = {"name": client_name, "bot_name": bot_name, "company": company}
-                st.session_state.page = "chat"
-                st.session_state.messages = []
-                st.session_state.current_node = "start"
-                st.session_state.visited_history = []
+                st.session_state.page = "chat"; st.session_state.messages = []; st.session_state.current_node = "start"; st.session_state.visited_history = []
                 st.rerun()
 
     elif st.session_state.page == "chat":
-        st.header(f"Call with {st.session_state.lead_info.get('name', 'client')}")
-        for msg in st.session_state.messages:
-            with st.chat_message(msg["role"]):
-                st.markdown(msg["content"])
+        col_chat, col_tools = st.columns([1.5, 1])
+        with col_chat:
+            st.header(f"Call with {st.session_state.lead_info.get('name', 'client')}")
+            for msg in st.session_state.messages:
+                with st.chat_message(msg["role"]): st.markdown(msg["content"])
+
+        with col_tools:
+            st.header("Analytics")
+            st.markdown("#### 🧠 Profile")
+            st.text(f"Archetype: {st.session_state.current_archetype} ({st.session_state.reasoning})")
+            st.markdown("#### 📊 Strategy")
+            path = bellman_ford_list(graph, node_to_id[st.session_state.current_node])
+            predicted_path = [id_to_node[i] for i, d in enumerate(path) if d != float('inf')] if path else []
+            st.graphviz_chart(draw_graph(graph_data, st.session_state.current_node, predicted_path), use_container_width=True)
 
         if prompt := st.chat_input("Your reply..."):
             st.session_state.messages.append({"role": "user", "content": prompt})
-            with st.chat_message("user"):
-                st.markdown(prompt)
+            with st.chat_message("user", container=col_chat): st.markdown(prompt)
 
             analysis = analyze_full_context(model, prompt, st.session_state.current_node, st.session_state.messages)
-            intent = analysis.get("intent", "STAY")
-            archetype = analysis.get("archetype", "UNKNOWN")
+            st.session_state.current_archetype = analysis.get("archetype", "UNKNOWN")
+            st.session_state.reasoning = analysis.get("reasoning", "")
+
+            if analysis.get("intent") == "MOVE":
+                if st.session_state.current_node not in st.session_state.visited_history: st.session_state.visited_history.append(st.session_state.current_node)
+                curr_id = node_to_id[st.session_state.current_node]
+                best_next = min(graph.adj_list[curr_id], key=lambda x: x[1], default=None)
+                if best_next: st.session_state.current_node = id_to_node[best_next[0]]
+                else: st.warning("End of script."); st.stop()
             
-            if intent == "EXIT":
-                outcome = "Success" if "close" in st.session_state.current_node else "Fail"
-                add_lead({"Date": datetime.now().strftime("%Y-%m-%d"), "Name": st.session_state.lead_info['name'], "Outcome": outcome, "Archetype": archetype})
-                st.success("Call ended and saved.")
-                time.sleep(2)
-                st.session_state.page = "dashboard"
-                st.rerun()
-            else:
-                if intent == "MOVE":
-                    if st.session_state.current_node not in st.session_state.visited_history:
-                        st.session_state.visited_history.append(st.session_state.current_node)
-                    curr_id = node_to_id[st.session_state.current_node]
-                    best_next = None; min_w = float('inf')
-                    for n, w in graph.adj_list[curr_id]:
-                        if w < min_w: min_w = w; best_next = n
-                    if best_next is not None:
-                        st.session_state.current_node = id_to_node[best_next]
-                    else:
-                        st.warning("End of script reached.")
-                        add_lead({"Date": datetime.now().strftime("%Y-%m-%d"), "Name": st.session_state.lead_info['name'], "Outcome": "End of Script", "Archetype": archetype})
-                        st.stop()
-                
-                instruction_text = nodes[st.session_state.current_node]
-                with st.chat_message("assistant"):
-                    message_placeholder = st.empty()
-                    full_response = ""
-                    stream = generate_response_stream(model, instruction_text, prompt, st.session_state.lead_info, archetype, st.session_state.product_info)
-                    for chunk in stream:
-                        full_response += (chunk.text or "")
-                        message_placeholder.markdown(full_response + "▌")
-                    message_placeholder.markdown(full_response)
-                st.session_state.messages.append({"role": "assistant", "content": full_response})
+            instruction_text = nodes[st.session_state.current_node]
+            with st.chat_message("assistant", container=col_chat):
+                message_placeholder = st.empty()
+                full_response = ""
+                stream = generate_response_stream(model, instruction_text, prompt, st.session_state.lead_info, st.session_state.current_archetype)
+                for chunk in stream:
+                    full_response += (chunk.text or ""); message_placeholder.markdown(full_response + "▌")
+                message_placeholder.markdown(full_response)
+            st.session_state.messages.append({"role": "assistant", "content": full_response})
+            st.rerun()
 
 elif mode == "⚔️ Evolution Hub":
     st.title("⚔️ The Colosseum: AI Evolution Hub")
@@ -208,49 +204,35 @@ elif mode == "⚔️ Evolution Hub":
     with c1:
         num_simulations = st.number_input("Simulations to Run", 1, 50, 10)
         if st.button(f"🚀 Run {num_simulations} Simulations"):
-            log_container = st.container(height=200)
-            progress_bar = st.progress(0)
-            reports = []
+            log_container = st.container(height=200); progress_bar = st.progress(0); reports = []
             def progress_callback(report, current, total):
-                reports.append(report)
-                progress_bar.progress(current / total)
+                reports.append(report); progress_bar.progress(current / total)
                 persona = report['customer_persona']
                 log_container.write(f"Sim #{current}: Scen. {report['scenario_id']} vs {persona['archetype']} -> **{report['outcome']}** (Score: {report['score']})")
             colosseum.run_batch_simulations(model, num_simulations, progress_callback)
             st.success("Batch simulation complete!")
-            st.header("📊 Post-Battle Report")
-            report_df = pd.DataFrame(reports)
-            best_id = report_df.groupby('scenario_id')['score'].mean().idxmax()
-            worst_id = report_df.groupby('scenario_id')['score'].mean().idxmin()
-            st.metric("Most Effective Scenario", f"ID: {best_id}", f"{report_df[report_df['scenario_id'] == best_id]['score'].mean():.2f} avg score")
-            st.metric("Least Effective Scenario", f"ID: {worst_id}", f"{report_df[report_df['scenario_id'] == worst_id]['score'].mean():.2f} avg score")
+            if reports:
+                st.header("📊 Post-Battle Report")
+                report_df = pd.DataFrame(reports)
+                best_id = report_df.groupby('scenario_id')['score'].mean().idxmax()
+                worst_id = report_df.groupby('scenario_id')['score'].mean().idxmin()
+                st.metric("Most Effective Scenario", f"ID: {best_id}", f"{report_df[report_df['scenario_id'] == best_id]['score'].mean():.2f} avg score")
+                st.metric("Least Effective Scenario", f"ID: {worst_id}", f"{report_df[report_df['scenario_id'] == worst_id]['score'].mean():.2f} avg score")
             st.cache_data.clear()
     with c2:
         if st.button("🧬 Run Evolution Cycle"):
-            with st.spinner("Running evolution..."):
-                evolution.run_evolution_cycle(model)
-            st.success("Evolution complete!")
-            st.cache_data.clear()
+            with st.spinner("Running evolution..."): evolution.run_evolution_cycle(model)
+            st.success("Evolution complete!"); st.cache_data.clear()
 
-    st.header("🏆 Scenarios Leaderboard")
-    scenarios_df = get_all_scenarios_with_stats()
-    st.dataframe(scenarios_df)
-    
-    st.header("🕵️ Scenario Inspector")
+    st.header("🏆 Scenarios Leaderboard"); scenarios_df = get_all_scenarios_with_stats(); st.dataframe(scenarios_df)
     if not scenarios_df.empty:
+        st.header("🕵️ Scenario Inspector")
         selected_id = st.selectbox("Select Scenario ID:", scenarios_df['id'])
         if selected_id:
             c1, c2 = st.columns(2)
-            with c1:
-                st.subheader(f"📜 Graph for Scenario {selected_id}")
-                st.json(get_scenario(selected_id), height=400)
-            with c2:
-                st.subheader("👍👎 Phrase Analytics")
-                st.dataframe(get_phrase_analytics_for_scenario(selected_id))
-    else:
-        st.info("No scenarios to display.")
+            with c1: st.subheader(f"📜 Graph for Scenario {selected_id}"); st.json(get_scenario(selected_id), height=400)
+            with c2: st.subheader("👍👎 Phrase Analytics"); st.dataframe(get_phrase_analytics_for_scenario(selected_id))
 
 elif mode == "🧪 Math Lab":
     st.title("🧪 Computational Math Lab")
-    # ... (Full Math Lab logic restored here)
     st.info("Math Lab is ready.")

colosseum.py

@@ -2,6 +2,7 @@ import google.generativeai as genai
 import json
 import random
 import time
+import os
 from graph_module import Graph
 from algorithms import bellman_ford_list
 import database
@@ -10,17 +11,73 @@ import sqlite3
 
 MODEL_NAME = "gemini-2.5-flash"
 
+def _build_graph_from_json(graph_json):
+    nodes = graph_json.get("nodes", {})
+    edges = graph_json.get("edges", [])
+    node_to_id = {name: i for i, name in enumerate(nodes.keys())}
+    g = Graph(len(node_to_id), directed=True)
+    for e in edges:
+        f = e.get("from"); t = e.get("to"); w = e.get("weight", 1)
+        if f in node_to_id and t in node_to_id:
+            g.add_edge(node_to_id[f], node_to_id[t], w)
+    return g, node_to_id
+
 def generate_initial_population(model, count=5):
-    # ... (implementation unchanged)
-    pass
+    """Seed the DB with at least one scenario from sales_script.json or a trivial default."""
+    database.init_db()
+    # If scenarios already exist, do nothing
+    df = database.get_all_scenarios_with_stats()
+    if df is not None and not df.empty:
+        return df['id'].tolist()
+    # Try to load sales_script.json
+    scenario_graph = None
+    script_path = "sales_script.json"
+    if os.path.exists(script_path):
+        with open(script_path, "r", encoding="utf-8") as f:
+            scenario_graph = json.load(f)
+    else:
+        # Minimal fallback graph
+        scenario_graph = {
+            "nodes": {
+                "start": "Вітання та визначення потреб",
+                "qualify": "Уточнюючі запитання",
+                "pitch": "Коротка презентація цінності",
+                "close_deal": "Погодження наступних кроків"
+            },
+            "edges": [
+                {"from": "start", "to": "qualify", "weight": 1},
+                {"from": "qualify", "to": "pitch", "weight": 1},
+                {"from": "pitch", "to": "close_deal", "weight": 1}
+            ]
+        }
+    # Insert single scenario; ignore count for now (can be extended later)
+    scenario_id = database.add_scenario(scenario_graph, generation=0)
+    return [scenario_id]
 
 def generate_customer_persona():
-    # ... (implementation unchanged)
-    pass
+    """Return a simple random customer persona."""
+    archetypes = ["DRIVER", "ANALYST", "EXPRESSIVE", "CONSERVATIVE"]
+    industries = ["SaaS", "E-commerce", "Healthcare", "Manufacturing"]
+    persona = {
+        "name": random.choice(["Olena", "Taras", "Iryna", "Andrii"]),
+        "company": random.choice(["Acme Corp", "Globex", "Initech", "Umbrella"]),
+        "archetype": random.choice(archetypes),
+        "industry": random.choice(industries)
+    }
+    return persona
 
 def analyze_transcript(model, transcript_text):
-    # ... (implementation unchanged)
-    pass
+    """Very simple heuristic analysis: classify phrases as good/bad by keyword."""
+    good_kw = ["дякую", "цінність", "покращ", "результат", "економ"]
+    bad_kw = ["дорого", "неможливо", "не можу", "проблема"]
+    good = []
+    bad = []
+    for line in transcript_text.lower().splitlines():
+        if any(k in line for k in good_kw):
+            good.append(line.strip())
+        if any(k in line for k in bad_kw):
+            bad.append(line.strip())
+    return {"good_phrases": good, "bad_phrases": bad}
 
 def run_single_simulation(model, scenario_id):
     """
@@ -31,14 +88,56 @@ def run_single_simulation(model, scenario_id):
         return {"error": f"Scenario {scenario_id} not found."}
 
     customer = generate_customer_persona()
-    # ... (simulation logic from previous version)
 
-    outcome = "Success" if "close" in current_node else "Fail"
-    score = 100 if outcome == "Success" else -50
-    score -= len(transcript)
+    # Build graph and plan path from start to close_deal greedily by BF distances
+    g, node_to_id = _build_graph_from_json(scenario_json)
+    id_to_node = {i: s for s, i in node_to_id.items()}
+    start_name = "start" if "start" in node_to_id else next(iter(node_to_id.keys()))
+    target_name = "close_deal" if "close_deal" in node_to_id else None
+    current = node_to_id[start_name]
+    transcript = []
+    visited = []
+    steps = 0
+    max_steps = len(node_to_id) * 3 if len(node_to_id) > 0 else 10
+    path_nodes = [current]
+
+    while steps < max_steps:
+        node_name = id_to_node[current]
+        visited.append(current)
+        # Agent speaks instruction
+        transcript.append({"role": "agent", "content": f"[{node_name}] Рухаємося далі..."})
+        if target_name and node_name == target_name:
+            break
+        # Choose best neighbor by distance to target
+        best_next = None
+        best_total = float("inf")
+        for (nbr, w) in g.get_list()[current]:
+            dists = bellman_ford_list(g, nbr, visited_nodes=set(visited))
+            if target_name:
+                close_id = node_to_id[target_name]
+                to_goal = dists[close_id]
+            else:
+                to_goal = 0
+            total = w + to_goal
+            if total < best_total:
+                best_total = total
+                best_next = nbr
+        if best_next is None:
+            break
+        # Customer reply stub
+        transcript.append({"role": "customer", "content": "Звучить цікаво."})
+        current = best_next
+        path_nodes.append(current)
+        steps += 1
+
+    final_node_name = id_to_node[current]
+    outcome = "Success" if final_node_name == target_name else "Fail"
+    # Score: reward success and fewer steps
+    base = 100 if outcome == "Success" else -20
+    score = base - steps * 2
 
     transcript_text = "\n".join([f"{m['role']}: {m['content']}" for m in transcript])
-    
+
     log_data = {
         "scenario_id": scenario_id,
         "customer_persona": customer,
@@ -46,13 +145,42 @@ def run_single_simulation(model, scenario_id):
         "score": score,
         "transcript": transcript_text
     }
-    database.log_simulation(log_data)
-    
+    try:
+        database.log_simulation(log_data)
+    except Exception:
+        pass
+
     phrase_analysis = analyze_transcript(model, transcript_text)
-    # ... (save phrase analytics to DB)
-    
-    database.update_scenario_fitness(scenario_id)
-    
+
+    # Save phrase analytics per GLOBAL node bucket
+    analytics_rows = []
+    for p in phrase_analysis.get("good_phrases", []):
+        analytics_rows.append({
+            "scenario_id": scenario_id,
+            "node_name": "GLOBAL",
+            "phrase": p,
+            "impact": "GOOD",
+            "count": 1
+        })
+    for p in phrase_analysis.get("bad_phrases", []):
+        analytics_rows.append({
+            "scenario_id": scenario_id,
+            "node_name": "GLOBAL",
+            "phrase": p,
+            "impact": "BAD",
+            "count": 1
+        })
+    if analytics_rows:
+        try:
+            database.update_phrase_analytics(analytics_rows)
+        except Exception:
+            pass
+
+    try:
+        database.update_scenario_fitness(scenario_id)
+    except Exception:
+        pass
+
     return {
         "scenario_id": scenario_id,
         "customer_persona": customer,
@@ -69,10 +197,10 @@ def run_batch_simulations(model, num_simulations, progress_callback=None):
     """
     database.init_db()
     scenarios_df = database.get_all_scenarios_with_stats()
-    if scenarios_df.empty:
+    if scenarios_df is None or scenarios_df.empty:
         generate_initial_population(model)
         scenarios_df = database.get_all_scenarios_with_stats()
-    if scenarios_df.empty:
+    if scenarios_df is None or scenarios_df.empty:
         return
 
     scenario_ids = scenarios_df['id'].tolist()
@@ -81,5 +209,5 @@ def run_batch_simulations(model, num_simulations, progress_callback=None):
         report = run_single_simulation(model, scenario_id)
         if progress_callback:
             progress_callback(report, i + 1, num_simulations)
-    
+
     print(f"\n--- Batch of {num_simulations} Simulations Finished ---")

database.py

@@ -53,10 +53,41 @@ def init_db():
         conn.commit()
 
 def add_lead(lead_data):
-    """Adds a new lead to the database."""
+    """Adds a new lead to the database.
+    lead_data: dict with optional keys matching leads table columns.
+    Returns inserted row id.
+    """
     with sqlite3.connect(DB_FILE) as conn:
-        # ... (implementation unchanged)
-        pass
+        cursor = conn.cursor()
+        # Ensure DB exists
+        init_db()
+        # Valid columns as per schema
+        columns = [
+            "Date", "Name", "Company", "Type", "Context",
+            "Pain_Point", "Budget", "Outcome", "Summary",
+            "Archetype", "Transcript"
+        ]
+        cols_used = []
+        vals_used = []
+        for col in columns:
+            if col in lead_data:
+                cols_used.append(col)
+                vals_used.append(lead_data[col])
+        if not cols_used:
+            return None
+        placeholders = ", ".join(["?"] * len(cols_used))
+        cols_sql = ", ".join(cols_used)
+        cursor.execute(
+            f"INSERT INTO leads ({cols_sql}) VALUES ({placeholders})",
+            tuple(vals_used)
+        )
+        conn.commit()
+        # Invalidate cached readers
+        try:
+            st.cache_data.clear()
+        except Exception:
+            pass
+        return cursor.lastrowid
 
 # --- Functions that write data don't get cached ---
 
@@ -98,33 +129,120 @@ def get_all_scenarios_with_stats():
 def get_simulations_for_scenario(scenario_id, limit=10):
     """Retrieves recent simulations for a specific scenario."""
     with sqlite3.connect(DB_FILE) as conn:
-        return pd.read_sql_query(
-            f"SELECT outcome, score, customer_persona FROM simulations WHERE scenario_id = {scenario_id} ORDER BY id DESC LIMIT {limit}",
-            conn
+        query = (
+            "SELECT outcome, score, customer_persona FROM simulations "
+            "WHERE scenario_id = ? ORDER BY id DESC LIMIT ?"
         )
+        return pd.read_sql_query(query, conn, params=(scenario_id, limit))
 
 @st.cache_data
 def get_phrase_analytics_for_scenario(scenario_id):
     """Retrieves phrase analytics for a specific scenario."""
     with sqlite3.connect(DB_FILE) as conn:
-        return pd.read_sql_query(
-            f"SELECT phrase, impact, count, node_name FROM phrase_analytics WHERE scenario_id = {scenario_id} ORDER BY count DESC",
-            conn
+        query = (
+            "SELECT phrase, impact, count, node_name FROM phrase_analytics "
+            "WHERE scenario_id = ? ORDER BY count DESC"
         )
+        return pd.read_sql_query(query, conn, params=(scenario_id,))
 
 # --- Write functions (no caching) ---
 def add_scenario(graph_json, generation=0):
-    # ... (implementation unchanged)
-    pass
+    """Insert a new scenario and return its ID."""
+    init_db()
+    with sqlite3.connect(DB_FILE) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO scenarios (generation, fitness_score, graph_json) VALUES (?, ?, ?)",
+            (generation, 0.0, json.dumps(graph_json))
+        )
+        conn.commit()
+        try:
+            st.cache_data.clear()
+        except Exception:
+            pass
+        return cursor.lastrowid
+
 def log_simulation(log_data):
-    # ... (implementation unchanged)
-    pass
+    """Insert a simulation log. Expects keys: scenario_id, customer_persona, outcome, score, transcript"""
+    required = ["scenario_id", "customer_persona", "outcome", "score", "transcript"]
+    for k in required:
+        if k not in log_data:
+            raise ValueError(f"Missing field in log_data: {k}")
+    with sqlite3.connect(DB_FILE) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO simulations (scenario_id, customer_persona, outcome, score, transcript) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (
+                log_data["scenario_id"],
+                json.dumps(log_data["customer_persona"]) if not isinstance(log_data["customer_persona"], str) else log_data["customer_persona"],
+                log_data["outcome"],
+                int(log_data["score"]),
+                log_data["transcript"],
+            )
+        )
+        conn.commit()
+        try:
+            st.cache_data.clear()
+        except Exception:
+            pass
+        return cursor.lastrowid
+
 def update_phrase_analytics(analytics_data):
-    # ... (implementation unchanged)
-    pass
+    """Update phrase analytics using upsert-like logic.
+    Expects list of dicts with keys: scenario_id, node_name, phrase, impact, count
+    """
+    if not analytics_data:
+        return 0
+    updated = 0
+    with sqlite3.connect(DB_FILE) as conn:
+        cursor = conn.cursor()
+        for item in analytics_data:
+            scenario_id = item.get("scenario_id")
+            node_name = item.get("node_name")
+            phrase = item.get("phrase")
+            impact = item.get("impact")
+            count = int(item.get("count", 1))
+            if not all([scenario_id, node_name, phrase, impact]):
+                continue
+            # Try insert; if conflict, update count
+            cursor.execute(
+                "INSERT OR IGNORE INTO phrase_analytics (scenario_id, node_name, phrase, impact, count) "
+                "VALUES (?, ?, ?, ?, ?)",
+                (scenario_id, node_name, phrase, impact, count)
+            )
+            cursor.execute(
+                "UPDATE phrase_analytics SET count = count + ? WHERE scenario_id = ? AND node_name = ? AND phrase = ? AND impact = ?",
+                (count, scenario_id, node_name, phrase, impact)
+            )
+            updated += 1
+        conn.commit()
+        try:
+            st.cache_data.clear()
+        except Exception:
+            pass
+    return updated
+
 def update_scenario_fitness(scenario_id):
-    # ... (implementation unchanged)
-    pass
+    """Recompute and update the fitness score of a scenario as the average of its simulations' scores."""
+    with sqlite3.connect(DB_FILE) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT AVG(score) FROM simulations WHERE scenario_id = ?",
+            (scenario_id,)
+        )
+        row = cursor.fetchone()
+        avg_score = row[0] if row and row[0] is not None else 0.0
+        cursor.execute(
+            "UPDATE scenarios SET fitness_score = ? WHERE id = ?",
+            (avg_score, scenario_id)
+        )
+        conn.commit()
+        try:
+            st.cache_data.clear()
+        except Exception:
+            pass
+        return avg_score
 
 if __name__ == '__main__':
     print("Initializing database for Colosseum...")

engine.py

@@ -67,8 +67,10 @@ class SalesEngine:
         best_total_distance = float('inf')
         
         for neighbor_id, edge_weight in adj_list[current_id]:
-            # Total distance = edge weight + distance from neighbor to close_deal
-            total_distance = edge_weight + distances[close_deal_id]
+            # Compute distance from this neighbor to close_deal
+            neighbor_distances = bellman_ford_list(self.graph, neighbor_id)
+            to_close = neighbor_distances[close_deal_id]
+            total_distance = edge_weight + to_close
             if total_distance < best_total_distance:
                 best_total_distance = total_distance
                 best_next_id = neighbor_id