aline-ai 0.1.10__py3-none-any.whl → 0.2.1__py3-none-any.whl

realign/mcp_watcher.py

@@ -1,4 +1,7 @@
-"""Session file watcher for MCP auto-commit per user request completion."""
+"""Session file watcher for MCP auto-commit per user request completion.
+
+Supports both Claude Code and Codex session formats with unified interface.
+"""
 
 import asyncio
 import json
@@ -6,49 +9,25 @@ import subprocess
 import sys
 import time
 from pathlib import Path
-from typing import Optional, Dict
+from typing import Optional, Dict, Literal
 from datetime import datetime
 
 from .config import ReAlignConfig
 from .hooks import find_all_active_sessions
 
 
-# File-based logger for debugging when stderr is not visible
-_log_file = None
-
-def _log(msg: str):
-    """Log to both stderr and a debug file."""
-    global _log_file
-    timestamp = datetime.now().strftime("%H:%M:%S")
-    full_msg = f"[{timestamp}] {msg}"
-    print(f"[MCP Watcher] {msg}", file=sys.stderr)
-
-    # Also write to file for debugging
-    if _log_file is None:
-        log_path = Path.home() / ".aline_watcher.log"
-        try:
-            _log_file = open(log_path, "a", buffering=1)  # Line buffered
-            _log_file.write(f"\n{'='*60}\n")
-            _log_file.write(f"[{timestamp}] MCP Watcher Started\n")
-            _log_file.write(f"{'='*60}\n")
-        except Exception:
-            _log_file = False  # Mark as failed so we don't retry
-
-    if _log_file and _log_file is not False:
-        try:
-            _log_file.write(full_msg + "\n")
-            _log_file.flush()
-        except Exception:
-            pass
+# Session type detection
+SessionType = Literal["claude", "codex", "unknown"]
 
 
 class DialogueWatcher:
     """Watch session files and auto-commit immediately after each user request completes."""
 
-    def __init__(self, repo_path: Path):
-        self.repo_path = repo_path  # Default repo path (may be overridden per-session)
+    def __init__(self):
+        """Initialize watcher without fixed repo_path - will extract dynamically from sessions."""
         self.config = ReAlignConfig.load()
-        self.last_commit_time: Dict[str, float] = {}  # Track commit time per project
+        self.project_path = self._detect_project_path()
+        self.last_commit_times: Dict[str, float] = {}  # Track last commit time per project
         self.last_session_sizes: Dict[str, int] = {}  # Track file sizes
         self.last_stop_reason_counts: Dict[str, int] = {}  # Track stop_reason counts per session
         self.min_commit_interval = 5.0  # Minimum 5 seconds between commits (cooldown)
@@ -59,38 +38,30 @@ class DialogueWatcher:
     async def start(self):
         """Start watching session files."""
         if not self.config.mcp_auto_commit:
-            _log("Auto-commit disabled in config")
+            print("[MCP Watcher] Auto-commit disabled in config", file=sys.stderr)
             return
 
         self.running = True
-        _log("Started watching for dialogue completion")
-        _log(f"Mode: Per-request (triggers at end of each Claude response)")
-        _log(f"Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s")
-        _log(f"Home directory: {Path.home()}")
-        _log(f"Current working directory: {Path.cwd()}")
+        print("[MCP Watcher] Started watching for dialogue completion", file=sys.stderr)
+        print(f"[MCP Watcher] Mode: Per-request (triggers at end of each AI response)", file=sys.stderr)
+        print(f"[MCP Watcher] Supports: Claude Code & Codex (auto-detected)", file=sys.stderr)
+        print(f"[MCP Watcher] Debounce: {self.debounce_delay}s, Cooldown: {self.min_commit_interval}s", file=sys.stderr)
+        if self.project_path:
+            print(f"[MCP Watcher] Monitoring project: {self.project_path}", file=sys.stderr)
+        else:
+            print("[MCP Watcher] Project path unknown, falling back to multi-project scan", file=sys.stderr)
 
         # Initialize baseline sizes and stop_reason counts
         self.last_session_sizes = self._get_session_sizes()
         self.last_stop_reason_counts = self._get_stop_reason_counts()
 
