htmlgraph 0.27.6__py3-none-any.whl → 0.28.0__py3-none-any.whl

htmlgraph/session_manager.py

@@ -2801,3 +2801,73 @@ class SessionManager:
             "has_thinking_traces": transcript.has_thinking_traces(),
             "entry_count": len(transcript.entries),
         }
+
+    # =========================================================================
+    # Session Context Builder - Delegates to SessionContextBuilder
+    # =========================================================================
+
+    def get_version_status(self) -> dict[str, Any]:
+        """
+        Check installed htmlgraph version against latest on PyPI.
+
+        Returns:
+            Dict with installed_version, latest_version, is_outdated
+        """
+        from htmlgraph.session_context import VersionChecker
+
+        return VersionChecker.get_version_status()
+
+    def initialize_git_hooks(self, project_dir: str | Path) -> bool:
+        """
+        Install pre-commit hooks if not already installed.
+
+        Args:
+            project_dir: Path to the project root
+
+        Returns:
+            True if hooks were installed or already exist
+        """
+        from htmlgraph.session_context import GitHooksInstaller
+
+        return GitHooksInstaller.install(project_dir)
+
+    def get_start_context(
+        self,
+        session_id: str,
+        project_dir: str | Path | None = None,
+        compute_async: bool = True,
+    ) -> str:
+        """
+        Build complete session start context for AI agents.
+
+        This is the primary method for generating the full context string
+        that gets injected via additionalContext in the SessionStart hook.
+
+        Args:
+            session_id: Current session ID
+            project_dir: Project root directory (uses graph_dir parent if not provided)
+            compute_async: Use parallel async operations for performance
+
+        Returns:
+            Complete formatted Markdown context string
+        """
+        from htmlgraph.session_context import SessionContextBuilder
+
+        if project_dir is None:
+            project_dir = self.graph_dir.parent
+
+        builder = SessionContextBuilder(self.graph_dir, project_dir)
+        return builder.build(session_id=session_id, compute_async=compute_async)
+
+    def detect_feature_conflicts(self) -> list[dict[str, Any]]:
+        """
+        Detect features being worked on by multiple agents simultaneously.
+
+        Returns:
+            List of conflict dicts with feature_id, title, agents
+        """
+        from htmlgraph.session_context import SessionContextBuilder
+
+        project_dir = self.graph_dir.parent
+        builder = SessionContextBuilder(self.graph_dir, project_dir)
+        return builder.detect_feature_conflicts()

htmlgraph/sync/__init__.py

@@ -0,0 +1,21 @@
+"""
+Git-based synchronization for multi-device continuity.
+
+Enables automatic sync of .htmlgraph/ directory across devices via Git.
+"""
+
+from .git_sync import (
+    GitSyncManager,
+    SyncConfig,
+    SyncResult,
+    SyncStatus,
+    SyncStrategy,
+)
+
+__all__ = [
+    "GitSyncManager",
+    "SyncConfig",
+    "SyncStrategy",
+    "SyncStatus",
+    "SyncResult",
+]

htmlgraph/sync/git_sync.py

