portacode 1.3.32__py3-none-any.whl → 1.4.11.dev5__py3-none-any.whl

portacode/connection/handlers/project_state/handlers.py

@@ -411,7 +411,11 @@ class ProjectStateGitStageHandler(AsyncHandler):
 
         if success:
             # Refresh git status only (no filesystem changes from staging)
-            await manager._refresh_project_state(source_client_session, git_only=True)
+            await manager._refresh_project_state(
+                source_client_session,
+                git_only=True,
+                reason="git_stage",
+            )
         
         # Build response
         response = {
@@ -485,7 +489,11 @@ class ProjectStateGitUnstageHandler(AsyncHandler):
 
         if success:
             # Refresh git status only (no filesystem changes from unstaging)
-            await manager._refresh_project_state(source_client_session, git_only=True)
+            await manager._refresh_project_state(
+                source_client_session,
+                git_only=True,
+                reason="git_unstage",
+            )
         
         # Build response
         response = {
@@ -559,7 +567,10 @@ class ProjectStateGitRevertHandler(AsyncHandler):
         
         if success:
             # Refresh entire project state to ensure consistency
-            await manager._refresh_project_state(source_client_session)
+            await manager._refresh_project_state(
+                source_client_session,
+                reason="git_revert",
+            )
         
         # Build response
         response = {
@@ -622,7 +633,11 @@ class ProjectStateGitCommitHandler(AsyncHandler):
                 commit_hash = git_manager.get_head_commit_hash()
 
                 # Refresh git status only (no filesystem changes from commit)
-                await manager._refresh_project_state(source_client_session, git_only=True)
+                await manager._refresh_project_state(
+                    source_client_session,
+                    git_only=True,
+                    reason="git_commit",
+                )
         except Exception as e:
             error_message = str(e)
             logger.error("Error during commit: %s", error_message)
@@ -656,7 +671,7 @@ async def handle_client_session_cleanup(handler, payload: Dict[str, Any], source
     manager = get_or_create_project_state_manager(handler.context, handler.control_channel)
     
     # Clean up the client session's project state
-    manager.cleanup_projects_by_client_session(client_session_id)
+    await manager.cleanup_projects_by_client_session(client_session_id)
     
     logger.info("Client session cleanup completed: %s", client_session_id)
     
@@ -764,14 +779,13 @@ class ProjectStateDiffContentHandler(AsyncHandler):
             if content is None or (content_type == "all" and not all([matching_tab.original_content, matching_tab.modified_content])):
                 if content_type in ["original", "modified", "all"]:
                     # Re-generate the diff content if needed
-                    await manager.create_diff_tab(
-                        source_client_session, 
-                        file_path, 
-                        from_ref, 
-                        to_ref, 
-                        from_hash, 
-                        to_hash,
-                        activate=False  # Don't activate, just ensure content is loaded
+                    await manager.open_diff_tab(
+                        source_client_session,
+                        file_path,
+                        from_ref,
+                        to_ref,
+                        from_hash,
+                        to_hash
                     )
                     
                     # Try to get content again after regeneration (use same matching logic)
@@ -858,4 +872,4 @@ class ProjectStateDiffContentHandler(AsyncHandler):
             # Add request_id if present in original message
             if "request_id" in message:
                 error_response["request_id"] = message["request_id"]
-            await self.send_response(error_response, project_id=server_project_id)
+            await self.send_response(error_response, project_id=server_project_id)

portacode/connection/handlers/project_state/manager.py

@@ -11,6 +11,8 @@ import logging
 import os
 import threading
 import time
+from pathlib import Path
+from asyncio import Lock
 from dataclasses import asdict
 from typing import Any, Dict, List, Optional, Set
 
@@ -34,9 +36,12 @@ class ProjectStateManager:
         self.context = context
         self.projects: Dict[str, ProjectState] = {}
         self.git_managers: Dict[str, GitManager] = {}
+        self._shared_git_managers: Dict[str, Dict[str, Any]] = {}
+        self._shared_git_lock: Lock = Lock()
         self.file_watcher = FileSystemWatcher(self)
         self.debug_mode = False
         self.debug_file_path: Optional[str] = None
+        self._session_locks: Dict[str, Lock] = {}
         
         # Content caching optimization
         self.use_content_caching = context.get("use_content_caching", False)
@@ -44,6 +49,7 @@ class ProjectStateManager:
         # Debouncing for file changes
         self._change_debounce_timer: Optional[asyncio.Task] = None
         self._pending_changes: Set[str] = set()
+        self._pending_change_sources: Dict[str, Dict[str, Any]] = {}
     
     def set_debug_mode(self, enabled: bool, debug_file_path: Optional[str] = None):
         """Enable or disable debug mode with JSON output."""
@@ -52,6 +58,14 @@ class ProjectStateManager:
         if enabled:
             logger.info("Project state debug mode enabled, output to: %s", debug_file_path)
     
+    def _get_session_lock(self, client_session_id: str) -> Lock:
+        """Get or create an asyncio lock for a client session."""
+        lock = self._session_locks.get(client_session_id)
+        if not lock:
+            lock = Lock()
+            self._session_locks[client_session_id] = lock
+        return lock
+    
     def _write_debug_state(self):
         """Write current state to debug JSON file (thread-safe)."""
         if not self.debug_mode or not self.debug_file_path:
@@ -127,65 +141,115 @@ class ProjectStateManager:
                 metadata.pop('diff_details', None)
             
         return tab_dict
+
+    async def _handle_shared_git_change(self, project_folder_path: str):
+        """Notify all sessions for a project when the shared git manager detects changes."""
+        async with self._shared_git_lock:
+            entry = self._shared_git_managers.get(project_folder_path)
+            target_sessions = list(entry["sessions"]) if entry else []
+
+        for session_id in target_sessions:
+            await self._refresh_project_state(session_id, git_only=True, reason="git_monitor")
+
+    async def _acquire_shared_git_manager(self, project_folder_path: str, client_session_id: str) -> GitManager:
+        """Get or create a shared git manager for a project path."""
+        async with self._shared_git_lock:
+            entry = self._shared_git_managers.get(project_folder_path)
+
+            if not entry:
+                async def git_change_callback():
+                    await self._handle_shared_git_change(project_folder_path)
+
+                git_manager = GitManager(
+                    project_folder_path,
+                    change_callback=git_change_callback,
+                    owner_session_id=client_session_id,
+                )
+                entry = {"manager": git_manager, "sessions": set()}
+                self._shared_git_managers[project_folder_path] = entry
+
+            entry["sessions"].add(client_session_id)
+            self.git_managers[client_session_id] = entry["manager"]
+            return entry["manager"]
+
+    async def _release_shared_git_manager(self, project_folder_path: Optional[str], client_session_id: str):
+        """Release a session's reference to a shared git manager and clean it up if unused."""
+        manager_to_cleanup: Optional[GitManager] = None
+
+        async with self._shared_git_lock:
+            manager = self.git_managers.pop(client_session_id, None)
+
+            if not project_folder_path:
+                manager_to_cleanup = manager
+            else:
+                entry = self._shared_git_managers.get(project_folder_path)
+                if entry:
+                    entry["sessions"].discard(client_session_id)
+                    if not entry["sessions"]:
+                        self._shared_git_managers.pop(project_folder_path, None)
+                        manager_to_cleanup = manager or entry["manager"]
+                else:
+                    manager_to_cleanup = manager
+
+        if manager_to_cleanup:
+            manager_to_cleanup.cleanup()
     
     async def initialize_project_state(self, client_session_id: str, project_folder_path: str) -> ProjectState:
         """Initialize project state for a client session."""
-        # Check if this client session already has a project state
-        if client_session_id in self.projects:
-            existing_project = self.projects[client_session_id]
-            # If it's the same folder, return existing state
-            if existing_project.project_folder_path == project_folder_path:
-                logger.info("Returning existing project state for client session: %s", client_session_id)
-                return existing_project
-            else:
-                # Different folder - cleanup old state and create new one
-                logger.info("Client session %s switching projects from %s to %s", 
-                          client_session_id, existing_project.project_folder_path, project_folder_path)
-                self.cleanup_project(client_session_id)
-        
-        # Note: Multiple client sessions can have independent project states for the same folder
-        # Each client session gets its own project state instance
-        
-        logger.info("Initializing project state for client session: %s, folder: %s", client_session_id, project_folder_path)
-        
-        # Initialize Git manager with change callback
-        async def git_change_callback():
-            """Callback when git status changes are detected."""
-            logger.debug("Git change detected, refreshing project state for %s", client_session_id)
-            # Git directory changes only affect git status, not filesystem
-            await self._refresh_project_state(client_session_id, git_only=True)
-        
-        git_manager = GitManager(project_folder_path, change_callback=git_change_callback)
-        self.git_managers[client_session_id] = git_manager
+        lock = self._get_session_lock(client_session_id)
+        async with lock:
+            existing_project = self.projects.get(client_session_id)
+            if existing_project:
+                if existing_project.project_folder_path == project_folder_path:
+                    logger.info("Returning existing project state for client session: %s", client_session_id)
+                    return existing_project
+                logger.info("Client session %s switching projects from %s to %s",
+                            client_session_id, existing_project.project_folder_path, project_folder_path)
+                previous_path = self._cleanup_project_locked(client_session_id)
+                await self._release_shared_git_manager(previous_path, client_session_id)
+            
+            logger.info("Initializing project state for client session: %s, folder: %s", client_session_id, project_folder_path)
+            git_manager = await self._acquire_shared_git_manager(project_folder_path, client_session_id)
+            
+            loop = asyncio.get_event_loop()
+            is_git_repo = git_manager.is_git_repo
+            git_branch = await loop.run_in_executor(None, git_manager.get_branch_name)
+            git_status_summary = await loop.run_in_executor(None, git_manager.get_status_summary)
+            git_detailed_status = await loop.run_in_executor(None, git_manager.get_detailed_status)
+            
+            project_state = ProjectState(
+                client_session_id=client_session_id,
+                project_folder_path=project_folder_path,
+                items=[],
+                is_git_repo=is_git_repo,
+                git_branch=git_branch,
+                git_status_summary=git_status_summary,
+                git_detailed_status=git_detailed_status,
+            )
+            
+            await self._initialize_monitored_folders(project_state)
+            await self._sync_all_state_with_monitored_folders(project_state)
+            
+            self.projects[client_session_id] = project_state
+            self._write_debug_state()
+            
+            return project_state
 
-        # Run git operations in executor to avoid blocking event loop
-        loop = asyncio.get_event_loop()
-        is_git_repo = git_manager.is_git_repo
-        git_branch = await loop.run_in_executor(None, git_manager.get_branch_name)
-        git_status_summary = await loop.run_in_executor(None, git_manager.get_status_summary)
-        git_detailed_status = await loop.run_in_executor(None, git_manager.get_detailed_status)
+    def get_diagnostics(self) -> Dict[str, Any]:
+        """Return aggregate stats for health monitoring."""
+        git_diag = {}
+        for session_id, git_manager in self.git_managers.items():
+            git_diag[session_id] = git_manager.get_diagnostics()
 
-        # Create project state
-        project_state = ProjectState(
-            client_session_id=client_session_id,
-            project_folder_path=project_folder_path,
-            items=[],
-            is_git_repo=is_git_repo,
-            git_branch=git_branch,
-            git_status_summary=git_status_summary,
-            git_detailed_status=git_detailed_status
-        )
-        
-        # Initialize monitored folders with project root and its immediate subdirectories
-        await self._initialize_monitored_folders(project_state)
-        
-        # Sync all dependent state (items, watchdog)
-        await self._sync_all_state_with_monitored_folders(project_state)
-        
-        self.projects[client_session_id] = project_state
-        self._write_debug_state()
-        
-        return project_state
+        watcher_diag = self.file_watcher.get_diagnostics() if self.file_watcher else {}
+
+        return {
+            "projects": len(self.projects),
+            "git_managers": len(self.git_managers),
+            "pending_file_changes": len(self._pending_changes),
+            "watcher": watcher_diag,
+            "git_sessions": git_diag,
+        }
     
     async def _initialize_monitored_folders(self, project_state: ProjectState):
         """Initialize monitored folders with project root (expanded) and its immediate subdirectories (collapsed)."""
@@ -216,18 +280,12 @@ class ProjectStateManager:
         for monitored_folder in project_state.monitored_folders:
             self.file_watcher.start_watching(monitored_folder.folder_path)
         
-        # For git repositories, also watch the .git directory for git status changes
+        # Intentionally avoid watching .git; Git status changes are polled separately
         if project_state.is_git_repo:
             git_dir_path = os.path.join(project_state.project_folder_path, '.git')
-            logger.debug("🔍 [TRACE] Project is git repo, checking .git directory: %s", LogCategory.GIT, git_dir_path)
-            if os.path.exists(git_dir_path):
-                logger.debug("🔍 [TRACE] ✅ Starting to watch .git directory: %s", LogCategory.GIT, git_dir_path)
-                self.file_watcher.start_watching_git_directory(git_dir_path)
-                logger.debug("🔍 [TRACE] ✅ Started monitoring .git directory for git status changes: %s", LogCategory.GIT, git_dir_path)
-            else:
-                logger.error("🔍 [TRACE] ❌ .git directory does not exist: %s", LogCategory.GIT, git_dir_path)
+            logger.debug("🔍 [TRACE] Project is git repo, but skipping .git watcher registration: %s", LogCategory.GIT, git_dir_path)
         else:
-            logger.debug("🔍 [TRACE] Project is NOT a git repo, skipping .git directory monitoring", LogCategory.GIT)
+            logger.debug("🔍 [TRACE] Project is NOT a git repo, no .git watcher needed", LogCategory.GIT)
         
         # Watchdog synchronized
     
@@ -308,8 +366,8 @@ class ProjectStateManager:
             with os.scandir(directory_path) as entries:
                 for entry in entries:
                     try:
-                        # Skip .git folders and their contents
-                        if entry.name == '.git' and entry.is_dir():
+                        # Skip .git metadata regardless of whether it's a dir or file (worktrees create files)
+                        if entry.name == '.git':
                             continue
                             
                         stat_info = entry.stat()
@@ -380,9 +438,10 @@ class ProjectStateManager:
                 child_paths = []
                 with os.scandir(monitored_folder.folder_path) as entries:
                     for entry in entries:
-                        if entry.name != '.git' or not entry.is_dir():
-                            child_paths.append(entry.path)
-                            all_file_paths.append(entry.path)
+                        if entry.name == '.git':
+                            continue
+                        child_paths.append(entry.path)
+                        all_file_paths.append(entry.path)
                 folder_to_paths[monitored_folder.folder_path] = child_paths
             except (OSError, PermissionError) as e:
                 logger.error("Error scanning folder %s: %s", monitored_folder.folder_path, e)
@@ -465,8 +524,8 @@ class ProjectStateManager:
             with os.scandir(directory_path) as entries:
                 for entry in entries:
                     try:
-                        # Skip .git folders and their contents
-                        if entry.name == '.git' and entry.is_dir():
+                        # Skip .git metadata regardless of whether it's a dir or file (worktrees create files)
+                        if entry.name == '.git':
                             continue
 
                         stat_info = entry.stat()
@@ -816,8 +875,18 @@ class ProjectStateManager:
     async def _handle_file_change(self, event):
         """Handle file system change events with debouncing."""
         logger.debug("🔍 [TRACE] _handle_file_change called: %s - %s", LogCategory.FILE_SYSTEM, event.event_type, event.src_path)
+        is_git_event = ".git" in Path(event.src_path).parts
+        if is_git_event:
+            logger.info("File watcher event from .git: %s %s", LogCategory.FILE_SYSTEM, event.event_type, event.src_path)
+        else:
+            logger.debug("File watcher event: %s %s", LogCategory.FILE_SYSTEM, event.event_type, event.src_path)
         
         self._pending_changes.add(event.src_path)
+        self._pending_change_sources[event.src_path] = {
+            "event_type": event.event_type,
+            "is_git_event": is_git_event,
+            "timestamp": time.time(),
+        }
         logger.debug("🔍 [TRACE] Added to pending changes: %s (total pending: %d)", LogCategory.FILE_SYSTEM, event.src_path, len(self._pending_changes))
         
         # Cancel existing timer
@@ -849,6 +918,16 @@ class ProjectStateManager:
             return
         
         logger.debug("🔍 [TRACE] Processing %d pending file changes: %s", len(self._pending_changes), list(self._pending_changes))
+        git_events = [path for path in self._pending_changes if self._pending_change_sources.get(path, {}).get("is_git_event")]
+        workspace_events = [path for path in self._pending_changes if path not in git_events]
+        logger.info(
+            "Pending change summary: total=%d git_events=%d workspace_events=%d sample_git=%s",
+            LogCategory.FILE_SYSTEM,
+            len(self._pending_changes),
+            len(git_events),
+            len(workspace_events),
+            git_events[:3],
+        )
         
         # Process changes for each affected project
         affected_projects = set()
@@ -872,13 +951,38 @@ class ProjectStateManager:
         
         # Refresh affected projects
         for client_session_id in affected_projects:
-            logger.debug("🔍 [TRACE] About to refresh project state for session: %s", client_session_id)
-            await self._refresh_project_state(client_session_id)
+            project_state = self.projects.get(client_session_id)
+            if not project_state:
+                continue
+            project_paths = [
+                path for path in self._pending_changes
+                if path.startswith(project_state.project_folder_path)
+            ]
+            git_paths = [
+                path for path in project_paths
+                if self._pending_change_sources.get(path, {}).get("is_git_event")
+            ]
+            is_git_only_batch = bool(project_paths) and len(project_paths) == len(git_paths)
+            logger.info(
+                "Refreshing project %s due to pending changes: total_paths=%d git_paths=%d git_only_batch=%s sample_paths=%s",
+                LogCategory.FILE_SYSTEM,
+                client_session_id,
+                len(project_paths),
+                len(git_paths),
+                is_git_only_batch,
+                project_paths[:3],
+            )
+            await self._refresh_project_state(
+                client_session_id,
+                git_only=is_git_only_batch,
+                reason="filesystem_watch_git_only" if is_git_only_batch else "filesystem_watch",
+            )
         
         self._pending_changes.clear()
+        self._pending_change_sources.clear()
         logger.debug("🔍 [TRACE] ✅ Finished processing file changes")
     
-    async def _refresh_project_state(self, client_session_id: str, git_only: bool = False):
+    async def _refresh_project_state(self, client_session_id: str, git_only: bool = False, reason: str = "unknown"):
         """Refresh project state after file changes.
 
         Args:
@@ -887,8 +991,8 @@ class ProjectStateManager:
                      detecting new directories and syncing file state). Use this for
                      git operations (stage, unstage, revert) to avoid unnecessary work.
         """
-        logger.debug("🔍 [TRACE] _refresh_project_state called for session: %s (git_only=%s)",
-                   client_session_id, git_only)
+        logger.debug("🔍 [TRACE] _refresh_project_state called for session: %s (git_only=%s, reason=%s)",
+                   client_session_id, git_only, reason)
         
         if client_session_id not in self.projects:
             logger.debug("🔍 [TRACE] ❌ Session not found in projects: %s", client_session_id)
@@ -906,19 +1010,11 @@ class ProjectStateManager:
             # Git repo was created
             logger.debug("🔍 [TRACE] Git repo detected, reinitializing git manager for session: %s", client_session_id)
             git_manager.reinitialize()
-            
-            # Start watching .git directory for git status changes
-            if git_manager.is_git_repo:
-                logger.debug("🔍 [TRACE] Starting to watch .git directory: %s", git_dir_path)
-                self.file_watcher.start_watching_git_directory(git_dir_path)
         elif git_manager.is_git_repo and not git_dir_exists:
             # Git repo was deleted
             logger.debug("🔍 [TRACE] Git repo removed, updating git manager for session: %s", client_session_id)
             git_manager.repo = None
             git_manager.is_git_repo = False
-            
-            # Stop watching .git directory
-            self.file_watcher.stop_watching(git_dir_path)
         
         # Update Git status
         if git_manager:
@@ -1063,10 +1159,33 @@ class ProjectStateManager:
         except Exception as e:
             logger.error("🔍 [TRACE] ❌ Failed to send project_state_update: %s", e)
     
-    def cleanup_project(self, client_session_id: str):
+    async def cleanup_project(self, client_session_id: str):
         """Clean up project state and resources."""
-        if client_session_id in self.projects:
-            project_state = self.projects[client_session_id]
+        lock = self._get_session_lock(client_session_id)
+        async with lock:
+            project_folder_path = self._cleanup_project_locked(client_session_id)
+        await self._release_shared_git_manager(project_folder_path, client_session_id)
+
+    def _cleanup_project_locked(self, client_session_id: str) -> Optional[str]:
+        """Internal helper to release resources associated with a project state. Lock must be held."""
+        project_state = self.projects.get(client_session_id)
+        project_folder_path = project_state.project_folder_path if project_state else None
+        
+        if project_state:
+            # Cancel debounce timer to prevent pending refreshes running after cleanup
+            if self._change_debounce_timer and not self._change_debounce_timer.done():
+                try:
+                    self._change_debounce_timer.cancel()
+                except Exception:
+                    pass
+            # Remove pending file change events related to this project
+            if self._pending_changes:
+                removed = [path for path in list(self._pending_changes) if path.startswith(project_state.project_folder_path)]
+                for path in removed:
+                    self._pending_changes.discard(path)
+                    self._pending_change_sources.pop(path, None)
+                if removed:
+                    logger.debug("Removed %d pending change paths for session %s during cleanup", len(removed), client_session_id)
             
             # Stop watching all monitored folders for this project
             for monitored_folder in project_state.monitored_folders:
@@ -1077,34 +1196,34 @@ class ProjectStateManager:
                 git_dir_path = os.path.join(project_state.project_folder_path, '.git')
                 self.file_watcher.stop_watching(git_dir_path)
             
-            # Clean up managers
-            git_manager = self.git_managers.get(client_session_id)
-            if git_manager:
-                git_manager.cleanup()
-            self.git_managers.pop(client_session_id, None)
             self.projects.pop(client_session_id, None)
-            
             logger.info("Cleaned up project state: %s", client_session_id)
-            self._write_debug_state()
+        else:
+            logger.info("No project state found for client session: %s during cleanup", client_session_id)
+        
+        # Clean up associated git manager even if project state was not registered
+        # (actual cleanup occurs when shared git manager refcount drops to zero)
+        self._write_debug_state()
+        return project_folder_path
     
-    def cleanup_projects_by_client_session(self, client_session_id: str):
+    async def cleanup_projects_by_client_session(self, client_session_id: str):
         """Clean up project state for a specific client session when explicitly notified of disconnection."""
         logger.info("Explicitly cleaning up project state for disconnected client session: %s", client_session_id)
         
         # With the new design, each client session has only one project
         if client_session_id in self.projects:
-            self.cleanup_project(client_session_id)
+            await self.cleanup_project(client_session_id)
             logger.info("Cleaned up project state for client session: %s", client_session_id)
         else:
             logger.info("No project state found for client session: %s", client_session_id)
     
-    def cleanup_all_projects(self):
+    async def cleanup_all_projects(self):
         """Clean up all project states. Used for shutdown or reset."""
         logger.info("Cleaning up all project states")
         
         client_session_ids = list(self.projects.keys())
         for client_session_id in client_session_ids:
-            self.cleanup_project(client_session_id)
+            await self.cleanup_project(client_session_id)
         
         logger.info("Cleaned up %d project states", len(client_session_ids))
     
@@ -1121,13 +1240,13 @@ class ProjectStateManager:
                 Path(file_path).relative_to(project_folder)
                 # File is within this project, trigger refresh
                 logger.info(f"Refreshing project state for session {client_session_id} after file change: {file_path}")
-                await self._refresh_project_state(client_session_id)
+                await self._refresh_project_state(client_session_id, reason="manual_file_change")
                 break
             except ValueError:
                 # File is not within this project
                 continue
 
-    def cleanup_orphaned_project_states(self, current_client_sessions: List[str]):
+    async def cleanup_orphaned_project_states(self, current_client_sessions: List[str]):
         """Clean up project states that don't match any current client session."""
         current_sessions_set = set(current_client_sessions)
         orphaned_keys = []
@@ -1139,7 +1258,7 @@ class ProjectStateManager:
         if orphaned_keys:
             logger.info("Found %d orphaned project states, cleaning up: %s", len(orphaned_keys), orphaned_keys)
             for session_id in orphaned_keys:
-                self.cleanup_project(session_id)
+                await self.cleanup_project(session_id)
             logger.info("Cleaned up %d orphaned project states", len(orphaned_keys))
         else:
             logger.debug("No orphaned project states found")
@@ -1183,6 +1302,12 @@ def get_or_create_project_state_manager(context: Dict[str, Any], control_channel
             return _global_project_state_manager
 
 
+def get_global_project_state_manager() -> Optional['ProjectStateManager']:
+    """Return the current global project state manager if it exists."""
+    with _manager_lock:
+        return _global_project_state_manager
+
+
 def reset_global_project_state_manager():
     """Reset the global project state manager (for testing/cleanup)."""
     global _global_project_state_manager
@@ -1203,4 +1328,4 @@ def debug_global_manager_state():
             logger.info("Active project states: %s", list(_global_project_state_manager.projects.keys()))
             logger.info("Total project states: %d", len(_global_project_state_manager.projects))
         else:
-            logger.info("No global ProjectStateManager exists (PID: %s)", os.getpid())
+            logger.info("No global ProjectStateManager exists (PID: %s)", os.getpid())