mcp-ticketer 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

mcp_ticketer/mcp/server.py

@@ -1,4 +1,4 @@
-"""MCP JSON-RPC server for ticket management."""
+"""MCP JSON-RPC server for ticket management - Simplified synchronous implementation."""
 
 import asyncio
 import json
@@ -12,9 +12,41 @@ from dotenv import load_dotenv
 import mcp_ticketer.adapters  # noqa: F401
 
 from ..core import AdapterRegistry
-from ..core.models import SearchQuery
-from ..queue import Queue, QueueStatus, WorkerManager
-from ..queue.health_monitor import HealthStatus, QueueHealthMonitor
+from ..core.models import Comment, Epic, Priority, SearchQuery, Task, TicketState
+from .constants import (
+    DEFAULT_BASE_PATH,
+    DEFAULT_LIMIT,
+    DEFAULT_MAX_DEPTH,
+    DEFAULT_OFFSET,
+    ERROR_INTERNAL,
+    ERROR_METHOD_NOT_FOUND,
+    ERROR_PARSE,
+    JSONRPC_VERSION,
+    MCP_PROTOCOL_VERSION,
+    MSG_EPIC_NOT_FOUND,
+    MSG_INTERNAL_ERROR,
+    MSG_MISSING_TICKET_ID,
+    MSG_MISSING_TITLE,
+    MSG_NO_TICKETS_PROVIDED,
+    MSG_NO_UPDATES_PROVIDED,
+    MSG_TICKET_NOT_FOUND,
+    MSG_TRANSITION_FAILED,
+    MSG_UNKNOWN_METHOD,
+    MSG_UNKNOWN_OPERATION,
+    MSG_UPDATE_FAILED,
+    SERVER_NAME,
+    SERVER_VERSION,
+    STATUS_COMPLETED,
+    STATUS_ERROR,
+)
+from .dto import (
+    CreateEpicRequest,
+    CreateIssueRequest,
+    CreateTaskRequest,
+    CreateTicketRequest,
+    ReadTicketRequest,
+)
+from .response_builder import ResponseBuilder
 
 # Load environment variables early (prioritize .env.local)
 # Check for .env.local first (takes precedence)
@@ -35,7 +67,7 @@ else:
 
 
 class MCPTicketServer:
