Update app.py

app.py

@@ -1,283 +1,222 @@
 #!/usr/bin/env python3
 """
-Overthinker — Gradio Server Backend
+Overthinker v28 — Gradio.Server Backend with SQLite Session Isolation + HF Trace Upload
+
+Changes from v27:
+- Default model reverted to nvidia/nemotron-3-nano-30b-a3b
+- Added /upload_trace endpoint that serializes full tree from SQLite and pushes to HF dataset
+- Dataset repository configured via HF_DATASET_REPO env var
+- HF token via HF_TOKEN env var
+- All other features preserved: SQLite per-session, full path context, no fallbacks, no undo/redo
 
-Dual Prompt Architecture:
-- Input nodes -> prompts to generate OPTIONS/CHOICES/DECISIONS
-- Outcome nodes -> prompts to generate OUTCOMES/CONSEQUENCES
-- Model: nvidia/nemotron-3-nano-30b-a3b via OpenRouter
 Port: 7860
 """
 
 import os
 import json
-import sys
 import uuid
-import random
-import re
-import html as html_mod
-from datetime import datetime
-from typing import Optional, List, Dict, Any
-
-import requests
-from dotenv import load_dotenv
+import sqlite3
+from pathlib import Path
+from typing import Optional, Dict, List, Any
 
 from gradio import Server
 from fastapi import HTTPException
-from starlette.responses import HTMLResponse
-
-load_dotenv()
-
-OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY', '')
+from starlette.responses import HTMLResponse, PlainTextResponse
 
 # ---------------------------------------------------------------------------
 # Application Setup
 # ---------------------------------------------------------------------------
 app = Server()
 PORT = 7860
-DEFAULT_MODEL = "nvidia/nemotron-3-nano-30b-a3b"
-
-# ---------------------------------------------------------------------------
-# Node Manager
-# ---------------------------------------------------------------------------
-class NodeManager:
-    def __init__(self):
-        self.trees: Dict[str, Dict[str, Any]] = {}
-
-    def create_tree(self, tree_id: str, root_node: dict) -> None:
-        self.trees[tree_id] = root_node
-
-    def get_tree(self, tree_id: str) -> Optional[dict]:
-        return self.trees.get(tree_id)
-
-    def get_node(self, tree_id: str, node_id: str) -> Optional[dict]:
-        tree = self.trees.get(tree_id)
-        if not tree:
-            return None
-        return self._find_node(tree, node_id)
-
-    def _find_node(self, node: dict, node_id: str) -> Optional[dict]:
-        if node.get('id') == node_id:
-            return node
-        for child in node.get('children', []):
-            result = self._find_node(child, node_id)
-            if result:
-                return result
-        return None
+DATA_DIR = Path("data")
+DATA_DIR.mkdir(exist_ok=True)
 
-    def add_children(self, tree_id: str, parent_id: str, children: List[dict]) -> bool:
-        parent = self.get_node(tree_id, parent_id)
-        if parent is None:
-            return False
-        if 'children' not in parent:
-            parent['children'] = []
-        parent['children'].extend(children)
-        return True
-
-    def delete_tree(self, tree_id: str) -> None:
-        if tree_id in self.trees:
-            del self.trees[tree_id]
-
-    def to_dict(self, tree_id: str) -> Optional[dict]:
-        return self.trees.get(tree_id)
-
-    def get_path(self, tree_id: str, node_id: str) -> List[dict]:
-        tree = self.trees.get(tree_id)
-        if not tree:
-            return []
-        path = []
-        self._find_path(tree, node_id, path)
-        return path
-
-    def _find_path(self, node: dict, target_id: str, path: List[dict]) -> bool:
-        path.append(node)
-        if node.get('id') == target_id:
-            return True
-        for child in node.get('children', []):
-            if self._find_path(child, target_id, path):
-                return True
-        path.pop()
-        return False
+OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY', '')
+OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
+DEFAULT_MODEL = "nvidia/nemotron-3-nano-30b-a3b"
 
-node_manager = NodeManager()
+HF_TOKEN = os.getenv('HF_TOKEN', '')
+HF_DATASET_REPO = os.getenv('HF_DATASET_REPO', '')
 
 # ---------------------------------------------------------------------------
-# History Manager
+# Database Helpers
 # ---------------------------------------------------------------------------
-class HistoryManager:
-    def __init__(self):
-        self.history: Dict[str, Dict] = {}
-
-    def init_tree(self, tree_id: str) -> None:
-        self.history[tree_id] = {'undo': [], 'redo': []}
-
-    def push_state(self, tree_id: str, state: dict) -> None:
-        if tree_id not in self.history:
-            self.init_tree(tree_id)
-        self.history[tree_id]['undo'].append(state)
-        self.history[tree_id]['redo'] = []
-
-    def undo(self, tree_id: str) -> Optional[dict]:
-        if tree_id not in self.history or not self.history[tree_id]['undo']:
-            return None
-        state = self.history[tree_id]['undo'].pop()
-        self.history[tree_id]['redo'].append(state)
-        return state
-
-    def redo(self, tree_id: str) -> Optional[dict]:
-        if tree_id not in self.history or not self.history[tree_id]['redo']:
-            return None
-        state = self.history[tree_id]['redo'].pop()
-        self.history[tree_id]['undo'].append(state)
-        return state
-
-history_manager = HistoryManager()
 
