windows: extract suppress_child_console helper, sweep server-side spawns

Builds on c24727f (which suppressed the cmd.exe window in
tool::bash::build_shell_command) by extracting a reusable
`platform::suppress_child_console{,_async}` helper and applying it to
the other server-side spawns of console-subsystem programs. Same root
cause: the server runs `DETACHED_PROCESS`, has no inherited console,
and Windows allocates a fresh console window for any console-subsystem
child unless `CREATE_NO_WINDOW` (0x08000000) is set. Stdio is already
piped on every site touched, so the suppression is purely cosmetic
(no functional change to tool I/O).

Sites swept:
- src/tool/bash.rs: refactored inline flag from c24727f to call helper.
- src/server/client_actions.rs: input shell command (cmd.exe /C ...).
- src/tool/ambient.rs: git rev-parse probe in ambient runner.
- src/tool/selfdev/status.rs: git status --porcelain.
- src/tool/selfdev/build_queue.rs: build streaming command (cargo etc).
- src/agent/utils.rs: git_output (used by image side-panel hooks).

The helper is a no-op on non-Windows platforms via cfg gates.

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

Author: h5kk

src/agent/utils.rs

@@ -29,11 +29,10 @@ pub(super) fn git_state_for_dir(dir: &Path) -> Option<GitState> {
 }
 
 fn git_output(dir: &Path, args: &[&str]) -> Option<String> {
-    let output = Command::new("git")
-        .args(args)
-        .current_dir(dir)
-        .output()
-        .ok()?;
+    let mut cmd = Command::new("git");
+    cmd.args(args).current_dir(dir);
+    crate::platform::suppress_child_console(&mut cmd);
+    let output = cmd.output().ok()?;
     if !output.status.success() {
         return None;
     }

src/platform.rs

@@ -372,6 +372,41 @@ pub fn spawn_detached(cmd: &mut std::process::Command) -> std::io::Result<std::p
     cmd.spawn()
 }
 
+/// Suppress allocation of a fresh console window for a child process on Windows.
+///
+/// When the jcode server runs detached (`DETACHED_PROCESS`, no inherited
+/// console) and spawns a console-subsystem program (`cmd.exe`, `git`,
+/// `cargo`, `python`, ...), Windows allocates a brand-new console window for
+/// the child unless we set `CREATE_NO_WINDOW` (`0x08000000`). That manifests
+/// as PowerShell/cmd windows flashing up on every Bash tool call, every
+/// background git/cargo probe, etc.
+///
+/// Use this on every `std::process::Command` spawned from server-side code
+/// where the child's stdio is already piped (so a console window would be
+/// pure noise). For `tokio::process::Command`, see
+/// [`suppress_child_console_async`].
+///
+/// On non-Windows platforms this is a no-op.
+#[cfg_attr(not(windows), allow(unused_variables))]
+pub fn suppress_child_console(cmd: &mut std::process::Command) {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+        cmd.creation_flags(CREATE_NO_WINDOW);
+    }
+}
+
+/// Tokio variant of [`suppress_child_console`].
+#[cfg_attr(not(windows), allow(unused_variables))]
+pub fn suppress_child_console_async(cmd: &mut tokio::process::Command) {
+    #[cfg(windows)]
+    {
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+        cmd.creation_flags(CREATE_NO_WINDOW);
+    }
+}
+
 #[cfg(windows)]
 fn spawn_replacement_process(
     cmd: &mut std::process::Command,

src/server/client_actions.rs

@@ -39,6 +39,7 @@ fn build_input_shell_command(command: &str) -> Command {
     {
         let mut cmd = Command::new("cmd.exe");
         cmd.arg("/C").arg(command);
+        crate::platform::suppress_child_console_async(&mut cmd);
         cmd
     }
 

src/tool/ambient.rs

@@ -802,11 +802,11 @@ impl Tool for ScheduleTool {
             .working_dir
             .as_ref()
             .and_then(|wd| {
-                std::process::Command::new("git")
-                    .args(["rev-parse", "--abbrev-ref", "HEAD"])
-                    .current_dir(wd)
-                    .output()
-                    .ok()
+                let mut cmd = std::process::Command::new("git");
+                cmd.args(["rev-parse", "--abbrev-ref", "HEAD"])
+                    .current_dir(wd);
+                crate::platform::suppress_child_console(&mut cmd);
+                cmd.output().ok()
             })
             .and_then(|out| {
                 if out.status.success() {

src/tool/bash.rs

@@ -436,14 +436,9 @@ async fn handle_background_output_line(
 fn build_shell_command(cmd_str: &str) -> TokioCommand {
     #[cfg(windows)]
     {
-        // CREATE_NO_WINDOW (0x08000000): cmd.exe is a console-subsystem program;
-        // when the server runs detached (no inherited console), Windows would
-        // otherwise allocate a fresh console window for every Bash tool call,
-        // which flashes up as a stray PowerShell/cmd window. Suppressing the
-        // window has no effect on stdio (we pipe stdout/stderr above).
-        const CREATE_NO_WINDOW: u32 = 0x08000000;
         let mut cmd = TokioCommand::new("cmd.exe");
-        cmd.arg("/C").arg(cmd_str).creation_flags(CREATE_NO_WINDOW);
+        cmd.arg("/C").arg(cmd_str);
+        crate::platform::suppress_child_console_async(&mut cmd);
         cmd
     }
     #[cfg(not(windows))]

src/tool/selfdev/build_queue.rs

@@ -61,6 +61,7 @@ impl SelfDevTool {
             .kill_on_drop(true)
             .stdout(Stdio::piped())
             .stderr(Stdio::piped());
+        crate::platform::suppress_child_console_async(&mut cmd);
 
         let mut child = cmd
             .spawn()

src/tool/selfdev/status.rs

@@ -9,11 +9,10 @@ pub fn selfdev_status_output() -> Result<ToolOutput> {
     status.push_str(&format!("**Running:** jcode {}\n", env!("JCODE_VERSION")));
 
     if let Some(repo_dir) = build::get_repo_dir() {
-        let output = std::process::Command::new("git")
-            .args(["status", "--porcelain"])
-            .current_dir(&repo_dir)
-            .output()
-            .ok();
+        let mut cmd = std::process::Command::new("git");
+        cmd.args(["status", "--porcelain"]).current_dir(&repo_dir);
+        crate::platform::suppress_child_console(&mut cmd);
+        let output = cmd.output().ok();
 
         if let Some(output) = output {
             let changes: Vec<&str> = std::str::from_utf8(&output.stdout)