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/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()
+        };
+    }
+}

src/Framework/Queue/ValueObjects/WorkerId.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Queue\ValueObjects;
+
+use App\Framework\Ulid\Ulid;
+
+/**
+ * Value Object representing a unique Worker identifier
+ */
+final readonly class WorkerId
+{
+    private function __construct(
+        private string $value
+    ) {
+        if (empty($value)) {
+            throw new \InvalidArgumentException('WorkerId cannot be empty');
+        }
+    }
+
+    /**
+     * Generate a new WorkerId
+     */
+    public static function generate(): self
+    {
+        // Use simple uniqid for now to avoid dependency injection in Value Objects
+        return new self(uniqid('worker_', true));
+    }
+
+    /**
+     * Create WorkerId for specific host and process
+     */
+    public static function forHost(string $hostname, int $pid): self
+    {
+        // Create a deterministic ID based on hostname and PID
+        $identifier = sprintf('%s_%d_%s', $hostname, $pid, uniqid());
+        return new self(substr(md5($identifier), 0, 16));
+    }
+
+    /**
+     * Create from existing string
+     */
+    public static function fromString(string $id): self
+    {
+        return new self($id);
+    }
+
+    /**
+     * Get string representation
+     */
+    public function toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * Get value (alias for toString)
+     */
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * Check if two WorkerIds are equal
+     */
+    public function equals(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;
+    }
+}