Claude Code: Create a "System Diagnostics" tab in that parses and displays t

app.py

@@ -138,6 +138,9 @@ async def root():
             "chat": "/api/chat",
             "health": "/api/health",
             "tools": "/api/tools",
+            "logs": "/api/logs",
+            "diagnostics": "/api/diagnostics",
+            "reset": "/api/reset",
             "docs": "/docs"
         },
         "gradio_dashboard": "/gradio",
@@ -396,6 +399,80 @@ async def get_logs(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error getting logs: {str(e)}")
 
+@app.get("/api/diagnostics", tags=["Monitoring"])
+async def get_diagnostics(limit: int = 100):
+    """
+    Get system diagnostics data including session archive logs and health status.
+
+    Returns data from:
+    - session-archive.jsonl (agent state changes)
+    - Health monitor component status
+    """
+    result = {
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+        "session_archive": {},
+        "health_monitor": {}
+    }
+
+    # Read session archive logs
+    session_archive_path = BASE_DIR / "agents" / "logs" / "session-archive.jsonl"
+    if session_archive_path.exists():
+        try:
+            entries = []
+            with open(session_archive_path, 'r') as f:
+                lines = f.readlines()
+
+            # Parse JSONL entries (most recent first)
+            for line in reversed(lines[-limit:]):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    pass
+
+            result["session_archive"] = {
+                "file_path": str(session_archive_path),
+                "total_lines": len(lines),
+                "entries_shown": len(entries),
+                "entries": entries
+            }
+        except Exception as e:
+            result["session_archive"] = {
+                "error": str(e),
+                "file_path": str(session_archive_path)
+            }
+    else:
+        result["session_archive"] = {
+            "error": "File not found",
+            "file_path": str(session_archive_path)
+        }
+
+    # Get health monitor status
+    monitor = get_health_monitor_instance()
+    if monitor:
+        try:
+            health_results = monitor.run_all_health_checks()
+            result["health_monitor"] = {
+                "overall_status": health_results.get("overall_status"),
+                "uptime_seconds": health_results.get("uptime_seconds"),
+                "check_count": health_results.get("check_count"),
+                "components": {
+                    name: {
+                        "status": result["status"].value if isinstance(result["status"], HealthStatus) else result["status"],
+                        "details": result.get("details", {})
+                    }
+                    for name, result in health_results.get("components", {}).items()
+                }
+            }
+        except Exception as e:
+            result["health_monitor"] = {"error": str(e)}
+    else:
+        result["health_monitor"] = {"error": "Health monitor not available"}
+
+    return result
+
 @app.post("/api/reset", tags=["Administration"])
 async def reset_agent():
     """

gradio_dashboard.py

@@ -38,6 +38,8 @@ CRON_LOGS_DIR = BASE_DIR / "logs"
 CRON_JOBS_FILE = BASE_DIR / "cron" / "jobs.json"
 MEMORY_STATE_FILE = Path("/data/memory/state.json")
 WORKSPACE_LOGS = BASE_DIR / "workspace"
+SESSION_ARCHIVE_FILE = BASE_DIR / "agents" / "logs" / "session-archive.jsonl"
+HEALTH_MONITOR_FILE = BASE_DIR / "health_monitor.py"
 
 
 # ========== API Client Functions ==========
@@ -323,6 +325,240 @@ def get_health_logs(level: str = "all", component: str = "all", limit: int = 100
         return [{"error": str(e)}]
 
 
+# ========== Diagnostic Functions ==========
+
+def get_session_archive_logs(limit: int = 100):
+    """Read and parse agent logs from session-archive.jsonl (fallback direct read)"""
+    logs = []
+
+    if not SESSION_ARCHIVE_FILE.exists():
+        return {
+            "error": f"Session archive file not found: {SESSION_ARCHIVE_FILE}",
+            "file_path": str(SESSION_ARCHIVE_FILE),
+            "entries": []
+        }
+
+    try:
+        with open(SESSION_ARCHIVE_FILE, 'r') as f:
+            lines = f.readlines()
+
+        # Parse JSONL entries (most recent first)
+        for line in reversed(lines[-limit:]):
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                entry = json.loads(line)
+                logs.append(entry)
+            except json.JSONDecodeError as e:
+                logs.append({
+                    "error": f"Failed to parse line: {str(e)}",
+                    "raw_line": line[:200]
+                })
+
+        return {
+            "file_path": str(SESSION_ARCHIVE_FILE),
+            "total_lines": len(lines),
+            "entries_shown": len(logs),
+            "entries": logs
+        }
+    except Exception as e:
+        return {
+            "error": f"Failed to read session archive: {str(e)}",
+            "file_path": str(SESSION_ARCHIVE_FILE),
+            "entries": []
+        }
+
+
+def get_health_monitor_status():
+    """Get health monitor status by running health checks (fallback direct read)"""
+    status = {
+        "monitor_file_exists": HEALTH_MONITOR_FILE.exists(),
+        "monitor_file_path": str(HEALTH_MONITOR_FILE),
+        "health_checks": {}
+    }
+
+    if not HEALTH_MONITOR_FILE.exists():
+        status["error"] = "Health monitor file not found"
+        return status
+
+    # Try to get health data from API
+    try:
+        health_data = get_system_health()
+
+        if "error" in health_data:
+            status["api_error"] = health_data["error"]
+        else:
+            status["overall_status"] = health_data.get("status", "unknown")
+            status["stage"] = health_data.get("stage", "UNKNOWN")
+            status["uptime_seconds"] = health_data.get("uptime_seconds", 0)
+            status["agent"] = health_data.get("agent", "cain")
+            status["components"] = health_data.get("components", {})
+
+            # Extract component health details
+            for comp_name, comp_data in status.get("components", {}).items():
+                if isinstance(comp_data, dict) and "status" in comp_data:
+                    status["health_checks"][comp_name] = {
+                        "status": comp_data["status"],
+                        "details": comp_data.get("details", {})
+                    }
+    except Exception as e:
+        status["error"] = f"Failed to get health status: {str(e)}"
+
+    return status
+
+
+def get_diagnostics_from_api(limit: int = 100):
+    """Get diagnostics data from the /api/diagnostics endpoint (preferred method)"""
+    try:
+        params = f"limit={limit}"
+        endpoint = f"/api/diagnostics?{params}"
+        data = fetch_api(endpoint)
+
+        if "error" in data:
+            return None  # Fallback to direct file read
+
+        return data
+    except Exception:
+        return None  # Fallback to direct file read
+
+
+def format_session_logs_for_table(log_data):
+    """Format session archive logs for table display"""
+    rows = []
+
+    entries = log_data.get("entries", [])
+
+    for entry in entries:
+        if "error" in entry:
+            rows.append([
+                "N/A",
+                "error",
+                entry.get("raw_line", "")[:100],
+                "N/A"
+            ])
+            continue
+
+        # Handle different entry types
+        entry_type = entry.get("type", "unknown")
+        timestamp = entry.get("timestamp", "N/A")
+
+        if entry_type == "state_change":
+            agent = entry.get("agent", "unknown")
+            state = entry.get("state", "unknown")
+            message = f"{agent} -> {state}"
+            rows.append([timestamp, entry_type, message, agent])
+        elif entry.get("action") == "archive_sessions":
+            status = entry.get("status", "unknown")
+            archived = entry.get("archived_count", 0)
+            message = f"Archive: {status}, archived: {archived}"
+            rows.append([timestamp, "archive", message, "system"])
+        else:
+            # Generic entry
+            message = json.dumps(entry, indent=2)[:150]
+            rows.append([timestamp, entry_type, message, "various"])
+
+    return rows[:50]  # Limit to 50 rows for display
+
+
+def format_diagnostics_markdown(session_data, health_data):
+    """Format diagnostic data as Markdown"""
+    lines = [
+        "# System Diagnostics Report",
+        f"Generated: {datetime.utcnow().isoformat()}Z",
+        "",
+        "## Session Archive Logs",
+        f"- **File Path:** `{session_data.get('file_path', 'N/A')}`",
+        f"- **Total Lines:** {session_data.get('total_lines', 0)}",
+        f"- **Entries Shown:** {session_data.get('entries_shown', 0)}",
+        ""
+    ]
+
+    if "error" in session_data:
+        lines.append(f"**Error:** {session_data['error']}")
+        lines.append("")
+
+    # Show recent entries
+    entries = session_data.get("entries", [])[:20]
+    if entries:
+        lines.append("### Recent Entries")
+        for i, entry in enumerate(entries, 1):
+            if "error" in entry:
+                lines.append(f"{i}. **Error:** {entry.get('error', 'Unknown error')}")
+            else:
+                entry_type = entry.get("type", "unknown")
+                timestamp = entry.get("timestamp", "N/A")
+                lines.append(f"{i}. **[{entry_type}]** {timestamp}")
+                lines.append(f"   ```json")
+                lines.append(f"   {json.dumps(entry, indent=2)[:200]}...")
+                lines.append(f"   ```")
+    else:
+        lines.append("No recent entries found.")
+
+    lines.extend([
+        "",
+        "## Health Monitor Status",
+        f"- **Monitor File:** `{health_data.get('monitor_file_path', 'N/A')}`",
+        f"- **File Exists:** {health_data.get('monitor_file_exists', False)}",
+        ""
+    ])
+
+    if "overall_status" in health_data:
+        lines.extend([
+            f"- **Overall Status:** {health_data.get('overall_status', 'unknown')}",
+            f"- **Stage:** {health_data.get('stage', 'UNKNOWN')}",
+            f"- **Agent:** {health_data.get('agent', 'cain')}",
+            f"- **Uptime:** {health_data.get('uptime_seconds', 0):.1f}s",
+            ""
+        ])
+
+    if "error" in health_data:
+        lines.append(f"**Error:** {health_data['error']}")
+        lines.append("")
+
+    # Show component health
+    health_checks = health_data.get("health_checks", {})
+    if health_checks:
+        lines.append("### Component Health Checks")
+        for comp_name, comp_data in health_checks.items():
+            status = comp_data.get("status", "unknown")
+            lines.append(f"- **{comp_name}:** {status}")
+            if comp_data.get("details"):
+                details_str = json.dumps(comp_data["details"], indent=2)[:200]
+                lines.append(f"  ```json")
+                lines.append(f"  {details_str}")
+                lines.append(f"  ```")
+    else:
+        lines.append("No component health data available.")
+
+    return "\n".join(lines)
+
+
+def refresh_diagnostics():
+    """Refresh all diagnostic data"""
+    # Try API first, fallback to direct file reads
+    api_data = get_diagnostics_from_api(limit=100)
+
+    if api_data:
+        # Use data from API
+        session_data = api_data.get("session_archive", {})
+        health_data = api_data.get("health_monitor", {})
+    else:
+        # Fallback to direct file reads
+        session_data = get_session_archive_logs(limit=100)
+        health_data = get_health_monitor_status()
+
+    # Format outputs
+    session_json = json.dumps(session_data, indent=2, default=str)
+    health_json = json.dumps(health_data, indent=2, default=str)
+    session_table = format_session_logs_for_table(session_data)
+    diagnostics_md = format_diagnostics_markdown(session_data, health_data)
+    timestamp = f"Last updated: {datetime.utcnow().isoformat()}Z"
+
+    return session_json, health_json, session_table, diagnostics_md, timestamp
+
+
 # ========== Formatting Functions ==========
 
 def format_agent_states(states):
@@ -633,6 +869,57 @@ def create_dashboard():
                     value={}
                 )
 
+            # System Diagnostics Tab (NEW)
+            with gr.Tab("🔍 System Diagnostics"):
+                with gr.Row():
+                    refresh_diagnostics_btn = gr.Button("🔍 Refresh Diagnostics", variant="primary")
+                    diagnostics_last_updated = gr.Markdown("Click refresh to load")
+
+                gr.Markdown("### Session Archive Logs")
+                gr.Markdown("Agent state changes and archived session data from `session-archive.jsonl`")
+
+                with gr.Row():
+                    with gr.Column():
+                        session_logs_table = gr.DataFrame(
+                            label="Recent Session Logs",
+                            headers=["Timestamp", "Type", "Message", "Agent"],
+                            value=[],
+                            interactive=False
+                        )
+                    with gr.Column():
+                        session_logs_json = gr.JSON(
+                            label="Raw Session Logs (JSON)",
+                            value={}
+                        )
+
+                gr.Markdown("---")
+
+                gr.Markdown("### Health Monitor Status")
+                gr.Markdown("Health check status from the health monitoring system")
+
+                with gr.Row():
+                    with gr.Column():
+                        health_status_json = gr.JSON(
+                            label="Health Check Results (JSON)",
+                            value={}
+                        )
+                    with gr.Column():
+                        diagnostics_markdown = gr.Markdown(
+                            value="Click refresh to load diagnostics",
+                            label="Diagnostics Summary"
+                        )
+
+                gr.Markdown("""
+                **Diagnostic Information Sources:**
+                - **Session Archive:** Agent state transitions, session archival events
+                - **Health Monitor:** Component health checks, system status, error tracking
+
+                **Common Error States:**
+                - **unknown error**: Check health monitor logs for component failures
+                - **RUNNING stage with errors**: Agent may be in recovery state
+                - **component unhealthy**: Specific component (brain, rbac, etc.) needs attention
+                """)
+
         # Footer with refresh
         with gr.Row():
             refresh_btn = gr.Button("🔄 Refresh Dashboard", variant="primary")
@@ -650,6 +937,9 @@ def create_dashboard():
             ]
         )
 
+        # Diagnostics refresh handler (this references the button inside the tab)
+        # Note: This is defined after the tabs are created, so the button reference is available
+
         # Manual refresh for main dashboard
         refresh_btn.click(
             fn=refresh_all,
@@ -689,6 +979,19 @@ def create_dashboard():
             outputs=[health_json, logs_table, health_report, last_updated]
         )
 
+        # Diagnostics refresh handler
+        refresh_diagnostics_btn.click(
+            fn=refresh_diagnostics,
+            inputs=[],
+            outputs=[
+                session_logs_json,
+                health_status_json,
+                session_logs_table,
+                diagnostics_markdown,
+                diagnostics_last_updated
+            ]
+        )
+
     return app