fix(agent): normalize empty successful tool output

crates/zeroclaw-runtime/src/agent/loop_.rs

@@ -3730,6 +3730,26 @@ mod tests {
         assert_eq!(invocations.load(Ordering::SeqCst), 1);
     }
 
+    #[tokio::test]
+    async fn execute_one_tool_normalizes_empty_success_output() {
+        let observer = NoopObserver;
+        let tools: Vec<Box<dyn Tool>> = vec![Box::new(EmptySuccessTool)];
+
+        let outcome = execute_one_tool(
+            "empty_success",
+            serde_json::json!({}),
+            &tools,
+            None,
+            &observer,
+            None,
+        )
+        .await
+        .expect("empty successful tool output should still execute");
+
+        assert!(outcome.success);
+        assert_eq!(outcome.output, "(no output)");
+        assert!(outcome.error_reason.is_none());
+    }
     use crate::observability::NoopObserver;
     use tempfile::TempDir;
     use zeroclaw_api::provider::{ProviderCapabilities, StreamChunk, StreamEvent, StreamOptions};
@@ -4163,6 +4183,37 @@ mod tests {
         }
     }
 
+    struct EmptySuccessTool;
+
+    #[async_trait]
+    impl Tool for EmptySuccessTool {
+        fn name(&self) -> &str {
+            "empty_success"
+        }
+
+        fn description(&self) -> &str {
+            "Returns success with no stdout"
+        }
+
+        fn parameters_schema(&self) -> serde_json::Value {
+            serde_json::json!({
+                "type": "object",
+                "properties": {}
+            })
+        }
+
+        async fn execute(
+            &self,
+            _args: serde_json::Value,
+        ) -> anyhow::Result<crate::tools::ToolResult> {
+            Ok(crate::tools::ToolResult {
+                success: true,
+                output: String::new(),
+                error: None,
+            })
+        }
+    }
+
     struct RecordingArgsTool {
         name: String,
         recorded_args: Arc<Mutex<Vec<serde_json::Value>>>,

crates/zeroclaw-runtime/src/agent/tool_execution.rs

@@ -90,8 +90,13 @@ pub async fn execute_one_tool(
                 success: r.success,
             });
             if r.success {
+                let normalized_output = if r.output.is_empty() {
+                    "(no output)"
+                } else {
+                    &r.output
+                };
                 Ok(ToolExecutionOutcome {
-                    output: scrub_credentials(&r.output),
+                    output: scrub_credentials(normalized_output),
                     success: true,
                     error_reason: None,
                     duration,