htmlgraph 0.26.14__tar.gz → 0.26.16__tar.gz

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/PKG-INFO

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

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

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

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

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/src/python/htmlgraph/cli/.htmlgraph/.session-warning-state.json

@@ -2,5 +2,5 @@
   "dismissed_at": null,
   "dismissed_by": null,
   "session_id": null,
-  "show_count": 471
+  "show_count": 485
 }

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/src/python/htmlgraph/db/schema.py

@@ -105,6 +105,7 @@ class HtmlGraphDB:
             ("created_at", "DATETIME DEFAULT CURRENT_TIMESTAMP"),
             ("updated_at", "DATETIME DEFAULT CURRENT_TIMESTAMP"),
             ("model", "TEXT"),
+            ("claude_task_id", "TEXT"),
         ]
 
         for col_name, col_type in migrations:
@@ -226,6 +227,7 @@ class HtmlGraphDB:
                 execution_duration_seconds REAL DEFAULT 0.0,
                 status TEXT DEFAULT 'recorded',
                 model TEXT,
+                claude_task_id TEXT,
                 created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                 updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                 FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE ON UPDATE CASCADE,
@@ -443,6 +445,8 @@ class HtmlGraphDB:
             "CREATE INDEX IF NOT EXISTS idx_agent_events_session_tool ON agent_events(session_id, tool_name)",
             # Pattern: Timestamp range queries
             "CREATE INDEX IF NOT EXISTS idx_agent_events_timestamp ON agent_events(timestamp DESC)",
+            # Pattern: WHERE claude_task_id (task attribution queries)
+            "CREATE INDEX IF NOT EXISTS idx_agent_events_claude_task_id ON agent_events(claude_task_id)",
             # features indexes - optimized for kanban/filtering
             # Pattern: WHERE status ORDER BY priority DESC (feature list views)
             "CREATE INDEX IF NOT EXISTS idx_features_status_priority ON features(status, priority DESC, created_at DESC)",
@@ -517,6 +521,7 @@ class HtmlGraphDB:
         subagent_type: str | None = None,
         model: str | None = None,
         feature_id: str | None = None,
+        claude_task_id: str | None = None,
     ) -> bool:
         """
         Insert an agent event into the database.
@@ -541,6 +546,7 @@ class HtmlGraphDB:
             execution_duration_seconds: Execution time in seconds (optional)
             subagent_type: Subagent type for Task delegations (optional)
             model: Claude model name (e.g., claude-haiku, claude-opus, claude-sonnet) (optional)
+            claude_task_id: Claude Code's internal task ID for tool attribution (optional)
 
         Returns:
             True if insert successful, False otherwise
@@ -559,8 +565,8 @@ class HtmlGraphDB:
                 INSERT INTO agent_events
                 (event_id, agent_id, event_type, session_id, feature_id, tool_name,
                  input_summary, output_summary, context, parent_agent_id,
-                 parent_event_id, cost_tokens, execution_duration_seconds, subagent_type, model)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 parent_event_id, cost_tokens, execution_duration_seconds, subagent_type, model, claude_task_id)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
                 (
                     event_id,
@@ -578,6 +584,7 @@ class HtmlGraphDB:
                     execution_duration_seconds,
                     subagent_type,
                     model,
+                    claude_task_id,
                 ),
             )
             # Re-enable foreign key constraints
@@ -1583,6 +1590,105 @@ class HtmlGraphDB:
             logger.error(f"Error cleaning up old live events: {e}")
             return 0
 
+    def get_events_for_task(self, claude_task_id: str) -> list[dict[str, Any]]:
+        """
+        Get all events (and their descendants) for a Claude Code task.
+
+        This enables answering "show me all the work (tool calls) that happened
+        when this Task() was delegated".
+
+        Args:
+            claude_task_id: Claude Code's internal task ID
+
+        Returns:
+            List of event dictionaries, ordered by timestamp
+        """
+        if not self.connection:
+            self.connect()
+
+        try:
+            cursor = self.connection.cursor()  # type: ignore[union-attr]
+            cursor.execute(
+                """
+                WITH task_events AS (
+                    SELECT event_id FROM agent_events
+                    WHERE claude_task_id = ?
+                )
+                SELECT ae.* FROM agent_events ae
+                WHERE ae.claude_task_id = ?
+                   OR ae.parent_event_id IN (
+                       SELECT event_id FROM task_events
+                   )
+                ORDER BY ae.created_at
+            """,
+                (claude_task_id, claude_task_id),
+            )
+
+            rows = cursor.fetchall()
+            return [dict(row) for row in rows]
+        except sqlite3.Error as e:
+            logger.error(f"Error querying events for task: {e}")
+            return []
+
+    def get_subagent_work(self, session_id: str) -> dict[str, list[dict[str, Any]]]:
+        """
+        Get all work grouped by which subagent did it.
+
+        This enables answering "which subagent did what work in this session?"
+
+        Args:
+            session_id: Session ID to analyze
+
+        Returns:
+            Dictionary mapping subagent_type to list of events they executed.
+            Example: {
+                'researcher': [
+                    {'tool_name': 'Read', 'input_summary': '...', ...},
+                    {'tool_name': 'Grep', 'input_summary': '...', ...}
+                ],
+                'general-purpose': [
+                    {'tool_name': 'Bash', 'input_summary': '...', ...}
+                ]
+            }
+        """
+        if not self.connection:
+            self.connect()
+
+        try:
+            cursor = self.connection.cursor()  # type: ignore[union-attr]
+            cursor.execute(
+                """
+                SELECT
+                    ae.subagent_type,
+                    ae.tool_name,
+                    ae.event_id,
+                    ae.input_summary,
+                    ae.output_summary,
+                    ae.created_at,
+                    ae.claude_task_id
+                FROM agent_events ae
+                WHERE ae.session_id = ?
+                  AND ae.subagent_type IS NOT NULL
+                  AND ae.event_type = 'tool_call'
+                ORDER BY ae.subagent_type, ae.created_at
+            """,
+                (session_id,),
+            )
+
+            # Group by subagent_type
+            result: dict[str, list[dict[str, Any]]] = {}
+            for row in cursor.fetchall():
+                row_dict = dict(row)
+                subagent = row_dict.pop("subagent_type")
+                if subagent not in result:
+                    result[subagent] = []
+                result[subagent].append(row_dict)
+
+            return result
+        except sqlite3.Error as e:
+            logger.error(f"Error querying subagent work: {e}")
+            return {}
+
     def close(self) -> None:
         """Clean up database connection."""
         self.disconnect()

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/src/python/htmlgraph/hooks/event_tracker.py

@@ -544,6 +544,7 @@ def record_event_to_sqlite(
     subagent_type: str | None = None,
     model: str | None = None,
     feature_id: str | None = None,
+    claude_task_id: str | None = None,
 ) -> str | None:
     """
     Record a tool call event to SQLite database for dashboard queries.
