Make project-scope sym-lib-table visible to symbol-discovery tools

search_symbols, list_symbol_libraries, list_library_symbols, and
get_symbol_info previously only consulted the global sym-lib-table. A
library registered with project scope (an entry in
<project>/sym-lib-table) was therefore invisible — even right after
open_project succeeded — making add_schematic_component the only tool
that could see it.

Fix has two parts:

1. Wrap project_commands.open_project and project_commands.create_project
   in handlers that rebuild SymbolLibraryCommands.library_manager against
   the project directory. After open_project, project-scope libraries are
   automatically visible to subsequent search/list/info calls.

2. Add an optional projectPath parameter to the four discovery tools
   (accepts a project directory, .kicad_pro, .kicad_pcb, or .kicad_sch
   path). Stateless callers can resolve project libraries without first
   calling open_project. SymbolLibraryCommands._derive_project_path also
   walks up from schematicPath/boardPath to find the directory that owns
   the project, mirroring the logic in _handle_add_schematic_component.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

python/commands/library_symbol.py

@@ -515,9 +515,57 @@ class SymbolLibraryCommands:
         """Initialize with optional library manager"""
         self.library_manager = library_manager or SymbolLibraryManager()
 
+    @staticmethod
+    def _derive_project_path(params: Dict) -> Optional[Path]:
+        """Derive a project directory from caller-supplied params.
+
+        Accepts an explicit project directory or .kicad_pro file via projectPath,
+        or any related file path (schematicPath/boardPath) — in which case the
+        nearest ancestor containing sym-lib-table or a .kicad_pro is used.
+        """
+        for key in ("projectPath", "project_path"):
+            value = params.get(key)
+            if value:
+                p = Path(value).expanduser()
+                if p.suffix == ".kicad_pro" or p.is_file():
+                    p = p.parent
+                return p
+
+        for key in ("schematicPath", "boardPath"):
+            value = params.get(key)
+            if value:
+                start = Path(value).expanduser().parent
+                for ancestor in [start, *start.parents]:
+                    if (ancestor / "sym-lib-table").exists() or list(
+                        ancestor.glob("*.kicad_pro")
+                    ):
+                        return ancestor
+                return start
+
+        return None
+
+    def use_project(self, project_path: Optional[Path]) -> None:
+        """Switch the underlying manager to load project-scope libraries.
+
+        Callers (e.g. open_project / create_project) use this to make
+        `<project>/sym-lib-table` visible to subsequent search/list/info calls
+        without requiring every caller to pass projectPath.
+        """
+        if project_path is None:
+            return
+        if self.library_manager.project_path == project_path:
+            return
+        logger.info(f"Rebuilding SymbolLibraryManager for project: {project_path}")
+        self.library_manager = SymbolLibraryManager(project_path=project_path)
+
+    def _ensure_manager_for(self, params: Dict) -> None:
+        """Rebuild the library manager if the caller's project differs."""
+        self.use_project(self._derive_project_path(params))
+
     def list_symbol_libraries(self, params: Dict) -> Dict:
         """List all available symbol libraries"""
         try:
+            self._ensure_manager_for(params)
             libraries = self.library_manager.list_libraries()
             return {"success": True, "libraries": libraries, "count": len(libraries)}
         except Exception as e:
@@ -535,6 +583,8 @@ class SymbolLibraryCommands:
             if not query:
                 return {"success": False, "message": "Missing query parameter"}
 
+            self._ensure_manager_for(params)
+
             limit = params.get("limit", 20)
             library_filter = params.get("library")
 
@@ -557,6 +607,8 @@ class SymbolLibraryCommands:
             if not library:
                 return {"success": False, "message": "Missing library parameter"}
 
+            self._ensure_manager_for(params)
+
             # Check if library exists in sym-lib-table
             if library not in self.library_manager.libraries:
                 available_libs = list(self.library_manager.libraries.keys())
@@ -593,6 +645,8 @@ class SymbolLibraryCommands:
             if not symbol_spec:
                 return {"success": False, "message": "Missing symbol parameter"}
 
+            self._ensure_manager_for(params)
+
             result = self.library_manager.find_symbol(symbol_spec)
 
             if result: