mcp-ticketer 0.1.26__py3-none-any.whl → 0.1.27__py3-none-any.whl

mcp_ticketer/queue/ticket_registry.py

@@ -0,0 +1,416 @@
+"""Ticket ID persistence and recovery system."""
+
+import json
+import sqlite3
+import threading
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .queue import QueueItem, QueueStatus
+
+
+class TicketRegistry:
+    """Persistent registry for tracking ticket IDs and their lifecycle."""
+    
+    def __init__(self, db_path: Optional[Path] = None):
+        """Initialize ticket registry.
+        
+        Args:
+            db_path: Path to SQLite database. Defaults to ~/.mcp-ticketer/tickets.db
+        """
+        if db_path is None:
+            db_dir = Path.home() / ".mcp-ticketer"
+            db_dir.mkdir(parents=True, exist_ok=True)
+            db_path = db_dir / "tickets.db"
+        
+        self.db_path = str(db_path)
+        self._lock = threading.Lock()
+        self._init_database()
+    
+    def _init_database(self):
+        """Initialize database schema."""
+        with sqlite3.connect(self.db_path) as conn:
+            # Ticket registry table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS ticket_registry (
+                    queue_id TEXT PRIMARY KEY,
+                    ticket_id TEXT,
+                    adapter TEXT NOT NULL,
+                    operation TEXT NOT NULL,
+                    title TEXT,
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL,
+                    ticket_data TEXT,
+                    result_data TEXT,
+                    error_message TEXT,
+                    retry_count INTEGER DEFAULT 0,
+                    CHECK (status IN ('queued', 'processing', 'completed', 'failed', 'recovered'))
+                )
+            """)
+            
+            # Create indices
+            conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_ticket_registry_ticket_id
+                ON ticket_registry(ticket_id)
+            """)
+            conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_ticket_registry_status
+                ON ticket_registry(status)
+            """)
+            conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_ticket_registry_adapter
+                ON ticket_registry(adapter)
+            """)
+            
+            # Ticket recovery log table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS recovery_log (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    queue_id TEXT NOT NULL,
+                    recovery_type TEXT NOT NULL,
+                    recovery_data TEXT,
+                    timestamp TEXT NOT NULL,
+                    success BOOLEAN NOT NULL
+                )
+            """)
+    
+    def register_ticket_operation(
+        self,
+        queue_id: str,
+        adapter: str,
+        operation: str,
+        title: str,
+        ticket_data: Dict[str, Any]
+    ) -> None:
+        """Register a new ticket operation.
+        
+        Args:
+            queue_id: Queue operation ID
+            adapter: Adapter name
+            operation: Operation type (create, update, etc.)
+            title: Ticket title
+            ticket_data: Original ticket data
+        """
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute("""
+                    INSERT OR REPLACE INTO ticket_registry (
+                        queue_id, adapter, operation, title, status,
+                        created_at, updated_at, ticket_data, retry_count
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    queue_id,
+                    adapter,
+                    operation,
+                    title,
+                    "queued",
+                    datetime.now().isoformat(),
+                    datetime.now().isoformat(),
+                    json.dumps(ticket_data),
+                    0
+                ))
+                conn.commit()
+    
+    def update_ticket_status(
+        self,
+        queue_id: str,
+        status: str,
+        ticket_id: Optional[str] = None,
+        result_data: Optional[Dict[str, Any]] = None,
+        error_message: Optional[str] = None,
+        retry_count: Optional[int] = None
+    ) -> None:
+        """Update ticket operation status.
+        
+        Args:
+            queue_id: Queue operation ID
+            status: New status
+            ticket_id: Created ticket ID (if available)
+            result_data: Operation result data
+            error_message: Error message if failed
+            retry_count: Current retry count
+        """
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                update_fields = ["status = ?", "updated_at = ?"]
+                values = [status, datetime.now().isoformat()]
+                
+                if ticket_id is not None:
+                    update_fields.append("ticket_id = ?")
+                    values.append(ticket_id)
+                
+                if result_data is not None:
+                    update_fields.append("result_data = ?")
+                    values.append(json.dumps(result_data))
+                
+                if error_message is not None:
+                    update_fields.append("error_message = ?")
+                    values.append(error_message)
+                
+                if retry_count is not None:
+                    update_fields.append("retry_count = ?")
+                    values.append(retry_count)
+                
+                values.append(queue_id)
+                
+                conn.execute(f"""
+                    UPDATE ticket_registry
+                    SET {', '.join(update_fields)}
+                    WHERE queue_id = ?
+                """, values)
+                conn.commit()
+    
+    def get_ticket_info(self, queue_id: str) -> Optional[Dict[str, Any]]:
+        """Get ticket information by queue ID.
+        
+        Args:
+            queue_id: Queue operation ID
+            
+        Returns:
+            Ticket information or None if not found
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("""
+                SELECT * FROM ticket_registry WHERE queue_id = ?
+            """, (queue_id,))
+            
+            row = cursor.fetchone()
+            if not row:
+                return None
+            
+            columns = [desc[0] for desc in cursor.description]
+            ticket_info = dict(zip(columns, row))
+            
+            # Parse JSON fields
+            if ticket_info.get("ticket_data"):
+                ticket_info["ticket_data"] = json.loads(ticket_info["ticket_data"])
+            if ticket_info.get("result_data"):
+                ticket_info["result_data"] = json.loads(ticket_info["result_data"])
+            
+            return ticket_info
+    
+    def find_tickets_by_id(self, ticket_id: str) -> List[Dict[str, Any]]:
+        """Find all operations for a specific ticket ID.
+        
+        Args:
+            ticket_id: Ticket ID to search for
+            
+        Returns:
+            List of ticket operations
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("""
+                SELECT * FROM ticket_registry 
+                WHERE ticket_id = ?
+                ORDER BY created_at DESC
+            """, (ticket_id,))
+            
+            results = []
+            columns = [desc[0] for desc in cursor.description]
+            
+            for row in cursor.fetchall():
+                ticket_info = dict(zip(columns, row))
+                
+                # Parse JSON fields
+                if ticket_info.get("ticket_data"):
+                    ticket_info["ticket_data"] = json.loads(ticket_info["ticket_data"])
+                if ticket_info.get("result_data"):
+                    ticket_info["result_data"] = json.loads(ticket_info["result_data"])
+                
+                results.append(ticket_info)
+            
+            return results
+    
+    def get_failed_operations(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """Get failed operations that might need recovery.
+        
+        Args:
+            limit: Maximum number of operations to return
+            
+        Returns:
+            List of failed operations
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("""
+                SELECT * FROM ticket_registry 
+                WHERE status = 'failed'
+                ORDER BY updated_at DESC
+                LIMIT ?
+            """, (limit,))
+            
+            results = []
+            columns = [desc[0] for desc in cursor.description]
+            
+            for row in cursor.fetchall():
+                ticket_info = dict(zip(columns, row))
+                
+                # Parse JSON fields
+                if ticket_info.get("ticket_data"):
+                    ticket_info["ticket_data"] = json.loads(ticket_info["ticket_data"])
+                if ticket_info.get("result_data"):
+                    ticket_info["result_data"] = json.loads(ticket_info["result_data"])
+                
+                results.append(ticket_info)
+            
+            return results
+    
+    def get_orphaned_tickets(self) -> List[Dict[str, Any]]:
+        """Get tickets that were created but queue operation failed.
+        
+        Returns:
+            List of potentially orphaned tickets
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("""
+                SELECT * FROM ticket_registry 
+                WHERE ticket_id IS NOT NULL 
+                AND status IN ('processing', 'failed')
+                ORDER BY updated_at DESC
+            """)
+            
+            results = []
+            columns = [desc[0] for desc in cursor.description]
+            
+            for row in cursor.fetchall():
+                ticket_info = dict(zip(columns, row))
+                
+                # Parse JSON fields
+                if ticket_info.get("ticket_data"):
+                    ticket_info["ticket_data"] = json.loads(ticket_info["ticket_data"])
+                if ticket_info.get("result_data"):
+                    ticket_info["result_data"] = json.loads(ticket_info["result_data"])
+                
+                results.append(ticket_info)
+            
+            return results
+    
+    def attempt_recovery(self, queue_id: str, recovery_type: str) -> Dict[str, Any]:
+        """Attempt to recover a failed operation.
+        
+        Args:
+            queue_id: Queue operation ID to recover
+            recovery_type: Type of recovery to attempt
+            
+        Returns:
+            Recovery result
+        """
+        ticket_info = self.get_ticket_info(queue_id)
+        if not ticket_info:
+            return {"success": False, "error": "Ticket operation not found"}
+        
+        recovery_data = {
+            "original_status": ticket_info["status"],
+            "recovery_type": recovery_type,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        try:
+            if recovery_type == "mark_completed":
+                # Mark as completed if ticket ID exists
+                if ticket_info.get("ticket_id"):
+                    self.update_ticket_status(queue_id, "recovered", 
+                                            result_data={"recovery": "marked_completed"})
+                    recovery_data["success"] = True
+                    recovery_data["action"] = "Marked as completed based on existing ticket ID"
+                else:
+                    recovery_data["success"] = False
+                    recovery_data["error"] = "No ticket ID available to mark as completed"
+            
+            elif recovery_type == "retry_operation":
+                # Reset to queued status for retry
+                self.update_ticket_status(queue_id, "queued", 
+                                        error_message=None,
+                                        retry_count=ticket_info.get("retry_count", 0))
+                recovery_data["success"] = True
+                recovery_data["action"] = "Reset to queued for retry"
+            
+            else:
+                recovery_data["success"] = False
+                recovery_data["error"] = f"Unknown recovery type: {recovery_type}"
+            
+            # Log recovery attempt
+            self._log_recovery(queue_id, recovery_type, recovery_data, recovery_data["success"])
+            
+            return recovery_data
+            
+        except Exception as e:
+            recovery_data["success"] = False
+            recovery_data["error"] = str(e)
+            self._log_recovery(queue_id, recovery_type, recovery_data, False)
+            return recovery_data
+    
+    def _log_recovery(
+        self, 
+        queue_id: str, 
+        recovery_type: str, 
+        recovery_data: Dict[str, Any], 
+        success: bool
+    ) -> None:
+        """Log recovery attempt."""
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute("""
+                    INSERT INTO recovery_log (
+                        queue_id, recovery_type, recovery_data, timestamp, success
+                    ) VALUES (?, ?, ?, ?, ?)
+                """, (
+                    queue_id,
+                    recovery_type,
+                    json.dumps(recovery_data),
+                    datetime.now().isoformat(),
+                    success
+                ))
+                conn.commit()
+    
+    def get_recovery_history(self, queue_id: str) -> List[Dict[str, Any]]:
+        """Get recovery history for a queue operation.
+        
+        Args:
+            queue_id: Queue operation ID
+            
+        Returns:
+            List of recovery attempts
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("""
+                SELECT * FROM recovery_log 
+                WHERE queue_id = ?
+                ORDER BY timestamp DESC
+            """, (queue_id,))
+            
+            results = []
+            columns = [desc[0] for desc in cursor.description]
+            
+            for row in cursor.fetchall():
+                recovery_info = dict(zip(columns, row))
+                if recovery_info.get("recovery_data"):
+                    recovery_info["recovery_data"] = json.loads(recovery_info["recovery_data"])
+                results.append(recovery_info)
+            
+            return results
+    
+    def cleanup_old_entries(self, days: int = 30) -> int:
+        """Clean up old completed entries.
+        
+        Args:
+            days: Remove entries older than this many days
+            
+        Returns:
+            Number of entries removed
+        """
+        cutoff_date = (datetime.now() - timedelta(days=days)).isoformat()
+        
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.execute("""
+                    DELETE FROM ticket_registry
+                    WHERE status IN ('completed', 'recovered')
+                    AND updated_at < ?
+                """, (cutoff_date,))
+                
+                deleted_count = cursor.rowcount
+                conn.commit()
+                
+                return deleted_count

mcp_ticketer/queue/worker.py

@@ -13,6 +13,10 @@ from dotenv import load_dotenv
 
 from ..core import AdapterRegistry, Task
 from .queue import Queue, QueueItem, QueueStatus
+from .ticket_registry import TicketRegistry
+
+# Import adapters module to trigger registration
+import mcp_ticketer.adapters  # noqa: F401
 
 # Load environment variables from .env.local
 env_path = Path.cwd() / ".env.local"
@@ -67,6 +71,7 @@ class Worker:
 
         """
         self.queue = queue or Queue()
+        self.ticket_registry = TicketRegistry()
         self.running = False
         self.stop_event = threading.Event()
         self.batch_size = batch_size
@@ -232,6 +237,13 @@ class Worker:
             f"Processing queue item {item.id}: {item.operation} on {item.adapter}"
         )
 
+        # Register operation start in ticket registry
+        title = item.ticket_data.get("title", "Unknown")
+        self.ticket_registry.register_ticket_operation(
+            item.id, item.adapter, item.operation, title, item.ticket_data
+        )
+        self.ticket_registry.update_ticket_status(item.id, "processing")
+
         try:
             # Check rate limit
             await self._check_rate_limit(item.adapter)
@@ -244,14 +256,34 @@ class Worker:
             # Process operation
             result = await self._execute_operation(adapter, item)
 
-            # Mark as completed
-            self.queue.update_status(item.id, QueueStatus.COMPLETED, result=result)
+            # Extract ticket ID from result if available
+            ticket_id = None
+            if isinstance(result, dict):
+                ticket_id = result.get("id")
+
+            # Mark as completed in both queue and registry (atomic)
+            success = self.queue.update_status(
+                item.id, QueueStatus.COMPLETED, result=result,
+                expected_status=QueueStatus.PROCESSING
+            )
+            if success:
+                self.ticket_registry.update_ticket_status(
+                    item.id, "completed", ticket_id=ticket_id, result_data=result
+                )
+            else:
+                logger.warning(f"Failed to update status for {item.id} - item may have been processed by another worker")
+
             self.stats["items_processed"] += 1
-            logger.info(f"Successfully processed {item.id}")
+            logger.info(f"Successfully processed {item.id}, ticket ID: {ticket_id}")
 
         except Exception as e:
             logger.error(f"Error processing {item.id}: {e}")
 
+            # Update registry with error
+            self.ticket_registry.update_ticket_status(
+                item.id, "failed", error_message=str(e), retry_count=item.retry_count
+            )
+
             # Check retry count
             if item.retry_count < self.MAX_RETRIES:
                 # Retry with exponential backoff
@@ -260,16 +292,31 @@ class Worker:
                     f"Retrying {item.id} after {retry_delay}s (attempt {item.retry_count + 1}/{self.MAX_RETRIES})"
                 )
 
