Update main.py

main.py

@@ -60,7 +60,7 @@ except Exception as e:
 bucket = storage.bucket()
 db_ref = db.reference()
 
-# --- Google GenAI Client Initialization (Gemini 3.0 Flash) ---
+# --- Google GenAI Client Initialization (Gemini 3.0) ---
 try:
     logger.info("Initializing Google GenAI Client...")
     api_key = os.environ.get("Gemini")
@@ -74,10 +74,11 @@ except Exception as e:
     exit(1)
 
 # Model Constants
-ATHENA_MODEL = "gemini-3-flash-preview"
+ATHENA_FLASH = "gemini-3-flash-preview"
+ATHENA_PRO = "gemini-3-pro-image-preview"
 BRIEFING_MODEL = "gemini-3-flash-preview"
 
-# Grounding API Keys
+# Grounding / External API
 WOLFRAM_APP_ID = os.environ.get("WOLFRAM_APP_ID")
 OPENALEX_MAILTO = os.environ.get("OPENALEX_MAILTO", "rairo@sozofix.tech")
 
@@ -99,10 +100,9 @@ def verify_token(auth_header):
 
 def verify_admin(auth_header):
     uid = verify_token(auth_header)
-    if not uid: raise PermissionError('Invalid or missing token')
+    if not uid: raise PermissionError('Invalid token')
     user_data = db_ref.child(f'users/{uid}').get()
     if not user_data or not user_data.get('is_admin', False):
-        logger.warning(f"Admin access denied for user: {uid}")
         raise PermissionError('Admin access required')
     return uid
 
@@ -117,388 +117,302 @@ def upload_to_storage(data_bytes, destination_blob_name, content_type):
         return None
 
 def query_wolfram_alpha(query):
-    logger.info(f"Querying Wolfram Alpha: {query}")
-    if not WOLFRAM_APP_ID: 
-        logger.warning("WOLFRAM_APP_ID missing.")
-        return "Wolfram|Alpha grounding unavailable."
+    if not WOLFRAM_APP_ID: return "Grounded in theoretical physics."
     try:
         url = f"http://api.wolframalpha.com/v1/result?appid={WOLFRAM_APP_ID}&i={query}"
         response = requests.get(url, timeout=5)
-        if response.status_code == 200:
-            logger.info("Wolfram Alpha check successful.")
-            return response.text
-        else:
-            logger.warning(f"Wolfram Alpha returned status {response.status_code}")
-            return "Fact-check pending."
-    except Exception as e:
-        logger.error(f"Wolfram Alpha query failed: {e}")
-        return "Grounding timeout."
-
-def query_openalex(topic):
-    logger.info(f"Querying OpenAlex for topic: {topic}")
-    try:
-        url = f"https://api.openalex.org/works?search={topic}&mailto={OPENALEX_MAILTO}"
-        resp = requests.get(url, timeout=5).json()
-        results = resp.get('results', [])
-        logger.info(f"OpenAlex found {len(results)} results.")
-        return [{"title": r['title'], "url": r['doi'] or r['id'], "year": r['publication_year']} for r in results[:3]]
-    except Exception as e:
-        logger.error(f"OpenAlex query failed: {e}")
-        return []
+        return response.text if response.status_code == 200 else "Fact-checking..."
+    except: return "Grounding context pending."
 
 # -----------------------------------------------------------------------------
-# 3. ASYNCHRONOUS VOICE ORCHESTRATION (ATHENA VOICE)
+# 3. TITANESS MEDIA ENGINE (PARALLEL BLUEPRINTS & NARRATION)
 # -----------------------------------------------------------------------------
 
-def generate_single_narration(text, uid, epiphany_id, layer_name):
-    """Deepgram Aura-Luna generation for a single layer."""
+def generate_narration_task(text, uid, epiphany_id, layer_name):
     try:
-        logger.info(f"Generating TTS for layer: {layer_name}")
         api_key = os.environ.get("DEEPGRAM_API_KEY")
