@mamdouh-aboammar/agentic-workflow 1.2.0

package/core/engine_py/executor.py

@@ -0,0 +1,186 @@
+"""
+executor.py — Main Engine Orchestrator & Single-Writer SOT Coordinator.
+
+Implements Absolute Criterion 2:
+- Single-File SOT (state.yaml) updated exclusively by this Orchestrator
+- Atomic write with filesystem lock to eliminate race conditions
+- Decider evaluation loop driving tasks into the queue
+- Event publishing for all lifecycle transitions
+"""
+
+import os
+import time
+import uuid
+import asyncio
+from typing import Optional, Dict, Any
+
+try:
+    import yaml
+except ImportError:
+    yaml = None
+
+import json
+
+from core.engine_py.models import (
+    WorkflowDefinition, WorkflowInstance, WorkflowStatus, TaskStatus, EngineEvent
+)
+from core.engine_py.decider import AgenticDecider
+from core.engine_py.queue import TaskQueue
+from core.engine_py.event_bus import AsyncEventBus
+from core.engine_py.energy import EnergyBudget
+
+
+class AgenticExecutor:
+    """Orchestrates workflow lifecycle, state transitions, and atomic SOT persistence."""
+
+    def __init__(
+        self,
+        workflow_def: WorkflowDefinition,
+        queue: TaskQueue,
+        event_bus: AsyncEventBus,
+        project_dir: str = ".",
+        sot_filename: str = "state.yaml",
+        energy_budget: Optional[EnergyBudget] = None
+    ):
+        self.workflow_def = workflow_def
+        self.queue = queue
+        self.event_bus = event_bus
+        self.project_dir = os.path.abspath(project_dir)
+        self.sot_path = os.path.join(self.project_dir, sot_filename)
+        self.decider = AgenticDecider()
+        self.energy = energy_budget or EnergyBudget()
+        
+        self.trace_id = f"auto_{int(time.time())}_{uuid.uuid4().hex[:6]}"
+        self.instance = WorkflowInstance(
+            workflow_id=f"wf_{uuid.uuid4().hex[:8]}",
+            workflow_def=workflow_def,
+            trace_id=self.trace_id,
+            variables=dict(workflow_def.input_parameters)
+        )
+        self._write_sot()
+
+    def _write_sot(self) -> None:
+        """Atomically persists Single Source of Truth state to state.yaml."""
+        current_stage = self.instance.get_current_stage()
+        sot_data = {
+            "workflow": {
+                "title": self.workflow_def.name,
+                "version": self.workflow_def.version,
+                "workflow_id": self.instance.workflow_id,
+                "trace_id": self.instance.trace_id,
+                "status": self.instance.status.value,
+                "current_stage": current_stage.id if current_stage else "COMPLETED",
+                "current_stage_name": current_stage.name if current_stage else "All Stages Finished",
+                "total_stages": len(self.workflow_def.stages),
+                "autopilot": {"enabled": self.instance.autopilot_enabled, "status": self.instance.status.value},
+                "energy_budget": {
+                    "remaining_pct": round(self.energy.energy_percentage, 1),
+                    "refuel_count": self.energy.refuel_count,
+                    "consumed_tokens": self.energy.consumed_tokens
+                }
+            },
+            "tasks": {
+                tid: {
+                    "task_id": t.task_id,
+                    "stage_id": t.stage_id,
+                    "type": t.task_def.type,
+                    "role": t.task_def.role.value,
+                    "status": t.status.value,
+                    "attempt": t.attempt,
+                    "pacs_score": t.pacs_score,
+                    "gate_verdict": t.gate_verdict,
+                    "deliverable": t.task_def.deliverable_path,
+                    "error": t.error_message
+                }
+                for tid, t in self.instance.tasks.items()
+            },
+            "outputs": self.instance.outputs
+        }
+
+        temp_path = f"{self.sot_path}.tmp"
+        with open(temp_path, "w", encoding="utf-8") as f:
+            if yaml is not None:
+                yaml.dump(sot_data, f, sort_keys=False)
+            else:
+                json.dump(sot_data, f, indent=2)
+        os.replace(temp_path, self.sot_path)
+
+    async def step(self) -> bool:
+        """Executes one evaluation cycle of the state decider."""
+        # 1. Reclaim any expired leases in queue
+        self.queue.reclaim_expired()
+
+        # 2. Evaluate state
+        res = self.decider.evaluate(self.instance)
+
+        # 3. Schedule newly ready tasks into queue
+        for task in res.tasks_to_schedule:
+            self.queue.push(task)
+            await self.event_bus.publish(EngineEvent(
+                event_type="task.scheduled",
+                workflow_id=self.instance.workflow_id,
+                stage_id=task.stage_id,
+                task_id=task.task_id,
+                trace_id=self.instance.trace_id,
+                payload={"type": task.task_def.type, "role": task.task_def.role.value}
+            ))
+
+        for task in res.tasks_to_retry:
+            self.queue.push(task)
+            await self.event_bus.publish(EngineEvent(
+                event_type="task.retrying",
+                workflow_id=self.instance.workflow_id,
+                stage_id=task.stage_id,
+                task_id=task.task_id,
+                trace_id=self.instance.trace_id,
+                payload={"attempt": task.attempt}
+            ))
+
+        if res.stage_transitioned:
+            await self.event_bus.publish(EngineEvent(
+                event_type="stage.transitioned",
+                workflow_id=self.instance.workflow_id,
+                stage_id=res.new_stage_id,
+                trace_id=self.instance.trace_id
+            ))
+
+        # 4. Atomic SOT update
+        self._write_sot()
+
+        if res.is_terminal:
+            event_name = "workflow.completed" if res.workflow_status == WorkflowStatus.COMPLETED else "workflow.failed"
+            await self.event_bus.publish(EngineEvent(
+                event_type=event_name,
+                workflow_id=self.instance.workflow_id,
+                trace_id=self.instance.trace_id,
+                payload={"status": res.workflow_status.value, "error": res.error_message}
+            ))
+            return False
+
+        return True
+
+    async def run_until_complete(self, workers: list, poll_interval: float = 0.05, max_iterations: int = 100) -> bool:
+        """Runs the orchestrator loop alongside active workers until terminal state."""
+        await self.event_bus.publish(EngineEvent(
+            event_type="workflow.started",
+            workflow_id=self.instance.workflow_id,
+            trace_id=self.instance.trace_id,
+            payload={"name": self.workflow_def.name}
+        ))
+
+        iterations = 0
+        while iterations < max_iterations:
+            iterations += 1
+
+            # Let workers process available tasks
+            for w in workers:
+                await w.run_once()
+
+            # Advance orchestrator decider step
+            active = await self.step()
+            if not active:
+                break
+
+            await asyncio.sleep(poll_interval)
+
+        return self.instance.status == WorkflowStatus.COMPLETED

