docs(priorities): refresh planner queue for 3835

.github/loop/PRIORITIES.md

@@ -21,8 +21,10 @@ changes, architectural rewrites. Those go to the human.
 
 ## Work queue (ranked)
 
-1. **Trace agent `RunInfo` into OpenTelemetry spans** ([#3867](https://github.com/micro/go-micro/issues/3867)) — #3857/#3865 closed the streaming queue item, there are no open `codex` PRs in flight, and the remaining Next-phase gap with the strongest mission fit is operability of the services → agents → workflows lifecycle. The README, website, roadmap, and recent blog all promise that agents are services you can run, chat with, inspect, and trust under the same runtime; projecting run steps, tool calls, delegation, streaming, cancellation, and errors into OTel spans makes that lived path debuggable without a public-API rewrite. Keep this additive/no-op when tracing is disabled, with tests proving representative `RunInfo` events become trace data.
-2. **Add an AP2 mandate layer over A2A and x402** ([#3552](https://github.com/micro/go-micro/issues/3552)) — this remains a forward interop investment, not a Now/Next blocker: Go Micro already has A2A agents and x402 paid tools, so a small signed-mandate foundation can keep agent payments aligned with the open-protocol story without pulling the queue ahead of adoption, resilience, streaming, or durable agent operation. Keep it additive and opt-in while the AP2/FIDO work settles.
+1. **Fix atlascloud A2A stream fallback marker validation** ([#3832](https://github.com/micro/go-micro/issues/3832)) — #3834 closed the plan/delegate timeout by classifying the provider timeout, and the latest live-provider red is now a narrower atlascloud A2A streaming fallback case: the task completes but the artifact text omits the marker the harness expects. Keep this first because the getting-started contract depends on dependable interop diagnostics across chat, tools, and A2A; the fix should make the validator assert a stable protocol-level invariant or make the marker deterministic without relying on brittle free-form model text.
+2. **Propagate agent run cancellation and deadlines through model and tool calls** ([#3544](https://github.com/micro/go-micro/issues/3544)) — once the remaining live-provider harness drift is stabilized, the highest-value Now-phase resilience gap is predictable failure semantics across agent runs, model calls, tool calls, plan/delegate, and flow handoffs. Tool retries, live-provider timeout classification, delegated-plan completion, side-effect enforcement, and file-store isolation are in place; the lifecycle still needs cancellation/deadline propagation so work fails safely instead of becoming opaque loops.
+3. **Emit OpenTelemetry spans for agent run timelines** ([#3525](https://github.com/micro/go-micro/issues/3525)) — recent work made runs inspectable, correlated trace metadata through scheduled dispatch, verified restart resume, added opt-in tool retries, hardened provider conformance, fixed provider-emitted text tool calls, and narrowed the latest provider failures to diagnosability/contract gaps. The next Next-phase step is to turn that RunInfo foundation into standard OTel spans for agent runs, model calls, tool calls, checkpoint/resume, cancellation/deadlines, and failures.
+4. **Add an AP2 mandate layer over A2A and x402** ([#3552](https://github.com/micro/go-micro/issues/3552)) — this is a forward interop investment, not a Now-phase blocker: Go Micro already has A2A agents and x402 paid tools, so a small signed-mandate foundation can keep agent payments aligned with the open-protocol story without pulling the queue away from adoption, resilience, or observability. Keep it additive and opt-in while the AP2/FIDO work settles.
 
 _Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
 architecture-review pass._

README.md

@@ -443,7 +443,6 @@ resp, _ := m.Generate(ctx, &ai.Request{Prompt: "hello"})
 - [multi-service](examples/multi-service/) — Multiple services in one binary
 - [mcp](examples/mcp/) — MCP integration with AI agents
 - [agent-plan-delegate](examples/agent-plan-delegate/) — Agent planning and multi-agent delegation
-- [agent-durable](examples/agent-durable/) — Checkpoint and resume an agent run without replaying completed tool side effects
 - [grpc-interop](examples/grpc-interop/) — Call go-micro from any gRPC client
 
 See [all examples](examples/README.md).

agent/agent.go

@@ -222,16 +222,12 @@ func (a *agentImpl) Stream(ctx context.Context, message string) (ai.Stream, erro
 		return nil, fmt.Errorf("discover tools: %w", err)
 	}
 	a.mem.Add("user", message)
-	stream, err := a.model.Stream(ctx, &ai.Request{
+	return a.model.Stream(ctx, &ai.Request{
 		Prompt:       message,
 		SystemPrompt: a.buildPrompt(),
 		Tools:        toolList,
 		Messages:     a.mem.Messages(),
 	})
-	if err != nil {
-		return nil, err
-	}
-	return &memoryRecordingStream{stream: stream, memory: a.mem}, nil
 }
 
 // Pending returns checkpointed agent runs that have not completed. It mirrors

agent/integration_test.go

@@ -2,7 +2,6 @@ package agent
 
 import (
 	"context"
-	"io"
 	"strings"
 	"testing"
 
@@ -17,7 +16,6 @@ import (
 // it with a deferred cleanup. Tests in this package are not parallel,
 // so a package-level hook is safe.
 var fakeGen func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error)
-var fakeStream func(ctx context.Context, opts ai.Options, req *ai.Request) (ai.Stream, error)
 
 type fakeModel struct{ opts ai.Options }
 
@@ -35,33 +33,10 @@ func (m *fakeModel) Generate(ctx context.Context, req *ai.Request, _ ...ai.Gener
 	return &ai.Response{Reply: "ok"}, nil
 }
 func (m *fakeModel) Stream(ctx context.Context, req *ai.Request, _ ...ai.GenerateOption) (ai.Stream, error) {
-	if fakeStream != nil {
-		return fakeStream(ctx, m.opts, req)
-	}
-	return &sliceStream{chunks: []string{"ok"}}, nil
+	return nil, nil
 }
 func (m *fakeModel) String() string { return "fake" }
 
-type sliceStream struct {
-	chunks []string
-	idx    int
-	closed bool
-}
-
-func (s *sliceStream) Recv() (*ai.Response, error) {
-	if s.idx >= len(s.chunks) {
-		return nil, io.EOF
-	}
-	chunk := s.chunks[s.idx]
-	s.idx++
-	return &ai.Response{Reply: chunk}, nil
-}
-
-func (s *sliceStream) Close() error {
-	s.closed = true
-	return nil
-}
-
 func init() {
 	ai.Register("fake", func(opts ...ai.Option) ai.Model {
 		m := &fakeModel{}

agent/otel.go

@@ -45,7 +45,6 @@ const (
 	AttrFlowStep         = "agent.flow.step"
 	AttrDispatch         = "agent.dispatch"
 	AttrTrigger          = "agent.trigger"
-	AttrRunEventKind     = "agent.event.kind"
 )
 
 type RunEvent struct {
@@ -324,7 +323,6 @@ func runEventAttributes(e RunEvent) []attribute.KeyValue {
 	attrs := []attribute.KeyValue{
 		attribute.String(AttrRunID, e.RunID),
 		attribute.String(AttrAgentName, e.Agent),
-		attribute.String(AttrRunEventKind, e.Kind),
 	}
 	if e.ParentID != "" {
 		attrs = append(attrs, attribute.String(AttrParentRunID, e.ParentID))

agent/otel_test.go

@@ -279,8 +279,7 @@ func spanEventHasRunInfo(events []trace.Event, name, runID, agentName string) bo
 			continue
 		}
 		attrs := spanAttributes(event.Attributes)
-		wantKind := strings.TrimPrefix(name, "agent.")
-		if attrs[AttrRunID] == runID && attrs[AttrAgentName] == agentName && attrs[AttrRunEventKind] == wantKind {
+		if attrs[AttrRunID] == runID && attrs[AttrAgentName] == agentName {
 			return true
 		}
 	}

agent/resilience_test.go

@@ -132,34 +132,6 @@ func TestToolCallTimeoutPropagatesDeadlineToCustomTool(t *testing.T) {
 	}
 }
 
-func TestAskCancellationDuringToolCallFailsRun(t *testing.T) {
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		res := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "cancel-self"})
-		if !strings.Contains(res.Content, context.Canceled.Error()) {
-			t.Fatalf("tool result = %q, want cancellation error", res.Content)
-		}
-		return &ai.Response{Reply: "should not succeed"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	a := newTestAgent(
-		Name("cancel-during-tool"),
-		WithTool("cancel-self", "cancel the run context", nil, func(context.Context, map[string]any) (string, error) {
-			cancel()
-			return "", context.Canceled
-		}),
-	)
-
-	_, err := a.Ask(ctx, "cancel during tool")
-	if !errors.Is(err, context.Canceled) {
-		t.Fatalf("Ask error = %v, want context canceled", err)
-	}
-}
-
 func TestAskCheckpointRecordsTerminalOperationalFailureStatus(t *testing.T) {
 	tests := []struct {
 		name string

agent/stream.go

@@ -185,45 +185,6 @@ type agentStreamAdapter struct {
 	stream AgentStream
 }
 
-type memoryRecordingStream struct {
-	stream ai.Stream
-	memory Memory
-
-	mu     sync.Mutex
-	chunks []string
-	closed bool
-}
-
-func (s *memoryRecordingStream) Recv() (*ai.Response, error) {
-	resp, err := s.stream.Recv()
-	if resp != nil && resp.Reply != "" {
-		s.mu.Lock()
-		s.chunks = append(s.chunks, resp.Reply)
-		s.mu.Unlock()
-	}
-	if errors.Is(err, io.EOF) {
-		s.recordAssistant()
-	}
-	return resp, err
-}
-
-func (s *memoryRecordingStream) Close() error {
-	s.recordAssistant()
-	return s.stream.Close()
-}
-
-func (s *memoryRecordingStream) recordAssistant() {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.closed {
-		return
-	}
-	s.closed = true
-	if reply := strings.Join(s.chunks, ""); reply != "" {
-		s.memory.Add("assistant", reply)
-	}
-}
-
 func (s *agentStreamAdapter) Recv() (*ai.Response, error) {
 	for {
 		event, err := s.stream.Recv()

agent/stream_test.go

@@ -82,52 +82,6 @@ func TestStreamAskHelperRejectsUnsupportedAgent(t *testing.T) {
 	}
 }
 
-func TestAgentStreamUsesProviderStreamingAndRecordsAssistantMemory(t *testing.T) {
-	var sawRequest bool
-	fakeStream = func(ctx context.Context, opts ai.Options, req *ai.Request) (ai.Stream, error) {
-		sawRequest = true
-		if req.Prompt != "stream the answer" {
-			t.Fatalf("Prompt = %q, want stream the answer", req.Prompt)
-		}
-		if len(req.Messages) != 1 || req.Messages[0].Role != "user" || req.Messages[0].Content != "stream the answer" {
-			t.Fatalf("Messages = %#v, want current user turn in memory", req.Messages)
-		}
-		return &sliceStream{chunks: []string{"hel", "lo"}}, nil
-	}
-	defer func() { fakeStream = nil }()
-
-	a := newTestAgent(Name("provider-stream"))
-	stream, err := a.Stream(context.Background(), "stream the answer")
-	if err != nil {
-		t.Fatalf("Stream: %v", err)
-	}
-
-	var reply string
-	for {
-		chunk, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("Recv: %v", err)
-		}
-		reply += chunk.Reply
-	}
-	if err := stream.Close(); err != nil {
-		t.Fatalf("Close: %v", err)
-	}
-	if !sawRequest {
-		t.Fatal("provider Stream was not called")
-	}
-	if reply != "hello" {
-		t.Fatalf("reply = %q, want hello", reply)
-	}
-	got := a.mem.Messages()
-	if len(got) != 2 || got[0].Role != "user" || got[0].Content != "stream the answer" || got[1].Role != "assistant" || got[1].Content != "hello" {
-		t.Fatalf("memory = %#v, want user turn and streamed assistant reply", got)
-	}
-}
-
 func TestResumeStreamAskDoesNotReplayCompletedTool(t *testing.T) {
 	ctx := context.Background()
 	cp := flow.StoreCheckpoint(store.NewStore(), "stream-resume-agent")

ai/retry.go

@@ -99,19 +99,15 @@ func GenerateWithRetry(ctx context.Context, m Model, req *Request, policy Genera
 		}
 		resp, err := m.Generate(callCtx, req, opts...)
 		cancel()
-
-		// Caller cancellation/deadline always wins and is not retried, even if
-		// a provider or tool loop swallowed the canceled tool result and returned
-		// a final response. This keeps agent runs from appearing successful after
-		// their controlling context was abandoned.
-		if ctxErr := ctx.Err(); ctxErr != nil {
-			return nil, ctxErr
-		}
 		if err == nil {
 			return resp, nil
 		}
 		last = err
 
+		// Caller cancellation/deadline always wins and is not retried.
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
 		transient := IsTransientError(err)
 		if attempt == policy.MaxAttempts || !transient {
 			if attempt > 1 || transient {

cmd/micro/cli/agent/preflight.go

@@ -16,7 +16,6 @@ type preflightCheck struct {
 	OK     bool
 	Detail string
 	Fix    string
-	Next   string
 }
 
 type preflightDeps struct {
@@ -53,9 +52,6 @@ func runAgentPreflight(w io.Writer, deps preflightDeps) error {
 		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 preflight failed: %d check(s) need attention", failures)
@@ -91,23 +87,19 @@ func agentPreflightChecks(deps preflightDeps) []preflightCheck {
 func checkGoToolchain(deps preflightDeps) preflightCheck {
 	path, err := deps.lookPath("go")
 	if err != nil {
-		return preflightCheck{Name: "Go toolchain", Detail: "go was not found on PATH", Fix: "Install Go 1.24 or newer from https://go.dev/doc/install and ensure go is on PATH.", Next: "After installing Go, rerun micro agent preflight, then continue with docs/guides/your-first-agent.html."}
+		return preflightCheck{Name: "Go toolchain", Fix: "Install Go 1.24 or newer and ensure go is on PATH."}
 	}
 	out, err := deps.commandOutput("go", "version")
 	if err != nil {
-		return preflightCheck{Name: "Go toolchain", Detail: strings.TrimSpace(string(out)), Fix: "Ensure the go command runs successfully (try `go version`) before starting the agent walkthrough.", Next: "Use docs/guides/debugging-agents.html after the toolchain check passes if an agent run still fails."}
+		return preflightCheck{Name: "Go toolchain", Detail: strings.TrimSpace(string(out)), Fix: "Ensure the go command runs successfully."}
 	}
-	version := firstLine(out)
-	if !goVersionAtLeast(version, 1, 24) {
-		return preflightCheck{Name: "Go toolchain", Detail: fmt.Sprintf("%s (%s)", version, path), Fix: "Upgrade to Go 1.24 or newer before running generated services.", Next: "Rerun micro agent preflight, then continue with docs/guides/your-first-agent.html."}
-	}
-	return preflightCheck{Name: "Go toolchain", OK: true, Detail: fmt.Sprintf("%s (%s)", version, path)}
+	return preflightCheck{Name: "Go toolchain", OK: true, Detail: fmt.Sprintf("%s (%s)", firstLine(out), path)}
 }
 
 func checkMicroBinary(deps preflightDeps) preflightCheck {
 	exe, err := deps.executable()
 	if err != nil || exe == "" {
-		return preflightCheck{Name: "micro binary", Detail: "micro executable path is unavailable", Fix: "Install the micro CLI or run this check through `go run ./cmd/micro agent preflight` from the repository.", Next: "Then follow docs/getting-started.html for the scaffold -> run path."}
+		return preflightCheck{Name: "micro binary", Fix: "Install the micro CLI or run this check through go run ./cmd/micro agent preflight."}
 	}
 	version := deps.version()
 	if version == "" {
@@ -125,7 +117,7 @@ func checkProviderKey(deps preflightDeps) preflightCheck {
 		}
 	}
 	if len(found) == 0 {
-		return preflightCheck{Name: "provider API key", Detail: "no supported provider key found", Fix: "Export MICRO_AI_API_KEY or a provider key such as ANTHROPIC_API_KEY before running provider-backed agents.", Next: "For a no-secret path, run the mock-model walkthrough in docs/guides/no-secret-first-agent.html; for real providers, see docs/guides/debugging-agents.html#provider-failures."}
+		return preflightCheck{Name: "provider API key", Detail: "no supported provider key found", Fix: "Export MICRO_AI_API_KEY or a provider key such as ANTHROPIC_API_KEY before running provider-backed agents."}
 	}
 	return preflightCheck{Name: "provider API key", OK: true, Detail: "found " + strings.Join(found, ", ")}
 }
@@ -133,7 +125,7 @@ func checkProviderKey(deps preflightDeps) preflightCheck {
 func checkPortAvailable(deps preflightDeps, addr, use string) preflightCheck {
 	ln, err := deps.listen("tcp", addr)
 	if err != nil {
-		return preflightCheck{Name: "local port " + addr, Detail: "busy or unavailable for " + use, Fix: "Stop the process using " + addr + " (for example, `lsof -i :8080`) or run `micro run --address` with a free port.", Next: "Once the gateway starts, open http://localhost:8080/agent or continue with docs/guides/your-first-agent.html#chat-with-your-agent."}
+		return preflightCheck{Name: "local port " + addr, Detail: "busy or unavailable for " + use, Fix: "Stop the process using " + addr + " or run micro run --address with a free port."}
 	}
 	_ = ln.Close()
 	return preflightCheck{Name: "local port " + addr, OK: true, Detail: "available for " + use}
@@ -146,18 +138,3 @@ func firstLine(b []byte) string {
 	}
 	return s
 }
-
-func goVersionAtLeast(line string, wantMajor, wantMinor int) bool {
-	idx := strings.Index(line, "go1.")
-	if idx < 0 {
-		return false
-	}
-	var major, minor int
-	if _, err := fmt.Sscanf(line[idx:], "go%d.%d", &major, &minor); err != nil {
-		return false
-	}
-	if major != wantMajor {
-		return major > wantMajor
-	}
-	return minor >= wantMinor
-}

cmd/micro/cli/agent/preflight_test.go

@@ -61,59 +61,13 @@ func TestRunAgentPreflightReportsActionableFailures(t *testing.T) {
 		t.Fatal("runAgentPreflight() error = nil")
 	}
 	got := out.String()
-	for _, want := range []string{"✗ Go toolchain", "go was not found on PATH", "https://go.dev/doc/install", "docs/guides/your-first-agent.html", "✗ micro binary", "go run ./cmd/micro agent preflight", "✗ provider API key", "docs/guides/no-secret-first-agent.html", "docs/guides/debugging-agents.html#provider-failures", "✗ local port :8080", "lsof -i :8080", "micro run --address"} {
+	for _, want := range []string{"✗ Go toolchain", "Install Go 1.24", "✗ micro binary", "✗ provider API key", "ANTHROPIC_API_KEY", "✗ local port :8080", "micro run --address"} {
 		if !strings.Contains(got, want) {
 			t.Fatalf("output missing %q:\n%s", want, got)
 		}
 	}
 }
 
-func TestRunAgentPreflightReportsOldGoVersion(t *testing.T) {
-	deps := preflightDeps{
-		lookPath: func(name string) (string, error) { return "/usr/bin/" + name, nil },
-		commandOutput: func(name string, args ...string) ([]byte, error) {
-			return []byte("go version go1.23.9 linux/amd64\n"), nil
-		},
-		executable: func() (string, error) { return "/usr/local/bin/micro", nil },
-		getenv: func(key string) string {
-			if key == "ANTHROPIC_API_KEY" {
-				return "set"
-			}
-			return ""
-		},
-		listen: func(network, address string) (net.Listener, error) { return stubListener{}, nil },
-	}
-
-	var out bytes.Buffer
-	err := runAgentPreflight(&out, deps)
-	if err == nil {
-		t.Fatal("runAgentPreflight() error = nil")
-	}
-	got := out.String()
-	for _, want := range []string{"✗ Go toolchain", "go1.23.9", "Upgrade to Go 1.24 or newer", "Rerun micro agent preflight"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestGoVersionAtLeast(t *testing.T) {
-	tests := []struct {
-		line string
-		want bool
-	}{
-		{line: "go version go1.24.0 linux/amd64", want: true},
-		{line: "go version go1.25.1 linux/amd64", want: true},
-		{line: "go version go1.23.9 linux/amd64", want: false},
-		{line: "unexpected", want: false},
-	}
-	for _, tt := range tests {
-		if got := goVersionAtLeast(tt.line, 1, 24); got != tt.want {
-			t.Fatalf("goVersionAtLeast(%q) = %v, want %v", tt.line, got, tt.want)
-		}
-	}
-}
-
 func TestFirstLine(t *testing.T) {
 	if got := firstLine([]byte("one\ntwo")); got != "one" {
 		t.Fatalf("firstLine() = %q", got)

internal/harness/a2a-stream-fallback/main.go

@@ -148,17 +148,13 @@ func main() {
 		fmt.Fprintf(os.Stderr, "content-type = %q, want text/event-stream\n", ct)
 		os.Exit(1)
 	}
-	summary, err := readSSESummary(res.Body)
+	payload, err := readSSEData(res.Body)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
-	if summary.State != "completed" {
-		fmt.Fprintf(os.Stderr, "stream final state = %q, want completed; payload: %s\n", summary.State, summary.Payload)
-		os.Exit(1)
-	}
-	if !summary.HasArtifactText {
-		fmt.Fprintf(os.Stderr, "stream completed without artifact text: %s\n", summary.Payload)
+	if !strings.Contains(payload, "a2a-fallback-ok") {
+		fmt.Fprintf(os.Stderr, "stream payload missing marker: %s\n", payload)
 		os.Exit(1)
 	}
 	if !sawTool || !sawRunInfo {
@@ -168,16 +164,10 @@ func main() {
 	fmt.Println("\n\033[32m✓ A2A message/stream fell back to Ask and preserved tool/run metadata\033[0m")
 }
 
-type streamSummary struct {
-	Payload         string
-	State           string
-	HasArtifactText bool
-}
-
-func readSSESummary(r io.Reader) (streamSummary, error) {
+func readSSEData(r io.Reader) (string, error) {
 	scanner := bufio.NewScanner(r)
 	var event strings.Builder
-	var summary streamSummary
+	var payload strings.Builder
 	seen := false
 	flush := func() error {
 		data := strings.TrimSpace(event.String())
@@ -185,40 +175,19 @@ func readSSESummary(r io.Reader) (streamSummary, error) {
 		if data == "" {
 			return nil
 		}
-		var envelope struct {
-			Result struct {
-				Status struct {
-					State string `json:"state"`
-				} `json:"status"`
-				Artifacts []struct {
-					Parts []struct {
-						Text string `json:"text"`
-					} `json:"parts"`
-				} `json:"artifacts"`
-			} `json:"result"`
-		}
-		if err := json.Unmarshal([]byte(data), &envelope); err != nil {
+		if !json.Valid([]byte(data)) {
 			return fmt.Errorf("SSE data event is not JSON: %s", data)
 		}
 		seen = true
-		summary.Payload += data + "\n"
-		if envelope.Result.Status.State != "" {
-			summary.State = envelope.Result.Status.State
-		}
-		for _, artifact := range envelope.Result.Artifacts {
-			for _, part := range artifact.Parts {
-				if strings.TrimSpace(part.Text) != "" {
-					summary.HasArtifactText = true
-				}
-			}
-		}
+		payload.WriteString(data)
+		payload.WriteByte('\n')
 		return nil
 	}
 	for scanner.Scan() {
 		line := scanner.Text()
 		if strings.TrimSpace(line) == "" {
 			if err := flush(); err != nil {
-				return streamSummary{}, err
+				return "", err
 			}
 			continue
 		}
@@ -232,13 +201,13 @@ func readSSESummary(r io.Reader) (streamSummary, error) {
 		event.WriteString(strings.TrimSpace(data))
 	}
 	if err := scanner.Err(); err != nil {
-		return streamSummary{}, err
+		return "", err
 	}
 	if err := flush(); err != nil {
-		return streamSummary{}, err
+		return "", err
 	}
 	if !seen {
-		return streamSummary{}, errors.New("no SSE data received")
+		return "", errors.New("no SSE data received")
 	}
-	return summary, nil
+	return payload.String(), nil
 }

internal/harness/a2a-stream-fallback/main_test.go

@@ -5,26 +5,19 @@ import (
 	"testing"
 )
 
-func TestReadSSESummaryUsesCompletedTaskInvariants(t *testing.T) {
-	summary, err := readSSESummary(strings.NewReader("data: {\"jsonrpc\":\"2.0\",\"result\":{\"status\":{\"state\":\"working\"}}}\n\n" +
-		"data: {\"jsonrpc\":\"2.0\",\"result\":{\"status\":{\"state\":\"completed\"},\"artifacts\":[{\"parts\":[{\"kind\":\"text\",\"text\":\"provider-specific answer\"}]}]}}\n\n"))
+func TestReadSSEDataAcceptsMultipleJSONEvents(t *testing.T) {
+	payload, err := readSSEData(strings.NewReader("event: status\ndata: {\"phase\":\"started\"}\n\ndata:{\"result\":\"a2a-fallback-ok\"}\n\n"))
 	if err != nil {
-		t.Fatalf("readSSESummary() error = %v", err)
+		t.Fatalf("readSSEData returned error: %v", err)
 	}
-	if summary.State != "completed" {
-		t.Fatalf("State = %q, want completed", summary.State)
-	}
-	if !summary.HasArtifactText {
-		t.Fatal("HasArtifactText = false, want true")
-	}
-	if strings.Contains(summary.Payload, "a2a-fallback-ok") {
-		t.Fatalf("test fixture should not rely on marker text: %s", summary.Payload)
+	if !strings.Contains(payload, "started") || !strings.Contains(payload, "a2a-fallback-ok") {
+		t.Fatalf("payload = %q, want both event payloads", payload)
 	}
 }
 
-func TestReadSSESummaryRejectsNonJSONData(t *testing.T) {
-	_, err := readSSESummary(strings.NewReader("data: not-json\n\n"))
+func TestReadSSEDataRejectsInvalidJSONEvent(t *testing.T) {
+	_, err := readSSEData(strings.NewReader("data: {\"ok\":true}\n\ndata: {bad json}\n\n"))
 	if err == nil {
-		t.Fatal("readSSESummary() error = nil, want non-JSON error")
+		t.Fatal("readSSEData returned nil error for invalid JSON event")
 	}
 }

internal/website/docs/examples/index.md

@@ -16,7 +16,6 @@ agents → workflows lifecycle.
 | First service-backed agent | [`examples/agent-demo`](https://github.com/micro/go-micro/tree/master/examples/agent-demo) | Multi-service project/task/team app with agent playground integration. |
 | 0→hero lifecycle | [`examples/support`](https://github.com/micro/go-micro/tree/master/examples/support) | No-secret support-desk story: typed services, an agent, an event-driven flow, and a guardrail. |
 | Planning and delegation | [`examples/agent-plan-delegate`](https://github.com/micro/go-micro/tree/master/examples/agent-plan-delegate) | Two agents collaborate through `plan` and `delegate` over normal Go Micro RPC. |
-| Durable agent runs | [`examples/agent-durable`](https://github.com/micro/go-micro/tree/master/examples/agent-durable) | Checkpoint and resume a model-directed run without replaying completed tool side effects. |
 | Durable workflows | [`examples/flow-durable`](https://github.com/micro/go-micro/tree/master/examples/flow-durable) | Ordered, checkpointed flow steps resume without duplicating completed side effects. |
 | AI-callable services | [`examples/mcp`](https://github.com/micro/go-micro/tree/master/examples/mcp) | MCP examples that expose service endpoints as model tools. |
 
@@ -36,11 +35,7 @@ agents → workflows lifecycle.
   [`examples/agent-plan-delegate`](https://github.com/micro/go-micro/tree/master/examples/agent-plan-delegate).
 - [Agents and Workflows](../guides/agents-and-workflows.html) → run
   [`examples/flow-durable`](https://github.com/micro/go-micro/tree/master/examples/flow-durable)
-  for deterministic checkpointed steps,
-  [`examples/agent-durable`](https://github.com/micro/go-micro/tree/master/examples/agent-durable)
-  for model-directed checkpointed runs, and
-  [`examples/support`](https://github.com/micro/go-micro/tree/master/examples/support)
-  for the full services → agents → workflows lifecycle.
+  and [`examples/support`](https://github.com/micro/go-micro/tree/master/examples/support).
 
 ## Repository examples
 

internal/website/docs/getting-started.md

@@ -25,7 +25,7 @@ Before your first provider-backed agent run, check the local path with:
 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.
+The preflight is read-only: it verifies Go, the `micro` binary, provider-key setup, and whether the default `micro run` gateway port is free, without calling an LLM provider.
 
 ## Install
 

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

@@ -17,9 +17,7 @@ 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. 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.
+any workflow that handed off to the agent.
 
 ## 1. Reproduce one small turn
 

internal/website/docs/guides/no-secret-first-agent.md

@@ -89,6 +89,6 @@ CI keeps those CLI boundaries present with:
 go test ./cmd/micro -run TestFirstAgentWalkthroughCLIBoundaries -count=1
 ```
 
-If `micro agent preflight` reports a missing provider key, you can still use this no-secret path because it runs against the mock model; the command now prints this guide as the next step for that failure. If chat behaves unexpectedly, continue to
+If chat behaves unexpectedly, continue to
 [Debugging your agent](debugging-agents.html) for provider checks, run history,
 memory, and tool-call inspection.

internal/website/docs/guides/your-first-agent.md

@@ -53,7 +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.
+It checks Go, the `micro` binary, provider-key setup, and the default local gateway port without contacting a provider.
 
 ## 1. Create a workspace