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

htmlgraph/dependency_models.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Data models for dependency analytics.
 
@@ -9,7 +11,6 @@ Provides Pydantic models for dependency-aware analytics results including:
 - Work prioritization
 """
 
-from __future__ import annotations
 
 from typing import Literal
 

htmlgraph/edge_index.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Edge Index for O(1) reverse edge lookups.
 
@@ -10,7 +12,6 @@ Without this index, finding incoming edges requires scanning all nodes
 in the graph - O(V×E) complexity.
 """
 
-from __future__ import annotations
 
 from collections import defaultdict
 from collections.abc import Iterator

htmlgraph/event_log.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Event logging for HtmlGraph.
 
@@ -9,84 +11,94 @@ Design goals:
 - Deterministic serialization for rebuildable analytics indexes
 """
 
-from __future__ import annotations
 
 import json
-from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from pydantic import BaseModel, ConfigDict, Field, field_serializer, field_validator
+
 if TYPE_CHECKING:
     pass
 
 
-@dataclass(frozen=True)
-class EventRecord:
-    event_id: str
-    timestamp: datetime
-    session_id: str
-    agent: str
-    tool: str
-    summary: str
-    success: bool
-    feature_id: str | None
-    drift_score: float | None
-    start_commit: str | None
-    continued_from: str | None
-    work_type: str | None = None  # WorkType enum value
-    session_status: str | None = None
-    file_paths: list[str] | None = None
-    payload: dict[str, Any] | None = None
-    parent_session_id: str | None = None  # Link to parent session (e.g. for subagents)
+class EventRecord(BaseModel):
+    """
+    Event record for HtmlGraph tracking.
+
+    Uses Pydantic for automatic validation and serialization.
+    Immutable via ConfigDict(frozen=True).
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    event_id: str = Field(..., min_length=1, description="Unique event identifier")
+    timestamp: datetime = Field(..., description="Event timestamp")
+    session_id: str = Field(..., min_length=1, description="Session identifier")
+    agent: str = Field(..., description="Agent name (e.g., 'claude', 'gemini')")
+    tool: str = Field(..., description="Tool used (e.g., 'Bash', 'Edit', 'Read')")
+    summary: str = Field(..., description="Human-readable event summary")
+    success: bool = Field(..., description="Whether the operation succeeded")
+    feature_id: str | None = Field(None, description="Associated feature ID")
+    drift_score: float | None = Field(None, description="Context drift score")
+    start_commit: str | None = Field(None, description="Starting git commit hash")
+    continued_from: str | None = Field(
+        None, description="Previous session ID if continued"
+    )
+    work_type: str | None = Field(None, description="WorkType enum value")
+    session_status: str | None = Field(None, description="Session status")
+    file_paths: list[str] | None = Field(None, description="Files involved in event")
+    payload: dict[str, Any] | None = Field(None, description="Additional event data")
+    parent_session_id: str | None = Field(
+        None, description="Parent session ID for subagents"
+    )
+
     # Phase 1: Enhanced Event Data Schema for multi-AI delegation tracking
-    delegated_to_ai: str | None = (
-        None  # "gemini", "codex", "copilot", "claude", or None
+    delegated_to_ai: str | None = Field(
+        None, description="AI delegate: 'gemini', 'codex', 'copilot', 'claude', or None"
+    )
+    task_id: str | None = Field(
+        None, description="Unique task ID for parallel tracking"
+    )
+    task_status: str | None = Field(
+        None,
+        description="Task status: 'pending', 'running', 'completed', 'failed', 'timeout'",
+    )
+    model_selected: str | None = Field(
+        None, description="Specific model (e.g., 'gemini-2.0-flash')"
+    )
+    complexity_level: str | None = Field(
+        None, description="Complexity: 'low', 'medium', 'high', 'very-high'"
+    )
+    budget_mode: str | None = Field(
+        None, description="Budget mode: 'free', 'balanced', 'performance'"
     )
-    task_id: str | None = None  # Unique task ID for parallel tracking
-    task_status: str | None = (
-        None  # "pending", "running", "completed", "failed", "timeout"
+    execution_duration_seconds: float | None = Field(
+        None, description="Delegation execution time"
     )
-    model_selected: str | None = None  # Specific model (e.g., "gemini-2.0-flash")
-    complexity_level: str | None = None  # "low", "medium", "high", "very-high"
-    budget_mode: str | None = None  # "free", "balanced", "performance"
-    execution_duration_seconds: float | None = None  # How long delegation took
-    tokens_estimated: int | None = None  # Estimated token usage
-    tokens_actual: int | None = None  # Actual token usage
-    cost_usd: float | None = None  # Calculated cost
-    task_findings: str | None = None  # Results from delegated task
-
-    def to_json(self) -> dict[str, Any]:
-        return {
-            "event_id": self.event_id,
-            "timestamp": self.timestamp.isoformat(),
-            "session_id": self.session_id,
-            "agent": self.agent,
-            "tool": self.tool,
-            "summary": self.summary,
-            "success": self.success,
-            "feature_id": self.feature_id,
-            "work_type": self.work_type,
-            "drift_score": self.drift_score,
-            "start_commit": self.start_commit,
-            "continued_from": self.continued_from,
-            "session_status": self.session_status,
-            "file_paths": self.file_paths or [],
-            "payload": self.payload,
-            "parent_session_id": self.parent_session_id,
-            # Delegation fields
-            "delegated_to_ai": self.delegated_to_ai,
-            "task_id": self.task_id,
-            "task_status": self.task_status,
-            "model_selected": self.model_selected,
-            "complexity_level": self.complexity_level,
-            "budget_mode": self.budget_mode,
-            "execution_duration_seconds": self.execution_duration_seconds,
-            "tokens_estimated": self.tokens_estimated,
-            "tokens_actual": self.tokens_actual,
-            "cost_usd": self.cost_usd,
-            "task_findings": self.task_findings,
-        }
+    tokens_estimated: int | None = Field(None, description="Estimated token usage")
+    tokens_actual: int | None = Field(None, description="Actual token usage")
+    cost_usd: float | None = Field(None, description="Calculated cost in USD")
+    task_findings: str | None = Field(None, description="Results from delegated task")
+
+    @field_validator("event_id", "session_id")
+    @classmethod
+    def validate_non_empty_string(cls, v: str) -> str:
+        """Ensure event_id and session_id are non-empty."""
+        if not v or not v.strip():
+            raise ValueError("Field must be a non-empty string")
+        return v
+
+    @field_serializer("timestamp")
+    def serialize_timestamp(self, timestamp: datetime) -> str:
+        """Serialize timestamp to ISO format string."""
+        return timestamp.isoformat()
+
+    @field_serializer("file_paths")
+    def serialize_file_paths(self, file_paths: list[str] | None) -> list[str]:
+        """Ensure file_paths is always a list (never None) in JSON output."""
+        return file_paths or []
 
 
 class JsonlEventLog:
@@ -104,7 +116,10 @@ class JsonlEventLog:
 
     def append(self, record: EventRecord) -> Path:
         path = self.path_for_session(record.session_id)
-        line = json.dumps(record.to_json(), ensure_ascii=False, default=str) + "\n"
+        line = (
+            json.dumps(record.model_dump(mode="json"), ensure_ascii=False, default=str)
+            + "\n"
+        )
         path.parent.mkdir(parents=True, exist_ok=True)
 
         # Best-effort dedupe: some producers (e.g. git hooks) may retry or be chained.

htmlgraph/event_migration.py

@@ -1,8 +1,9 @@
+from __future__ import annotations
+
 """
 Helpers to migrate legacy session HTML activity logs to JSONL event logs.
 """
 
-from __future__ import annotations
 
 import json
 from pathlib import Path

htmlgraph/file_watcher.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 File watcher for automatic graph reloading.
 
@@ -67,7 +71,7 @@ class GraphFileHandler(FileSystemEventHandler):
 
     def _trigger_reload(self) -> None:
         """Trigger a reload after debounce delay."""
-        print(f"[FileWatcher] Reloading collection: {self.collection}")
+        logger.info(f"[FileWatcher] Reloading collection: {self.collection}")
         self.reload_callback()
 
     def _debounced_reload(self) -> None:
@@ -87,7 +91,7 @@ class GraphFileHandler(FileSystemEventHandler):
         if not self._is_relevant_file(str(event.src_path)):
             return
 
-        print(
+        logger.debug(
             f"[FileWatcher] {self.collection}: File created - {Path(str(event.src_path)).name}"
         )
         self._debounced_reload()
@@ -101,7 +105,7 @@ class GraphFileHandler(FileSystemEventHandler):
         if not self._is_relevant_file(str(event.src_path)):
             return
 
-        print(
+        logger.debug(
             f"[FileWatcher] {self.collection}: File modified - {Path(str(event.src_path)).name}"
         )
         self._debounced_reload()
@@ -115,7 +119,7 @@ class GraphFileHandler(FileSystemEventHandler):
         if not self._is_relevant_file(str(event.src_path)):
             return
 
-        print(
+        logger.debug(
             f"[FileWatcher] {self.collection}: File deleted - {Path(str(event.src_path)).name}"
         )
         self._debounced_reload()
@@ -146,7 +150,7 @@ class GraphWatcher:
 
     def start(self) -> None:
         """Start watching for file changes."""
-        print(
+        logger.info(
             f"[FileWatcher] Starting file watcher for {len(self.collections)} collections..."
         )
 
@@ -160,7 +164,7 @@ class GraphWatcher:
                 def reload() -> None:
                     graph = self.get_graph_callback(coll)
                     count = graph.reload()
-                    print(f"[FileWatcher] Reloaded {count} nodes in {coll}")
+                    logger.info(f"[FileWatcher] Reloaded {count} nodes in {coll}")
 
                 return reload
 
@@ -173,11 +177,11 @@ class GraphWatcher:
             self.observer.schedule(handler, str(collection_dir), recursive=recursive)
 
         self.observer.start()
-        print(f"[FileWatcher] Watching {self.graph_dir} for changes...")
+        logger.info(f"[FileWatcher] Watching {self.graph_dir} for changes...")
 
     def stop(self) -> None:
         """Stop watching for file changes."""
-        print("[FileWatcher] Stopping file watcher...")
+        logger.info("[FileWatcher] Stopping file watcher...")
         self.observer.stop()
         self.observer.join()
 

htmlgraph/find_api.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 BeautifulSoup-style Find API for HtmlGraph.
 
@@ -22,7 +24,6 @@ Example:
     nodes = graph.find_all(properties__effort__gt=8)
 """
 
-from __future__ import annotations
 
 import re
 from collections.abc import Callable

htmlgraph/git_events.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Git event logging for HtmlGraph.
 
@@ -10,7 +12,6 @@ Design goals:
 - Analytics-friendly: schema compatible with EventRecord/AnalyticsIndex
 """
 
-from __future__ import annotations
 
 import os
 import re
@@ -277,7 +278,10 @@ def _append_event(
         p.parent.mkdir(parents=True, exist_ok=True)
         with p.open("a", encoding="utf-8") as f:
             f.write(
-                json.dumps(record.to_json(), ensure_ascii=False, default=str) + "\n"
+                json.dumps(
+                    record.model_dump(mode="json"), ensure_ascii=False, default=str
+                )
+                + "\n"
             )
         return
 

htmlgraph/hooks/cigs_pretool_enforcer.py

@@ -1,3 +1,7 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
 """
 CIGS PreToolUse Enforcer - Enhanced Orchestrator Enforcement with Escalation
 
@@ -309,7 +313,7 @@ def enforce_cigs_pretool(tool_input: dict[str, Any]) -> dict[str, Any]:
         return enforcer.enforce(tool, params)
     except Exception as e:
         # Graceful degradation - allow on error
-        print(f"Warning: CIGS enforcement error: {e}", file=sys.stderr)
+        logger.warning(f"Warning: CIGS enforcement error: {e}")
         return {
             "hookSpecificOutput": {
                 "hookEventName": "PreToolUse",

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
 

htmlgraph/hooks/orchestrator_reflector.py

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