feat(event-dispatcher): unify event dispatch via EventInterface trait

Extract a superclass-trait EventInterface from the base Event.

pool_builder's PrePoolCreateEvent stays deferred: its constructor needs
owned, non-cloneable Request and repository boxes the builder only holds
by reference (owned-payload blocker). The event is plugin-only, so its
construction is re-tagged TODO(plugin).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

17 files changed, 314 insertions, 117 deletions

diff --git a/crates/shirabe/src/command/base_command.rs b/crates/shirabe/src/command/base_command.rs
index d7418ff..c98bc2b 100644
--- a/crates/shirabe/src/command/base_command.rs
+++ b/crates/shirabe/src/command/base_command.rs
@@ -378,15 +378,17 @@ impl<C: HasBaseCommandData> BaseCommand for C {
         if let Some(composer) = composer.as_ref() {
             // TODO(phase-b): requires inner Symfony Command get_name access
             let command_name: String = todo!();
-            let pre_command_run_event = PreCommandRunEvent::new(
+            let mut pre_command_run_event = PreCommandRunEvent::new(
                 PluginEvents::PRE_COMMAND_RUN.to_string(),
                 input,
                 command_name,
             );
-            // TODO(phase-b): event_dispatcher.dispatch expects Option<Event>; need wrapper from
-            // PreCommandRunEvent.
-            let _ = composer.borrow_partial().get_event_dispatcher();
-            let _ = pre_command_run_event.get_name();
+            let pre_command_run_event_name = pre_command_run_event.get_name().to_string();
+            let dispatcher = composer.borrow_partial().get_event_dispatcher();
+            dispatcher.borrow_mut().dispatch(
+                Some(&pre_command_run_event_name),
+                Some(&mut pre_command_run_event),
+            )?;
         }
 
         if input.borrow().has_parameter_option(&["--no-ansi"], false)
diff --git a/crates/shirabe/src/command/remove_command.rs b/crates/shirabe/src/command/remove_command.rs
index ddb14f0..1857b17 100644
--- a/crates/shirabe/src/command/remove_command.rs
+++ b/crates/shirabe/src/command/remove_command.rs
@@ -485,18 +485,17 @@ impl RemoveCommand {
             root_package.set_dev_requires(links.remove("require-dev").unwrap_or_default());
         }
 
-        // TODO(plugin): dispatch CommandEvent(PluginEvents::COMMAND, 'remove', input, output)
-        let command_event = crate::plugin::CommandEvent::new(
+        let mut command_event = crate::plugin::CommandEvent::new(
             crate::plugin::PluginEvents::COMMAND,
             "remove",
             input.clone(),
             output,
         );
+        let command_event_name = command_event.get_name().to_string();
         composer
             .get_event_dispatcher()
             .borrow_mut()
-            // TODO(phase-b): dispatch expects Option<Event>; CommandEvent is a different type
-            .dispatch(Some(command_event.get_name()), None);
+            .dispatch(Some(&command_event_name), Some(&mut command_event));
 
         let allow_plugins = composer.get_config().borrow_mut().get("allow-plugins");
         let removed_plugins: Vec<String> =
diff --git a/crates/shirabe/src/command/show_command.rs b/crates/shirabe/src/command/show_command.rs
index 7ee103a..1ce91cb 100644
--- a/crates/shirabe/src/command/show_command.rs
+++ b/crates/shirabe/src/command/show_command.rs
@@ -452,7 +452,7 @@ impl ShowCommand {
 
         if let Some(ref composer) = composer {
             let composer = crate::command::composer_full(composer);
-            let command_event = CommandEvent::new6(
+            let mut command_event = CommandEvent::new6(
                 PluginEvents::COMMAND,
                 "show",
                 input.clone(),
@@ -460,13 +460,11 @@ impl ShowCommand {
                 vec![],
                 IndexMap::new(),
             );
-            // TODO(phase-b): EventDispatcher::dispatch wants Option<Event>, but PHP passes
-            // the CommandEvent subclass directly. Phase D will introduce trait-based dispatch.
-            let _event_name = command_event.get_name().to_string();
+            let command_event_name = command_event.get_name().to_string();
             composer
                 .get_event_dispatcher()
                 .borrow_mut()
-                .dispatch(Some(&_event_name), None)?;
+                .dispatch(Some(&command_event_name), Some(&mut command_event))?;
         }
 
         if input.borrow().get_option("latest").as_bool() == Some(true) && composer.is_none() {
diff --git a/crates/shirabe/src/command/update_command.rs b/crates/shirabe/src/command/update_command.rs
index a4fbf99..751203c 100644
--- a/crates/shirabe/src/command/update_command.rs
+++ b/crates/shirabe/src/command/update_command.rs
@@ -306,12 +306,11 @@ impl UpdateCommand {
 
         let mut command_event =
             CommandEvent::new(PluginEvents::COMMAND, "update", input.clone(), output);
-        // TODO(phase-b): dispatch should accept the CommandEvent itself; passing the
-        // event by name only for now to keep types aligned with EventDispatcher::dispatch.
+        let command_event_name = command_event.get_name().to_string();
         composer
             .get_event_dispatcher()
             .borrow_mut()
-            .dispatch(Some(command_event.get_name()), None)?;
+            .dispatch(Some(&command_event_name), Some(&mut command_event))?;
 
         composer
             .get_installation_manager()
diff --git a/crates/shirabe/src/dependency_resolver/pool_builder.rs b/crates/shirabe/src/dependency_resolver/pool_builder.rs
index 8647cef..b96dc79 100644
--- a/crates/shirabe/src/dependency_resolver/pool_builder.rs
+++ b/crates/shirabe/src/dependency_resolver/pool_builder.rs
@@ -299,8 +299,10 @@ impl PoolBuilder {
         }
 
         if self.event_dispatcher.is_some() {
-            // TODO(phase-b): PrePoolCreateEvent::new takes Request and Vec<Box<dyn RepositoryInterface>>
-            // by value but neither can be cloned (PHP class shared semantics). Needs Rc-based migration.
+            // TODO(plugin): PrePoolCreateEvent::new takes Request and Vec<Box<dyn RepositoryInterface>>
+            // by value but neither can be cloned (PHP class shared semantics). This event is purely
+            // plugin-facing and nothing in the no-plugin path reads it back, so it stays deferred
+            // until the plugin API drives an Rc-based migration of Request/repositories.
             let mut pre_pool_create_event = PrePoolCreateEvent::new(
                 PluginEvents::PRE_POOL_CREATE.to_string(),
                 todo!("share repositories with PrePoolCreateEvent without moving"),
@@ -315,12 +317,15 @@ impl PoolBuilder {
                     .cloned()
                     .collect(),
             );
-            // TODO(phase-b): EventDispatcher::dispatch expects an owned Event, not &mut PrePoolCreateEvent
+            let pre_pool_create_event_name = pre_pool_create_event.get_name().to_string();
             self.event_dispatcher
                 .as_ref()
                 .unwrap()
                 .borrow_mut()
-                .dispatch(Some(pre_pool_create_event.get_name()), None)?;
+                .dispatch(
+                    Some(&pre_pool_create_event_name),
+                    Some(&mut pre_pool_create_event),
+                )?;
             // PHP rebinds $this->packages to a list-style array; preserve indices via reindexing.
             // TODO(plugin)/TODO(phase-c): rebind self.packages from the (handle-based) event packages
             // once EventDispatcher::dispatch returns the mutated event.
diff --git a/crates/shirabe/src/event_dispatcher/event.rs b/crates/shirabe/src/event_dispatcher/event.rs
index 81ab921..f04839f 100644
--- a/crates/shirabe/src/event_dispatcher/event.rs
+++ b/crates/shirabe/src/event_dispatcher/event.rs
@@ -21,6 +21,10 @@ impl Event {
         }
     }
 
+    pub fn from_name(name: String) -> Self {
+        Event::new(name, Vec::new(), IndexMap::new())
+    }
+
     pub fn get_name(&self) -> &str {
         &self.name
     }
@@ -41,3 +45,33 @@ impl Event {
         self.propagation_stopped = true;
     }
 }
+
+pub trait EventInterface: std::fmt::Debug {
+    fn get_name(&self) -> &str;
+    fn get_arguments(&self) -> &Vec<String>;
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed>;
+    fn is_propagation_stopped(&self) -> bool;
+    fn stop_propagation(&mut self);
+}
+
+impl EventInterface for Event {
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        &self.args
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        &self.flags
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.propagation_stopped
+    }
+
+    fn stop_propagation(&mut self) {
+        self.propagation_stopped = true;
+    }
+}
diff --git a/crates/shirabe/src/event_dispatcher/event_dispatcher.rs b/crates/shirabe/src/event_dispatcher/event_dispatcher.rs
index affecdd..a9da6e8 100644
--- a/crates/shirabe/src/event_dispatcher/event_dispatcher.rs
+++ b/crates/shirabe/src/event_dispatcher/event_dispatcher.rs
@@ -24,6 +24,7 @@ use crate::composer::PartialComposerWeakHandle;
 use crate::dependency_resolver::Transaction;
 use crate::dependency_resolver::operation::OperationInterface;
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
 use crate::event_dispatcher::EventSubscriberInterface;
 use crate::event_dispatcher::ScriptExecutionException;
 use crate::installer::BinaryInstaller;
@@ -118,9 +119,9 @@ impl EventDispatcher {
     pub fn dispatch(
         &mut self,
         event_name: Option<&str>,
-        event: Option<Event>,
+        event: Option<&mut dyn EventInterface>,
     ) -> anyhow::Result<i64> {
-        let event = match event {
+        match event {
             None => {
                 let name = event_name.ok_or_else(|| {
                     anyhow::anyhow!(InvalidArgumentException {
@@ -130,12 +131,11 @@ impl EventDispatcher {
                         code: 0,
                     })
                 })?;
-                Event::new(name.to_string(), Vec::new(), IndexMap::new())
+                let mut event = Event::new(name.to_string(), Vec::new(), IndexMap::new());
+                self.do_dispatch(&mut event)
             }
-            Some(e) => e,
-        };
-
-        self.do_dispatch(event)
+            Some(event) => self.do_dispatch(event),
+        }
     }
 
     /// Dispatch a script event.
@@ -216,7 +216,7 @@ impl EventDispatcher {
     }
 
     /// Triggers the listeners of an event.
-    fn do_dispatch(&mut self, event: Event) -> anyhow::Result<i64> {
+    fn do_dispatch(&mut self, event: &mut dyn EventInterface) -> anyhow::Result<i64> {
         if Platform::get_env("COMPOSER_DEBUG_EVENTS").is_some() {
             // TODO(plugin): PackageEvent / CommandEvent / PreCommandRunEvent specialization
             // requires polymorphic dispatch; the simple Event branch is sufficient for now.
@@ -235,13 +235,13 @@ impl EventDispatcher {
             );
         }
 
-        let listeners = self.get_listeners(&event);
+        let listeners = self.get_listeners(&*event);
 
-        self.push_event(&event)?;
+        self.push_event(&*event)?;
 
         let autoloaders_before = spl_autoload_functions();
 
-        let result = self.do_dispatch_body(&event, listeners);
+        let result = self.do_dispatch_body(&*event, listeners);
 
         // finally block
         self.pop_event();
@@ -279,7 +279,11 @@ impl EventDispatcher {
         result
     }
 
-    fn do_dispatch_body(&mut self, event: &Event, listeners: Vec<Callable>) -> anyhow::Result<i64> {
+    fn do_dispatch_body(
+        &mut self,
+        event: &dyn EventInterface,
+        listeners: Vec<Callable>,
+    ) -> anyhow::Result<i64> {
         let mut return_max = 0_i64;
         for callable in listeners {
             let mut r#return: i64 = 0;
@@ -471,14 +475,7 @@ impl EventDispatcher {
                                 flags,
                             );
                             // TODO(plugin): script_event.set_originating_event(event.clone())
-                            match self.dispatch(
-                                Some(&script_name),
-                                Some(Event::new(
-                                    script_name.clone(),
-                                    script_event.inner_args_for_dispatch(),
-                                    script_event.inner_flags_for_dispatch(),
-                                )),
-                            ) {
+                            match self.dispatch(Some(&script_name), Some(&mut script_event)) {
                                 Ok(v) => r#return = v,
                                 Err(e) => {
                                     if e.downcast_ref::<ScriptExecutionException>().is_some() {
@@ -857,30 +854,16 @@ impl EventDispatcher {
         Ok(return_max)
     }
 
-    fn do_dispatch_script(&mut self, event: ScriptEvent) -> anyhow::Result<i64> {
-        // TODO(plugin): proper polymorphic dispatch — currently delegate to base Event path.
-        let base = Event::new(
-            event.get_inner().get_name().to_string(),
-            event.get_inner().get_arguments().clone(),
-            event.get_inner().get_flags().clone(),
-        );
-        self.do_dispatch(base)
+    fn do_dispatch_script(&mut self, mut event: ScriptEvent) -> anyhow::Result<i64> {
+        self.do_dispatch(&mut event)
     }
 
-    fn do_dispatch_package(&mut self, event: PackageEvent) -> anyhow::Result<i64> {
-        // TODO(plugin): preserve PackageEvent identity for `instanceof` checks above.
-        let base = Event::new(event.get_name().to_string(), Vec::new(), IndexMap::new());
-        self.do_dispatch(base)
+    fn do_dispatch_package(&mut self, mut event: PackageEvent) -> anyhow::Result<i64> {
+        self.do_dispatch(&mut event)
     }
 
-    fn do_dispatch_installer(&mut self, event: InstallerEvent) -> anyhow::Result<i64> {
-        // TODO(plugin): preserve InstallerEvent identity for `instanceof` checks above.
-        let base = Event::new(
-            event.get_inner_name().to_string(),
-            Vec::new(),
-            IndexMap::new(),
-        );
-        self.do_dispatch(base)
+    fn do_dispatch_installer(&mut self, mut event: InstallerEvent) -> anyhow::Result<i64> {
+        self.do_dispatch(&mut event)
     }
 
     fn execute_tty(&self, exec: &str) -> anyhow::Result<i64> {
@@ -936,7 +919,7 @@ impl EventDispatcher {
         &self,
         class_name: &str,
         method_name: &str,
-        event: &Event,
+        event: &dyn EventInterface,
     ) -> anyhow::Result<PhpMixed> {
         if self.io.is_verbose() {
             self.io.write_error3(
@@ -969,7 +952,7 @@ impl EventDispatcher {
         todo!("dynamic static method invocation requires plugin runtime")
     }
 
-    fn event_needs_to_output(&self, event: &Event) -> bool {
+    fn event_needs_to_output(&self, event: &dyn EventInterface) -> bool {
         // do not output the command being run when using `composer exec` as it is fairly obvious the user is running it
         if event.get_name() == "__exec_command" {
             return false;
@@ -1031,7 +1014,7 @@ impl EventDispatcher {
     }
 
     /// Retrieves all listeners for a given event
-    fn get_listeners(&mut self, event: &Event) -> Vec<Callable> {
+    fn get_listeners(&mut self, event: &dyn EventInterface) -> Vec<Callable> {
         let script_listeners: Vec<Callable> = if self.run_scripts {
             self.get_script_listeners(event)
         } else {
@@ -1071,14 +1054,14 @@ impl EventDispatcher {
     }
 
     /// Checks if an event has listeners registered
-    pub fn has_event_listeners(&mut self, event: &Event) -> bool {
+    pub fn has_event_listeners(&mut self, event: &dyn EventInterface) -> bool {
         let listeners = self.get_listeners(event);
 
         listeners.len() > 0
     }
 
     /// Finds all listeners defined as scripts in the package
-    fn get_script_listeners(&self, event: &Event) -> Vec<Callable> {
+    fn get_script_listeners(&self, event: &dyn EventInterface) -> Vec<Callable> {
         let composer = self.composer();
         let composer = composer.borrow_partial();
         let package = composer.get_package();
@@ -1128,7 +1111,7 @@ impl EventDispatcher {
     }
 
     /// Push an event to the stack of active event
-    fn push_event(&mut self, event: &Event) -> anyhow::Result<i64> {
+    fn push_event(&mut self, event: &dyn EventInterface) -> anyhow::Result<i64> {
         let event_name = event.get_name().to_string();
         if self.event_stack.iter().any(|n| n == &event_name) {
             return Err(anyhow::anyhow!(RuntimeException {
@@ -1227,7 +1210,11 @@ impl EventDispatcher {
         "unsupported".to_string()
     }
 
-    fn make_autoloader(&mut self, event: &Event, callable: &Callable) -> anyhow::Result<()> {
+    fn make_autoloader(
+        &mut self,
+        event: &dyn EventInterface,
+        callable: &Callable,
+    ) -> anyhow::Result<()> {
         let composer = self.composer();
         // TODO(plugin): full autoloader rebuild on plugin-supplied callables — currently a stub.
         let Some(composer) = composer.as_full() else {
@@ -1334,34 +1321,3 @@ impl EventDispatcher {
         }
     }
 }
-
-// TODO(plugin): re-export the `Event::name`-only constructor `Event::new` PHP variant so callers
-// can build an `Event` from just a name, mirroring `new Event($eventName)`.
-impl Event {
-    pub fn from_name(name: String) -> Self {
-        Event::new(name, Vec::new(), IndexMap::new())
-    }
-}
-
-// Convenience accessors that ScriptEvent doesn't currently expose for the base Event fields.
-// TODO(plugin): replace with proper getters once ScriptEvent grows them.
-impl ScriptEvent {
-    fn get_inner(&self) -> &Event {
-        unimplemented!("ScriptEvent::get_inner — Phase B")
-    }
-
-    fn inner_args_for_dispatch(&self) -> Vec<String> {
-        Vec::new()
-    }
-
-    fn inner_flags_for_dispatch(&self) -> IndexMap<String, PhpMixed> {
-        IndexMap::new()
-    }
-}
-
-// Convenience accessor for InstallerEvent's underlying name.
-impl InstallerEvent {
-    fn get_inner_name(&self) -> &str {
-        unimplemented!("InstallerEvent::get_inner_name — Phase B")
-    }
-}
diff --git a/crates/shirabe/src/factory.rs b/crates/shirabe/src/factory.rs
index e0eb42c..101e4cd 100644
--- a/crates/shirabe/src/factory.rs
+++ b/crates/shirabe/src/factory.rs
@@ -844,12 +844,12 @@ impl Factory {
         if full_load {
             // The back-reference is now upgradeable, so dispatching the INIT event (which may read
             // the Composer through the dispatcher) is safe only after the Rc has been constructed.
-            let init_event = Event::from_name(PluginEvents::INIT.to_string());
+            let mut init_event = Event::from_name(PluginEvents::INIT.to_string());
             let init_event_name = init_event.get_name().to_string();
             let dispatcher = composer.borrow().get_event_dispatcher();
             dispatcher
                 .borrow_mut()
-                .dispatch(Some(&init_event_name), Some(init_event))?;
+                .dispatch(Some(&init_event_name), Some(&mut init_event))?;
 
             // once everything is initialized we can
             // purge packages from local repos if they have been deleted on the filesystem
diff --git a/crates/shirabe/src/installer/installer_event.rs b/crates/shirabe/src/installer/installer_event.rs
index 5adde1c..ca0be22 100644
--- a/crates/shirabe/src/installer/installer_event.rs
+++ b/crates/shirabe/src/installer/installer_event.rs
@@ -1,8 +1,12 @@
 //! ref: composer/src/Composer/Installer/InstallerEvent.php
 
+use indexmap::IndexMap;
+use shirabe_php_shim::PhpMixed;
+
 use crate::composer::ComposerWeakHandle;
 use crate::dependency_resolver::Transaction;
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
 use crate::io::IOInterface;
 
 #[derive(Debug)]
@@ -55,3 +59,25 @@ impl InstallerEvent {
         Some(&self.transaction)
     }
 }
+
+impl EventInterface for InstallerEvent {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}
diff --git a/crates/shirabe/src/installer/package_event.rs b/crates/shirabe/src/installer/package_event.rs
index 17f9113..6661e0d 100644
--- a/crates/shirabe/src/installer/package_event.rs
+++ b/crates/shirabe/src/installer/package_event.rs
@@ -3,9 +3,11 @@
 use crate::composer::ComposerWeakHandle;
 use crate::dependency_resolver::operation::OperationInterface;
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
 use crate::io::IOInterface;
 use crate::repository::RepositoryInterface;
 use indexmap::IndexMap;
+use shirabe_php_shim::PhpMixed;
 
 #[derive(Debug)]
 pub struct PackageEvent {
@@ -67,3 +69,25 @@ impl PackageEvent {
         self.operation.as_ref()
     }
 }
+
+impl EventInterface for PackageEvent {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}
diff --git a/crates/shirabe/src/plugin/command_event.rs b/crates/shirabe/src/plugin/command_event.rs
index fc19fcb..ca63461 100644
--- a/crates/shirabe/src/plugin/command_event.rs
+++ b/crates/shirabe/src/plugin/command_event.rs
@@ -1,6 +1,7 @@
 //! ref: composer/src/Composer/Plugin/CommandEvent.php
 
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
 use indexmap::IndexMap;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
@@ -57,3 +58,25 @@ impl CommandEvent {
         &self.command_name
     }
 }
+
+impl EventInterface for CommandEvent {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}
diff --git a/crates/shirabe/src/plugin/post_file_download_event.rs b/crates/shirabe/src/plugin/post_file_download_event.rs
index 2124f1e..9ba946e 100644
--- a/crates/shirabe/src/plugin/post_file_download_event.rs
+++ b/crates/shirabe/src/plugin/post_file_download_event.rs
@@ -1,8 +1,10 @@
 //! ref: composer/src/Composer/Plugin/PostFileDownloadEvent.php
 
+use indexmap::IndexMap;
 use shirabe_php_shim::PhpMixed;
 
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
 
 #[derive(Debug)]
 pub struct PostFileDownloadEvent {
@@ -57,3 +59,25 @@ impl PostFileDownloadEvent {
         &self.r#type
     }
 }
+
+impl EventInterface for PostFileDownloadEvent {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}
diff --git a/crates/shirabe/src/plugin/pre_command_run_event.rs b/crates/shirabe/src/plugin/pre_command_run_event.rs
index 29567cb..854c47f 100644
--- a/crates/shirabe/src/plugin/pre_command_run_event.rs
+++ b/crates/shirabe/src/plugin/pre_command_run_event.rs
@@ -2,7 +2,10 @@
 
 // TODO(plugin): this event is part of the plugin API and is dispatched before a command runs
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
+use indexmap::IndexMap;
 use shirabe_external_packages::symfony::console::input::InputInterface;
+use shirabe_php_shim::PhpMixed;
 
 #[derive(Debug)]
 pub struct PreCommandRunEvent {
@@ -37,3 +40,25 @@ impl PreCommandRunEvent {
         &self.command
     }
 }
+
+impl EventInterface for PreCommandRunEvent {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}
diff --git a/crates/shirabe/src/plugin/pre_file_download_event.rs b/crates/shirabe/src/plugin/pre_file_download_event.rs
index f6198b6..3bf6296 100644
--- a/crates/shirabe/src/plugin/pre_file_download_event.rs
+++ b/crates/shirabe/src/plugin/pre_file_download_event.rs
@@ -4,6 +4,7 @@ use indexmap::IndexMap;
 use shirabe_php_shim::PhpMixed;
 
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
 use crate::util::HttpDownloader;
 
 #[derive(Debug)]
@@ -76,3 +77,25 @@ impl PreFileDownloadEvent {
         self.transport_options = options;
     }
 }
+
+impl EventInterface for PreFileDownloadEvent {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}
diff --git a/crates/shirabe/src/plugin/pre_pool_create_event.rs b/crates/shirabe/src/plugin/pre_pool_create_event.rs
index 2bbaa6c..303159a 100644
--- a/crates/shirabe/src/plugin/pre_pool_create_event.rs
+++ b/crates/shirabe/src/plugin/pre_pool_create_event.rs
@@ -2,8 +2,11 @@
 
 use indexmap::IndexMap;
 
+use shirabe_php_shim::PhpMixed;
+
 use crate::dependency_resolver::Request;
 use crate::event_dispatcher::Event;
+use crate::event_dispatcher::EventInterface;
 use crate::package::BasePackageHandle;
 use crate::repository::RepositoryInterface;
 
@@ -92,3 +95,25 @@ impl PrePoolCreateEvent {
         self.unacceptable_fixed_packages = packages;
     }
 }
+
+impl EventInterface for PrePoolCreateEvent {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}
diff --git a/crates/shirabe/src/repository/composer_repository.rs b/crates/shirabe/src/repository/composer_repository.rs
index 3dbca7d..f634e23 100644
--- a/crates/shirabe/src/repository/composer_repository.rs
+++ b/crates/shirabe/src/repository/composer_repository.rs
@@ -2757,10 +2757,12 @@ impl ComposerRepository {
                             .map(|(k, v)| (k, Box::new(v)))
                             .collect(),
                     );
-                    // TODO(phase-b): dispatcher.dispatch expects Option<Event>, not concrete event types;
-                    // need a way to pass PreFileDownloadEvent through EventDispatcher's API.
-                    let _ = &mut pre_file_download_event;
-                    dispatcher.dispatch(Some(pre_file_download_event.get_name()), None)?;
+                    let pre_file_download_event_name =
+                        pre_file_download_event.get_name().to_string();
+                    dispatcher.dispatch(
+                        Some(&pre_file_download_event_name),
+                        Some(&mut pre_file_download_event),
+                    )?;
                     filename = pre_file_download_event.get_processed_url().to_string();
                     options = pre_file_download_event
                         .get_transport_options()
@@ -2815,9 +2817,12 @@ impl ComposerRepository {
                             m.into()
                         },
                     );
-                    // TODO(phase-b): dispatcher.dispatch expects Option<Event>, not concrete event types
-                    let _ = &mut post_file_download_event;
-                    dispatcher.dispatch(Some(post_file_download_event.get_name()), None)?;
+                    let post_file_download_event_name =
+                        post_file_download_event.get_name().to_string();
+                    dispatcher.dispatch(
+                        Some(&post_file_download_event_name),
+                        Some(&mut post_file_download_event),
+                    )?;
                 }
 
                 let decoded = response.decode_json()?;
@@ -2954,9 +2959,11 @@ impl ComposerRepository {
                         .map(|(k, v)| (k, Box::new(v)))
                         .collect(),
                 );
-                // TODO(phase-b): dispatcher.dispatch expects Option<Event>, not concrete event types
-                let _ = &mut pre_file_download_event;
-                dispatcher.dispatch(Some(pre_file_download_event.get_name()), None)?;
+                let pre_file_download_event_name = pre_file_download_event.get_name().to_string();
+                dispatcher.dispatch(
+                    Some(&pre_file_download_event_name),
+                    Some(&mut pre_file_download_event),
+                )?;
                 filename = pre_file_download_event.get_processed_url().to_string();
                 options = pre_file_download_event
                     .get_transport_options()
@@ -3015,9 +3022,11 @@ impl ComposerRepository {
                         m.into()
                     },
                 );
-                // TODO(phase-b): dispatcher.dispatch expects Option<Event>, not concrete event types
-                let _ = &mut post_file_download_event;
-                dispatcher.dispatch(Some(post_file_download_event.get_name()), None)?;
+                let post_file_download_event_name = post_file_download_event.get_name().to_string();
+                dispatcher.dispatch(
+                    Some(&post_file_download_event_name),
+                    Some(&mut post_file_download_event),
+                )?;
             }
 
             let decoded = response.decode_json()?;
@@ -3120,9 +3129,11 @@ impl ComposerRepository {
                     .map(|(k, v)| (k, Box::new(v)))
                     .collect(),
             );
-            // TODO(phase-b): dispatcher.dispatch expects Option<Event>, not concrete event types
-            let _ = &mut pre_file_download_event;
-            dispatcher.dispatch(Some(pre_file_download_event.get_name()), None)?;
+            let pre_file_download_event_name = pre_file_download_event.get_name().to_string();
+            dispatcher.dispatch(
+                Some(&pre_file_download_event_name),
+                Some(&mut pre_file_download_event),
+            )?;
             filename = pre_file_download_event.get_processed_url().to_string();
             options = pre_file_download_event
                 .get_transport_options()
diff --git a/crates/shirabe/src/script/event.rs b/crates/shirabe/src/script/event.rs
index 60557b0..5680c22 100644
--- a/crates/shirabe/src/script/event.rs
+++ b/crates/shirabe/src/script/event.rs
@@ -2,6 +2,7 @@
 
 use crate::composer::ComposerWeakHandle;
 use crate::event_dispatcher::Event as BaseEvent;
+use crate::event_dispatcher::EventInterface;
 use crate::io::IOInterface;
 use indexmap::IndexMap;
 use shirabe_php_shim::PhpMixed;
@@ -63,3 +64,25 @@ impl Event {
         todo!()
     }
 }
+
+impl EventInterface for Event {
+    fn get_name(&self) -> &str {
+        self.inner.get_name()
+    }
+
+    fn get_arguments(&self) -> &Vec<String> {
+        self.inner.get_arguments()
+    }
+
+    fn get_flags(&self) -> &IndexMap<String, PhpMixed> {
+        self.inner.get_flags()
+    }
+
+    fn is_propagation_stopped(&self) -> bool {
+        self.inner.is_propagation_stopped()
+    }
+
+    fn stop_propagation(&mut self) {
+        self.inner.stop_propagation();
+    }
+}