feat(forge): add tool_silent mode propagation for headless/ACP execution

Add a `tool_silent` flag to `ChatRequest` that propagates through the entire
tool execution chain down to the command executor. When `true`, shell
tool output is suppressed on stdout to protect JSON-RPC transports.

- chat_request: add `tool_silent: bool` field (default false)
- orch: add `tool_silent` field, propagate to ToolCallContext
- app: forward ChatRequest.tool_silent to Orchestrator
- agent_executor: inherit silent flag from parent ToolCallContext
- executor: clean up TODO(acp), add inline comment

Signed-off-by: ssfdust <ssfdust@gmail.com>
Co-Authored-By: ForgeCode <noreply@forgecode.dev>
Co-Authored-By: DeepSeek <contact@deepseek.com>

Author: 3 people

crates/forge_app/src/agent_executor.rs

@@ -75,12 +75,12 @@ impl<S: Services + EnvironmentInfra<Config = forge_config::ForgeConfig>> AgentEx
                 .await?;
             conversation
         };
-        // Execute the request through the ForgeApp
+        // Execute the request through the ForgeApp, propagating silent mode.
         let app = crate::ForgeApp::new(self.services.clone());
         let mut response_stream = app
             .chat(
                 agent_id.clone(),
-                ChatRequest::new(Event::new(task.clone()), conversation.id),
+                ChatRequest::new(Event::new(task.clone()), conversation.id).tool_silent(ctx.silent),
             )
             .await?;
 

crates/forge_app/src/app.rs

@@ -180,7 +180,8 @@ impl<S: Services + EnvironmentInfra<Config = forge_config::ForgeConfig>> ForgeAp
         .error_tracker(ToolErrorTracker::new(max_tool_failure_per_turn))
         .tool_definitions(tool_definitions)
         .models(models)
-        .hook(Arc::new(hook));
+        .hook(Arc::new(hook))
+        .tool_silent(chat.tool_silent);
 
         // Create and return the stream
         let stream = MpscStream::spawn(

crates/forge_app/src/orch.rs

@@ -26,6 +26,13 @@ pub struct Orchestrator<S> {
     error_tracker: ToolErrorTracker,
     hook: Arc<Hook>,
     config: forge_config::ForgeConfig,
+    /// When `true`, shell tool output is suppressed on stdout to avoid
+    /// contaminating the ACP JSON-RPC transport.
+    ///
+    /// Set from [`ChatRequest::tool_silent`] during `ForgeApp::chat()`. This field
+    /// is consumed in [`Orchestrator::run()`] when constructing the
+    /// [`ToolCallContext`].
+    tool_silent: bool,
 }
 
 impl<S: AgentService + EnvironmentInfra<Config = forge_config::ForgeConfig>> Orchestrator<S> {
@@ -45,6 +52,7 @@ impl<S: AgentService + EnvironmentInfra<Config = forge_config::ForgeConfig>> Orc
             models: Default::default(),
             error_tracker: Default::default(),
             hook: Arc::new(Hook::default()),
+            tool_silent: false,
         }
     }
 
@@ -262,11 +270,11 @@ impl<S: AgentService + EnvironmentInfra<Config = forge_config::ForgeConfig>> Orc
 
         // Retrieve the number of requests allowed per tick.
         let max_requests_per_turn = self.agent.max_requests_per_turn;
-        // TODO(acp): when running in ACP stdio mode, chain `.silent(true)`
-        // so that shell tool output is suppressed on stdout (see
-        // ToolCallContext and tool_executor).
-        let tool_context =
-            ToolCallContext::new(self.conversation.metrics.clone()).sender(self.sender.clone());
+        // Propagate silent mode to ToolCallContext.
+        // See designs/acp-silent-mode-propagation.md.
+        let tool_context = ToolCallContext::new(self.conversation.metrics.clone())
+            .sender(self.sender.clone())
+            .silent(self.tool_silent);
 
         while !should_yield {
             // Set context for the current loop iteration

crates/forge_domain/src/chat_request.rs

@@ -8,10 +8,14 @@ use crate::{ConversationId, Event};
 pub struct ChatRequest {
     pub event: Event,
     pub conversation_id: ConversationId,
+    /// When `true`, shell tool output is suppressed on stdout (routed to
+    /// `io::sink()`) to protect the ACP JSON-RPC transport.
+    /// See `designs/acp-silent-mode-propagation.md`.
+    pub tool_silent: bool,
 }
 
 impl ChatRequest {
     pub fn new(content: Event, conversation_id: ConversationId) -> Self {
-        Self { event: content, conversation_id }
+        Self { event: content, conversation_id, tool_silent: false }
     }
 }

crates/forge_infra/src/executor.rs

@@ -108,13 +108,8 @@ impl ForgeCommandExecutorService {
         let mut stdout_pipe = child.stdout.take();
         let mut stderr_pipe = child.stderr.take();
 
-        // Stream the output of the command to stdout and stderr concurrently.
-        //
-        // TODO(acp): when `silent` is true (ACP stdio mode), output is
-        // streamed to io::sink() so that raw command output does not
-        // contaminate the ACP JSON-RPC transport on stdout. The captured
-        // output is still returned via CommandOutput for the ACP
-        // notification channel.
+        // Suppress stdout in headless mode to avoid contaminating the JSON-RPC
+        // transport.
         let (status, stdout_buffer, stderr_buffer) = if silent {
             tokio::try_join!(
                 child.wait(),