fix(acp_thread): format Qwen Code shell output nicely for Helix sync

When syncing tool call output to Helix via external_websocket_sync,
Qwen Code shell output was being shown as raw JSON.

The fix is in ToolCall::to_markdown which now:
1. First tries to format raw_output using format_shell_output
2. If that works, shows a markdown table with Command, Directory,
   Exit (code/signal), and the output in a code block
3. Falls back to content-based rendering if raw_output isn't present
   or isn't in the expected format

Fallback behavior:
- If output has "output" field but not in Qwen Code format: show as code block
- If no "output" field: show content as-is (existing behavior)

Note: This formatting is specific to Qwen Code's shell tool output
format. The built-in zed-agent uses ACP's terminal protocol which
has different rendering.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lukemarsden

crates/acp_thread/src/acp_thread.rs

@@ -345,6 +345,17 @@ impl ToolCall {
             self.label.read(cx).source(),
             self.status
         );
+
+        // Try to format raw_output nicely (e.g., Qwen Code shell output)
+        if let Some(raw_output) = &self.raw_output {
+            if let Some(formatted) = format_shell_output(raw_output) {
+                markdown.push_str(&formatted);
+                markdown.push_str("\n\n");
+                return markdown;
+            }
+        }
+
+        // Fallback to content-based rendering
         for content in &self.content {
             markdown.push_str(content.to_markdown(cx).as_str());
             markdown.push_str("\n\n");
@@ -2377,14 +2388,139 @@ fn markdown_for_raw_output(
                 cx,
             )
         })),
-        value => Some(cx.new(|cx| {
-            Markdown::new(
-                format!("```json\n{}\n```", value).into(),
-                Some(language_registry.clone()),
-                None,
-                cx,
-            )
-        })),
+        value => {
+            // Try to format shell output nicely
+            if let Some(formatted) = format_shell_output(value) {
+                Some(cx.new(|cx| {
+                    Markdown::new(
+                        formatted.into(),
+                        Some(language_registry.clone()),
+                        None,
+                        cx,
+                    )
+                }))
+            } else {
+                Some(cx.new(|cx| {
+                    Markdown::new(
+                        format!("```json\n{}\n```", value).into(),
+                        Some(language_registry.clone()),
+                        None,
+                        cx,
+                    )
+                }))
+            }
+        }
+    }
+}
+
+/// Format shell command output with a metadata table and output code block.
+/// Extracts Command, Directory, Exit Code into a table, and Output into a code block.
+/// Returns None if the output doesn't match the expected shell output format.
+fn format_shell_output(output: &serde_json::Value) -> Option<String> {
+    // Shell output comes as {"output":"Command: cd /path\nDirectory: ...\nOutput: ...\nExit Code: 0"}
+    let obj = output.as_object()?;
+    let output_str = obj.get("output")?.as_str()?;
+
+    // Parse all the shell output fields
+    let field_markers = [
+        "Command:",
+        "Directory:",
+        "Output:",
+        "Error:",
+        "Exit Code:",
+        "Signal:",
+        "Background PIDs:",
+        "Process Group PGID:",
+    ];
+
+    let mut command: Option<String> = None;
+    let mut directory: Option<String> = None;
+    let mut exit_code: Option<String> = None;
+    let mut signal: Option<String> = None;
+    let mut cmd_output = Vec::new();
+    let mut in_output_field = false;
+
+    for line in output_str.lines() {
+        // Check if this line starts a new field
+        let starts_new_field = field_markers.iter().any(|m| line.starts_with(m));
+
+        if line.starts_with("Command:") {
+            in_output_field = false;
+            command = Some(line.strip_prefix("Command:").unwrap_or("").trim().to_string());
+        } else if line.starts_with("Directory:") {
+            in_output_field = false;
+            directory = Some(line.strip_prefix("Directory:").unwrap_or("").trim().to_string());
+        } else if line.starts_with("Exit Code:") {
+            in_output_field = false;
+            exit_code = Some(line.strip_prefix("Exit Code:").unwrap_or("").trim().to_string());
+        } else if line.starts_with("Signal:") {
+            in_output_field = false;
+            signal = Some(line.strip_prefix("Signal:").unwrap_or("").trim().to_string());
+        } else if line.starts_with("Output:") {
+            in_output_field = true;
+            let value = line.strip_prefix("Output:").unwrap_or("").trim();
+            if !value.is_empty() {
+                cmd_output.push(value.to_string());
+            }
+        } else if starts_new_field {
+            in_output_field = false;
+        } else if in_output_field {
+            cmd_output.push(line.to_string());
+        }
+    }
+
+    let full_output = cmd_output.join("\n");
+    let has_output = !full_output.is_empty() && full_output != "(empty)";
+
+    // Build the formatted result with a markdown table for metadata
+    let mut result = String::new();
+
+    // Build table rows
+    let mut table_rows = Vec::new();
+    if let Some(cmd) = &command {
+        table_rows.push(format!("| Command | `{}` |", cmd));
+    }
+    if let Some(dir) = &directory {
+        table_rows.push(format!("| Directory | `{}` |", dir));
+    }
+    // Combine exit code and signal into one field
+    match (&exit_code, &signal) {
+        (Some(code), Some(sig)) => {
+            table_rows.push(format!("| Exit | {} (signal: {}) |", code, sig));
+        }
+        (Some(code), None) => {
+            table_rows.push(format!("| Exit | {} |", code));
+        }
+        (None, Some(sig)) => {
+            table_rows.push(format!("| Exit | signal: {} |", sig));
+        }
+        (None, None) => {}
+    }
+
+    // Add table if we have metadata
+    if !table_rows.is_empty() {
+        result.push_str("| | |\n|---|---|\n");
+        result.push_str(&table_rows.join("\n"));
+    }
+
+    // Add output code block
+    if has_output {
+        if !result.is_empty() {
+            result.push_str("\n\n");
+        }
+        result.push_str(&format!("```\n{}\n```", full_output));
+    }
+
+    if result.is_empty() {
+        // Fallback: if we have an "output" field but couldn't parse it in the
+        // expected format, just show the raw output in a code block
+        if !output_str.is_empty() {
+            Some(format!("```\n{}\n```", output_str))
+        } else {
+            None
+        }
+    } else {
+        Some(result)
     }
 }