-	if err := json.Unmarshal([]byte(raw), &arguments); err != nil {
-		return output.ErrValidation("invalid --args (must be a JSON object): %v", err)
-	}
+	if err := json.Unmarshal([]byte(raw), &arguments); err != nil {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --args (must be a JSON object)").
+			WithParam("--args").
+			WithCause(err)
+	}

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/call.go` around lines 52 - 54, Replace the legacy
output.ErrValidation return in the json.Unmarshal failure path (the block that
checks if json.Unmarshal([]byte(raw), &arguments) returns an error) with a typed
validation error: call errs.NewValidationError(errs.SubtypeInvalidArgument,
"invalid --args (must be a JSON object): %v", err), chain .WithParam("--args")
and preserve the original error as the cause (e.g., .WithCause(err)), and return
that instead of output.ErrValidation.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/client_test.go` around lines 17 - 24, Update the error-path tests to
assert the typed problem metadata and preserved causes instead of only
inspecting *output.ExitError fields: where tests currently call asExit (the
helper shown) and then assert ExitError.Code/Detail, change them to use
errs.ProblemOf on the returned error to assert category/subtype/params, and also
use errors.As to check for a *errs.ValidationError when you need to assert Param
values; additionally assert that the original cause is preserved (use
errors.Unwrap or errors.As on the err returned by the operation to verify the
underlying cause). Apply these changes at the other affected test sites (the
regions noted at lines 96-103, 109-113, 119-121, 136-141) so each test validates
typed metadata via errs.ProblemOf and cause chaining rather than only the
ExitError shape.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/client_test.go` around lines 45 - 161, Add unit tests in
cmd/mcp/client_test.go that directly exercise the URL validation in the
httpClientFor function: create tests that call httpClientFor with invalid/unsafe
URLs (e.g., "file://", "data:", malformed URLs) and assert it returns an
error/ExitValidation, and add a test that calls httpClientFor with an http://
URL to assert HTTPS-only enforcement (expect error) and another that toggles any
existing "allow HTTP" option/flag (or context) to verify http:// is accepted
when explicitly allowed; place these new tests alongside the existing
TestJSONRPC_* tests and use the httpClientFor identifier so the test fails if
the validation behavior changes.

- h, _ := parseHeaders([]string{"Authorization: Bearer xyz"})
+ h, err := parseHeaders([]string{"Authorization: Bearer xyz"})
+ if err != nil {
+ t.Fatalf("parseHeaders: %v", err)
+ }
- if _, err := jsonRPC(context.Background(), srv.Client(), srv.URL, "tools/list", map[string]any{}, h); err != nil {
+ if _, err := jsonRPC(context.Background(), srv.Client(), srv.URL, "tools/list", map[string]any{}, h); err != nil {
 t.Fatalf("jsonRPC: %v", err)
 }

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/client_test.go` around lines 154 - 155, The test currently ignores
the error return from parseHeaders (used to build h) which can mask setup
failures and cause misleading jsonRPC errors; update the test to capture the
error (e.g., h, err := parseHeaders(...)) and immediately fail the test if err
!= nil (use t.Fatalf or t.Fatal/require for the test framework in use) before
calling jsonRPC so that parseHeaders failures are reported directly.

- return nil, output.ErrValidation("invalid --header %q (expected \"Key: Value\")", item)
+ return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --header format").WithParam("--header")
- return nil, output.ErrValidation("invalid --url: %v", err)
+ return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid MCP server URL").WithParam("--url").WithCause(err)
- return nil, output.ErrNetwork("MCP transport failed: %v", err)
+ return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "MCP transport failed").WithCause(err)

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/client.go` at line 33, The command code returns legacy
output.ErrValidation for bad header parsing; replace that with a typed errs.*
error, e.g. errs.InvalidUserInput("invalid --header %q (expected \"Key:
Value\")", item).WithParam("--header") and, if this is wrapping a lower-level
error, chain the cause via .WithCause(err); update every other legacy output.*
site in cmd/mcp/client.go (the return at the header parse, and the other
occurrences flagged in the review) to use the appropriate errs.* constructor,
include WithParam("--flag") for user-argument errors and .WithCause(...) when
there is an underlying error so typed metadata and cause propagation are
preserved.

 if errObj, ok := payload["error"]; ok {
 return nil, mcpErrorFrom(errObj)
 }
- return payload["result"], nil
+ result, ok := payload["result"]
+ if !ok {
+ return nil, output.Errorf(output.ExitAPI, "mcp_error", "MCP response missing both result and error")
+ }
+ return result, nil

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/client.go` around lines 101 - 105, The code currently returns
payload["result"] even when the "result" key is missing; change the flow to
treat a response missing both "error" and "result" as malformed. Specifically,
after checking if errObj, ok := payload["error"]; ok { return nil,
mcpErrorFrom(errObj) }, add an explicit check for the presence of "result" (e.g.
if res, ok := payload["result"]; ok { return res, nil }) and otherwise return
nil and an error (e.g. fmt.Errorf or a suitable MCP error) indicating "malformed
JSON-RPC response: missing result and error". Keep references to payload,
"error", "result", and mcpErrorFrom when implementing the fix.

- var last []byte
+ var dataLines [][]byte
 for _, line := range bytes.Split(trimmed, []byte("\n")) {
 line = bytes.TrimSpace(line)
 if rest, ok := bytes.CutPrefix(line, []byte("data:")); ok {
- last = bytes.TrimSpace(rest)
+ dataLines = append(dataLines, bytes.TrimSpace(rest))
 }
 }
- trimmed = last
+ trimmed = bytes.Join(dataLines, []byte("\n"))

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/client.go` around lines 112 - 121, The SSE parsing loop in
cmd/mcp/client.go currently overwrites the variable last for each "data:" line,
dropping earlier lines; change the loop that inspects bytes.Split(trimmed,
[]byte("\n")) to accumulate each bytes.TrimSpace(rest) into a slice or
bytes.Buffer and then set trimmed to the concatenation of those lines joined
with a single '\n' (SSE semantics) instead of only the last line; keep the
existing use of bytes.CutPrefix and trimming but replace the single-variable
last with an append-and-join approach so multiline `data:` payloads are
preserved.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.
In `@cmd/mcp/list.go` around lines 39 - 50, runList currently returns lower-layer
errors directly but must convert legacy output.Err*/output.Errorf errors into
the new typed errs.* before returning while leaving already-typed errs.*
untouched; update runList (and its error returns from parseHeaders,
httpClientFor, jsonRPC) to detect legacy output errors and wrap/translate them
into the appropriate errs.* variant (preserving message and metadata) and pass
through any errs.* errors unchanged; use a small converter helper (e.g.,
translateLegacyError(err) used inside runList) to centralize the mapping logic
so future calls (parseHeaders/httpClientFor/jsonRPC) get normalized typed
errors.