-        if not api_key:
-            logger.error("DEEPGRAM_API_KEY is not set.")
-            return layer_name, None
-
+        if not api_key: return layer_name, None
         DEEPGRAM_URL = "https://api.deepgram.com/v1/speak?model=aura-luna-en"
         headers = {"Authorization": f"Token {api_key}", "Content-Type": "text/plain"}
-        
         response = requests.post(DEEPGRAM_URL, headers=headers, data=text.encode('utf-8'))
         response.raise_for_status()
-
-        audio_path = f"users/{uid}/epiphanies/{epiphany_id}/narrations/{layer_name}.mp3"
-        url = upload_to_storage(response.content, audio_path, 'audio/mpeg')
-        logger.info(f"TTS Uploaded: {url}")
-        return layer_name, url
+        path = f"users/{uid}/epiphanies/{epiphany_id}/narrations/{layer_name}.mp3"
+        return layer_name, upload_to_storage(response.content, path, 'audio/mpeg')
     except Exception as e:
-        logger.error(f"TTS Error [{layer_name}]: {e}")
+        logger.error(f"TTS Task Error [{layer_name}]: {e}")
         return layer_name, None
 
-def generate_all_narrations_async(data_dict, uid, epiphany_id):
-    """Uses ThreadPoolExecutor to generate all 4 layers in parallel."""
-    logger.info(f"Starting parallel TTS generation for epiphany: {epiphany_id}")
-    layers = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
-    results = {}
-    with ThreadPoolExecutor(max_workers=4) as executor:
-        futures = [executor.submit(generate_single_narration, data_dict[l], uid, epiphany_id, l) for l in layers]
-        for f in futures:
-            layer, url = f.result()
-            results[layer] = url
-    return results
+def generate_blueprint_task(subject, text, uid, epiphany_id, layer_name):
+    """Nano Banana Pro: High-fidelity 4K blueprints."""
+    try:
+        prompt = (
+            f"Generate a technical 4K blueprint infographic of a {subject}'s {layer_name}. "
+            f"Context: {text}. Style: Leonardo Da Vinci sketch meets modern 4K schematic. "
+            f"Midnight navy background, white-line art. Use Google Search to ensure physical accuracy."
+        )
+        response = client.models.generate_content(
+            model=ATHENA_PRO,
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                tools=[{"google_search": {}}],
+                image_config=types.ImageConfig(aspect_ratio="16:9", image_size="4K")
+            )
+        )
+        image_parts = [part for part in response.parts if part.inline_data]
+        if image_parts:
+            img_bytes = image_parts[0].inline_data.data
+            path = f"users/{uid}/epiphanies/{epiphany_id}/blueprints/{layer_name}.png"
+            return layer_name, upload_to_storage(img_bytes, path, 'image/png')
+        return layer_name, None
+    except Exception as e:
+        logger.error(f"Nano Banana Pro Task Error [{layer_name}]: {e}")
+        return layer_name, None
 
 # -----------------------------------------------------------------------------
-# 4. EPIPHANY SYNTHESIS (THE DISCOVERY ENDPOINTS)
+# 4. EPIPHANY & THEIA ENDPOINTS
 # -----------------------------------------------------------------------------
+
 @app.route('/api/image-proxy', methods=['GET'])
 def image_proxy():
-    """Proxies images from Firebase Storage to bypass CORS/Preview issues."""
     image_url = request.args.get('url')
     if not image_url: return jsonify({'error': 'No URL'}), 400
     try:
         resp = requests.get(image_url, timeout=10)
         return Response(resp.content, content_type=resp.headers['Content-Type'])
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
+    except Exception as e: return jsonify({'error': str(e)}), 500
 
 @app.route('/api/epiphany/generate', methods=['POST'])
 def generate_epiphany():
-    logger.info(">>> START generate_epiphany request")
+    """Core Epiphany + Feynman Scholar Search."""
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
-    logger.info(f"User validated: {uid}")
     user_ref = db_ref.child(f'users/{uid}')
     user_data = user_ref.get()
