htmlgraph 0.26.24__py3-none-any.whl → 0.27.0__py3-none-any.whl

htmlgraph/hooks/drift_handler.py

@@ -133,7 +133,7 @@ def load_drift_config(graph_dir: Path) -> dict[str, Any]:
     Example:
         ```python
         config = load_drift_config(Path(".htmlgraph"))
-        print(f"Auto-classify threshold: {config['drift_detection']['auto_classify_threshold']}")
+        logger.info(f"Auto-classify threshold: {config['drift_detection']['auto_classify_threshold']}")
         ```
     """
     graph_dir = Path(graph_dir)
@@ -196,7 +196,7 @@ def detect_drift(
         ```python
         score, feature_id = detect_drift(activity_result, config)
         if score > config['drift_detection']['auto_classify_threshold']:
-            print(f"HIGH DRIFT: {score:.2f}")
+            logger.info(f"HIGH DRIFT: {score:.2f}")
         ```
     """
     drift_score = getattr(activity_result, "drift_score", 0.0) or 0.0
@@ -242,7 +242,7 @@ def handle_high_drift(
         ```python
         nudge = handle_high_drift(context, 0.87, queue, config)
         if nudge:
-            print(nudge)  # "HIGH DRIFT (0.87): Activity queued for classification..."
+            logger.info("%s", nudge)  # "HIGH DRIFT (0.87): Activity queued for classification..."
         ```
     """
     drift_config = config.get("drift_detection", {})

htmlgraph/hooks/event_tracker.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 HtmlGraph Event Tracker Module
 
@@ -22,7 +26,6 @@ import json
 import os
 import re
 import subprocess
-import sys
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, cast  # noqa: F401
@@ -149,10 +152,7 @@ def get_parent_user_query(db: HtmlGraphDB, session_id: str) -> str | None:
             return str(row[0])
         return None
     except Exception as e:
-        print(
-            f"Debug: Database query for UserQuery failed: {e}",
-            file=sys.stderr,
-        )
+        logger.warning(f"Debug: Database query for UserQuery failed: {e}")
         return None
 
 
@@ -194,9 +194,8 @@ def load_drift_queue(graph_dir: Path, max_age_hours: int = 48) -> dict[str, Any]
                 queue["activities"] = fresh_activities
                 save_drift_queue(graph_dir, queue)
                 removed = original_count - len(fresh_activities)
-                print(
-                    f"Cleaned {removed} stale drift queue entries (older than {max_age_hours}h)",
-                    file=sys.stderr,
+                logger.warning(
+                    f"Cleaned {removed} stale drift queue entries (older than {max_age_hours}h)"
                 )
 
             return cast(dict[Any, Any], queue)
@@ -212,7 +211,7 @@ def save_drift_queue(graph_dir: Path, queue: dict[str, Any]) -> None:
         with open(queue_path, "w") as f:
             json.dump(queue, f, indent=2, default=str)
     except Exception as e:
-        print(f"Warning: Could not save drift queue: {e}", file=sys.stderr)
+        logger.warning(f"Warning: Could not save drift queue: {e}")
 
 
 def clear_drift_queue_activities(graph_dir: Path) -> None:
@@ -236,7 +235,7 @@ def clear_drift_queue_activities(graph_dir: Path) -> None:
         with open(queue_path, "w") as f:
             json.dump(queue, f, indent=2)
     except Exception as e:
-        print(f"Warning: Could not clear drift queue: {e}", file=sys.stderr)
+        logger.warning(f"Warning: Could not clear drift queue: {e}")
 
 
 def add_to_drift_queue(
@@ -624,7 +623,7 @@ def record_event_to_sqlite(
         return None
 
     except Exception as e:
-        print(f"Warning: Could not record event to SQLite: {e}", file=sys.stderr)
+        logger.warning(f"Warning: Could not record event to SQLite: {e}")
         return None
 
 
@@ -676,7 +675,7 @@ def record_delegation_to_sqlite(
         return None
 
     except Exception as e:
-        print(f"Warning: Could not record delegation to SQLite: {e}", file=sys.stderr)
+        logger.warning(f"Warning: Could not record delegation to SQLite: {e}")
         return None
 
 
@@ -702,7 +701,7 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
     try:
         manager = SessionManager(graph_dir)
     except Exception as e:
-        print(f"Warning: Could not initialize SessionManager: {e}", file=sys.stderr)
+        logger.warning(f"Warning: Could not initialize SessionManager: {e}")
         return {"continue": True}
 
     # Initialize SQLite database for event recording
@@ -713,7 +712,7 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
 
         db = HtmlGraphDB(str(get_database_path()))
     except Exception as e:
-        print(f"Warning: Could not initialize SQLite database: {e}", file=sys.stderr)
+        logger.warning(f"Warning: Could not initialize SQLite database: {e}")
         # Continue without SQLite (graceful degradation)
 
     # Detect agent and model from environment
@@ -804,36 +803,28 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                         task_row = cursor.fetchone()
                         if task_row:
                             task_event_id_from_db = task_row[0]
-                            print(
-                                f"DEBUG Method 1 fallback: Found task_delegation={task_event_id_from_db} for {subagent_type}",
-                                file=sys.stderr,
+                            logger.warning(
+                                f"DEBUG Method 1 fallback: Found task_delegation={task_event_id_from_db} for {subagent_type}"
                             )
                         else:
-                            print(
-                                f"DEBUG Method 1: No task_delegation found for subagent_type={subagent_type}",
-                                file=sys.stderr,
+                            logger.warning(
+                                f"DEBUG Method 1: No task_delegation found for subagent_type={subagent_type}"
                             )
                     else:
-                        print(
-                            f"DEBUG Method 1: Found task_delegation={task_event_id_from_db} for subagent {subagent_type}",
-                            file=sys.stderr,
+                        logger.warning(
+                            f"DEBUG Method 1: Found task_delegation={task_event_id_from_db} for subagent {subagent_type}"
                         )
                 except Exception as e:
-                    print(
-                        f"DEBUG: Error finding task_delegation for Method 1: {e}",
-                        file=sys.stderr,
+                    logger.warning(
+                        f"DEBUG: Error finding task_delegation for Method 1: {e}"
                     )
 
-                print(
+                logger.debug(
                     f"DEBUG subagent persistence: Found current session as subagent in sessions table: "
                     f"type={subagent_type}, parent_session={parent_session_id}, task_event={task_event_id_from_db}",
-                    file=sys.stderr,
                 )
         except Exception as e:
-            print(
-                f"DEBUG: Error checking sessions table for subagent: {e}",
-                file=sys.stderr,
-            )
+            logger.warning(f"DEBUG: Error checking sessions table for subagent: {e}")
 
     # Method 2: Environment variables (for first tool call before session table is populated)
     if not subagent_type:
@@ -878,17 +869,13 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                 task_event_id_from_db = (
                     task_event_id  # Store for later use as parent_event_id
                 )
-                print(
+                logger.debug(
                     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,
+                    f"parent_event={task_event_id}"
                 )
         except Exception as e:
-            print(
-                f"DEBUG: Error detecting subagent from database: {e}",
-                file=sys.stderr,
-            )
+            logger.warning(f"DEBUG: Error detecting subagent from database: {e}")
 
     if subagent_type and parent_session_id:
         # We're in a subagent - create or get subagent session
@@ -899,9 +886,8 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
         existing = manager.session_converter.load(subagent_session_id)
         if existing:
             active_session = existing
-            print(
-                f"Debug: Using existing subagent session: {subagent_session_id}",
-                file=sys.stderr,
+            logger.warning(
+                f"Debug: Using existing subagent session: {subagent_session_id}"
             )
         else:
             # Create new subagent session with parent link
@@ -913,16 +899,12 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                     parent_session_id=parent_session_id,
                     title=f"{subagent_type.capitalize()} Subagent",
                 )
-                print(
+                logger.debug(
                     f"Debug: Created subagent session: {subagent_session_id} "
-                    f"(parent: {parent_session_id})",
-                    file=sys.stderr,
+                    f"(parent: {parent_session_id})"
                 )
             except Exception as e:
-                print(
-                    f"Warning: Could not create subagent session: {e}",
-                    file=sys.stderr,
-                )
+                logger.warning(f"Warning: Could not create subagent session: {e}")
                 return {"continue": True}
 
         # Override detected agent for subagent context
@@ -1004,9 +986,8 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
             )
         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,
+            logger.warning(
+                f"Debug: Could not insert session to SQLite (may already exist): {e}"
             )
 
     # Handle different hook types
@@ -1031,7 +1012,7 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                     feature_id=result.feature_id if result else None,
                 )
         except Exception as e:
-            print(f"Warning: Could not track stop: {e}", file=sys.stderr)
+            logger.warning(f"Warning: Could not track stop: {e}")
         return {"continue": True}
 
     elif hook_type == "UserPromptSubmit":
@@ -1063,7 +1044,7 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                 )
 
         except Exception as e:
-            print(f"Warning: Could not track query: {e}", file=sys.stderr)
+            logger.warning(f"Warning: Could not track query: {e}")
         return {"continue": True}
 
     elif hook_type == "PostToolUse":
@@ -1160,14 +1141,12 @@ def track_event(hook_type: str, hook_input: dict[str, Any]) -> dict[str, Any]:
                     task_row = cursor.fetchone()
                     if task_row:
                         parent_activity_id = task_row[0]
-                        print(
-                            f"DEBUG: Found active task_delegation={parent_activity_id} in parent_activity_id fallback",
-                            file=sys.stderr,
+                        logger.warning(
+                            f"DEBUG: Found active task_delegation={parent_activity_id} in parent_activity_id fallback"
                         )
                 except Exception as e:
-                    print(
-                        f"DEBUG: Error finding task_delegation in parent_activity_id: {e}",
-                        file=sys.stderr,
+                    logger.warning(
+                        f"DEBUG: Error finding task_delegation in parent_activity_id: {e}"
                     )
 
                 # Only if no active task found, fall back to UserQuery
@@ -1320,7 +1299,7 @@ Or manually create a work item in .htmlgraph/ (bug, feature, spike, or chore).""
                     nudge = f"Drift detected ({drift_score:.2f}): Activity may not align with {feature_id}. Consider refocusing or updating the feature."
 
         except Exception as e:
-            print(f"Warning: Could not track activity: {e}", file=sys.stderr)
+            logger.warning(f"Warning: Could not track activity: {e}")
 
         # Build response
         response: dict[str, Any] = {"continue": True}

htmlgraph/hooks/installer.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Git hooks installation and configuration management.
 """
@@ -52,7 +56,7 @@ class HookConfig:
                 user_config = json.load(f)
                 self.config.update(user_config)
         except Exception as e:
-            print(f"Warning: Failed to load hook config: {e}")
+            logger.info(f"Warning: Failed to load hook config: {e}")
 
     def save(self) -> None:
         """Save configuration to file."""

htmlgraph/hooks/orchestrator.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Orchestrator Enforcement Module
 
@@ -94,6 +98,73 @@ def load_tool_history(session_id: str) -> list[dict]:
         return []
 
 
+def record_tool_event(tool_name: str, session_id: str) -> None:
+    """
+    Record a tool event to the database for history tracking.
+
+    This is called at the end of PreToolUse hook execution to track
+    tool usage patterns for sequence detection.
+
+    Args:
+        tool_name: Name of the tool being called
+        session_id: Session identifier for isolation
+    """
+    try:
+        import datetime
+        import uuid
+
+        from htmlgraph.db.schema import HtmlGraphDB
+
+        # Find database path
+        cwd = Path.cwd()
+        graph_dir = cwd / ".htmlgraph"
+        if not graph_dir.exists():
+            for parent in [cwd.parent, cwd.parent.parent, cwd.parent.parent.parent]:
+                candidate = parent / ".htmlgraph"
+                if candidate.exists():
+                    graph_dir = candidate
+                    break
+
+        if not graph_dir.exists():
+            return
+
+        db_path = graph_dir / "htmlgraph.db"
+        db = HtmlGraphDB(str(db_path))
+        if db.connection is None:
+            return
+
+        cursor = db.connection.cursor()
+        timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+        # Ensure session exists (required by FK constraint)
+        cursor.execute(
+            """
+            INSERT OR IGNORE INTO sessions (session_id, agent_assigned, created_at, status)
+            VALUES (?, ?, ?, ?)
+        """,
+            (session_id, "orchestrator-hook", timestamp, "active"),
+        )
+
+        # Record the tool event using the actual schema
+        # Schema has: event_id, agent_id, event_type, timestamp, tool_name, session_id, etc.
+        event_id = str(uuid.uuid4())
+        agent_id = "orchestrator-hook"  # Identifier for the hook
+
+        cursor.execute(
+            """
+            INSERT INTO agent_events (event_id, agent_id, event_type, timestamp, tool_name, session_id)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """,
+            (event_id, agent_id, "tool_call", timestamp, tool_name, session_id),
+        )
+
+        db.connection.commit()
+        db.disconnect()
+    except Exception:
+        # Graceful degradation - don't fail hook on recording error
+        pass
+
+
 def is_allowed_orchestrator_operation(
     tool: str, params: dict[str, Any], session_id: str = "unknown"
 ) -> tuple[bool, str, str]:
@@ -402,6 +473,7 @@ def enforce_orchestrator_mode(
     # Check if this is a subagent context - subagents have unrestricted tool access
     if is_subagent_context():
         return {
+            "continue": True,
             "hookSpecificOutput": {
                 "hookEventName": "PreToolUse",
                 "permissionDecision": "allow",
@@ -425,18 +497,14 @@ def enforce_orchestrator_mode(
         manager = OrchestratorModeManager(graph_dir)
 
         if not manager.is_enabled():
-            # Mode not active, allow everything
-            return {
-                "hookSpecificOutput": {
-                    "hookEventName": "PreToolUse",
-                    "permissionDecision": "allow",
-                },
-            }
+            # Mode not active, allow everything with no additional output
+            return {"continue": True}
 
         enforcement_level = manager.get_enforcement_level()
     except Exception:
         # If we can't check mode, fail open (allow)
         return {
+            "continue": True,
             "hookSpecificOutput": {
                 "hookEventName": "PreToolUse",
                 "permissionDecision": "allow",
@@ -467,6 +535,7 @@ def enforce_orchestrator_mode(
             )
 
             return {
+                "continue": False,
                 "hookSpecificOutput": {
                     "hookEventName": "PreToolUse",
                     "permissionDecision": "deny",
@@ -491,6 +560,7 @@ def enforce_orchestrator_mode(
         ):
             # Provide guidance even when allowing
             return {
+                "continue": True,
                 "hookSpecificOutput": {
                     "hookEventName": "PreToolUse",
                     "permissionDecision": "allow",
@@ -498,6 +568,7 @@ def enforce_orchestrator_mode(
                 },
             }
         return {
+            "continue": True,
             "hookSpecificOutput": {
                 "hookEventName": "PreToolUse",
                 "permissionDecision": "allow",
@@ -513,8 +584,8 @@ def enforce_orchestrator_mode(
     suggestion = create_task_suggestion(tool, params)
 
     if enforcement_level == "strict":
-        # STRICT mode - loud warning with violation count
-        error_message = (
+        # STRICT mode - advisory warning with violation count (does not block)
+        warning_message = (
             f"🚫 ORCHESTRATOR MODE VIOLATION ({violations}/{circuit_breaker_threshold}): {reason}\n\n"
             f"⚠️  WARNING: Direct operations waste context and break delegation pattern!\n\n"
             f"Suggested delegation:\n"
@@ -523,23 +594,25 @@ def enforce_orchestrator_mode(
 
         # Add circuit breaker warning if approaching threshold
         if violations >= circuit_breaker_threshold:
-            error_message += (
+            warning_message += (
                 "🚨 CIRCUIT BREAKER TRIGGERED - Further violations will be blocked!\n\n"
                 "Reset with: uv run htmlgraph orchestrator reset-violations\n"
             )
         elif violations == circuit_breaker_threshold - 1:
-            error_message += "⚠️  Next violation will trigger circuit breaker!\n\n"
+            warning_message += "⚠️  Next violation will trigger circuit breaker!\n\n"
 
-        error_message += (
+        warning_message += (
             "See ORCHESTRATOR_DIRECTIVES in session context for HtmlGraph delegation pattern.\n"
             "To disable orchestrator mode: uv run htmlgraph orchestrator disable"
         )
 
+        # Advisory-only: allow operation but provide warning
         return {
+            "continue": True,
             "hookSpecificOutput": {
                 "hookEventName": "PreToolUse",
-                "permissionDecision": "deny",
-                "permissionDecisionReason": error_message,
+                "permissionDecision": "allow",
+                "additionalContext": warning_message,
             },
         }
     else:
@@ -549,6 +622,7 @@ def enforce_orchestrator_mode(
         )
 
         return {
+            "continue": True,
             "hookSpecificOutput": {
                 "hookEventName": "PreToolUse",
                 "permissionDecision": "allow",
@@ -592,5 +666,9 @@ def main() -> None:
     # Enforce orchestrator mode with session_id for history lookup
     response = enforce_orchestrator_mode(tool_name, tool_input, session_id)
 
+    # Record tool event to database for history tracking
+    # This allows subsequent calls to detect patterns (e.g., multiple Reads)
+    record_tool_event(tool_name, session_id)
+
     # Output JSON response
     print(json.dumps(response))

htmlgraph/hooks/orchestrator_reflector.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Orchestrator Reflection Module
 

htmlgraph/hooks/post_tool_use_failure.py

@@ -1,4 +1,8 @@
 #!/usr/bin/env python3
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 PostToolUseFailure Hook - Automatic Error Tracking and Debug Spike Creation
 
@@ -109,7 +113,7 @@ def run(hook_input: dict[str, Any]) -> dict[str, Any]:
 
     except Exception as e:
         # Never raise - log and continue
-        print(f"PostToolUseFailure hook error: {e}", file=sys.stderr)
+        logger.warning(f"PostToolUseFailure hook error: {e}")
         return {"continue": True}
 
 
@@ -238,10 +242,10 @@ def create_debug_spike(tool: str, error: str, log_path: Path) -> None:
         with open(spike_marker, "w") as f:
             json.dump(existing_spikes, f, indent=2)
 
-        print(f"Created debug spike: {spike.id}", file=sys.stderr)
+        logger.warning(f"Created debug spike: {spike.id}")
 
     except Exception as e:
-        print(f"Failed to create debug spike: {e}", file=sys.stderr)
+        logger.warning(f"Failed to create debug spike: {e}")
 
 
 def main() -> None:

htmlgraph/hooks/posttooluse.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Unified PostToolUse Hook - Parallel Execution of Multiple Tasks
 

htmlgraph/hooks/prompt_analyzer.py

@@ -259,7 +259,7 @@ def get_session_violation_count(context: HookContext) -> tuple[int, int]:
     Example:
         >>> violation_count, waste_tokens = get_session_violation_count(context)
         >>> if violation_count > 0:
-        ...     print(f"Violations this session: {violation_count}")
+        ...     logger.info(f"Violations this session: {violation_count}")
     """
     try:
         from htmlgraph.cigs import ViolationTracker
@@ -289,7 +289,7 @@ def get_active_work_item(context: HookContext) -> dict[str, Any] | None:
     Example:
         >>> active = get_active_work_item(context)
         >>> if active and active['type'] == 'feature':
-        ...     print(f"Active feature: {active['title']}")
+        ...     logger.info(f"Active feature: {active['title']}")
     """
     try:
         from htmlgraph import SDK
@@ -326,7 +326,7 @@ def generate_guidance(
         >>> classification = classify_prompt("Implement new API endpoint")
         >>> guidance = generate_guidance(classification, None, prompt)
         >>> if guidance:
-        ...     print(guidance)
+        ...     logger.info("%s", guidance)
     """
 
     # If continuing and has active work, no guidance needed
@@ -467,7 +467,7 @@ def generate_cigs_guidance(
         >>> cigs = classify_cigs_intent("Search for all error handling")
         >>> guidance = generate_cigs_guidance(cigs, 0, 0)
         >>> if guidance:
-        ...     print(guidance)
+        ...     logger.info("%s", guidance)
     """
     imperatives = []
 
@@ -544,7 +544,7 @@ def create_user_query_event(context: HookContext, prompt: str) -> str | None:
         >>> context = HookContext.from_input(hook_input)
         >>> event_id = create_user_query_event(context, "Implement feature X")
         >>> if event_id:
-        ...     print(f"Created event: {event_id}")
+        ...     logger.info(f"Created event: {event_id}")
     """
     try:
         session_id = context.session_id

htmlgraph/hooks/session_handler.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 HtmlGraph Session Handler Module
 
@@ -24,7 +26,6 @@ Public API:
         Check if HtmlGraph has updates available
 """
 
-from __future__ import annotations
 
 import json
 import logging
@@ -185,7 +186,9 @@ def handle_session_start(context: HookContext, session: Any | None) -> dict[str,
 
 {feature_list}
 
-Activity will be attributed to these features based on file patterns and keywords."""
+Activity will be attributed to these features based on file patterns and keywords.
+
+**To view all work and progress:** `htmlgraph snapshot --summary`"""
             output["hookSpecificOutput"]["sessionFeatureContext"] = context_str
             context.log("info", f"Loaded {len(active_features)} active features")
 

htmlgraph/hooks/session_summary.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Session Summary Module - CIGS Integration
 
@@ -353,7 +357,7 @@ class CIGSSessionSummarizer:
             with open(summary_file, "w") as f:
                 json.dump(summary_data, f, indent=2, default=str)
         except Exception as e:
-            print(f"Warning: Failed to persist summary: {e}", file=sys.stderr)
+            logger.warning(f"Warning: Failed to persist summary: {e}")
 
 
 def main() -> None:
@@ -387,5 +391,5 @@ def main() -> None:
         result = summarizer.summarize(session_id)
         print(json.dumps(result))
     except Exception as e:
-        print(f"Warning: Could not generate CIGS summary: {e}", file=sys.stderr)
+        logger.warning(f"Warning: Could not generate CIGS summary: {e}")
         print(json.dumps({"continue": True}))

htmlgraph/hooks/validator.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 Work Validation Module for HtmlGraph Hooks
 
@@ -22,9 +26,9 @@ Example:
     result = validate_tool_call("Edit", {"file_path": "test.py"}, config, history)
 
     if result["decision"] == "block":
-        print(result["reason"])
+        logger.debug("Validation reason: %s", result["reason"])
     elif "guidance" in result:
-        print(result["guidance"])
+        logger.debug("Validation guidance: %s", result["guidance"])
 """
 
 import json
@@ -448,9 +452,9 @@ def validate_tool_call(
         history = load_tool_history(session_id)
         result = validate_tool_call("Edit", {"file_path": "test.py"}, config, history)
         if result["decision"] == "block":
-            print(result["reason"])
+            logger.debug("Validation reason: %s", result["reason"])
         elif "guidance" in result:
-            print(result["guidance"])
+            logger.debug("Validation guidance: %s", result["guidance"])
     """
     # Check if this is a subagent context - subagents have unrestricted tool access
     if is_subagent_context():

htmlgraph/ids.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Hash-based ID generation for HtmlGraph.
 
@@ -15,7 +17,6 @@ collision probability is effectively zero even with thousands
 of concurrent agents creating tasks simultaneously.
 """
 
-from __future__ import annotations
 
 import hashlib
 import os