-                # Increment retry count and reset to pending
-                self.queue.increment_retry(item.id)
+                # Increment retry count and reset to pending (atomic)
+                new_retry_count = self.queue.increment_retry(
+                    item.id, expected_status=QueueStatus.PROCESSING
+                )
+                if new_retry_count >= 0:
+                    self.ticket_registry.update_ticket_status(
+                        item.id, "queued", retry_count=new_retry_count
+                    )
+                else:
+                    logger.warning(f"Failed to increment retry for {item.id} - item may have been processed by another worker")
 
                 # Wait before retry
                 await asyncio.sleep(retry_delay)
             else:
-                # Max retries exceeded, mark as failed
-                self.queue.update_status(
-                    item.id, QueueStatus.FAILED, error_message=str(e)
+                # Max retries exceeded, mark as failed (atomic)
+                success = self.queue.update_status(
+                    item.id, QueueStatus.FAILED, error_message=str(e),
+                    expected_status=QueueStatus.PROCESSING
                 )
+                if success:
+                    self.ticket_registry.update_ticket_status(
+                        item.id, "failed", error_message=str(e), retry_count=item.retry_count
+                    )
+                else:
+                    logger.warning(f"Failed to mark {item.id} as failed - item may have been processed by another worker")
                 self.stats["items_failed"] += 1
                 logger.error(f"Max retries exceeded for {item.id}, marking as failed")
 
@@ -387,6 +434,53 @@ class Worker:
             await adapter.add_comment(ticket_id, content)
             return {"success": True}
 
+        # Hierarchy operations
+        elif operation == "create_epic":
+            result = await adapter.create_epic(
+                title=data["title"],
+                description=data.get("description"),
+                **{k: v for k, v in data.items()
+                   if k not in ["title", "description"]}
+            )
+            return {
+                "id": result.id if result else None,
+                "title": result.title if result else None,
+                "type": "epic",
+                "success": bool(result)
+            }
+
+        elif operation == "create_issue":
+            result = await adapter.create_issue(
+                title=data["title"],
+                description=data.get("description"),
+                epic_id=data.get("epic_id"),
+                **{k: v for k, v in data.items()
+                   if k not in ["title", "description", "epic_id"]}
+            )
+            return {
+                "id": result.id if result else None,
+                "title": result.title if result else None,
+                "type": "issue",
+                "epic_id": data.get("epic_id"),
+                "success": bool(result)
+            }
+
+        elif operation == "create_task":
+            result = await adapter.create_task(
+                title=data["title"],
+                parent_id=data["parent_id"],
+                description=data.get("description"),
+                **{k: v for k, v in data.items()
+                   if k not in ["title", "parent_id", "description"]}
+            )
+            return {
+                "id": result.id if result else None,
+                "title": result.title if result else None,
+                "type": "task",
+                "parent_id": data["parent_id"],
+                "success": bool(result)
+            }
+
         else:
             raise ValueError(f"Unknown operation: {operation}")
 

{mcp_ticketer-0.1.26.dist-info → mcp_ticketer-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-ticketer
-Version: 0.1.26
+Version: 0.1.27
 Summary: Universal ticket management interface for AI agents with MCP support
 Author-email: MCP Ticketer Team <support@mcp-ticketer.io>
 Maintainer-email: MCP Ticketer Team <support@mcp-ticketer.io>

{mcp_ticketer-0.1.26.dist-info → mcp_ticketer-0.1.27.dist-info}/RECORD

@@ -1,10 +1,10 @@
 mcp_ticketer/__init__.py,sha256=Xx4WaprO5PXhVPbYi1L6tBmwmJMkYS-lMyG4ieN6QP0,717
-mcp_ticketer/__version__.py,sha256=Blu_YTtqV4xVWOGVEqjOak3E8m3Fe2X2xVHzhlPhTTA,1118
+mcp_ticketer/__version__.py,sha256=gJUzlDdgl1Llr0GmKo1nWN84jviu8fvgk3jadt7EbaU,1118
 mcp_ticketer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_ticketer/adapters/__init__.py,sha256=B5DFllWn23hkhmrLykNO5uMMSdcFuuPHXyLw_jyFzuE,358
 mcp_ticketer/adapters/aitrackdown.py,sha256=24h3UqMj5CltCl271kmqnDFOicCVp9w7yMTKK8s_dTA,16283
 mcp_ticketer/adapters/github.py,sha256=X0lEWBCfy-vztX2vauuVSYsOCa9_ezt9hGa5BsCQTu8,46663
-mcp_ticketer/adapters/hybrid.py,sha256=XFqHtWTLguE61ZGuZ156gxoz-wMr21AxLSADI1QVxcU,19025
+mcp_ticketer/adapters/hybrid.py,sha256=UADYZLc_UNw0xHPSbgguBNzvUCnuYn12Qi9ea-zdlMk,19086
 mcp_ticketer/adapters/jira.py,sha256=W2pU-YxrSqgjm1gVt2eGc8We-G0MbRMSggQ2gWkThME,30602
 mcp_ticketer/adapters/linear.py,sha256=C6rHIxRaWvOBjX6ue2Nt-IPTcwFAwBkksstb7zV3YJw,71484
 mcp_ticketer/cache/__init__.py,sha256=Xcd-cKnt-Cx7jBzvfzUUUPaGkmyXFi5XUFWw3Z4b7d4,138
@@ -15,7 +15,7 @@ mcp_ticketer/cli/codex_configure.py,sha256=xDppHouT6_-cYXswyAggoPX5bSlRXMvCoM_x9
 mcp_ticketer/cli/configure.py,sha256=BsA_pSHQMQS0t1bJO_wMM8LWsd5sWJDASjEPRHvwC18,16198
 mcp_ticketer/cli/discover.py,sha256=AF_qlQc1Oo0UkWayoF5pmRChS5J3fJjH6f2YZzd_k8w,13188
 mcp_ticketer/cli/gemini_configure.py,sha256=ZNSA1lBW-itVToza-JxW95Po7daVXKiZAh7lp6pmXMU,9343
-mcp_ticketer/cli/main.py,sha256=AvWLtlKrAtgWv6cfXNRzESqJE7CRhHdKeDuNWOxj5GM,47111
+mcp_ticketer/cli/main.py,sha256=hXPQyeQ9dv5Ry1XxSJZqmanw2KTgN912eXd1dkwd_os,53326
 mcp_ticketer/cli/mcp_configure.py,sha256=RzV50UjXgOmvMp-9S0zS39psuvjffVByaMrqrUaAGAM,9594
 mcp_ticketer/cli/migrate_config.py,sha256=MYsr_C5ZxsGg0P13etWTWNrJ_lc6ElRCkzfQADYr3DM,5956
 mcp_ticketer/cli/queue_commands.py,sha256=mm-3H6jmkUGJDyU_E46o9iRpek8tvFCm77F19OtHiZI,7884
@@ -30,16 +30,18 @@ mcp_ticketer/core/models.py,sha256=DRuJoYbjp9fcPV9GwQfhVcNUB0XmwQB3vuqW8hQWZ_k,6
 mcp_ticketer/core/project_config.py,sha256=yYxlgxjcEPeOwx-b-SXFpe0k9pW9xzBRAK72PsItG-o,23346
 mcp_ticketer/core/registry.py,sha256=ShYLDPE62KFJpB0kj_zFyQzRxSH3LkQEEuo1jaakb1k,3483
 mcp_ticketer/mcp/__init__.py,sha256=Y05eTzsPk0wH8yKNIM-ekpGjgSDO0bQr0EME-vOP4GE,123
-mcp_ticketer/mcp/server.py,sha256=YXhKqxz5b4k7_38yj0dCHOmNBFbXppQbctbL8zUOLVQ,37134
+mcp_ticketer/mcp/server.py,sha256=PpENqLi9qdhxT1KTYrjkekT1LWP2mfTZY-PF6la1hs4,68078
 mcp_ticketer/queue/__init__.py,sha256=1YIaCpZpFqPcqvDEQXiEvDLiw94DXRdCJkBaVIFQrms,231
 mcp_ticketer/queue/__main__.py,sha256=gc_tE9NUdK07OJfTZuD4t6KeBD_vxFQIhknGTQUG_jk,109
+mcp_ticketer/queue/health_monitor.py,sha256=aQrlBzfbLWu8-fV2b5CuHs4oqyTqGGcntKIHM3r-dDI,11844
 mcp_ticketer/queue/manager.py,sha256=qqUqq_JtH8jfg-MDfc-UIgFaa7gYsA1eBaR2KsCw48c,7513
-mcp_ticketer/queue/queue.py,sha256=zD7SRDP7zfGm4gokqzgL0CLuPUPxbBNmddsOqLMCbjQ,13162
+mcp_ticketer/queue/queue.py,sha256=jSAkYNEIbNH1cbYuF8s6eFuZmXqn8WHXx3mbfMU2Ud8,17131
 mcp_ticketer/queue/run_worker.py,sha256=_IBezjvhbJJ7gn0evTBIMbSPjvfFZwxEdT-1DLo_bRk,799
-mcp_ticketer/queue/worker.py,sha256=2wusez3Wxmun6qAmup3WsGjBD-vNgtLwxygYviXdECQ,14634
-mcp_ticketer-0.1.26.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
-mcp_ticketer-0.1.26.dist-info/METADATA,sha256=U39e27Ve_r8quq7j089RGcFHPuTN6QL1UbVI6o6ZwrA,13191
-mcp_ticketer-0.1.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_ticketer-0.1.26.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
-mcp_ticketer-0.1.26.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
-mcp_ticketer-0.1.26.dist-info/RECORD,,
+mcp_ticketer/queue/ticket_registry.py,sha256=k8FYg2cFYsI4POb94-o-fTrIVr-ttfi60r0O5YhJYck,15321
+mcp_ticketer/queue/worker.py,sha256=TLXXXTAQT1k9Oiw2WjSd8bzT3rr8TQ8NLt9JBovGQEA,18679
+mcp_ticketer-0.1.27.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
+mcp_ticketer-0.1.27.dist-info/METADATA,sha256=XPG1iLoD_XDRGzMfufeIwycZk3b_vvJ4aaHRhE_2nws,13191
+mcp_ticketer-0.1.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_ticketer-0.1.27.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
+mcp_ticketer-0.1.27.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
+mcp_ticketer-0.1.27.dist-info/RECORD,,