diff --git a/contrib/kyua/cli/cmd_debug.cpp b/contrib/kyua/cli/cmd_debug.cpp
--- a/contrib/kyua/cli/cmd_debug.cpp
+++ b/contrib/kyua/cli/cmd_debug.cpp
@@ -149,7 +149,11 @@
     const engine::test_filter filter = engine::test_filter::parse(
         test_case_name);
 
-    auto debugger = std::shared_ptr< engine::debugger >(new dbg(ui, cmdline));
+    engine::debugger_ptr debugger = nullptr;
+    if (cmdline.has_option(pause_before_cleanup_upon_fail_option.long_name())
+        || cmdline.has_option(pause_before_cleanup_option.long_name())) {
+        debugger = std::shared_ptr< engine::debugger >(new dbg(ui, cmdline));
+    }
 
     const drivers::debug_test::result result = drivers::debug_test::drive(
         debugger,
diff --git a/contrib/kyua/engine/scheduler.hpp b/contrib/kyua/engine/scheduler.hpp
--- a/contrib/kyua/engine/scheduler.hpp
+++ b/contrib/kyua/engine/scheduler.hpp
@@ -74,6 +74,8 @@
 #include "utils/process/executor_fwd.hpp"
 #include "utils/process/status_fwd.hpp"
 
+using utils::none;
+
 namespace engine {
 namespace scheduler {
 
@@ -248,7 +250,9 @@
                                      const utils::config::tree&);
     exec_handle spawn_test(const model::test_program_ptr,
                            const std::string&,
-                           const utils::config::tree&);
+                           const utils::config::tree&,
+                           const utils::optional<utils::fs::path>& = none,
+                           const utils::optional<utils::fs::path>& = none);
     result_handle_ptr wait_any(void);
 
     result_handle_ptr debug_test(const model::test_program_ptr,
diff --git a/contrib/kyua/engine/scheduler.cpp b/contrib/kyua/engine/scheduler.cpp
--- a/contrib/kyua/engine/scheduler.cpp
+++ b/contrib/kyua/engine/scheduler.cpp
@@ -1283,7 +1283,9 @@
 scheduler::scheduler_handle::spawn_test(
     const model::test_program_ptr test_program,
     const std::string& test_case_name,
-    const config::tree& user_config)
+    const config::tree& user_config,
+    const utils::optional<utils::fs::path>& stdout_target,
+    const utils::optional<utils::fs::path>& stderr_target)
 {
     _pimpl->generic.check_interrupt();
 
@@ -1305,7 +1307,7 @@
         run_test_program(interface, test_program, test_case_name,
                          user_config),
         test_case.get_metadata().timeout(),
-        unprivileged_user);
+        unprivileged_user, stdout_target, stderr_target);
 
     const exec_data_ptr data(new test_exec_data(
         test_program, test_case_name, interface, user_config, handle.pid()));
@@ -1563,8 +1565,16 @@
     const fs::path& stdout_target,
     const fs::path& stderr_target)
 {
+    optional<fs::path> out = none;
+    optional<fs::path> err = none;
+    const model::test_case& test_case = test_program->find(test_case_name);
+    if (test_case.get_debugger() != nullptr) {
+        out = stdout_target;
+        err = stderr_target;
+    }
+
     const exec_handle exec_handle = spawn_test(
-        test_program, test_case_name, user_config);
+        test_program, test_case_name, user_config, out, err);
     result_handle_ptr result_handle = wait_any();
 
     // TODO(jmmv): We need to do this while the subprocess is alive.  This is
@@ -1574,12 +1584,12 @@
     // Unfortunately, we cannot do so.  We cannot just read and block from a
     // file, waiting for further output to appear... as this only works on pipes
     // or sockets.  We need a better interface for this whole thing.
-    {
+    if (test_case.get_debugger() == nullptr) {
         std::unique_ptr< std::ostream > output = utils::open_ostream(
             stdout_target);
         *output << utils::read_file(result_handle->stdout_file());
     }
-    {
+    if (test_case.get_debugger() == nullptr) {
         std::unique_ptr< std::ostream > output = utils::open_ostream(
             stderr_target);
         *output << utils::read_file(result_handle->stderr_file());