htmlgraph 0.26.6__tar.gz → 0.26.8__tar.gz

{htmlgraph-0.26.6 → htmlgraph-0.26.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.26.6
+Version: 0.26.8
 Summary: HTML is All You Need - Graph database on web standards
 Project-URL: Homepage, https://github.com/Shakes-tzd/htmlgraph
 Project-URL: Documentation, https://github.com/Shakes-tzd/htmlgraph#readme

{htmlgraph-0.26.6 → htmlgraph-0.26.8}/packages/gemini-extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlgraph",
-  "version": "0.26.6",
+  "version": "0.26.8",
   "description": "HtmlGraph session tracking and documentation for Gemini CLI. Ensures proper activity attribution, feature awareness, and continuous work tracking.",
   "author": "Shakes",
   "license": "MIT",

{htmlgraph-0.26.6 → htmlgraph-0.26.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "htmlgraph"
-version = "0.26.6"
+version = "0.26.8"
 description = "HTML is All You Need - Graph database on web standards"
 authors = [{name = "Shakes", email = "shakestzd@gmail.com"}]
 readme = "README.md"

{htmlgraph-0.26.6 → htmlgraph-0.26.8}/src/python/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.26.6"
+__version__ = "0.26.8"
 __all__ = [
     # Exceptions
     "HtmlGraphError",

{htmlgraph-0.26.6 → htmlgraph-0.26.8}/src/python/htmlgraph/hooks/event_tracker.py

@@ -353,6 +353,7 @@ def detect_model_from_hook_input(hook_input: dict[str, Any]) -> str | None:
     1. Task() model parameter (if tool_name == 'Task')
     2. HTMLGRAPH_MODEL environment variable (set by hooks)
     3. ANTHROPIC_MODEL or CLAUDE_MODEL environment variables
+    4. Status line cache (for orchestrator tool calls)
 
     Args:
         hook_input: Hook input dict containing tool_name and tool_input
@@ -386,6 +387,14 @@ def detect_model_from_hook_input(hook_input: dict[str, Any]) -> str | None:
             if model:
                 return model
 
+    # 3. Fallback to status line cache for orchestrator's own tool calls
+    # This gives regular tool calls (Bash, Read, etc.) the model of the orchestrator
+    session_id = hook_input.get("session_id") or hook_input.get("sessionId")
+    if session_id:
+        model_from_cache = get_model_from_status_cache(session_id)
+        if model_from_cache:
+            return model_from_cache
+
     return None
 
 
@@ -447,7 +456,10 @@ def detect_agent_from_environment() -> tuple[str, str | None]:
 
 
 def detect_subagent_context_from_database(
-    db: HtmlGraphDB, current_session_id: str
+    db: HtmlGraphDB,
+    current_session_id: str,
+    parent_event_id_hint: str | None = None,
+    current_tool_name: str | None = None,
 ) -> tuple[str | None, str | None, str | None]:
     """
     Detect if we're in a subagent context by checking for active task_delegation events.
@@ -456,28 +468,124 @@ def detect_subagent_context_from_database(
     environment variables set by PreToolUse hooks in the parent process do NOT propagate
     to subagent processes spawned by Claude Code's Task() tool.
 
-    Strategy:
-    1. Query for task_delegation events with status='started' (not yet completed)
-    2. If found within the last 5 minutes, we're likely in a subagent context
-    3. Return the subagent_type and parent session info
+    IMPORTANT CONTEXT:
+    - Claude Code passes the SAME session_id to both parent and subagent hooks
+    - Environment variables set in hooks don't persist (each hook is a new subprocess)
+    - The only way to detect subagent context is through database state
+
+    DETECTION STRATEGY:
+    - If there's an active task_delegation (status='started') within the time window,
+      AND the current tool is NOT the Task tool itself (to avoid self-detection),
+      then we're likely in a subagent context.
+    - The Task tool check is critical: when PostToolUse fires for the Task tool itself,
+      we should NOT consider ourselves in a subagent context - we're the orchestrator
+      that just finished delegating.
+
+    Strategy (in order of precedence):
+    1. If parent_event_id_hint is provided, look up that specific event directly
+    2. Otherwise, query for task_delegation events with status='started' (fallback)
+    3. If found within the last 5 minutes AND current tool is not Task, we're in subagent context
+    4. Return the subagent_type and parent session info
 
     Args:
         db: HtmlGraphDB instance
         current_session_id: The session_id from hook_input (Claude Code's session ID)
+        parent_event_id_hint: Optional event_id from environment variable for direct lookup.
+                              This is the preferred method when available, as it correctly
+                              handles parallel Task() calls.
+        current_tool_name: The tool being executed. If "Task", we skip subagent detection
+                           to avoid the orchestrator thinking it's a subagent.
 
     Returns:
         Tuple of (subagent_type, parent_session_id, parent_event_id)
         All None if not in subagent context
     """
+    # Skip detection if the current tool is Task - we're the orchestrator, not a subagent
+    if current_tool_name == "Task":
+        print(
+            "DEBUG detect_subagent_context_from_database: "
+            "Skipping detection for Task tool (we're the orchestrator)",
+            file=sys.stderr,
+        )
+        return None, None, None
     try:
         if db.connection is None:
             return None, None, None
 
         cursor = db.connection.cursor()
 
-        # Query for active task_delegation events (started but not completed)
-        # that were created in the last 5 minutes
-        # Exclude events that belong to the current session (those are parent context, not subagent)
+        # Priority 1: Direct lookup using parent_event_id_hint (handles parallel tasks correctly)
+        if parent_event_id_hint:
+            cursor.execute(
+                """
+                SELECT event_id, session_id, subagent_type, timestamp
+                FROM agent_events
+                WHERE event_id = ?
+                AND event_type = 'task_delegation'
+                AND status = 'started'
+                """,
+                (parent_event_id_hint,),
+            )
+            row = cursor.fetchone()
+
+            if row:
+                parent_event_id = row[0]
+                parent_session_id = row[1]
+                subagent_type = row[2] or "general-purpose"
+
+                print(
+                    f"Debug: Detected subagent context via hint: "
+                    f"type={subagent_type}, parent_session={parent_session_id}, "
+                    f"parent_event={parent_event_id}",
+                    file=sys.stderr,
+                )
+
+                return subagent_type, parent_session_id, parent_event_id
+
+            # Hint provided but event not found or not in 'started' status
+            # This can happen if the event was already completed
+            print(
+                f"Debug: Parent event hint '{parent_event_id_hint}' not found or not active",
+                file=sys.stderr,
+            )
+
+        # Priority 2: Fallback to most recent active task_delegation
+        # WARNING: This can pick the wrong parent when multiple Task() calls run in parallel!
+        # This is kept as a fallback for cases where environment variables don't propagate.
+        #
+        # IMPORTANT: We previously had `AND session_id != ?` to exclude the current session,
+        # but this was WRONG. Claude Code passes the SAME session_id to subagent hooks as
+        # to the parent session. So we need to find task_delegation events from the SAME
+        # session that are in 'started' status (not yet completed).
+        #
+        # The key insight: when a subagent runs, the task_delegation event from the parent
+        # is ALREADY in the database with status='started'. We just need to find it.
+        print(
+            f"DEBUG detect_subagent_context_from_database: "
+            f"Querying for task_delegation events in session {current_session_id}",
+            file=sys.stderr,
+        )
+
+        # First, let's see what task_delegation events exist at all (debug)
+        cursor.execute(
+            """
+            SELECT event_id, session_id, subagent_type, status, timestamp
+            FROM agent_events
+            WHERE event_type = 'task_delegation'
+            ORDER BY timestamp DESC
+            LIMIT 5
+            """
+        )
+        debug_rows = cursor.fetchall()
+        print(
+            f"DEBUG detect_subagent_context_from_database: "
+            f"Recent task_delegation events: {debug_rows}",
+            file=sys.stderr,
+        )
+
+        # Query for active task_delegation in the SAME session (or any session within time window)
+        # The subagent may have the same session_id as parent, so we look for ANY active
+        # task_delegation within the time window. The most recent one is likely our parent.
         cursor.execute(
             """
             SELECT event_id, session_id, subagent_type, timestamp
@@ -485,13 +593,16 @@ def detect_subagent_context_from_database(
             WHERE event_type = 'task_delegation'
             AND status = 'started'
             AND timestamp >= datetime('now', '-5 minutes')
-            AND session_id != ?
             ORDER BY timestamp DESC
             LIMIT 1
-            """,
-            (current_session_id,),
+            """
         )
         row = cursor.fetchone()
+        print(
+            f"DEBUG detect_subagent_context_from_database: "
+            f"Fallback query result: {row}",
+            file=sys.stderr,
+        )
 
         if row:
             parent_event_id = row[0]
@@ -499,7 +610,7 @@ def detect_subagent_context_from_database(
             subagent_type = row[2] or "general-purpose"
 
             print(
-                f"Debug: Detected subagent context from database: "
+                f"Debug: Detected subagent context from database (fallback): "
                 f"type={subagent_type}, parent_session={parent_session_id}, "
                 f"parent_event={parent_event_id}",
                 file=sys.stderr,
@@ -751,6 +862,24 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
     Returns:
         Response dict with {"continue": True} and optional hookSpecificOutput
     """
+    # Check for debug mode (set HTMLGRAPH_DEBUG=1 to enable verbose logging)
+    debug_mode = os.environ.get("HTMLGRAPH_DEBUG") == "1"
+
+    if debug_mode:
+        print(
+            f"DEBUG track_event: hook_type={hook_type}, "
+            f"session_id={hook_input.get('session_id')}, "
+            f"tool_name={hook_input.get('tool_name', hook_input.get('name', 'unknown'))}",
+            file=sys.stderr,
+        )
+        print(
+            f"DEBUG track_event: ENV HTMLGRAPH_PARENT_EVENT="
+            f"{os.environ.get('HTMLGRAPH_PARENT_EVENT')}, "
+            f"HTMLGRAPH_SUBAGENT_TYPE={os.environ.get('HTMLGRAPH_SUBAGENT_TYPE')}, "
+            f"HTMLGRAPH_PARENT_SESSION={os.environ.get('HTMLGRAPH_PARENT_SESSION')}",
+            file=sys.stderr,
+        )
+
     cwd = hook_input.get("cwd")
     project_dir = resolve_project_path(cwd if cwd else None)
     graph_dir = Path(project_dir) / ".htmlgraph"
@@ -791,34 +920,106 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
     hook_session_id = hook_input.get("session_id") or hook_input.get("sessionId")
 
     # Check if we're in a subagent context using multiple methods:
+    #
+    # PRECEDENCE ORDER (fixes parallel Task() bug):
+    # 1. Environment variables - most reliable when available, correctly identifies
+    #    the specific parent event even with multiple parallel Task() calls
+    # 2. Database with hint - uses env var as hint for direct lookup
+    # 3. Database fallback - picks most recent (WARNING: wrong for parallel tasks!)
+    #
     # Method 1: Environment variables (works if Task() spawner sets them)
     subagent_type = os.environ.get("HTMLGRAPH_SUBAGENT_TYPE")
     parent_session_id = os.environ.get("HTMLGRAPH_PARENT_SESSION")
+    env_parent_event_id = os.environ.get("HTMLGRAPH_PARENT_EVENT")
+
+    # DEBUG: Log subagent detection attempt
+    print(
+        f"DEBUG subagent detection: "
+        f"env subagent_type={subagent_type}, "
+        f"env parent_session_id={parent_session_id}, "
+        f"env parent_event_id={env_parent_event_id}",
+        file=sys.stderr,
+    )
+
+    # If we have parent event from environment, use it directly
+    if env_parent_event_id:
+        parent_event_id_for_session = env_parent_event_id
+        print(
+            f"Debug: Using environment variable for parent event: {env_parent_event_id}",
+            file=sys.stderr,
+        )
 
     # Method 2: Database-based detection (CRITICAL for Claude Code Task() tool)
-    # Environment variables don't propagate to subagent processes, so we check
-    # the database for active task_delegation events
+    # Environment variables may not propagate to subagent processes, so we check
+    # the database for active task_delegation events.
+    # IMPORTANT: Pass env_parent_event_id as hint to handle parallel Task() correctly
+    # Get the current tool name for subagent detection
+    current_tool_name = hook_input.get("tool_name") or hook_input.get("name")
+
+    print(
+        f"DEBUG db detection: will_check={not subagent_type and db and hook_session_id}, "
+        f"subagent_type={subagent_type}, db={db is not None}, hook_session_id={hook_session_id}, "
+        f"current_tool_name={current_tool_name}",
+        file=sys.stderr,
+    )
     if not subagent_type and db and hook_session_id:
+        print(
+            f"DEBUG db detection: calling detect_subagent_context_from_database "
+            f"with current_session_id={hook_session_id}, hint={env_parent_event_id}, "
+            f"current_tool_name={current_tool_name}",
+            file=sys.stderr,
+        )
         db_subagent_type, db_parent_session_id, db_parent_event_id = (
-            detect_subagent_context_from_database(db, hook_session_id)
+            detect_subagent_context_from_database(
+                db,
+                hook_session_id,
+                parent_event_id_hint=env_parent_event_id,
+                current_tool_name=current_tool_name,
+            )
+        )
+        print(
+            f"DEBUG db detection result: "
+            f"db_subagent_type={db_subagent_type}, "
+            f"db_parent_session_id={db_parent_session_id}, "
+            f"db_parent_event_id={db_parent_event_id}",
+            file=sys.stderr,
         )
         if db_subagent_type:
             subagent_type = db_subagent_type
             parent_session_id = db_parent_session_id
-            parent_event_id_for_session = db_parent_event_id
+            # Only update parent_event_id if not already set from env
+            if not parent_event_id_for_session:
+                parent_event_id_for_session = db_parent_event_id
             print(
                 f"Debug: Using database-based subagent detection: "
-                f"type={subagent_type}, parent={parent_session_id}",
+                f"type={subagent_type}, parent={parent_session_id}, "
+                f"parent_event={parent_event_id_for_session}",
                 file=sys.stderr,
             )
 
+    # DEBUG: Log subagent context decision
+    print(
+        f"DEBUG subagent context decision: "
+        f"subagent_type={subagent_type}, parent_session_id={parent_session_id}, "
+        f"will_create_subagent_session={bool(subagent_type and parent_session_id)}",
+        file=sys.stderr,
+    )
+
     if subagent_type and parent_session_id:
         # We're in a subagent context
         is_subagent_session = True
+        print(
+            "DEBUG: SUBAGENT CONTEXT DETECTED! Creating subagent session...",
+            file=sys.stderr,
+        )
 
         # Use Claude's session_id (hook_session_id) as the subagent session ID
         # This ensures events are properly tracked to this session
         subagent_session_id = hook_session_id or f"{parent_session_id}-{subagent_type}"
+        print(
+            f"DEBUG: subagent_session_id={subagent_session_id}",
+            file=sys.stderr,
+        )
 
         # Check if session already exists in our system
         existing = manager.session_converter.load(subagent_session_id)
@@ -831,6 +1032,11 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
         else:
             # Create new subagent session with parent link
             try:
+                print(
+                    f"DEBUG: Creating NEW subagent session with is_subagent=True, "
+                    f"parent_session_id={parent_session_id}",
+                    file=sys.stderr,
+                )
                 active_session = manager.start_session(
                     session_id=subagent_session_id,
                     agent=f"{subagent_type}-spawner",

{htmlgraph-0.26.6 → htmlgraph-0.26.8}/src/python/htmlgraph/hooks/subagent_stop.py

@@ -35,12 +35,61 @@ def get_parent_event_id() -> str | None:
 
     Set by PreToolUse hook when Task() is detected.
 
+    NOTE: This relies on environment variables which DON'T persist between
+    hook invocations (each hook is a new subprocess). This function is kept
+    for backward compatibility but will almost always return None.
+    Use get_parent_event_id_from_database() instead.
+
     Returns:
         Parent event ID (evt-XXXXX) or None if not found
     """
     return os.environ.get("HTMLGRAPH_PARENT_EVENT")
 
 
+def get_parent_event_id_from_database(db_path: str) -> tuple[str | None, str | None]:
+    """
+    Get the parent event ID by querying the database for active task_delegation events.
+
+    This is the reliable method for finding parent events since environment variables
+    don't persist between hook invocations.
+
+    Args:
+        db_path: Path to SQLite database
+
+    Returns:
+        Tuple of (parent_event_id, parent_start_time) or (None, None) if not found
+    """
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+
+        # Find the most recent task_delegation event that's still 'started'
+        cursor.execute(
+            """
+            SELECT event_id, timestamp
+            FROM agent_events
+            WHERE event_type = 'task_delegation'
+            AND status = 'started'
+            AND timestamp >= datetime('now', '-10 minutes')
+            ORDER BY timestamp DESC
+            LIMIT 1
+            """
+        )
+        row = cursor.fetchone()
+        conn.close()
+
+        if row:
+            logger.debug(f"Found active task_delegation from database: {row[0]}")
+            return row[0], row[1]
+
+        logger.debug("No active task_delegation found in database")
+        return None, None
+
+    except Exception as e:
+        logger.warning(f"Error querying database for parent event: {e}")
+        return None, None
+
+
 def get_session_id() -> str | None:
     """
     Get the current session ID from environment.
@@ -222,14 +271,7 @@ def handle_subagent_stop(hook_input: dict[str, Any]) -> dict[str, Any]:
     Returns:
         Response: {"continue": True} with optional context
     """
-    # Get parent event ID from environment
-    parent_event_id = get_parent_event_id()
-
-    if not parent_event_id:
-        logger.debug("No parent event ID found, skipping subagent stop tracking")
-        return {"continue": True}
-
-    # Get project directory and database path
+    # Get project directory and database path first (needed for database-based detection)
     try:
         from htmlgraph.config import get_database_path
 
@@ -244,12 +286,29 @@ def handle_subagent_stop(hook_input: dict[str, Any]) -> dict[str, Any]:
         logger.warning(f"Error resolving database path: {e}")
         return {"continue": True}
 
-    # Get parent event start time
-    parent_start_time = get_parent_event_start_time(db_path, parent_event_id)
-    if not parent_start_time:
-        logger.warning(f"Could not find parent event: {parent_event_id}")
+    # Try environment variable first (unlikely to work, but kept for compatibility)
+    parent_event_id = get_parent_event_id()
+    parent_start_time = None
+
+    # Fall back to database-based detection (the reliable method)
+    if not parent_event_id:
+        parent_event_id, parent_start_time = get_parent_event_id_from_database(db_path)
+
+    if not parent_event_id:
+        logger.debug(
+            "No parent event ID found (env or database), skipping subagent stop tracking"
+        )
         return {"continue": True}
 
+    logger.info(f"SubagentStop: Found parent event {parent_event_id}")
+
+    # Get parent event start time if not already retrieved from database
+    if not parent_start_time:
+        parent_start_time = get_parent_event_start_time(db_path, parent_event_id)
+        if not parent_start_time:
+            logger.warning(f"Could not find parent event start time: {parent_event_id}")
+            return {"continue": True}
+
     # Count child spikes
     child_spike_count = count_child_spikes(db_path, parent_event_id, parent_start_time)