package/core/engine_py/models.py

@@ -0,0 +1,193 @@
+"""
+models.py — Data structures and state definitions for AgenticWorkflow Engine.
+
+Defines:
+- Workflow & Task definitions
+- Workflow & Task execution instances
+- State enumerations (TaskStatus, WorkflowStatus, BackoffType)
+- Standard EngineEvent envelope
+"""
+
+import time
+import uuid
+from enum import Enum
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Optional, Any, Union
+
+
+class TaskStatus(str, Enum):
+    SCHEDULED = "SCHEDULED"
+    POLLED = "POLLED"
+    IN_PROGRESS = "IN_PROGRESS"
+    GATE_EVALUATING = "GATE_EVALUATING"
+    DIAGNOSING = "DIAGNOSING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    TIMED_OUT = "TIMED_OUT"
+    SKIPPED = "SKIPPED"
+    CANCELLED = "CANCELLED"
+
+
+class WorkflowStatus(str, Enum):
+    RUNNING = "RUNNING"
+    PAUSED = "PAUSED"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    CANCELLED = "CANCELLED"
+
+
+class BackoffType(str, Enum):
+    FIXED = "FIXED"
+    LINEAR = "LINEAR"
+    EXPONENTIAL = "EXPONENTIAL"
+
+
+class AgentRole(str, Enum):
+    ORCHESTRATOR = "orchestrator"
+    RESEARCHER = "researcher"
+    ARCHITECT = "architect"
+    ENGINEER = "engineer"
+    REVIEWER = "reviewer"
+    FACT_CHECKER = "fact_checker"
+    CLEAN_CODE_GUARD = "clean_code_guard"
+    RECOVERY = "recovery"
+
+
+@dataclass
+class RetryPolicy:
+    max_retries: int = 3
+    delay_seconds: float = 2.0
+    backoff_rate: BackoffType = BackoffType.EXPONENTIAL
+
+    def calculate_delay(self, attempt: int) -> float:
+        if self.backoff_rate == BackoffType.FIXED:
+            return self.delay_seconds
+        elif self.backoff_rate == BackoffType.LINEAR:
+            return self.delay_seconds * attempt
+        else:  # EXPONENTIAL
+            return self.delay_seconds * (2 ** (attempt - 1))
+
+
+@dataclass
+class CircuitBreakerConfig:
+    failure_threshold: int = 2
+    cooldown_seconds: float = 30.0
+
+
+@dataclass
+class TaskDefinition:
+    id: str
+    type: str  # system.code, system.wait, agent.task, agent.human, agent.review, etc.
+    name: str = ""
+    description: str = ""
+    role: AgentRole = AgentRole.ENGINEER
+    deliverable_path: Optional[str] = None
+    criteria: List[str] = field(default_factory=list)
+    input_parameters: Dict[str, Any] = field(default_factory=dict)
+    retry_policy: RetryPolicy = field(default_factory=RetryPolicy)
+    timeout_seconds: int = 300
+    circuit_breaker: CircuitBreakerConfig = field(default_factory=CircuitBreakerConfig)
+    compensation_task: Optional[str] = None
+    branches: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class StageDefinition:
+    id: str
+    name: str
+    stage_type: str = "custom"  # research, planning, implementation, verification
+    tasks: List[TaskDefinition] = field(default_factory=list)
+
+
+@dataclass
+class WorkflowDefinition:
+    name: str
+    version: str = "1.0.0"
+    description: str = ""
+    stages: List[StageDefinition] = field(default_factory=list)
+    input_parameters: Dict[str, Any] = field(default_factory=dict)
+    timeout_seconds: int = 3600
+    failure_workflow: Optional[str] = None
+
+
+@dataclass
+class TaskInstance:
+    task_id: str
+    workflow_id: str
+    stage_id: str
+    task_def: TaskDefinition
+    status: TaskStatus = TaskStatus.SCHEDULED
+    attempt: int = 1
+    input_data: Dict[str, Any] = field(default_factory=dict)
+    output_data: Dict[str, Any] = field(default_factory=dict)
+    worker_id: Optional[str] = None
+    scheduled_at: float = field(default_factory=time.time)
+    started_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    lease_expires_at: Optional[float] = None
+    pacs_score: Optional[int] = None
+    gate_verdict: Optional[str] = None
+    error_message: Optional[str] = None
+    trace_id: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d["status"] = self.status.value
+        d["task_def"]["role"] = self.task_def.role.value
+        d["task_def"]["retry_policy"]["backoff_rate"] = self.task_def.retry_policy.backoff_rate.value
+        return d
+
+
+@dataclass
+class WorkflowInstance:
+    workflow_id: str
+    workflow_def: WorkflowDefinition
+    trace_id: str
+    status: WorkflowStatus = WorkflowStatus.RUNNING
+    current_stage_index: int = 0
+    tasks: Dict[str, TaskInstance] = field(default_factory=dict)
+    variables: Dict[str, Any] = field(default_factory=dict)
+    outputs: Dict[str, Any] = field(default_factory=dict)
+    started_at: float = field(default_factory=time.time)
+    completed_at: Optional[float] = None
+    autopilot_enabled: bool = True
+    error_message: Optional[str] = None
+
+    def get_current_stage(self) -> Optional[StageDefinition]:
+        if 0 <= self.current_stage_index < len(self.workflow_def.stages):
+            return self.workflow_def.stages[self.current_stage_index]
+        return None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "workflow_id": self.workflow_id,
+            "name": self.workflow_def.name,
+            "version": self.workflow_def.version,
+            "trace_id": self.trace_id,
+            "status": self.status.value,
+            "current_stage_index": self.current_stage_index,
+            "current_stage_id": self.get_current_stage().id if self.get_current_stage() else None,
+            "autopilot_enabled": self.autopilot_enabled,
+            "tasks": {tid: t.to_dict() for tid, t in self.tasks.items()},
+            "variables": self.variables,
+            "outputs": self.outputs,
+            "started_at": self.started_at,
+            "completed_at": self.completed_at,
+            "error_message": self.error_message
+        }
+
+
+@dataclass
+class EngineEvent:
+    event_id: str = field(default_factory=lambda: f"evt_{uuid.uuid4().hex[:12]}")
+    event_type: str = "workflow.started"
+    timestamp: float = field(default_factory=lambda: time.time() * 1000)
+    trace_id: str = ""
+    workflow_id: str = ""
+    stage_id: Optional[str] = None
+    task_id: Optional[str] = None
+    worker_id: Optional[str] = None
+    payload: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)

