fix(platform): 未捕获的有界运行必须继承 stdio,而不是先缓冲后回放

自审发现的真回归。`run_exec_deadline` 是 `mcpp test` 非 JSON 模式跑测试二进制
的路径,原本继承调用方的 stdio —— 输出实时出现,且子进程的 stdout 是终端。
把它改成「捕获后在结束时一次性回放」有两个后果:

  1. 长测试的输出全部憋到退出才出现,恰好抵消了 `mcpp test` 可观察性那一整
     轮工作(「只有子进程输出、mcpp 一行没有」正是缓冲问题的指纹);
  2. 子进程的 stdout 变成管道而非终端,gtest 之类会静默关掉彩色输出。

两侧启动器现在共用一条契约:`sink == nullptr` 表示「不捕获」,子进程直接继承
调用方的 stdio,但**仍然有界**。POSIX 侧不建管道也不设 dup2 file action;
Windows 侧不设 STARTF_USESTDHANDLES,也不加 CREATE_NO_WINDOW(未捕获的运行
本来就是要给人看的)。`dispatch_bounded` 多一个 capture 形参把这个选择传下去。

Author: speak-agent

src/platform/process.cppm

@@ -582,11 +582,15 @@ struct BoundedOutcome {
     std::string output;
 };
 
+// `capture == false` runs the child on the caller's stdio: live output, and a
+// real terminal for anything that checks. `run_exec_deadline` needs that; the
+// capturing variants need the pipe.
 BoundedOutcome dispatch_bounded(
     const std::vector<std::string>& argv,
     const std::vector<std::pair<std::string, std::string>>& extraEnv,
     std::string_view cwd,
-    std::chrono::milliseconds deadline)
+    std::chrono::milliseconds deadline,
+    bool capture)
 {
     BoundedOutcome outcome;
 
@@ -603,10 +607,14 @@ BoundedOutcome dispatch_bounded(
     const char* cwdArg = cwdStore.empty() ? nullptr : cwdStore.c_str();
     const auto ms = static_cast<long long>(deadline.count());
 
-    // One sink for both, appending into the outcome's own buffer.
-    const auto sink = +[](void* ctx, const char* data, unsigned long len) {
-        static_cast<std::string*>(ctx)->append(data, len);
-    };
+    // One sink for both, appending into the outcome's own buffer. Null when the
+    // caller wants the child on its own stdio.
+    using Sink = void (*)(void*, const char*, unsigned long);
+    const Sink sink = capture
+        ? +[](void* ctx, const char* data, unsigned long len) {
+              static_cast<std::string*>(ctx)->append(data, len);
+          }
+        : nullptr;
 
     if constexpr (mcpp::platform::is_windows) {
         const auto cmd = windows_command_from_argv(argv);
@@ -639,12 +647,13 @@ int run_exec_deadline(const std::vector<std::string>& argv,
     if (deadline.count() <= 0) return run_exec(argv, extraEnv);
     if (argv.empty()) return 127;
 
-    auto r = dispatch_bounded(argv, extraEnv, {}, deadline);
+    // capture=false: identical stdio behaviour to `run_exec` — the child writes
+    // straight to our terminal as it goes. `mcpp test`'s non-JSON path runs
+    // test binaries through here, and buffering their output until exit would
+    // undo the observability work that path exists for (and would hide gtest's
+    // colors by making its stdout a pipe).
+    auto r = dispatch_bounded(argv, extraEnv, {}, deadline, /*capture=*/false);
     if (!r.supported) return run_exec(argv, extraEnv);
-    // `run_exec` streams to the terminal; the bounded launchers capture. The
-    // output is replayed here rather than dropped — a bounded run that must
-    // ALSO stream live has no implementation and, today, no caller.
-    if (!r.output.empty()) std::fputs(r.output.c_str(), stdout);
     if (timed_out) *timed_out = r.timed_out;
     return r.exit_code;
 }
@@ -661,7 +670,7 @@ RunResult capture_exec_deadline(
     RunResult result;
     if (argv.empty()) { result.exit_code = 127; return result; }
 
-    auto r = dispatch_bounded(argv, extraEnv, cwd, deadline);
+    auto r = dispatch_bounded(argv, extraEnv, cwd, deadline, /*capture=*/true);
     // `supported == false` means the child COULD NOT BE SPAWNED — not that it
     // ran and failed. Reporting those the same way would hide a launcher
     // problem behind a child's exit code, so fall back to the untimed path and

src/platform/unix/bounded_process.cppm

@@ -72,8 +72,12 @@ using OutputSink = void (*)(void* ctx, const char* data, unsigned long len);
 // `cwd` may be null. A non-positive `deadlineMs` is rejected with
 // supported=false: "no bound" belongs on the caller's untimed path.
 //
-// When `sink` is null the output is discarded but the child is still bounded —
-// that is the `run_exec_deadline` shape.
+// A NULL `sink` means "do not capture": the child INHERITS the caller's stdio
+// and is still bounded. That is not an optimization — it is the
+// `run_exec_deadline` contract. Routing an uncaptured run through a pipe would
+// (a) delay every line until the child exits, which is the opposite of what a
+// bounded `mcpp test` run is for, and (b) make the child's stdout a pipe
+// rather than a terminal, so gtest and friends silently drop their colors.
 DeadlineRun capture_with_deadline(const char* const* argvEntries,
                                   unsigned long      argvCount,
                                   const char* const* envEntries,
@@ -149,8 +153,9 @@ DeadlineRun capture_with_deadline(const char* const* argvEntries,
         cargv.push_back(const_cast<char*>(argvEntries[i]));
     cargv.push_back(nullptr);
 
-    int fds[2];
-    if (::pipe(fds) != 0) return out;
+    const bool capture = (sink != nullptr);
+    int fds[2] = {-1, -1};
+    if (capture && ::pipe(fds) != 0) return out;
 
     posix_spawn_file_actions_t fa;
     ::posix_spawn_file_actions_init(&fa);
@@ -159,44 +164,50 @@ DeadlineRun capture_with_deadline(const char* const* argvEntries,
     // silently move where a build program's relative writes go.
     if (cwd && *cwd)
         ::posix_spawn_file_actions_addchdir_np(&fa, cwd);
-    ::posix_spawn_file_actions_adddup2(&fa, fds[1], 1);
-    ::posix_spawn_file_actions_adddup2(&fa, fds[1], 2);
-    ::posix_spawn_file_actions_addclose(&fa, fds[0]);
-    ::posix_spawn_file_actions_addclose(&fa, fds[1]);
+    if (capture) {
+        ::posix_spawn_file_actions_adddup2(&fa, fds[1], 1);
+        ::posix_spawn_file_actions_adddup2(&fa, fds[1], 2);
+        ::posix_spawn_file_actions_addclose(&fa, fds[0]);
+        ::posix_spawn_file_actions_addclose(&fa, fds[1]);
+    }
+    // else: no file actions for stdio at all — the child inherits ours, which
+    // keeps its output live AND keeps it a terminal.
 
     pid_t pid = 0;
     int sp = ::posix_spawnp(&pid, cargv[0], &fa, nullptr, cargv.data(), envp.data());
     ::posix_spawn_file_actions_destroy(&fa);
-    ::close(fds[1]);
-    if (sp != 0) { ::close(fds[0]); return out; }
+    if (capture) ::close(fds[1]);
+    if (sp != 0) { if (capture) ::close(fds[0]); return out; }
 
     // Non-blocking reads so the deadline is still checked while the child is
     // quiet. A blocking read on a silent, hung child is exactly the hang this
     // whole mechanism exists to stop.
-    ::fcntl(fds[0], F_SETFL, ::fcntl(fds[0], F_GETFL, 0) | O_NONBLOCK);
+    if (capture)
+        ::fcntl(fds[0], F_SETFL, ::fcntl(fds[0], F_GETFL, 0) | O_NONBLOCK);
 
     const auto until = std::chrono::steady_clock::now()
                      + std::chrono::milliseconds(deadlineMs);
     std::array<char, 4096> buf{};
     bool  killed = false;
     int   status = 0;
 
-    for (;;) {
+    auto drain = [&]() -> bool {
+        if (!capture) return false;
         ssize_t n;
-        bool drained = false;
+        bool any = false;
         while ((n = ::read(fds[0], buf.data(), buf.size())) > 0) {
-            if (sink) sink(ctx, buf.data(),
-                           static_cast<unsigned long>(n));
-            drained = true;
+            sink(ctx, buf.data(), static_cast<unsigned long>(n));
+            any = true;
         }
-        if (drained) continue;
+        return any;
+    };
+
+    for (;;) {
+        if (drain()) continue;
 
         pid_t r = ::waitpid(pid, &status, WNOHANG);
         if (r == pid) {
-            // Drain the tail: the child is gone, so this terminates.
-            while ((n = ::read(fds[0], buf.data(), buf.size())) > 0)
-                if (sink) sink(ctx, buf.data(),
-                               static_cast<unsigned long>(n));
+            while (drain()) { /* tail — the child is gone, so this ends */ }
             break;
         }
         if (r < 0 && errno != EINTR && errno != ECHILD) break;
@@ -209,7 +220,7 @@ DeadlineRun capture_with_deadline(const char* const* argvEntries,
         struct timespec ts{0, 20'000'000};   // 20ms
         ::nanosleep(&ts, nullptr);
     }
-    ::close(fds[0]);
+    if (capture) ::close(fds[0]);
 
     out.exit_code = normalize_status(status);
     out.timed_out = killed;

src/platform/windows/bounded_process.cppm

@@ -76,6 +76,12 @@ struct DeadlineRun {
 };
 
 // Receives stdout+stderr as it arrives. Called on the calling thread only.
+//
+// A NULL sink means "do not capture": the child inherits the caller's stdio and
+// is still bounded. Same contract as the POSIX peer, and for the same reason —
+// an uncaptured bounded run (`run_exec_deadline`) must keep its output LIVE and
+// keep the child's stdout a console, or console-detecting children drop their
+// colors and every line waits for exit.
 using OutputSink = void (*)(void* ctx, const char* data, unsigned long len);
 
 // `commandLine` is already quoted for CreateProcess (callers pass the output
@@ -176,16 +182,20 @@ DeadlineRun capture_with_deadline(const char*        commandLine,
     DeadlineRun out;
     if (deadlineMs <= 0 || !commandLine || !*commandLine) return out;
 
+    const bool capture = (sink != nullptr);
+
     SECURITY_ATTRIBUTES sa{};
     sa.nLength        = sizeof(sa);
     sa.bInheritHandle = TRUE;
 
     Handle readEnd, writeEnd;
-    if (!::CreatePipe(&readEnd.h, &writeEnd.h, &sa, 0)) return out;
-    // Only the WRITE end may cross into the child. An inheritable read end
-    // there would keep the pipe alive past the child's exit and the drain
-    // below would never see EOF.
-    if (!::SetHandleInformation(readEnd.h, HANDLE_FLAG_INHERIT, 0)) return out;
+    if (capture) {
+        if (!::CreatePipe(&readEnd.h, &writeEnd.h, &sa, 0)) return out;
+        // Only the WRITE end may cross into the child. An inheritable read end
+        // there would keep the pipe alive past the child's exit and the drain
+        // below would never see EOF.
+        if (!::SetHandleInformation(readEnd.h, HANDLE_FLAG_INHERIT, 0)) return out;
+    }
 
     Handle job;
     job.h = ::CreateJobObjectA(nullptr, nullptr);
@@ -198,21 +208,27 @@ DeadlineRun capture_with_deadline(const char*        commandLine,
     }
 
     STARTUPINFOA si{};
-    si.cb         = sizeof(si);
-    si.dwFlags    = STARTF_USESTDHANDLES;
-    si.hStdOutput = writeEnd.h;
-    si.hStdError  = writeEnd.h;
-    si.hStdInput  = ::GetStdHandle(STD_INPUT_HANDLE);
+    si.cb = sizeof(si);
+    if (capture) {
+        si.dwFlags    = STARTF_USESTDHANDLES;
+        si.hStdOutput = writeEnd.h;
+        si.hStdError  = writeEnd.h;
+        si.hStdInput  = ::GetStdHandle(STD_INPUT_HANDLE);
+    }
+    // else: no STARTF_USESTDHANDLES — the child inherits our console.
 
     PROCESS_INFORMATION pi{};
     std::string cmdBuf(commandLine);        // CreateProcessA may modify it
     auto envBlock = environment_block(envEntries, envCount);
 
     // CREATE_SUSPENDED so the child joins the job BEFORE it can spawn
     // anything — a grandchild created in that gap would escape the kill.
+    // CREATE_NO_WINDOW only when capturing: an uncaptured run is meant to be
+    // seen, and suppressing the console for it would hide the output this
+    // branch exists to show.
     BOOL ok = ::CreateProcessA(
         nullptr, cmdBuf.data(), nullptr, nullptr, /*bInheritHandles=*/TRUE,
-        CREATE_SUSPENDED | CREATE_NO_WINDOW,
+        CREATE_SUSPENDED | (capture ? CREATE_NO_WINDOW : 0u),
         envBlock.data(),
         (cwd && *cwd) ? cwd : nullptr,
         &si, &pi);
@@ -233,6 +249,7 @@ DeadlineRun capture_with_deadline(const char*        commandLine,
     bool killed = false;
 
     auto drain_available = [&]() -> bool {
+        if (!capture) return false;
         DWORD avail = 0;
         if (!::PeekNamedPipe(readEnd.h, nullptr, 0, nullptr, &avail, nullptr))
             return false;