refactor(runtime): extract tool execution into pkg/runtime/toolexec

[dgageot]

Goal

Make tool execution easier to read, test, and build on top of, by extracting it from pkg/runtime into a self-contained pkg/runtime/toolexec sub-package — following the existing pkg/runtime/compactor and pkg/runtime/delegator precedents.

pkg/runtime/tool_dispatch.go shrinks from 442 LOC of orchestration to 123 LOC of runtime adapters, and the new package is fully unit-testable without spinning up a runtime.

Public API

Zero changes. runtime.Runtime, runtime.ResumeRequest, runtime.ResumeType, the ResumeType* constants, runtime.LocalRuntime.Resume(...), the Run/RunStream/Steer/FollowUp flow — all byte-for-byte identical. Resume types are now type aliases over toolexec.

Commits (each one builds, lints, and tests cleanly)

#	Commit	What moved
1	extract pure tool-execution utilities into pkg/runtime/toolexec	Loop detector + per-tool model override (already pure helpers)
2	move hooks-input helpers into toolexec	parseToolInput, newHooksInput (+ tests)
3	extract approval-pipeline decision into toolexec.Decide	The yolo → checkers → read-only → default ladder, as a pure Decide function with full unit-test matrix
4	extract Dispatcher into pkg/runtime/toolexec	toolexec.Dispatcher + Emitter / HookDispatcher interfaces, with 10 dispatcher unit tests covering routing, approval outcomes, and batch-cancellation synthesis
5	simplify dispatcher with per-call value type	Internal cleanup: per-call *call value type to cut 7-arg method signatures, plus 4 review fixes (see below)

What lives in pkg/runtime/toolexec now

pkg/runtime/toolexec/
├── doc.go                      # explains the package's purpose
├── loop_detector.go            # consecutive-duplicate detector
├── model_override.go           # per-toolset model-override resolution
├── hooks_input.go              # ParseToolInput, NewHooksInput
├── permissions.go              # Decide(yolo, checkers, name, args, readOnly)
├── dispatcher.go               # Dispatcher + Process(ctx, sess, calls, tools, em)
└── *_test.go                   # 30+ unit tests, no runtime needed

Design highlights

• Dispatcher carries its dependencies as struct fields: Tracer, Hooks, Resume, AgentFor, Permissions, Handlers. No method-on-LocalRuntime hidden state.
• Emitter is a 5-method interface covering only the dispatch-shaped events (ToolCall, ToolCallResponse, ToolCallConfirmation, HookBlocked, MessageAdded). Anything else stays runtime-private.
• HookDispatcher is a 2-method interface so the dispatcher doesn't depend on the runtime's hook registry directly.
• Approval policy is pure: toolexec.Decide(...) → PermissionDecision{Outcome, Reason, Source}. Every log message the original code emitted is preserved via the Reason field, with no behavior change.
• Per-call state lives in a *call value type so helper methods take (ctx) or (ctx, runTool) instead of 7 arguments.
• ctx is never stored in a struct — passed explicitly to every method that needs it (idiomatic Go, satisfies containedctx).

Validation

• go build ./... ✅
• go vet ./... ✅
• mise lint (golangci-lint + custom 800-file Go cop + go mod tidy --diff) → 0 issues ✅
• mise test → all packages pass, no failures ✅
• go test -race -count=1 ./pkg/runtime/... ✅

Reviewing tip

Each commit is independently reviewable. For the cleanest reading order:

1. Start with commit 1 to see the package's seed (pure utilities).
2. Skim commits 2–3 for the small, mechanical extractions.
3. Spend most time on commit 4 (the Dispatcher extraction) — that's where the architectural shape lives.
4. Commit 5 is internal cleanup of commit 4; the diff is mostly mechanical (per-call struct rather than wide signatures).

Suggested follow-ups (not in this PR)

• Move ToolHandlerFunc and r.toolMap registration into toolexec so the runtime stops needing to bind handlers to a chan Event per stream.
• Move pkg/runtime/event.go constructors to pkg/runtime/events, then drop the chanEmitter adapter in favour of a direct chan Event implementation of Emitter.