@@ -0,0 +1,458 @@
+"""
+Git-based synchronization manager for multi-device continuity.
+
+Provides automatic push/pull of .htmlgraph/ directory with conflict resolution.
+"""
+
+import asyncio
+import logging
+import socket
+import subprocess
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class SyncStrategy(str, Enum):
+    """Conflict resolution strategies."""
+
+    AUTO_MERGE = "auto_merge"  # Let git auto-merge
+    ABORT_ON_CONFLICT = "abort_on_conflict"  # Fail if conflicts
+    OURS = "ours"  # Keep local on conflict
+    THEIRS = "theirs"  # Take remote on conflict
+
+
+class SyncStatus(str, Enum):
+    """Current sync operation status."""
+
+    IDLE = "idle"
+    PUSHING = "pushing"
+    PULLING = "pulling"
+    CONFLICT = "conflict"
+    ERROR = "error"
+    SUCCESS = "success"
+
+
+@dataclass
+class SyncConfig:
+    """Configuration for Git sync."""
+
+    push_interval_seconds: int = 300  # 5 min
+    pull_interval_seconds: int = 60  # 1 min
+    remote_name: str = "origin"
+    branch_name: str = "main"
+    conflict_strategy: SyncStrategy = SyncStrategy.AUTO_MERGE
+    auto_stash: bool = True  # Stash uncommitted changes before pull
+    sync_path: str = ".htmlgraph"  # Path to sync within repo
+
+
+@dataclass
+class SyncResult:
+    """Result of a sync operation."""
+
+    status: SyncStatus
+    operation: str  # "push" or "pull"
+    timestamp: datetime
+    files_changed: int = 0
+    conflicts: list[str] = field(default_factory=list)
+    message: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "status": self.status.value,
+            "operation": self.operation,
+            "timestamp": self.timestamp.isoformat(),
+            "files_changed": self.files_changed,
+            "conflicts": self.conflicts,
+            "message": self.message,
+        }
+
+
+class GitSyncManager:
+    """Manages automatic Git sync of .htmlgraph/ directory."""
+
+    def __init__(self, repo_root: str, config: SyncConfig | None = None):
+        """
+        Initialize Git sync manager.
+
+        Args:
+            repo_root: Path to git repository root
+            config: Sync configuration (uses defaults if None)
+        """
+        self.repo_root = Path(repo_root)
+        self.htmlgraph_dir = self.repo_root / ".htmlgraph"
+        self.config = config or SyncConfig()
+        self.last_push: datetime | None = None
+        self.last_pull: datetime | None = None
+        self.status = SyncStatus.IDLE
+        self.sync_history: list[SyncResult] = []
+        self._running = False
+        self._push_task: asyncio.Task | None = None
+        self._pull_task: asyncio.Task | None = None
+
+    async def start_background_sync(self) -> None:
+        """Start background sync tasks."""
+        if self._running:
+            logger.warning("Background sync already running")
+            return
+
+        logger.info("Starting background sync service...")
+        self._running = True
+
+        # Create sync tasks
+        self._push_task = asyncio.create_task(self._push_loop())
+        self._pull_task = asyncio.create_task(self._pull_loop())
+
+        # Wait for both tasks
+        try:
+            await asyncio.gather(self._push_task, self._pull_task)
+        except asyncio.CancelledError:
+            logger.info("Background sync cancelled")
+
+    async def stop_background_sync(self) -> None:
+        """Stop background sync tasks."""
+        logger.info("Stopping background sync service...")
+        self._running = False
+
+        if self._push_task:
+            self._push_task.cancel()
+            try:
+                await self._push_task
+            except asyncio.CancelledError:
+                pass
+
+        if self._pull_task:
+            self._pull_task.cancel()
+            try:
+                await self._pull_task
+            except asyncio.CancelledError:
+                pass
+
+    async def _push_loop(self) -> None:
+        """Periodically push changes to remote."""
+        while self._running:
+            try:
+                await asyncio.sleep(self.config.push_interval_seconds)
+                if self._running:  # Check again after sleep
+                    await self.push()
+            except Exception as e:
+                logger.error(f"Push error: {e}")
+                self.status = SyncStatus.ERROR
+
+    async def _pull_loop(self) -> None:
+        """Periodically pull changes from remote."""
+        while self._running:
+            try:
+                await asyncio.sleep(self.config.pull_interval_seconds)
+                if self._running:  # Check again after sleep
+                    await self.pull()
+            except Exception as e:
+                logger.error(f"Pull error: {e}")
+                self.status = SyncStatus.ERROR
+
+    async def push(self, force: bool = False) -> SyncResult:
+        """
+        Push local changes to remote.
+
+        Args:
+            force: Force push even if recently pushed
+
+        Returns:
+            SyncResult with operation details
+        """
+        # Skip if pushed recently (unless forced)
+        if not force and self.last_push:
+            elapsed = (datetime.now() - self.last_push).total_seconds()
+            if elapsed < self.config.push_interval_seconds:
+                return SyncResult(
+                    status=SyncStatus.IDLE,
+                    operation="push",
+                    timestamp=datetime.now(),
+                    message=f"Skip: {int(elapsed)}s since last push",
+                )
+
+        try:
+            self.status = SyncStatus.PUSHING
+
+            # Check for uncommitted changes in .htmlgraph
+            result = await self._run_git(
+                ["status", "--porcelain", str(self.config.sync_path)]
+            )
+
+            if not result:
+                self.status = SyncStatus.IDLE
+                sync_result = SyncResult(
+                    status=SyncStatus.SUCCESS,
+                    operation="push",
+                    timestamp=datetime.now(),
+                    message="No changes to push",
+                )
+                self.sync_history.append(sync_result)
+                return sync_result
+
+            # Stage changes
+            await self._run_git(["add", str(self.config.sync_path)])
+
+            # Commit
+            commit_msg = f"chore: auto-sync htmlgraph from {self._get_hostname()}"
+            await self._run_git(["commit", "-m", commit_msg])
+
+            # Push to remote
+            await self._run_git(
+                [
+                    "push",
+                    self.config.remote_name,
+                    f"{self.config.branch_name}:refs/heads/{self.config.branch_name}",
+                ]
+            )
+
+            self.last_push = datetime.now()
+            self.status = SyncStatus.SUCCESS
+
+            logger.info(f"Pushed changes to {self.config.remote_name}")
+
+            sync_result = SyncResult(
+                status=SyncStatus.SUCCESS,
+                operation="push",
+                timestamp=self.last_push,
+                files_changed=len(result.strip().split("\n")),
+                message=f"Pushed {len(result.strip().split(chr(10)))} files",
+            )
+            self.sync_history.append(sync_result)
+            return sync_result
+
+        except Exception as e:
+            self.status = SyncStatus.ERROR
+            logger.error(f"Push failed: {e}")
+
+            sync_result = SyncResult(
+                status=SyncStatus.ERROR,
+                operation="push",
+                timestamp=datetime.now(),
+                message=str(e),
+            )
+            self.sync_history.append(sync_result)
+            return sync_result
+
+    async def pull(self, force: bool = False) -> SyncResult:
+        """
+        Pull remote changes.
+
+        Args:
+            force: Force pull even if recently pulled
+
+        Returns:
+            SyncResult with operation details
+        """
+        # Skip if pulled recently (unless forced)
+        if not force and self.last_pull:
+            elapsed = (datetime.now() - self.last_pull).total_seconds()
+            if elapsed < self.config.pull_interval_seconds:
+                return SyncResult(
+                    status=SyncStatus.IDLE,
+                    operation="pull",
+                    timestamp=datetime.now(),
+                    message=f"Skip: {int(elapsed)}s since last pull",
+                )
+
+        try:
+            self.status = SyncStatus.PULLING
+
+            # Stash uncommitted changes if enabled
+            if self.config.auto_stash:
+                await self._run_git(
+                    ["stash", "push", "-m", "auto-stash before pull"], allow_fail=True
+                )
+
+            # Fetch latest from remote
+            await self._run_git(["fetch", self.config.remote_name])
+
+            # Try to merge
+            try:
+                await self._run_git(
+                    [
+                        "merge",
+                        f"{self.config.remote_name}/{self.config.branch_name}",
+                        "-m",
+                        "auto-merge from remote",
+                    ]
+                )
+
+                self.last_pull = datetime.now()
+                self.status = SyncStatus.SUCCESS
+
+                logger.info(f"Pulled changes from {self.config.remote_name}")
+
+                sync_result = SyncResult(
+                    status=SyncStatus.SUCCESS,
+                    operation="pull",
+                    timestamp=self.last_pull,
+                    message="Merged successfully",
+                )
+                self.sync_history.append(sync_result)
+                return sync_result
+
+            except subprocess.CalledProcessError:
+                # Merge conflict
+                conflicts = await self._get_conflicts()
+                self.status = SyncStatus.CONFLICT
+
+                logger.warning(f"Merge conflict detected: {conflicts}")
+
+                # Handle conflict based on strategy
+                if self.config.conflict_strategy == SyncStrategy.AUTO_MERGE:
+                    await self._resolve_conflicts_auto()
+                    await self._run_git(["commit", "-m", "auto-resolve merge conflict"])
+                elif self.config.conflict_strategy == SyncStrategy.OURS:
+                    await self._run_git(["checkout", "--ours", "."])
+                    await self._run_git(["add", "."])
+                    await self._run_git(["commit", "-m", "conflict: keep local"])
+                elif self.config.conflict_strategy == SyncStrategy.THEIRS:
+                    await self._run_git(["checkout", "--theirs", "."])
+                    await self._run_git(["add", "."])
+                    await self._run_git(["commit", "-m", "conflict: keep remote"])
+                elif self.config.conflict_strategy == SyncStrategy.ABORT_ON_CONFLICT:
+                    await self._run_git(["merge", "--abort"])
+
+                    sync_result = SyncResult(
+                        status=SyncStatus.CONFLICT,
+                        operation="pull",
+                        timestamp=datetime.now(),
+                        conflicts=conflicts,
+                        message=f"Merge conflict in {len(conflicts)} files",
+                    )
+                    self.sync_history.append(sync_result)
+                    return sync_result
+
+                self.last_pull = datetime.now()
+                self.status = SyncStatus.SUCCESS
+
+                sync_result = SyncResult(
+                    status=SyncStatus.SUCCESS,
+                    operation="pull",
+                    timestamp=self.last_pull,
+                    conflicts=conflicts,
+                    message=f"Resolved conflicts in {len(conflicts)} files",
+                )
+                self.sync_history.append(sync_result)
+                return sync_result
+
+        except Exception as e:
+            self.status = SyncStatus.ERROR
+            logger.error(f"Pull failed: {e}")
+
+            sync_result = SyncResult(
+                status=SyncStatus.ERROR,
+                operation="pull",
+                timestamp=datetime.now(),
+                message=str(e),
+            )
+            self.sync_history.append(sync_result)
+            return sync_result
+
+    async def _run_git(self, args: list[str], allow_fail: bool = False) -> str:
+        """
+        Run git command asynchronously.
+
+        Args:
+            args: Git command arguments
+            allow_fail: Whether to suppress errors
+
+        Returns:
+            Command stdout as string
+
+        Raises:
+            RuntimeError: If command fails and allow_fail=False
+        """
+        cmd = ["git", "-C", str(self.repo_root)] + args
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=30)
+
+            if process.returncode != 0 and not allow_fail:
+                raise RuntimeError(f"Git command failed: {stderr.decode().strip()}")
+
+            return stdout.decode().strip()
+
+        except asyncio.TimeoutError as e:
+            if allow_fail:
+                return ""
+            raise RuntimeError(f"Git command timeout: {' '.join(args)}") from e
+
+    async def _get_conflicts(self) -> list[str]:
+        """Get list of conflicted files."""
+        try:
+            result = await self._run_git(["diff", "--name-only", "--diff-filter=U"])
+            return result.split("\n") if result else []
+        except Exception:
+            return []
+
+    async def _resolve_conflicts_auto(self) -> None:
+        """
+        Attempt automatic conflict resolution.
+
+        Strategy:
+        - SQLite files: use ours (local)
+        - JSONL files: use ours (event log is append-only)
+        - Other files: accept git's merge
+        """
+        conflicts = await self._get_conflicts()
+
+        for conflict in conflicts:
+            if conflict.endswith(".db"):
+                # SQLite: keep local version
+                await self._run_git(["checkout", "--ours", conflict])
+            elif conflict.endswith(".jsonl"):
+                # JSONL: keep local (event log is append-only)
+                await self._run_git(["checkout", "--ours", conflict])
+            # Text files: accept git's merge (do nothing)
+
+        await self._run_git(["add", "."])
+
+    def _get_hostname(self) -> str:
+        """Get hostname for commit messages."""
+        return socket.gethostname()
+
+    def get_sync_history(self, limit: int = 50) -> list[dict[str, Any]]:
+        """
+        Get recent sync history.
+
+        Args:
+            limit: Maximum number of results
+
+        Returns:
+            List of sync result dictionaries
+        """
+        return [s.to_dict() for s in self.sync_history[-limit:]]
+
+    def get_status(self) -> dict[str, Any]:
+        """
+        Get current sync status.
+
+        Returns:
+            Status dictionary with sync state and config
+        """
+        return {
+            "status": self.status.value,
+            "last_push": self.last_push.isoformat() if self.last_push else None,
+            "last_pull": self.last_pull.isoformat() if self.last_pull else None,
+            "config": {
+                "push_interval": self.config.push_interval_seconds,
+                "pull_interval": self.config.pull_interval_seconds,
+                "remote": self.config.remote_name,
+                "branch": self.config.branch_name,
+                "conflict_strategy": self.config.conflict_strategy.value,
+                "sync_path": self.config.sync_path,
+            },
+        }

