Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@pkg/runner/messages_test.go`:
- Around line 11-151: Refactor the individual tests in messages_test.go
(TestOptionsMessagesField, TestResultMessagesField, TestDryRunInfoMessageCount,
TestMessageTypeCanBeConstructed, TestToProviderMessages,
TestFromProviderMessage, TestRoundTripConversion and the remaining cases
mentioned) into table-driven tests using slices of structs with fields like
name, input, want (and any helper fields for expected ToolCalls/ToolResults),
then iterate the table with t.Run to assert expectations; keep the same
assertions (checking Options.Messages, Result.Messages, DryRunInfo.MessageCount,
Message fields, toProviderMessages/fromProviderMessage round-trips and
ToolCalls/ToolResults) but centralized in looped subtests to follow the
[]struct{name,input,want} pattern mandated by the testing guidelines.

In `@pkg/runner/messages.go`:
- Around line 11-15: Remove the package-level mutable map validRoles and replace
it with a side-effect-free helper predicate (e.g., an unexported
isValidRole(role string) bool) that uses a local switch or an immutable literal
lookup to validate roles; update all places that reference validRoles to call
isValidRole instead so you eliminate global mutable state while preserving the
same checks.

In `@pkg/runner/result_test.go`:
- Around line 63-164: The two one-off tests TestResultMarshalJSON_WithMessages
and TestResultMarshalJSON_WithMessagesAndToolCalls should be merged into a
single table-driven test (e.g., TestResultMarshalJSON) using a []struct{name
string, input Result, validate func(parsed map[string]interface{}) error} (or a
want struct describing expected message counts and fields) and iterating over
cases with t.Run(tc.name, func(t *testing.T){...}); locate the existing Result
instances and JSON marshal/unmarshal/assert logic in those functions and move
them into table entries, then run the same marshal/unmarshal flow and call the
per-case validate or compare fields (messages, tool_calls, tool_results, ids,
contents, is_error) to assert expected values.

In `@pkg/runner/run_test.go`:
- Around line 292-338: Refactor the standalone pre-built message tests
(including TestRun_PreBuiltMessages_Streaming and the other cases in the 589-957
range) into a table-driven test using a []struct{name string, opts Options,
mockResponses []testutil.MockLLMResponse, wantContent string, wantInputTokens
int, wantOutputTokens int, wantStdoutContains string} (or similar) and iterate
with for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { ... }) };
inside each subtest set up the mock server using tt.mockResponses, call Run with
tt.opts, assert result fields against tt.want* and assert stdout contains
tt.wantStdoutContains when applicable (preserve the existing streaming test
behavior), and extract repeated setup code (setupTestEnv, newMockStdoutStderr,
env vars) into small helpers to keep each table entry concise.