htmlgraph 0.26.8__tar.gz → 0.26.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.26.8
+Version: 0.26.9
 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.8 → htmlgraph-0.26.9}/packages/gemini-extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlgraph",
-  "version": "0.26.8",
+  "version": "0.26.9",
   "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.8 → htmlgraph-0.26.9}/pyproject.toml

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

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

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

@@ -353,7 +353,6 @@ 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
@@ -387,14 +386,6 @@ 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
 
 
@@ -455,179 +446,6 @@ def detect_agent_from_environment() -> tuple[str, str | None]:
     return agent_id, model_name
 
 
-def detect_subagent_context_from_database(
-    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.
-
-    This is the DATABASE-BASED approach to subagent detection, which is necessary because
-    environment variables set by PreToolUse hooks in the parent process do NOT propagate
-    to subagent processes spawned by Claude Code's Task() tool.
-
-    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()
-
-        # 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
-            FROM agent_events
-            WHERE event_type = 'task_delegation'
-            AND status = 'started'
-            AND timestamp >= datetime('now', '-5 minutes')
-            ORDER BY timestamp DESC
-            LIMIT 1
-            """
-        )
-        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]
-            parent_session_id = row[1]
-            subagent_type = row[2] or "general-purpose"
-
-            print(
-                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,
-            )
-
-            return subagent_type, parent_session_id, parent_event_id
-
-        return None, None, None
-
-    except Exception as e:
-        print(
-            f"Debug: Error detecting subagent context from database: {e}",
-            file=sys.stderr,
-        )
-        return None, None, None
-
-
 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 = []
@@ -862,24 +680,6 @@ 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"
@@ -913,115 +713,104 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
         detected_model = model_from_input
 
     active_session = None
-    is_subagent_session = False
-    parent_event_id_for_session = None
-
-    # Get session_id from hook_input first (Claude Code provides this)
-    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!)
+    # PRECEDENCE ORDER:
+    # 1. Sessions table - if THIS session is already marked as subagent, use stored parent info
+    #    (fixes persistence issue for subsequent tool calls in same subagent)
+    # 2. Environment variables - set by spawner router for first tool call
+    # 3. Fallback to normal orchestrator context
     #
-    # 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 1: Check if current session is already a subagent (CRITICAL for persistence!)
+    # This fixes the issue where subsequent tool calls in the same subagent session
+    # lose the parent_event_id linkage.
+    subagent_type = None
+    parent_session_id = None
+    hook_session_id = hook_input.get("session_id") or hook_input.get("sessionId")
 
-    # Method 2: Database-based detection (CRITICAL for Claude Code Task() tool)
-    # 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,
-                parent_event_id_hint=env_parent_event_id,
-                current_tool_name=current_tool_name,
+    if db and db.connection and hook_session_id:
+        try:
+            cursor = db.connection.cursor()
+            cursor.execute(
+                """
+                SELECT parent_session_id, agent_assigned
+                FROM sessions
+                WHERE session_id = ? AND is_subagent = 1
+                LIMIT 1
+                """,
+                (hook_session_id,),
             )
-        )
-        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
-            # 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
+            row = cursor.fetchone()
+            if row:
+                parent_session_id = row[0]
+                # Extract subagent_type from agent_assigned (e.g., "general-purpose-spawner" -> "general-purpose")
+                agent_assigned = row[1] or ""
+                if agent_assigned and agent_assigned.endswith("-spawner"):
+                    subagent_type = agent_assigned[:-8]  # Remove "-spawner" suffix
+                else:
+                    subagent_type = "general-purpose"  # Default if format unexpected
+
+                print(
+                    f"DEBUG subagent persistence: Found current session as subagent in sessions table: "
+                    f"type={subagent_type}, parent_session={parent_session_id}",
+                    file=sys.stderr,
+                )
+        except Exception as e:
             print(
-                f"Debug: Using database-based subagent detection: "
-                f"type={subagent_type}, parent={parent_session_id}, "
-                f"parent_event={parent_event_id_for_session}",
+                f"DEBUG: Error checking sessions table for subagent: {e}",
                 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,
-    )
+    # Method 2: Environment variables (for first tool call before session table is populated)
+    if not subagent_type:
+        subagent_type = os.environ.get("HTMLGRAPH_SUBAGENT_TYPE")
+        parent_session_id = os.environ.get("HTMLGRAPH_PARENT_SESSION")
 
-    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,
-        )
+    # Method 3: Database detection of active task_delegation events
+    # CRITICAL: When Task() subprocess is launched, environment variables don't propagate
+    # So we must query the database for active task_delegation events to detect subagent context
+    if not subagent_type and db and db.connection:
+        try:
+            cursor = db.connection.cursor()
+            # Find the most recent active task_delegation event
+            cursor.execute(
+                """
+                SELECT event_id, subagent_type, session_id
+                FROM agent_events
+                WHERE event_type = 'task_delegation'
+                  AND status = 'started'
+                  AND tool_name = 'Task'
+                ORDER BY timestamp DESC
+                LIMIT 1
+                """,
+            )
+            row = cursor.fetchone()
+            if row:
+                task_event_id, detected_subagent_type, parent_sess = row
+                # Only treat as subagent if we're in a DIFFERENT session
+                # (same session = we're the orchestrator running Task())
+                if hook_session_id and hook_session_id != parent_sess:
+                    subagent_type = detected_subagent_type or "general-purpose"
+                    parent_session_id = parent_sess
+                    print(
+                        f"DEBUG subagent detection (database): Detected active task_delegation "
+                        f"type={subagent_type}, parent_session={parent_session_id}, "
+                        f"parent_event={task_event_id}",
+                        file=sys.stderr,
+                    )
+        except Exception as e:
+            print(
+                f"DEBUG: Error detecting subagent from database: {e}",
+                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,
-        )
+    if subagent_type and parent_session_id:
+        # We're in a subagent - create or get subagent session
+        # Use deterministic session ID based on parent + subagent type
+        subagent_session_id = f"{parent_session_id}-{subagent_type}"
 
-        # Check if session already exists in our system
+        # Check if subagent session already exists
         existing = manager.session_converter.load(subagent_session_id)
         if existing:
             active_session = existing
@@ -1032,11 +821,6 @@ 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",
@@ -1046,7 +830,7 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                 )
                 print(
                     f"Debug: Created subagent session: {subagent_session_id} "
-                    f"(parent: {parent_session_id}, is_subagent=True)",
+                    f"(parent: {parent_session_id})",
                     file=sys.stderr,
                 )
             except Exception as e:
@@ -1062,6 +846,8 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
         # Normal orchestrator/parent context
         # CRITICAL: Use session_id from hook_input (Claude Code provides this)
         # Only fall back to manager.get_active_session() if not in hook_input
+        # hook_session_id already defined at line 730
+
         if hook_session_id:
             # Claude Code provided session_id - use it directly
             # Check if session already exists
@@ -1110,13 +896,10 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                 except Exception:
                     return default
 
-            # Use is_subagent_session flag from our detection, not just from session object
             is_subagent_raw = safe_getattr(active_session, "is_subagent", False)
-            is_subagent_from_obj = (
+            is_subagent = (
                 bool(is_subagent_raw) if isinstance(is_subagent_raw, bool) else False
             )
-            # Prefer our detection (is_subagent_session) over object attribute
-            final_is_subagent = is_subagent_session or is_subagent_from_obj
 
             transcript_id = safe_getattr(active_session, "transcript_id", None)
             transcript_path = safe_getattr(active_session, "transcript_path", None)
@@ -1126,35 +909,14 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
             if transcript_path is not None and not isinstance(transcript_path, str):
                 transcript_path = None
 
-            # Get parent_session_id from our detection or from session object
-            final_parent_session_id = parent_session_id or safe_getattr(
-                active_session, "parent_session_id", None
-            )
-            if final_parent_session_id is not None and not isinstance(
-                final_parent_session_id, str
-            ):
-                final_parent_session_id = None
-
             db.insert_session(
                 session_id=active_session_id,
                 agent_assigned=safe_getattr(active_session, "agent", None)
                 or detected_agent,
-                parent_session_id=final_parent_session_id,
-                parent_event_id=parent_event_id_for_session,
-                is_subagent=final_is_subagent,
+                is_subagent=is_subagent,
                 transcript_id=transcript_id,
                 transcript_path=transcript_path,
             )
-
-            # Log subagent session creation for debugging
-            if final_is_subagent:
-                print(
-                    f"Debug: Inserted subagent session to SQLite: "
-                    f"session_id={active_session_id}, is_subagent=True, "
-                    f"parent_session={final_parent_session_id}, "
-                    f"parent_event={parent_event_id_for_session}",
-                    file=sys.stderr,
-                )
         except Exception as e:
             # Session may already exist, that's OK - continue
             print(
@@ -1265,29 +1027,20 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
         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 using multiple sources
+        # Determine parent activity context using database-only lookup
         parent_activity_id = None
 
-        # Priority 1: If we're in a subagent context, use the parent event from
-        # the task_delegation that spawned us (detected from database)
-        if is_subagent_session and parent_event_id_for_session:
-            parent_activity_id = parent_event_id_for_session
-            print(
-                f"Debug: Using parent_event from subagent detection: {parent_activity_id}",
-                file=sys.stderr,
-            )
-        # Priority 2: Check environment variable for cross-process parent linking
+        # Check environment variable FIRST for cross-process parent linking
         # This is set by PreToolUse hook when Task() spawns a subagent
-        else:
-            env_parent = os.environ.get("HTMLGRAPH_PARENT_EVENT") or os.environ.get(
-                "HTMLGRAPH_PARENT_QUERY_EVENT"
-            )
-            if env_parent:
-                parent_activity_id = env_parent
-            # Priority 3: 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)
+        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