package/core/engine_py/queue.py

@@ -0,0 +1,314 @@
+"""
+queue.py — Pluggable Task Queuing System (QueueDAO).
+
+Implements:
+- Abstract TaskQueue base interface
+- InMemoryTaskQueue for testing & sub-millisecond local execution
+- SQLiteTaskQueue for durable, ACID, zero-infra persistence with lease renewal
+"""
+
+import time
+import json
+import sqlite3
+import threading
+from contextlib import contextmanager
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Any
+from core.engine_py.models import TaskInstance, TaskStatus, TaskDefinition, AgentRole, RetryPolicy, BackoffType, CircuitBreakerConfig
+
+
+class TaskQueue(ABC):
+    """Abstract interface for task scheduling, leasing, and completion."""
+
+    @abstractmethod
+    def push(self, task: TaskInstance) -> None:
+        """Enqueues a task for worker execution."""
+        pass
+
+    @abstractmethod
+    def poll(self, task_types: List[str], worker_id: str, lease_seconds: float = 60.0) -> Optional[TaskInstance]:
+        """Polls for a matching task and acquires an execution lease."""
+        pass
+
+    @abstractmethod
+    def ack(self, task_id: str) -> None:
+        """Acknowledges successful task completion, removing it from queue."""
+        pass
+
+    @abstractmethod
+    def nack(self, task_id: str, requeue: bool = True) -> None:
+        """Negative acknowledgment; resets task to QUEUED or marks failed."""
+        pass
+
+    @abstractmethod
+    def heartbeat(self, task_id: str, worker_id: str, extend_seconds: float = 60.0) -> bool:
+        """Renews the active worker lease to prevent timeout reclamation."""
+        pass
+
+    @abstractmethod
+    def reclaim_expired(self) -> List[str]:
+        """Reclaims tasks whose leases have expired and returns their IDs."""
+        pass
+
+    @abstractmethod
+    def size(self) -> int:
+        """Returns count of active tasks in queue."""
+        pass
+
+
+class InMemoryTaskQueue(TaskQueue):
+    """Thread-safe in-memory task queue."""
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._tasks: Dict[str, TaskInstance] = {}
+        self._queue: List[str] = []  # task_ids waiting to be polled
+
+    def push(self, task: TaskInstance) -> None:
+        with self._lock:
+            self._tasks[task.task_id] = task
+            if task.task_id not in self._queue:
+                self._queue.append(task.task_id)
+
+    def poll(self, task_types: List[str], worker_id: str, lease_seconds: float = 60.0) -> Optional[TaskInstance]:
+        with self._lock:
+            for idx, task_id in enumerate(self._queue):
+                task = self._tasks.get(task_id)
+                if task and (not task_types or task.task_def.type in task_types):
+                    self._queue.pop(idx)
+                    task.status = TaskStatus.POLLED
+                    task.worker_id = worker_id
+                    task.lease_expires_at = time.time() + lease_seconds
+                    return task
+            return None
+
+    def ack(self, task_id: str) -> None:
+        with self._lock:
+            self._tasks.pop(task_id, None)
+            if task_id in self._queue:
+                self._queue.remove(task_id)
+
+    def nack(self, task_id: str, requeue: bool = True) -> None:
+        with self._lock:
+            task = self._tasks.get(task_id)
+            if task:
+                task.worker_id = None
+                task.lease_expires_at = None
+                if requeue and task_id not in self._queue:
+                    task.status = TaskStatus.SCHEDULED
+                    self._queue.append(task_id)
+                elif not requeue:
+                    task.status = TaskStatus.FAILED
+                    self._tasks.pop(task_id, None)
+
+    def heartbeat(self, task_id: str, worker_id: str, extend_seconds: float = 60.0) -> bool:
+        with self._lock:
+            task = self._tasks.get(task_id)
+            if task and task.worker_id == worker_id:
+                task.lease_expires_at = time.time() + extend_seconds
+                return True
+            return False
+
+    def reclaim_expired(self) -> List[str]:
+        now = time.time()
+        reclaimed = []
+        with self._lock:
+            for task_id, task in list(self._tasks.items()):
+                if task.worker_id and task.lease_expires_at and task.lease_expires_at < now:
+                    task.worker_id = None
+                    task.lease_expires_at = None
+                    task.status = TaskStatus.SCHEDULED
+                    if task_id not in self._queue:
+                        self._queue.append(task_id)
+                    reclaimed.append(task_id)
+        return reclaimed
+
+    def size(self) -> int:
+        with self._lock:
+            return len(self._queue)
+
+
+class SQLiteTaskQueue(TaskQueue):
+    """Durable, ACID SQLite-backed queue with row locking and lease renewal."""
+
+    def __init__(self, db_path: str = ".queue.db"):
+        self.db_path = db_path
+        self._lock = threading.Lock()
+        self._init_db()
+
+    @contextmanager
+    def _connection(self):
+        conn = sqlite3.connect(self.db_path, timeout=30.0)
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+        finally:
+            conn.close()
+
+    def _init_db(self) -> None:
+        with self._lock, self._connection() as conn:
+            conn.execute("PRAGMA journal_mode=WAL;")
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS tasks (
+                    task_id TEXT PRIMARY KEY,
+                    task_type TEXT NOT NULL,
+                    workflow_id TEXT NOT NULL,
+                    stage_id TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    worker_id TEXT,
+                    lease_expires_at REAL,
+                    task_json TEXT NOT NULL,
+                    created_at REAL NOT NULL
+                );
+            """)
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_tasks_poll ON tasks(status, task_type);")
+            conn.commit()
+
+    def push(self, task: TaskInstance) -> None:
+        with self._lock, self._connection() as conn:
+            conn.execute("""
+                INSERT OR REPLACE INTO tasks 
+                (task_id, task_type, workflow_id, stage_id, status, worker_id, lease_expires_at, task_json, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                task.task_id,
+                task.task_def.type,
+                task.workflow_id,
+                task.stage_id,
+                "QUEUED",
+                None,
+                None,
+                json.dumps(task.to_dict()),
+                time.time()
+            ))
+            conn.commit()
+
+    def poll(self, task_types: List[str], worker_id: str, lease_seconds: float = 60.0) -> Optional[TaskInstance]:
+        with self._lock, self._connection() as conn:
+            query = "SELECT task_id, task_json FROM tasks WHERE status = 'QUEUED'"
+            params: List[Any] = []
+            if task_types:
+                placeholders = ",".join("?" for _ in task_types)
+                query += f" AND task_type IN ({placeholders})"
+                params.extend(task_types)
+            query += " ORDER BY created_at ASC LIMIT 1"
+
+            cursor = conn.execute(query, params)
+            row = cursor.fetchone()
+            if not row:
+                return None
+
+            task_id = row["task_id"]
+            now = time.time()
+            expires_at = now + lease_seconds
+
+            conn.execute("""
+                UPDATE tasks 
+                SET status = 'ASSIGNED', worker_id = ?, lease_expires_at = ?
+                WHERE task_id = ?
+            """, (worker_id, expires_at, task_id))
+            conn.commit()
+
+            raw_dict = json.loads(row["task_json"])
+            task = self._deserialize_task(raw_dict)
+            task.status = TaskStatus.POLLED
+            task.worker_id = worker_id
+            task.lease_expires_at = expires_at
+            return task
+
+    def ack(self, task_id: str) -> None:
+        with self._lock, self._connection() as conn:
+            conn.execute("DELETE FROM tasks WHERE task_id = ?", (task_id,))
+            conn.commit()
+
+    def nack(self, task_id: str, requeue: bool = True) -> None:
+        with self._lock, self._connection() as conn:
+            if requeue:
+                conn.execute("""
+                    UPDATE tasks 
+                    SET status = 'QUEUED', worker_id = NULL, lease_expires_at = NULL
+                    WHERE task_id = ?
+                """, (task_id,))
+            else:
+                conn.execute("DELETE FROM tasks WHERE task_id = ?", (task_id,))
+            conn.commit()
+
+    def heartbeat(self, task_id: str, worker_id: str, extend_seconds: float = 60.0) -> bool:
+        with self._lock, self._connection() as conn:
+            cursor = conn.execute("""
+                UPDATE tasks 
+                SET lease_expires_at = ?
+                WHERE task_id = ? AND worker_id = ?
+            """, (time.time() + extend_seconds, task_id, worker_id))
+            conn.commit()
+            return cursor.rowcount > 0
+
+    def reclaim_expired(self) -> List[str]:
+        now = time.time()
+        with self._lock, self._connection() as conn:
+            cursor = conn.execute("""
+                SELECT task_id FROM tasks 
+                WHERE status = 'ASSIGNED' AND lease_expires_at < ?
+            """, (now,))
+            expired_ids = [row["task_id"] for row in cursor.fetchall()]
+            if expired_ids:
+                placeholders = ",".join("?" for _ in expired_ids)
+                conn.execute(f"""
+                    UPDATE tasks 
+                    SET status = 'QUEUED', worker_id = NULL, lease_expires_at = NULL
+                    WHERE task_id IN ({placeholders})
+                """, expired_ids)
+                conn.commit()
+            return expired_ids
+
+    def size(self) -> int:
+        with self._lock, self._connection() as conn:
+            cursor = conn.execute("SELECT COUNT(*) as count FROM tasks WHERE status = 'QUEUED'")
+            row = cursor.fetchone()
+            return row["count"] if row else 0
+
+    def _deserialize_task(self, d: Dict[str, Any]) -> TaskInstance:
+        td = d["task_def"]
+        rp = td.get("retry_policy", {})
+        cb = td.get("circuit_breaker", {})
+        task_def = TaskDefinition(
+            id=td["id"],
+            type=td["type"],
+            name=td.get("name", ""),
+            description=td.get("description", ""),
+            role=AgentRole(td.get("role", "engineer")),
+            deliverable_path=td.get("deliverable_path"),
+            criteria=td.get("criteria", []),
+            input_parameters=td.get("input_parameters", {}),
+            retry_policy=RetryPolicy(
+                max_retries=rp.get("max_retries", 3),
+                delay_seconds=rp.get("delay_seconds", 2.0),
+                backoff_rate=BackoffType(rp.get("backoff_rate", "EXPONENTIAL"))
+            ),
+            timeout_seconds=td.get("timeout_seconds", 300),
+            circuit_breaker=CircuitBreakerConfig(
+                failure_threshold=cb.get("failure_threshold", 2),
+                cooldown_seconds=cb.get("cooldown_seconds", 30.0)
+            ),
+            compensation_task=td.get("compensation_task"),
+            branches=td.get("branches", {})
+        )
+        return TaskInstance(
+            task_id=d["task_id"],
+            workflow_id=d["workflow_id"],
+            stage_id=d["stage_id"],
+            task_def=task_def,
+            status=TaskStatus(d.get("status", "SCHEDULED")),
+            attempt=d.get("attempt", 1),
+            input_data=d.get("input_data", {}),
+            output_data=d.get("output_data", {}),
+            worker_id=d.get("worker_id"),
+            scheduled_at=d.get("scheduled_at", time.time()),
+            started_at=d.get("started_at"),
+            completed_at=d.get("completed_at"),
+            lease_expires_at=d.get("lease_expires_at"),
+            pacs_score=d.get("pacs_score"),
+            gate_verdict=d.get("gate_verdict"),
+            error_message=d.get("error_message"),
+            trace_id=d.get("trace_id", "")
+        )