-        # Log initial session files being monitored
-        if self.last_session_sizes:
-            _log(f"Monitoring {len(self.last_session_sizes)} session file(s):")
-            for session_path in list(self.last_session_sizes.keys())[:5]:  # Show first 5
-                _log(f"  - {session_path}")
-            if len(self.last_session_sizes) > 5:
-                _log(f"  ... and {len(self.last_session_sizes) - 5} more")
-        else:
-            claude_projects = Path.home() / ".claude" / "projects"
-            _log(f"WARNING: No session files found in {claude_projects}")
-
         # Poll for file changes more frequently
         while self.running:
             try:
                 await self.check_for_changes()
                 await asyncio.sleep(0.5)  # Check every 0.5 seconds for responsiveness
             except Exception as e:
-                _log(f"Error: {e}")
+                print(f"[MCP Watcher] Error: {e}", file=sys.stderr)
                 await asyncio.sleep(1.0)
 
     async def stop(self):
@@ -98,42 +69,178 @@ class DialogueWatcher:
         self.running = False
         if self.pending_commit_task:
             self.pending_commit_task.cancel()
-        _log("Stopped")
+        print("[MCP Watcher] Stopped", file=sys.stderr)
 
     def _get_session_sizes(self) -> Dict[str, int]:
-        """Get current sizes of all active session files (from all Claude projects)."""
+        """Get current sizes of all active session files."""
         sizes = {}
         try:
-            # Watch ALL Claude session files, not just one project
-            claude_projects = Path.home() / ".claude" / "projects"
-            if claude_projects.exists():
-                for session_file in claude_projects.glob("*/*.jsonl"):
-                    if session_file.exists():
-                        sizes[str(session_file)] = session_file.stat().st_size
+            session_files = find_all_active_sessions(
+                self.config,
+                project_path=self.project_path if self.project_path and self.project_path.exists() else None,
+            )
+            for session_file in session_files:
+                if session_file.exists():
+                    sizes[str(session_file)] = session_file.stat().st_size
         except Exception as e:
-            _log(f"Error getting session sizes: {e}")
+            print(f"[MCP Watcher] Error getting session sizes: {e}", file=sys.stderr)
         return sizes
 
     def _get_stop_reason_counts(self) -> Dict[str, int]:
-        """Get current count of stop_reason entries in all active session files."""
+        """Get current count of turn completion markers in all active session files."""
         counts = {}
         try:
-            # Watch ALL Claude session files
-            claude_projects = Path.home() / ".claude" / "projects"
-            if claude_projects.exists():
-                for session_file in claude_projects.glob("*/*.jsonl"):
-                    if session_file.exists():
-                        counts[str(session_file)] = self._count_stop_reasons(session_file)
+            session_files = find_all_active_sessions(
+                self.config,
+                project_path=self.project_path if self.project_path and self.project_path.exists() else None,
+            )
+            for session_file in session_files:
+                if session_file.exists():
+                    counts[str(session_file)] = self._count_complete_turns(session_file)
         except Exception as e:
-            _log(f"Error getting stop_reason counts: {e}")
+            print(f"[MCP Watcher] Error getting turn counts: {e}", file=sys.stderr)
         return counts
 