-    
-    if not user_data or user_data.get('credits', 0) < 1:
-        logger.warning(f"User {uid} has insufficient credits.")
-        return jsonify({'error': 'Insufficient sparks for an Epiphany.'}), 402
+    if not user_data or user_data.get('credits', 0) < 4:
+        return jsonify({'error': 'Need 4 Sparks for Synthesis.'}), 402
 
-    if 'image' not in request.files:
-        logger.error("No image file provided in request.")
-        return jsonify({'error': 'Visual input is required.'}), 400
-    
     image_file = request.files['image']
     image_bytes = image_file.read()
-    
+    pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+
     try:
-        pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
-        logger.info("Image bytes successfully converted to PIL.")
-
-        # Step 1: Rapid Identification
-        logger.info("Step 1: Running Rapid Identification...")
-        id_prompt = "Identify this precisely. If biological, include the Latin name. If mechanical, include the inventor if known. Reply with ONLY the name."
-        id_response = client.models.generate_content(model=ATHENA_MODEL, contents=[id_prompt, pil_image])
-        subject = id_response.text.strip()
-        logger.info(f"Subject Identified: {subject}")
-
-        # Step 2: Grounding (Parallel Dispatch)
-        logger.info("Step 2: Grounding Dispatch...")
-        physics_fact = query_wolfram_alpha(f"constants of {subject}")
-        papers = query_openalex(subject)
-
-        # Step 3: Synthesis (Feynman Technique)
-        logger.info("Step 3: Generating Feynman Synthesis JSON...")
+        # Step 1: ID
+        id_prompt = "Identify this object/system precisely. Reply with ONLY the name."
+        subject = client.models.generate_content(model=ATHENA_FLASH, contents=[id_prompt, pil_image]).text.strip()
+        logger.info(f"Subject: {subject}")
+
+        # Step 2: Feynman Synthesis + Universal Research Search
+        physics_fact = query_wolfram_alpha(f"physics laws of {subject}")
         synthesis_prompt = f"""
-        Act as Athena, the Systems Synthesizer. Reveal the first principles of '{subject}'.
+        Act as Athena. Analyze '{subject}' grounded in this: {physics_fact}.
         Style: Richard Feynman. Simple analogies, profound scientific truths.
         
-        Grounding Context: {physics_fact}
+        Tasks:
+        1. Search the web (ArXiv, Patents, Journals) for 3 diverse sources about {subject} using Google Search.
+        2. Create 4 Discovery Layers (JSON keys: title, genesis, scientific_core, engineering_edge, cross_pollination).
+        3. For each of the 3 research sources, provide its URL, Title, and a 2-sentence Feynman Summary.
         
-        Output JSON:
-        {{
-            "title": "Epic 3-word title",
-            "genesis": "The origin and the core 'Aha!' moment of this system.",
-            "scientific_core": "The first principles of physics/biology at play here.",
-            "engineering_edge": "Detailed analysis of material, stress, or evolutionary advantage.",
-            "cross_pollination": "How this principle applies to a completely different field."
-        }}
+        Return JSON ONLY.
         """
         