{htmlgraph-0.27.6.dist-info → htmlgraph-0.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.27.6
+Version: 0.28.0
 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.27.6.dist-info → htmlgraph-0.28.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-htmlgraph/__init__.py,sha256=uOeA6rclaPyDSJry64EF_-hlCIcl0vNxeEXKD9juFKs,6407
+htmlgraph/__init__.py,sha256=n4sKlB0iT9Pcx5U77329ssQl39UMvLSskHP8oC_HqtQ,6595
 htmlgraph/__init__.pyi,sha256=8JuFVuDll9jMx9s8ZQHt2tXic-geOJHiXUMB2YjmHhU,6683
 htmlgraph/agent_detection.py,sha256=wEmrDv4hssPX2OkEnJZBHPbalxcaloiJF_hOOow_5WE,3511
 htmlgraph/agent_registry.py,sha256=80TPYr4P0YMizPUbTH4N5wH6D84IKs-HPBLHGeeP6bY,9449
@@ -7,6 +7,7 @@ htmlgraph/analytics_index.py,sha256=fm0cnZjce2Ii4F9FQo1np_mWsFXuRgTTOzbrCJWGW3g,
 htmlgraph/atomic_ops.py,sha256=f0ULZoJThfC-A8xORvRv5OuFuhEnnH7uJrZslnZwmuw,18781
 htmlgraph/attribute_index.py,sha256=oF4TwbFGdtg1_W5AUJ-Ka4VcH-aYz-qldtiPvStJlfA,6594
 htmlgraph/bounded_paths.py,sha256=4HHXiT8q2fhGkrGsGrACFnDrnAzwJ-Tk_4V9h-voenM,18832
+htmlgraph/broadcast_integration.py,sha256=dcWiKDIcpyvNXff56hXUMYp3Z4ECue6-EniiGIwr-XI,7475
 htmlgraph/cli_framework.py,sha256=YfAjTGIECmv_uNpkenYyc9_iKd3jXIG5OstEKpIGWJM,3551
 htmlgraph/config.py,sha256=dhOSfMfZCT-APe_uAvqABWyQ0nEhL6F0NS-15KLPZNg,6888
 htmlgraph/context_analytics.py,sha256=fGuIhGCM-500wH_pTKE24k0Rl01QvQ8Kznoj61KpjiU,11345
@@ -49,13 +50,15 @@ htmlgraph/pydantic_models.py,sha256=4vGAp2n59Hf8v5mZG-Tx2vOSm3lcE_PypBprcejJUXE,
 htmlgraph/quality_gates.py,sha256=ovPrjGgAwK5MjMzEIda4a6M5_S-yGiRJYy8KhzdyTZ0,11686
 htmlgraph/query_builder.py,sha256=GBrjf_6Qoq98JxJr8cYeAMV4QpdmrfFyadJpDjH4clM,18093
 htmlgraph/query_composer.py,sha256=ilasmZBc8_mLS1iq45Kcw2Ig1zCN04-r1HVKr8f9YP0,17332
+htmlgraph/reactive_integration.py,sha256=7Vf7AqPdp-Oe-rzBvwSCV_HWCb5DvaujQRzP4oqd7ag,4113
 htmlgraph/reflection.py,sha256=agNfHsI1ynayTG3kgt5fiQj30LkG9b-v3wtnDsu4-Gk,15663
 htmlgraph/refs.py,sha256=jgsPWRTfPDxhH_dr4EeYdU1ly-e3HpuHgAPnMXMbaF4,10011
 htmlgraph/repo_hash.py,sha256=wYQlgYf0W1LfU95PA6vViA-MlUxA6ry_xDh7kyCB4v4,14888
 htmlgraph/routing.py,sha256=QYDY6bzYPmv6kocAXCqguB1cazN0i_xTo9EVCO3fO2Y,8803
 htmlgraph/server.py,sha256=BZcUM9sfGQzS0PyFOvl5_f4MP9-8C4E8tp77VcanwLM,56211
+htmlgraph/session_context.py,sha256=4XsywYg4-J7ct9B-z3mnbkIUvyD_K389Y73yh5AxBWQ,57007
 htmlgraph/session_hooks.py,sha256=AOjpPMZo2s_d_KXuPiWDo8TIOdkXsEU0CoOHd4G5A10,9195
-htmlgraph/session_manager.py,sha256=Bf7l0H67t6mo-ogoPFdz2XxBDxfJrh02wIx4rSOtFM8,98630
+htmlgraph/session_manager.py,sha256=X-xm9JvfbMt2V2dI9I_lgiosqTV7YnHTLXlwy7F7FZw,101084
 htmlgraph/session_registry.py,sha256=xF6VaFp3tE9LA8PXXnaIs2PKZxMOktxRUJJ7vCs0Mcs,18725
 htmlgraph/session_state.py,sha256=2UcgQNzwBjHkVuGxrAGfHkODopqDexU4wjy9qXKcQIk,15245
 htmlgraph/session_warning.py,sha256=XPT2Cbg6YRNNhw7NpM8aAp5ny-qfCsYY86DURL_eAPc,7878
@@ -91,9 +94,18 @@ htmlgraph/analytics/strategic/pattern_detector.py,sha256=5SEUpzX5wXsX1tvzkG0oMVG
 htmlgraph/analytics/strategic/preference_manager.py,sha256=uO8cX-kaK7EIJh-ovXh5cMc0qkMhUfC6zavvvb7osnc,24776
 htmlgraph/analytics/strategic/suggestion_engine.py,sha256=KV43DF6PETJkmrMA_Ni34heSdQqS_GXKeeGsq5zO6ck,26093
 htmlgraph/api/__init__.py,sha256=PPFJ5QSv-Zei8U0yGOSs8dJKtUQMeloEqsxVBfzNbbA,105
-htmlgraph/api/cost_alerts_websocket.py,sha256=6e_2pKn0-Hcz2ClFyNuJEhVBffqmcUBOkbseSgSkAqQ,14839
-htmlgraph/api/main.py,sha256=rQ9758JJ3qqabr8qmQDWuW2T7XlfnDWdRCydPyD9R6o,98121
-htmlgraph/api/websocket.py,sha256=L8a_p9cSLdmG1dcVQLZSfxS994Dm-caNPnYQWZ_a-Z0,17592
+htmlgraph/api/broadcast.py,sha256=G2vsgbUFOeahy8l1GJwu5X2yBJAID02lgNXxyDMexx0,9051
+htmlgraph/api/broadcast_routes.py,sha256=OJQaUx6_izB_TlyL5N7tzTx3nD9sFs3RUhehlRtl_3k,11376
+htmlgraph/api/broadcast_websocket.py,sha256=ZTHmLsYCExaCkHiDD7LNKQaAjaTQadNoO4OZOrGsU3Q,3822
+htmlgraph/api/cost_alerts_websocket.py,sha256=jmPJ0kO7PKXYe-MwN0rReQ6ACa6E--p9DaMCqDDs3IE,14478
+htmlgraph/api/main.py,sha256=veNvUf4MkyCneV0lQB1R6Zuz_BdGk862rn-lpFQ3fts,101924
+htmlgraph/api/offline.py,sha256=u6RbmeoDPvPsFJYsTNhFZ6yoNE0bgYXFzUi2g2pmeYU,25881
+htmlgraph/api/presence.py,sha256=eF7j5yp7lgO9tF0_VMdE0zeWrUYIAYhgOUHSKe8dr70,14246
+htmlgraph/api/reactive.py,sha256=WW8bBCiu9RBCgNeKE-fohvklJNBnvWj_zdllPkZun2M,14941
+htmlgraph/api/reactive_routes.py,sha256=YdXSpkh8GmmvUhmgXdnJmEJY6Lu0jLTm6QM6BVng2-4,6032
+htmlgraph/api/sync_routes.py,sha256=0ei-TYi0axEAK1aZYbobBIfRsvZ7csiQjJ-zbi-0oQg,4863
+htmlgraph/api/websocket.py,sha256=bO0WS985Ej_27rwoFKy3fFcNLYjV0obvAIju8WzKURY,19915
+htmlgraph/api/static/broadcast-demo.html,sha256=kJ45f9AmHmtCZnf2O3hsfGxa2RAgXLFqxbA689jY8Cg,12611
 htmlgraph/api/static/htmx.min.js,sha256=0VEHzH8ECp6DsbZhdv2SetQLXgJVgToD-Mz-7UbuQrA,48036
 htmlgraph/api/static/style-redesign.css,sha256=zp0ggDJHz81FN5SW5tRcWXPK_jVNCAJyqKhwlZkBfnQ,26759
 htmlgraph/api/static/style.css,sha256=6nUzPvf3Xri0vxbEIunrbJkujP6k3HrM3KC5nrkOjyw,20022
@@ -163,6 +175,7 @@ htmlgraph/cli/work/snapshot.py,sha256=ZJFF8ea8WlD1EP2iFXfhKK2mfUufWbe_cYvMPcmATo
 htmlgraph/cli/work/tracks.py,sha256=MzymITEkbq_jNeCYGLgqWwwa0hAv3UWpPqhEMTHC8zI,16290
 htmlgraph/cli_commands/__init__.py,sha256=GYdoNv80KS2p7bCThuoRbhiLmIZW6ddPqPEFEx567nQ,35
 htmlgraph/cli_commands/feature.py,sha256=KqC0daKE1aMb9-FBHlEEUZbLFvZdjlW5CxqSeO1HVVU,6689
+htmlgraph/cli_commands/sync.py,sha256=3XmqCPgZ11cZ3aAs4523oS54ORlgU24IjioE23XslkQ,5795
 htmlgraph/collections/__init__.py,sha256=bDUTK5grqWKCR5sawI8fa-XoL09p5-heReGdkdSXArY,1163
 htmlgraph/collections/base.py,sha256=Wbpf_5Z340bds4mohzjS_w9fB-qKG01hBa81NkWnDtE,26728
 htmlgraph/collections/bug.py,sha256=uqOWAtJShwZtDYEfsrs6kMnTDUrqhykezMd72_WMaXE,1332
@@ -183,7 +196,7 @@ htmlgraph/cost_analysis/__init__.py,sha256=kuAA4Fd0gUplOWOiqs3CF4eO1wwekGs_3DaiF
 htmlgraph/cost_analysis/analyzer.py,sha256=TDKgRXeOQ-td5LZhkFob4ajEf-JssSCGKlMS3GysYJU,15040
 htmlgraph/db/__init__.py,sha256=1yWTyWrN2kcmW6mVKCUf4POSUXTOSaAljwEyyC0Xs1w,1033
 htmlgraph/db/queries.py,sha256=FtqOIBJC0EociEYNJr6gTVROqd9m5yZdVGYLxXNVSdk,22608
-htmlgraph/db/schema.py,sha256=aVo9jeYW_rgPv0JB5RpXm7ZdzOyljLfc3sJwuQRtrtU,69262
+htmlgraph/db/schema.py,sha256=HLfUqtRC9QoU3mwPRWU3KugCMAdvwns9_Iu0BWSVO3s,78559
 htmlgraph/docs/API_REFERENCE.md,sha256=LYsYeHinF6GEsjMvrgdQSbgmMPsOh4ZQ1WK11niqNvo,17862
 htmlgraph/docs/HTTP_API.md,sha256=IrX-wZckFn-K3ztCVcT-zyGqJL2TtY1qYV7dUuC7kzc,13344
 htmlgraph/docs/INTEGRATION_GUIDE.md,sha256=uNNM0ipY0bFAkZaL1CkvnA_Wt2MVPGRBdA4927cZaHo,16910
@@ -213,7 +226,7 @@ htmlgraph/hooks/cigs_pretool_enforcer.py,sha256=LC5y5IrKdTx2aq5ht5U7Tceq0k63-7EI
 htmlgraph/hooks/concurrent_sessions.py,sha256=qOiwDfynphVG0-2pVBakEzOwMORU8ebN1gMjcN4S0z0,6476
 htmlgraph/hooks/context.py,sha256=tJ4dIL8uTFHyqyuuMc-ETDuOikeD5cN3Mdjmfg6W0HE,13108
 htmlgraph/hooks/drift_handler.py,sha256=UchkeVmjgI6J4NE4vKNTHsY6ZorvUHvp1FOfwTEY-Cs,17626
-htmlgraph/hooks/event_tracker.py,sha256=Cx51c2VExLKWRlJCYYlnOItU9oGgj8gbceOHys00Tjs,51398
+htmlgraph/hooks/event_tracker.py,sha256=yFDGVsRTvVkmEhVPkZGwEz66ymIWZh9hDbuYMEvUkLM,53442
 htmlgraph/hooks/git_commands.py,sha256=NPzthfzGJ_bkDi7soehHOxI9FLL-6BL8Tie9Byb_zf4,4803
 htmlgraph/hooks/hooks-config.example.json,sha256=tXpk-U-FZzGOoNJK2uiDMbIHCYEHA794J-El0fBwkqg,197
 htmlgraph/hooks/installer.py,sha256=NdZHOER7DHFyZYXiZIS-CgLt1ZUxJ4O4ju8HcPjJajs,11816
@@ -322,16 +335,18 @@ htmlgraph/services/__init__.py,sha256=Cy-4RI7raV4jd2Vfc5Zya0VTgV0x9LNt32h9DhYVGk
 htmlgraph/services/claiming.py,sha256=HcrltEJKN72mxuD7fGuXWeh1U0vwhjMvhZcFc02EiyU,6071
 htmlgraph/sessions/__init__.py,sha256=58XJkCNtksEalKFhQsovzyewQlI6hrPKXzQOuEuMDy4,429
 htmlgraph/sessions/handoff.py,sha256=YqSVtVwQp99Zcnq5jlbsDaWmTKv8NpLPdouXVJ96RaI,21880
+htmlgraph/sync/__init__.py,sha256=j6zkmrGGi5LRFMsNntZ6_E8d_45OGRu2J8R6KujXFl4,360
+htmlgraph/sync/git_sync.py,sha256=n1ItI0hEFPXrfOyryTfcIJfZcRLeVtMrhs4RFrtII_c,15734
 htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
 htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
 htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
 htmlgraph/templates/orchestration-view.html,sha256=DlS7LlcjH0oO_KYILjuF1X42t8QhKLH4F85rkO54alY,10472
-htmlgraph-0.27.6.data/data/htmlgraph/dashboard.html,sha256=MUT6SaYnazoyDcvHz5hN1omYswyIoUfeoZLf2M_iblo,251268
-htmlgraph-0.27.6.data/data/htmlgraph/styles.css,sha256=oDUSC8jG-V-hKojOBO9J88hxAeY2wJrBYTq0uCwX_Y4,7135
-htmlgraph-0.27.6.data/data/htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
-htmlgraph-0.27.6.data/data/htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
-htmlgraph-0.27.6.data/data/htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
-htmlgraph-0.27.6.dist-info/METADATA,sha256=tU22e3oeC3VapYYv-SmSDYIhkUCpUHOwwNHYhMPHmrI,10220
-htmlgraph-0.27.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-htmlgraph-0.27.6.dist-info/entry_points.txt,sha256=Wmdo5cx8pt6NoMsssVE2mZH1CZLSUsrg_3iSWatiyn0,103
-htmlgraph-0.27.6.dist-info/RECORD,,
+htmlgraph-0.28.0.data/data/htmlgraph/dashboard.html,sha256=MUT6SaYnazoyDcvHz5hN1omYswyIoUfeoZLf2M_iblo,251268
+htmlgraph-0.28.0.data/data/htmlgraph/styles.css,sha256=oDUSC8jG-V-hKojOBO9J88hxAeY2wJrBYTq0uCwX_Y4,7135
+htmlgraph-0.28.0.data/data/htmlgraph/templates/AGENTS.md.template,sha256=f96h7V6ygwj-v-fanVI48eYMxR6t_se4bet1H4ZsDpI,7642
+htmlgraph-0.28.0.data/data/htmlgraph/templates/CLAUDE.md.template,sha256=h1kG2hTX2XYig2KszsHBfzrwa_4Cfcq2Pj4SwqzeDlM,1984
+htmlgraph-0.28.0.data/data/htmlgraph/templates/GEMINI.md.template,sha256=gAGzE53Avki87BM_otqy5HdcYCoLsHgqaKjVzNzPMX8,1622
+htmlgraph-0.28.0.dist-info/METADATA,sha256=XE3zRpXFYTI3tn0e2C_-Ipsi29pWYwXzcfasXfS24is,10220
+htmlgraph-0.28.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+htmlgraph-0.28.0.dist-info/entry_points.txt,sha256=Wmdo5cx8pt6NoMsssVE2mZH1CZLSUsrg_3iSWatiyn0,103
+htmlgraph-0.28.0.dist-info/RECORD,,