-# ---------------------------------------------------------------------------
-# LLM API Call — OpenRouter
-# ---------------------------------------------------------------------------
-def call_api(prompt: str, system_prompt: str = "You are a helpful assistant that generates decision trees.") -> Optional[str]:
-    if not OPENROUTER_API_KEY:
-        print("[OpenRouter Error] No API key configured")
-        return None
+def get_db_path(session_id: str) -> Path:
+    return DATA_DIR / f"session_{session_id}.db"
+
+def init_session(session_id: str):
+    db_path = get_db_path(session_id)
+    if db_path.exists():
+        return
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("""
+        CREATE TABLE nodes (
+            id TEXT PRIMARY KEY,
+            parent_id TEXT,
+            type TEXT NOT NULL,
+            label TEXT NOT NULL,
+            description TEXT DEFAULT '',
+            emoji TEXT DEFAULT '\U0001f539',
+            tips TEXT DEFAULT '[]',
+            order_index INTEGER DEFAULT 0,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    root_id = str(uuid.uuid4())
+    conn.execute(
+        "INSERT INTO nodes (id, parent_id, type, label, description, emoji) VALUES (?, ?, ?, ?, ?, ?)",
+        (root_id, None, "root", "What decision do you want to explore?", "", "\U0001f333")
+    )
+    conn.commit()
+    conn.close()
 
+def get_node_db(session_id: str, node_id: str) -> Optional[Dict]:
+    db_path = get_db_path(session_id)
+    if not db_path.exists():
+        return None
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    row = conn.execute("SELECT * FROM nodes WHERE id=?", (node_id,)).fetchone()
+    conn.close()
+    if row is None:
+        return None
+    result = dict(row)
     try:
-        headers = {
-            'Authorization': f'Bearer {OPENROUTER_API_KEY}',
-            'Content-Type': 'application/json',
-            'HTTP-Referer': 'http://localhost:7860',
-            'X-Title': 'Overthinker'
-        }
-        data = {
-            'model': DEFAULT_MODEL,
-            'messages': [
-                {'role': 'system', 'content': system_prompt},
-                {'role': 'user', 'content': prompt}
-            ],
-            'temperature': 0.8,
-            'max_tokens': 2048
-        }
-        response = requests.post(
-            'https://openrouter.ai/api/v1/chat/completions',
-            headers=headers,
-            json=data,
-            timeout=30
-        )
-        if response.status_code == 200:
-            result = response.json()
-            return result['choices'][0]['message']['content']
-        else:
-            print(f"[OpenRouter Error] {response.status_code}: {response.text}")
-    except Exception as e:
-        print(f"[OpenRouter Exception] {e}")
+        result['tips'] = json.loads(result.get('tips', '[]'))
+    except:
+        result['tips'] = []
+    return result
+
+def get_children_db(session_id: str, parent_id: str) -> List[Dict]:
+    db_path = get_db_path(session_id)
+    if not db_path.exists():
+        return []
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    rows = conn.execute(
+        "SELECT * FROM nodes WHERE parent_id=? ORDER BY order_index",
+        (parent_id,)
+    ).fetchall()
+    conn.close()
+    result = []
+    for row in rows:
+        d = dict(row)
+        try:
+            d['tips'] = json.loads(d.get('tips', '[]'))
+        except:
+            d['tips'] = []
+        result.append(d)
+    return result
+
+def add_node_db(session_id: str, parent_id: str, node_type: str, label: str,
+                description: str = "", emoji: str = "\U0001f539",
+                tips: list = None, order_index: int = 0) -> Dict:
+    node_id = str(uuid.uuid4())
+    tips_json = json.dumps(tips or [])
+    db_path = get_db_path(session_id)
+    conn = sqlite3.connect(str(db_path))
+    conn.execute(
+        "INSERT INTO nodes (id, parent_id, type, label, description, emoji, tips, order_index) VALUES (?,?,?,?,?,?,?,?)",
+        (node_id, parent_id, node_type, label, description, emoji, tips_json, order_index)
+    )
+    conn.commit()
+    conn.close()
+    return {
+        "id": node_id,
+        "parent_id": parent_id,
+        "type": node_type,
+        "label": label,
+        "description": description,
+        "emoji": emoji,
+        "tips": tips or [],
+        "order_index": order_index
+    }
 
-    return None
+def update_root_db(session_id: str, label: str, description: str = ""):
+    db_path = get_db_path(session_id)
+    conn = sqlite3.connect(str(db_path))
+    conn.execute(
+        "UPDATE nodes SET label=?, description=? WHERE parent_id IS NULL",
+        (label, description)
+    )
+    conn.commit()
+    conn.close()
+
+def get_path_db(session_id: str, node_id: str) -> List[Dict]:
+    path = []
+    current_id = node_id
+    while current_id:
+        node = get_node_db(session_id, current_id)
+        if node is None:
+            break
+        path.append(node)
+        current_id = node.get("parent_id")
+    path.reverse()
+    return path
+
+def build_path_string(session_id: str, node_id: str) -> str:
+    nodes = get_path_db(session_id, node_id)
+    parts = []
+    for n in nodes:
+        t = n["type"]
+        label = n["label"]
+        if t == "root":
+            parts.append(f"[ROOT] {label}")
+        elif t == "input":
+            parts.append(f"[INPUT] {label}")
+        elif t == "outcome":
+            parts.append(f"[OUTCOME] {label}")
+    return " → ".join(parts)
+
+def get_root_node(session_id: str) -> Optional[Dict]:
+    db_path = get_db_path(session_id)
+    if not db_path.exists():
+        return None
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    row = conn.execute("SELECT * FROM nodes WHERE parent_id IS NULL LIMIT 1").fetchone()
+    conn.close()
+    if row is None:
+        return None
+    result = dict(row)
+    try:
+        result['tips'] = json.loads(result.get('tips', '[]'))
+    except:
+        result['tips'] = []
+    return result
+
+def get_all_node_ids(session_id: str) -> List[str]:
+    """Get IDs of all nodes in the tree (for full export)."""
+    db_path = get_db_path(session_id)
+    if not db_path.exists():
+        return []
+    conn = sqlite3.connect(str(db_path))
+    rows = conn.execute("SELECT id FROM nodes").fetchall()
+    conn.close()
+    return [r[0] for r in rows]
+
+def build_tree_nested(session_id: str) -> Optional[Dict]:
+    """Build a nested tree structure from the SQLite DB."""
+    root = get_root_node(session_id)
+    if not root:
+        return None
+    def build_tree(node):
+        children = get_children_db(session_id, node['id'])
+        node_copy = dict(node)
+        if isinstance(node_copy.get('tips'), str):
+            try:
+                node_copy['tips'] = json.loads(node_copy['tips'])
+            except:
+                node_copy['tips'] = []
+        node_copy['children'] = [build_tree(c) for c in children]
+        return node_copy
+    return build_tree(root)
 
 # ---------------------------------------------------------------------------
-# Fallback Generators
+# Prompt Builders (with path_context)
 # ---------------------------------------------------------------------------
-def _fallback_options(decision: str, context: str = "") -> dict:
-    """Generate fallback children that read as options/choices."""
-    import random
-    options = [
-        f"Approach this by seeking more information",
-        f"Consider consulting with trusted advisors",
-        f"Take a gradual step-by-step approach",
-        f"Weigh the pros and cons carefully",
-        f"Commit to a trial period before deciding",
-        f"Seek out alternative perspectives",
-        f"Prioritize your core values in the decision",
-        f"Create a contingency plan for risks",
-        f"Focus on short-term wins first",
-        f"Delegate aspects to reduce overwhelm"
-    ]
-    random.shuffle(options)
-    children = []
-    for i in range(min(3, len(options))):
-        child = {
-            'id': f'local_{datetime.now().timestamp()}_{i}_{random.randint(100,999)}',
-            'label': options[i],
-            'description': f'A possible approach: {options[i].lower()}. Consider how this option aligns with your goals.',
-            'type': 'input',
-            'tips': [f'Evaluate this option in the context of your overall decision.'],
-            'children': []
-        }
-        children.append(child)
-    return {'children': children}
-
-
-def _fallback_outcomes(decision: str, context: str = "") -> dict:
-    """Generate fallback children that read as outcomes (positive, neutral, negative)."""
-    import random
-    positive_outcomes = [
-        "Financial stability increases substantially",
-        "Personal growth accelerates beyond expectations",
-        "Relationships deepen and strengthen",
-        "Professional opportunities multiply rapidly",
-        "Your confidence and competence both grow",
-        "A supportive community forms around you",
-        "Health and well-being improve noticeably",
-        "Creative energy flows more freely",
-        "Unexpected doors open in your career",
-        "Your resilience is strengthened by this path"
-    ]
-    neutral_outcomes = [
-        "Your daily routine shifts gradually",
-        "Your perspective on the situation evolves",
-        "You gain new skills through necessity",
-        "Your priorities naturally reorganize",
-        "The outcome depends largely on external factors",
-        "Your support network becomes more defined",
-        "Both opportunities and risks emerge simultaneously",
-        "Time reveals consequences that aren't immediately visible",
-        "Your understanding of the situation deepens",
-        "The path forward becomes clearer over time"
-    ]
-    negative_outcomes = [
-        "Financial resources become stretched thin",
-        "Relationships come under significant strain",
-        "Your stress levels increase substantially",
-        "Career progress slows or stalls temporarily",
-        "Health issues may arise from increased pressure",
-        "Your support network may dwindle",
-        "Opportunity costs become more apparent",
-        "Self-doubt and uncertainty intensify",
-        "Work-life balance deteriorates further",
-        "The decision leads to unforeseen complications"
-    ]
-    pos = random.choice(positive_outcomes)
-    neu = random.choice(neutral_outcomes)
-    neg = random.choice(negative_outcomes)
-    sentiments = ['positive', 'neutral', 'negative']
-    labels = [pos, neu, neg]
-    desc_map = {
-        'positive': f'If this path unfolds favorably, {pos.lower()}. This represents a best-case scenario where your decision leads to growth and improvement.',
-        'neutral': f'On this path, {neu.lower()}. The outcome is neither clearly good nor bad — it requires careful monitoring.',
-        'negative': f'In a challenging scenario, {neg.lower()}. This represents potential risks and difficulties that may arise.'
-    }
-    tip_map = {
-        'positive': 'Nurture this positive outcome by staying engaged and proactive.',
-        'neutral': 'Monitor this neutral path closely — small changes can shift the outcome.',
-        'negative': 'Prepare contingency plans to mitigate this risk if it materializes.'
-    }
-    children = []
-    for i in range(3):
-        sentiment = sentiments[i]
-        child = {
-            'id': f'local_{datetime.now().timestamp()}_{i}_{random.randint(100,999)}',
-            'label': labels[i],
-            'description': desc_map[sentiment],
-            'type': 'outcome',
-            'tips': [tip_map[sentiment]],
-            'children': [],
-            'sentiment': sentiment
-        }
-        children.append(child)
-    return {'children': children}
 
-# ---------------------------------------------------------------------------
-# Prompt Builders — Dual prompts
-# ---------------------------------------------------------------------------
 def build_root_prompt(decision: str) -> str:
     return f'''You are an AI that helps people explore decisions by generating decision trees.
 
@@ -289,86 +228,114 @@ Return ONLY valid JSON with exactly this structure (no markdown, no backticks):
 {{
     "label": "A concise label for this decision tree (3-6 words)",
     "description": "A 1-2 sentence description of this decision context",
-    "type": "root",
+    "emoji": "An emoji representing this decision",
     "tips": ["One actionable tip for approaching this decision"]
 }}'''
 
-
-def build_options_prompt(decision_label: str, decision_desc: str, count: int, comment: str = "") -> str:
-    """
-    Prompt for generating OPTIONS/CHOICES/DECISIONS (for input-type nodes).
-    """
-    comment_section = f'\nUser context/comment: "{comment}"' if comment else ''
+def build_options_prompt(decision_label: str, decision_desc: str, count: int, path_context: str, comment: str = "") -> str:
+    path_section = f'\nFull path from root to this node: "{path_context}"' if path_context else ''
+    comment_section = f'\nUser context: "{comment}"' if comment else ''
     return f'''You are an AI that helps explore decisions by generating decision tree branches.
 
 Parent node: "{decision_label}"
-Description: "{decision_desc}"{comment_section}
+Description: "{decision_desc}"{path_section}{comment_section}
+
+Generate EXACTLY {count} child nodes that represent different OPTIONS or CHOICES the person could take.
 
-Generate EXACTLY {count} child nodes that represent different OPTIONS or CHOICES the person could take. Each child should be a distinct, realistic possibility — an actionable decision they could make at this point.
+IMPORTANT: Frame each child as an OPTION or CHOICE, not as an outcome.
 
-IMPORTANT: Frame each child as an OPTION or CHOICE, not as an outcome. For example:
-- GOOD: "Consult a financial advisor" (describes an action/choice)
-- BAD: "Financial situation improves" (describes an outcome — DO NOT use here)
+Consider the full decision path above to ensure the options are contextually relevant.
 
 Return ONLY valid JSON with exactly this structure (no markdown, no backticks):
 {{
     "children": [
         {{
             "id": "child_1",
-            "label": "Short option label (3-6 words) describing the choice",
-            "description": "1-2 sentence description of this option and its potential implications",
-            "type": "input",
-            "tips": ["One practical tip for evaluating this option"]
+            "label": "Short option label (3-6 words)",
+            "description": "1-2 sentence description",
+            "emoji": "An emoji",
+            "tips": ["One practical tip"]
         }},
-        ...repeat for each child...
+        ...
     ]
 }}
 
 Ensure children have unique IDs like child_1, child_2, etc.'''
 
-
-def build_outcomes_prompt(decision_label: str, decision_desc: str, count: int, comment: str = "") -> str:
-    """
-    Prompt for generating OUTCOMES/CONSEQUENCES (for outcome-type nodes).
-    Requests a diverse range: positive, neutral, and negative outcomes.
-    """
-    comment_section = f'\nUser context/comment: "{comment}"' if comment else ''
+def build_outcomes_prompt(decision_label: str, decision_desc: str, count: int, path_context: str, comment: str = "") -> str:
+    path_section = f'\nFull path from root to this node: "{path_context}"' if path_context else ''
+    comment_section = f'\nUser context: "{comment}"' if comment else ''
     return f'''You are an AI that helps explore decisions by generating decision tree branches.
 
 Parent node: "{decision_label}"
-Description: "{decision_desc}"{comment_section}
+Description: "{decision_desc}"{path_section}{comment_section}
 
-Generate EXACTLY {count} child nodes that represent a DIVERSE RANGE of possible OUTCOMES or CONSEQUENCES that could naturally follow from this decision path. Include a MIX of positive, neutral, and negative outcomes so the user sees the full spectrum of possibilities.
+Generate EXACTLY {count} child nodes that represent a DIVERSE RANGE of possible OUTCOMES. Include a MIX of positive, neutral, and negative outcomes.
 
-- Positive outcomes: beneficial results, improvements, gains
-- Neutral outcomes: mixed results, neither clearly good nor bad, trade-offs
-- Negative outcomes: risks, challenges, downsides
+IMPORTANT: Frame each child as an OUTCOME or CONSEQUENCE, not as a choice someone makes.
 
-IMPORTANT: Frame each child as an OUTCOME or CONSEQUENCE, not as a choice someone makes. For example:
-- GOOD: "Financial stability improves" (describes a result)
-- BAD: "Consider financial planning" (describes a choice — DO NOT do this)
+Consider the full decision path above to ensure the outcomes are contextually relevant.
 
 Return ONLY valid JSON with exactly this structure (no markdown, no backticks):
 {{
     "children": [
         {{
             "id": "child_1",
-            "label": "Short outcome label (3-6 words) describing the result",
-            "description": "1-2 sentence description of this possible consequence",
-            "type": "outcome",
-            "tips": ["One practical tip for navigating this outcome"]
+            "label": "Short outcome label (3-6 words)",
+            "description": "1-2 sentence description",
+            "emoji": "An emoji",
+            "tips": ["One practical tip"]
         }},
-        ...repeat for each child...
+        ...
     ]
 }}
 
-Ensure children have unique IDs like child_1, child_2, etc. Make sure the first child is a POSITIVE outcome, the second is NEUTRAL, and the third is NEGATIVE to guarantee diversity.'''
+Ensure children have unique IDs. Make sure the first child is POSITIVE, the second is NEUTRAL, and the third is NEGATIVE.'''
 
+# ---------------------------------------------------------------------------
+# AI Call (using OpenRouter via requests)
+# ---------------------------------------------------------------------------
+
+def call_api(prompt: str, system_prompt: str = "You are a helpful assistant that generates decision trees.") -> Optional[str]:
+    if not OPENROUTER_API_KEY:
+        print("[OpenRouter Error] No API key configured")
+        return None
+    try:
+        headers = {
+            'Authorization': f'Bearer {OPENROUTER_API_KEY}',
+            'Content-Type': 'application/json',
+            'HTTP-Referer': 'http://localhost:7860',
+            'X-Title': 'Overthinker'
+        }
+        data = {
+            'model': DEFAULT_MODEL,
+            'messages': [
+                {'role': 'system', 'content': system_prompt},
+                {'role': 'user', 'content': prompt}
+            ],
+            'temperature': 0.8,
+            'max_tokens': 2048
+        }
+        response = requests.post(
+            OPENROUTER_URL,
+            headers=headers,
+            json=data,
+            timeout=30
+        )
+        if response.status_code == 200:
+            result = response.json()
+            return result['choices'][0]['message']['content']
+        else:
+            print(f"[OpenRouter Error] {response.status_code}: {response.text}")
+    except Exception as e:
+        print(f"[OpenRouter Exception] {e}")
+    return None
 
 def parse_json_response(text: str) -> Optional[dict]:
     if not text:
         return None
     text = text.strip()
+    import re
     text = re.sub(r'```json\s*', '', text)
     text = re.sub(r'```\s*', '', text)
     text = text.strip()
@@ -384,7 +351,7 @@ def parse_json_response(text: str) -> Optional[dict]:
         return None
 
 # ---------------------------------------------------------------------------
-# Routes
+# Routes (All POST, no GET except for serving index)
 # ---------------------------------------------------------------------------
 
 @app.get("/")
@@ -395,224 +362,213 @@ async def index():
             return HTMLResponse(content=f.read(), status_code=200)
     return HTMLResponse(content="<h1>Overthinker</h1><p>index.html not found</p>", status_code=404)
 
+@app.post("/root")
+async def create_root(request: dict):
+    session_id = request.get('session_id', str(uuid.uuid4()))
+    init_session(session_id)
+    root = get_root_node(session_id)
+    if root is None:
+        raise HTTPException(status_code=500, detail="Could not initialize session.")
+    return {"session_id": session_id, "node": root}
 
 @app.post("/create_tree")
 async def create_tree(request: dict):
-    decision = request.get('decision', 'Make a decision')
-    tree_id = f'tree_{datetime.now().timestamp()}'
+    session_id = request.get('session_id', str(uuid.uuid4()))
+    decision = request.get('decision', '')
+    if not decision:
+        raise HTTPException(status_code=400, detail="Decision text is required.")
+    init_session(session_id)
     prompt = build_root_prompt(decision)
     ai_response = call_api(prompt)
     parsed = parse_json_response(ai_response) if ai_response else None
-    if parsed:
-        root_node = {
-            'id': tree_id,
-            'label': parsed.get('label', f'Overthinking: {decision[:40]}'),
-            'description': parsed.get('description', f'You are overthinking: {decision}'),
-            'type': 'root',
-            'tips': parsed.get('tips', ['Start by exploring the first set of options.']),
-            'children': [],
-        }
-    else:
-        root_node = {
-            'id': tree_id,
-            'label': f'Overthinking: {decision[:40]}',
-            'description': f'You are overthinking: {decision}',
-            'type': 'root',
-            'tips': ['Start by exploring the first set of options.'],
-            'children': [],
-        }
-    node_manager.create_tree(tree_id, root_node)
-    history_manager.init_tree(tree_id)
-    history_manager.push_state(tree_id, {'action': 'create', 'tree': root_node})
-    return {'tree_id': tree_id, 'root_node': root_node}
-
-
-@app.get("/get_children")
-async def get_children(node_id: str, count: int = 3, node_type: str = "outcome", comment: Optional[str] = None):
-    # Find which tree contains this node
-    tree_id = None
-    for tid in list(node_manager.trees.keys()):
-        node = node_manager.get_node(tid, node_id)
-        if node:
-            tree_id = tid
-            break
-    if not tree_id:
+    if not parsed:
+        raise HTTPException(status_code=500, detail="Failed to generate root node. Please check your API key and try again.")
+    label = parsed.get('label', f'Overthinking: {decision[:40]}')
+    description = parsed.get('description', f'You are overthinking: {decision}')
+    emoji = parsed.get('emoji', '\U0001f333')
+    tips = parsed.get('tips', ['Start by exploring options.'])
+    update_root_db(session_id, label, description)
+    db_path = get_db_path(session_id)
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("UPDATE nodes SET emoji=?, tips=? WHERE parent_id IS NULL", (emoji, json.dumps(tips)))
+    conn.commit()
+    conn.close()
+    root = get_root_node(session_id)
+    return {'session_id': session_id, 'node': root}
+
+@app.post("/get_node")
+async def get_node_endpoint(request: dict):
+    session_id = request.get('session_id')
+    node_id = request.get('node_id')
+    if not session_id or not node_id:
+        raise HTTPException(status_code=400, detail="Missing session_id or node_id")
+    init_session(session_id)
+    node = get_node_db(session_id, node_id)
+    if node is None:
         raise HTTPException(status_code=404, detail="Node not found")
-    parent = node_manager.get_node(tree_id, node_id)
-    if not parent:
-        raise HTTPException(status_code=404, detail="Parent node not found")
+    children = get_children_db(session_id, node_id)
+    path_context = build_path_string(session_id, node_id)
+    return {
+        'node': node,
+        'children': children,
+        'path_context': path_context
+    }
 
-    # Determine what type of children to generate (input -> options; outcome -> outcomes)
+@app.post("/get_children")
+async def get_children(request: dict):
+    session_id = request.get('session_id')
+    node_id = request.get('node_id')
+    count = request.get('count', 3)
+    node_type = request.get('node_type', 'outcome')
+    comment = request.get('comment', '')
+    if not session_id or not node_id:
+        raise HTTPException(status_code=400, detail="Missing session_id or node_id")
+    init_session(session_id)
+    parent = get_node_db(session_id, node_id)
+    if parent is None:
+        raise HTTPException(status_code=404, detail="Node not found")
+    path_context = build_path_string(session_id, node_id)
     next_type_map = {'root': 'input', 'input': 'outcome', 'outcome': 'input'}
     next_type = next_type_map.get(node_type, 'outcome')
-
     parent_label = parent.get('label', 'Unknown')
     parent_desc = parent.get('description', '')
-
-    # Select the appropriate prompt and fallback based on next_type
     if next_type == 'input':
-        prompt = build_options_prompt(parent_label, parent_desc, count, comment or "")
-        fallback_func = _fallback_options
+        prompt = build_options_prompt(parent_label, parent_desc, count, path_context, comment)
     else:
-        prompt = build_outcomes_prompt(parent_label, parent_desc, count, comment or "")
-        fallback_func = _fallback_outcomes
-
+        prompt = build_outcomes_prompt(parent_label, parent_desc, count, path_context, comment)
     ai_response = call_api(prompt)
     parsed = parse_json_response(ai_response) if ai_response else None
-
-    if parsed and 'children' in parsed:
-        children = parsed['children']
-        for i, child in enumerate(children):
-            if not child.get('id') or child['id'] == f'child_{i+1}':
-                child['id'] = f'{node_id}_child_{i}_{uuid.uuid4().hex[:8]}'
-            child['type'] = next_type
-            if 'tips' not in child or not child['tips']:
-                child['tips'] = [f'Consider this {next_type} as a possible next step.']
-            if 'children' not in child:
-                child['children'] = []
-        node_manager.add_children(tree_id, node_id, children)
-        history_manager.push_state(tree_id, {'action': 'expand', 'node_id': node_id, 'children': children})
-        return {'children': children}
-
-    # Fallback
-    fallback = fallback_func(parent_label, parent_desc)
-    children = fallback.get('children', [])
-    for i, child in enumerate(children):
-        child['id'] = f'{node_id}_child_{i}_{uuid.uuid4().hex[:8]}'
-        child['type'] = next_type
-    node_manager.add_children(tree_id, node_id, children)
-    history_manager.push_state(tree_id, {'action': 'expand', 'node_id': node_id, 'children': children})
-    return {'children': children}
-
+    if not parsed or 'children' not in parsed or not isinstance(parsed['children'], list):
+        raise HTTPException(status_code=500, detail="Generation failed. Please check your API key and try again.")
+    children_data = parsed['children']
+    children = []
+    for i, child in enumerate(children_data):
+        label = child.get('label', 'Unknown')
+        description = child.get('description', '')
+        emoji = child.get('emoji', '\U0001f539')
+        tips = child.get('tips', [f'Consider this {next_type}.'])
+        existing = get_children_db(session_id, node_id)
+        existing_labels = [c['label'] for c in existing]
+        if label in existing_labels or label in [c['label'] for c in children]:
+            label = f"{label} ({i+1})"
+        child_node = add_node_db(session_id, node_id, next_type, label, description, emoji, tips, order_index=i)
+        child_node['type'] = next_type
+        children.append(child_node)
+    return {'children': children, 'next_type': next_type}
 
 @app.post("/add_options")
 async def add_options(request: dict):
-    node_id = request.get('node_id', '')
+    session_id = request.get('session_id')
+    node_id = request.get('node_id')
     count = request.get('count', 3)
-    tree_id = None
-    for tid in list(node_manager.trees.keys()):
-        node = node_manager.get_node(tid, node_id)
-        if node:
-            tree_id = tid
-            break
-    if not tree_id:
+    comment = request.get('comment', '')
+    if not session_id or not node_id:
+        raise HTTPException(status_code=400, detail="Missing session_id or node_id")
+    init_session(session_id)
+    parent = get_node_db(session_id, node_id)
+    if parent is None:
         raise HTTPException(status_code=404, detail="Node not found")
-    parent = node_manager.get_node(tree_id, node_id)
-    if not parent:
-        raise HTTPException(status_code=404, detail="Parent node not found")
-
+    path_context = build_path_string(session_id, node_id)
+    next_type_map = {'root': 'input', 'input': 'outcome', 'outcome': 'input'}
+    next_type = next_type_map.get(parent.get('type', 'root'), 'outcome')
     parent_label = parent.get('label', 'Unknown')
     parent_desc = parent.get('description', '')
-    node_type = parent.get('type', 'root')
-    next_type_map = {'root': 'input', 'input': 'outcome', 'outcome': 'input'}
-    next_type = next_type_map.get(node_type, 'outcome')
-
     if next_type == 'input':
-        prompt = build_options_prompt(parent_label, parent_desc, count)
-        fallback_func = _fallback_options
+        prompt = build_options_prompt(parent_label, parent_desc, count, path_context, comment)
     else:
-        prompt = build_outcomes_prompt(parent_label, parent_desc, count)
-        fallback_func = _fallback_outcomes
-
+        prompt = build_outcomes_prompt(parent_label, parent_desc, count, path_context, comment)
     ai_response = call_api(prompt)
     parsed = parse_json_response(ai_response) if ai_response else None
-
-    if parsed and 'children' in parsed:
-        children = parsed['children']
-        for i, child in enumerate(children):
-            if not child.get('id') or child['id'] == f'child_{i+1}':
-                child['id'] = f'{node_id}_extra_{i}_{uuid.uuid4().hex[:8]}'
-            child['type'] = next_type
-            if 'tips' not in child or not child['tips']:
-                child['tips'] = [f'Additional {next_type} to consider.']
-            if 'children' not in child:
-                child['children'] = []
-        node_manager.add_children(tree_id, node_id, children)
-        history_manager.push_state(tree_id, {'action': 'add', 'node_id': node_id, 'children': children})
-        return {'children': children}
-
-    fallback = fallback_func(parent_label, parent_desc)
-    children = fallback.get('children', [])
-    for i, child in enumerate(children):
-        child['id'] = f'{node_id}_extra_{i}_{uuid.uuid4().hex[:8]}'
-        child['type'] = next_type
-    node_manager.add_children(tree_id, node_id, children)
-    history_manager.push_state(tree_id, {'action': 'add', 'node_id': node_id, 'children': children})
-    return {'children': children}
-
-
-@app.get("/get_tree")
-async def get_tree_get(tree_id: Optional[str] = None):
-    if not tree_id:
-        for tid in list(node_manager.trees.keys()):
-            tree_id = tid
-            break
-    if not tree_id or tree_id not in node_manager.trees:
-        raise HTTPException(status_code=404, detail="Tree not found")
-    return node_manager.to_dict(tree_id)
-
-
-@app.post("/get_tree")
-async def get_tree_post(request: dict):
-    tree_id = request.get('tree_id', '')
-    if not tree_id:
-        for tid in list(node_manager.trees.keys()):
-            tree_id = tid
-            break
-    if not tree_id or tree_id not in node_manager.trees:
-        raise HTTPException(status_code=404, detail="Tree not found")
-    return node_manager.to_dict(tree_id)
-
-
-@app.post("/undo")
-async def undo(request: dict):
-    tree_id = request.get('tree_id', '')
-    if not tree_id:
-        return {'error': 'No tree ID provided'}
-    state = history_manager.undo(tree_id)
-    if not state:
-        return {'error': 'Nothing to undo'}
-    return {'success': True, 'message': 'Undo performed'}
-
-
-@app.post("/redo")
-async def redo(request: dict):
-    tree_id = request.get('tree_id', '')
-    if not tree_id:
-        return {'error': 'No tree ID provided'}
-    state = history_manager.redo(tree_id)
-    if not state:
-        return {'error': 'Nothing to redo'}
-    return {'success': True, 'message': 'Redo performed'}
-
+    if not parsed or 'children' not in parsed or not isinstance(parsed['children'], list):
+        raise HTTPException(status_code=500, detail="Failed to add options. Please try again.")
+    children_data = parsed['children']
+    children = []
+    for i, child in enumerate(children_data):
+        label = child.get('label', 'Unknown')
+        description = child.get('description', '')
+        emoji = child.get('emoji', '\U0001f539')
+        tips = child.get('tips', [f'Additional {next_type}.'])
+        existing = get_children_db(session_id, node_id)
+        existing_labels = [c['label'] for c in existing]
+        if label in existing_labels or label in [c['label'] for c in children]:
+            label = f"{label} ({i+1})"
+        child_node = add_node_db(session_id, node_id, next_type, label, description, emoji, tips, order_index=i)
+        child_node['type'] = next_type
+        children.append(child_node)
+    return {'children': children, 'next_type': next_type}
+
+@app.post("/upload_trace")
+async def upload_trace(request: dict):
+    """Serialize the full tree from SQLite and push to HuggingFace dataset."""
+    session_id = request.get('session_id')
+    if not session_id:
+        raise HTTPException(status_code=400, detail="Missing session_id")
+    
+    if not HF_TOKEN or not HF_DATASET_REPO:
+        raise HTTPException(status_code=500, detail="HF_TOKEN and HF_DATASET_REPO must be configured in environment.")
+    
+    tree = build_tree_nested(session_id)
+    if tree is None:
+        raise HTTPException(status_code=404, detail="No tree found for this session.")
+    
+    try:
+        from datasets import Dataset, concatenate_datasets, load_dataset
+        import pandas as pd
+        
+        row = {
+            'session_id': session_id,
+            'tree_json': json.dumps(tree),
+            'created_at': str(tree.get('created_at', ''))
+        }
+        df = pd.DataFrame([row])
+        new_dataset = Dataset.from_pandas(df)
+        
+        try:
+            existing_dataset = load_dataset(HF_DATASET_REPO, split='train', token=HF_TOKEN)
+            combined = concatenate_datasets([existing_dataset, new_dataset])
+        except Exception:
+            combined = new_dataset
+        
+        combined.push_to_hub(HF_DATASET_REPO, token=HF_TOKEN, private=False)
+        
+        return {'status': 'success', 'message': 'Trace uploaded successfully!'}
+    except Exception as e:
+        print(f"[Upload Trace Error] {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to upload trace: {str(e)}")
 
 @app.post("/export_json")
 async def export_json(request: dict):
-    tree_id = request.get('tree_id', '')
-    if not tree_id or tree_id not in node_manager.trees:
-        raise HTTPException(status_code=404, detail="Tree not found")
-    tree = node_manager.to_dict(tree_id)
-    return tree
-
+    session_id = request.get('session_id')
+    if not session_id:
+        raise HTTPException(status_code=400, detail="Missing session_id")
+    root = get_root_node(session_id)
+    if not root:
+        raise HTTPException(status_code=404, detail="No tree found")
+    def build_tree(node):
+        children = get_children_db(session_id, node['id'])
+        node_copy = dict(node)
+        node_copy['children'] = [build_tree(c) for c in children]
+        return node_copy
+    full_tree = build_tree(root)
+    return full_tree
 
 @app.post("/export_path_json")
 async def export_path_json(request: dict):
-    tree_id = request.get('tree_id', '')
-    node_id = request.get('node_id', '')
-    if not tree_id or not node_id:
-        return {'error': 'Missing tree_id or node_id'}
-    path = node_manager.get_path(tree_id, node_id)
-    return {'path': path}
-
+    session_id = request.get('session_id')
+    node_id = request.get('node_id')
+    if not session_id or not node_id:
+        raise HTTPException(status_code=400, detail="Missing session_id or node_id")
+    path_nodes = get_path_db(session_id, node_id)
+    return {'path': path_nodes}
 
 @app.post("/export_path_md")
 async def export_path_md(request: dict):
-    tree_id = request.get('tree_id', '')
-    node_id = request.get('node_id', '')
-    if not tree_id or not node_id:
-        raise HTTPException(status_code=400, detail="Missing tree_id or node_id")
-    path = node_manager.get_path(tree_id, node_id)
-    md = '# \U0001f9e0 Overthinker \u2014 Decision Path\n\n'
+    session_id = request.get('session_id')
+    node_id = request.get('node_id')
+    if not session_id or not node_id:
+        raise HTTPException(status_code=400, detail="Missing session_id or node_id")
+    path = get_path_db(session_id, node_id)
+    md = '# \U0001f9e0 Overthinker — Decision Path\n\n'
     for i, node in enumerate(path):
         indent = '  ' * i
         emoji = {'root': '\U0001f333', 'input': '\U0001f9e0', 'outcome': '\U0001f4ca'}.get(node.get('type', ''), '\U0001f4cc')
@@ -622,20 +578,22 @@ async def export_path_md(request: dict):
         if node.get('tips') and len(node['tips']) > 0:
             md += f'{indent}  > \U0001f4a1 {node["tips"][0]}\n'
         md += '\n'
-    return md
+    return PlainTextResponse(content=md, status_code=200)
 
 # ---------------------------------------------------------------------------
 # Launch
 # ---------------------------------------------------------------------------
 if __name__ == "__main__":
-    print(f"\U0001f9e0 Overthinker \u2014 Starting on port {PORT}")
+    import requests  # needed for sync calls inside async routes
+    print(f"\U0001f9e0 Overthinker v28 — SQLite Session Mode + HF Trace Upload on port {PORT}")
     print(f"\U0001f916 Model: {DEFAULT_MODEL}")
     print(f"\U0001f310 Open http://localhost:{PORT} in your browser")
     if not OPENROUTER_API_KEY:
-        print("\u26a0\ufe0f  No OPENROUTER_API_KEY found. Add it to your .env file. Fallback generation will be used.")
-    print(f"\U0001f4da API docs available at http://localhost:{PORT}/docs")
+        print("\u26a0\ufe0f  No OPENROUTER_API_KEY found. Add to .env or environment. Generation will fail.")
+    if not HF_TOKEN or not HF_DATASET_REPO:
+        print("\u26a0\ufe0f  No HF_TOKEN or HF_DATASET_REPO set. Upload will fail.")
     app.launch(
         server_port=PORT,
         show_error=True,
         share=False
-    )
+    )