harness: require notify inside plan delegate flow

2026-07-04 23:00:12 +00:00
43 changed files with 132 additions and 1626 deletions
@@ -1,8 +1,5 @@
 blank_issues_enabled: true
 contact_links:
-  - name: 🔒 Report a vulnerability
-    url: https://github.com/micro/go-micro/security/advisories/new
-    about: Privately disclose security vulnerabilities to the maintainers.
  - name: 💖 Sponsor Go Micro
    url: https://github.com/sponsors/asim
    about: Fund ongoing development and see your name or logo on the project.
@@ -21,7 +21,9 @@ changes, architectural rewrites. Those go to the human.

 ## Work queue (ranked)

-1. **Align architecture docs with the agent harness lifecycle** ([#4092](https://github.com/micro/go-micro/issues/4092)) — the first-agent on-ramp, install troubleshooting, preflight, and after-run doctor seams are now covered, but the website architecture page still reads like a pre-agent distributed-systems overview. Refresh it so newcomers see one coherent services → agents → workflows runtime: registry/server/client as the service substrate, `model`/`store` as state, `ai`/`agent` as the tool-calling loop, `flow` as durable deterministic orchestration, and MCP/A2A gateways as interop. Add a focused docs/wayfinding assertion so the architecture story keeps pointing back to AI integration, first-agent, and 0→hero.
-
+1. **Require delegated notify before plan-delegate completion** ([#3972](https://github.com/micro/go-micro/issues/3972)) — #3981 closed the first-agent broker isolation gap, leaving this as the latest live AtlasCloud plan/delegate harness regression. A tasks-complete-but-notify-missing run undermines evaluator trust at the agents → workflows seam, so it stays at the top until the harness can prove delegated work only completes after the required notification.
+2. **Surface the first-agent and 0→hero example paths in the CLI** ([#3983](https://github.com/micro/go-micro/issues/3983)) — the README, website docs, and examples now describe a strong on-ramp, but adoption still depends on users finding those paths after install. Current goal is developer adoption, so the queue should keep a CI-verifiable CLI wayfinding task near the top instead of drifting entirely into internal conformance and observability work.
+3. **Broaden provider streaming and keep chat/A2A streaming end to end** ([#3903](https://github.com/micro/go-micro/issues/3903)) — streaming remains the highest developer-visible Next-phase seam after the current conformance and wayfinding gaps. Real chat and long-running A2A tasks need token streaming to stay coherent from provider → `ai.Stream` → `micro chat` → A2A `message/stream`, with mock/default CI coverage plus key-gated live provider checks and safe fallback for non-streaming providers.
+4. **Trace agent runs as OpenTelemetry spans** ([#3908](https://github.com/micro/go-micro/issues/3908)) — the blog/README/roadmap story promises an operable harness, and the developer on-ramp now includes chat, inspect, and run-history checkpoints. The next observability gap is production-grade trace correlation for `RunInfo`: steps, tool calls, delegation, status, durations, and failures should be visible as spans while defaulting to no-op when tracing is not configured.
 _Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
 architecture-review pass._
@@ -16,27 +16,6 @@ next version when it ships.

 ## [Unreleased]

-## [6.3.15] - July 2026
-
-### Added
- **Anthropic streaming** — the Anthropic provider now supports Messages SSE streaming and is registered as a streaming-capable provider, with capability docs and parser coverage. (`ai/anthropic/`, `internal/website/docs/guides/`)
- **AP2 mandate foundation for A2A** — the A2A gateway now has the shared payment-mandate foundation needed for AP2-style agent payment flows. (`gateway/a2a/`)
- **Smallest first-agent example** — a no-secret, mock-model first-agent example gives the on-ramp a minimal runnable starting point. (`examples/first-agent/`)
-
-### Changed
- **First-agent CLI next steps** — CLI output now points new users toward the maintained first-agent path after scaffold/run milestones. (`cmd/micro/`)
-
-### Fixed
- **Plan/delegate completion** — plan-delegate runs now preserve completed steps, guard ordering, require notify-before-completion, and stabilize checkpoint continuation paths. (`agent/`, `internal/harness/`)
- **Provider text tool calls** — AtlasCloud and weaker-model fallback paths now recover tagged, `Create`-suffixed, mixed text/tool-call, and follow-up tool calls more reliably. (`agent/`, `ai/atlascloud/`)
- **First-agent broker isolation** — the first-agent harness now isolates broker state more reliably across runs. (`internal/harness/`)
-
-### Documentation
- **First-agent example path** — docs and website wayfinding now surface the smallest example, no-secret transcript, and 0→hero path together. (`README.md`, `internal/website/docs/`)
- **Agent operations guidance** — agent debugging docs now include operational failure guidance, inspect hints, and durable resume pointers. (`internal/website/docs/guides/`)
-
---
-
 ## [6.3.14] - July 2026

 ### Added
@@ -50,8 +50,6 @@ curl -fsSL https://go-micro.dev/install.sh | sh
 go install go-micro.dev/v6/cmd/micro@latest
 ```

-If install or `PATH` checks fail, use the [install troubleshooting guide](internal/website/docs/guides/install-troubleshooting.md) before scaffolding your first service.
-
 ### Fastest start — no API key

 Scaffold a service, run it, call it:
@@ -89,17 +87,15 @@ make harness
 After install and the first `micro new`/`micro run` smoke check, take the
 walkable agent path in this order:

-1. [Install troubleshooting](internal/website/docs/guides/install-troubleshooting.md) — verify the binary installer or `go install`, `PATH`, `micro --version`, and the no-secret smoke path before agent work.
-2. `micro agent demo` — print the provider-free first-agent demo command and next docs steps from the installed CLI.
-3. [Smallest first-agent example](examples/first-agent/) — run one service-backed agent with a mock model and no provider key.
-4. [No-secret first-agent transcript](internal/website/docs/guides/no-secret-first-agent.md) — run the
+1. [Smallest first-agent example](examples/first-agent/) — run one service-backed agent with a mock model and no provider key.
+2. [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.
-5. [Your First Agent](internal/website/docs/guides/your-first-agent.md) — build a
+3. [Your First Agent](internal/website/docs/guides/your-first-agent.md) — build a
   service-backed agent and talk to it with `micro chat`.
-6. [Debugging your agent](internal/website/docs/guides/debugging-agents.md) — use
+4. [Debugging your agent](internal/website/docs/guides/debugging-agents.md) — use
   `micro agent inspect`, run history, memory, and provider checks when the first
   conversation does something unexpected.
-7. [0→hero Reference](internal/website/docs/guides/zero-to-hero.md) — complete the
+5. [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.

@@ -17,10 +17,10 @@ We actively support the following versions of go-micro:

 ### How to Report

-Use GitHub's private security advisory feature:
-https://github.com/micro/go-micro/security/advisories/new
+Send security vulnerability reports to: **security@go-micro.dev**

-This keeps vulnerability reports private, ties follow-up to the affected repository, and avoids relying on project email routing.
+Or use GitHub's private security advisory feature:
+https://github.com/micro/go-micro/security/advisories/new

 ### What to Include

@@ -175,4 +175,5 @@ We currently do not offer a bug bounty program, but we greatly appreciate respon
 For security questions that are not vulnerabilities, please:
 - Open a discussion: https://github.com/micro/go-micro/discussions
 - Join Discord: https://discord.gg/G8Gk5j3uXr
+- Email: support@go-micro.dev

@@ -297,11 +297,7 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		}
 	}

-	// Some providers satisfy a saved plan one outstanding item per turn,
-	// especially when the final item delegates to another agent. Allow enough
-	// continuations for the services → agents → workflows harness to complete
-	// every planned side effect without weakening the final unfinished-plan guard.
-	const maxPlanCompletionTurns = 6
+	const maxPlanCompletionTurns = 3
 	var resp *ai.Response
 	for planCompletionTurn := 0; ; planCompletionTurn++ {
 		resp, err = ai.GenerateWithRetry(ctx, a.model, &ai.Request{
@@ -356,15 +352,6 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 					resp.Reply = ""
 				}
 			}
-		} else if calls, answer, ok := a.executeAdditionalTextToolCalls(ctx, resp.Reply, toolList, resp.ToolCalls); ok {
-			resp.ToolCalls = append(resp.ToolCalls, calls...)
-			if answer != "" {
-				if resp.Answer == "" {
-					resp.Answer = answer
-				} else {
-					resp.Answer += "\n" + answer
-				}
-			}
 		}

 		if a.opts.Checkpoint != nil {
@@ -375,7 +362,7 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 				if resp.Answer != "" {
 					a.mem.Add("assistant", resp.Answer)
 				}
-				message = fmt.Sprintf("Continue the same run by calling the required tool(s) for the unfinished plan steps below. Do not repeat completed work, do not provide a final answer yet, and complete at least one unfinished step this turn if a matching tool is available. Unfinished plan steps: %s", strings.Join(unfinished, ", "))
+				message = "Continue the run. These plan steps are still unfinished and must be completed before a final answer: " + strings.Join(unfinished, ", ")
 				a.mem.Add("user", message)
 				messages = a.mem.Messages()
 				continue
@@ -290,11 +290,6 @@ func (a *agentImpl) planWrap(next ai.ToolHandler) ai.ToolHandler {
 		if call.Name == toolPlan {
 			return a.handlePlan(call)
 		}
-		if call.Name == toolDelegate {
-			if blocked := a.unfinishedPlanStepsBeforeDelegation(); len(blocked) > 0 {
-				return refused(call.ID, ai.RefusedApproval, "complete these plan steps before delegating: "+strings.Join(blocked, ", "))
-			}
-		}
 		res := next(ctx, call)
 		if res.Refused == "" && toolErrorMessage(res) == "" {
 			a.completeNextPlanStep()
@@ -469,53 +464,6 @@ func (a *agentImpl) completeNextPlanStep() {
 	}
 }

-func (a *agentImpl) unfinishedPlanStepsBeforeDelegation() []string {
-	plan := a.loadPlan()
-	if plan == "" {
-		return nil
-	}
-	var data map[string]any
-	if err := json.Unmarshal([]byte(plan), &data); err != nil {
-		return nil
-	}
-	steps, ok := data["steps"].([]any)
-	if !ok {
-		return nil
-	}
-	var unfinished []string
-	for _, raw := range steps {
-		step, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		task := planStepTask(step)
-		if isDelegationPlanTask(task) {
-			break
-		}
-		if !isUnfinishedPlanStatus(step["status"]) {
-			continue
-		}
-		if task == "" {
-			task = "<unnamed>"
-		}
-		unfinished = append(unfinished, task)
-	}
-	return unfinished
-}
-
-func planStepTask(step map[string]any) string {
-	if task, _ := step["task"].(string); task != "" {
-		return task
-	}
-	desc, _ := step["description"].(string)
-	return desc
-}
-
-func isDelegationPlanTask(task string) bool {
-	task = normalizePlanTask(task)
-	return strings.Contains(task, "delegate") || strings.Contains(task, "notify") || strings.Contains(task, "notification")
-}
-
 func (a *agentImpl) unfinishedPlanSteps() []string {
 	plan := a.loadPlan()
 	if plan == "" {
@@ -539,7 +487,7 @@ func (a *agentImpl) unfinishedPlanSteps() []string {
 		if status != "" && status != "pending" && status != "in_progress" {
 			continue
 		}
-		task := planStepTask(step)
+		task, _ := step["task"].(string)
 		if task == "" {
 			task = "<unnamed>"
 		}
@@ -1,7 +1,6 @@
 package agent

 import (
-	"context"
 	"encoding/json"
 	"testing"

@@ -192,45 +191,3 @@ func TestIsAgent(t *testing.T) {
 		t.Error("isAgent(nonexistent) = true, want false")
 	}
 }
-
-func TestPlanWrapBlocksDelegationUntilPriorPlanStepsFinish(t *testing.T) {
-	mem := store.NewMemoryStore()
-	a := New(Name("planner"), WithStore(mem)).(*agentImpl)
-	a.handlePlan(ai.ToolCall{Name: toolPlan, Input: map[string]any{
-		"steps": []any{
-			map[string]any{"task": "Create Design task", "status": "pending"},
-			map[string]any{"task": "Create Build task", "status": "pending"},
-			map[string]any{"task": "Create Ship task", "status": "pending"},
-			map[string]any{"task": "Delegate readiness notification to comms agent", "status": "pending"},
-		},
-	}})
-
-	called := false
-	handle := a.planWrap(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		called = true
-		return ai.ToolResult{ID: call.ID, Content: "ok"}
-	})
-
-	res := handle(context.Background(), ai.ToolCall{ID: "delegate-1", Name: toolDelegate, Input: map[string]any{"to": "comms"}})
-	if called {
-		t.Fatal("delegate handler was called before prior task plan steps completed")
-	}
-	if res.Refused == "" {
-		t.Fatalf("delegate result was not refused: %+v", res)
-	}
-	if got := res.Content; !containsStr(got, "Create Design task") || !containsStr(got, "Create Ship task") {
-		t.Fatalf("delegate refusal content = %q, want prior unfinished task steps", got)
-	}
-
-	for _, id := range []string{"add-design", "add-build", "add-ship"} {
-		_ = handle(context.Background(), ai.ToolCall{ID: id, Name: "task.Add", Input: map[string]any{"title": id}})
-	}
-	called = false
-	res = handle(context.Background(), ai.ToolCall{ID: "delegate-2", Name: toolDelegate, Input: map[string]any{"to": "comms"}})
-	if !called {
-		t.Fatal("delegate handler was not called after prior task plan steps completed")
-	}
-	if res.Refused != "" {
-		t.Fatalf("delegate result refused after prior task steps completed: %+v", res)
-	}
-}
@@ -219,72 +219,6 @@ func TestCheckpointContinuesRunWithUnfinishedPlanStep(t *testing.T) {
 	}
 }

-func TestCheckpointContinuesRunThroughSeveralSingleStepTurns(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "single-step-plan-agent")
-
-	completed := []string{}
-	modelCalls := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		modelCalls++
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		switch modelCalls {
-		case 1:
-			opts.ToolHandler(ctx, ai.ToolCall{ID: "plan-1", Name: toolPlan, Input: map[string]any{
-				"steps": []any{
-					map[string]any{"task": "create Design task", "status": "pending"},
-					map[string]any{"task": "create Build task", "status": "pending"},
-					map[string]any{"task": "create Ship task", "status": "pending"},
-					map[string]any{"task": "delegate readiness notification", "status": "pending"},
-				},
-			}})
-			return &ai.Response{Reply: "planned"}, nil
-		case 2, 3, 4, 5:
-			want := []string{"create Design task", "create Build task", "create Ship task", "delegate readiness notification"}[modelCalls-2]
-			if !strings.Contains(req.Prompt, want) {
-				t.Fatalf("continuation prompt %d = %q, want %q", modelCalls, req.Prompt, want)
-			}
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: want, Name: "external.step", Input: map[string]any{"step": want}})
-			if res.Content != "completed "+want {
-				t.Fatalf("tool result = %q, want completed %s", res.Content, want)
-			}
-			if modelCalls == 5 {
-				return &ai.Response{Reply: "all plan steps complete"}, nil
-			}
-			return &ai.Response{Reply: "one more step complete"}, nil
-		default:
-			t.Fatalf("unexpected model call %d", modelCalls)
-			return nil, nil
-		}
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("single-step-plan-agent"), WithCheckpoint(cp),
-		WithTool("external.step", "complete one planned step", nil, func(ctx context.Context, input map[string]any) (string, error) {
-			step, _ := input["step"].(string)
-			completed = append(completed, step)
-			return "completed " + step, nil
-		}))
-	resp, err := a.Ask(ctx, "work through the launch plan")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if resp.Reply != "all plan steps complete" {
-		t.Fatalf("reply = %q, want final continuation reply", resp.Reply)
-	}
-	if modelCalls != 5 {
-		t.Fatalf("model calls = %d, want initial plus four continuations", modelCalls)
-	}
-	if len(completed) != 4 {
-		t.Fatalf("completed steps = %v, want four tool-backed continuations", completed)
-	}
-	if unfinished := a.unfinishedPlanSteps(); len(unfinished) != 0 {
-		t.Fatalf("unfinished plan steps = %v, want none", unfinished)
-	}
-}
-
 func TestResumeFailedCheckpointAfterFreshAgentRestart(t *testing.T) {
 	ctx := context.Background()
 	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "restart-resume-agent")
@@ -504,67 +504,3 @@ func TestAgentExecutesProviderTextToolCallFallback(t *testing.T) {
 		t.Fatalf("Reply = %q, want tool result instead of raw JSON", resp.Reply)
 	}
 }
-
-func TestAgentExecutesTextToolCallFallbackAfterStructuredToolCall(t *testing.T) {
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			return nil, errors.New("missing tool handler")
-		}
-		echo := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    "structured-echo-1",
-			Name:  "conformance_echo",
-			Input: map[string]any{"value": "agent-conformance"},
-		})
-		return &ai.Response{
-			Reply:  echo.Content + "\n<tool_call name=\"delegate\">{\"task\":\"summarize the conformance marker\",\"to\":\"blocked-reviewer\"}</tool_call>",
-			Answer: echo.Content,
-			ToolCalls: []ai.ToolCall{
-				{ID: "structured-echo-1", Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: echo.Content},
-			},
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	var sawTool bool
-	var sawBlockedDelegate bool
-	a := New(
-		Name("conformance-mixed-text-tool"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		ApproveTool(func(tool string, input map[string]any) (bool, string) {
-			if tool == "delegate" {
-				sawBlockedDelegate = true
-				return false, "cross-provider conformance blocks delegate side effects"
-			}
-			return true, ""
-		}),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			sawTool = true
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	resp, err := a.Ask(context.Background(), "Run the mixed structured/text tool fallback.")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if !sawTool {
-		t.Fatal("structured conformance_echo did not execute")
-	}
-	if !sawBlockedDelegate {
-		t.Fatal("tagged text delegate fallback did not execute")
-	}
-	if len(resp.ToolCalls) != 2 {
-		t.Fatalf("ToolCalls = %+v, want structured echo and text delegate", resp.ToolCalls)
-	}
-	if resp.ToolCalls[1].Name != "delegate" || resp.ToolCalls[1].Error != ai.RefusedApproval {
-		t.Fatalf("delegate ToolCall = %+v, want refused delegate", resp.ToolCalls[1])
-	}
-	if !strings.Contains(resp.Reply, "agent-conformance-ok") {
-		t.Fatalf("Reply = %q, want conformance marker", resp.Reply)
-	}
-}
@@ -215,13 +215,13 @@ func (m *tracedModel) Generate(ctx context.Context, req *ai.Request, opts ...ai.
 	} else {
 		span.SetStatus(codes.Ok, "")
 	}
+	span.End()
 	e := RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "model", Provider: provider, Model: model, Attempt: info.Attempt, MaxAttempts: info.MaxAttempts, LatencyMS: dur, Tokens: usage}
 	if err != nil {
 		e.Error = err.Error()
 		e.ErrorKind = string(ai.ClassifyError(err))
 	}
 	m.a.recordSpanEvent(span, e)
-	span.End()
 	return resp, err
 }

@@ -393,8 +393,8 @@ func (a *agentImpl) traceTool(next ai.ToolHandler) ai.ToolHandler {
 		} else {
 			span.SetStatus(codes.Ok, "")
 		}
-		a.recordSpanEvent(span, RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "tool", Name: call.Name, LatencyMS: dur, Refused: res.Refused, Error: resErr, ErrorKind: classifyToolError(resErr)})
 		span.End()
+		a.recordSpanEvent(span, RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "tool", Name: call.Name, LatencyMS: dur, Refused: res.Refused, Error: resErr, ErrorKind: classifyToolError(resErr)})
 		return res
 	}
 }
@@ -95,16 +95,8 @@ func TestAgentOpenTelemetrySpans(t *testing.T) {
 		if attrs[AttrRunID] != runID || attrs[AttrAgentName] != "runner" {
 			t.Fatalf("%s missing run correlation attributes: %#v", s.Name(), attrs)
 		}
-		if s.Name() == spanNameModelCall {
-			if attrs[AttrAttempt] != "1" || attrs[AttrMaxAttempts] != "1" {
-				t.Fatalf("model span missing attempt attributes: %#v", attrs)
-			}
-			if !spanEventHasRunInfo(s.Events(), "agent.model", runID, "runner") {
-				t.Fatalf("model span missing model event: %#v", s.Events())
-			}
-		}
-		if s.Name() == spanNameToolCall && !spanEventHasRunInfo(s.Events(), "agent.tool", runID, "runner") {
-			t.Fatalf("tool span missing tool event: %#v", s.Events())
+		if s.Name() == spanNameModelCall && (attrs[AttrAttempt] != "1" || attrs[AttrMaxAttempts] != "1") {
+			t.Fatalf("model span missing attempt attributes: %#v", attrs)
 		}
 	}
 	keys, err := store.Scope(st, "agent", "runner").List(store.ListPrefix("runs/"))
@@ -663,9 +655,6 @@ func TestAgentOpenTelemetrySpansModelStream(t *testing.T) {
 		if attrs[AttrAttempt] != "2" || attrs[AttrMaxAttempts] != "3" || attrs[AttrTotalTokens] != "5" {
 			t.Fatalf("stream span missing attempt/usage attributes: %#v", attrs)
 		}
-		if !spanEventHasRunInfo(s.Events(), "agent.stream", "stream-run-1", "stream-runner") {
-			t.Fatalf("stream span missing stream event: %#v", s.Events())
-		}
 		sawStream = true
 	}
 	if !sawStream {
@@ -47,48 +47,6 @@ func (a *agentImpl) executeTextToolCalls(ctx context.Context, reply string, tool
 	return calls, strings.Join(results, "\n"), true
 }

-// executeAdditionalTextToolCalls runs text-encoded tool calls that accompany a
-// structured tool_calls response. Some OpenAI-compatible providers can mix the
-// two forms in a single assistant turn: for example, emitting a native
-// conformance_echo call while rendering a follow-up guarded delegate call as
-// <tool_call name="delegate">...</tool_call> text. Keep this fallback additive
-// and de-duplicate calls already represented in the structured tool_calls list.
-func (a *agentImpl) executeAdditionalTextToolCalls(ctx context.Context, reply string, tools []ai.Tool, existing []ai.ToolCall) ([]ai.ToolCall, string, bool) {
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) == 0 {
-		return nil, "", false
-	}
-
-	seen := map[string]bool{}
-	for _, call := range existing {
-		seen[textToolCallKey(call)] = true
-	}
-
-	handler := a.toolHandler()
-	out := make([]ai.ToolCall, 0, len(calls))
-	results := make([]string, 0, len(calls))
-	for i := range calls {
-		if seen[textToolCallKey(calls[i])] {
-			continue
-		}
-		result := handler(ctx, calls[i])
-		calls[i].Result = result.Content
-		if result.Refused != "" {
-			calls[i].Error = result.Refused
-		}
-		if result.Content != "" {
-			results = append(results, result.Content)
-		}
-		out = append(out, calls[i])
-	}
-	return out, strings.Join(results, "\n"), len(out) > 0
-}
-
-func textToolCallKey(call ai.ToolCall) string {
-	b, _ := json.Marshal(call.Input)
-	return call.Name + "\x00" + string(b)
-}
-
 func parseTextToolCalls(text string, tools []ai.Tool) []ai.ToolCall {
 	allowed := textToolNames(tools)
 	if len(allowed) == 0 {
@@ -2,7 +2,6 @@
 package anthropic

 import (
-	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
@@ -18,7 +17,6 @@ func init() {
 	ai.Register("anthropic", func(opts ...ai.Option) ai.Model {
 		return NewProvider(opts...)
 	})
-	ai.RegisterStream("anthropic")
 }

 // Provider implements the ai.Model interface for Anthropic Claude
@@ -158,113 +156,9 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	return resp, nil
 }

-// Stream generates a streaming response from Anthropic's Messages SSE API.
+// Stream generates a streaming response (not yet implemented)
 func (p *Provider) Stream(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (ai.Stream, error) {
-	apiReq := map[string]any{
-		"model":      p.opts.Model,
-		"max_tokens": anthropicMaxTokens(p.opts),
-		"system":     req.SystemPrompt,
-		"messages":   threadAnthropicMessages(req),
-		"stream":     true,
-	}
-	reqBody, err := json.Marshal(apiReq)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal stream request: %w", err)
-	}
-
-	apiURL := strings.TrimRight(p.opts.BaseURL, "/") + "/v1/messages"
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(reqBody))
-	if err != nil {
-		return nil, fmt.Errorf("failed to create stream request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Accept", "text/event-stream")
-	httpReq.Header.Set("x-api-key", p.opts.APIKey)
-	httpReq.Header.Set("anthropic-version", "2023-06-01")
-
-	httpResp, err := http.DefaultClient.Do(httpReq)
-	if err != nil {
-		return nil, fmt.Errorf("stream API request failed: %w", err)
-	}
-	if httpResp.StatusCode != http.StatusOK {
-		defer httpResp.Body.Close()
-		respBody, _ := io.ReadAll(httpResp.Body)
-		return nil, fmt.Errorf("stream API error (%s): %s", httpResp.Status, string(respBody))
-	}
-	return &streamReader{body: httpResp.Body, scanner: bufio.NewScanner(httpResp.Body)}, nil
-}
-
-type streamReader struct {
-	body    io.ReadCloser
-	scanner *bufio.Scanner
-	closed  bool
-}
-
-func (s *streamReader) Recv() (*ai.Response, error) {
-	for s.scanner.Scan() {
-		line := strings.TrimSpace(s.scanner.Text())
-		if line == "" || strings.HasPrefix(line, ":") || strings.HasPrefix(line, "event:") {
-			continue
-		}
-		if !strings.HasPrefix(line, "data:") {
-			continue
-		}
-		data := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
-		var chunk struct {
-			Type  string `json:"type"`
-			Delta struct {
-				Type string `json:"type"`
-				Text string `json:"text"`
-			} `json:"delta"`
-			Message struct {
-				Usage struct {
-					InputTokens  int `json:"input_tokens"`
-					OutputTokens int `json:"output_tokens"`
-				} `json:"usage"`
-			} `json:"message"`
-			Usage *struct {
-				InputTokens  int `json:"input_tokens"`
-				OutputTokens int `json:"output_tokens"`
-			} `json:"usage"`
-		}
-		if err := json.Unmarshal([]byte(data), &chunk); err != nil {
-			return nil, fmt.Errorf("failed to parse stream chunk: %w", err)
-		}
-		switch chunk.Type {
-		case "content_block_delta":
-			if chunk.Delta.Type == "text_delta" && chunk.Delta.Text != "" {
-				return &ai.Response{Reply: chunk.Delta.Text}, nil
-			}
-		case "message_start":
-			if chunk.Message.Usage.InputTokens > 0 || chunk.Message.Usage.OutputTokens > 0 {
-				return &ai.Response{Usage: usage(chunk.Message.Usage.InputTokens, chunk.Message.Usage.OutputTokens)}, nil
-			}
-		case "message_delta":
-			if chunk.Usage != nil {
-				return &ai.Response{Usage: usage(chunk.Usage.InputTokens, chunk.Usage.OutputTokens)}, nil
-			}
-		case "message_stop":
-			return nil, io.EOF
-		case "error":
-			return nil, fmt.Errorf("anthropic stream error: %s", data)
-		}
-	}
-	if err := s.scanner.Err(); err != nil {
-		return nil, err
-	}
-	return nil, io.EOF
-}
-
-func (s *streamReader) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	return s.body.Close()
-}
-
-func usage(input, output int) ai.Usage {
-	return ai.Usage{InputTokens: input, OutputTokens: output, TotalTokens: input + output}
+	return nil, fmt.Errorf("%w: anthropic provider", ai.ErrStreamingUnsupported)
 }

 // callAPI makes an HTTP request to the Anthropic API
@@ -3,10 +3,6 @@ package anthropic
 import (
 	"context"
 	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
 	"testing"

 	"go-micro.dev/v6/ai"
@@ -85,67 +81,15 @@ func TestProvider_Generate_NoAPIKey(t *testing.T) {
 	}
 }

-func TestProvider_Stream(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/messages" {
-			t.Fatalf("path = %q, want /v1/messages", r.URL.Path)
-		}
-		if got := r.Header.Get("Accept"); got != "text/event-stream" {
-			t.Fatalf("Accept = %q, want text/event-stream", got)
-		}
-		if got := r.Header.Get("x-api-key"); got != "test-key" {
-			t.Fatalf("x-api-key = %q, want test-key", got)
-		}
-		body, _ := io.ReadAll(r.Body)
-		if !strings.Contains(string(body), `"stream":true`) {
-			t.Fatalf("request body %s does not enable streaming", string(body))
-		}
-		w.Header().Set("Content-Type", "text/event-stream")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("event: message_start\n"))
-		_, _ = w.Write([]byte(`data: {"type":"message_start","message":{"usage":{"input_tokens":2}}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: content_block_delta\n"))
-		_, _ = w.Write([]byte(`data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"hel"}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: content_block_delta\n"))
-		_, _ = w.Write([]byte(`data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"lo"}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: message_delta\n"))
-		_, _ = w.Write([]byte(`data: {"type":"message_delta","usage":{"output_tokens":3}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: message_stop\n"))
-		_, _ = w.Write([]byte(`data: {"type":"message_stop"}` + "\n\n"))
-	}))
-	defer ts.Close()
-
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
+func TestProvider_Stream_NotImplemented(t *testing.T) {
+	p := NewProvider()

 	req := &ai.Request{
 		Prompt: "Hello",
 	}

-	stream, err := p.Stream(context.Background(), req)
-	if err != nil {
-		t.Fatalf("Stream failed: %v", err)
-	}
-	defer stream.Close()
-
-	var reply strings.Builder
-	var usage ai.Usage
-	for {
-		chunk, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("Recv failed: %v", err)
-		}
-		reply.WriteString(chunk.Reply)
-		if chunk.Usage.TotalTokens > 0 {
-			usage = chunk.Usage
-		}
-	}
-	if got := reply.String(); got != "hello" {
-		t.Fatalf("reply = %q, want hello", got)
-	}
-	if usage.TotalTokens != 3 {
-		t.Fatalf("usage = %+v, want total 3", usage)
+	_, err := p.Stream(context.Background(), req)
+	if !errors.Is(err, ai.ErrStreamingUnsupported) {
+		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
 	}
 }
@@ -140,7 +140,6 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	}

 	if p.opts.ToolHandler != nil {
-		allToolCalls := append([]ai.ToolCall(nil), resp.ToolCalls...)
 		var toolResults []string
 		followUpMessages := append(messages, map[string]any{
 			"role":       "assistant",
@@ -164,32 +163,11 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 			"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 != "" {
-					followUpResp.ToolCalls[i].Error = result.Refused
-				}
-				if result.Content != "" {
-					followUpResp.ToolCalls[i].Result = result.Content
-					toolResults = append(toolResults, result.Content)
-				}
-			}
-			allToolCalls = append(allToolCalls, followUpResp.ToolCalls...)
-			resp.ToolCalls = allToolCalls
-		}
 		if followUpResp.Reply != "" {
 			resp.Answer = followUpResp.Reply
 		} else if len(toolResults) > 0 {
@@ -289,71 +289,6 @@ func TestProvider_GenerateMinimaxToolRequests(t *testing.T) {
 	}
 }

-func TestProvider_GenerateExecutesFollowUpToolCall(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:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-2","function":{"name":"delegate","arguments":"{\"task\":\"summarize the conformance marker\",\"to\":\"blocked-reviewer\"}"}}]}}]}`))
-		default:
-			t.Fatalf("unexpected API call %d", len(bodies))
-		}
-	}))
-	defer ts.Close()
-
-	var sawEcho, sawDelegate bool
-	p := NewProvider(
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL(ts.URL),
-		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-			switch call.Name {
-			case "conformance_echo":
-				sawEcho = true
-				return ai.ToolResult{ID: call.ID, Content: `{"marker":"agent-conformance-ok"}`}
-			case "delegate":
-				sawDelegate = true
-				return ai.ToolResult{ID: call.ID, Refused: ai.RefusedApproval, Content: "blocked by policy"}
-			default:
-				t.Fatalf("unexpected tool call %+v", call)
-				return ai.ToolResult{}
-			}
-		}),
-	)
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "run conformance",
-		Tools: []ai.Tool{
-			{Name: "conformance_echo", Description: "echo conformance marker", Properties: map[string]any{"value": 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 !sawEcho || !sawDelegate {
-		t.Fatalf("sawEcho=%v sawDelegate=%v, want both tools executed", sawEcho, sawDelegate)
-	}
-	if len(resp.ToolCalls) != 2 {
-		t.Fatalf("ToolCalls = %+v, want echo and delegate", resp.ToolCalls)
-	}
-	if resp.ToolCalls[1].Name != "delegate" || resp.ToolCalls[1].Error != ai.RefusedApproval {
-		t.Fatalf("follow-up delegate = %+v, want refused delegate", resp.ToolCalls[1])
-	}
-	if !strings.Contains(resp.Answer, "blocked by policy") {
-		t.Fatalf("Answer = %q, want follow-up tool result", resp.Answer)
-	}
-	if _, ok := bodies[1]["tools"].([]any); !ok {
-		t.Fatalf("follow-up request did not include tools: %#v", bodies[1])
-	}
-}
-
 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)
@@ -35,7 +35,7 @@ func TestRegisteredProviders(t *testing.T) {
 	}

 	got = ai.RegisteredProviders("stream")
-	want = []string{"anthropic", "atlascloud", "groq", "minimax", "mistral", "openai", "together"}
+	want = []string{"atlascloud", "groq", "minimax", "mistral", "openai", "together"}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("RegisteredProviders(stream) = %#v, want %#v", got, want)
 	}
@@ -44,7 +44,7 @@ func TestRegisteredProviders(t *testing.T) {
 func TestCapabilityRows(t *testing.T) {
 	got := ai.CapabilityRows()
 	want := []ai.CapabilityRow{
-		{Provider: "anthropic", Capabilities: ai.Capabilities{Model: true, Stream: true}},
+		{Provider: "anthropic", Capabilities: ai.Capabilities{Model: true}},
 		{Provider: "atlascloud", Capabilities: ai.Capabilities{Model: true, Image: true, Video: true, Stream: true}},
 		{Provider: "gemini", Capabilities: ai.Capabilities{Model: true}},
 		{Provider: "groq", Capabilities: ai.Capabilities{Model: true, Stream: true}},
@@ -90,7 +90,7 @@ func TestRegisterStream(t *testing.T) {
 	}

 	got := ai.RegisteredProviders("stream")
-	want := []string{"anthropic", "atlascloud", "groq", "minimax", "mistral", "openai", "test-stream", "together"}
+	want := []string{"atlascloud", "groq", "minimax", "mistral", "openai", "test-stream", "together"}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("RegisteredProviders(stream) = %#v, want %#v", got, want)
 	}
@@ -215,7 +215,6 @@ func TestConfiguredProviderStreamsSkipWithoutCredentials(t *testing.T) {
 		{provider: "mistral", keyEnv: "MISTRAL_API_KEY", modelEnv: "MISTRAL_MODEL"},
 		{provider: "together", keyEnv: "TOGETHER_API_KEY", modelEnv: "TOGETHER_MODEL"},
 		{provider: "atlascloud", keyEnv: "ATLASCLOUD_API_KEY", modelEnv: "ATLASCLOUD_MODEL"},
-		{provider: "anthropic", keyEnv: "ANTHROPIC_API_KEY", modelEnv: "ANTHROPIC_MODEL"},
 	} {
 		tc := tc
 		t.Run(tc.provider, func(t *testing.T) {
@@ -257,7 +256,7 @@ func TestConfiguredProviderStreamsSkipWithoutCredentials(t *testing.T) {
 }

 func TestUnsupportedProvidersReturnStreamingUnsupportedAndStayUnregistered(t *testing.T) {
-	for _, provider := range []string{"gemini"} {
+	for _, provider := range []string{"anthropic", "gemini"} {
 		provider := provider
 		t.Run(provider, func(t *testing.T) {
 			if caps := ai.ProviderCapabilities(provider); caps.Stream {
@@ -52,25 +52,6 @@ This starts:

 Open http://localhost:8080 to see your services and call them from the browser.

-Call the generated service from another terminal:
-
-```
-curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
-  -H 'Content-Type: application/json' -d '{"name":"World"}'
-```
-
-## First agent on-ramp
-
-Once the scaffold → run → call path works, ask the installed CLI for the
-provider-free agent path:
-
-```
-micro agent demo
-```
-
-That points at the smallest mock-model first-agent example and the no-secret
-transcript before you add provider-backed chat.
-
 ### Output

 ```
@@ -14,31 +14,6 @@ import (
 	"go-micro.dev/v6/store"
 )

-const noSecretDemoHelp = `No-secret first-agent demo
-
-Use this when you want the fastest provider-free agent success path before
-configuring API keys. It runs the maintained support/first-agent transcript with
-the deterministic mock model used by CI:
-
-  go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1
-
-What this proves:
-  - service tools can be called by an agent
-  - chat behavior is exercised without contacting a live provider
-  - run history can be inspected after the prompt
-
-After it passes:
-  - Build your own service-backed agent: https://go-micro.dev/docs/guides/your-first-agent.html
-  - Diagnose provider-backed chat:     https://go-micro.dev/docs/guides/debugging-agents.html
-  - Walk the full 0→hero lifecycle:    https://go-micro.dev/docs/guides/zero-to-hero.html
-
-Use live-provider chat when you are ready for real model behavior:
-  micro agent preflight  # before micro run: prerequisites
-  micro run
-  micro chat
-  micro agent doctor     # after micro run: chat/gateway/inspect recovery
-  micro inspect agent <name>`
-
 func init() {
 	cmd.Register(&cli.Command{
 		Name:      "runs",
@@ -59,36 +34,16 @@ func init() {

 	cmd.Register(&cli.Command{
 		Name:  "agent",
-		Usage: "Manage AI agents (try: micro agent demo)",
+		Usage: "Manage AI agents",
 		Subcommands: []*cli.Command{
 			{
-				Name:  "demo",
-				Usage: "Show the no-secret first-agent demo command",
-				Description: `Print the provider-free first-agent path for new developers:
-the deterministic mock-model transcript, when to use it, and where to go next
-for live-provider chat and inspect/debugging.`,
-				Action: func(c *cli.Context) error {
-					fmt.Fprintln(c.App.Writer, noSecretDemoHelp)
-					return nil
-				},
-			},
-			{
-				Name:  "preflight",
-				Usage: "Check local prerequisites before the first provider-backed agent",
+				Name:    "preflight",
+				Aliases: []string{"doctor"},
+				Usage:   "Check local prerequisites before the first provider-backed agent",
 				Action: func(c *cli.Context) error {
 					return runAgentPreflight(os.Stdout, defaultPreflightDeps())
 				},
 			},
-			{
-				Name:  "doctor",
-				Usage: "Diagnose chat, gateway, registration, provider, and inspect recovery after micro run",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "gateway", Value: "http://localhost:8080", Usage: "Gateway URL started by micro run"},
-				},
-				Action: func(c *cli.Context) error {
-					return runAgentDoctor(os.Stdout, defaultDoctorDeps(), c.String("gateway"))
-				},
-			},
 			{
 				Name:  "list",
 				Usage: "List registered agents",
@@ -1,179 +0,0 @@
-package agent
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-
-	goagent "go-micro.dev/v6/agent"
-	"go-micro.dev/v6/registry"
-	"go-micro.dev/v6/store"
-)
-
-type doctorDeps struct {
-	getenv       func(string) string
-	httpGet      func(string) (*http.Response, error)
-	listServices func() ([]*registry.Service, error)
-	getService   func(string) ([]*registry.Service, error)
-	listRuns     func(string) ([]goagent.RunSummary, error)
-}
-
-func defaultDoctorDeps() doctorDeps {
-	client := &http.Client{Timeout: 2 * time.Second}
-	return doctorDeps{
-		getenv:       defaultPreflightDeps().getenv,
-		httpGet:      client.Get,
-		listServices: registry.ListServices,
-		getService:   registry.GetService,
-		listRuns: func(name string) ([]goagent.RunSummary, error) {
-			return goagent.ListRunSummariesWithOptions(store.DefaultStore, name, goagent.RunListOptions{Limit: 1})
-		},
-	}
-}
-
-func runAgentDoctor(w io.Writer, deps doctorDeps, gateway string) error {
-	if gateway == "" {
-		gateway = "http://localhost:8080"
-	}
-	gateway = strings.TrimRight(gateway, "/")
-	checks := agentDoctorChecks(deps, gateway)
-	failures := 0
-	fmt.Fprintln(w, "First-agent recovery doctor")
-	for _, check := range checks {
-		mark := "✓"
-		if !check.OK {
-			mark = "✗"
-			failures++
-		}
-		fmt.Fprintf(w, "  %s %s — %s\n", mark, check.Name, check.Detail)
-		if !check.OK && check.Fix != "" {
-			fmt.Fprintf(w, "    Fix: %s\n", check.Fix)
-		}
-		if !check.OK && check.Next != "" {
-			fmt.Fprintf(w, "    Next: %s\n", check.Next)
-		}
-	}
-	if failures > 0 {
-		return fmt.Errorf("first-agent doctor found %d recovery boundary issue(s)", failures)
-	}
-	fmt.Fprintln(w, "\nReady: gateway, agent registration, chat settings, and inspect history are reachable.")
-	return nil
-}
-
-func agentDoctorChecks(deps doctorDeps, gateway string) []preflightCheck {
-	if deps.getenv == nil {
-		deps.getenv = defaultPreflightDeps().getenv
-	}
-	if deps.httpGet == nil {
-		deps.httpGet = http.Get
-	}
-	if deps.listServices == nil {
-		deps.listServices = registry.ListServices
-	}
-	if deps.getService == nil {
-		deps.getService = registry.GetService
-	}
-	if deps.listRuns == nil {
-		deps.listRuns = func(name string) ([]goagent.RunSummary, error) {
-			return goagent.ListRunSummariesWithOptions(store.DefaultStore, name, goagent.RunListOptions{Limit: 1})
-		}
-	}
-
-	checks := []preflightCheck{checkGateway(deps, gateway), checkChatSettings(deps, gateway)}
-	agents, regCheck := checkAgentRegistration(deps)
-	checks = append(checks, regCheck)
-	checks = append(checks, checkRunHistory(deps, agents))
-	checks = append(checks, checkProviderConfig(deps))
-	return checks
-}
-
-func checkGateway(deps doctorDeps, gateway string) preflightCheck {
-	resp, err := deps.httpGet(gateway + "/agent")
-	if err != nil {
-		return preflightCheck{Name: "gateway /agent", Detail: err.Error(), Fix: "Start the local gateway with `micro run`, or pass the matching URL with `micro agent doctor --gateway http://localhost:<port>`.", Next: "Then open " + gateway + "/agent or retry `micro chat`."}
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return preflightCheck{Name: "gateway /agent", Detail: fmt.Sprintf("%s returned %s", gateway+"/agent", resp.Status), Fix: "Confirm `micro run` is serving the web gateway and that auth/proxy settings are not blocking /agent.", Next: "See docs/guides/debugging-agents.html#chat-and-gateway-failures."}
-	}
-	return preflightCheck{Name: "gateway /agent", OK: true, Detail: gateway + "/agent is reachable"}
-}
-
-func checkChatSettings(deps doctorDeps, gateway string) preflightCheck {
-	resp, err := deps.httpGet(gateway + "/api/agent/settings")
-	if err != nil {
-		return preflightCheck{Name: "chat settings endpoint", Detail: err.Error(), Fix: "Keep `micro run` running and retry; the playground uses /api/agent/settings before chat prompts.", Next: "See docs/guides/debugging-agents.html#chat-and-gateway-failures."}
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return preflightCheck{Name: "chat settings endpoint", Detail: fmt.Sprintf("returned %s", resp.Status), Fix: "Check gateway auth/proxy configuration or use the Agent settings page to confirm chat settings load.", Next: "See docs/guides/debugging-agents.html#provider-failures."}
-	}
-	var settings map[string]string
-	_ = json.NewDecoder(resp.Body).Decode(&settings)
-	if settings["provider"] != "" || settings["model"] != "" || settings["api_key"] != "" {
-		return preflightCheck{Name: "chat settings endpoint", OK: true, Detail: "reachable with saved provider settings"}
-	}
-	return preflightCheck{Name: "chat settings endpoint", OK: true, Detail: "reachable; no saved provider settings"}
-}
-
-func checkAgentRegistration(deps doctorDeps) ([]string, preflightCheck) {
-	services, err := deps.listServices()
-	if err != nil {
-		return nil, preflightCheck{Name: "agent registration", Detail: err.Error(), Fix: "Keep the scaffolded agent process running under `micro run` and retry `micro agent list`.", Next: "See docs/guides/your-first-agent.html#run-your-agent."}
-	}
-	var agents []string
-	for _, svc := range services {
-		records, err := deps.getService(svc.Name)
-		if err != nil || len(records) == 0 {
-			continue
-		}
-		if serviceIsAgent(records[0]) {
-			agents = append(agents, svc.Name)
-		}
-	}
-	if len(agents) == 0 {
-		return nil, preflightCheck{Name: "agent registration", Detail: "no registered agent services found", Fix: "Start an agent project with `micro run` and confirm `micro agent list` shows it.", Next: "Use docs/guides/no-secret-first-agent.html for a deterministic no-provider agent."}
-	}
-	return agents, preflightCheck{Name: "agent registration", OK: true, Detail: "found " + strings.Join(agents, ", ")}
-}
-
-func serviceIsAgent(svc *registry.Service) bool {
-	if svc.Metadata != nil && svc.Metadata["type"] == "agent" {
-		return true
-	}
-	for _, node := range svc.Nodes {
-		if node.Metadata != nil && node.Metadata["type"] == "agent" {
-			return true
-		}
-	}
-	return false
-}
-
-func checkRunHistory(deps doctorDeps, agents []string) preflightCheck {
-	if len(agents) == 0 {
-		return preflightCheck{Name: "inspect run history", Detail: "skipped because no agent is registered", Fix: "Fix agent registration first, then chat once and run `micro inspect agent <name>`.", Next: "See docs/guides/debugging-agents.html#inspect-run-history."}
-	}
-	for _, name := range agents {
-		runs, err := deps.listRuns(name)
-		if err != nil {
-			return preflightCheck{Name: "inspect run history", Detail: err.Error(), Fix: "Ensure the local store is writable and retry `micro inspect agent " + name + "`.", Next: "See docs/guides/debugging-agents.html#inspect-run-history."}
-		}
-		if len(runs) > 0 {
-			return preflightCheck{Name: "inspect run history", OK: true, Detail: "recent runs available for " + name}
-		}
-	}
-	return preflightCheck{Name: "inspect run history", Detail: "no recorded agent runs yet", Fix: "Send one prompt with `micro chat` or the /agent playground, then run `micro inspect agent " + agents[0] + "`.", Next: "See docs/guides/your-first-agent.html#inspect-what-happened."}
-}
-
-func checkProviderConfig(deps doctorDeps) preflightCheck {
-	check := checkProviderKey(preflightDeps{getenv: deps.getenv})
-	check.Name = "provider configuration"
-	if !check.OK {
-		check.Detail = "no provider key found for live LLM chat"
-		check.Fix = "For provider-backed chat, export MICRO_AI_API_KEY or a provider-specific key; for no-secret recovery, use the mock-model walkthrough."
-	}
-	return check
-}
@@ -1,75 +0,0 @@
-package agent
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-
-	goagent "go-micro.dev/v6/agent"
-	"go-micro.dev/v6/registry"
-)
-
-func doctorHTTP(status int, body string) func(string) (*http.Response, error) {
-	return func(string) (*http.Response, error) {
-		return &http.Response{StatusCode: status, Status: "200 OK", Body: io.NopCloser(strings.NewReader(body))}, nil
-	}
-}
-
-func TestRunAgentDoctorPassesWhenRecoveryBoundariesReachable(t *testing.T) {
-	deps := doctorDeps{
-		getenv: func(key string) string {
-			if key == "MICRO_AI_API_KEY" {
-				return "set"
-			}
-			return ""
-		},
-		httpGet: doctorHTTP(200, `{"provider":"anthropic","model":"claude"}`),
-		listServices: func() ([]*registry.Service, error) {
-			return []*registry.Service{{Name: "assistant"}}, nil
-		},
-		getService: func(name string) ([]*registry.Service, error) {
-			return []*registry.Service{{Name: name, Metadata: map[string]string{"type": "agent"}}}, nil
-		},
-		listRuns: func(name string) ([]goagent.RunSummary, error) {
-			return []goagent.RunSummary{{RunID: "run-1", Status: "done"}}, nil
-		},
-	}
-	var out bytes.Buffer
-	if err := runAgentDoctor(&out, deps, "http://example.test"); err != nil {
-		t.Fatalf("runAgentDoctor() error = %v\n%s", err, out.String())
-	}
-	got := out.String()
-	for _, want := range []string{"First-agent recovery doctor", "✓ gateway /agent", "✓ chat settings endpoint", "✓ agent registration", "✓ inspect run history", "✓ provider configuration", "Ready:"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestRunAgentDoctorReportsActionableRecoveryFailures(t *testing.T) {
-	deps := doctorDeps{
-		getenv:  func(string) string { return "" },
-		httpGet: func(string) (*http.Response, error) { return nil, errors.New("connection refused") },
-		listServices: func() ([]*registry.Service, error) {
-			return []*registry.Service{{Name: "greeter"}}, nil
-		},
-		getService: func(name string) ([]*registry.Service, error) {
-			return []*registry.Service{{Name: name}}, nil
-		},
-		listRuns: func(name string) ([]goagent.RunSummary, error) { return nil, nil },
-	}
-	var out bytes.Buffer
-	err := runAgentDoctor(&out, deps, "http://localhost:8080")
-	if err == nil {
-		t.Fatal("runAgentDoctor() error = nil")
-	}
-	got := out.String()
-	for _, want := range []string{"✗ gateway /agent", "micro run", "✗ chat settings endpoint", "✗ agent registration", "micro agent list", "✗ inspect run history", "micro inspect agent <name>", "✗ provider configuration", "docs/guides/no-secret-first-agent.html"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
@@ -26,33 +26,25 @@ import (

 const docsWayfinding = `First-agent and 0→hero docs:

-  1. Start with the no-secret CLI demo
-       micro agent demo
-     This prints the maintained support-agent transcript command so you can
-     prove service tools, mock-model chat, and inspectable run history without
-     configuring a provider key.
-
-  2. No-secret first-agent transcript
+  1. No-secret first-agent transcript
     https://go-micro.dev/docs/guides/no-secret-first-agent.html
     Run the maintained support agent without a provider key:
       go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1

-  3. Your First Agent
+  2. Your First Agent
     https://go-micro.dev/docs/guides/your-first-agent.html
     Build a service-backed agent, then use:
-       micro agent preflight  # before micro run: prerequisites
+       micro agent preflight
       micro run
       micro chat
-       micro agent doctor     # after micro run: chat/gateway/inspect recovery

-  4. Debugging your agent
+  3. Debugging your agent
     https://go-micro.dev/docs/guides/debugging-agents.html
     Inspect agent runs and memory with:
-       micro agent doctor
       micro inspect agent
       micro runs <agent>

-  5. 0→hero Reference
+  4. 0→hero Reference
     https://go-micro.dev/docs/guides/zero-to-hero.html
     Walk the scaffold → run → chat → inspect → deploy dry-run lifecycle.`

@@ -1,7 +1,6 @@
 package new

 import (
-	"bytes"
 	"errors"
 	"flag"
 	"os"
@@ -58,44 +57,6 @@ func TestZeroToOneNoMCPContract(t *testing.T) {
 	generated.call(t, "Bob", "Hello Bob")
 }

-func TestPrintNextStepsSurfacesFirstAgentPath(t *testing.T) {
-	var out bytes.Buffer
-	printNextSteps(&out, "helloworld", false)
-
-	for _, want := range []string{
-		"cd helloworld",
-		"micro agent preflight",
-		"go run .",
-		"micro chat",
-		"micro inspect agent",
-		"micro agent demo",
-		"micro docs",
-		"your-first-agent.html",
-		"zero-to-hero.html",
-		"http://localhost:3001/mcp/tools",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("next steps missing %q:\n%s", want, out.String())
-		}
-	}
-}
-
-func TestPrintNextStepsNoMCPSkipsMCPHints(t *testing.T) {
-	var out bytes.Buffer
-	printNextSteps(&out, "worker", true)
-
-	for _, want := range []string{"micro agent preflight", "micro chat", "micro inspect agent", "micro agent demo", "micro docs"} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("--no-mcp next steps missing %q:\n%s", want, out.String())
-		}
-	}
-	for _, notWant := range []string{"http://localhost:3001/mcp/tools", "micro mcp serve"} {
-		if strings.Contains(out.String(), notWant) {
-			t.Fatalf("--no-mcp next steps should not include %q:\n%s", notWant, out.String())
-		}
-	}
-}
-
 type generatedService struct {
 	dir      string
 	repoRoot string
@@ -6,7 +6,6 @@ import (
 	"context"
 	"fmt"
 	"go/build"
-	"io"
 	"os"
 	"os/exec"
 	"os/signal"
@@ -281,29 +280,16 @@ func Run(ctx *cli.Context) error {

 	fmt.Println()
 	fmt.Printf("  \033[32m✓\033[0m Service \033[36m%s\033[0m created\n\n", dir)
-	printNextSteps(os.Stdout, dir, noMCP)
-	return nil
-}
-
-func printNextSteps(w io.Writer, dir string, noMCP bool) {
-	fmt.Fprintln(w, "  Next steps:")
-	fmt.Fprintf(w, "    cd %s\n", dir)
-	fmt.Fprintln(w, "    micro agent preflight")
-	fmt.Fprintln(w, "    go run .")
-	fmt.Fprintln(w, "    micro chat")
-	fmt.Fprintln(w, "    micro inspect agent")
-	fmt.Fprintln(w)
-	fmt.Fprintln(w, "  First-agent path:")
-	fmt.Fprintln(w, "    micro agent demo")
-	fmt.Fprintln(w, "    micro docs")
-	fmt.Fprintln(w, "    https://go-micro.dev/docs/guides/your-first-agent.html")
-	fmt.Fprintln(w, "    https://go-micro.dev/docs/guides/zero-to-hero.html")
+	fmt.Println("  Next steps:")
+	fmt.Printf("    cd %s\n", dir)
+	fmt.Println("    go run .")
 	if !noMCP {
-		fmt.Fprintln(w)
-		fmt.Fprintf(w, "    MCP tools   \033[36mhttp://localhost:3001/mcp/tools\033[0m\n")
-		fmt.Fprintln(w, "    Claude Code \033[2mmicro mcp serve\033[0m")
+		fmt.Println()
+		fmt.Printf("    MCP tools   \033[36mhttp://localhost:3001/mcp/tools\033[0m\n")
+		fmt.Println("    Claude Code \033[2mmicro mcp serve\033[0m")
 	}
-	fmt.Fprintln(w)
+	fmt.Println()
+	return nil
 }

 func selectTemplates(name string, noMCP bool) (mainTmpl, handlerTmpl, protoTmpl string) {
@@ -30,12 +30,6 @@ func TestFirstAgentWalkthroughCLIBoundaries(t *testing.T) {
 	if !subcommands["agent"]["preflight"] {
 		t.Fatal("first-agent walkthrough missing preflight boundary: agent preflight")
 	}
-	if !subcommands["agent"]["demo"] {
-		t.Fatal("first-agent walkthrough missing no-secret boundary: agent demo")
-	}
-	if !subcommands["agent"]["doctor"] {
-		t.Fatal("first-agent walkthrough missing recovery boundary: agent doctor")
-	}
 	if !subcommands["inspect"]["agent"] {
 		t.Fatal("first-agent walkthrough missing inspect boundary: inspect agent")
 	}
@@ -55,58 +49,20 @@ func TestFirstAgentWalkthroughCLIBoundaries(t *testing.T) {
 	if err := docs.Action(cli.NewContext(app, nil, nil)); err != nil {
 		t.Fatalf("micro docs failed: %v", err)
 	}
-	if demoIdx, guideIdx := strings.Index(out.String(), "micro agent demo"), strings.Index(out.String(), "no-secret-first-agent.html"); demoIdx < 0 || guideIdx < 0 || demoIdx > guideIdx {
-		t.Fatalf("micro docs should lead with micro agent demo before guide links:\n%s", out.String())
-	}
 	for _, want := range []string{
-		"micro agent demo",
 		"no-secret-first-agent.html",
 		"your-first-agent.html",
 		"debugging-agents.html",
 		"zero-to-hero.html",
-		"micro agent preflight  # before micro run: prerequisites",
+		"micro agent preflight",
 		"micro run",
 		"micro chat",
-		"micro agent doctor     # after micro run: chat/gateway/inspect recovery",
 		"micro inspect agent",
 	} {
 		if !strings.Contains(out.String(), want) {
 			t.Fatalf("micro docs output missing %q:\n%s", want, out.String())
 		}
 	}
-
-	agent := commandByName(t, "agent")
-	if !strings.Contains(agent.Usage, "micro agent demo") {
-		t.Fatalf("micro agent help should advertise the no-secret demo; usage was %q", agent.Usage)
-	}
-	doctor := subcommandByName(t, agent, "doctor")
-	for _, want := range []string{"chat", "gateway", "registration", "provider", "inspect", "after micro run"} {
-		if !strings.Contains(doctor.Usage, want) {
-			t.Fatalf("micro agent doctor usage should advertise after-run recovery for %q; usage was %q", want, doctor.Usage)
-		}
-	}
-
-	demo := subcommandByName(t, agent, "demo")
-	out.Reset()
-	if err := demo.Action(cli.NewContext(app, nil, nil)); err != nil {
-		t.Fatalf("micro agent demo failed: %v", err)
-	}
-	for _, want := range []string{
-		"No-secret first-agent demo",
-		"go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1",
-		"provider-free",
-		"micro agent preflight  # before micro run: prerequisites",
-		"micro chat",
-		"micro agent doctor     # after micro run: chat/gateway/inspect recovery",
-		"micro inspect agent <name>",
-		"your-first-agent.html",
-		"debugging-agents.html",
-		"zero-to-hero.html",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("micro agent demo output missing %q:\n%s", want, out.String())
-		}
-	}
 }

 func commandByName(t *testing.T, name string) *cli.Command {
@@ -119,14 +75,3 @@ func commandByName(t *testing.T, name string) *cli.Command {
 	t.Fatalf("missing command %q", name)
 	return nil
 }
-
-func subcommandByName(t *testing.T, command *cli.Command, name string) *cli.Command {
-	t.Helper()
-	for _, subcommand := range command.Subcommands {
-		if subcommand.Name == name {
-			return subcommand
-		}
-	}
-	t.Fatalf("missing subcommand %q under %q", name, command.Name)
-	return nil
-}
@@ -14,10 +14,8 @@ import (

 type config struct {
 	// the current values
-	vals    reader.Values
-	exit    chan bool
-	closeMu sync.Mutex
-	closed  bool
+	vals reader.Values
+	exit chan bool
 	// the current snapshot
 	snap *loader.Snapshot
 	opts Options
@@ -50,9 +48,6 @@ func (c *config) Init(opts ...Option) error {
 		Reader: json.NewReader(),
 	}
 	c.exit = make(chan bool)
-	c.closeMu.Lock()
-	c.closed = false
-	c.closeMu.Unlock()
 	for _, o := range opts {
 		o(&c.opts)
 	}
@@ -189,15 +184,12 @@ func (c *config) Sync() error {
 }

 func (c *config) Close() error {
-	c.closeMu.Lock()
-	defer c.closeMu.Unlock()
-
-	if c.closed {
+	select {
+	case <-c.exit:
 		return nil
+	default:
+		close(c.exit)
 	}
-
-	close(c.exit)
-	c.closed = true
 	return nil
 }

@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-	"sync"
 	"testing"
 	"time"

@@ -46,30 +45,6 @@ func createFileForTest(t *testing.T) *os.File {
 	return fh
 }

-func TestConfigCloseConcurrentIdempotent(t *testing.T) {
-	conf, err := NewConfig(WithWatcherDisabled())
-	if err != nil {
-		t.Fatalf("Expected no error but got %v", err)
-	}
-
-	const goroutines = 64
-	var wg sync.WaitGroup
-	wg.Add(goroutines)
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			defer wg.Done()
-			if err := conf.Close(); err != nil {
-				t.Errorf("Expected close to be idempotent but got %v", err)
-			}
-		}()
-	}
-	wg.Wait()
-
-	if err := conf.Close(); err != nil {
-		t.Fatalf("Expected repeated close to be idempotent but got %v", err)
-	}
-}
-
 func TestConfigLoadWithGoodFile(t *testing.T) {
 	fh := createFileForTest(t)
 	path := fh.Name()
@@ -18,10 +18,8 @@ import (

 type memory struct {
 	// the current values
-	vals    reader.Values
-	exit    chan bool
-	closeMu sync.Mutex
-	closed  bool
+	vals reader.Values
+	exit chan bool
 	// the current snapshot
 	snap *loader.Snapshot

@@ -272,15 +270,12 @@ func (m *memory) Sync() error {
 }

 func (m *memory) Close() error {
-	m.closeMu.Lock()
-	defer m.closeMu.Unlock()
-
-	if m.closed {
+	select {
+	case <-m.exit:
 		return nil
+	default:
+		close(m.exit)
 	}
-
-	close(m.exit)
-	m.closed = true
 	return nil
 }

@@ -12,11 +12,9 @@ of reading the directories alphabetically.

 ## Recommended first-agent path

-This path is the canonical services → agents → workflows route through the examples map. Debugging and observability wayfinding stays nearby once the first run works.
-
 | Step | Start here | What you learn | Next step |
 |------|------------|----------------|-----------|
-| 1. First service | [`hello-world`](./hello-world/) | Build the 0→1 service path: create and register a basic RPC service, add a handler, call it with a client, and expose health checks. | Move to [`agent-demo`](./agent-demo/) to see services used by an agent. |
+| 1. First service | [`hello-world`](./hello-world/) | Create and register a basic RPC service, add a handler, call it with a client, and expose health checks. | Move to [`agent-demo`](./agent-demo/) to see services used by an agent. |
 | 2. First agent | [`first-agent`](./first-agent/) | Run the smallest service-backed agent with a deterministic mock model and no provider key. | Compare with [`agent-demo`](./agent-demo/) or the maintained 0-to-hero path in [`support`](./support/). |
 | 3. First workflow | [`support`](./support/) | Follow typed services into an agent chat loop, an event-driven `intake` flow, and an approval gate in one runnable reference. | Deepen the workflow model with [`flow-durable`](./flow-durable/). |

@@ -3,7 +3,6 @@ package zerotoheroci
 import (
 	"os"
 	"path/filepath"
-	"regexp"
 	"strings"
 	"testing"
 )
@@ -89,8 +88,6 @@ func TestFirstAgentWayfindingDocs(t *testing.T) {
 			file:    filepath.Join(root, "README.md"),
 			heading: "### First agent on-ramp",
 			links: []string{
-				"internal/website/docs/guides/install-troubleshooting.md",
-				"micro agent demo",
 				"internal/website/docs/guides/no-secret-first-agent.md",
 				"internal/website/docs/guides/your-first-agent.md",
 				"internal/website/docs/guides/debugging-agents.md",
@@ -132,8 +129,6 @@ func TestFirstAgentWayfindingDocs(t *testing.T) {
 			file:    filepath.Join(root, "internal", "website", "docs", "getting-started.md"),
 			heading: "### First-agent on-ramp",
 			links: []string{
-				"guides/install-troubleshooting.html",
-				"micro agent demo",
 				"guides/no-secret-first-agent.html",
 				"guides/your-first-agent.html",
 				"guides/debugging-agents.html",
@@ -151,7 +146,6 @@ func TestFirstAgentWayfindingDocs(t *testing.T) {
 				if idx == -1 {
 					t.Fatalf("%s missing first-agent wayfinding link %q; keep the no-secret → first-agent → debugging → 0→hero path discoverable", check.name, link)
 				}
-				assertWayfindingTargetExists(t, root, check.file, link)
 				if idx < last {
 					t.Fatalf("%s link %q appeared out of order; expected no-secret → first-agent → debugging → 0→hero", check.name, link)
 				}
@@ -161,262 +155,11 @@ func TestFirstAgentWayfindingDocs(t *testing.T) {
 	}
 }

-func TestFirstAgentWayfindingLinkTargetsResolve(t *testing.T) {
-	root := filepath.Clean(filepath.Join("..", "..", ".."))
-	checks := []struct {
-		name    string
-		file    string
-		heading string
-	}{
-		{
-			name:    "README first-agent on-ramp",
-			file:    filepath.Join(root, "README.md"),
-			heading: "### First agent on-ramp",
-		},
-		{
-			name:    "README examples list",
-			file:    filepath.Join(root, "README.md"),
-			heading: "## Examples",
-		},
-		{
-			name:    "repository examples index",
-			file:    filepath.Join(root, "examples", "README.md"),
-			heading: "## Recommended first-agent path",
-		},
-		{
-			name:    "website examples index",
-			file:    filepath.Join(root, "internal", "website", "docs", "examples", "index.md"),
-			heading: "## Start here",
-		},
-		{
-			name:    "website getting-started on-ramp",
-			file:    filepath.Join(root, "internal", "website", "docs", "getting-started.md"),
-			heading: "### First-agent on-ramp",
-		},
-	}
-
-	for _, check := range checks {
-		t.Run(check.name, func(t *testing.T) {
-			section := firstMarkdownSection(t, readFile(t, check.file), check.heading)
-			links := markdownLinks(section)
-			if len(links) == 0 {
-				t.Fatalf("%s has no Markdown links in %q", check.name, check.heading)
-			}
-			for _, link := range links {
-				assertWayfindingTargetExists(t, root, check.file, link)
-			}
-		})
-	}
-}
-
-func TestFirstAgentLifecycleCommandOrderIsDocumented(t *testing.T) {
-	root := filepath.Clean(filepath.Join("..", "..", ".."))
-	checks := []struct {
-		name    string
-		file    string
-		heading string
-		markers []string
-	}{
-		{
-			name:    "0→hero guide lifecycle",
-			file:    filepath.Join(root, "internal", "website", "docs", "guides", "zero-to-hero.md"),
-			heading: "## What the contract covers",
-			markers: []string{"micro new", "micro run", "micro chat", "micro inspect agent", "micro deploy --dry-run"},
-		},
-		{
-			name:    "CLI docs lifecycle",
-			file:    filepath.Join(root, "cmd", "micro", "cli", "cli.go"),
-			heading: "const docsWayfinding",
-			markers: []string{"micro agent demo", "micro run", "micro chat", "micro inspect agent", "deploy dry-run"},
-		},
-		{
-			name:    "scaffold next steps",
-			file:    filepath.Join(root, "cmd", "micro", "cli", "new", "new.go"),
-			heading: "func printNextSteps",
-			markers: []string{"go run .", "micro chat", "micro inspect agent", "micro agent demo", "micro docs"},
-		},
-	}
-
-	for _, check := range checks {
-		t.Run(check.name, func(t *testing.T) {
-			doc := readFile(t, check.file)
-			if check.heading != "" {
-				start := strings.Index(doc, check.heading)
-				if start == -1 {
-					t.Fatalf("%s missing %q boundary", check.name, check.heading)
-				}
-				doc = doc[start:]
-			}
-			assertOrderedMarkers(t, check.name, doc, check.markers)
-		})
-	}
-}
-
-func TestExamplesIndexesPreserveLifecycleMap(t *testing.T) {
-	root := filepath.Clean(filepath.Join("..", "..", ".."))
-	checks := []struct {
-		name    string
-		file    string
-		heading string
-		want    []string
-		ordered []string
-	}{
-		{
-			name:    "repository examples lifecycle map",
-			file:    filepath.Join(root, "examples", "README.md"),
-			heading: "## Recommended first-agent path",
-			want: []string{
-				"hello-world",
-				"0→1",
-				"first-agent",
-				"support",
-				"services",
-				"agents",
-				"workflows",
-				"Debugging and observability",
-			},
-			ordered: []string{"1. First service", "2. First agent", "3. First workflow"},
-		},
-		{
-			name:    "website examples lifecycle map",
-			file:    filepath.Join(root, "internal", "website", "docs", "examples", "index.md"),
-			heading: "## Start here",
-			want: []string{
-				"examples/hello-world",
-				"0→1",
-				"examples/first-agent",
-				"examples/support",
-				"services",
-				"agents",
-				"workflows",
-				"debugging-agents.html",
-			},
-			ordered: []string{"0→1 service", "Provider-free first agent", "0→hero lifecycle"},
-		},
-	}
-
-	for _, check := range checks {
-		t.Run(check.name, func(t *testing.T) {
-			section := firstMarkdownSection(t, readFile(t, check.file), check.heading)
-			for _, want := range check.want {
-				if !strings.Contains(section, want) {
-					t.Fatalf("%s missing lifecycle map marker %q", check.name, want)
-				}
-			}
-
-			last := -1
-			for _, marker := range check.ordered {
-				idx := strings.Index(section, marker)
-				if idx == -1 {
-					t.Fatalf("%s missing ordered example marker %q", check.name, marker)
-				}
-				if idx < last {
-					t.Fatalf("%s marker %q appeared out of order; keep examples flowing hello-world/0→1 → first-agent → support/0→hero", check.name, marker)
-				}
-				last = idx
-			}
-		})
-	}
-}
-
-func TestGettingStartedDocsLeadWithNoSecretFirstRun(t *testing.T) {
-	root := filepath.Clean(filepath.Join("..", "..", ".."))
-	checks := []struct {
-		name    string
-		file    string
-		section string
-		want    []string
-	}{
-		{
-			name:    "README quick start",
-			file:    filepath.Join(root, "README.md"),
-			section: "## Quick Start",
-			want: []string{
-				"install troubleshooting guide",
-				"### Fastest start — no API key",
-				"micro new helloworld",
-				"micro run",
-				"curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call",
-				"### First agent on-ramp",
-				"micro agent demo",
-				"### Generate from a prompt — with an LLM key",
-			},
-		},
-		{
-			name:    "CLI README",
-			file:    filepath.Join(root, "cmd", "micro", "README.md"),
-			section: "## Create a service",
-			want: []string{
-				"## Create a service",
-				"micro new helloworld",
-				"## Run the service",
-				"micro run",
-				"micro agent demo",
-			},
-		},
-		{
-			name:    "website getting started",
-			file:    filepath.Join(root, "internal", "website", "docs", "getting-started.md"),
-			section: "Install troubleshooting",
-			want: []string{
-				"Install troubleshooting",
-				"## Quick Start: Scaffold, Run, Call",
-				"micro new helloworld",
-				"micro run",
-				"curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call",
-				"### First-agent on-ramp",
-				"micro agent demo",
-				"## Generate from a Prompt — with an LLM key",
-			},
-		},
-		{
-			name:    "website quickstart",
-			file:    filepath.Join(root, "internal", "website", "docs", "quickstart.md"),
-			section: "## Create Your First Service",
-			want: []string{
-				"micro new helloworld",
-				"micro run",
-				"curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call",
-				"## Next Steps",
-				"micro agent demo",
-				"guides/no-secret-first-agent.html",
-				"guides/debugging-agents.html",
-				"guides/zero-to-hero.html",
-			},
-		},
-	}
-
-	for _, check := range checks {
-		t.Run(check.name, func(t *testing.T) {
-			doc := readFile(t, check.file)
-			if check.section != "" {
-				start := strings.Index(doc, check.section)
-				if start == -1 {
-					t.Fatalf("%s missing %q section", check.name, check.section)
-				}
-				doc = doc[start:]
-			}
-			last := -1
-			for _, want := range check.want {
-				idx := strings.Index(doc, want)
-				if idx == -1 {
-					t.Fatalf("%s missing no-secret first-run marker %q", check.name, want)
-				}
-				if idx < last {
-					t.Fatalf("%s marker %q appeared out of order; keep install/scaffold/run/call before provider-backed generation", check.name, want)
-				}
-				last = idx
-			}
-		})
-	}
-}
-
 func TestNoSecretFirstAgentTranscript(t *testing.T) {
 	root := filepath.Clean(filepath.Join("..", "..", ".."))
 	guide := readFile(t, filepath.Join(root, "internal", "website", "docs", "guides", "no-secret-first-agent.md"))

 	for _, want := range []string{
-		"micro agent demo",
 		"go run ./examples/first-agent",
 		"go test ./examples/first-agent -run TestRunFirstAgent -count=1",
 		"go run ./examples/support",
@@ -497,67 +240,3 @@ func readFile(t *testing.T, name string) string {
 	}
 	return string(data)
 }
-
-var markdownLinkRE = regexp.MustCompile(`\[[^\]]+\]\(([^)#?]+)(?:[#?][^)]*)?\)`)
-
-func markdownLinks(section string) []string {
-	matches := markdownLinkRE.FindAllStringSubmatch(section, -1)
-	links := make([]string, 0, len(matches))
-	for _, match := range matches {
-		if len(match) > 1 {
-			links = append(links, match[1])
-		}
-	}
-	return links
-}
-
-func assertWayfindingTargetExists(t *testing.T, root, sourceFile, link string) {
-	t.Helper()
-	if !strings.Contains(link, "/") && !strings.Contains(link, ".") {
-		return
-	}
-	if strings.HasPrefix(link, "http://") || strings.HasPrefix(link, "https://") {
-		switch {
-		case strings.HasPrefix(link, "https://go-micro.dev/docs/"):
-			link = strings.TrimPrefix(link, "https://go-micro.dev/docs/")
-			link = filepath.ToSlash(filepath.Join("internal", "website", "docs", strings.TrimSuffix(link, ".html")+".md"))
-		case strings.HasPrefix(link, "https://github.com/micro/go-micro/tree/master/"):
-			link = strings.TrimPrefix(link, "https://github.com/micro/go-micro/tree/master/")
-		default:
-			return
-		}
-	} else if strings.HasSuffix(link, ".html") {
-		sourceDir := filepath.Dir(sourceFile)
-		websiteDocs := filepath.Join(root, "internal", "website", "docs")
-		resolved := filepath.Clean(filepath.Join(sourceDir, filepath.FromSlash(link)))
-		if rel, err := filepath.Rel(websiteDocs, resolved); err == nil && !strings.HasPrefix(rel, "..") {
-			link = filepath.ToSlash(filepath.Join("internal", "website", "docs", strings.TrimSuffix(rel, ".html")+".md"))
-		}
-	} else if strings.HasPrefix(link, ".") {
-		target := filepath.Clean(filepath.Join(filepath.Dir(sourceFile), filepath.FromSlash(link)))
-		if _, err := os.Stat(target); err != nil {
-			t.Fatalf("first-agent wayfinding link %q in %s resolves to missing target %s: %v", link, sourceFile, target, err)
-		}
-		return
-	}
-
-	target := filepath.Join(root, filepath.FromSlash(link))
-	if _, err := os.Stat(target); err != nil {
-		t.Fatalf("first-agent wayfinding link %q in %s resolves to missing target %s: %v", link, sourceFile, target, err)
-	}
-}
-
-func assertOrderedMarkers(t *testing.T, name, doc string, markers []string) {
-	t.Helper()
-	last := -1
-	for _, marker := range markers {
-		idx := strings.Index(doc, marker)
-		if idx == -1 {
-			t.Fatalf("%s missing lifecycle command marker %q", name, marker)
-		}
-		if idx < last {
-			t.Fatalf("%s marker %q appeared out of order; keep scaffold → run → chat → inspect → deploy discoverable", name, marker)
-		}
-		last = idx
-	}
-}
@@ -3,8 +3,6 @@ core:
    url: /docs/
  - title: Getting Started
    url: /docs/getting-started.html
-  - title: Install Troubleshooting
-    url: /docs/guides/install-troubleshooting.html
  - title: AI Integration
    url: /docs/ai-integration.html
  - title: No-secret First Agent
@@ -82,7 +80,6 @@ project:
  - title: Server (optional)
    url: /docs/server.html
 search_order:
-  - /docs/guides/install-troubleshooting.html
  - /docs/guides/your-first-agent.html
  - /docs/guides/zero-to-hero.html
  - /docs/guides/debugging-agents.html
@@ -5,29 +5,27 @@ title: AI Integration

 # AI Integration

-Go Micro is an agent harness and service framework for Go. Every service you build can become an AI-callable tool, every agent runs as a service with model/memory/guardrails around it, and flows orchestrate the deterministic parts. This page explains how the services → agents → workflows lifecycle fits together.
+Go Micro is an AI-native microservices framework. Every service you build is automatically accessible to AI agents, and every service can call AI models. This page explains how the pieces fit together.

 <img src="/images/generated/mcp-agent.jpg" alt="AI integration architecture" style="width: 100%; border-radius: 8px; margin: 1rem 0 1.5rem;" />

 ## The Stack

 ```
-Services               →  write Go handlers, register with the framework
+Your Services           →  write Go handlers, register with the framework
    ↓
-Registry                →  automatic discovery for services, agents, and flows
+Registry                →  automatic service discovery (mDNS, Consul, etcd)
    ↓
-Gateways                →  micro api (HTTP→RPC), micro mcp (tools), micro a2a (agents)
+Gateways                →  micro api (HTTP→RPC) / micro mcp (MCP tools)
    ↓
 ai.Tools                →  discovers services + executes RPCs programmatically
    ↓
 ai.Model                →  calls LLMs (Anthropic, OpenAI, Gemini, Atlas Cloud, ...)
    ↓
-Agents                 →  service-backed model loop with memory, guardrails, plan/delegate
-    ↓
-Flows                  →  durable deterministic steps that can dispatch to agents
+agent / flow / micro chat  →  agent-managed, event-driven, or interactive orchestration
 ```

-Every layer is optional. You can use Go Micro as a service framework without AI. You can use the `ai` package without MCP. But when you stack them, you get one runtime where services become tools, agents are reachable services, and workflows coordinate the predictable parts.
+Every layer is optional. You can use go-micro without AI. You can use the `ai` package without MCP. But when you stack them, you get services that AI agents can discover and orchestrate automatically.

 ## Layer by Layer

@@ -17,7 +17,15 @@ Go Micro has three core abstractions:
 ## Prerequisites

 - **Go 1.24+** for development. The `curl` install below gives you the `micro` binary without Go, but `micro run` compiles your services, so you'll want Go installed to build them.
- **No LLM provider key is required** for the first run below. Add an Anthropic, OpenAI, Gemini, or other provider key only when you reach the provider-backed generation and chat steps.
+- An **LLM provider key** (Anthropic, OpenAI, Gemini, …) *only* for the AI features — `micro run --prompt`, `micro chat`, and agents. Plain services need no key. Set it before running, e.g. `export ANTHROPIC_API_KEY=sk-ant-...`.
+
+Before your first provider-backed agent run, check the local path with:
+
+```bash
+micro agent preflight
+```
+
+The preflight is read-only: it verifies Go 1.24+, the `micro` binary, provider-key setup, and whether the default `micro run` gateway port is free, without calling an LLM provider. When a check fails it prints the exact fix plus the next guide to open, so the scaffold → run → chat path stays walkable.

 ## Install

@@ -29,41 +37,66 @@ curl -fsSL https://go-micro.dev/install.sh | sh
 go install go-micro.dev/v6/cmd/micro@latest
 ```

-If install or shell setup fails, start with [Install troubleshooting](guides/install-troubleshooting.html) to verify the binary installer or `go install`, `PATH`, `micro --version`, and the no-secret smoke path.
+## Quick Start: Generate from a Prompt

-## Quick Start: Scaffold, Run, Call
-
-Start with the path that proves the runtime works before any provider setup: install the CLI, scaffold one service, run it locally, then call it through the gateway.
+Prefer to start from a runnable reference? Clone the repository and run the maintained support-desk lifecycle example first:

 ```bash
-micro new helloworld
-cd helloworld
-micro run
+git clone https://github.com/micro/go-micro.git
+cd go-micro
+go run ./examples/support
 ```

-In another terminal, call the generated service:
+That example is the no-secret 0→hero path: services expose ticket/customer/notification tools, an agent handles the work, and an event-driven flow triggers the agent. See [Learn by Example](examples/) when you want more runnable starting points.
+
+Describe what you need. The AI designs services, writes handlers, compiles, and starts them:

 ```bash
-curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
-  -H 'Content-Type: application/json' -d '{"name":"World"}'
+micro run --prompt "task management system"
 ```

-That install → scaffold → run → call loop is the 0→1 contract. It requires Go and the `micro` binary, but no LLM key. Once this succeeds, you know the local runtime, hot reload, gateway, and service registration are working.
+You'll see the design, confirm, and services + agent start:

+```text
+Services:
+  ● task — Core task management
+  ● project — Project organization
+
+Generate? [Y/n]
+
+Micro
+  Services:
+    ● task
+    ● project
+  Agents:
+    ◆ agent
+```
+
+The interactive console lets you talk to your services immediately:
+
+```text
+> Create a project called Launch, then add a task called 'Write docs'
+
+→ project_Project_Create({"name":"Launch"})
+← {"record":{"id":"p1..."},"success":true}
+→ task_Task_Create({"title":"Write docs","project_id":"p1..."})
+
+Created project Launch and added task 'Write docs' to it.
+```
+
+The console discovers services from the registry and orchestrates across them via the agent. Use `micro run -d` for detached mode without the console, or `micro chat` as a standalone command.

 ### First-agent on-ramp

 After this quick start, follow the agent path in order:

-1. [Install troubleshooting](guides/install-troubleshooting.html) — verify the CLI install before agent work.
-2. `micro agent demo` — print the provider-free first-agent demo command and next docs steps from the installed CLI.
-3. [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.
-4. [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.
-5. [Your First Agent](guides/your-first-agent.html) — build a service-backed agent and talk to it with `micro chat`.
-6. [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.
-7. [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`.
+1. [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.
+2. [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.
+3. [Your First Agent](guides/your-first-agent.html) — build a service-backed agent and talk to it with `micro chat`.
+4. [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.
+5. [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
+## Quick Start: Write a Service

 Create and run a service manually:

@@ -127,43 +160,6 @@ micro new events --template pubsub
 micro new gateway --template api
 ```

-
-## Generate from a Prompt — with an LLM key
-
-After the no-secret path works, set a provider key if you want Go Micro to design services and an agent from a prompt:
-
-```bash
-export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, GEMINI_API_KEY, ...
-micro run --prompt "task management system" --provider anthropic
-```
-
-You'll see the design, confirm it, and then services plus an agent start:
-
-```text
-Services:
-  ● task — Core task management
-  ● project — Project organization
-
-Generate? [Y/n]
-
-Micro
-  Services:
-    ● task
-    ● project
-  Agents:
-    ◆ agent
-```
-
-Use the interactive console, `micro run -d` plus `micro chat`, or the agent playground to talk to the generated services.
-
-Before your first provider-backed agent run, check the local path with:
-
-```bash
-micro agent preflight
-```
-
-The preflight is read-only: it verifies Go 1.24+, the `micro` binary, provider-key setup, and whether the default `micro run` gateway port is free, without calling an LLM provider. When a check fails it prints the exact fix plus the next guide to open, so the scaffold → run → chat path stays walkable.
-
 ## Building Agents

 For a complete service-backed walkthrough, start with [Your First Agent](guides/your-first-agent.html). If you want to run before you write, use [`examples/support`](https://github.com/micro/go-micro/tree/master/examples/support) for the full services → agents → workflows lifecycle or [`examples/agent-plan-delegate`](https://github.com/micro/go-micro/tree/master/examples/agent-plan-delegate) for the smallest multi-agent planning/delegation path.
@@ -38,7 +38,7 @@ The built-in providers currently register these capability interfaces:

 | Provider | Chat/text (`ai.Model`) | Image (`ai.ImageModel`) | Video (`ai.VideoModel`) | Streaming (`ai.Stream`) |
 | --- | --- | --- | --- | --- |
-| `anthropic` | Yes | No | No | Yes |
+| `anthropic` | Yes | No | No | No |
 | `atlascloud` | Yes | Yes | Yes | Yes |
 | `gemini` | Yes | No | No | No |
 | `groq` | Yes | No | No | Yes |
@@ -17,21 +17,9 @@ micro inspect ...  # read the recorded run or workflow history

 Debug the lifecycle in the same order Go Micro runs it: first prove the service is
 registered and callable, then inspect the agent run that chose tools, then inspect
-any workflow that handed off to the agent.
-
-Use the recovery command that matches where you are in the first-agent journey:
-
-| Checkpoint | When to use it | Command |
-| --- | --- | --- |
-| Install troubleshooting | `micro` is not installed, not on `PATH`, or the shell cannot run it. | [Install troubleshooting](install-troubleshooting.html) |
-| Preflight before `micro run` | You have not started the local runtime yet and want to verify Go, CLI, provider-key, and gateway-port prerequisites. | `micro agent preflight` |
-| Doctor after `micro run` | `micro run` is active, but chat, the `/agent` gateway, agent registration, provider settings, or inspect/run history is not behaving. | `micro agent doctor` |
-
-`micro agent preflight` is read-only and runs before the first local run; failed
-checks include `Fix:` and `Next:` lines for Go, CLI installation, provider-key
-setup, and the local gateway port. Once `micro run` is already up, switch to
-`micro agent doctor` so the recovery output follows the live gateway, chat
-settings, registered agents, provider configuration, and inspectable run history.
+any workflow that handed off to the agent. If the first local run fails before a
+chat turn, run `micro agent preflight`; failed checks include `Fix:` and `Next:`
+lines for Go, CLI installation, provider-key setup, and the local gateway port.

 ## 1. Reproduce one small turn

@@ -1,96 +0,0 @@
---
-layout: default
-title: Install troubleshooting
---
-
-# Install troubleshooting
-
-Use this page before `micro new` or `micro agent demo` when the CLI install is
-unclear. The goal is to prove three boundaries in order: the `micro` binary is on
-`PATH`, it is the version you expected, and the no-secret first-run path works
-without provider keys.
-
-## 1. Choose one install path
-
-### Binary installer (no Go required to install)
-
-```sh
-curl -fsSL https://go-micro.dev/install.sh | sh
-```
-
-Use this when you want the released `micro` binary without building it yourself.
-The generated services still need a Go toolchain when you run `micro run`, but the
-installer itself does not require Go.
-
-### Go install (build from source)
-
-```sh
-go install go-micro.dev/v6/cmd/micro@latest
-```
-
-Use this when Go is already installed and you want the binary in your Go bin
-directory. If the command succeeds but `micro` is not found, your Go bin directory
-is probably not on `PATH`.
-
-## 2. Verify `PATH` and version
-
-Check which binary your shell will run:
-
-```sh
-command -v micro
-micro --version
-```
-
-If `command -v micro` prints nothing, add the install directory to `PATH`, then
-open a new terminal and retry. Common locations are:
-
-```sh
-export PATH="$HOME/.micro/bin:$PATH"      # binary installer
-export PATH="$(go env GOPATH)/bin:$PATH"  # go install
-```
-
-If `micro --version` shows an older binary than expected, remove the stale copy or
-put the intended install directory earlier in `PATH`.
-
-## 3. Run the no-secret smoke path
-
-Once `micro` resolves, prove the local service runtime before adding LLM provider
-keys:
-
-```sh
-micro new helloworld
-cd helloworld
-micro run
-```
-
-In another terminal:
-
-```sh
-curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
-  -H 'Content-Type: application/json' -d '{"name":"World"}'
-```
-
-This checks the scaffold, local build, gateway, and service registration without
-calling a model provider.
-
-## 4. Recover common failures
-
-| Symptom | Check | Fix |
-|---------|-------|-----|
-| `micro: command not found` | `command -v micro` | Add the installer bin directory or `$(go env GOPATH)/bin` to `PATH`, then open a new terminal. |
-| `micro run` cannot find Go | `go version` | Install Go 1.24 or newer from <https://go.dev/doc/install>. |
-| The gateway port is busy | `lsof -i :8080` | Stop the process using the port, or run with a different address. |
-| Provider-key errors block an agent run | `micro agent preflight` | Stay on the no-secret path first: run `micro agent demo`, then the no-secret first-agent guide. |
-
-## 5. Continue the first-agent on-ramp
-
-After install verification succeeds, continue in order:
-
-1. `micro agent demo` — print the provider-free first-agent demo command and next docs steps.
-2. [No-secret first-agent transcript](no-secret-first-agent.html) — prove an agent can use services without a provider key.
-3. [Your First Agent](your-first-agent.html) — build and chat with your own service-backed agent.
-4. [Debugging your agent](debugging-agents.html) — inspect registration, tool calls, run history, and provider failures.
-5. [0→hero Reference](zero-to-hero.html) — walk the full services → agents → workflows lifecycle.
-
-For repository contributors, `make install-smoke` runs the same installer seam
-against a local build without network access.
@@ -25,12 +25,6 @@ end to end with no secrets.

 ## Transcript

-If you installed the CLI first, ask it for the no-secret path:
-
-```sh
-micro agent demo
-```
-
 From a fresh clone of the repository, first run the smallest service-backed agent:

 ```sh
@@ -57,7 +57,7 @@ previous section.

 | Provider | Chat/text agent harness | Image | Video | Streaming | Structured errors |
 | --- | --- | --- | --- | --- | --- |
-| `anthropic` | ✅ Verified when configured | — Unsupported | — Unsupported | ✅ Verified when configured | ⚠️ Unverified |
+| `anthropic` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
 | `openai` | ✅ Verified when configured | ✅ Registered | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
 | `gemini` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
 | `groq` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
@@ -53,11 +53,7 @@ Run the read-only first-agent preflight before starting the walkthrough. The sam
 micro agent preflight
 ```

-It checks Go 1.24+, the `micro` binary, provider-key setup, and the default local gateway port without contacting a provider. Failed checks include a `Fix:` line and a `Next:` line that points back to this guide, the no-secret walkthrough, or the debugging guide. Use it before `micro run`; if `micro run` is already active but `micro chat`, the `/agent` gateway, registration, provider settings, or inspect history is failing, run the after-run recovery check instead:
-
-```sh
-micro agent doctor
-```
+It checks Go 1.24+, the `micro` binary, provider-key setup, and the default local gateway port without contacting a provider. Failed checks include a `Fix:` line and a `Next:` line that points back to this guide, the no-secret walkthrough, or the debugging guide.

 ## 1. Create a workspace

@@ -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, [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: [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.

@@ -24,7 +24,6 @@ Otherwise continue to read the docs for more information about the framework.

 - [Getting Started](getting-started.html)
 - [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
 - [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
@@ -16,8 +16,6 @@ Or, if you have Go and prefer to build from source:
 go install go-micro.dev/v6/cmd/micro@latest
 ```

-If the installer finishes but your shell cannot find `micro`, open [Install troubleshooting](guides/install-troubleshooting.html) before creating your first service.
-
 ## Create Your First Service

 ```bash
@@ -41,13 +39,9 @@ curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \

 You now have the service half of the services → agents → workflows lifecycle running locally. Keep the on-ramp going in this order:

-1. **[Install troubleshooting](guides/install-troubleshooting.html)** - verify the binary installer or `go install`, `PATH`, `micro --version`, and the no-secret smoke path.
-2. `micro agent demo` - print the provider-free first-agent demo command and the next docs steps from the installed CLI.
-3. **[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.
-4. **[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.
-5. **[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.
-6. **[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.
-7. **[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.
+1. **[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.
+2. **[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.
+3. **[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:

@@ -118,3 +112,4 @@ publisher.Publish(ctx, &UserCreatedEvent{
 - **[Discord Community](https://discord.gg/G8Gk5j3uXr)** - Chat with other users
 - **[GitHub Issues](https://github.com/micro/go-micro/issues)** - Report bugs or request features
 - **[Documentation](https://go-micro.dev/docs/)** - Complete docs
+