codegraph-engine 2.3.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

codegraph/mcp/server.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 import functools
 import json
 from pathlib import Path
 from typing import Any
 
+import anyio
+
 from codegraph.architecture import get_architecture as arch_get_architecture
 from codegraph.config import Settings
 from codegraph.context import _resolve_task_or_query_input
@@ -442,9 +445,9 @@ def create_server(
         task: dict[str, Any] | str = "",
         intent: str | None = None,
         max_tokens: int = 4000,
-        max_files: int = 15,
+        max_files: int = 25,
         max_lines: int = 500,
-        top_k: int = 15,
+        top_k: int = 25,
         plan: dict[str, Any] | None = None,
         mode: str = "BALANCED",
         explain: bool = False,
@@ -609,7 +612,7 @@ def create_server(
             return [
                 dict(r)
                 for r in con.execute(
-                    "SELECT source_path,imported FROM imports ORDER BY source_path,imported LIMIT 500"
+                    "SELECT source_path, COALESCE(NULLIF(imported_module, ''), module) AS imported FROM imports ORDER BY source_path, imported LIMIT 500"
                 )
             ]
 
@@ -956,6 +959,64 @@ def create_server(
         with indexer.session() as con:
             return runtime_reconcile_static_runtime(con, indexer.repository, symbol=symbol, route=route, table=table)
 
+    def get_live_services() -> dict[str, Any]:
+        """Detect and attribute active localhost services, ports, PIDs, frameworks, and workspace sub-packages with zero idle CPU. Use when diagnosing running dev servers or multi-service architectures. Does not prove live HTTP response payloads or application layer health."""
+        from codegraph.runtime.port_inspector import (
+            discover_live_listening_ports,
+            discover_static_configured_ports,
+        )
+        live = [s.as_dict() for s in discover_live_listening_ports(indexer.repository)]
+        static = [s.as_dict() for s in discover_static_configured_ports(indexer.repository).values()]
+        return {"live_services": live, "configured_services": static, "count": len(live)}
+
+    def check_db_drift() -> dict[str, Any]:
+        """Detect database schema drift between migration files, live database state, and code ORM models with zero idle CPU. Flags unmapped tables, missing columns, and migration version state. Use when verifying whether database migrations are up to date with code models. Does not execute SQL data assertions or validate column constraints against live row data."""
+        from codegraph.runtime.db_watcher import detect_schema_drift
+        with indexer.session() as con:
+            return detect_schema_drift(con, indexer.repository).as_dict()
+
+    def get_distributed_trace(trace_id: str) -> dict[str, Any]:
+        """Stitch and reconstruct multi-service distributed execution trees across frontend, backend, and database boundaries for a specific W3C trace ID. Use when tracing cross-service requests or debugging multi-service latency bottlenecks. Does not capture unobserved code paths or untraced sidecar requests."""
+        from codegraph.runtime.trace_linker import link_distributed_trace
+        with indexer.session() as con:
+            res = link_distributed_trace(con, indexer.repository, trace_id)
+            return res.as_dict() if res else {"status": "not_found", "trace_id": trace_id}
+
+    def check_route_schema_drift(
+        route: str = "",
+        handler: str = "",
+        table: str | None = None,
+        schema: str | None = None,
+    ) -> dict[str, Any]:
+        """Detect schema validation drift between a route/handler input schema (Pydantic BaseModel, Django Form, DRF Serializer) and destination database table columns. Flags MISSING_REQUIRED_COLUMN, NULLABILITY_MISMATCH, TYPE_INCOMPATIBILITY, LENGTH_CONSTRAINT_DRIFT, and UNUSED_SCHEMA_FIELD. Does not execute live requests."""
+        from codegraph.database.schema_drift import detect_schema_drift as impl_detect_drift
+        target = route or handler
+        with indexer.session() as con:
+            return impl_detect_drift(
+                con,
+                indexer.repository,
+                route_or_handler=target,
+                target_table=table,
+                schema_name=schema,
+            )
+
+    def check_api_drift() -> dict[str, Any]:
+        """Detect client-server API contract drift between frontend fetch or axios calls and backend route registrations. Flags orphaned client endpoints (404s), HTTP method mismatches (405s), and cross-language TypeScript-to-backend model drift. Use when validating frontend API calls against backend endpoints before deployment. Does not execute live HTTP requests or validate dynamic URL strings constructed via runtime interpolation."""
+        from codegraph.api_drift import detect_api_contract_drift
+        with indexer.session() as con:
+            return detect_api_contract_drift(con, indexer.repository).as_dict()
+
+    def get_monorepo_packages() -> dict[str, Any]:
+        """Catalog monorepo workspace packages, tools (pnpm, Turborepo, npm/yarn workspaces), entry points, and inter-package dependencies. Use when mapping multi-package repository structure and package boundaries. Does not prove build system execution order or runtime dependency loading."""
+        from codegraph.monorepo import discover_workspace
+        return discover_workspace(indexer.repository).as_dict()
+
+    def find_dead_code(max_symbols: int = 50) -> dict[str, Any]:
+        """Detect zero-caller functions, classes, uncalled zombie HTTP routes, and orphaned database tables by cross-referencing AST graphs with runtime traces. Use when identifying unused code, zombie endpoints, or unread/unwritten database tables. Does not prove unobserved paths are impossible when runtime traces are absent."""
+        from codegraph.dead_code import analyze_dead_code
+        with indexer.session() as con:
+            return analyze_dead_code(con, indexer.repository, max_symbols=max_symbols).as_dict()
+
     # -----------------------------------------------------------------------
     # Git Intelligence Tools (5 Unified Capabilities)
     # -----------------------------------------------------------------------
@@ -980,8 +1041,12 @@ def create_server(
     def get_change_impact(base: str = "HEAD~1", head: str = "HEAD", max_depth: int = 2, max_results: int = 50) -> dict[str, Any]:
         """Compute deep downstream change impact across callers, callees, framework routes, covering tests, mutating database queries, and monorepo packages. Use when analyzing blast radius and ripple effects of git commits. Does not assume unobserved runtime paths are impossible."""
         from codegraph.change_impact import get_deep_change_impact
+        target_sym = None
+        clean_base = base.strip()
+        if clean_base.startswith("symbol:"):
+            target_sym = clean_base.split("symbol:", 1)[1]
         with indexer.session() as con:
-            return get_deep_change_impact(indexer.repository, con, base=base, head=head, max_depth=max_depth, max_results=max_results).as_dict()
+            return get_deep_change_impact(indexer.repository, con, base=base, head=head, max_depth=max_depth, max_results=max_results, symbol=target_sym).as_dict()
 
     def check_context_freshness(task: str = "", context_packet: dict[str, Any] | None = None) -> dict[str, Any]:
         """Validate whether a previously compiled context packet or task context is still VALID, PARTIALLY_STALE, or STALE. Use when checking if cached context is valid after edits. Does not invalidate context when only unrelated files change."""
@@ -1015,6 +1080,323 @@ def create_server(
         with indexer.session() as con:
             return impl_detect_semantic_conflicts(indexer.repository, base_branch=base_branch, head_branch=head_branch, con=con).as_dict()
 
+    def safe_rename(
+        target: str,
+        new_name: str,
+        dry_run: bool = True,
+        force_uncertain: bool = False,
+    ) -> dict[str, Any]:
+        """Perform a deterministic, syntax-validated, transaction-safe AST rename of a symbol across the repository.
+        Follows the core invariant: DISCOVER -> PLAN -> PREVIEW -> VALIDATE -> COMMIT -> REINDEX -> VERIFY.
+        When dry_run=True, performs zero disk mutation and returns preview diffs, risk assessment, affected tests, and affected routes.
+        When dry_run=False, validates all preconditions and syntax in memory, commits atomically using sibling temp files and os.replace, persists a rollback manifest, and triggers an incremental index update.
+        If risk != LOW (due to UNKNOWN/POSSIBLE/AMBIGUOUS references), the rename is BLOCKED unless force_uncertain=True."""
+        from codegraph.refactor.renamer import execute_safe_rename
+
+        with indexer.session() as con:
+            result = execute_safe_rename(
+                repository=indexer.repository,
+                con=con,
+                target=target,
+                new_name=new_name,
+                dry_run=dry_run,
+                force_uncertain=force_uncertain,
+            )
+            return result.to_dict()
+
+    def rollback_refactor(
+        transaction_id: str,
+    ) -> dict[str, Any]:
+        """Atomically rollback an applied refactoring transaction using its rollback manifest ID.
+        Verifies that files on disk have not been modified externally since the refactor before restoring original contents."""
+        from codegraph.refactor.models import RefactorStatus
+        from codegraph.refactor.transactions import rollback_refactor as do_rollback
+
+        result = do_rollback(
+            repository=indexer.repository,
+            transaction_id=transaction_id,
+        )
+        if result.status == RefactorStatus.ROLLED_BACK:
+            try:
+                indexer.index()
+            except Exception:
+                pass
+        return result.to_dict()
+
+    def batch_get_symbols(symbols: list[str]) -> dict[str, Any]:
+        """Retrieve declaration metadata, signature, kind, and source snippet for multiple symbols in a single round-trip.
+        Reduces LLM latency and tool call overhead when inspecting multiple related symbols. Bounded to 50 symbols max."""
+        bounded_symbols = symbols[:50]
+        results: dict[str, Any] = {}
+        with indexer.session() as con:
+            for s in bounded_symbols:
+                s_str = str(s).strip()
+                if not s_str:
+                    continue
+                results[s_str] = interrogation_get_symbol(con, indexer.repository, symbol=s_str)
+        return {
+            "results": results,
+            "count": len(results),
+            "found_count": sum(1 for r in results.values() if r.get("status") != "NOT_FOUND"),
+        }
+
+    def batch_find_callers(symbols: list[str], max_results_per_symbol: int = 10) -> dict[str, Any]:
+        """Find functions and methods calling each of the specified symbols in a single round-trip.
+        Reduces multi-hop turn count for AI coding agents. Bounded to 30 symbols max."""
+        bounded_symbols = symbols[:30]
+        results: dict[str, Any] = {}
+        with indexer.session() as con:
+            for s in bounded_symbols:
+                s_str = str(s).strip()
+                if not s_str:
+                    continue
+                results[s_str] = [dict(r) for r in graph_find_callers(con, s_str, max_results=max_results_per_symbol)]
+        return {
+            "results": results,
+            "count": len(results),
+            "total_callers": sum(len(c) for c in results.values()),
+        }
+
+    def batch_get_context(
+        tasks: list[dict[str, Any]] | list[str],
+        max_tokens_per_task: int = 2000,
+    ) -> dict[str, Any]:
+        """Compile token-bounded, coverage-optimized ContextPackets for multiple task prompts or symbol targets in a single call.
+        Enables agents to retrieve separate contexts for different sub-tasks in one request. Bounded to 5 tasks max."""
+        bounded_tasks = tasks[:5]
+        results: list[dict[str, Any]] = []
+        with indexer.session() as con:
+            for t in bounded_tasks:
+                effective_task = t if isinstance(t, str) else t.get("query") or t.get("task") or str(t)
+                effective_intent = t.get("intent") if isinstance(t, dict) else None
+                packet = compile_context(
+                    con,
+                    indexer.repository,
+                    task=effective_task,
+                    intent=effective_intent,
+                    max_tokens=max_tokens_per_task,
+                    mode="FAST",
+                )
+                results.append(packet.as_dict())
+        return {
+            "results": results,
+            "count": len(results),
+        }
+
+    def preview_semantic_patch(
+        patches: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        """Dry-run preview a multi-file semantic patch across repository files with syntax validation and unified diffs.
+        Invariants: Zero disk mutation; pre-flight AST validation for Python, Luau, JSON, and JS/TS; boundary checks. Does not commit modifications to disk."""
+        from codegraph.refactor.patcher import preview_semantic_patch as do_preview
+
+        result = do_preview(
+            repository=indexer.repository,
+            patch_specs=patches,
+        )
+        return result.to_dict()
+
+    def apply_semantic_patch(
+        patches: list[dict[str, Any]],
+        dry_run: bool = False,
+    ) -> dict[str, Any]:
+        """Atomically apply a multi-file semantic patch with pre-flight syntax validation and rollback support.
+        When dry_run=False: checks preconditions and hashes, validates syntax in memory, commits atomically using sibling temp files and os.replace under RefactorLock, persists a rollback manifest, and triggers an incremental index update."""
+        from codegraph.refactor.models import RefactorStatus
+        from codegraph.refactor.patcher import apply_semantic_patch as do_apply
+
+        result = do_apply(
+            repository=indexer.repository,
+            patch_specs=patches,
+            dry_run=dry_run,
+        )
+        if result.status == RefactorStatus.APPLIED:
+            try:
+                indexer.index()
+            except Exception:
+                pass
+        return result.to_dict()
+
+    def generate_pr_review(base_ref: str = "main", head_ref: str = "HEAD") -> dict[str, Any]:
+        """Generate comprehensive semantic PR review evaluating structural diffs, caller contract breaks, affected routes, and test gaps. Use when reviewing pull requests or evaluating branch changes before merging. Does not execute repository code."""
+        from codegraph.pr_review import generate_pr_review as impl_pr_review
+        with indexer.session() as con:
+            return impl_pr_review(indexer.repository, base_ref=base_ref, head_ref=head_ref, con=con).as_dict()
+
+    def generate_test_scaffolding(target: str, framework: str | None = None) -> dict[str, Any]:
+        """Generate production-ready test scaffolding with fixtures, dependency mocks (DB sessions, HTTP clients), and boundary test cases for a symbol or route. Use when writing tests for untested functions or HTTP endpoints. Does not execute the generated test code."""
+        from codegraph.test_gen import generate_test_scaffolding as impl_gen_test
+        with indexer.session() as con:
+            return impl_gen_test(con, target=target, repository=indexer.repository, framework=framework).as_dict()
+
+    def federate_repositories(workspace_root: str | None = None) -> dict[str, Any]:
+        """Discover and catalog federated repositories in a multi-repo workspace. Use when mapping microservice boundaries and cross-service index sizes. Does not modify child repository indices."""
+        from codegraph.federation import federate_workspace
+        root = Path(workspace_root) if workspace_root else indexer.repository.parent
+        return federate_workspace(root).as_dict()
+
+    def find_cross_repo_routes(workspace_root: str | None = None, query: str | None = None) -> dict[str, Any]:
+        """Resolve cross-repository HTTP and RPC service-to-service links across microservices. Use when tracing requests across separate repositories. Does not guess unobserved endpoints without route evidence."""
+        from codegraph.federation import federate_workspace
+        root = Path(workspace_root) if workspace_root else indexer.repository.parent
+        rep = federate_workspace(root)
+        links = rep.cross_repo_links
+        if query:
+            clean_q = query.lower()
+            links = [item for item in links if clean_q in item.route_path.lower() or clean_q in item.target_repo.lower() or clean_q in item.source_repo.lower()]
+        return {
+            "workspace_root": rep.workspace_root,
+            "total_links": len(links),
+            "cross_repo_links": [item.as_dict() for item in links],
+        }
+
+    def store_agent_memory(
+        title: str,
+        resolution: str,
+        category: str = "BUG_FIX",
+        symptoms: str = "",
+        root_cause: str = "",
+    ) -> dict[str, Any]:
+        """Store an agent debugging trajectory, test repair pattern, or architectural decision into persistent memory. Use when recording successful bug resolutions or architecture decisions for future recall. Does not share memory outside the local repository index."""
+        from codegraph.memory.trajectory import get_trajectory_memory_store
+        store = get_trajectory_memory_store(indexer.repository)
+        return store.store(
+            title=title,
+            resolution=resolution,
+            category=category,
+            symptoms=symptoms,
+            root_cause=root_cause,
+        ).as_dict()
+
+    def query_agent_memory(
+        query: str,
+        category: str | None = None,
+        limit: int = 5,
+        max_tokens: int = 1500,
+    ) -> dict[str, Any]:
+        """Search past agent debugging memories and architectural decisions using FTS5 BM25 ranking. Use when investigating recurring bugs or checking past resolutions. Does not execute stored resolution code."""
+        from codegraph.memory.trajectory import get_trajectory_memory_store
+        store = get_trajectory_memory_store(indexer.repository)
+        records = store.search(query=query, category=category, limit=limit, max_tokens=max_tokens)
+        return {
+            "query": query,
+            "count": len(records),
+            "memories": [r.as_dict() for r in records],
+        }
+
+    def analyze_dataflow_taint(
+        entrypoint_symbol: str | None = None,
+        filter_cwe: str | None = None,
+        max_depth: int = 12,
+    ) -> dict[str, Any]:
+        """Analyze source-to-sink dataflow taint paths for injection and security vulnerabilities (SQL injection, command execution, path traversal, SSRF, insecure deserialization) using AST dataflow tracking. Use when auditing endpoint security, sanitization gaps, or vulnerable data sinks. Does not execute repository code."""
+        from codegraph.security.taint import audit_repository_taint
+        with indexer.session() as con:
+            return audit_repository_taint(indexer.repository, con=con, entrypoint_symbol=entrypoint_symbol, filter_cwe=filter_cwe, max_depth=max_depth).as_dict()
+
+    def repair_repository_index(
+        deep: bool = True,
+        vacuum: bool = False,
+    ) -> dict[str, Any]:
+        """Perform automated self-healing, SQLite integrity verification, rebuilding corrupted FTS5 indices, pruning dangling FK references, clearing stale locks, and truncating WAL logs. Use when the repository index encounters lock contention, corrupted FTS entries, or orphaned edges. Does not delete source repository code."""
+        from codegraph.repair import repair_repository_index as impl_repair
+        return impl_repair(indexer.repository, deep=deep, vacuum=vacuum).as_dict()
+
+    def get_lsp_diagnostics(file_path: str | None = None) -> dict[str, Any]:
+        """Collect live compiler diagnostics, type errors, and lint warnings via Language Server Protocol (LSP) daemons (pyright, gopls, rust-analyzer, clangd). Use when diagnosing compile errors or verifying code correctness. Does not modify source files."""
+        from codegraph.lsp_bridge.bridge import collect_lsp_diagnostics
+        return collect_lsp_diagnostics(indexer.repository, file_path=file_path).as_dict()
+
+    def register_agent_session(agent_id: str, name: str, task: str) -> dict[str, Any]:
+        """Register an active AI coding agent session in the multi-agent shared workspace. Use when joining a swarm or announcing an active coding task to coordinate with other agents. Does not lock files."""
+        from codegraph.multi_agent.coordinator import MultiAgentCoordinator
+        coord = MultiAgentCoordinator(indexer.repository)
+        return coord.register_session(agent_id, name, task).as_dict()
+
+    def claim_file_lease(
+        agent_id: str,
+        file_path: str,
+        lease_type: str = "EXCLUSIVE_WRITE",
+        ttl_seconds: float = 60.0,
+    ) -> dict[str, Any]:
+        """Claim a lease lock on a file path to prevent concurrent edit clobbering by other AI agents. Use before modifying a file in a multi-agent environment. Does not modify file content."""
+        from codegraph.multi_agent.coordinator import MultiAgentCoordinator
+        coord = MultiAgentCoordinator(indexer.repository)
+        ok, msg = coord.claim_lease(agent_id, file_path, lease_type=lease_type, ttl_seconds=ttl_seconds)
+        return {"success": ok, "message": msg, "file_path": file_path, "agent_id": agent_id, "lease_type": lease_type}
+
+    def release_file_lease(agent_id: str, file_path: str | None = None) -> dict[str, Any]:
+        """Release one or all file leases held by an AI agent upon completing task edits. Use after committing or discarding file edits. Does not delete source files."""
+        from codegraph.multi_agent.coordinator import MultiAgentCoordinator
+        coord = MultiAgentCoordinator(indexer.repository)
+        released_count = coord.release_lease(agent_id, file_path)
+        return {"released_count": released_count, "agent_id": agent_id, "file_path": file_path}
+
+    def get_multi_agent_status() -> dict[str, Any]:
+        """Return consolidated multi-agent status report including active agent sessions, held file leases, and predicted AST conflicts. Use to check if other agents are working on related files. Does not acquire locks."""
+        from codegraph.multi_agent.coordinator import MultiAgentCoordinator
+        coord = MultiAgentCoordinator(indexer.repository)
+        with indexer.session() as con:
+            conflicts = coord.check_conflicts(con=con)
+            rep = coord.get_status_report()
+            rep.conflicts = conflicts
+            rep.conflicts_count = len(conflicts)
+            return rep.as_dict()
+
+    def evaluate_speculative_patch(patches: dict[str, str]) -> dict[str, Any]:
+        """Project an in-memory virtual AST branch in RAM to evaluate caller breakages, parameter mismatches, and route mutations without modifying disk files. Use before writing refactoring patches. Does not modify disk files."""
+        from codegraph.sandbox import evaluate_speculative_patch as impl_sandbox
+        with indexer.session() as con:
+            return impl_sandbox(indexer.repository, file_patches=patches, con=con).as_dict()
+
+    def verify_architectural_rules(rules: list[dict[str, Any]] | None = None) -> dict[str, Any]:
+        """Evaluate declarative architectural boundaries, forbidden cross-module dependencies, and layer rules against the repository index. Use when checking pull request compliance with enterprise architecture. Does not modify code."""
+        from codegraph.architecture_rules import evaluate_architecture_rules as impl_arch
+        with indexer.session() as con:
+            return impl_arch(indexer.repository, con=con, rules=rules).as_dict()
+
+    def find_unreachable_code() -> dict[str, Any]:
+        """Perform DI-aware root-to-leaf reachability analysis from HTTP routes, CLIs, and crons to detect true dead code with STATIC_VERIFIED confidence. Use when pruning dead code. Does not delete code."""
+        from codegraph.reachability import compute_di_aware_reachability as impl_reach
+        with indexer.session() as con:
+            return impl_reach(indexer.repository, con=con).as_dict()
+
+    def generate_semantic_changelog(base_ref: str = "HEAD~1", head_ref: str = "HEAD") -> dict[str, Any]:
+        """Synthesize human-readable release changelog categorizing breaking changes, new endpoints, and database mutations from AST diffs. Use when writing release notes. Does not modify git repository."""
+        from codegraph.changelog import generate_semantic_changelog as impl_changelog
+        return impl_changelog(indexer.repository, base_ref=base_ref, head_ref=head_ref).as_dict()
+
+    def fast_graph_path(start_node: str, end_node: str) -> dict[str, Any]:
+        """Compute microsecond BFS shortest path between two symbols using the Compressed Sparse Row (CSR) binary graph. Use for instant path tracing between caller and callee. Does not modify graph."""
+        from codegraph.graph_csr import CSRGraph
+        with indexer.session() as con:
+            cur = con.cursor()
+            cur.execute("SELECT source, target, relationship FROM graph_edges LIMIT 5000;")
+            edges = [(str(r[0]), str(r[1]), str(r[2])) for r in cur.fetchall()]
+        csr = CSRGraph.build_from_edges(edges)
+        path = csr.shortest_path(start_node, end_node)
+        return {"start_node": start_node, "end_node": end_node, "path": path, "length": len(path) if path else 0}
+
+    def resolve_polymorphic_callees(interface_symbol: str, method_name: str) -> dict[str, Any]:
+        """Resolve an abstract interface method or trait invocation to all concrete implementing classes in the workspace. Use when tracing dynamic dispatch or trait method implementations. Does not execute code."""
+        from codegraph.polymorphism import resolve_polymorphic_callees as impl_poly
+        with indexer.session() as con:
+            return impl_poly(con, interface_symbol=interface_symbol, method_name=method_name).as_dict()
+
+    def propagate_interprocedural_dataflow(target_symbol: str) -> dict[str, Any]:
+        """Trace inter-procedural dataflow, return type inference, and unguarded None/null dereferences across caller-callee boundaries. Use when investigating NullPointerExceptions or type contract violations. Does not execute code."""
+        from codegraph.dataflow_propagation import (
+            propagate_interprocedural_dataflow as impl_dataflow,
+        )
+        with indexer.session() as con:
+            return impl_dataflow(con, target_symbol=target_symbol).as_dict()
+
+    def analyze_supply_chain_cve_impact(target_package: str | None = None) -> dict[str, Any]:
+        """Inspect third-party dependency manifests (package.json, go.mod, Cargo.toml, requirements.txt) and trace actual internal call site reachability. Use when assessing CVE vulnerability blast radius. Does not execute external dependencies."""
+        from codegraph.security.supply_chain import analyze_supply_chain as impl_supply
+        with indexer.session() as con:
+            return impl_supply(indexer.repository, con=con, target_package=target_package).as_dict()
+
     core_tools: dict[str, Any] = {
         "resolve_symbol": resolve_symbol,
         "search_symbols": search_symbols,
@@ -1040,10 +1422,25 @@ def create_server(
         "detect_semantic_conflicts": detect_semantic_conflicts,
     }
 
+    refactor_tools: dict[str, Any] = {
+        "safe_rename": safe_rename,
+        "rollback_refactor": rollback_refactor,
+        "preview_semantic_patch": preview_semantic_patch,
+        "apply_semantic_patch": apply_semantic_patch,
+    }
+
+    batch_tools: dict[str, Any] = {
+        "batch_get_symbols": batch_get_symbols,
+        "batch_find_callers": batch_find_callers,
+        "batch_get_context": batch_get_context,
+    }
+
     # Map of all available tools
     all_tools: dict[str, Any] = {
         **core_tools,
         **git_intelligence_tools,
+        **refactor_tools,
+        **batch_tools,
         "search_code": search_code,
         "read_file": read_file,
         "find_symbol": find_symbol,
@@ -1087,6 +1484,34 @@ def create_server(
         "ingest_runtime_traces": ingest_runtime_traces,
         "get_runtime_trace": get_runtime_trace,
         "reconcile_static_runtime": reconcile_static_runtime,
+        "get_live_services": get_live_services,
+        "check_db_drift": check_db_drift,
+        "check_route_schema_drift": check_route_schema_drift,
+        "get_distributed_trace": get_distributed_trace,
+        "check_api_drift": check_api_drift,
+        "get_monorepo_packages": get_monorepo_packages,
+        "find_dead_code": find_dead_code,
+        "generate_pr_review": generate_pr_review,
+        "generate_test_scaffolding": generate_test_scaffolding,
+        "federate_repositories": federate_repositories,
+        "find_cross_repo_routes": find_cross_repo_routes,
+        "store_agent_memory": store_agent_memory,
+        "query_agent_memory": query_agent_memory,
+        "analyze_dataflow_taint": analyze_dataflow_taint,
+        "repair_repository_index": repair_repository_index,
+        "get_lsp_diagnostics": get_lsp_diagnostics,
+        "register_agent_session": register_agent_session,
+        "claim_file_lease": claim_file_lease,
+        "release_file_lease": release_file_lease,
+        "get_multi_agent_status": get_multi_agent_status,
+        "evaluate_speculative_patch": evaluate_speculative_patch,
+        "verify_architectural_rules": verify_architectural_rules,
+        "find_unreachable_code": find_unreachable_code,
+        "generate_semantic_changelog": generate_semantic_changelog,
+        "fast_graph_path": fast_graph_path,
+        "resolve_polymorphic_callees": resolve_polymorphic_callees,
+        "propagate_interprocedural_dataflow": propagate_interprocedural_dataflow,
+        "analyze_supply_chain_cve_impact": analyze_supply_chain_cve_impact,
     }
 
     agent_names = {
@@ -1179,6 +1604,7 @@ def create_server(
 
             get_graph_cache().clear()
             get_parse_cache().clear()
+            indexer.reset_pool()
             return True
         return False
 
@@ -1196,6 +1622,40 @@ def create_server(
 
         app.tool(name=tool_name)(_make_guarded(target_fn))
 
+    # FastMCP Event Loop Offload:
+    # Ensure synchronous tools execute in worker threads so MCP asyncio loop is never blocked
+    orig_call_tool = app._tool_manager.call_tool
+
+    async def _concurrent_call_tool(
+        name: str,
+        arguments: dict[str, Any],
+        context: Any = None,
+        convert_result: bool = False,
+    ) -> Any:
+        tool = app._tool_manager.get_tool(name)
+        if tool is not None and not tool.is_async:
+            def _invoke_in_thread() -> Any:
+                return asyncio.run(
+                    orig_call_tool(
+                        name,
+                        arguments,
+                        context=context,
+                        convert_result=convert_result,
+                    )
+                )
+
+            return await anyio.to_thread.run_sync(_invoke_in_thread)
+
+        return await orig_call_tool(
+            name,
+            arguments,
+            context=context,
+            convert_result=convert_result,
+        )
+
+    app._tool_manager.call_tool = _concurrent_call_tool  # type: ignore[method-assign]
+
+
     # -----------------------------------------------------------------------
     # MCP Resources
     # -----------------------------------------------------------------------
@@ -1208,47 +1668,60 @@ def create_server(
         return json.dumps(get_capability_manifest(), indent=2)
 
     @app.resource("codebase://status")
-    def resource_status() -> str:
+    async def resource_status() -> str:
         """Repository index status, generation, and file counts."""
-        with indexer.session() as con:
-            report = check_freshness(indexer.repository, con)
-            return json.dumps(
-                {
-                    "repository": str(indexer.repository),
-                    "generation": report.index_generation,
-                    "freshness": report.status.value,
-                    "files": con.execute("SELECT count(*) FROM files").fetchone()[0],
-                    "symbols": con.execute("SELECT count(*) FROM symbols").fetchone()[0],
-                },
-                indent=2,
-            )
+        def _get_status() -> str:
+            with indexer.session() as con:
+                report = check_freshness(indexer.repository, con)
+                return json.dumps(
+                    {
+                        "repository": str(indexer.repository),
+                        "generation": report.index_generation,
+                        "freshness": report.status.value,
+                        "files": con.execute("SELECT count(*) FROM files").fetchone()[0],
+                        "symbols": con.execute("SELECT count(*) FROM symbols").fetchone()[0],
+                    },
+                    indent=2,
+                )
+
+        return await anyio.to_thread.run_sync(_get_status)
 
     @app.resource("codebase://architecture")
-    def resource_architecture() -> str:
+    async def resource_architecture() -> str:
         """High-level architectural overview."""
-        with indexer.session() as con:
-            arch = arch_get_architecture(con, indexer.repository)
-            return json.dumps(arch, indent=2)
+        def _get_arch() -> str:
+            with indexer.session() as con:
+                arch = arch_get_architecture(con, indexer.repository)
+                return json.dumps(arch, indent=2)
+
+        return await anyio.to_thread.run_sync(_get_arch)
 
     @app.resource("codebase://modules")
-    def resource_modules() -> str:
+    async def resource_modules() -> str:
         """List of indexed repository module paths."""
-        with indexer.session() as con:
-            rows = con.execute("SELECT path FROM files ORDER BY path LIMIT 500").fetchall()
-            return "\n".join(r[0] for r in rows)
+        def _get_modules() -> str:
+            with indexer.session() as con:
+                rows = con.execute("SELECT path FROM files ORDER BY path LIMIT 500").fetchall()
+                return "\n".join(r[0] for r in rows)
+
+        return await anyio.to_thread.run_sync(_get_modules)
 
     @app.resource("codebase://health")
-    def resource_health() -> str:
+    async def resource_health() -> str:
         """Database health and integrity report."""
-        with indexer.session() as con:
-            health = check_database_health(con)
-            return json.dumps(health, indent=2)
+        def _get_health() -> str:
+            with indexer.session() as con:
+                health = check_database_health(con)
+                return json.dumps(health, indent=2)
+
+        return await anyio.to_thread.run_sync(_get_health)
 
     @app.resource("codebase://resources")
     def resource_resources() -> str:
         """Resource governor state, memory bounds, pressure, and activity mode."""
         return json.dumps(indexer.governor.get_state().as_dict(), indent=2)
 
+
     # -----------------------------------------------------------------------
     # MCP Prompts
     # -----------------------------------------------------------------------