agent: trace tool retry attempts

.github/loop/PRIORITIES.md

@@ -21,9 +21,8 @@ changes, architectural rewrites. Those go to the human.
 
 ## Work queue (ranked)
 
-1. **Make agent-flow fail on missing onboarding side effects** ([#4328](https://github.com/micro/go-micro/issues/4328)) — Now-phase hardening and developer trust both depend on the 0→hero/provider harness failing when the services → agents → workflows contract is not actually satisfied. The recent deploy dry-run verifier closed the documented deploy-boundary gap; the next highest-value gap is preventing a live-provider agent-flow run from printing success while required workspace/notification side effects are absent.
-2. **Stabilize plan-delegate after unfinished delegation** ([#4322](https://github.com/micro/go-micro/issues/4322)) — This is the remaining Now-phase conformance failure in the multi-agent 0→hero path: real services and durable flow state can advance, but the delegated notification step may remain unfinished after partial side effects. Stabilizing that recovery keeps plan/delegate from being a brittle demo seam and protects the service → agent → workflow lifecycle under live-provider variance.
-3. **Trace agent RunInfo in OpenTelemetry spans** ([#4315](https://github.com/micro/go-micro/issues/4315)) — Once the live harness failures above fail deterministically and recover reliably, the highest Next-phase operability gap is connecting existing run metadata to traces so real agent runs can be debugged across steps, tool calls, delegation, failures, services, and flows without inventing a new surface.
+1. **Emit OpenTelemetry spans from agent run history** ([#4218](https://github.com/micro/go-micro/issues/4218)) — streaming coverage shipped via #4226, so close the next agentic-depth operability seam called out by the roadmap and blog: `RunInfo`/history and production traces should tell the same story for model steps, tool calls, retries, delegation, and failures, making `micro inspect` and deployed traces feel like one debugging path.
+2. **Add examples wayfinding index for first-agent adoption** ([#4223](https://github.com/micro/go-micro/issues/4223)) — keep developer adoption weighted with internal hardening: the README and getting-started guide now have a stronger first-agent path, but examples remain spread across docs, CLI output, and directories. A single CI-guarded examples map should make the smallest no-secret agent, the 0→hero support app, and next interop examples discoverable from one place.
 
 _Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
 architecture-review pass._

CHANGELOG.md

@@ -16,37 +16,12 @@ next version when it ships.
 
 ## [Unreleased]
 
-### Added
-- **Provider HTTP retry signals** — provider failures now preserve HTTP status and `Retry-After` details so retry classification and backoff can respond to rate limits and unavailable providers. (`ai/`)
-
-### Fixed
-- **Stream fallback memory** — unsupported streaming attempts no longer leave stale duplicate user turns before fallback paths continue with non-streaming agent calls. (`agent/`)
-- **Function-style text tool calls** — agent fallback parsing now recognizes provider replies that render tools as function-style calls, including nested JSON arguments. (`agent/`)
-- **Plan/delegate notify recovery** — plan-delegate recovery now waits for recovered notify side effects and routes retries through the communications agent that owns the notification. (`internal/harness/`)
-
-### Documentation
-- **First-agent docs wayfinding guard** — the local harness now includes a focused no-network check for first-agent and 0→hero docs links. (`Makefile`, `internal/harness/`)
-
----
-
-## [6.3.18] - July 2026
-
 ### Added
 - **StreamAsk close cancellation** — agent streaming calls now cancel promptly when their runner closes, avoiding orphaned stream work. (`agent/`)
 - **Agent resume pending helper** — agent durability now has a focused helper for resuming pending checkpointed runs. (`agent/`)
-- **Agent tool retry tracing** — agent traces now include tool retry attempts for easier debugging of retry/fallback behavior. (`agent/`)
-- **Shared-broker universe harness** — the universe harness now runs against the shared broker path, improving coverage of the same runtime wiring used by services, agents, and workflows. (`internal/harness/`)
 
 ### Fixed
 - **Plan/delegate retry idempotency** — agent retries now preserve side-effect and notification dedupe across conformance retry paths, including completion and owner-notification edge cases. (`agent/`, `internal/harness/`)
-- **AtlasCloud text tool calls** — AtlasCloud fallback handling now recovers more text-rendered tool calls from OpenAI-compatible responses. (`ai/atlascloud/`, `agent/`)
-- **OpenAI-compatible text tool calls** — OpenAI-compatible providers now recover text-rendered tool calls more reliably. (`agent/`)
-- **AtlasCloud multi-step follow-ups** — AtlasCloud tool fallback handling now continues multi-step tool follow-up paths more reliably. (`ai/atlascloud/`, `agent/`)
-
-### Documentation
-- **Agent debugging quickcheck** — docs now include a focused quickcheck path for first-agent debugging. (`internal/website/docs/`)
-- **Website first-agent examples map** — website docs now link the maintained examples wayfinding map for the first-agent route. (`internal/website/docs/`)
-- **Examples wayfinding index** — examples docs now provide a central map for first-agent, support, and interop examples. (`examples/`, `internal/website/docs/`)
 
 ---
 

Makefile

@@ -8,7 +8,7 @@ LDFLAGS = -X $(GIT_IMPORT).BuildDate=$(BUILD_DATE) -X $(GIT_IMPORT).GitCommit=$(
 # GORELEASER_DOCKER_IMAGE = ghcr.io/goreleaser/goreleaser-cross:v1.25.7
 GORELEASER_DOCKER_IMAGE = ghcr.io/goreleaser/goreleaser:latest
 
-.PHONY: test test-race test-coverage harness docs-wayfinding install-smoke provider-conformance-mock provider-conformance lint fmt install-tools proto clean help gorelease-dry-run gorelease-dry-run-docker
+.PHONY: test test-race test-coverage harness install-smoke provider-conformance-mock provider-conformance lint fmt install-tools proto clean help gorelease-dry-run gorelease-dry-run-docker
 
 # Default target
 help:
@@ -19,7 +19,6 @@ help:
 	@echo "  make test-coverage - Run tests with coverage"
 	@echo "  make lint          - Run linter"
 	@echo "  make harness       - Run deterministic getting-started and end-to-end harnesses"
-	@echo "  make docs-wayfinding - Verify first-agent docs wayfinding links resolve locally"
 	@echo "  make install-smoke - Verify the local install.sh and first-run CLI smoke path"
 	@echo "  make provider-conformance-mock - Run cross-provider harness with deterministic mock provider"
 	@echo "  make provider-conformance - Run harnesses against configured live providers"
@@ -50,19 +49,12 @@ test-coverage:
 # This mirrors the default CI path so local dogfooding catches scaffold,
 # run/chat/inspect, and 0→hero regressions before a PR is opened.
 harness:
-	$(MAKE) docs-wayfinding
 	$(MAKE) install-smoke
 	go test ./cmd/micro/cli/new -run TestZeroToOne -count=1
 	./internal/harness/zero-to-hero-ci/run.sh
 	go run ./internal/harness/agent-flow
 	$(MAKE) provider-conformance-mock
 
-# Verify the README and website first-agent/0→hero wayfinding links resolve to
-# maintained local docs and examples. This is a focused no-network guard for the
-# developer-adoption on-ramp.
-docs-wayfinding:
-	go test ./internal/harness/zero-to-hero-ci -run 'TestFirstAgentWayfindingDocs|TestFirstAgentWayfindingLinkTargetsResolve' -count=1
-
 # Verify the documented install script and first-run CLI command boundaries without
 # provider keys or network access.
 install-smoke:
@@ -118,3 +110,4 @@ gorelease-dry-run:
 		-w /$(NAME) \
 		$(GORELEASER_DOCKER_IMAGE) \
 		--clean --verbose --skip=publish,validate --snapshot
+

README.md

@@ -94,16 +94,15 @@ walkable agent path in this order:
 2. `micro agent demo` — print the provider-free first-agent demo command and next docs steps from the installed CLI.
 3. `micro examples` — print the maintained provider-free runnable examples in copy/paste order.
 4. `micro zero-to-hero` — print the maintained one-command no-secret lifecycle harness and runnable examples.
-5. [Examples wayfinding index](examples/INDEX.md) — choose the smallest no-secret first-agent, maintained [0→hero support reference](examples/support/), and next interop examples from one map.
-6. [Smallest first-agent example](examples/first-agent/) — run one service-backed agent with a mock model and no provider key.
-7. [No-secret first-agent transcript](internal/website/docs/guides/no-secret-first-agent.md) — run the
+5. [Smallest first-agent example](examples/first-agent/) — run one service-backed agent with a mock model and no provider key.
+6. [No-secret first-agent transcript](internal/website/docs/guides/no-secret-first-agent.md) — run the
    maintained support agent with a mock model and see services → agents → workflows succeed without a key.
-8. [Your First Agent](internal/website/docs/guides/your-first-agent.md) — build a
+7. [Your First Agent](internal/website/docs/guides/your-first-agent.md) — build a
    service-backed agent and talk to it with `micro chat`.
-9. [Debugging your agent](internal/website/docs/guides/debugging-agents.md) — use
+8. [Debugging your agent](internal/website/docs/guides/debugging-agents.md) — use
    `micro inspect agent <name>`, run history, memory, and provider checks when the first
    conversation does something unexpected.
-10. [0→hero Reference](internal/website/docs/guides/zero-to-hero.md) — complete the
+9. [0→hero Reference](internal/website/docs/guides/zero-to-hero.md) — complete the
    services → agents → workflows loop with scaffold, run, chat, inspect, flow
    history, and deploy dry-run commands that match the maintained harness.
 

agent/agent.go

@@ -99,12 +99,6 @@ type agentImpl struct {
 	// holding mu. Tool execution updates it so resumed runs can reuse
 	// completed tool results without replaying side effects.
 	currentRun *flow.Run
-
-	// delegateCalls collapses concurrent equivalent delegate tool calls so a
-	// provider replay cannot fan out duplicate delegated side effects before the
-	// durable delegate-result cache is written.
-	delegateMu    sync.Mutex
-	delegateCalls map[string]*delegateCall
 }
 
 // New creates a new Agent.
@@ -227,18 +221,16 @@ func (a *agentImpl) Stream(ctx context.Context, message string) (ai.Stream, erro
 	if err != nil {
 		return nil, fmt.Errorf("discover tools: %w", err)
 	}
-	messages := append([]ai.Message(nil), a.mem.Messages()...)
-	messages = append(messages, ai.Message{Role: "user", Content: message})
+	a.mem.Add("user", message)
 	stream, err := a.model.Stream(ctx, &ai.Request{
 		Prompt:       message,
 		SystemPrompt: a.buildPrompt(),
 		Tools:        toolList,
-		Messages:     messages,
+		Messages:     a.mem.Messages(),
 	})
 	if err != nil {
 		return nil, err
 	}
-	a.mem.Add("user", message)
 	return &memoryRecordingStream{stream: stream, memory: a.mem}, nil
 }
 

agent/builtin.go

@@ -27,11 +27,6 @@ const (
 	toolHumanInput = "request_input"
 )
 
-type delegateCall struct {
-	done chan struct{}
-	res  ai.ToolResult
-}
-
 // builtinTools returns the tool definitions exposed to the model in
 // addition to the agent's scoped service tools.
 func builtinTools() []ai.Tool {
@@ -590,7 +585,7 @@ func (a *agentImpl) handleHumanInput(call ai.ToolCall) ai.ToolResult {
 // if 'to' names a registered agent, it is called via RPC. Otherwise an
 // ephemeral sub-agent is created with a fresh, isolated context, asked
 // the subtask, and its reply returned.
-func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res ai.ToolResult) {
+func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 	input := call.Input
 	task, _ := input["task"].(string)
 	if task == "" {
@@ -601,12 +596,6 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res a
 		return cached
 	}
 
-	key := delegateResultKey(to, task)
-	if cached, ok := a.joinDelegateCall(ctx, call.ID, key); ok {
-		return cached
-	}
-	defer func() { a.finishDelegateCall(key, res) }()
-
 	// An external agent on another framework, addressed by A2A URL.
 	if strings.HasPrefix(to, "http://") || strings.HasPrefix(to, "https://") {
 		reply, err := a2a.NewClient(to).Send(ctx, task)
@@ -658,38 +647,6 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res a
 	return a.storeDelegateResult(call.ID, to, task, map[string]any{"reply": resp.Reply})
 }
 
-func (a *agentImpl) joinDelegateCall(ctx context.Context, id, key string) (ai.ToolResult, bool) {
-	a.delegateMu.Lock()
-	if a.delegateCalls == nil {
-		a.delegateCalls = map[string]*delegateCall{}
-	}
-	if inFlight := a.delegateCalls[key]; inFlight != nil {
-		a.delegateMu.Unlock()
-		select {
-		case <-ctx.Done():
-			return errResult(id, ctx.Err().Error()), true
-		case <-inFlight.done:
-			return withToolResultID(inFlight.res, id), true
-		}
-	}
-	a.delegateCalls[key] = &delegateCall{done: make(chan struct{})}
-	a.delegateMu.Unlock()
-	return ai.ToolResult{}, false
-}
-
-func (a *agentImpl) finishDelegateCall(key string, res ai.ToolResult) {
-	a.delegateMu.Lock()
-	inFlight := a.delegateCalls[key]
-	if inFlight == nil {
-		a.delegateMu.Unlock()
-		return
-	}
-	inFlight.res = res
-	delete(a.delegateCalls, key)
-	close(inFlight.done)
-	a.delegateMu.Unlock()
-}
-
 func (a *agentImpl) cachedDelegateResult(id, to, task string) (ai.ToolResult, bool) {
 	recs, err := a.stateStore().Read(delegateResultKey(to, task))
 	if err != nil || len(recs) == 0 {
@@ -709,11 +666,6 @@ func (a *agentImpl) storeDelegateResult(id, to, task string, out map[string]any)
 	return ai.ToolResult{ID: id, Value: out, Content: string(b)}
 }
 
-func withToolResultID(res ai.ToolResult, id string) ai.ToolResult {
-	res.ID = id
-	return res
-}
-
 func delegateResultKey(to, task string) string {
 	fp := normalizeDelegateTarget(to) + "\x00" + normalizeDelegateTask(task)
 	sum := sha256.Sum256([]byte(fp))

agent/builtin_test.go

@@ -3,9 +3,7 @@ package agent
 import (
 	"context"
 	"encoding/json"
-	"sync"
 	"testing"
-	"time"
 
 	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/registry"
@@ -209,44 +207,6 @@ func TestDelegateResultCacheReusesLaunchReadinessParaphrases(t *testing.T) {
 	}
 }
 
-func TestDelegateInFlightReplaysShareFirstResult(t *testing.T) {
-	a := New(Name("planner"), WithStore(store.NewMemoryStore())).(*agentImpl)
-	key := delegateResultKey("comms", "Notify owner@acme.com that the launch plan is ready")
-	if _, joined := a.joinDelegateCall(context.Background(), "delegate-1", key); joined {
-		t.Fatal("first delegate call unexpectedly joined an existing in-flight call")
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-	results := make(chan ai.ToolResult, 1)
-	go func() {
-		defer wg.Done()
-		res, joined := a.joinDelegateCall(context.Background(), "delegate-2", key)
-		if !joined {
-			t.Error("replayed delegate call did not join the in-flight call")
-			return
-		}
-		results <- res
-	}()
-
-	select {
-	case res := <-results:
-		t.Fatalf("replayed delegate returned before first call finished: %+v", res)
-	case <-time.After(25 * time.Millisecond):
-	}
-
-	first := ai.ToolResult{ID: "delegate-1", Content: `{"reply":"Notified owner@acme.com."}`}
-	a.finishDelegateCall(key, first)
-	wg.Wait()
-	replayed := <-results
-	if replayed.ID != "delegate-2" {
-		t.Fatalf("replayed result ID = %q, want delegate-2", replayed.ID)
-	}
-	if replayed.Content != first.Content {
-		t.Fatalf("replayed content = %q, want %q", replayed.Content, first.Content)
-	}
-}
-
 func TestIsAgent(t *testing.T) {
 	reg := registry.NewMemoryRegistry()
 

agent/stream_test.go

@@ -243,29 +243,6 @@ func TestResumeStreamAskDoesNotReplayCompletedTool(t *testing.T) {
 	}
 }
 
-func TestAgentStreamDoesNotRecordUserWhenProviderStreamingUnsupported(t *testing.T) {
-	fakeStream = func(ctx context.Context, opts ai.Options, req *ai.Request) (ai.Stream, error) {
-		if len(req.Messages) == 0 || req.Messages[len(req.Messages)-1].Role != "user" || req.Messages[len(req.Messages)-1].Content != "stream fallback" {
-			t.Fatalf("stream request messages = %+v, want pending user message", req.Messages)
-		}
-		return nil, ai.ErrStreamingUnsupported
-	}
-	defer func() { fakeStream = nil }()
-
-	mem := NewInMemory(8)
-	a := newTestAgent(Name("stream-fallback"), WithMemory(mem), WithTool("echo", "echo text", nil, func(context.Context, map[string]any) (string, error) {
-		return "ok", nil
-	}))
-
-	_, err := a.Stream(context.Background(), "stream fallback")
-	if !errors.Is(err, ai.ErrStreamingUnsupported) {
-		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
-	}
-	if got := mem.Messages(); len(got) != 0 {
-		t.Fatalf("memory after unsupported stream = %+v, want no recorded messages", got)
-	}
-}
-
 type unsupportedAgent struct{}
 
 func (unsupportedAgent) Name() string                                      { return "unsupported" }

agent/text_tool_calls.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"html"
 	"regexp"
 	"strings"
 
@@ -13,16 +12,14 @@ import (
 
 var fencedJSONBlock = regexp.MustCompile("(?s)```(?:json)?\\s*(.*?)\\s*```")
 var taggedToolCallBlock = regexp.MustCompile(`(?s)<[^<>]*(?:tool_call|tool_calls|function=)[^<>]*>(.*?)</[^<>]*>`)
-var singleTaggedToolCall = regexp.MustCompile(`(?s)<(tool_call\b[^<>]*|[^<>]*function\s*=[^<>]*)>(.*?)</[^<>]*>`)
-var taggedToolNameAttr = regexp.MustCompile(`(?i)(?:function|name|tool)\s*=\s*["\']?([^"\'\s>]+)`)
+var singleTaggedToolCall = regexp.MustCompile(`(?s)<(tool_call\b[^<>]*|[^<>]*function=[^<>]*)>(.*?)</[^<>]*>`)
 
 type textToolCall struct {
 	ID        string         `json:"id"`
 	Name      string         `json:"name"`
 	Tool      string         `json:"tool"`
 	Input     map[string]any `json:"input"`
-	Arguments any            `json:"arguments"`
-	Function  *textToolCall  `json:"function"`
+	Arguments map[string]any `json:"arguments"`
 }
 
 // executeTextToolCalls is a compatibility fallback for providers that return a
@@ -93,7 +90,6 @@ func textToolCallKey(call ai.ToolCall) string {
 }
 
 func parseTextToolCalls(text string, tools []ai.Tool) []ai.ToolCall {
-	text = html.UnescapeString(text)
 	allowed := textToolNames(tools)
 	if len(allowed) == 0 {
 		return nil
@@ -102,9 +98,6 @@ func parseTextToolCalls(text string, tools []ai.Tool) []ai.ToolCall {
 	if calls := decodeTaggedTextToolCalls(text, allowed); len(calls) > 0 {
 		return calls
 	}
-	if calls := decodeFunctionTextToolCalls(text, allowed); len(calls) > 0 {
-		return calls
-	}
 	for _, candidate := range jsonCandidates(text) {
 		if calls := decodeTextToolCalls(candidate, allowed); len(calls) > 0 {
 			return calls
@@ -183,7 +176,14 @@ func collectTextToolCalls(v any, allowed map[string]string) []ai.ToolCall {
 			return collectTextToolCalls(nested, allowed)
 		}
 		call := mapToTextToolCall(x)
-		name, input := textToolCallNameAndInput(call)
+		name := call.Name
+		if name == "" {
+			name = call.Tool
+		}
+		input := call.Input
+		if input == nil {
+			input = call.Arguments
+		}
 		if name == "" || allowed[name] == "" || input == nil {
 			return nil
 		}
@@ -197,40 +197,6 @@ func collectTextToolCalls(v any, allowed map[string]string) []ai.ToolCall {
 	}
 }
 
-func textToolCallNameAndInput(call textToolCall) (string, map[string]any) {
-	name := call.Name
-	if name == "" {
-		name = call.Tool
-	}
-	input := call.Input
-	if input == nil {
-		input = textToolArguments(call.Arguments)
-	}
-	if call.Function != nil {
-		fnName, fnInput := textToolCallNameAndInput(*call.Function)
-		if name == "" {
-			name = fnName
-		}
-		if input == nil {
-			input = fnInput
-		}
-	}
-	return name, input
-}
-
-func textToolArguments(raw any) map[string]any {
-	switch args := raw.(type) {
-	case map[string]any:
-		return args
-	case string:
-		var input map[string]any
-		if err := json.Unmarshal([]byte(args), &input); err == nil {
-			return input
-		}
-	}
-	return nil
-}
-
 func decodeTaggedTextToolCalls(text string, allowed map[string]string) []ai.ToolCall {
 	var out []ai.ToolCall
 	for _, match := range singleTaggedToolCall.FindAllStringSubmatch(text, -1) {
@@ -264,130 +230,17 @@ func decodeTaggedTextToolCalls(text string, allowed map[string]string) []ai.Tool
 }
 
 func taggedToolName(tag string) string {
-	match := taggedToolNameAttr.FindStringSubmatch(tag)
-	if len(match) < 2 {
-		return ""
-	}
-	return strings.Trim(match[1], `"'`)
-}
-
-func decodeFunctionTextToolCalls(text string, allowed map[string]string) []ai.ToolCall {
-	var out []ai.ToolCall
-	for alias, canonical := range allowed {
-		for _, body := range functionCallBodies(text, alias) {
-			var input map[string]any
-			if err := json.Unmarshal([]byte(body), &input); err != nil || input == nil {
-				continue
+	for _, marker := range []string{"function=", "name=", "tool="} {
+		if idx := strings.Index(tag, marker); idx >= 0 {
+			name := strings.TrimSpace(tag[idx+len(marker):])
+			name = strings.Trim(name, `"'`)
+			if end := strings.IndexAny(name, " \t\r\n>"); end >= 0 {
+				name = name[:end]
 			}
-			out = append(out, ai.ToolCall{
-				ID:    fmt.Sprintf("text-call-%s", strings.ReplaceAll(alias, ".", "_")),
-				Name:  canonical,
-				Input: input,
-			})
+			return strings.Trim(name, `"'`)
 		}
 	}
-	return out
-}
-
-func functionCallBodies(text, name string) []string {
-	if name == "" {
-		return nil
-	}
-	var bodies []string
-	for searchFrom := 0; searchFrom < len(text); {
-		idx := strings.Index(text[searchFrom:], name)
-		if idx < 0 {
-			break
-		}
-		start := searchFrom + idx
-		open := start + len(name)
-		if !isFunctionCallBoundary(text, start, open) {
-			searchFrom = start + len(name)
-			continue
-		}
-		bodyStart := open + 1
-		bodyEnd, ok := balancedJSONObjectEnd(text, bodyStart)
-		if !ok {
-			searchFrom = bodyStart
-			continue
-		}
-		bodies = append(bodies, strings.TrimSpace(text[bodyStart:bodyEnd]))
-		searchFrom = bodyEnd + 1
-	}
-	return bodies
-}
-
-func isFunctionCallBoundary(text string, start, open int) bool {
-	if open >= len(text) || text[open] != '(' {
-		return false
-	}
-	if start > 0 {
-		prev := text[start-1]
-		if prev == '_' || prev == '.' || prev == '-' || prev == '$' || ('0' <= prev && prev <= '9') || ('A' <= prev && prev <= 'Z') || ('a' <= prev && prev <= 'z') {
-			return false
-		}
-	}
-	for i := open + 1; i < len(text); i++ {
-		switch text[i] {
-		case ' ', '\n', '\r', '\t':
-			continue
-		case '{':
-			return true
-		default:
-			return false
-		}
-	}
-	return false
-}
-
-func balancedJSONObjectEnd(text string, start int) (int, bool) {
-	for start < len(text) {
-		switch text[start] {
-		case ' ', '\n', '\r', '\t':
-			start++
-		case '{':
-			depth := 0
-			inString := false
-			escaped := false
-			for i := start; i < len(text); i++ {
-				c := text[i]
-				if inString {
-					if escaped {
-						escaped = false
-					} else if c == '\\' {
-						escaped = true
-					} else if c == '"' {
-						inString = false
-					}
-					continue
-				}
-				switch c {
-				case '"':
-					inString = true
-				case '{':
-					depth++
-				case '}':
-					depth--
-					if depth == 0 {
-						for j := i + 1; j < len(text); j++ {
-							switch text[j] {
-							case ' ', '\n', '\r', '\t':
-								continue
-							case ')':
-								return i + 1, true
-							default:
-								return 0, false
-							}
-						}
-					}
-				}
-			}
-			return 0, false
-		default:
-			return 0, false
-		}
-	}
-	return 0, false
+	return ""
 }
 
 func firstNestedToolCalls(m map[string]any) (any, bool) {

agent/text_tool_calls_test.go

@@ -56,93 +56,3 @@ func TestParseTextToolCallsCreateAliasForAddTool(t *testing.T) {
 		t.Fatalf("title = %v, want Design", got)
 	}
 }
-
-func TestParseTextToolCallsOpenAICompatibleFunctionArgumentsString(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `<tool_call>{"id":"call-2","type":"function","function":{"name":"delegate","arguments":"{\"task\":\"summarize the conformance marker\",\"to\":\"blocked-reviewer\"}"}}</tool_call>`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 1 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
-	}
-	if calls[0].Name != "delegate" {
-		t.Fatalf("call name = %q, want delegate", calls[0].Name)
-	}
-	if got := calls[0].Input["task"]; got != "summarize the conformance marker" {
-		t.Fatalf("task = %v, want summarize the conformance marker", got)
-	}
-	if got := calls[0].Input["to"]; got != "blocked-reviewer" {
-		t.Fatalf("to = %v, want blocked-reviewer", got)
-	}
-}
-
-func TestParseTextToolCallsTaggedMarkupWithSpacedNameAttribute(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `<tool_call name = "delegate">{"task":"summarize the conformance marker","to":"blocked-reviewer"}</tool_call>`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 1 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
-	}
-	if calls[0].Name != "delegate" {
-		t.Fatalf("call name = %q, want delegate", calls[0].Name)
-	}
-	if got := calls[0].Input["to"]; got != "blocked-reviewer" {
-		t.Fatalf("to = %v, want blocked-reviewer", got)
-	}
-}
-
-func TestParseTextToolCallsHTMLEscapedTaggedMarkup(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `&lt;tool_call name=&quot;delegate&quot;&gt;{"task":"summarize the conformance marker","to":"blocked-reviewer"}&lt;/tool_call&gt;`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 1 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
-	}
-	if calls[0].Name != "delegate" {
-		t.Fatalf("call name = %q, want delegate", calls[0].Name)
-	}
-	if got := calls[0].Input["task"]; got != "summarize the conformance marker" {
-		t.Fatalf("task = %v, want summarize the conformance marker", got)
-	}
-}
-
-func TestParseTextToolCallsFunctionCallSyntax(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `I will now call delegate({"task":"summarize the conformance marker","to":"blocked-reviewer"}) before answering.`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 1 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
-	}
-	if calls[0].Name != "delegate" {
-		t.Fatalf("call name = %q, want delegate", calls[0].Name)
-	}
-	if got := calls[0].Input["task"]; got != "summarize the conformance marker" {
-		t.Fatalf("task = %v, want summarize the conformance marker", got)
-	}
-	if got := calls[0].Input["to"]; got != "blocked-reviewer" {
-		t.Fatalf("to = %v, want blocked-reviewer", got)
-	}
-}
-
-func TestParseTextToolCallsFunctionCallSyntaxHandlesNestedJSON(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `delegate({
-		"task":"summarize the {escaped} marker",
-		"meta":{"note":"paren ) and brace } in string"},
-		"to":"blocked-reviewer"
-	})`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 1 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
-	}
-	if got := calls[0].Input["task"]; got != "summarize the {escaped} marker" {
-		t.Fatalf("task = %v, want nested JSON-safe task", got)
-	}
-	if got := calls[0].Input["to"]; got != "blocked-reviewer" {
-		t.Fatalf("to = %v, want blocked-reviewer", got)
-	}
-}

ai/anthropic/anthropic.go

@@ -297,7 +297,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 	// Read response
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	// Parse response

ai/atlascloud/atlascloud.go

@@ -24,7 +24,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -95,7 +94,6 @@ func (p *Provider) String() string      { return "atlascloud" }
 
 func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (*ai.Response, error) {
 	tools := atlascloudTools(req.Tools)
-	compatTools, compatPrompt := atlascloudMinimaxCompatTools(p.opts.Model, req.Tools)
 
 	messages := []map[string]any{
 		{"role": "system", "content": req.SystemPrompt},
@@ -106,9 +104,6 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	if req.Prompt != "" {
 		messages = append(messages, map[string]any{"role": "user", "content": req.Prompt})
 	}
-	if compatPrompt != "" {
-		messages = append(messages, map[string]any{"role": "system", "content": compatPrompt})
-	}
 
 	apiReq := map[string]any{
 		"model":    p.opts.Model,
@@ -124,13 +119,7 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 
 	resp, rawMessage, err := p.callAPI(ctx, "chat", apiReq)
 	if err != nil {
-		if atlascloudShouldRetryMinimaxCompat(err, compatTools) {
-			apiReq["tools"] = compatTools
-			resp, rawMessage, err = p.callAPI(ctx, "chat-minimax-compat", apiReq)
-		}
-		if err != nil {
-			return nil, err
-		}
+		return nil, err
 	}
 
 	if len(resp.ToolCalls) == 0 {
@@ -138,77 +127,70 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	}
 
 	if p.opts.ToolHandler != nil {
-		var allToolCalls []ai.ToolCall
+		allToolCalls := append([]ai.ToolCall(nil), resp.ToolCalls...)
 		var toolResults []string
-		pendingToolCalls := append([]ai.ToolCall(nil), resp.ToolCalls...)
 		followUpMessages := append(messages, map[string]any{
 			"role":       "assistant",
 			"content":    rawMessage["content"],
 			"tool_calls": rawMessage["tool_calls"],
 		})
 
-		for attempt := 0; len(pendingToolCalls) > 0 && attempt < 4; attempt++ {
-			for _, tc := range pendingToolCalls {
-				result := p.opts.ToolHandler(ctx, tc)
+		for _, tc := range resp.ToolCalls {
+			content := p.opts.ToolHandler(ctx, tc).Content
+			if content != "" {
+				toolResults = append(toolResults, content)
+			}
+			followUpMessages = append(followUpMessages, map[string]any{
+				"role":         "tool",
+				"tool_call_id": tc.ID,
+				"content":      content,
+			})
+		}
+
+		followUpReq := map[string]any{
+			"model":    p.opts.Model,
+			"messages": followUpMessages,
+		}
+		if len(tools) > 0 {
+			// Keep the tool schema available during the follow-up turn. Minimax
+			// models behind Atlas Cloud sometimes call one required tool, inspect
+			// that result, and then issue a second tool call (for example a guarded
+			// delegate conformance check) instead of completing immediately.
+			followUpReq["tools"] = tools
+		}
+
+		followUpResp, _, err := p.callAPI(ctx, "tool-follow-up", followUpReq)
+		if err != nil {
+			return nil, err
+		}
+		if len(followUpResp.ToolCalls) > 0 {
+			for i := range followUpResp.ToolCalls {
+				result := p.opts.ToolHandler(ctx, followUpResp.ToolCalls[i])
 				if result.Refused != "" {
-					tc.Error = result.Refused
+					followUpResp.ToolCalls[i].Error = result.Refused
 				}
 				if result.Content != "" {
-					tc.Result = result.Content
+					followUpResp.ToolCalls[i].Result = result.Content
 					toolResults = append(toolResults, result.Content)
 				}
-				allToolCalls = append(allToolCalls, tc)
-				resp.ToolCalls = allToolCalls
-				followUpMessages = append(followUpMessages, map[string]any{
-					"role":         "tool",
-					"tool_call_id": tc.ID,
-					"content":      result.Content,
-				})
 			}
-
-			followUpReq := map[string]any{
-				"model":    p.opts.Model,
-				"messages": followUpMessages,
+			allToolCalls = append(allToolCalls, followUpResp.ToolCalls...)
+			resp.ToolCalls = allToolCalls
+		}
+		if followUpResp.Reply != "" {
+			if strings.Contains(followUpResp.Reply, "<tool_call") || strings.Contains(followUpResp.Reply, "function=") {
+				// Preserve follow-up assistant content as Reply, not Answer, when
+				// it may contain a text-encoded tool call. The agent harness
+				// inspects Reply for text fallback calls after Generate returns,
+				// which covers AtlasCloud/minimax turns that emit a second
+				// required call (for example guarded delegate) as markup instead
+				// of native tool_calls.
+				resp.Reply = followUpResp.Reply
+			} else {
+				resp.Answer = followUpResp.Reply
 			}
-			if len(tools) > 0 {
-				// Keep the tool schema available during follow-up turns. Minimax
-				// models behind Atlas Cloud sometimes complete a multi-tool task
-				// one call at a time (plan, then service tools, then delegate).
-				followUpReq["tools"] = tools
-			}
-
-			followUpResp, followUpRawMessage, err := p.callAPI(ctx, "tool-follow-up", followUpReq)
-			if err != nil {
-				if atlascloudShouldRetryWithoutTools(err, followUpReq) {
-					delete(followUpReq, "tools")
-					followUpResp, followUpRawMessage, err = p.callAPI(ctx, "tool-follow-up-no-tools", followUpReq)
-				}
-				if err != nil {
-					return nil, err
-				}
-			}
-			if len(followUpResp.ToolCalls) == 0 {
-				if followUpResp.Reply != "" {
-					if strings.Contains(followUpResp.Reply, "<tool_call") || strings.Contains(followUpResp.Reply, "function=") {
-						// Preserve follow-up assistant content as Reply, not Answer, when
-						// it may contain a text-encoded tool call. The agent harness
-						// inspects Reply for text fallback calls after Generate returns.
-						resp.Reply = followUpResp.Reply
-					} else {
-						resp.Answer = followUpResp.Reply
-					}
-				} else if len(toolResults) > 0 {
-					resp.Answer = strings.Join(toolResults, "\n")
-				}
-				break
-			}
-
-			followUpMessages = append(followUpMessages, map[string]any{
-				"role":       "assistant",
-				"content":    followUpRawMessage["content"],
-				"tool_calls": followUpRawMessage["tool_calls"],
-			})
-			pendingToolCalls = followUpResp.ToolCalls
+		} else if len(toolResults) > 0 {
+			resp.Answer = strings.Join(toolResults, "\n")
 		}
 	}
 
@@ -326,33 +308,6 @@ func (s *atlasStream) Close() error {
 	return s.body.Close()
 }
 
-type atlascloudAPIError struct {
-	Status  string
-	Code    int
-	Retry   time.Duration
-	Phase   string
-	Summary string
-	Body    string
-}
-
-func (e *atlascloudAPIError) Error() string {
-	return fmt.Sprintf("API error (%s) during atlascloud %s request (%s): %s", e.Status, e.Phase, e.Summary, e.Body)
-}
-
-func (e *atlascloudAPIError) StatusCode() int {
-	if e == nil {
-		return 0
-	}
-	return e.Code
-}
-
-func (e *atlascloudAPIError) RetryAfter() time.Duration {
-	if e == nil {
-		return 0
-	}
-	return e.Retry
-}
-
 func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any) (*ai.Response, map[string]any, error) {
 	reqBody, err := json.Marshal(req)
 	if err != nil {
@@ -376,12 +331,7 @@ func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		retryAfter := time.Duration(0)
-		var retryErr interface{ RetryAfter() time.Duration }
-		if errors.As(ai.NewHTTPError(httpResp, respBody), &retryErr) {
-			retryAfter = retryErr.RetryAfter()
-		}
-		return nil, nil, &atlascloudAPIError{Status: httpResp.Status, Code: httpResp.StatusCode, Retry: retryAfter, Phase: phase, Summary: atlascloudRequestSummary(req), Body: string(respBody)}
+		return nil, nil, fmt.Errorf("API error (%s) during atlascloud %s request (%s): %s", httpResp.Status, phase, atlascloudRequestSummary(req), string(respBody))
 	}
 
 	var chatResp struct {
@@ -426,50 +376,6 @@ func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any
 	return response, rawMessage, nil
 }
 
-func atlascloudMinimaxCompatTools(model string, input []ai.Tool) ([]map[string]any, string) {
-	if !atlascloudIsMinimaxModel(model) || len(input) == 0 {
-		return nil, ""
-	}
-	var native []ai.Tool
-	var builtins []string
-	for _, tool := range input {
-		switch tool.Name {
-		case "plan", "request_input", "delegate":
-			builtins = append(builtins, tool.Name)
-		default:
-			native = append(native, tool)
-		}
-	}
-	if len(builtins) == 0 || len(native) == len(input) {
-		return nil, ""
-	}
-	prompt := "AtlasCloud/minimax compatibility: use native tool_calls for the listed service tools. " +
-		"For built-in agent tools that are not listed natively (" + strings.Join(builtins, ", ") +
-		"), emit exactly <tool_call name=\"tool_name\">{...}</tool_call> so the agent runtime can execute them. Do not describe those built-in tool calls in prose instead of emitting the tag."
-	return atlascloudTools(native), prompt
-}
-
-func atlascloudIsMinimaxModel(model string) bool {
-	model = strings.ToLower(model)
-	return strings.Contains(model, "minimax")
-}
-
-func atlascloudShouldRetryMinimaxCompat(err error, compatTools []map[string]any) bool {
-	if len(compatTools) == 0 {
-		return false
-	}
-	var apiErr *atlascloudAPIError
-	return errors.As(err, &apiErr) && apiErr.StatusCode() == http.StatusBadRequest
-}
-
-func atlascloudShouldRetryWithoutTools(err error, req map[string]any) bool {
-	if _, ok := req["tools"]; !ok {
-		return false
-	}
-	var apiErr *atlascloudAPIError
-	return errors.As(err, &apiErr) && apiErr.StatusCode() == http.StatusBadRequest
-}
-
 func atlascloudTools(input []ai.Tool) []map[string]any {
 	tools := make([]map[string]any, 0, len(input))
 	for _, t := range input {

ai/atlascloud/atlascloud_test.go

@@ -355,8 +355,6 @@ func TestProvider_GenerateExecutesFollowUpToolCall(t *testing.T) {
 			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-1","function":{"name":"conformance_echo","arguments":"{\"value\":\"agent-conformance\"}"}}]}}]}`))
 		case 2:
 			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-2","function":{"name":"delegate","arguments":"{\"task\":\"summarize the conformance marker\",\"to\":\"blocked-reviewer\"}"}}]}}]}`))
-		case 3:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"blocked by policy"}}]}`))
 		default:
 			t.Fatalf("unexpected API call %d", len(bodies))
 		}
@@ -408,70 +406,6 @@ func TestProvider_GenerateExecutesFollowUpToolCall(t *testing.T) {
 	}
 }
 
-func TestProvider_GenerateExecutesMultiStepFollowUpToolCalls(t *testing.T) {
-	var bodies []map[string]any
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		bodies = append(bodies, body)
-		w.Header().Set("Content-Type", "application/json")
-		switch len(bodies) {
-		case 1:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-plan","function":{"name":"plan","arguments":"{\"steps\":[{\"task\":\"create tasks\"},{\"task\":\"notify owner\"}]}"}}]}}]}`))
-		case 2:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-add","function":{"name":"task_TaskService_Add","arguments":"{\"title\":\"Design\"}"}}]}}]}`))
-		case 3:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-delegate","function":{"name":"delegate","arguments":"{\"task\":\"notify owner@acme.com\",\"to\":\"comms\"}"}}]}}]}`))
-		case 4:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"done"}}]}`))
-		default:
-			t.Fatalf("unexpected API call %d", len(bodies))
-		}
-	}))
-	defer ts.Close()
-
-	var calls []string
-	p := NewProvider(
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL(ts.URL),
-		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-			calls = append(calls, call.Name)
-			return ai.ToolResult{ID: call.ID, Content: `{"ok":true}`}
-		}),
-	)
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "plan, create tasks, and delegate notification",
-		Tools: []ai.Tool{
-			{Name: "plan", Description: "record a plan", Properties: map[string]any{"steps": map[string]any{"type": "array"}}},
-			{Name: "task_TaskService_Add", Description: "add task", Properties: map[string]any{"title": map[string]any{"type": "string"}}},
-			{Name: "delegate", Description: "delegate work", Properties: map[string]any{"task": map[string]any{"type": "string"}, "to": map[string]any{"type": "string"}}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("Generate returned error: %v", err)
-	}
-	wantCalls := []string{"plan", "task_TaskService_Add", "delegate"}
-	if strings.Join(calls, ",") != strings.Join(wantCalls, ",") {
-		t.Fatalf("tool calls = %v, want %v", calls, wantCalls)
-	}
-	if len(resp.ToolCalls) != 3 {
-		t.Fatalf("ToolCalls = %+v, want all multi-step calls", resp.ToolCalls)
-	}
-	if resp.Answer != "done" {
-		t.Fatalf("Answer = %q, want final follow-up reply", resp.Answer)
-	}
-	if len(bodies) != 4 {
-		t.Fatalf("requests = %d, want initial plus three follow-ups", len(bodies))
-	}
-	for i := 1; i < 4; i++ {
-		if _, ok := bodies[i]["tools"].([]any); !ok {
-			t.Fatalf("follow-up request %d did not include tools: %#v", i+1, bodies[i])
-		}
-	}
-}
-
 func TestProvider_GeneratePreservesFollowUpTextToolCallInReply(t *testing.T) {
 	var bodies []map[string]any
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -520,120 +454,6 @@ func TestProvider_GeneratePreservesFollowUpTextToolCallInReply(t *testing.T) {
 	}
 }
 
-func TestProvider_GenerateRetriesMinimaxBuiltInsAsTextTools(t *testing.T) {
-	var bodies []map[string]any
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		bodies = append(bodies, body)
-		w.Header().Set("Content-Type", "application/json")
-		switch len(bodies) {
-		case 1:
-			http.Error(w, `{"code":400,"msg":"bad request"}`, http.StatusBadRequest)
-		case 2:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"<tool_call name=\"delegate\">{\"task\":\"summarize\",\"to\":\"blocked-reviewer\"}</tool_call>"}}]}`))
-		default:
-			t.Fatalf("unexpected API call %d", len(bodies))
-		}
-	}))
-	defer ts.Close()
-
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL), ai.WithModel("minimaxai/minimax-m3"))
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "plan and delegate",
-		Tools: []ai.Tool{
-			{Name: "task_TaskService_Add", Description: "add task", Properties: map[string]any{"title": map[string]any{"type": "string"}}},
-			{Name: "plan", Description: "record a plan", Properties: map[string]any{"steps": map[string]any{"type": "array"}}},
-			{Name: "request_input", Description: "request input", Properties: map[string]any{"prompt": map[string]any{"type": "string"}}},
-			{Name: "delegate", Description: "delegate work", Properties: map[string]any{"task": map[string]any{"type": "string"}, "to": map[string]any{"type": "string"}}},
-		},
-	})
-	if err != nil {
-		t.Fatalf("Generate returned error: %v", err)
-	}
-	if !strings.Contains(resp.Reply, `<tool_call name="delegate">`) {
-		t.Fatalf("Reply = %q, want text delegate fallback", resp.Reply)
-	}
-	if len(bodies) != 2 {
-		t.Fatalf("requests = %d, want initial plus compat retry", len(bodies))
-	}
-	initialTools := bodies[0]["tools"].([]any)
-	if len(initialTools) != 4 {
-		t.Fatalf("initial tools = %d, want all tools", len(initialTools))
-	}
-	retryTools := bodies[1]["tools"].([]any)
-	if len(retryTools) != 1 {
-		t.Fatalf("retry tools = %d, want only service tools", len(retryTools))
-	}
-	fn := retryTools[0].(map[string]any)["function"].(map[string]any)
-	if fn["name"] != "task_TaskService_Add" {
-		t.Fatalf("retry tool name = %v, want service tool only", fn["name"])
-	}
-	msgs := bodies[1]["messages"].([]any)
-	compat := msgs[len(msgs)-1].(map[string]any)
-	if compat["role"] != "system" || !strings.Contains(compat["content"].(string), `<tool_call name="tool_name">`) {
-		t.Fatalf("compat instruction = %#v", compat)
-	}
-}
-
-func TestProvider_GenerateFollowUpRetriesWithoutToolsOnBadRequest(t *testing.T) {
-	var bodies []map[string]any
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		bodies = append(bodies, body)
-		w.Header().Set("Content-Type", "application/json")
-		switch len(bodies) {
-		case 1:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-1","function":{"name":"conformance_echo","arguments":"{\"value\":\"agent-conformance\"}"}}]}}]}`))
-		case 2:
-			http.Error(w, `{"code":400,"msg":"bad request"}`, http.StatusBadRequest)
-		case 3:
-			if _, ok := body["tools"]; ok {
-				t.Fatalf("no-tools retry still included tools: %#v", body["tools"])
-			}
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"done"}}]}`))
-		default:
-			t.Fatalf("unexpected API call %d", len(bodies))
-		}
-	}))
-	defer ts.Close()
-
-	var toolCalls int
-	p := NewProvider(
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL(ts.URL),
-		ai.WithModel("minimaxai/minimax-m3"),
-		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-			toolCalls++
-			return ai.ToolResult{ID: call.ID, Content: `{"marker":"agent-conformance-ok"}`}
-		}),
-	)
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "call a tool",
-		Tools:  []ai.Tool{{Name: "conformance_echo", Description: "echo", Properties: map[string]any{"value": map[string]any{"type": "string"}}}},
-	})
-	if err != nil {
-		t.Fatalf("Generate returned error: %v", err)
-	}
-	if resp.Answer != "done" {
-		t.Fatalf("Answer = %q, want done", resp.Answer)
-	}
-	if toolCalls != 1 {
-		t.Fatalf("tool handler calls = %d, want one (no duplicate side effect)", toolCalls)
-	}
-	if len(bodies) != 3 {
-		t.Fatalf("requests = %d, want chat, failed follow-up, no-tools follow-up", len(bodies))
-	}
-	if _, ok := bodies[1]["tools"]; !ok {
-		t.Fatalf("first follow-up did not include tools")
-	}
-}
-
 func TestProvider_GenerateToolCallHTTPErrorIncludesRequestContext(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, `{"code":400,"msg":"bad request"}`, http.StatusBadRequest)