-        synth_response = client.models.generate_content(
-            model=ATHENA_MODEL, 
+        res = client.models.generate_content(
+            model=ATHENA_FLASH,
             contents=[synthesis_prompt, pil_image],
-            config=types.GenerateContentConfig(response_mime_type='application/json')
+            config=types.GenerateContentConfig(
+                tools=[{"google_search": {}}],
+                response_mime_type='application/json'
+            )
         )
         
-        # Log raw response for debugging 500s
-        raw_text = synth_response.text
-        logger.info(f"Raw Synthesis Response: {raw_text}")
-
-        # Cleaning up markdown code blocks if present
-        if raw_text.startswith("```json"):
-            raw_text = raw_text.replace("```json", "").replace("```", "").strip()
-
-        data = json.loads(raw_text)
+        data = json.loads(res.text)
         epiphany_id = str(uuid.uuid4())
-        logger.info(f"Epiphany ID generated: {epiphany_id}")
-        
-        # Step 4: Parallel Audio Generation
-        logger.info("Step 4: Running Parallel TTS...")
-        narration_urls = generate_all_narrations_async(data, uid, epiphany_id)
-
-        # Step 5: Persistence
-        logger.info("Step 5: Finalizing record and uploading image...")
-        image_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/vision.jpg", 'image/jpeg')
-
+        layers = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
+
+        # Step 3: Parallel Media (Titaness Execution)
+        final_audios = {}
+        final_blueprints = {}
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            aud_futures = [executor.submit(generate_narration_task, data[l], uid, epiphany_id, l) for l in layers]
+            blu_futures = [executor.submit(generate_blueprint_task, subject, data[l], uid, epiphany_id, l) for l in layers]
+            for f in aud_futures: 
+                k, v = f.result()
+                final_audios[k] = v
+            for f in blu_futures: 
+                k, v = f.result()
+                final_blueprints[k] = v
+
+        # Step 4: Storage
+        image_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/original.jpg", 'image/jpeg')
         epiphany_record = {
             "epiphanyId": epiphany_id,
             "uid": uid,
-            "title": data.get('title', 'Unknown Discovery'),
+            "title": data.get('title', 'System Epiphany'),
             "subject": subject,
             "imageURL": image_url,
             "layers": {
-                "genesis": {"text": data.get('genesis', ''), "audio": narration_urls.get('genesis')},
-                "scientific_core": {"text": data.get('scientific_core', ''), "audio": narration_urls.get('scientific_core')},
-                "engineering_edge": {"text": data.get('engineering_edge', ''), "audio": narration_urls.get('engineering_edge')},
-                "cross_pollination": {"text": data.get('cross_pollination', ''), "audio": narration_urls.get('cross_pollination')}
+                l: {
+                    "text": data[l], 
+                    "audio": final_audios.get(l), 
+                    "blueprint": final_blueprints.get(l)
+                } for l in layers
             },
-            "grounding": {"physics": physics_fact, "papers": papers},
+            "scholar": data.get('scholar_sources', []),
             "createdAt": datetime.utcnow().isoformat()
         }
 
         db_ref.child(f'epiphanies/{epiphany_id}').set(epiphany_record)
-        user_ref.update({'credits': user_data.get('credits', 0) - 1})
-        logger.info(f"EP-GEN SUCCESS: {epiphany_id}")
-
+        user_ref.update({'credits': user_data.get('credits', 0) - 4})
         return jsonify(epiphany_record), 201
 
-    except json.JSONDecodeError as je:
-        logger.error(f"JSON Parsing Error: {je}. Raw output was: {synth_response.text}")
-        return jsonify({'error': 'AI generated invalid JSON. Try again.'}), 500
     except Exception as e:
-        logger.error(f"Generate Epiphany Global Error: {e}")
-        logger.error(traceback.format_exc())
+        logger.error(f"Epiphany Gen Error: {e}")
         return jsonify({'error': str(e)}), 500
 
-@app.route('/api/epiphany/deep-dive', methods=['POST'])
-def deep_dive():
-    logger.info(">>> START deep-dive request")
+@app.route('/api/epiphany/theia', methods=['POST'])
+def theia_sweep():
+    """
+    Separate Feature: Theia Mode.
+    Takes an epiphany context and performs an annotated 'Universal Sight Sweep'.
+    """
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
+    user_ref = db_ref.child(f'users/{uid}')
+    if user_ref.get().get('credits', 0) < 4:
+        return jsonify({'error': 'Need 4 Sparks for Theia Mode.'}), 402
+
+    epiphany_id = request.form.get('epiphanyId')
     image_file = request.files['image']
+    
+    # Fetch context from existing epiphany
+    context_data = db_ref.child(f'epiphanies/{epiphany_id}').get() or {}
+    subject = context_data.get('subject', 'Unknown System')
+
+    sweep_prompt = f"""
+    Activate Theia Mode for: {subject}.
+    Task: Use Python Code Execution to perform a surgical spatial deconstruction of this image.
+    Identify every functional component.
+    For each component return:
+    1. Label.
+    2. Bounding Box [ymin, xmin, ymax, xmax] (0-1000).
+    3. A 20-word Feynman-style 'Micro-Epiphany' about its role.
+    
+    Return JSON list ONLY.
+    """
+
     try:
         pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
-        dive_prompt = "Act as an Engineering Lead. In 50 words, explain the microscopic or mechanical significance of this specific detail."
-        
-        res = client.models.generate_content(model=ATHENA_MODEL, contents=[dive_prompt, pil_image])
-        logger.info("Deep dive reasoning completed.")
+        res = client.models.generate_content(
+            model=ATHENA_FLASH,
+            contents=[sweep_prompt, pil_image],
+            config=types.GenerateContentConfig(
+                tools=[types.Tool(code_execution=types.ToolCodeExecution)],
+                response_mime_type='application/json'
+            )
+        )
+        annotations = json.loads(res.text)
+        user_ref.update({'credits': user_ref.get().get('credits', 0) - 4})
+        return jsonify({"annotations": annotations}), 200
+    except Exception as e:
+        logger.error(f"Theia Mode Error: {e}")
+        return jsonify({'error': str(e)}), 500
 
+@app.route('/api/epiphany/deep-dive', methods=['POST'])
+def deep_dive():
+    uid = verify_token(request.headers.get('Authorization'))
+    if not uid: return jsonify({'error': 'Unauthorized'}), 401
+    image_file = request.files['image']
+    try:
+        pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
+        res = client.models.generate_content(
+            model=ATHENA_FLASH,
+            contents=["Feynman style: Explain this zoomed-in detail in 50 words.", pil_image]
+        )
         user_ref = db_ref.child(f'users/{uid}')
         user_ref.update({'credits': max(0, user_ref.get().get('credits', 0) - 1)})
         return jsonify({"analysis": res.text.strip()}), 200
-    except Exception as e:
-        logger.error(f"Deep Dive Error: {e}")
-        return jsonify({'error': str(e)}), 500
+    except Exception as e: return jsonify({'error': str(e)}), 500
 
 # -----------------------------------------------------------------------------
-# 5. THE CHIRON MENTOR (INTERACTION & MEMORY)
+# 5. CHIRON, ADMIN & AUTH (NO REGRESSION)
 # -----------------------------------------------------------------------------
 
 @app.route('/api/user/call-briefing', methods=['GET'])
 def get_chiron_briefing():
-    logger.info(">>> START get_chiron_briefing request")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
-
     try:
-        last_epiphany = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).limit_to_last(1).get() or {}
-        
-        context_data = ""
-        if last_epiphany:
-            eid = list(last_epiphany.keys())[0]
-            e_data = last_epiphany[eid]
-            papers = e_data.get('grounding', {}).get('papers', [])
-            paper_titles = [p['title'] for p in papers]
-            context_data = f"Current focus: {e_data['subject']}. Recent papers unlocked: {', '.join(paper_titles)}."
-
-        logger.info(f"Generating briefing with context: {context_data}")
-        brief_prompt = f"""
-        Prep Chiron, the Socratic Mentor.
-        User Context: {context_data}
-        Write a 4-sentence brief for Chiron. He must reference the scientific papers or topics the user just explored.
-        """
-        
-        response = client.models.generate_content(model=BRIEFING_MODEL, contents=[brief_prompt])
-        return jsonify({"memory_summary": response.text.strip(), "grounding_context": context_data}), 200
-    except Exception as e:
-        logger.error(f"Call Briefing Error: {e}")
-        return jsonify({'error': str(e)}), 500
+        last = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).limit_to_last(1).get() or {}
+        ctx = "New Seeker."
+        if last:
+            e = list(last.values())[0]
+            ctx = f"Subject: {e['subject']}. Recent Research: {e.get('scholar', [])[:1]}"
+        prompt = f"Prep Chiron (Socratic Mentor). Context: {ctx}. 4-sentence brief."
+        res = client.models.generate_content(model=BRIEFING_MODEL, contents=[prompt])
+        return jsonify({"memory_summary": res.text.strip()}), 200
+    except Exception as e: return jsonify({'error': str(e)}), 500
 
 @app.route('/api/log-call-usage', methods=['POST'])
-def log_call_usage():
-    logger.info(">>> START log_call_usage request")
+def log_usage():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
-
-    data = request.get_json()
-    duration = data.get("durationSeconds", 0)
-    transcript = data.get("transcript", "")
-    
-    cost = math.ceil(duration / 60) * 3
-    logger.info(f"Call ended for {uid}. Duration: {duration}s, Cost: {cost} sparks.")
-    
+    data = request.json
+    cost = math.ceil(data.get("durationSeconds", 0) / 60) * 3
+    user_ref = db_ref.child(f'users/{uid}')
+    new_bal = max(0, user_ref.get().get('credits', 0) - cost)
+    user_ref.update({'credits': new_bal})
+    if data.get("transcript"):
+        db_ref.child(f'transcripts/{uid}').push({"text": data["transcript"], "at": datetime.utcnow().isoformat()})
+    return jsonify({"success": True, "remainingCredits": new_bal}), 200
+
+@app.route('/api/admin/dashboard', methods=['GET'])
+def admin_dashboard():
     try:
-        user_ref = db_ref.child(f'users/{uid}')
-        user_data = user_ref.get()
-        new_bal = max(0, user_data.get('credits', 0) - cost)
-        user_ref.update({'credits': new_bal})
-
-        if transcript:
-            db_ref.child(f'transcripts/{uid}').push({
-                "text": transcript,
-                "createdAt": datetime.utcnow().isoformat()
-            })
-            logger.info("Transcript saved to database.")
-            
-        return jsonify({"success": True, "remainingCredits": new_bal}), 200
-    except Exception as e:
-        logger.error(f"Usage Logging Error: {e}")
-        return jsonify({'error': str(e)}), 500
-
-# -----------------------------------------------------------------------------
-# 6. ADMIN, FEEDBACK & CREDITS
-# -----------------------------------------------------------------------------
+        verify_admin(request.headers.get('Authorization'))
+        return jsonify({
+            "users": len(db_ref.child('users').get() or {}),
+            "epiphanies": len(db_ref.child('epiphanies').get() or {}),
+            "requests": len([r for r in (db_ref.child('credit_requests').get() or {}).values() if r.get('status') == 'pending'])
+        })
+    except Exception as e: return jsonify({'error': str(e)}), 403
 
 @app.route('/api/feedback', methods=['POST'])
-def submit_feedback():
+def feedback():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
-    data = request.get_json()
-    try:
-        fb_ref = db_ref.child('feedback').push()
-        fb_ref.set({
-            "userId": uid,
-            "message": data.get('message'),
-            "type": data.get('type', 'general'),
-            "status": "open",
-            "createdAt": datetime.utcnow().isoformat()
-        })
-        logger.info(f"Feedback received from user {uid}.")
-        return jsonify({"success": True}), 201
-    except Exception as e:
-        logger.error(f"Feedback Submission Error: {e}")
-        return jsonify({'error': str(e)}), 500
+    db_ref.child('feedback').push({"uid": uid, "msg": request.json.get('message'), "at": datetime.utcnow().isoformat()})
+    return jsonify({"success": True})
 
 @app.route('/api/user/request-credits', methods=['POST'])
-def request_credits():
+def request_sparks():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
-    data = request.get_json()
-    try:
-        req_ref = db_ref.child('credit_requests').push()
-        req_ref.set({
-            "userId": uid,
-            "requested_amount": data.get('amount', 50),
-            "status": "pending",
-            "createdAt": datetime.utcnow().isoformat()
-        })
-        logger.info(f"Spark request logged for user {uid}.")
-        return jsonify({"success": True}), 201
-    except Exception as e:
-        logger.error(f"Credit Request Error: {e}")
-        return jsonify({'error': str(e)}), 500
-
-# -----------------------------------------------------------------------------
-# 7. AUTHENTICATION & PROFILE
-# -----------------------------------------------------------------------------
+    db_ref.child('credit_requests').push({"uid": uid, "at": datetime.utcnow().isoformat(), "status": "pending"})
+    return jsonify({"success": True})
 
 @app.route('/api/auth/signup', methods=['POST'])
 def signup():