-    def _count_stop_reasons(self, session_file: Path) -> int:
+    def _extract_project_path(self, session_file: Path) -> Optional[Path]:
+        """
+        Extract project path (cwd) from session file.
+
+        Supports:
+        1. Codex: Read cwd from session_meta payload
+        2. Claude Code: Read cwd from message objects OR infer from project directory name
+
+        Args:
+            session_file: Path to session file
+
+        Returns:
+            Path to project directory, or None if cannot determine
+        """
+        try:
+            # Method 1: Try to read cwd from session content
+            with open(session_file, 'r', encoding='utf-8') as f:
+                # Check first 10 lines for cwd field
+                for i, line in enumerate(f):
+                    if i >= 10:
+                        break
+
+                    line = line.strip()
+                    if not line:
+                        continue
+
+                    try:
+                        data = json.loads(line)
+
+                        # Codex format: session_meta.payload.cwd
+                        if data.get('type') == 'session_meta':
+                            cwd = data.get('payload', {}).get('cwd')
+                            if cwd:
+                                project_path = Path(cwd)
+                                if project_path.exists():
+                                    return project_path
+
+                        # Claude Code format: message object has cwd field
+                        if 'cwd' in data:
+                            cwd = data['cwd']
+                            if cwd:
+                                project_path = Path(cwd)
+                                if project_path.exists():
+                                    return project_path
+
+                    except json.JSONDecodeError:
+                        continue
+
+            # Method 2: For Claude Code, infer from project directory name
+            # ~/.claude/projects/-Users-huminhao-Projects-ReAlign/xxx.jsonl
+            if '.claude/projects/' in str(session_file):
+                project_dir_name = session_file.parent.name
+                if project_dir_name.startswith('-'):
+                    # Decode: -Users-huminhao-Projects-ReAlign -> /Users/huminhao/Projects/ReAlign
+                    project_path_str = '/' + project_dir_name[1:].replace('-', '/')
+                    project_path = Path(project_path_str)
+                    if project_path.exists() and (project_path / '.git').exists():
+                        return project_path
+
+            print(f"[MCP Watcher] Could not extract project path from {session_file.name}", file=sys.stderr)
+            return None
+
+        except Exception as e:
+            print(f"[MCP Watcher] Error extracting project path from {session_file}: {e}", file=sys.stderr)
+            return None
+
+    def _detect_session_type(self, session_file: Path) -> SessionType:
+        """
+        Detect the type of session file by examining its structure.
+
+        Returns:
+            "claude" for Claude Code sessions
+            "codex" for Codex/GPT sessions
+            "unknown" if cannot determine
+        """
+        try:
+            with open(session_file, 'r', encoding='utf-8') as f:
+                # Check first 20 lines for format indicators
+                for i, line in enumerate(f):
+                    if i >= 20:
+                        break
+
+                    line = line.strip()
+                    if not line:
+                        continue
+
+                    try:
+                        data = json.loads(line)
+
+                        # Claude Code format: {type: "assistant", message: {...}}
+                        if data.get("type") in ("assistant", "user") and "message" in data:
+                            return "claude"
+
+                        # Codex format: {type: "session_meta", payload: {originator: "codex_*"}}
+                        if data.get("type") == "session_meta":
+                            payload = data.get("payload", {})
+                            if "codex" in payload.get("originator", "").lower():
+                                return "codex"
+
+                        # Codex format: {type: "response_item", payload: {...}}
+                        if data.get("type") == "response_item":
+                            payload = data.get("payload", {})
+                            # Claude has "message" wrapper, Codex doesn't
+                            if "message" not in data and "role" in payload:
+                                return "codex"
+
+                    except json.JSONDecodeError:
+                        continue
+
+            return "unknown"
+
+        except Exception as e:
+            print(f"[MCP Watcher] Error detecting session type for {session_file.name}: {e}", file=sys.stderr)
+            return "unknown"
+
+    def _count_complete_turns(self, session_file: Path) -> int:
+        """
+        Unified interface to count complete dialogue turns for any session type.
+
+        Automatically detects session format and uses appropriate counting method.
+
+        Returns:
+            Number of complete dialogue turns (user request + assistant response)
+        """
+        session_type = self._detect_session_type(session_file)
+
+        if session_type == "claude":
+            return self._count_claude_turns(session_file)
+        elif session_type == "codex":
+            return self._count_codex_turns(session_file)
+        else:
+            print(f"[MCP Watcher] Unknown session type for {session_file.name}, skipping", file=sys.stderr)
+            return 0
+
+    def _count_claude_turns(self, session_file: Path) -> int:
         """
-        Count the number of unique stop_reason='end_turn' entries in a session file.
+        Count complete dialogue turns for Claude Code sessions.
 
-        Deduplicates by message ID since Claude Code writes the same message multiple times
-        (first with thinking, then with full content).
+        Uses stop_reason='end_turn' as the marker, with message ID deduplication
+        to handle Claude Code's incremental writes (thinking first, then full content).
         """
         unique_message_ids = set()
         try:
@@ -157,26 +264,50 @@ class DialogueWatcher:
                     except json.JSONDecodeError:
                         continue
         except Exception as e:
-            _log(f"Error counting stop_reasons in {session_file}: {e}")
+            print(f"[MCP Watcher] Error counting Claude turns in {session_file}: {e}", file=sys.stderr)
         return len(unique_message_ids)
 