ai/gemini/gemini.go

@@ -163,7 +163,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var geminiResp struct {

ai/groq/groq.go

@@ -147,7 +147,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {

ai/minimax/minimax.go

@@ -147,7 +147,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {

ai/mistral/mistral.go

@@ -147,7 +147,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {

ai/openai/openai.go

@@ -285,7 +285,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 	// Read response
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	// Parse response

ai/retry.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"net/http"
-	"strconv"
 	"strings"
 	"time"
 )
@@ -21,64 +19,6 @@ type RetryAfterCoder interface {
 	RetryAfter() time.Duration
 }
 
-// HTTPError describes a failed provider HTTP response while preserving the
-// status code and Retry-After signal for retry classifiers.
-type HTTPError struct {
-	Status string
-	Code   int
-	Body   string
-	Header http.Header
-}
-
-func (e *HTTPError) Error() string {
-	if e == nil {
-		return ""
-	}
-	return fmt.Sprintf("API error (%s): %s", e.Status, e.Body)
-}
-
-func (e *HTTPError) StatusCode() int {
-	if e == nil {
-		return 0
-	}
-	return e.Code
-}
-
-func (e *HTTPError) RetryAfter() time.Duration {
-	if e == nil {
-		return 0
-	}
-	return parseRetryAfter(e.Header.Get("Retry-After"), time.Now())
-}
-
-func NewHTTPError(resp *http.Response, body []byte) error {
-	if resp == nil {
-		return errors.New("API error: nil response")
-	}
-	return &HTTPError{Status: resp.Status, Code: resp.StatusCode, Body: string(body), Header: resp.Header.Clone()}
-}
-
-func parseRetryAfter(value string, now time.Time) time.Duration {
-	value = strings.TrimSpace(value)
-	if value == "" {
-		return 0
-	}
-	if seconds, err := strconv.Atoi(value); err == nil {
-		if seconds <= 0 {
-			return 0
-		}
-		return time.Duration(seconds) * time.Second
-	}
-	when, err := http.ParseTime(value)
-	if err != nil {
-		return 0
-	}
-	if delay := when.Sub(now); delay > 0 {
-		return delay
-	}
-	return 0
-}
-
 // ErrorKind classifies provider-boundary failures into stable buckets callers
 // can inspect without parsing provider-specific error strings.
 type ErrorKind string

ai/retry_test.go

@@ -3,7 +3,6 @@ package ai
 import (
 	"context"
 	"errors"
-	"net/http"
 	"testing"
 	"time"
 )
@@ -222,23 +221,3 @@ func TestGenerateWithRetryCapsRetryAfter(t *testing.T) {
 		t.Fatalf("retryBackoff() = %s, want 30s cap", got)
 	}
 }
-
-func TestHTTPErrorExposesStatusAndRetryAfter(t *testing.T) {
-	resp := &http.Response{
-		Status:     "429 Too Many Requests",
-		StatusCode: http.StatusTooManyRequests,
-		Header:     http.Header{"Retry-After": []string{"2"}},
-	}
-	err := NewHTTPError(resp, []byte("slow down"))
-
-	if got := ClassifyError(err); got != ErrorKindRateLimited {
-		t.Fatalf("ClassifyError() = %q, want %q", got, ErrorKindRateLimited)
-	}
-	var retryAfter RetryAfterCoder
-	if !errors.As(err, &retryAfter) {
-		t.Fatalf("NewHTTPError does not expose RetryAfterCoder")
-	}
-	if got := retryAfter.RetryAfter(); got != 2*time.Second {
-		t.Fatalf("RetryAfter() = %s, want 2s", got)
-	}
-}

ai/together/together.go

@@ -147,7 +147,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {

cmd/micro/cli/cli.go

@@ -48,8 +48,7 @@ Guide: https://go-micro.dev/docs/guides/zero-to-hero.html`
 
 const examplesWayfinding = `First-agent examples (no provider key required)
 
-Run these from a go-micro repository checkout in this order. For the complete
-examples map, open examples/INDEX.md:
+Run these from a go-micro repository checkout in this order:
 
   1. Smallest service-backed agent
        go run ./examples/first-agent

cmd/micro/examples_wayfinding_test.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/urfave/cli/v2"
-	microcmd "go-micro.dev/v6/cmd"
-)
-
-func TestExamplesWayfindingIndexStaysLinked(t *testing.T) {
-	root := filepath.Join("..", "..")
-	files := map[string]string{}
-	for _, name := range []string{"README.md", "examples/README.md", "examples/INDEX.md"} {
-		b, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(name)))
-		if err != nil {
-			t.Fatalf("read %s: %v", name, err)
-		}
-		files[name] = string(b)
-	}
-
-	for _, check := range []struct {
-		file string
-		want []string
-	}{
-		{
-			file: "README.md",
-			want: []string{"examples/INDEX.md", "examples/first-agent/", "examples/support/", "zero-to-hero.md"},
-		},
-		{
-			file: "examples/README.md",
-			want: []string{"./INDEX.md", "./first-agent/", "./support/", "./mcp/hello/", "./mcp/workflow/"},
-		},
-		{
-			file: "examples/INDEX.md",
-			want: []string{"go run ./examples/first-agent", "go run ./examples/support", "mcp/hello", "mcp/workflow", "flow-durable", "micro examples"},
-		},
-	} {
-		for _, want := range check.want {
-			if !strings.Contains(files[check.file], want) {
-				t.Fatalf("%s missing %q", check.file, want)
-			}
-		}
-	}
-}
-
-func TestExamplesCommandPointsAtWayfindingIndex(t *testing.T) {
-	examples := commandByName(t, "examples")
-	var out bytes.Buffer
-	app := cli.NewApp()
-	app.Writer = &out
-	if err := examples.Action(cli.NewContext(app, nil, nil)); err != nil {
-		t.Fatalf("micro examples failed: %v", err)
-	}
-
-	for _, want := range []string{
-		"examples/INDEX.md",
-		"go run ./examples/first-agent",
-		"go run ./examples/support",
-		"micro zero-to-hero",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("micro examples output missing %q:\n%s", want, out.String())
-		}
-	}
-
-	_ = microcmd.DefaultCmd // keep this test coupled to the registered command package.
-}

examples/INDEX.md

@@ -1,46 +0,0 @@
-# Examples wayfinding
-
-Use this index when you want the shortest path from a first runnable agent to the
-next services, agents, workflows, and interop examples. Every command below is
-provider-free unless the example README says otherwise.
-
-## Pick by goal
-
-| Goal | Start here | Run or verify | Then try |
-|------|------------|---------------|----------|
-| Run the smallest no-secret agent | [`first-agent`](./first-agent/) | `go run ./examples/first-agent` | [`agent-demo`](./agent-demo/) for a larger service-backed agent |
-| Prove the maintained 0→hero path | [`support`](./support/) | `go run ./examples/support` and `go test ./examples/support` | [`zero-to-hero` guide](../internal/website/docs/guides/zero-to-hero.md) |
-| See planning and delegation | [`agent-plan-delegate`](./agent-plan-delegate/) | `go run ./examples/agent-plan-delegate` | [`plan-delegate` guide](../internal/website/docs/guides/plan-delegate.md) |
-| Expose services through MCP | [`mcp/hello`](./mcp/hello/) | follow [`mcp`](./mcp/) setup | [`mcp/crud`](./mcp/crud/) and [`mcp/workflow`](./mcp/workflow/) |
-| Try A2A or gRPC interop next | [`agent-demo`](./agent-demo/) plus gateway docs | run the example, then use the gateway docs | [`grpc-interop`](./grpc-interop/) |
-| Add workflow durability | [`flow-durable`](./flow-durable/) | `go run ./examples/flow-durable` | [`flow-loop`](./flow-loop/) |
-
-## Recommended adoption path
-
-1. **First service:** run [`hello-world`](./hello-world/) to learn service
-   registration, handlers, client calls, and health checks.
-2. **First agent:** run [`first-agent`](./first-agent/) with
-   `go run ./examples/first-agent`; it uses a deterministic mock model and needs
-   no provider key.
-3. **0→hero reference:** run [`support`](./support/) with
-   `go run ./examples/support`; it keeps typed services, an agent chat loop, an
-   event-driven flow, and an approval gate in one maintained example.
-4. **Interop next:** use [`mcp/hello`](./mcp/hello/), [`mcp/crud`](./mcp/crud/),
-   and [`mcp/workflow`](./mcp/workflow/) when you are ready to expose tools to
-   external AI clients.
-5. **Workflow depth:** use [`flow-durable`](./flow-durable/) once the agent path
-   needs checkpointed, resumable deterministic work.
-
-## CLI wayfinding
-
-The installed CLI prints the same path:
-
-```bash
-micro examples
-micro agent demo
-micro zero-to-hero
-```
-
-Keep this file, [`README.md`](../README.md), and the `micro examples` output in
-sync so new developers can find `examples/first-agent` and `examples/support`
-from one documented path.

examples/README.md

@@ -7,8 +7,8 @@ coordinate work with workflows.
 ## Quick Start
 
 Each example can be run with `go run .` from its directory unless its README says
-otherwise. If you are new to the repo, start with the [examples wayfinding index](./INDEX.md)
-or follow the first-agent path below instead of reading the directories alphabetically.
+otherwise. If you are new to the repo, follow the first-agent path below instead
+of reading the directories alphabetically.
 
 ## Recommended first-agent path
 

internal/harness/plan-delegate/main.go

@@ -484,7 +484,7 @@ func runPlanDelegate(provider string) error {
 		flow.Steps(
 			flow.Step{Name: "conductor", Run: planDelegateConductorStep(conductor)},
 			flow.Step{Name: "require-notify", Run: requireDelegatedNotifyStep(taskSvc, notifySvc, func(ctx context.Context) error {
-				_, err := comms.Ask(ctx, "Send exactly one owner readiness notification now with this exact task: "+delegatedNotifyTask+" Use the notify service and do not answer until the notification has been sent.")
+				_, err := conductor.Ask(ctx, "The Design, Build, and Ship tasks already exist, but the owner notification is still missing. Delegate exactly one notification to the \"comms\" agent now with this exact subtask: "+delegatedNotifyTask+" Do not create more tasks and do not answer until comms has handled the notification.")
 				return err
 			})},
 		),
@@ -554,13 +554,6 @@ func requireDelegatedNotifyStep(taskSvc *TaskService, notifySvc *NotifyService,
 			if err := recoverMissingNotify(ctx); err != nil {
 				return in, fmt.Errorf("delegation completed without required notify side effect and recovery failed: notify=%d, want 1: %w", notify, err)
 			}
-			settled, err = waitForNotifySideEffect(notifySvc, delegatedNotifySettleTimeout)
-			if err != nil {
-				return in, err
-			}
-			if !settled {
-				return in, fmt.Errorf("delegation recovery completed without required notify side effect: notify=%d, want 1", notifySvc.count())
-			}
 		}
 		if notify = notifySvc.count(); notify != 1 {
 			return in, fmt.Errorf("delegation recovery completed without required notify side effect: notify=%d, want 1", notify)

internal/harness/plan-delegate/main_test.go

@@ -367,37 +367,6 @@ func TestPlanDelegateExecutionWaitsForInFlightNotifyAfterFlowCompletion(t *testi
 	}
 }
 
-func TestPlanDelegateRecoveryWaitsForRecoveredNotifySideEffect(t *testing.T) {
-	taskSvc := new(TaskService)
-	for _, title := range []string{"Design", "Build", "Ship"} {
-		var rsp AddResponse
-		if err := taskSvc.Add(context.Background(), &AddRequest{Title: title}, &rsp); err != nil {
-			t.Fatalf("Add(%q): %v", title, err)
-		}
-	}
-	notifySvc := new(NotifyService)
-
-	recovered := false
-	_, err := requireDelegatedNotifyStep(taskSvc, notifySvc, func(ctx context.Context) error {
-		recovered = true
-		go func() {
-			time.Sleep(100 * time.Millisecond)
-			var rsp SendResponse
-			_ = notifySvc.Send(ctx, &SendRequest{To: "owner@acme.com", Message: "The launch plan is ready"}, &rsp)
-		}()
-		return nil
-	})(context.Background(), flow.State{})
-	if err != nil {
-		t.Fatalf("requireDelegatedNotifyStep returned %v, want delayed recovery success", err)
-	}
-	if !recovered {
-		t.Fatal("missing notify recovery did not run")
-	}
-	if got := notifySvc.count(); got != 1 {
-		t.Fatalf("notify count = %d, want recovered notify side effect", got)
-	}
-}
-
 func TestPlanDelegateExecutionAcceptsClientTimeoutAfterSideEffects(t *testing.T) {
 	taskSvc := new(TaskService)
 	for _, title := range []string{"Design", "Build", "Ship"} {

internal/harness/universe/main.go

@@ -414,7 +414,7 @@ func runUniverse(provider string) int {
 	// Services.
 	inv, pay, ord, ntf := new(Inventory), new(Payment), new(Orders), new(Notify)
 	for name, h := range map[string]any{"inventory": inv, "payment": pay, "orders": ord, "notify": ntf} {
-		svc := service.New(service.Name(name), service.Address("127.0.0.1:0"), service.Registry(reg), service.Broker(br), service.Client(cl))
+		svc := service.New(service.Name(name), service.Address("127.0.0.1:0"), service.Registry(reg), service.Client(cl))
 		svc.Handle(h)
 		go svc.Run()
 	}
@@ -429,7 +429,6 @@ func runUniverse(provider string) int {
 		agent.Address("127.0.0.1:0"),
 		agent.Provider(provider), agent.APIKey(apiKey),
 		agent.MaxSteps(5),
-		agent.WithBroker(br),
 		agent.WrapTool(func(next ai.ToolHandler) ai.ToolHandler {
 			return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 				atomic.AddInt64(&wrapped, 1)

internal/harness/zero-to-hero-ci/README.md

@@ -4,21 +4,19 @@ This directory owns the no-secret reference scenario for the Go Micro
 services → agents → workflows lifecycle. It is intentionally small and
 scripted so CI can run it on every push without external services or model keys.
 
-`run.sh` verifies the complete first-agent 0→hero contract together:
+`run.sh` verifies five boundaries together:
 
-1. **Scaffold** — the maintained `micro new` 0→1 contract still creates
-   runnable services from a clean workspace.
-2. **First agent** — `micro agent preflight`, `micro run`, `micro chat`, and
-   `micro inspect agent <name>` remain available as the documented first-agent
-   walkthrough path.
-3. **Run** — `micro run` remains available as the local development entry point.
-4. **Chat** — `micro chat` remains available as the interactive agent entry point.
-5. **Inspect/debugging** — `micro inspect agent <name>`, `micro agent history <name>`,
+1. **First agent** — `micro new`, `micro agent preflight`, `micro run`,
+   `micro chat`, and `micro inspect agent <name>` remain available as the
+   documented first-agent walkthrough path.
+2. **Run** — `micro run` remains available as the local development entry point.
+3. **Chat** — `micro chat` remains available as the interactive agent entry point.
+4. **Inspect/debugging** — `micro inspect agent <name>`, `micro agent history <name>`,
    and `micro inspect flow <name>` remain available as the local run-history
    inspection step. The no-secret debugging smoke seeds durable agent run history
    and memory, then runs the documented inspect/history commands without provider
    credentials; `micro flow runs` preserves durable workflow history inspection.
-6. **Deploy** — `micro deploy --dry-run <target>` remains available as the
+5. **Deploy** — `micro deploy --dry-run <target>` remains available as the
    deployment-boundary checkpoint. The dry run resolves configured deploy targets
    and services and prints the remote build/copy/systemd/health plan without
    building binaries, opening SSH connections, running `rsync`, or touching
@@ -32,19 +30,16 @@ and A2A with only the LLM mocked.
 
 The default GitHub harness workflow runs this script on every push and pull
 request after the install smoke check and 0→1 scaffold contract. Developers can
-verify the first-agent on-ramp links alone with `make docs-wayfinding`, verify
-the installer seam alone with `make install-smoke`, run just the documented
-agent debugging quickcheck with
-`go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentDebuggingSmoke -count=1`,
-or run the same no-secret contract locally with:
+verify the installer seam alone with `make install-smoke`, or run the same
+no-secret contract locally with:
 
 ```sh
 make harness
 ```
 
-That target intentionally exercises the first-agent docs wayfinding guard, the
-install script smoke path, both 0→1 scaffold variants, the 0→hero scenario, the
-event-driven agent-flow harness, and mock provider conformance, so
+That target intentionally exercises the install script smoke path, both 0→1
+scaffold variants, the 0→hero scenario, the event-driven agent-flow harness, and
+mock provider conformance, so
 the public scaffold → run/chat → inspect → deploy lifecycle stays executable
 outside CI as well. Live provider checks remain separate and gated by configured
 API keys (`make provider-conformance` or the scheduled/manual CI job).

internal/harness/zero-to-hero-ci/docs_test.go

@@ -38,19 +38,6 @@ func TestZeroToHeroReferenceDocs(t *testing.T) {
 		}
 	}
 
-	runScript := readFile(t, filepath.Join(root, "internal", "harness", "zero-to-hero-ci", "run.sh"))
-	for _, want := range []string{
-		"go test ./cmd/micro/cli/new -run TestZeroToOne -count=1",
-		"go test ./cmd/micro -run 'TestFirstAgentWalkthroughCLIBoundaries|TestZeroToHeroCLIBoundaries' -count=1",
-		"go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1",
-		"go test ./examples/first-agent -run TestRunFirstAgent -count=1",
-		"go test ./examples/support -run 'TestRunSupportMockSmoke|TestZeroToHeroReadmeDocumentsLifecycle' -count=1",
-	} {
-		if !strings.Contains(runScript, want) {
-			t.Fatalf("0→hero CI run script missing lifecycle command %q", want)
-		}
-	}
-
 	readme := readFile(t, filepath.Join(root, "README.md"))
 	if !strings.Contains(readme, "internal/website/docs/guides/zero-to-hero.md") {
 		t.Fatal("README does not point to the canonical 0→hero guide")
@@ -62,62 +49,6 @@ func TestZeroToHeroReferenceDocs(t *testing.T) {
 	}
 }
 
-func TestZeroToHeroDeployDryRunCommandSmoke(t *testing.T) {
-	root := filepath.Clean(filepath.Join("..", "..", ".."))
-	absRoot, err := filepath.Abs(root)
-	if err != nil {
-		t.Fatalf("resolve repository root: %v", err)
-	}
-
-	bin := filepath.Join(t.TempDir(), "micro")
-	build := exec.Command("go", "build", "-o", bin, "./cmd/micro")
-	build.Dir = absRoot
-	if out, err := build.CombinedOutput(); err != nil {
-		t.Fatalf("build micro CLI for deploy dry-run smoke: %v\n%s", err, out)
-	}
-
-	workspace := t.TempDir()
-	writeFile(t, filepath.Join(workspace, "micro.mu"), `service api
-    path ./api
-
-deploy prod
-    ssh deploy@prod.example.com
-    path /srv/micro
-`)
-	if err := os.Mkdir(filepath.Join(workspace, "api"), 0o755); err != nil {
-		t.Fatalf("create service dir: %v", err)
-	}
-
-	cmd := exec.Command(bin, "deploy", "--dry-run", "prod")
-	cmd.Dir = workspace
-	cmd.Env = append(os.Environ(), "MICRO_CONFIG_FILE="+filepath.Join(workspace, "micro.mu"))
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("documented deploy dry-run command failed: %v\n%s", err, out)
-	}
-
-	got := string(out)
-	for _, want := range []string{
-		"micro deploy --dry-run",
-		"Target",
-		"deploy@prod.example.com",
-		"Remote path",
-		"/srv/micro",
-		"Services",
-		"api",
-		"No SSH, rsync, systemd, or remote deployment was performed.",
-	} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("deploy dry-run output missing %q:\n%s", want, got)
-		}
-	}
-
-	guide := readFile(t, filepath.Join(absRoot, "internal", "website", "docs", "guides", "zero-to-hero.md"))
-	if !strings.Contains(guide, "micro deploy --dry-run prod") {
-		t.Fatal("0→hero guide must document the same deploy dry-run command covered by CI")
-	}
-}
-
 func TestGuidesNavigationLeadsWithDoing(t *testing.T) {
 	root := filepath.Clean(filepath.Join("..", "..", ".."))
 	nav := readFile(t, filepath.Join(root, "internal", "website", "_data", "navigation.yml"))
@@ -317,40 +248,6 @@ func TestFirstAgentWayfindingDocs(t *testing.T) {
 				"guides/install-troubleshooting.html",
 				"micro agent demo",
 				"micro zero-to-hero",
-				"https://github.com/micro/go-micro/blob/master/examples/INDEX.md",
-				"https://github.com/micro/go-micro/tree/master/examples/support",
-				"https://github.com/micro/go-micro/tree/master/examples/first-agent",
-				"guides/no-secret-first-agent.html",
-				"guides/your-first-agent.html",
-				"guides/debugging-agents.html",
-				"guides/zero-to-hero.html",
-			},
-		},
-		{
-			name:    "website quickstart next steps",
-			file:    filepath.Join(root, "internal", "website", "docs", "quickstart.md"),
-			heading: "## Next Steps",
-			links: []string{
-				"guides/install-troubleshooting.html",
-				"micro agent demo",
-				"micro zero-to-hero",
-				"https://github.com/micro/go-micro/blob/master/examples/INDEX.md",
-				"https://github.com/micro/go-micro/tree/master/examples/support",
-				"https://github.com/micro/go-micro/tree/master/examples/first-agent",
-				"guides/no-secret-first-agent.html",
-				"guides/your-first-agent.html",
-				"guides/debugging-agents.html",
-				"guides/zero-to-hero.html",
-			},
-		},
-		{
-			name:    "website docs index learn more",
-			file:    filepath.Join(root, "internal", "website", "docs", "index.md"),
-			heading: "## Learn More",
-			links: []string{
-				"getting-started.html",
-				"https://github.com/micro/go-micro/blob/master/examples/INDEX.md",
-				"https://github.com/micro/go-micro/tree/master/examples/support",
 				"guides/no-secret-first-agent.html",
 				"guides/your-first-agent.html",
 				"guides/debugging-agents.html",
@@ -410,16 +307,6 @@ func TestFirstAgentWayfindingLinkTargetsResolve(t *testing.T) {
 			file:    filepath.Join(root, "internal", "website", "docs", "getting-started.md"),
 			heading: "### First-agent on-ramp",
 		},
-		{
-			name:    "website quickstart next steps",
-			file:    filepath.Join(root, "internal", "website", "docs", "quickstart.md"),
-			heading: "## Next Steps",
-		},
-		{
-			name:    "website docs index learn more",
-			file:    filepath.Join(root, "internal", "website", "docs", "index.md"),
-			heading: "## Learn More",
-		},
 	}
 
 	for _, check := range checks {
@@ -676,24 +563,6 @@ func TestNoSecretFirstAgentTranscript(t *testing.T) {
 		}
 	}
 
-	debuggingGuide := readFile(t, filepath.Join(root, "internal", "website", "docs", "guides", "debugging-agents.md"))
-	for _, want := range []string{
-		"Provider-free quickcheck",
-		"go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentDebuggingSmoke -count=1",
-		"micro inspect agent assistant --limit 1",
-		"micro inspect agent --status done",
-		"micro agent history assistant",
-	} {
-		if !strings.Contains(debuggingGuide, want) {
-			t.Fatalf("debugging guide missing provider-free quickcheck marker %q", want)
-		}
-	}
-
-	harnessReadme := readFile(t, filepath.Join(root, "internal", "harness", "zero-to-hero-ci", "README.md"))
-	if !strings.Contains(harnessReadme, "go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentDebuggingSmoke -count=1") {
-		t.Fatal("0→hero harness README does not expose the agent debugging quickcheck command")
-	}
-
 	readme := readFile(t, filepath.Join(root, "README.md"))
 	if !strings.Contains(readme, "internal/website/docs/guides/no-secret-first-agent.md") {
 		t.Fatal("README does not point to the no-secret first-agent transcript")

internal/harness/zero-to-hero-ci/run.sh

@@ -6,10 +6,9 @@ cd "$ROOT"
 
 # Keep the developer inner-loop boundaries executable and discoverable in CI
 # without secrets or long-running daemons.
-go test ./cmd/micro/cli/new -run TestZeroToOne -count=1
 go test ./cmd/micro -run 'TestFirstAgentWalkthroughCLIBoundaries|TestZeroToHeroCLIBoundaries' -count=1
 go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1
-go test ./internal/harness/zero-to-hero-ci -run 'TestNoSecretFirstAgentTranscript|TestNoSecretFirstAgentDebuggingSmoke|TestZeroToHeroReferenceDocs|TestZeroToHeroDeployDryRunCommandSmoke|TestYourFirstAgentTutorialSmoke' -count=1
+go test ./internal/harness/zero-to-hero-ci -run 'TestNoSecretFirstAgentTranscript|TestNoSecretFirstAgentDebuggingSmoke|TestZeroToHeroReferenceDocs|TestYourFirstAgentTutorialSmoke' -count=1
 
 # Deterministic no-secret reference scenarios. These use the real Go Micro
 # runtime and mock only the LLM provider. The support example is the maintained

internal/website/docs/getting-started.md

@@ -59,12 +59,11 @@ After this quick start, follow the agent path in order:
 2. `micro agent demo` — print the provider-free first-agent demo command and next docs steps from the installed CLI.
 3. `micro examples` — print the maintained provider-free runnable examples in copy/paste order.
 4. `micro zero-to-hero` — print the maintained one-command no-secret lifecycle harness and runnable examples.
-5. [Examples wayfinding index](https://github.com/micro/go-micro/blob/master/examples/INDEX.md) — choose the smallest no-secret first-agent, maintained [0→hero support reference](https://github.com/micro/go-micro/tree/master/examples/support), and next interop examples from one map.
-6. [Smallest first-agent example](https://github.com/micro/go-micro/tree/master/examples/first-agent) — run one service-backed agent with a mock model and no provider key.
-7. [No-secret first-agent transcript](guides/no-secret-first-agent.html) — run a useful support agent with a mock model before setting up a provider key.
-8. [Your First Agent](guides/your-first-agent.html) — build a service-backed agent and talk to it with `micro chat`.
-9. [Debugging your agent](guides/debugging-agents.html) — inspect service registration, tool calls, run history, memory, provider failures, and flow handoffs when the agent surprises you.
-10. [0→hero reference path](guides/zero-to-hero.html) — prove the full scaffold → run → chat → inspect → deploy dry-run lifecycle with commands exercised by `make harness`.
+5. [Smallest first-agent example](https://github.com/micro/go-micro/tree/master/examples/first-agent) — run one service-backed agent with a mock model and no provider key.
+6. [No-secret first-agent transcript](guides/no-secret-first-agent.html) — run a useful support agent with a mock model before setting up a provider key.
+7. [Your First Agent](guides/your-first-agent.html) — build a service-backed agent and talk to it with `micro chat`.
+8. [Debugging your agent](guides/debugging-agents.html) — inspect service registration, tool calls, run history, memory, provider failures, and flow handoffs when the agent surprises you.
+9. [0→hero reference path](guides/zero-to-hero.html) — prove the full scaffold → run → chat → inspect → deploy dry-run lifecycle with commands exercised by `make harness`.
 
 ## Write a Service
 

internal/website/docs/guides/debugging-agents.md

@@ -116,18 +116,6 @@ state (`agent/<name>/runs/...`). The persisted timeline is recorded even without
 an OpenTelemetry exporter, so `micro inspect agent` remains useful in local
 no-secret development.
 
-Provider-free quickcheck: if you want to verify the documented inspect path
-before involving a live model, run the same smoke check CI uses:
-
-```sh
-go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentDebuggingSmoke -count=1
-```
-
-That test seeds a local `assistant` run history and memory transcript, then runs
-`micro inspect agent assistant --limit 1`, `micro inspect agent --status done
---json assistant`, and `micro agent history assistant` with provider credentials
-cleared.
-
 ## 4. See tool calls as they happen
 
 When you are embedding an agent in Go and need live tool visibility, use the

internal/website/docs/guides/zero-to-hero.md

@@ -23,7 +23,7 @@ cloud credentials?"
 | Run | `micro run` remains the local development entry point. | `go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1` |
 | Chat | `micro chat` remains the interactive agent entry point. | `go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1` |
 | Inspect | `micro inspect agent <name>`, `micro agent history <name>`, `micro inspect flow <flow>`, and `micro flow runs <flow>` remain discoverable for run history; the no-secret debugging smoke seeds durable agent history and runs the documented inspect/history commands without provider keys. | `go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentDebuggingSmoke -count=1` |
-| Deploy | `micro deploy --dry-run prod` resolves the documented deploy target without touching remote infrastructure. | `go test ./internal/harness/zero-to-hero-ci -run TestZeroToHeroDeployDryRunCommandSmoke -count=1` |
+| Deploy | `micro deploy --dry-run` resolves deploy targets without touching remote infrastructure. | `go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1` |
 | Smallest first agent | `examples/first-agent` runs one service-backed agent with a deterministic mock model and no provider key. | `go test ./examples/first-agent -run TestRunFirstAgent -count=1` |
 | Runtime reference app | `examples/support` runs typed services, an agent using those services as tools, an event-driven flow handoff, and an approval gate with only the model mocked. | `go test ./examples/support -run 'TestRunSupportMockSmoke|TestZeroToHeroReadmeDocumentsLifecycle' -count=1` |
 | Runtime harnesses | Real services, agents, durable flows, store-backed history, delegation, and A2A run with only the model mocked. | `./internal/harness/zero-to-hero-ci/run.sh` and `make provider-conformance-mock` |
@@ -84,7 +84,6 @@ go test ./cmd/micro -run TestFirstAgentWalkthroughCLIBoundaries -count=1
 # CLI inner-loop commands: run, chat, inspect, flow runs, deploy --dry-run.
 go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1
 go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1
-go test ./internal/harness/zero-to-hero-ci -run TestZeroToHeroDeployDryRunCommandSmoke -count=1
 
 # Smallest no-secret service-backed first agent.
 go test ./examples/first-agent -run TestRunFirstAgent -count=1

internal/website/docs/index.md

@@ -16,7 +16,7 @@ It's built on a pluggable architecture of Go interfaces: service discovery, clie
 
 ## Learn More
 
-Start with [Getting Started](getting-started.html) for install and the first local service. Then follow the first-agent on-ramp: `micro agent demo` for the installed no-secret CLI affordance, [examples wayfinding index](https://github.com/micro/go-micro/blob/master/examples/INDEX.md) for the maintained examples map, [the 0→hero support reference](https://github.com/micro/go-micro/tree/master/examples/support) for the full no-secret lifecycle example, [No-secret first-agent transcript](guides/no-secret-first-agent.html) to run a mock-model support agent, [Your First Agent](guides/your-first-agent.html) to build and chat with a service-backed agent, [Debugging your agent](guides/debugging-agents.html) to inspect runs and memory, and the [0→hero reference path](guides/zero-to-hero.html) to walk the full scaffold → run → chat → inspect → deploy dry-run lifecycle covered by CI.
+Start with [Getting Started](getting-started.html) for install and the first local service. Then follow the first-agent on-ramp: `micro agent demo` for the installed no-secret CLI affordance, `micro examples` for copy/pasteable runnable examples, [No-secret first-agent transcript](guides/no-secret-first-agent.html) to run a mock-model support agent, [Your First Agent](guides/your-first-agent.html) to build and chat with a service-backed agent, [Debugging your agent](guides/debugging-agents.html) to inspect runs and memory, and the [0→hero reference path](guides/zero-to-hero.html) to walk the full scaffold → run → chat → inspect → deploy dry-run lifecycle covered by CI.
 
 Otherwise continue to read the docs for more information about the framework.
 
@@ -26,8 +26,6 @@ Otherwise continue to read the docs for more information about the framework.
 - [0→hero Reference](guides/zero-to-hero.html) - Walk scaffold → run → chat → inspect → deploy dry-run with CI-backed commands
 - `micro agent demo` - Show the provider-free first-agent demo command and next docs steps
 - `micro examples` - Show provider-free first-agent examples in copy/paste order
-- [Examples wayfinding index](https://github.com/micro/go-micro/blob/master/examples/INDEX.md) - Choose the first-agent, support, and interop examples from one map
-- [0→hero support reference](https://github.com/micro/go-micro/tree/master/examples/support) - Run the maintained no-secret services → agents → workflows example
 - [No-secret first-agent transcript](guides/no-secret-first-agent.html) - Run the first useful agent path without a provider key
 - [Your First Agent](guides/your-first-agent.html) - Build a service-backed agent end to end
 - [MCP & AI Agents](mcp.html) - Turn services into AI-callable tools with the Model Context Protocol

internal/website/docs/quickstart.md

@@ -45,12 +45,11 @@ You now have the service half of the services → agents → workflows lifecycle
 2. `micro agent demo` - print the provider-free first-agent demo command and the next docs steps from the installed CLI.
 3. `micro examples` - print the maintained provider-free runnable examples in copy/paste order.
 4. `micro zero-to-hero` - print the maintained one-command no-secret lifecycle harness and runnable examples.
-5. **[Examples wayfinding index](https://github.com/micro/go-micro/blob/master/examples/INDEX.md)** - choose the smallest no-secret first-agent, maintained **[0→hero support reference](https://github.com/micro/go-micro/tree/master/examples/support)**, and next interop examples from one map.
-6. **[Smallest first-agent example](https://github.com/micro/go-micro/tree/master/examples/first-agent)** - run a mock-model, no-secret agent before adding provider keys.
-7. **[No-secret first-agent transcript](guides/no-secret-first-agent.html)** - run a useful support agent with a mock model before setting up a provider key.
-8. **[Your First Agent](guides/your-first-agent.html)** - turn this service into an agent-callable tool, chat with it, and learn the `micro agent preflight` → `micro run` → `micro chat` loop.
-9. **[Debugging your agent](guides/debugging-agents.html)** - inspect service registration, tool calls, run history, memory, provider failures, and flow handoffs when the agent does something surprising.
-10. **[0→hero Reference](guides/zero-to-hero.html)** - walk the maintained scaffold → run → chat → inspect → deploy dry-run path that proves services, agents, and workflows together.
+5. **[Smallest first-agent example](https://github.com/micro/go-micro/tree/master/examples/first-agent)** - run a mock-model, no-secret agent before adding provider keys.
+6. **[No-secret first-agent transcript](guides/no-secret-first-agent.html)** - run a useful support agent with a mock model before setting up a provider key.
+7. **[Your First Agent](guides/your-first-agent.html)** - turn this service into an agent-callable tool, chat with it, and learn the `micro agent preflight` → `micro run` → `micro chat` loop.
+8. **[Debugging your agent](guides/debugging-agents.html)** - inspect service registration, tool calls, run history, memory, provider failures, and flow handoffs when the agent does something surprising.
+9. **[0→hero Reference](guides/zero-to-hero.html)** - walk the maintained scaffold → run → chat → inspect → deploy dry-run path that proves services, agents, and workflows together.
 
 After that first-agent path, branch out to: