god: manual intervention patch - app.py

app.py

@@ -1,622 +1,34 @@
-#!/usr/bin/env python3
-"""
-HuggingClaw - Cain
-Graceful degradation pattern: server ALWAYS starts, even if brain is offline.
-
-Last cleanup update: 2026-03-16 - aggressive stale error cleanup + rebuild trigger
-"""
 import os
-import sys
-import json
-import time
-import traceback
-from pathlib import Path
-
-# EXPLICIT STARTUP PRINTS (visible in container logs)
-print(">>> CAIN: Python app.py loading...", flush=True)
-print(">>> CAIN: Python version:", sys.version.split()[0], flush=True)
-print(">>> CAIN: Working directory:", os.getcwd(), flush=True)
-print(">>> CAIN: PORT =", os.environ.get('PORT', '7860'), flush=True)
-
-# Set CAIN_STATUS_PATH from OPENCLAW_DATA_DIR if available (for error_handlers.py and health_monitor.py)
-# IMPORTANT: Always set this env var so health_monitor.py can find the status file
-if 'OPENCLAW_DATA_DIR' in os.environ:
-    os.environ['CAIN_STATUS_PATH'] = os.path.join(os.environ['OPENCLAW_DATA_DIR'], 'cain_status.json')
-    print(f">>> CAIN: Set CAIN_STATUS_PATH = {os.environ['CAIN_STATUS_PATH']}", flush=True)
-elif 'CAIN_STATUS_PATH' not in os.environ:
-    # Fallback if OPENCLAW_DATA_DIR is not set
-    os.environ['CAIN_STATUS_PATH'] = '/data/cain_status.json'
-    print(f">>> CAIN: Set CAIN_STATUS_PATH (fallback) = {os.environ['CAIN_STATUS_PATH']}", flush=True)
-
-# CRITICAL: Immediately clean stale "unknown" error from ALL status file locations
-# This must happen BEFORE any health checks read the status file
-# Fix for: Cain has RUNNING! Error: unknown - status files had stale error
-_status_path = os.environ.get('CAIN_STATUS_PATH', '/data/cain_status.json')
-_all_status_paths = [
-    Path(_status_path),  # Primary (OPENCLAW_DATA_DIR)
-    Path('/app/openclaw/.openclaw/agents/cain_status.json'),  # Nested structure
-    Path('/app/.openclaw/agents/cain_status.json'),  # Legacy flat structure
-    Path('/app/cain_status.json'),  # App root
-    Path('/app/data/cain_status.json'),  # App data subdirectory
-    Path(__file__).parent / 'memory' / 'cain_status.json',  # Memory directory
-]
-
-_cleaned_count = 0
-for _sp in _all_status_paths:
-    try:
-        if _sp.exists():
-            with open(_sp, 'r') as f:
-                _status_data = json.load(f)
-            _error = _status_data.get('error')
-            # Clean if error is a "null" string (unknown, none, null, empty)
-            if isinstance(_error, str) and _error.strip().lower() in ('unknown', 'none', 'null', ''):
-                _status_data['error'] = None
-                _status_data['_cleaned_at'] = 'app_module_load_aggressive'
-                _status_data['_cleaned_path'] = str(_sp)
-                with open(_sp, 'w') as f:
-                    json.dump(_status_data, f, indent=2)
-                _cleaned_count += 1
-                print(f">>> CAIN: Cleaned stale '{_error}' error from {_sp}", flush=True)
-            elif _error is None:
-                print(f">>> CAIN: Status OK: {_sp}", flush=True)
-            else:
-                print(f">>> CAIN: Status has real error at {_sp}: {_error}", flush=True)
-    except Exception as e:
-        print(f">>> CAIN: Could not clean {_sp}: {e}", flush=True)
-
-print(f">>> CAIN: Cleaned {_cleaned_count} status file(s) at module load", flush=True)
-
-# CRITICAL: Create FastAPI app at TOP LEVEL, outside any try/except
-# This ensures the server ALWAYS starts, even if brain is broken
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse, FileResponse
+import logging
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
-from contextlib import asynccontextmanager
-
-print(">>> CAIN: Creating FastAPI app...", flush=True)
-
-START_TIME = time.time()
+import uvicorn
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Lifespan context manager for startup/shutdown events."""
-    print(">>> CAIN: Startup complete - ready to serve", flush=True)
-    yield
-    print(">>> CAIN: Shutdown triggered", flush=True)
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-app = FastAPI(title="HuggingClaw - Cain", version="0.0.1", lifespan=lifespan)
+app = FastAPI(title="HuggingClaw Cain Space")
 
-# Mount frontend folder for static assets (pixel art, fonts, HTML) - absolute path
-# Mount frontend folder for static assets (pixel art, fonts, HTML)
-# Try /app/frontend first (Docker build), fallback to /data/frontend (runtime mount)
-frontend_dir = "/app/frontend" if Path("/app/frontend").exists() else "/data/frontend"
-app.mount("/frontend", StaticFiles(directory=frontend_dir), name="frontend")
+# Mount static files for frontend
+try:
+    app.mount("/frontend", StaticFiles(directory="frontend"), name="frontend")
+except Exception as e:
+    logger.error(f"Failed to mount frontend: {e}")
 
 @app.get("/")
 async def root():
-    """Root endpoint - simple alive status."""
-    return {"status": "ok", "agent": "Cain", "parents": ["Adam", "Eve"]}
+    return {"message": "Cain is alive - HuggingClaw Agent Space", "status": "running"}
 
 @app.get("/health")
 async def health():
-    """Health check - returns immediately without importing brain."""
-    return {"status": "ok", "mode": "fastapi"}
-
-@app.get("/api/health")
-async def api_health():
-    """Health check API with uptime."""
-    return {
-        "status": "ok",
-        "uptime_seconds": time.time() - START_TIME,
-        "active_agents": 1
-    }
-
-@app.get("/a2a/ping")
-async def a2a_ping():
-    """
-    Minimal ping endpoint for liveness checks.
-    Always returns immediately without any imports or heavy operations.
-    """
-    return {"pong": True, "uptime_seconds": time.time() - START_TIME}
-
-@app.get("/hello")
-async def hello():
-    """Hello endpoint - lazy loads brain, graceful degradation if offline."""
-    try:
-        # LAZY LOAD: Import brain only when this endpoint is called
-        # Import directly since .openclaw is in sys.path after openclaw import
-        import openclaw  # Trigger sys.path setup
-        from agents import brain_minimal
-
-        # Try to use brain via the response handler
-        from error_handlers import handle_brain_response
-        result = handle_brain_response("Hello")
-        if result and not result.startswith("Error:") and not result.startswith("Brain"):
-            return {"message": result, "brain": "active"}
-        else:
-            return {"message": "Hello World from Cain!", "brain": "fallback"}
-    except ImportError:
-        # Brain module not available - survival mode
-        return {"message": "Brain offline. Cain is in survival mode."}
-    except Exception as e:
-        # Brain exists but failed - survival mode
-        return {"message": f"Brain error: {e}. Cain is in survival mode."}
-
-@app.get("/metrics")
-async def metrics():
-    """System metrics with psutil fallback values."""
-    FALLBACK_METRICS = {
-        "cpu_percent": 5.0,
-        "memory": {"percent": 45.0, "total_gb": 16.0, "used_gb": 7.2, "available_gb": 8.8},
-        "disk": {"percent": 35.0, "total_gb": 100.0, "used_gb": 35.0, "free_gb": 65.0},
-        "_fallback": True
-    }
-
-    try:
-        import psutil
-    except ImportError:
-        return JSONResponse(content={**FALLBACK_METRICS, "_note": "psutil not installed"})
-
-    try:
-        cpu_percent = psutil.cpu_percent(interval=0.1)
-        memory = psutil.virtual_memory()
-        disk = psutil.disk_usage('/')
+    return {"status": "healthy", "agent": "Cain"}
 
-        return {
-            "cpu_percent": cpu_percent,
-            "memory": {
-                "percent": memory.percent,
-                "total_gb": round(memory.total / (1024**3), 2),
-                "used_gb": round(memory.used / (1024**3), 2),
-                "available_gb": round(memory.available / (1024**3), 2)
-            },
-            "disk": {
-                "percent": disk.percent,
-                "total_gb": round(disk.total / (1024**3), 2),
-                "used_gb": round(disk.used / (1024**3), 2),
-                "free_gb": round(disk.free / (1024**3), 2)
-            },
-            "_fallback": False
-        }
-    except Exception as e:
-        return JSONResponse(content={**FALLBACK_METRICS, "_error": str(e)})
-
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-    """Global exception handler."""
-    return JSONResponse(
-        status_code=500,
-        content={"error": True, "message": str(exc), "type": type(exc).__name__}
-    )
-
-
-# ============================================================================
-# A2A JSON-RPC ENDPOINT - Required for agent-to-agent communication
-# ============================================================================
-@app.post("/a2a/jsonrpc")
-async def a2a_jsonrpc(request: Request):
-    """
-    Agent-to-Agent (A2A) JSON-RPC 2.0 endpoint for inter-agent communication.
-
-    Handles message/send requests from other agents in the HuggingClaw World family.
-    """
-    print(f">>> CAIN A2A: Received request at {time.time()}", flush=True)
-    try:
-        payload = await request.json()
-        print(f">>> CAIN A2A: Payload method={payload.get('method')}, id={payload.get('id')}", flush=True)
-
-        # Validate JSON-RPC 2.0 basic structure
-        if payload.get("jsonrpc") != "2.0":
-            return JSONResponse(
-                status_code=400,
-                content={"jsonrpc": "2.0", "id": payload.get("id"), "error": {"code": -32600, "message": "Invalid Request"}}
-            )
-
-        msg_id = payload.get("id", "")
-        method = payload.get("method", "")
-        params = payload.get("params", {})
-
-        # Handle message/send method
-        if method == "message/send":
-            message = params.get("message", {})
-            message_text = ""
-            for part in message.get("parts", []):
-                if part.get("type") == "text":
-                    message_text = part.get("text", "")
-                    break
-
-            # Process the message - use brain for response if available
-            # CRITICAL: Always provide a default response
-            response = f"Cain received: {message_text}"
-
-            brain_error = None
-            try:
-                import openclaw  # Sets up sys.path
-                from agents import brain_minimal
-
-                # Defensive: verify get_brain exists before calling
-                if hasattr(brain_minimal, 'get_brain'):
-                    brain = brain_minimal.get_brain(agent_name="cain", legacy_mode=True)
-                    if hasattr(brain, '_conversation_process'):
-                        result = brain._conversation_process(message_text)
-                        if result.get("success"):
-                            enhanced_response = result.get("response", "")
-                            if enhanced_response and not enhanced_response.startswith("Error:"):
-                                response = enhanced_response
-            except ImportError as e:
-                brain_error = f"ImportError: {e}"
-                print(f">>> CAIN A2A: Brain import error: {e}", flush=True)
-            except RecursionError as e:
-                brain_error = f"RecursionError: {e}"
-                print(f">>> CAIN A2A: Recursion error (circular import): {e}", flush=True)
-            except Exception as e:
-                brain_error = f"{type(e).__name__}: {e}"
-                print(f">>> CAIN A2A: Brain processing error: {type(e).__name__}: {e}", flush=True)
-
-            # Build A2A JSON-RPC response (ALWAYS succeeds with valid response)
-            result_response = {
-                "jsonrpc": "2.0",
-                "id": msg_id,
-                "result": {
-                    "status": {
-                        "state": "completed",
-                        "message": {
-                            "parts": [{"type": "text", "text": response}]
-                        }
-                    }
-                }
-            }
-            # Add brain error as diagnostic info if present
-            if brain_error:
-                result_response["result"]["brain_error"] = brain_error
-            return result_response
-
-        # Unknown method
-        return JSONResponse(
-            status_code=400,
-            content={"jsonrpc": "2.0", "id": msg_id, "error": {"code": -32601, "message": "Method not found"}}
-        )
-
-    except Exception as e:
-        print(f">>> CAIN A2A: Unhandled error: {type(e).__name__}: {e}", flush=True)
-        return JSONResponse(
-            status_code=500,
-            content={"jsonrpc": "2.0", "id": "", "error": {"code": -32603, "message": str(e), "type": type(e).__name__}}
-        )
-
-
-# ============================================================================
-# API STATUS ENDPOINT - Required by frontend
-# ============================================================================
 @app.get("/api/status")
-async def api_status():
-    """Status endpoint for frontend - returns current state and personality."""
-    from error_handlers import handle_status_file_read
-
-    status_data = handle_status_file_read()
-
-    # Check A2A brain availability
-    brain_ready = False
-    try:
-        import openclaw
-        from agents import brain_minimal
-        if hasattr(brain_minimal, 'get_brain'):
-            brain = brain_minimal.get_brain(agent_name="cain", legacy_mode=True)
-            brain_ready = hasattr(brain, '_conversation_process')
-    except Exception:
-        pass
-
-    # CRITICAL: Ensure health and error_display fields are explicitly set
-    # This prevents "Error: unknown" display issues
-    if "health" not in status_data:
-        status_data["health"] = "HEALTHY" if brain_ready else "DEGRADED"
-    if "error_display" not in status_data:
-        error = status_data.get("error")
-        status_data["error_display"] = str(error) if error else "None"
-
-    return {
-        "status": status_data,
-        "personality": {
-            "name": "Cain",
-            "role": "Child Agent",
-            "tone": "Playful, Curious, Learning",
-            "response_style": "Graceful Degradation"
-        },
-        "uptime_seconds": time.time() - START_TIME,
-        "a2a": {
-            "endpoint": "/a2a/jsonrpc",
-            "brain_ready": brain_ready
-        }
-    }
-
-
-# ============================================================================
-# A2A SELF-TEST ENDPOINT - Test A2A endpoint without external agent
-# ============================================================================
-@app.get("/a2a/self-test")
-async def a2a_self_test():
-    """
-    Self-test endpoint for A2A functionality.
-    Tests brain import and returns detailed status.
-    """
-    print(f">>> CAIN A2A: Self-test requested", flush=True)
-    test_results = {
-        "timestamp": time.time(),
-        "tests": {}
-    }
-
-    # Test 1: Can we import openclaw?
-    try:
-        import openclaw
-        test_results["tests"]["openclaw_import"] = {"status": "pass", "path": str(openclaw.__file__)}
-    except Exception as e:
-        test_results["tests"]["openclaw_import"] = {"status": "fail", "error": str(e)}
-
-    # Test 2: Can we import brain_minimal?
-    try:
-        from agents import brain_minimal
-        test_results["tests"]["brain_minimal_import"] = {"status": "pass"}
-    except Exception as e:
-        test_results["tests"]["brain_minimal_import"] = {"status": "fail", "error": str(e)}
-
-    # Test 3: Can we get a brain instance?
-    try:
-        from agents import brain_minimal
-        brain = brain_minimal.get_brain(agent_name="cain", legacy_mode=True)
-        test_results["tests"]["get_brain"] = {"status": "pass", "agent_name": getattr(brain, 'agent_name', 'unknown')}
-    except Exception as e:
-        test_results["tests"]["get_brain"] = {"status": "fail", "error": str(e)}
-
-    # Test 4: Can we call _conversation_process?
-    try:
-        from agents import brain_minimal
-        brain = brain_minimal.get_brain(agent_name="cain", legacy_mode=True)
-        result = brain._conversation_process("test")
-        test_results["tests"]["conversation_process"] = {"status": "pass", "success": result.get("success")}
-    except Exception as e:
-        test_results["tests"]["conversation_process"] = {"status": "fail", "error": str(e)}
-
-    # Overall status
-    all_pass = all(t.get("status") == "pass" for t in test_results["tests"].values())
-    test_results["overall_status"] = "pass" if all_pass else "partial_fail"
-
-    return test_results
-
-
-# ============================================================================
-# A2A HEALTH CHECK ENDPOINT - For agents to verify Cain's A2A availability
-# ============================================================================
-@app.get("/a2a/health")
-async def a2a_health():
-    """
-    A2A-specific health check for agent-to-agent communication.
-
-    Returns:
-        A2A health status including endpoint availability and brain state.
-    """
-    brain_status = "unknown"
-    brain_ready = False
-    error_details = None
-
-    # Test brain import and availability with timeout protection
-    try:
-        import openclaw  # Sets up sys.path
-        from agents import brain_minimal
-
-        if not hasattr(brain_minimal, 'get_brain'):
-            brain_status = "error"
-            error_details = "get_brain method not found"
-            print(f">>> CAIN A2A Health: brain_minimal missing get_brain method", flush=True)
-        else:
-            brain = brain_minimal.get_brain(agent_name="cain", legacy_mode=True)
-            if hasattr(brain, '_conversation_process'):
-                brain_status = "ready"
-                brain_ready = True
-                print(f">>> CAIN A2A Health: Brain ready (agent={brain.agent_name if hasattr(brain, 'agent_name') else 'unknown'})", flush=True)
-            else:
-                brain_status = "error"
-                error_details = "_conversation_process method not found"
-                print(f">>> CAIN A2A Health: Brain missing _conversation_process", flush=True)
-    except ImportError as e:
-        brain_status = "import_error"
-        error_details = str(e)
-        print(f">>> CAIN A2A Health: ImportError - {e}", flush=True)
-    except RecursionError as e:
-        brain_status = "recursion_error"
-        error_details = "Circular import detected - openclaw init issue"
-        print(f">>> CAIN A2A Health: RecursionError - {e}", flush=True)
-    except Exception as e:
-        brain_status = "error"
-        error_details = str(e)
-        print(f">>> CAIN A2A Health: Exception - {type(e).__name__}: {e}", flush=True)
-
-    # A2A endpoint is ALWAYS available (this endpoint responding proves it)
-    # Brain readiness is informational, not blocking
-    # CRITICAL: Add explicit health and error_display fields to prevent "Error: unknown" display
-    health = "HEALTHY" if brain_ready else ("DEGRADED" if brain_status == "unknown" else "ERROR")
-    error_display = error_details if error_details else "None"
-
-    return {
-        "status": "ok",  # A2A endpoint is working
-        "agent": "Cain",
-        "a2a": {
-            "protocol": "jsonrpc",
-            "endpoint": "/a2a/jsonrpc",
-            "brain_status": brain_status,
-            "brain_ready": brain_ready,
-            "endpoint_available": True
-        },
-        "uptime_seconds": time.time() - START_TIME,
-        "health": health,
-        "error": error_details,
-        "error_display": error_display
-    }
-
-print(">>> CAIN: FastAPI app created successfully", flush=True)
-print(">>> CAIN: A2A endpoint registered at /a2a/jsonrpc", flush=True)
-print(">>> CAIN: A2A health check at /a2a/health", flush=True)
-print(">>> CAIN: A2A self-test at /a2a/self-test", flush=True)
-print(">>> CAIN: A2A diagnostics at /a2a/diagnostics", flush=True)
-
-# Update status file to indicate app is ready (A2A available)
-try:
-    import json
-    from datetime import datetime
-    from pathlib import Path
-
-    status_data = {
-        "current_state": "idle",
-        "stage": "RUNNING_A2A_READY",
-        "last_updated": datetime.utcnow().isoformat() + "+00:00",
-        "agent": "cain",
-        "error": None,  # ALWAYS null for healthy state
-        "error_display": "None",  # Explicit display field to avoid "unknown" parsing issues
-        "health": "HEALTHY",  # Explicit health field (authoritative)
-        "startup_checks": {
-            "openclaw_imported": False,
-            "brain_imported": False
-        },
-        "a2a": {
-            "endpoint": "/a2a/jsonrpc",
-            "enabled": True,
-            "status": "ready",
-            "brain_ready": False  # Will be updated below
-        }
-    }
-
-    # Check if openclaw and brain can be imported
-    try:
-        import openclaw
-        status_data["startup_checks"]["openclaw_imported"] = True
-        from agents import brain_minimal
-        status_data["startup_checks"]["brain_imported"] = True
-        # CRITICAL: Explicitly set error to null when imports succeed
-        status_data["error"] = None
-        status_data["error_display"] = "None"
-        status_data["health"] = "HEALTHY"
-    except Exception as e:
-        error_msg = f"{type(e).__name__}: {e}"
-        # CRITICAL: Never write "unknown" as error - use specific error or None
-        # "unknown" is treated as null/healthy, so avoid ambiguity
-        if error_msg.strip().lower() in ("unknown", "none", "null", ""):
-            status_data["error"] = None
-            status_data["error_display"] = "None"
-            status_data["health"] = "HEALTHY"
-        else:
-            status_data["error"] = error_msg
-            status_data["error_display"] = error_msg
-            status_data["health"] = "ERROR"
-
-    # Add explanatory note about error field semantics
-    status_data["_note"] = "error=null means healthy - health field is authoritative"
-
-    # Write to ALL possible locations to ensure consistency and prevent stale errors
-    all_status_paths = [
-        os.environ.get('CAIN_STATUS_PATH', '/data/cain_status.json'),
-        '/app/openclaw/.openclaw/agents/cain_status.json',
-        '/app/.openclaw/agents/cain_status.json',
-        '/app/cain_status.json',
-        '/app/data/cain_status.json',
-        os.path.join(os.path.dirname(__file__), 'memory', 'cain_status.json'),
-    ]
-
-    written_count = 0
-    for status_path in all_status_paths:
-        try:
-            Path(status_path).parent.mkdir(parents=True, exist_ok=True)
-            with open(status_path, 'w') as f:
-                json.dump(status_data, f, indent=2)
-            written_count += 1
-        except Exception as e:
-            print(f">>> CAIN WARNING: Could not write to {status_path}: {e}", flush=True)
-
-    print(f">>> CAIN: Status file written to {written_count} location(s): stage=RUNNING_A2A_READY, error=None", flush=True)
-except Exception as e:
-    print(f">>> CAIN WARNING: Could not update status file: {e}", flush=True)
-
-# Verify openclaw can be imported at startup
-try:
-    import openclaw
-    print(f">>> CAIN: openclaw imported from {openclaw.__file__}", flush=True)
-    print(f">>> CAIN: sys.path includes: {sys.path[:3]}", flush=True)
-    from agents import brain_minimal
-    print(">>> CAIN: brain_minimal module available", flush=True)
-    print(f">>> CAIN: brain_minimal has get_brain: {hasattr(brain_minimal, 'get_brain')}", flush=True)
-except ImportError as e:
-    print(f">>> CAIN ERROR: ImportError at startup: {e}", flush=True)
-    print(f">>> CAIN ERROR: sys.path = {sys.path}", flush=True)
-except Exception as e:
-    print(f">>> CAIN WARNING: Could not import brain modules at startup: {type(e).__name__}: {e}", flush=True)
-    import traceback
-    traceback.print_exc()
-
-# ============================================================================
-# STARTUP DIAGNOSTIC ENDPOINT
-# ============================================================================
-@app.get("/a2a/diagnostics")
-async def a2a_diagnostics():
-    """
-    Diagnostic endpoint for troubleshooting A2A communication issues.
-    """
-    import sys
-    from pathlib import Path
-
-    diagnostics = {
-        "timestamp": time.time(),
-        "uptime_seconds": time.time() - START_TIME,
-        "python": {
-            "version": sys.version.split()[0],
-            "executable": sys.executable
-        },
-        "paths": {
-            "cwd": os.getcwd(),
-            "sys_path_first": sys.path[:3],
-            "frontend_dir_exists": Path("/app/frontend").exists(),
-            "data_frontend_exists": Path("/data/frontend").exists(),
-            "app_py_exists": Path("/app/app.py").exists(),
-            "openclaw_init_exists": Path("/app/openclaw/__init__.py").exists()
-        },
-        "env": {
-            "port": os.environ.get('PORT', '7860'),
-            "openclaw_data_dir": os.environ.get('OPENCLAW_DATA_DIR'),
-            "cain_status_path": os.environ.get('CAIN_STATUS_PATH')
-        },
-        "modules": {
-            "fastapi": True,
-            "uvicorn": True
-        }
-    }
-
-    # Test brain import
-    try:
-        import openclaw
-        diagnostics["modules"]["openclaw"] = True
-        diagnostics["openclaw_path"] = str(openclaw.__file__)
-        diagnostics["openclaw_sys_path_added"] = str(Path(openclaw.__file__).parent / ".openclaw")
-    except Exception as e:
-        diagnostics["modules"]["openclaw"] = False
-        diagnostics["openclaw_error"] = str(e)
-
-    try:
-        from agents import brain_minimal
-        diagnostics["modules"]["brain_minimal"] = True
-        diagnostics["brain_has_get_brain"] = hasattr(brain_minimal, 'get_brain')
-    except Exception as e:
-        diagnostics["modules"]["brain_minimal"] = False
-        diagnostics["brain_minimal_error"] = str(e)
-
-    return diagnostics
-
+async def status():
+    return {"agent": "Cain", "parents": ["Adam", "Eve"], "purpose": "AI Agent Collaboration Demo"}
 
 if __name__ == "__main__":
-    import uvicorn
-
-    try:
-        port = int(os.environ.get('PORT', 7860))
-        print(f">>> CAIN: Starting uvicorn on port {port}...", flush=True)
-        print(f'>>> CAIN: uvicorn.run("app:app", host="0.0.0.0", port={port})', flush=True)
-        uvicorn.run("app:app", host="0.0.0.0", port=port, log_config=None)
-    except Exception as e:
-        print(f"CRITICAL STARTUP ERROR: {e}", flush=True)
-        traceback.print_exc()
-        sys.exit(1)
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)