htmlgraph 0.25.0__py3-none-any.whl → 0.26.2__py3-none-any.whl

htmlgraph/.htmlgraph/.session-warning-state.json

@@ -0,0 +1,6 @@
+{
+  "dismissed_at": null,
+  "dismissed_by": null,
+  "session_id": null,
+  "show_count": 30
+}

htmlgraph/.htmlgraph/agents.json

@@ -0,0 +1,72 @@
+{
+  "version": "1.0",
+  "updated": "2026-01-11T04:13:54.354401",
+  "agents": {
+    "claude": {
+      "id": "claude",
+      "name": "Claude",
+      "capabilities": [
+        "python",
+        "javascript",
+        "typescript",
+        "html",
+        "css",
+        "code-review",
+        "testing",
+        "documentation",
+        "debugging",
+        "refactoring",
+        "architecture",
+        "api-design"
+      ],
+      "max_parallel_tasks": 3,
+      "preferred_complexity": [
+        "low",
+        "medium",
+        "high",
+        "very-high"
+      ],
+      "active": true,
+      "metadata": {}
+    },
+    "gemini": {
+      "id": "gemini",
+      "name": "Gemini",
+      "capabilities": [
+        "python",
+        "data-analysis",
+        "documentation",
+        "testing",
+        "code-review",
+        "javascript"
+      ],
+      "max_parallel_tasks": 2,
+      "preferred_complexity": [
+        "low",
+        "medium",
+        "high"
+      ],
+      "active": true,
+      "metadata": {}
+    },
+    "codex": {
+      "id": "codex",
+      "name": "Codex",
+      "capabilities": [
+        "python",
+        "javascript",
+        "debugging",
+        "testing",
+        "code-generation",
+        "documentation"
+      ],
+      "max_parallel_tasks": 2,
+      "preferred_complexity": [
+        "low",
+        "medium"
+      ],
+      "active": true,
+      "metadata": {}
+    }
+  }
+}

htmlgraph/__init__.py

@@ -95,7 +95,7 @@ from htmlgraph.types import (
 )
 from htmlgraph.work_type_utils import infer_work_type, infer_work_type_from_id
 
-__version__ = "0.25.0"
+__version__ = "0.26.2"
 __all__ = [
     # Exceptions
     "HtmlGraphError",

htmlgraph/api/main.py

@@ -17,6 +17,7 @@ Architecture:
 import asyncio
 import json
 import logging
+import random
 import sqlite3
 import time
 from datetime import datetime
@@ -88,6 +89,7 @@ class EventModel(BaseModel):
     session_id: str
     parent_event_id: str | None = None
     status: str
+    model: str | None = None
 
 
 class FeatureModel(BaseModel):
@@ -212,9 +214,12 @@ def get_app(db_path: str) -> FastAPI:
     # ========== DATABASE HELPERS ==========
 
     async def get_db() -> aiosqlite.Connection:
-        """Get database connection."""
+        """Get database connection with busy_timeout to prevent lock errors."""
         db = await aiosqlite.connect(app.state.db_path)
         db.row_factory = aiosqlite.Row
+        # Set busy_timeout to 5 seconds - prevents "database is locked" errors
+        # during concurrent access from spawner scripts and WebSocket polling
+        await db.execute("PRAGMA busy_timeout = 5000")
         return db
 
     # ========== ROUTES ==========
@@ -389,7 +394,7 @@ def get_app(db_path: str) -> FastAPI:
                 query = """
                     SELECT e.event_id, e.agent_id, e.event_type, e.timestamp, e.tool_name,
                            e.input_summary, e.output_summary, e.session_id,
-                           e.status
+                           e.parent_event_id, e.status, e.model
                     FROM agent_events e
                     WHERE 1=1
                 """
@@ -423,8 +428,9 @@ def get_app(db_path: str) -> FastAPI:
                         input_summary=row[5],
                         output_summary=row[6],
                         session_id=row[7],
-                        parent_event_id=None,  # Not available in all schema versions
-                        status=row[8],
+                        parent_event_id=row[8],
+                        status=row[9],
+                        model=row[10],
                     )
                     for row in rows
                 ]
