fix(helexa-acp): forward Dispatch::Response to its awaiting router

The catch-all on_receive_dispatch handler was applying
respond_with_error to *every* Dispatch variant, including Response.
For Response variants, that call routes the error to the
ResponseRouter for the *outgoing* request — silently overwriting
the real reply from Zed with "Internal error: not implemented yet".

Every ACP roundtrip we issue (fs/read_text_file, fs/write_text_file,
session/request_permission, terminal/*) was therefore returning an
error to the tool runner regardless of what Zed actually responded.
The model saw uniformly-failing tools, gave up, and confabulated
plausible explanations.

Fix: pattern-match the Dispatch. Response → forward to its router
via respond_with_result. Request / Notification → keep the
"not implemented yet" error response as before.

Found via debug logs showing
  WARN helexa_acp::agent: unhandled ACP message method="fs/read_text_file"
right before every tool failure.

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

crates/helexa-acp/src/agent.rs

@@ -158,11 +158,31 @@ impl Agent {
             )
             .on_receive_dispatch(
                 async move |message: Dispatch, cx: ConnectionTo<Client>| {
-                    tracing::warn!(method = ?message.method(), "unhandled ACP message");
+                    // `Dispatch` has three variants. For Request and
-                    message.respond_with_error(
+                    // Notification we want the "not implemented yet"
-                        agent_client_protocol::util::internal_error("not implemented yet"),
+                    // error response. For *Response* we MUST forward
-                        cx,
+                    // the result to its awaiting `ResponseRouter` —
-                    )
+                    // otherwise our own outbound ACP calls
+                    // (`fs/read_text_file`, `session/request_permission`,
+                    // `terminal/*`, …) get their replies silently
+                    // overwritten with whatever error we'd send a
+                    // peer for an unknown method. That's how Stage 3
+                    // tool dispatches were appearing as
+                    // "Internal error: not implemented yet" results
+                    // to the model.
+                    match message {
+                        Dispatch::Response(result, router) => router.respond_with_result(result),
+                        other => {
+                            tracing::warn!(
+                                method = ?other.method(),
+                                "unhandled ACP message"
+                            );
+                            other.respond_with_error(
+                                agent_client_protocol::util::internal_error("not implemented yet"),
+                                cx,
+                            )
+                        }
+                    }
                 },
                 agent_client_protocol::on_receive_dispatch!(),
             )