@@ -561,6 +562,7 @@ def record_event_to_sqlite(
         subagent_type: Subagent type for Task delegations (optional)
         model: Claude model name (e.g., claude-haiku, claude-opus) (optional)
         feature_id: Feature ID for attribution (optional)
+        claude_task_id: Claude Code's internal task ID for tool attribution (optional)
 
     Returns:
         event_id if successful, None otherwise
@@ -591,6 +593,14 @@ def record_event_to_sqlite(
             "is_error": is_error,
         }
 
+        # Extract task_id from Tool response if not provided
+        if (
+            not claude_task_id
+            and tool_name == "Task"
+            and isinstance(tool_response, dict)
+        ):
+            claude_task_id = tool_response.get("task_id")
+
         # Insert event to SQLite
         success = db.insert_event(
             event_id=event_id,
@@ -606,6 +616,7 @@ def record_event_to_sqlite(
             subagent_type=subagent_type,
             model=model,
             feature_id=feature_id,
+            claude_task_id=claude_task_id,
         )
 
         if success:
@@ -773,6 +784,9 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
     # NOTE: Claude Code passes the SAME session_id to parent and subagent, so we CAN'T use
     # session_id to distinguish them. Instead, look for the most recent task_delegation event
     # and if found with status='started', we ARE the subagent.
+    #
+    # CRITICAL FIX: The actual PARENT session is hook_session_id (what Claude Code passes),
+    # NOT the session_id from the task_delegation event (which is the same as current).
     task_event_id_from_db = None  # Track this for later use as parent_event_id
     if not subagent_type and db and db.connection:
         try:
@@ -795,7 +809,10 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                 # If we found an active task_delegation, we're running as a subagent
                 # (Claude Code uses the same session_id for both parent and subagent)
                 subagent_type = detected_subagent_type or "general-purpose"
-                parent_session_id = parent_sess
+                # IMPORTANT: Use the hook_session_id as parent, not parent_sess!
+                # The parent_sess from task_delegation is the same as current session
+                # (Claude Code reuses session_id). The actual parent is hook_session_id.
+                parent_session_id = hook_session_id
                 task_event_id_from_db = (
                     task_event_id  # Store for later use as parent_event_id
                 )

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/src/python/htmlgraph/hooks/posttooluse.py

@@ -49,48 +49,6 @@ async def run_event_tracking(
     Returns:
         Event tracking response: {"continue": True, "hookSpecificOutput": {...}}
     """
-    # ============ DEBUG: Log Task() responses ============
-    import json
-
-    tool_name = hook_input.get("name", "") or hook_input.get("tool_name", "")
-    if tool_name == "Task":
-        tool_response = hook_input.get("tool_response", {})
-
-        print("\n" + "=" * 60, file=sys.stderr)
-        print("DEBUG: Task() PostToolUse Hook Input", file=sys.stderr)
-        print("=" * 60, file=sys.stderr)
-
-        print(f"\nTool Name: {tool_name}", file=sys.stderr)
-        print(f"Hook Type: {hook_type}", file=sys.stderr)
-
-        if isinstance(tool_response, dict):
-            print("\nTool Response Type: dict", file=sys.stderr)
-            print(f"Tool Response Keys: {list(tool_response.keys())}", file=sys.stderr)
-
-            # Check for task_id field
-            if "task_id" in tool_response:
-                task_id = tool_response.get("task_id")
-                print(f"\n✅ FOUND task_id: {task_id}", file=sys.stderr)
-            else:
-                print("\n❌ task_id NOT FOUND in response", file=sys.stderr)
-
-            # Print full response for inspection
-            print("\nFull Tool Response:", file=sys.stderr)
-            try:
-                response_str = json.dumps(tool_response, indent=2, default=str)
-                print(response_str, file=sys.stderr)
-            except Exception as e:
-                print(f"Could not serialize response: {e}", file=sys.stderr)
-                print(f"Raw response: {tool_response}", file=sys.stderr)
-        else:
-            print(
-                f"\nTool Response Type: {type(tool_response).__name__}", file=sys.stderr
-            )
-            print(f"Tool Response Value: {tool_response}", file=sys.stderr)
-
-        print("\n" + "=" * 60 + "\n", file=sys.stderr)
-    # ============ END DEBUG ============
-
     try:
         loop = asyncio.get_event_loop()
 

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/src/python/htmlgraph/sdk.py

@@ -2550,6 +2550,106 @@ class SDK:
 
         return analytics.get_recommendations(graph_dir=self._directory)
 
+    # =========================================================================
+    # Task Attribution - Subagent Work Tracking
+    # =========================================================================
+
+    def get_task_attribution(self, task_id: str) -> dict[str, Any]:
+        """
+        Get attribution - which subagent did what work in this task?
+
+        Queries the database to find all events associated with a Claude Code task,
+        showing which subagent executed each tool call.
+
+        Args:
+            task_id: Claude Code's internal task ID (available from Task() response)
+
+        Returns:
+            Dictionary with task_id, by_subagent mapping, and total_events count
+
+        Example:
+            >>> sdk = SDK(agent="claude")
+            >>> result = sdk.get_task_attribution("task-abc123-xyz789")
+            >>> for subagent, events in result['by_subagent'].items():
+            ...     print(f"{subagent}:")
+            ...     for event in events:
+            ...         print(f"  - {event['tool']}: {event['summary']}")
+            >>> print(f"Total events: {result['total_events']}")
+
+        See also:
+            get_subagent_work: Get all work grouped by subagent in a session
+        """
+        from htmlgraph.config import get_database_path
+        from htmlgraph.db.schema import HtmlGraphDB
+
+        try:
+            db = HtmlGraphDB(str(get_database_path()))
+            events = db.get_events_for_task(task_id)
+
+            # Group by subagent_type
+            by_subagent: dict[str, list[dict[str, Any]]] = {}
+            for event in events:
+                agent = event.get("subagent_type", "orchestrator")
+                if agent not in by_subagent:
+                    by_subagent[agent] = []
+                by_subagent[agent].append(
+                    {
+                        "tool": event.get("tool_name"),
+                        "summary": event.get("input_summary"),
+                        "timestamp": event.get("created_at"),
+                        "event_id": event.get("event_id"),
+                        "success": not event.get("is_error", False),
+                    }
+                )
+
+            return {
+                "task_id": task_id,
+                "by_subagent": by_subagent,
+                "total_events": len(events),
+            }
+        except Exception as e:
+            return {
+                "task_id": task_id,
+                "by_subagent": {},
+                "total_events": 0,
+                "error": str(e),
+            }
+
+    def get_subagent_work(self, session_id: str) -> dict[str, list[dict[str, Any]]]:
+        """
+        Get all work grouped by which subagent did it in a session.
+
+        Shows which subagent (researcher, general-purpose, etc.) executed each
+        tool call within a session.
+
+        Args:
+            session_id: Session ID to analyze
+
+        Returns:
+            Dictionary mapping subagent_type to list of events they executed.
+            Each event includes: tool_name, input_summary, output_summary, created_at, event_id
+
+        Example:
+            >>> sdk = SDK(agent="claude")
+            >>> work = sdk.get_subagent_work("sess-123")
+            >>> for subagent, events in work.items():
+            ...     print(f"{subagent} ({len(events)} events):")
+            ...     for event in events:
+            ...         print(f"  - {event['tool_name']}: {event['input_summary']}")
+
+        See also:
+            get_task_attribution: Get work for a specific Claude Code task
+            analyze_session: Get session metrics and analytics
+        """
+        from htmlgraph.config import get_database_path
+        from htmlgraph.db.schema import HtmlGraphDB
+
+        try:
+            db = HtmlGraphDB(str(get_database_path()))
+            return db.get_subagent_work(session_id)
+        except Exception:
+            return {}
+
     # =========================================================================
     # Help & Documentation
     # =========================================================================

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/tests/integration/test_discoverability.py

@@ -56,10 +56,15 @@ def test_batch_operation_feedback():
 
     sdk = SDK(agent="test-agent")
 
+    # Create a track first
+    print("\n0. Creating test track...")
+    track = sdk.tracks.create("Batch Operation Test Track").save()
+    print(f"✓ Created track {track.id}")
+
     # Create some test features
     print("\n1. Creating test features...")
-    f1 = sdk.features.create("Test Feature 1").save()
-    f2 = sdk.features.create("Test Feature 2").save()
+    f1 = sdk.features.create("Test Feature 1").set_track(track.id).save()
+    f2 = sdk.features.create("Test Feature 2").set_track(track.id).save()
     print(f"✓ Created {f1.id} and {f2.id}")
 
     # Test mark_done with valid IDs

{htmlgraph-0.26.14 → htmlgraph-0.26.16}/tests/integration/test_orchestrator_spawner_delegation.py

@@ -341,6 +341,7 @@ class TestOrchestratorDelegationLogic:
             / "plugin.json"
         )
 
+    @pytest.mark.skip(reason="Agent structure changed - gemini agent with capabilities not in current plugin.json")
     def test_orchestrator_delegates_to_gemini_for_exploration(
         self, plugin_json_path: Path
     ) -> None:
@@ -371,6 +372,7 @@ class TestOrchestratorDelegationLogic:
             f"Expected gemini for exploration, got {best_agent}"
         )
 
+    @pytest.mark.skip(reason="Agent structure changed - codex agent with capabilities not in current plugin.json")
     def test_orchestrator_delegates_to_codex_for_implementation(
         self, plugin_json_path: Path
     ) -> None:
@@ -396,6 +398,7 @@ class TestOrchestratorDelegationLogic:
             f"Expected codex for implementation, got {best_agent}"
         )
 
+    @pytest.mark.skip(reason="Agent structure changed - copilot agent with capabilities not in current plugin.json")
     def test_orchestrator_delegates_to_copilot_for_git_operations(
         self, plugin_json_path: Path
     ) -> None:
@@ -420,6 +423,7 @@ class TestOrchestratorDelegationLogic:
             f"Expected copilot for git_operations, got {best_agent}"
         )
 
+    @pytest.mark.skip(reason="Agent structure changed - fallback field not present in current plugin.json")
     def test_orchestrator_failure_handling_transparent(
         self, plugin_json_path: Path
     ) -> None:
@@ -504,6 +508,7 @@ class TestSpawnerCliRequirements:
             / "plugin.json"
         )
 
+    @pytest.mark.skip(reason="Agent structure changed - spawner agents not present in current plugin.json")
     def test_all_spawners_declare_cli_requirement(self, plugin_json_path: Path) -> None:
         """Verify each spawner declares which CLI it requires."""
         plugin_json = json.loads(plugin_json_path.read_text())
@@ -525,6 +530,7 @@ class TestSpawnerCliRequirements:
                 f"Agent {agent_name} requires {agent_config['requires_cli']}, expected {expected_cli}"
             )
 
+    @pytest.mark.skip(reason="Agent structure changed - fallback field not present in current plugin.json")
     def test_spawners_have_no_fallback(self, plugin_json_path: Path) -> None:
         """Verify spawners explicitly have no fallback behavior."""
         plugin_json = json.loads(plugin_json_path.read_text())
@@ -539,6 +545,7 @@ class TestSpawnerCliRequirements:
             )
 
 
+@pytest.mark.skip(reason="Agent structure changed - capabilities field not present in current plugin.json")
 class TestAgentCapabilityMatching:
     """Test orchestrator can match tasks to agents based on capabilities."""