feat(hooks): surface post_tool verification output to the model (verify-into-fix)

post_tool steering hooks ran but their output was discarded — `run_post_tool_hooks`
only logged errors — and `run_hook_command` dropped stderr and returned `Ok(None)`
on a non-zero exit. So a `cargo build` / `pytest` / lint hook configured to verify
the agent's edits produced output the model never saw, leaving the documented
verify-into-fix self-correction loop unbound.

- `run_hook_command` gains `capture_failure`: for post_tool hooks it pipes stderr
  and returns the combined stdout+stderr **even on a non-zero exit** (prefixed with
  the exit status) — a failing build/test is exactly what must reach the model.
  pre_tool / user_prompt directive hooks pass `false` and keep the legacy contract
  (stderr dropped, non-zero exit -> `Ok(None)` -> proceed). Both pipes are now drained
  concurrently with `wait()` under one timeout, so a hook that fills a pipe buffer
  can't deadlock (previously stdout was read only after `wait()` returned).
- `read_bounded` is generic over the pipe type, truncates (instead of erroring) on
  overflow so a verbose hook still yields a usable prefix, and decodes lossily so
  non-UTF-8 compiler/test output isn't dropped wholesale.
- `run_post_tool_hooks` returns the combined hook output; the tool dispatch appends
  it to the tool result via `append_post_tool_output`, preserving Ok/Err polarity, so
  the model sees the verification output alongside the tool's own result.

Tests: post_tool captures a failing hook's stdout+stderr with its exit code, captures
success stdout, and returns None when a hook is silent; plus an Ok/Err-polarity test
for the appender.

Author: efecnc

src/agent/mod.rs

@@ -287,6 +287,16 @@ fn extract_exec_command(args: &Value) -> Option<String> {
         .filter(|s| !s.is_empty())
 }
 
+/// Append post_tool verification-hook output (build/test/lint results) to a tool result, preserving
+/// Ok/Err polarity so the model sees it alongside the tool's own output and can self-correct.
+fn append_post_tool_output(res: Result<String, String>, hook_out: &str) -> Result<String, String> {
+    let note = format!("\n\n[post-tool hook]\n{hook_out}");
+    match res {
+        Ok(s) => Ok(format!("{s}{note}")),
+        Err(s) => Err(format!("{s}{note}")),
+    }
+}
+
 fn should_require_shell_approval(command: &str, patterns: &[String]) -> bool {
     let lower = command.to_ascii_lowercase();
     patterns.iter().any(|p| lower.contains(p))
@@ -398,6 +408,22 @@ mod code_exec_gate_tests {
         // ...but a destructive one does.
         assert!(code_exec_requires_approval("exec", "rm -rf /tmp/x", &patterns));
     }
+
+    #[test]
+    fn append_post_tool_output_preserves_polarity() {
+        // Appends to an Ok result, staying Ok (verification output is informational).
+        let ok = append_post_tool_output(Ok("applied".into()), "tests passed");
+        assert_eq!(
+            ok.as_deref(),
+            Ok("applied\n\n[post-tool hook]\ntests passed")
+        );
+        // Appends to an Err result, staying Err (the tool itself failed).
+        let err = append_post_tool_output(Err("boom".into()), "lint output");
+        assert_eq!(
+            err.as_ref().err().map(String::as_str),
+            Some("boom\n\n[post-tool hook]\nlint output")
+        );
+    }
 }
 
 fn hook_observe_telemetry(
@@ -697,6 +723,7 @@ async fn execute_tool_call_with_activity(
             }
         };
 
+        let mut post_tool_output: Option<String> = None;
         if let Some(ref hc) = runtime.hook_tool_ctx {
             if let Some(st) = &hc.steering {
                 let res_for_hook = match &completed {
@@ -710,7 +737,7 @@ async fn execute_tool_call_with_activity(
                     metadata: runtime.inbound_metadata.as_ref(),
                     is_subagent: runtime.is_subagent,
                 };
-                run_post_tool_hooks(
+                post_tool_output = run_post_tool_hooks(
                     st.as_ref(),
                     &tool_name,
                     tool_call_id_for_hooks.as_deref(),
@@ -733,6 +760,12 @@ async fn execute_tool_call_with_activity(
                         return ToolExecutionFinished::Waiting(ticket_id.to_string());
                     }
                 }
+                // Append any post_tool verification-hook output so the model sees test/lint/build
+                // results (including failures) and can self-correct. Ok/Err polarity is preserved.
+                let res = match post_tool_output {
+                    Some(hook_out) => append_post_tool_output(res, &hook_out),
+                    None => res,
+                };
                 ToolExecutionFinished::Completed(res)
             }
             None => {