@@ -575,7 +581,7 @@ def get_app(db_path: str) -> FastAPI:
             # Query parent events (task delegations)
             parent_query = """
                 SELECT event_id, agent_id, subagent_type, timestamp, status,
-                       child_spike_count, output_summary
+                       child_spike_count, output_summary, model
                 FROM agent_events
                 WHERE event_type = 'task_delegation'
             """
@@ -601,6 +607,7 @@ def get_app(db_path: str) -> FastAPI:
                 status = parent_row[4]
                 child_spike_count = parent_row[5] or 0
                 output_summary = parent_row[6]
+                model = parent_row[7]
 
                 # Parse output summary to get child spike IDs if available
                 child_spikes = []
@@ -663,6 +670,7 @@ def get_app(db_path: str) -> FastAPI:
                     "child_events": child_events,
                     "child_spike_count": child_spike_count,
                     "child_spikes": child_spikes,
+                    "model": model,
                 }
 
                 traces.append(trace)
@@ -759,7 +767,9 @@ def get_app(db_path: str) -> FastAPI:
                     input_summary,
                     output_summary,
                     session_id,
-                    status
+                    status,
+                    model,
+                    parent_event_id
                 FROM agent_events
                 WHERE event_type IN ({event_type_placeholders})
             """
@@ -789,6 +799,8 @@ def get_app(db_path: str) -> FastAPI:
                         "output_summary": row[7],
                         "session_id": row[8],
                         "status": row[9],
+                        "model": row[10],
+                        "parent_event_id": row[11],
                     }
                 )
 
@@ -1007,56 +1019,148 @@ def get_app(db_path: str) -> FastAPI:
                         input_summary,
                         execution_duration_seconds,
                         status,
-                        COALESCE(subagent_type, agent_id) as agent_id
+                        agent_id,
+                        model,
+                        context,
+                        subagent_type
                     FROM agent_events
                     WHERE parent_event_id = ?
                     ORDER BY timestamp ASC
                 """
 
-                children_cursor = await db.execute(children_query, [uq_event_id])
-                children_rows = await children_cursor.fetchall()
+                # Recursive helper to fetch children at any depth
+                async def fetch_children_recursive(
+                    parent_id: str, depth: int = 0, max_depth: int = 4
+                ) -> tuple[list[dict[str, Any]], float, int, int]:
+                    """Recursively fetch children up to max_depth levels."""
+                    if depth >= max_depth:
+                        return [], 0.0, 0, 0
 
-                # Step 3: Build child events with proper formatting
-                children: list[dict[str, Any]] = []
-                total_duration = uq_duration
-                success_count = (
-                    1 if uq_status == "recorded" or uq_status == "success" else 0
-                )
-                error_count = (
-                    0 if uq_status == "recorded" or uq_status == "success" else 1
-                )
+                    cursor = await db.execute(children_query, [parent_id])
+                    rows = await cursor.fetchall()
 
