feat: OpenAI, Anthropic, and native-Ollama providers + media pipeline

Phase 3:
- provider/openai: Chat Completions for OpenAI + compat endpoints (SSE
  streaming with by-index tool-call assembly, response_format json_schema,
  legacy max_tokens option, reasoning_effort)
- provider/anthropic: Messages API (tool_use/tool_result, GA structured
  output via output_config.format, full SSE event parser, 529 transient)
- provider/ollama: one native /api/chat client behind the ollama,
  ollama-cloud, and foreman built-ins (presets; NDJSON streaming tolerant
  of foreman's buffered single-object responses; object tool arguments;
  format-schema structured output; think mapping)
- media/: capability normalization (sniff, downscale, transcode, byte
  ladder, ErrUnsupported), wired into the chain executor per target with
  penalty-free advance past incapable elements
- registry: real provider + scheme wiring, WithHTTPClient option, required
  env-foreman TLS chat round-trip test
- ADR-0009 multimodal strategy, ADR-0010 tools/structured mapping; README
  matrix + CLAUDE.md synced

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

builtin.go

@@ -3,8 +3,12 @@ package majordomo
 import (
 	"context"
 	"fmt"
+	"net/http"
 
 	"gitea.stevedudenhoeffer.com/steve/majordomo/llm"
+	"gitea.stevedudenhoeffer.com/steve/majordomo/provider/anthropic"
+	"gitea.stevedudenhoeffer.com/steve/majordomo/provider/ollama"
+	"gitea.stevedudenhoeffer.com/steve/majordomo/provider/openai"
 )
 
 // Built-in provider names. Real client implementations land per-phase
@@ -20,23 +24,78 @@ const (
 )
 
 // registerBuiltins installs the built-in providers and env-DSN scheme
-// factories into a fresh registry.
-func registerBuiltins(r *Registry) {
-	stub := func(kind string) SchemeFactory {
-		return func(name string, dsn DSN) (llm.Provider, error) {
-			return &stubProvider{name: name, kind: kind, baseURL: dsn.BaseURL(), token: dsn.Token}, nil
+// factories into a fresh registry. httpClient, when non-nil, is used by
+// every provider and factory the registry itself constructs.
+func registerBuiltins(r *Registry, httpClient *http.Client) {
+	ollamaOpts := func(extra ...ollama.Option) []ollama.Option {
+		if httpClient != nil {
+			extra = append(extra, ollama.WithHTTPClient(httpClient))
 		}
+		return extra
 	}
 
-	for _, kind := range []string{
-		ProviderOpenAI, ProviderAnthropic, ProviderGoogle,
-		ProviderOllama, ProviderOllamaCloud, ProviderForeman,
-	} {
-		r.providers[kind] = &stubProvider{name: kind, kind: kind}
-		r.schemes[kind] = stub(kind)
+	// Native-Ollama family: three names over one client with presets.
+	r.providers[ProviderOllama] = ollama.Local(ollamaOpts()...)
+	r.providers[ProviderOllamaCloud] = ollama.Cloud(ollamaOpts()...)
+	// foreman has no default URL; the no-DSN registration resolves but
+	// errors on use with a clear message (use an LLM_* DSN or
+	// ollama.Foreman(...) + RegisterProvider).
+	r.providers[ProviderForeman] = ollama.New(ollamaOpts(ollama.WithName(ProviderForeman))...)
+
+	ollamaScheme := func(name string, dsn DSN) (llm.Provider, error) {
+		return ollama.New(ollamaOpts(
+			ollama.WithName(name),
+			ollama.WithBaseURL(dsn.BaseURL()),
+			ollama.WithToken(dsn.Token),
+		)...), nil
 	}
+	r.schemes[ProviderOllama] = ollamaScheme
+	r.schemes[ProviderOllamaCloud] = ollamaScheme
+	r.schemes[ProviderForeman] = ollamaScheme
+
+	// OpenAI and OpenAI-compatible endpoints.
+	openaiOpts := func(extra ...openai.Option) []openai.Option {
+		if httpClient != nil {
+			extra = append(extra, openai.WithHTTPClient(httpClient))
+		}
+		return extra
+	}
+	r.providers[ProviderOpenAI] = openai.New(openaiOpts()...)
+	r.schemes[ProviderOpenAI] = func(name string, dsn DSN) (llm.Provider, error) {
+		return openai.New(openaiOpts(
+			openai.WithName(name),
+			openai.WithBaseURL(dsn.BaseURL()),
+			openai.WithAPIKey(dsn.Token),
+		)...), nil
+	}
+
+	// Anthropic and Anthropic-compatible endpoints.
+	anthropicOpts := func(extra ...anthropic.Option) []anthropic.Option {
+		if httpClient != nil {
+			extra = append(extra, anthropic.WithHTTPClient(httpClient))
+		}
+		return extra
+	}
+	r.providers[ProviderAnthropic] = anthropic.New(anthropicOpts()...)
+	r.schemes[ProviderAnthropic] = func(name string, dsn DSN) (llm.Provider, error) {
+		return anthropic.New(anthropicOpts(
+			anthropic.WithName(name),
+			anthropic.WithBaseURL(dsn.BaseURL()),
+			anthropic.WithAPIKey(dsn.Token),
+		)...), nil
+	}
+
+	// Google lands in its own phase; stub until then.
+	r.providers[ProviderGoogle] = &stubProvider{name: ProviderGoogle, kind: ProviderGoogle}
+	r.schemes[ProviderGoogle] = stubScheme(ProviderGoogle)
 	// "gemini" is an alternate scheme for the Google provider.
-	r.schemes["gemini"] = stub(ProviderGoogle)
+	r.schemes["gemini"] = stubScheme(ProviderGoogle)
+}
+
+func stubScheme(kind string) SchemeFactory {
+	return func(name string, dsn DSN) (llm.Provider, error) {
+		return &stubProvider{name: name, kind: kind, baseURL: dsn.BaseURL(), token: dsn.Token}, nil
+	}
 }
 
 // stubProvider stands in for a provider implementation that lands in a