Claude Code: Investigate the file to identify the cause of the "unknown" run

.openclaw/agents/brain_minimal.py

@@ -666,10 +666,12 @@ class BrainMinimal:
         return {
             "success": True,
             "status": "healthy",
+            "stage": "RUNNING",
             "state": self.brain_state.value,
             "agent": self.agent_name,
             "role": self.current_role.value if self.current_role else "unknown",
-            "tools_count": len(self.get_allowed_tools())
+            "tools_count": len(self.get_allowed_tools()),
+            "error": None
         }
 
     def _get_status(self) -> Dict[str, Any]:

.openclaw/agents/cain_status.json

@@ -1,5 +1,5 @@
 {
   "current_state": "idle",
-  "last_updated": "2026-03-14T19:10:02.929644+00:00",
+  "last_updated": "2026-03-14T19:17:42.455943+00:00",
   "agent": "cain"
 }

.openclaw/agents/logs/session-archive.jsonl

@@ -19,3 +19,6 @@
 {"type": "state_change", "state": "processing", "timestamp": "2026-03-14T19:10:02.927551+00:00", "agent": "cain"}
 {"type": "state_change", "state": "success", "timestamp": "2026-03-14T19:10:02.928572+00:00", "agent": "cain"}
 {"type": "state_change", "state": "idle", "timestamp": "2026-03-14T19:10:02.929525+00:00", "agent": "cain"}
+{"type": "state_change", "state": "processing", "timestamp": "2026-03-14T19:17:35.121684+00:00", "agent": "cain"}
+{"type": "state_change", "state": "success", "timestamp": "2026-03-14T19:17:35.122941+00:00", "agent": "cain"}
+{"type": "state_change", "state": "idle", "timestamp": "2026-03-14T19:17:35.124108+00:00", "agent": "cain"}

app.py

@@ -9,6 +9,8 @@ import os
 import sys
 import json
 import asyncio
+import traceback
+import logging
 from typing import Dict, Any, List, Optional
 from datetime import datetime
 from pathlib import Path
@@ -18,6 +20,21 @@ from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field
 import uvicorn
 
+# Configure logging
+LOG_DIR = Path.home() / ".openclaw" / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = LOG_DIR / "api_errors.log"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(LOG_FILE),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger("cain_api")
+
 # Paths
 WORKSPACE_DIR = Path("/tmp/claude-workspace")
 OPENCLAW_HOME = Path.home() / ".openclaw"
@@ -36,16 +53,20 @@ sys.path.insert(0, str(BASE_DIR))
 try:
     from brain_minimal import get_brain, BrainState
     BRAIN_AVAILABLE = True
-except ImportError:
+    logger.info("brain_minimal module loaded successfully")
+except ImportError as e:
     BRAIN_AVAILABLE = False
-    print("[API] Warning: brain_minimal not available")
+    logger.error(f"Failed to import brain_minimal: {e}\n{traceback.format_exc()}")
+    print(f"[API] Warning: brain_minimal not available - {e}")
 
 try:
     from health_monitor import get_health_monitor, LogLevel, HealthStatus
     HEALTH_MONITOR_AVAILABLE = True
-except ImportError:
+    logger.info("health_monitor module loaded successfully")
+except ImportError as e:
     HEALTH_MONITOR_AVAILABLE = False
-    print("[API] Warning: health_monitor not available")
+    logger.error(f"Failed to import health_monitor: {e}\n{traceback.format_exc()}")
+    print(f"[API] Warning: health_monitor not available - {e}")
 
 # FastAPI app
 app = FastAPI(
@@ -54,6 +75,41 @@ app = FastAPI(
     version="1.0.0"
 )
 
+
+# ========== Global Exception Handler ==========
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request, exc):
+    """
+    Global exception handler that logs full stack traces for all errors.
+    This ensures no error is silently swallowed as "unknown".
+    """
+    # Get full traceback
+    tb_str = traceback.format_exc()
+    error_type = type(exc).__name__
+    error_msg = str(exc)
+
+    # Log the full error with traceback
+    logger.error(
+        f"Unhandled exception: {error_type}: {error_msg}\n"
+        f"Path: {request.url.path}\n"
+        f"Method: {request.method}\n"
+        f"Traceback:\n{tb_str}"
+    )
+
+    # Return detailed error response
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": error_msg,
+            "error_type": error_type,
+            "traceback": tb_str,
+            "path": str(request.url.path),
+            "method": request.method,
+            "timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+    )
+
 # ========== Request/Response Models ==========
 
 class ChatMessage(BaseModel):
@@ -101,6 +157,36 @@ class HealthResponse(BaseModel):
 _brain_instance = None
 _start_time = datetime.utcnow()
 
