htmlgraph 0.24.2__py3-none-any.whl → 0.26.1__py3-none-any.whl

htmlgraph/hooks/event_tracker.py

@@ -2,11 +2,20 @@
 HtmlGraph Event Tracker Module
 
 Reusable event tracking logic for hook integrations.
-Provides session management, drift detection, and activity logging.
+Provides session management, drift detection, activity logging, and SQLite persistence.
 
 Public API:
-    track_event(hook_type: str, tool_input: dict) -> dict
+    track_event(hook_type: str, tool_input: dict[str, Any]) -> dict
         Main entry point for tracking hook events (PostToolUse, Stop, UserPromptSubmit)
+
+Events are recorded to both:
+    - HTML files via SessionManager (existing)
+    - SQLite database via HtmlGraphDB (new - for dashboard queries)
+
+Parent-child event linking:
+    - Database is the single source of truth for parent-child linking
+    - UserQuery events are stored in agent_events table with tool_name='UserQuery'
+    - get_parent_user_query() queries database for most recent UserQuery in session
 """
 
 import json
@@ -14,19 +23,60 @@ import os
 import re
 import subprocess
 import sys
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, cast  # noqa: F401
 
+from htmlgraph.db.schema import HtmlGraphDB
+from htmlgraph.ids import generate_id
 from htmlgraph.session_manager import SessionManager
 
 # Drift classification queue (stored in session directory)
 DRIFT_QUEUE_FILE = "drift-queue.json"
-# Active parent activity tracker (for Skill/Task invocations)
-PARENT_ACTIVITY_FILE = "parent-activity.json"
 
 
-def load_drift_config() -> dict:
+def get_model_from_status_cache(session_id: str | None = None) -> str | None:
+    """
+    Read current model from SQLite model_cache table.
+
+    The status line script writes model info to the model_cache table.
+    This allows hooks to know which Claude model is currently running,
+    even though hooks don't receive model info directly from Claude Code.
+
+    Args:
+        session_id: Unused, kept for backward compatibility.
+
+    Returns:
+        Model display name (e.g., "Opus 4.5", "Sonnet", "Haiku") or None if not found.
+    """
+    import sqlite3
+
+    try:
+        # Try project database first
+        db_path = Path.cwd() / ".htmlgraph" / "htmlgraph.db"
+        if not db_path.exists():
+            return None
+
+        conn = sqlite3.connect(str(db_path), timeout=1.0)
+        cursor = conn.cursor()
+
+        # Check if model_cache table exists and has data
+        cursor.execute("SELECT model FROM model_cache WHERE id = 1 LIMIT 1")
+        row = cursor.fetchone()
+        conn.close()
+
+        if row and row[0] and row[0] != "Claude":
+            return str(row[0])
+        return str(row[0]) if row else None
+
+    except Exception:
+        # Table doesn't exist or read error - silently fail
+        pass
+
+    return None
+
+
+def load_drift_config() -> dict[str, Any]:
     """Load drift configuration from plugin config or project .claude directory."""
     config_paths = [
         Path(__file__).parent.parent.parent.parent.parent
@@ -67,48 +117,46 @@ def load_drift_config() -> dict:
     }
 
 
-def load_parent_activity(graph_dir: Path) -> dict:
-    """Load the active parent activity state."""
-    path = graph_dir / PARENT_ACTIVITY_FILE
-    if path.exists():
-        try:
-            with open(path) as f:
-                data = cast(dict[Any, Any], json.load(f))
-                # Clean up stale parent activities (older than 5 minutes)
-                if data.get("timestamp"):
-                    ts = datetime.fromisoformat(data["timestamp"])
-                    if datetime.now() - ts > timedelta(minutes=5):
-                        return {}
-                return data
-        except Exception:
-            pass
-    return {}
+def get_parent_user_query(db: HtmlGraphDB, session_id: str) -> str | None:
+    """
+    Get the most recent UserQuery event_id for this session from database.
+
+    This is the primary method for parent-child event linking.
+    Database is the single source of truth - no file-based state.
 