-    """MCP server for ticket operations over stdio."""
+    """MCP server for ticket operations over stdio - synchronous implementation."""
 
     def __init__(
         self, adapter_type: str = "aitrackdown", config: Optional[dict[str, Any]] = None
@@ -47,9 +79,9 @@ class MCPTicketServer:
             config: Adapter configuration
 
         """
-        self.adapter = AdapterRegistry.get_adapter(
-            adapter_type, config or {"base_path": ".aitrackdown"}
-        )
+        self.adapter_type = adapter_type
+        self.adapter_config = config or {"base_path": DEFAULT_BASE_PATH}
+        self.adapter = AdapterRegistry.get_adapter(adapter_type, self.adapter_config)
         self.running = False
 
     async def handle_request(self, request: dict[str, Any]) -> dict[str, Any]:
@@ -87,14 +119,10 @@ class MCPTicketServer:
                 result = await self._handle_transition(params)
             elif method == "ticket/comment":
                 result = await self._handle_comment(params)
-            elif method == "ticket/status":
-                result = await self._handle_queue_status(params)
             elif method == "ticket/create_pr":
                 result = await self._handle_create_pr(params)
             elif method == "ticket/link_pr":
                 result = await self._handle_link_pr(params)
-            elif method == "queue/health":
-                result = await self._handle_queue_health(params)
             # Hierarchy management tools
             elif method == "epic/create":
                 result = await self._handle_epic_create(params)
@@ -128,14 +156,18 @@ class MCPTicketServer:
             elif method == "tools/call":
                 result = await self._handle_tools_call(params)
             else:
-                return self._error_response(
-                    request_id, -32601, f"Method not found: {method}"
+                return ResponseBuilder.error(
+                    request_id,
+                    ERROR_METHOD_NOT_FOUND,
+                    MSG_UNKNOWN_METHOD.format(method=method),
                 )
 
-            return {"jsonrpc": "2.0", "result": result, "id": request_id}
+            return {"jsonrpc": JSONRPC_VERSION, "result": result, "id": request_id}
 
         except Exception as e:
-            return self._error_response(request_id, -32603, f"Internal error: {str(e)}")
+            return ResponseBuilder.error(
+                request_id, ERROR_INTERNAL, MSG_INTERNAL_ERROR.format(error=str(e))
+            )
 
     def _error_response(
         self, request_id: Any, code: int, message: str
@@ -158,663 +190,291 @@ class MCPTicketServer:
         }
 
     async def _handle_create(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle ticket creation."""
-        # Check queue health before proceeding
-        health_monitor = QueueHealthMonitor()
-        health = health_monitor.check_health()
-
-        # If queue is in critical state, try auto-repair
-        if health["status"] == HealthStatus.CRITICAL:
-            repair_result = health_monitor.auto_repair()
-            # Re-check health after repair
-            health = health_monitor.check_health()
-
-            # If still critical, return error immediately
-            if health["status"] == HealthStatus.CRITICAL:
-                critical_alerts = [
-                    alert for alert in health["alerts"] if alert["level"] == "critical"
-                ]
-                return {
-                    "status": "error",
-                    "error": "Queue system is in critical state",
-                    "details": {
-                        "health_status": health["status"],
-                        "critical_issues": critical_alerts,
-                        "repair_attempted": repair_result["actions_taken"],
-                    },
-                }
-
-        # Queue the operation
-        queue = Queue()
-        task_data = {
-            "title": params["title"],
-            "description": params.get("description"),
-            "priority": params.get("priority", "medium"),
-            "tags": params.get("tags", []),
-            "assignee": params.get("assignee"),
-        }
-
-        queue_id = queue.add(
-            ticket_data=task_data,
-            adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-            operation="create",
+        """Handle task creation - SYNCHRONOUS with validation."""
+        # Validate and parse request
+        request = CreateTicketRequest(**params)
+
+        # Build task from validated DTO
+        task = Task(
+            title=request.title,
+            description=request.description,
+            priority=Priority(request.priority),
+            tags=request.tags,
+            assignee=request.assignee,
         )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        worker_started = manager.start_if_needed()
-
-        # If worker failed to start and we have pending items, that's critical
-        if not worker_started and queue.get_pending_count() > 0:
-            return {
-                "status": "error",
-                "error": "Failed to start worker process",
-                "queue_id": queue_id,
-                "details": {
-                    "pending_count": queue.get_pending_count(),
-                    "action": "Worker process could not be started to process queued operations",
-                },
-            }
-
-        # Check if async mode is requested (for backward compatibility)
-        if params.get("async_mode", False):
-            return {
-                "queue_id": queue_id,
-                "status": "queued",
-                "message": f"Ticket creation queued with ID: {queue_id}",
-            }
-
-        # Poll for completion with timeout (default synchronous behavior)
-        max_wait_time = params.get("timeout", 30)  # seconds, allow override
-        poll_interval = 0.5  # seconds
-        start_time = asyncio.get_event_loop().time()
-
-        while True:
-            # Check queue status
-            item = queue.get_item(queue_id)
-
-            if not item:
-                return {
-                    "queue_id": queue_id,
-                    "status": "error",
-                    "error": f"Queue item {queue_id} not found",
-                }
-
-            # If completed, return with ticket ID
-            if item.status == QueueStatus.COMPLETED:
-                response = {
-                    "queue_id": queue_id,
-                    "status": "completed",
-                    "title": params["title"],
-                }
-
-                # Add ticket ID and other result data if available
-                if item.result:
-                    response["ticket_id"] = item.result.get("id")
-                    if "state" in item.result:
-                        response["state"] = item.result["state"]
-                    # Try to construct URL if we have enough information
-                    if response.get("ticket_id"):
-                        # This is adapter-specific, but we can add URL generation later
-                        response["id"] = response[
-                            "ticket_id"
-                        ]  # Also include as "id" for compatibility
-
-                response["message"] = (
-                    f"Ticket created successfully: {response.get('ticket_id', queue_id)}"
-                )
-                return response
-
-            # If failed, return error
-            if item.status == QueueStatus.FAILED:
-                return {
-                    "queue_id": queue_id,
-                    "status": "failed",
-                    "error": item.error_message or "Ticket creation failed",
-                    "title": params["title"],
-                }
+        # Create directly
+        created = await self.adapter.create(task)
 
-            # Check timeout
-            elapsed = asyncio.get_event_loop().time() - start_time
-            if elapsed > max_wait_time:
-                return {
-                    "queue_id": queue_id,
-                    "status": "timeout",
-                    "message": f"Ticket creation timed out after {max_wait_time} seconds. Use ticket_status with queue_id to check status.",
-                    "title": params["title"],
-                }
-
-            # Wait before next poll
-            await asyncio.sleep(poll_interval)
-
-    async def _handle_read(self, params: dict[str, Any]) -> Optional[dict[str, Any]]:
-        """Handle ticket read."""
-        ticket = await self.adapter.read(params["ticket_id"])
-        return ticket.model_dump() if ticket else None
-
-    async def _handle_update(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle ticket update."""
-        # Queue the operation
-        queue = Queue()
-        updates = params.get("updates", {})
-        updates["ticket_id"] = params["ticket_id"]
-
-        queue_id = queue.add(
-            ticket_data=updates,
-            adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-            operation="update",
+        # Return immediately
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.ticket_result(created)
         )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        manager.start_if_needed()
-
-        # Poll for completion with timeout
-        max_wait_time = 30  # seconds
-        poll_interval = 0.5  # seconds
-        start_time = asyncio.get_event_loop().time()
+    async def _handle_read(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle ticket read - SYNCHRONOUS with validation."""
+        # Validate and parse request
+        request = ReadTicketRequest(**params)
 
-        while True:
-            # Check queue status
-            item = queue.get_item(queue_id)
+        ticket = await self.adapter.read(request.ticket_id)
 
-            if not item:
-                return {
-                    "queue_id": queue_id,
-                    "status": "error",
-                    "error": f"Queue item {queue_id} not found",
-                }
-
-            # If completed, return with ticket ID
-            if item.status == QueueStatus.COMPLETED:
-                response = {
-                    "queue_id": queue_id,
-                    "status": "completed",
-                    "ticket_id": params["ticket_id"],
-                }
+        if ticket is None:
+            return ResponseBuilder.status_result(
+                STATUS_ERROR,
+                error=MSG_TICKET_NOT_FOUND.format(ticket_id=request.ticket_id),
+            )
 
-                # Add result data if available
-                if item.result:
-                    if item.result.get("id"):
-                        response["ticket_id"] = item.result["id"]
-                    response["success"] = item.result.get("success", True)
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.ticket_result(ticket)
+        )
 
-                response["message"] = (
-                    f"Ticket updated successfully: {response['ticket_id']}"
-                )
-                return response
+    async def _handle_update(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle ticket update - SYNCHRONOUS."""
+        ticket_id = params["ticket_id"]
 
-            # If failed, return error
-            if item.status == QueueStatus.FAILED:
-                return {
-                    "queue_id": queue_id,
-                    "status": "failed",
-                    "error": item.error_message or "Ticket update failed",
-                    "ticket_id": params["ticket_id"],
-                }
+        # Support both formats: {"ticket_id": "x", "updates": {...}} and {"ticket_id": "x", "field": "value"}
+        if "updates" in params:
+            updates = params["updates"]
+        else:
+            # Extract all non-ticket_id fields as updates
+            updates = {k: v for k, v in params.items() if k != "ticket_id"}
 
-            # Check timeout
-            elapsed = asyncio.get_event_loop().time() - start_time
-            if elapsed > max_wait_time:
-                return {
-                    "queue_id": queue_id,
-                    "status": "timeout",
-                    "message": f"Ticket update timed out after {max_wait_time} seconds. Use ticket_status with queue_id to check status.",
-                    "ticket_id": params["ticket_id"],
-                }
+        updated = await self.adapter.update(ticket_id, updates)
 
-            # Wait before next poll
-            await asyncio.sleep(poll_interval)
+        if updated is None:
+            return ResponseBuilder.status_result(
+                STATUS_ERROR, error=MSG_UPDATE_FAILED.format(ticket_id=ticket_id)
+            )
 
-    async def _handle_delete(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle ticket deletion."""
-        # Queue the operation
-        queue = Queue()
-        queue_id = queue.add(
-            ticket_data={"ticket_id": params["ticket_id"]},
-            adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-            operation="delete",
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.ticket_result(updated)
         )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        manager.start_if_needed()
+    async def _handle_delete(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle ticket deletion - SYNCHRONOUS."""
+        ticket_id = params["ticket_id"]
+        success = await self.adapter.delete(ticket_id)
 
-        return {
-            "queue_id": queue_id,
-            "status": "queued",
-            "message": f"Ticket deletion queued with ID: {queue_id}",
-        }
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.deletion_result(ticket_id, success)
+        )
 
-    async def _handle_list(self, params: dict[str, Any]) -> list[dict[str, Any]]:
-        """Handle ticket listing."""
+    async def _handle_list(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle ticket listing - SYNCHRONOUS."""
         tickets = await self.adapter.list(
-            limit=params.get("limit", 10),
-            offset=params.get("offset", 0),
+            limit=params.get("limit", DEFAULT_LIMIT),
+            offset=params.get("offset", DEFAULT_OFFSET),
             filters=params.get("filters"),
         )
-        return [ticket.model_dump() for ticket in tickets]
 
-    async def _handle_search(self, params: dict[str, Any]) -> list[dict[str, Any]]:
-        """Handle ticket search."""
-        query = SearchQuery(**params)
-        tickets = await self.adapter.search(query)
-        return [ticket.model_dump() for ticket in tickets]
-
-    async def _handle_transition(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle state transition."""
-        # Queue the operation
-        queue = Queue()
-        queue_id = queue.add(
-            ticket_data={
-                "ticket_id": params["ticket_id"],
-                "state": params["target_state"],
-            },
-            adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-            operation="transition",
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.tickets_result(tickets)
         )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        manager.start_if_needed()
-
-        # Poll for completion with timeout
-        max_wait_time = 30  # seconds
-        poll_interval = 0.5  # seconds
-        start_time = asyncio.get_event_loop().time()
-
-        while True:
-            # Check queue status
-            item = queue.get_item(queue_id)
-
-            if not item:
-                return {
-                    "queue_id": queue_id,
-                    "status": "error",
-                    "error": f"Queue item {queue_id} not found",
-                }
+    async def _handle_search(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle ticket search - SYNCHRONOUS."""
+        query = SearchQuery(
+            query=params.get("query"),
+            state=TicketState(params["state"]) if params.get("state") else None,
+            priority=Priority(params["priority"]) if params.get("priority") else None,
+            assignee=params.get("assignee"),
+            tags=params.get("tags"),
+            limit=params.get("limit", DEFAULT_LIMIT),
+        )
 
-            # If completed, return with ticket ID
-            if item.status == QueueStatus.COMPLETED:
-                response = {
-                    "queue_id": queue_id,
-                    "status": "completed",
-                    "ticket_id": params["ticket_id"],
-                    "state": params["target_state"],
-                }
+        results = await self.adapter.search(query)
 
-                # Add result data if available
-                if item.result:
-                    if item.result.get("id"):
-                        response["ticket_id"] = item.result["id"]
-                    response["success"] = item.result.get("success", True)
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.tickets_result(results)
+        )
 
-                response["message"] = (
-                    f"State transition completed successfully: {response['ticket_id']} → {params['target_state']}"
-                )
-                return response
+    async def _handle_transition(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle state transition - SYNCHRONOUS."""
+        ticket_id = params["ticket_id"]
+        target_state = TicketState(params["target_state"])
 
-            # If failed, return error
-            if item.status == QueueStatus.FAILED:
-                return {
-                    "queue_id": queue_id,
-                    "status": "failed",
-                    "error": item.error_message or "State transition failed",
-                    "ticket_id": params["ticket_id"],
-                }
+        updated = await self.adapter.transition_state(ticket_id, target_state)
 
-            # Check timeout
-            elapsed = asyncio.get_event_loop().time() - start_time
-            if elapsed > max_wait_time:
-                return {
-                    "queue_id": queue_id,
-                    "status": "timeout",
-                    "message": f"State transition timed out after {max_wait_time} seconds. Use ticket_status with queue_id to check status.",
-                    "ticket_id": params["ticket_id"],
-                }
+        if updated is None:
+            return ResponseBuilder.status_result(
+                STATUS_ERROR, error=MSG_TRANSITION_FAILED.format(ticket_id=ticket_id)
+            )
 
-            # Wait before next poll
-            await asyncio.sleep(poll_interval)
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.ticket_result(updated)
+        )
 
     async def _handle_comment(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle comment operations."""
+        """Handle comment operations - SYNCHRONOUS."""
         operation = params.get("operation", "add")
 
         if operation == "add":
-            # Queue the comment addition
-            queue = Queue()
-            queue_id = queue.add(
-                ticket_data={
-                    "ticket_id": params["ticket_id"],
-                    "content": params["content"],
-                    "author": params.get("author"),
-                },
-                adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-                operation="comment",
+            comment = Comment(
+                ticket_id=params["ticket_id"],
+                content=params["content"],
+                author=params.get("author"),
             )
 
-            # Start worker if needed
-            manager = WorkerManager()
-            manager.start_if_needed()
+            created = await self.adapter.add_comment(comment)
 
-            return {
-                "queue_id": queue_id,
-                "status": "queued",
-                "message": f"Comment addition queued with ID: {queue_id}",
-            }
+            return ResponseBuilder.status_result(
+                STATUS_COMPLETED, **ResponseBuilder.comment_result(created)
+            )
 
         elif operation == "list":
-            # Comments list is read-only, execute directly
             comments = await self.adapter.get_comments(
                 params["ticket_id"],
-                limit=params.get("limit", 10),
-                offset=params.get("offset", 0),
+                limit=params.get("limit", DEFAULT_LIMIT),
+                offset=params.get("offset", DEFAULT_OFFSET),
             )
-            return [comment.model_dump() for comment in comments]
-
-        else:
-            raise ValueError(f"Unknown comment operation: {operation}")
-
-    async def _handle_queue_status(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Check status of queued operation."""
-        queue_id = params.get("queue_id")
-        if not queue_id:
-            raise ValueError("queue_id is required")
-
-        queue = Queue()
-        item = queue.get_item(queue_id)
-
-        if not item:
-            return {"error": f"Queue item not found: {queue_id}"}
-
-        response = {
-            "queue_id": item.id,
-            "status": item.status.value,
-            "operation": item.operation,
-            "created_at": item.created_at.isoformat(),
-            "retry_count": item.retry_count,
-        }
 
-        if item.processed_at:
-            response["processed_at"] = item.processed_at.isoformat()
-
-        if item.error_message:
-            response["error"] = item.error_message
-
-        if item.result:
-            response["result"] = item.result
-
-        return response
-
-    async def _handle_queue_health(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle queue health check."""
-        health_monitor = QueueHealthMonitor()
-        health = health_monitor.check_health()
-
-        # Add auto-repair option
-        auto_repair = params.get("auto_repair", False)
-        if auto_repair and health["status"] in [
-            HealthStatus.CRITICAL,
-            HealthStatus.WARNING,
-        ]:
-            repair_result = health_monitor.auto_repair()
-            health["auto_repair"] = repair_result
-            # Re-check health after repair
-            health.update(health_monitor.check_health())
+            return ResponseBuilder.status_result(
+                STATUS_COMPLETED, **ResponseBuilder.comments_result(comments)
+            )
 
-        return health
+        else:
+            raise ValueError(MSG_UNKNOWN_OPERATION.format(operation=operation))
 
     # Hierarchy Management Handlers
 
     async def _handle_epic_create(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle epic creation."""
-        # Check queue health before proceeding
-        health_monitor = QueueHealthMonitor()
-        health = health_monitor.check_health()
-
-        if health["status"] == HealthStatus.CRITICAL:
-            repair_result = health_monitor.auto_repair()
-            health = health_monitor.check_health()
-
-            if health["status"] == HealthStatus.CRITICAL:
-                critical_alerts = [
-                    alert for alert in health["alerts"] if alert["level"] == "critical"
-                ]
-                return {
-                    "status": "error",
-                    "error": "Queue system is in critical state",
-                    "details": {
-                        "health_status": health["status"],
-                        "critical_issues": critical_alerts,
-                        "repair_attempted": repair_result["actions_taken"],
-                    },
-                }
-
-        # Queue the epic creation
-        queue = Queue()
-        epic_data = {
-            "title": params["title"],
-            "description": params.get("description"),
-            "child_issues": params.get("child_issues", []),
-            "target_date": params.get("target_date"),
-            "lead_id": params.get("lead_id"),
-        }
-
-        queue_id = queue.add(
-            ticket_data=epic_data,
-            adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-            operation="create_epic",
+        """Handle epic creation - SYNCHRONOUS with validation."""
+        # Validate and parse request
+        request = CreateEpicRequest(**params)
+
+        # Build epic from validated DTO
+        epic = Epic(
+            title=request.title,
+            description=request.description,
+            child_issues=request.child_issues,
+            target_date=request.target_date,
+            lead_id=request.lead_id,
         )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        worker_started = manager.start_if_needed()
+        # Create directly
+        created = await self.adapter.create(epic)
 
-        if not worker_started and queue.get_pending_count() > 0:
-            return {
-                "status": "error",
-                "error": "Failed to start worker process",
-                "queue_id": queue_id,
-                "details": {
-                    "pending_count": queue.get_pending_count(),
-                    "action": "Worker process could not be started to process queued operations",
-                },
-            }
-
-        return {
-            "queue_id": queue_id,
-            "status": "queued",
-            "message": f"Epic creation queued with ID: {queue_id}",
-            "epic_data": epic_data,
-        }
+        # Return immediately
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.ticket_result(created)
+        )
 
-    async def _handle_epic_list(self, params: dict[str, Any]) -> list[dict[str, Any]]:
-        """Handle epic listing."""
+    async def _handle_epic_list(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle epic listing - SYNCHRONOUS."""
         epics = await self.adapter.list_epics(
-            limit=params.get("limit", 10),
-            offset=params.get("offset", 0),
+            limit=params.get("limit", DEFAULT_LIMIT),
+            offset=params.get("offset", DEFAULT_OFFSET),
             **{k: v for k, v in params.items() if k not in ["limit", "offset"]},
         )
-        return [epic.model_dump() for epic in epics]
 
-    async def _handle_epic_issues(self, params: dict[str, Any]) -> list[dict[str, Any]]:
-        """Handle listing issues in an epic."""
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.epics_result(epics)
+        )
+
+    async def _handle_epic_issues(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle listing issues in an epic - SYNCHRONOUS."""
         epic_id = params["epic_id"]
         issues = await self.adapter.list_issues_by_epic(epic_id)
-        return [issue.model_dump() for issue in issues]
 
-    async def _handle_issue_create(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle issue creation."""
-        # Check queue health
-        health_monitor = QueueHealthMonitor()
-        health = health_monitor.check_health()
-
-        if health["status"] == HealthStatus.CRITICAL:
-            repair_result = health_monitor.auto_repair()
-            health = health_monitor.check_health()
-
-            if health["status"] == HealthStatus.CRITICAL:
-                critical_alerts = [
-                    alert for alert in health["alerts"] if alert["level"] == "critical"
-                ]
-                return {
-                    "status": "error",
-                    "error": "Queue system is in critical state",
-                    "details": {
-                        "health_status": health["status"],
-                        "critical_issues": critical_alerts,
-                        "repair_attempted": repair_result["actions_taken"],
-                    },
-                }
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.issues_result(issues)
+        )
 
-        # Queue the issue creation
-        queue = Queue()
-        issue_data = {
-            "title": params["title"],
-            "description": params.get("description"),
-            "epic_id": params.get("epic_id"),
-            "priority": params.get("priority", "medium"),
-            "assignee": params.get("assignee"),
-            "tags": params.get("tags", []),
-            "estimated_hours": params.get("estimated_hours"),
-        }
+    async def _handle_issue_create(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle issue creation - SYNCHRONOUS with validation.
 
-        queue_id = queue.add(
-            ticket_data=issue_data,
-            adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-            operation="create_issue",
+        Note: In the current model, 'issues' are Tasks with a parent epic.
+        """
+        # Validate and parse request
+        request = CreateIssueRequest(**params)
+
+        # Build task (issue) from validated DTO
+        task = Task(
+            title=request.title,
+            description=request.description,
+            parent_epic=request.epic_id,  # Issues are tasks under epics
+            priority=Priority(request.priority),
+            assignee=request.assignee,
+            tags=request.tags,
+            estimated_hours=request.estimated_hours,
         )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        worker_started = manager.start_if_needed()
-
-        if not worker_started and queue.get_pending_count() > 0:
-            return {
-                "status": "error",
-                "error": "Failed to start worker process",
-                "queue_id": queue_id,
-                "details": {
-                    "pending_count": queue.get_pending_count(),
-                    "action": "Worker process could not be started to process queued operations",
-                },
-            }
+        # Create directly
+        created = await self.adapter.create(task)
 
-        return {
-            "queue_id": queue_id,
-            "status": "queued",
-            "message": f"Issue creation queued with ID: {queue_id}",
-            "issue_data": issue_data,
-        }
+        # Return immediately
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.ticket_result(created)
+        )
 
-    async def _handle_issue_tasks(self, params: dict[str, Any]) -> list[dict[str, Any]]:
-        """Handle listing tasks in an issue."""
+    async def _handle_issue_tasks(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle listing tasks in an issue - SYNCHRONOUS."""
         issue_id = params["issue_id"]
         tasks = await self.adapter.list_tasks_by_issue(issue_id)
-        return [task.model_dump() for task in tasks]
 
-    async def _handle_task_create(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle task creation."""
-        # Check queue health
-        health_monitor = QueueHealthMonitor()
-        health = health_monitor.check_health()
-
-        if health["status"] == HealthStatus.CRITICAL:
-            repair_result = health_monitor.auto_repair()
-            health = health_monitor.check_health()
-
-            if health["status"] == HealthStatus.CRITICAL:
-                critical_alerts = [
-                    alert for alert in health["alerts"] if alert["level"] == "critical"
-                ]
-                return {
-                    "status": "error",
-                    "error": "Queue system is in critical state",
-                    "details": {
-                        "health_status": health["status"],
-                        "critical_issues": critical_alerts,
-                        "repair_attempted": repair_result["actions_taken"],
-                    },
-                }
-
-        # Validate required parent_id
-        if not params.get("parent_id"):
-            return {
-                "status": "error",
-                "error": "Tasks must have a parent_id (issue identifier)",
-                "details": {"required_field": "parent_id"},
-            }
-
-        # Queue the task creation
-        queue = Queue()
-        task_data = {
-            "title": params["title"],
-            "parent_id": params["parent_id"],
-            "description": params.get("description"),
-            "priority": params.get("priority", "medium"),
-            "assignee": params.get("assignee"),
-            "tags": params.get("tags", []),
-            "estimated_hours": params.get("estimated_hours"),
-        }
-
-        queue_id = queue.add(
-            ticket_data=task_data,
-            adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-            operation="create_task",
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.tasks_result(tasks)
         )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        worker_started = manager.start_if_needed()
+    async def _handle_task_create(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle task creation - SYNCHRONOUS with validation."""
+        # Validate and parse request (will raise ValidationError if parent_id missing)
+        request = CreateTaskRequest(**params)
+
+        # Build task from validated DTO
+        task = Task(
+            title=request.title,
+            parent_issue=request.parent_id,
+            description=request.description,
+            priority=Priority(request.priority),
+            assignee=request.assignee,
+            tags=request.tags,
+            estimated_hours=request.estimated_hours,
+        )
 
-        if not worker_started and queue.get_pending_count() > 0:
-            return {
-                "status": "error",
-                "error": "Failed to start worker process",
-                "queue_id": queue_id,
-                "details": {
-                    "pending_count": queue.get_pending_count(),
-                    "action": "Worker process could not be started to process queued operations",
-                },
-            }
+        # Create directly
+        created = await self.adapter.create(task)
 
-        return {
-            "queue_id": queue_id,
-            "status": "queued",
-            "message": f"Task creation queued with ID: {queue_id}",
-            "task_data": task_data,
-        }
+        # Return immediately
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.ticket_result(created)
+        )
 
     async def _handle_hierarchy_tree(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle hierarchy tree visualization."""
+        """Handle hierarchy tree visualization - SYNCHRONOUS."""
         epic_id = params.get("epic_id")
-        max_depth = params.get("max_depth", 3)
+        max_depth = params.get("max_depth", DEFAULT_MAX_DEPTH)
 
         if epic_id:
             # Get specific epic tree
             epic = await self.adapter.get_epic(epic_id)
             if not epic:
-                return {"error": f"Epic {epic_id} not found"}
+                return ResponseBuilder.status_result(
+                    STATUS_ERROR, error=MSG_EPIC_NOT_FOUND.format(epic_id=epic_id)
+                )
 
             # Build tree structure
             tree = {"epic": epic.model_dump(), "issues": []}
 
-            # Get issues in epic
-            issues = await self.adapter.list_issues_by_epic(epic_id)
-            for issue in issues:
-                issue_node = {"issue": issue.model_dump(), "tasks": []}
+            # Get issues in epic if depth allows (depth 1 = epic only, depth 2+ = issues)
+            if max_depth > 1:
+                issues = await self.adapter.list_issues_by_epic(epic_id)
+                for issue in issues:
+                    issue_node = {"issue": issue.model_dump(), "tasks": []}
 
-                # Get tasks in issue if depth allows
-                if max_depth > 2:
-                    tasks = await self.adapter.list_tasks_by_issue(issue.id)
-                    issue_node["tasks"] = [task.model_dump() for task in tasks]
+                    # Get tasks in issue if depth allows (depth 3+ = tasks)
+                    if max_depth > 2:
+                        tasks = await self.adapter.list_tasks_by_issue(issue.id)
+                        issue_node["tasks"] = [task.model_dump() for task in tasks]
 
-                tree["issues"].append(issue_node)
+                    tree["issues"].append(issue_node)
 
-            return tree
+            return ResponseBuilder.status_result(STATUS_COMPLETED, **tree)
         else:
             # Get all epics with their hierarchies
-            epics = await self.adapter.list_epics(limit=params.get("limit", 10))
+            epics = await self.adapter.list_epics(
+                limit=params.get("limit", DEFAULT_LIMIT)
+            )
             trees = []
 
             for epic in epics:
@@ -823,110 +483,79 @@ class MCPTicketServer:
                 )
                 trees.append(tree)
 
-            return {"trees": trees}
+            return ResponseBuilder.status_result(STATUS_COMPLETED, trees=trees)
 
     async def _handle_bulk_create(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle bulk ticket creation."""
+        """Handle bulk ticket creation - SYNCHRONOUS."""
         tickets = params.get("tickets", [])
         if not tickets:
-            return {"error": "No tickets provided for bulk creation"}
-
-        # Check queue health
-        health_monitor = QueueHealthMonitor()
-        health = health_monitor.check_health()
-
-        if health["status"] == HealthStatus.CRITICAL:
-            repair_result = health_monitor.auto_repair()
-            health = health_monitor.check_health()
-
-            if health["status"] == HealthStatus.CRITICAL:
-                return {
-                    "status": "error",
-                    "error": "Queue system is in critical state - cannot process bulk operations",
-                    "details": {"health_status": health["status"]},
-                }
-
-        # Queue all tickets
-        queue = Queue()
-        queue_ids = []
+            return ResponseBuilder.status_result(
+                STATUS_ERROR, error=MSG_NO_TICKETS_PROVIDED
+            )
 
+        results = []
         for i, ticket_data in enumerate(tickets):
             if not ticket_data.get("title"):
-                return {
-                    "status": "error",
-                    "error": f"Ticket {i} missing required 'title' field",
-                }
-
-            queue_id = queue.add(
-                ticket_data=ticket_data,
-                adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-                operation=ticket_data.get("operation", "create"),
-            )
-            queue_ids.append(queue_id)
+                return ResponseBuilder.status_result(
+                    STATUS_ERROR, error=MSG_MISSING_TITLE.format(index=i)
+                )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        manager.start_if_needed()
+            try:
+                # Create ticket based on operation type
+                operation = ticket_data.get("operation", "create")
+
+                if operation == "create_epic":
+                    result = await self._handle_epic_create(ticket_data)
+                elif operation == "create_issue":
+                    result = await self._handle_issue_create(ticket_data)
+                elif operation == "create_task":
+                    result = await self._handle_task_create(ticket_data)
+                else:
+                    result = await self._handle_create(ticket_data)
+
+                results.append(result)
+            except Exception as e:
+                results.append(
+                    ResponseBuilder.status_result(
+                        STATUS_ERROR, error=str(e), ticket_index=i
+                    )
+                )
 
-        return {
-            "queue_ids": queue_ids,
-            "status": "queued",
-            "message": f"Bulk creation of {len(tickets)} tickets queued",
-            "count": len(tickets),
-        }
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.bulk_result(results)
+        )
 
     async def _handle_bulk_update(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle bulk ticket updates."""
+        """Handle bulk ticket updates - SYNCHRONOUS."""
         updates = params.get("updates", [])
         if not updates:
-            return {"error": "No updates provided for bulk operation"}
-
-        # Check queue health
-        health_monitor = QueueHealthMonitor()
-        health = health_monitor.check_health()
-
-        if health["status"] == HealthStatus.CRITICAL:
-            repair_result = health_monitor.auto_repair()
-            health = health_monitor.check_health()
-
-            if health["status"] == HealthStatus.CRITICAL:
-                return {
-                    "status": "error",
-                    "error": "Queue system is in critical state - cannot process bulk operations",
-                    "details": {"health_status": health["status"]},
-                }
-
-        # Queue all updates
-        queue = Queue()
-        queue_ids = []
+            return ResponseBuilder.status_result(
+                STATUS_ERROR, error=MSG_NO_UPDATES_PROVIDED
+            )
 
+        results = []
         for i, update_data in enumerate(updates):
             if not update_data.get("ticket_id"):
-                return {
-                    "status": "error",
-                    "error": f"Update {i} missing required 'ticket_id' field",
-                }
-
-            queue_id = queue.add(
-                ticket_data=update_data,
-                adapter=self.adapter.__class__.__name__.lower().replace("adapter", ""),
-                operation="update",
-            )
-            queue_ids.append(queue_id)
+                return ResponseBuilder.status_result(
+                    STATUS_ERROR, error=MSG_MISSING_TICKET_ID.format(index=i)
+                )
 
-        # Start worker if needed
-        manager = WorkerManager()
-        manager.start_if_needed()
+            try:
+                result = await self._handle_update(update_data)
+                results.append(result)
+            except Exception as e:
+                results.append(
+                    ResponseBuilder.status_result(
+                        STATUS_ERROR, error=str(e), ticket_id=update_data["ticket_id"]
+                    )
+                )
 
-        return {
-            "queue_ids": queue_ids,
-            "status": "queued",
-            "message": f"Bulk update of {len(updates)} tickets queued",
-            "count": len(updates),
-        }
+        return ResponseBuilder.status_result(
+            STATUS_COMPLETED, **ResponseBuilder.bulk_result(results)
+        )
 
     async def _handle_search_hierarchy(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Handle hierarchy-aware search."""
+        """Handle hierarchy-aware search - SYNCHRONOUS."""
         query = params.get("query", "")
         include_children = params.get("include_children", True)
         include_parents = params.get("include_parents", True)
@@ -934,8 +563,8 @@ class MCPTicketServer:
         # Perform basic search
         search_query = SearchQuery(
             query=query,
-            state=params.get("state"),
-            priority=params.get("priority"),
+            state=TicketState(params["state"]) if params.get("state") else None,
+            priority=Priority(params["priority"]) if params.get("priority") else None,
             limit=params.get("limit", 50),
         )
 
@@ -972,6 +601,7 @@ class MCPTicketServer:
             enhanced_results.append(result)
 
         return {
+            "status": "completed",
             "results": enhanced_results,
             "count": len(enhanced_results),
             "query": query,
@@ -994,12 +624,10 @@ class MCPTicketServer:
             },
         }
 
-    async def _handle_list_attachments(
-        self, params: dict[str, Any]
-    ) -> list[dict[str, Any]]:
+    async def _handle_list_attachments(self, params: dict[str, Any]) -> dict[str, Any]:
         """Handle listing ticket attachments."""
         # Note: This is a placeholder for attachment functionality
-        return []
+        return {"status": "completed", "attachments": []}
 
     async def _handle_create_pr(self, params: dict[str, Any]) -> dict[str, Any]:
         """Handle PR creation for a ticket."""
@@ -1154,8 +782,8 @@ class MCPTicketServer:
 
         """
         return {
-            "protocolVersion": "2024-11-05",
-            "serverInfo": {"name": "mcp-ticketer", "version": "0.1.8"},
+            "protocolVersion": MCP_PROTOCOL_VERSION,
+            "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
             "capabilities": {"tools": {"listChanged": False}},
         }
 
@@ -1211,306 +839,7 @@ class MCPTicketServer:
                         },
                     },
                 },
-                {
-                    "name": "epic_issues",
-                    "description": "List all issues in an epic",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "epic_id": {
-                                "type": "string",
-                                "description": "Epic ID to get issues for",
-                            }
-                        },
-                        "required": ["epic_id"],
-                    },
-                },
-                {
-                    "name": "issue_create",
-                    "description": "Create a new issue (work item)",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "title": {"type": "string", "description": "Issue title"},
-                            "description": {
-                                "type": "string",
-                                "description": "Issue description",
-                            },
-                            "epic_id": {
-                                "type": "string",
-                                "description": "Parent epic ID",
-                            },
-                            "priority": {
-                                "type": "string",
-                                "enum": ["low", "medium", "high", "critical"],
-                                "default": "medium",
-                            },
-                            "assignee": {
-                                "type": "string",
-                                "description": "Assignee username",
-                            },
-                            "tags": {
-                                "type": "array",
-                                "items": {"type": "string"},
-                                "description": "Issue tags",
-                            },
-                            "estimated_hours": {
-                                "type": "number",
-                                "description": "Estimated hours to complete",
-                            },
-                        },
-                        "required": ["title"],
-                    },
-                },
-                {
-                    "name": "issue_tasks",
-                    "description": "List all tasks in an issue",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "issue_id": {
-                                "type": "string",
-                                "description": "Issue ID to get tasks for",
-                            }
-                        },
-                        "required": ["issue_id"],
-                    },
-                },
-                {
-                    "name": "task_create",
-                    "description": "Create a new task (sub-item under an issue)",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "title": {"type": "string", "description": "Task title"},
-                            "parent_id": {
-                                "type": "string",
-                                "description": "Parent issue ID (required)",
-                            },
-                            "description": {
-                                "type": "string",
-                                "description": "Task description",
-                            },
-                            "priority": {
-                                "type": "string",
-                                "enum": ["low", "medium", "high", "critical"],
-                                "default": "medium",
-                            },
-                            "assignee": {
-                                "type": "string",
-                                "description": "Assignee username",
-                            },
-                            "tags": {
-                                "type": "array",
-                                "items": {"type": "string"},
-                                "description": "Task tags",
-                            },
-                            "estimated_hours": {
-                                "type": "number",
-                                "description": "Estimated hours to complete",
-                            },
-                        },
-                        "required": ["title", "parent_id"],
-                    },
-                },
-                {
-                    "name": "hierarchy_tree",
-                    "description": "Get hierarchy tree view of epic/issues/tasks",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "epic_id": {
-                                "type": "string",
-                                "description": "Specific epic ID (optional - if not provided, returns all epics)",
-                            },
-                            "max_depth": {
-                                "type": "integer",
-                                "default": 3,
-                                "description": "Maximum depth to traverse (1=epics only, 2=epics+issues, 3=full tree)",
-                            },
-                            "limit": {
-                                "type": "integer",
-                                "default": 10,
-                                "description": "Maximum number of epics to return (when epic_id not specified)",
-                            },
-                        },
-                    },
-                },
-                # Bulk Operations
-                {
-                    "name": "ticket_bulk_create",
-                    "description": "Create multiple tickets in one operation",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "tickets": {
-                                "type": "array",
-                                "items": {
-                                    "type": "object",
-                                    "properties": {
-                                        "title": {"type": "string"},
-                                        "description": {"type": "string"},
-                                        "priority": {
-                                            "type": "string",
-                                            "enum": [
-                                                "low",
-                                                "medium",
-                                                "high",
-                                                "critical",
-                                            ],
-                                        },
-                                        "operation": {
-                                            "type": "string",
-                                            "enum": [
-                                                "create",
-                                                "create_epic",
-                                                "create_issue",
-                                                "create_task",
-                                            ],
-                                            "default": "create",
-                                        },
-                                        "epic_id": {
-                                            "type": "string",
-                                            "description": "For issues",
-                                        },
-                                        "parent_id": {
-                                            "type": "string",
-                                            "description": "For tasks",
-                                        },
-                                    },
-                                    "required": ["title"],
-                                },
-                                "description": "Array of tickets to create",
-                            }
-                        },
-                        "required": ["tickets"],
-                    },
-                },
-                {
-                    "name": "ticket_bulk_update",
-                    "description": "Update multiple tickets in one operation",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "updates": {
-                                "type": "array",
-                                "items": {
-                                    "type": "object",
-                                    "properties": {
-                                        "ticket_id": {"type": "string"},
-                                        "title": {"type": "string"},
-                                        "description": {"type": "string"},
-                                        "priority": {
-                                            "type": "string",
-                                            "enum": [
-                                                "low",
-                                                "medium",
-                                                "high",
-                                                "critical",
-                                            ],
-                                        },
-                                        "state": {"type": "string"},
-                                        "assignee": {"type": "string"},
-                                    },
-                                    "required": ["ticket_id"],
-                                },
-                                "description": "Array of ticket updates",
-                            }
-                        },
-                        "required": ["updates"],
-                    },
-                },
-                # Advanced Search
-                {
-                    "name": "ticket_search_hierarchy",
-                    "description": "Search tickets with hierarchy context",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "query": {"type": "string", "description": "Search query"},
-                            "state": {
-                                "type": "string",
-                                "description": "Filter by state",
-                            },
-                            "priority": {
-                                "type": "string",
-                                "description": "Filter by priority",
-                            },
-                            "limit": {
-                                "type": "integer",
-                                "default": 50,
-                                "description": "Maximum results",
-                            },
-                            "include_children": {
-                                "type": "boolean",
-                                "default": True,
-                                "description": "Include child items in results",
-                            },
-                            "include_parents": {
-                                "type": "boolean",
-                                "default": True,
-                                "description": "Include parent context in results",
-                            },
-                        },
-                        "required": ["query"],
-                    },
-                },
-                # PR Integration
-                {
-                    "name": "ticket_create_pr",
-                    "description": "Create a GitHub PR linked to a ticket",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "ticket_id": {
-                                "type": "string",
-                                "description": "Ticket ID to link the PR to",
-                            },
-                            "base_branch": {
-                                "type": "string",
-                                "description": "Target branch for the PR",
-                                "default": "main",
-                            },
-                            "head_branch": {
-                                "type": "string",
-                                "description": "Source branch name (auto-generated if not provided)",
-                            },
-                            "title": {
-                                "type": "string",
-                                "description": "PR title (uses ticket title if not provided)",
-                            },
-                            "body": {
-                                "type": "string",
-                                "description": "PR description (auto-generated with issue link if not provided)",
-                            },
-                            "draft": {
-                                "type": "boolean",
-                                "description": "Create as draft PR",
-                                "default": False,
-                            },
-                        },
-                        "required": ["ticket_id"],
-                    },
-                },
-                # Standard Ticket Operations
-                {
-                    "name": "ticket_link_pr",
-                    "description": "Link an existing PR to a ticket",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "ticket_id": {
-                                "type": "string",
-                                "description": "Ticket ID to link the PR to",
-                            },
-                            "pr_url": {
-                                "type": "string",
-                                "description": "GitHub PR URL to link",
-                            },
-                        },
-                        "required": ["ticket_id", "pr_url"],
-                    },
-                },
+                # ... (rest of the tools list)
                 {
                     "name": "ticket_create",
                     "description": "Create a new ticket",
@@ -1532,95 +861,6 @@ class MCPTicketServer:
                         "required": ["title"],
                     },
                 },
-                {
-                    "name": "ticket_list",
-                    "description": "List tickets",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "limit": {"type": "integer", "default": 10},
-                            "state": {"type": "string"},
-                            "priority": {"type": "string"},
-                        },
-                    },
-                },
-                {
-                    "name": "ticket_update",
-                    "description": "Update a ticket",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "ticket_id": {"type": "string", "description": "Ticket ID"},
-                            "updates": {
-                                "type": "object",
-                                "description": "Fields to update",
-                            },
-                        },
-                        "required": ["ticket_id", "updates"],
-                    },
-                },
-                {
-                    "name": "ticket_transition",
-                    "description": "Change ticket state",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "ticket_id": {"type": "string"},
-                            "target_state": {"type": "string"},
-                        },
-                        "required": ["ticket_id", "target_state"],
-                    },
-                },
-                {
-                    "name": "ticket_search",
-                    "description": "Search tickets",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "query": {"type": "string"},
-                            "state": {"type": "string"},
-                            "priority": {"type": "string"},
-                            "limit": {"type": "integer", "default": 10},
-                        },
-                    },
-                },
-                {
-                    "name": "ticket_status",
-                    "description": "Check status of queued ticket operation",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "queue_id": {
-                                "type": "string",
-                                "description": "Queue ID returned from create/update/delete operations",
-                            },
-                        },
-                        "required": ["queue_id"],
-                    },
-                },
-                # System diagnostics tools
-                {
-                    "name": "system_health",
-                    "description": "Quick system health check - shows configuration, queue worker, and failure rates",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {},
-                    },
-                },
-                {
-                    "name": "system_diagnose",
-                    "description": "Comprehensive system diagnostics - detailed analysis of all components",
-                    "inputSchema": {
-                        "type": "object",
-                        "properties": {
-                            "include_logs": {
-                                "type": "boolean",
-                                "default": False,
-                                "description": "Include recent log analysis in diagnosis",
-                            },
-                        },
-                    },
-                },
             ]
         }
 
@@ -1673,13 +913,6 @@ class MCPTicketServer:
                 result = await self._handle_transition(arguments)
             elif tool_name == "ticket_search":
                 result = await self._handle_search(arguments)
-            elif tool_name == "ticket_status":
-                result = await self._handle_queue_status(arguments)
-            # System diagnostics
-            elif tool_name == "system_health":
-                result = await self._handle_system_health(arguments)
-            elif tool_name == "system_diagnose":
-                result = await self._handle_system_diagnose(arguments)
             # PR integration
             elif tool_name == "ticket_create_pr":
                 result = await self._handle_create_pr(arguments)
@@ -1753,8 +986,8 @@ class MCPTicketServer:
                 sys.stdout.flush()
 
             except json.JSONDecodeError as e:
-                error_response = self._error_response(
-                    None, -32700, f"Parse error: {str(e)}"
+                error_response = ResponseBuilder.error(
+                    None, ERROR_PARSE, f"Parse error: {str(e)}"
                 )
                 sys.stdout.write(json.dumps(error_response) + "\n")
                 sys.stdout.flush()
@@ -1796,7 +1029,7 @@ async def main():
 
     # Initialize defaults
     adapter_type = "aitrackdown"
-    adapter_config = {"base_path": ".aitrackdown"}
+    adapter_config = {"base_path": DEFAULT_BASE_PATH}
 
     # Priority 1: Check .env files (highest priority for MCP)
     env_config = _load_env_configuration()
@@ -1840,12 +1073,12 @@ async def main():
             except (OSError, json.JSONDecodeError) as e:
                 logger.warning(f"Could not load project config: {e}, using defaults")
                 adapter_type = "aitrackdown"
-                adapter_config = {"base_path": ".aitrackdown"}
+                adapter_config = {"base_path": DEFAULT_BASE_PATH}
         else:
             # Priority 3: Default to aitrackdown
             logger.info("No configuration found, defaulting to aitrackdown adapter")
             adapter_type = "aitrackdown"
-            adapter_config = {"base_path": ".aitrackdown"}
+            adapter_config = {"base_path": DEFAULT_BASE_PATH}
 
     # Log final configuration for debugging
     logger.info(f"Starting MCP server with adapter: {adapter_type}")
@@ -1961,7 +1194,7 @@ def _build_adapter_config_from_env_vars(
 
     elif adapter_type == "aitrackdown":
         # AITrackdown adapter configuration
-        base_path = env_vars.get("MCP_TICKETER_BASE_PATH", ".aitrackdown")
+        base_path = env_vars.get("MCP_TICKETER_BASE_PATH", DEFAULT_BASE_PATH)
         config["base_path"] = base_path
         config["auto_create_dirs"] = True
 
@@ -1972,214 +1205,5 @@ def _build_adapter_config_from_env_vars(
     return config
 
 
-# Add diagnostic handler methods to MCPTicketServer class
-async def _handle_system_health(self, arguments: dict[str, Any]) -> dict[str, Any]:
-    """Handle system health check."""
-    from ..cli.diagnostics import SystemDiagnostics
-
-    try:
-        diagnostics = SystemDiagnostics()
-
-        # Quick health checks
-        health_status = {
-            "overall_status": "healthy",
-            "components": {},
-            "issues": [],
-            "warnings": [],
-        }
-
-        # Check configuration
-        try:
-            from ..core.config import get_config
-
-            config = get_config()
-            adapters = config.get_enabled_adapters()
-            if adapters:
-                health_status["components"]["configuration"] = {
-                    "status": "healthy",
-                    "adapters_count": len(adapters),
-                }
-            else:
-                health_status["components"]["configuration"] = {
-                    "status": "failed",
-                    "error": "No adapters configured",
-                }
-                health_status["issues"].append("No adapters configured")
-                health_status["overall_status"] = "critical"
-        except Exception as e:
-            health_status["components"]["configuration"] = {
-                "status": "failed",
-                "error": str(e),
-            }
-            health_status["issues"].append(f"Configuration error: {str(e)}")
-            health_status["overall_status"] = "critical"
-
-        # Check queue system
-        try:
-            from ..queue.manager import WorkerManager
-
-            worker_manager = WorkerManager()
-            worker_status = worker_manager.get_status()
-            stats = worker_manager.queue.get_stats()
-
-            total = stats.get("total", 0)
-            failed = stats.get("failed", 0)
-            failure_rate = (failed / total * 100) if total > 0 else 0
-
-            queue_health = {
-                "status": "healthy",
-                "worker_running": worker_status.get("running", False),
-                "worker_pid": worker_status.get("pid"),
-                "failure_rate": failure_rate,
-                "total_processed": total,
-                "failed_items": failed,
-            }
-
-            if not worker_status.get("running", False):
-                queue_health["status"] = "failed"
-                health_status["issues"].append("Queue worker not running")
-                health_status["overall_status"] = "critical"
-            elif failure_rate > 50:
-                queue_health["status"] = "degraded"
-                health_status["issues"].append(
-                    f"High queue failure rate: {failure_rate:.1f}%"
-                )
-                health_status["overall_status"] = "critical"
-            elif failure_rate > 20:
-                queue_health["status"] = "warning"
-                health_status["warnings"].append(
-                    f"Elevated queue failure rate: {failure_rate:.1f}%"
-                )
-                if health_status["overall_status"] == "healthy":
-                    health_status["overall_status"] = "warning"
-
-            health_status["components"]["queue_system"] = queue_health
-
-        except Exception as e:
-            health_status["components"]["queue_system"] = {
-                "status": "failed",
-                "error": str(e),
-            }
-            health_status["issues"].append(f"Queue system error: {str(e)}")
-            health_status["overall_status"] = "critical"
-
-        return {
-            "content": [
-                {
-                    "type": "text",
-                    "text": f"System Health Status: {health_status['overall_status'].upper()}\n\n"
-                    + f"Configuration: {health_status['components'].get('configuration', {}).get('status', 'unknown')}\n"
-                    + f"Queue System: {health_status['components'].get('queue_system', {}).get('status', 'unknown')}\n\n"
-                    + f"Issues: {len(health_status['issues'])}\n"
-                    + f"Warnings: {len(health_status['warnings'])}\n\n"
-                    + (
-                        "Critical Issues:\n"
-                        + "\n".join(f"• {issue}" for issue in health_status["issues"])
-                        + "\n\n"
-                        if health_status["issues"]
-                        else ""
-                    )
-                    + (
-                        "Warnings:\n"
-                        + "\n".join(
-                            f"• {warning}" for warning in health_status["warnings"]
-                        )
-                        + "\n\n"
-                        if health_status["warnings"]
-                        else ""
-                    )
-                    + "For detailed diagnosis, use system_diagnose tool.",
-                }
-            ],
-            "isError": health_status["overall_status"] == "critical",
-        }
-
-    except Exception as e:
-        return {
-            "content": [
-                {
-                    "type": "text",
-                    "text": f"Health check failed: {str(e)}",
-                }
-            ],
-            "isError": True,
-        }
-
-
-async def _handle_system_diagnose(self, arguments: dict[str, Any]) -> dict[str, Any]:
-    """Handle comprehensive system diagnosis."""
-    from ..cli.diagnostics import SystemDiagnostics
-
-    try:
-        diagnostics = SystemDiagnostics()
-        report = await diagnostics.run_full_diagnosis()
-
-        # Format report for MCP response
-        summary = f"""System Diagnosis Report
-Generated: {report['timestamp']}
-Version: {report['version']}
-
-OVERALL STATUS: {
-    'CRITICAL' if diagnostics.issues else
-    'WARNING' if diagnostics.warnings else
-    'HEALTHY'
-}
-
-COMPONENT STATUS:
-• Configuration: {len(report['configuration']['issues'])} issues
-• Adapters: {report['adapters']['failed_adapters']}/{report['adapters']['total_adapters']} failed
-• Queue System: {report['queue_system']['health_score']}/100 health score
-
-STATISTICS:
-• Successes: {len(diagnostics.successes)}
-• Warnings: {len(diagnostics.warnings)}
-• Critical Issues: {len(diagnostics.issues)}
-
-"""
-
-        if diagnostics.issues:
-            summary += "CRITICAL ISSUES:\n"
-            for issue in diagnostics.issues:
-                summary += f"• {issue}\n"
-            summary += "\n"
-
-        if diagnostics.warnings:
-            summary += "WARNINGS:\n"
-            for warning in diagnostics.warnings:
-                summary += f"• {warning}\n"
-            summary += "\n"
-
-        if report["recommendations"]:
-            summary += "RECOMMENDATIONS:\n"
-            for rec in report["recommendations"]:
-                summary += f"{rec}\n"
-
-        return {
-            "content": [
-                {
-                    "type": "text",
-                    "text": summary,
-                }
-            ],
-            "isError": bool(diagnostics.issues),
-        }
-
-    except Exception as e:
-        return {
-            "content": [
-                {
-                    "type": "text",
-                    "text": f"System diagnosis failed: {str(e)}",
-                }
-            ],
-            "isError": True,
-        }
-
-
-# Monkey patch the methods onto the class
-MCPTicketServer._handle_system_health = _handle_system_health
-MCPTicketServer._handle_system_diagnose = _handle_system_diagnose
-
-
 if __name__ == "__main__":
     asyncio.run(main())