proto: give the generated C++ Dispatcher a real error channel (P1, 1.4.0)

DAEMON's daemon/docs/proto-requests-m1.md P1: velox::proto::Dispatcher's
on_* methods returned Result<T> = expected<T, ParseError>, and dispatch()
mapped every handler error to -32603 InternalError. A handler had no way to
return -32010 (download.get not-found), -32011 (download.add invalid-path)
or -32013 (probe-failed) with their data payloads -- three error fixtures a
conformant server must satisfy were unreachable, blocking DAEMON's
"conformance as a server" M1 DoD.

Two error channels now, kept separate on purpose:
  - parse: Result<T> / ParseError -- dispatch() failing to turn the wire into
    typed params. Always -32602, always structural.
  - handler: HandlerResult<T> / HandlerError -- a handler deciding the request
    can't be fulfilled. Carries any ErrorCode + message + free-form data.

    struct HandlerError {
        ErrorCode code{ErrorCode::InternalError};  // bare {} is a valid -32603
        std::string message;
        nlohmann::json data = nullptr;             // straight into the error's data
    };
    template <class T> using HandlerResult = std::expected<T, HandlerError>;

dispatch()'s handler branch is now
  make_error(id, r.error().code, r.error().message, r.error().data)
instead of a hard-coded InternalError. -32001/-32002/-32003 stay the server
layer's to raise around dispatch(), as DAEMON already does.

Verified end to end against the real dispatch() path: a handler returning
TaskNotFound/InvalidPath/ProbeFailed produces -32010/-32011/-32013 with the
data object intact, and a bare HandlerError{} still yields a clean -32603
with no data field. The `= nullptr` on the member (not `{nullptr}`) matters:
brace-init of nlohmann::json from nullptr is the array [null], not JSON null.

FixtureDispatcher regenerated to HandlerResult; conformance_main.cpp only
inspects dispatch()'s JSON and needed no change. TS side is untouched beyond
the version string -- no server Dispatcher is generated there.

P2 also handled: session.hello.version-mismatch's data.expected was a stale
"1.0.0"; now $any, with a note that the error-fixture compare is on `code`
only so a server echoing kProtocolVersion there is fine.

Version: minor, 1.3.0 -> 1.4.0. Wire is byte-identical (no schema, fixture,
or OpenRPC change) but every Dispatcher implementer must swap Result ->
HandlerResult on regen, and the bump is how lanes are told to. Not an ADR:
one lane consumes this binding, it's the one that asked, and the shape is
the one they proposed. Answered in contracts/proto-answers-daemon-m1.md.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_012fgjnqFCS5h5L7gZTZo3rV

contracts/codegen/gen_cpp.py

@@ -7,6 +7,13 @@ Design notes that matter to the CORE and DAEMON lanes:
   not used and not emitted. Parsing goes through `velox::proto::parse<T>(json)` which
   returns `std::expected<T, ParseError>`, so a malformed frame from the wire is an ordinary
   value the RPC loop handles, not a throw unwinding through the transfer path.
+* **Two error channels, kept separate.** `parse<T>() -> Result<T>` (i.e. `expected<T,
+  ParseError>`) is the wire failing to become typed params — always `-32602`, always
+  structural. A `Dispatcher::on_*` handler returns `HandlerResult<T>` (i.e. `expected<T,
+  HandlerError>`), which carries any contract error code plus a free-form `data` object,
+  so a handler can answer `-32010` `{taskId}`, `-32011` `{path}`, `-32013` `{httpStatus}`
+  and so on. `dispatch()` forwards the handler's code/message/data straight into the
+  JSON-RPC error object.
 * **Serialisation is ADL `to_json`,** so `nlohmann::json j = task;` works as expected.
   Only the outbound direction is allowed to be implicit; the wire is never trusted.
 * **`libveloxproto`, not `libveloxcore`.** This code includes nlohmann/json, which
@@ -285,16 +292,37 @@ def emit_header(c: Contract) -> str:
           "nlohmann::json make_result(const nlohmann::json& id, nlohmann::json result);",
           "nlohmann::json make_notification(Event e, nlohmann::json params);",
           "",
+          "/// A handler's own failure — as opposed to ParseError, which is the wire failing",
+          "/// to become typed params. Carries any contract error code, a message, and a",
+          "/// free-form `data` object that goes straight into the JSON-RPC error's `data`",
+          "/// field: `{\"taskId\": ...}` for TaskNotFound, `{\"path\": ...}` for InvalidPath,",
+          "/// `{\"httpStatus\": ...}` for ProbeFailed. `code` defaults to InternalError so a",
+          "/// handler that sets only a message still produces a valid error response.",
+          "///",
+          "/// -32001/-32002/-32003 are the server layer's to raise around dispatch(), not a",
+          "/// handler's: they are decided before or without reference to method params.",
+          "struct HandlerError {",
+          "    ErrorCode code{ErrorCode::InternalError};",
+          "    std::string message;",
+          "    // `= nullptr`, not `{nullptr}`: brace-init of nlohmann::json from nullptr",
+          "    // yields the array [null], not JSON null. make_error() drops a null data.",
+          "    nlohmann::json data = nullptr;",
+          "};",
+          "",
+          "template <class T>",
+          "using HandlerResult = std::expected<T, HandlerError>;",
+          "",
           "/// One virtual per method. The daemon implements this; `dispatch` below does the",
           "/// envelope handling, the transport check and the parameter parsing, so a handler",
-          "/// only ever sees a validated, typed params struct.",
+          "/// only ever sees a validated, typed params struct. Return `std::unexpected(",
+          "/// HandlerError{...})` to answer with a specific error code and data.",
           "class Dispatcher {",
           "public:",
           "    virtual ~Dispatcher() = default;",
           ""]
     for m in c.methods:
         o += doc_comment(m.doc, "    ")
-        o.append(f"    virtual Result<{cpp_type(m.result)}> {handler_name(m.name)}(const {cpp_type(m.params)}& params) = 0;")
+        o.append(f"    virtual HandlerResult<{cpp_type(m.result)}> {handler_name(m.name)}(const {cpp_type(m.params)}& params) = 0;")
         o.append("")
     o += ["};", "",
           "/// Parse one JSON-RPC request, route it, and return the response to write back.",
@@ -579,8 +607,7 @@ def emit_dispatch(c: Contract) -> list[str]:
             '                              nlohmann::json{{"path", p.error().path}});',
             f"        auto r = handler.{handler_name(m.name)}(*p);",
             "        if (!r)",
-            "            return make_error(id, ErrorCode::InternalError, r.error().message,",
-            '                              nlohmann::json{{"path", r.error().path}});',
+            "            return make_error(id, r.error().code, r.error().message, r.error().data);",
             "        nlohmann::json out = *r;",
             "        return make_result(id, std::move(out));",
             "    }",