+    Args:
+        db: HtmlGraphDB instance
+        session_id: Session ID to query
 
-def save_parent_activity(
-    graph_dir: Path, parent_id: str | None, tool: str | None = None
-) -> None:
-    """Save the active parent activity state."""
-    path = graph_dir / PARENT_ACTIVITY_FILE
+    Returns:
+        event_id of the most recent UserQuery event, or None if not found
+    """
     try:
-        if parent_id:
-            with open(path, "w") as f:
-                json.dump(
-                    {
-                        "parent_id": parent_id,
-                        "tool": tool,
-                        "timestamp": datetime.now().isoformat(),
-                    },
-                    f,
-                )
-        else:
-            # Clear parent activity
-            path.unlink(missing_ok=True)
+        if db.connection is None:
+            return None
+        cursor = db.connection.cursor()
+        cursor.execute(
+            """
+            SELECT event_id FROM agent_events
+            WHERE session_id = ? AND tool_name = 'UserQuery'
+            ORDER BY timestamp DESC
+            LIMIT 1
+            """,
+            (session_id,),
+        )
+        row = cursor.fetchone()
+        if row:
+            return str(row[0])
+        return None
     except Exception as e:
-        print(f"Warning: Could not save parent activity: {e}", file=sys.stderr)
+        print(
+            f"Debug: Database query for UserQuery failed: {e}",
+            file=sys.stderr,
+        )
+        return None
 
 
-def load_drift_queue(graph_dir: Path, max_age_hours: int = 48) -> dict:
+def load_drift_queue(graph_dir: Path, max_age_hours: int = 48) -> dict[str, Any]:
     """
     Load the drift queue from file and clean up stale entries.
 
@@ -157,7 +205,7 @@ def load_drift_queue(graph_dir: Path, max_age_hours: int = 48) -> dict:
     return {"activities": [], "last_classification": None}
 
 
-def save_drift_queue(graph_dir: Path, queue: dict) -> None:
+def save_drift_queue(graph_dir: Path, queue: dict[str, Any]) -> None:
     """Save the drift queue to file."""
     queue_path = graph_dir / DRIFT_QUEUE_FILE
     try:
@@ -191,7 +239,9 @@ def clear_drift_queue_activities(graph_dir: Path) -> None:
         print(f"Warning: Could not clear drift queue: {e}", file=sys.stderr)
 
 
-def add_to_drift_queue(graph_dir: Path, activity: dict, config: dict) -> dict:
+def add_to_drift_queue(
+    graph_dir: Path, activity: dict[str, Any], config: dict[str, Any]
+) -> dict[str, Any]:
     """Add a high-drift activity to the queue."""
     max_age_hours = config.get("queue", {}).get("max_age_hours", 48)
     queue = load_drift_queue(graph_dir, max_age_hours=max_age_hours)
