Enable Discovery debug logging for production troubleshooting

- Add DISCOVERY_LOG_LEVEL=debug
- Add DISCOVERY_SHOW_PROGRESS=true
- Temporary changes for debugging InitializerProcessor fixes on production

tests/Framework/Core/Events/EventDispatcherTest.php

@@ -0,0 +1,166 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Core\Events\EventDispatcher;
+use App\Framework\Core\Events\OnEvent;
+use App\Framework\DI\DefaultContainer;
+
+beforeEach(function () {
+    $this->container = new DefaultContainer();
+    $this->dispatcher = new EventDispatcher($this->container);
+});
+
+test('dispatch with no handlers returns empty array', function () {
+    $event = new TestEvent('test');
+    $results = $this->dispatcher->dispatch($event);
+
+    expect($results)->toBeEmpty();
+});
+
+test('null event handlers do not cause errors', function () {
+    $dispatcher = new EventDispatcher($this->container, null);
+    $event = new TestEvent('test');
+    $results = $dispatcher->dispatch($event);
+
+    expect($results)->toBeEmpty();
+});
+
+test('manual handler registration works', function () {
+    $event = new TestEvent('test message');
+
+    // Register handler manually using the public method
+    $this->dispatcher->addHandler(TestEvent::class, function ($event) {
+        return 'Manual handler: ' . $event->message;
+    });
+
+    $results = $this->dispatcher->dispatch($event);
+
+    expect($results)->toHaveCount(1)
+        ->and($results[0])->toBe('Manual handler: test message');
+});
+
+test('multiple manual handlers are called', function () {
+    $event = new TestEvent('test');
+
+    $this->dispatcher->addHandler(TestEvent::class, function ($event) {
+        return 'Handler 1: ' . $event->message;
+    });
+
+    $this->dispatcher->addHandler(TestEvent::class, function ($event) {
+        return 'Handler 2: ' . $event->message;
+    });
+
+    $results = $this->dispatcher->dispatch($event);
+
+    expect($results)->toHaveCount(2)
+        ->and($results[0])->toBe('Handler 1: test')
+        ->and($results[1])->toBe('Handler 2: test');
+});
+
+test('event inheritance works with manual handlers', function () {
+    $childEvent = new ChildTestEvent('child message');
+
+    // Register handler for base event
+    $this->dispatcher->addHandler(BaseTestEvent::class, function ($event) {
+        return 'Base handler: ' . $event->message;
+    });
+
+    $results = $this->dispatcher->dispatch($childEvent);
+
+    expect($results)->toHaveCount(1)
+        ->and($results[0])->toBe('Base handler: child message');
+});
+
+test('class-based handlers work with container', function () {
+    $handler = new TestEventHandler();
+    $this->container->instance(TestEventHandler::class, $handler);
+
+    $eventHandlers = [
+        [
+            'event_class' => TestEvent::class,
+            'class' => TestEventHandler::class,
+            'method' => 'handle',
+            'attribute_data' => ['stopPropagation' => false],
+        ],
+    ];
+
+    $dispatcher = new EventDispatcher($this->container, $eventHandlers);
+    $event = new TestEvent('test message');
+    $results = $dispatcher->dispatch($event);
+
+    expect($results)->toHaveCount(1)
+        ->and($results[0])->toBe('Handled: test message')
+        ->and($handler->wasHandled())->toBeTrue();
+});
+
+// Test fixtures
+class TestEvent
+{
+    public function __construct(
+        public readonly string $message
+    ) {
+    }
+}
+
+class BaseTestEvent
+{
+    public function __construct(
+        public readonly string $message
+    ) {
+    }
+}
+
+class ChildTestEvent extends BaseTestEvent
+{
+}
+
+class TestEventHandler
+{
+    private bool $handled = false;
+
+    private int $handleCount = 0;
+
+    #[OnEvent]
+    public function handle(TestEvent $event): string
+    {
+        $this->handled = true;
+        $this->handleCount++;
+
+        return 'Handled: ' . $event->message;
+    }
+
+    #[OnEvent]
+    public function handleBase(BaseTestEvent $event): string
+    {
+        return 'Base handled: ' . $event->message;
+    }
+
+    public function wasHandled(): bool
+    {
+        return $this->handled;
+    }
+
+    public function getHandleCount(): int
+    {
+        return $this->handleCount;
+    }
+}
+
+class AnotherTestEventHandler
+{
+    private bool $processed = false;
+
+    #[OnEvent]
+    public function process(TestEvent $event): string
+    {
+        $this->processed = true;
+
+        return 'Processed: ' . $event->message;
+    }
+
+    public function wasProcessed(): bool
+    {
+        return $this->processed;
+    }
+}