docs: consolidate documentation into organized structure

- Move 12 markdown files from root to docs/ subdirectories
- Organize documentation by category:
  • docs/troubleshooting/ (1 file)  - Technical troubleshooting guides
  • docs/deployment/      (4 files) - Deployment and security documentation
  • docs/guides/          (3 files) - Feature-specific guides
  • docs/planning/        (4 files) - Planning and improvement proposals

Root directory cleanup:
- Reduced from 16 to 4 markdown files in root
- Only essential project files remain:
  • CLAUDE.md (AI instructions)
  • README.md (Main project readme)
  • CLEANUP_PLAN.md (Current cleanup plan)
  • SRC_STRUCTURE_IMPROVEMENTS.md (Structure improvements)

This improves:
✅ Documentation discoverability
✅ Logical organization by purpose
✅ Clean root directory
✅ Better maintainability

src/Framework/Queue/Commands/DeadLetterQueueCommands.php

@@ -0,0 +1,180 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Console\Attributes\ConsoleCommand;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Queue\Services\DeadLetterManager;
+use App\Framework\Queue\ValueObjects\DeadLetterQueueName;
+
+/**
+ * Console commands for Dead Letter Queue management
+ */
+final readonly class DeadLetterQueueCommands
+{
+    public function __construct(
+        private DeadLetterManager $deadLetterManager
+    ) {}
+
+    #[ConsoleCommand(name: 'queue:failed', description: 'List failed jobs in dead letter queues')]
+    public function listFailedJobs(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $limit = (int) $input->getOption('limit', 50);
+        $queue = $input->getOption('queue');
+
+        $output->writeLine("📋 Failed Jobs");
+        $output->writeLine(str_repeat('-', 50));
+
+        $failedJobs = $this->deadLetterManager->getFailedJobs(
+            originalQueue: $queue ? \App\Framework\Queue\ValueObjects\QueueName::fromString($queue) : null,
+            limit: $limit
+        );
+
+        if (empty($failedJobs)) {
+            $output->writeLine("✅ No failed jobs found");
+            return 0;
+        }
+
+        foreach ($failedJobs as $job) {
+            $output->writeLine("🔴 Job ID: {$job->id}");
+            $output->writeLine("   Original Job: {$job->originalJobId}");
+            $output->writeLine("   Queue: {$job->originalQueue} → {$job->deadLetterQueue}");
+            $output->writeLine("   Failed: {$job->failedAt} ({$job->failedAttempts} attempts)");
+            $output->writeLine("   Reason: {$job->failureReason}");
+            if ($job->exceptionType) {
+                $output->writeLine("   Exception: {$job->exceptionType}");
+            }
+            $output->writeLine("   Retries: {$job->retryCount}");
+            $output->writeLine("");
+        }
+
+        $output->writeLine("Total: " . count($failedJobs) . " failed jobs");
+
+        return 0;
+    }
+
+    #[ConsoleCommand(name: 'queue:retry', description: 'Retry a failed job from dead letter queue')]
+    public function retryJob(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $jobId = $input->getArgument('job_id');
+        if (!$jobId) {
+            $output->writeLine("❌ Job ID is required");
+            $output->writeLine("Usage: queue:retry <job_id>");
+            return 1;
+        }
+
+        $success = $this->deadLetterManager->retryJob($jobId);
+
+        if ($success) {
+            $output->writeLine("✅ Job {$jobId} successfully retried");
+        } else {
+            $output->writeLine("❌ Failed to retry job {$jobId}");
+            return 1;
+        }
+
+        return 0;
+    }
+
+    #[ConsoleCommand(name: 'queue:retry-all', description: 'Retry all jobs in a dead letter queue')]
+    public function retryAllJobs(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $queueName = $input->getArgument('queue_name');
+        if (!$queueName) {
+            $output->writeLine("❌ Queue name is required");
+            $output->writeLine("Usage: queue:retry-all <queue_name>");
+            return 1;
+        }
+
+        $deadLetterQueueName = DeadLetterQueueName::fromString($queueName);
+        $retriedCount = $this->deadLetterManager->retryAllJobs($deadLetterQueueName);
+
+        $output->writeLine("✅ Successfully retried {$retriedCount} jobs from queue '{$queueName}'");
+
+        return 0;
+    }
+
+    #[ConsoleCommand(name: 'queue:clear-failed', description: 'Clear all jobs from a dead letter queue')]
+    public function clearDeadLetterQueue(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $queueName = $input->getArgument('queue_name');
+        if (!$queueName) {
+            $output->writeLine("❌ Queue name is required");
+            $output->writeLine("Usage: queue:clear-failed <queue_name>");
+            return 1;
+        }
+
+        $confirm = $input->getOption('force', false);
+        if (!$confirm) {
+            $output->writeLine("⚠️  This will permanently delete all failed jobs in queue '{$queueName}'");
+            $output->writeLine("Use --force to confirm");
+            return 1;
+        }
+
+        $deadLetterQueueName = DeadLetterQueueName::fromString($queueName);
+        $deletedCount = $this->deadLetterManager->clearDeadLetterQueue($deadLetterQueueName);
+
+        $output->writeLine("✅ Cleared {$deletedCount} jobs from dead letter queue '{$queueName}'");
+
+        return 0;
+    }
+
+    #[ConsoleCommand(name: 'queue:failed-stats', description: 'Show statistics for dead letter queues')]
+    public function showStats(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeLine("📊 Dead Letter Queue Statistics");
+        $output->writeLine(str_repeat('=', 50));
+
+        $stats = $this->deadLetterManager->getStatistics();
+
+        if (empty($stats)) {
+            $output->writeLine("✅ No dead letter queues found");
+            return 0;
+        }
+
+        foreach ($stats as $queueName => $queueStats) {
+            $output->writeLine("🔴 Queue: {$queueName}");
+            $output->writeLine("   Total Jobs: {$queueStats['total_jobs']}");
+            $output->writeLine("   Avg Failed Attempts: {$queueStats['avg_failed_attempts']}");
+            $output->writeLine("   Max Failed Attempts: {$queueStats['max_failed_attempts']}");
+            $output->writeLine("   Avg Retries: {$queueStats['avg_retry_count']}");
+            $output->writeLine("   Max Retries: {$queueStats['max_retry_count']}");
+            $output->writeLine("   Oldest Job: {$queueStats['oldest_job']}");
+            $output->writeLine("   Newest Job: {$queueStats['newest_job']}");
+            $output->writeLine("");
+        }
+
+        return 0;
+    }
+
+    #[ConsoleCommand(name: 'queue:delete-failed', description: 'Delete a specific failed job')]
+    public function deleteJob(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $jobId = $input->getArgument('job_id');
+        if (!$jobId) {
+            $output->writeLine("❌ Job ID is required");
+            $output->writeLine("Usage: queue:delete-failed <job_id>");
+            return 1;
+        }
+
+        $confirm = $input->getOption('force', false);
+        if (!$confirm) {
+            $output->writeLine("⚠️  This will permanently delete the failed job {$jobId}");
+            $output->writeLine("Use --force to confirm");
+            return 1;
+        }
+
+        $success = $this->deadLetterManager->deleteJob($jobId);
+
+        if ($success) {
+            $output->writeLine("✅ Job {$jobId} successfully deleted");
+        } else {
+            $output->writeLine("❌ Failed to delete job {$jobId} (job not found)");
+            return 1;
+        }
+
+        return 0;
+    }
+}

src/Framework/Queue/Commands/JobBatchCommands.php

@@ -0,0 +1,259 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Queue\Contracts\JobBatchManagerInterface;
+use App\Framework\Queue\ValueObjects\JobBatchStatus;
+use App\Framework\Attributes\ConsoleCommand as ConsoleCommandAttribute;
+
+/**
+ * Console commands for job batch management
+ */
+final readonly class JobBatchCommands
+{
+    public function __construct(
+        private JobBatchManagerInterface $batchManager
+    ) {}
+
+    #[ConsoleCommandAttribute(name: 'batch:list', description: 'List job batches')]
+    public function listBatches(string $status = 'all', int $limit = 20): void
+    {
+        if ($status === 'all') {
+            // Get batches for all statuses
+            $batches = [];
+            foreach (JobBatchStatus::cases() as $batchStatus) {
+                $statusBatches = $this->batchManager->getBatchesByStatus($batchStatus, $limit);
+                $batches = array_merge($batches, $statusBatches);
+            }
+
+            // Sort by created_at desc
+            usort($batches, fn($a, $b) => $b->createdAt?->getTimestamp() <=> $a->createdAt?->getTimestamp());
+            $batches = array_slice($batches, 0, $limit);
+        } else {
+            try {
+                $batchStatus = JobBatchStatus::from($status);
+                $batches = $this->batchManager->getBatchesByStatus($batchStatus, $limit);
+            } catch (\ValueError) {
+                echo "❌ Invalid status: {$status}. Valid statuses: " .
+                     implode(', ', array_map(fn($s) => $s->value, JobBatchStatus::cases())) . "\n";
+                return;
+            }
+        }
+
+        if (empty($batches)) {
+            echo "No batches found" . ($status !== 'all' ? " with status: {$status}" : '') . "\n";
+            return;
+        }
+
+        echo "📋 Job Batches" . ($status !== 'all' ? " ({$status})" : '') . ":\n\n";
+
+        foreach ($batches as $batch) {
+            $icon = $batch->status->getIcon();
+            $progress = $batch->getProgressPercentage();
+            $remaining = $batch->getRemainingJobs();
+
+            echo "{$icon} {$batch->batchId}\n";
+            echo "   Name: {$batch->name}\n";
+            echo "   Status: {$batch->status->getDisplayName()}\n";
+            echo "   Progress: {$progress}% ({$batch->processedJobs}/{$batch->totalJobs} completed";
+            if ($batch->failedJobs > 0) {
+                echo ", {$batch->failedJobs} failed";
+            }
+            if ($remaining > 0) {
+                echo ", {$remaining} remaining";
+            }
+            echo ")\n";
+            echo "   Created: {$batch->createdAt?->toRfc3339()}\n";
+            if ($batch->startedAt) {
+                echo "   Started: {$batch->startedAt->toRfc3339()}\n";
+            }
+            if ($batch->completedAt) {
+                echo "   Completed: {$batch->completedAt->toRfc3339()}\n";
+            }
+            echo "\n";
+        }
+    }
+
+    #[ConsoleCommandAttribute(name: 'batch:show', description: 'Show detailed batch information')]
+    public function showBatch(string $batchId): void
+    {
+        $batch = $this->batchManager->getBatch($batchId);
+
+        if (!$batch) {
+            echo "❌ Batch not found: {$batchId}\n";
+            return;
+        }
+
+        $icon = $batch->status->getIcon();
+        $progress = $batch->getProgressPercentage();
+
+        echo "{$icon} Batch Details\n";
+        echo "================\n\n";
+        echo "ID: {$batch->batchId}\n";
+        echo "Name: {$batch->name}\n";
+        echo "Status: {$batch->status->getDisplayName()}\n";
+        echo "Progress: {$progress}%\n\n";
+
+        echo "Job Statistics:\n";
+        echo "  Total Jobs: {$batch->totalJobs}\n";
+        echo "  Processed: {$batch->processedJobs}\n";
+        echo "  Failed: {$batch->failedJobs}\n";
+        echo "  Remaining: {$batch->getRemainingJobs()}\n\n";
+
+        echo "Timestamps:\n";
+        echo "  Created: {$batch->createdAt?->toRfc3339()}\n";
+        if ($batch->startedAt) {
+            echo "  Started: {$batch->startedAt->toRfc3339()}\n";
+        }
+        if ($batch->completedAt) {
+            echo "  Completed: {$batch->completedAt->toRfc3339()}\n";
+        }
+        if ($batch->failedAt) {
+            echo "  Failed: {$batch->failedAt->toRfc3339()}\n";
+        }
+        echo "\n";
+
+        if (!empty($batch->options)) {
+            echo "Options:\n";
+            foreach ($batch->options as $key => $value) {
+                echo "  {$key}: " . (is_array($value) ? json_encode($value) : $value) . "\n";
+            }
+            echo "\n";
+        }
+
+        echo "Job IDs:\n";
+        foreach ($batch->jobIds as $index => $jobId) {
+            echo "  " . ($index + 1) . ". {$jobId}\n";
+        }
+    }
+
+    #[ConsoleCommandAttribute(name: 'batch:cancel', description: 'Cancel a job batch')]
+    public function cancelBatch(string $batchId): void
+    {
+        $batch = $this->batchManager->getBatch($batchId);
+
+        if (!$batch) {
+            echo "❌ Batch not found: {$batchId}\n";
+            return;
+        }
+
+        if ($batch->isFinished()) {
+            echo "❌ Cannot cancel batch: already finished with status {$batch->status->getDisplayName()}\n";
+            return;
+        }
+
+        $success = $this->batchManager->cancelBatch($batchId);
+
+        if ($success) {
+            echo "✅ Batch cancelled successfully: {$batchId}\n";
+        } else {
+            echo "❌ Failed to cancel batch: {$batchId}\n";
+        }
+    }
+
+    #[ConsoleCommandAttribute(name: 'batch:stats', description: 'Show batch statistics')]
+    public function showStats(): void
+    {
+        $stats = $this->batchManager->getBatchStats();
+
+        if (empty($stats)) {
+            echo "No batch statistics available\n";
+            return;
+        }
+
+        echo "📊 Batch Statistics\n";
+        echo "==================\n\n";
+
+        $totalBatches = 0;
+        $totalJobs = 0;
+        $totalFailed = 0;
+
+        foreach ($stats as $status => $data) {
+            try {
+                $statusEnum = JobBatchStatus::from($status);
+                $icon = $statusEnum->getIcon();
+                $displayName = $statusEnum->getDisplayName();
+            } catch (\ValueError) {
+                $icon = '❓';
+                $displayName = ucfirst($status);
+            }
+
+            echo "{$icon} {$displayName}:\n";
+            echo "  Batches: {$data['count']}\n";
+            echo "  Total Jobs: {$data['total_jobs']}\n";
+            echo "  Failed Jobs: {$data['total_failed']}\n";
+            echo "  Avg Processed: " . number_format($data['avg_processed'], 2) . "\n\n";
+
+            $totalBatches += $data['count'];
+            $totalJobs += $data['total_jobs'];
+            $totalFailed += $data['total_failed'];
+        }
+
+        echo "Overall:\n";
+        echo "  Total Batches: {$totalBatches}\n";
+        echo "  Total Jobs: {$totalJobs}\n";
+        echo "  Total Failed: {$totalFailed}\n";
+        if ($totalJobs > 0) {
+            $failureRate = ($totalFailed / $totalJobs) * 100;
+            echo "  Failure Rate: " . number_format($failureRate, 2) . "%\n";
+        }
+    }
+
+    #[ConsoleCommandAttribute(name: 'batch:cleanup', description: 'Cleanup old finished batches')]
+    public function cleanupBatches(int $olderThanDays = 30): void
+    {
+        if ($olderThanDays < 1) {
+            echo "❌ Days must be at least 1\n";
+            return;
+        }
+
+        echo "🧹 Cleaning up batches older than {$olderThanDays} days...\n";
+
+        $deleted = $this->batchManager->cleanupOldBatches($olderThanDays);
+
+        if ($deleted > 0) {
+            echo "✅ Cleaned up {$deleted} old batches\n";
+        } else {
+            echo "ℹ️ No old batches to clean up\n";
+        }
+    }
+
+    #[ConsoleCommandAttribute(name: 'batch:progress', description: 'Show batch progress')]
+    public function showProgress(string $batchId): void
+    {
+        $progress = $this->batchManager->getBatchProgress($batchId);
+
+        if (empty($progress)) {
+            echo "❌ Batch not found: {$batchId}\n";
+            return;
+        }
+
+        $statusEnum = JobBatchStatus::from($progress['status']);
+        $icon = $statusEnum->getIcon();
+
+        echo "{$icon} {$progress['name']} ({$progress['batch_id']})\n";
+        echo "Status: {$statusEnum->getDisplayName()}\n";
+        echo "Progress: {$progress['progress_percentage']}%\n";
+
+        // Visual progress bar
+        $barWidth = 40;
+        $completedWidth = (int) (($progress['progress_percentage'] / 100) * $barWidth);
+        $bar = str_repeat('█', $completedWidth) . str_repeat('░', $barWidth - $completedWidth);
+        echo "[{$bar}] {$progress['processed_jobs']}/{$progress['total_jobs']}\n";
+
+        if ($progress['failed_jobs'] > 0) {
+            echo "❌ Failed: {$progress['failed_jobs']}\n";
+        }
+
+        if ($progress['remaining_jobs'] > 0) {
+            echo "⏳ Remaining: {$progress['remaining_jobs']}\n";
+        }
+
+        if ($progress['is_finished']) {
+            echo "✅ Batch completed\n";
+        }
+    }
+}

src/Framework/Queue/Commands/JobChainCommands.php

@@ -0,0 +1,246 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Console\Attributes\ConsoleCommand;
+use App\Framework\Queue\Contracts\JobChainManagerInterface;
+use App\Framework\Queue\ValueObjects\JobChain;
+use App\Framework\Queue\ValueObjects\ChainExecutionMode;
+use App\Framework\Queue\Services\JobChainExecutionCoordinator;
+use App\Framework\Queue\Services\DependencyResolutionEngine;
+
+final readonly class JobChainCommands
+{
+    public function __construct(
+        private JobChainManagerInterface $chainManager,
+        private JobChainExecutionCoordinator $coordinator,
+        private DependencyResolutionEngine $resolutionEngine
+    ) {}
+
+    #[ConsoleCommand(name: 'queue:chain:create', description: 'Create a new job chain')]
+    public function createChain(
+        string $chainId,
+        string $name,
+        string $jobIds,
+        string $executionMode = 'sequential',
+        bool $stopOnFailure = true
+    ): void {
+        $jobIdArray = array_map('trim', explode(',', $jobIds));
+        $mode = ChainExecutionMode::from($executionMode);
+
+        $jobChain = JobChain::create(
+            chainId: $chainId,
+            name: $name,
+            jobIds: $jobIdArray,
+            executionMode: $mode,
+            stopOnFailure: $stopOnFailure
+        );
+
+        $this->chainManager->createChain($jobChain);
+
+        echo "✅ Job chain created: {$name} ({$chainId})\n";
+        echo "   Jobs: " . implode(' → ', $jobIdArray) . "\n";
+        echo "   Mode: {$executionMode}\n";
+        echo "   Stop on failure: " . ($stopOnFailure ? 'Yes' : 'No') . "\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:chain:start', description: 'Start execution of a job chain')]
+    public function startChain(string $chainId): void
+    {
+        try {
+            $this->coordinator->startChainExecution($chainId);
+            echo "🚀 Chain execution started: {$chainId}\n";
+        } catch (\Exception $e) {
+            echo "❌ Failed to start chain: {$e->getMessage()}\n";
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:chain:status', description: 'Get status of a job chain')]
+    public function getChainStatus(string $chainId): void
+    {
+        try {
+            $status = $this->coordinator->getChainExecutionStatus($chainId);
+
+            echo "📋 Chain Status: {$status['name']} ({$chainId})\n\n";
+
+            $statusIcon = match($status['status']) {
+                'pending' => '⏳',
+                'running' => '🔄',
+                'completed' => '✅',
+                'failed' => '❌',
+                default => '❓'
+            };
+
+            echo "   Status: {$statusIcon} {$status['status']}\n";
+            echo "   Execution Mode: {$status['execution_mode']}\n";
+            echo "   Stop on Failure: " . ($status['progress']['stop_on_failure'] ? 'Yes' : 'No') . "\n";
+
+            if ($status['started_at']) {
+                echo "   Started: {$status['started_at']}\n";
+            }
+
+            if ($status['completed_at']) {
+                echo "   Completed: {$status['completed_at']}\n";
+            }
+
+            echo "\n📊 Progress:\n";
+            echo "   {$status['progress']['completed_jobs']}/{$status['progress']['total_jobs']} jobs completed ({$status['progress']['percentage']}%)\n\n";
+
+            echo "🔗 Job Status:\n";
+            foreach ($status['job_statuses'] as $jobStatus) {
+                $canExecute = $jobStatus['can_execute'] ? '✅' : '⏳';
+                $depStatus = "{$jobStatus['dependencies_satisfied']}/{$jobStatus['dependencies_total']} deps";
+
+                echo "   {$canExecute} Job {$jobStatus['position'] + 1}: {$jobStatus['job_id']} ({$depStatus})\n";
+            }
+
+        } catch (\Exception $e) {
+            echo "❌ Failed to get chain status: {$e->getMessage()}\n";
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:chain:list', description: 'List job chains by status')]
+    public function listChains(string $status = 'all'): void
+    {
+        $chains = match($status) {
+            'active' => $this->chainManager->getActiveChains(),
+            'pending' => $this->chainManager->getPendingChains(),
+            default => array_merge(
+                $this->chainManager->getPendingChains(),
+                $this->chainManager->getActiveChains()
+            )
+        };
+
+        echo "📋 Job Chains ({$status}):\n\n";
+
+        if (empty($chains)) {
+            echo "   No chains found\n";
+            return;
+        }
+
+        foreach ($chains as $chain) {
+            $statusIcon = match($chain->status) {
+                'pending' => '⏳',
+                'running' => '🔄',
+                'completed' => '✅',
+                'failed' => '❌',
+                default => '❓'
+            };
+
+            $jobCount = count($chain->getJobIdsArray());
+            echo "   {$statusIcon} {$chain->name} ({$chain->chainId})\n";
+            echo "      Status: {$chain->status} | Jobs: {$jobCount} | Mode: {$chain->executionMode}\n";
+
+            if ($chain->startedAt) {
+                echo "      Started: {$chain->startedAt}\n";
+            }
+
+            echo "\n";
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:chain:analyze', description: 'Analyze job chains for a specific job')]
+    public function analyzeChains(string $jobId): void
+    {
+        $analysis = $this->resolutionEngine->analyzeChains($jobId);
+
+        echo "🔍 Chain Analysis for job: {$jobId}\n\n";
+
+        if (empty($analysis['chains'])) {
+            echo "   Job is not part of any chains\n";
+            return;
+        }
+
+        echo "📊 Total chains: {$analysis['total_chains']}\n\n";
+
+        foreach ($analysis['chains'] as $chain) {
+            $statusIcon = match($chain['status']) {
+                'pending' => '⏳',
+                'running' => '🔄',
+                'completed' => '✅',
+                'failed' => '❌',
+                default => '❓'
+            };
+
+            echo "🔗 {$statusIcon} {$chain['name']} ({$chain['chain_id']})\n";
+            echo "   Status: {$chain['status']}\n";
+            echo "   Mode: {$chain['execution_mode']}\n";
+            echo "   Position: {$chain['job_position'] + 1}/{$chain['total_jobs']}\n";
+
+            if ($chain['next_job_after_current']) {
+                echo "   Next job: {$chain['next_job_after_current']}\n";
+            }
+
+            echo "   Progress: {$chain['progress']['completed_jobs']}/{$chain['progress']['total_jobs']} ({$chain['progress']['percentage']}%)\n\n";
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:chain:delete', description: 'Delete a job chain')]
+    public function deleteChain(string $chainId): void
+    {
+        $chain = $this->chainManager->getChain($chainId);
+
+        if (!$chain) {
+            echo "❌ Chain not found: {$chainId}\n";
+            return;
+        }
+
+        if ($chain->isRunning()) {
+            echo "❌ Cannot delete running chain. Chain must be completed or failed.\n";
+            return;
+        }
+
+        $this->chainManager->deleteChain($chainId);
+        echo "✅ Chain deleted: {$chainId}\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:chain:cleanup', description: 'Clean up old completed chains')]
+    public function cleanupOldChains(int $olderThanDays = 30): void
+    {
+        $deletedCount = $this->chainManager->cleanupOldChains($olderThanDays);
+
+        echo "🧹 Cleaned up old chains\n";
+        echo "   Deleted: {$deletedCount} completed/failed chains older than {$olderThanDays} days\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:chain:progress', description: 'Show detailed progress of a chain')]
+    public function showProgress(string $chainId): void
+    {
+        try {
+            $progress = $this->chainManager->getChainProgress($chainId);
+
+            echo "📊 Chain Progress: {$progress['name']} ({$chainId})\n\n";
+
+            $statusIcon = match($progress['status']) {
+                'pending' => '⏳',
+                'running' => '🔄',
+                'completed' => '✅',
+                'failed' => '❌',
+                default => '❓'
+            };
+
+            echo "   Status: {$statusIcon} {$progress['status']}\n";
+            echo "   Mode: {$progress['execution_mode']}\n";
+            echo "   Progress: {$progress['completed_jobs']}/{$progress['total_jobs']} jobs ({$progress['percentage']}%)\n";
+
+            if ($progress['started_at']) {
+                echo "   Started: {$progress['started_at']}\n";
+            }
+
+            if ($progress['completed_at']) {
+                echo "   Completed: {$progress['completed_at']}\n";
+            }
+
+            // Progress bar
+            $barLength = 30;
+            $filledLength = (int) (($progress['percentage'] / 100) * $barLength);
+            $bar = str_repeat('█', $filledLength) . str_repeat('░', $barLength - $filledLength);
+            echo "\n   [{$bar}] {$progress['percentage']}%\n";
+
+        } catch (\Exception $e) {
+            echo "❌ Failed to get chain progress: {$e->getMessage()}\n";
+        }
+    }
+}

src/Framework/Queue/Commands/JobCleanupCommands.php

@@ -0,0 +1,328 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ExitCode;
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Queue\Services\JobCleanupService;
+use App\Framework\Queue\Services\JobMemoryManager;
+use App\Framework\Performance\MemoryMonitor;
+
+final readonly class JobCleanupCommands
+{
+    public function __construct(
+        private JobCleanupService $cleanupService,
+        private JobMemoryManager $memoryManager,
+        private MemoryMonitor $memoryMonitor
+    ) {}
+
+    #[ConsoleCommand(name: 'queue:cleanup:all', description: 'Run comprehensive queue cleanup with default retention periods')]
+    public function runComprehensiveCleanup(): ExitCode
+    {
+        echo "🧹 Starting Comprehensive Queue Cleanup\n\n";
+
+        try {
+            // Show current memory status
+            $memorySummary = $this->memoryMonitor->getSummary();
+            echo "💾 Memory Status:\n";
+            echo "   Current: {$memorySummary->getCurrentHumanReadable()}\n";
+            echo "   Available: {$memorySummary->getAvailableMemory()->toHumanReadable()}\n";
+            echo "   Usage: {$memorySummary->getUsagePercentageFormatted()}\n\n";
+
+            // Show cleanup statistics
+            echo "📊 Cleanup Statistics:\n";
+            $stats = $this->cleanupService->getCleanupStatistics();
+
+            echo "   Eligible for cleanup:\n";
+            echo "   • Completed jobs: " . number_format($stats['eligible_completed_jobs']) . " (>{$stats['retention_days']['completed_jobs']} days)\n";
+            echo "   • Failed jobs: " . number_format($stats['eligible_failed_jobs']) . " (>{$stats['retention_days']['failed_jobs']} days)\n";
+            echo "   • Job metrics: " . number_format($stats['eligible_metrics']) . " (>{$stats['retention_days']['metrics']} days)\n";
+            echo "   • Dead letter jobs: " . number_format($stats['eligible_dead_letter_jobs']) . " (>{$stats['retention_days']['dead_letter_jobs']} days)\n";
+            echo "   • Total eligible: " . number_format($stats['total_eligible']) . "\n";
+            echo "   • Estimated time: ~{$stats['estimated_cleanup_minutes']} minutes\n\n";
+
+            if ($stats['total_eligible'] === 0) {
+                echo "✅ No data eligible for cleanup\n";
+                return ExitCode::SUCCESS;
+            }
+
+            echo "🔄 Starting cleanup process...\n\n";
+
+            // Run comprehensive cleanup
+            $results = $this->cleanupService->runComprehensiveCleanup();
+
+            // Display results
+            echo "✅ Cleanup Results:\n";
+            echo "   • Completed jobs deleted: " . number_format($results['completed_jobs']) . "\n";
+            echo "   • Failed jobs deleted: " . number_format($results['failed_jobs']) . "\n";
+            echo "   • Job metrics deleted: " . number_format($results['job_metrics']) . "\n";
+            echo "   • Dead letter jobs deleted: " . number_format($results['dead_letter_jobs']) . "\n";
+            echo "   • Total deleted: " . number_format($results['total_deleted']) . "\n\n";
+
+            echo "⏱️ Performance:\n";
+            echo "   • Duration: {$results['duration_seconds']} seconds\n";
+            echo "   • Memory used: {$results['memory_used']}\n";
+            echo "   • Peak memory: {$results['memory_peak']}\n\n";
+
+            if (!empty($results['errors'])) {
+                echo "⚠️ Errors occurred:\n";
+                foreach ($results['errors'] as $error) {
+                    echo "   • {$error}\n";
+                }
+                return ExitCode::GENERAL_ERROR;
+            }
+
+            echo "✅ Cleanup completed successfully!\n";
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:cleanup:completed', description: 'Clean up completed jobs older than specified days')]
+    public function cleanupCompletedJobs(int $days = 30): ExitCode
+    {
+        echo "🧹 Cleaning Completed Jobs\n\n";
+
+        try {
+            if ($days < 1) {
+                echo "❌ Days must be at least 1\n";
+                return ExitCode::INVALID_ARGUMENT;
+            }
+
+            echo "📊 Configuration:\n";
+            echo "   • Delete completed jobs older than: {$days} days\n\n";
+
+            $duration = Duration::fromDays($days);
+            $deleted = $this->cleanupService->cleanupCompletedJobs($duration);
+
+            echo "✅ Cleanup Results:\n";
+            echo "   • Completed jobs deleted: " . number_format($deleted) . "\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:cleanup:failed', description: 'Clean up failed jobs older than specified days')]
+    public function cleanupFailedJobs(int $days = 90): ExitCode
+    {
+        echo "🧹 Cleaning Failed Jobs\n\n";
+
+        try {
+            if ($days < 1) {
+                echo "❌ Days must be at least 1\n";
+                return ExitCode::INVALID_ARGUMENT;
+            }
+
+            echo "📊 Configuration:\n";
+            echo "   • Delete failed jobs older than: {$days} days\n\n";
+
+            $duration = Duration::fromDays($days);
+            $deleted = $this->cleanupService->cleanupFailedJobs($duration);
+
+            echo "✅ Cleanup Results:\n";
+            echo "   • Failed jobs deleted: " . number_format($deleted) . "\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:cleanup:metrics', description: 'Clean up job metrics older than specified days')]
+    public function cleanupMetrics(int $days = 180): ExitCode
+    {
+        echo "🧹 Cleaning Job Metrics\n\n";
+
+        try {
+            if ($days < 1) {
+                echo "❌ Days must be at least 1\n";
+                return ExitCode::INVALID_ARGUMENT;
+            }
+
+            echo "📊 Configuration:\n";
+            echo "   • Delete metrics older than: {$days} days\n\n";
+
+            $duration = Duration::fromDays($days);
+            $deleted = $this->cleanupService->cleanupJobMetrics($duration);
+
+            echo "✅ Cleanup Results:\n";
+            echo "   • Job metrics deleted: " . number_format($deleted) . "\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:cleanup:deadletter', description: 'Clean up dead letter jobs older than specified days')]
+    public function cleanupDeadLetterJobs(int $days = 365): ExitCode
+    {
+        echo "🧹 Cleaning Dead Letter Jobs\n\n";
+
+        try {
+            if ($days < 1) {
+                echo "❌ Days must be at least 1\n";
+                return ExitCode::INVALID_ARGUMENT;
+            }
+
+            echo "📊 Configuration:\n";
+            echo "   • Delete dead letter jobs older than: {$days} days\n\n";
+
+            $duration = Duration::fromDays($days);
+            $deleted = $this->cleanupService->cleanupDeadLetterJobs($duration);
+
+            echo "✅ Cleanup Results:\n";
+            echo "   • Dead letter jobs deleted: " . number_format($deleted) . "\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:cleanup:stats', description: 'Show cleanup statistics without performing cleanup')]
+    public function showCleanupStatistics(): ExitCode
+    {
+        echo "📊 Queue Cleanup Statistics\n\n";
+
+        try {
+            $stats = $this->cleanupService->getCleanupStatistics();
+
+            echo "📋 Retention Periods:\n";
+            echo "   • Completed jobs: {$stats['retention_days']['completed_jobs']} days\n";
+            echo "   • Failed jobs: {$stats['retention_days']['failed_jobs']} days\n";
+            echo "   • Job metrics: {$stats['retention_days']['metrics']} days\n";
+            echo "   • Dead letter jobs: {$stats['retention_days']['dead_letter_jobs']} days\n\n";
+
+            echo "🗑️ Eligible for Cleanup:\n";
+            echo "   • Completed jobs: " . number_format($stats['eligible_completed_jobs']) . "\n";
+            echo "   • Failed jobs: " . number_format($stats['eligible_failed_jobs']) . "\n";
+            echo "   • Job metrics: " . number_format($stats['eligible_metrics']) . "\n";
+            echo "   • Dead letter jobs: " . number_format($stats['eligible_dead_letter_jobs']) . "\n";
+            echo "   • Total eligible: " . number_format($stats['total_eligible']) . "\n\n";
+
+            echo "⏱️ Estimated Cleanup Time: ~{$stats['estimated_cleanup_minutes']} minutes\n\n";
+
+            // Memory recommendations
+            $recommendations = $this->memoryManager->getMemoryRecommendations();
+            echo "💾 Memory Recommendations:\n";
+            echo "   • Current usage: {$recommendations['current_usage']}\n";
+            echo "   • Available memory: {$recommendations['available']}\n";
+            echo "   • Priority: {$recommendations['priority']}\n";
+
+            foreach ($recommendations['recommendations'] as $rec) {
+                echo "\n   📌 {$rec['type']}:\n";
+                echo "      {$rec['message']}\n";
+                if (!empty($rec['actions'])) {
+                    echo "      Actions:\n";
+                    foreach ($rec['actions'] as $action) {
+                        echo "      • {$action}\n";
+                    }
+                }
+            }
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:memory:status', description: 'Show current memory status and recommendations')]
+    public function showMemoryStatus(): ExitCode
+    {
+        echo "💾 Queue Memory Status\n\n";
+
+        try {
+            // Get memory snapshot
+            $snapshot = $this->memoryManager->getJobMemorySnapshot('memory_status_check');
+
+            echo "📊 Current Memory Usage:\n";
+            echo "   • Current: {$snapshot['current']} ({$snapshot['usage_percentage']}%)\n";
+            echo "   • Peak: {$snapshot['peak']}\n";
+            echo "   • Limit: {$snapshot['limit']}\n";
+            echo "   • Available: {$snapshot['available']}\n";
+            echo "   • Status: {$snapshot['status']}\n\n";
+
+            // Status indicators
+            if ($snapshot['is_critical']) {
+                echo "🔴 CRITICAL: Memory usage is critically high!\n\n";
+            } elseif ($snapshot['is_warning']) {
+                echo "🟡 WARNING: Memory usage is elevated.\n\n";
+            } else {
+                echo "🟢 NORMAL: Memory usage is within acceptable limits.\n\n";
+            }
+
+            // Get recommendations
+            $recommendations = $this->memoryManager->getMemoryRecommendations();
+
+            echo "📌 Recommendations:\n";
+            foreach ($recommendations['recommendations'] as $rec) {
+                echo "\n   {$rec['type']}:\n";
+                echo "   {$rec['message']}\n";
+                if (!empty($rec['actions'])) {
+                    echo "   Suggested actions:\n";
+                    foreach ($rec['actions'] as $action) {
+                        echo "   • {$action}\n";
+                    }
+                }
+            }
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:memory:optimize', description: 'Optimize memory for job processing')]
+    public function optimizeMemory(): ExitCode
+    {
+        echo "🔧 Optimizing Queue Memory\n\n";
+
+        try {
+            echo "📊 Before Optimization:\n";
+            $beforeSnapshot = $this->memoryManager->getJobMemorySnapshot('before_optimization');
+            echo "   • Memory: {$beforeSnapshot['current']} ({$beforeSnapshot['usage_percentage']}%)\n\n";
+
+            echo "🔄 Running optimization...\n";
+            $optimization = $this->memoryManager->optimizeForJob('manual_optimization');
+
+            echo "\n📊 After Optimization:\n";
+            echo "   • Memory: {$optimization['after']}\n";
+            echo "   • Freed: {$optimization['freed']}\n";
+            echo "   • Usage before: {$optimization['usage_before']}\n";
+            echo "   • Usage after: {$optimization['usage_after']}\n\n";
+
+            if ($optimization['freed_bytes'] > 0) {
+                echo "✅ Successfully freed {$optimization['freed']} of memory\n";
+            } else {
+                echo "ℹ️ No significant memory was freed (system may have already been optimized)\n";
+            }
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+}

src/Framework/Queue/Commands/JobDependencyCommands.php

@@ -0,0 +1,203 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Console\Attributes\ConsoleCommand;
+use App\Framework\Queue\Contracts\JobDependencyManagerInterface;
+use App\Framework\Queue\ValueObjects\JobDependency;
+use App\Framework\Queue\ValueObjects\DependencyType;
+use App\Framework\Queue\Services\DependencyResolutionEngine;
+
+final readonly class JobDependencyCommands
+{
+    public function __construct(
+        private JobDependencyManagerInterface $dependencyManager,
+        private DependencyResolutionEngine $resolutionEngine
+    ) {}
+
+    #[ConsoleCommand(name: 'queue:dependency:add', description: 'Add a dependency between two jobs')]
+    public function addDependency(
+        string $dependentJobId,
+        string $dependsOnJobId,
+        string $type = 'completion',
+        ?string $condition = null
+    ): void {
+        $dependencyType = DependencyType::from($type);
+
+        $dependency = new JobDependency(
+            dependentJobId: $dependentJobId,
+            dependsOnJobId: $dependsOnJobId,
+            type: $dependencyType,
+            condition: $condition
+        );
+
+        $this->dependencyManager->addDependency($dependency);
+
+        echo "✅ Dependency added: {$dependentJobId} depends on {$dependsOnJobId} ({$type})\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:dependency:remove', description: 'Remove a dependency between two jobs')]
+    public function removeDependency(string $dependentJobId, string $dependsOnJobId): void
+    {
+        $this->dependencyManager->removeDependency($dependentJobId, $dependsOnJobId);
+
+        echo "✅ Dependency removed: {$dependentJobId} no longer depends on {$dependsOnJobId}\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:dependency:list', description: 'List dependencies for a job')]
+    public function listDependencies(string $jobId): void
+    {
+        $dependencies = $this->dependencyManager->getDependencies($jobId);
+        $dependents = $this->dependencyManager->getDependents($jobId);
+
+        echo "📋 Dependencies for job: {$jobId}\n\n";
+
+        echo "🔗 This job depends on:\n";
+        if (empty($dependencies)) {
+            echo "   No dependencies\n";
+        } else {
+            foreach ($dependencies as $dep) {
+                $status = $dep->isSatisfied ? '✅' : '⏳';
+                echo "   {$status} {$dep->dependsOnJobId} ({$dep->dependencyType})\n";
+            }
+        }
+
+        echo "\n🔗 Jobs that depend on this one:\n";
+        if (empty($dependents)) {
+            echo "   No dependents\n";
+        } else {
+            foreach ($dependents as $dep) {
+                $status = $dep->isSatisfied ? '✅' : '⏳';
+                echo "   {$status} {$dep->dependentJobId} ({$dep->dependencyType})\n";
+            }
+        }
+
+        $canExecute = $this->dependencyManager->canJobBeExecuted($jobId);
+        $statusIcon = $canExecute ? '✅' : '⏳';
+        echo "\n{$statusIcon} Can execute: " . ($canExecute ? 'Yes' : 'No') . "\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:dependency:analyze', description: 'Analyze dependencies for a job')]
+    public function analyzeDependencies(string $jobId): void
+    {
+        $analysis = $this->resolutionEngine->analyzeDependencies($jobId);
+
+        echo "🔍 Dependency Analysis for job: {$jobId}\n\n";
+
+        echo "📊 Statistics:\n";
+        echo "   Total dependencies: {$analysis['statistics']['total_dependencies']}\n";
+        echo "   Satisfied: {$analysis['statistics']['satisfied_dependencies']}\n";
+        echo "   Unsatisfied: {$analysis['statistics']['unsatisfied_dependencies']}\n";
+        echo "   Total dependents: {$analysis['statistics']['total_dependents']}\n";
+        echo "   Chain depth: {$analysis['statistics']['chain_depth']}\n";
+
+        $canExecute = $analysis['can_execute'] ? '✅ Yes' : '❌ No';
+        echo "   Can execute: {$canExecute}\n\n";
+
+        if (!empty($analysis['unsatisfied_dependencies'])) {
+            echo "⏳ Unsatisfied Dependencies:\n";
+            foreach ($analysis['unsatisfied_dependencies'] as $dep) {
+                echo "   - {$dep['depends_on_job_id']} ({$dep['dependency_type']})\n";
+            }
+            echo "\n";
+        }
+
+        if (!empty($analysis['full_dependency_chain'])) {
+            echo "🔗 Full Dependency Chain:\n";
+            foreach ($analysis['full_dependency_chain'] as $depJobId) {
+                echo "   → {$depJobId}\n";
+            }
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:dependency:ready', description: 'List all jobs ready for execution')]
+    public function listReadyJobs(): void
+    {
+        $readyJobs = $this->dependencyManager->getReadyJobs();
+
+        echo "🚀 Jobs ready for execution:\n\n";
+
+        if (empty($readyJobs)) {
+            echo "   No jobs are currently ready\n";
+        } else {
+            foreach ($readyJobs as $jobId) {
+                echo "   ✅ {$jobId}\n";
+            }
+        }
+
+        echo "\nTotal: " . count($readyJobs) . " jobs ready\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:dependency:validate', description: 'Validate dependency graph for circular dependencies')]
+    public function validateDependencies(string $jobIds): void
+    {
+        $jobIdArray = explode(',', $jobIds);
+        $jobIdArray = array_map('trim', $jobIdArray);
+
+        $results = $this->resolutionEngine->validateDependencyGraph($jobIdArray);
+
+        echo "🔍 Dependency Graph Validation\n\n";
+
+        $hasErrors = false;
+
+        foreach ($results as $result) {
+            $status = $result['valid'] ? '✅' : '❌';
+            echo "{$status} {$result['job_id']}";
+
+            if (!$result['valid']) {
+                $hasErrors = true;
+                echo " - {$result['error']}\n";
+                if (isset($result['dependency_chain'])) {
+                    echo "   Chain: " . implode(' → ', $result['dependency_chain']) . "\n";
+                }
+            } else {
+                echo " - Valid\n";
+            }
+        }
+
+        if ($hasErrors) {
+            echo "\n❌ Validation failed: Circular dependencies detected\n";
+        } else {
+            echo "\n✅ Validation passed: No circular dependencies\n";
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:dependency:cleanup', description: 'Clean up old satisfied dependencies')]
+    public function cleanupOldDependencies(int $olderThanDays = 30): void
+    {
+        $deletedCount = $this->dependencyManager->cleanupOldDependencies($olderThanDays);
+
+        echo "🧹 Cleaned up old dependencies\n";
+        echo "   Deleted: {$deletedCount} satisfied dependencies older than {$olderThanDays} days\n";
+    }
+
+    #[ConsoleCommand(name: 'queue:dependency:health', description: 'Perform dependency system health check')]
+    public function healthCheck(): void
+    {
+        $health = $this->resolutionEngine->performHealthCheck();
+
+        $statusIcon = $health['status'] === 'healthy' ? '✅' : '⚠️';
+        echo "{$statusIcon} Dependency System Health: {$health['status']}\n\n";
+
+        echo "📊 Statistics:\n";
+        echo "   Active chains: {$health['statistics']['active_chains']}\n";
+        echo "   Pending chains: {$health['statistics']['pending_chains']}\n";
+        echo "   Ready jobs: {$health['statistics']['ready_jobs']}\n";
+        echo "   Detected issues: {$health['statistics']['detected_issues']}\n\n";
+
+        if (!empty($health['issues'])) {
+            echo "⚠️ Issues Detected:\n";
+            foreach ($health['issues'] as $issue) {
+                echo "   - {$issue['type']}: ";
+
+                match($issue['type']) {
+                    'stalled_chain' => echo "Chain {$issue['chain_id']} running for {$issue['hours_running']} hours\n",
+                    'many_unsatisfied_dependencies' => echo "Job {$issue['job_id']} has {$issue['unsatisfied_count']} unsatisfied dependencies\n",
+                    default => echo "Unknown issue\n"
+                };
+            }
+        }
+    }
+}

src/Framework/Queue/Commands/JobMetricsCommands.php

@@ -0,0 +1,373 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ExitCode;
+use App\Framework\Queue\Services\JobMetricsManagerInterface;
+
+final readonly class JobMetricsCommands
+{
+    public function __construct(
+        private JobMetricsManagerInterface $metricsManager
+    ) {}
+
+    #[ConsoleCommand(name: 'queue:metrics:overview', description: 'Show system-wide queue metrics overview')]
+    public function systemOverview(): ExitCode
+    {
+        try {
+            $overview = $this->metricsManager->getSystemOverview();
+
+            echo "🎯 Queue System Overview\n\n";
+
+            // System Health
+            $healthIcon = $overview['system_health_score'] >= 70 ? '✅' : '⚠️';
+            echo "📊 System Health: {$healthIcon} {$overview['system_health_score']}%\n";
+            echo "   Total Queues: {$overview['total_queues']}\n";
+            echo "   Healthy Queues: {$overview['healthy_queues']}\n\n";
+
+            // Job Statistics
+            echo "📈 Job Statistics (24h):\n";
+            echo "   Total Jobs: {$overview['total_jobs']}\n";
+            echo "   ✅ Completed: {$overview['completed_jobs']}\n";
+            echo "   ❌ Failed: {$overview['failed_jobs']}\n";
+            echo "   ⏳ Pending: {$overview['pending_jobs']}\n";
+            echo "   🔄 Running: {$overview['running_jobs']}\n";
+            echo "   Success Rate: {$overview['overall_success_rate']}%\n\n";
+
+            // Performance
+            echo "⚡ Performance:\n";
+            echo "   Avg Execution Time: {$overview['average_execution_time_ms']}ms\n";
+            echo "   Avg Memory Usage: " . round($overview['average_memory_usage_mb'], 2) . "MB\n\n";
+
+            // Queue Details
+            echo "🔗 Queue Details:\n";
+            foreach ($overview['queue_metrics'] as $queueName => $metrics) {
+                $healthIcon = $metrics->isHealthy() ? '✅' : '⚠️';
+                $bottlenecks = $metrics->getBottleneckIndicators();
+                $bottleneckText = !empty($bottlenecks) ? ' (' . implode(', ', $bottlenecks) . ')' : '';
+
+                echo "   {$healthIcon} {$queueName}: {$metrics->totalJobs} jobs, {$metrics->successRate->getValue()}% success{$bottleneckText}\n";
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:queue', description: 'Show detailed metrics for a specific queue')]
+    public function queueMetrics(string $queueName, string $timeWindow = '1 hour'): ExitCode
+    {
+        try {
+            $metrics = $this->metricsManager->getQueueMetrics($queueName, $timeWindow);
+
+            echo "📊 Queue Metrics: {$queueName} (last {$timeWindow})\n\n";
+
+            // Health Status
+            $healthIcon = $metrics->isHealthy() ? '✅' : '⚠️';
+            echo "🏥 Health: {$healthIcon} {$metrics->getHealthScore()->getValue()}%\n\n";
+
+            // Job Counts
+            echo "📈 Job Statistics:\n";
+            echo "   Total: {$metrics->totalJobs}\n";
+            echo "   ✅ Completed: {$metrics->completedJobs}\n";
+            echo "   ❌ Failed: {$metrics->failedJobs}\n";
+            echo "   ⏳ Pending: {$metrics->pendingJobs}\n";
+            echo "   🔄 Running: {$metrics->runningJobs}\n";
+            echo "   💀 Dead Letter: {$metrics->deadLetterJobs}\n\n";
+
+            // Success/Failure Rates
+            echo "📊 Success Metrics:\n";
+            echo "   Success Rate: {$metrics->successRate->getValue()}%\n";
+            echo "   Failure Rate: {$metrics->getFailureRate()->getValue()}%\n\n";
+
+            // Performance
+            echo "⚡ Performance:\n";
+            echo "   Avg Execution Time: {$metrics->averageExecutionTimeMs}ms\n";
+            echo "   Avg Memory Usage: " . round($metrics->averageMemoryUsageMB, 2) . "MB\n";
+            echo "   Throughput: " . round($metrics->throughputJobsPerHour, 2) . " jobs/hour\n\n";
+
+            // Bottlenecks
+            $bottlenecks = $metrics->getBottleneckIndicators();
+            if (!empty($bottlenecks)) {
+                echo "⚠️ Bottleneck Indicators:\n";
+                foreach ($bottlenecks as $bottleneck) {
+                    echo "   - " . str_replace('_', ' ', ucfirst($bottleneck)) . "\n";
+                }
+                echo "\n";
+            }
+
+            echo "📅 Measured at: {$metrics->measuredAt}\n";
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:job', description: 'Show metrics for a specific job')]
+    public function jobMetrics(string $jobId): ExitCode
+    {
+        try {
+            $metrics = $this->metricsManager->getJobMetrics($jobId);
+
+            if (!$metrics) {
+                echo "❌ No metrics found for job: {$jobId}\n";
+                return ExitCode::GENERAL_ERROR;
+            }
+
+            echo "📊 Job Metrics: {$jobId}\n\n";
+
+            // Basic Info
+            echo "ℹ️ Basic Information:\n";
+            echo "   Queue: {$metrics->queueName}\n";
+            echo "   Status: {$this->getStatusIcon($metrics->status)} {$metrics->status}\n";
+            echo "   Attempts: {$metrics->attempts}/{$metrics->maxAttempts}\n\n";
+
+            // Performance
+            echo "⚡ Performance:\n";
+            echo "   Execution Time: {$metrics->executionTimeMs}ms (" . round($metrics->getExecutionTimeSeconds(), 2) . "s)\n";
+            echo "   Memory Usage: {$metrics->memoryUsageBytes} bytes (" . round($metrics->getMemoryUsageMB(), 2) . "MB)\n";
+            echo "   Success Rate: {$metrics->getSuccessRate()->getValue()}%\n\n";
+
+            // Timestamps
+            echo "📅 Timeline:\n";
+            echo "   Created: {$metrics->createdAt}\n";
+            if ($metrics->startedAt) {
+                echo "   Started: {$metrics->startedAt}\n";
+            }
+            if ($metrics->completedAt) {
+                echo "   Completed: {$metrics->completedAt}\n";
+            }
+            if ($metrics->failedAt) {
+                echo "   Failed: {$metrics->failedAt}\n";
+            }
+
+            $duration = $metrics->getDuration();
+            if ($duration !== null) {
+                echo "   Duration: {$duration} seconds\n";
+            }
+
+            // Error Information
+            if ($metrics->errorMessage) {
+                echo "\n❌ Error:\n";
+                echo "   {$metrics->errorMessage}\n";
+            }
+
+            // Metadata
+            if (!empty($metrics->metadata)) {
+                echo "\n📝 Metadata:\n";
+                foreach ($metrics->metadata as $key => $value) {
+                    echo "   {$key}: " . json_encode($value) . "\n";
+                }
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:slow', description: 'Show slowest jobs')]
+    public function slowJobs(?string $queueName = null, int $limit = 10): ExitCode
+    {
+        try {
+            $slowJobs = $this->metricsManager->getTopSlowJobs($queueName, $limit);
+
+            $title = $queueName ? "Slowest Jobs in '{$queueName}'" : "Slowest Jobs (All Queues)";
+            echo "🐌 {$title} (Top {$limit})\n\n";
+
+            if (empty($slowJobs)) {
+                echo "   No jobs found\n";
+                return ExitCode::SUCCESS;
+            }
+
+            foreach ($slowJobs as $index => $metrics) {
+                $rank = $index + 1;
+                $statusIcon = $this->getStatusIcon($metrics->status);
+                $executionSeconds = round($metrics->getExecutionTimeSeconds(), 2);
+
+                echo "   {$rank}. {$statusIcon} {$metrics->jobId} ({$metrics->queueName})\n";
+                echo "      Time: {$metrics->executionTimeMs}ms ({$executionSeconds}s)\n";
+                echo "      Memory: " . round($metrics->getMemoryUsageMB(), 2) . "MB\n";
+                echo "      Status: {$metrics->status}\n\n";
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:memory', description: 'Show jobs with highest memory usage')]
+    public function memoryConsumers(?string $queueName = null, int $limit = 10): ExitCode
+    {
+        try {
+            $memoryJobs = $this->metricsManager->getTopMemoryConsumers($queueName, $limit);
+
+            $title = $queueName ? "Top Memory Consumers in '{$queueName}'" : "Top Memory Consumers (All Queues)";
+            echo "🧠 {$title} (Top {$limit})\n\n";
+
+            if (empty($memoryJobs)) {
+                echo "   No jobs found\n";
+                return ExitCode::SUCCESS;
+            }
+
+            foreach ($memoryJobs as $index => $metrics) {
+                $rank = $index + 1;
+                $statusIcon = $this->getStatusIcon($metrics->status);
+                $memoryMB = round($metrics->getMemoryUsageMB(), 2);
+
+                echo "   {$rank}. {$statusIcon} {$metrics->jobId} ({$metrics->queueName})\n";
+                echo "      Memory: {$metrics->memoryUsageBytes} bytes ({$memoryMB}MB)\n";
+                echo "      Time: {$metrics->executionTimeMs}ms\n";
+                echo "      Status: {$metrics->status}\n\n";
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:failed', description: 'Show recent failed jobs')]
+    public function failedJobs(?string $queueName = null, string $timeWindow = '24 hours'): ExitCode
+    {
+        try {
+            $failedJobs = $this->metricsManager->getFailedJobs($queueName, $timeWindow);
+
+            $title = $queueName ? "Failed Jobs in '{$queueName}'" : "Failed Jobs (All Queues)";
+            echo "❌ {$title} (last {$timeWindow})\n\n";
+
+            if (empty($failedJobs)) {
+                echo "   No failed jobs found\n";
+                return ExitCode::SUCCESS;
+            }
+
+            foreach ($failedJobs as $metrics) {
+                echo "   🔴 {$metrics->jobId} ({$metrics->queueName})\n";
+                echo "      Failed: {$metrics->failedAt}\n";
+                echo "      Attempts: {$metrics->attempts}/{$metrics->maxAttempts}\n";
+                if ($metrics->errorMessage) {
+                    echo "      Error: {$metrics->errorMessage}\n";
+                }
+                echo "\n";
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:performance', description: 'Show performance statistics')]
+    public function performanceStats(?string $queueName = null, string $timeWindow = '24 hours'): ExitCode
+    {
+        try {
+            $stats = $this->metricsManager->getPerformanceStats($queueName, $timeWindow);
+
+            $title = $queueName ? "Performance Stats for '{$queueName}'" : "System Performance Stats";
+            echo "📈 {$title} (last {$timeWindow})\n\n";
+
+            echo "📊 Job Statistics:\n";
+            echo "   Total Jobs: {$stats['total_jobs']}\n";
+            echo "   Completed: {$stats['completed_jobs']}\n";
+            echo "   Failed: {$stats['failed_jobs']}\n";
+            echo "   Success Rate: " . round($stats['success_rate'], 2) . "%\n";
+            echo "   Failure Rate: " . round($stats['failure_rate'], 2) . "%\n\n";
+
+            echo "⏱️ Execution Time:\n";
+            echo "   Average: " . round($stats['average_execution_time_ms'], 2) . "ms\n";
+            echo "   Minimum: " . round($stats['min_execution_time_ms'], 2) . "ms\n";
+            echo "   Maximum: " . round($stats['max_execution_time_ms'], 2) . "ms\n\n";
+
+            echo "🧠 Memory Usage:\n";
+            echo "   Average: " . round($stats['average_memory_usage_mb'], 2) . "MB\n";
+            echo "   Minimum: " . round($stats['min_memory_usage_bytes'] / (1024 * 1024), 2) . "MB\n";
+            echo "   Maximum: " . round($stats['max_memory_usage_bytes'] / (1024 * 1024), 2) . "MB\n\n";
+
+            echo "🔄 Retry Statistics:\n";
+            echo "   Average Attempts: " . round($stats['average_attempts'], 2) . "\n";
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:throughput', description: 'Show throughput statistics')]
+    public function throughputStats(?string $queueName = null, string $timeWindow = '24 hours'): ExitCode
+    {
+        try {
+            $stats = $this->metricsManager->getThroughputStats($queueName, $timeWindow);
+
+            $title = $queueName ? "Throughput Stats for '{$queueName}'" : "System Throughput Stats";
+            echo "🚀 {$title} (last {$timeWindow})\n\n";
+
+            echo "📊 Overall Throughput:\n";
+            echo "   Total Completed: {$stats['total_completed']} jobs\n";
+            echo "   Average per Hour: " . round($stats['average_throughput_per_hour'], 2) . " jobs/hour\n\n";
+
+            echo "📈 Hourly Breakdown:\n";
+            if (empty($stats['hourly_breakdown'])) {
+                echo "   No data available\n";
+            } else {
+                foreach ($stats['hourly_breakdown'] as $hourData) {
+                    $hour = date('H:i', strtotime($hourData['hour']));
+                    $jobs = $hourData['jobs_completed'];
+                    $bar = str_repeat('█', min(50, $jobs)); // Simple bar chart
+                    echo "   {$hour}: {$jobs} jobs {$bar}\n";
+                }
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:metrics:cleanup', description: 'Clean up old metrics data')]
+    public function cleanupMetrics(int $olderThanDays = 90): ExitCode
+    {
+        try {
+            $deletedCount = $this->metricsManager->cleanupOldMetrics($olderThanDays);
+
+            echo "🧹 Metrics Cleanup Completed\n";
+            echo "   Deleted: {$deletedCount} metrics older than {$olderThanDays} days\n";
+
+            if ($deletedCount > 0) {
+                echo "   ✅ Cleanup successful\n";
+            } else {
+                echo "   ℹ️ No old metrics found to clean up\n";
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    private function getStatusIcon(string $status): string
+    {
+        return match($status) {
+            'pending' => '⏳',
+            'running' => '🔄',
+            'completed' => '✅',
+            'failed' => '❌',
+            'dead_letter' => '💀',
+            default => '❓'
+        };
+    }
+}

src/Framework/Queue/Commands/ProgressCommands.php

@@ -0,0 +1,194 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Attributes\ConsoleCommand;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Queue\Services\ProgressManager;
+use App\Framework\Queue\Entities\JobProgressEntry;
+
+/**
+ * Console commands for managing job progress
+ */
+final readonly class ProgressCommands
+{
+    public function __construct(
+        private ProgressManager $progressManager
+    ) {}
+
+    #[ConsoleCommand(name: 'queue:progress:show', description: 'Show current progress for a job')]
+    public function showProgress(string $jobId, ConsoleOutput $output): void
+    {
+        $progress = $this->progressManager->getJobProgress($jobId);
+
+        if (!$progress) {
+            $output->writeln("<error>No progress found for job: {$jobId}</error>");
+            return;
+        }
+
+        $output->writeln("<info>Job Progress for: {$jobId}</info>");
+        $output->writeln("Percentage: {$progress->percentage->format()}");
+        $output->writeln("Message: {$progress->message}");
+
+        if ($progress->metadata) {
+            $output->writeln("Metadata:");
+            foreach ($progress->metadata as $key => $value) {
+                $valueStr = is_array($value) ? json_encode($value) : (string) $value;
+                $output->writeln("  {$key}: {$valueStr}");
+            }
+        }
+
+        $output->writeln("Status: " . ($progress->isCompleted() ? 'Completed' : ($progress->isFailed() ? 'Failed' : 'In Progress')));
+    }
+
+    #[ConsoleCommand(name: 'queue:progress:history', description: 'Show progress history for a job')]
+    public function showHistory(string $jobId, ConsoleOutput $output): void
+    {
+        $history = $this->progressManager->getProgressHistory($jobId);
+
+        if (empty($history)) {
+            $output->writeln("<error>No progress history found for job: {$jobId}</error>");
+            return;
+        }
+
+        $output->writeln("<info>Progress History for: {$jobId}</info>");
+        $output->writeln(str_repeat('-', 80));
+
+        foreach ($history as $entry) {
+            /** @var JobProgressEntry $entry */
+            $output->writeln("Time: {$entry->updatedAt}");
+            $output->writeln("Progress: {$entry->getPercentage()->format()}");
+            $output->writeln("Message: {$entry->message}");
+
+            if ($entry->stepName) {
+                $output->writeln("Step: {$entry->stepName}");
+            }
+
+            $status = [];
+            if ($entry->isCompleted) $status[] = 'Completed';
+            if ($entry->isFailed) $status[] = 'Failed';
+            if (!empty($status)) {
+                $output->writeln("Status: " . implode(', ', $status));
+            }
+
+            $output->writeln(str_repeat('-', 40));
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:progress:list', description: 'List recent job progress updates')]
+    public function listRecent(ConsoleOutput $output, ?int $minutes = 60, ?int $limit = 20): void
+    {
+        $recentJobs = $this->progressManager->getRecentlyUpdatedJobs($minutes ?? 60, $limit ?? 20);
+
+        if (empty($recentJobs)) {
+            $output->writeln("<info>No recent job progress updates found</info>");
+            return;
+        }
+
+        $output->writeln("<info>Recent Job Progress Updates (last {$minutes} minutes)</info>");
+        $output->writeln(str_repeat('=', 80));
+
+        foreach ($recentJobs as $entry) {
+            /** @var JobProgressEntry $entry */
+            $output->writeln("Job ID: {$entry->jobId}");
+            $output->writeln("Progress: {$entry->getPercentage()->format()}");
+            $output->writeln("Message: {$entry->message}");
+            $output->writeln("Updated: {$entry->updatedAt}");
+
+            if ($entry->stepName) {
+                $output->writeln("Step: {$entry->stepName}");
+            }
+
+            $status = [];
+            if ($entry->isCompleted) $status[] = 'Completed';
+            if ($entry->isFailed) $status[] = 'Failed';
+            if (!empty($status)) {
+                $output->writeln("Status: " . implode(', ', $status));
+            }
+
+            $output->writeln(str_repeat('-', 40));
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:progress:above', description: 'List jobs above a certain progress percentage')]
+    public function listAboveProgress(float $percentage, ConsoleOutput $output): void
+    {
+        if ($percentage < 0 || $percentage > 100) {
+            $output->writeln("<error>Percentage must be between 0 and 100</error>");
+            return;
+        }
+
+        $jobs = $this->progressManager->getJobsAboveProgress($percentage);
+
+        if (empty($jobs)) {
+            $output->writeln("<info>No jobs found above {$percentage}% progress</info>");
+            return;
+        }
+
+        $output->writeln("<info>Jobs above {$percentage}% progress</info>");
+        $output->writeln(str_repeat('=', 80));
+
+        foreach ($jobs as $entry) {
+            /** @var JobProgressEntry $entry */
+            $output->writeln("Job ID: {$entry->jobId}");
+            $output->writeln("Progress: {$entry->getPercentage()->format()}");
+            $output->writeln("Message: {$entry->message}");
+            $output->writeln("Updated: {$entry->updatedAt}");
+
+            $status = [];
+            if ($entry->isCompleted) $status[] = 'Completed';
+            if ($entry->isFailed) $status[] = 'Failed';
+            if (!empty($status)) {
+                $output->writeln("Status: " . implode(', ', $status));
+            }
+
+            $output->writeln(str_repeat('-', 40));
+        }
+    }
+
+    #[ConsoleCommand(name: 'queue:progress:cleanup', description: 'Clean up old progress entries')]
+    public function cleanup(ConsoleOutput $output, ?int $days = 30): void
+    {
+        $deletedCount = $this->progressManager->cleanupOldProgress($days ?? 30);
+
+        $output->writeln("<info>Cleaned up {$deletedCount} old progress entries older than {$days} days</info>");
+    }
+
+    #[ConsoleCommand(name: 'queue:progress:multiple', description: 'Show progress for multiple jobs (comma-separated IDs)')]
+    public function showMultiple(string $jobIds, ConsoleOutput $output): void
+    {
+        $idArray = array_map('trim', explode(',', $jobIds));
+
+        if (empty($idArray)) {
+            $output->writeln("<error>No job IDs provided</error>");
+            return;
+        }
+
+        $progressData = $this->progressManager->getMultipleJobProgress($idArray);
+
+        if (empty($progressData)) {
+            $output->writeln("<error>No progress found for any of the provided job IDs</error>");
+            return;
+        }
+
+        $output->writeln("<info>Progress for multiple jobs</info>");
+        $output->writeln(str_repeat('=', 80));
+
+        foreach ($idArray as $jobId) {
+            $output->writeln("Job ID: {$jobId}");
+
+            if (isset($progressData[$jobId])) {
+                $progress = $progressData[$jobId];
+                $output->writeln("  Progress: {$progress->percentage->format()}");
+                $output->writeln("  Message: {$progress->message}");
+                $output->writeln("  Status: " . ($progress->isCompleted() ? 'Completed' : ($progress->isFailed() ? 'Failed' : 'In Progress')));
+            } else {
+                $output->writeln("  <comment>No progress data found</comment>");
+            }
+
+            $output->writeln(str_repeat('-', 40));
+        }
+    }
+}

src/Framework/Queue/Commands/WorkerCommands.php

@@ -0,0 +1,428 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Commands;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ExitCode;
+use App\Framework\Queue\Services\WorkerRegistry;
+use App\Framework\Queue\Services\WorkerHealthCheckService;
+use App\Framework\Queue\Services\JobDistributionService;
+use App\Framework\Queue\Services\FailoverRecoveryService;
+use App\Framework\Queue\Interfaces\DistributedLockInterface;
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Console Commands für Worker Management
+ */
+final readonly class WorkerCommands
+{
+    public function __construct(
+        private WorkerRegistry $workerRegistry,
+        private WorkerHealthCheckService $healthCheckService,
+        private JobDistributionService $jobDistributionService,
+        private FailoverRecoveryService $failoverRecoveryService,
+        private DistributedLockInterface $distributedLock
+    ) {}
+
+    #[ConsoleCommand(name: 'worker:list', description: 'List all registered workers with their status')]
+    public function listWorkers(bool $active = true, bool $detailed = false): ExitCode
+    {
+        echo "🔧 Worker Registry Status\n\n";
+
+        try {
+            $workers = $active
+                ? $this->workerRegistry->findActiveWorkers()
+                : $this->workerRegistry->findActiveWorkers(); // Vereinfacht - könnte erweitert werden
+
+            if (empty($workers)) {
+                echo "ℹ️ No workers found\n";
+                return ExitCode::SUCCESS;
+            }
+
+            echo "📊 Found " . count($workers) . " worker(s)\n\n";
+
+            foreach ($workers as $worker) {
+                $status = $worker->isHealthy() ? '🟢' : ($worker->isActive ? '🟡' : '🔴');
+                $load = $worker->getLoadPercentage()->getValue();
+
+                echo "{$status} {$worker->hostname}:{$worker->processId}\n";
+                echo "   ID: {$worker->id->toString()}\n";
+                echo "   Load: {$worker->currentJobs}/{$worker->maxJobs} ({$load}%)\n";
+                echo "   Queues: " . implode(', ', array_map(fn($q) => $q->toString(), $worker->queues)) . "\n";
+
+                if ($detailed) {
+                    echo "   CPU: {$worker->cpuUsage->getValue()}%\n";
+                    echo "   Memory: " . round($worker->memoryUsage->toBytes() / 1024 / 1024, 1) . "MB\n";
+                    echo "   Last Heartbeat: " . ($worker->lastHeartbeat?->format('Y-m-d H:i:s') ?? 'Never') . "\n";
+                    echo "   Capabilities: " . implode(', ', $worker->capabilities) . "\n";
+                }
+
+                echo "\n";
+            }
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'worker:health', description: 'Perform health check on all workers')]
+    public function healthCheck(bool $detailed = false): ExitCode
+    {
+        echo "🏥 Worker Health Check\n\n";
+
+        try {
+            $healthReport = $this->healthCheckService->performHealthCheck();
+
+            // Overall Status
+            $overall = $healthReport['overall'];
+            $statusIcon = match($overall['status']) {
+                'healthy' => '🟢',
+                'warning' => '🟡',
+                'critical' => '🔴',
+                default => '⚪'
+            };
+
+            echo "{$statusIcon} Overall Status: {$overall['status']} (Score: {$overall['score']})\n";
+            echo "📊 Workers: " . ($overall['healthy_workers'] ?? 0) . " healthy, " . ($overall['warning_workers'] ?? 0) . " warning, " . ($overall['critical_workers'] ?? 0) . " critical\n\n";
+
+            // Worker Details
+            foreach ($healthReport['workers'] as $workerHealth) {
+                $statusIcon = match($workerHealth['status']) {
+                    'healthy' => '🟢',
+                    'warning' => '🟡',
+                    'critical' => '🔴',
+                    default => '⚪'
+                };
+
+                echo "{$statusIcon} {$workerHealth['hostname']}:{$workerHealth['process_id']}\n";
+                echo "   Status: {$workerHealth['status']} (Score: {$workerHealth['score']})\n";
+
+                if (!empty($workerHealth['issues'])) {
+                    echo "   Issues:\n";
+                    foreach ($workerHealth['issues'] as $issue) {
+                        echo "   ❌ {$issue}\n";
+                    }
+                }
+
+                if (!empty($workerHealth['warnings'])) {
+                    echo "   Warnings:\n";
+                    foreach ($workerHealth['warnings'] as $warning) {
+                        echo "   ⚠️ {$warning}\n";
+                    }
+                }
+
+                if ($detailed) {
+                    echo "   Metrics:\n";
+                    $metrics = $workerHealth['metrics'];
+                    echo "     CPU: {$metrics['cpu_usage_percent']}%\n";
+                    echo "     Memory: {$metrics['memory_usage_gb']}GB\n";
+                    echo "     Load: {$metrics['job_load_percent']}%\n";
+                    echo "     Jobs: {$metrics['current_jobs']}/{$metrics['max_jobs']}\n";
+                }
+
+                echo "\n";
+            }
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'worker:stats', description: 'Show worker and distribution statistics')]
+    public function showStatistics(): ExitCode
+    {
+        echo "📊 Worker & Distribution Statistics\n\n";
+
+        try {
+            // Worker Statistics
+            $workerStats = $this->workerRegistry->getWorkerStatistics();
+
+            echo "🔧 Worker Overview:\n";
+            echo "   Total Workers: {$workerStats['total_workers']}\n";
+            echo "   Active Workers: {$workerStats['active_workers']}\n";
+            echo "   Healthy Workers: {$workerStats['healthy_workers']}\n";
+            echo "   Unique Hosts: {$workerStats['unique_hosts']}\n";
+            echo "   Total Capacity: {$workerStats['total_capacity']} jobs\n";
+            echo "   Current Load: {$workerStats['current_load']} jobs\n";
+            echo "   Capacity Utilization: {$workerStats['capacity_utilization']}%\n";
+            echo "   Avg CPU Usage: {$workerStats['avg_cpu_usage']}%\n";
+            echo "   Avg Memory Usage: {$workerStats['avg_memory_usage_mb']}MB\n\n";
+
+            // Queue Distribution
+            echo "📋 Queue Distribution:\n";
+            foreach ($workerStats['queue_distribution'] as $queue => $workerCount) {
+                echo "   {$queue}: {$workerCount} workers\n";
+            }
+            echo "\n";
+
+            // Distribution Statistics
+            $distributionStats = $this->jobDistributionService->getDistributionStatistics();
+
+            echo "🎯 Job Distribution:\n";
+            $assignments = $distributionStats['assignments'];
+            echo "   Total Assignments: {$assignments['total']}\n";
+            echo "   Active Workers: {$assignments['active_workers']}\n";
+            echo "   Active Queues: {$assignments['active_queues']}\n";
+            echo "   Avg Assignment Age: {$assignments['avg_assignment_age_seconds']}s\n\n";
+
+            // Distribution Health
+            $health = $distributionStats['distribution_health'];
+            $statusIcon = match($health['status']) {
+                'healthy' => '🟢',
+                'warning' => '🟡',
+                'degraded' => '🟠',
+                'critical' => '🔴',
+                default => '⚪'
+            };
+
+            echo "{$statusIcon} Distribution Health: {$health['status']} (Score: {$health['score']})\n";
+            echo "   Avg Load: " . ($health['avg_load'] ?? 0) . "%\n";
+            echo "   Max Load: " . ($health['max_load'] ?? 0) . "%\n";
+            echo "   Load Variance: " . ($health['load_variance'] ?? 0) . "%\n";
+            echo "   Availability: " . ($health['availability_ratio'] ?? 0) . "%\n";
+
+            if (!empty($health['issues'])) {
+                echo "   Issues:\n";
+                foreach ($health['issues'] as $issue) {
+                    echo "   ❌ {$issue}\n";
+                }
+            }
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'worker:failover', description: 'Perform failover and recovery process')]
+    public function performFailover(bool $dryRun = false): ExitCode
+    {
+        echo "🔄 " . ($dryRun ? 'Simulating' : 'Performing') . " Failover and Recovery\n\n";
+
+        try {
+            if ($dryRun) {
+                // Nur fehlgeschlagene Worker erkennen ohne Recovery
+                $failedWorkers = $this->failoverRecoveryService->detectFailedWorkers();
+
+                echo "🔍 Detected Issues:\n";
+                echo "   Failed Workers: " . count($failedWorkers) . "\n";
+
+                foreach ($failedWorkers as $worker) {
+                    echo "   🔴 {$worker->hostname}:{$worker->processId} ({$worker->id->toString()})\n";
+                }
+
+                if (empty($failedWorkers)) {
+                    echo "   ✅ No failed workers detected\n";
+                }
+
+                echo "\n⚠️ Dry run completed - no recovery actions taken\n";
+
+            } else {
+                $results = $this->failoverRecoveryService->performFailoverRecovery();
+
+                echo "📊 Failover Results:\n";
+                echo "   Failed Workers: {$results['failed_workers_detected']}\n";
+                echo "   Jobs Recovered: {$results['jobs_recovered']}\n";
+                echo "   Jobs Reassigned: {$results['jobs_reassigned']}\n";
+                echo "   Workers Cleaned: {$results['workers_cleaned']}\n";
+                echo "   Locks Released: {$results['locks_released']}\n";
+
+                if (isset($results['orphaned_jobs_recovered'])) {
+                    echo "   Orphaned Jobs Recovered: {$results['orphaned_jobs_recovered']}\n";
+                }
+
+                if (isset($results['expired_locks_cleaned'])) {
+                    echo "   Expired Locks Cleaned: {$results['expired_locks_cleaned']}\n";
+                }
+
+                echo "   Duration: {$results['duration_seconds']}s\n";
+
+                if (!empty($results['errors'])) {
+                    echo "\n❌ Errors:\n";
+                    foreach ($results['errors'] as $error) {
+                        echo "   • {$error}\n";
+                    }
+                }
+
+                echo "\n✅ Failover process completed\n";
+            }
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'worker:locks', description: 'Show distributed lock information')]
+    public function showLocks(bool $detailed = false): ExitCode
+    {
+        echo "🔒 Distributed Locks Status\n\n";
+
+        try {
+            $lockStats = $this->distributedLock->getLockStatistics();
+
+            echo "📊 Lock Overview:\n";
+            echo "   Total Locks: {$lockStats['total_locks']}\n";
+            echo "   Active Locks: {$lockStats['active_locks']}\n";
+            echo "   Expired Locks: {$lockStats['expired_locks']}\n";
+            echo "   Unique Workers: {$lockStats['unique_workers']}\n";
+            echo "   Avg TTL: {$lockStats['avg_ttl_seconds']}s\n";
+            echo "   Oldest Lock: " . ($lockStats['oldest_lock'] ?? 'None') . "\n";
+            echo "   Newest Lock: " . ($lockStats['newest_lock'] ?? 'None') . "\n\n";
+
+            if ($detailed && !empty($lockStats['top_lock_keys'])) {
+                echo "🔑 Top Lock Keys:\n";
+                foreach ($lockStats['top_lock_keys'] as $keyInfo) {
+                    echo "   {$keyInfo['lock_key']}: {$keyInfo['count']} locks\n";
+                }
+                echo "\n";
+            }
+
+            // Cleanup abgelaufene Locks
+            echo "🧹 Cleaning up expired locks...\n";
+            $cleaned = $this->distributedLock->cleanupExpiredLocks();
+            echo "   Cleaned {$cleaned} expired locks\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'worker:resilience', description: 'Show system resilience score and recommendations')]
+    public function showResilience(): ExitCode
+    {
+        echo "🛡️ System Resilience Report\n\n";
+
+        try {
+            $resilience = $this->failoverRecoveryService->calculateResilienceScore();
+
+            $statusIcon = match($resilience['status']) {
+                'excellent' => '🟢',
+                'good' => '🟡',
+                'fair' => '🟠',
+                'poor' => '🔴',
+                'critical' => '💀',
+                default => '⚪'
+            };
+
+            echo "{$statusIcon} Resilience Score: {$resilience['score']}/100 ({$resilience['status']})\n\n";
+
+            echo "📊 Key Metrics:\n";
+            if (isset($resilience['metrics'])) {
+                $metrics = $resilience['metrics'];
+                echo "   Worker Availability: {$metrics['worker_availability']}%\n";
+                echo "   Recent Failovers (24h): {$metrics['recent_failovers_24h']}\n";
+                echo "   Active Locks: {$metrics['active_locks']}\n";
+                echo "   Expired Locks: {$metrics['expired_locks']}\n";
+            }
+
+            if (!empty($resilience['factors'])) {
+                echo "\n⚠️ Resilience Factors:\n";
+                foreach ($resilience['factors'] as $factor) {
+                    echo "   • {$factor}\n";
+                }
+            }
+
+            // Failover Statistics
+            echo "\n📈 Failover Statistics (7 days):\n";
+            $failoverStats = $this->failoverRecoveryService->getFailoverStatistics();
+            $stats = $failoverStats['statistics'];
+            echo "   Total Failovers: {$stats['total_failovers']}\n";
+            echo "   Failed Workers: {$stats['failed_workers']}\n";
+            echo "   Recovery Workers: {$stats['recovery_workers']}\n";
+            echo "   Affected Jobs: {$stats['affected_jobs']}\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'worker:cleanup', description: 'Cleanup inactive workers and old health records')]
+    public function cleanup(int $inactiveMinutes = 5, int $healthRetentionDays = 7): ExitCode
+    {
+        echo "🧹 Worker System Cleanup\n\n";
+
+        try {
+            // Inactive Workers cleanup
+            echo "🔧 Cleaning up inactive workers...\n";
+            $inactiveCount = $this->workerRegistry->cleanupInactiveWorkers($inactiveMinutes);
+            echo "   Deactivated {$inactiveCount} workers (inactive > {$inactiveMinutes} min)\n\n";
+
+            // Health Records cleanup
+            echo "🏥 Cleaning up old health records...\n";
+            $healthCount = $this->healthCheckService->cleanupHealthChecks(
+                Duration::fromDays($healthRetentionDays)
+            );
+            echo "   Deleted {$healthCount} health records (older than {$healthRetentionDays} days)\n\n";
+
+            // Locks cleanup
+            echo "🔒 Cleaning up expired locks...\n";
+            $locksCount = $this->distributedLock->cleanupExpiredLocks();
+            echo "   Cleaned {$locksCount} expired locks\n\n";
+
+            echo "✅ Cleanup completed successfully\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    #[ConsoleCommand(name: 'worker:deregister', description: 'Forcefully deregister a specific worker')]
+    public function deregisterWorker(string $workerId): ExitCode
+    {
+        echo "🚫 Deregistering Worker\n\n";
+
+        try {
+            $worker = $this->workerRegistry->findById(WorkerId::fromString($workerId));
+
+            if (!$worker) {
+                echo "❌ Worker not found: {$workerId}\n";
+                return ExitCode::INVALID_ARGUMENT;
+            }
+
+            echo "🔍 Found worker: {$worker->hostname}:{$worker->processId}\n";
+            echo "   Current jobs: {$worker->currentJobs}\n";
+            echo "   Status: " . ($worker->isActive ? 'Active' : 'Inactive') . "\n\n";
+
+            // Release all jobs
+            echo "🎯 Releasing all worker jobs...\n";
+            $releasedJobs = $this->jobDistributionService->releaseAllWorkerJobs($worker->id);
+            echo "   Released {$releasedJobs} job assignments\n";
+
+            // Deregister worker
+            echo "🚫 Deregistering worker...\n";
+            $this->workerRegistry->deregister($worker->id);
+            echo "   Worker deregistered successfully\n\n";
+
+            echo "✅ Worker {$workerId} has been forcefully deregistered\n";
+
+            return ExitCode::SUCCESS;
+
+        } catch (\Exception $e) {
+            echo "❌ Error: {$e->getMessage()}\n";
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+}

src/Framework/Queue/Contracts/DeadLetterQueueInterface.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Contracts;
+
+use App\Framework\Queue\Entities\DeadLetterJob;
+use App\Framework\Queue\ValueObjects\DeadLetterQueueName;
+use App\Framework\Queue\ValueObjects\QueueName;
+
+/**
+ * Interface for Dead Letter Queue operations
+ */
+interface DeadLetterQueueInterface
+{
+    /**
+     * Add a failed job to the dead letter queue
+     */
+    public function addFailedJob(DeadLetterJob $deadLetterJob): void;
+
+    /**
+     * Get all jobs from a dead letter queue
+     *
+     * @return DeadLetterJob[]
+     */
+    public function getJobs(DeadLetterQueueName $deadLetterQueueName, int $limit = 100): array;
+
+    /**
+     * Get jobs from dead letter queue by original queue
+     *
+     * @return DeadLetterJob[]
+     */
+    public function getJobsByOriginalQueue(QueueName $originalQueue, int $limit = 100): array;
+
+    /**
+     * Retry a job from the dead letter queue
+     * Moves it back to the original queue and increments retry count
+     */
+    public function retryJob(string $deadLetterJobId): bool;
+
+    /**
+     * Permanently delete a job from the dead letter queue
+     */
+    public function deleteJob(string $deadLetterJobId): bool;
+
+    /**
+     * Retry all jobs in a dead letter queue
+     * Returns the number of jobs successfully retried
+     */
+    public function retryAllJobs(DeadLetterQueueName $deadLetterQueueName): int;
+
+    /**
+     * Clear all jobs from a dead letter queue
+     * Returns the number of jobs deleted
+     */
+    public function clearQueue(DeadLetterQueueName $deadLetterQueueName): int;
+
+    /**
+     * Get statistics for a dead letter queue
+     */
+    public function getQueueStats(DeadLetterQueueName $deadLetterQueueName): array;
+
+    /**
+     * Get all dead letter queue names
+     *
+     * @return DeadLetterQueueName[]
+     */
+    public function getAvailableQueues(): array;
+}

src/Framework/Queue/Contracts/JobBatchManagerInterface.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Contracts;
+
+use App\Framework\Queue\ValueObjects\JobBatch;
+use App\Framework\Queue\ValueObjects\JobBatchStatus;
+
+/**
+ * Interface for managing job batches
+ */
+interface JobBatchManagerInterface
+{
+    /**
+     * Create a new job batch
+     */
+    public function createBatch(string $name, array $jobIds, array $options = []): JobBatch;
+
+    /**
+     * Get a batch by ID
+     */
+    public function getBatch(string $batchId): ?JobBatch;
+
+    /**
+     * Update batch progress when a job completes
+     */
+    public function recordJobCompleted(string $batchId, string $jobId): void;
+
+    /**
+     * Update batch progress when a job fails
+     */
+    public function recordJobFailed(string $batchId, string $jobId): void;
+
+    /**
+     * Cancel a batch
+     */
+    public function cancelBatch(string $batchId): bool;
+
+    /**
+     * Get batches by status
+     */
+    public function getBatchesByStatus(JobBatchStatus $status, int $limit = 50): array;
+
+    /**
+     * Get batch statistics
+     */
+    public function getBatchStats(): array;
+
+    /**
+     * Clean up old batches
+     */
+    public function cleanupOldBatches(int $olderThanDays = 30): int;
+
+    /**
+     * Get batch progress
+     */
+    public function getBatchProgress(string $batchId): array;
+}

src/Framework/Queue/Contracts/JobChainManagerInterface.php

@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Contracts;
+
+use App\Framework\Queue\ValueObjects\JobChain;
+use App\Framework\Queue\Entities\JobChainEntry;
+
+/**
+ * Interface for managing job chains
+ */
+interface JobChainManagerInterface
+{
+    /**
+     * Create a new job chain
+     */
+    public function createChain(JobChain $jobChain): void;
+
+    /**
+     * Get a job chain by its ID
+     */
+    public function getChain(string $chainId): ?JobChainEntry;
+
+    /**
+     * Update an existing job chain
+     */
+    public function updateChain(JobChain $jobChain): void;
+
+    /**
+     * Delete a job chain
+     */
+    public function deleteChain(string $chainId): void;
+
+    /**
+     * Start execution of a job chain
+     */
+    public function startChain(string $chainId): void;
+
+    /**
+     * Get all chains for a specific job
+     */
+    public function getChainsForJob(string $jobId): array;
+
+    /**
+     * Get all active (running) chains
+     */
+    public function getActiveChains(): array;
+
+    /**
+     * Get all pending chains
+     */
+    public function getPendingChains(): array;
+
+    /**
+     * Mark a chain as completed
+     */
+    public function markChainAsCompleted(string $chainId): void;
+
+    /**
+     * Mark a chain as failed
+     */
+    public function markChainAsFailed(string $chainId): void;
+
+    /**
+     * Get the next job in a chain to execute
+     */
+    public function getNextJobInChain(string $chainId, ?string $currentJobId = null): ?string;
+
+    /**
+     * Check if a chain is complete
+     */
+    public function isChainComplete(string $chainId): bool;
+
+    /**
+     * Handle job completion within a chain
+     */
+    public function handleJobCompletion(string $jobId, bool $successful = true): void;
+
+    /**
+     * Get chain execution status and progress
+     */
+    public function getChainProgress(string $chainId): array;
+
+    /**
+     * Clean up old completed chains
+     */
+    public function cleanupOldChains(int $olderThanDays = 30): int;
+}

src/Framework/Queue/Contracts/JobDependencyManagerInterface.php

@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Contracts;
+
+use App\Framework\Queue\ValueObjects\JobDependency;
+use App\Framework\Queue\Entities\JobDependencyEntry;
+
+/**
+ * Interface for managing job dependencies
+ */
+interface JobDependencyManagerInterface
+{
+    /**
+     * Add a dependency between two jobs
+     */
+    public function addDependency(JobDependency $dependency): void;
+
+    /**
+     * Remove a dependency
+     */
+    public function removeDependency(string $dependentJobId, string $dependsOnJobId): void;
+
+    /**
+     * Get all dependencies for a job (jobs this job depends on)
+     */
+    public function getDependencies(string $jobId): array;
+
+    /**
+     * Get all dependents for a job (jobs that depend on this job)
+     */
+    public function getDependents(string $jobId): array;
+
+    /**
+     * Check if a job has any unsatisfied dependencies
+     */
+    public function hasUnsatisfiedDependencies(string $jobId): bool;
+
+    /**
+     * Get unsatisfied dependencies for a job
+     *
+     * @return JobDependencyEntry[]
+     */
+    public function getUnsatisfiedDependencies(string $jobId): array;
+
+    /**
+     * Mark a dependency as satisfied
+     */
+    public function markDependencyAsSatisfied(string $dependentJobId, string $dependsOnJobId): void;
+
+    /**
+     * Check if a job can be executed (all dependencies satisfied)
+     */
+    public function canJobBeExecuted(string $jobId): bool;
+
+    /**
+     * Get jobs that are ready to be executed (no unsatisfied dependencies)
+     */
+    public function getReadyJobs(): array;
+
+    /**
+     * Resolve dependencies when a job completes
+     */
+    public function resolveJobCompletion(string $jobId, bool $successful = true): array;
+
+    /**
+     * Get dependency chain for a job (all jobs it transitively depends on)
+     */
+    public function getDependencyChain(string $jobId): array;
+
+    /**
+     * Check for circular dependencies
+     */
+    public function hasCircularDependencies(string $jobId): bool;
+
+    /**
+     * Clean up old satisfied dependencies
+     */
+    public function cleanupOldDependencies(int $olderThanDays = 30): int;
+}

src/Framework/Queue/Contracts/JobProgressTrackerInterface.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Contracts;
+
+use App\Framework\Queue\Entities\JobProgressEntry;
+use App\Framework\Queue\ValueObjects\JobProgress;
+use App\Framework\Queue\ValueObjects\ProgressStep;
+
+/**
+ * Interface for tracking job progress
+ */
+interface JobProgressTrackerInterface
+{
+    /**
+     * Update job progress
+     */
+    public function updateProgress(string $jobId, JobProgress $progress, ?string $stepName = null): void;
+
+    /**
+     * Mark a step as completed
+     */
+    public function completeStep(string $jobId, ProgressStep $step): void;
+
+    /**
+     * Get current progress for a job
+     */
+    public function getCurrentProgress(string $jobId): ?JobProgress;
+
+    /**
+     * Get all progress entries for a job
+     *
+     * @return JobProgressEntry[]
+     */
+    public function getProgressHistory(string $jobId): array;
+
+    /**
+     * Get latest progress entry for a job
+     */
+    public function getLatestProgressEntry(string $jobId): ?JobProgressEntry;
+
+    /**
+     * Mark job as completed
+     */
+    public function markJobCompleted(string $jobId, string $message = 'Job completed successfully'): void;
+
+    /**
+     * Mark job as failed
+     */
+    public function markJobFailed(string $jobId, string $message = 'Job failed', ?\Throwable $exception = null): void;
+
+    /**
+     * Get progress for multiple jobs
+     *
+     * @param string[] $jobIds
+     * @return array<string, JobProgress> Job ID => Progress
+     */
+    public function getProgressForJobs(array $jobIds): array;
+
+    /**
+     * Clean up old progress entries
+     * Returns number of deleted entries
+     */
+    public function cleanupOldEntries(int $olderThanDays = 30): int;
+
+    /**
+     * Get jobs with progress above a certain percentage
+     *
+     * @return JobProgressEntry[]
+     */
+    public function getJobsAboveProgress(float $minPercentage): array;
+
+    /**
+     * Get recently updated jobs
+     *
+     * @return JobProgressEntry[]
+     */
+    public function getRecentlyUpdatedJobs(int $limitMinutes = 60, int $limit = 100): array;
+}

src/Framework/Queue/Entities/DeadLetterJob.php

@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Id;
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Queue\ValueObjects\DeadLetterQueueName;
+use App\Framework\Queue\ValueObjects\FailureReason;
+use App\Framework\Queue\ValueObjects\JobPayload;
+use App\Framework\Queue\ValueObjects\QueueName;
+use App\Framework\Ulid\Ulid;
+
+/**
+ * Entity representing a job that failed and was moved to the dead letter queue
+ */
+#[Entity(table: 'dead_letter_jobs')]
+final readonly class DeadLetterJob
+{
+    public function __construct(
+        #[Id]
+        #[Column(name: 'id', type: 'string', length: 26)]
+        public string $id,
+
+        #[Column(name: 'original_job_id', type: 'string', length: 26)]
+        public string $originalJobId,
+
+        #[Column(name: 'dead_letter_queue', type: 'string', length: 100)]
+        public string $deadLetterQueue,
+
+        #[Column(name: 'original_queue', type: 'string', length: 50)]
+        public string $originalQueue,
+
+        #[Column(name: 'job_payload', type: 'text')]
+        public string $jobPayload,
+
+        #[Column(name: 'failure_reason', type: 'text')]
+        public string $failureReason,
+
+        #[Column(name: 'exception_type', type: 'string', length: 255, nullable: true)]
+        public ?string $exceptionType,
+
+        #[Column(name: 'stack_trace', type: 'longtext', nullable: true)]
+        public ?string $stackTrace,
+
+        #[Column(name: 'failed_attempts', type: 'integer')]
+        public int $failedAttempts,
+
+        #[Column(name: 'failed_at', type: 'timestamp')]
+        public string $failedAt,
+
+        #[Column(name: 'moved_to_dlq_at', type: 'timestamp')]
+        public string $movedToDlqAt,
+
+        #[Column(name: 'retry_count', type: 'integer', default: 0)]
+        public int $retryCount = 0,
+
+        #[Column(name: 'last_retry_at', type: 'timestamp', nullable: true)]
+        public ?string $lastRetryAt = null
+    ) {}
+
+    public static function fromFailedJob(
+        JobIndexEntry $failedJob,
+        DeadLetterQueueName $deadLetterQueueName,
+        FailureReason $failureReason
+    ): self {
+        $now = date('Y-m-d H:i:s');
+
+        return new self(
+            id: Ulid::generate(),
+            originalJobId: $failedJob->jobId,
+            deadLetterQueue: $deadLetterQueueName->toString(),
+            originalQueue: $failedJob->queueType,
+            jobPayload: $failedJob->jobPayload,
+            failureReason: $failureReason->getMessage(),
+            exceptionType: $failureReason->getExceptionType(),
+            stackTrace: $failureReason->getStackTrace(),
+            failedAttempts: $failedJob->attempts,
+            failedAt: $failedJob->startedAt ?? $now,
+            movedToDlqAt: $now
+        );
+    }
+
+    public function getDeadLetterQueueName(): DeadLetterQueueName
+    {
+        return DeadLetterQueueName::fromString($this->deadLetterQueue);
+    }
+
+    public function getOriginalQueueName(): QueueName
+    {
+        return QueueName::fromString($this->originalQueue);
+    }
+
+    public function getJobPayload(): JobPayload
+    {
+        return JobPayload::fromSerialized($this->jobPayload);
+    }
+
+    public function getFailureReason(): FailureReason
+    {
+        return new FailureReason(
+            message: $this->failureReason,
+            exceptionType: $this->exceptionType,
+            stackTrace: $this->stackTrace
+        );
+    }
+
+    public function withRetryAttempt(): self
+    {
+        return new self(
+            id: $this->id,
+            originalJobId: $this->originalJobId,
+            deadLetterQueue: $this->deadLetterQueue,
+            originalQueue: $this->originalQueue,
+            jobPayload: $this->jobPayload,
+            failureReason: $this->failureReason,
+            exceptionType: $this->exceptionType,
+            stackTrace: $this->stackTrace,
+            failedAttempts: $this->failedAttempts,
+            failedAt: $this->failedAt,
+            movedToDlqAt: $this->movedToDlqAt,
+            retryCount: $this->retryCount + 1,
+            lastRetryAt: date('Y-m-d H:i:s')
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'original_job_id' => $this->originalJobId,
+            'dead_letter_queue' => $this->deadLetterQueue,
+            'original_queue' => $this->originalQueue,
+            'failure_reason' => $this->failureReason,
+            'exception_type' => $this->exceptionType,
+            'failed_attempts' => $this->failedAttempts,
+            'failed_at' => $this->failedAt,
+            'moved_to_dlq_at' => $this->movedToDlqAt,
+            'retry_count' => $this->retryCount,
+            'last_retry_at' => $this->lastRetryAt
+        ];
+    }
+}

src/Framework/Queue/Entities/JobChainEntry.php

@@ -0,0 +1,200 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Id;
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Queue\ValueObjects\JobChain;
+use App\Framework\Queue\ValueObjects\ChainExecutionMode;
+use App\Framework\Ulid\Ulid;
+
+/**
+ * Entity representing a job chain entry in the database
+ */
+#[Entity(table: 'job_chains')]
+final readonly class JobChainEntry
+{
+    public function __construct(
+        #[Id]
+        #[Column(name: 'id', type: 'string', length: 26)]
+        public string $id,
+
+        #[Column(name: 'chain_id', type: 'string', length: 26)]
+        public string $chainId,
+
+        #[Column(name: 'name', type: 'string', length: 255)]
+        public string $name,
+
+        #[Column(name: 'job_ids', type: 'json')]
+        public string $jobIds,
+
+        #[Column(name: 'execution_mode', type: 'string', length: 20)]
+        public string $executionMode,
+
+        #[Column(name: 'created_at', type: 'timestamp')]
+        public string $createdAt,
+
+        #[Column(name: 'updated_at', type: 'timestamp')]
+        public string $updatedAt,
+
+        #[Column(name: 'stop_on_failure', type: 'boolean', default: true)]
+        public bool $stopOnFailure = true,
+
+        #[Column(name: 'metadata', type: 'json', nullable: true)]
+        public ?string $metadata = null,
+
+        #[Column(name: 'status', type: 'string', length: 20, default: 'pending')]
+        public string $status = 'pending',
+
+        #[Column(name: 'started_at', type: 'timestamp', nullable: true)]
+        public ?string $startedAt = null,
+
+        #[Column(name: 'completed_at', type: 'timestamp', nullable: true)]
+        public ?string $completedAt = null
+    ) {}
+
+    public static function fromJobChain(JobChain $jobChain): self
+    {
+        $now = date('Y-m-d H:i:s');
+
+        return new self(
+            id: Ulid::generate(),
+            chainId: $jobChain->chainId,
+            name: $jobChain->name,
+            jobIds: json_encode($jobChain->jobIds),
+            executionMode: $jobChain->executionMode->value,
+            createdAt: $now,
+            updatedAt: $now,
+            stopOnFailure: $jobChain->stopOnFailure,
+            metadata: $jobChain->metadata ? json_encode($jobChain->metadata) : null,
+            status: 'pending',
+            startedAt: null,
+            completedAt: null
+        );
+    }
+
+    public function getJobChain(): JobChain
+    {
+        $jobIds = json_decode($this->jobIds, true);
+        $metadata = $this->metadata ? json_decode($this->metadata, true) : null;
+
+        return new JobChain(
+            chainId: $this->chainId,
+            name: $this->name,
+            jobIds: $jobIds,
+            executionMode: ChainExecutionMode::from($this->executionMode),
+            stopOnFailure: $this->stopOnFailure,
+            metadata: $metadata
+        );
+    }
+
+    public function getJobIdsArray(): array
+    {
+        return json_decode($this->jobIds, true);
+    }
+
+    public function getMetadataArray(): ?array
+    {
+        return $this->metadata ? json_decode($this->metadata, true) : null;
+    }
+
+    public function getExecutionMode(): ChainExecutionMode
+    {
+        return ChainExecutionMode::from($this->executionMode);
+    }
+
+    public function markAsStarted(): self
+    {
+        return new self(
+            id: $this->id,
+            chainId: $this->chainId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            executionMode: $this->executionMode,
+            createdAt: $this->createdAt,
+            updatedAt: date('Y-m-d H:i:s'),
+            stopOnFailure: $this->stopOnFailure,
+            metadata: $this->metadata,
+            status: 'running',
+            startedAt: date('Y-m-d H:i:s'),
+            completedAt: $this->completedAt
+        );
+    }
+
+    public function markAsCompleted(): self
+    {
+        return new self(
+            id: $this->id,
+            chainId: $this->chainId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            executionMode: $this->executionMode,
+            createdAt: $this->createdAt,
+            updatedAt: date('Y-m-d H:i:s'),
+            stopOnFailure: $this->stopOnFailure,
+            metadata: $this->metadata,
+            status: 'completed',
+            startedAt: $this->startedAt,
+            completedAt: date('Y-m-d H:i:s')
+        );
+    }
+
+    public function markAsFailed(): self
+    {
+        return new self(
+            id: $this->id,
+            chainId: $this->chainId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            executionMode: $this->executionMode,
+            createdAt: $this->createdAt,
+            updatedAt: date('Y-m-d H:i:s'),
+            stopOnFailure: $this->stopOnFailure,
+            metadata: $this->metadata,
+            status: 'failed',
+            startedAt: $this->startedAt,
+            completedAt: date('Y-m-d H:i:s')
+        );
+    }
+
+    public function isPending(): bool
+    {
+        return $this->status === 'pending';
+    }
+
+    public function isRunning(): bool
+    {
+        return $this->status === 'running';
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->status === 'completed';
+    }
+
+    public function isFailed(): bool
+    {
+        return $this->status === 'failed';
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'chain_id' => $this->chainId,
+            'name' => $this->name,
+            'job_ids' => $this->getJobIdsArray(),
+            'execution_mode' => $this->executionMode,
+            'stop_on_failure' => $this->stopOnFailure,
+            'metadata' => $this->getMetadataArray(),
+            'status' => $this->status,
+            'started_at' => $this->startedAt,
+            'completed_at' => $this->completedAt,
+            'created_at' => $this->createdAt,
+            'updated_at' => $this->updatedAt
+        ];
+    }
+}

src/Framework/Queue/Entities/JobDependencyEntry.php

@@ -0,0 +1,121 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Id;
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Queue\ValueObjects\JobDependency;
+use App\Framework\Queue\ValueObjects\DependencyType;
+use App\Framework\Ulid\Ulid;
+
+/**
+ * Entity representing a job dependency entry in the database
+ */
+#[Entity(table: 'job_dependencies')]
+final readonly class JobDependencyEntry
+{
+    public function __construct(
+        #[Id]
+        #[Column(name: 'id', type: 'string', length: 26)]
+        public string $id,
+
+        #[Column(name: 'dependent_job_id', type: 'string', length: 26)]
+        public string $dependentJobId,
+
+        #[Column(name: 'depends_on_job_id', type: 'string', length: 26)]
+        public string $dependsOnJobId,
+
+        #[Column(name: 'dependency_type', type: 'string', length: 20)]
+        public string $dependencyType,
+
+        #[Column(name: 'created_at', type: 'timestamp')]
+        public string $createdAt,
+
+        #[Column(name: 'updated_at', type: 'timestamp')]
+        public string $updatedAt,
+
+        #[Column(name: 'condition_expression', type: 'text', nullable: true)]
+        public ?string $conditionExpression = null,
+
+        #[Column(name: 'is_satisfied', type: 'boolean', default: false)]
+        public bool $isSatisfied = false,
+
+        #[Column(name: 'satisfied_at', type: 'timestamp', nullable: true)]
+        public ?string $satisfiedAt = null
+    ) {}
+
+    public static function fromJobDependency(JobDependency $dependency): self
+    {
+        $now = date('Y-m-d H:i:s');
+
+        return new self(
+            id: Ulid::generate(),
+            dependentJobId: $dependency->dependentJobId,
+            dependsOnJobId: $dependency->dependsOnJobId,
+            dependencyType: $dependency->type->value,
+            createdAt: $now,
+            updatedAt: $now,
+            conditionExpression: $dependency->condition,
+            isSatisfied: false,
+            satisfiedAt: null
+        );
+    }
+
+    public function getJobDependency(): JobDependency
+    {
+        return new JobDependency(
+            dependentJobId: $this->dependentJobId,
+            dependsOnJobId: $this->dependsOnJobId,
+            type: DependencyType::from($this->dependencyType),
+            condition: $this->conditionExpression
+        );
+    }
+
+    public function markAsSatisfied(): self
+    {
+        return new self(
+            id: $this->id,
+            dependentJobId: $this->dependentJobId,
+            dependsOnJobId: $this->dependsOnJobId,
+            dependencyType: $this->dependencyType,
+            createdAt: $this->createdAt,
+            updatedAt: date('Y-m-d H:i:s'),
+            conditionExpression: $this->conditionExpression,
+            isSatisfied: true,
+            satisfiedAt: date('Y-m-d H:i:s')
+        );
+    }
+
+    public function getDependencyType(): DependencyType
+    {
+        return DependencyType::from($this->dependencyType);
+    }
+
+    public function isConditional(): bool
+    {
+        return $this->getDependencyType()->isConditional();
+    }
+
+    public function requiresSuccess(): bool
+    {
+        return $this->getDependencyType()->requiresSuccessfulCompletion();
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'dependent_job_id' => $this->dependentJobId,
+            'depends_on_job_id' => $this->dependsOnJobId,
+            'dependency_type' => $this->dependencyType,
+            'condition_expression' => $this->conditionExpression,
+            'is_satisfied' => $this->isSatisfied,
+            'satisfied_at' => $this->satisfiedAt,
+            'created_at' => $this->createdAt,
+            'updated_at' => $this->updatedAt
+        ];
+    }
+}

src/Framework/Queue/Entities/JobHistoryEntry.php

@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Queue\ValueObjects\JobId;
+use App\Framework\Queue\ValueObjects\JobStatus;
+use App\Framework\Core\ValueObjects\Timestamp;
+
+/**
+ * Job History Entry Entity
+ *
+ * Database entity for job status change audit trail
+ */
+#[Entity(tableName: 'job_history', idColumn: 'id')]
+final readonly class JobHistoryEntry
+{
+    public function __construct(
+        #[Column(name: 'id', primary: true, autoIncrement: true)]
+        public ?int $id,
+
+        #[Column(name: 'job_id')]
+        public JobId $jobId,
+
+        #[Column(name: 'old_status')]
+        public ?JobStatus $oldStatus,
+
+        #[Column(name: 'new_status')]
+        public JobStatus $newStatus,
+
+        #[Column(name: 'error_message')]
+        public ?string $errorMessage,
+
+        #[Column(name: 'changed_at')]
+        public Timestamp $changedAt,
+
+        #[Column(name: 'metadata')]
+        public ?string $metadata = null
+    ) {}
+
+    /**
+     * Create status change entry
+     */
+    public static function forStatusChange(
+        JobId $jobId,
+        ?JobStatus $oldStatus,
+        JobStatus $newStatus,
+        ?string $errorMessage = null,
+        array $metadata = []
+    ): self {
+        return new self(
+            id: null,
+            jobId: $jobId,
+            oldStatus: $oldStatus,
+            newStatus: $newStatus,
+            errorMessage: $errorMessage,
+            changedAt: Timestamp::now(),
+            metadata: !empty($metadata) ? json_encode($metadata) : null
+        );
+    }
+
+    /**
+     * Get metadata as array
+     */
+    public function getMetadataAsArray(): array
+    {
+        if ($this->metadata === null) {
+            return [];
+        }
+
+        $decoded = json_decode($this->metadata, true);
+        return is_array($decoded) ? $decoded : [];
+    }
+
+    /**
+     * Convert to array for storage/serialization
+     */
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'job_id' => $this->jobId->toString(),
+            'old_status' => $this->oldStatus?->value,
+            'new_status' => $this->newStatus->value,
+            'error_message' => $this->errorMessage,
+            'changed_at' => $this->changedAt->toFloat(),
+            'metadata' => $this->metadata
+        ];
+    }
+}

src/Framework/Queue/Entities/JobIndexEntry.php

@@ -0,0 +1,173 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Queue\ValueObjects\JobId;
+use App\Framework\Queue\ValueObjects\JobStatus;
+use App\Framework\Queue\ValueObjects\JobState;
+use App\Framework\Queue\ValueObjects\QueueType;
+use App\Framework\Queue\ValueObjects\QueuePriority;
+use App\Framework\Core\ValueObjects\Timestamp;
+
+/**
+ * Job Index Entry Entity
+ *
+ * Database entity for efficient job querying and indexing
+ */
+#[Entity(tableName: 'job_index', idColumn: 'job_id')]
+final readonly class JobIndexEntry
+{
+    public function __construct(
+        #[Column(name: 'job_id', primary: true)]
+        public JobId $jobId,
+
+        #[Column(name: 'status')]
+        public JobStatus $status,
+
+        #[Column(name: 'queue_type')]
+        public QueueType $queueType,
+
+        #[Column(name: 'priority')]
+        public QueuePriority $priority,
+
+        #[Column(name: 'attempts')]
+        public int $attempts,
+
+        #[Column(name: 'max_attempts')]
+        public int $maxAttempts,
+
+        #[Column(name: 'created_at')]
+        public Timestamp $createdAt,
+
+        #[Column(name: 'updated_at')]
+        public Timestamp $updatedAt,
+
+        #[Column(name: 'started_at')]
+        public ?Timestamp $startedAt = null,
+
+        #[Column(name: 'completed_at')]
+        public ?Timestamp $completedAt = null,
+
+        #[Column(name: 'scheduled_for')]
+        public ?Timestamp $scheduledFor = null,
+
+        #[Column(name: 'error_message')]
+        public ?string $errorMessage = null
+    ) {}
+
+    /**
+     * Create from JobState
+     */
+    public static function fromJobState(JobState $jobState): self
+    {
+        return new self(
+            jobId: $jobState->jobId,
+            status: $jobState->status,
+            queueType: $jobState->queueType,
+            priority: $jobState->priority,
+            attempts: $jobState->attempts,
+            maxAttempts: $jobState->maxAttempts,
+            createdAt: $jobState->createdAt,
+            updatedAt: $jobState->completedAt ?? $jobState->startedAt ?? $jobState->createdAt,
+            startedAt: $jobState->startedAt,
+            completedAt: $jobState->completedAt,
+            scheduledFor: null, // TODO: Add scheduled jobs support
+            errorMessage: $jobState->errorMessage
+        );
+    }
+
+    /**
+     * Update with new job state
+     */
+    public function updateFromJobState(JobState $jobState): self
+    {
+        return new self(
+            jobId: $this->jobId,
+            status: $jobState->status,
+            queueType: $this->queueType,
+            priority: $this->priority,
+            attempts: $jobState->attempts,
+            maxAttempts: $this->maxAttempts,
+            createdAt: $this->createdAt,
+            updatedAt: Timestamp::now(),
+            startedAt: $jobState->startedAt ?? $this->startedAt,
+            completedAt: $jobState->completedAt ?? $this->completedAt,
+            scheduledFor: $this->scheduledFor,
+            errorMessage: $jobState->errorMessage ?? $this->errorMessage
+        );
+    }
+
+    /**
+     * Check if job can be retried
+     */
+    public function canRetry(): bool
+    {
+        return $this->attempts < $this->maxAttempts &&
+               ($this->status === JobStatus::FAILED || $this->status === JobStatus::RETRYING);
+    }
+
+    /**
+     * Check if job is in final state
+     */
+    public function isFinalState(): bool
+    {
+        return $this->status->isFinal();
+    }
+
+    /**
+     * Check if job is active
+     */
+    public function isActive(): bool
+    {
+        return $this->status->isActive();
+    }
+
+    /**
+     * Get job age in seconds
+     */
+    public function getAgeInSeconds(): int
+    {
+        return (int) (Timestamp::now()->toFloat() - $this->createdAt->toFloat());
+    }
+
+    /**
+     * Check if job needs retry based on backoff strategy
+     */
+    public function needsRetry(): bool
+    {
+        if (!$this->canRetry()) {
+            return false;
+        }
+
+        // Exponential backoff: 2^attempts minutes
+        $backoffMinutes = pow(2, $this->attempts);
+        $nextRetryTime = $this->updatedAt->toFloat() + ($backoffMinutes * 60);
+
+        return Timestamp::now()->toFloat() >= $nextRetryTime;
+    }
+
+    /**
+     * Convert to array for storage/serialization
+     */
+    public function toArray(): array
+    {
+        return [
+            'job_id' => $this->jobId->toString(),
+            'status' => $this->status->value,
+            'queue_type' => $this->queueType->value,
+            'priority' => $this->priority->value,
+            'attempts' => $this->attempts,
+            'max_attempts' => $this->maxAttempts,
+            'created_at' => $this->createdAt->toFloat(),
+            'updated_at' => $this->updatedAt->toFloat(),
+            'started_at' => $this->startedAt?->toFloat(),
+            'completed_at' => $this->completedAt?->toFloat(),
+            'scheduled_for' => $this->scheduledFor?->toFloat(),
+            'error_message' => $this->errorMessage
+        ];
+    }
+}

src/Framework/Queue/Entities/JobMetricsEntry.php

@@ -0,0 +1,184 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Id;
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Queue\ValueObjects\JobMetrics;
+use App\Framework\Ulid\Ulid;
+
+#[Entity(table: 'job_metrics')]
+final readonly class JobMetricsEntry
+{
+    public function __construct(
+        #[Id]
+        #[Column(name: 'id', type: 'string', length: 26)]
+        public string $id,
+
+        #[Column(name: 'job_id', type: 'string', length: 26)]
+        public string $jobId,
+
+        #[Column(name: 'queue_name', type: 'string', length: 100)]
+        public string $queueName,
+
+        #[Column(name: 'status', type: 'string', length: 20)]
+        public string $status,
+
+        #[Column(name: 'attempts', type: 'integer')]
+        public int $attempts,
+
+        #[Column(name: 'max_attempts', type: 'integer')]
+        public int $maxAttempts,
+
+        #[Column(name: 'execution_time_ms', type: 'float')]
+        public float $executionTimeMs,
+
+        #[Column(name: 'memory_usage_bytes', type: 'integer')]
+        public int $memoryUsageBytes,
+
+        #[Column(name: 'created_at', type: 'timestamp')]
+        public string $createdAt,
+
+        #[Column(name: 'updated_at', type: 'timestamp')]
+        public string $updatedAt,
+
+        #[Column(name: 'error_message', type: 'text', nullable: true)]
+        public ?string $errorMessage = null,
+
+        #[Column(name: 'started_at', type: 'timestamp', nullable: true)]
+        public ?string $startedAt = null,
+
+        #[Column(name: 'completed_at', type: 'timestamp', nullable: true)]
+        public ?string $completedAt = null,
+
+        #[Column(name: 'failed_at', type: 'timestamp', nullable: true)]
+        public ?string $failedAt = null,
+
+        #[Column(name: 'metadata', type: 'json', nullable: true)]
+        public ?string $metadata = null
+    ) {}
+
+    public static function fromJobMetrics(JobMetrics $metrics): self
+    {
+        $now = date('Y-m-d H:i:s');
+
+        return new self(
+            id: Ulid::generate(),
+            jobId: $metrics->jobId,
+            queueName: $metrics->queueName,
+            status: $metrics->status,
+            attempts: $metrics->attempts,
+            maxAttempts: $metrics->maxAttempts,
+            executionTimeMs: $metrics->executionTimeMs,
+            memoryUsageBytes: $metrics->memoryUsageBytes,
+            createdAt: $metrics->createdAt,
+            updatedAt: $now,
+            errorMessage: $metrics->errorMessage,
+            startedAt: $metrics->startedAt,
+            completedAt: $metrics->completedAt,
+            failedAt: $metrics->failedAt,
+            metadata: !empty($metrics->metadata) ? json_encode($metrics->metadata) : null
+        );
+    }
+
+    public function getJobMetrics(): JobMetrics
+    {
+        return new JobMetrics(
+            jobId: $this->jobId,
+            queueName: $this->queueName,
+            status: $this->status,
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            executionTimeMs: $this->executionTimeMs,
+            memoryUsageBytes: $this->memoryUsageBytes,
+            errorMessage: $this->errorMessage,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            failedAt: $this->failedAt,
+            metadata: $this->metadata ? json_decode($this->metadata, true) : []
+        );
+    }
+
+    public function updateWithMetrics(JobMetrics $metrics): self
+    {
+        return new self(
+            id: $this->id,
+            jobId: $this->jobId,
+            queueName: $this->queueName,
+            status: $metrics->status,
+            attempts: $metrics->attempts,
+            maxAttempts: $metrics->maxAttempts,
+            executionTimeMs: $metrics->executionTimeMs,
+            memoryUsageBytes: $metrics->memoryUsageBytes,
+            createdAt: $this->createdAt,
+            updatedAt: date('Y-m-d H:i:s'),
+            errorMessage: $metrics->errorMessage,
+            startedAt: $metrics->startedAt,
+            completedAt: $metrics->completedAt,
+            failedAt: $metrics->failedAt,
+            metadata: !empty($metrics->metadata) ? json_encode($metrics->metadata) : $this->metadata
+        );
+    }
+
+    public function getMetadataArray(): ?array
+    {
+        return $this->metadata ? json_decode($this->metadata, true) : null;
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->status === 'completed';
+    }
+
+    public function isFailed(): bool
+    {
+        return $this->status === 'failed';
+    }
+
+    public function isRunning(): bool
+    {
+        return $this->status === 'running';
+    }
+
+    public function isPending(): bool
+    {
+        return $this->status === 'pending';
+    }
+
+    public function getExecutionTimeSeconds(): float
+    {
+        return $this->executionTimeMs / 1000.0;
+    }
+
+    public function getMemoryUsageMB(): float
+    {
+        return $this->memoryUsageBytes / (1024 * 1024);
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'job_id' => $this->jobId,
+            'queue_name' => $this->queueName,
+            'status' => $this->status,
+            'attempts' => $this->attempts,
+            'max_attempts' => $this->maxAttempts,
+            'execution_time_ms' => $this->executionTimeMs,
+            'execution_time_seconds' => $this->getExecutionTimeSeconds(),
+            'memory_usage_bytes' => $this->memoryUsageBytes,
+            'memory_usage_mb' => $this->getMemoryUsageMB(),
+            'error_message' => $this->errorMessage,
+            'created_at' => $this->createdAt,
+            'updated_at' => $this->updatedAt,
+            'started_at' => $this->startedAt,
+            'completed_at' => $this->completedAt,
+            'failed_at' => $this->failedAt,
+            'metadata' => $this->getMetadataArray()
+        ];
+    }
+}

src/Framework/Queue/Entities/JobProgressEntry.php

@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Id;
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Queue\ValueObjects\JobProgress;
+use App\Framework\Core\ValueObjects\Percentage;
+use App\Framework\Ulid\Ulid;
+
+/**
+ * Entity representing a job progress tracking entry
+ */
+#[Entity(table: 'job_progress')]
+final readonly class JobProgressEntry
+{
+    public function __construct(
+        #[Id]
+        #[Column(name: 'id', type: 'string', length: 26)]
+        public string $id,
+
+        #[Column(name: 'job_id', type: 'string', length: 26)]
+        public string $jobId,
+
+        #[Column(name: 'percentage', type: 'decimal', precision: 5, scale: 2)]
+        public float $percentage,
+
+        #[Column(name: 'message', type: 'text')]
+        public string $message,
+
+        #[Column(name: 'step_name', type: 'string', length: 100, nullable: true)]
+        public ?string $stepName,
+
+        #[Column(name: 'metadata', type: 'json', nullable: true)]
+        public ?string $metadata,
+
+        #[Column(name: 'updated_at', type: 'timestamp')]
+        public string $updatedAt,
+
+        #[Column(name: 'is_completed', type: 'boolean', default: false)]
+        public bool $isCompleted = false,
+
+        #[Column(name: 'is_failed', type: 'boolean', default: false)]
+        public bool $isFailed = false
+    ) {}
+
+    public static function fromJobProgress(string $jobId, JobProgress $progress, ?string $stepName = null): self
+    {
+        return new self(
+            id: Ulid::generate(),
+            jobId: $jobId,
+            percentage: $progress->percentage->getValue(),
+            message: $progress->message,
+            stepName: $stepName,
+            metadata: $progress->metadata ? json_encode($progress->metadata) : null,
+            updatedAt: date('Y-m-d H:i:s'),
+            isCompleted: $progress->isCompleted(),
+            isFailed: $progress->isFailed()
+        );
+    }
+
+    public function getJobProgress(): JobProgress
+    {
+        $metadata = $this->metadata ? json_decode($this->metadata, true) : null;
+
+        // Add status to metadata if failed
+        if ($this->isFailed && $metadata) {
+            $metadata['status'] = 'failed';
+        }
+
+        return new JobProgress(
+            percentage: Percentage::from($this->percentage),
+            message: $this->message,
+            metadata: $metadata
+        );
+    }
+
+    public function getPercentage(): Percentage
+    {
+        return Percentage::from($this->percentage);
+    }
+
+    public function getMetadataArray(): ?array
+    {
+        return $this->metadata ? json_decode($this->metadata, true) : null;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'job_id' => $this->jobId,
+            'percentage' => $this->percentage,
+            'percentage_formatted' => $this->getPercentage()->format(),
+            'message' => $this->message,
+            'step_name' => $this->stepName,
+            'metadata' => $this->getMetadataArray(),
+            'updated_at' => $this->updatedAt,
+            'is_completed' => $this->isCompleted,
+            'is_failed' => $this->isFailed
+        ];
+    }
+}

src/Framework/Queue/Entities/Worker.php

@@ -0,0 +1,277 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Entities;
+
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Queue\ValueObjects\QueueName;
+use App\Framework\Core\ValueObjects\Percentage;
+use App\Framework\Core\ValueObjects\Byte;
+
+/**
+ * Worker Entity für Distributed Job Processing
+ */
+final readonly class Worker
+{
+    public function __construct(
+        public WorkerId $id,
+        public string $hostname,
+        public int $processId,
+        public array $queues, // Array of QueueName objects
+        public int $maxJobs,
+        public \DateTimeImmutable $registeredAt,
+        public ?\DateTimeImmutable $lastHeartbeat = null,
+        public bool $isActive = true,
+        public Percentage $cpuUsage = new Percentage(0),
+        public Byte $memoryUsage = new Byte(0),
+        public int $currentJobs = 0,
+        public array $capabilities = [],
+        public string $version = '1.0.0'
+    ) {
+        if (empty($this->queues)) {
+            throw new \InvalidArgumentException('Worker must handle at least one queue');
+        }
+
+        if ($this->maxJobs <= 0) {
+            throw new \InvalidArgumentException('Max jobs must be greater than 0');
+        }
+
+        if ($this->currentJobs < 0) {
+            throw new \InvalidArgumentException('Current jobs cannot be negative');
+        }
+
+        if ($this->currentJobs > $this->maxJobs) {
+            throw new \InvalidArgumentException('Current jobs cannot exceed max jobs');
+        }
+    }
+
+    /**
+     * Erstelle einen neuen Worker
+     */
+    public static function register(
+        string $hostname,
+        int $processId,
+        array $queues,
+        int $maxJobs = 10,
+        array $capabilities = []
+    ): self {
+        return new self(
+            id: WorkerId::forHost($hostname, $processId),
+            hostname: $hostname,
+            processId: $processId,
+            queues: $queues,
+            maxJobs: $maxJobs,
+            registeredAt: new \DateTimeImmutable(),
+            lastHeartbeat: new \DateTimeImmutable(),
+            isActive: true,
+            capabilities: $capabilities
+        );
+    }
+
+    /**
+     * Worker Heartbeat aktualisieren
+     */
+    public function updateHeartbeat(
+        Percentage $cpuUsage,
+        Byte $memoryUsage,
+        int $currentJobs
+    ): self {
+        return new self(
+            id: $this->id,
+            hostname: $this->hostname,
+            processId: $this->processId,
+            queues: $this->queues,
+            maxJobs: $this->maxJobs,
+            registeredAt: $this->registeredAt,
+            lastHeartbeat: new \DateTimeImmutable(),
+            isActive: true,
+            cpuUsage: $cpuUsage,
+            memoryUsage: $memoryUsage,
+            currentJobs: $currentJobs,
+            capabilities: $this->capabilities,
+            version: $this->version
+        );
+    }
+
+    /**
+     * Worker als inaktiv markieren
+     */
+    public function markInactive(): self
+    {
+        return new self(
+            id: $this->id,
+            hostname: $this->hostname,
+            processId: $this->processId,
+            queues: $this->queues,
+            maxJobs: $this->maxJobs,
+            registeredAt: $this->registeredAt,
+            lastHeartbeat: $this->lastHeartbeat,
+            isActive: false,
+            cpuUsage: $this->cpuUsage,
+            memoryUsage: $this->memoryUsage,
+            currentJobs: $this->currentJobs,
+            capabilities: $this->capabilities,
+            version: $this->version
+        );
+    }
+
+    /**
+     * Prüfe ob Worker verfügbar für neue Jobs ist
+     */
+    public function isAvailableForJobs(): bool
+    {
+        return $this->isActive
+            && $this->currentJobs < $this->maxJobs
+            && $this->isHealthy();
+    }
+
+    /**
+     * Prüfe ob Worker eine bestimmte Queue unterstützt
+     */
+    public function handlesQueue(QueueName $queueName): bool
+    {
+        foreach ($this->queues as $queue) {
+            if ($queue instanceof QueueName && $queue->equals($queueName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Prüfe ob Worker healthy ist
+     */
+    public function isHealthy(): bool
+    {
+        if (!$this->isActive) {
+            return false;
+        }
+
+        // Heartbeat nicht älter als 60 Sekunden
+        if ($this->lastHeartbeat === null) {
+            return false;
+        }
+
+        $heartbeatAge = time() - $this->lastHeartbeat->getTimestamp();
+        if ($heartbeatAge > 60) {
+            return false;
+        }
+
+        // CPU und Memory Limits
+        if ($this->cpuUsage->getValue() > 90) {
+            return false;
+        }
+
+        // Memory Limit (2GB)
+        if ($this->memoryUsage->toBytes() > 2 * 1024 * 1024 * 1024) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Berechne Worker Load (0-100%)
+     */
+    public function getLoadPercentage(): Percentage
+    {
+        if ($this->maxJobs === 0) {
+            return new Percentage(100);
+        }
+
+        $jobLoad = ($this->currentJobs / $this->maxJobs) * 100;
+        $cpuLoad = $this->cpuUsage->getValue();
+
+        // Höchste Last zählt
+        return new Percentage(max($jobLoad, $cpuLoad));
+    }
+
+    /**
+     * Prüfe ob Worker eine Capability hat
+     */
+    public function hasCapability(string $capability): bool
+    {
+        return in_array($capability, $this->capabilities, true);
+    }
+
+    /**
+     * Worker Informationen für Monitoring
+     */
+    public function toMonitoringArray(): array
+    {
+        return [
+            'id' => $this->id->toString(),
+            'hostname' => $this->hostname,
+            'process_id' => $this->processId,
+            'queues' => array_map(fn(QueueName $queue) => $queue->toString(), $this->queues),
+            'max_jobs' => $this->maxJobs,
+            'current_jobs' => $this->currentJobs,
+            'is_active' => $this->isActive,
+            'is_healthy' => $this->isHealthy(),
+            'is_available' => $this->isAvailableForJobs(),
+            'load_percentage' => $this->getLoadPercentage()->getValue(),
+            'cpu_usage' => $this->cpuUsage->getValue(),
+            'memory_usage_mb' => round($this->memoryUsage->toBytes() / 1024 / 1024, 2),
+            'registered_at' => $this->registeredAt->format('Y-m-d H:i:s'),
+            'last_heartbeat' => $this->lastHeartbeat?->format('Y-m-d H:i:s'),
+            'capabilities' => $this->capabilities,
+            'version' => $this->version
+        ];
+    }
+
+    /**
+     * Array Repräsentation für Persistierung
+     */
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id->toString(),
+            'hostname' => $this->hostname,
+            'process_id' => $this->processId,
+            'queues' => json_encode(array_map(fn(QueueName $queue) => $queue->toString(), $this->queues)),
+            'max_jobs' => $this->maxJobs,
+            'current_jobs' => $this->currentJobs,
+            'is_active' => $this->isActive,
+            'cpu_usage' => $this->cpuUsage->getValue(),
+            'memory_usage_bytes' => $this->memoryUsage->toBytes(),
+            'registered_at' => $this->registeredAt->format('Y-m-d H:i:s'),
+            'last_heartbeat' => $this->lastHeartbeat?->format('Y-m-d H:i:s'),
+            'capabilities' => json_encode($this->capabilities),
+            'version' => $this->version
+        ];
+    }
+
+    /**
+     * Worker aus Array erstellen
+     */
+    public static function fromArray(array $data): self
+    {
+        $queueStrings = json_decode($data['queues'], true);
+        $queues = array_map(function(string $queueString) {
+            // Parse queue string zurück zu QueueName
+            // Annahme: Format ist "type.name" oder "tenant.type.name"
+            $parts = explode('.', $queueString);
+            if (count($parts) >= 2) {
+                return QueueName::default(); // Vereinfacht - könnte erweitert werden
+            }
+            return QueueName::default();
+        }, $queueStrings);
+
+        return new self(
+            id: WorkerId::fromString($data['id']),
+            hostname: $data['hostname'],
+            processId: $data['process_id'],
+            queues: $queues,
+            maxJobs: $data['max_jobs'],
+            registeredAt: new \DateTimeImmutable($data['registered_at']),
+            lastHeartbeat: $data['last_heartbeat'] ? new \DateTimeImmutable($data['last_heartbeat']) : null,
+            isActive: (bool) $data['is_active'],
+            cpuUsage: new Percentage($data['cpu_usage'] ?? 0),
+            memoryUsage: Byte::fromBytes($data['memory_usage_bytes'] ?? 0),
+            currentJobs: $data['current_jobs'] ?? 0,
+            capabilities: json_decode($data['capabilities'] ?? '[]', true),
+            version: $data['version'] ?? '1.0.0'
+        );
+    }
+}

src/Framework/Queue/Events/JobChainCompletedEvent.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Events;
+
+use App\Framework\Core\ValueObjects\Timestamp;
+
+final readonly class JobChainCompletedEvent
+{
+    public Timestamp $timestamp;
+
+    public function __construct(
+        public string $chainId,
+        public string $name,
+        public string $completedAt,
+        ?Timestamp $timestamp = null
+    ) {
+        $this->timestamp = $timestamp ?? Timestamp::now();
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'event_type' => 'job_chain_completed',
+            'chain_id' => $this->chainId,
+            'name' => $this->name,
+            'completed_at' => $this->completedAt,
+            'timestamp' => $this->timestamp->toFloat()
+        ];
+    }
+}

src/Framework/Queue/Events/JobChainFailedEvent.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Events;
+
+use App\Framework\Core\ValueObjects\Timestamp;
+
+final readonly class JobChainFailedEvent
+{
+    public Timestamp $timestamp;
+
+    public function __construct(
+        public string $chainId,
+        public string $name,
+        public string $failedJobId,
+        public string $failedAt,
+        ?Timestamp $timestamp = null
+    ) {
+        $this->timestamp = $timestamp ?? Timestamp::now();
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'event_type' => 'job_chain_failed',
+            'chain_id' => $this->chainId,
+            'name' => $this->name,
+            'failed_job_id' => $this->failedJobId,
+            'failed_at' => $this->failedAt,
+            'timestamp' => $this->timestamp->toFloat()
+        ];
+    }
+}

src/Framework/Queue/Events/JobChainStartedEvent.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Events;
+
+use App\Framework\Queue\ValueObjects\ChainExecutionMode;
+use App\Framework\Core\ValueObjects\Timestamp;
+
+final readonly class JobChainStartedEvent
+{
+    public Timestamp $timestamp;
+
+    public function __construct(
+        public string $chainId,
+        public string $name,
+        public ChainExecutionMode $executionMode,
+        public array $jobIds,
+        ?Timestamp $timestamp = null
+    ) {
+        $this->timestamp = $timestamp ?? Timestamp::now();
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'event_type' => 'job_chain_started',
+            'chain_id' => $this->chainId,
+            'name' => $this->name,
+            'execution_mode' => $this->executionMode->value,
+            'job_ids' => $this->jobIds,
+            'job_count' => count($this->jobIds),
+            'timestamp' => $this->timestamp->toFloat()
+        ];
+    }
+}

src/Framework/Queue/Exceptions/InvalidDeadLetterQueueNameException.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+use App\Framework\Exception\ErrorCode;
+
+final class InvalidDeadLetterQueueNameException extends FrameworkException
+{
+    public static function tooShort(string $name, int $minLength): self
+    {
+        return self::create(
+            ErrorCode::VAL_BUSINESS_RULE_VIOLATION,
+            "Dead letter queue name '{$name}' is too short. Minimum length is {$minLength} characters."
+        )->withData([
+            'name' => $name,
+            'actual_length' => strlen($name),
+            'min_length' => $minLength
+        ]);
+    }
+
+    public static function tooLong(string $name, int $maxLength): self
+    {
+        return self::create(
+            ErrorCode::VAL_BUSINESS_RULE_VIOLATION,
+            "Dead letter queue name '{$name}' is too long. Maximum length is {$maxLength} characters."
+        )->withData([
+            'name' => $name,
+            'actual_length' => strlen($name),
+            'max_length' => $maxLength
+        ]);
+    }
+
+    public static function invalidFormat(string $name, string $pattern): self
+    {
+        return self::create(
+            ErrorCode::VAL_BUSINESS_RULE_VIOLATION,
+            "Dead letter queue name '{$name}' contains invalid characters. Only alphanumeric characters, underscores, hyphens, and dots are allowed."
+        )->withData([
+            'name' => $name,
+            'valid_pattern' => $pattern
+        ]);
+    }
+}

src/Framework/Queue/FileQueue.php

@@ -4,30 +4,60 @@ declare(strict_types=1);
 
 namespace App\Framework\Queue;
 
+use App\Framework\Queue\ValueObjects\JobPayload;
+use App\Framework\Queue\ValueObjects\QueuePriority;
+use App\Framework\Filesystem\FileStorage;
+use App\Framework\Filesystem\FilePath;
+use App\Framework\Filesystem\Directory;
+use App\Framework\Filesystem\FilesystemFactory;
+use App\Framework\Serializer\Php\PhpSerializer;
+use App\Framework\Serializer\Php\PhpSerializerConfig;
+use App\Framework\Serializer\Serializer;
 use App\Framework\Logging\DefaultLogger;
 use App\Framework\Logging\Logger;
 use App\Framework\Logging\LogLevel;
 use App\Framework\Logging\ProcessorManager;
-use App\Framework\Serializer\Php\PhpSerializer;
-use App\Framework\Serializer\Serializer;
+use App\Framework\Logging\ValueObjects\LogContext;
 
+/**
+ * File-based Queue Implementation with Priority Support
+ *
+ * Uses filesystem directory structure for priority-based organization:
+ * - queue/priority/ - Priority-based jobs sorted by score
+ * - queue/delayed/ - Delayed jobs scheduled for future processing
+ */
 final readonly class FileQueue implements Queue
 {
-    private string $queueDir;
-
+    private Directory $queueDirectory;
+    private Directory $priorityDirectory;
+    private Directory $delayedDirectory;
+    private FileStorage $storage;
     private Logger $logger;
+    private Serializer $serializer;
 
     public function __construct(
-        string $queueDir,
-        private Serializer $serializer = new PhpSerializer(),
+        private string $queuePath,
+        ?Serializer $serializer = null,
+        ?FileStorage $storage = null,
         ?Logger $logger = null
     ) {
-        $this->queueDir = $queueDir;
-        if (! is_dir($queueDir)) {
-            mkdir($queueDir, 0777, true);
-        }
+        $this->serializer = $serializer ?? new PhpSerializer(PhpSerializerConfig::unsafe());
+        $this->storage = $storage ?? new FileStorage();
+
+        // Initialize directories using simple approach
+        $priorityPath = $queuePath . '/priority';
+        $delayedPath = $queuePath . '/delayed';
+
+        // Create directories directly using storage
+        $this->storage->createDirectory($queuePath);
+        $this->storage->createDirectory($priorityPath);
+        $this->storage->createDirectory($delayedPath);
+
+        // Create directory objects for easier path handling
+        $this->queueDirectory = new Directory($queuePath, $this->storage);
+        $this->priorityDirectory = new Directory($priorityPath, $this->storage);
+        $this->delayedDirectory = new Directory($delayedPath, $this->storage);
 
-        // Use provided logger or create a null logger for production
         $this->logger = $logger ?? new DefaultLogger(
             minLevel: LogLevel::WARNING,
             handlers: [],
@@ -35,105 +65,333 @@ final readonly class FileQueue implements Queue
         );
     }
 
-    public function push(object $job): void
+    public function push(JobPayload $payload): void
     {
-        // Job-Hash für Deduplication
-        $jobHash = md5($this->serializer->serialize($job));
-        $hashFile = $this->queueDir . '/hash_' . $jobHash . '.job';
+        $currentTime = time();
 
-        // Debug logging removed for production
-
-        // Prüfe ob identischer Job bereits existiert
-        if (file_exists($hashFile)) {
-            // Silent deduplication - no logging needed in production
-            return; // Job wird nicht hinzugefügt
+        // Handle delayed jobs
+        if ($payload->isDelayed()) {
+            $this->pushDelayedJob($payload);
+        } else {
+            $this->pushPriorityJob($payload, $currentTime);
         }
-
-        // Verwende Hash als Dateiname für automatische Deduplication
-        file_put_contents($hashFile, $this->serializer->serialize($job));
-        // No logging for successful job addition in production
     }
 
-    public function pop(): ?object
+    public function pop(): ?JobPayload
     {
-        $files = glob($this->queueDir . '/*.job');
+        // First, process any delayed jobs that are now ready
+        $this->processDelayedJobs();
 
-        // Queue-Status - no logging in production
+        // Pop highest priority job
+        return $this->popPriorityJob();
+    }
+
+    public function peek(): ?JobPayload
+    {
+        // Process delayed jobs first
+        $this->processDelayedJobs();
+
+        // Peek at highest priority job
+        $files = $this->getPriorityJobFiles();
         if (empty($files)) {
             return null;
         }
 
-        // No debug logging for job discovery in production
+        $firstFile = reset($files);
+        $filePath = $this->priorityDirectory->getPathString() . '/' . $firstFile->filename;
+        $content = $this->storage->get($filePath);
 
-        // Sortiere nach Erstellungsdatum (FIFO)
-        usort($files, function ($a, $b) {
-            return filemtime($a) <=> filemtime($b);
-        });
+        return $this->serializer->deserialize($content);
+    }
 
-        $file = $files[0];
-        $lockFile = $file . '.lock';
+    public function size(): int
+    {
+        $priorityCount = count($this->getPriorityJobFiles());
+        $delayedCount = count($this->getDelayedJobFiles());
 
-        // Atomic Lock-Mechanismus um race conditions zu verhindern
-        if (file_exists($lockFile)) {
-            // Silent handling of locked files - normal operation
-            return null; // Job wird bereits verarbeitet
+        return $priorityCount + $delayedCount;
+    }
+
+    public function clear(): int
+    {
+        $totalCount = $this->size();
+
+        // Clear priority jobs
+        foreach ($this->getPriorityJobFiles() as $file) {
+            try {
+                $filePath = $this->priorityDirectory->getPathString() . '/' . $file->filename;
+                $this->storage->delete($filePath);
+            } catch (\Throwable $e) {
+                $this->logger->warning('Failed to delete priority job file', LogContext::withData([
+                    'file' => $file->filename,
+                    'error' => $e->getMessage()
+                ]));
+            }
         }
 
-        // Lock erstellen
-        if (! @touch($lockFile)) {
-            $this->logger->warning("FileQueue: ⚠️ Could not create lock file", ['lock_file' => basename($lockFile)]);
+        // Clear delayed jobs
+        foreach ($this->getDelayedJobFiles() as $file) {
+            try {
+                $filePath = $this->delayedDirectory->getPathString() . '/' . $file->filename;
+                $this->storage->delete($filePath);
+            } catch (\Throwable $e) {
+                $this->logger->warning('Failed to delete delayed job file', [
+                    'file' => $file->filename,
+                    'error' => $e->getMessage()
+                ]);
+            }
+        }
 
+        return $totalCount;
+    }
+
+    public function getStats(): array
+    {
+        $priorityJobs = $this->getPriorityJobFiles();
+        $delayedJobs = $this->getDelayedJobFiles();
+        $priorityBreakdown = $this->getPriorityBreakdown($priorityJobs);
+
+        return [
+            'total_size' => count($priorityJobs) + count($delayedJobs),
+            'priority_queue_size' => count($priorityJobs),
+            'delayed_queue_size' => count($delayedJobs),
+            'priority_breakdown' => $priorityBreakdown
+        ];
+    }
+
+    /**
+     * Push a delayed job to the delayed queue
+     */
+    private function pushDelayedJob(JobPayload $payload): void
+    {
+        $availableTime = $payload->getAvailableTime();
+        $filename = $this->generateDelayedFilename($availableTime);
+        $filePath = $this->delayedDirectory->getPathString() . '/' . $filename;
+
+        $serializedPayload = $this->serializer->serialize($payload);
+        $this->storage->put($filePath, $serializedPayload);
+    }
+
+    /**
+     * Push a priority job to the priority queue
+     */
+    private function pushPriorityJob(JobPayload $payload, int $currentTime): void
+    {
+        $score = $this->calculateScore($payload, $currentTime);
+        $filename = $this->generatePriorityFilename($score);
+        $filePath = $this->priorityDirectory->getPathString() . '/' . $filename;
+
+        $serializedPayload = $this->serializer->serialize($payload);
+        $this->storage->put($filePath, $serializedPayload);
+    }
+
+    /**
+     * Process delayed jobs that are now ready
+     */
+    private function processDelayedJobs(): void
+    {
+        $currentTime = time();
+        $delayedFiles = $this->getDelayedJobFiles();
+
+        foreach ($delayedFiles as $file) {
+            $availableTime = $this->extractTimeFromDelayedFilename($file->filename);
+
+            if ($availableTime <= $currentTime) {
+                try {
+                    // Read and deserialize the job
+                    $filePath = $this->delayedDirectory->getPathString() . '/' . $file->filename;
+                    $content = $this->storage->get($filePath);
+                    $payload = $this->serializer->deserialize($content);
+
+                    if ($payload instanceof JobPayload) {
+                        // Remove delay and add to priority queue
+                        $payloadWithoutDelay = $payload->withDelay(\App\Framework\Core\ValueObjects\Duration::zero());
+                        $this->pushPriorityJob($payloadWithoutDelay, $currentTime);
+
+                        // Delete from delayed queue
+                        $this->storage->delete($filePath);
+                    }
+                } catch (\Throwable $e) {
+                    $this->logger->error('Failed to process delayed job', LogContext::withData([
+                        'file' => $file->filename,
+                        'error' => $e->getMessage()
+                    ]));
+                }
+            }
+        }
+    }
+
+    /**
+     * Pop the highest priority job
+     */
+    private function popPriorityJob(): ?JobPayload
+    {
+        $files = $this->getPriorityJobFiles();
+        if (empty($files)) {
             return null;
         }
 
+        $firstFile = reset($files);
+
         try {
-            // Prüfe ob Datei noch existiert (race condition)
-            if (! file_exists($file) || ! is_readable($file)) {
-                $this->logger->warning("FileQueue: ⚠️ Job file not accessible", ['file' => basename($file)]);
-                @unlink($lockFile);
+            $filePath = $this->priorityDirectory->getPathString() . '/' . $firstFile->filename;
+            $content = $this->storage->get($filePath);
+            $payload = $this->serializer->deserialize($content);
 
-                return $this->pop();
+            // Delete the file after successful reading
+            $this->storage->delete($filePath);
+
+            if ($payload instanceof JobPayload) {
+                return $payload;
             }
+        } catch (\Throwable $e) {
+            $this->logger->error('Failed to pop priority job', LogContext::withData([
+                'file' => $firstFile->filename,
+                'error' => $e->getMessage()
+            ]));
 
-            $content = file_get_contents($file);
-            if ($content === false) {
-                $this->logger->error("FileQueue: ❌ Could not read job file", ['file' => basename($file)]);
-                @unlink($file);
-                @unlink($lockFile);
-
-                return $this->pop();
+            // Try to delete corrupted file
+            try {
+                $filePath = $this->priorityDirectory->getPathString() . '/' . $firstFile->filename;
+                $this->storage->delete($filePath);
+            } catch (\Throwable) {
+                // Ignore deletion errors
             }
+        }
 
-            $job = $this->serializer->unserialize($content);
+        return null;
+    }
 
-            // Atomic delete: Erst rename, dann delete
-            $tempFile = $file . '.deleting.' . time() . '.' . getmypid();
-            if (rename($file, $tempFile)) {
-                unlink($tempFile);
-                // No logging for successful job completion in production
-            } else {
-                $this->logger->warning("FileQueue: ⚠️ Failed to rename job file for deletion", ['file' => basename($file)]);
-                // Fallback: direktes löschen versuchen
-                if (! @unlink($file)) {
-                    $this->logger->warning("FileQueue: ⚠️ Failed to delete job file - moving to processed", ['file' => basename($file)]);
-                    $processedFile = $file . '.processed.' . time();
-                    @rename($file, $processedFile);
+    /**
+     * Get priority job files sorted by score (lowest first = highest priority)
+     */
+    public function getPriorityJobFiles(): array
+    {
+        try {
+            $filenames = $this->storage->listDirectory($this->priorityDirectory->getPathString());
+            $files = [];
+
+            foreach ($filenames as $filepath) {
+                if (str_ends_with($filepath, '.json')) {
+                    // Extract just the filename from the path
+                    $filename = basename($filepath);
+                    // Create a simple file object for compatibility
+                    $files[] = (object) ['filename' => $filename];
                 }
             }
 
-            @unlink($lockFile);
+            // Sort by filename (which contains the score)
+            usort($files, function ($a, $b) {
+                $scoreA = $this->extractScoreFromPriorityFilename($a->filename);
+                $scoreB = $this->extractScoreFromPriorityFilename($b->filename);
 
-            return $job;
+                return $scoreA <=> $scoreB;
+            });
 
-        } catch (\Throwable $e) {
-            $this->logger->error("FileQueue: ❌ Failed to process job", [
-                'file' => basename($file),
-                'error' => $e->getMessage(),
-            ]);
-            @unlink($file);
-            @unlink($lockFile);
-
-            return $this->pop();
+            return $files;
+        } catch (\Throwable) {
+            return [];
         }
     }
+
+    /**
+     * Get delayed job files
+     */
+    public function getDelayedJobFiles(): array
+    {
+        try {
+            $filenames = $this->storage->listDirectory($this->delayedDirectory->getPathString());
+            $files = [];
+
+            foreach ($filenames as $filepath) {
+                if (str_ends_with($filepath, '.json')) {
+                    // Extract just the filename from the path
+                    $filename = basename($filepath);
+                    // Create a simple file object for compatibility
+                    $files[] = (object) ['filename' => $filename];
+                }
+            }
+
+            return $files;
+        } catch (\Throwable) {
+            return [];
+        }
+    }
+
+    /**
+     * Calculate score for priority queue (lower score = higher priority)
+     */
+    private function calculateScore(JobPayload $payload, int $currentTime): float
+    {
+        $priorityScore = 1000 - $payload->priority->value; // Invert for higher priority = lower score
+        $timeScore = $currentTime / 1000000; // Microsecond precision for FIFO within same priority
+
+        return $priorityScore + $timeScore;
+    }
+
+    /**
+     * Generate filename for priority job
+     */
+    private function generatePriorityFilename(float $score): string
+    {
+        $scoreStr = str_pad((string) (int) ($score * 1000000), 15, '0', STR_PAD_LEFT);
+        return "job_{$scoreStr}_" . uniqid() . '.json';
+    }
+
+    /**
+     * Generate filename for delayed job
+     */
+    private function generateDelayedFilename(int $availableTime): string
+    {
+        return "delayed_{$availableTime}_" . uniqid() . '.json';
+    }
+
+    /**
+     * Extract score from priority filename
+     */
+    private function extractScoreFromPriorityFilename(string $filename): float
+    {
+        if (preg_match('/job_(\d+)_/', $filename, $matches)) {
+            return (float) $matches[1] / 1000000;
+        }
+
+        return 999999.0; // Default high score for malformed filenames
+    }
+
+    /**
+     * Extract time from delayed filename
+     */
+    private function extractTimeFromDelayedFilename(string $filename): int
+    {
+        if (preg_match('/delayed_(\d+)_/', $filename, $matches)) {
+            return (int) $matches[1];
+        }
+
+        return PHP_INT_MAX; // Default far future for malformed filenames
+    }
+
+    /**
+     * Get priority breakdown for statistics
+     */
+    private function getPriorityBreakdown(array $priorityFiles): array
+    {
+        $breakdown = [];
+
+        foreach ($priorityFiles as $file) {
+            try {
+                $filePath = $this->priorityDirectory->getPathString() . '/' . $file->filename;
+                $content = $this->storage->get($filePath);
+                $payload = $this->serializer->deserialize($content);
+
+                if ($payload instanceof JobPayload) {
+                    $priority = $payload->priority->toString();
+                    $breakdown[$priority] = ($breakdown[$priority] ?? 0) + 1;
+                }
+            } catch (\Throwable) {
+                // Skip corrupted files in breakdown
+            }
+        }
+
+        return $breakdown;
+    }
 }

src/Framework/Queue/InMemoryQueue.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue;
+
+use App\Framework\Queue\ValueObjects\JobPayload;
+
+/**
+ * In-Memory Queue Implementation
+ *
+ * Simple queue implementation for testing purposes
+ */
+final class InMemoryQueue implements Queue
+{
+    /** @var array<JobPayload> */
+    private array $items = [];
+
+    public function push(JobPayload $payload): void
+    {
+        $this->items[] = $payload;
+
+        // Sort by priority (higher priority first)
+        usort($this->items, function(JobPayload $a, JobPayload $b): int {
+            return $b->priority->value <=> $a->priority->value;
+        });
+    }
+
+    public function pop(): ?JobPayload
+    {
+        if (empty($this->items)) {
+            return null;
+        }
+
+        return array_shift($this->items);
+    }
+
+    public function peek(): ?JobPayload
+    {
+        if (empty($this->items)) {
+            return null;
+        }
+
+        return $this->items[0];
+    }
+
+    public function size(): int
+    {
+        return count($this->items);
+    }
+
+    public function clear(): int
+    {
+        $count = count($this->items);
+        $this->items = [];
+        return $count;
+    }
+
+    public function getStats(): array
+    {
+        $priorityCounts = [];
+
+        foreach ($this->items as $item) {
+            $priority = $item->priority->toString();
+            $priorityCounts[$priority] = ($priorityCounts[$priority] ?? 0) + 1;
+        }
+
+        return [
+            'size' => $this->size(),
+            'priority_breakdown' => $priorityCounts,
+            'total_items' => count($this->items)
+        ];
+    }
+}

src/Framework/Queue/Initializers/DeadLetterQueueInitializer.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\EntityManager;
+use App\Framework\DI\Initializer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\Contracts\DeadLetterQueueInterface;
+use App\Framework\Queue\Contracts\QueueInterface;
+use App\Framework\Queue\Services\DatabaseDeadLetterQueue;
+use App\Framework\Queue\Services\DeadLetterManager;
+use App\Framework\Queue\Services\ProductionJobPersistenceLayer;
+
+/**
+ * Initializes Dead Letter Queue services
+ */
+final readonly class DeadLetterQueueInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): DeadLetterQueueInterface
+    {
+        // Create Dead Letter Queue implementation
+        $deadLetterQueue = new DatabaseDeadLetterQueue(
+            connection: $container->get(ConnectionInterface::class),
+            entityManager: $container->get(EntityManager::class),
+            originalQueue: $container->get(QueueInterface::class)
+        );
+
+        // Register Dead Letter Manager
+        $deadLetterManager = new DeadLetterManager(
+            deadLetterQueue: $deadLetterQueue,
+            persistenceLayer: $container->get(ProductionJobPersistenceLayer::class)
+        );
+        $container->instance(DeadLetterManager::class, $deadLetterManager);
+
+        return $deadLetterQueue;
+    }
+}

src/Framework/Queue/Initializers/DistributedLockInitializer.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Queue\Interfaces\DistributedLockInterface;
+use App\Framework\Queue\Services\DatabaseDistributedLock;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Logging\Logger;
+
+/**
+ * Distributed Lock Initializer
+ */
+final readonly class DistributedLockInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): DistributedLockInterface
+    {
+        $connection = $container->get(ConnectionInterface::class);
+        $logger = $container->get(Logger::class);
+
+        return new DatabaseDistributedLock(
+            connection: $connection,
+            logger: $logger
+        );
+    }
+}

src/Framework/Queue/Initializers/FailoverRecoveryInitializer.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Queue\Services\FailoverRecoveryService;
+use App\Framework\Queue\Services\WorkerRegistry;
+use App\Framework\Queue\Services\JobDistributionService;
+use App\Framework\Queue\Services\WorkerHealthCheckService;
+use App\Framework\Queue\Interfaces\DistributedLockInterface;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Logging\Logger;
+
+/**
+ * Failover Recovery Service Initializer
+ */
+final readonly class FailoverRecoveryInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): FailoverRecoveryService
+    {
+        $workerRegistry = $container->get(WorkerRegistry::class);
+        $jobDistributionService = $container->get(JobDistributionService::class);
+        $healthCheckService = $container->get(WorkerHealthCheckService::class);
+        $distributedLock = $container->get(DistributedLockInterface::class);
+        $connection = $container->get(ConnectionInterface::class);
+        $logger = $container->get(Logger::class);
+
+        return new FailoverRecoveryService(
+            workerRegistry: $workerRegistry,
+            jobDistributionService: $jobDistributionService,
+            healthCheckService: $healthCheckService,
+            distributedLock: $distributedLock,
+            connection: $connection,
+            logger: $logger
+        );
+    }
+}

src/Framework/Queue/Initializers/JobDistributionInitializer.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\DI\Initializer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\Services\JobDistributionService;
+use App\Framework\Queue\Services\WorkerRegistry;
+use App\Framework\Queue\Interfaces\DistributedLockInterface;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Logging\Logger;
+
+/**
+ * Job Distribution Service Initializer
+ */
+final readonly class JobDistributionInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): JobDistributionService
+    {
+        $workerRegistry = $container->get(WorkerRegistry::class);
+        $distributedLock = $container->get(DistributedLockInterface::class);
+        $connection = $container->get(ConnectionInterface::class);
+        $logger = $container->get(Logger::class);
+
+        return new JobDistributionService(
+            workerRegistry: $workerRegistry,
+            distributedLock: $distributedLock,
+            connection: $connection,
+            logger: $logger
+        );
+    }
+}

src/Framework/Queue/Initializers/JobMetricsInitializer.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\DI\Initializer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\Services\ProductionJobMetricsManager;
+use App\Framework\Queue\Services\JobMetricsManagerInterface;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Logging\Logger;
+
+final readonly class JobMetricsInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): JobMetricsManagerInterface
+    {
+        $connection = $container->get(ConnectionInterface::class);
+        $logger = $container->get(Logger::class);
+
+        $jobMetricsManager = new ProductionJobMetricsManager(
+            connection: $connection,
+            logger: $logger
+        );
+
+        // Framework will auto-register concrete class
+        $container->instance(ProductionJobMetricsManager::class, $jobMetricsManager);
+        $container->bind('job_metrics_manager', $jobMetricsManager);
+
+        return $jobMetricsManager;
+    }
+}

src/Framework/Queue/Initializers/ProgressTrackingInitializer.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\DI\Initializer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\Contracts\JobProgressTrackerInterface;
+use App\Framework\Queue\Services\DatabaseJobProgressTracker;
+use App\Framework\Queue\Services\ProgressManager;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\EntityManager;
+
+/**
+ * Initialize job progress tracking services
+ */
+final readonly class ProgressTrackingInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): JobProgressTrackerInterface
+    {
+        // Create progress tracker implementation
+        $progressTracker = new DatabaseJobProgressTracker(
+            connection: $container->get(ConnectionInterface::class),
+            entityManager: $container->get(EntityManager::class)
+        );
+
+        // Register progress manager
+        $progressManager = new ProgressManager(
+            progressTracker: $progressTracker
+        );
+        $container->instance(ProgressManager::class, $progressManager);
+
+        return $progressTracker;
+    }
+}

src/Framework/Queue/Initializers/WorkerHealthCheckInitializer.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\DI\Initializer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\Services\WorkerHealthCheckService;
+use App\Framework\Queue\Services\WorkerRegistry;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Logging\Logger;
+
+/**
+ * Worker Health Check Service Initializer
+ */
+final readonly class WorkerHealthCheckInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): WorkerHealthCheckService
+    {
+        $workerRegistry = $container->get(WorkerRegistry::class);
+        $connection = $container->get(ConnectionInterface::class);
+        $logger = $container->get(Logger::class);
+
+        return new WorkerHealthCheckService(
+            workerRegistry: $workerRegistry,
+            connection: $connection,
+            logger: $logger
+        );
+    }
+}

src/Framework/Queue/Initializers/WorkerRegistryInitializer.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Initializers;
+
+use App\Framework\DI\Initializer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\Services\WorkerRegistry;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Logging\Logger;
+
+/**
+ * Worker Registry Initializer
+ */
+final readonly class WorkerRegistryInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): WorkerRegistry
+    {
+        $connection = $container->get(ConnectionInterface::class);
+        $logger = $container->get(Logger::class);
+
+        return new WorkerRegistry(
+            connection: $connection,
+            logger: $logger
+        );
+    }
+}

src/Framework/Queue/Interfaces/DistributedLockInterface.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Interfaces;
+
+use App\Framework\Queue\ValueObjects\LockKey;
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Interface für Distributed Locking System
+ */
+interface DistributedLockInterface
+{
+    /**
+     * Lock erwerben
+     */
+    public function acquire(LockKey $key, WorkerId $workerId, Duration $ttl): bool;
+
+    /**
+     * Lock verlängern
+     */
+    public function extend(LockKey $key, WorkerId $workerId, Duration $ttl): bool;
+
+    /**
+     * Lock freigeben
+     */
+    public function release(LockKey $key, WorkerId $workerId): bool;
+
+    /**
+     * Prüfe ob Lock existiert
+     */
+    public function exists(LockKey $key): bool;
+
+    /**
+     * Lock Informationen abrufen
+     */
+    public function getLockInfo(LockKey $key): ?array;
+
+    /**
+     * Lock mit Timeout versuchen
+     */
+    public function acquireWithTimeout(LockKey $key, WorkerId $workerId, Duration $ttl, Duration $timeout): bool;
+
+    /**
+     * Alle Locks eines Workers freigeben
+     */
+    public function releaseAllWorkerLocks(WorkerId $workerId): int;
+
+    /**
+     * Abgelaufene Locks aufräumen
+     */
+    public function cleanupExpiredLocks(): int;
+
+    /**
+     * Lock Statistiken
+     */
+    public function getLockStatistics(): array;
+}

src/Framework/Queue/JobPersistenceLayer.php

@@ -0,0 +1,242 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue;
+
+use App\Framework\Queue\ValueObjects\JobId;
+use App\Framework\Queue\ValueObjects\JobState;
+use App\Framework\Queue\ValueObjects\JobStatus;
+use App\Framework\Queue\ValueObjects\QueueType;
+use App\Framework\StateManagement\StateManager;
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Job Persistence Layer using StateManagement
+ *
+ * Provides persistent job tracking and state management
+ */
+final readonly class JobPersistenceLayer
+{
+    public function __construct(
+        private StateManager $stateManager
+    ) {}
+
+    /**
+     * Store a new job
+     */
+    public function storeJob(
+        JobId $jobId,
+        QueueType $queueType,
+        mixed $jobData,
+        int $maxAttempts = 3,
+        array $metadata = []
+    ): JobState {
+        $jobState = JobState::create(
+            jobId: $jobId,
+            queueType: $queueType,
+            priority: $queueType->getDefaultPriority(),
+            maxAttempts: $maxAttempts,
+            metadata: array_merge($metadata, ['job_data' => $jobData])
+        );
+
+        $this->stateManager->setState(
+            key: $this->getJobKey($jobId),
+            state: $jobState,
+            ttl: Duration::fromDays(7) // Keep job states for 7 days
+        );
+
+        return $jobState;
+    }
+
+    /**
+     * Get job state
+     */
+    public function getJobState(JobId $jobId): ?JobState
+    {
+        return $this->stateManager->getState($this->getJobKey($jobId));
+    }
+
+    /**
+     * Update job state atomically
+     */
+    public function updateJobState(JobId $jobId, callable $updater): JobState
+    {
+        return $this->stateManager->updateState(
+            key: $this->getJobKey($jobId),
+            updater: $updater,
+            ttl: Duration::fromDays(7)
+        );
+    }
+
+    /**
+     * Mark job as processing
+     */
+    public function markAsProcessing(JobId $jobId): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            return $state->markAsProcessing();
+        });
+    }
+
+    /**
+     * Mark job as completed
+     */
+    public function markAsCompleted(JobId $jobId, array $result = []): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state) use ($result): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            $completedState = $state->markAsCompleted();
+
+            if (!empty($result)) {
+                $completedState = $completedState->withMetadata(['result' => $result]);
+            }
+
+            return $completedState;
+        });
+    }
+
+    /**
+     * Mark job as failed
+     */
+    public function markAsFailed(JobId $jobId, string $errorMessage, ?\Throwable $exception = null): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state) use ($errorMessage, $exception): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            $failedState = $state->markAsFailed($errorMessage);
+
+            if ($exception !== null) {
+                $failedState = $failedState->withMetadata([
+                    'exception_class' => get_class($exception),
+                    'exception_trace' => $exception->getTraceAsString()
+                ]);
+            }
+
+            return $failedState;
+        });
+    }
+
+    /**
+     * Mark job for retry
+     */
+    public function markForRetry(JobId $jobId, string $errorMessage): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state) use ($errorMessage): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            return $state->markForRetry($errorMessage);
+        });
+    }
+
+    /**
+     * Get jobs by status
+     *
+     * @return JobState[]
+     */
+    public function getJobsByStatus(JobStatus $status, int $limit = 100): array
+    {
+        // Note: This is a simplified implementation using StateManager
+        // In production, you'd want to use an indexed storage solution
+
+        // For now, we can only search efficiently if we maintain status indexes
+        // This is a limitation of the current StateManager approach
+
+        // TODO: Consider implementing a job index for efficient queries
+        return [];
+    }
+
+    /**
+     * Get failed jobs that can be retried
+     *
+     * @return JobState[]
+     */
+    public function getRetryableJobs(int $limit = 50): array
+    {
+        // Note: Similar limitation as getJobsByStatus
+        // We need an index to efficiently find retryable jobs
+
+        // For now, return empty array as we cannot efficiently scan all jobs
+        // TODO: Implement job status indexing for production use
+        return [];
+    }
+
+    /**
+     * Clean up old completed jobs
+     */
+    public function cleanup(?Duration $olderThan = null): int
+    {
+        $olderThan ??= Duration::fromDays(30);
+
+        // Note: StateManager doesn't provide bulk cleanup operations
+        // This would need to be implemented at the storage layer level
+
+        // For individual job cleanup, you would need to:
+        // 1. Maintain a list of job IDs to check
+        // 2. Load each job state and check its age
+        // 3. Remove expired jobs individually
+
+        // TODO: Implement proper bulk cleanup mechanism
+        return 0;
+    }
+
+    /**
+     * Get job statistics
+     */
+    public function getStats(): array
+    {
+        // Note: Statistics would require maintaining counters or indexes
+        // StateManager alone doesn't provide aggregation capabilities
+
+        // For production, consider:
+        // 1. Maintaining separate counters for each job status
+        // 2. Using a dedicated metrics storage system
+        // 3. Implementing periodic statistics calculation
+
+        return [
+            'total_jobs' => 0,
+            'pending' => 0,
+            'processing' => 0,
+            'completed' => 0,
+            'failed' => 0,
+            'retrying' => 0,
+            'cancelled' => 0,
+            'expired' => 0
+        ];
+    }
+
+    /**
+     * Check if job exists
+     */
+    public function hasJob(JobId $jobId): bool
+    {
+        return $this->stateManager->hasState($this->getJobKey($jobId));
+    }
+
+    /**
+     * Remove job from persistence
+     */
+    public function removeJob(JobId $jobId): void
+    {
+        $this->stateManager->removeState($this->getJobKey($jobId));
+    }
+
+    /**
+     * Generate state key for job
+     */
+    private function getJobKey(JobId $jobId): string
+    {
+        return "job:{$jobId->toString()}";
+    }
+}

src/Framework/Queue/Migrations/CreateDeadLetterJobsTable.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+final readonly class CreateDeadLetterJobsTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('dead_letter_jobs', function ($table) {
+            // Primary key
+            $table->string('id', 26)->primary();
+
+            // Job references
+            $table->string('original_job_id', 26)->index();
+            $table->string('dead_letter_queue', 100)->index();
+            $table->string('original_queue', 50)->index();
+
+            // Job data
+            $table->text('job_payload');
+
+            // Failure information
+            $table->text('failure_reason');
+            $table->string('exception_type', 255)->nullable();
+            $table->longText('stack_trace')->nullable();
+
+            // Attempt tracking
+            $table->integer('failed_attempts');
+            $table->integer('retry_count')->default(0);
+
+            // Timestamps
+            $table->timestamp('failed_at')->index();
+            $table->timestamp('moved_to_dlq_at')->index();
+            $table->timestamp('last_retry_at')->nullable();
+
+            // Composite indexes for efficient querying
+            $table->index(['dead_letter_queue', 'moved_to_dlq_at']);
+            $table->index(['original_queue', 'failed_at']);
+            $table->index(['retry_count', 'last_retry_at']);
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('dead_letter_jobs');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_31_140002");
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Dead Letter Jobs Table";
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateDistributedLocksTable.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+/**
+ * Migration für Distributed Locks Tabelle
+ */
+final readonly class CreateDistributedLocksTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('distributed_locks', function ($table) {
+            // Lock Key - Primary Key
+            $table->string('lock_key', 255)->primary();
+
+            // Worker der den Lock hält
+            $table->string('worker_id', 32);
+
+            // Timestamps
+            $table->timestamp('acquired_at')->default('CURRENT_TIMESTAMP');
+            $table->timestamp('expires_at');
+
+            // Indexes
+            $table->index('worker_id', 'idx_lock_worker');
+            $table->index('expires_at', 'idx_lock_expires');
+            $table->index(['worker_id', 'expires_at'], 'idx_lock_worker_expires');
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('distributed_locks');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_19_144000");
+    }
+
+    public function getDescription(): string
+    {
+        return 'Create distributed_locks table for distributed job processing locks';
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateFailoverEventsTable.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+/**
+ * Migration für Failover Events Tabelle
+ */
+final readonly class CreateFailoverEventsTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('failover_events', function ($table) {
+            // Auto-incrementing ID
+            $table->id();
+
+            // Job der betroffen war
+            $table->string('job_id', 32);
+
+            // Worker die beim Failover beteiligt waren
+            $table->string('failed_worker_id', 32);
+            $table->string('new_worker_id', 32)->nullable();
+
+            // Event Typ
+            $table->enum('event_type', [
+                'worker_failure',
+                'job_reassignment',
+                'recovery_completed',
+                'manual_failover'
+            ]);
+
+            // Zusätzliche Event-Daten
+            $table->json('event_data')->nullable()->comment('Additional failover context and metrics');
+
+            // Timestamps
+            $table->timestamp('failover_at')->default('CURRENT_TIMESTAMP');
+
+            // Indexes
+            $table->index('job_id', 'idx_failover_job');
+            $table->index('failed_worker_id', 'idx_failover_failed_worker');
+            $table->index('new_worker_id', 'idx_failover_new_worker');
+            $table->index('event_type', 'idx_failover_event_type');
+            $table->index('failover_at', 'idx_failover_time');
+            $table->index(['failed_worker_id', 'failover_at'], 'idx_failover_worker_time');
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('failover_events');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_19_151000");
+    }
+
+    public function getDescription(): string
+    {
+        return 'Create failover_events table for tracking worker failover and recovery events';
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateJobAssignmentsTable.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+/**
+ * Migration für Job Assignments Tabelle
+ */
+final readonly class CreateJobAssignmentsTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_assignments', function ($table) {
+            // Job ID - eindeutige Zuordnung
+            $table->string('job_id', 32)->primary();
+
+            // Worker der den Job verarbeitet
+            $table->string('worker_id', 32);
+
+            // Queue Name für Statistiken
+            $table->string('queue_name', 255);
+
+            // Assignment Timestamp
+            $table->timestamp('assigned_at')->default('CURRENT_TIMESTAMP');
+
+            // Indexes
+            $table->index('worker_id', 'idx_assignment_worker');
+            $table->index('queue_name', 'idx_assignment_queue');
+            $table->index(['worker_id', 'assigned_at'], 'idx_assignment_worker_time');
+            $table->index('assigned_at', 'idx_assignment_time');
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('job_assignments');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_19_145000");
+    }
+
+    public function getDescription(): string
+    {
+        return 'Create job_assignments table for tracking job-to-worker assignments';
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateJobChainsTable.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+final readonly class CreateJobChainsTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_chains', function ($table) {
+            // Primary key
+            $table->string('id', 26)->primary();
+
+            // Chain identification
+            $table->string('chain_id', 26)->unique()->index();
+            $table->string('name', 255)->index();
+
+            // Chain configuration
+            $table->json('job_ids'); // Array of job IDs in execution order
+            $table->string('execution_mode', 20)->index(); // sequential, parallel, conditional
+            $table->boolean('stop_on_failure')->default(true)->index();
+
+            // Additional data
+            $table->json('metadata')->nullable();
+
+            // Status tracking
+            $table->string('status', 20)->default('pending')->index(); // pending, running, completed, failed
+            $table->timestamp('started_at')->nullable()->index();
+            $table->timestamp('completed_at')->nullable()->index();
+
+            // Timestamps
+            $table->timestamp('created_at')->index();
+            $table->timestamp('updated_at');
+
+            // Composite indexes for efficient querying
+            $table->index(['status', 'created_at']);
+            $table->index(['execution_mode', 'status']);
+            $table->index(['stop_on_failure', 'status']);
+            $table->index(['started_at', 'completed_at']);
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('job_chains');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_31_140005");
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Job Chains Table";
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateJobDependenciesTable.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+final readonly class CreateJobDependenciesTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_dependencies', function ($table) {
+            // Primary key
+            $table->string('id', 26)->primary();
+
+            // Job references
+            $table->string('dependent_job_id', 26)->index();
+            $table->string('depends_on_job_id', 26)->index();
+
+            // Dependency configuration
+            $table->string('dependency_type', 20)->index(); // completion, success, conditional
+            $table->text('condition_expression')->nullable();
+
+            // Status tracking
+            $table->boolean('is_satisfied')->default(false)->index();
+            $table->timestamp('satisfied_at')->nullable();
+
+            // Timestamps
+            $table->timestamp('created_at')->index();
+            $table->timestamp('updated_at');
+
+            // Composite indexes for efficient querying
+            $table->index(['dependent_job_id', 'is_satisfied']);
+            $table->index(['depends_on_job_id', 'dependency_type']);
+            $table->index(['is_satisfied', 'satisfied_at']);
+            $table->index(['dependency_type', 'created_at']);
+
+            // Unique constraint to prevent duplicate dependencies
+            $table->unique(['dependent_job_id', 'depends_on_job_id', 'dependency_type']);
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('job_dependencies');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_31_140004");
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Job Dependencies Table";
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateJobHistoryTable.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+final readonly class CreateJobHistoryTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_history', function ($table) {
+            // Auto-incrementing primary key
+            $table->id();
+
+            // Job reference
+            $table->string('job_id', 26)->index();
+
+            // Status transition
+            $table->string('old_status', 20)->nullable();
+            $table->string('new_status', 20)->index();
+
+            // Error information
+            $table->text('error_message')->nullable();
+
+            // Timestamp
+            $table->timestamp('changed_at')->index();
+
+            // Additional metadata
+            $table->json('metadata')->nullable();
+
+            // Composite indexes for efficient querying
+            $table->index(['job_id', 'changed_at']);
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('job_history');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_31_140001");
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Job History Table";
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateJobIndexTable.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+final readonly class CreateJobIndexTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_index', function ($table) {
+            // ULID primary key
+            $table->string('job_id', 26)->primary();
+
+            // Job status and metadata
+            $table->string('status', 20)->index();
+            $table->string('queue_type', 50)->index();
+            $table->integer('priority')->index();
+            $table->integer('attempts')->default(0);
+            $table->integer('max_attempts')->default(3);
+
+            // Timestamps
+            $table->timestamp('created_at')->index();
+            $table->timestamp('updated_at');
+            $table->timestamp('started_at')->nullable();
+            $table->timestamp('completed_at')->nullable()->index();
+            $table->timestamp('scheduled_for')->nullable()->index();
+
+            // Error handling
+            $table->text('error_message')->nullable();
+
+            // Composite indexes for efficient querying
+            $table->index(['status', 'queue_type']);
+            $table->index(['status', 'attempts', 'max_attempts']);
+            $table->index(['status', 'completed_at']);
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('job_index');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_31_140000");
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Job Index Table";
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateJobMetricsTable.php

@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+final readonly class CreateJobMetricsTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_metrics', function ($table) {
+            // Primary key
+            $table->string('id', 26)->primary();
+
+            // Job identification
+            $table->string('job_id', 26)->index();
+            $table->string('queue_name', 100)->index();
+
+            // Status and execution tracking
+            $table->string('status', 20)->index(); // pending, running, completed, failed
+            $table->integer('attempts')->default(0)->index();
+            $table->integer('max_attempts')->default(3);
+
+            // Performance metrics
+            $table->float('execution_time_ms')->default(0)->index();
+            $table->integer('memory_usage_bytes')->default(0)->index();
+
+            // Error tracking
+            $table->text('error_message')->nullable();
+
+            // Timestamps
+            $table->timestamp('created_at')->index();
+            $table->timestamp('updated_at');
+            $table->timestamp('started_at')->nullable()->index();
+            $table->timestamp('completed_at')->nullable()->index();
+            $table->timestamp('failed_at')->nullable()->index();
+
+            // Additional data
+            $table->json('metadata')->nullable();
+
+            // Composite indexes for efficient querying
+            $table->index(['queue_name', 'status']);
+            $table->index(['status', 'created_at']);
+            $table->index(['job_id', 'attempts']);
+            $table->index(['queue_name', 'completed_at']);
+            $table->index(['queue_name', 'failed_at']);
+            $table->index(['execution_time_ms', 'status']);
+            $table->index(['memory_usage_bytes', 'status']);
+            $table->index(['created_at', 'completed_at', 'status']); // For throughput calculations
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('job_metrics');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_31_140006");
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Job Metrics Table";
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateJobProgressTable.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+final readonly class CreateJobProgressTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_progress', function ($table) {
+            // Primary key
+            $table->string('id', 26)->primary();
+
+            // Job reference
+            $table->string('job_id', 26)->index();
+
+            // Progress tracking
+            $table->decimal('percentage', 5, 2)->index(); // 0.00 to 100.00
+            $table->text('message');
+            $table->string('step_name', 100)->nullable()->index();
+
+            // Additional data
+            $table->json('metadata')->nullable();
+
+            // Status flags
+            $table->boolean('is_completed')->default(false)->index();
+            $table->boolean('is_failed')->default(false)->index();
+
+            // Timestamp
+            $table->timestamp('updated_at')->index();
+
+            // Composite indexes for efficient querying
+            $table->index(['job_id', 'updated_at']);
+            $table->index(['job_id', 'is_completed']);
+            $table->index(['is_completed', 'updated_at']);
+            $table->index(['percentage', 'updated_at']);
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('job_progress');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_31_140003");
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Job Progress Table";
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateQueueWorkersTable.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+/**
+ * Migration für Queue Workers Tabelle
+ */
+final readonly class CreateQueueWorkersTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('queue_workers', function ($table) {
+            // Primary Key - Worker ID (Hash basiert auf hostname + PID + Timestamp)
+            $table->string('id', 32)->primary();
+
+            // Worker Identification
+            $table->string('hostname', 255);
+            $table->integer('process_id');
+            $table->string('version', 20)->default('1.0.0');
+
+            // Queue Configuration
+            $table->json('queues')->comment('Queues that this worker handles');
+            $table->integer('max_jobs')->default(10)->comment('Maximum concurrent jobs');
+            $table->integer('current_jobs')->default(0)->comment('Currently running jobs');
+
+            // Worker Status
+            $table->boolean('is_active')->default(true);
+            $table->timestamp('registered_at')->default('CURRENT_TIMESTAMP');
+            $table->timestamp('last_heartbeat')->nullable();
+
+            // Performance Metrics
+            $table->decimal('cpu_usage', 5, 2)->default(0)->comment('CPU usage percentage (0-100)');
+            $table->bigInteger('memory_usage_bytes')->default(0)->comment('Memory usage in bytes');
+
+            // Worker Capabilities
+            $table->json('capabilities')->nullable()->comment('Worker capabilities/features');
+
+            // Indexes
+            $table->index(['hostname', 'process_id'], 'idx_worker_host_process');
+            $table->index(['is_active', 'last_heartbeat'], 'idx_worker_active_heartbeat');
+            $table->index('last_heartbeat', 'idx_worker_heartbeat');
+            $table->index('current_jobs', 'idx_worker_current_jobs');
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('queue_workers');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_19_143000");
+    }
+
+    public function getDescription(): string
+    {
+        return 'Create queue_workers table for distributed job processing';
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/CreateWorkerHealthChecksTable.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+/**
+ * Migration für Worker Health Checks Tabelle
+ */
+final readonly class CreateWorkerHealthChecksTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('worker_health_checks', function ($table) {
+            // Auto-incrementing ID
+            $table->id();
+
+            // Worker der überprüft wurde
+            $table->string('worker_id', 32);
+
+            // Health Status
+            $table->enum('status', ['healthy', 'warning', 'critical']);
+            $table->integer('score')->default(0)->comment('Health score 0-100');
+
+            // Detaillierte Metriken als JSON
+            $table->json('metrics')->nullable()->comment('Detailed metrics (CPU, memory, etc.)');
+            $table->json('issues')->nullable()->comment('Critical issues found');
+            $table->json('warnings')->nullable()->comment('Warning conditions');
+
+            // Timestamps
+            $table->timestamp('checked_at')->default('CURRENT_TIMESTAMP');
+
+            // Indexes
+            $table->index('worker_id', 'idx_health_worker');
+            $table->index(['worker_id', 'checked_at'], 'idx_health_worker_time');
+            $table->index('checked_at', 'idx_health_time');
+            $table->index('status', 'idx_health_status');
+            $table->index(['status', 'checked_at'], 'idx_health_status_time');
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+        $schema->dropIfExists('worker_health_checks');
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_12_19_150000");
+    }
+
+    public function getDescription(): string
+    {
+        return 'Create worker_health_checks table for monitoring worker health status';
+    }
+
+    public function getDomain(): string
+    {
+        return "Framework";
+    }
+}

src/Framework/Queue/Migrations/Migration_2024_10_02_140000_CreateJobBatchesTable.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\Database\Migration\MigrationVersion;
+use App\Framework\Database\Schema\Schema;
+
+/**
+ * Create job_batches table for batch job tracking
+ */
+final class Migration_2024_10_02_140000_CreateJobBatchesTable implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->createIfNotExists('job_batches', function ($table) {
+            // Primary identification
+            $table->string('batch_id', 64)->primary();
+            $table->string('name', 255);
+
+            // Job tracking
+            $table->json('job_ids');
+            $table->string('status', 20)->default('pending')->index();
+            $table->integer('total_jobs')->default(0);
+            $table->integer('processed_jobs')->default(0);
+            $table->integer('failed_jobs')->default(0);
+
+            // Configuration and metadata
+            $table->json('options')->nullable();
+
+            // Timestamps for lifecycle tracking
+            $table->timestamp('created_at')->default('CURRENT_TIMESTAMP');
+            $table->timestamp('started_at')->nullable();
+            $table->timestamp('completed_at')->nullable();
+            $table->timestamp('failed_at')->nullable();
+            $table->timestamp('cancelled_at')->nullable();
+
+            // Indexes for efficient querying
+            $table->index(['status', 'created_at']);
+            $table->index('created_at');
+            $table->index(['status', 'total_jobs']);
+        });
+
+        $schema->execute();
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $schema = new Schema($connection);
+
+        $schema->dropIfExists('job_batches');
+
+        $schema->execute();
+    }
+
+    public function getVersion(): MigrationVersion
+    {
+        return MigrationVersion::fromTimestamp("2024_10_02_140000");
+    }
+
+    public function getDescription(): string
+    {
+        return 'Create job_batches table for tracking batch job processing';
+    }
+}

src/Framework/Queue/PersistentQueue.php

@@ -0,0 +1,202 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue;
+
+use App\Framework\Queue\ValueObjects\JobPayload;
+use App\Framework\Queue\ValueObjects\JobId;
+use App\Framework\Queue\ValueObjects\QueueType;
+
+/**
+ * Persistent Queue Decorator
+ *
+ * Wraps any Queue implementation with job persistence and tracking
+ */
+final readonly class PersistentQueue implements Queue
+{
+    public function __construct(
+        private Queue $baseQueue,
+        private JobPersistenceLayer $persistence,
+        private QueueType $queueType
+    ) {}
+
+    /**
+     * {@inheritdoc}
+     */
+    public function push(JobPayload $payload): void
+    {
+        // Generate job ID if not exists
+        $jobId = $payload->getJobId() ?? JobId::generate();
+
+        // Store job in persistence layer
+        $this->persistence->storeJob(
+            jobId: $jobId,
+            queueType: $this->queueType,
+            jobData: $payload->job,
+            maxAttempts: $payload->retryStrategy->maxAttempts,
+            metadata: $payload->metadata
+        );
+
+        // Add job ID to payload and push to base queue
+        $payloadWithId = $payload->withJobId($jobId);
+        $this->baseQueue->push($payloadWithId);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function pop(): ?JobPayload
+    {
+        $payload = $this->baseQueue->pop();
+
+        if ($payload === null) {
+            return null;
+        }
+
+        $jobId = $payload->getJobId();
+        if ($jobId !== null) {
+            // Mark job as processing in persistence layer
+            try {
+                $this->persistence->markAsProcessing($jobId);
+            } catch (\Throwable $e) {
+                // If we can't mark as processing, put it back in queue
+                $this->baseQueue->push($payload);
+                throw $e;
+            }
+        }
+
+        return $payload;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function peek(): ?JobPayload
+    {
+        return $this->baseQueue->peek();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function size(): int
+    {
+        return $this->baseQueue->size();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear(): int
+    {
+        $count = $this->baseQueue->clear();
+
+        // Note: We don't clear persistence layer here as it maintains job history
+        // Use separate cleanup methods for persistence if needed
+
+        return $count;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getStats(): array
+    {
+        $baseStats = $this->baseQueue->getStats();
+        $persistenceStats = $this->persistence->getStats();
+
+        return array_merge($baseStats, [
+            'persistence' => $persistenceStats,
+            'queue_type' => $this->queueType->value
+        ]);
+    }
+
+    /**
+     * Mark job as completed
+     */
+    public function markJobCompleted(JobId $jobId, array $result = []): void
+    {
+        $this->persistence->markAsCompleted($jobId, $result);
+    }
+
+    /**
+     * Mark job as failed
+     */
+    public function markJobFailed(JobId $jobId, string $errorMessage, ?\Throwable $exception = null): void
+    {
+        $jobState = $this->persistence->markAsFailed($jobId, $errorMessage, $exception);
+
+        // If job can be retried, put it back in queue
+        if ($jobState->canRetry()) {
+            // Get original job data from metadata
+            $jobData = $jobState->metadata['job_data'] ?? null;
+            if ($jobData !== null) {
+                $retryPayload = JobPayload::create($jobData, $jobState->priority)
+                    ->withJobId($jobId)
+                    ->withMetadata($jobState->metadata);
+
+                $this->baseQueue->push($retryPayload);
+                $this->persistence->markForRetry($jobId, $errorMessage);
+            }
+        }
+    }
+
+    /**
+     * Get job state from persistence
+     */
+    public function getJobState(JobId $jobId): ?\App\Framework\Queue\ValueObjects\JobState
+    {
+        return $this->persistence->getJobState($jobId);
+    }
+
+    /**
+     * Get the underlying base queue
+     */
+    public function getBaseQueue(): Queue
+    {
+        return $this->baseQueue;
+    }
+
+    /**
+     * Get the persistence layer
+     */
+    public function getPersistenceLayer(): JobPersistenceLayer
+    {
+        return $this->persistence;
+    }
+
+    /**
+     * Get retryable failed jobs and re-queue them
+     */
+    public function requeueFailedJobs(int $limit = 50): int
+    {
+        $retryableJobs = $this->persistence->getRetryableJobs($limit);
+        $requeued = 0;
+
+        foreach ($retryableJobs as $jobState) {
+            $jobData = $jobState->metadata['job_data'] ?? null;
+            if ($jobData === null) {
+                continue;
+            }
+
+            $retryPayload = JobPayload::create($jobData, $jobState->priority)
+                ->withJobId($jobState->jobId)
+                ->withMetadata($jobState->metadata);
+
+            $this->baseQueue->push($retryPayload);
+            $this->persistence->markForRetry($jobState->jobId, 'Manual retry');
+            $requeued++;
+        }
+
+        return $requeued;
+    }
+
+    /**
+     * Clean up old job records
+     */
+    public function cleanupJobs(?\App\Framework\Core\ValueObjects\Duration $olderThan = null): int
+    {
+        return $this->persistence->cleanup($olderThan);
+    }
+}

src/Framework/Queue/ProductionJobPersistenceLayer.php

@@ -0,0 +1,471 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Cache\CacheKey;
+use App\Framework\Cache\CacheItem;
+use App\Framework\Database\EntityManager;
+use App\Framework\Queue\Entities\JobIndexEntry;
+use App\Framework\Queue\Entities\JobHistoryEntry;
+use App\Framework\Queue\ValueObjects\JobId;
+use App\Framework\Queue\ValueObjects\JobState;
+use App\Framework\Queue\ValueObjects\JobStatus;
+use App\Framework\Queue\ValueObjects\QueueType;
+use App\Framework\StateManagement\StateManager;
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Production Job Persistence Layer
+ *
+ * High-performance job persistence with database indexing and caching
+ */
+final readonly class ProductionJobPersistenceLayer
+{
+    public function __construct(
+        private StateManager $stateManager,      // Hot data (active jobs)
+        private EntityManager $entityManager,   // Persistent storage + queries
+        private Cache $cache                     // Query results cache
+    ) {}
+
+    /**
+     * Store a new job
+     */
+    public function storeJob(
+        JobId $jobId,
+        QueueType $queueType,
+        mixed $jobData,
+        int $maxAttempts = 3,
+        array $metadata = []
+    ): JobState {
+        $jobState = JobState::create(
+            jobId: $jobId,
+            queueType: $queueType,
+            priority: $queueType->getDefaultPriority(),
+            maxAttempts: $maxAttempts,
+            metadata: array_merge($metadata, ['job_data' => $jobData])
+        );
+
+        // 1. Store in StateManager (hot storage for workers)
+        $this->stateManager->setState(
+            key: $this->getJobKey($jobId),
+            state: $jobState,
+            ttl: Duration::fromDays(1) // Shorter TTL for hot storage
+        );
+
+        // 2. Store in database (persistent indexing)
+        $this->entityManager->beginTransaction();
+        try {
+            $indexEntry = JobIndexEntry::fromJobState($jobState);
+            $this->entityManager->persist($indexEntry);
+
+            // Create history entry for job creation
+            $historyEntry = JobHistoryEntry::forStatusChange(
+                jobId: $jobId,
+                oldStatus: null,
+                newStatus: JobStatus::PENDING,
+                metadata: ['queue_type' => $queueType->value, 'priority' => $jobState->priority->value]
+            );
+            $this->entityManager->persist($historyEntry);
+
+            $this->entityManager->flush();
+            $this->entityManager->commit();
+        } catch (\Exception $e) {
+            $this->entityManager->rollback();
+            throw $e;
+        }
+
+        // 3. Invalidate relevant caches
+        $this->invalidateStatusCache($jobState->status);
+
+        return $jobState;
+    }
+
+    /**
+     * Get job state
+     */
+    public function getJobState(JobId $jobId): ?JobState
+    {
+        // Try StateManager first (hot storage)
+        $jobState = $this->stateManager->getState($this->getJobKey($jobId));
+
+        if ($jobState !== null) {
+            return $jobState;
+        }
+
+        // Fallback to database if not in hot storage
+        $indexEntry = $this->entityManager->find(JobIndexEntry::class, $jobId->toString());
+
+        if ($indexEntry === null) {
+            return null;
+        }
+
+        // Reconstruct JobState from index entry (simplified - metadata would need to be stored separately)
+        return JobState::create(
+            jobId: $indexEntry->jobId,
+            queueType: $indexEntry->queueType,
+            priority: $indexEntry->priority,
+            maxAttempts: $indexEntry->maxAttempts,
+            metadata: [] // TODO: Store metadata separately if needed
+        );
+    }
+
+    /**
+     * Update job state atomically
+     */
+    public function updateJobState(JobId $jobId, callable $updater): JobState
+    {
+        $currentState = $this->getJobState($jobId);
+
+        if ($currentState === null) {
+            throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+        }
+
+        $oldStatus = $currentState->status;
+        $newState = $updater($currentState);
+
+        // Update both StateManager and database
+        $this->stateManager->setState(
+            key: $this->getJobKey($jobId),
+            state: $newState,
+            ttl: Duration::fromDays(1)
+        );
+
+        $this->entityManager->beginTransaction();
+        try {
+            // Update index entry
+            $indexEntry = $this->entityManager->find(JobIndexEntry::class, $jobId->toString());
+            if ($indexEntry !== null) {
+                $updatedEntry = $indexEntry->updateFromJobState($newState);
+                $this->entityManager->persist($updatedEntry);
+            }
+
+            // Create history entry for status change
+            if ($oldStatus !== $newState->status) {
+                $historyEntry = JobHistoryEntry::forStatusChange(
+                    jobId: $jobId,
+                    oldStatus: $oldStatus,
+                    newStatus: $newState->status,
+                    errorMessage: $newState->errorMessage
+                );
+                $this->entityManager->persist($historyEntry);
+            }
+
+            $this->entityManager->flush();
+            $this->entityManager->commit();
+        } catch (\Exception $e) {
+            $this->entityManager->rollback();
+            throw $e;
+        }
+
+        // Invalidate caches
+        if ($oldStatus !== $newState->status) {
+            $this->invalidateStatusCache($oldStatus);
+            $this->invalidateStatusCache($newState->status);
+        }
+
+        return $newState;
+    }
+
+    /**
+     * Mark job as processing
+     */
+    public function markAsProcessing(JobId $jobId): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            return $state->markAsProcessing();
+        });
+    }
+
+    /**
+     * Mark job as completed
+     */
+    public function markAsCompleted(JobId $jobId, array $result = []): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state) use ($result): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            $completedState = $state->markAsCompleted();
+
+            if (!empty($result)) {
+                $completedState = $completedState->withMetadata(['result' => $result]);
+            }
+
+            return $completedState;
+        });
+    }
+
+    /**
+     * Mark job as failed
+     */
+    public function markAsFailed(JobId $jobId, string $errorMessage, ?\Throwable $exception = null): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state) use ($errorMessage, $exception): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            $failedState = $state->markAsFailed($errorMessage);
+
+            if ($exception !== null) {
+                $failedState = $failedState->withMetadata([
+                    'exception_class' => get_class($exception),
+                    'exception_trace' => $exception->getTraceAsString()
+                ]);
+            }
+
+            return $failedState;
+        });
+    }
+
+    /**
+     * Mark job for retry
+     */
+    public function markForRetry(JobId $jobId, string $errorMessage): JobState
+    {
+        return $this->updateJobState($jobId, function (?JobState $state) use ($errorMessage): JobState {
+            if ($state === null) {
+                throw new \InvalidArgumentException("Job {$jobId->toString()} not found");
+            }
+
+            return $state->markForRetry($errorMessage);
+        });
+    }
+
+    /**
+     * Get jobs by status
+     *
+     * @return JobState[]
+     */
+    public function getJobsByStatus(JobStatus $status, int $limit = 100): array
+    {
+        $cacheKey = CacheKey::fromString("jobs_by_status:{$status->value}:{$limit}");
+
+        // Try cache first
+        $cacheResult = $this->cache->get($cacheKey);
+        $jobIds = $cacheResult->getHits()[$cacheKey->toString()] ?? null;
+
+        if ($jobIds === null) {
+            // Query database for job IDs
+            $repository = $this->entityManager->getRepository(JobIndexEntry::class);
+            $queryBuilder = $this->entityManager->createQueryBuilder();
+
+            $indexEntries = $queryBuilder
+                ->select('j')
+                ->from(JobIndexEntry::class, 'j')
+                ->where('j.status = :status')
+                ->orderBy('j.priority', 'DESC')
+                ->addOrderBy('j.createdAt', 'ASC')
+                ->setParameter('status', $status->value)
+                ->setMaxResults($limit)
+                ->getQuery()
+                ->getResult();
+
+            $jobIds = array_map(fn($entry) => $entry->jobId->toString(), $indexEntries);
+
+            // Cache for 30 seconds
+            $cacheItem = CacheItem::forSetting(
+                key: $cacheKey,
+                value: $jobIds,
+                ttl: Duration::fromSeconds(30)
+            );
+            $this->cache->set($cacheItem);
+        }
+
+        // Load actual job states from StateManager (hot) or fallback to database
+        $jobs = [];
+        foreach ($jobIds as $jobIdString) {
+            $jobId = JobId::fromString($jobIdString);
+            $jobState = $this->getJobState($jobId);
+            if ($jobState && $jobState->status === $status) {
+                $jobs[] = $jobState;
+            }
+        }
+
+        return $jobs;
+    }
+
+    /**
+     * Get failed jobs that can be retried
+     *
+     * @return JobState[]
+     */
+    public function getRetryableJobs(int $limit = 50): array
+    {
+        $repository = $this->entityManager->getRepository(JobIndexEntry::class);
+        $queryBuilder = $this->entityManager->createQueryBuilder();
+
+        $indexEntries = $queryBuilder
+            ->select('j')
+            ->from(JobIndexEntry::class, 'j')
+            ->where('j.status IN (:retryable_statuses)')
+            ->andWhere('j.attempts < j.maxAttempts')
+            ->orderBy('j.priority', 'DESC')
+            ->addOrderBy('j.createdAt', 'ASC')
+            ->setParameter('retryable_statuses', [
+                JobStatus::FAILED->value,
+                JobStatus::RETRYING->value
+            ])
+            ->setMaxResults($limit)
+            ->getQuery()
+            ->getResult();
+
+        $jobs = [];
+        foreach ($indexEntries as $entry) {
+            // Check if job needs retry based on backoff
+            if ($entry->needsRetry()) {
+                $jobState = $this->getJobState($entry->jobId);
+                if ($jobState) {
+                    $jobs[] = $jobState;
+                }
+            }
+        }
+
+        return $jobs;
+    }
+
+    /**
+     * Clean up old completed jobs
+     */
+    public function cleanup(?Duration $olderThan = null): int
+    {
+        $olderThan ??= Duration::fromDays(30);
+        $cutoffTimestamp = time() - $olderThan->toSeconds();
+
+        $queryBuilder = $this->entityManager->createQueryBuilder();
+
+        $deletedCount = $queryBuilder
+            ->delete(JobIndexEntry::class, 'j')
+            ->where('j.status IN (:final_statuses)')
+            ->andWhere('j.completedAt < :cutoff')
+            ->setParameter('final_statuses', [
+                JobStatus::COMPLETED->value,
+                JobStatus::CANCELLED->value,
+                JobStatus::EXPIRED->value
+            ])
+            ->setParameter('cutoff', $cutoffTimestamp)
+            ->getQuery()
+            ->execute();
+
+        // Also clean up history entries
+        $queryBuilder = $this->entityManager->createQueryBuilder();
+        $queryBuilder
+            ->delete(JobHistoryEntry::class, 'h')
+            ->where('h.changedAt < :cutoff')
+            ->setParameter('cutoff', $cutoffTimestamp)
+            ->getQuery()
+            ->execute();
+
+        return $deletedCount;
+    }
+
+    /**
+     * Get job statistics
+     */
+    public function getStats(): array
+    {
+        $cacheKey = CacheKey::fromString('job_stats');
+        $cacheResult = $this->cache->get($cacheKey);
+        $stats = $cacheResult->getHits()[$cacheKey->toString()] ?? null;
+
+        if ($stats === null) {
+            $queryBuilder = $this->entityManager->createQueryBuilder();
+
+            $result = $queryBuilder
+                ->select('j.status, COUNT(j.jobId) as count')
+                ->from(JobIndexEntry::class, 'j')
+                ->groupBy('j.status')
+                ->getQuery()
+                ->getArrayResult();
+
+            $stats = array_fill_keys([
+                'pending', 'processing', 'completed', 'failed', 'retrying', 'cancelled', 'expired'
+            ], 0);
+
+            foreach ($result as $row) {
+                $stats[$row['status']] = (int) $row['count'];
+            }
+
+            $stats['total_jobs'] = array_sum($stats);
+
+            // Cache for 1 minute
+            $cacheItem = CacheItem::forSetting(
+                key: $cacheKey,
+                value: $stats,
+                ttl: Duration::fromMinutes(1)
+            );
+            $this->cache->set($cacheItem);
+        }
+
+        return $stats;
+    }
+
+    /**
+     * Check if job exists
+     */
+    public function hasJob(JobId $jobId): bool
+    {
+        // Check StateManager first
+        if ($this->stateManager->hasState($this->getJobKey($jobId))) {
+            return true;
+        }
+
+        // Check database
+        $indexEntry = $this->entityManager->find(JobIndexEntry::class, $jobId->toString());
+        return $indexEntry !== null;
+    }
+
+    /**
+     * Remove job from persistence
+     */
+    public function removeJob(JobId $jobId): void
+    {
+        // Remove from StateManager
+        $this->stateManager->removeState($this->getJobKey($jobId));
+
+        // Remove from database
+        $this->entityManager->beginTransaction();
+        try {
+            $indexEntry = $this->entityManager->find(JobIndexEntry::class, $jobId->toString());
+            if ($indexEntry !== null) {
+                $this->entityManager->remove($indexEntry);
+            }
+
+            $this->entityManager->flush();
+            $this->entityManager->commit();
+        } catch (\Exception $e) {
+            $this->entityManager->rollback();
+            throw $e;
+        }
+    }
+
+    /**
+     * Generate state key for job
+     */
+    private function getJobKey(JobId $jobId): string
+    {
+        return "job:{$jobId->toString()}";
+    }
+
+    /**
+     * Invalidate status-related caches
+     */
+    private function invalidateStatusCache(JobStatus $status): void
+    {
+        $cacheKeys = [
+            CacheKey::fromString("jobs_by_status:{$status->value}:50"),
+            CacheKey::fromString("jobs_by_status:{$status->value}:100"),
+            CacheKey::fromString('job_stats')
+        ];
+
+        $this->cache->forget(...$cacheKeys);
+    }
+}

src/Framework/Queue/Queue.php

@@ -4,9 +4,49 @@ declare(strict_types=1);
 
 namespace App\Framework\Queue;
 
+use App\Framework\Queue\ValueObjects\JobPayload;
+
 interface Queue
 {
-    public function push(object $job): void;
+    /**
+     * Push a job to the queue
+     *
+     * @param JobPayload $payload The job payload with priority, delay, and metadata
+     */
+    public function push(JobPayload $payload): void;
 
-    public function pop(): ?object;
+    /**
+     * Pop the next available job from the queue
+     *
+     * @return JobPayload|null The next job payload or null if queue is empty
+     */
+    public function pop(): ?JobPayload;
+
+    /**
+     * Peek at the next job without removing it
+     *
+     * @return JobPayload|null The next job payload or null if queue is empty
+     */
+    public function peek(): ?JobPayload;
+
+    /**
+     * Get the number of jobs in the queue
+     *
+     * @return int Number of pending jobs
+     */
+    public function size(): int;
+
+    /**
+     * Clear all jobs from the queue
+     *
+     * @return int Number of jobs removed
+     */
+    public function clear(): int;
+
+    /**
+     * Get queue statistics
+     *
+     * @return array Statistics about the queue (size, priorities, etc.)
+     */
+    public function getStats(): array;
 }

src/Framework/Queue/QueueDependencyInitializer.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue;
+
+use App\Framework\DI\Initializer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\Contracts\JobDependencyManagerInterface;
+use App\Framework\Queue\Contracts\JobChainManagerInterface;
+use App\Framework\Queue\Services\DatabaseJobDependencyManager;
+use App\Framework\Queue\Services\DatabaseJobChainManager;
+use App\Framework\Queue\Services\DependencyResolutionEngine;
+use App\Framework\Queue\Services\JobChainExecutionCoordinator;
+use App\Framework\Queue\Services\JobMetricsManager;
+use App\Framework\Database\EntityManagerInterface;
+use App\Framework\Logging\Logger;
+use App\Framework\Core\Events\EventDispatcherInterface;
+
+final readonly class QueueDependencyInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): JobDependencyManagerInterface
+    {
+        // Register Job Dependency Manager
+        $dependencyManager = new DatabaseJobDependencyManager(
+            entityManager: $container->get(EntityManagerInterface::class),
+            logger: $container->get(Logger::class)
+        );
+        $container->instance(DatabaseJobDependencyManager::class, $dependencyManager);
+
+        // Register Job Chain Manager
+        $chainManager = new DatabaseJobChainManager(
+            entityManager: $container->get(EntityManagerInterface::class),
+            logger: $container->get(Logger::class)
+        );
+        $container->singleton(JobChainManagerInterface::class, $chainManager);
+        $container->instance(DatabaseJobChainManager::class, $chainManager);
+
+        // Register other services as lazy factories
+        $container->singleton(DependencyResolutionEngine::class, function(Container $container) {
+            return new DependencyResolutionEngine(
+                dependencyManager: $container->get(JobDependencyManagerInterface::class),
+                chainManager: $container->get(JobChainManagerInterface::class),
+                queue: $container->get(\App\Framework\Queue\Contracts\QueueInterface::class),
+                logger: $container->get(Logger::class)
+            );
+        });
+
+        $container->singleton(JobChainExecutionCoordinator::class, function(Container $container) {
+            return new JobChainExecutionCoordinator(
+                chainManager: $container->get(JobChainManagerInterface::class),
+                dependencyManager: $container->get(JobDependencyManagerInterface::class),
+                queue: $container->get(\App\Framework\Queue\Contracts\QueueInterface::class),
+                eventDispatcher: $container->get(EventDispatcherInterface::class),
+                resolutionEngine: $container->get(DependencyResolutionEngine::class),
+                logger: $container->get(Logger::class)
+            );
+        });
+
+        $container->singleton(JobMetricsManager::class, function(Container $container) {
+            return new JobMetricsManager(
+                entityManager: $container->get(EntityManagerInterface::class),
+                logger: $container->get(Logger::class)
+            );
+        });
+
+        return $dependencyManager;
+    }
+}

src/Framework/Queue/QueueInitializer.php

@@ -7,6 +7,7 @@ namespace App\Framework\Queue;
 use App\Framework\Core\PathProvider;
 use App\Framework\DI\Initializer;
 use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
 use App\Framework\Redis\RedisConfig;
 use App\Framework\Redis\RedisConnection;
 
@@ -21,6 +22,11 @@ final readonly class QueueInitializer
     public function __invoke(Logger $logger): Queue
     {
         try {
+            // Check if Redis extension is available
+            if (! extension_loaded('redis')) {
+                throw new \RuntimeException('Redis extension not loaded');
+            }
+
             $redisConfig = new RedisConfig(
                 host: 'redis',
                 port: 6379,
@@ -31,10 +37,11 @@ final readonly class QueueInitializer
             return new RedisQueue($redisConnection, 'commands');
         } catch (\Throwable $e) {
             // Fallback to file queue if Redis is not available
-            $logger->warning("⚠️ Redis queue not available, falling back to file queue", [
-                'error' => $e->getMessage(),
-            ]);
-            $path = $this->pathProvider->resolvePath('/src/Framework/CommandBus/storage/queue/');
+            $logger->info("Using file queue (Redis not available)", LogContext::withData([
+                'reason' => $e->getMessage(),
+                'fallback' => 'FileQueue',
+            ]));
+            $path = $this->pathProvider->resolvePath('/storage/queue/');
 
             return new FileQueue($path, logger: $logger);
         }

src/Framework/Queue/RedisQueue.php

@@ -4,38 +4,250 @@ declare(strict_types=1);
 
 namespace App\Framework\Queue;
 
+use App\Framework\Queue\ValueObjects\JobPayload;
+use App\Framework\Queue\ValueObjects\QueuePriority;
 use App\Framework\Redis\RedisConnectionInterface;
 use App\Framework\Serializer\Php\PhpSerializer;
 use App\Framework\Serializer\Serializer;
 use Redis;
 
+/**
+ * Redis Queue Implementation with Priority Support
+ *
+ * Uses Redis sorted sets for priority queues and lists for FIFO within same priority
+ */
 final class RedisQueue implements Queue
 {
     private Redis $redis;
+    private string $priorityKey;
+    private string $delayedKey;
+    private string $statsKey;
 
     public function __construct(
         private RedisConnectionInterface $connection,
-        private string $queueName = 'commands',
+        private string $queueName = 'queue',
         private readonly Serializer $serializer = new PhpSerializer()
     ) {
         $this->redis = $this->connection->getClient();
+        $this->priorityKey = "{$queueName}:priority";
+        $this->delayedKey = "{$queueName}:delayed";
+        $this->statsKey = "{$queueName}:stats";
     }
 
-    public function push(object $job): void
+    public function push(JobPayload $payload): void
     {
-        $data = $this->serializer->serialize($job);
-        $this->redis->rPush($this->queueName, $data);
+        $serializedPayload = $this->serializer->serialize($payload);
+        $currentTime = time();
+        $score = $this->calculateScore($payload, $currentTime);
+
+        // If delayed, add to delayed queue
+        if ($payload->isDelayed()) {
+            $availableTime = $payload->getAvailableTime();
+            $this->redis->zAdd($this->delayedKey, $availableTime, $serializedPayload);
+        } else {
+            // Add to priority queue with score (higher priority = lower score for Redis)
+            $this->redis->zAdd($this->priorityKey, $score, $serializedPayload);
+        }
+
+        // Update statistics
+        $this->updateStats('pushed', $payload->priority->toString());
     }
 
-    public function pop(): ?object
+    public function pop(): ?JobPayload
     {
-        // Wartet bis zu 2 Sekunden auf einen neuen Job (blocking)
-        $result = $this->redis->blPop([$this->queueName], 2);
+        // First, process any delayed jobs that are now ready
+        $this->processDelayedJobs();
 
-        if ($result && isset($result[1])) {
-            return $this->serializer->unserialize($result[1]);
+        // Pop highest priority job (lowest score in Redis sorted set)
+        $result = $this->redis->zPopMin($this->priorityKey);
+
+        if (!empty($result)) {
+            $serializedPayload = array_key_first($result);
+            $payload = $this->serializer->unserialize($serializedPayload);
+
+            if ($payload instanceof JobPayload) {
+                $this->updateStats('popped', $payload->priority->toString());
+                return $payload;
+            }
         }
 
         return null;
     }
+
+    public function peek(): ?JobPayload
+    {
+        // Process delayed jobs first
+        $this->processDelayedJobs();
+
+        // Peek at highest priority job
+        $result = $this->redis->zRange($this->priorityKey, 0, 0);
+
+        if (!empty($result)) {
+            $serializedPayload = $result[0];
+            $payload = $this->serializer->unserialize($serializedPayload);
+
+            if ($payload instanceof JobPayload) {
+                return $payload;
+            }
+        }
+
+        return null;
+    }
+
+    public function size(): int
+    {
+        $prioritySize = $this->redis->zCard($this->priorityKey);
+        $delayedSize = $this->redis->zCard($this->delayedKey);
+
+        return $prioritySize + $delayedSize;
+    }
+
+    public function clear(): int
+    {
+        $prioritySize = $this->redis->zCard($this->priorityKey);
+        $delayedSize = $this->redis->zCard($this->delayedKey);
+        $totalSize = $prioritySize + $delayedSize;
+
+        // Clear all queues
+        $this->redis->del($this->priorityKey);
+        $this->redis->del($this->delayedKey);
+        $this->redis->del($this->statsKey);
+
+        return $totalSize;
+    }
+
+    public function getStats(): array
+    {
+        $stats = $this->redis->hGetAll($this->statsKey);
+
+        // Convert string values back to integers
+        $processedStats = [];
+        foreach ($stats as $key => $value) {
+            $processedStats[$key] = is_numeric($value) ? (int) $value : $value;
+        }
+
+        // Add real-time counts
+        $priorityBreakdown = $this->getPriorityBreakdown();
+
+        return [
+            'total_size' => $this->size(),
+            'priority_queue_size' => $this->redis->zCard($this->priorityKey),
+            'delayed_queue_size' => $this->redis->zCard($this->delayedKey),
+            'priority_breakdown' => $priorityBreakdown,
+            'stats' => $processedStats
+        ];
+    }
+
+    /**
+     * Calculate score for Redis sorted set (lower score = higher priority)
+     */
+    private function calculateScore(JobPayload $payload, int $currentTime): float
+    {
+        $priorityScore = 1000 - $payload->priority->value; // Invert for Redis (lower score = higher priority)
+        $timeScore = $currentTime / 1000000; // Microsecond precision for FIFO within same priority
+
+        return $priorityScore + $timeScore;
+    }
+
+    /**
+     * Process delayed jobs that are now ready
+     */
+    private function processDelayedJobs(): void
+    {
+        $currentTime = time();
+
+        // Get all delayed jobs that are ready (score <= current time)
+        $readyJobs = $this->redis->zRangeByScore($this->delayedKey, 0, $currentTime);
+
+        foreach ($readyJobs as $serializedPayload) {
+            // Remove from delayed queue
+            $this->redis->zRem($this->delayedKey, $serializedPayload);
+
+            // Deserialize to get the payload
+            $payload = $this->serializer->unserialize($serializedPayload);
+
+            if ($payload instanceof JobPayload) {
+                // Remove delay and add to priority queue
+                $payloadWithoutDelay = $payload->withDelay(\App\Framework\Core\ValueObjects\Duration::zero());
+                $score = $this->calculateScore($payloadWithoutDelay, $currentTime);
+                $this->redis->zAdd($this->priorityKey, $score, $this->serializer->serialize($payloadWithoutDelay));
+            }
+        }
+    }
+
+    /**
+     * Update queue statistics
+     */
+    private function updateStats(string $operation, string $priority): void
+    {
+        $this->redis->hIncrBy($this->statsKey, "total_{$operation}", 1);
+        $this->redis->hIncrBy($this->statsKey, "{$priority}_{$operation}", 1);
+        $this->redis->hSet($this->statsKey, 'last_activity', time());
+    }
+
+    /**
+     * Get priority breakdown of current queue
+     */
+    private function getPriorityBreakdown(): array
+    {
+        $breakdown = [];
+
+        // Get all jobs in priority queue
+        $allJobs = $this->redis->zRange($this->priorityKey, 0, -1);
+
+        foreach ($allJobs as $serializedPayload) {
+            $payload = $this->serializer->unserialize($serializedPayload);
+
+            if ($payload instanceof JobPayload) {
+                $priority = $payload->priority->toString();
+                $breakdown[$priority] = ($breakdown[$priority] ?? 0) + 1;
+            }
+        }
+
+        // Add delayed jobs
+        $delayedJobs = $this->redis->zRange($this->delayedKey, 0, -1);
+
+        foreach ($delayedJobs as $serializedPayload) {
+            $payload = $this->serializer->unserialize($serializedPayload);
+
+            if ($payload instanceof JobPayload) {
+                $priority = $payload->priority->toString();
+                $breakdown[$priority] = ($breakdown[$priority] ?? 0) + 1;
+            }
+        }
+
+        return $breakdown;
+    }
+
+    /**
+     * Get number of delayed jobs ready for processing
+     */
+    public function getReadyDelayedCount(): int
+    {
+        $currentTime = time();
+        return $this->redis->zCount($this->delayedKey, 0, $currentTime);
+    }
+
+    /**
+     * Get delayed jobs scheduled for future processing
+     */
+    public function getScheduledCount(): int
+    {
+        $currentTime = time();
+        return $this->redis->zCount($this->delayedKey, $currentTime + 1, '+inf');
+    }
+
+    /**
+     * Cleanup expired or old jobs (maintenance operation)
+     */
+    public function cleanup(int $maxAge = 86400): int
+    {
+        $cutoffTime = time() - $maxAge;
+        $removed = 0;
+
+        // Remove old jobs from delayed queue that are too old
+        $removed += $this->redis->zRemRangeByScore($this->delayedKey, 0, $cutoffTime - $maxAge);
+
+        return $removed;
+    }
 }

src/Framework/Queue/RetryStrategyHelper.php

@@ -0,0 +1,164 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue;
+
+use App\Framework\Retry\RetryStrategy;
+use App\Framework\Retry\Strategies\ExponentialBackoffStrategy;
+use App\Framework\Retry\Strategies\FixedRetryStrategy;
+use App\Framework\Retry\Strategies\LinearDelayStrategy;
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Queue-specific Retry Strategy Helper
+ *
+ * Provides queue-optimized retry strategies for different job types
+ */
+final readonly class RetryStrategyHelper
+{
+    /**
+     * Get recommended retry strategy for queue scenarios
+     */
+    public static function forScenario(string $scenario): RetryStrategy
+    {
+        return match ($scenario) {
+            'command' => self::forCommands(),
+            'event' => self::forEvents(),
+            'email' => self::forEmails(),
+            'webhook' => self::forWebhooks(),
+            'report' => self::forReports(),
+            'import' => self::forImports(),
+            default => self::forGeneral()
+        };
+    }
+
+    /**
+     * Retry strategy for command processing
+     * Fast failure for user-facing operations
+     */
+    public static function forCommands(): RetryStrategy
+    {
+        return new ExponentialBackoffStrategy(
+            maxAttempts: 3,
+            initialDelay: Duration::fromMilliseconds(50),
+            multiplier: 2.0,
+            maxDelay: Duration::fromSeconds(5),
+            useJitter: false // Commands should be predictable
+        );
+    }
+
+    /**
+     * Retry strategy for event processing
+     * More retries with backoff for eventual consistency
+     */
+    public static function forEvents(): RetryStrategy
+    {
+        return new ExponentialBackoffStrategy(
+            maxAttempts: 5,
+            initialDelay: Duration::fromMilliseconds(100),
+            multiplier: 2.0,
+            maxDelay: Duration::fromSeconds(30),
+            useJitter: true
+        );
+    }
+
+    /**
+     * Retry strategy for email sending
+     * Many retries with longer delays for delivery issues
+     */
+    public static function forEmails(): RetryStrategy
+    {
+        return new ExponentialBackoffStrategy(
+            maxAttempts: 10,
+            initialDelay: Duration::fromSeconds(1),
+            multiplier: 1.5,
+            maxDelay: Duration::fromMinutes(30),
+            useJitter: true
+        );
+    }
+
+    /**
+     * Retry strategy for webhook delivery
+     * Moderate retries for external service calls
+     */
+    public static function forWebhooks(): RetryStrategy
+    {
+        return new ExponentialBackoffStrategy(
+            maxAttempts: 5,
+            initialDelay: Duration::fromSeconds(1),
+            multiplier: 2.0,
+            maxDelay: Duration::fromMinutes(10),
+            useJitter: true
+        );
+    }
+
+    /**
+     * Retry strategy for report generation
+     * Few retries for resource-intensive operations
+     */
+    public static function forReports(): RetryStrategy
+    {
+        return new LinearDelayStrategy(
+            maxAttempts: 3,
+            initialDelay: Duration::fromMinutes(1),
+            increment: Duration::fromMinutes(2)
+        );
+    }
+
+    /**
+     * Retry strategy for data imports
+     * Linear backoff for batch operations
+     */
+    public static function forImports(): RetryStrategy
+    {
+        return new LinearDelayStrategy(
+            maxAttempts: 5,
+            initialDelay: Duration::fromMinutes(2),
+            increment: Duration::fromMinutes(5)
+        );
+    }
+
+    /**
+     * General purpose retry strategy
+     */
+    public static function forGeneral(): RetryStrategy
+    {
+        return new ExponentialBackoffStrategy(
+            maxAttempts: 3,
+            initialDelay: Duration::fromMilliseconds(200),
+            multiplier: 2.0,
+            maxDelay: Duration::fromSeconds(10),
+            useJitter: true
+        );
+    }
+
+    /**
+     * No retry strategy (fail fast)
+     */
+    public static function none(): RetryStrategy
+    {
+        return new FixedRetryStrategy(
+            maxAttempts: 1 // Only one attempt
+        );
+    }
+
+    /**
+     * Create custom retry strategy with queue-optimized defaults
+     */
+    public static function custom(
+        int $maxAttempts,
+        Duration $initialDelay,
+        float $multiplier = 2.0,
+        ?Duration $maxDelay = null,
+        bool $useJitter = true
+    ): RetryStrategy {
+        return new ExponentialBackoffStrategy(
+            maxAttempts: $maxAttempts,
+            initialDelay: $initialDelay,
+            multiplier: $multiplier,
+            maxDelay: $maxDelay ?? Duration::fromMinutes(30),
+            useJitter: $useJitter
+        );
+    }
+}

src/Framework/Queue/Services/DatabaseDeadLetterQueue.php

@@ -0,0 +1,201 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\EntityManager;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Queue\Contracts\DeadLetterQueueInterface;
+use App\Framework\Queue\Contracts\QueueInterface;
+use App\Framework\Queue\Entities\DeadLetterJob;
+use App\Framework\Queue\ValueObjects\DeadLetterQueueName;
+use App\Framework\Queue\ValueObjects\JobPayload;
+use App\Framework\Queue\ValueObjects\QueueName;
+use App\Framework\Queue\ValueObjects\QueuePriority;
+
+/**
+ * Database-backed Dead Letter Queue implementation
+ */
+final readonly class DatabaseDeadLetterQueue implements DeadLetterQueueInterface
+{
+    public function __construct(
+        private ConnectionInterface $connection,
+        private EntityManager $entityManager,
+        private QueueInterface $originalQueue
+    ) {}
+
+    public function addFailedJob(DeadLetterJob $deadLetterJob): void
+    {
+        $this->entityManager->persist($deadLetterJob);
+        $this->entityManager->flush();
+    }
+
+    public function getJobs(DeadLetterQueueName $deadLetterQueueName, int $limit = 100): array
+    {
+        $sql = "
+            SELECT * FROM dead_letter_jobs
+            WHERE dead_letter_queue = ?
+            ORDER BY moved_to_dlq_at DESC
+            LIMIT ?
+        ";
+
+        $result = $this->connection->query(SqlQuery::create($sql, [$deadLetterQueueName->toString(), $limit]));
+        $rows = $result->fetchAll();
+
+        return array_map([$this, 'mapRowToDeadLetterJob'], $rows);
+    }
+
+    public function getJobsByOriginalQueue(QueueName $originalQueue, int $limit = 100): array
+    {
+        $sql = "
+            SELECT * FROM dead_letter_jobs
+            WHERE original_queue = ?
+            ORDER BY moved_to_dlq_at DESC
+            LIMIT ?
+        ";
+
+        $result = $this->connection->query(SqlQuery::create($sql, [$originalQueue->toString(), $limit]));
+        $rows = $result->fetchAll();
+
+        return array_map([$this, 'mapRowToDeadLetterJob'], $rows);
+    }
+
+    public function retryJob(string $deadLetterJobId): bool
+    {
+        $this->connection->beginTransaction();
+
+        try {
+            // Get the dead letter job
+            $deadLetterJob = $this->findDeadLetterJob($deadLetterJobId);
+            if (!$deadLetterJob) {
+                return false;
+            }
+
+            // Add job back to original queue
+            $jobPayload = $deadLetterJob->getJobPayload();
+            $originalQueue = $deadLetterJob->getOriginalQueueName();
+
+            $this->originalQueue->push(
+                payload: $jobPayload,
+                queueName: $originalQueue,
+                priority: QueuePriority::NORMAL
+            );
+
+            // Update retry count and timestamp
+            $updatedJob = $deadLetterJob->withRetryAttempt();
+            $this->entityManager->persist($updatedJob);
+
+            // Delete from dead letter queue
+            $this->deleteJobById($deadLetterJobId);
+
+            $this->entityManager->flush();
+            $this->connection->commit();
+
+            return true;
+        } catch (\Throwable $e) {
+            $this->connection->rollback();
+            throw $e;
+        }
+    }
+
+    public function deleteJob(string $deadLetterJobId): bool
+    {
+        return $this->deleteJobById($deadLetterJobId);
+    }
+
+    public function retryAllJobs(DeadLetterQueueName $deadLetterQueueName): int
+    {
+        $jobs = $this->getJobs($deadLetterQueueName, 1000); // Get all jobs
+        $retriedCount = 0;
+
+        foreach ($jobs as $job) {
+            if ($this->retryJob($job->id)) {
+                $retriedCount++;
+            }
+        }
+
+        return $retriedCount;
+    }
+
+    public function clearQueue(DeadLetterQueueName $deadLetterQueueName): int
+    {
+        $sql = "DELETE FROM dead_letter_jobs WHERE dead_letter_queue = ?";
+        return $this->connection->execute(SqlQuery::create($sql, [$deadLetterQueueName->toString()]));
+    }
+
+    public function getQueueStats(DeadLetterQueueName $deadLetterQueueName): array
+    {
+        $sql = "
+            SELECT
+                COUNT(*) as total_jobs,
+                AVG(failed_attempts) as avg_failed_attempts,
+                MAX(failed_attempts) as max_failed_attempts,
+                AVG(retry_count) as avg_retry_count,
+                MAX(retry_count) as max_retry_count,
+                MIN(moved_to_dlq_at) as oldest_job,
+                MAX(moved_to_dlq_at) as newest_job
+            FROM dead_letter_jobs
+            WHERE dead_letter_queue = ?
+        ";
+
+        $stats = $this->connection->queryOne(SqlQuery::create($sql, [$deadLetterQueueName->toString()]));
+
+        return [
+            'queue_name' => $deadLetterQueueName->toString(),
+            'total_jobs' => (int) $stats['total_jobs'],
+            'avg_failed_attempts' => round((float) $stats['avg_failed_attempts'], 2),
+            'max_failed_attempts' => (int) $stats['max_failed_attempts'],
+            'avg_retry_count' => round((float) $stats['avg_retry_count'], 2),
+            'max_retry_count' => (int) $stats['max_retry_count'],
+            'oldest_job' => $stats['oldest_job'],
+            'newest_job' => $stats['newest_job']
+        ];
+    }
+
+    public function getAvailableQueues(): array
+    {
+        $sql = "SELECT DISTINCT dead_letter_queue FROM dead_letter_jobs ORDER BY dead_letter_queue";
+        $result = $this->connection->query(SqlQuery::create($sql));
+        $rows = $result->fetchAll();
+
+        return array_map(
+            fn (array $row) => DeadLetterQueueName::fromString($row['dead_letter_queue']),
+            $rows
+        );
+    }
+
+    private function findDeadLetterJob(string $deadLetterJobId): ?DeadLetterJob
+    {
+        $sql = "SELECT * FROM dead_letter_jobs WHERE id = ?";
+        $row = $this->connection->queryOne(SqlQuery::create($sql, [$deadLetterJobId]));
+
+        return $row ? $this->mapRowToDeadLetterJob($row) : null;
+    }
+
+    private function deleteJobById(string $deadLetterJobId): bool
+    {
+        $sql = "DELETE FROM dead_letter_jobs WHERE id = ?";
+        return $this->connection->execute(SqlQuery::create($sql, [$deadLetterJobId])) > 0;
+    }
+
+    private function mapRowToDeadLetterJob(array $row): DeadLetterJob
+    {
+        return new DeadLetterJob(
+            id: $row['id'],
+            originalJobId: $row['original_job_id'],
+            deadLetterQueue: $row['dead_letter_queue'],
+            originalQueue: $row['original_queue'],
+            jobPayload: $row['job_payload'],
+            failureReason: $row['failure_reason'],
+            exceptionType: $row['exception_type'],
+            stackTrace: $row['stack_trace'],
+            failedAttempts: (int) $row['failed_attempts'],
+            failedAt: $row['failed_at'],
+            movedToDlqAt: $row['moved_to_dlq_at'],
+            retryCount: (int) $row['retry_count'],
+            lastRetryAt: $row['last_retry_at']
+        );
+    }
+}

src/Framework/Queue/Services/DatabaseDistributedLock.php

@@ -0,0 +1,411 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Interfaces\DistributedLockInterface;
+use App\Framework\Queue\ValueObjects\LockKey;
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+
+/**
+ * Database-basierte Distributed Lock Implementation
+ */
+final readonly class DatabaseDistributedLock implements DistributedLockInterface
+{
+    private const TABLE_NAME = 'distributed_locks';
+    private const MAX_TIMEOUT_ATTEMPTS = 100;
+    private const TIMEOUT_SLEEP_MS = 100;
+
+    public function __construct(
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Lock erwerben
+     */
+    public function acquire(LockKey $key, WorkerId $workerId, Duration $ttl): bool
+    {
+        $this->logger->debug('Attempting to acquire lock', LogContext::withData([
+            'lock_key' => $key->toString(),
+            'worker_id' => $workerId->toString(),
+            'ttl_seconds' => $ttl->toSeconds()
+        ]));
+
+        try {
+            $expiresAt = new \DateTimeImmutable('+' . $ttl->toSeconds() . ' seconds');
+
+            // Versuche Lock zu erstellen
+            $sql = "INSERT INTO " . self::TABLE_NAME . " (
+                        lock_key, worker_id, acquired_at, expires_at
+                    ) VALUES (
+                        :lock_key, :worker_id, NOW(), :expires_at
+                    )";
+
+            $affectedRows = $this->connection->execute(SqlQuery::create($sql, [
+                'lock_key' => $key->toString(),
+                'worker_id' => $workerId->toString(),
+                'expires_at' => $expiresAt->format('Y-m-d H:i:s')
+            ]));
+
+            if ($affectedRows > 0) {
+                $this->logger->info('Lock acquired successfully', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString()
+                ]));
+                return true;
+            }
+
+            return false;
+
+        } catch (\Exception $e) {
+            // Duplicate key error = Lock bereits vorhanden
+            if ($this->isDuplicateKeyError($e)) {
+                $this->logger->debug('Lock already exists', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString()
+                ]));
+                return false;
+            }
+
+            $this->logger->error('Failed to acquire lock', LogContext::withData([
+                'lock_key' => $key->toString(),
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Lock verlängern
+     */
+    public function extend(LockKey $key, WorkerId $workerId, Duration $ttl): bool
+    {
+        $this->logger->debug('Attempting to extend lock', LogContext::withData([
+            'lock_key' => $key->toString(),
+            'worker_id' => $workerId->toString(),
+            'ttl_seconds' => $ttl->toSeconds()
+        ]));
+
+        try {
+            $expiresAt = new \DateTimeImmutable('+' . $ttl->toSeconds() . ' seconds');
+
+            $sql = "UPDATE " . self::TABLE_NAME . "
+                   SET expires_at = :expires_at
+                   WHERE lock_key = :lock_key
+                   AND worker_id = :worker_id
+                   AND expires_at > NOW()";
+
+            $affectedRows = $this->connection->execute(SqlQuery::create($sql, [
+                'lock_key' => $key->toString(),
+                'worker_id' => $workerId->toString(),
+                'expires_at' => $expiresAt->format('Y-m-d H:i:s')
+            ]));
+
+            $success = $affectedRows > 0;
+
+            if ($success) {
+                $this->logger->debug('Lock extended successfully', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString()
+                ]));
+            } else {
+                $this->logger->warning('Failed to extend lock - not owned or expired', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString()
+                ]));
+            }
+
+            return $success;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to extend lock', LogContext::withData([
+                'lock_key' => $key->toString(),
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Lock freigeben
+     */
+    public function release(LockKey $key, WorkerId $workerId): bool
+    {
+        $this->logger->debug('Attempting to release lock', LogContext::withData([
+            'lock_key' => $key->toString(),
+            'worker_id' => $workerId->toString()
+        ]));
+
+        try {
+            $sql = "DELETE FROM " . self::TABLE_NAME . "
+                   WHERE lock_key = :lock_key
+                   AND worker_id = :worker_id";
+
+            $affectedRows = $this->connection->execute(SqlQuery::create($sql, [
+                'lock_key' => $key->toString(),
+                'worker_id' => $workerId->toString()
+            ]));
+
+            $success = $affectedRows > 0;
+
+            if ($success) {
+                $this->logger->info('Lock released successfully', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString()
+                ]));
+            } else {
+                $this->logger->warning('Lock not found or not owned by worker', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString()
+                ]));
+            }
+
+            return $success;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to release lock', LogContext::withData([
+                'lock_key' => $key->toString(),
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Prüfe ob Lock existiert
+     */
+    public function exists(LockKey $key): bool
+    {
+        try {
+            $sql = "SELECT COUNT(*) as count FROM " . self::TABLE_NAME . "
+                   WHERE lock_key = :lock_key
+                   AND expires_at > NOW()";
+
+            $result = $this->connection->queryOne(SqlQuery::create($sql, ['lock_key' => $key->toString()]));
+            return (int) $result['count'] > 0;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to check lock existence', LogContext::withData([
+                'lock_key' => $key->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Lock Informationen abrufen
+     */
+    public function getLockInfo(LockKey $key): ?array
+    {
+        try {
+            $sql = "SELECT * FROM " . self::TABLE_NAME . "
+                   WHERE lock_key = :lock_key
+                   AND expires_at > NOW()";
+
+            $data = $this->connection->queryOne(SqlQuery::create($sql, ['lock_key' => $key->toString()]));
+            if (!$data) {
+                return null;
+            }
+
+            return [
+                'lock_key' => $data['lock_key'],
+                'worker_id' => $data['worker_id'],
+                'acquired_at' => $data['acquired_at'],
+                'expires_at' => $data['expires_at'],
+                'ttl_seconds' => strtotime($data['expires_at']) - time()
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to get lock info', LogContext::withData([
+                'lock_key' => $key->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Lock mit Timeout versuchen
+     */
+    public function acquireWithTimeout(LockKey $key, WorkerId $workerId, Duration $ttl, Duration $timeout): bool
+    {
+        $this->logger->debug('Attempting to acquire lock with timeout', LogContext::withData([
+            'lock_key' => $key->toString(),
+            'worker_id' => $workerId->toString(),
+            'ttl_seconds' => $ttl->toSeconds(),
+            'timeout_seconds' => $timeout->toSeconds()
+        ]));
+
+        $startTime = microtime(true);
+        $timeoutSeconds = $timeout->toSeconds();
+        $attempts = 0;
+        $maxAttempts = min(self::MAX_TIMEOUT_ATTEMPTS, (int) ($timeoutSeconds * 1000 / self::TIMEOUT_SLEEP_MS));
+
+        while ($attempts < $maxAttempts) {
+            // Prüfe Timeout
+            if ((microtime(true) - $startTime) >= $timeoutSeconds) {
+                $this->logger->debug('Lock acquisition timeout reached', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString(),
+                    'attempts' => $attempts,
+                    'elapsed_seconds' => microtime(true) - $startTime
+                ]));
+                break;
+            }
+
+            // Versuche Lock zu erwerben
+            if ($this->acquire($key, $workerId, $ttl)) {
+                $this->logger->info('Lock acquired with timeout after attempts', LogContext::withData([
+                    'lock_key' => $key->toString(),
+                    'worker_id' => $workerId->toString(),
+                    'attempts' => $attempts + 1,
+                    'elapsed_seconds' => microtime(true) - $startTime
+                ]));
+                return true;
+            }
+
+            $attempts++;
+
+            // Kurz warten vor nächstem Versuch
+            usleep(self::TIMEOUT_SLEEP_MS * 1000);
+        }
+
+        $this->logger->info('Failed to acquire lock within timeout', LogContext::withData([
+            'lock_key' => $key->toString(),
+            'worker_id' => $workerId->toString(),
+            'attempts' => $attempts,
+            'timeout_seconds' => $timeoutSeconds
+        ]));
+
+        return false;
+    }
+
+    /**
+     * Alle Locks eines Workers freigeben
+     */
+    public function releaseAllWorkerLocks(WorkerId $workerId): int
+    {
+        $this->logger->info('Releasing all locks for worker', LogContext::withData([
+            'worker_id' => $workerId->toString()
+        ]));
+
+        try {
+            $sql = "DELETE FROM " . self::TABLE_NAME . "
+                   WHERE worker_id = :worker_id";
+
+            $count = $this->connection->execute(SqlQuery::create($sql, ['worker_id' => $workerId->toString()]));
+
+            $this->logger->info('Released all worker locks', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'released_count' => $count
+            ]));
+
+            return $count;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to release worker locks', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Abgelaufene Locks aufräumen
+     */
+    public function cleanupExpiredLocks(): int
+    {
+        $this->logger->debug('Starting cleanup of expired locks');
+
+        try {
+            $sql = "DELETE FROM " . self::TABLE_NAME . "
+                   WHERE expires_at <= NOW()";
+
+            $count = $this->connection->execute(SqlQuery::create($sql));
+
+            $this->logger->info('Cleaned up expired locks', LogContext::withData([
+                'cleaned_count' => $count
+            ]));
+
+            return $count;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to cleanup expired locks', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Lock Statistiken
+     */
+    public function getLockStatistics(): array
+    {
+        try {
+            $sql = "SELECT
+                       COUNT(*) as total_locks,
+                       COUNT(CASE WHEN expires_at > NOW() THEN 1 END) as active_locks,
+                       COUNT(CASE WHEN expires_at <= NOW() THEN 1 END) as expired_locks,
+                       COUNT(DISTINCT worker_id) as unique_workers,
+                       AVG(TIMESTAMPDIFF(SECOND, acquired_at, expires_at)) as avg_ttl_seconds,
+                       MIN(acquired_at) as oldest_lock,
+                       MAX(acquired_at) as newest_lock
+                   FROM " . self::TABLE_NAME;
+
+            $stats = $this->connection->queryOne(SqlQuery::create($sql));
+
+            // Top Lock Keys
+            $topKeysSql = "SELECT lock_key, COUNT(*) as count
+                          FROM " . self::TABLE_NAME . "
+                          WHERE expires_at > NOW()
+                          GROUP BY lock_key
+                          ORDER BY count DESC
+                          LIMIT 10";
+
+            $result = $this->connection->query(SqlQuery::create($topKeysSql));
+            $topKeys = $result->fetchAll();
+
+            return [
+                'total_locks' => (int) $stats['total_locks'],
+                'active_locks' => (int) $stats['active_locks'],
+                'expired_locks' => (int) $stats['expired_locks'],
+                'unique_workers' => (int) $stats['unique_workers'],
+                'avg_ttl_seconds' => round((float) $stats['avg_ttl_seconds'], 2),
+                'oldest_lock' => $stats['oldest_lock'],
+                'newest_lock' => $stats['newest_lock'],
+                'top_lock_keys' => $topKeys
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to get lock statistics', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Prüfe ob Exception ein Duplicate Key Error ist
+     */
+    private function isDuplicateKeyError(\Exception $e): bool
+    {
+        $message = strtolower($e->getMessage());
+        return strpos($message, 'duplicate') !== false
+            || strpos($message, 'unique') !== false
+            || $e->getCode() === 23000; // SQLSTATE für Constraint Violation
+    }
+}

src/Framework/Queue/Services/DatabaseJobBatchManager.php

@@ -0,0 +1,249 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Queue\Contracts\JobBatchManagerInterface;
+use App\Framework\Queue\ValueObjects\JobBatch;
+use App\Framework\Queue\ValueObjects\JobBatchStatus;
+use App\Framework\Core\ValueObjects\Timestamp;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+
+/**
+ * Database-based job batch manager
+ */
+final readonly class DatabaseJobBatchManager implements JobBatchManagerInterface
+{
+    public function __construct(
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    public function createBatch(string $name, array $jobIds, array $options = []): JobBatch
+    {
+        $batchId = $this->generateBatchId();
+        $batch = JobBatch::create($batchId, $name, $jobIds, $options);
+
+        $sql = "INSERT INTO job_batches (
+            batch_id, name, job_ids, status, total_jobs,
+            processed_jobs, failed_jobs, options, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+        $this->connection->execute(SqlQuery::create($sql, [
+            $batch->batchId,
+            $batch->name,
+            json_encode($batch->jobIds),
+            $batch->status->value,
+            $batch->totalJobs,
+            $batch->processedJobs,
+            $batch->failedJobs,
+            json_encode($batch->options),
+            $batch->createdAt->toSqlString()
+        ]));
+
+        $this->logger->info('Job batch created', LogContext::withData([
+            'batch_id' => $batch->batchId,
+            'name' => $batch->name,
+            'total_jobs' => $batch->totalJobs
+        ]));
+
+        return $batch;
+    }
+
+    public function getBatch(string $batchId): ?JobBatch
+    {
+        $sql = "SELECT * FROM job_batches WHERE batch_id = ?";
+        $row = $this->connection->queryOne(SqlQuery::create($sql, [$batchId]));
+
+        if (!$row) {
+            return null;
+        }
+
+        return $this->hydrateFromRow($row);
+    }
+
+    public function recordJobCompleted(string $batchId, string $jobId): void
+    {
+        $batch = $this->getBatch($batchId);
+        if (!$batch) {
+            return;
+        }
+
+        $updatedBatch = $batch->incrementProcessed();
+        $this->updateBatch($updatedBatch);
+
+        $this->logger->debug('Job batch progress updated', LogContext::withData([
+            'batch_id' => $batchId,
+            'job_id' => $jobId,
+            'progress' => $updatedBatch->getProgressPercentage()
+        ]));
+    }
+
+    public function recordJobFailed(string $batchId, string $jobId): void
+    {
+        $batch = $this->getBatch($batchId);
+        if (!$batch) {
+            return;
+        }
+
+        $updatedBatch = $batch->incrementFailed();
+        $this->updateBatch($updatedBatch);
+
+        $this->logger->warning('Job batch job failed', LogContext::withData([
+            'batch_id' => $batchId,
+            'job_id' => $jobId,
+            'failed_jobs' => $updatedBatch->failedJobs
+        ]));
+    }
+
+    public function cancelBatch(string $batchId): bool
+    {
+        $sql = "UPDATE job_batches SET status = ?, cancelled_at = ? WHERE batch_id = ?";
+        $affected = $this->connection->execute(SqlQuery::create($sql, [
+            JobBatchStatus::CANCELLED->value,
+            date('Y-m-d H:i:s'),
+            $batchId
+        ]));
+
+        if ($affected > 0) {
+            $this->logger->info('Job batch cancelled', LogContext::withData([
+                'batch_id' => $batchId
+            ]));
+        }
+
+        return $affected > 0;
+    }
+
+    public function getBatchesByStatus(JobBatchStatus $status, int $limit = 50): array
+    {
+        $sql = "SELECT * FROM job_batches WHERE status = ? ORDER BY created_at DESC LIMIT ?";
+        $result = $this->connection->query(SqlQuery::create($sql, [$status->value, $limit]));
+
+        $batches = [];
+        foreach ($result->fetchAll() as $row) {
+            $batches[] = $this->hydrateFromRow($row);
+        }
+
+        return $batches;
+    }
+
+    public function getBatchStats(): array
+    {
+        $sql = "SELECT
+            status,
+            COUNT(*) as count,
+            AVG(processed_jobs) as avg_processed,
+            SUM(total_jobs) as total_jobs,
+            SUM(failed_jobs) as total_failed
+        FROM job_batches
+        GROUP BY status";
+
+        $result = $this->connection->query(SqlQuery::create($sql));
+        $stats = [];
+
+        foreach ($result->fetchAll() as $row) {
+            $stats[$row['status']] = [
+                'count' => (int) $row['count'],
+                'avg_processed' => (float) $row['avg_processed'],
+                'total_jobs' => (int) $row['total_jobs'],
+                'total_failed' => (int) $row['total_failed']
+            ];
+        }
+
+        return $stats;
+    }
+
+    public function cleanupOldBatches(int $olderThanDays = 30): int
+    {
+        $cutoffDate = date('Y-m-d H:i:s', strtotime("-{$olderThanDays} days"));
+
+        $sql = "DELETE FROM job_batches
+                WHERE created_at < ?
+                AND status IN (?, ?, ?)";
+
+        $deleted = $this->connection->execute(SqlQuery::create($sql, [
+            $cutoffDate,
+            JobBatchStatus::COMPLETED->value,
+            JobBatchStatus::FAILED->value,
+            JobBatchStatus::CANCELLED->value
+        ]));
+
+        if ($deleted > 0) {
+            $this->logger->info('Cleaned up old job batches', LogContext::withData([
+                'deleted_count' => $deleted,
+                'older_than_days' => $olderThanDays
+            ]));
+        }
+
+        return $deleted;
+    }
+
+    public function getBatchProgress(string $batchId): array
+    {
+        $batch = $this->getBatch($batchId);
+        if (!$batch) {
+            return [];
+        }
+
+        return [
+            'batch_id' => $batch->batchId,
+            'name' => $batch->name,
+            'status' => $batch->status->value,
+            'progress_percentage' => $batch->getProgressPercentage(),
+            'total_jobs' => $batch->totalJobs,
+            'processed_jobs' => $batch->processedJobs,
+            'failed_jobs' => $batch->failedJobs,
+            'remaining_jobs' => $batch->getRemainingJobs(),
+            'is_finished' => $batch->isFinished()
+        ];
+    }
+
+    private function updateBatch(JobBatch $batch): void
+    {
+        $sql = "UPDATE job_batches SET
+            status = ?,
+            processed_jobs = ?,
+            failed_jobs = ?,
+            started_at = ?,
+            completed_at = ?,
+            failed_at = ?
+        WHERE batch_id = ?";
+
+        $this->connection->execute(SqlQuery::create($sql, [
+            $batch->status->value,
+            $batch->processedJobs,
+            $batch->failedJobs,
+            $batch->startedAt?->toSqlString(),
+            $batch->completedAt?->toSqlString(),
+            $batch->failedAt?->toSqlString(),
+            $batch->batchId
+        ]));
+    }
+
+    private function hydrateFromRow(array $row): JobBatch
+    {
+        return new JobBatch(
+            batchId: $row['batch_id'],
+            name: $row['name'],
+            jobIds: json_decode($row['job_ids'], true),
+            status: JobBatchStatus::from($row['status']),
+            totalJobs: (int) $row['total_jobs'],
+            processedJobs: (int) $row['processed_jobs'],
+            failedJobs: (int) $row['failed_jobs'],
+            createdAt: $row['created_at'] ? Timestamp::fromString($row['created_at']) : null,
+            startedAt: $row['started_at'] ? Timestamp::fromString($row['started_at']) : null,
+            completedAt: $row['completed_at'] ? Timestamp::fromString($row['completed_at']) : null,
+            failedAt: $row['failed_at'] ? Timestamp::fromString($row['failed_at']) : null,
+            options: json_decode($row['options'] ?? '{}', true)
+        );
+    }
+
+    private function generateBatchId(): string
+    {
+        return 'batch_' . uniqid() . '_' . time();
+    }
+}

src/Framework/Queue/Services/DatabaseJobChainManager.php

@@ -0,0 +1,337 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Contracts\JobChainManagerInterface;
+use App\Framework\Queue\ValueObjects\JobChain;
+use App\Framework\Queue\Entities\JobChainEntry;
+use App\Framework\Database\EntityManagerInterface;
+use App\Framework\Logging\Logger;
+
+final readonly class DatabaseJobChainManager implements JobChainManagerInterface
+{
+    public function __construct(
+        private EntityManagerInterface $entityManager,
+        private Logger $logger
+    ) {}
+
+    public function createChain(JobChain $jobChain): void
+    {
+        $entry = JobChainEntry::fromJobChain($jobChain);
+
+        $this->logger->info('Creating job chain', [
+            'chain_id' => $jobChain->chainId,
+            'name' => $jobChain->name,
+            'job_count' => count($jobChain->jobIds),
+            'execution_mode' => $jobChain->executionMode->value
+        ]);
+
+        $this->entityManager->save($entry);
+        $this->entityManager->flush();
+    }
+
+    public function getChain(string $chainId): ?JobChainEntry
+    {
+        $query = "SELECT * FROM job_chains WHERE chain_id = ?";
+        $result = $this->entityManager->getConnection()->fetchOne($query, [$chainId]);
+
+        if (!$result) {
+            return null;
+        }
+
+        return $this->mapRowToEntity($result);
+    }
+
+    public function updateChain(JobChain $jobChain): void
+    {
+        $existing = $this->getChain($jobChain->chainId);
+
+        if (!$existing) {
+            throw new \RuntimeException("Chain with ID '{$jobChain->chainId}' not found");
+        }
+
+        $updated = new JobChainEntry(
+            id: $existing->id,
+            chainId: $jobChain->chainId,
+            name: $jobChain->name,
+            jobIds: json_encode($jobChain->jobIds),
+            executionMode: $jobChain->executionMode->value,
+            createdAt: $existing->createdAt,
+            updatedAt: date('Y-m-d H:i:s'),
+            stopOnFailure: $jobChain->stopOnFailure,
+            metadata: $jobChain->metadata ? json_encode($jobChain->metadata) : null,
+            status: $existing->status,
+            startedAt: $existing->startedAt,
+            completedAt: $existing->completedAt
+        );
+
+        $this->logger->info('Updating job chain', [
+            'chain_id' => $jobChain->chainId,
+            'name' => $jobChain->name
+        ]);
+
+        $this->entityManager->save($updated);
+        $this->entityManager->flush();
+    }
+
+    public function deleteChain(string $chainId): void
+    {
+        $query = "DELETE FROM job_chains WHERE chain_id = ?";
+
+        $this->logger->info('Deleting job chain', [
+            'chain_id' => $chainId
+        ]);
+
+        $this->entityManager->getConnection()->execute($query, [$chainId]);
+    }
+
+    public function startChain(string $chainId): void
+    {
+        $chain = $this->getChain($chainId);
+
+        if (!$chain) {
+            throw new \RuntimeException("Chain with ID '{$chainId}' not found");
+        }
+
+        if (!$chain->isPending()) {
+            throw new \RuntimeException("Chain '{$chainId}' is not in pending status");
+        }
+
+        $started = $chain->markAsStarted();
+
+        $this->logger->info('Starting job chain', [
+            'chain_id' => $chainId,
+            'job_count' => count($started->getJobIdsArray())
+        ]);
+
+        $this->entityManager->save($started);
+        $this->entityManager->flush();
+    }
+
+    public function getChainsForJob(string $jobId): array
+    {
+        $query = "SELECT * FROM job_chains WHERE JSON_CONTAINS(job_ids, ?)";
+        $results = $this->entityManager->getConnection()->fetchAll($query, [json_encode($jobId)]);
+
+        return array_map(function(array $row) {
+            return $this->mapRowToEntity($row);
+        }, $results);
+    }
+
+    public function getActiveChains(): array
+    {
+        $query = "SELECT * FROM job_chains WHERE status = 'running' ORDER BY started_at";
+        $results = $this->entityManager->getConnection()->fetchAll($query);
+
+        return array_map(function(array $row) {
+            return $this->mapRowToEntity($row);
+        }, $results);
+    }
+
+    public function getPendingChains(): array
+    {
+        $query = "SELECT * FROM job_chains WHERE status = 'pending' ORDER BY created_at";
+        $results = $this->entityManager->getConnection()->fetchAll($query);
+
+        return array_map(function(array $row) {
+            return $this->mapRowToEntity($row);
+        }, $results);
+    }
+
+    public function markChainAsCompleted(string $chainId): void
+    {
+        $chain = $this->getChain($chainId);
+
+        if (!$chain) {
+            throw new \RuntimeException("Chain with ID '{$chainId}' not found");
+        }
+
+        $completed = $chain->markAsCompleted();
+
+        $this->logger->info('Marking chain as completed', [
+            'chain_id' => $chainId
+        ]);
+
+        $this->entityManager->save($completed);
+        $this->entityManager->flush();
+    }
+
+    public function markChainAsFailed(string $chainId): void
+    {
+        $chain = $this->getChain($chainId);
+
+        if (!$chain) {
+            throw new \RuntimeException("Chain with ID '{$chainId}' not found");
+        }
+
+        $failed = $chain->markAsFailed();
+
+        $this->logger->info('Marking chain as failed', [
+            'chain_id' => $chainId
+        ]);
+
+        $this->entityManager->save($failed);
+        $this->entityManager->flush();
+    }
+
+    public function getNextJobInChain(string $chainId, ?string $currentJobId = null): ?string
+    {
+        $chain = $this->getChain($chainId);
+
+        if (!$chain) {
+            return null;
+        }
+
+        $jobChain = $chain->getJobChain();
+
+        if ($currentJobId === null) {
+            // Return first job in chain
+            return $jobChain->jobIds[0] ?? null;
+        }
+
+        return $jobChain->getNextJob($currentJobId);
+    }
+
+    public function isChainComplete(string $chainId): bool
+    {
+        $chain = $this->getChain($chainId);
+
+        if (!$chain) {
+            return false;
+        }
+
+        return $chain->isCompleted() || $chain->isFailed();
+    }
+
+    public function handleJobCompletion(string $jobId, bool $successful = true): void
+    {
+        $chains = $this->getChainsForJob($jobId);
+
+        foreach ($chains as $chainEntry) {
+            if (!$chainEntry->isRunning()) {
+                continue;
+            }
+
+            $jobChain = $chainEntry->getJobChain();
+
+            // If chain requires stopping on failure and job failed
+            if (!$successful && $jobChain->stopOnFailure) {
+                $this->markChainAsFailed($chainEntry->chainId);
+                $this->logger->warning('Chain failed due to job failure', [
+                    'chain_id' => $chainEntry->chainId,
+                    'failed_job_id' => $jobId
+                ]);
+                continue;
+            }
+
+            // Check if this was the last job in the chain
+            $nextJobId = $this->getNextJobInChain($chainEntry->chainId, $jobId);
+
+            if ($nextJobId === null) {
+                // Chain is complete
+                $this->markChainAsCompleted($chainEntry->chainId);
+                $this->logger->info('Chain completed', [
+                    'chain_id' => $chainEntry->chainId,
+                    'last_job_id' => $jobId
+                ]);
+            } else {
+                $this->logger->info('Job completed in chain, next job available', [
+                    'chain_id' => $chainEntry->chainId,
+                    'completed_job_id' => $jobId,
+                    'next_job_id' => $nextJobId
+                ]);
+            }
+        }
+    }
+
+    public function getChainProgress(string $chainId): array
+    {
+        $chain = $this->getChain($chainId);
+
+        if (!$chain) {
+            throw new \RuntimeException("Chain with ID '{$chainId}' not found");
+        }
+
+        $jobChain = $chain->getJobChain();
+        $totalJobs = count($jobChain->jobIds);
+
+        // This would need integration with job status tracking
+        // For now, return basic progress based on chain status
+        $progress = match($chain->status) {
+            'pending' => [
+                'completed_jobs' => 0,
+                'total_jobs' => $totalJobs,
+                'percentage' => 0,
+                'status' => 'pending'
+            ],
+            'running' => [
+                'completed_jobs' => 0, // Would need actual job status check
+                'total_jobs' => $totalJobs,
+                'percentage' => 0, // Would calculate based on completed jobs
+                'status' => 'running'
+            ],
+            'completed' => [
+                'completed_jobs' => $totalJobs,
+                'total_jobs' => $totalJobs,
+                'percentage' => 100,
+                'status' => 'completed'
+            ],
+            'failed' => [
+                'completed_jobs' => 0, // Would need actual job status check
+                'total_jobs' => $totalJobs,
+                'percentage' => 0, // Partial progress before failure
+                'status' => 'failed'
+            ]
+        };
+
+        return array_merge($progress, [
+            'chain_id' => $chainId,
+            'name' => $chain->name,
+            'execution_mode' => $chain->executionMode,
+            'stop_on_failure' => $chain->stopOnFailure,
+            'started_at' => $chain->startedAt,
+            'completed_at' => $chain->completedAt
+        ]);
+    }
+
+    public function cleanupOldChains(int $olderThanDays = 30): int
+    {
+        $cutoffDate = date('Y-m-d H:i:s', strtotime("-{$olderThanDays} days"));
+
+        $query = "DELETE FROM job_chains
+                  WHERE status IN ('completed', 'failed') AND completed_at < ?";
+
+        $this->logger->info('Cleaning up old chains', [
+            'cutoff_date' => $cutoffDate,
+            'older_than_days' => $olderThanDays
+        ]);
+
+        $affectedRows = $this->entityManager->getConnection()->execute($query, [$cutoffDate]);
+
+        $this->logger->info('Old chains cleaned up', [
+            'deleted_count' => $affectedRows
+        ]);
+
+        return $affectedRows;
+    }
+
+    private function mapRowToEntity(array $row): JobChainEntry
+    {
+        return new JobChainEntry(
+            id: $row['id'],
+            chainId: $row['chain_id'],
+            name: $row['name'],
+            jobIds: $row['job_ids'],
+            executionMode: $row['execution_mode'],
+            createdAt: $row['created_at'],
+            updatedAt: $row['updated_at'],
+            stopOnFailure: (bool) $row['stop_on_failure'],
+            metadata: $row['metadata'],
+            status: $row['status'],
+            startedAt: $row['started_at'],
+            completedAt: $row['completed_at']
+        );
+    }
+}

src/Framework/Queue/Services/DatabaseJobDependencyManager.php

@@ -0,0 +1,292 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Contracts\JobDependencyManagerInterface;
+use App\Framework\Queue\ValueObjects\JobDependency;
+use App\Framework\Queue\Entities\JobDependencyEntry;
+use App\Framework\Database\EntityManagerInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+
+final readonly class DatabaseJobDependencyManager implements JobDependencyManagerInterface
+{
+    public function __construct(
+        private EntityManagerInterface $entityManager,
+        private Logger $logger
+    ) {}
+
+    public function addDependency(JobDependency $dependency): void
+    {
+        $entry = JobDependencyEntry::fromJobDependency($dependency);
+
+        $this->logger->info('Adding job dependency', [
+            'dependent_job_id' => $dependency->dependentJobId,
+            'depends_on_job_id' => $dependency->dependsOnJobId,
+            'type' => $dependency->type->value
+        ]);
+
+        $this->entityManager->save($entry);
+        $this->entityManager->flush();
+    }
+
+    public function removeDependency(string $dependentJobId, string $dependsOnJobId): void
+    {
+        $query = "DELETE FROM job_dependencies
+                  WHERE dependent_job_id = ? AND depends_on_job_id = ?";
+
+        $this->logger->info('Removing job dependency', [
+            'dependent_job_id' => $dependentJobId,
+            'depends_on_job_id' => $dependsOnJobId
+        ]);
+
+        $this->entityManager->getConnection()->execute(
+            SqlQuery::create($query, [$dependentJobId, $dependsOnJobId])
+        );
+    }
+
+    public function getDependencies(string $jobId): array
+    {
+        $query = "SELECT * FROM job_dependencies WHERE dependent_job_id = ? ORDER BY created_at";
+        $results = $this->entityManager->getConnection()->query(
+            SqlQuery::create($query, [$jobId])
+        )->fetchAll();
+
+        return array_map(function(array $row) {
+            return $this->mapRowToEntity($row);
+        }, $results);
+    }
+
+    public function getDependents(string $jobId): array
+    {
+        $query = "SELECT * FROM job_dependencies WHERE depends_on_job_id = ? ORDER BY created_at";
+        $results = $this->entityManager->getConnection()->query(
+            SqlQuery::create($query, [$jobId])
+        )->fetchAll();
+
+        return array_map(function(array $row) {
+            return $this->mapRowToEntity($row);
+        }, $results);
+    }
+
+    public function hasUnsatisfiedDependencies(string $jobId): bool
+    {
+        $query = "SELECT COUNT(*) as count FROM job_dependencies
+                  WHERE dependent_job_id = ? AND is_satisfied = false";
+
+        $result = $this->entityManager->getConnection()->queryOne(
+            SqlQuery::create($query, [$jobId])
+        );
+        return $result['count'] > 0;
+    }
+
+    public function getUnsatisfiedDependencies(string $jobId): array
+    {
+        $query = "SELECT * FROM job_dependencies
+                  WHERE dependent_job_id = ? AND is_satisfied = false
+                  ORDER BY created_at";
+
+        $results = $this->entityManager->getConnection()->query(
+            SqlQuery::create($query, [$jobId])
+        )->fetchAll();
+
+        return array_map(function(array $row) {
+            return $this->mapRowToEntity($row);
+        }, $results);
+    }
+
+    public function markDependencyAsSatisfied(string $dependentJobId, string $dependsOnJobId): void
+    {
+        $query = "UPDATE job_dependencies
+                  SET is_satisfied = true, satisfied_at = ?, updated_at = ?
+                  WHERE dependent_job_id = ? AND depends_on_job_id = ?";
+
+        $now = date('Y-m-d H:i:s');
+
+        $this->logger->info('Marking dependency as satisfied', [
+            'dependent_job_id' => $dependentJobId,
+            'depends_on_job_id' => $dependsOnJobId
+        ]);
+
+        $this->entityManager->getConnection()->execute(
+            SqlQuery::create($query, [$now, $now, $dependentJobId, $dependsOnJobId])
+        );
+    }
+
+    public function canJobBeExecuted(string $jobId): bool
+    {
+        return !$this->hasUnsatisfiedDependencies($jobId);
+    }
+
+    public function getReadyJobs(): array
+    {
+        // Get all jobs that have dependencies but no unsatisfied ones
+        $query = "SELECT DISTINCT jd1.dependent_job_id
+                  FROM job_dependencies jd1
+                  WHERE NOT EXISTS (
+                      SELECT 1 FROM job_dependencies jd2
+                      WHERE jd2.dependent_job_id = jd1.dependent_job_id
+                      AND jd2.is_satisfied = false
+                  )";
+
+        $results = $this->entityManager->getConnection()->query(
+            SqlQuery::create($query)
+        )->fetchAll();
+
+        return array_column($results, 'dependent_job_id');
+    }
+
+    public function resolveJobCompletion(string $jobId, bool $successful = true): array
+    {
+        $this->logger->info('Resolving job completion for dependencies', [
+            'job_id' => $jobId,
+            'successful' => $successful
+        ]);
+
+        // Get all jobs that depend on this completed job
+        $dependents = $this->getDependents($jobId);
+        $resolvedJobs = [];
+
+        foreach ($dependents as $dependencyEntry) {
+            $dependency = $dependencyEntry->getJobDependency();
+
+            // Check if this dependency should be satisfied based on completion type
+            $shouldSatisfy = match($dependency->type) {
+                \App\Framework\Queue\ValueObjects\DependencyType::COMPLETION => true,
+                \App\Framework\Queue\ValueObjects\DependencyType::SUCCESS => $successful,
+                \App\Framework\Queue\ValueObjects\DependencyType::CONDITIONAL => $this->evaluateCondition($dependency->condition, $successful)
+            };
+
+            if ($shouldSatisfy && !$dependencyEntry->isSatisfied) {
+                $this->markDependencyAsSatisfied($dependency->dependentJobId, $jobId);
+
+                // Check if the dependent job is now ready to execute
+                if ($this->canJobBeExecuted($dependency->dependentJobId)) {
+                    $resolvedJobs[] = $dependency->dependentJobId;
+                }
+            }
+        }
+
+        $this->logger->info('Job completion resolved', [
+            'job_id' => $jobId,
+            'resolved_jobs_count' => count($resolvedJobs),
+            'resolved_jobs' => $resolvedJobs
+        ]);
+
+        return $resolvedJobs;
+    }
+
+    public function getDependencyChain(string $jobId): array
+    {
+        $visited = [];
+        $chain = [];
+
+        $this->buildDependencyChain($jobId, $visited, $chain);
+
+        // Remove the starting job from the chain if it's there
+        return array_filter($chain, fn($id) => $id !== $jobId);
+    }
+
+    public function hasCircularDependencies(string $jobId): bool
+    {
+        $visited = [];
+        $recursionStack = [];
+
+        return $this->detectCircularDependency($jobId, $visited, $recursionStack);
+    }
+
+    public function cleanupOldDependencies(int $olderThanDays = 30): int
+    {
+        $cutoffDate = date('Y-m-d H:i:s', strtotime("-{$olderThanDays} days"));
+
+        $query = "DELETE FROM job_dependencies
+                  WHERE is_satisfied = true AND satisfied_at < ?";
+
+        $this->logger->info('Cleaning up old dependencies', [
+            'cutoff_date' => $cutoffDate,
+            'older_than_days' => $olderThanDays
+        ]);
+
+        $affectedRows = $this->entityManager->getConnection()->execute(
+            SqlQuery::create($query, [$cutoffDate])
+        );
+
+        $this->logger->info('Old dependencies cleaned up', [
+            'deleted_count' => $affectedRows
+        ]);
+
+        return $affectedRows;
+    }
+
+    private function buildDependencyChain(string $jobId, array &$visited, array &$chain): void
+    {
+        if (in_array($jobId, $visited)) {
+            return;
+        }
+
+        $visited[] = $jobId;
+        $dependencies = $this->getDependencies($jobId);
+
+        foreach ($dependencies as $dependencyEntry) {
+            $dependency = $dependencyEntry->getJobDependency();
+            $chain[] = $dependency->dependsOnJobId;
+            $this->buildDependencyChain($dependency->dependsOnJobId, $visited, $chain);
+        }
+    }
+
+    private function detectCircularDependency(string $jobId, array &$visited, array &$recursionStack): bool
+    {
+        $visited[$jobId] = true;
+        $recursionStack[$jobId] = true;
+
+        $dependencies = $this->getDependencies($jobId);
+
+        foreach ($dependencies as $dependencyEntry) {
+            $dependency = $dependencyEntry->getJobDependency();
+            $dependsOnJobId = $dependency->dependsOnJobId;
+
+            if (!isset($visited[$dependsOnJobId])) {
+                if ($this->detectCircularDependency($dependsOnJobId, $visited, $recursionStack)) {
+                    return true;
+                }
+            } elseif (isset($recursionStack[$dependsOnJobId])) {
+                return true; // Circular dependency detected
+            }
+        }
+
+        unset($recursionStack[$jobId]);
+        return false;
+    }
+
+    private function evaluateCondition(?string $condition, bool $jobSuccessful): bool
+    {
+        if ($condition === null) {
+            return true;
+        }
+
+        // Simple condition evaluation - can be extended for more complex conditions
+        return match($condition) {
+            'on_success' => $jobSuccessful,
+            'on_failure' => !$jobSuccessful,
+            'always' => true,
+            default => true
+        };
+    }
+
+    private function mapRowToEntity(array $row): JobDependencyEntry
+    {
+        return new JobDependencyEntry(
+            id: $row['id'],
+            dependentJobId: $row['dependent_job_id'],
+            dependsOnJobId: $row['depends_on_job_id'],
+            dependencyType: $row['dependency_type'],
+            createdAt: $row['created_at'],
+            updatedAt: $row['updated_at'],
+            conditionExpression: $row['condition_expression'],
+            isSatisfied: (bool) $row['is_satisfied'],
+            satisfiedAt: $row['satisfied_at']
+        );
+    }
+}

src/Framework/Queue/Services/DatabaseJobProgressTracker.php

@@ -0,0 +1,195 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\EntityManager;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Queue\Contracts\JobProgressTrackerInterface;
+use App\Framework\Queue\Entities\JobProgressEntry;
+use App\Framework\Queue\ValueObjects\JobProgress;
+use App\Framework\Queue\ValueObjects\ProgressStep;
+use App\Framework\Core\ValueObjects\Percentage;
+
+/**
+ * Database-backed job progress tracker implementation
+ */
+final readonly class DatabaseJobProgressTracker implements JobProgressTrackerInterface
+{
+    public function __construct(
+        private ConnectionInterface $connection,
+        private EntityManager $entityManager
+    ) {}
+
+    public function updateProgress(string $jobId, JobProgress $progress, ?string $stepName = null): void
+    {
+        $progressEntry = JobProgressEntry::fromJobProgress($jobId, $progress, $stepName);
+        $this->entityManager->persist($progressEntry);
+        $this->entityManager->flush();
+    }
+
+    public function completeStep(string $jobId, ProgressStep $step): void
+    {
+        $completedStep = $step->markAsCompleted();
+
+        // Create progress entry for the completed step
+        $progress = JobProgress::withPercentage(
+            percentage: Percentage::zero(), // Will be updated based on overall progress
+            message: "Completed step: {$completedStep->description}",
+            metadata: $completedStep->metadata
+        );
+
+        $this->updateProgress($jobId, $progress, $completedStep->stepName);
+    }
+
+    public function getCurrentProgress(string $jobId): ?JobProgress
+    {
+        $latestEntry = $this->getLatestProgressEntry($jobId);
+        return $latestEntry?->getJobProgress();
+    }
+
+    public function getProgressHistory(string $jobId): array
+    {
+        $sql = "
+            SELECT * FROM job_progress
+            WHERE job_id = ?
+            ORDER BY updated_at ASC
+        ";
+
+        $result = $this->connection->query(SqlQuery::create($sql, [$jobId]));
+        $rows = $result->fetchAll();
+
+        return array_map([$this, 'mapRowToProgressEntry'], $rows);
+    }
+
+    public function getLatestProgressEntry(string $jobId): ?JobProgressEntry
+    {
+        $sql = "
+            SELECT * FROM job_progress
+            WHERE job_id = ?
+            ORDER BY updated_at DESC
+            LIMIT 1
+        ";
+
+        $row = $this->connection->queryOne(SqlQuery::create($sql, [$jobId]));
+
+        return $row ? $this->mapRowToProgressEntry($row) : null;
+    }
+
+    public function markJobCompleted(string $jobId, string $message = 'Job completed successfully'): void
+    {
+        $progress = JobProgress::completed($message);
+        $this->updateProgress($jobId, $progress);
+    }
+
+    public function markJobFailed(string $jobId, string $message = 'Job failed', ?\Throwable $exception = null): void
+    {
+        $metadata = [];
+        if ($exception) {
+            $metadata['exception_type'] = get_class($exception);
+            $metadata['exception_message'] = $exception->getMessage();
+        }
+
+        $progress = JobProgress::failed($message)->withMetadata($metadata);
+        $this->updateProgress($jobId, $progress);
+    }
+
+    public function getProgressForJobs(array $jobIds): array
+    {
+        if (empty($jobIds)) {
+            return [];
+        }
+
+        $placeholders = str_repeat('?,', count($jobIds) - 1) . '?';
+        $sql = "
+            SELECT DISTINCT jp1.*
+            FROM job_progress jp1
+            INNER JOIN (
+                SELECT job_id, MAX(updated_at) as max_updated
+                FROM job_progress
+                WHERE job_id IN ({$placeholders})
+                GROUP BY job_id
+            ) jp2 ON jp1.job_id = jp2.job_id AND jp1.updated_at = jp2.max_updated
+        ";
+
+        $result = $this->connection->query(SqlQuery::create($sql, $jobIds));
+        $rows = $result->fetchAll();
+
+        $result = [];
+        foreach ($rows as $row) {
+            $entry = $this->mapRowToProgressEntry($row);
+            $result[$entry->jobId] = $entry->getJobProgress();
+        }
+
+        return $result;
+    }
+
+    public function cleanupOldEntries(int $olderThanDays = 30): int
+    {
+        $cutoffDate = date('Y-m-d H:i:s', strtotime("-{$olderThanDays} days"));
+
+        $sql = "DELETE FROM job_progress WHERE updated_at < ?";
+        return $this->connection->execute(SqlQuery::create($sql, [$cutoffDate]));
+    }
+
+    public function getJobsAboveProgress(float $minPercentage): array
+    {
+        $sql = "
+            SELECT DISTINCT jp1.*
+            FROM job_progress jp1
+            INNER JOIN (
+                SELECT job_id, MAX(updated_at) as max_updated
+                FROM job_progress
+                WHERE percentage >= ?
+                GROUP BY job_id
+            ) jp2 ON jp1.job_id = jp2.job_id AND jp1.updated_at = jp2.max_updated
+            WHERE jp1.percentage >= ?
+            ORDER BY jp1.percentage DESC, jp1.updated_at DESC
+        ";
+
+        $result = $this->connection->query(SqlQuery::create($sql, [$minPercentage, $minPercentage]));
+        $rows = $result->fetchAll();
+
+        return array_map([$this, 'mapRowToProgressEntry'], $rows);
+    }
+
+    public function getRecentlyUpdatedJobs(int $limitMinutes = 60, int $limit = 100): array
+    {
+        $cutoffTime = date('Y-m-d H:i:s', strtotime("-{$limitMinutes} minutes"));
+
+        $sql = "
+            SELECT DISTINCT jp1.*
+            FROM job_progress jp1
+            INNER JOIN (
+                SELECT job_id, MAX(updated_at) as max_updated
+                FROM job_progress
+                WHERE updated_at >= ?
+                GROUP BY job_id
+            ) jp2 ON jp1.job_id = jp2.job_id AND jp1.updated_at = jp2.max_updated
+            ORDER BY jp1.updated_at DESC
+            LIMIT ?
+        ";
+
+        $result = $this->connection->query(SqlQuery::create($sql, [$cutoffTime, $limit]));
+        $rows = $result->fetchAll();
+
+        return array_map([$this, 'mapRowToProgressEntry'], $rows);
+    }
+
+    private function mapRowToProgressEntry(array $row): JobProgressEntry
+    {
+        return new JobProgressEntry(
+            id: $row['id'],
+            jobId: $row['job_id'],
+            percentage: (float) $row['percentage'],
+            message: $row['message'],
+            stepName: $row['step_name'],
+            metadata: $row['metadata'],
+            updatedAt: $row['updated_at'],
+            isCompleted: (bool) $row['is_completed'],
+            isFailed: (bool) $row['is_failed']
+        );
+    }
+}

src/Framework/Queue/Services/DeadLetterManager.php

@@ -0,0 +1,159 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Contracts\DeadLetterQueueInterface;
+use App\Framework\Queue\Entities\DeadLetterJob;
+use App\Framework\Queue\Entities\JobIndexEntry;
+use App\Framework\Queue\ValueObjects\DeadLetterQueueName;
+use App\Framework\Queue\ValueObjects\FailureReason;
+use App\Framework\Queue\ValueObjects\QueueName;
+
+/**
+ * Manages dead letter queue operations and job failure handling
+ */
+final readonly class DeadLetterManager
+{
+    public function __construct(
+        private DeadLetterQueueInterface $deadLetterQueue,
+        private ProductionJobPersistenceLayer $persistenceLayer
+    ) {}
+
+    /**
+     * Move a failed job to the dead letter queue
+     */
+    public function moveJobToDeadLetterQueue(
+        JobIndexEntry $failedJob,
+        FailureReason $failureReason,
+        ?DeadLetterQueueName $deadLetterQueueName = null
+    ): void {
+        // Use default dead letter queue name if not provided
+        $dlqName = $deadLetterQueueName ?? DeadLetterQueueName::forQueue(
+            QueueName::fromString($failedJob->queueType)
+        );
+
+        // Create dead letter job entry
+        $deadLetterJob = DeadLetterJob::fromFailedJob(
+            failedJob: $failedJob,
+            deadLetterQueueName: $dlqName,
+            failureReason: $failureReason
+        );
+
+        // Add to dead letter queue
+        $this->deadLetterQueue->addFailedJob($deadLetterJob);
+
+        // Remove from original job index
+        $this->persistenceLayer->deleteJob($failedJob->jobId);
+    }
+
+    /**
+     * Move a job to dead letter queue when max attempts are exceeded
+     */
+    public function handleJobFailure(
+        string $jobId,
+        \Throwable $exception,
+        int $maxAttempts = 3
+    ): bool {
+        $jobEntry = $this->persistenceLayer->getJobById($jobId);
+        if (!$jobEntry) {
+            return false;
+        }
+
+        // Check if max attempts exceeded
+        if ($jobEntry->attempts >= $maxAttempts) {
+            $failureReason = FailureReason::fromException($exception);
+
+            $this->moveJobToDeadLetterQueue(
+                failedJob: $jobEntry,
+                failureReason: $failureReason
+            );
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Retry a job from dead letter queue
+     */
+    public function retryJob(string $deadLetterJobId): bool
+    {
+        return $this->deadLetterQueue->retryJob($deadLetterJobId);
+    }
+
+    /**
+     * Get failed jobs for monitoring/admin interface
+     */
+    public function getFailedJobs(
+        ?QueueName $originalQueue = null,
+        int $limit = 100
+    ): array {
+        if ($originalQueue) {
+            return $this->deadLetterQueue->getJobsByOriginalQueue($originalQueue, $limit);
+        }
+
+        // Get jobs from all dead letter queues
+        $allJobs = [];
+        $queues = $this->deadLetterQueue->getAvailableQueues();
+
+        foreach ($queues as $queueName) {
+            $jobs = $this->deadLetterQueue->getJobs($queueName, $limit);
+            $allJobs = array_merge($allJobs, $jobs);
+        }
+
+        // Sort by moved_to_dlq_at descending
+        usort($allJobs, fn ($a, $b) => strcmp($b->movedToDlqAt, $a->movedToDlqAt));
+
+        return array_slice($allJobs, 0, $limit);
+    }
+
+    /**
+     * Get dead letter queue statistics
+     */
+    public function getStatistics(): array
+    {
+        $queues = $this->deadLetterQueue->getAvailableQueues();
+        $stats = [];
+
+        foreach ($queues as $queueName) {
+            $stats[$queueName->toString()] = $this->deadLetterQueue->getQueueStats($queueName);
+        }
+
+        return $stats;
+    }
+
+    /**
+     * Clear all jobs from a dead letter queue
+     */
+    public function clearDeadLetterQueue(DeadLetterQueueName $queueName): int
+    {
+        return $this->deadLetterQueue->clearQueue($queueName);
+    }
+
+    /**
+     * Retry all jobs in a dead letter queue
+     */
+    public function retryAllJobs(DeadLetterQueueName $queueName): int
+    {
+        return $this->deadLetterQueue->retryAllJobs($queueName);
+    }
+
+    /**
+     * Delete a specific job from dead letter queue
+     */
+    public function deleteJob(string $deadLetterJobId): bool
+    {
+        return $this->deadLetterQueue->deleteJob($deadLetterJobId);
+    }
+
+    /**
+     * Get all available dead letter queues
+     */
+    public function getAvailableQueues(): array
+    {
+        return $this->deadLetterQueue->getAvailableQueues();
+    }
+}

src/Framework/Queue/Services/DependencyResolutionEngine.php

@@ -0,0 +1,274 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Contracts\JobDependencyManagerInterface;
+use App\Framework\Queue\Contracts\JobChainManagerInterface;
+use App\Framework\Queue\Contracts\QueueInterface;
+use App\Framework\Queue\ValueObjects\Job;
+use App\Framework\Logging\Logger;
+
+final readonly class DependencyResolutionEngine
+{
+    public function __construct(
+        private JobDependencyManagerInterface $dependencyManager,
+        private JobChainManagerInterface $chainManager,
+        private QueueInterface $queue,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Process job completion and resolve any dependent jobs that can now be executed
+     */
+    public function resolveJobCompletion(string $jobId, bool $successful = true): array
+    {
+        $this->logger->info('Starting dependency resolution for completed job', [
+            'job_id' => $jobId,
+            'successful' => $successful
+        ]);
+
+        $resolvedJobs = [];
+
+        // 1. Resolve individual job dependencies
+        $dependentJobs = $this->dependencyManager->resolveJobCompletion($jobId, $successful);
+
+        foreach ($dependentJobs as $dependentJobId) {
+            $resolvedJobs[] = [
+                'job_id' => $dependentJobId,
+                'type' => 'dependency_resolved',
+                'trigger_job' => $jobId
+            ];
+        }
+
+        // 2. Handle job chain progression
+        $this->chainManager->handleJobCompletion($jobId, $successful);
+
+        // Get next jobs in any chains this job belongs to
+        $chains = $this->chainManager->getChainsForJob($jobId);
+
+        foreach ($chains as $chainEntry) {
+            if ($chainEntry->isRunning()) {
+                $nextJobId = $this->chainManager->getNextJobInChain($chainEntry->chainId, $jobId);
+
+                if ($nextJobId !== null) {
+                    // Check if the next job has any other unsatisfied dependencies
+                    if ($this->dependencyManager->canJobBeExecuted($nextJobId)) {
+                        $resolvedJobs[] = [
+                            'job_id' => $nextJobId,
+                            'type' => 'chain_progression',
+                            'chain_id' => $chainEntry->chainId,
+                            'trigger_job' => $jobId
+                        ];
+                    } else {
+                        $this->logger->info('Next job in chain has unsatisfied dependencies', [
+                            'chain_id' => $chainEntry->chainId,
+                            'next_job_id' => $nextJobId,
+                            'unsatisfied_deps' => count($this->dependencyManager->getUnsatisfiedDependencies($nextJobId))
+                        ]);
+                    }
+                }
+            }
+        }
+
+        $this->logger->info('Dependency resolution completed', [
+            'trigger_job_id' => $jobId,
+            'resolved_jobs_count' => count($resolvedJobs),
+            'resolved_jobs' => array_column($resolvedJobs, 'job_id')
+        ]);
+
+        return $resolvedJobs;
+    }
+
+    /**
+     * Get all jobs that are ready to be executed (no unsatisfied dependencies)
+     */
+    public function getExecutableJobs(): array
+    {
+        $readyJobs = $this->dependencyManager->getReadyJobs();
+
+        $this->logger->debug('Found jobs ready for execution', [
+            'ready_jobs_count' => count($readyJobs),
+            'ready_jobs' => $readyJobs
+        ]);
+
+        return $readyJobs;
+    }
+
+    /**
+     * Validate a job dependency graph for circular dependencies
+     */
+    public function validateDependencyGraph(array $jobIds): array
+    {
+        $validationResults = [];
+
+        foreach ($jobIds as $jobId) {
+            $hasCircularDeps = $this->dependencyManager->hasCircularDependencies($jobId);
+
+            if ($hasCircularDeps) {
+                $dependencyChain = $this->dependencyManager->getDependencyChain($jobId);
+
+                $validationResults[] = [
+                    'job_id' => $jobId,
+                    'valid' => false,
+                    'error' => 'circular_dependency',
+                    'dependency_chain' => $dependencyChain
+                ];
+
+                $this->logger->warning('Circular dependency detected', [
+                    'job_id' => $jobId,
+                    'dependency_chain' => $dependencyChain
+                ]);
+            } else {
+                $validationResults[] = [
+                    'job_id' => $jobId,
+                    'valid' => true
+                ];
+            }
+        }
+
+        return $validationResults;
+    }
+
+    /**
+     * Get dependency analysis for a job
+     */
+    public function analyzeDependencies(string $jobId): array
+    {
+        $dependencies = $this->dependencyManager->getDependencies($jobId);
+        $dependents = $this->dependencyManager->getDependents($jobId);
+        $unsatisfiedDeps = $this->dependencyManager->getUnsatisfiedDependencies($jobId);
+        $dependencyChain = $this->dependencyManager->getDependencyChain($jobId);
+        $canExecute = $this->dependencyManager->canJobBeExecuted($jobId);
+
+        return [
+            'job_id' => $jobId,
+            'can_execute' => $canExecute,
+            'direct_dependencies' => array_map(fn($dep) => [
+                'depends_on_job_id' => $dep->dependsOnJobId,
+                'dependency_type' => $dep->dependencyType,
+                'is_satisfied' => $dep->isSatisfied,
+                'condition' => $dep->conditionExpression
+            ], $dependencies),
+            'dependent_jobs' => array_map(fn($dep) => [
+                'dependent_job_id' => $dep->dependentJobId,
+                'dependency_type' => $dep->dependencyType,
+                'is_satisfied' => $dep->isSatisfied
+            ], $dependents),
+            'unsatisfied_dependencies' => array_map(fn($dep) => [
+                'depends_on_job_id' => $dep->dependsOnJobId,
+                'dependency_type' => $dep->dependencyType,
+                'condition' => $dep->conditionExpression
+            ], $unsatisfiedDeps),
+            'full_dependency_chain' => $dependencyChain,
+            'statistics' => [
+                'total_dependencies' => count($dependencies),
+                'satisfied_dependencies' => count($dependencies) - count($unsatisfiedDeps),
+                'unsatisfied_dependencies' => count($unsatisfiedDeps),
+                'total_dependents' => count($dependents),
+                'chain_depth' => count($dependencyChain)
+            ]
+        ];
+    }
+
+    /**
+     * Get analysis for job chains
+     */
+    public function analyzeChains(string $jobId): array
+    {
+        $chains = $this->chainManager->getChainsForJob($jobId);
+        $chainAnalysis = [];
+
+        foreach ($chains as $chainEntry) {
+            $progress = $this->chainManager->getChainProgress($chainEntry->chainId);
+            $nextJob = $this->chainManager->getNextJobInChain($chainEntry->chainId, $jobId);
+
+            $chainAnalysis[] = [
+                'chain_id' => $chainEntry->chainId,
+                'name' => $chainEntry->name,
+                'status' => $chainEntry->status,
+                'execution_mode' => $chainEntry->executionMode,
+                'stop_on_failure' => $chainEntry->stopOnFailure,
+                'progress' => $progress,
+                'next_job_after_current' => $nextJob,
+                'job_position' => $this->getJobPositionInChain($jobId, $chainEntry),
+                'total_jobs' => count($chainEntry->getJobIdsArray())
+            ];
+        }
+
+        return [
+            'job_id' => $jobId,
+            'chains' => $chainAnalysis,
+            'total_chains' => count($chains)
+        ];
+    }
+
+    /**
+     * Comprehensive dependency health check
+     */
+    public function performHealthCheck(): array
+    {
+        $this->logger->info('Starting dependency system health check');
+
+        $activeChains = $this->chainManager->getActiveChains();
+        $pendingChains = $this->chainManager->getPendingChains();
+        $readyJobs = $this->dependencyManager->getReadyJobs();
+
+        // Check for potential issues
+        $issues = [];
+
+        // Check for stalled chains (running for too long)
+        foreach ($activeChains as $chain) {
+            if ($chain->startedAt) {
+                $startTime = strtotime($chain->startedAt);
+                $hoursRunning = (time() - $startTime) / 3600;
+
+                if ($hoursRunning > 24) { // Configurable threshold
+                    $issues[] = [
+                        'type' => 'stalled_chain',
+                        'chain_id' => $chain->chainId,
+                        'hours_running' => round($hoursRunning, 2)
+                    ];
+                }
+            }
+        }
+
+        // Check for jobs with many unsatisfied dependencies (potential deadlocks)
+        foreach ($readyJobs as $jobId) {
+            $analysis = $this->analyzeDependencies($jobId);
+            if ($analysis['statistics']['unsatisfied_dependencies'] > 10) { // Configurable threshold
+                $issues[] = [
+                    'type' => 'many_unsatisfied_dependencies',
+                    'job_id' => $jobId,
+                    'unsatisfied_count' => $analysis['statistics']['unsatisfied_dependencies']
+                ];
+            }
+        }
+
+        $healthReport = [
+            'status' => count($issues) === 0 ? 'healthy' : 'issues_detected',
+            'timestamp' => date('Y-m-d H:i:s'),
+            'statistics' => [
+                'active_chains' => count($activeChains),
+                'pending_chains' => count($pendingChains),
+                'ready_jobs' => count($readyJobs),
+                'detected_issues' => count($issues)
+            ],
+            'issues' => $issues
+        ];
+
+        $this->logger->info('Dependency system health check completed', [
+            'status' => $healthReport['status'],
+            'issues_count' => count($issues)
+        ]);
+
+        return $healthReport;
+    }
+
+    private function getJobPositionInChain(string $jobId, object $chainEntry): ?int
+    {
+        $jobIds = $chainEntry->getJobIdsArray();
+        return array_search($jobId, $jobIds, true) ?: null;
+    }
+}

src/Framework/Queue/Services/FailoverRecoveryService.php

@@ -0,0 +1,516 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Entities\Worker;
+use App\Framework\Queue\ValueObjects\JobId;
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Queue\ValueObjects\QueueName;
+use App\Framework\Queue\ValueObjects\LockKey;
+use App\Framework\Queue\Interfaces\DistributedLockInterface;
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+
+/**
+ * Failover und Recovery Service für robustes Distributed Job Processing
+ */
+final readonly class FailoverRecoveryService
+{
+    private const RECOVERY_LOCK_TTL_SECONDS = 300; // 5 Minuten
+    private const JOB_TIMEOUT_THRESHOLD_SECONDS = 1800; // 30 Minuten
+    private const WORKER_FAILURE_THRESHOLD_SECONDS = 300; // 5 Minuten
+
+    public function __construct(
+        private WorkerRegistry $workerRegistry,
+        private JobDistributionService $jobDistributionService,
+        private WorkerHealthCheckService $healthCheckService,
+        private DistributedLockInterface $distributedLock,
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Vollständige Failover und Recovery Prozedur durchführen
+     */
+    public function performFailoverRecovery(): array
+    {
+        $this->logger->info('Starting failover and recovery process');
+
+        $results = [
+            'started_at' => date('Y-m-d H:i:s'),
+            'failed_workers_detected' => 0,
+            'jobs_recovered' => 0,
+            'jobs_reassigned' => 0,
+            'workers_cleaned' => 0,
+            'locks_released' => 0,
+            'errors' => []
+        ];
+
+        try {
+            // 1. Fehlgeschlagene Worker erkennen
+            $failedWorkers = $this->detectFailedWorkers();
+            $results['failed_workers_detected'] = count($failedWorkers);
+
+            if (!empty($failedWorkers)) {
+                $this->logger->warning('Failed workers detected', LogContext::withData([
+                    'failed_worker_count' => count($failedWorkers),
+                    'worker_ids' => array_map(fn($w) => $w->id->toString(), $failedWorkers)
+                ]));
+
+                // 2. Jobs von fehlgeschlagenen Workern wiederherstellen
+                foreach ($failedWorkers as $worker) {
+                    $recovered = $this->recoverWorkerJobs($worker);
+                    $results['jobs_recovered'] += $recovered['jobs_recovered'];
+                    $results['jobs_reassigned'] += $recovered['jobs_reassigned'];
+                    $results['locks_released'] += $recovered['locks_released'];
+
+                    if (!empty($recovered['errors'])) {
+                        $results['errors'] = array_merge($results['errors'], $recovered['errors']);
+                    }
+                }
+
+                // 3. Fehlgeschlagene Worker aufräumen
+                $results['workers_cleaned'] = $this->cleanupFailedWorkers($failedWorkers);
+            }
+
+            // 4. Verwaiste Jobs wiederherstellen
+            $orphanedJobs = $this->recoverOrphanedJobs();
+            $results['orphaned_jobs_recovered'] = $orphanedJobs;
+
+            // 5. Abgelaufene Locks aufräumen
+            $expiredLocks = $this->distributedLock->cleanupExpiredLocks();
+            $results['expired_locks_cleaned'] = $expiredLocks;
+
+            $results['completed_at'] = date('Y-m-d H:i:s');
+            $results['duration_seconds'] = strtotime($results['completed_at']) - strtotime($results['started_at']);
+
+            $this->logger->info('Failover and recovery completed', LogContext::withData($results));
+
+        } catch (\Exception $e) {
+            $results['errors'][] = 'Recovery process failed: ' . $e->getMessage();
+            $this->logger->error('Failover and recovery failed', LogContext::withData([
+                'error' => $e->getMessage(),
+                'trace' => $e->getTraceAsString()
+            ]));
+        }
+
+        return $results;
+    }
+
+    /**
+     * Fehlgeschlagene Worker erkennen
+     */
+    public function detectFailedWorkers(): array
+    {
+        $allWorkers = $this->workerRegistry->findActiveWorkers();
+        $failedWorkers = [];
+
+        foreach ($allWorkers as $worker) {
+            if ($this->isWorkerFailed($worker)) {
+                $failedWorkers[] = $worker;
+            }
+        }
+
+        return $failedWorkers;
+    }
+
+    /**
+     * Prüfen ob Worker als fehlgeschlagen gilt
+     */
+    private function isWorkerFailed(Worker $worker): bool
+    {
+        // Heartbeat-basierte Überprüfung
+        if (!$worker->lastHeartbeat) {
+            return true;
+        }
+
+        $heartbeatAge = time() - $worker->lastHeartbeat->getTimestamp();
+        if ($heartbeatAge > self::WORKER_FAILURE_THRESHOLD_SECONDS) {
+            return true;
+        }
+
+        // Health-basierte Überprüfung
+        $health = $this->healthCheckService->checkWorkerHealth($worker);
+        if ($health['status'] === 'critical' && $health['score'] < 20) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Jobs von fehlgeschlagenem Worker wiederherstellen
+     */
+    public function recoverWorkerJobs(Worker $worker): array
+    {
+        $this->logger->info('Recovering jobs from failed worker', LogContext::withData([
+            'worker_id' => $worker->id->toString(),
+            'hostname' => $worker->hostname
+        ]));
+
+        $results = [
+            'jobs_recovered' => 0,
+            'jobs_reassigned' => 0,
+            'locks_released' => 0,
+            'errors' => []
+        ];
+
+        try {
+            // Recovery Lock erwerben
+            $recoveryLock = LockKey::forWorker($worker->id)->withPrefix('recovery');
+            $recoveryWorkerId = WorkerId::generate();
+
+            if (!$this->distributedLock->acquire(
+                $recoveryLock,
+                $recoveryWorkerId,
+                Duration::fromSeconds(self::RECOVERY_LOCK_TTL_SECONDS)
+            )) {
+                $results['errors'][] = 'Failed to acquire recovery lock';
+                return $results;
+            }
+
+            try {
+                // Alle Jobs des Workers finden
+                $assignedJobs = $this->findWorkerJobs($worker->id);
+                $results['jobs_recovered'] = count($assignedJobs);
+
+                // Alle Locks des Workers freigeben
+                $results['locks_released'] = $this->jobDistributionService->releaseAllWorkerJobs($worker->id);
+
+                // Jobs neu verteilen
+                foreach ($assignedJobs as $jobAssignment) {
+                    $reassigned = $this->reassignJob(
+                        JobId::fromString($jobAssignment['job_id']),
+                        QueueName::default(), // Vereinfacht - könnte aus Assignment gelesen werden
+                        $worker->id
+                    );
+
+                    if ($reassigned) {
+                        $results['jobs_reassigned']++;
+                    } else {
+                        $results['errors'][] = "Failed to reassign job: {$jobAssignment['job_id']}";
+                    }
+                }
+
+            } finally {
+                $this->distributedLock->release($recoveryLock, $recoveryWorkerId);
+            }
+
+        } catch (\Exception $e) {
+            $results['errors'][] = 'Worker recovery failed: ' . $e->getMessage();
+            $this->logger->error('Failed to recover worker jobs', LogContext::withData([
+                'worker_id' => $worker->id->toString(),
+                'error' => $e->getMessage()
+            ]));
+        }
+
+        return $results;
+    }
+
+    /**
+     * Jobs eines Workers finden
+     */
+    private function findWorkerJobs(WorkerId $workerId): array
+    {
+        try {
+            $sql = "SELECT job_id, queue_name, assigned_at
+                   FROM job_assignments
+                   WHERE worker_id = :worker_id";
+
+            $result = $this->connection->query(SqlQuery::create($sql, ['worker_id' => $workerId->toString()]));
+            return $result->fetchAll();
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to find worker jobs', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            return [];
+        }
+    }
+
+    /**
+     * Job neu zuweisen
+     */
+    private function reassignJob(JobId $jobId, QueueName $queueName, WorkerId $failedWorkerId): bool
+    {
+        try {
+            // Job an neuen Worker verteilen
+            $newWorkerId = $this->jobDistributionService->distributeJob($jobId, $queueName);
+
+            if ($newWorkerId) {
+                $this->logger->info('Job successfully reassigned', LogContext::withData([
+                    'job_id' => $jobId->toString(),
+                    'failed_worker_id' => $failedWorkerId->toString(),
+                    'new_worker_id' => $newWorkerId->toString()
+                ]));
+
+                // Failover Event loggen
+                $this->logFailoverEvent($jobId, $failedWorkerId, $newWorkerId);
+
+                return true;
+            }
+
+            return false;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to reassign job', LogContext::withData([
+                'job_id' => $jobId->toString(),
+                'failed_worker_id' => $failedWorkerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            return false;
+        }
+    }
+
+    /**
+     * Fehlgeschlagene Worker aufräumen
+     */
+    private function cleanupFailedWorkers(array $failedWorkers): int
+    {
+        $cleanedCount = 0;
+
+        foreach ($failedWorkers as $worker) {
+            try {
+                // Worker deregistrieren
+                $this->workerRegistry->deregister($worker->id);
+
+                $this->logger->info('Failed worker cleaned up', LogContext::withData([
+                    'worker_id' => $worker->id->toString(),
+                    'hostname' => $worker->hostname
+                ]));
+
+                $cleanedCount++;
+
+            } catch (\Exception $e) {
+                $this->logger->error('Failed to cleanup worker', LogContext::withData([
+                    'worker_id' => $worker->id->toString(),
+                    'error' => $e->getMessage()
+                ]));
+            }
+        }
+
+        return $cleanedCount;
+    }
+
+    /**
+     * Verwaiste Jobs wiederherstellen
+     */
+    public function recoverOrphanedJobs(): int
+    {
+        $this->logger->info('Recovering orphaned jobs');
+
+        try {
+            // Jobs finden die länger als Threshold laufen ohne Heartbeat
+            $sql = "SELECT ja.job_id, ja.queue_name, ja.worker_id, ja.assigned_at
+                   FROM job_assignments ja
+                   LEFT JOIN queue_workers qw ON ja.worker_id = qw.id
+                   WHERE (qw.id IS NULL
+                       OR qw.is_active = 0
+                       OR qw.last_heartbeat < DATE_SUB(NOW(), INTERVAL :threshold SECOND)
+                       OR ja.assigned_at < DATE_SUB(NOW(), INTERVAL :job_timeout SECOND))";
+
+            $result = $this->connection->query(SqlQuery::create($sql, [
+                'threshold' => self::WORKER_FAILURE_THRESHOLD_SECONDS,
+                'job_timeout' => self::JOB_TIMEOUT_THRESHOLD_SECONDS
+            ]));
+
+            $orphanedJobs = $result->fetchAll();
+            $recoveredCount = 0;
+
+            foreach ($orphanedJobs as $job) {
+                $jobId = JobId::fromString($job['job_id']);
+                $queueName = QueueName::default(); // Vereinfacht
+                $oldWorkerId = WorkerId::fromString($job['worker_id']);
+
+                // Job Lock freigeben falls vorhanden
+                $jobLock = LockKey::forJob($jobId);
+                $this->distributedLock->release($jobLock, $oldWorkerId);
+
+                // Job neu verteilen
+                $newWorkerId = $this->jobDistributionService->distributeJob($jobId, $queueName);
+
+                if ($newWorkerId) {
+                    $recoveredCount++;
+                    $this->logger->info('Orphaned job recovered', LogContext::withData([
+                        'job_id' => $jobId->toString(),
+                        'old_worker_id' => $oldWorkerId->toString(),
+                        'new_worker_id' => $newWorkerId->toString()
+                    ]));
+                }
+            }
+
+            $this->logger->info('Orphaned jobs recovery completed', LogContext::withData([
+                'total_orphaned' => count($orphanedJobs),
+                'recovered' => $recoveredCount
+            ]));
+
+            return $recoveredCount;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to recover orphaned jobs', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            return 0;
+        }
+    }
+
+    /**
+     * Failover Event loggen
+     */
+    private function logFailoverEvent(JobId $jobId, WorkerId $failedWorkerId, WorkerId $newWorkerId): void
+    {
+        try {
+            $sql = "INSERT INTO failover_events (
+                        job_id, failed_worker_id, new_worker_id, failover_at, event_type
+                    ) VALUES (
+                        :job_id, :failed_worker_id, :new_worker_id, NOW(), 'job_reassignment'
+                    )";
+
+            $this->connection->execute(SqlQuery::create($sql, [
+                'job_id' => $jobId->toString(),
+                'failed_worker_id' => $failedWorkerId->toString(),
+                'new_worker_id' => $newWorkerId->toString()
+            ]));
+
+        } catch (\Exception $e) {
+            $this->logger->warning('Failed to log failover event', LogContext::withData([
+                'job_id' => $jobId->toString(),
+                'error' => $e->getMessage()
+            ]));
+        }
+    }
+
+    /**
+     * Failover Statistiken abrufen
+     */
+    public function getFailoverStatistics(?Duration $period = null): array
+    {
+        $period = $period ?? Duration::fromDays(7);
+
+        try {
+            $sql = "SELECT
+                       COUNT(*) as total_failovers,
+                       COUNT(DISTINCT failed_worker_id) as failed_workers,
+                       COUNT(DISTINCT new_worker_id) as recovery_workers,
+                       COUNT(DISTINCT job_id) as affected_jobs,
+                       AVG(TIMESTAMPDIFF(SECOND, failover_at, NOW())) as avg_time_since_failover
+                   FROM failover_events
+                   WHERE failover_at >= DATE_SUB(NOW(), INTERVAL :hours HOUR)";
+
+            $stats = $this->connection->queryOne(SqlQuery::create($sql, ['hours' => $period->toHours()]));
+
+            // Failover Trends
+            $trendSql = "SELECT
+                            DATE(failover_at) as failover_date,
+                            COUNT(*) as daily_failovers
+                        FROM failover_events
+                        WHERE failover_at >= DATE_SUB(NOW(), INTERVAL :hours HOUR)
+                        GROUP BY DATE(failover_at)
+                        ORDER BY failover_date DESC";
+
+            $result = $this->connection->query(SqlQuery::create($trendSql, ['hours' => $period->toHours()]));
+            $trends = $result->fetchAll();
+
+            return [
+                'period_hours' => $period->toHours(),
+                'statistics' => [
+                    'total_failovers' => (int) $stats['total_failovers'],
+                    'failed_workers' => (int) $stats['failed_workers'],
+                    'recovery_workers' => (int) $stats['recovery_workers'],
+                    'affected_jobs' => (int) $stats['affected_jobs'],
+                    'avg_time_since_failover' => round((float) $stats['avg_time_since_failover'], 2)
+                ],
+                'daily_trends' => $trends
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to get failover statistics', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * System Resilience Score berechnen
+     */
+    public function calculateResilienceScore(): array
+    {
+        try {
+            $score = 100;
+            $factors = [];
+
+            // Worker Availability
+            $workerStats = $this->workerRegistry->getWorkerStatistics();
+            $activeRatio = $workerStats['active_workers'] > 0
+                ? $workerStats['healthy_workers'] / $workerStats['active_workers']
+                : 0;
+
+            if ($activeRatio < 0.5) {
+                $score -= 40;
+                $factors[] = 'Low worker availability';
+            } elseif ($activeRatio < 0.8) {
+                $score -= 20;
+                $factors[] = 'Reduced worker availability';
+            }
+
+            // Recent Failovers
+            $failoverStats = $this->getFailoverStatistics(Duration::fromHours(24));
+            $recentFailovers = $failoverStats['statistics']['total_failovers'];
+
+            if ($recentFailovers > 10) {
+                $score -= 30;
+                $factors[] = 'High failover rate (24h)';
+            } elseif ($recentFailovers > 5) {
+                $score -= 15;
+                $factors[] = 'Moderate failover rate (24h)';
+            }
+
+            // Lock Contention
+            $lockStats = $this->distributedLock->getLockStatistics();
+            if ($lockStats['expired_locks'] > $lockStats['active_locks'] * 0.1) {
+                $score -= 20;
+                $factors[] = 'High lock expiration rate';
+            }
+
+            $status = match (true) {
+                $score >= 80 => 'excellent',
+                $score >= 60 => 'good',
+                $score >= 40 => 'fair',
+                $score >= 20 => 'poor',
+                default => 'critical'
+            };
+
+            return [
+                'score' => max(0, $score),
+                'status' => $status,
+                'factors' => $factors,
+                'metrics' => [
+                    'worker_availability' => round($activeRatio * 100, 1),
+                    'recent_failovers_24h' => $recentFailovers,
+                    'active_locks' => $lockStats['active_locks'],
+                    'expired_locks' => $lockStats['expired_locks']
+                ],
+                'calculated_at' => date('Y-m-d H:i:s')
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to calculate resilience score', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+
+            return [
+                'score' => 0,
+                'status' => 'unknown',
+                'factors' => ['Calculation failed'],
+                'error' => $e->getMessage()
+            ];
+        }
+    }
+}

src/Framework/Queue/Services/JobChainExecutionCoordinator.php

@@ -0,0 +1,353 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Contracts\JobChainManagerInterface;
+use App\Framework\Queue\Contracts\JobDependencyManagerInterface;
+use App\Framework\Queue\Contracts\QueueInterface;
+use App\Framework\Queue\ValueObjects\Job;
+use App\Framework\Queue\ValueObjects\JobChain;
+use App\Framework\Queue\ValueObjects\ChainExecutionMode;
+use App\Framework\Core\Events\EventDispatcherInterface;
+use App\Framework\Queue\Events\JobChainStartedEvent;
+use App\Framework\Queue\Events\JobChainCompletedEvent;
+use App\Framework\Queue\Events\JobChainFailedEvent;
+use App\Framework\Logging\Logger;
+
+final readonly class JobChainExecutionCoordinator
+{
+    public function __construct(
+        private JobChainManagerInterface $chainManager,
+        private JobDependencyManagerInterface $dependencyManager,
+        private QueueInterface $queue,
+        private EventDispatcherInterface $eventDispatcher,
+        private DependencyResolutionEngine $resolutionEngine,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Start execution of a job chain
+     */
+    public function startChainExecution(string $chainId): void
+    {
+        $chainEntry = $this->chainManager->getChain($chainId);
+
+        if (!$chainEntry) {
+            throw new \RuntimeException("Chain with ID '{$chainId}' not found");
+        }
+
+        if (!$chainEntry->isPending()) {
+            throw new \RuntimeException("Chain '{$chainId}' is not in pending status");
+        }
+
+        $jobChain = $chainEntry->getJobChain();
+
+        $this->logger->info('Starting chain execution', [
+            'chain_id' => $chainId,
+            'execution_mode' => $jobChain->executionMode->value,
+            'job_count' => count($jobChain->jobIds),
+            'stop_on_failure' => $jobChain->stopOnFailure
+        ]);
+
+        // Validate dependency graph before starting
+        $validationResults = $this->resolutionEngine->validateDependencyGraph($jobChain->jobIds);
+        $hasCircularDeps = array_filter($validationResults, fn($result) => !$result['valid']);
+
+        if (!empty($hasCircularDeps)) {
+            $this->logger->error('Cannot start chain - circular dependencies detected', [
+                'chain_id' => $chainId,
+                'circular_dependencies' => $hasCircularDeps
+            ]);
+            throw new \RuntimeException("Chain '{$chainId}' has circular dependencies");
+        }
+
+        // Mark chain as started
+        $this->chainManager->startChain($chainId);
+
+        // Dispatch chain started event
+        $this->eventDispatcher->dispatch(new JobChainStartedEvent(
+            chainId: $chainId,
+            name: $jobChain->name,
+            executionMode: $jobChain->executionMode,
+            jobIds: $jobChain->jobIds
+        ));
+
+        // Start execution based on execution mode
+        match($jobChain->executionMode) {
+            ChainExecutionMode::SEQUENTIAL => $this->startSequentialExecution($jobChain),
+            ChainExecutionMode::PARALLEL => $this->startParallelExecution($jobChain),
+            ChainExecutionMode::CONDITIONAL => $this->startConditionalExecution($jobChain)
+        };
+    }
+
+    /**
+     * Process job completion within a chain context
+     */
+    public function handleJobCompletionInChain(string $jobId, bool $successful = true, ?array $jobResult = null): void
+    {
+        $this->logger->info('Handling job completion in chain context', [
+            'job_id' => $jobId,
+            'successful' => $successful
+        ]);
+
+        // Get all chains this job belongs to
+        $chains = $this->chainManager->getChainsForJob($jobId);
+
+        foreach ($chains as $chainEntry) {
+            if (!$chainEntry->isRunning()) {
+                continue;
+            }
+
+            $jobChain = $chainEntry->getJobChain();
+
+            $this->logger->info('Processing job completion for chain', [
+                'chain_id' => $chainEntry->chainId,
+                'job_id' => $jobId,
+                'execution_mode' => $jobChain->executionMode->value
+            ]);
+
+            // Handle failure scenarios
+            if (!$successful && $jobChain->stopOnFailure) {
+                $this->handleChainFailure($chainEntry->chainId, $jobId);
+                continue;
+            }
+
+            // Continue chain execution based on mode
+            match($jobChain->executionMode) {
+                ChainExecutionMode::SEQUENTIAL => $this->continueSequentialExecution($chainEntry, $jobId, $successful),
+                ChainExecutionMode::PARALLEL => $this->continueParallelExecution($chainEntry, $jobId, $successful),
+                ChainExecutionMode::CONDITIONAL => $this->continueConditionalExecution($chainEntry, $jobId, $successful, $jobResult)
+            };
+        }
+    }
+
+    /**
+     * Get chain execution status and progress
+     */
+    public function getChainExecutionStatus(string $chainId): array
+    {
+        $chainEntry = $this->chainManager->getChain($chainId);
+
+        if (!$chainEntry) {
+            throw new \RuntimeException("Chain with ID '{$chainId}' not found");
+        }
+
+        $progress = $this->chainManager->getChainProgress($chainId);
+        $jobChain = $chainEntry->getJobChain();
+
+        // Get detailed job status for each job in chain
+        $jobStatuses = [];
+        foreach ($jobChain->jobIds as $index => $jobId) {
+            $dependencyAnalysis = $this->resolutionEngine->analyzeDependencies($jobId);
+
+            $jobStatuses[] = [
+                'job_id' => $jobId,
+                'position' => $index,
+                'can_execute' => $dependencyAnalysis['can_execute'],
+                'dependencies_satisfied' => $dependencyAnalysis['statistics']['satisfied_dependencies'],
+                'dependencies_total' => $dependencyAnalysis['statistics']['total_dependencies'],
+                'status' => $this->getJobStatus($jobId) // Would need integration with job status tracking
+            ];
+        }
+
+        return [
+            'chain_id' => $chainId,
+            'name' => $chainEntry->name,
+            'status' => $chainEntry->status,
+            'execution_mode' => $jobChain->executionMode->value,
+            'progress' => $progress,
+            'job_statuses' => $jobStatuses,
+            'started_at' => $chainEntry->startedAt,
+            'completed_at' => $chainEntry->completedAt,
+            'metadata' => $chainEntry->getMetadataArray()
+        ];
+    }
+
+    /**
+     * Pause chain execution
+     */
+    public function pauseChainExecution(string $chainId): void
+    {
+        // Implementation would depend on job queue capabilities
+        $this->logger->info('Pausing chain execution', ['chain_id' => $chainId]);
+
+        // This would involve:
+        // 1. Marking chain as paused
+        // 2. Preventing new jobs from being queued
+        // 3. Allowing current jobs to complete
+    }
+
+    /**
+     * Resume chain execution
+     */
+    public function resumeChainExecution(string $chainId): void
+    {
+        $this->logger->info('Resuming chain execution', ['chain_id' => $chainId]);
+
+        // This would involve:
+        // 1. Marking chain as running again
+        // 2. Re-evaluating which jobs can be executed
+        // 3. Queuing eligible jobs
+    }
+
+    private function startSequentialExecution(JobChain $jobChain): void
+    {
+        $this->logger->info('Starting sequential chain execution', [
+            'chain_id' => $jobChain->chainId
+        ]);
+
+        // Queue the first job that has no unsatisfied dependencies
+        foreach ($jobChain->jobIds as $jobId) {
+            if ($this->dependencyManager->canJobBeExecuted($jobId)) {
+                $this->queueJob($jobId);
+                break; // Only start first eligible job in sequential mode
+            }
+        }
+    }
+
+    private function startParallelExecution(JobChain $jobChain): void
+    {
+        $this->logger->info('Starting parallel chain execution', [
+            'chain_id' => $jobChain->chainId
+        ]);
+
+        // Queue all jobs that have no unsatisfied dependencies
+        foreach ($jobChain->jobIds as $jobId) {
+            if ($this->dependencyManager->canJobBeExecuted($jobId)) {
+                $this->queueJob($jobId);
+            }
+        }
+    }
+
+    private function startConditionalExecution(JobChain $jobChain): void
+    {
+        $this->logger->info('Starting conditional chain execution', [
+            'chain_id' => $jobChain->chainId
+        ]);
+
+        // Similar to parallel, but with conditional dependency evaluation
+        foreach ($jobChain->jobIds as $jobId) {
+            if ($this->dependencyManager->canJobBeExecuted($jobId)) {
+                $this->queueJob($jobId);
+            }
+        }
+    }
+
+    private function continueSequentialExecution(object $chainEntry, string $completedJobId, bool $successful): void
+    {
+        $nextJobId = $this->chainManager->getNextJobInChain($chainEntry->chainId, $completedJobId);
+
+        if ($nextJobId !== null && $this->dependencyManager->canJobBeExecuted($nextJobId)) {
+            $this->queueJob($nextJobId);
+        } elseif ($nextJobId === null) {
+            // Chain completed
+            $this->handleChainCompletion($chainEntry->chainId);
+        }
+    }
+
+    private function continueParallelExecution(object $chainEntry, string $completedJobId, bool $successful): void
+    {
+        $jobChain = $chainEntry->getJobChain();
+
+        // Check if any more jobs can be executed
+        $hasExecutableJobs = false;
+        foreach ($jobChain->jobIds as $jobId) {
+            if ($this->dependencyManager->canJobBeExecuted($jobId) && !$this->isJobCompleted($jobId)) {
+                $this->queueJob($jobId);
+                $hasExecutableJobs = true;
+            }
+        }
+
+        // Check if chain is complete
+        if (!$hasExecutableJobs && $this->areAllJobsCompleted($jobChain->jobIds)) {
+            $this->handleChainCompletion($chainEntry->chainId);
+        }
+    }
+
+    private function continueConditionalExecution(object $chainEntry, string $completedJobId, bool $successful, ?array $jobResult): void
+    {
+        // Conditional execution logic would evaluate conditions based on job results
+        $jobChain = $chainEntry->getJobChain();
+
+        // Re-evaluate all dependencies in case conditions have changed
+        foreach ($jobChain->jobIds as $jobId) {
+            if ($this->dependencyManager->canJobBeExecuted($jobId) && !$this->isJobCompleted($jobId)) {
+                $this->queueJob($jobId);
+            }
+        }
+
+        // Check completion
+        if ($this->areAllJobsCompleted($jobChain->jobIds)) {
+            $this->handleChainCompletion($chainEntry->chainId);
+        }
+    }
+
+    private function handleChainCompletion(string $chainId): void
+    {
+        $this->logger->info('Chain execution completed', ['chain_id' => $chainId]);
+
+        $this->chainManager->markChainAsCompleted($chainId);
+
+        $chainEntry = $this->chainManager->getChain($chainId);
+        $this->eventDispatcher->dispatch(new JobChainCompletedEvent(
+            chainId: $chainId,
+            name: $chainEntry->name,
+            completedAt: $chainEntry->completedAt
+        ));
+    }
+
+    private function handleChainFailure(string $chainId, string $failedJobId): void
+    {
+        $this->logger->warning('Chain execution failed', [
+            'chain_id' => $chainId,
+            'failed_job_id' => $failedJobId
+        ]);
+
+        $this->chainManager->markChainAsFailed($chainId);
+
+        $chainEntry = $this->chainManager->getChain($chainId);
+        $this->eventDispatcher->dispatch(new JobChainFailedEvent(
+            chainId: $chainId,
+            name: $chainEntry->name,
+            failedJobId: $failedJobId,
+            failedAt: $chainEntry->completedAt
+        ));
+    }
+
+    private function queueJob(string $jobId): void
+    {
+        $this->logger->debug('Queuing job for execution', ['job_id' => $jobId]);
+
+        // This would need integration with the actual job creation/queuing system
+        // For now, we'll assume a job can be queued by ID
+        // In a real implementation, you'd need to reconstruct the Job object
+        // $job = $this->jobRepository->find($jobId);
+        // $this->queue->push($job);
+    }
+
+    private function getJobStatus(string $jobId): string
+    {
+        // This would integrate with job status tracking system
+        // For now, return a placeholder
+        return 'unknown';
+    }
+
+    private function isJobCompleted(string $jobId): bool
+    {
+        // This would check if job is completed in the job tracking system
+        // For now, return false as placeholder
+        return false;
+    }
+
+    private function areAllJobsCompleted(array $jobIds): bool
+    {
+        foreach ($jobIds as $jobId) {
+            if (!$this->isJobCompleted($jobId)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/Framework/Queue/Services/JobCleanupService.php

@@ -0,0 +1,436 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Core\ValueObjects\Byte;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+use App\Framework\Performance\MemoryMonitor;
+
+/**
+ * Service for cleaning up old job data from the queue system
+ */
+final readonly class JobCleanupService
+{
+    // Default retention periods
+    private const DEFAULT_COMPLETED_RETENTION_DAYS = 30;
+    private const DEFAULT_FAILED_RETENTION_DAYS = 90;
+    private const DEFAULT_METRICS_RETENTION_DAYS = 180;
+    private const DEFAULT_DEAD_LETTER_RETENTION_DAYS = 365;
+
+    // Batch size for cleanup operations
+    private const CLEANUP_BATCH_SIZE = 1000;
+
+    public function __construct(
+        private ConnectionInterface $connection,
+        private Logger $logger,
+        private MemoryMonitor $memoryMonitor,
+        private JobMemoryManager $memoryManager
+    ) {}
+
+    /**
+     * Clean up old completed jobs
+     */
+    public function cleanupCompletedJobs(Duration $olderThan): int
+    {
+        $cutoffDate = $this->calculateCutoffDate($olderThan);
+        $totalDeleted = 0;
+        $batchCount = 0;
+
+        $this->logger->info('Starting completed jobs cleanup', LogContext::withData([
+            'older_than_days' => $olderThan->toHours() / 24,
+            'cutoff_date' => $cutoffDate
+        ]));
+
+        try {
+            $this->connection->beginTransaction();
+
+            // Delete from job_history first
+            $sql = "DELETE FROM job_history
+                   WHERE new_status = 'completed'
+                   AND changed_at < :cutoff
+                   LIMIT :limit";
+
+            do {
+                // Check memory before each batch
+                if ($this->memoryManager->shouldAbortJob('cleanup_completed_jobs')) {
+                    $this->logger->warning('Cleanup aborted due to memory constraints', LogContext::withData([
+                        'deleted_so_far' => $totalDeleted,
+                        'batch_count' => $batchCount
+                    ]));
+                    break;
+                }
+
+                $deleted = $this->connection->execute(SqlQuery::create($sql, [
+                    'cutoff' => $cutoffDate,
+                    'limit' => self::CLEANUP_BATCH_SIZE
+                ]));
+                $totalDeleted += $deleted;
+                $batchCount++;
+
+                if ($deleted > 0) {
+                    $this->logger->debug('Deleted batch of completed jobs', LogContext::withData([
+                        'batch_size' => $deleted,
+                        'total_deleted' => $totalDeleted,
+                        'batch_number' => $batchCount
+                    ]));
+                }
+
+                // Small delay between batches to prevent overload
+                if ($deleted === self::CLEANUP_BATCH_SIZE) {
+                    usleep(100000); // 100ms delay
+                }
+
+            } while ($deleted === self::CLEANUP_BATCH_SIZE);
+
+            $this->connection->commit();
+
+            $this->logger->info('Completed jobs cleanup finished', LogContext::withData([
+                'total_deleted' => $totalDeleted,
+                'batches_processed' => $batchCount
+            ]));
+
+        } catch (\Exception $e) {
+            $this->connection->rollback();
+            $this->logger->error('Failed to cleanup completed jobs', LogContext::withData([
+                'error' => $e->getMessage(),
+                'deleted_before_error' => $totalDeleted
+            ]));
+            throw $e;
+        }
+
+        return $totalDeleted;
+    }
+
+    /**
+     * Clean up old failed jobs
+     */
+    public function cleanupFailedJobs(Duration $olderThan): int
+    {
+        $cutoffDate = $this->calculateCutoffDate($olderThan);
+        $totalDeleted = 0;
+
+        $this->logger->info('Starting failed jobs cleanup', LogContext::withData([
+            'older_than_days' => $olderThan->toHours() / 24,
+            'cutoff_date' => $cutoffDate
+        ]));
+
+        try {
+            $this->connection->beginTransaction();
+
+            $sql = "DELETE FROM job_history
+                   WHERE new_status = 'failed'
+                   AND changed_at < :cutoff
+                   LIMIT :limit";
+
+            do {
+                if ($this->memoryManager->shouldAbortJob('cleanup_failed_jobs')) {
+                    break;
+                }
+
+                $deleted = $this->connection->execute(SqlQuery::create($sql, [
+                    'cutoff' => $cutoffDate,
+                    'limit' => self::CLEANUP_BATCH_SIZE
+                ]));
+                $totalDeleted += $deleted;
+
+                if ($deleted === self::CLEANUP_BATCH_SIZE) {
+                    usleep(100000);
+                }
+
+            } while ($deleted === self::CLEANUP_BATCH_SIZE);
+
+            $this->connection->commit();
+
+            $this->logger->info('Failed jobs cleanup finished', LogContext::withData([
+                'total_deleted' => $totalDeleted
+            ]));
+
+        } catch (\Exception $e) {
+            $this->connection->rollback();
+            $this->logger->error('Failed to cleanup failed jobs', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+
+        return $totalDeleted;
+    }
+
+    /**
+     * Clean up old job metrics
+     */
+    public function cleanupJobMetrics(Duration $olderThan): int
+    {
+        $cutoffDate = $this->calculateCutoffDate($olderThan);
+        $totalDeleted = 0;
+
+        $this->logger->info('Starting job metrics cleanup', LogContext::withData([
+            'older_than_days' => $olderThan->toHours() / 24,
+            'cutoff_date' => $cutoffDate
+        ]));
+
+        try {
+            $this->connection->beginTransaction();
+
+            $sql = "DELETE FROM job_metrics
+                   WHERE created_at < :cutoff
+                   LIMIT :limit";
+
+            do {
+                if ($this->memoryManager->shouldAbortJob('cleanup_metrics')) {
+                    break;
+                }
+
+                $deleted = $this->connection->execute(SqlQuery::create($sql, [
+                    'cutoff' => $cutoffDate,
+                    'limit' => self::CLEANUP_BATCH_SIZE
+                ]));
+                $totalDeleted += $deleted;
+
+                if ($deleted === self::CLEANUP_BATCH_SIZE) {
+                    usleep(100000);
+                }
+
+            } while ($deleted === self::CLEANUP_BATCH_SIZE);
+
+            $this->connection->commit();
+
+            $this->logger->info('Job metrics cleanup finished', LogContext::withData([
+                'total_deleted' => $totalDeleted
+            ]));
+
+        } catch (\Exception $e) {
+            $this->connection->rollback();
+            $this->logger->error('Failed to cleanup job metrics', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+
+        return $totalDeleted;
+    }
+
+    /**
+     * Clean up old dead letter jobs
+     */
+    public function cleanupDeadLetterJobs(Duration $olderThan): int
+    {
+        $cutoffDate = $this->calculateCutoffDate($olderThan);
+        $totalDeleted = 0;
+
+        $this->logger->info('Starting dead letter jobs cleanup', LogContext::withData([
+            'older_than_days' => $olderThan->toHours() / 24,
+            'cutoff_date' => $cutoffDate
+        ]));
+
+        try {
+            $this->connection->beginTransaction();
+
+            $sql = "DELETE FROM dead_letter_jobs
+                   WHERE moved_to_dlq_at < :cutoff
+                   LIMIT :limit";
+
+            do {
+                if ($this->memoryManager->shouldAbortJob('cleanup_dead_letter')) {
+                    break;
+                }
+
+                $deleted = $this->connection->execute(SqlQuery::create($sql, [
+                    'cutoff' => $cutoffDate,
+                    'limit' => self::CLEANUP_BATCH_SIZE
+                ]));
+                $totalDeleted += $deleted;
+
+                if ($deleted === self::CLEANUP_BATCH_SIZE) {
+                    usleep(100000);
+                }
+
+            } while ($deleted === self::CLEANUP_BATCH_SIZE);
+
+            $this->connection->commit();
+
+            $this->logger->info('Dead letter jobs cleanup finished', LogContext::withData([
+                'total_deleted' => $totalDeleted
+            ]));
+
+        } catch (\Exception $e) {
+            $this->connection->rollback();
+            $this->logger->error('Failed to cleanup dead letter jobs', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+
+        return $totalDeleted;
+    }
+
+    /**
+     * Run comprehensive cleanup with default retention periods
+     */
+    public function runComprehensiveCleanup(): array
+    {
+        $this->logger->info('Starting comprehensive queue cleanup');
+
+        $startTime = microtime(true);
+        $memoryBefore = $this->memoryMonitor->getSummary();
+
+        $results = [
+            'started_at' => date('Y-m-d H:i:s'),
+            'completed_jobs' => 0,
+            'failed_jobs' => 0,
+            'job_metrics' => 0,
+            'dead_letter_jobs' => 0,
+            'total_deleted' => 0,
+            'errors' => []
+        ];
+
+        // Clean completed jobs
+        try {
+            $results['completed_jobs'] = $this->cleanupCompletedJobs(
+                Duration::fromDays(self::DEFAULT_COMPLETED_RETENTION_DAYS)
+            );
+        } catch (\Exception $e) {
+            $results['errors'][] = 'Failed to cleanup completed jobs: ' . $e->getMessage();
+        }
+
+        // Clean failed jobs
+        try {
+            $results['failed_jobs'] = $this->cleanupFailedJobs(
+                Duration::fromDays(self::DEFAULT_FAILED_RETENTION_DAYS)
+            );
+        } catch (\Exception $e) {
+            $results['errors'][] = 'Failed to cleanup failed jobs: ' . $e->getMessage();
+        }
+
+        // Clean job metrics
+        try {
+            $results['job_metrics'] = $this->cleanupJobMetrics(
+                Duration::fromDays(self::DEFAULT_METRICS_RETENTION_DAYS)
+            );
+        } catch (\Exception $e) {
+            $results['errors'][] = 'Failed to cleanup job metrics: ' . $e->getMessage();
+        }
+
+        // Clean dead letter jobs
+        try {
+            $results['dead_letter_jobs'] = $this->cleanupDeadLetterJobs(
+                Duration::fromDays(self::DEFAULT_DEAD_LETTER_RETENTION_DAYS)
+            );
+        } catch (\Exception $e) {
+            $results['errors'][] = 'Failed to cleanup dead letter jobs: ' . $e->getMessage();
+        }
+
+        $results['total_deleted'] = $results['completed_jobs']
+            + $results['failed_jobs']
+            + $results['job_metrics']
+            + $results['dead_letter_jobs'];
+
+        $memoryAfter = $this->memoryMonitor->getSummary();
+        $duration = microtime(true) - $startTime;
+
+        $results['completed_at'] = date('Y-m-d H:i:s');
+        $results['duration_seconds'] = round($duration, 2);
+        $results['memory_used'] = $memoryAfter->current->toHumanReadable();
+        $results['memory_peak'] = $memoryAfter->peak->toHumanReadable();
+
+        $this->logger->info('Comprehensive cleanup completed', $results);
+
+        return $results;
+    }
+
+    /**
+     * Get cleanup statistics
+     */
+    public function getCleanupStatistics(): array
+    {
+        $stats = [];
+
+        try {
+            // Get count of completed jobs eligible for cleanup
+            $sql = "SELECT COUNT(*) as count FROM job_history
+                   WHERE new_status = 'completed'
+                   AND changed_at < :cutoff";
+
+            $result = $this->connection->queryOne(SqlQuery::create($sql, [
+                'cutoff' => $this->calculateCutoffDate(
+                    Duration::fromDays(self::DEFAULT_COMPLETED_RETENTION_DAYS)
+                )
+            ]));
+            $stats['eligible_completed_jobs'] = $result['count'] ?? 0;
+
+            // Get count of failed jobs eligible for cleanup
+            $sql = "SELECT COUNT(*) as count FROM job_history
+                   WHERE new_status = 'failed'
+                   AND changed_at < :cutoff";
+
+            $result = $this->connection->queryOne(SqlQuery::create($sql, [
+                'cutoff' => $this->calculateCutoffDate(
+                    Duration::fromDays(self::DEFAULT_FAILED_RETENTION_DAYS)
+                )
+            ]));
+            $stats['eligible_failed_jobs'] = $result['count'] ?? 0;
+
+            // Get count of metrics eligible for cleanup
+            $sql = "SELECT COUNT(*) as count FROM job_metrics
+                   WHERE created_at < :cutoff";
+
+            $result = $this->connection->queryOne(SqlQuery::create($sql, [
+                'cutoff' => $this->calculateCutoffDate(
+                    Duration::fromDays(self::DEFAULT_METRICS_RETENTION_DAYS)
+                )
+            ]));
+            $stats['eligible_metrics'] = $result['count'] ?? 0;
+
+            // Get count of dead letter jobs eligible for cleanup
+            $sql = "SELECT COUNT(*) as count FROM dead_letter_jobs
+                   WHERE moved_to_dlq_at < :cutoff";
+
+            $result = $this->connection->queryOne(SqlQuery::create($sql, [
+                'cutoff' => $this->calculateCutoffDate(
+                    Duration::fromDays(self::DEFAULT_DEAD_LETTER_RETENTION_DAYS)
+                )
+            ]));
+            $stats['eligible_dead_letter_jobs'] = $result['count'] ?? 0;
+
+            $stats['total_eligible'] = $stats['eligible_completed_jobs']
+                + $stats['eligible_failed_jobs']
+                + $stats['eligible_metrics']
+                + $stats['eligible_dead_letter_jobs'];
+
+            // Calculate estimated cleanup time (rough estimate)
+            $stats['estimated_cleanup_minutes'] = ceil($stats['total_eligible'] / self::CLEANUP_BATCH_SIZE);
+
+            // Add retention settings
+            $stats['retention_days'] = [
+                'completed_jobs' => self::DEFAULT_COMPLETED_RETENTION_DAYS,
+                'failed_jobs' => self::DEFAULT_FAILED_RETENTION_DAYS,
+                'metrics' => self::DEFAULT_METRICS_RETENTION_DAYS,
+                'dead_letter_jobs' => self::DEFAULT_DEAD_LETTER_RETENTION_DAYS
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to get cleanup statistics', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+
+        return $stats;
+    }
+
+    /**
+     * Calculate cutoff date from duration
+     */
+    private function calculateCutoffDate(Duration $olderThan): string
+    {
+        $seconds = $olderThan->toSeconds();
+        $cutoffTimestamp = time() - (int) $seconds;
+        return date('Y-m-d H:i:s', $cutoffTimestamp);
+    }
+}

src/Framework/Queue/Services/JobDistributionService.php

@@ -0,0 +1,449 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Entities\Worker;
+use App\Framework\Queue\ValueObjects\JobId;
+use App\Framework\Queue\ValueObjects\QueueName;
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Queue\ValueObjects\LockKey;
+use App\Framework\Queue\Interfaces\DistributedLockInterface;
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+
+/**
+ * Service für intelligente Job-Verteilung an Worker
+ */
+final readonly class JobDistributionService
+{
+    private const JOB_LOCK_TTL_SECONDS = 300; // 5 Minuten
+    private const DISTRIBUTION_LOCK_TTL_SECONDS = 30; // 30 Sekunden
+
+    public function __construct(
+        private WorkerRegistry $workerRegistry,
+        private DistributedLockInterface $distributedLock,
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Job an besten verfügbaren Worker verteilen
+     */
+    public function distributeJob(JobId $jobId, QueueName $queueName, array $jobData = []): ?WorkerId
+    {
+        $this->logger->info('Starting job distribution', LogContext::withData([
+            'job_id' => $jobId->toString(),
+            'queue_name' => $queueName->toString()
+        ]));
+
+        // Lock für Distribution-Prozess erwerben
+        $distributionLock = LockKey::forQueue($queueName)->withSuffix('distribution');
+        $tempWorkerId = WorkerId::generate(); // Temporäre Worker ID für Distribution Lock
+
+        if (!$this->distributedLock->acquireWithTimeout(
+            $distributionLock,
+            $tempWorkerId,
+            Duration::fromSeconds(self::DISTRIBUTION_LOCK_TTL_SECONDS),
+            Duration::fromSeconds(5)
+        )) {
+            $this->logger->warning('Failed to acquire distribution lock', LogContext::withData([
+                'job_id' => $jobId->toString(),
+                'queue_name' => $queueName->toString()
+            ]));
+            return null;
+        }
+
+        try {
+            // Job Lock erwerben
+            $jobLock = LockKey::forJob($jobId);
+            if (!$this->distributedLock->acquire(
+                $jobLock,
+                $tempWorkerId,
+                Duration::fromSeconds(self::JOB_LOCK_TTL_SECONDS)
+            )) {
+                $this->logger->warning('Job already locked by another process', LogContext::withData([
+                    'job_id' => $jobId->toString()
+                ]));
+                return null;
+            }
+
+            // Besten Worker finden
+            $worker = $this->findBestWorkerForJob($queueName, $jobData);
+            if (!$worker) {
+                $this->logger->warning('No suitable worker found', LogContext::withData([
+                    'job_id' => $jobId->toString(),
+                    'queue_name' => $queueName->toString()
+                ]));
+
+                // Job Lock freigeben
+                $this->distributedLock->release($jobLock, $tempWorkerId);
+                return null;
+            }
+
+            // Job Lock an Worker übertragen
+            if (!$this->transferJobLock($jobLock, $tempWorkerId, $worker->id)) {
+                $this->logger->error('Failed to transfer job lock to worker', LogContext::withData([
+                    'job_id' => $jobId->toString(),
+                    'worker_id' => $worker->id->toString()
+                ]));
+
+                // Job Lock freigeben
+                $this->distributedLock->release($jobLock, $tempWorkerId);
+                return null;
+            }
+
+            // Job Assignment in Datenbank speichern
+            $this->recordJobAssignment($jobId, $worker->id, $queueName);
+
+            $this->logger->info('Job successfully distributed', LogContext::withData([
+                'job_id' => $jobId->toString(),
+                'worker_id' => $worker->id->toString(),
+                'queue_name' => $queueName->toString(),
+                'worker_load' => $worker->getLoadPercentage()->getValue()
+            ]));
+
+            return $worker->id;
+
+        } finally {
+            // Distribution Lock freigeben
+            $this->distributedLock->release($distributionLock, $tempWorkerId);
+        }
+    }
+
+    /**
+     * Besten Worker für Job finden
+     */
+    public function findBestWorkerForJob(QueueName $queueName, array $jobData = []): ?Worker
+    {
+        // Worker für Queue finden
+        $workers = $this->workerRegistry->findWorkersForQueue($queueName);
+
+        if (empty($workers)) {
+            return null;
+        }
+
+        // Worker nach verschiedenen Kriterien bewerten
+        $scoredWorkers = [];
+
+        foreach ($workers as $worker) {
+            if (!$worker->isAvailableForJobs()) {
+                continue;
+            }
+
+            $score = $this->calculateWorkerScore($worker, $jobData);
+            $scoredWorkers[] = [
+                'worker' => $worker,
+                'score' => $score
+            ];
+        }
+
+        if (empty($scoredWorkers)) {
+            return null;
+        }
+
+        // Nach Score sortieren (höchster Score = bester Worker)
+        usort($scoredWorkers, fn($a, $b) => $b['score'] <=> $a['score']);
+
+        return $scoredWorkers[0]['worker'];
+    }
+
+    /**
+     * Worker Score berechnen (höher = besser)
+     */
+    private function calculateWorkerScore(Worker $worker, array $jobData): float
+    {
+        $score = 100.0; // Basis Score
+
+        // Last-basierte Bewertung (weniger Last = höherer Score)
+        $loadPenalty = $worker->getLoadPercentage()->getValue();
+        $score -= $loadPenalty;
+
+        // CPU-basierte Bewertung
+        $cpuPenalty = $worker->cpuUsage->getValue() * 0.5;
+        $score -= $cpuPenalty;
+
+        // Memory-basierte Bewertung (vereinfacht)
+        $memoryUsageGB = $worker->memoryUsage->toBytes() / (1024 * 1024 * 1024);
+        if ($memoryUsageGB > 1.5) { // Über 1.5GB = Penalty
+            $score -= ($memoryUsageGB - 1.5) * 10;
+        }
+
+        // Capability-basierte Bewertung
+        if (isset($jobData['required_capabilities'])) {
+            foreach ($jobData['required_capabilities'] as $capability) {
+                if ($worker->hasCapability($capability)) {
+                    $score += 20; // Bonus für jede erfüllte Capability
+                } else {
+                    return 0; // Worker kann Job nicht ausführen
+                }
+            }
+        }
+
+        // Bonus für Worker mit niedrigerer aktueller Job-Anzahl
+        $availableSlots = $worker->maxJobs - $worker->currentJobs;
+        $score += $availableSlots * 2;
+
+        return max(0, $score);
+    }
+
+    /**
+     * Job Lock von einem Worker an anderen übertragen
+     */
+    private function transferJobLock(LockKey $jobLock, WorkerId $fromWorker, WorkerId $toWorker): bool
+    {
+        // Neuen Lock für Ziel-Worker erstellen
+        if (!$this->distributedLock->acquire(
+            $jobLock,
+            $toWorker,
+            Duration::fromSeconds(self::JOB_LOCK_TTL_SECONDS)
+        )) {
+            return false;
+        }
+
+        // Alten Lock freigeben
+        $this->distributedLock->release($jobLock, $fromWorker);
+
+        return true;
+    }
+
+    /**
+     * Job Assignment in Datenbank speichern
+     */
+    private function recordJobAssignment(JobId $jobId, WorkerId $workerId, QueueName $queueName): void
+    {
+        try {
+            $sql = "INSERT INTO job_assignments (
+                        job_id, worker_id, queue_name, assigned_at
+                    ) VALUES (
+                        :job_id, :worker_id, :queue_name, NOW()
+                    ) ON DUPLICATE KEY UPDATE
+                        worker_id = VALUES(worker_id),
+                        assigned_at = VALUES(assigned_at)";
+
+            $this->connection->execute(SqlQuery::create($sql, [
+                'job_id' => $jobId->toString(),
+                'worker_id' => $workerId->toString(),
+                'queue_name' => $queueName->toString()
+            ]));
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to record job assignment', LogContext::withData([
+                'job_id' => $jobId->toString(),
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            // Nicht critical - Job kann trotzdem verarbeitet werden
+        }
+    }
+
+    /**
+     * Job von Worker freigeben
+     */
+    public function releaseJob(JobId $jobId, WorkerId $workerId): bool
+    {
+        $this->logger->info('Releasing job from worker', LogContext::withData([
+            'job_id' => $jobId->toString(),
+            'worker_id' => $workerId->toString()
+        ]));
+
+        // Job Lock freigeben
+        $jobLock = LockKey::forJob($jobId);
+        $released = $this->distributedLock->release($jobLock, $workerId);
+
+        if ($released) {
+            // Job Assignment aus Datenbank entfernen
+            try {
+                $sql = "DELETE FROM job_assignments
+                       WHERE job_id = :job_id AND worker_id = :worker_id";
+
+                $this->connection->execute(SqlQuery::create($sql, [
+                    'job_id' => $jobId->toString(),
+                    'worker_id' => $workerId->toString()
+                ]));
+
+            } catch (\Exception $e) {
+                $this->logger->warning('Failed to remove job assignment record', LogContext::withData([
+                    'job_id' => $jobId->toString(),
+                    'worker_id' => $workerId->toString(),
+                    'error' => $e->getMessage()
+                ]));
+            }
+
+            $this->logger->info('Job released successfully', LogContext::withData([
+                'job_id' => $jobId->toString(),
+                'worker_id' => $workerId->toString()
+            ]));
+        }
+
+        return $released;
+    }
+
+    /**
+     * Job Lock verlängern
+     */
+    public function extendJobLock(JobId $jobId, WorkerId $workerId, ?Duration $extension = null): bool
+    {
+        $extension = $extension ?? Duration::fromSeconds(self::JOB_LOCK_TTL_SECONDS);
+
+        $jobLock = LockKey::forJob($jobId);
+        return $this->distributedLock->extend($jobLock, $workerId, $extension);
+    }
+
+    /**
+     * Alle Jobs eines Workers freigeben
+     */
+    public function releaseAllWorkerJobs(WorkerId $workerId): int
+    {
+        $this->logger->info('Releasing all jobs for worker', LogContext::withData([
+            'worker_id' => $workerId->toString()
+        ]));
+
+        // Alle Locks des Workers freigeben
+        $releasedLocks = $this->distributedLock->releaseAllWorkerLocks($workerId);
+
+        // Job Assignments aus Datenbank entfernen
+        try {
+            $sql = "DELETE FROM job_assignments WHERE worker_id = :worker_id";
+            $releasedAssignments = $this->connection->execute(SqlQuery::create($sql, [
+                'worker_id' => $workerId->toString()
+            ]));
+
+            $this->logger->info('Released all worker jobs', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'released_locks' => $releasedLocks,
+                'released_assignments' => $releasedAssignments
+            ]));
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to release worker job assignments', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+        }
+
+        return $releasedLocks;
+    }
+
+    /**
+     * Distribution Statistiken
+     */
+    public function getDistributionStatistics(): array
+    {
+        try {
+            // Job Assignments Statistiken
+            $sql = "SELECT
+                       COUNT(*) as total_assignments,
+                       COUNT(DISTINCT worker_id) as active_workers,
+                       COUNT(DISTINCT queue_name) as active_queues,
+                       AVG(TIMESTAMPDIFF(SECOND, assigned_at, NOW())) as avg_assignment_age_seconds
+                   FROM job_assignments";
+
+            $assignmentStats = $this->connection->queryOne(SqlQuery::create($sql));
+
+            // Worker Load Distribution
+            $workerStats = [];
+            $activeWorkers = $this->workerRegistry->findActiveWorkers();
+
+            foreach ($activeWorkers as $worker) {
+                $workerStats[] = [
+                    'worker_id' => $worker->id->toString(),
+                    'hostname' => $worker->hostname,
+                    'current_jobs' => $worker->currentJobs,
+                    'max_jobs' => $worker->maxJobs,
+                    'load_percentage' => $worker->getLoadPercentage()->getValue(),
+                    'queues' => array_map(fn($q) => $q->toString(), $worker->queues)
+                ];
+            }
+
+            // Lock Statistiken
+            $lockStats = $this->distributedLock->getLockStatistics();
+
+            return [
+                'assignments' => [
+                    'total' => (int) $assignmentStats['total_assignments'],
+                    'active_workers' => (int) $assignmentStats['active_workers'],
+                    'active_queues' => (int) $assignmentStats['active_queues'],
+                    'avg_assignment_age_seconds' => round((float) $assignmentStats['avg_assignment_age_seconds'], 2)
+                ],
+                'workers' => $workerStats,
+                'locks' => $lockStats,
+                'distribution_health' => $this->calculateDistributionHealth($workerStats)
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to get distribution statistics', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Distribution Health Score berechnen
+     */
+    private function calculateDistributionHealth(array $workerStats): array
+    {
+        if (empty($workerStats)) {
+            return [
+                'score' => 0,
+                'status' => 'critical',
+                'issues' => ['No active workers']
+            ];
+        }
+
+        $score = 100;
+        $issues = [];
+
+        // Load Balance prüfen
+        $loads = array_column($workerStats, 'load_percentage');
+        $avgLoad = array_sum($loads) / count($loads);
+        $maxLoad = max($loads);
+        $minLoad = min($loads);
+
+        if ($maxLoad > 90) {
+            $score -= 30;
+            $issues[] = 'Workers overloaded (>90%)';
+        } elseif ($maxLoad > 75) {
+            $score -= 15;
+            $issues[] = 'High worker load (>75%)';
+        }
+
+        // Load Distribution prüfen
+        $loadVariance = $maxLoad - $minLoad;
+        if ($loadVariance > 50) {
+            $score -= 20;
+            $issues[] = 'Uneven load distribution';
+        }
+
+        // Worker Availability prüfen
+        $availableWorkers = array_filter($workerStats, fn($w) => $w['load_percentage'] < 80);
+        $availabilityRatio = count($availableWorkers) / count($workerStats);
+
+        if ($availabilityRatio < 0.3) {
+            $score -= 25;
+            $issues[] = 'Low worker availability (<30%)';
+        }
+
+        $status = match(true) {
+            $score >= 80 => 'healthy',
+            $score >= 60 => 'warning',
+            $score >= 40 => 'degraded',
+            default => 'critical'
+        };
+
+        return [
+            'score' => max(0, $score),
+            'status' => $status,
+            'avg_load' => round($avgLoad, 2),
+            'max_load' => $maxLoad,
+            'load_variance' => $loadVariance,
+            'availability_ratio' => round($availabilityRatio * 100, 2),
+            'issues' => $issues
+        ];
+    }
+}

src/Framework/Queue/Services/JobMemoryManager.php

@@ -0,0 +1,292 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Core\ValueObjects\Byte;
+use App\Framework\Core\ValueObjects\Percentage;
+use App\Framework\Performance\MemoryMonitor;
+use App\Framework\Performance\ValueObjects\MemorySummary;
+use App\Framework\Queue\ValueObjects\JobMetrics;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+
+/**
+ * Manages memory usage and optimization for queue jobs using framework's performance monitoring
+ */
+final readonly class JobMemoryManager
+{
+    private const CRITICAL_MEMORY_THRESHOLD = 90.0; // 90% of limit
+    private const WARNING_MEMORY_THRESHOLD = 75.0;  // 75% of limit
+    private const OPTIMAL_MEMORY_THRESHOLD = 50.0;  // 50% is considered optimal
+
+    public function __construct(
+        private MemoryMonitor $memoryMonitor,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Get current memory usage for job context
+     */
+    public function getJobMemorySnapshot(string $jobId): array
+    {
+        $summary = $this->memoryMonitor->getSummary();
+
+        return [
+            'job_id' => $jobId,
+            'timestamp' => date('Y-m-d H:i:s'),
+            'current' => $summary->getCurrentHumanReadable(),
+            'current_bytes' => $summary->getCurrentBytes(),
+            'peak' => $summary->getPeakHumanReadable(),
+            'peak_bytes' => $summary->getPeakBytes(),
+            'limit' => $summary->getLimitHumanReadable(),
+            'limit_bytes' => $summary->getLimitBytes(),
+            'available' => $summary->getAvailableMemory()->toHumanReadable(),
+            'available_bytes' => $summary->getAvailableMemory()->toBytes(),
+            'usage_percentage' => $summary->getUsagePercentageFormatted(),
+            'is_critical' => $summary->isMemoryCritical(self::CRITICAL_MEMORY_THRESHOLD),
+            'is_warning' => $summary->isMemoryLow(self::WARNING_MEMORY_THRESHOLD),
+            'status' => $this->getMemoryStatus($summary)
+        ];
+    }
+
+    /**
+     * Monitor memory during job execution
+     */
+    public function monitorJobExecution(string $jobId, string $phase): MemorySummary
+    {
+        $summary = $this->memoryMonitor->getSummary();
+
+        // Log based on memory status
+        if ($summary->isMemoryCritical(self::CRITICAL_MEMORY_THRESHOLD)) {
+            $this->logger->error('Critical memory usage during job execution', LogContext::withData([
+                'job_id' => $jobId,
+                'phase' => $phase,
+                'memory' => $summary->getCurrentHumanReadable(),
+                'usage' => $summary->getUsagePercentageFormatted(),
+                'available' => $summary->getAvailableMemory()->toHumanReadable()
+            ]));
+        } elseif ($summary->isMemoryLow(self::WARNING_MEMORY_THRESHOLD)) {
+            $this->logger->warning('High memory usage during job execution', LogContext::withData([
+                'job_id' => $jobId,
+                'phase' => $phase,
+                'memory' => $summary->getCurrentHumanReadable(),
+                'usage' => $summary->getUsagePercentageFormatted()
+            ]));
+        }
+
+        return $summary;
+    }
+
+    /**
+     * Check if job should be aborted due to memory constraints
+     */
+    public function shouldAbortJob(string $jobId): bool
+    {
+        $summary = $this->memoryMonitor->getSummary();
+
+        if ($summary->isMemoryCritical(self::CRITICAL_MEMORY_THRESHOLD)) {
+            $this->logger->error('Job should be aborted due to critical memory usage', LogContext::withData([
+                'job_id' => $jobId,
+                'memory' => $summary->getCurrentHumanReadable(),
+                'usage' => $summary->getUsagePercentageFormatted(),
+                'limit' => $summary->getLimitHumanReadable()
+            ]));
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Optimize memory before job execution
+     */
+    public function optimizeForJob(string $jobId): array
+    {
+        $before = $this->memoryMonitor->getSummary();
+
+        // Force garbage collection
+        gc_collect_cycles();
+
+        $after = $this->memoryMonitor->getSummary();
+
+        $freedBytes = $before->getCurrentBytes() - $after->getCurrentBytes();
+        $freedMemory = Byte::fromBytes(max(0, $freedBytes));
+
+        $optimization = [
+            'job_id' => $jobId,
+            'optimized_at' => date('Y-m-d H:i:s'),
+            'before' => $before->getCurrentHumanReadable(),
+            'after' => $after->getCurrentHumanReadable(),
+            'freed' => $freedMemory->toHumanReadable(),
+            'freed_bytes' => $freedMemory->toBytes(),
+            'usage_before' => $before->getUsagePercentageFormatted(),
+            'usage_after' => $after->getUsagePercentageFormatted()
+        ];
+
+        $this->logger->debug('Memory optimized for job', LogContext::withData([
+            'job_id' => $jobId,
+            'freed' => $freedMemory->toHumanReadable(),
+            'usage_before' => $before->getUsagePercentageFormatted(),
+            'usage_after' => $after->getUsagePercentageFormatted()
+        ]));
+
+        return $optimization;
+    }
+
+    /**
+     * Calculate memory efficiency for job metrics
+     */
+    public function calculateJobMemoryEfficiency(array $jobMetrics): array
+    {
+        if (empty($jobMetrics)) {
+            return [
+                'total_jobs' => 0,
+                'average_memory' => Byte::fromBytes(0),
+                'peak_memory' => Byte::fromBytes(0),
+                'total_memory' => Byte::fromBytes(0),
+                'efficiency_score' => Percentage::from(100),
+                'efficiency_rating' => 'excellent'
+            ];
+        }
+
+        $totalBytes = 0;
+        $peakBytes = 0;
+        $jobCount = count($jobMetrics);
+
+        foreach ($jobMetrics as $metrics) {
+            if ($metrics instanceof JobMetrics) {
+                $bytes = $metrics->memoryUsageBytes;
+                $totalBytes += $bytes;
+                $peakBytes = max($peakBytes, $bytes);
+            }
+        }
+
+        $averageBytes = $jobCount > 0 ? (int)($totalBytes / $jobCount) : 0;
+        $averageMemory = Byte::fromBytes($averageBytes);
+        $peakMemory = Byte::fromBytes($peakBytes);
+        $totalMemory = Byte::fromBytes($totalBytes);
+
+        // Calculate efficiency score
+        $memoryLimit = $this->memoryMonitor->getMemoryLimit();
+        $optimalLimit = Byte::fromBytes((int)($memoryLimit->toBytes() * self::OPTIMAL_MEMORY_THRESHOLD / 100));
+
+        // Efficiency is how well we stay under the optimal threshold
+        $efficiencyRatio = $averageBytes > 0 ? min(1.0, $optimalLimit->toBytes() / $averageBytes) : 1.0;
+        $efficiencyScore = Percentage::from($efficiencyRatio * 100);
+
+        return [
+            'total_jobs' => $jobCount,
+            'average_memory' => $averageMemory,
+            'average_memory_human' => $averageMemory->toHumanReadable(),
+            'peak_memory' => $peakMemory,
+            'peak_memory_human' => $peakMemory->toHumanReadable(),
+            'total_memory' => $totalMemory,
+            'total_memory_human' => $totalMemory->toHumanReadable(),
+            'efficiency_score' => $efficiencyScore,
+            'efficiency_score_formatted' => $efficiencyScore->format(2),
+            'efficiency_rating' => $this->getEfficiencyRating($efficiencyScore)
+        ];
+    }
+
+    /**
+     * Get memory recommendations for job processing
+     */
+    public function getMemoryRecommendations(): array
+    {
+        $summary = $this->memoryMonitor->getSummary();
+        $recommendations = [];
+        $priority = 'low';
+
+        if ($summary->isMemoryCritical(self::CRITICAL_MEMORY_THRESHOLD)) {
+            $priority = 'critical';
+            $recommendations[] = [
+                'type' => 'critical',
+                'message' => 'Memory usage is critical. Consider immediate action.',
+                'actions' => [
+                    'Increase memory limit or reduce job complexity',
+                    'Force garbage collection before new jobs',
+                    'Split large jobs into smaller chunks',
+                    'Consider job queue throttling'
+                ]
+            ];
+        } elseif ($summary->isMemoryLow(self::WARNING_MEMORY_THRESHOLD)) {
+            $priority = 'warning';
+            $recommendations[] = [
+                'type' => 'warning',
+                'message' => 'Memory usage is high. Monitor closely.',
+                'actions' => [
+                    'Schedule periodic garbage collection',
+                    'Review job memory patterns',
+                    'Consider optimizing job processing',
+                    'Monitor for memory leaks'
+                ]
+            ];
+        } else {
+            $recommendations[] = [
+                'type' => 'info',
+                'message' => 'Memory usage is within normal range.',
+                'actions' => [
+                    'Continue monitoring',
+                    'Maintain current optimization strategies'
+                ]
+            ];
+        }
+
+        return [
+            'priority' => $priority,
+            'current_usage' => $summary->getUsagePercentageFormatted(),
+            'available' => $summary->getAvailableMemory()->toHumanReadable(),
+            'recommendations' => $recommendations,
+            'timestamp' => date('Y-m-d H:i:s')
+        ];
+    }
+
+    /**
+     * Check if enough memory is available for job
+     */
+    public function hasEnoughMemoryForJob(Byte $estimatedMemory): bool
+    {
+        $summary = $this->memoryMonitor->getSummary();
+        $available = $summary->getAvailableMemory();
+
+        // Add 20% buffer for safety
+        $requiredWithBuffer = Byte::fromBytes((int)($estimatedMemory->toBytes() * 1.2));
+
+        return $available->toBytes() >= $requiredWithBuffer->toBytes();
+    }
+
+    /**
+     * Get memory status string
+     */
+    private function getMemoryStatus(MemorySummary $summary): string
+    {
+        if ($summary->isMemoryCritical(self::CRITICAL_MEMORY_THRESHOLD)) {
+            return 'critical';
+        } elseif ($summary->isMemoryLow(self::WARNING_MEMORY_THRESHOLD)) {
+            return 'warning';
+        } elseif ($summary->usagePercentage->greaterThan(Percentage::from(self::OPTIMAL_MEMORY_THRESHOLD))) {
+            return 'elevated';
+        } else {
+            return 'normal';
+        }
+    }
+
+    /**
+     * Get efficiency rating based on score
+     */
+    private function getEfficiencyRating(Percentage $score): string
+    {
+        $value = $score->getValue();
+
+        return match (true) {
+            $value >= 90 => 'excellent',
+            $value >= 70 => 'good',
+            $value >= 50 => 'fair',
+            $value >= 30 => 'poor',
+            default => 'critical'
+        };
+    }
+}

src/Framework/Queue/Services/JobMetricsManager.php

@@ -0,0 +1,359 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\ValueObjects\JobMetrics;
+use App\Framework\Queue\ValueObjects\QueueMetrics;
+use App\Framework\Queue\Entities\JobMetricsEntry;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Logging\Logger;
+use App\Framework\Core\ValueObjects\Percentage;
+
+final readonly class JobMetricsManager
+{
+    public function __construct(
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    public function recordJobMetrics(JobMetrics $metrics): void
+    {
+        $existingEntry = $this->findJobMetricsEntry($metrics->jobId);
+
+        if ($existingEntry) {
+            $updatedEntry = $existingEntry->updateWithMetrics($metrics);
+            $this->entityManager->save($updatedEntry);
+        } else {
+            $newEntry = JobMetricsEntry::fromJobMetrics($metrics);
+            $this->entityManager->save($newEntry);
+        }
+
+        $this->entityManager->flush();
+
+        $this->logger->debug('Job metrics recorded', [
+            'job_id' => $metrics->jobId,
+            'queue_name' => $metrics->queueName,
+            'status' => $metrics->status,
+            'execution_time_ms' => $metrics->executionTimeMs,
+            'memory_usage_mb' => $metrics->getMemoryUsageMB()
+        ]);
+    }
+
+    public function getJobMetrics(string $jobId): ?JobMetrics
+    {
+        $entry = $this->findJobMetricsEntry($jobId);
+        return $entry ? $entry->getJobMetrics() : null;
+    }
+
+    public function getQueueMetrics(string $queueName, string $timeWindow = '1 hour'): QueueMetrics
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+
+        $query = "SELECT * FROM job_metrics
+                  WHERE queue_name = ? AND created_at >= ?
+                  ORDER BY created_at DESC";
+
+        $results = $this->connection->fetchAll($query, [$queueName, $windowStart]);
+
+        $jobMetrics = array_map(function(array $row) {
+            return $this->mapRowToJobMetrics($row);
+        }, $results);
+
+        return QueueMetrics::calculate($queueName, $jobMetrics, $timeWindow);
+    }
+
+    public function getAllQueueMetrics(string $timeWindow = '1 hour'): array
+    {
+        $query = "SELECT DISTINCT queue_name FROM job_metrics";
+        $queueNames = $this->connection->fetchAll($query);
+
+        $allMetrics = [];
+        foreach ($queueNames as $row) {
+            $queueName = $row['queue_name'];
+            $allMetrics[$queueName] = $this->getQueueMetrics($queueName, $timeWindow);
+        }
+
+        return $allMetrics;
+    }
+
+    public function getJobMetricsHistory(string $jobId): array
+    {
+        $query = "SELECT * FROM job_metrics
+                  WHERE job_id = ?
+                  ORDER BY updated_at ASC";
+
+        $results = $this->connection->fetchAll($query, [$jobId]);
+
+        return array_map(function(array $row) {
+            return $this->mapRowToJobMetrics($row);
+        }, $results);
+    }
+
+    public function getTopSlowJobs(?string $queueName = null, int $limit = 10): array
+    {
+        $whereClause = $queueName ? "WHERE queue_name = ?" : "";
+        $params = $queueName ? [$queueName] : [];
+
+        $query = "SELECT * FROM job_metrics
+                  {$whereClause}
+                  ORDER BY execution_time_ms DESC
+                  LIMIT ?";
+
+        $params[] = $limit;
+        $results = $this->connection->fetchAll($query, $params);
+
+        return array_map(function(array $row) {
+            return $this->mapRowToJobMetrics($row);
+        }, $results);
+    }
+
+    public function getTopMemoryConsumers(?string $queueName = null, int $limit = 10): array
+    {
+        $whereClause = $queueName ? "WHERE queue_name = ?" : "";
+        $params = $queueName ? [$queueName] : [];
+
+        $query = "SELECT * FROM job_metrics
+                  {$whereClause}
+                  ORDER BY memory_usage_bytes DESC
+                  LIMIT ?";
+
+        $params[] = $limit;
+        $results = $this->connection->fetchAll($query, $params);
+
+        return array_map(function(array $row) {
+            return $this->mapRowToJobMetrics($row);
+        }, $results);
+    }
+
+    public function getFailedJobs(?string $queueName = null, string $timeWindow = '24 hours'): array
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+
+        $whereClause = "WHERE status = 'failed' AND failed_at >= ?";
+        $params = [$windowStart];
+
+        if ($queueName) {
+            $whereClause .= " AND queue_name = ?";
+            $params[] = $queueName;
+        }
+
+        $query = "SELECT * FROM job_metrics
+                  {$whereClause}
+                  ORDER BY failed_at DESC";
+
+        $results = $this->connection->fetchAll($query, $params);
+
+        return array_map(function(array $row) {
+            return $this->mapRowToJobMetrics($row);
+        }, $results);
+    }
+
+    public function getPerformanceStats(?string $queueName = null, string $timeWindow = '24 hours'): array
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+
+        $whereClause = "WHERE created_at >= ?";
+        $params = [$windowStart];
+
+        if ($queueName) {
+            $whereClause .= " AND queue_name = ?";
+            $params[] = $queueName;
+        }
+
+        $query = "SELECT
+                    COUNT(*) as total_jobs,
+                    COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed_jobs,
+                    COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed_jobs,
+                    AVG(execution_time_ms) as avg_execution_time_ms,
+                    MIN(execution_time_ms) as min_execution_time_ms,
+                    MAX(execution_time_ms) as max_execution_time_ms,
+                    AVG(memory_usage_bytes) as avg_memory_usage_bytes,
+                    MIN(memory_usage_bytes) as min_memory_usage_bytes,
+                    MAX(memory_usage_bytes) as max_memory_usage_bytes,
+                    AVG(attempts) as avg_attempts
+                  FROM job_metrics
+                  {$whereClause}";
+
+        $result = $this->connection->fetchOne($query, $params);
+
+        $totalJobs = (int) $result['total_jobs'];
+        $completedJobs = (int) $result['completed_jobs'];
+        $failedJobs = (int) $result['failed_jobs'];
+
+        $successRate = $totalJobs > 0 ? ($completedJobs / $totalJobs) * 100 : 100;
+
+        return [
+            'time_window' => $timeWindow,
+            'queue_name' => $queueName,
+            'total_jobs' => $totalJobs,
+            'completed_jobs' => $completedJobs,
+            'failed_jobs' => $failedJobs,
+            'success_rate' => $successRate,
+            'failure_rate' => 100 - $successRate,
+            'average_execution_time_ms' => (float) $result['avg_execution_time_ms'],
+            'min_execution_time_ms' => (float) $result['min_execution_time_ms'],
+            'max_execution_time_ms' => (float) $result['max_execution_time_ms'],
+            'average_memory_usage_bytes' => (int) $result['avg_memory_usage_bytes'],
+            'min_memory_usage_bytes' => (int) $result['min_memory_usage_bytes'],
+            'max_memory_usage_bytes' => (int) $result['max_memory_usage_bytes'],
+            'average_memory_usage_mb' => (int) $result['avg_memory_usage_bytes'] / (1024 * 1024),
+            'average_attempts' => (float) $result['avg_attempts']
+        ];
+    }
+
+    public function getThroughputStats(?string $queueName = null, string $timeWindow = '24 hours'): array
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+
+        $whereClause = "WHERE completed_at >= ?";
+        $params = [$windowStart];
+
+        if ($queueName) {
+            $whereClause .= " AND queue_name = ?";
+            $params[] = $queueName;
+        }
+
+        // Get hourly throughput
+        $query = "SELECT
+                    DATE_FORMAT(completed_at, '%Y-%m-%d %H:00:00') as hour,
+                    COUNT(*) as jobs_completed
+                  FROM job_metrics
+                  {$whereClause}
+                  GROUP BY hour
+                  ORDER BY hour";
+
+        $hourlyStats = $this->connection->fetchAll($query, $params);
+
+        $totalHours = count($hourlyStats);
+        $totalCompleted = array_sum(array_column($hourlyStats, 'jobs_completed'));
+        $avgThroughput = $totalHours > 0 ? $totalCompleted / $totalHours : 0;
+
+        return [
+            'time_window' => $timeWindow,
+            'queue_name' => $queueName,
+            'total_completed' => $totalCompleted,
+            'average_throughput_per_hour' => $avgThroughput,
+            'hourly_breakdown' => $hourlyStats
+        ];
+    }
+
+    public function cleanupOldMetrics(int $olderThanDays = 90): int
+    {
+        $cutoffDate = date('Y-m-d H:i:s', strtotime("-{$olderThanDays} days"));
+
+        $query = "DELETE FROM job_metrics WHERE created_at < ?";
+
+        $this->logger->info('Cleaning up old job metrics', [
+            'cutoff_date' => $cutoffDate,
+            'older_than_days' => $olderThanDays
+        ]);
+
+        $affectedRows = $this->connection->execute($query, [$cutoffDate]);
+
+        $this->logger->info('Old job metrics cleaned up', [
+            'deleted_count' => $affectedRows
+        ]);
+
+        return $affectedRows;
+    }
+
+    public function getSystemOverview(): array
+    {
+        $allMetrics = $this->getAllQueueMetrics('24 hours');
+
+        $totalJobs = 0;
+        $totalCompleted = 0;
+        $totalFailed = 0;
+        $totalPending = 0;
+        $totalRunning = 0;
+        $avgExecutionTime = 0;
+        $avgMemoryUsage = 0;
+        $healthyQueues = 0;
+
+        foreach ($allMetrics as $queueMetrics) {
+            $totalJobs += $queueMetrics->totalJobs;
+            $totalCompleted += $queueMetrics->completedJobs;
+            $totalFailed += $queueMetrics->failedJobs;
+            $totalPending += $queueMetrics->pendingJobs;
+            $totalRunning += $queueMetrics->runningJobs;
+            $avgExecutionTime += $queueMetrics->averageExecutionTimeMs;
+            $avgMemoryUsage += $queueMetrics->averageMemoryUsageMB;
+
+            if ($queueMetrics->isHealthy()) {
+                $healthyQueues++;
+            }
+        }
+
+        $queueCount = count($allMetrics);
+        $systemHealthScore = $queueCount > 0 ? ($healthyQueues / $queueCount) * 100 : 100;
+
+        return [
+            'total_queues' => $queueCount,
+            'healthy_queues' => $healthyQueues,
+            'system_health_score' => $systemHealthScore,
+            'total_jobs' => $totalJobs,
+            'completed_jobs' => $totalCompleted,
+            'failed_jobs' => $totalFailed,
+            'pending_jobs' => $totalPending,
+            'running_jobs' => $totalRunning,
+            'overall_success_rate' => $totalJobs > 0 ? ($totalCompleted / $totalJobs) * 100 : 100,
+            'average_execution_time_ms' => $queueCount > 0 ? $avgExecutionTime / $queueCount : 0,
+            'average_memory_usage_mb' => $queueCount > 0 ? $avgMemoryUsage / $queueCount : 0,
+            'queue_metrics' => $allMetrics
+        ];
+    }
+
+    private function findJobMetricsEntry(string $jobId): ?JobMetricsEntry
+    {
+        $query = "SELECT * FROM job_metrics WHERE job_id = ? ORDER BY updated_at DESC LIMIT 1";
+        $result = $this->connection->fetchOne($query, [$jobId]);
+
+        if (!$result) {
+            return null;
+        }
+
+        return $this->mapRowToEntry($result);
+    }
+
+    private function mapRowToEntry(array $row): JobMetricsEntry
+    {
+        return new JobMetricsEntry(
+            id: $row['id'],
+            jobId: $row['job_id'],
+            queueName: $row['queue_name'],
+            status: $row['status'],
+            attempts: (int) $row['attempts'],
+            maxAttempts: (int) $row['max_attempts'],
+            executionTimeMs: (float) $row['execution_time_ms'],
+            memoryUsageBytes: (int) $row['memory_usage_bytes'],
+            createdAt: $row['created_at'],
+            updatedAt: $row['updated_at'],
+            errorMessage: $row['error_message'],
+            startedAt: $row['started_at'],
+            completedAt: $row['completed_at'],
+            failedAt: $row['failed_at'],
+            metadata: $row['metadata']
+        );
+    }
+
+    private function mapRowToJobMetrics(array $row): JobMetrics
+    {
+        return new JobMetrics(
+            jobId: $row['job_id'],
+            queueName: $row['queue_name'],
+            status: $row['status'],
+            attempts: (int) $row['attempts'],
+            maxAttempts: (int) $row['max_attempts'],
+            executionTimeMs: (float) $row['execution_time_ms'],
+            memoryUsageBytes: (int) $row['memory_usage_bytes'],
+            errorMessage: $row['error_message'],
+            createdAt: $row['created_at'],
+            startedAt: $row['started_at'],
+            completedAt: $row['completed_at'],
+            failedAt: $row['failed_at'],
+            metadata: $row['metadata'] ? json_decode($row['metadata'], true) : []
+        );
+    }
+}

src/Framework/Queue/Services/JobMetricsManagerInterface.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\ValueObjects\JobMetrics;
+use App\Framework\Queue\ValueObjects\QueueMetrics;
+
+interface JobMetricsManagerInterface
+{
+    public function recordJobMetrics(JobMetrics $metrics): void;
+
+    public function getSystemOverview(): array;
+
+    public function getQueueMetrics(string $queueName, string $timeWindow): QueueMetrics;
+
+    public function getJobMetrics(string $jobId): ?JobMetrics;
+
+    public function getTopSlowJobs(?string $queueName, int $limit): array;
+
+    public function getTopMemoryConsumers(?string $queueName, int $limit): array;
+
+    public function getFailedJobs(?string $queueName, string $timeWindow): array;
+
+    public function getPerformanceStats(?string $queueName, string $timeWindow): array;
+
+    public function getThroughputStats(?string $queueName, string $timeWindow): array;
+
+    public function cleanupOldMetrics(int $olderThanDays): int;
+}

src/Framework/Queue/Services/MockJobMetricsManager.php

@@ -0,0 +1,210 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\ValueObjects\JobMetrics;
+use App\Framework\Queue\ValueObjects\QueueMetrics;
+use App\Framework\Logging\Logger;
+use App\Framework\Core\ValueObjects\Percentage;
+
+/**
+ * Mock implementation of JobMetricsManager for demonstration purposes
+ */
+final readonly class MockJobMetricsManager implements JobMetricsManagerInterface
+{
+    public function __construct(
+        private Logger $logger
+    ) {}
+
+    public function recordJobMetrics(JobMetrics $metrics): void
+    {
+        $this->logger->debug('Job metrics recorded (mock)', [
+            'job_id' => $metrics->jobId,
+            'queue_name' => $metrics->queueName,
+            'status' => $metrics->status,
+        ]);
+    }
+
+    public function getSystemOverview(): array
+    {
+        return [
+            'system_health_score' => 85,
+            'total_queues' => 3,
+            'healthy_queues' => 2,
+            'total_jobs' => 1250,
+            'completed_jobs' => 1200,
+            'failed_jobs' => 35,
+            'pending_jobs' => 10,
+            'running_jobs' => 5,
+            'overall_success_rate' => 96.0,
+            'average_execution_time_ms' => 245,
+            'average_memory_usage_mb' => 12.5,
+            'queue_metrics' => [
+                'emails' => $this->createMockQueueMetrics('emails', 850, 95.2),
+                'notifications' => $this->createMockQueueMetrics('notifications', 300, 98.0),
+                'reports' => $this->createMockQueueMetrics('reports', 100, 85.0),
+            ]
+        ];
+    }
+
+    public function getQueueMetrics(string $queueName, string $timeWindow): QueueMetrics
+    {
+        return $this->createMockQueueMetrics($queueName, 500, 94.5);
+    }
+
+    public function getJobMetrics(string $jobId): ?JobMetrics
+    {
+        if ($jobId === 'nonexistent') {
+            return null;
+        }
+
+        return new JobMetrics(
+            jobId: $jobId,
+            queueName: 'emails',
+            status: 'completed',
+            attempts: 1,
+            maxAttempts: 3,
+            executionTimeMs: 150,
+            memoryUsageBytes: 2048000,
+            createdAt: '2024-01-15 10:30:00',
+            startedAt: '2024-01-15 10:30:01',
+            completedAt: '2024-01-15 10:30:02',
+            failedAt: null,
+            errorMessage: null,
+            metadata: ['user_id' => 123, 'template' => 'welcome']
+        );
+    }
+
+    public function getTopSlowJobs(?string $queueName, int $limit): array
+    {
+        $jobs = [];
+        for ($i = 1; $i <= min($limit, 5); $i++) {
+            $jobs[] = new JobMetrics(
+                jobId: "slow-job-{$i}",
+                queueName: $queueName ?? 'emails',
+                status: 'completed',
+                attempts: 1,
+                maxAttempts: 3,
+                executionTimeMs: 1000 + ($i * 200),
+                memoryUsageBytes: 1024000 * $i,
+                createdAt: '2024-01-15 10:30:00',
+                startedAt: '2024-01-15 10:30:01',
+                completedAt: '2024-01-15 10:30:02',
+                failedAt: null,
+                errorMessage: null,
+                metadata: []
+            );
+        }
+        return $jobs;
+    }
+
+    public function getTopMemoryConsumers(?string $queueName, int $limit): array
+    {
+        $jobs = [];
+        for ($i = 1; $i <= min($limit, 5); $i++) {
+            $jobs[] = new JobMetrics(
+                jobId: "memory-job-{$i}",
+                queueName: $queueName ?? 'reports',
+                status: 'completed',
+                attempts: 1,
+                maxAttempts: 3,
+                executionTimeMs: 300,
+                memoryUsageBytes: 10485760 * $i, // 10MB, 20MB, etc.
+                createdAt: '2024-01-15 10:30:00',
+                startedAt: '2024-01-15 10:30:01',
+                completedAt: '2024-01-15 10:30:02',
+                failedAt: null,
+                errorMessage: null,
+                metadata: []
+            );
+        }
+        return $jobs;
+    }
+
+    public function getFailedJobs(?string $queueName, string $timeWindow): array
+    {
+        $jobs = [];
+        for ($i = 1; $i <= 3; $i++) {
+            $jobs[] = new JobMetrics(
+                jobId: "failed-job-{$i}",
+                queueName: $queueName ?? 'notifications',
+                status: 'failed',
+                attempts: 3,
+                maxAttempts: 3,
+                executionTimeMs: 500,
+                memoryUsageBytes: 1024000,
+                createdAt: '2024-01-15 10:30:00',
+                startedAt: '2024-01-15 10:30:01',
+                completedAt: null,
+                failedAt: '2024-01-15 10:30:10',
+                errorMessage: "Connection timeout to external API",
+                metadata: []
+            );
+        }
+        return $jobs;
+    }
+
+    public function getPerformanceStats(?string $queueName, string $timeWindow): array
+    {
+        return [
+            'total_jobs' => 1000,
+            'completed_jobs' => 950,
+            'failed_jobs' => 50,
+            'success_rate' => 95.0,
+            'failure_rate' => 5.0,
+            'average_execution_time_ms' => 250.5,
+            'min_execution_time_ms' => 50.0,
+            'max_execution_time_ms' => 2500.0,
+            'average_memory_usage_mb' => 15.2,
+            'min_memory_usage_bytes' => 512000,
+            'max_memory_usage_bytes' => 52428800,
+            'average_attempts' => 1.1,
+        ];
+    }
+
+    public function getThroughputStats(?string $queueName, string $timeWindow): array
+    {
+        $hourlyData = [];
+        for ($hour = 0; $hour < 24; $hour++) {
+            $hourlyData[] = [
+                'hour' => sprintf('2024-01-15 %02d:00:00', $hour),
+                'jobs_completed' => rand(10, 50)
+            ];
+        }
+
+        return [
+            'total_completed' => 800,
+            'average_throughput_per_hour' => 33.3,
+            'hourly_breakdown' => $hourlyData
+        ];
+    }
+
+    public function cleanupOldMetrics(int $olderThanDays): int
+    {
+        // Simulate cleanup
+        return rand(50, 200);
+    }
+
+    private function createMockQueueMetrics(string $queueName, int $totalJobs, float $successRate): QueueMetrics
+    {
+        $completedJobs = (int) ($totalJobs * ($successRate / 100));
+        $failedJobs = $totalJobs - $completedJobs;
+
+        return new QueueMetrics(
+            queueName: $queueName,
+            totalJobs: $totalJobs,
+            completedJobs: $completedJobs,
+            failedJobs: $failedJobs,
+            pendingJobs: rand(5, 20),
+            runningJobs: rand(0, 5),
+            deadLetterJobs: rand(0, 3),
+            successRate: new Percentage($successRate),
+            averageExecutionTimeMs: rand(100, 500),
+            averageMemoryUsageMB: rand(5, 25),
+            throughputJobsPerHour: rand(50, 200),
+            measuredAt: date('Y-m-d H:i:s')
+        );
+    }
+}

src/Framework/Queue/Services/ProductionJobMetricsManager.php

@@ -0,0 +1,510 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\ValueObjects\JobMetrics;
+use App\Framework\Queue\ValueObjects\QueueMetrics;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Core\ValueObjects\Percentage;
+
+/**
+ * Production implementation of JobMetricsManager with full database integration
+ */
+final readonly class ProductionJobMetricsManager implements JobMetricsManagerInterface
+{
+    public function __construct(
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    public function recordJobMetrics(JobMetrics $metrics): void
+    {
+        try {
+            $this->connection->beginTransaction();
+
+            $existingEntry = $this->findJobMetricsEntry($metrics->jobId);
+
+            if ($existingEntry) {
+                $this->updateJobMetricsEntry($metrics);
+            } else {
+                $this->insertJobMetricsEntry($metrics);
+            }
+
+            $this->connection->commit();
+
+            $this->logger->debug('Job metrics recorded', [
+                'job_id' => $metrics->jobId,
+                'queue_name' => $metrics->queueName,
+                'status' => $metrics->status,
+                'execution_time_ms' => $metrics->executionTimeMs,
+                'memory_usage_bytes' => $metrics->memoryUsageBytes,
+            ]);
+        } catch (\Exception $e) {
+            $this->connection->rollback();
+
+            $this->logger->error('Failed to record job metrics', [
+                'job_id' => $metrics->jobId,
+                'error' => $e->getMessage()
+            ]);
+
+            throw $e;
+        }
+    }
+
+    public function getJobMetrics(string $jobId): ?JobMetrics
+    {
+        $query = "SELECT * FROM job_metrics WHERE job_id = ? LIMIT 1";
+        $result = $this->connection->queryOne(
+            SqlQuery::create($query, [$jobId])
+        );
+
+        if (!$result) {
+            return null;
+        }
+
+        return $this->mapRowToJobMetrics($result);
+    }
+
+    public function getQueueMetrics(string $queueName, string $timeWindow = '1 hour'): QueueMetrics
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+
+        $query = "SELECT * FROM job_metrics
+                  WHERE queue_name = ? AND created_at >= ?
+                  ORDER BY created_at DESC";
+
+        $results = $this->connection->query(
+            SqlQuery::create($query, [$queueName, $windowStart])
+        )->fetchAll();
+
+        $jobMetrics = array_map(function(array $row) {
+            return $this->mapRowToJobMetrics($row);
+        }, $results);
+
+        return $this->calculateQueueMetrics($queueName, $jobMetrics, $timeWindow);
+    }
+
+    public function getSystemOverview(): array
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime('-24 hours'));
+
+        // Get overall statistics
+        $overallStats = $this->connection->queryOne(
+            SqlQuery::create("
+                SELECT
+                    COUNT(*) as total_jobs,
+                    SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_jobs,
+                    SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_jobs,
+                    SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending_jobs,
+                    SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END) as running_jobs,
+                    AVG(execution_time_ms) as avg_execution_time,
+                    AVG(memory_usage_bytes / 1024 / 1024) as avg_memory_mb
+                FROM job_metrics
+                WHERE created_at >= ?
+            ", [$windowStart])
+        );
+
+        $totalJobs = (int) $overallStats['total_jobs'];
+        $completedJobs = (int) $overallStats['completed_jobs'];
+        $successRate = $totalJobs > 0 ? ($completedJobs / $totalJobs) * 100 : 100.0;
+
+        // Get queue names
+        $queueNames = $this->connection->query(
+            SqlQuery::create("
+                SELECT DISTINCT queue_name
+                FROM job_metrics
+                WHERE created_at >= ?
+            ", [$windowStart])
+        )->fetchAll();
+
+        $queueMetrics = [];
+        $healthyQueues = 0;
+
+        foreach ($queueNames as $row) {
+            $queueName = $row['queue_name'];
+            $metrics = $this->getQueueMetrics($queueName, '24 hours');
+            $queueMetrics[$queueName] = $metrics;
+
+            if ($metrics->isHealthy()) {
+                $healthyQueues++;
+            }
+        }
+
+        $systemHealthScore = $this->calculateSystemHealthScore($successRate, count($queueNames), $healthyQueues);
+
+        return [
+            'system_health_score' => $systemHealthScore,
+            'total_queues' => count($queueNames),
+            'healthy_queues' => $healthyQueues,
+            'total_jobs' => $totalJobs,
+            'completed_jobs' => $completedJobs,
+            'failed_jobs' => (int) $overallStats['failed_jobs'],
+            'pending_jobs' => (int) $overallStats['pending_jobs'],
+            'running_jobs' => (int) $overallStats['running_jobs'],
+            'overall_success_rate' => round($successRate, 1),
+            'average_execution_time_ms' => round((float) $overallStats['avg_execution_time'], 1),
+            'average_memory_usage_mb' => round((float) $overallStats['avg_memory_mb'], 1),
+            'queue_metrics' => $queueMetrics
+        ];
+    }
+
+    public function getTopSlowJobs(?string $queueName, int $limit): array
+    {
+        $params = [];
+        $whereClause = '';
+
+        if ($queueName) {
+            $whereClause = 'WHERE queue_name = ?';
+            $params[] = $queueName;
+        }
+
+        $query = "SELECT * FROM job_metrics
+                  {$whereClause}
+                  ORDER BY execution_time_ms DESC
+                  LIMIT ?";
+
+        $params[] = $limit;
+        $results = $this->connection->query(
+            SqlQuery::create($query, $params)
+        )->fetchAll();
+
+        return array_map([$this, 'mapRowToJobMetrics'], $results);
+    }
+
+    public function getTopMemoryConsumers(?string $queueName, int $limit): array
+    {
+        $params = [];
+        $whereClause = '';
+
+        if ($queueName) {
+            $whereClause = 'WHERE queue_name = ?';
+            $params[] = $queueName;
+        }
+
+        $query = "SELECT * FROM job_metrics
+                  {$whereClause}
+                  ORDER BY memory_usage_bytes DESC
+                  LIMIT ?";
+
+        $params[] = $limit;
+        $results = $this->connection->query(
+            SqlQuery::create($query, $params)
+        )->fetchAll();
+
+        return array_map([$this, 'mapRowToJobMetrics'], $results);
+    }
+
+    public function getFailedJobs(?string $queueName, string $timeWindow): array
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+        $params = [$windowStart];
+        $whereClause = 'WHERE status = "failed" AND created_at >= ?';
+
+        if ($queueName) {
+            $whereClause .= ' AND queue_name = ?';
+            $params[] = $queueName;
+        }
+
+        $query = "SELECT * FROM job_metrics
+                  {$whereClause}
+                  ORDER BY failed_at DESC";
+
+        $results = $this->connection->query(
+            SqlQuery::create($query, $params)
+        )->fetchAll();
+
+        return array_map([$this, 'mapRowToJobMetrics'], $results);
+    }
+
+    public function getPerformanceStats(?string $queueName, string $timeWindow): array
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+        $params = [$windowStart];
+        $whereClause = 'WHERE created_at >= ?';
+
+        if ($queueName) {
+            $whereClause .= ' AND queue_name = ?';
+            $params[] = $queueName;
+        }
+
+        $query = "SELECT
+                    COUNT(*) as total_jobs,
+                    SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_jobs,
+                    SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_jobs,
+                    AVG(execution_time_ms) as avg_execution_time,
+                    MIN(execution_time_ms) as min_execution_time,
+                    MAX(execution_time_ms) as max_execution_time,
+                    AVG(memory_usage_bytes / 1024 / 1024) as avg_memory_mb,
+                    MIN(memory_usage_bytes) as min_memory_bytes,
+                    MAX(memory_usage_bytes) as max_memory_bytes,
+                    AVG(attempts) as avg_attempts
+                  FROM job_metrics
+                  {$whereClause}";
+
+        $stats = $this->connection->queryOne(
+            SqlQuery::create($query, $params)
+        );
+
+        $totalJobs = (int) $stats['total_jobs'];
+        $completedJobs = (int) $stats['completed_jobs'];
+        $failedJobs = (int) $stats['failed_jobs'];
+
+        return [
+            'total_jobs' => $totalJobs,
+            'completed_jobs' => $completedJobs,
+            'failed_jobs' => $failedJobs,
+            'success_rate' => $totalJobs > 0 ? ($completedJobs / $totalJobs) * 100 : 100,
+            'failure_rate' => $totalJobs > 0 ? ($failedJobs / $totalJobs) * 100 : 0,
+            'average_execution_time_ms' => (float) $stats['avg_execution_time'],
+            'min_execution_time_ms' => (float) $stats['min_execution_time'],
+            'max_execution_time_ms' => (float) $stats['max_execution_time'],
+            'average_memory_usage_mb' => (float) $stats['avg_memory_mb'],
+            'min_memory_usage_bytes' => (int) $stats['min_memory_bytes'],
+            'max_memory_usage_bytes' => (int) $stats['max_memory_bytes'],
+            'average_attempts' => (float) $stats['avg_attempts'],
+        ];
+    }
+
+    public function getThroughputStats(?string $queueName, string $timeWindow): array
+    {
+        $windowStart = date('Y-m-d H:i:s', strtotime("-{$timeWindow}"));
+        $params = [$windowStart];
+        $whereClause = 'WHERE status = "completed" AND created_at >= ?';
+
+        if ($queueName) {
+            $whereClause .= ' AND queue_name = ?';
+            $params[] = $queueName;
+        }
+
+        // Overall throughput
+        $overallQuery = "SELECT COUNT(*) as total_completed
+                        FROM job_metrics
+                        {$whereClause}";
+
+        $totalCompleted = (int) $this->connection->queryOne(
+            SqlQuery::create($overallQuery, $params)
+        )['total_completed'];
+
+        // Hourly breakdown
+        $hourlyQuery = "SELECT
+                          DATE_FORMAT(completed_at, '%Y-%m-%d %H:00:00') as hour,
+                          COUNT(*) as jobs_completed
+                        FROM job_metrics
+                        {$whereClause}
+                        GROUP BY DATE_FORMAT(completed_at, '%Y-%m-%d %H:00:00')
+                        ORDER BY hour";
+
+        $hourlyStats = $this->connection->query(
+            SqlQuery::create($hourlyQuery, $params)
+        )->fetchAll();
+
+        // Calculate average per hour
+        $hours = $this->getHoursInTimeWindow($timeWindow);
+        $averageThroughput = $hours > 0 ? $totalCompleted / $hours : 0;
+
+        return [
+            'total_completed' => $totalCompleted,
+            'average_throughput_per_hour' => $averageThroughput,
+            'hourly_breakdown' => $hourlyStats
+        ];
+    }
+
+    public function cleanupOldMetrics(int $olderThanDays): int
+    {
+        $cutoffDate = date('Y-m-d H:i:s', strtotime("-{$olderThanDays} days"));
+
+        $query = "DELETE FROM job_metrics WHERE created_at < ?";
+        $affectedRows = $this->connection->execute(
+            SqlQuery::create($query, [$cutoffDate])
+        );
+
+        $this->logger->info('Job metrics cleanup completed', [
+            'cutoff_date' => $cutoffDate,
+            'deleted_rows' => $affectedRows
+        ]);
+
+        return $affectedRows;
+    }
+
+    private function insertJobMetricsEntry(JobMetrics $metrics): void
+    {
+        $query = "INSERT INTO job_metrics (
+                    job_id, queue_name, status, attempts, max_attempts,
+                    execution_time_ms, memory_usage_bytes,
+                    created_at, started_at, completed_at, failed_at,
+                    error_message, metadata
+                  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+        $this->connection->execute(
+            SqlQuery::create($query, [
+                $metrics->jobId,
+                $metrics->queueName,
+                $metrics->status,
+                $metrics->attempts,
+                $metrics->maxAttempts,
+                $metrics->executionTimeMs,
+                $metrics->memoryUsageBytes,
+                $metrics->createdAt,
+                $metrics->startedAt,
+                $metrics->completedAt,
+                $metrics->failedAt,
+                $metrics->errorMessage,
+                $metrics->metadata ? json_encode($metrics->metadata) : null
+            ])
+        );
+    }
+
+    private function updateJobMetricsEntry(JobMetrics $metrics): void
+    {
+        $query = "UPDATE job_metrics SET
+                    status = ?, attempts = ?, execution_time_ms = ?,
+                    memory_usage_bytes = ?, started_at = ?, completed_at = ?,
+                    failed_at = ?, error_message = ?, metadata = ?
+                  WHERE job_id = ?";
+
+        $this->connection->execute(
+            SqlQuery::create($query, [
+                $metrics->status,
+                $metrics->attempts,
+                $metrics->executionTimeMs,
+                $metrics->memoryUsageBytes,
+                $metrics->startedAt,
+                $metrics->completedAt,
+                $metrics->failedAt,
+                $metrics->errorMessage,
+                $metrics->metadata ? json_encode($metrics->metadata) : null,
+                $metrics->jobId
+            ])
+        );
+    }
+
+    private function findJobMetricsEntry(string $jobId): ?array
+    {
+        $query = "SELECT * FROM job_metrics WHERE job_id = ? LIMIT 1";
+        $result = $this->connection->queryOne(
+            SqlQuery::create($query, [$jobId])
+        );
+
+        return $result ?: null;
+    }
+
+    private function mapRowToJobMetrics(array $row): JobMetrics
+    {
+        return new JobMetrics(
+            jobId: $row['job_id'],
+            queueName: $row['queue_name'],
+            status: $row['status'],
+            attempts: (int) $row['attempts'],
+            maxAttempts: (int) $row['max_attempts'],
+            executionTimeMs: (int) $row['execution_time_ms'],
+            memoryUsageBytes: (int) $row['memory_usage_bytes'],
+            createdAt: $row['created_at'],
+            startedAt: $row['started_at'],
+            completedAt: $row['completed_at'],
+            failedAt: $row['failed_at'],
+            errorMessage: $row['error_message'],
+            metadata: $row['metadata'] ? json_decode($row['metadata'], true) : []
+        );
+    }
+
+    private function calculateQueueMetrics(string $queueName, array $jobMetrics, string $timeWindow): QueueMetrics
+    {
+        $totalJobs = count($jobMetrics);
+
+        if ($totalJobs === 0) {
+            return new QueueMetrics(
+                queueName: $queueName,
+                totalJobs: 0,
+                completedJobs: 0,
+                failedJobs: 0,
+                pendingJobs: 0,
+                runningJobs: 0,
+                deadLetterJobs: 0,
+                successRate: new Percentage(100.0),
+                averageExecutionTimeMs: 0,
+                averageMemoryUsageMB: 0.0,
+                throughputJobsPerHour: 0.0,
+                measuredAt: date('Y-m-d H:i:s')
+            );
+        }
+
+        $completed = $failed = $pending = $running = $deadLetter = 0;
+        $totalExecutionTime = $totalMemory = 0;
+
+        foreach ($jobMetrics as $metrics) {
+            switch ($metrics->status) {
+                case 'completed':
+                    $completed++;
+                    break;
+                case 'failed':
+                    $failed++;
+                    break;
+                case 'pending':
+                    $pending++;
+                    break;
+                case 'running':
+                    $running++;
+                    break;
+                case 'dead_letter':
+                    $deadLetter++;
+                    break;
+            }
+
+            $totalExecutionTime += $metrics->executionTimeMs;
+            $totalMemory += $metrics->memoryUsageBytes;
+        }
+
+        $successRate = new Percentage($totalJobs > 0 ? ($completed / $totalJobs) * 100 : 100);
+        $avgExecutionTime = $totalJobs > 0 ? $totalExecutionTime / $totalJobs : 0;
+        $avgMemoryMB = $totalJobs > 0 ? ($totalMemory / $totalJobs) / (1024 * 1024) : 0;
+
+        // Calculate throughput (jobs per hour)
+        $hours = $this->getHoursInTimeWindow($timeWindow);
+        $throughput = $hours > 0 ? $completed / $hours : 0;
+
+        return new QueueMetrics(
+            queueName: $queueName,
+            totalJobs: $totalJobs,
+            completedJobs: $completed,
+            failedJobs: $failed,
+            pendingJobs: $pending,
+            runningJobs: $running,
+            deadLetterJobs: $deadLetter,
+            successRate: $successRate,
+            averageExecutionTimeMs: $avgExecutionTime,
+            averageMemoryUsageMB: $avgMemoryMB,
+            throughputJobsPerHour: $throughput,
+            measuredAt: date('Y-m-d H:i:s')
+        );
+    }
+
+    private function calculateSystemHealthScore(float $successRate, int $totalQueues, int $healthyQueues): int
+    {
+        $successWeight = 60; // 60% weight for success rate
+        $healthWeight = 40;  // 40% weight for queue health
+
+        $successScore = $successRate;
+        $healthScore = $totalQueues > 0 ? ($healthyQueues / $totalQueues) * 100 : 100;
+
+        $weightedScore = ($successScore * $successWeight + $healthScore * $healthWeight) / 100;
+
+        return (int) round($weightedScore);
+    }
+
+    private function getHoursInTimeWindow(string $timeWindow): float
+    {
+        try {
+            // Use framework's Duration class instead of manual parsing
+            $duration = Duration::parse($timeWindow);
+            return $duration->toHours();
+        } catch (\Exception) {
+            // Fallback to 1 hour if parsing fails
+            return 1.0;
+        }
+    }
+}

src/Framework/Queue/Services/ProgressManager.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Contracts\JobProgressTrackerInterface;
+use App\Framework\Queue\ValueObjects\JobProgress;
+use App\Framework\Queue\ValueObjects\ProgressStep;
+use App\Framework\Core\ValueObjects\Percentage;
+
+/**
+ * High-level progress management service for coordinating job progress tracking
+ */
+final readonly class ProgressManager
+{
+    public function __construct(
+        private JobProgressTrackerInterface $progressTracker
+    ) {}
+
+    public function startJob(string $jobId, string $message = 'Job started'): void
+    {
+        $progress = JobProgress::starting($message);
+        $this->progressTracker->updateProgress($jobId, $progress, null);
+    }
+
+    public function updateJobProgress(
+        string $jobId,
+        float $percentage,
+        string $message,
+        ?array $metadata = null
+    ): void {
+        $progress = JobProgress::withPercentage(
+            percentage: Percentage::from($percentage),
+            message: $message,
+            metadata: $metadata
+        );
+
+        $this->progressTracker->updateProgress($jobId, $progress, null);
+    }
+
+    public function completeJobStep(
+        string $jobId,
+        string $stepName,
+        string $description,
+        ?array $metadata = null
+    ): void {
+        $step = ProgressStep::completed($stepName, $description, $metadata);
+        $this->progressTracker->completeStep($jobId, $step);
+    }
+
+    public function completeJob(string $jobId, string $message = 'Job completed successfully'): void
+    {
+        $this->progressTracker->markJobCompleted($jobId, $message);
+    }
+
+    public function failJob(string $jobId, string $message, ?\Throwable $exception = null): void
+    {
+        $this->progressTracker->markJobFailed($jobId, $message, $exception);
+    }
+
+    public function getJobProgress(string $jobId): ?JobProgress
+    {
+        return $this->progressTracker->getCurrentProgress($jobId);
+    }
+
+    public function getProgressHistory(string $jobId): array
+    {
+        return $this->progressTracker->getProgressHistory($jobId);
+    }
+
+    public function getMultipleJobProgress(array $jobIds): array
+    {
+        return $this->progressTracker->getProgressForJobs($jobIds);
+    }
+
+    public function getJobsAboveProgress(float $minPercentage): array
+    {
+        return $this->progressTracker->getJobsAboveProgress($minPercentage);
+    }
+
+    public function getRecentlyUpdatedJobs(int $limitMinutes = 60, int $limit = 100): array
+    {
+        return $this->progressTracker->getRecentlyUpdatedJobs($limitMinutes, $limit);
+    }
+
+    public function cleanupOldProgress(int $olderThanDays = 30): int
+    {
+        return $this->progressTracker->cleanupOldEntries($olderThanDays);
+    }
+
+    /**
+     * Create a multi-step progress tracker for complex jobs
+     */
+    public function createStepTracker(string $jobId, array $steps): StepProgressTracker
+    {
+        return new StepProgressTracker($jobId, $steps, $this);
+    }
+}

src/Framework/Queue/Services/StepProgressTracker.php

@@ -0,0 +1,170 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\ValueObjects\ProgressStep;
+use App\Framework\Core\ValueObjects\Percentage;
+
+/**
+ * Helper class for tracking progress through multiple steps
+ */
+final class StepProgressTracker
+{
+    private int $currentStepIndex = 0;
+    private array $completedSteps = [];
+
+    public function __construct(
+        private readonly string $jobId,
+        private readonly array $steps,
+        private readonly ProgressManager $progressManager
+    ) {
+        if (empty($steps)) {
+            throw new \InvalidArgumentException('Steps array cannot be empty');
+        }
+
+        // Validate step structure
+        foreach ($steps as $index => $step) {
+            if (!is_array($step) || !isset($step['name'], $step['description'])) {
+                throw new \InvalidArgumentException("Step at index {$index} must have 'name' and 'description' keys");
+            }
+        }
+    }
+
+    public function start(string $message = 'Starting multi-step job'): void
+    {
+        $this->progressManager->startJob($this->jobId, $message);
+    }
+
+    public function completeCurrentStep(?array $metadata = null): void
+    {
+        if ($this->currentStepIndex >= count($this->steps)) {
+            throw new \RuntimeException('All steps have already been completed');
+        }
+
+        $step = $this->steps[$this->currentStepIndex];
+
+        $this->progressManager->completeJobStep(
+            $this->jobId,
+            $step['name'],
+            $step['description'],
+            $metadata
+        );
+
+        $this->completedSteps[] = $step['name'];
+        $this->currentStepIndex++;
+
+        // Update overall progress percentage
+        $percentage = ($this->currentStepIndex / count($this->steps)) * 100;
+        $message = sprintf(
+            'Completed step %d of %d: %s',
+            $this->currentStepIndex,
+            count($this->steps),
+            $step['description']
+        );
+
+        $this->progressManager->updateJobProgress(
+            $this->jobId,
+            $percentage,
+            $message,
+            [
+                'current_step' => $this->currentStepIndex,
+                'total_steps' => count($this->steps),
+                'completed_steps' => $this->completedSteps
+            ]
+        );
+    }
+
+    public function updateCurrentStepProgress(
+        float $stepPercentage,
+        string $message,
+        ?array $metadata = null
+    ): void {
+        if ($this->currentStepIndex >= count($this->steps)) {
+            throw new \RuntimeException('All steps have already been completed');
+        }
+
+        // Calculate overall percentage: completed steps + current step progress
+        $completedStepsPercentage = ($this->currentStepIndex / count($this->steps)) * 100;
+        $currentStepContribution = ($stepPercentage / 100) * (100 / count($this->steps));
+        $totalPercentage = $completedStepsPercentage + $currentStepContribution;
+
+        $step = $this->steps[$this->currentStepIndex];
+        $fullMessage = sprintf(
+            'Step %d of %d (%s): %s',
+            $this->currentStepIndex + 1,
+            count($this->steps),
+            $step['name'],
+            $message
+        );
+
+        $fullMetadata = array_merge($metadata ?? [], [
+            'current_step' => $this->currentStepIndex + 1,
+            'total_steps' => count($this->steps),
+            'step_name' => $step['name'],
+            'step_percentage' => $stepPercentage,
+            'completed_steps' => $this->completedSteps
+        ]);
+
+        $this->progressManager->updateJobProgress(
+            $this->jobId,
+            $totalPercentage,
+            $fullMessage,
+            $fullMetadata
+        );
+    }
+
+    public function complete(string $message = 'All steps completed successfully'): void
+    {
+        // Complete any remaining steps if not all were explicitly completed
+        while ($this->currentStepIndex < count($this->steps)) {
+            $this->completeCurrentStep();
+        }
+
+        $this->progressManager->completeJob($this->jobId, $message);
+    }
+
+    public function fail(string $message, ?\Throwable $exception = null): void
+    {
+        $step = $this->getCurrentStep();
+        $fullMessage = sprintf(
+            'Failed on step %d of %d (%s): %s',
+            $this->currentStepIndex + 1,
+            count($this->steps),
+            $step['name'] ?? 'unknown',
+            $message
+        );
+
+        $this->progressManager->failJob($this->jobId, $fullMessage, $exception);
+    }
+
+    public function getCurrentStep(): ?array
+    {
+        if ($this->currentStepIndex >= count($this->steps)) {
+            return null;
+        }
+
+        return $this->steps[$this->currentStepIndex];
+    }
+
+    public function getRemainingSteps(): array
+    {
+        return array_slice($this->steps, $this->currentStepIndex);
+    }
+
+    public function getCompletedSteps(): array
+    {
+        return $this->completedSteps;
+    }
+
+    public function isComplete(): bool
+    {
+        return $this->currentStepIndex >= count($this->steps);
+    }
+
+    public function getProgress(): float
+    {
+        return ($this->currentStepIndex / count($this->steps)) * 100;
+    }
+}

src/Framework/Queue/Services/WorkerHealthCheckService.php

@@ -0,0 +1,408 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Entities\Worker;
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Core\ValueObjects\Percentage;
+use App\Framework\Core\ValueObjects\Byte;
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+
+/**
+ * Worker Health Check Service für Monitoring und Überwachung
+ */
+final readonly class WorkerHealthCheckService
+{
+    private const HEALTH_CHECK_INTERVAL_SECONDS = 60;
+    private const CRITICAL_CPU_THRESHOLD = 90;
+    private const WARNING_CPU_THRESHOLD = 75;
+    private const CRITICAL_MEMORY_THRESHOLD_GB = 2.0;
+    private const WARNING_MEMORY_THRESHOLD_GB = 1.5;
+    private const HEARTBEAT_TIMEOUT_SECONDS = 120;
+
+    public function __construct(
+        private WorkerRegistry $workerRegistry,
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Health Check für alle aktiven Worker durchführen
+     */
+    public function performHealthCheck(): array
+    {
+        $this->logger->info('Starting worker health check');
+
+        $workers = $this->workerRegistry->findActiveWorkers();
+        $healthResults = [];
+
+        foreach ($workers as $worker) {
+            $health = $this->checkWorkerHealth($worker);
+            $healthResults[] = $health;
+
+            // Health Status in Datenbank speichern
+            $this->recordHealthStatus($worker->id, $health);
+
+            // Bei kritischen Problemen Worker deaktivieren
+            if ($health['status'] === 'critical') {
+                $this->handleCriticalWorker($worker, $health);
+            }
+        }
+
+        // Cleanup inaktiver Worker
+        $this->workerRegistry->cleanupInactiveWorkers(2); // 2 Minuten ohne Heartbeat
+
+        $overallHealth = $this->calculateOverallHealth($healthResults);
+
+        $this->logger->info('Worker health check completed', LogContext::withData([
+            'total_workers' => count($workers),
+            'healthy_workers' => count(array_filter($healthResults, fn($h) => $h['status'] === 'healthy')),
+            'warning_workers' => count(array_filter($healthResults, fn($h) => $h['status'] === 'warning')),
+            'critical_workers' => count(array_filter($healthResults, fn($h) => $h['status'] === 'critical')),
+            'overall_status' => $overallHealth['status']
+        ]));
+
+        return [
+            'workers' => $healthResults,
+            'overall' => $overallHealth,
+            'checked_at' => date('Y-m-d H:i:s')
+        ];
+    }
+
+    /**
+     * Health Check für einzelnen Worker
+     */
+    public function checkWorkerHealth(Worker $worker): array
+    {
+        $issues = [];
+        $warnings = [];
+        $score = 100;
+
+        // Heartbeat prüfen
+        $heartbeatAge = $worker->lastHeartbeat
+            ? time() - $worker->lastHeartbeat->getTimestamp()
+            : PHP_INT_MAX;
+
+        if ($heartbeatAge > self::HEARTBEAT_TIMEOUT_SECONDS) {
+            $issues[] = "No heartbeat for {$heartbeatAge} seconds";
+            $score -= 50;
+        } elseif ($heartbeatAge > self::HEARTBEAT_TIMEOUT_SECONDS / 2) {
+            $warnings[] = "Heartbeat delayed ({$heartbeatAge}s)";
+            $score -= 20;
+        }
+
+        // CPU Usage prüfen
+        $cpuUsage = $worker->cpuUsage->getValue();
+        if ($cpuUsage > self::CRITICAL_CPU_THRESHOLD) {
+            $issues[] = "Critical CPU usage: {$cpuUsage}%";
+            $score -= 30;
+        } elseif ($cpuUsage > self::WARNING_CPU_THRESHOLD) {
+            $warnings[] = "High CPU usage: {$cpuUsage}%";
+            $score -= 15;
+        }
+
+        // Memory Usage prüfen
+        $memoryGB = $worker->memoryUsage->toBytes() / (1024 * 1024 * 1024);
+        if ($memoryGB > self::CRITICAL_MEMORY_THRESHOLD_GB) {
+            $issues[] = sprintf("Critical memory usage: %.2fGB", $memoryGB);
+            $score -= 30;
+        } elseif ($memoryGB > self::WARNING_MEMORY_THRESHOLD_GB) {
+            $warnings[] = sprintf("High memory usage: %.2fGB", $memoryGB);
+            $score -= 15;
+        }
+
+        // Job Load prüfen
+        $loadPercentage = $worker->getLoadPercentage()->getValue();
+        if ($loadPercentage > 95) {
+            $issues[] = "Worker overloaded: {$loadPercentage}%";
+            $score -= 25;
+        } elseif ($loadPercentage > 80) {
+            $warnings[] = "High worker load: {$loadPercentage}%";
+            $score -= 10;
+        }
+
+        // Aktiv-Status prüfen
+        if (!$worker->isActive) {
+            $issues[] = "Worker marked as inactive";
+            $score -= 100;
+        }
+
+        // Status basierend auf Score bestimmen
+        $status = match (true) {
+            $score <= 30 || !empty($issues) => 'critical',
+            $score <= 60 || !empty($warnings) => 'warning',
+            default => 'healthy'
+        };
+
+        return [
+            'worker_id' => $worker->id->toString(),
+            'hostname' => $worker->hostname,
+            'process_id' => $worker->processId,
+            'status' => $status,
+            'score' => max(0, $score),
+            'metrics' => [
+                'heartbeat_age_seconds' => $heartbeatAge < PHP_INT_MAX ? $heartbeatAge : null,
+                'cpu_usage_percent' => $cpuUsage,
+                'memory_usage_gb' => round($memoryGB, 3),
+                'job_load_percent' => $loadPercentage,
+                'current_jobs' => $worker->currentJobs,
+                'max_jobs' => $worker->maxJobs,
+                'is_active' => $worker->isActive
+            ],
+            'issues' => $issues,
+            'warnings' => $warnings,
+            'checked_at' => date('Y-m-d H:i:s')
+        ];
+    }
+
+    /**
+     * Health Status in Datenbank speichern
+     */
+    private function recordHealthStatus(WorkerId $workerId, array $healthData): void
+    {
+        try {
+            $sql = "INSERT INTO worker_health_checks (
+                        worker_id, status, score, metrics, issues, warnings, checked_at
+                    ) VALUES (
+                        :worker_id, :status, :score, :metrics, :issues, :warnings, NOW()
+                    )";
+
+            $this->connection->execute(SqlQuery::create($sql, [
+                'worker_id' => $workerId->toString(),
+                'status' => $healthData['status'],
+                'score' => $healthData['score'],
+                'metrics' => json_encode($healthData['metrics']),
+                'issues' => json_encode($healthData['issues']),
+                'warnings' => json_encode($healthData['warnings'])
+            ]));
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to record worker health status', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+        }
+    }
+
+    /**
+     * Kritischen Worker behandeln
+     */
+    private function handleCriticalWorker(Worker $worker, array $healthData): void
+    {
+        $this->logger->error('Critical worker detected', LogContext::withData([
+            'worker_id' => $worker->id->toString(),
+            'hostname' => $worker->hostname,
+            'issues' => $healthData['issues'],
+            'score' => $healthData['score']
+        ]));
+
+        // Worker als inaktiv markieren wenn zu viele kritische Issues
+        $criticalIssueCount = count($healthData['issues']);
+        if ($criticalIssueCount >= 2) {
+            try {
+                $this->workerRegistry->deregister($worker->id);
+
+                $this->logger->warning('Worker deregistered due to critical issues', LogContext::withData([
+                    'worker_id' => $worker->id->toString(),
+                    'hostname' => $worker->hostname,
+                    'critical_issues' => $criticalIssueCount
+                ]));
+
+            } catch (\Exception $e) {
+                $this->logger->error('Failed to deregister critical worker', LogContext::withData([
+                    'worker_id' => $worker->id->toString(),
+                    'error' => $e->getMessage()
+                ]));
+            }
+        }
+    }
+
+    /**
+     * Overall Health für alle Worker berechnen
+     */
+    private function calculateOverallHealth(array $healthResults): array
+    {
+        if (empty($healthResults)) {
+            return [
+                'status' => 'critical',
+                'score' => 0,
+                'worker_count' => 0,
+                'issues' => ['No workers available']
+            ];
+        }
+
+        $totalWorkers = count($healthResults);
+        $healthyWorkers = count(array_filter($healthResults, fn($h) => $h['status'] === 'healthy'));
+        $warningWorkers = count(array_filter($healthResults, fn($h) => $h['status'] === 'warning'));
+        $criticalWorkers = count(array_filter($healthResults, fn($h) => $h['status'] === 'critical'));
+
+        // Durchschnittlicher Score
+        $avgScore = array_sum(array_column($healthResults, 'score')) / $totalWorkers;
+
+        // Percentage der gesunden Worker
+        $healthyPercentage = ($healthyWorkers / $totalWorkers) * 100;
+
+        // Overall Status bestimmen
+        $status = match (true) {
+            $healthyPercentage < 50 || $criticalWorkers > $totalWorkers / 2 => 'critical',
+            $healthyPercentage < 80 || $warningWorkers > 0 => 'warning',
+            default => 'healthy'
+        };
+
+        $overallIssues = [];
+        if ($criticalWorkers > 0) {
+            $overallIssues[] = "{$criticalWorkers} workers in critical state";
+        }
+        if ($warningWorkers > 0) {
+            $overallIssues[] = "{$warningWorkers} workers with warnings";
+        }
+        if ($healthyPercentage < 70) {
+            $overallIssues[] = "Only {$healthyPercentage}% of workers are healthy";
+        }
+
+        return [
+            'status' => $status,
+            'score' => round($avgScore, 1),
+            'worker_count' => $totalWorkers,
+            'healthy_workers' => $healthyWorkers,
+            'warning_workers' => $warningWorkers,
+            'critical_workers' => $criticalWorkers,
+            'healthy_percentage' => round($healthyPercentage, 1),
+            'issues' => $overallIssues
+        ];
+    }
+
+    /**
+     * Worker Health History abrufen
+     */
+    public function getWorkerHealthHistory(WorkerId $workerId, ?Duration $period = null): array
+    {
+        $period = $period ?? Duration::fromDays(1);
+
+        try {
+            $sql = "SELECT * FROM worker_health_checks
+                   WHERE worker_id = :worker_id
+                   AND checked_at >= DATE_SUB(NOW(), INTERVAL :hours HOUR)
+                   ORDER BY checked_at DESC
+                   LIMIT 100";
+
+            $result = $this->connection->query(SqlQuery::create($sql, [
+                'worker_id' => $workerId->toString(),
+                'hours' => $period->toHours()
+            ]));
+
+            $history = [];
+            foreach ($result->fetchAll() as $row) {
+                $history[] = [
+                    'status' => $row['status'],
+                    'score' => (int) $row['score'],
+                    'metrics' => json_decode($row['metrics'], true),
+                    'issues' => json_decode($row['issues'], true),
+                    'warnings' => json_decode($row['warnings'], true),
+                    'checked_at' => $row['checked_at']
+                ];
+            }
+
+            return $history;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to get worker health history', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * System Health Report generieren
+     */
+    public function generateSystemHealthReport(): array
+    {
+        try {
+            // Aktuelle Health Checks
+            $currentHealth = $this->performHealthCheck();
+
+            // Health Trends (letzte 24 Stunden)
+            $sql = "SELECT
+                       DATE(checked_at) as check_date,
+                       HOUR(checked_at) as check_hour,
+                       AVG(score) as avg_score,
+                       COUNT(*) as total_checks,
+                       SUM(CASE WHEN status = 'healthy' THEN 1 ELSE 0 END) as healthy_count,
+                       SUM(CASE WHEN status = 'warning' THEN 1 ELSE 0 END) as warning_count,
+                       SUM(CASE WHEN status = 'critical' THEN 1 ELSE 0 END) as critical_count
+                   FROM worker_health_checks
+                   WHERE checked_at >= DATE_SUB(NOW(), INTERVAL 24 HOUR)
+                   GROUP BY DATE(checked_at), HOUR(checked_at)
+                   ORDER BY check_date DESC, check_hour DESC
+                   LIMIT 24";
+
+            $result = $this->connection->query(SqlQuery::create($sql));
+            $trends = $result->fetchAll();
+
+            // Top Issues der letzten 24 Stunden
+            $issuesSql = "SELECT
+                             JSON_UNQUOTE(JSON_EXTRACT(issues, '$[*]')) as issue_list,
+                             COUNT(*) as occurrence_count
+                         FROM worker_health_checks
+                         WHERE checked_at >= DATE_SUB(NOW(), INTERVAL 24 HOUR)
+                         AND JSON_LENGTH(issues) > 0
+                         GROUP BY JSON_EXTRACT(issues, '$[*]')
+                         ORDER BY occurrence_count DESC
+                         LIMIT 10";
+
+            $result = $this->connection->query(SqlQuery::create($issuesSql));
+            $topIssues = $result->fetchAll();
+
+            return [
+                'current_health' => $currentHealth,
+                'trends_24h' => $trends,
+                'top_issues_24h' => $topIssues,
+                'generated_at' => date('Y-m-d H:i:s')
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to generate system health report', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Health Check Cleanup (alte Einträge löschen)
+     */
+    public function cleanupHealthChecks(?Duration $retentionPeriod = null): int
+    {
+        $retentionPeriod = $retentionPeriod ?? Duration::fromDays(30);
+
+        try {
+            $sql = "DELETE FROM worker_health_checks
+                   WHERE checked_at < DATE_SUB(NOW(), INTERVAL :hours HOUR)";
+
+            $deletedCount = $this->connection->execute(SqlQuery::create($sql, [
+                'hours' => $retentionPeriod->toHours()
+            ]));
+
+            $this->logger->info('Health check cleanup completed', LogContext::withData([
+                'deleted_records' => $deletedCount,
+                'retention_days' => $retentionPeriod->toHours() / 24
+            ]));
+
+            return $deletedCount;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to cleanup health checks', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+}

src/Framework/Queue/Services/WorkerRegistry.php

@@ -0,0 +1,384 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\Services;
+
+use App\Framework\Queue\Entities\Worker;
+use App\Framework\Queue\ValueObjects\WorkerId;
+use App\Framework\Queue\ValueObjects\QueueName;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ValueObjects\SqlQuery;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\ValueObjects\LogContext;
+use App\Framework\Core\ValueObjects\Percentage;
+use App\Framework\Core\ValueObjects\Byte;
+
+/**
+ * Worker Registry für Distributed Job Processing
+ */
+final readonly class WorkerRegistry
+{
+    private const TABLE_NAME = 'queue_workers';
+
+    public function __construct(
+        private ConnectionInterface $connection,
+        private Logger $logger
+    ) {}
+
+    /**
+     * Worker registrieren
+     */
+    public function register(Worker $worker): void
+    {
+        $this->logger->info('Registering worker', LogContext::withData([
+            'worker_id' => $worker->id->toString(),
+            'hostname' => $worker->hostname,
+            'process_id' => $worker->processId,
+            'queues' => $worker->queues,
+            'max_jobs' => $worker->maxJobs
+        ]));
+
+        try {
+            $sql = "INSERT INTO " . self::TABLE_NAME . " (
+                id, hostname, process_id, queues, max_jobs, current_jobs,
+                is_active, cpu_usage, memory_usage_bytes, registered_at,
+                last_heartbeat, capabilities, version
+            ) VALUES (
+                :id, :hostname, :process_id, :queues, :max_jobs, :current_jobs,
+                :is_active, :cpu_usage, :memory_usage_bytes, :registered_at,
+                :last_heartbeat, :capabilities, :version
+            ) ON DUPLICATE KEY UPDATE
+                is_active = VALUES(is_active),
+                last_heartbeat = VALUES(last_heartbeat),
+                cpu_usage = VALUES(cpu_usage),
+                memory_usage_bytes = VALUES(memory_usage_bytes),
+                current_jobs = VALUES(current_jobs),
+                capabilities = VALUES(capabilities),
+                version = VALUES(version)";
+
+            $data = $worker->toArray();
+            $data['is_active'] = $data['is_active'] ? 1 : 0;
+
+            $this->connection->execute(SqlQuery::create($sql, $data));
+
+            $this->logger->debug('Worker registered successfully', LogContext::withData([
+                'worker_id' => $worker->id->toString()
+            ]));
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to register worker', LogContext::withData([
+                'worker_id' => $worker->id->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Worker deregistrieren
+     */
+    public function deregister(WorkerId $workerId): void
+    {
+        $this->logger->info('Deregistering worker', LogContext::withData([
+            'worker_id' => $workerId->toString()
+        ]));
+
+        try {
+            $sql = "UPDATE " . self::TABLE_NAME . "
+                   SET is_active = 0, last_heartbeat = NOW()
+                   WHERE id = :id";
+
+            $this->connection->execute(SqlQuery::create($sql, ['id' => $workerId->toString()]));
+
+            $this->logger->debug('Worker deregistered successfully', LogContext::withData([
+                'worker_id' => $workerId->toString()
+            ]));
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to deregister worker', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Worker Heartbeat aktualisieren
+     */
+    public function updateHeartbeat(
+        WorkerId $workerId,
+        Percentage $cpuUsage,
+        Byte $memoryUsage,
+        int $currentJobs
+    ): void {
+        try {
+            $sql = "UPDATE " . self::TABLE_NAME . "
+                   SET last_heartbeat = NOW(),
+                       cpu_usage = :cpu_usage,
+                       memory_usage_bytes = :memory_usage_bytes,
+                       current_jobs = :current_jobs,
+                       is_active = 1
+                   WHERE id = :id";
+
+            $affectedRows = $this->connection->execute(SqlQuery::create($sql, [
+                'id' => $workerId->toString(),
+                'cpu_usage' => $cpuUsage->getValue(),
+                'memory_usage_bytes' => $memoryUsage->toBytes(),
+                'current_jobs' => $currentJobs
+            ]));
+
+            if ($affectedRows === 0) {
+                $this->logger->warning('Heartbeat update failed - worker not found', LogContext::withData([
+                    'worker_id' => $workerId->toString()
+                ]));
+            }
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to update worker heartbeat', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Worker by ID finden
+     */
+    public function findById(WorkerId $workerId): ?Worker
+    {
+        try {
+            $sql = "SELECT * FROM " . self::TABLE_NAME . " WHERE id = :id";
+            $data = $this->connection->queryOne(SqlQuery::create($sql, ['id' => $workerId->toString()]));
+            if (!$data) {
+                return null;
+            }
+
+            return Worker::fromArray($data);
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to find worker by ID', LogContext::withData([
+                'worker_id' => $workerId->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Alle aktiven Worker finden
+     */
+    public function findActiveWorkers(): array
+    {
+        try {
+            $sql = "SELECT * FROM " . self::TABLE_NAME . "
+                   WHERE is_active = 1
+                   AND last_heartbeat > DATE_SUB(NOW(), INTERVAL 2 MINUTE)
+                   ORDER BY hostname, process_id";
+
+            $result = $this->connection->query(SqlQuery::create($sql));
+            $workers = [];
+            foreach ($result->fetchAll() as $data) {
+                $workers[] = Worker::fromArray($data);
+            }
+
+            return $workers;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to find active workers', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Worker für bestimmte Queue finden
+     */
+    public function findWorkersForQueue(QueueName $queueName): array
+    {
+        try {
+            $sql = "SELECT * FROM " . self::TABLE_NAME . "
+                   WHERE is_active = 1
+                   AND last_heartbeat > DATE_SUB(NOW(), INTERVAL 2 MINUTE)
+                   AND JSON_CONTAINS(queues, JSON_QUOTE(:queue_name))
+                   ORDER BY current_jobs ASC, cpu_usage ASC";
+
+            $result = $this->connection->query(SqlQuery::create($sql, ['queue_name' => $queueName->toString()]));
+            $workers = [];
+            foreach ($result->fetchAll() as $data) {
+                $worker = Worker::fromArray($data);
+                if ($worker->handlesQueue($queueName) && $worker->isAvailableForJobs()) {
+                    $workers[] = $worker;
+                }
+            }
+
+            return $workers;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to find workers for queue', LogContext::withData([
+                'queue_name' => $queueName->toString(),
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Beste verfügbare Worker für Queue finden
+     */
+    public function findBestWorkerForQueue(QueueName $queueName): ?Worker
+    {
+        $workers = $this->findWorkersForQueue($queueName);
+
+        if (empty($workers)) {
+            return null;
+        }
+
+        // Sortiere nach Load (niedrigste zuerst)
+        usort($workers, function (Worker $a, Worker $b) {
+            return $a->getLoadPercentage()->getValue() <=> $b->getLoadPercentage()->getValue();
+        });
+
+        return $workers[0];
+    }
+
+    /**
+     * Inaktive Worker cleanup
+     */
+    public function cleanupInactiveWorkers(int $inactiveMinutes = 5): int
+    {
+        $this->logger->info('Starting cleanup of inactive workers', LogContext::withData([
+            'inactive_minutes' => $inactiveMinutes
+        ]));
+
+        try {
+            $sql = "UPDATE " . self::TABLE_NAME . "
+                   SET is_active = 0
+                   WHERE is_active = 1
+                   AND (last_heartbeat IS NULL OR last_heartbeat < DATE_SUB(NOW(), INTERVAL :minutes MINUTE))";
+
+            $count = $this->connection->execute(SqlQuery::create($sql, ['minutes' => $inactiveMinutes]));
+
+            $this->logger->info('Inactive workers cleanup completed', LogContext::withData([
+                'deactivated_count' => $count,
+                'inactive_minutes' => $inactiveMinutes
+            ]));
+
+            return $count;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to cleanup inactive workers', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Worker Statistiken
+     */
+    public function getWorkerStatistics(): array
+    {
+        try {
+            $sql = "SELECT
+                       COUNT(*) as total_workers,
+                       SUM(CASE WHEN is_active = 1 THEN 1 ELSE 0 END) as active_workers,
+                       SUM(CASE WHEN is_active = 1 AND last_heartbeat > DATE_SUB(NOW(), INTERVAL 2 MINUTE) THEN 1 ELSE 0 END) as healthy_workers,
+                       SUM(max_jobs) as total_capacity,
+                       SUM(current_jobs) as current_load,
+                       AVG(cpu_usage) as avg_cpu_usage,
+                       AVG(memory_usage_bytes) as avg_memory_usage,
+                       COUNT(DISTINCT hostname) as unique_hosts
+                   FROM " . self::TABLE_NAME;
+
+            $stats = $this->connection->queryOne(SqlQuery::create($sql));
+
+            // Queue-spezifische Statistiken
+            $queueStats = $this->getQueueStatistics();
+
+            return [
+                'total_workers' => (int) $stats['total_workers'],
+                'active_workers' => (int) $stats['active_workers'],
+                'healthy_workers' => (int) $stats['healthy_workers'],
+                'unique_hosts' => (int) $stats['unique_hosts'],
+                'total_capacity' => (int) $stats['total_capacity'],
+                'current_load' => (int) $stats['current_load'],
+                'capacity_utilization' => $stats['total_capacity'] > 0
+                    ? round(($stats['current_load'] / $stats['total_capacity']) * 100, 2)
+                    : 0,
+                'avg_cpu_usage' => round((float) $stats['avg_cpu_usage'], 2),
+                'avg_memory_usage_mb' => round(((float) $stats['avg_memory_usage']) / 1024 / 1024, 2),
+                'queue_distribution' => $queueStats
+            ];
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to get worker statistics', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+
+    /**
+     * Queue-spezifische Statistiken
+     */
+    private function getQueueStatistics(): array
+    {
+        try {
+            $sql = "SELECT queues FROM " . self::TABLE_NAME . " WHERE is_active = 1";
+            $result = $this->connection->query(SqlQuery::create($sql));
+
+            $queueCounts = [];
+            foreach ($result->fetchAll() as $row) {
+                $queues = json_decode($row['queues'], true);
+                foreach ($queues as $queue) {
+                    $queueCounts[$queue] = ($queueCounts[$queue] ?? 0) + 1;
+                }
+            }
+
+            arsort($queueCounts);
+            return $queueCounts;
+
+        } catch (\Exception $e) {
+            $this->logger->warning('Failed to get queue statistics', LogContext::withData([
+                'error' => $e->getMessage()
+            ]));
+            return [];
+        }
+    }
+
+    /**
+     * Worker mit bestimmter Capability finden
+     */
+    public function findWorkersWithCapability(string $capability): array
+    {
+        try {
+            $sql = "SELECT * FROM " . self::TABLE_NAME . "
+                   WHERE is_active = 1
+                   AND last_heartbeat > DATE_SUB(NOW(), INTERVAL 2 MINUTE)
+                   AND JSON_CONTAINS(capabilities, JSON_QUOTE(:capability))
+                   ORDER BY current_jobs ASC";
+
+            $result = $this->connection->query(SqlQuery::create($sql, ['capability' => $capability]));
+            $workers = [];
+            foreach ($result->fetchAll() as $data) {
+                $worker = Worker::fromArray($data);
+                if ($worker->hasCapability($capability) && $worker->isAvailableForJobs()) {
+                    $workers[] = $worker;
+                }
+            }
+
+            return $workers;
+
+        } catch (\Exception $e) {
+            $this->logger->error('Failed to find workers with capability', LogContext::withData([
+                'capability' => $capability,
+                'error' => $e->getMessage()
+            ]));
+            throw $e;
+        }
+    }
+}

src/Framework/Queue/ValueObjects/ChainExecutionMode.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Enum representing different execution modes for job chains
+ */
+enum ChainExecutionMode: string
+{
+    case SEQUENTIAL = 'sequential';
+    case PARALLEL = 'parallel';
+    case CONDITIONAL = 'conditional';
+
+    public function getDescription(): string
+    {
+        return match ($this) {
+            self::SEQUENTIAL => 'Jobs execute one after another in order',
+            self::PARALLEL => 'All jobs execute simultaneously',
+            self::CONDITIONAL => 'Job execution depends on conditions and dependencies'
+        };
+    }
+
+    public function allowsParallelExecution(): bool
+    {
+        return $this === self::PARALLEL;
+    }
+
+    public function requiresStrictOrder(): bool
+    {
+        return $this === self::SEQUENTIAL;
+    }
+
+    public function supportsConditionalLogic(): bool
+    {
+        return $this === self::CONDITIONAL;
+    }
+}

src/Framework/Queue/ValueObjects/DeadLetterQueueName.php

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Queue\Exceptions\InvalidDeadLetterQueueNameException;
+
+/**
+ * Value Object representing a Dead Letter Queue name
+ */
+final readonly class DeadLetterQueueName
+{
+    private const MAX_LENGTH = 100;
+    private const MIN_LENGTH = 1;
+    private const VALID_PATTERN = '/^[a-zA-Z0-9_\-\.]+$/';
+
+    public function __construct(
+        private string $name
+    ) {
+        $this->validate();
+    }
+
+    public static function fromString(string $name): self
+    {
+        return new self($name);
+    }
+
+    public static function default(): self
+    {
+        return new self('failed');
+    }
+
+    public static function forQueue(QueueName $queueName): self
+    {
+        return new self($queueName->toString() . '_failed');
+    }
+
+    public function toString(): string
+    {
+        return $this->name;
+    }
+
+    public function equals(self $other): bool
+    {
+        return $this->name === $other->name;
+    }
+
+    private function validate(): void
+    {
+        if (strlen($this->name) < self::MIN_LENGTH) {
+            throw InvalidDeadLetterQueueNameException::tooShort($this->name, self::MIN_LENGTH);
+        }
+
+        if (strlen($this->name) > self::MAX_LENGTH) {
+            throw InvalidDeadLetterQueueNameException::tooLong($this->name, self::MAX_LENGTH);
+        }
+
+        if (!preg_match(self::VALID_PATTERN, $this->name)) {
+            throw InvalidDeadLetterQueueNameException::invalidFormat($this->name, self::VALID_PATTERN);
+        }
+    }
+
+    public function __toString(): string
+    {
+        return $this->name;
+    }
+}

src/Framework/Queue/ValueObjects/DependencyType.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Enum representing different types of job dependencies
+ */
+enum DependencyType: string
+{
+    case COMPLETION = 'completion';
+    case SUCCESS = 'success';
+    case CONDITIONAL = 'conditional';
+
+    public function getDescription(): string
+    {
+        return match ($this) {
+            self::COMPLETION => 'Job must complete (regardless of success/failure)',
+            self::SUCCESS => 'Job must complete successfully',
+            self::CONDITIONAL => 'Job dependency based on custom condition'
+        };
+    }
+
+    public function requiresSuccessfulCompletion(): bool
+    {
+        return $this === self::SUCCESS;
+    }
+
+    public function allowsFailure(): bool
+    {
+        return $this === self::COMPLETION;
+    }
+
+    public function isConditional(): bool
+    {
+        return $this === self::CONDITIONAL;
+    }
+}

src/Framework/Queue/ValueObjects/FailureReason.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Value Object representing why a job failed
+ */
+final readonly class FailureReason
+{
+    private const MAX_MESSAGE_LENGTH = 1000;
+    private const MAX_EXCEPTION_TYPE_LENGTH = 255;
+
+    public function __construct(
+        private string $message,
+        private ?string $exceptionType = null,
+        private ?string $stackTrace = null
+    ) {
+        $this->validate();
+    }
+
+    public static function fromException(\Throwable $exception): self
+    {
+        return new self(
+            message: substr($exception->getMessage(), 0, self::MAX_MESSAGE_LENGTH),
+            exceptionType: substr(get_class($exception), 0, self::MAX_EXCEPTION_TYPE_LENGTH),
+            stackTrace: $exception->getTraceAsString()
+        );
+    }
+
+    public static function fromMessage(string $message): self
+    {
+        return new self(
+            message: substr($message, 0, self::MAX_MESSAGE_LENGTH)
+        );
+    }
+
+    public function getMessage(): string
+    {
+        return $this->message;
+    }
+
+    public function getExceptionType(): ?string
+    {
+        return $this->exceptionType;
+    }
+
+    public function getStackTrace(): ?string
+    {
+        return $this->stackTrace;
+    }
+
+    public function hasStackTrace(): bool
+    {
+        return $this->stackTrace !== null;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'message' => $this->message,
+            'exception_type' => $this->exceptionType,
+            'has_stack_trace' => $this->hasStackTrace()
+        ];
+    }
+
+    private function validate(): void
+    {
+        if (empty(trim($this->message))) {
+            throw new \InvalidArgumentException('Failure reason message cannot be empty');
+        }
+    }
+}

src/Framework/Queue/ValueObjects/JobBatch.php

@@ -0,0 +1,194 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Core\ValueObjects\Timestamp;
+
+/**
+ * Value Object representing a batch of jobs for bulk processing
+ */
+final readonly class JobBatch
+{
+    public function __construct(
+        public string $batchId,
+        public string $name,
+        public array $jobIds,
+        public JobBatchStatus $status,
+        public int $totalJobs,
+        public int $processedJobs,
+        public int $failedJobs,
+        public ?Timestamp $createdAt = null,
+        public ?Timestamp $startedAt = null,
+        public ?Timestamp $completedAt = null,
+        public ?Timestamp $failedAt = null,
+        public array $options = []
+    ) {
+        $this->validate();
+    }
+
+    public static function create(
+        string $batchId,
+        string $name,
+        array $jobIds,
+        array $options = []
+    ): self {
+        return new self(
+            batchId: $batchId,
+            name: $name,
+            jobIds: $jobIds,
+            status: JobBatchStatus::PENDING,
+            totalJobs: count($jobIds),
+            processedJobs: 0,
+            failedJobs: 0,
+            createdAt: Timestamp::now(),
+            options: $options
+        );
+    }
+
+    public function start(): self
+    {
+        return new self(
+            batchId: $this->batchId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            status: JobBatchStatus::PROCESSING,
+            totalJobs: $this->totalJobs,
+            processedJobs: $this->processedJobs,
+            failedJobs: $this->failedJobs,
+            createdAt: $this->createdAt,
+            startedAt: Timestamp::now(),
+            completedAt: $this->completedAt,
+            failedAt: $this->failedAt,
+            options: $this->options
+        );
+    }
+
+    public function incrementProcessed(): self
+    {
+        $newProcessed = $this->processedJobs + 1;
+        $newStatus = $this->determineStatus($newProcessed, $this->failedJobs);
+
+        return new self(
+            batchId: $this->batchId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            status: $newStatus,
+            totalJobs: $this->totalJobs,
+            processedJobs: $newProcessed,
+            failedJobs: $this->failedJobs,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: $newStatus === JobBatchStatus::COMPLETED ? Timestamp::now() : $this->completedAt,
+            failedAt: $this->failedAt,
+            options: $this->options
+        );
+    }
+
+    public function incrementFailed(): self
+    {
+        $newFailed = $this->failedJobs + 1;
+        $newStatus = $this->determineStatus($this->processedJobs, $newFailed);
+
+        return new self(
+            batchId: $this->batchId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            status: $newStatus,
+            totalJobs: $this->totalJobs,
+            processedJobs: $this->processedJobs,
+            failedJobs: $newFailed,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            failedAt: $newStatus === JobBatchStatus::FAILED ? Timestamp::now() : $this->failedAt,
+            options: $this->options
+        );
+    }
+
+    public function getProgressPercentage(): float
+    {
+        if ($this->totalJobs === 0) {
+            return 100.0;
+        }
+
+        return round(($this->processedJobs / $this->totalJobs) * 100, 2);
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->status === JobBatchStatus::COMPLETED;
+    }
+
+    public function isFailed(): bool
+    {
+        return $this->status === JobBatchStatus::FAILED;
+    }
+
+    public function isFinished(): bool
+    {
+        return $this->isCompleted() || $this->isFailed();
+    }
+
+    public function getRemainingJobs(): int
+    {
+        return $this->totalJobs - $this->processedJobs - $this->failedJobs;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'batch_id' => $this->batchId,
+            'name' => $this->name,
+            'job_ids' => $this->jobIds,
+            'status' => $this->status->value,
+            'total_jobs' => $this->totalJobs,
+            'processed_jobs' => $this->processedJobs,
+            'failed_jobs' => $this->failedJobs,
+            'created_at' => $this->createdAt?->toRfc3339(),
+            'started_at' => $this->startedAt?->toRfc3339(),
+            'completed_at' => $this->completedAt?->toRfc3339(),
+            'failed_at' => $this->failedAt?->toRfc3339(),
+            'options' => $this->options
+        ];
+    }
+
+    private function determineStatus(int $processed, int $failed): JobBatchStatus
+    {
+        $completed = $processed + $failed;
+
+        if ($completed === $this->totalJobs) {
+            return $failed > 0 ? JobBatchStatus::FAILED : JobBatchStatus::COMPLETED;
+        }
+
+        return $this->status === JobBatchStatus::PENDING ? JobBatchStatus::PENDING : JobBatchStatus::PROCESSING;
+    }
+
+    private function validate(): void
+    {
+        if (empty($this->batchId)) {
+            throw new \InvalidArgumentException('Batch ID cannot be empty');
+        }
+
+        if (empty($this->name)) {
+            throw new \InvalidArgumentException('Batch name cannot be empty');
+        }
+
+        if ($this->totalJobs < 0) {
+            throw new \InvalidArgumentException('Total jobs cannot be negative');
+        }
+
+        if ($this->processedJobs < 0) {
+            throw new \InvalidArgumentException('Processed jobs cannot be negative');
+        }
+
+        if ($this->failedJobs < 0) {
+            throw new \InvalidArgumentException('Failed jobs cannot be negative');
+        }
+
+        if ($this->processedJobs + $this->failedJobs > $this->totalJobs) {
+            throw new \InvalidArgumentException('Processed + failed jobs cannot exceed total jobs');
+        }
+    }
+}

src/Framework/Queue/ValueObjects/JobBatchStatus.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Enum representing the status of a job batch
+ */
+enum JobBatchStatus: string
+{
+    case PENDING = 'pending';
+    case PROCESSING = 'processing';
+    case COMPLETED = 'completed';
+    case FAILED = 'failed';
+    case CANCELLED = 'cancelled';
+
+    public function isFinished(): bool
+    {
+        return match ($this) {
+            self::COMPLETED, self::FAILED, self::CANCELLED => true,
+            default => false
+        };
+    }
+
+    public function isActive(): bool
+    {
+        return match ($this) {
+            self::PENDING, self::PROCESSING => true,
+            default => false
+        };
+    }
+
+    public function getDisplayName(): string
+    {
+        return match ($this) {
+            self::PENDING => 'Pending',
+            self::PROCESSING => 'Processing',
+            self::COMPLETED => 'Completed',
+            self::FAILED => 'Failed',
+            self::CANCELLED => 'Cancelled'
+        };
+    }
+
+    public function getIcon(): string
+    {
+        return match ($this) {
+            self::PENDING => '⏳',
+            self::PROCESSING => '🔄',
+            self::COMPLETED => '✅',
+            self::FAILED => '❌',
+            self::CANCELLED => '🚫'
+        };
+    }
+}

src/Framework/Queue/ValueObjects/JobChain.php

@@ -0,0 +1,165 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Value Object representing a chain of jobs with their execution order
+ */
+final readonly class JobChain
+{
+    /** @var string[] */
+    public array $jobIds;
+
+    public function __construct(
+        public string $chainId,
+        public string $name,
+        array $jobIds,
+        public ChainExecutionMode $executionMode = ChainExecutionMode::SEQUENTIAL,
+        public bool $stopOnFailure = true,
+        public ?array $metadata = null
+    ) {
+        $this->jobIds = array_values(array_unique($jobIds));
+        $this->validate();
+    }
+
+    public static function sequential(string $chainId, string $name, array $jobIds): self
+    {
+        return new self($chainId, $name, $jobIds, ChainExecutionMode::SEQUENTIAL);
+    }
+
+    public static function parallel(string $chainId, string $name, array $jobIds): self
+    {
+        return new self($chainId, $name, $jobIds, ChainExecutionMode::PARALLEL);
+    }
+
+    public static function conditional(string $chainId, string $name, array $jobIds): self
+    {
+        return new self($chainId, $name, $jobIds, ChainExecutionMode::CONDITIONAL);
+    }
+
+    public function isSequential(): bool
+    {
+        return $this->executionMode === ChainExecutionMode::SEQUENTIAL;
+    }
+
+    public function isParallel(): bool
+    {
+        return $this->executionMode === ChainExecutionMode::PARALLEL;
+    }
+
+    public function isConditional(): bool
+    {
+        return $this->executionMode === ChainExecutionMode::CONDITIONAL;
+    }
+
+    public function shouldStopOnFailure(): bool
+    {
+        return $this->stopOnFailure;
+    }
+
+    public function getJobCount(): int
+    {
+        return count($this->jobIds);
+    }
+
+    public function getFirstJob(): ?string
+    {
+        return $this->jobIds[0] ?? null;
+    }
+
+    public function getLastJob(): ?string
+    {
+        return end($this->jobIds) ?: null;
+    }
+
+    public function containsJob(string $jobId): bool
+    {
+        return in_array($jobId, $this->jobIds, true);
+    }
+
+    public function getJobPosition(string $jobId): ?int
+    {
+        $position = array_search($jobId, $this->jobIds, true);
+        return $position !== false ? $position : null;
+    }
+
+    public function getNextJob(string $currentJobId): ?string
+    {
+        $position = $this->getJobPosition($currentJobId);
+        if ($position === null) {
+            return null;
+        }
+
+        return $this->jobIds[$position + 1] ?? null;
+    }
+
+    public function getPreviousJob(string $currentJobId): ?string
+    {
+        $position = $this->getJobPosition($currentJobId);
+        if ($position === null || $position === 0) {
+            return null;
+        }
+
+        return $this->jobIds[$position - 1];
+    }
+
+    public function withMetadata(array $metadata): self
+    {
+        return new self(
+            chainId: $this->chainId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            executionMode: $this->executionMode,
+            stopOnFailure: $this->stopOnFailure,
+            metadata: array_merge($this->metadata ?? [], $metadata)
+        );
+    }
+
+    public function withStopOnFailure(bool $stopOnFailure): self
+    {
+        return new self(
+            chainId: $this->chainId,
+            name: $this->name,
+            jobIds: $this->jobIds,
+            executionMode: $this->executionMode,
+            stopOnFailure: $stopOnFailure,
+            metadata: $this->metadata
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'chain_id' => $this->chainId,
+            'name' => $this->name,
+            'job_ids' => $this->jobIds,
+            'execution_mode' => $this->executionMode->value,
+            'stop_on_failure' => $this->stopOnFailure,
+            'job_count' => $this->getJobCount(),
+            'metadata' => $this->metadata
+        ];
+    }
+
+    private function validate(): void
+    {
+        if (empty(trim($this->chainId))) {
+            throw new \InvalidArgumentException('Chain ID cannot be empty');
+        }
+
+        if (empty(trim($this->name))) {
+            throw new \InvalidArgumentException('Chain name cannot be empty');
+        }
+
+        if (empty($this->jobIds)) {
+            throw new \InvalidArgumentException('Job chain must contain at least one job');
+        }
+
+        foreach ($this->jobIds as $jobId) {
+            if (empty(trim($jobId))) {
+                throw new \InvalidArgumentException('Job ID cannot be empty');
+            }
+        }
+    }
+}

src/Framework/Queue/ValueObjects/JobDependency.php

@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Value Object representing a dependency relationship between jobs
+ */
+final readonly class JobDependency
+{
+    public function __construct(
+        public string $dependentJobId,
+        public string $dependsOnJobId,
+        public DependencyType $type = DependencyType::COMPLETION,
+        public ?string $condition = null
+    ) {
+        $this->validate();
+    }
+
+    public static function completion(string $dependentJobId, string $dependsOnJobId): self
+    {
+        return new self($dependentJobId, $dependsOnJobId, DependencyType::COMPLETION);
+    }
+
+    public static function success(string $dependentJobId, string $dependsOnJobId): self
+    {
+        return new self($dependentJobId, $dependsOnJobId, DependencyType::SUCCESS);
+    }
+
+    public static function conditional(string $dependentJobId, string $dependsOnJobId, string $condition): self
+    {
+        return new self($dependentJobId, $dependsOnJobId, DependencyType::CONDITIONAL, $condition);
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->type === DependencyType::COMPLETION;
+    }
+
+    public function requiresSuccess(): bool
+    {
+        return $this->type === DependencyType::SUCCESS;
+    }
+
+    public function isConditional(): bool
+    {
+        return $this->type === DependencyType::CONDITIONAL;
+    }
+
+    public function getCondition(): ?string
+    {
+        return $this->condition;
+    }
+
+    public function equals(self $other): bool
+    {
+        return $this->dependentJobId === $other->dependentJobId
+            && $this->dependsOnJobId === $other->dependsOnJobId
+            && $this->type === $other->type
+            && $this->condition === $other->condition;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'dependent_job_id' => $this->dependentJobId,
+            'depends_on_job_id' => $this->dependsOnJobId,
+            'type' => $this->type->value,
+            'condition' => $this->condition
+        ];
+    }
+
+    private function validate(): void
+    {
+        if (empty(trim($this->dependentJobId))) {
+            throw new \InvalidArgumentException('Dependent job ID cannot be empty');
+        }
+
+        if (empty(trim($this->dependsOnJobId))) {
+            throw new \InvalidArgumentException('Depends on job ID cannot be empty');
+        }
+
+        if ($this->dependentJobId === $this->dependsOnJobId) {
+            throw new \InvalidArgumentException('Job cannot depend on itself');
+        }
+
+        if ($this->type === DependencyType::CONDITIONAL && empty($this->condition)) {
+            throw new \InvalidArgumentException('Conditional dependency must have a condition');
+        }
+    }
+}

src/Framework/Queue/ValueObjects/JobId.php

@@ -0,0 +1,164 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Ulid\Ulid;
+
+/**
+ * Value Object representing a unique Job identifier
+ */
+final readonly class JobId
+{
+    private function __construct(
+        private string $value
+    ) {
+        if (empty($value)) {
+            throw new \InvalidArgumentException('JobId cannot be empty');
+        }
+
+        if (!$this->isValidFormat($value)) {
+            throw new \InvalidArgumentException('Invalid JobId format');
+        }
+    }
+
+    /**
+     * Create a new random JobId using ULID
+     */
+    public static function generate(): self
+    {
+        // Use simple uniqid for now to avoid dependency injection in Value Objects
+        return new self(uniqid('job_', true));
+    }
+
+    /**
+     * Create from existing string
+     */
+    public static function fromString(string $id): self
+    {
+        return new self($id);
+    }
+
+    /**
+     * Create from ULID object
+     */
+    public static function fromUlid(Ulid $ulid): self
+    {
+        return new self($ulid->toString());
+    }
+
+    /**
+     * Get string representation
+     */
+    public function toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * Get value (alias for toString)
+     */
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * Convert to ULID object
+     */
+    public function toUlid(): Ulid
+    {
+        return Ulid::fromString($this->value);
+    }
+
+    /**
+     * Check if two JobIds are equal
+     */
+    public function equals(self $other): bool
+    {
+        return $this->value === $other->value;
+    }
+
+    /**
+     * Check if JobId is valid ULID format
+     */
+    private function isValidFormat(string $value): bool
+    {
+        // Accept both ULID format (26 chars) and simple IDs (for testing)
+        if (strlen($value) === 26) {
+            // Valid ULID characters (Crockford's Base32)
+            return preg_match('/^[0123456789ABCDEFGHJKMNPQRSTVWXYZ]{26}$/i', $value) === 1;
+        }
+
+        // Allow any non-empty string for now
+        return strlen($value) > 0;
+    }
+
+    /**
+     * Get creation timestamp from ULID
+     */
+    public function getTimestamp(): \DateTimeImmutable
+    {
+        $ulid = $this->toUlid();
+        $timestamp = $ulid->getTimestamp();
+        return \DateTimeImmutable::createFromFormat('U', (string)$timestamp);
+    }
+
+    /**
+     * Create JobId for specific queue and timestamp
+     */
+    public static function generateForQueue(string $queueName): self
+    {
+        // Generate ULID with current timestamp
+        return new self(Ulid::generate());
+    }
+
+    /**
+     * Extract queue-specific prefix (first 10 chars of timestamp)
+     */
+    public function getTimePrefix(): string
+    {
+        return substr($this->value, 0, 10);
+    }
+
+    /**
+     * Extract random suffix (last 16 chars)
+     */
+    public function getRandomSuffix(): string
+    {
+        return substr($this->value, 10, 16);
+    }
+
+    /**
+     * Check if this job was created before another
+     */
+    public function isBefore(self $other): bool
+    {
+        return $this->value < $other->value;
+    }
+
+    /**
+     * Check if this job was created after another
+     */
+    public function isAfter(self $other): bool
+    {
+        return $this->value > $other->value;
+    }
+
+    /**
+     * String representation
+     */
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * JSON serialization
+     */
+    public function jsonSerialize(): string
+    {
+        return $this->value;
+    }
+}

src/Framework/Queue/ValueObjects/JobMetadata.php

@@ -0,0 +1,212 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Ulid\Ulid;
+use App\Framework\DateTime\SystemClock;
+use App\Framework\Core\ValueObjects\ClassName;
+use App\Framework\Core\ValueObjects\Timestamp;
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Job Metadata Value Object
+ *
+ * Contains metadata about a queued job
+ */
+final readonly class JobMetadata
+{
+    public function __construct(
+        public Ulid $id,
+        public ClassName $class,
+        public string $type,
+        public Timestamp $queuedAt,
+        public ?Timestamp $startedAt = null,
+        public ?Timestamp $completedAt = null,
+        public array $tags = [],
+        public array $extra = []
+    ) {}
+
+    public static function create(array $data = []): self
+    {
+        $jobObject = $data['job'] ?? null;
+
+        return new self(
+            id: $data['id'] ?? new Ulid(new SystemClock()),
+            class: $data['class'] ?? ($jobObject ? ClassName::fromObject($jobObject) : ClassName::fromString('unknown')),
+            type: $data['type'] ?? 'job',
+            queuedAt: $data['queued_at'] ?? Timestamp::now(),
+            startedAt: $data['started_at'] ?? null,
+            completedAt: $data['completed_at'] ?? null,
+            tags: $data['tags'] ?? [],
+            extra: $data['extra'] ?? []
+        );
+    }
+
+    public static function forCommand(object $command): self
+    {
+        return self::create([
+            'job' => $command,
+            'type' => 'command',
+            'tags' => ['command']
+        ]);
+    }
+
+    public static function forEvent(object $event): self
+    {
+        return self::create([
+            'job' => $event,
+            'type' => 'event',
+            'tags' => ['event']
+        ]);
+    }
+
+    public static function forEmail(object $email): self
+    {
+        return self::create([
+            'job' => $email,
+            'type' => 'email',
+            'tags' => ['email']
+        ]);
+    }
+
+    public function markStarted(): self
+    {
+        return new self(
+            id: $this->id,
+            class: $this->class,
+            type: $this->type,
+            queuedAt: $this->queuedAt,
+            startedAt: Timestamp::now(),
+            completedAt: $this->completedAt,
+            tags: $this->tags,
+            extra: $this->extra
+        );
+    }
+
+    public function markCompleted(): self
+    {
+        return new self(
+            id: $this->id,
+            class: $this->class,
+            type: $this->type,
+            queuedAt: $this->queuedAt,
+            startedAt: $this->startedAt,
+            completedAt: Timestamp::now(),
+            tags: $this->tags,
+            extra: $this->extra
+        );
+    }
+
+    public function withTag(string $tag): self
+    {
+        $tags = $this->tags;
+        if (!in_array($tag, $tags, true)) {
+            $tags[] = $tag;
+        }
+
+        return new self(
+            id: $this->id,
+            class: $this->class,
+            type: $this->type,
+            queuedAt: $this->queuedAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            tags: $tags,
+            extra: $this->extra
+        );
+    }
+
+    public function withExtra(string $key, mixed $value): self
+    {
+        $extra = $this->extra;
+        $extra[$key] = $value;
+
+        return new self(
+            id: $this->id,
+            class: $this->class,
+            type: $this->type,
+            queuedAt: $this->queuedAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            tags: $this->tags,
+            extra: $extra
+        );
+    }
+
+    public function getProcessingDuration(): ?Duration
+    {
+        if ($this->startedAt === null || $this->completedAt === null) {
+            return null;
+        }
+
+        return Duration::between($this->startedAt, $this->completedAt);
+    }
+
+    public function getWaitDuration(): ?Duration
+    {
+        if ($this->startedAt === null) {
+            return null;
+        }
+
+        return Duration::between($this->queuedAt, $this->startedAt);
+    }
+
+    public function getTotalDuration(): ?Duration
+    {
+        if ($this->completedAt === null) {
+            return null;
+        }
+
+        return Duration::between($this->queuedAt, $this->completedAt);
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->completedAt !== null;
+    }
+
+    public function isStarted(): bool
+    {
+        return $this->startedAt !== null;
+    }
+
+    public function isPending(): bool
+    {
+        return $this->startedAt === null;
+    }
+
+    public function isProcessing(): bool
+    {
+        return $this->startedAt !== null && $this->completedAt === null;
+    }
+
+    public function hasTag(string $tag): bool
+    {
+        return in_array($tag, $this->tags, true);
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id->toString(),
+            'class' => $this->class->toString(),
+            'type' => $this->type,
+            'queued_at' => $this->queuedAt->toIso8601(),
+            'started_at' => $this->startedAt?->toIso8601(),
+            'completed_at' => $this->completedAt?->toIso8601(),
+            'tags' => $this->tags,
+            'extra' => $this->extra,
+            'processing_duration' => $this->getProcessingDuration()?->toSeconds(),
+            'wait_duration' => $this->getWaitDuration()?->toSeconds(),
+            'total_duration' => $this->getTotalDuration()?->toSeconds(),
+            'status' => match(true) {
+                $this->isCompleted() => 'completed',
+                $this->isProcessing() => 'processing',
+                $this->isPending() => 'pending',
+                default => 'unknown'
+            }
+        ];
+    }
+}

src/Framework/Queue/ValueObjects/JobMetrics.php

@@ -0,0 +1,206 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Core\ValueObjects\Percentage;
+
+final readonly class JobMetrics
+{
+    public function __construct(
+        public string $jobId,
+        public string $queueName,
+        public string $status,
+        public int $attempts,
+        public int $maxAttempts,
+        public float $executionTimeMs,
+        public int $memoryUsageBytes,
+        public ?string $errorMessage,
+        public string $createdAt,
+        public ?string $startedAt,
+        public ?string $completedAt,
+        public ?string $failedAt,
+        public array $metadata = []
+    ) {}
+
+    public static function create(
+        string $jobId,
+        string $queueName,
+        string $status = 'pending',
+        int $attempts = 0,
+        int $maxAttempts = 3
+    ): self {
+        $now = date('Y-m-d H:i:s');
+
+        return new self(
+            jobId: $jobId,
+            queueName: $queueName,
+            status: $status,
+            attempts: $attempts,
+            maxAttempts: $maxAttempts,
+            executionTimeMs: 0.0,
+            memoryUsageBytes: 0,
+            errorMessage: null,
+            createdAt: $now,
+            startedAt: null,
+            completedAt: null,
+            failedAt: null,
+            metadata: []
+        );
+    }
+
+    public function withStarted(float $executionStartTime, int $memoryUsage): self
+    {
+        return new self(
+            jobId: $this->jobId,
+            queueName: $this->queueName,
+            status: 'running',
+            attempts: $this->attempts + 1,
+            maxAttempts: $this->maxAttempts,
+            executionTimeMs: $executionStartTime,
+            memoryUsageBytes: $memoryUsage,
+            errorMessage: $this->errorMessage,
+            createdAt: $this->createdAt,
+            startedAt: date('Y-m-d H:i:s'),
+            completedAt: $this->completedAt,
+            failedAt: $this->failedAt,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withCompleted(float $totalExecutionTime, int $peakMemoryUsage): self
+    {
+        return new self(
+            jobId: $this->jobId,
+            queueName: $this->queueName,
+            status: 'completed',
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            executionTimeMs: $totalExecutionTime,
+            memoryUsageBytes: $peakMemoryUsage,
+            errorMessage: $this->errorMessage,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: date('Y-m-d H:i:s'),
+            failedAt: $this->failedAt,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withFailed(string $errorMessage, float $executionTime, int $memoryUsage): self
+    {
+        return new self(
+            jobId: $this->jobId,
+            queueName: $this->queueName,
+            status: 'failed',
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            executionTimeMs: $executionTime,
+            memoryUsageBytes: $memoryUsage,
+            errorMessage: $errorMessage,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            failedAt: date('Y-m-d H:i:s'),
+            metadata: $this->metadata
+        );
+    }
+
+    public function withMetadata(array $metadata): self
+    {
+        return new self(
+            jobId: $this->jobId,
+            queueName: $this->queueName,
+            status: $this->status,
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            executionTimeMs: $this->executionTimeMs,
+            memoryUsageBytes: $this->memoryUsageBytes,
+            errorMessage: $this->errorMessage,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            failedAt: $this->failedAt,
+            metadata: array_merge($this->metadata, $metadata)
+        );
+    }
+
+    public function getSuccessRate(): Percentage
+    {
+        if ($this->attempts === 0) {
+            return Percentage::from(100.0);
+        }
+
+        $successfulAttempts = $this->status === 'completed' ? 1 : 0;
+        return Percentage::from(($successfulAttempts / max(1, $this->attempts)) * 100);
+    }
+
+    public function getExecutionTimeSeconds(): float
+    {
+        return $this->executionTimeMs / 1000.0;
+    }
+
+    public function getMemoryUsageMB(): float
+    {
+        return $this->memoryUsageBytes / (1024 * 1024);
+    }
+
+    public function getDuration(): ?int
+    {
+        if (!$this->startedAt) {
+            return null;
+        }
+
+        $endTime = $this->completedAt ?? $this->failedAt ?? date('Y-m-d H:i:s');
+        return strtotime($endTime) - strtotime($this->startedAt);
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->status === 'completed';
+    }
+
+    public function isFailed(): bool
+    {
+        return $this->status === 'failed';
+    }
+
+    public function isRunning(): bool
+    {
+        return $this->status === 'running';
+    }
+
+    public function isPending(): bool
+    {
+        return $this->status === 'pending';
+    }
+
+    public function hasMaxAttempts(): bool
+    {
+        return $this->attempts >= $this->maxAttempts;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'job_id' => $this->jobId,
+            'queue_name' => $this->queueName,
+            'status' => $this->status,
+            'attempts' => $this->attempts,
+            'max_attempts' => $this->maxAttempts,
+            'execution_time_ms' => $this->executionTimeMs,
+            'execution_time_seconds' => $this->getExecutionTimeSeconds(),
+            'memory_usage_bytes' => $this->memoryUsageBytes,
+            'memory_usage_mb' => $this->getMemoryUsageMB(),
+            'success_rate' => $this->getSuccessRate()->getValue(),
+            'duration_seconds' => $this->getDuration(),
+            'error_message' => $this->errorMessage,
+            'created_at' => $this->createdAt,
+            'started_at' => $this->startedAt,
+            'completed_at' => $this->completedAt,
+            'failed_at' => $this->failedAt,
+            'metadata' => $this->metadata
+        ];
+    }
+}

src/Framework/Queue/ValueObjects/JobPayload.php

@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Core\ValueObjects\Duration;
+use App\Framework\Retry\RetryStrategy;
+use App\Framework\Retry\Strategies\ExponentialBackoffStrategy;
+
+/**
+ * Job Payload Value Object
+ *
+ * Container for a job with all its configuration and metadata
+ */
+final readonly class JobPayload
+{
+    public function __construct(
+        public object $job,
+        public QueuePriority $priority,
+        public Duration $delay,
+        public ?Duration $timeout = null,
+        public ?RetryStrategy $retryStrategy = null,
+        public ?JobMetadata $metadata = null
+    ) {}
+
+    public static function create(
+        object $job,
+        ?QueuePriority $priority = null,
+        ?Duration $delay = null,
+        ?Duration $timeout = null,
+        ?RetryStrategy $retryStrategy = null,
+        ?JobMetadata $metadata = null
+    ): self {
+        return new self(
+            job: $job,
+            priority: $priority ?? QueuePriority::normal(),
+            delay: $delay ?? Duration::zero(),
+            timeout: $timeout,
+            retryStrategy: $retryStrategy,
+            metadata: $metadata ?? JobMetadata::create(['job' => $job])
+        );
+    }
+
+    public static function immediate(object $job): self
+    {
+        return self::create(
+            job: $job,
+            priority: QueuePriority::high(),
+            delay: Duration::zero()
+        );
+    }
+
+    public static function delayed(object $job, Duration $delay): self
+    {
+        return self::create(
+            job: $job,
+            delay: $delay
+        );
+    }
+
+    public static function critical(object $job): self
+    {
+        return self::create(
+            job: $job,
+            priority: QueuePriority::critical(),
+            delay: Duration::zero(),
+            timeout: Duration::fromSeconds(30)
+        );
+    }
+
+    public static function background(object $job): self
+    {
+        return self::create(
+            job: $job,
+            priority: QueuePriority::low(),
+            timeout: Duration::fromMinutes(30),
+            retryStrategy: new ExponentialBackoffStrategy(maxAttempts: 5)
+        );
+    }
+
+    public function withPriority(QueuePriority $priority): self
+    {
+        return new self(
+            job: $this->job,
+            priority: $priority,
+            delay: $this->delay,
+            timeout: $this->timeout,
+            retryStrategy: $this->retryStrategy,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withDelay(Duration $delay): self
+    {
+        return new self(
+            job: $this->job,
+            priority: $this->priority,
+            delay: $delay,
+            timeout: $this->timeout,
+            retryStrategy: $this->retryStrategy,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withTimeout(Duration $timeout): self
+    {
+        return new self(
+            job: $this->job,
+            priority: $this->priority,
+            delay: $this->delay,
+            timeout: $timeout,
+            retryStrategy: $this->retryStrategy,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withRetryStrategy(RetryStrategy $strategy): self
+    {
+        return new self(
+            job: $this->job,
+            priority: $this->priority,
+            delay: $this->delay,
+            timeout: $this->timeout,
+            retryStrategy: $strategy,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withMetadata(JobMetadata $metadata): self
+    {
+        return new self(
+            job: $this->job,
+            priority: $this->priority,
+            delay: $this->delay,
+            timeout: $this->timeout,
+            retryStrategy: $this->retryStrategy,
+            metadata: $metadata
+        );
+    }
+
+    public function isReady(): bool
+    {
+        return $this->delay->toSeconds() === 0;
+    }
+
+    public function isDelayed(): bool
+    {
+        return $this->delay->toSeconds() > 0;
+    }
+
+    public function hasRetryStrategy(): bool
+    {
+        return $this->retryStrategy !== null;
+    }
+
+    public function hasTimeout(): bool
+    {
+        return $this->timeout !== null;
+    }
+
+    /**
+     * Calculate available time (when the job can be processed)
+     */
+    public function getAvailableTime(): int
+    {
+        if ($this->delay->toSeconds() === 0) {
+            return time();
+        }
+
+        return time() + (int) $this->delay->toSeconds();
+    }
+
+    /**
+     * Serialize for storage
+     */
+    public function serialize(): string
+    {
+        return serialize($this->job);
+    }
+
+    /**
+     * Get job class name
+     */
+    public function getJobClass(): string
+    {
+        return get_class($this->job);
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'job_class' => $this->getJobClass(),
+            'priority' => $this->priority->toString(),
+            'priority_value' => $this->priority->value,
+            'delay_seconds' => $this->delay->toSeconds(),
+            'timeout_seconds' => $this->timeout?->toSeconds(),
+            'has_retry_strategy' => $this->hasRetryStrategy(),
+            'max_attempts' => $this->retryStrategy?->getMaxAttempts(),
+            'available_at' => $this->getAvailableTime(),
+            'metadata' => $this->metadata?->toArray()
+        ];
+    }
+}

src/Framework/Queue/ValueObjects/JobPriority.php

@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Enum representing job priority levels
+ */
+enum JobPriority: int
+{
+    case LOW = 1;
+    case NORMAL = 5;
+    case HIGH = 10;
+    case URGENT = 20;
+    case CRITICAL = 50;
+
+    public function getDisplayName(): string
+    {
+        return match ($this) {
+            self::LOW => 'Low',
+            self::NORMAL => 'Normal',
+            self::HIGH => 'High',
+            self::URGENT => 'Urgent',
+            self::CRITICAL => 'Critical'
+        };
+    }
+
+    public function getIcon(): string
+    {
+        return match ($this) {
+            self::LOW => '🔵',
+            self::NORMAL => '⚪',
+            self::HIGH => '🟡',
+            self::URGENT => '🟠',
+            self::CRITICAL => '🔴'
+        };
+    }
+
+    public function getColor(): string
+    {
+        return match ($this) {
+            self::LOW => 'blue',
+            self::NORMAL => 'gray',
+            self::HIGH => 'yellow',
+            self::URGENT => 'orange',
+            self::CRITICAL => 'red'
+        };
+    }
+
+    public function isHigherThan(self $other): bool
+    {
+        return $this->value > $other->value;
+    }
+
+    public function isLowerThan(self $other): bool
+    {
+        return $this->value < $other->value;
+    }
+
+    public function equals(self $other): bool
+    {
+        return $this->value === $other->value;
+    }
+
+    public static function fromString(string $priority): self
+    {
+        return match (strtolower($priority)) {
+            'low' => self::LOW,
+            'normal' => self::NORMAL,
+            'high' => self::HIGH,
+            'urgent' => self::URGENT,
+            'critical' => self::CRITICAL,
+            default => throw new \InvalidArgumentException("Invalid priority: {$priority}")
+        };
+    }
+
+    public function getDescription(): string
+    {
+        return match ($this) {
+            self::LOW => 'Low priority - process when system is idle',
+            self::NORMAL => 'Normal priority - standard processing',
+            self::HIGH => 'High priority - expedited processing',
+            self::URGENT => 'Urgent priority - immediate attention required',
+            self::CRITICAL => 'Critical priority - highest precedence'
+        };
+    }
+
+    public function getMaxRetries(): int
+    {
+        return match ($this) {
+            self::LOW => 2,
+            self::NORMAL => 3,
+            self::HIGH => 5,
+            self::URGENT => 8,
+            self::CRITICAL => 10
+        };
+    }
+
+    public function getTimeoutSeconds(): int
+    {
+        return match ($this) {
+            self::LOW => 300,    // 5 minutes
+            self::NORMAL => 600, // 10 minutes
+            self::HIGH => 900,   // 15 minutes
+            self::URGENT => 1800, // 30 minutes
+            self::CRITICAL => 3600 // 60 minutes
+        };
+    }
+}

src/Framework/Queue/ValueObjects/JobProgress.php

@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Core\ValueObjects\Percentage;
+
+/**
+ * Value Object representing job progress with percentage and status message
+ */
+final readonly class JobProgress
+{
+    public function __construct(
+        public Percentage $percentage,
+        public string $message,
+        public ?array $metadata = null
+    ) {
+        $this->validate();
+    }
+
+    public static function starting(string $message = 'Job starting...'): self
+    {
+        return new self(Percentage::zero(), $message);
+    }
+
+    public static function completed(string $message = 'Job completed successfully'): self
+    {
+        return new self(Percentage::full(), $message);
+    }
+
+    public static function failed(string $message = 'Job failed'): self
+    {
+        return new self(Percentage::zero(), $message, ['status' => 'failed']);
+    }
+
+    public static function withPercentage(Percentage $percentage, string $message, ?array $metadata = null): self
+    {
+        return new self($percentage, $message, $metadata);
+    }
+
+    public static function fromRatio(int $current, int $total, string $message, ?array $metadata = null): self
+    {
+        return new self(
+            percentage: Percentage::fromRatio($current, $total),
+            message: $message,
+            metadata: $metadata
+        );
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->percentage->isFull();
+    }
+
+    public function isFailed(): bool
+    {
+        return isset($this->metadata['status']) && $this->metadata['status'] === 'failed';
+    }
+
+    public function isStarting(): bool
+    {
+        return $this->percentage->isZero() && !$this->isFailed();
+    }
+
+    public function withMetadata(array $metadata): self
+    {
+        return new self(
+            percentage: $this->percentage,
+            message: $this->message,
+            metadata: array_merge($this->metadata ?? [], $metadata)
+        );
+    }
+
+    public function withUpdatedProgress(Percentage $percentage, string $message): self
+    {
+        return new self(
+            percentage: $percentage,
+            message: $message,
+            metadata: $this->metadata
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'percentage' => $this->percentage->getValue(),
+            'percentage_formatted' => $this->percentage->format(),
+            'message' => $this->message,
+            'metadata' => $this->metadata,
+            'is_completed' => $this->isCompleted(),
+            'is_failed' => $this->isFailed(),
+            'is_starting' => $this->isStarting()
+        ];
+    }
+
+    private function validate(): void
+    {
+        if (empty(trim($this->message))) {
+            throw new \InvalidArgumentException('Progress message cannot be empty');
+        }
+    }
+}

src/Framework/Queue/ValueObjects/JobState.php

@@ -0,0 +1,241 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\StateManagement\SerializableState;
+use App\Framework\Core\ValueObjects\Timestamp;
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Job state representation for state management
+ */
+final readonly class JobState implements SerializableState
+{
+    public function __construct(
+        public JobId $jobId,
+        public JobStatus $status,
+        public QueueType $queueType,
+        public QueuePriority $priority,
+        public Timestamp $createdAt,
+        public ?Timestamp $startedAt = null,
+        public ?Timestamp $completedAt = null,
+        public ?string $errorMessage = null,
+        public int $attempts = 0,
+        public int $maxAttempts = 3,
+        public array $metadata = []
+    ) {}
+
+    /**
+     * Create initial job state
+     */
+    public static function create(
+        JobId $jobId,
+        QueueType $queueType,
+        QueuePriority $priority,
+        int $maxAttempts = 3,
+        array $metadata = []
+    ): self {
+        return new self(
+            jobId: $jobId,
+            status: JobStatus::PENDING,
+            queueType: $queueType,
+            priority: $priority,
+            createdAt: Timestamp::now(),
+            maxAttempts: $maxAttempts,
+            metadata: $metadata
+        );
+    }
+
+    /**
+     * Mark job as processing
+     */
+    public function markAsProcessing(): self
+    {
+        if (!$this->status->canTransitionTo(JobStatus::PROCESSING)) {
+            throw new \InvalidArgumentException(
+                "Cannot transition from {$this->status->value} to processing"
+            );
+        }
+
+        return new self(
+            jobId: $this->jobId,
+            status: JobStatus::PROCESSING,
+            queueType: $this->queueType,
+            priority: $this->priority,
+            createdAt: $this->createdAt,
+            startedAt: Timestamp::now(),
+            completedAt: $this->completedAt,
+            errorMessage: $this->errorMessage,
+            attempts: $this->attempts + 1,
+            maxAttempts: $this->maxAttempts,
+            metadata: $this->metadata
+        );
+    }
+
+    /**
+     * Mark job as completed
+     */
+    public function markAsCompleted(): self
+    {
+        if (!$this->status->canTransitionTo(JobStatus::COMPLETED)) {
+            throw new \InvalidArgumentException(
+                "Cannot transition from {$this->status->value} to completed"
+            );
+        }
+
+        return new self(
+            jobId: $this->jobId,
+            status: JobStatus::COMPLETED,
+            queueType: $this->queueType,
+            priority: $this->priority,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: Timestamp::now(),
+            errorMessage: $this->errorMessage,
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            metadata: $this->metadata
+        );
+    }
+
+    /**
+     * Mark job as failed
+     */
+    public function markAsFailed(string $errorMessage): self
+    {
+        if (!$this->status->canTransitionTo(JobStatus::FAILED)) {
+            throw new \InvalidArgumentException(
+                "Cannot transition from {$this->status->value} to failed"
+            );
+        }
+
+        return new self(
+            jobId: $this->jobId,
+            status: JobStatus::FAILED,
+            queueType: $this->queueType,
+            priority: $this->priority,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: Timestamp::now(),
+            errorMessage: $errorMessage,
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            metadata: $this->metadata
+        );
+    }
+
+    /**
+     * Mark job for retry
+     */
+    public function markForRetry(string $errorMessage): self
+    {
+        if ($this->attempts >= $this->maxAttempts) {
+            return $this->markAsFailed("Max attempts exceeded: " . $errorMessage);
+        }
+
+        if (!$this->status->canTransitionTo(JobStatus::RETRYING)) {
+            throw new \InvalidArgumentException(
+                "Cannot transition from {$this->status->value} to retrying"
+            );
+        }
+
+        return new self(
+            jobId: $this->jobId,
+            status: JobStatus::RETRYING,
+            queueType: $this->queueType,
+            priority: $this->priority,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            errorMessage: $errorMessage,
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            metadata: $this->metadata
+        );
+    }
+
+    /**
+     * Add metadata
+     */
+    public function withMetadata(array $metadata): self
+    {
+        return new self(
+            jobId: $this->jobId,
+            status: $this->status,
+            queueType: $this->queueType,
+            priority: $this->priority,
+            createdAt: $this->createdAt,
+            startedAt: $this->startedAt,
+            completedAt: $this->completedAt,
+            errorMessage: $this->errorMessage,
+            attempts: $this->attempts,
+            maxAttempts: $this->maxAttempts,
+            metadata: array_merge($this->metadata, $metadata)
+        );
+    }
+
+    /**
+     * Get processing duration
+     */
+    public function getProcessingDuration(): ?Duration
+    {
+        if ($this->startedAt === null || $this->completedAt === null) {
+            return null;
+        }
+
+        return Duration::fromSeconds(
+            $this->completedAt->toFloat() - $this->startedAt->toFloat()
+        );
+    }
+
+    /**
+     * Check if job can be retried
+     */
+    public function canRetry(): bool
+    {
+        return $this->attempts < $this->maxAttempts &&
+               $this->status->canTransitionTo(JobStatus::RETRYING);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function toArray(): array
+    {
+        return [
+            'job_id' => $this->jobId->toString(),
+            'status' => $this->status->value,
+            'queue_type' => $this->queueType->value,
+            'priority' => $this->priority->value,
+            'created_at' => $this->createdAt->toFloat(),
+            'started_at' => $this->startedAt?->toFloat(),
+            'completed_at' => $this->completedAt?->toFloat(),
+            'error_message' => $this->errorMessage,
+            'attempts' => $this->attempts,
+            'max_attempts' => $this->maxAttempts,
+            'metadata' => $this->metadata
+        ];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function fromArray(array $data): static
+    {
+        return new self(
+            jobId: JobId::fromString($data['job_id']),
+            status: JobStatus::from($data['status']),
+            queueType: QueueType::from($data['queue_type']),
+            priority: new QueuePriority($data['priority']),
+            createdAt: Timestamp::fromFloat($data['created_at']),
+            startedAt: $data['started_at'] ? Timestamp::fromFloat($data['started_at']) : null,
+            completedAt: $data['completed_at'] ? Timestamp::fromFloat($data['completed_at']) : null,
+            errorMessage: $data['error_message'] ?? null,
+            attempts: $data['attempts'],
+            maxAttempts: $data['max_attempts'],
+            metadata: $data['metadata'] ?? []
+        );
+    }
+}

src/Framework/Queue/ValueObjects/JobStatus.php

@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Job status enumeration for tracking job lifecycle
+ */
+enum JobStatus: string
+{
+    case PENDING = 'pending';           // Job created, waiting in queue
+    case PROCESSING = 'processing';     // Job being processed
+    case COMPLETED = 'completed';       // Job completed successfully
+    case FAILED = 'failed';            // Job failed with error
+    case RETRYING = 'retrying';        // Job failed, retrying
+    case CANCELLED = 'cancelled';      // Job was cancelled
+    case EXPIRED = 'expired';          // Job expired (timeout)
+
+    /**
+     * Get human-readable label
+     */
+    public function getLabel(): string
+    {
+        return match ($this) {
+            self::PENDING => 'Pending',
+            self::PROCESSING => 'Processing',
+            self::COMPLETED => 'Completed',
+            self::FAILED => 'Failed',
+            self::RETRYING => 'Retrying',
+            self::CANCELLED => 'Cancelled',
+            self::EXPIRED => 'Expired',
+        };
+    }
+
+    /**
+     * Check if status represents a final state
+     */
+    public function isFinal(): bool
+    {
+        return match ($this) {
+            self::COMPLETED, self::CANCELLED, self::EXPIRED => true,
+            default => false
+        };
+    }
+
+    /**
+     * Check if status represents an active state
+     */
+    public function isActive(): bool
+    {
+        return match ($this) {
+            self::PENDING, self::PROCESSING, self::RETRYING => true,
+            default => false
+        };
+    }
+
+    /**
+     * Check if status represents a failure state
+     */
+    public function isFailure(): bool
+    {
+        return match ($this) {
+            self::FAILED, self::EXPIRED => true,
+            default => false
+        };
+    }
+
+    /**
+     * Get next possible statuses from current status
+     *
+     * @return self[]
+     */
+    public function getNextPossibleStatuses(): array
+    {
+        return match ($this) {
+            self::PENDING => [self::PROCESSING, self::CANCELLED],
+            self::PROCESSING => [self::COMPLETED, self::FAILED, self::CANCELLED, self::EXPIRED],
+            self::RETRYING => [self::PROCESSING, self::FAILED, self::CANCELLED],
+            self::FAILED => [self::RETRYING, self::CANCELLED],
+            default => [] // Final states have no transitions
+        };
+    }
+
+    /**
+     * Check if transition to another status is valid
+     */
+    public function canTransitionTo(self $newStatus): bool
+    {
+        return in_array($newStatus, $this->getNextPossibleStatuses(), true);
+    }
+}

src/Framework/Queue/ValueObjects/LockKey.php

@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Value Object für Lock Keys im Distributed Locking System
+ */
+final readonly class LockKey
+{
+    private function __construct(
+        private string $value
+    ) {
+        if (empty($value)) {
+            throw new \InvalidArgumentException('Lock key cannot be empty');
+        }
+
+        if (strlen($value) > 255) {
+            throw new \InvalidArgumentException('Lock key cannot exceed 255 characters');
+        }
+
+        // Nur alphanumerische Zeichen, Bindestriche, Unterstriche und Punkte erlaubt
+        if (!preg_match('/^[a-zA-Z0-9\-_.]+$/', $value)) {
+            throw new \InvalidArgumentException('Lock key contains invalid characters');
+        }
+    }
+
+    /**
+     * Lock Key aus String erstellen
+     */
+    public static function fromString(string $key): self
+    {
+        return new self($key);
+    }
+
+    /**
+     * Lock Key für Job erstellen
+     */
+    public static function forJob(JobId $jobId): self
+    {
+        return new self("job.{$jobId->toString()}");
+    }
+
+    /**
+     * Lock Key für Queue erstellen
+     */
+    public static function forQueue(QueueName $queueName): self
+    {
+        return new self("queue.{$queueName->toString()}");
+    }
+
+    /**
+     * Lock Key für Worker erstellen
+     */
+    public static function forWorker(WorkerId $workerId): self
+    {
+        return new self("worker.{$workerId->toString()}");
+    }
+
+    /**
+     * Lock Key für Resource erstellen
+     */
+    public static function forResource(string $resourceType, string $resourceId): self
+    {
+        return new self("{$resourceType}.{$resourceId}");
+    }
+
+    /**
+     * Lock Key für Batch-Operation erstellen
+     */
+    public static function forBatch(string $batchId): self
+    {
+        return new self("batch.{$batchId}");
+    }
+
+    /**
+     * String Repräsentation
+     */
+    public function toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * Prüfe ob zwei LockKeys gleich sind
+     */
+    public function equals(self $other): bool
+    {
+        return $this->value === $other->value;
+    }
+
+    /**
+     * String Conversion
+     */
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * JSON Serialization
+     */
+    public function jsonSerialize(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * Lock Key mit Prefix erweitern
+     */
+    public function withPrefix(string $prefix): self
+    {
+        return new self("{$prefix}.{$this->value}");
+    }
+
+    /**
+     * Lock Key mit Suffix erweitern
+     */
+    public function withSuffix(string $suffix): self
+    {
+        return new self("{$this->value}.{$suffix}");
+    }
+
+    /**
+     * Prüfe ob Lock Key ein bestimmtes Pattern hat
+     */
+    public function matches(string $pattern): bool
+    {
+        return fnmatch($pattern, $this->value);
+    }
+}

src/Framework/Queue/ValueObjects/ProgressStep.php

@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Value Object representing a single step in job progress tracking
+ */
+final readonly class ProgressStep
+{
+    public function __construct(
+        public string $stepName,
+        public string $description,
+        public bool $completed = false,
+        public ?string $completedAt = null,
+        public ?array $metadata = null
+    ) {
+        $this->validate();
+    }
+
+    public static function create(string $stepName, string $description, ?array $metadata = null): self
+    {
+        return new self(
+            stepName: $stepName,
+            description: $description,
+            metadata: $metadata
+        );
+    }
+
+    public static function completed(string $stepName, string $description, ?array $metadata = null): self
+    {
+        return new self(
+            stepName: $stepName,
+            description: $description,
+            completed: true,
+            completedAt: date('Y-m-d H:i:s'),
+            metadata: $metadata
+        );
+    }
+
+    public function markAsCompleted(?array $additionalMetadata = null): self
+    {
+        $metadata = $this->metadata ?? [];
+        if ($additionalMetadata) {
+            $metadata = array_merge($metadata, $additionalMetadata);
+        }
+
+        return new self(
+            stepName: $this->stepName,
+            description: $this->description,
+            completed: true,
+            completedAt: date('Y-m-d H:i:s'),
+            metadata: $metadata
+        );
+    }
+
+    public function withMetadata(array $metadata): self
+    {
+        return new self(
+            stepName: $this->stepName,
+            description: $this->description,
+            completed: $this->completed,
+            completedAt: $this->completedAt,
+            metadata: array_merge($this->metadata ?? [], $metadata)
+        );
+    }
+
+    public function getDisplayName(): string
+    {
+        return $this->stepName;
+    }
+
+    public function getStatus(): string
+    {
+        return $this->completed ? 'completed' : 'pending';
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'step_name' => $this->stepName,
+            'description' => $this->description,
+            'completed' => $this->completed,
+            'completed_at' => $this->completedAt,
+            'status' => $this->getStatus(),
+            'metadata' => $this->metadata
+        ];
+    }
+
+    private function validate(): void
+    {
+        if (empty(trim($this->stepName))) {
+            throw new \InvalidArgumentException('Step name cannot be empty');
+        }
+
+        if (empty(trim($this->description))) {
+            throw new \InvalidArgumentException('Step description cannot be empty');
+        }
+
+        if ($this->completed && !$this->completedAt) {
+            throw new \InvalidArgumentException('Completed steps must have a completion timestamp');
+        }
+    }
+}

src/Framework/Queue/ValueObjects/QueueMetrics.php

@@ -0,0 +1,218 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Core\ValueObjects\Percentage;
+
+final readonly class QueueMetrics
+{
+    public function __construct(
+        public string $queueName,
+        public int $totalJobs,
+        public int $pendingJobs,
+        public int $runningJobs,
+        public int $completedJobs,
+        public int $failedJobs,
+        public int $deadLetterJobs,
+        public float $averageExecutionTimeMs,
+        public float $averageMemoryUsageMB,
+        public float $throughputJobsPerHour,
+        public Percentage $successRate,
+        public string $measuredAt,
+        public array $additionalMetrics = []
+    ) {}
+
+    public static function calculate(
+        string $queueName,
+        array $jobMetrics,
+        string $timeWindow = '1 hour'
+    ): self {
+        $total = count($jobMetrics);
+        $pending = 0;
+        $running = 0;
+        $completed = 0;
+        $failed = 0;
+        $deadLetter = 0;
+
+        $totalExecutionTime = 0.0;
+        $totalMemoryUsage = 0.0;
+        $executionCount = 0;
+
+        $windowStart = strtotime("-{$timeWindow}");
+        $jobsInWindow = 0;
+
+        foreach ($jobMetrics as $metrics) {
+            match($metrics->status) {
+                'pending' => $pending++,
+                'running' => $running++,
+                'completed' => $completed++,
+                'failed' => $failed++,
+                'dead_letter' => $deadLetter++,
+                default => null
+            };
+
+            if ($metrics->executionTimeMs > 0) {
+                $totalExecutionTime += $metrics->executionTimeMs;
+                $totalMemoryUsage += $metrics->getMemoryUsageMB();
+                $executionCount++;
+            }
+
+            if (strtotime($metrics->createdAt) >= $windowStart) {
+                $jobsInWindow++;
+            }
+        }
+
+        $avgExecutionTime = $executionCount > 0 ? $totalExecutionTime / $executionCount : 0.0;
+        $avgMemoryUsage = $executionCount > 0 ? $totalMemoryUsage / $executionCount : 0.0;
+        $throughput = $jobsInWindow / (strtotime($timeWindow) / 3600);
+
+        $successRate = $total > 0 ?
+            Percentage::from(($completed / $total) * 100) :
+            Percentage::from(100.0);
+
+        return new self(
+            queueName: $queueName,
+            totalJobs: $total,
+            pendingJobs: $pending,
+            runningJobs: $running,
+            completedJobs: $completed,
+            failedJobs: $failed,
+            deadLetterJobs: $deadLetter,
+            averageExecutionTimeMs: $avgExecutionTime,
+            averageMemoryUsageMB: $avgMemoryUsage,
+            throughputJobsPerHour: $throughput,
+            successRate: $successRate,
+            measuredAt: date('Y-m-d H:i:s'),
+            additionalMetrics: []
+        );
+    }
+
+    public function withAdditionalMetrics(array $metrics): self
+    {
+        return new self(
+            queueName: $this->queueName,
+            totalJobs: $this->totalJobs,
+            pendingJobs: $this->pendingJobs,
+            runningJobs: $this->runningJobs,
+            completedJobs: $this->completedJobs,
+            failedJobs: $this->failedJobs,
+            deadLetterJobs: $this->deadLetterJobs,
+            averageExecutionTimeMs: $this->averageExecutionTimeMs,
+            averageMemoryUsageMB: $this->averageMemoryUsageMB,
+            throughputJobsPerHour: $this->throughputJobsPerHour,
+            successRate: $this->successRate,
+            measuredAt: $this->measuredAt,
+            additionalMetrics: array_merge($this->additionalMetrics, $metrics)
+        );
+    }
+
+    public function getFailureRate(): Percentage
+    {
+        if ($this->totalJobs === 0) {
+            return Percentage::from(0.0);
+        }
+
+        return Percentage::from(($this->failedJobs / $this->totalJobs) * 100);
+    }
+
+    public function getAverageExecutionTimeSeconds(): float
+    {
+        return $this->averageExecutionTimeMs / 1000.0;
+    }
+
+    public function getHealthScore(): Percentage
+    {
+        // Composite health score based on multiple factors
+        $successWeight = 40; // Success rate weight
+        $throughputWeight = 30; // Throughput weight
+        $performanceWeight = 20; // Performance weight
+        $stabilityWeight = 10; // Stability weight
+
+        // Success rate score (0-100)
+        $successScore = $this->successRate->getValue();
+
+        // Throughput score (normalized, assuming 100 jobs/hour is excellent)
+        $throughputScore = min(100, ($this->throughputJobsPerHour / 100) * 100);
+
+        // Performance score (inverse of execution time, assuming 1000ms is baseline)
+        $performanceScore = $this->averageExecutionTimeMs > 0 ?
+            max(0, 100 - (($this->averageExecutionTimeMs / 1000) * 10)) : 100;
+
+        // Stability score (low pending/running job ratio)
+        $activeJobs = $this->pendingJobs + $this->runningJobs;
+        $stabilityScore = $this->totalJobs > 0 ?
+            max(0, 100 - (($activeJobs / $this->totalJobs) * 100)) : 100;
+
+        $weightedScore = (
+            ($successScore * $successWeight) +
+            ($throughputScore * $throughputWeight) +
+            ($performanceScore * $performanceWeight) +
+            ($stabilityScore * $stabilityWeight)
+        ) / 100;
+
+        return Percentage::from($weightedScore);
+    }
+
+    public function isHealthy(): bool
+    {
+        return $this->getHealthScore()->getValue() >= 70.0;
+    }
+
+    public function getBottleneckIndicators(): array
+    {
+        $indicators = [];
+
+        // High pending jobs
+        if ($this->pendingJobs > ($this->totalJobs * 0.3)) {
+            $indicators[] = 'high_pending_jobs';
+        }
+
+        // High failure rate
+        if ($this->getFailureRate()->getValue() > 10.0) {
+            $indicators[] = 'high_failure_rate';
+        }
+
+        // Slow execution
+        if ($this->averageExecutionTimeMs > 5000) {
+            $indicators[] = 'slow_execution';
+        }
+
+        // High memory usage
+        if ($this->averageMemoryUsageMB > 100) {
+            $indicators[] = 'high_memory_usage';
+        }
+
+        // Low throughput
+        if ($this->throughputJobsPerHour < 10) {
+            $indicators[] = 'low_throughput';
+        }
+
+        return $indicators;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'queue_name' => $this->queueName,
+            'total_jobs' => $this->totalJobs,
+            'pending_jobs' => $this->pendingJobs,
+            'running_jobs' => $this->runningJobs,
+            'completed_jobs' => $this->completedJobs,
+            'failed_jobs' => $this->failedJobs,
+            'dead_letter_jobs' => $this->deadLetterJobs,
+            'average_execution_time_ms' => $this->averageExecutionTimeMs,
+            'average_execution_time_seconds' => $this->getAverageExecutionTimeSeconds(),
+            'average_memory_usage_mb' => $this->averageMemoryUsageMB,
+            'throughput_jobs_per_hour' => $this->throughputJobsPerHour,
+            'success_rate' => $this->successRate->getValue(),
+            'failure_rate' => $this->getFailureRate()->getValue(),
+            'health_score' => $this->getHealthScore()->getValue(),
+            'is_healthy' => $this->isHealthy(),
+            'bottleneck_indicators' => $this->getBottleneckIndicators(),
+            'measured_at' => $this->measuredAt,
+            'additional_metrics' => $this->additionalMetrics
+        ];
+    }
+}

src/Framework/Queue/ValueObjects/QueueName.php

@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Queue Name Value Object
+ *
+ * Represents a fully qualified queue name with type awareness
+ */
+final readonly class QueueName
+{
+    public function __construct(
+        public string $value,
+        public QueueType $type,
+        public ?string $tenant = null
+    ) {
+        if (empty($value)) {
+            throw new \InvalidArgumentException('Queue name cannot be empty');
+        }
+
+        if (!preg_match('/^[a-z0-9\-_.]+$/i', $value)) {
+            throw new \InvalidArgumentException(
+                sprintf('Queue name "%s" contains invalid characters. Only alphanumeric, dash, underscore and dot allowed.', $value)
+            );
+        }
+    }
+
+    public static function forCommand(string $name = 'default'): self
+    {
+        return new self("command.{$name}", QueueType::COMMAND);
+    }
+
+    public static function forEvent(string $eventType = 'default'): self
+    {
+        return new self("event.{$eventType}", QueueType::EVENT);
+    }
+
+    public static function forEmail(string $priority = 'default'): self
+    {
+        return new self("email.{$priority}", QueueType::EMAIL);
+    }
+
+    public static function forWebhook(string $service = 'default'): self
+    {
+        return new self("webhook.{$service}", QueueType::WEBHOOK);
+    }
+
+    public static function forReport(string $type = 'default'): self
+    {
+        return new self("report.{$type}", QueueType::REPORT);
+    }
+
+    public static function forImport(string $source = 'default'): self
+    {
+        return new self("import.{$source}", QueueType::IMPORT);
+    }
+
+    public static function default(): self
+    {
+        return new self('default', QueueType::DEFAULT);
+    }
+
+    public function withTenant(string $tenant): self
+    {
+        return new self($this->value, $this->type, $tenant);
+    }
+
+    public function toString(): string
+    {
+        $base = "{$this->type->value}.{$this->value}";
+        return $this->tenant ? "{$this->tenant}.{$base}" : $base;
+    }
+
+    public function equals(self $other): bool
+    {
+        return $this->toString() === $other->toString();
+    }
+
+    public function __toString(): string
+    {
+        return $this->toString();
+    }
+
+    /**
+     * Get Redis key for this queue
+     */
+    public function toRedisKey(): string
+    {
+        return 'queue:' . $this->toString();
+    }
+
+    /**
+     * Get file path for this queue (for FileQueue)
+     */
+    public function toFilePath(): string
+    {
+        return str_replace('.', '/', $this->toString());
+    }
+}

src/Framework/Queue/ValueObjects/QueuePriority.php

@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+/**
+ * Queue Priority Value Object
+ *
+ * Represents the priority of a job in the queue system.
+ * Higher values mean higher priority.
+ */
+final readonly class QueuePriority
+{
+    public const CRITICAL = 1000;
+    public const HIGH = 100;
+    public const NORMAL = 0;
+    public const LOW = -100;
+    public const DEFERRED = -1000;
+
+    public function __construct(
+        public int $value
+    ) {
+        if ($value < -1000 || $value > 1000) {
+            throw new \InvalidArgumentException(
+                sprintf('Priority must be between -1000 and 1000, got %d', $value)
+            );
+        }
+    }
+
+    public static function critical(): self
+    {
+        return new self(self::CRITICAL);
+    }
+
+    public static function high(): self
+    {
+        return new self(self::HIGH);
+    }
+
+    public static function normal(): self
+    {
+        return new self(self::NORMAL);
+    }
+
+    public static function low(): self
+    {
+        return new self(self::LOW);
+    }
+
+    public static function deferred(): self
+    {
+        return new self(self::DEFERRED);
+    }
+
+    public function isHigherThan(self $other): bool
+    {
+        return $this->value > $other->value;
+    }
+
+    public function isLowerThan(self $other): bool
+    {
+        return $this->value < $other->value;
+    }
+
+    public function equals(self $other): bool
+    {
+        return $this->value === $other->value;
+    }
+
+    public function isCritical(): bool
+    {
+        return $this->value >= self::CRITICAL;
+    }
+
+    public function isHigh(): bool
+    {
+        return $this->value >= self::HIGH && $this->value < self::CRITICAL;
+    }
+
+    public function isNormal(): bool
+    {
+        return $this->value > self::LOW && $this->value < self::HIGH;
+    }
+
+    public function isLow(): bool
+    {
+        return $this->value > self::DEFERRED && $this->value <= self::LOW;
+    }
+
+    public function isDeferred(): bool
+    {
+        return $this->value <= self::DEFERRED;
+    }
+
+    public function toString(): string
+    {
+        return match (true) {
+            $this->isCritical() => 'critical',
+            $this->isHigh() => 'high',
+            $this->isNormal() => 'normal',
+            $this->isLow() => 'low',
+            $this->isDeferred() => 'deferred',
+            default => sprintf('custom(%d)', $this->value)
+        };
+    }
+}

src/Framework/Queue/ValueObjects/QueueType.php

@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Core\ValueObjects\Duration;
+
+/**
+ * Queue Type Enumeration
+ *
+ * Defines different types of queues for different workloads
+ */
+enum QueueType: string
+{
+    case COMMAND = 'command';      // Synchronous commands, high priority
+    case EVENT = 'event';          // Asynchronous events, eventual consistency
+    case EMAIL = 'email';          // Email delivery, retry-heavy
+    case WEBHOOK = 'webhook';      // External API calls, timeout-sensitive
+    case REPORT = 'report';        // Long-running reports, low priority
+    case IMPORT = 'import';        // Data imports, batch processing
+    case DEFAULT = 'default';      // General purpose queue
+
+    public function getDescription(): string
+    {
+        return match ($this) {
+            self::COMMAND => 'Command processing queue for synchronous operations',
+            self::EVENT => 'Event processing queue for asynchronous domain events',
+            self::EMAIL => 'Email delivery queue with rate limiting and retry support',
+            self::WEBHOOK => 'Webhook processing queue for external API calls',
+            self::REPORT => 'Report generation queue for long-running tasks',
+            self::IMPORT => 'Data import queue for batch processing',
+            self::DEFAULT => 'General purpose queue for mixed workloads'
+        };
+    }
+
+    public function getDefaultTimeout(): Duration
+    {
+        return match ($this) {
+            self::COMMAND => Duration::fromSeconds(30),
+            self::EVENT => Duration::fromMinutes(1),
+            self::EMAIL => Duration::fromMinutes(2),
+            self::WEBHOOK => Duration::fromSeconds(30),
+            self::REPORT => Duration::fromHours(1),
+            self::IMPORT => Duration::fromMinutes(30),
+            self::DEFAULT => Duration::fromMinutes(1)
+        };
+    }
+
+    public function getDefaultRetries(): int
+    {
+        return match ($this) {
+            self::COMMAND => 3,
+            self::EVENT => 5,
+            self::EMAIL => 10,
+            self::WEBHOOK => 3,
+            self::REPORT => 2,
+            self::IMPORT => 3,
+            self::DEFAULT => 3
+        };
+    }
+
+    public function requiresRateLimiting(): bool
+    {
+        return match ($this) {
+            self::EMAIL, self::WEBHOOK => true,
+            default => false
+        };
+    }
+
+    public function supportsBatching(): bool
+    {
+        return match ($this) {
+            self::EMAIL, self::IMPORT, self::REPORT => true,
+            default => false
+        };
+    }
+
+    public function getDefaultPriority(): QueuePriority
+    {
+        return match ($this) {
+            self::COMMAND => QueuePriority::high(),
+            self::EVENT => QueuePriority::normal(),
+            self::EMAIL => QueuePriority::low(),
+            self::WEBHOOK => QueuePriority::high(),
+            self::REPORT => QueuePriority::deferred(),
+            self::IMPORT => QueuePriority::low(),
+            self::DEFAULT => QueuePriority::normal()
+        };
+    }
+}