+    def _count_codex_turns(self, session_file: Path) -> int:
+        """
+        Count complete dialogue turns for Codex sessions.
+
+        Uses 'token_count' event_msg as the marker for dialogue turn completion.
+        Each token_count event appears after an assistant response finishes.
+
+        Note: Codex doesn't have the duplicate write issue that Claude Code has,
+        so no deduplication is needed.
+        """
+        count = 0
+        try:
+            with open(session_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        data = json.loads(line)
+                        # Look for token_count events which mark turn completion
+                        if data.get("type") == "event_msg":
+                            payload = data.get("payload", {})
+                            if payload.get("type") == "token_count":
+                                count += 1
+                    except json.JSONDecodeError:
+                        continue
+        except Exception as e:
+            print(f"[MCP Watcher] Error counting Codex turns in {session_file}: {e}", file=sys.stderr)
+        return count
+
     async def check_for_changes(self):
         """Check if any session file has been modified."""
         try:
             current_sizes = self._get_session_sizes()
 
-            # Debug: log if no sessions found (only once)
-            if not current_sizes and not hasattr(self, '_no_session_warned'):
-                print(f"[MCP Watcher] Warning: No active sessions found for repo: {self.repo_path}", file=sys.stderr)
-                self._no_session_warned = True
-
             # Detect changed files
             changed_files = []
             for path, size in current_sizes.items():
                 old_size = self.last_session_sizes.get(path, 0)
                 if size > old_size:
                     changed_files.append(Path(path))
-                    _log(f"Session file changed: {Path(path).name} ({old_size} -> {size} bytes)")
 
             if changed_files:
                 # File changed - cancel any pending commit and schedule a new one
@@ -192,7 +323,7 @@ class DialogueWatcher:
             self.last_session_sizes = current_sizes
 
         except Exception as e:
-            _log(f"Error checking for changes: {e}")
+            print(f"[MCP Watcher] Error checking for changes: {e}", file=sys.stderr)
 
     async def _debounced_commit(self, changed_files: list):
         """Wait for debounce period, then check if dialogue is complete and commit."""
@@ -201,51 +332,65 @@ class DialogueWatcher:
             await asyncio.sleep(self.debounce_delay)
 
             # Check if any of the changed files contains a complete dialogue turn
+            # And collect the session file that triggered the commit
+            session_to_commit = None
             for session_file in changed_files:
                 if await self._check_if_turn_complete(session_file):
-                    _log(f"Complete turn detected in {session_file.name}")
-
-                    # Extract project path from session file's parent directory
-                    project_path = self._get_project_path_from_session(session_file)
-                    if project_path:
-                        # Check cooldown for this specific project
-                        current_time = time.time()
-                        last_time = self.last_commit_time.get(str(project_path), 0)
-                        if current_time - last_time < self.min_commit_interval:
-                            _log(f"Skipping commit for {project_path} (cooldown)")
-                            continue
-
-                        await self._do_commit(project_path)
-                    else:
-                        _log(f"WARNING: Could not extract project path from {session_file}, skipping commit")
+                    session_to_commit = session_file
+                    print(f"[MCP Watcher] Complete turn detected in {session_file.name}", file=sys.stderr)
+                    break
+
+            if session_to_commit:
+                # Extract project path from the session file
+                project_path = self._extract_project_path(session_to_commit)
+                if not project_path:
+                    print(f"[MCP Watcher] Could not determine project path for {session_to_commit.name}, skipping commit", file=sys.stderr)
+                    return
+
+                # Check cooldown period for this specific project
+                current_time = time.time()
+                project_key = str(project_path)
+                last_commit_time = self.last_commit_times.get(project_key)
+                if last_commit_time:
+                    time_since_last = current_time - last_commit_time
+                    if time_since_last < self.min_commit_interval:
+                        print(f"[MCP Watcher] Skipping commit for {project_path.name} (cooldown: {time_since_last:.1f}s < {self.min_commit_interval}s)", file=sys.stderr)
+                        return
+
+                # Perform commit for this project
+                await self._do_commit(project_path, session_to_commit)
 
         except asyncio.CancelledError:
             # Task was cancelled because a newer change was detected
             pass
         except Exception as e:
-            _log(f"Error in debounced commit: {e}")
+            print(f"[MCP Watcher] Error in debounced commit: {e}", file=sys.stderr)
 
     async def _check_if_turn_complete(self, session_file: Path) -> bool:
         """
-        Check if the session file has at least 1 new stop_reason='end_turn' entry since last check.
+        Check if the session file has at least 1 new complete dialogue turn since last check.
 
-        Each complete dialogue round in Claude Code has:
-        1. User message (no stop_reason field)
-        2. Assistant response with stop_reason: "end_turn"
+        Supports both Claude Code and Codex formats:
+        - Claude Code: Uses stop_reason='end_turn' (deduplicated by message ID)
+        - Codex: Uses token_count events (no deduplication needed)
 
-        We deduplicate by message ID to handle incremental writes of the same message.
-        Therefore, each request-response cycle produces 1 unique end_turn entry.
+        Each complete dialogue round consists of:
+        1. User message/request
+        2. Assistant response
+        3. Turn completion marker (format-specific)
         """
         try:
             session_path = str(session_file)
-            current_count = self._count_stop_reasons(session_file)
+            session_type = self._detect_session_type(session_file)
+
+            current_count = self._count_complete_turns(session_file)
             last_count = self.last_stop_reason_counts.get(session_path, 0)
 
-            new_stop_reasons = current_count - last_count
+            new_turns = current_count - last_count
 
-            # Commit after each complete assistant response (1 new end_turn)
-            if new_stop_reasons >= 1:
-                _log(f"Detected {new_stop_reasons} new end_turn entry(ies) in {session_file.name}")
+            # Commit after each complete assistant response (1 new turn)
+            if new_turns >= 1:
+                print(f"[MCP Watcher] Detected {new_turns} new turn(s) in {session_file.name} ({session_type})", file=sys.stderr)
                 # Update baseline immediately to avoid double-counting
                 self.last_stop_reason_counts[session_path] = current_count
                 return True
@@ -253,216 +398,174 @@ class DialogueWatcher:
             return False
 
         except Exception as e:
-            _log(f"Error checking turn completion: {e}")
+            print(f"[MCP Watcher] Error checking turn completion: {e}", file=sys.stderr)
             return False
 
-    def _get_project_path_from_session(self, session_file: Path) -> Optional[Path]:
+    async def _do_commit(self, project_path: Path, session_file: Path):
         """
-        Extract the actual project path from a Claude session file's location.
+        Perform the actual commit for a specific project.
 
-        Claude Code stores sessions in: ~/.claude/projects/-Users-username-path/session.jsonl
-        The directory name encodes the project path with dashes replacing both slashes and underscores.
-        This means we need to intelligently reconstruct the path by testing which separators work.
+        Args:
+            project_path: Path to the project directory
+            session_file: Session file that triggered the commit
         """
-        try:
-            project_dir_name = session_file.parent.name
-            _log(f"Extracting project path from: {project_dir_name}")
-
-            if project_dir_name.startswith('-'):
-                # Split into segments
-                segments = project_dir_name[1:].split('-')
-                _log(f"Path segments: {segments}")
-
-                # Try to reconstruct the path by checking which combinations exist
-                candidate_path = self._reconstruct_path_from_segments(segments)
-
-                if candidate_path and candidate_path.exists():
-                    _log(f"Project path exists: {candidate_path}")
-                    return candidate_path
-                else:
-                    # Fallback: try simple replacement (for backward compatibility)
-                    simple_path = Path('/' + project_dir_name[1:].replace('-', '/'))
-                    if simple_path.exists():
-                        _log(f"Project path exists (simple method): {simple_path}")
-                        return simple_path
-                    _log(f"WARNING: Could not find valid project path for: {project_dir_name}")
-            else:
-                _log(f"WARNING: Directory name doesn't start with '-': {project_dir_name}")
-        except Exception as e:
-            _log(f"Error extracting project path: {e}")
-        return None
-
-    def _reconstruct_path_from_segments(self, segments: list) -> Optional[Path]:
-        """
-        Reconstruct a file path from encoded segments.
-
-        Claude Code encodes paths by replacing both '/' and '_' with '-'.
-        This method tries to find the correct path by testing which separators
-        produce valid paths.
-
-        Strategy:
-        1. Start from root '/'
-        2. Build path incrementally, checking if each partial path exists
-        3. When a segment doesn't match, try combining with next segment using '_' or '-'
-        """
-        if not segments:
-            return None
-
-        current_path = Path('/')
-        i = 0
-
-        while i < len(segments):
-            segment = segments[i]
-
-            # Try direct match first (segment is a directory/file name)
-            test_path = current_path / segment
-            if test_path.exists():
-                current_path = test_path
-                i += 1
-                continue
-
-            # If direct match fails, try combining with next segments using '_' or '-'
-            found_match = False
-            for lookahead in range(1, min(10, len(segments) - i)):  # Try up to 10 segments ahead
-                # Try combining segments with underscores
-                combined_underscore = '_'.join(segments[i:i+lookahead+1])
-                test_path_underscore = current_path / combined_underscore
-
-                # Try combining segments with hyphens
-                combined_hyphen = '-'.join(segments[i:i+lookahead+1])
-                test_path_hyphen = current_path / combined_hyphen
-
-                # Try mixed combinations for longer paths
-                if test_path_underscore.exists():
-                    current_path = test_path_underscore
-                    i += lookahead + 1
-                    found_match = True
-                    _log(f"Found match with underscores: {combined_underscore}")
-                    break
-                elif test_path_hyphen.exists():
-                    current_path = test_path_hyphen
-                    i += lookahead + 1
-                    found_match = True
-                    _log(f"Found match with hyphens: {combined_hyphen}")
-                    break
-
-            if not found_match:
-                # If no match found, this might be the final segment (file or non-existent dir)
-                # Just append remaining segments with '/' and check
-                remaining = '/'.join(segments[i:])
-                final_path = current_path / remaining
-                if final_path.exists():
-                    return final_path
-
-                # Try treating remaining as underscore-joined
-                remaining_underscore = '_'.join(segments[i:])
-                final_path_underscore = current_path / remaining_underscore
-                if final_path_underscore.exists():
-                    return final_path_underscore
-
-                # Nothing worked, return what we have
-                _log(f"Could not match segment '{segment}' at path {current_path}")
-                return None
-
-        return current_path if current_path != Path('/') else None
-
-    async def _do_commit(self, project_path: Path):
-        """Perform the actual commit for a specific project."""
         try:
             # Generate commit message
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             message = f"chore: Auto-commit MCP session ({timestamp})"
 
-            _log(f"Attempting commit in {project_path} with message: {message}")
-
-            # Use realign commit command with the specific project path
+            # Use realign commit command
             result = await asyncio.get_event_loop().run_in_executor(
                 None,
                 self._run_realign_commit,
-                message,
-                project_path
+                project_path,
+                message
             )
 
             if result:
-                _log(f"✓ Committed in {project_path}: {message}")
-                self.last_commit_time[str(project_path)] = time.time()
+                print(f"[MCP Watcher] ✓ Committed to {project_path.name}: {message}", file=sys.stderr)
+                # Update last commit time for this project
+                self.last_commit_times[str(project_path)] = time.time()
                 # Baseline counts already updated in _check_if_turn_complete()
 
         except Exception as e:
-            _log(f"Error during commit: {e}")
+            print(f"[MCP Watcher] Error during commit for {project_path}: {e}", file=sys.stderr)
 
-    def _run_realign_commit(self, message: str, project_path: Path) -> bool:
+    def _run_realign_commit(self, project_path: Path, message: str) -> bool:
         """
-        Run aline commit command using Python functions directly.
+        Run realign commit command with file locking to prevent race conditions.
+
+        Args:
+            project_path: Path to the project directory
+            message: Commit message
 
         The command will:
-        - Auto-initialize git and Aline if needed
+        - Acquire a file lock to prevent concurrent commits from multiple watchers
+        - Auto-initialize git and ReAlign if needed
         - Check for session changes (modified within last 5 minutes)
         - Create empty commit if only sessions changed
         - Return True if commit was created, False otherwise
         """
+        from .file_lock import commit_lock
+
         try:
-            from .commands.init import init_repository
-            from .commands.commit import smart_commit
+            # Acquire commit lock to prevent concurrent commits from multiple MCP servers
+            with commit_lock(project_path, timeout=5.0) as locked:
+                if not locked:
+                    print(f"[MCP Watcher] Another watcher is committing to {project_path.name}, skipping", file=sys.stderr)
+                    return False
+
+                return self._do_commit_locked(project_path, message)
+
+        except TimeoutError:
+            print("[MCP Watcher] Could not acquire commit lock (timeout)", file=sys.stderr)
+            return False
+        except Exception as e:
+            print(f"[MCP Watcher] Commit error: {e}", file=sys.stderr)
+            return False
 
-            # Check if Aline is initialized
+    def _do_commit_locked(self, project_path: Path, message: str) -> bool:
+        """
+        Perform the actual commit operation (must be called with lock held).
+
+        Args:
+            project_path: Path to the project directory
+            message: Commit message
+
+        Returns:
+            True if commit was created, False otherwise
+        """
+        try:
+            # Check if ReAlign is initialized
             realign_dir = project_path / ".realign"
 
             if not realign_dir.exists():
-                _log(f"Aline not initialized in {project_path}, initializing...")
-
-                # Auto-initialize Aline (which also inits git if needed)
-                init_result = init_repository(
-                    repo_path=str(project_path),
-                    auto_init_git=True,
-                    skip_commit=False,
+                print(f"[MCP Watcher] ReAlign not initialized in {project_path.name}, initializing...", file=sys.stderr)
+
+                # Auto-initialize ReAlign (which also inits git if needed)
+                init_result = subprocess.run(
+                    ["python3", "-m", "realign.cli", "init", "--yes"],
+                    cwd=project_path,
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
                 )
 
-                if not init_result.get("success"):
-                    _log(f"Failed to initialize Aline: {init_result.get('message', 'Unknown error')}")
+                if init_result.returncode != 0:
+                    print(f"[MCP Watcher] Failed to initialize ReAlign in {project_path.name}: {init_result.stderr}", file=sys.stderr)
                     return False
 
-                _log("✓ Aline initialized successfully")
+                print(f"[MCP Watcher] ✓ ReAlign initialized successfully in {project_path.name}", file=sys.stderr)
 
-            # Now run the commit with stage_all=True
-            result = smart_commit(
+            # Use direct function call instead of subprocess
+            # This allows environment variables (like OPENAI_API_KEY) to be inherited
+            from realign.commands.commit import commit_internal
+
+            success, commit_hash, status_msg = commit_internal(
+                repo_root=project_path,
                 message=message,
-                repo_path=str(project_path),
-                stage_all=True,
+                all_files=True,
                 amend=False,
                 no_edit=False,
             )
 
-            # Check if commit was successful
-            if result.get("success"):
+            if success:
+                print(f"[MCP Watcher] ✓ {status_msg}", file=sys.stderr)
                 return True
-            elif result.get("no_changes"):
+            elif "No changes detected" in status_msg:
                 # No changes - this is expected, not an error
                 return False
             else:
                 # Log the error for debugging
-                error_msg = result.get("message", "Unknown error")
-                _log(f"Commit failed: {error_msg}")
+                print(f"[MCP Watcher] Commit failed for {project_path.name}: {status_msg}", file=sys.stderr)
                 return False
 
         except Exception as e:
-            _log(f"Commit error: {e}")
+            print(f"[MCP Watcher] Commit error for {project_path.name}: {e}", file=sys.stderr)
             return False
 
+    def _detect_project_path(self) -> Optional[Path]:
+        """
+        Attempt to detect the git repository root for the current process.
+        Returns None if not inside a git repo.
+        """
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            repo_path = Path(result.stdout.strip())
+            if repo_path.exists():
+                return repo_path
+        except subprocess.CalledProcessError:
+            current_dir = Path.cwd()
+            if (current_dir / ".git").exists():
+                return current_dir
+        except Exception as e:
+            print(f"[MCP Watcher] Could not detect project path: {e}", file=sys.stderr)
+        return None
+
 
 # Global watcher instance
 _watcher: Optional[DialogueWatcher] = None
 
 
-async def start_watcher(repo_path: Path):
-    """Start the global session watcher for auto-commit on user request completion."""
+async def start_watcher():
+    """
+    Start the global session watcher for auto-commit on user request completion.
+
+    No longer requires a repo_path - the watcher will dynamically extract project paths
+    from session files and commit to the appropriate repositories.
+    """
     global _watcher
 
     if _watcher and _watcher.running:
         print("[MCP Watcher] Already running", file=sys.stderr)
         return
 
-    _watcher = DialogueWatcher(repo_path)
+    _watcher = DialogueWatcher()
     asyncio.create_task(_watcher.start())