-                for child_row in children_rows:
-                    child_event_id = child_row[0]
-                    child_tool = child_row[1]
-                    child_timestamp = child_row[2]
-                    child_input = child_row[3] or ""
-                    child_duration = child_row[4] or 0.0
-                    child_status = child_row[5]
-                    child_agent = child_row[6] or "unknown"
-
-                    # Build summary: "ToolName: description"
-                    summary = f"{child_tool}: {child_input[:60]}..."
-                    if len(child_input) <= 60:
-                        summary = f"{child_tool}: {child_input}"
-
-                    children.append(
-                        {
-                            "event_id": child_event_id,
-                            "tool_name": child_tool,
-                            "timestamp": child_timestamp,
+                    children_list: list[dict[str, Any]] = []
+                    total_dur = 0.0
+                    success_cnt = 0
+                    error_cnt = 0
+
+                    for row in rows:
+                        evt_id = row[0]
+                        tool = row[1]
+                        timestamp = row[2]
+                        input_text = row[3] or ""
+                        duration = row[4] or 0.0
+                        status = row[5]
+                        agent = row[6] or "unknown"
+                        model = row[7]
+                        context_json = row[8]
+                        subagent_type = row[9]
+
+                        # Parse context to extract spawner metadata
+                        context = {}
+                        spawner_type = None
+                        spawned_agent = None
+                        if context_json:
+                            try:
+                                context = json.loads(context_json)
+                                spawner_type = context.get("spawner_type")
+                                spawned_agent = context.get("spawned_agent")
+                            except (json.JSONDecodeError, TypeError):
+                                pass
+
+                        # If no spawner_type but subagent_type is set, treat it as a spawner delegation
+                        # This handles both HeadlessSpawner (spawner_type in context) and
+                        # Claude Code plugin agents (subagent_type field)
+                        if not spawner_type and subagent_type:
+                            # Extract spawner name from subagent_type (e.g., ".claude-plugin:gemini" -> "gemini")
+                            if ":" in subagent_type:
+                                spawner_type = subagent_type.split(":")[-1]
+                            else:
+                                spawner_type = subagent_type
+                            spawned_agent = (
+                                agent  # Use the agent_id as the spawned agent
+                            )
+
+                        # Build summary (input_text already contains formatted summary)
+                        summary = input_text[:80] + (
+                            "..." if len(input_text) > 80 else ""
+                        )
+
+                        # Recursively fetch this child's children
+                        (
+                            nested_children,
+                            nested_dur,
+                            nested_success,
+                            nested_error,
+                        ) = await fetch_children_recursive(evt_id, depth + 1, max_depth)
+
+                        child_dict: dict[str, Any] = {
+                            "event_id": evt_id,
+                            "tool_name": tool,
+                            "timestamp": timestamp,
                             "summary": summary,
-                            "duration_seconds": round(child_duration, 2),
-                            "agent": child_agent,
+                            "duration_seconds": round(duration, 2),
+                            "agent": agent,
+                            "depth": depth,
+                            "model": model,
                         }
-                    )
 
-                    # Update stats
-                    total_duration += child_duration
-                    if child_status == "recorded" or child_status == "success":
-                        success_count += 1
-                    else:
-                        error_count += 1
+                        # Include spawner metadata if present
+                        if spawner_type:
+                            child_dict["spawner_type"] = spawner_type
+                        if spawned_agent:
+                            child_dict["spawned_agent"] = spawned_agent
+                        if subagent_type:
+                            child_dict["subagent_type"] = subagent_type
+
+                        # Only add children key if there are nested children
+                        if nested_children:
+                            child_dict["children"] = nested_children
+
+                        children_list.append(child_dict)
+
+                        # Update stats (include nested)
+                        total_dur += duration + nested_dur
+                        if status == "recorded" or status == "success":
+                            success_cnt += 1
+                        else:
+                            error_cnt += 1
+                        success_cnt += nested_success
+                        error_cnt += nested_error
+
+                    return children_list, total_dur, success_cnt, error_cnt
+
+                # Step 3: Build child events with recursive nesting
+                (
+                    children,
+                    children_duration,
+                    children_success,
+                    children_error,
+                ) = await fetch_children_recursive(uq_event_id, depth=0, max_depth=4)
+
+                total_duration = uq_duration + children_duration
+                success_count = (
+                    1 if uq_status == "recorded" or uq_status == "success" else 0
+                ) + children_success
+                error_count = (
+                    0 if uq_status == "recorded" or uq_status == "success" else 1
+                ) + children_error
+
+                # Check if any child has spawner metadata
+                def has_spawner_in_children(
+                    children_list: list[dict[str, Any]],
+                ) -> bool:
+                    """Recursively check if any child has spawner metadata."""
+                    for child in children_list:
+                        if child.get("spawner_type") or child.get("spawned_agent"):
+                            return True
+                        if child.get("children") and has_spawner_in_children(
+                            child["children"]
+                        ):
+                            return True
+                    return False
+
+                has_spawner = has_spawner_in_children(children)
 
                 # Step 4: Build conversation turn object
                 conversation_turn = {
@@ -1065,8 +1169,10 @@ def get_app(db_path: str) -> FastAPI:
                         "timestamp": uq_timestamp,
                         "prompt": prompt_text[:200],  # Truncate for display
                         "duration_seconds": round(uq_duration, 2),
+                        "agent_id": uq_row[5],  # Include agent_id from UserQuery
                     },
                     "children": children,
+                    "has_spawner": has_spawner,
                     "stats": {
                         "tool_count": len(children),
                         "total_duration": round(total_duration, 2),
@@ -2034,23 +2140,29 @@ def get_app(db_path: str) -> FastAPI:
         IMPORTANT: Initializes last_timestamp to current time to only stream NEW events.
         Historical events are already counted in /api/initial-stats, so streaming them
         again would cause double-counting in the header stats.
+
+        LIVE EVENTS: Also polls live_events table for real-time spawner activity
+        streaming. These events are marked as broadcast after sending and cleaned up.
         """
         await websocket.accept()
         # Initialize to current time - only stream events created AFTER connection
         # This prevents double-counting: initial-stats already includes historical events
         last_timestamp: str = datetime.now().isoformat()
         poll_interval = 0.5  # OPTIMIZATION: Adaptive polling (reduced from 1s)
+        last_live_event_id = 0  # Track last broadcast live event ID
 
         try:
             while True:
                 db = await get_db()
+                has_activity = False
                 try:
+                    # ===== 1. Poll agent_events (existing logic) =====
                     # OPTIMIZATION: Only select needed columns, use DESC index
                     # Pattern uses index: idx_agent_events_timestamp DESC
                     # Only fetch events AFTER last_timestamp to stream new events only
                     query = """
                         SELECT event_id, agent_id, event_type, timestamp, tool_name,
-                               input_summary, output_summary, session_id, status
+                               input_summary, output_summary, session_id, status, model
                         FROM agent_events
                         WHERE timestamp > ?
                         ORDER BY timestamp ASC
@@ -2061,6 +2173,7 @@ def get_app(db_path: str) -> FastAPI:
                     rows = await cursor.fetchall()
 
                     if rows:
+                        has_activity = True
                         rows_list = [list(row) for row in rows]
                         # Update last timestamp (last row since ORDER BY ts ASC)
                         last_timestamp = rows_list[-1][3]
@@ -2078,14 +2191,106 @@ def get_app(db_path: str) -> FastAPI:
                                 "output_summary": row[6],
                                 "session_id": row[7],
                                 "status": row[8],
+                                "model": row[9],
                                 "parent_event_id": None,
                                 "cost_tokens": 0,
                                 "execution_duration_seconds": 0.0,
                             }
                             await websocket.send_json(event_data)
+
+                    # ===== 2. Poll live_events for spawner streaming =====
+                    # Fetch pending live events that haven't been broadcast yet
+                    live_query = """
+                        SELECT id, event_type, event_data, parent_event_id,
+                               session_id, spawner_type, created_at
+                        FROM live_events
+                        WHERE broadcast_at IS NULL AND id > ?
+                        ORDER BY created_at ASC
+                        LIMIT 50
+                    """
+                    live_cursor = await db.execute(live_query, [last_live_event_id])
+                    live_rows = list(await live_cursor.fetchall())
+
+                    if live_rows:
+                        logger.info(
+                            f"[WebSocket] Found {len(live_rows)} pending live_events to broadcast"
+                        )
+                        has_activity = True
+                        broadcast_ids: list[int] = []
+
+                        for live_row in live_rows:
+                            live_id: int = live_row[0]
+                            event_type: str = live_row[1]
+                            event_data_json: str | None = live_row[2]
+                            parent_event_id: str | None = live_row[3]
+                            session_id: str | None = live_row[4]
+                            spawner_type: str | None = live_row[5]
+                            created_at: str = live_row[6]
+
+                            # Parse event_data JSON
+                            try:
+                                event_data_parsed = (
+                                    json.loads(event_data_json)
+                                    if event_data_json
+                                    else {}
+                                )
+                            except (json.JSONDecodeError, TypeError):
+                                event_data_parsed = {}
+
+                            # Send spawner event to client
+                            spawner_event = {
+                                "type": "spawner_event",
+                                "live_event_id": live_id,
+                                "event_type": event_type,
+                                "spawner_type": spawner_type,
+                                "parent_event_id": parent_event_id,
+                                "session_id": session_id,
+                                "timestamp": created_at,
+                                "data": event_data_parsed,
+                            }
+                            logger.info(
+                                f"[WebSocket] Sending spawner_event: id={live_id}, type={event_type}, spawner={spawner_type}"
+                            )
+                            await websocket.send_json(spawner_event)
+
+                            broadcast_ids.append(live_id)
+                            last_live_event_id = max(last_live_event_id, live_id)
+
+                        # Mark events as broadcast
+                        if broadcast_ids:
+                            logger.info(
+                                f"[WebSocket] Marking {len(broadcast_ids)} events as broadcast: {broadcast_ids}"
+                            )
+                            placeholders = ",".join("?" for _ in broadcast_ids)
+                            await db.execute(
+                                f"""
+                                UPDATE live_events
+                                SET broadcast_at = CURRENT_TIMESTAMP
+                                WHERE id IN ({placeholders})
+                                """,
+                                broadcast_ids,
+                            )
+                            await db.commit()
+
+                    # ===== 3. Periodic cleanup of old broadcast events =====
+                    # Clean up events older than 5 minutes (every ~10 poll cycles)
+                    if random.random() < 0.1:  # 10% chance each cycle
+                        await db.execute(
+                            """
+                            DELETE FROM live_events
+                            WHERE broadcast_at IS NOT NULL
+                              AND created_at < datetime('now', '-5 minutes')
+                            """
+                        )
+                        await db.commit()
+
+                    # Adjust poll interval based on activity
+                    if has_activity:
+                        poll_interval = 0.3  # Speed up when active
                     else:
                         # No new events, increase poll interval (exponential backoff)
                         poll_interval = min(poll_interval * 1.2, 2.0)
+
                 finally:
                     await db.close()
 

htmlgraph/api/templates/dashboard.html

@@ -161,6 +161,7 @@
             ws.onmessage = function(event) {
                 try {
                     const data = JSON.parse(event.data);
+                    console.log('[WebSocket] Received message type:', data.type);
 
                     if (data.type === 'event') {
                         // Prevent duplicate event insertions
@@ -187,6 +188,16 @@
                         // Insert new event into Activity Feed if visible
                         insertNewEventIntoActivityFeed(data);
                     }
+                    // Handle live spawner events for real-time streaming
+                    else if (data.type === 'spawner_event') {
+                        console.log('[WebSocket] spawner_event received:', data.event_type, data.spawner_type, 'handler exists:', typeof window.handleSpawnerEvent === 'function');
+                        // Delegate to activity-feed.html handler if available
+                        if (typeof window.handleSpawnerEvent === 'function') {
+                            window.handleSpawnerEvent(data);
+                        } else {
+                            console.warn('[WebSocket] handleSpawnerEvent not available, spawner event dropped:', data.event_type, data.spawner_type);
+                        }
+                    }
                 } catch (e) {
                     console.error('WebSocket message error:', e);
                 }