🔧 Worker Daemon: базова реалізація v1

- Capability Registry (Postgres heartbeat)
- NATS Client (підписка на streams)
- Job Executor (виконання jobs)
- Metrics Exporter (Prometheus)
- Dockerfile для deployment
- Виправлено server_name в NATS (emptyDir)

TODO: Реальна реалізація embed/retrieve/summarize, Matrix Gateway, Auth

infrastructure/worker-daemon/worker/job_executor.py

@@ -0,0 +1,128 @@
+"""
+Job Executor — виконання jobs з NATS
+"""
+
+import asyncio
+import json
+from typing import Dict, Any, Optional
+from datetime import datetime
+
+
+class JobExecutor:
+    def __init__(self, node_id: str, tier: str):
+        self.node_id = node_id
+        self.tier = tier
+        
+    async def execute_job(self, job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Виконання job"""
+        job_id = job_data.get("job_id", "unknown")
+        job_type = job_data.get("type", "unknown")
+        priority = job_data.get("priority", "offline")
+        
+        print(f"📦 Виконання job: {job_id} (type: {job_type}, priority: {priority})")
+        
+        # Перевірка requirements
+        if not self._can_fulfill(job_data.get("requirements", {})):
+            return {
+                "success": False,
+                "reason": "requirements_not_met"
+            }
+            
+        # Виконання залежно від типу
+        try:
+            if job_type == "embed":
+                result = await self._execute_embed(job_data)
+            elif job_type == "retrieve":
+                result = await self._execute_retrieve(job_data)
+            elif job_type == "summarize":
+                result = await self._execute_summarize(job_data)
+            elif job_type == "qdrant_upsert":
+                result = await self._execute_qdrant_upsert(job_data)
+            elif job_type == "pg_write":
+                result = await self._execute_pg_write(job_data)
+            elif job_type == "neo4j_write":
+                result = await self._execute_neo4j_write(job_data)
+            else:
+                return {
+                    "success": False,
+                    "reason": f"unknown_job_type: {job_type}"
+                }
+                
+            return {
+                "success": True,
+                "result": result
+            }
+            
+        except Exception as e:
+            print(f"❌ Помилка виконання job {job_id}: {e}")
+            return {
+                "success": False,
+                "reason": str(e),
+                "backoff": 30  # Retry через 30 секунд
+            }
+            
+    def _can_fulfill(self, requirements: Dict[str, Any]) -> bool:
+        """Перевірка, чи воркер може виконати job"""
+        # Перевірка tier
+        required_tier = requirements.get("tier")
+        if required_tier and required_tier != self.tier:
+            return False
+            
+        # Перевірка GPU
+        needs_gpu = requirements.get("needs_gpu", False)
+        if needs_gpu:
+            # TODO: Перевірити наявність GPU
+            pass
+            
+        # Перевірка VRAM
+        min_vram = requirements.get("min_vram_gb", 0)
+        if min_vram > 0:
+            # TODO: Перевірити доступну VRAM
+            pass
+            
+        return True
+        
+    async def _execute_embed(self, job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Виконання embedding job"""
+        input_data = job_data.get("input", {})
+        texts = input_data.get("text", [])
+        model = input_data.get("model", "cohere/embed-multilingual-v3.0")
+        
+        # TODO: Реальна реалізація через Cohere API або локальну модель
+        print(f"  → Embedding {len(texts)} texts з {model}")
+        
+        # Симуляція
+        await asyncio.sleep(0.1)
+        
+        embeddings = [[0.0] * 1024 for _ in texts]  # Placeholder
+        
+        return {
+            "embeddings": embeddings,
+            "model": model,
+            "dims": 1024
+        }
+        
+    async def _execute_retrieve(self, job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Виконання retrieval job"""
+        # TODO: Реальна реалізація через Qdrant
+        return {"results": []}
+        
+    async def _execute_summarize(self, job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Виконання summarization job"""
+        # TODO: Реальна реалізація через LLM
+        return {"summary": "Placeholder summary"}
+        
+    async def _execute_qdrant_upsert(self, job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Виконання Qdrant upsert"""
+        # TODO: Реальна реалізація
+        return {"status": "ok"}
+        
+    async def _execute_pg_write(self, job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Виконання PostgreSQL write"""
+        # TODO: Реальна реалізація
+        return {"status": "ok"}
+        
+    async def _execute_neo4j_write(self, job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Виконання Neo4j write"""
+        # TODO: Реальна реалізація
+        return {"status": "ok"}