@@ -199,7 +249,7 @@ def add_to_drift_queue(graph_dir: Path, activity: dict, config: dict) -> dict:
 
     queue["activities"].append(
         {
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "tool": activity.get("tool"),
             "summary": activity.get("summary"),
             "file_paths": activity.get("file_paths", []),
@@ -214,7 +264,9 @@ def add_to_drift_queue(graph_dir: Path, activity: dict, config: dict) -> dict:
     return queue
 
 
-def should_trigger_classification(queue: dict, config: dict) -> bool:
+def should_trigger_classification(
+    queue: dict[str, Any], config: dict[str, Any]
+) -> bool:
     """Check if we should trigger auto-classification."""
     drift_config = config.get("drift_detection", {})
 
@@ -241,7 +293,7 @@ def should_trigger_classification(queue: dict, config: dict) -> bool:
     return True
 
 
-def build_classification_prompt(queue: dict, feature_id: str) -> str:
+def build_classification_prompt(queue: dict[str, Any], feature_id: str) -> str:
     """Build the prompt for the classification agent."""
     activities = queue.get("activities", [])
 
@@ -293,7 +345,108 @@ def resolve_project_path(cwd: str | None = None) -> str:
     return start_dir
 
 
-def extract_file_paths(tool_input: dict, tool_name: str) -> list[str]:
+def detect_model_from_hook_input(hook_input: dict[str, Any]) -> str | None:
+    """
+    Detect the Claude model from hook input data.
+
+    Checks in order of priority:
+    1. Task() model parameter (if tool_name == 'Task')
+    2. HTMLGRAPH_MODEL environment variable (set by hooks)
+    3. ANTHROPIC_MODEL or CLAUDE_MODEL environment variables
+
+    Args:
+        hook_input: Hook input dict containing tool_name and tool_input
+
+    Returns:
+        Model name (e.g., 'claude-opus', 'claude-sonnet', 'claude-haiku') or None
+    """
+    # Get tool info
+    tool_name_value: Any = hook_input.get("tool_name", "") or hook_input.get("name", "")
+    tool_name = tool_name_value if isinstance(tool_name_value, str) else ""
+    tool_input_value: Any = hook_input.get("tool_input", {}) or hook_input.get(
+        "input", {}
+    )
+    tool_input = tool_input_value if isinstance(tool_input_value, dict) else {}
+
+    # 1. Check for Task() model parameter first
+    if tool_name == "Task" and "model" in tool_input:
+        model_value: Any = tool_input.get("model")
+        if model_value and isinstance(model_value, str):
+            model = model_value.strip().lower()
+            if model:
+                if not model.startswith("claude-"):
+                    model = f"claude-{model}"
+                return cast(str, model)
+
+    # 2. Check environment variables (set by PreToolUse hook)
+    for env_var in ["HTMLGRAPH_MODEL", "ANTHROPIC_MODEL", "CLAUDE_MODEL"]:
+        value = os.environ.get(env_var)
+        if value and isinstance(value, str):
+            model = value.strip()
+            if model:
+                return model
+
+    return None
+
+
+def detect_agent_from_environment() -> tuple[str, str | None]:
+    """
+    Detect the agent/model name from environment variables and status cache.
+
+    Checks multiple sources in order of priority:
+    1. HTMLGRAPH_AGENT - Explicit agent name set by user
+    2. HTMLGRAPH_SUBAGENT_TYPE - For subagent sessions
+    3. HTMLGRAPH_PARENT_AGENT - Parent agent context
+    4. HTMLGRAPH_MODEL - Model name (e.g., claude-haiku, claude-opus)
+    5. CLAUDE_MODEL - Model name if exposed by Claude Code
+    6. ANTHROPIC_MODEL - Alternative model env var
+    7. Status line cache (model only) - ~/.cache/claude-code/status-{session_id}.json
+
+    Falls back to 'claude-code' if no environment variable is set.
+
+    Returns:
+        Tuple of (agent_id, model_name). Model name may be None if not detected.
+    """
+    # Check for explicit agent name first
+    agent_id = None
+    env_vars_agent = [
+        "HTMLGRAPH_AGENT",
+        "HTMLGRAPH_SUBAGENT_TYPE",
+        "HTMLGRAPH_PARENT_AGENT",
+    ]
+
+    for var in env_vars_agent:
+        value = os.environ.get(var)
+        if value and value.strip():
+            agent_id = value.strip()
+            break
+
+    # Check for model name separately
+    model_name = None
+    env_vars_model = [
+        "HTMLGRAPH_MODEL",
+        "CLAUDE_MODEL",
+        "ANTHROPIC_MODEL",
+    ]
+
+    for var in env_vars_model:
+        value = os.environ.get(var)
+        if value and value.strip():
+            model_name = value.strip()
+            break
+
+    # Fallback: Try to read model from status line cache
+    if not model_name:
+        model_name = get_model_from_status_cache()
+
+    # Default fallback for agent_id
+    if not agent_id:
+        agent_id = "claude-code"
+
+    return agent_id, model_name
+
+
+def extract_file_paths(tool_input: dict[str, Any], tool_name: str) -> list[str]:
     """Extract file paths from tool input based on tool type."""
     paths = []
 
@@ -318,7 +471,7 @@ def extract_file_paths(tool_input: dict, tool_name: str) -> list[str]:
 
 
 def format_tool_summary(
-    tool_name: str, tool_input: dict, tool_result: dict | None = None
+    tool_name: str, tool_input: dict[str, Any], tool_result: dict | None = None
 ) -> str:
     """Format a human-readable summary of the tool call."""
     if tool_name == "Read":
@@ -366,13 +519,156 @@ def format_tool_summary(
         url = tool_input.get("url", "")[:40]
         return f"WebFetch: {url}"
 
+    elif tool_name == "UserQuery":
+        # Extract the actual prompt text from the tool_input
+        prompt = str(tool_input.get("prompt", ""))
+        preview = prompt[:100].replace("\n", " ")
+        if len(prompt) > 100:
+            preview += "..."
+        return preview
+
     else:
         return f"{tool_name}: {str(tool_input)[:50]}"
 
 
-def track_event(hook_type: str, hook_input: dict) -> dict:
+def record_event_to_sqlite(
+    db: HtmlGraphDB,
+    session_id: str,
+    tool_name: str,
+    tool_input: dict[str, Any],
+    tool_response: dict[str, Any],
+    is_error: bool,
+    file_paths: list[str] | None = None,
+    parent_event_id: str | None = None,
+    agent_id: str | None = None,
+    subagent_type: str | None = None,
+    model: str | None = None,
+) -> str | None:
     """
-    Track a hook event and log it to HtmlGraph.
+    Record a tool call event to SQLite database for dashboard queries.
+
+    Args:
+        db: HtmlGraphDB instance
+        session_id: Session ID from HtmlGraph
+        tool_name: Name of the tool called
+        tool_input: Tool input parameters
+        tool_response: Tool response/result
+        is_error: Whether the tool call resulted in an error
+        file_paths: File paths affected by the tool
+        parent_event_id: Parent event ID if this is a child event
+        agent_id: Agent identifier (optional)
+        subagent_type: Subagent type for Task delegations (optional)
+        model: Claude model name (e.g., claude-haiku, claude-opus) (optional)
+
+    Returns:
+        event_id if successful, None otherwise
+    """
+    try:
+        event_id = generate_id("event")
+        input_summary = format_tool_summary(tool_name, tool_input, tool_response)
+
+        # Build output summary from tool response
+        output_summary = ""
+        if isinstance(tool_response, dict):  # type: ignore[arg-type]
+            if is_error:
+                output_summary = tool_response.get("error", "error")[:200]
+            else:
+                # Extract summary from response
+                content = tool_response.get("content", tool_response.get("output", ""))
+                if isinstance(content, str):
+                    output_summary = content[:200]
+                elif isinstance(content, list):
+                    output_summary = f"{len(content)} items"
+                else:
+                    output_summary = "success"
+
+        # Build context metadata
+        context = {
+            "file_paths": file_paths or [],
+            "tool_input_keys": list(tool_input.keys()),
+            "is_error": is_error,
+        }
+
+        # Insert event to SQLite
+        success = db.insert_event(
+            event_id=event_id,
+            agent_id=agent_id or "claude-code",
+            event_type="tool_call",
+            session_id=session_id,
+            tool_name=tool_name,
+            input_summary=input_summary,
+            output_summary=output_summary,
+            context=context,
+            parent_event_id=parent_event_id,
+            cost_tokens=0,
+            subagent_type=subagent_type,
+            model=model,
+        )
+
+        if success:
+            return event_id
+        return None
+
+    except Exception as e:
+        print(f"Warning: Could not record event to SQLite: {e}", file=sys.stderr)
+        return None
+
+
+def record_delegation_to_sqlite(
+    db: HtmlGraphDB,
+    session_id: str,
+    from_agent: str,
+    to_agent: str,
+    task_description: str,
+    task_input: dict[str, Any],
+) -> str | None:
+    """
+    Record a Task() delegation to agent_collaboration table.
+
+    Args:
+        db: HtmlGraphDB instance
+        session_id: Session ID from HtmlGraph
+        from_agent: Agent delegating the task (usually 'orchestrator' or 'claude-code')
+        to_agent: Target subagent type (e.g., 'general-purpose', 'researcher')
+        task_description: Task description/prompt
+        task_input: Full task input parameters
+
+    Returns:
+        handoff_id if successful, None otherwise
+    """
+    try:
+        handoff_id = generate_id("handoff")
+
+        # Build context with task input
+        context = {
+            "task_input_keys": list(task_input.keys()),
+            "model": task_input.get("model"),
+            "temperature": task_input.get("temperature"),
+        }
+
+        # Insert delegation record
+        success = db.insert_collaboration(
+            handoff_id=handoff_id,
+            from_agent=from_agent,
+            to_agent=to_agent,
+            session_id=session_id,
+            handoff_type="delegation",
+            reason=task_description[:200],
+            context=context,
+        )
+
+        if success:
+            return handoff_id
+        return None
+
+    except Exception as e:
+        print(f"Warning: Could not record delegation to SQLite: {e}", file=sys.stderr)
+        return None
+
+
+def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
+    """
+    Track a hook event and log it to HtmlGraph (both HTML files and SQLite).
 
     Args:
         hook_type: Type of hook event ("PostToolUse", "Stop", "UserPromptSubmit")
@@ -388,13 +684,29 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
     # Load drift configuration
     drift_config = load_drift_config()
 
-    # Initialize SessionManager
+    # Initialize SessionManager and SQLite DB
     try:
         manager = SessionManager(graph_dir)
     except Exception as e:
         print(f"Warning: Could not initialize SessionManager: {e}", file=sys.stderr)
         return {"continue": True}
 
+    # Initialize SQLite database for event recording
+    db = None
+    try:
+        db = HtmlGraphDB(str(graph_dir / "index.sqlite"))
+    except Exception as e:
+        print(f"Warning: Could not initialize SQLite database: {e}", file=sys.stderr)
+        # Continue without SQLite (graceful degradation)
+
+    # Detect agent and model from environment
+    detected_agent, detected_model = detect_agent_from_environment()
+
+    # Also try to detect model from hook input (more specific than environment)
+    model_from_input = detect_model_from_hook_input(hook_input)
+    if model_from_input:
+        detected_model = model_from_input
+
     # Get active session ID
     active_session = manager.get_active_session()
     if not active_session:
@@ -402,7 +714,7 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
         try:
             active_session = manager.start_session(
                 session_id=None,
-                agent="claude-code",
+                agent=detected_agent,
                 title=f"Session {datetime.now().strftime('%Y-%m-%d %H:%M')}",
             )
         except Exception:
@@ -410,6 +722,50 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
 
     active_session_id = active_session.id
 
+    # Ensure session exists in SQLite database (for foreign key constraints)
+    if db:
+        try:
+            # Get attributes safely - MagicMock objects can cause SQLite binding errors
+            # When getattr is called on a MagicMock, it returns another MagicMock, not the default
+            def safe_getattr(obj: Any, attr: str, default: Any) -> Any:
+                """Get attribute safely, returning default for MagicMock/invalid values."""
+                try:
+                    val = getattr(obj, attr, default)
+                    # Check if it's a mock object (has _mock_name attribute)
+                    if hasattr(val, "_mock_name"):
+                        return default
+                    return val
+                except Exception:
+                    return default
+
+            is_subagent_raw = safe_getattr(active_session, "is_subagent", False)
+            is_subagent = (
+                bool(is_subagent_raw) if isinstance(is_subagent_raw, bool) else False
+            )
+
+            transcript_id = safe_getattr(active_session, "transcript_id", None)
+            transcript_path = safe_getattr(active_session, "transcript_path", None)
+            # Ensure strings or None, not mock objects
+            if transcript_id is not None and not isinstance(transcript_id, str):
+                transcript_id = None
+            if transcript_path is not None and not isinstance(transcript_path, str):
+                transcript_path = None
+
+            db.insert_session(
+                session_id=active_session_id,
+                agent_assigned=safe_getattr(active_session, "agent", None)
+                or detected_agent,
+                is_subagent=is_subagent,
+                transcript_id=transcript_id,
+                transcript_path=transcript_path,
+            )
+        except Exception as e:
+            # Session may already exist, that's OK - continue
+            print(
+                f"Debug: Could not insert session to SQLite (may already exist): {e}",
+                file=sys.stderr,
+            )
+
     # Handle different hook types
     if hook_type == "Stop":
         # Session is ending - track stop event
@@ -417,6 +773,19 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
             manager.track_activity(
                 session_id=active_session_id, tool="Stop", summary="Agent stopped"
             )
+
+            # Record to SQLite if available
+            if db:
+                record_event_to_sqlite(
+                    db=db,
+                    session_id=active_session_id,
+                    tool_name="Stop",
+                    tool_input={},
+                    tool_response={"content": "Agent stopped"},
+                    is_error=False,
+                    agent_id=detected_agent,
+                    model=detected_model,
+                )
         except Exception as e:
             print(f"Warning: Could not track stop: {e}", file=sys.stderr)
         return {"continue": True}
@@ -432,6 +801,22 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
             manager.track_activity(
                 session_id=active_session_id, tool="UserQuery", summary=f'"{preview}"'
             )
+
+            # Record to SQLite if available
+            # UserQuery event is stored in database - no file-based state needed
+            # Subsequent tool calls query database for parent via get_parent_user_query()
+            if db:
+                record_event_to_sqlite(
+                    db=db,
+                    session_id=active_session_id,
+                    tool_name="UserQuery",
+                    tool_input={"prompt": prompt},
+                    tool_response={"content": "Query received"},
+                    is_error=False,
+                    agent_id=detected_agent,
+                    model=detected_model,
+                )
+
         except Exception as e:
             print(f"Warning: Could not track query: {e}", file=sys.stderr)
         return {"continue": True}
@@ -456,7 +841,7 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
         summary = format_tool_summary(tool_name, tool_input_data, tool_response)
 
         # Determine success
-        if isinstance(tool_response, dict):
+        if isinstance(tool_response, dict):  # type: ignore[arg-type]
             success_field = tool_response.get("success")
             if isinstance(success_field, bool):
                 is_error = not success_field
@@ -479,26 +864,23 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
 
         # Get drift thresholds from config
         drift_settings = drift_config.get("drift_detection", {})
-        warning_threshold = drift_settings.get("warning_threshold", 0.7)
-        auto_classify_threshold = drift_settings.get("auto_classify_threshold", 0.85)
+        warning_threshold = drift_settings.get("warning_threshold") or 0.7
+        auto_classify_threshold = drift_settings.get("auto_classify_threshold") or 0.85
 
-        # Determine parent activity context
-        parent_activity_state = load_parent_activity(graph_dir)
+        # Determine parent activity context using database-only lookup
         parent_activity_id = None
 
-        # Tools that create parent context (Skill, Task)
-        parent_tools = {"Skill", "Task"}
-
-        # If this is a parent tool invocation, save its context for subsequent activities
-        if tool_name in parent_tools:
-            # We'll get the event_id after tracking, so we use a placeholder for now
-            # The actual parent_id will be set below after we track the activity
-            is_parent_tool = True
-        else:
-            is_parent_tool = False
-            # Check if there's an active parent context
-            if parent_activity_state.get("parent_id"):
-                parent_activity_id = parent_activity_state["parent_id"]
+        # Check environment variable FIRST for cross-process parent linking
+        # This is set by PreToolUse hook when Task() spawns a subagent
+        env_parent = os.environ.get("HTMLGRAPH_PARENT_EVENT") or os.environ.get(
+            "HTMLGRAPH_PARENT_QUERY_EVENT"
+        )
+        if env_parent:
+            parent_activity_id = env_parent
+        # Query database for most recent UserQuery event as parent
+        # Database is the single source of truth for parent-child linking
+        elif db:
+            parent_activity_id = get_parent_user_query(db, active_session_id)
 
         # Track the activity
         nudge = None
@@ -512,11 +894,41 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
                 parent_activity_id=parent_activity_id,
             )
 
-            # If this was a parent tool, save its ID for subsequent activities
-            if is_parent_tool and result:
-                save_parent_activity(graph_dir, result.id, tool_name)
-            # If this tool finished a parent context (e.g., Task completed), clear it
-            # We'll clear parent context after 5 minutes automatically (see load_parent_activity)
+            # Record to SQLite if available
+            if db:
+                # Extract subagent_type for Task delegations
+                task_subagent_type = None
+                if tool_name == "Task":
+                    task_subagent_type = tool_input_data.get(
+                        "subagent_type", "general-purpose"
+                    )
+
+                record_event_to_sqlite(
+                    db=db,
+                    session_id=active_session_id,
+                    tool_name=tool_name,
+                    tool_input=tool_input_data,
+                    tool_response=tool_response,
+                    is_error=is_error,
+                    file_paths=file_paths if file_paths else None,
+                    parent_event_id=parent_activity_id,  # Link to parent event
+                    agent_id=detected_agent,
+                    subagent_type=task_subagent_type,
+                    model=detected_model,
+                )
+
+            # If this was a Task() delegation, also record to agent_collaboration
+            if tool_name == "Task" and db:
+                subagent = tool_input_data.get("subagent_type", "general-purpose")
+                description = tool_input_data.get("description", "")
+                record_delegation_to_sqlite(
+                    db=db,
+                    session_id=active_session_id,
+                    from_agent=detected_agent,
+                    to_agent=subagent,
+                    task_description=description,
+                    task_input=tool_input_data,
+                )
 
             # Check for drift and handle accordingly
             # Skip drift detection for child activities (they inherit parent's context)
@@ -524,7 +936,10 @@ def track_event(hook_type: str, hook_input: dict) -> dict:
                 drift_score = result.drift_score
                 feature_id = getattr(result, "feature_id", "unknown")
 
-                if drift_score and drift_score >= auto_classify_threshold:
+                # Skip drift detection if no score available
+                if drift_score is None:
+                    pass  # No active features - can't calculate drift
+                elif drift_score >= auto_classify_threshold:
                     # High drift - add to classification queue
                     queue = add_to_drift_queue(
                         graph_dir,
@@ -598,7 +1013,9 @@ Task tool with subagent_type="general-purpose", model="haiku", prompt:
 Or manually create a work item in .htmlgraph/ (bug, feature, spike, or chore)."""
 
                         # Mark classification as triggered
-                        queue["last_classification"] = datetime.now().isoformat()
+                        queue["last_classification"] = datetime.now(
+                            timezone.utc
+                        ).isoformat()
                         save_drift_queue(graph_dir, queue)
                     else:
                         nudge = f"Drift detected ({drift_score:.2f}): Activity queued for classification ({len(queue['activities'])}/{drift_settings.get('min_activities_before_classify', 3)} needed)."