-    logger.info(">>> START signup sync")
     uid = verify_token(request.headers.get('Authorization'))
-    if not uid:
-        return jsonify({'error': 'Invalid or expired token'}), 401
-
-    try:
-        user_ref = db_ref.child(f'users/{uid}')
-        user_data = user_ref.get()
-
-        if user_data:
-            logger.info(f"User {uid} already exists, skipping initialization.")
-            return jsonify({'uid': uid, **user_data}), 200
-
-        data = request.get_json()
-        new_user_record = {
-            'email': data.get('email'),
-            'displayName': data.get('displayName', 'Seeker'),
-            'credits': 30,
-            'is_admin': False,
-            'createdAt': datetime.utcnow().isoformat()
-        }
-        
-        user_ref.set(new_user_record)
-        logger.info(f"New seeker initialized: {uid} with 30 Sparks.")
-        return jsonify({'success': True, 'uid': uid, **new_user_record}), 201
-
-    except Exception as e:
-        logger.error(f"Signup Sync Error: {e}")
-        return jsonify({'error': str(e)}), 400
+    if not uid: return jsonify({'error': 'Unauthorized'}), 401
+    user_ref = db_ref.child(f'users/{uid}')
+    if not user_ref.get():
+        data = request.json
+        user_ref.set({'email': data.get('email'), 'displayName': data.get('displayName', 'Seeker'), 'credits': 30, 'is_admin': False, 'createdAt': datetime.utcnow().isoformat()})
+    return jsonify({'uid': uid, **user_ref.get()}), 201
 
 @app.route('/api/auth/social-signin', methods=['POST'])
 def social_signin():
     uid = verify_token(request.headers.get('Authorization'))
-    if not uid: return jsonify({'error': 'Invalid token'}), 401
-
+    if not uid: return jsonify({'error': 'Unauthorized'}), 401
     user_ref = db_ref.child(f'users/{uid}')
-    user_data = user_ref.get()
-
-    if not user_data:
-        logger.info(f"Initializing social user: {uid}")
-        firebase_user = auth.get_user(uid)
-        user_data = {
-            'email': firebase_user.email,
-            'displayName': firebase_user.display_name or 'Seeker',
-            'credits': 30,
-            'is_admin': False,
-            'createdAt': datetime.utcnow().isoformat()
-        }
-        user_ref.set(user_data)
-    
-    return jsonify({'uid': uid, **user_data}), 200
+    if not user_ref.get():
+        fu = auth.get_user(uid)
+        user_ref.set({'email': fu.email, 'displayName': fu.display_name or 'Seeker', 'credits': 30, 'is_admin': False, 'createdAt': datetime.utcnow().isoformat()})
+    return jsonify({'uid': uid, **user_ref.get()}), 200
 
 @app.route('/api/user/profile', methods=['GET'])
-def get_profile():
+def profile():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
     return jsonify(db_ref.child(f'users/{uid}').get())
@@ -507,15 +421,13 @@ def get_profile():
 def list_epiphanies():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
-    logger.info(f"Listing epiphanies for user {uid}.")
-    results = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).get() or {}
-    return jsonify(list(results.values()))
+    res = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).get() or {}
+    return jsonify(list(res.values()))
 
 # -----------------------------------------------------------------------------
 # 8. MAIN EXECUTION
 # -----------------------------------------------------------------------------
 
 if __name__ == '__main__':
-    # Standard HF Port 7860
-    logger.info("Starting Sozo Athena Server on port 7860...")
-    app.run(debug=False, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))
+    logger.info("Titaness Final Backbone Active on 7860...")
+    app.run(debug=False, host="0.0.0.0", port=7860)