+# ========== Startup Event ==========
+
+@app.on_event("startup")
+async def startup_event():
+    """Log startup information and verify components"""
+    logger.info("=" * 50)
+    logger.info("Cain API Starting")
+    logger.info(f"Start time: {_start_time.isoformat()}")
+    logger.info(f"Brain available: {BRAIN_AVAILABLE}")
+    logger.info(f"Health monitor available: {HEALTH_MONITOR_AVAILABLE}")
+    logger.info(f"Working directory: {os.getcwd()}")
+    logger.info(f"Python version: {sys.version}")
+    logger.info(f"API log file: {LOG_FILE}")
+    logger.info("=" * 50)
+
+    # Test brain initialization
+    if BRAIN_AVAILABLE:
+        try:
+            brain = get_brain_instance()
+            if brain:
+                logger.info(f"Brain initialized: agent={brain.agent_name}, role={brain.current_role}")
+                health = brain.execute_tool("health_check")
+                logger.info(f"Initial health check: {health}")
+            else:
+                logger.warning("Brain instance is None after initialization")
+        except Exception as e:
+            logger.error(f"Brain initialization test failed: {e}\n{traceback.format_exc()}")
+    else:
+        logger.warning("BRAIN_AVAILABLE=False - brain features will be limited")
+
 def get_brain_instance():
     """Get or create brain instance"""
     global _brain_instance
@@ -158,7 +244,12 @@ async def get_agents_status():
     brain = get_brain_instance()
 
     if brain is None:
-        raise HTTPException(status_code=503, detail="Brain not available")
+        logger.error("Brain not available for /api/agents")
+        raise HTTPException(
+            status_code=503,
+            detail="Brain not available",
+            headers={"X-Error-Timestamp": datetime.utcnow().isoformat() + "Z"}
+        )
 
     try:
         info = brain.get_info()
@@ -178,7 +269,12 @@ async def get_agents_status():
             timestamp=datetime.utcnow().isoformat() + "Z"
         )
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error getting agent status: {str(e)}")
+        logger.error(f"Error getting agent status: {e}\n{traceback.format_exc()}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error getting agent status: {str(e)}",
+            headers={"X-Error-Type": type(e).__name__}
+        )
 
 @app.post("/api/chat", response_model=ChatResponse, tags=["Chat"])
 async def chat(message: ChatMessage, background_tasks: BackgroundTasks):
@@ -240,9 +336,10 @@ async def get_health():
             health_result = brain.execute_tool("health_check")
             components["brain"] = health_result
         except Exception as e:
-            components["brain"] = {"status": "error", "error": str(e)}
+            logger.error(f"Brain health check failed: {e}\n{traceback.format_exc()}")
+            components["brain"] = {"status": "error", "error": str(e), "traceback": traceback.format_exc()}
     else:
-        components["brain"] = {"status": "unavailable"}
+        components["brain"] = {"status": "unavailable", "error": "Brain not initialized"}
 
     # Health monitor components
     if monitor:
@@ -260,18 +357,34 @@ async def get_health():
                 }
             }
         except Exception as e:
-            components["health_monitor"] = {"status": "error", "error": str(e)}
+            logger.error(f"Health monitor check failed: {e}\n{traceback.format_exc()}")
+            components["health_monitor"] = {"status": "error", "error": str(e), "traceback": traceback.format_exc()}
+    else:
+        components["health_monitor"] = {"status": "unavailable", "error": "Health monitor not initialized"}
 
     # Determine overall status
     if brain:
-        brain_health = brain.execute_tool("health_check")
-        overall_status = brain_health.get("status", "unknown")
-        stage = brain_health.get("stage", "UNKNOWN")
-        agent = brain_health.get("agent", "cain")
+        try:
+            brain_health = brain.execute_tool("health_check")
+            overall_status = brain_health.get("status", "unknown")
+            stage = brain_health.get("stage", "UNKNOWN")
+            agent = brain_health.get("agent", "cain")
+            error = brain_health.get("error", None)
+
+            # Log if there's an error but status is healthy
+            if error:
+                logger.warning(f"Health check returned with error: {error}")
+        except Exception as e:
+            logger.error(f"Failed to get brain health: {e}\n{traceback.format_exc()}")
+            overall_status = "error"
+            stage = "ERROR"
+            agent = "cain"
+            error = str(e)
     else:
         overall_status = "degraded"
         stage = "BRAIN_UNAVAILABLE"
         agent = "cain"
+        error = "Brain not initialized"
 
     return HealthResponse(
         status=overall_status,
@@ -517,10 +630,13 @@ try:
     app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
 
     print("[API] Gradio dashboard mounted at /gradio")
-except ImportError:
-    print("[API] Warning: Gradio not available, dashboard not mounted")
+    logger.info("Gradio dashboard mounted successfully at /gradio")
+except ImportError as e:
+    print(f"[API] Warning: Gradio not available, dashboard not mounted - {e}")
+    logger.error(f"Failed to import gradio: {e}\n{traceback.format_exc()}")
 except Exception as e:
     print(f"[API] Warning: Could not mount Gradio dashboard: {e}")
+    logger.error(f"Failed to mount Gradio dashboard: {e}\n{traceback.format_exc()}")
 
 # ========== Main Entry Point ==========