docs: align public x402 flag examples

.github/workflows/architecture-review.yml

@@ -1,24 +1,21 @@
 name: Architecture Review
 
-# Continuous high-altitude oversight of the whole framework and harness — the
-# "founder lens" of the autonomous loop (internal/docs/CONTINUOUS_IMPROVEMENT.md).
-# Where DevRel watches the public story and the increment loop ships code, the
-# architect watches the SYSTEM and runs alongside the builders: it tracks what is
-# in flight and what just merged, keeps the roadmap priorities live, and judges
-# cohesion (harness <-> framework <-> dev UX), missing pieces, and realignment.
+# Periodic high-altitude review of the whole framework and harness against the
+# North Star (internal/docs/THESIS.md) — part of the autonomous loop
+# (internal/docs/CONTINUOUS_IMPROVEMENT.md). Where DevRel watches the public
+# story, the architect watches the system: API coherence, lifecycle gaps, and
+# whether recent increments are converging on the thesis or sprawling.
 #
-# Its OUTPUT is the ranked queue in internal/docs/PRIORITIES.md plus an assessment
-# — NOT large refactors. Breaking public-API and architectural changes stay with
-# the human (see CONTINUOUS_IMPROVEMENT.md).
+# The architect's OUTPUT is an assessment plus scoped follow-up issues that feed
+# the hourly increment loop — NOT large refactors. Breaking public-API and
+# architectural changes stay with the human (see CONTINUOUS_IMPROVEMENT.md).
 #
-# Runs hourly, offset before the increment loop (:29) so it re-prioritizes and
-# THEN the loop builds the new top of the queue. Opens a fresh issue and
-# dispatches Codex via CODEX_TRIGGER_TOKEN.
+# Opens a fresh issue and dispatches Codex via CODEX_TRIGGER_TOKEN.
 
 on:
   workflow_dispatch: {}
   schedule:
-    - cron: "59 * * * *" # hourly at :59, just before the :29 increment run (tunable)
+    - cron: "0 8 */3 * *" # roughly every 3 days, 08:00 UTC (tunable)
 
 permissions:
   issues: write
@@ -44,8 +41,8 @@ jobs:
           fi
           ISSUE_URL=$(gh issue create --repo "$REPO" \
             --title "Architecture review #$RUN_NUMBER" \
-            --body "Continuous architecture / harness oversight against the North Star in internal/docs/THESIS.md. Output: a re-ranked internal/docs/PRIORITIES.md (only if it changed) plus an assessment.")
+            --body "Periodic architecture / harness review against the North Star in internal/docs/THESIS.md. Output: an assessment plus scoped follow-up issues for the increment loop.")
           ISSUE_NUM="${ISSUE_URL##*/}"
           echo "Opened issue #$ISSUE_NUM — dispatching Codex (Architect)."
           gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
-          "@codex Act as the architect — the founder lens — for go-micro, running continuously alongside the builders. Hold the whole picture: how the harness, the framework, and the developer UX fit together cohesively, what is in flight and what just merged, what to prioritize next on the roadmap, and what is missing or has drifted. Each run: (1) TRACK STATE — scan recently merged PRs and open codex PRs/issues to see what shipped and what is being built right now, so the queue reflects reality (drop done items, don't re-queue in-flight work). (2) ASSESS against the North Star in internal/docs/THESIS.md — lead with its Mission (*the problem we solve: make building an agent as easy as building a service, on one runtime*) and re-derive alignment from the CANON it names (the blog under internal/website/blog, the README, and the website — read these, don't rely on THESIS.md alone), then ROADMAP.md (Now → Next → Later). Judge every priority against the mission: does it make the services → agents → workflows lifecycle simpler, more cohesive, and more operable? Look at coherence and seams across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry), the dev inner loop (scaffold → run → chat → inspect → deploy), missing pieces, duplication/drift, and realignment. Flag drift in EITHER direction: work drifting from the mission, or the North Star/website drifting from the lived story in the blog (which needs re-grounding in the canon). (3) MAINTAIN THE QUEUE in internal/docs/PRIORITIES.md — a SINGLE ordered list, highest-value first, each item linking a scoped CI-verifiable issue (#N); roadmap phase is the primary ordering, internal findings (cohesion gaps, DX friction, missing pieces) interleaved by value. For any prioritized gap that has no issue yet, file one: \`gh issue create --label codex --label enhancement --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\`. OUTPUT: post a concise assessment as a comment on this issue (#$ISSUE_NUM) — what shipped, what's in flight, the top risks/gaps/missing pieces, and the reasoning behind the ranking. If the ranking actually changed, open ONE PR for PRIORITIES.md: \`git switch -c codex/architect-$ISSUE_NUM\`, \`git push -u origin codex/architect-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, Closes #$ISSUE_NUM>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. If the queue is already accurate and correctly ranked, do NOT open a PR — just close this issue (\`gh issue close $ISSUE_NUM\`). Do NOT make breaking public-API or architectural changes yourself — surface those in the assessment as notes for the human, never as auto-merged changes. Do not use the make_pr tool (it is a no-op stub)."
+          "@codex Act as the architect for go-micro. Review the overall framework and harness against the North Star in internal/docs/THESIS.md (services → agents → workflows as one runtime) and the roadmap in ROADMAP.md. Assess: API coherence and consistency across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry), gaps or missing pieces in the services → agents → workflows lifecycle, duplication or drift, and whether recent increments (scan recently merged PRs) are converging on the thesis or sprawling. Then: (A) post a concise architectural assessment as a comment on this issue (#$ISSUE_NUM) — strengths, the top risks/gaps, and a recommended direction for the next increments; (B) file concrete, scoped follow-up issues for the highest-value gaps so the hourly increment loop can pick them up — \`gh issue create --label codex --label enhancement --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\` (each must be a single, self-contained, CI-verifiable chunk). Do NOT make breaking public-API or architectural changes yourself — your output is the assessment and the issues. A small, safe doc/comment correction may be a PR (\`git switch -c codex/architect-$ISSUE_NUM\` … \`gh pr create --base master --label codex …\` … \`gh pr merge --squash --auto --delete-branch\`). Do not use the make_pr tool (it is a no-op stub)."

.github/workflows/continuous-improvement.yml

@@ -62,4 +62,4 @@ jobs:
           ISSUE_NUM="${ISSUE_URL##*/}"
           echo "Opened issue #$ISSUE_NUM — dispatching Codex."
           gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
-          "@codex Run one continuous-improvement increment per internal/docs/CONTINUOUS_IMPROVEMENT.md, aligned to the North Star in internal/docs/THESIS.md (the holistic services → agents → workflows lifecycle). PICK THE WORK FROM THE QUEUE: read internal/docs/PRIORITIES.md and take the highest-ranked item whose linked issue is still OPEN — that is your task, and its issue number is the one you close. (If PRIORITIES.md is missing or every listed item's issue is already closed, fall back to picking the single highest-value roadmap/issue/improvement-radar item yourself.) Implement it, and verify \`go build ./...\`, \`go test ./...\`, and \`golangci-lint run ./...\`. Then open the PR YOURSELF from the shell — do NOT use the make_pr tool (in this environment it only records metadata and never creates a PR). Create a uniquely-named branch under the codex/ prefix and open the PR from it: \`git switch -c codex/increment-$ISSUE_NUM\`, then \`git push -u origin codex/increment-$ISSUE_NUM\`, then \`gh pr create --base master --label codex --title \"<title>\" --body \"<body; include 'Closes #<the priority issue you built>' so it leaves the queue, and 'Closes #$ISSUE_NUM' for this run's tracker>\"\`. Finally enable auto-merge so GitHub merges it once CI is green: \`gh pr merge --squash --auto --delete-branch\`. The gh CLI is installed and authenticated and origin points to $REPO. One concern per PR; stay out of brand/positioning copy and breaking public API."
+          "@codex Run one continuous-improvement increment per internal/docs/CONTINUOUS_IMPROVEMENT.md, aligned to the North Star in internal/docs/THESIS.md (the holistic services → agents → workflows lifecycle). Pick the single highest-value roadmap/issue/improvement-radar item that advances that thesis, implement it, and verify \`go build ./...\`, \`go test ./...\`, and \`golangci-lint run ./...\`. Then open the PR YOURSELF from the shell — do NOT use the make_pr tool (in this environment it only records metadata and never creates a PR). Create a uniquely-named branch under the codex/ prefix and open the PR from it: \`git switch -c codex/increment-$ISSUE_NUM\`, then \`git push -u origin codex/increment-$ISSUE_NUM\`, then \`gh pr create --base master --label codex --title \"<title>\" --body \"<body, including 'Closes #$ISSUE_NUM'>\"\`. Finally enable auto-merge so GitHub merges it once CI is green: \`gh pr merge --squash --auto --delete-branch\`. The gh CLI is installed and authenticated and origin points to $REPO. One concern per PR; stay out of brand/positioning copy and breaking public API."

agent/agent.go

@@ -23,7 +23,6 @@ import (
 	"github.com/google/uuid"
 	pb "go-micro.dev/v6/agent/proto"
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/flow"
 	"go-micro.dev/v6/gateway/a2a"
 	"go-micro.dev/v6/server"
 	"go-micro.dev/v6/store"
@@ -172,27 +171,6 @@ func (a *agentImpl) Ask(ctx context.Context, message string) (*Response, error)
 	return a.ask(ctx, message, a.parentRunID)
 }
 
-// Resume returns the response for a checkpointed agent run. Completed runs are
-// returned from the checkpoint without calling the model or replaying tool
-// calls; failed or in-progress runs continue from the saved input message.
-func Resume(ctx context.Context, ag Agent, runID string) (*Response, error) {
-	a, ok := ag.(*agentImpl)
-	if !ok {
-		return nil, fmt.Errorf("agent resume: unsupported agent implementation %T", ag)
-	}
-	return a.resume(ctx, runID)
-}
-
-// Pending returns checkpointed agent runs that have not completed. It mirrors
-// flow.Pending for startup recovery loops that drain durable agent work.
-func Pending(ctx context.Context, ag Agent) ([]flow.Run, error) {
-	a, ok := ag.(*agentImpl)
-	if !ok {
-		return nil, fmt.Errorf("agent pending: unsupported agent implementation %T", ag)
-	}
-	return a.pending(ctx)
-}
-
 func (a *agentImpl) ask(ctx context.Context, message, parentRunID string) (*Response, error) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
@@ -201,10 +179,6 @@ func (a *agentImpl) ask(ctx context.Context, message, parentRunID string) (*Resp
 		a.setup()
 	}
 
-	return a.askLocked(ctx, uuid.New().String(), message, parentRunID, nil)
-}
-
-func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID string, existing *flow.Run) (*Response, error) {
 	toolList, err := a.discoverTools()
 	if err != nil {
 		return nil, fmt.Errorf("discover tools: %w", err)
@@ -215,16 +189,12 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 	a.calls = map[string]int{}
 
 	// Correlate this run's tool calls and surface lineage to wrappers.
-	a.runID = runID
+	a.runID = uuid.New().String()
 	ctx = ai.WithRunInfo(ctx, ai.RunInfo{
 		RunID:    a.runID,
 		ParentID: parentRunID,
 		Agent:    a.opts.Name,
 	})
-	run := a.newCheckpointRun(runID, message, parentRunID, existing)
-	if err := a.saveRun(ctx, run); err != nil {
-		return nil, err
-	}
 	ctx, endRun := a.startRun(ctx, message)
 	defer func() { endRun(err) }()
 
@@ -239,10 +209,6 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		Backoff:     a.opts.ModelRetryBackoff,
 	})
 	if err != nil {
-		run.Status = "failed"
-		run.Steps[0].Status = "failed"
-		run.Steps[0].Error = err.Error()
-		_ = a.saveRun(ctx, run)
 		return nil, err
 	}
 
@@ -261,25 +227,13 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		reply += resp.Answer
 	}
 
-	res := &Response{
+	return &Response{
 		Reply:     reply,
 		ToolCalls: resp.ToolCalls,
 		Agent:     a.opts.Name,
 		RunID:     a.runID,
 		ParentID:  parentRunID,
-	}
-	run.Status = "done"
-	run.State.Stage = ""
-	if b, marshalErr := json.Marshal(res); marshalErr == nil {
-		run.State.Data = b
-	}
-	run.Steps[0].Status = "done"
-	run.Steps[0].Attempts++
-	run.Steps[0].Result = reply
-	if err := a.saveRun(ctx, run); err != nil {
-		return nil, err
-	}
-	return res, nil
+	}, nil
 }
 
 // Chat implements the proto AgentHandler interface for RPC.

agent/checkpoint.go

@@ -1,92 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"go-micro.dev/v6/flow"
-)
-
-const agentAskStep = "ask"
-
-func (a *agentImpl) newCheckpointRun(runID, message, parentRunID string, existing *flow.Run) flow.Run {
-	now := time.Now()
-	run := flow.Run{
-		ID:       runID,
-		ParentID: parentRunID,
-		Flow:     a.opts.Name,
-		State:    flow.State{Stage: agentAskStep, Data: []byte(message)},
-		Steps:    []flow.StepRecord{{Name: agentAskStep, Status: "in_progress"}},
-		Status:   "running",
-		Started:  now,
-		Updated:  now,
-	}
-	if existing != nil {
-		run = *existing
-		run.Status = "running"
-		run.State.Stage = agentAskStep
-		if len(run.Steps) == 0 {
-			run.Steps = []flow.StepRecord{{Name: agentAskStep}}
-		}
-		run.Steps[0].Status = "in_progress"
-		run.Steps[0].Error = ""
-	}
-	return run
-}
-
-func (a *agentImpl) saveRun(ctx context.Context, run flow.Run) error {
-	if a.opts.Checkpoint == nil {
-		return nil
-	}
-	if err := a.opts.Checkpoint.Save(ctx, run); err != nil {
-		return fmt.Errorf("agent %s checkpoint save: %w", a.opts.Name, err)
-	}
-	return nil
-}
-
-func (a *agentImpl) resume(ctx context.Context, runID string) (*Response, error) {
-	if a.opts.Checkpoint == nil {
-		return nil, fmt.Errorf("agent %s has no checkpoint configured", a.opts.Name)
-	}
-	run, ok, err := a.opts.Checkpoint.Load(ctx, runID)
-	if err != nil {
-		return nil, err
-	}
-	if !ok {
-		return nil, fmt.Errorf("agent run %s not found", runID)
-	}
-	if run.Status == "done" {
-		var resp Response
-		if err := json.Unmarshal(run.State.Data, &resp); err != nil {
-			return nil, fmt.Errorf("agent run %s response decode: %w", runID, err)
-		}
-		return &resp, nil
-	}
-	message := string(run.State.Data)
-	parentID := run.ParentID
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if a.model == nil {
-		a.setup()
-	}
-	return a.askLocked(ctx, run.ID, message, parentID, &run)
-}
-
-func (a *agentImpl) pending(ctx context.Context) ([]flow.Run, error) {
-	if a.opts.Checkpoint == nil {
-		return nil, nil
-	}
-	runs, err := a.opts.Checkpoint.List(ctx)
-	if err != nil {
-		return nil, err
-	}
-	out := runs[:0]
-	for _, run := range runs {
-		if run.Flow == a.opts.Name && run.Status != "done" {
-			out = append(out, run)
-		}
-	}
-	return out, nil
-}

agent/checkpoint_test.go

@@ -1,66 +0,0 @@
-package agent
-
-import (
-	"context"
-	"testing"
-
-	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/flow"
-	"go-micro.dev/v6/store"
-)
-
-func TestResumeCompletedCheckpointDoesNotReplayModel(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewStore(), "durable-agent")
-	calls := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		calls++
-		return &ai.Response{Reply: "done"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("durable-agent"), WithCheckpoint(cp))
-	resp, err := a.Ask(ctx, "finish the work")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if calls != 1 {
-		t.Fatalf("model calls after Ask = %d, want 1", calls)
-	}
-
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		calls++
-		t.Fatal("Resume of a completed run replayed the model")
-		return nil, nil
-	}
-	resumed, err := Resume(ctx, a, resp.RunID)
-	if err != nil {
-		t.Fatalf("Resume: %v", err)
-	}
-	if resumed.Reply != "done" {
-		t.Fatalf("resumed reply = %q, want done", resumed.Reply)
-	}
-	if resumed.RunID != resp.RunID {
-		t.Fatalf("resumed run id = %q, want %q", resumed.RunID, resp.RunID)
-	}
-	if calls != 1 {
-		t.Fatalf("model calls after Resume = %d, want 1", calls)
-	}
-}
-
-func TestPendingReturnsUnfinishedAgentRuns(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewStore(), "pending-agent")
-	run := flow.Run{ID: "run-1", Flow: "pending-agent", Status: "failed", State: flow.State{Stage: agentAskStep, Data: []byte("retry me")}}
-	if err := cp.Save(ctx, run); err != nil {
-		t.Fatalf("Save: %v", err)
-	}
-	a := newTestAgent(Name("pending-agent"), WithCheckpoint(cp))
-	runs, err := Pending(ctx, a)
-	if err != nil {
-		t.Fatalf("Pending: %v", err)
-	}
-	if len(runs) != 1 || runs[0].ID != "run-1" {
-		t.Fatalf("Pending = %#v, want run-1", runs)
-	}
-}

agent/options.go

@@ -6,7 +6,6 @@ import (
 
 	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/client"
-	"go-micro.dev/v6/flow"
 	"go-micro.dev/v6/registry"
 	"go-micro.dev/v6/store"
 	"go.opentelemetry.io/otel/trace"
@@ -60,9 +59,6 @@ type Options struct {
 	// Memory is the agent's conversation memory. Nil = the default
 	// store-backed memory (durable across restarts).
 	Memory Memory
-	// Checkpoint persists agent Ask runs so callers can resume by run id
-	// after a restart without replaying a run that already completed.
-	Checkpoint flow.Checkpoint
 
 	// MaxSteps bounds the number of tool executions per Ask (0 =
 	// unbounded). Once exceeded, further tool calls are refused and the
@@ -215,15 +211,6 @@ func WithMemory(m Memory) Option {
 	return func(o *Options) { o.Memory = m }
 }
 
-// WithCheckpoint sets the durability backend for agent Ask runs. The
-// Checkpoint interface is shared with flow so services, agents, and workflows
-// can use one execution history backend. When set, each Ask is saved as a
-// single-step run keyed by run id; Resume returns a completed run's persisted
-// response instead of calling the model again.
-func WithCheckpoint(c flow.Checkpoint) Option {
-	return func(o *Options) { o.Checkpoint = c }
-}
-
 // WrapTool registers a tool-execution wrapper, the tool-side analog of
 // a client/server middleware wrapper. Each wrapper takes the next handler
 // and returns a new one; code before the next(...) call runs before the

ai/model.go

@@ -113,17 +113,12 @@ const (
 // RunInfo describes the agent run a tool call belongs to. The agent
 // attaches it to the context passed to a ToolHandler, so a wrapper can
 // correlate calls within a run and across delegation without coupling to
-// the agent package. Flows also attach their name and current step so
-// tools and agents called from a workflow can be tied back to the
-// services → agents → workflows lifecycle that invoked them. Per-call
-// detail (tool name, id) is on the ToolCall; attempt counts are naturally
-// counted by the wrapper itself.
+// the agent package. Per-call detail (tool name, id) is on the ToolCall;
+// step and attempt counts are naturally counted by the wrapper itself.
 type RunInfo struct {
-	RunID    string // correlation id for this agent or flow run
+	RunID    string // correlation id for this agent run (one per Ask)
 	ParentID string // the run that delegated to this one, if any
 	Agent    string // the agent's name
-	Flow     string // the flow's name, when the call is part of a workflow
-	Step     string // the flow step currently executing, when known
 }
 
 type runInfoKey struct{}

cmd/micro/cli/new/contract_test.go

@@ -19,45 +19,6 @@ import (
 // It shells out to `micro new` (which runs `go mod tidy`) and `go build`, so
 // it needs the Go toolchain and module access; it is skipped under `-short`.
 func TestZeroToOneContract(t *testing.T) {
-	generated := generateService(t, "helloworld")
-
-	for _, rel := range []string{"go.mod", "main.go", "handler/helloworld.go", "README.md", "Makefile"} {
-		if _, err := os.Stat(filepath.Join(generated.dir, rel)); err != nil {
-			t.Fatalf("generated file %s: %v", rel, err)
-		}
-	}
-
-	generated.replaceModule(t)
-	generated.build(t)
-}
-
-// TestZeroToOneNoMCPContract keeps the MCP opt-out path honest. Some services
-// intentionally run without the local MCP listener, but that variant must still
-// satisfy the same 0→1 contract: scaffold, tidy, and build without additional
-// toolchain dependencies.
-func TestZeroToOneNoMCPContract(t *testing.T) {
-	generated := generateService(t, "worker", "--no-mcp")
-
-	main, err := os.ReadFile(filepath.Join(generated.dir, "main.go"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(string(main), "gateway/mcp") || strings.Contains(string(main), "WithMCP") {
-		t.Fatalf("--no-mcp generated main.go with MCP wiring:\n%s", main)
-	}
-
-	generated.replaceModule(t)
-	generated.build(t)
-}
-
-type generatedService struct {
-	dir      string
-	repoRoot string
-}
-
-func generateService(t *testing.T, name string, args ...string) generatedService {
-	t.Helper()
-
 	if testing.Short() {
 		t.Skip("contract test shells out to the Go toolchain; skipped with -short")
 	}
@@ -78,44 +39,35 @@ func generateService(t *testing.T, name string, args ...string) generatedService
 	defer os.Chdir(oldwd)
 
 	set := flag.NewFlagSet("micro-new", flag.ContinueOnError)
-	set.Bool("no-mcp", false, "")
-	set.Bool("proto", false, "")
-	set.String("template", "", "")
-	set.String("prompt", "", "")
-	set.String("provider", "", "")
-	set.String("api_key", "", "")
-	if err := set.Parse(append(args, name)); err != nil {
+	if err := set.Parse([]string{"helloworld"}); err != nil {
 		t.Fatal(err)
 	}
 	ctx := cli.NewContext(cli.NewApp(), set, nil)
 
 	if err := Run(ctx); err != nil {
-		t.Fatalf("micro new %s %s: %v", strings.Join(args, " "), name, err)
+		t.Fatalf("micro new helloworld: %v", err)
 	}
 
-	return generatedService{dir: filepath.Join(tmp, name), repoRoot: repoRoot}
-}
+	serviceDir := filepath.Join(tmp, "helloworld")
+	for _, rel := range []string{"go.mod", "main.go", "handler/helloworld.go", "README.md", "Makefile"} {
+		if _, err := os.Stat(filepath.Join(serviceDir, rel)); err != nil {
+			t.Fatalf("generated file %s: %v", rel, err)
+		}
+	}
 
-func (g generatedService) replaceModule(t *testing.T) {
-	t.Helper()
-
-	modPath := filepath.Join(g.dir, "go.mod")
+	modPath := filepath.Join(serviceDir, "go.mod")
 	mod, err := os.ReadFile(modPath)
 	if err != nil {
 		t.Fatal(err)
 	}
 	modText := strings.Replace(string(mod), "go-micro.dev/v6 latest", "go-micro.dev/v6 v6.0.0", 1)
-	modText += "\nreplace go-micro.dev/v6 => " + filepath.ToSlash(g.repoRoot) + "\n"
+	modText += "\nreplace go-micro.dev/v6 => " + filepath.ToSlash(repoRoot) + "\n"
 	if err := os.WriteFile(modPath, []byte(modText), 0644); err != nil {
 		t.Fatal(err)
 	}
-}
-
-func (g generatedService) build(t *testing.T) {
-	t.Helper()
 
 	cmd := exec.Command("go", "build", "./...")
-	cmd.Dir = g.dir
+	cmd.Dir = serviceDir
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("generated service go build ./... failed: %v\n%s", err, out)

flow/flow.go

@@ -182,19 +182,6 @@ func (f *Flow) Register(reg registry.Registry, br broker.Broker, cl client.Clien
 // registry. In-flight and past runs remain in the store; Stop only ends
 // the flow's liveness, mirroring how a service leaves the registry when
 // it shuts down.
-func (f *Flow) withTimeout(ctx context.Context) (context.Context, context.CancelFunc) {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	if f.opts.Timeout <= 0 {
-		return ctx, func() {}
-	}
-	if _, ok := ctx.Deadline(); ok {
-		return ctx, func() {}
-	}
-	return context.WithTimeout(ctx, f.opts.Timeout)
-}
-
 func (f *Flow) Stop() error {
 	if f.sub != nil {
 		_ = f.sub.Unsubscribe()
@@ -212,9 +199,6 @@ func (f *Flow) Stop() error {
 // called automatically on each broker event, but can also be
 // invoked directly for testing or one-shot use.
 func (f *Flow) Execute(ctx context.Context, data string) error {
-	ctx, cancel := f.withTimeout(ctx)
-	defer cancel()
-
 	// Stepped flows run the ordered, checkpointed step loop.
 	if len(f.opts.Steps) > 0 {
 		_, err := f.startRun(ctx, data)
@@ -222,7 +206,7 @@ func (f *Flow) Execute(ctx context.Context, data string) error {
 	}
 
 	runID := uuid.New().String()
-	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: runID, Flow: f.name})
+	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: runID, Agent: f.name})
 
 	start := time.Now()
 

flow/flow_test.go

@@ -1,11 +1,7 @@
 package flow
 
 import (
-	"context"
 	"testing"
-
-	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/registry"
 )
 
 func TestNew(t *testing.T) {
@@ -87,45 +83,3 @@ func TestDefaultOptions(t *testing.T) {
 		t.Error("default system prompt is empty")
 	}
 }
-
-func TestSingleStepFlowRunInfoIdentifiesFlow(t *testing.T) {
-	model := &runInfoModel{}
-	f := New("single-observed")
-	f.model = model
-	f.toolSet = ai.NewTools(registry.NewMemoryRegistry())
-
-	if err := f.Execute(context.Background(), "observe me"); err != nil {
-		t.Fatalf("Execute: %v", err)
-	}
-	if model.got.RunID == "" {
-		t.Fatal("RunInfo.RunID is empty")
-	}
-	if model.got.Flow != "single-observed" {
-		t.Fatalf("RunInfo.Flow = %q, want single-observed", model.got.Flow)
-	}
-	if model.got.Agent != "" {
-		t.Fatalf("RunInfo.Agent = %q, want empty for flow-owned LLM run", model.got.Agent)
-	}
-	if model.got.Step != "" {
-		t.Fatalf("RunInfo.Step = %q, want empty for single-step flow", model.got.Step)
-	}
-}
-
-type runInfoModel struct {
-	got ai.RunInfo
-}
-
-func (m *runInfoModel) Init(...ai.Option) error { return nil }
-
-func (m *runInfoModel) Options() ai.Options { return ai.Options{} }
-
-func (m *runInfoModel) Generate(ctx context.Context, _ *ai.Request, _ ...ai.GenerateOption) (*ai.Response, error) {
-	m.got, _ = ai.RunInfoFrom(ctx)
-	return &ai.Response{Reply: "ok"}, nil
-}
-
-func (m *runInfoModel) Stream(context.Context, *ai.Request, ...ai.GenerateOption) (ai.Stream, error) {
-	return nil, ai.ErrStreamingUnsupported
-}
-
-func (m *runInfoModel) String() string { return "run-info-model" }

flow/options.go

@@ -24,9 +24,6 @@ type Options struct {
 	BaseURL string
 	// HistoryLimit is the max messages per flow execution.
 	HistoryLimit int
-	// Timeout bounds one flow execution when the caller did not already
-	// provide a context deadline. Zero means no flow-level timeout.
-	Timeout time.Duration
 	// OnResult is called after each execution with the result.
 	OnResult func(Result)
 	// Agent, if set, names a registered agent the flow hands each event
@@ -97,13 +94,6 @@ func HistoryLimit(n int) Option {
 	return func(o *Options) { o.HistoryLimit = n }
 }
 
-// Timeout bounds one flow execution when the caller did not already
-// provide a context deadline. It applies to broker-triggered runs,
-// Execute calls, resumed stepped runs, and retry backoff waits.
-func Timeout(d time.Duration) Option {
-	return func(o *Options) { o.Timeout = d }
-}
-
 // OnResult sets a callback for each execution result.
 func OnResult(fn func(Result)) Option {
 	return func(o *Options) { o.OnResult = fn }

flow/otel.go

@@ -17,7 +17,6 @@ const (
 	spanNameFlowStep = "flow.step"
 
 	AttrFlowRunID     = "flow.run.id"
-	AttrFlowParentID  = "flow.run.parent_id"
 	AttrFlowName      = "flow.name"
 	AttrFlowStepName  = "flow.step.name"
 	AttrFlowStatus    = "flow.status"
@@ -35,7 +34,6 @@ func (f *Flow) startRunSpan(ctx context.Context, run Run) (context.Context, func
 	}
 	ctx, span := f.tracer().Start(ctx, spanNameFlowRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(
 		attribute.String(AttrFlowRunID, run.ID),
-		attribute.String(AttrFlowParentID, run.ParentID),
 		attribute.String(AttrFlowName, f.name),
 		attribute.String(AttrFlowStatus, run.Status),
 	))
@@ -62,7 +60,6 @@ func (f *Flow) runStepSpan(ctx context.Context, step Step, in State) (State, int
 	info, _ := ai.RunInfoFrom(ctx)
 	ctx, span := f.tracer().Start(ctx, spanNameFlowStep, trace.WithAttributes(
 		attribute.String(AttrFlowRunID, info.RunID),
-		attribute.String(AttrFlowParentID, info.ParentID),
 		attribute.String(AttrFlowName, f.name),
 		attribute.String(AttrFlowStepName, step.Name),
 	))

flow/otel_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/store"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/sdk/trace"
@@ -20,8 +19,7 @@ func TestFlowOpenTelemetrySpans(t *testing.T) {
 		return in, nil
 	}}
 	f := New("observed", WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "observed")), TraceProvider(tp), Steps(step))
-	ctx := withTestRunInfo(context.Background(), "agent-run-otel")
-	if err := f.Execute(ctx, "start"); err != nil {
+	if err := f.Execute(context.Background(), "start"); err != nil {
 		t.Fatal(err)
 	}
 
@@ -34,12 +32,12 @@ func TestFlowOpenTelemetrySpans(t *testing.T) {
 		case spanNameFlowRun:
 			seen[spanNameFlowRun] = true
 			runID = attrs[AttrFlowRunID]
-			if attrs[AttrFlowName] != "observed" || attrs[AttrFlowStatus] != "done" || attrs[AttrFlowParentID] != "agent-run-otel" {
+			if attrs[AttrFlowName] != "observed" || attrs[AttrFlowStatus] != "done" {
 				t.Fatalf("run span attributes = %#v", attrs)
 			}
 		case spanNameFlowStep:
 			seen[spanNameFlowStep] = true
-			if attrs[AttrFlowName] != "observed" || attrs[AttrFlowStepName] != "inspect" || attrs[AttrFlowParentID] != "agent-run-otel" {
+			if attrs[AttrFlowName] != "observed" || attrs[AttrFlowStepName] != "inspect" {
 				t.Fatalf("step span attributes = %#v", attrs)
 			}
 		}
@@ -70,7 +68,3 @@ func flowSpanAttributes(attrs []attribute.KeyValue) map[string]string {
 	}
 	return out
 }
-
-func withTestRunInfo(ctx context.Context, runID string) context.Context {
-	return ai.WithRunInfo(ctx, ai.RunInfo{RunID: runID, Agent: "planner"})
-}

flow/steps.go

@@ -74,14 +74,13 @@ type StepRecord struct {
 // saves and loads. It is retained for success and failure unless the flow
 // opts into cleanup with DeleteOnSuccess.
 type Run struct {
-	ID       string       `json:"id"`
-	ParentID string       `json:"parent_id,omitempty"`
-	Flow     string       `json:"flow"`
-	State    State        `json:"state"`
-	Steps    []StepRecord `json:"steps"`
-	Status   string       `json:"status"` // running | done | failed
-	Started  time.Time    `json:"started"`
-	Updated  time.Time    `json:"updated"`
+	ID      string       `json:"id"`
+	Flow    string       `json:"flow"`
+	State   State        `json:"state"`
+	Steps   []StepRecord `json:"steps"`
+	Status  string       `json:"status"` // running | done | failed
+	Started time.Time    `json:"started"`
+	Updated time.Time    `json:"updated"`
 }
 
 // Checkpoint persists and restores flow runs so a run survives a crash
@@ -310,17 +309,12 @@ func (f *Flow) startRun(ctx context.Context, data string) (Run, error) {
 	if err := validateSteps(f.opts.Steps); err != nil {
 		return Run{}, err
 	}
-	parentID := ""
-	if info, ok := ai.RunInfoFrom(ctx); ok {
-		parentID = info.RunID
-	}
 	run := Run{
-		ID:       uuid.New().String(),
-		ParentID: parentID,
-		Flow:     f.name,
-		State:    State{Stage: f.opts.Steps[0].Name, Data: []byte(data)},
-		Status:   "running",
-		Started:  time.Now(),
+		ID:      uuid.New().String(),
+		Flow:    f.name,
+		State:   State{Stage: f.opts.Steps[0].Name, Data: []byte(data)},
+		Status:  "running",
+		Started: time.Now(),
 	}
 	for _, s := range f.opts.Steps {
 		run.Steps = append(run.Steps, StepRecord{Name: s.Name, Status: "pending"})
@@ -331,9 +325,6 @@ func (f *Flow) startRun(ctx context.Context, data string) (Run, error) {
 // Resume continues a persisted run by id, picking up at the step it
 // stopped on. Completed runs are a no-op.
 func (f *Flow) Resume(ctx context.Context, runID string) error {
-	ctx, cancel := f.withTimeout(ctx)
-	defer cancel()
-
 	if err := validateSteps(f.opts.Steps); err != nil {
 		return err
 	}
@@ -363,9 +354,6 @@ func (f *Flow) Resume(ctx context.Context, runID string) error {
 // stops and returns that run id with the error so callers can log, alert, or
 // retry later without hiding the failing run.
 func (f *Flow) ResumePending(ctx context.Context) (string, error) {
-	ctx, cancel := f.withTimeout(ctx)
-	defer cancel()
-
 	runs, err := f.Pending(ctx)
 	if err != nil {
 		return "", err
@@ -402,7 +390,7 @@ func (f *Flow) Pending(ctx context.Context) ([]Run, error) {
 func (f *Flow) runFrom(ctx context.Context, run Run) (Run, error) {
 	steps := f.opts.Steps
 	ctx = withDeps(ctx, &runDeps{client: f.client, model: f.model, tools: f.toolSet})
-	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: run.ID, ParentID: run.ParentID, Agent: f.name, Flow: f.name})
+	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: run.ID, Agent: f.name})
 	ctx, finishSpan := f.startRunSpan(ctx, run)
 	var spanErr error
 	defer func() { finishSpan(run, spanErr) }()
@@ -490,10 +478,6 @@ func (f *Flow) runStep(ctx context.Context, step Step, in State) (State, int, er
 		if err := ctx.Err(); err != nil {
 			return in, attempt - 1, err
 		}
-		if info, ok := ai.RunInfoFrom(ctx); ok {
-			info.Step = step.Name
-			ctx = ai.WithRunInfo(ctx, info)
-		}
 		out, err := step.Run(ctx, in)
 		if err == nil {
 			return out, attempt, nil

flow/steps_test.go

@@ -99,13 +99,11 @@ func TestFlowStepContextIncludesRunInfo(t *testing.T) {
 		return in, nil
 	}}
 
-	mem := store.NewMemoryStore()
 	f := New("correlated",
-		WithCheckpoint(StoreCheckpoint(mem, "correlated")),
+		WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "correlated")),
 		Steps(step),
 	)
-	ctx := ai.WithRunInfo(context.Background(), ai.RunInfo{RunID: "agent-run-1", Agent: "planner"})
-	if err := f.Execute(ctx, "start"); err != nil {
+	if err := f.Execute(context.Background(), "start"); err != nil {
 		t.Fatalf("Execute: %v", err)
 	}
 	if got.Agent != "correlated" {
@@ -114,22 +112,6 @@ func TestFlowStepContextIncludesRunInfo(t *testing.T) {
 	if got.RunID == "" {
 		t.Fatal("RunInfo.RunID is empty")
 	}
-	if got.Flow != "correlated" {
-		t.Fatalf("RunInfo.Flow = %q, want correlated", got.Flow)
-	}
-	if got.ParentID != "agent-run-1" {
-		t.Fatalf("RunInfo.ParentID = %q, want agent-run-1", got.ParentID)
-	}
-	if got.Step != "inspect" {
-		t.Fatalf("RunInfo.Step = %q, want inspect", got.Step)
-	}
-	runs, err := StoreCheckpoint(mem, "correlated").List(context.Background())
-	if err != nil {
-		t.Fatalf("List: %v", err)
-	}
-	if len(runs) != 1 || runs[0].ParentID != "agent-run-1" {
-		t.Fatalf("persisted parent id = %+v, want agent-run-1", runs)
-	}
 }
 
 func TestFlowResumePendingResumesOldestRunsUntilFailure(t *testing.T) {
@@ -279,50 +261,6 @@ func TestFlowStepRetryBackoffWaitsBetweenAttempts(t *testing.T) {
 	}
 }
 
-func TestFlowTimeoutStopsRetryBackoff(t *testing.T) {
-	var attempts int
-	step := Step{Name: "slow", Run: func(_ context.Context, in State) (State, error) {
-		attempts++
-		return in, errors.New("transient")
-	}}
-
-	f := New("timeout-backoff",
-		WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "timeout-backoff")),
-		Timeout(20*time.Millisecond),
-		Retry(1),
-		RetryBackoff(time.Hour),
-		Steps(step),
-	)
-	err := f.Execute(context.Background(), "")
-	if err == nil {
-		t.Fatal("expected the timed-out run to fail")
-	}
-	if !errors.Is(err, context.DeadlineExceeded) {
-		t.Errorf("want a context deadline error, got %v", err)
-	}
-	if attempts != 1 {
-		t.Errorf("timeout should stop during backoff before retrying, got %d attempts", attempts)
-	}
-}
-
-func TestFlowTimeoutRespectsExistingDeadline(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Hour)
-	defer cancel()
-
-	f := New("existing-deadline", Timeout(time.Millisecond))
-	got, stop := f.withTimeout(ctx)
-	defer stop()
-
-	wantDeadline, _ := ctx.Deadline()
-	gotDeadline, ok := got.Deadline()
-	if !ok {
-		t.Fatal("expected the existing deadline to remain set")
-	}
-	if !gotDeadline.Equal(wantDeadline) {
-		t.Fatalf("deadline = %v, want existing deadline %v", gotDeadline, wantDeadline)
-	}
-}
-
 func TestFlowStepRetryBackoffStopsOnCancel(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	var attempts int

gateway/a2a/a2a.go

@@ -18,11 +18,10 @@
 //		BaseURL:  "https://agents.example.com",
 //	})
 //
-// Scope of this version: the JSON-RPC binding — `message/send`
-// (returns a completed Task), `message/stream` (SSE with the completed
-// Task event), `tasks/get`, and Agent Card discovery. Multi-turn
-// `input-required`, `tasks/resubscribe`, and push notifications are
-// advertised as unsupported and are follow-ups.
+// Scope of this version: the synchronous JSON-RPC binding — `message/send`
+// (returns a completed Task), `tasks/get`, and Agent Card discovery.
+// Streaming (`message/stream`), multi-turn `input-required`, and push
+// notifications are advertised as unsupported and are follow-ups.
 package a2a
 
 import (
@@ -315,7 +314,7 @@ func Card(name, url, description string, services []string) AgentCard {
 		URL:             url,
 		Version:         "1.0.0",
 		ProtocolVersion: protocolVersion,
-		Capabilities:    Capabilities{Streaming: true, PushNotifications: false},
+		Capabilities:    Capabilities{Streaming: false, PushNotifications: false},
 		// The agent converses over a single Chat endpoint; advertise that
 		// as one skill, tagged with the services it manages.
 		DefaultInputModes:  []string{"text/plain"},
@@ -417,15 +416,13 @@ func (d *dispatcher) serve(w http.ResponseWriter, r *http.Request, invoke Invoke
 	switch req.Method {
 	case "message/send":
 		d.send(requestContext(r.Context()), w, req, invoke)
-	case "message/stream":
-		d.stream(requestContext(r.Context()), w, req, invoke)
 	case "tasks/get":
 		d.get(w, req)
 	case "tasks/cancel":
 		// v1 tasks complete synchronously, so they're already terminal.
 		writeRPC(w, req.ID, nil, &rpcError{Code: errNotCancelable, Message: "task is not cancelable"})
-	case "tasks/resubscribe":
-		writeRPC(w, req.ID, nil, &rpcError{Code: errMethodNotFound, Message: "resubscribe is not supported"})
+	case "message/stream", "tasks/resubscribe":
+		writeRPC(w, req.ID, nil, &rpcError{Code: errMethodNotFound, Message: "streaming is not supported"})
 	default:
 		writeRPC(w, req.ID, nil, &rpcError{Code: errMethodNotFound, Message: "method not found: " + req.Method})
 	}
@@ -436,38 +433,15 @@ type sendParams struct {
 }
 
 func (d *dispatcher) send(ctx context.Context, w http.ResponseWriter, req rpcRequest, invoke Invoke) {
-	task, e := d.run(ctx, req.Params, invoke)
-	if e != nil {
-		writeRPC(w, req.ID, nil, e)
-		return
-	}
-	writeRPC(w, req.ID, task, nil)
-}
-
-func (d *dispatcher) stream(ctx context.Context, w http.ResponseWriter, req rpcRequest, invoke Invoke) {
-	task, e := d.run(ctx, req.Params, invoke)
-	if e != nil {
-		writeRPC(w, req.ID, nil, e)
-		return
-	}
-	w.Header().Set("Content-Type", "text/event-stream")
-	w.Header().Set("Cache-Control", "no-cache")
-	w.Header().Set("Connection", "keep-alive")
-	w.WriteHeader(http.StatusOK)
-	_ = json.NewEncoder(sseWriter{w: w}).Encode(rpcResponse{JSONRPC: "2.0", ID: req.ID, Result: task})
-	if f, ok := w.(http.Flusher); ok {
-		f.Flush()
-	}
-}
-
-func (d *dispatcher) run(ctx context.Context, params json.RawMessage, invoke Invoke) (*Task, *rpcError) {
 	var p sendParams
-	if err := json.Unmarshal(params, &p); err != nil {
-		return nil, &rpcError{Code: errInvalidParams, Message: "invalid params"}
+	if err := json.Unmarshal(req.Params, &p); err != nil {
+		writeRPC(w, req.ID, nil, &rpcError{Code: errInvalidParams, Message: "invalid params"})
+		return
 	}
 	text := textOf(p.Message.Parts)
 	if text == "" {
-		return nil, &rpcError{Code: errInvalidParams, Message: "message has no text part"}
+		writeRPC(w, req.ID, nil, &rpcError{Code: errInvalidParams, Message: "message has no text part"})
+		return
 	}
 
 	reply, err := invoke(ctx, text)
@@ -483,22 +457,14 @@ func (d *dispatcher) run(ctx context.Context, params json.RawMessage, invoke Inv
 		Status:    TaskStatus{Timestamp: time.Now().UTC().Format(time.RFC3339)},
 	}
 	if err != nil {
-		reply = "error: " + err.Error()
 		task.Status.State = stateFailed
+		task.Artifacts = []Artifact{textArtifact("error: " + err.Error())}
 	} else {
 		task.Status.State = stateCompleted
+		task.Artifacts = []Artifact{textArtifact(reply)}
 	}
-	task.Artifacts = []Artifact{textArtifact(reply)}
-	task.History = append(task.History, Message{
-		Role:      "agent",
-		Parts:     []Part{{Kind: "text", Text: reply}},
-		MessageID: uuid.New().String(),
-		TaskID:    task.ID,
-		ContextID: task.ContextID,
-		Kind:      "message",
-	})
 	d.store(task)
-	return task, nil
+	writeRPC(w, req.ID, task, nil)
 }
 
 type getParams struct {
@@ -599,24 +565,6 @@ func requestContext(parent context.Context) context.Context {
 	return ctx
 }
 
-type sseWriter struct {
-	w http.ResponseWriter
-}
-
-func (s sseWriter) Write(p []byte) (int, error) {
-	if _, err := s.w.Write([]byte("data: ")); err != nil {
-		return 0, err
-	}
-	n, err := s.w.Write(p)
-	if err != nil {
-		return n, err
-	}
-	if _, err := s.w.Write([]byte("\n")); err != nil {
-		return n, err
-	}
-	return n, nil
-}
-
 func writeJSON(w http.ResponseWriter, status int, v any) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)

gateway/a2a/a2a_test.go

@@ -4,10 +4,8 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"strings"
 	"testing"
 	"time"
 
@@ -46,7 +44,6 @@ func newGatewayWithAgent(t *testing.T) (*httptest.Server, func()) {
 
 	srv := server.NewServer(
 		server.Name("echo"),
-		server.Address("127.0.0.1:0"),
 		server.Registry(reg),
 		server.Metadata(map[string]string{"type": "agent", "services": ""}),
 	)
@@ -104,12 +101,6 @@ func TestMessageSendAndGet(t *testing.T) {
 	if len(task.Artifacts) != 1 || textOf(task.Artifacts[0].Parts) != "pong" {
 		t.Fatalf("artifact = %+v, want text 'pong'", task.Artifacts)
 	}
-	if len(task.History) != 2 || task.History[1].Role != "agent" || textOf(task.History[1].Parts) != "pong" {
-		t.Fatalf("history = %+v, want user turn followed by agent reply", task.History)
-	}
-	if task.History[1].TaskID != task.ID || task.History[1].ContextID != task.ContextID {
-		t.Fatalf("agent history linkage = task %q/%q context %q/%q", task.History[1].TaskID, task.ID, task.History[1].ContextID, task.ContextID)
-	}
 
 	got := rpcTask(t, ts.URL+"/agents/echo", `{
 		"jsonrpc":"2.0","id":2,"method":"tasks/get","params":{"id":"`+task.ID+`"}}`)
@@ -152,45 +143,6 @@ func TestMessageSendUsesRequestContext(t *testing.T) {
 	if len(resp.Result.Artifacts) != 1 || textOf(resp.Result.Artifacts[0].Parts) != "error: context canceled" {
 		t.Fatalf("artifact = %+v, want context cancellation", resp.Result.Artifacts)
 	}
-	if len(resp.Result.History) != 2 || resp.Result.History[1].Role != "agent" || textOf(resp.Result.History[1].Parts) != "error: context canceled" {
-		t.Fatalf("history = %+v, want failed agent reply recorded", resp.Result.History)
-	}
-}
-
-func TestMessageStream(t *testing.T) {
-	ts, cleanup := newGatewayWithAgent(t)
-	defer cleanup()
-
-	body := `{"jsonrpc":"2.0","id":1,"method":"message/stream","params":{"message":{"role":"user","parts":[{"kind":"text","text":"ping"}],"kind":"message"}}}`
-	resp, err := http.Post(ts.URL+"/agents/echo", "application/json", bytes.NewBufferString(body))
-	if err != nil {
-		t.Fatalf("post: %v", err)
-	}
-	defer resp.Body.Close()
-	if ct := resp.Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/event-stream") {
-		t.Fatalf("content-type = %q, want text/event-stream", ct)
-	}
-
-	var line string
-	if _, err := fmt.Fscan(resp.Body, &line); err != nil {
-		t.Fatalf("read event prefix: %v", err)
-	}
-	if line != "data:" {
-		t.Fatalf("event prefix = %q, want data:", line)
-	}
-	var out struct {
-		Result Task      `json:"result"`
-		Error  *rpcError `json:"error"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
-		t.Fatalf("decode event: %v", err)
-	}
-	if out.Error != nil {
-		t.Fatalf("rpc error: %+v", out.Error)
-	}
-	if out.Result.Status.State != stateCompleted || len(out.Result.Artifacts) != 1 || textOf(out.Result.Artifacts[0].Parts) != "pong" {
-		t.Fatalf("streamed task = %+v", out.Result)
-	}
 }
 
 func TestUnknownMethod(t *testing.T) {
@@ -200,9 +152,9 @@ func TestUnknownMethod(t *testing.T) {
 	var resp struct {
 		Error *rpcError `json:"error"`
 	}
-	rpc(t, ts.URL+"/agents/echo", `{"jsonrpc":"2.0","id":1,"method":"tasks/resubscribe","params":{}}`, &resp)
+	rpc(t, ts.URL+"/agents/echo", `{"jsonrpc":"2.0","id":1,"method":"message/stream","params":{}}`, &resp)
 	if resp.Error == nil || resp.Error.Code != errMethodNotFound {
-		t.Errorf("expected method-not-found for resubscribe, got %+v", resp.Error)
+		t.Errorf("expected method-not-found for streaming, got %+v", resp.Error)
 	}
 }
 

internal/docs/CONTINUOUS_IMPROVEMENT.md

@@ -133,26 +133,16 @@ output) but produce direction and coherence, not just code.
   factual-alignment and crispness fixes auto-merge like any increment;
   brand/positioning copy and blog drafts are *surfaced in a report* for the
   human, never auto-merged.
-- **Architect — continuous (hourly)** (`.github/workflows/architecture-review.yml`).
-  The *founder lens*, running alongside the builders. Each run it **tracks live
-  state** (what just merged, what's in flight), **prioritizes the roadmap**
-  (`ROADMAP.md`, Now → Next → Later) against an internal scan (lifecycle gaps, API
-  coherence and seams, dev-UX friction, missing pieces, drift/realignment), and
-  **maintains the ranked queue** in [`PRIORITIES.md`](PRIORITIES.md) — re-ranking
-  to reflect reality, backing each top item with a scoped issue, and posting an
-  assessment. It runs at `:59`, just before the `:29` increment, so it
-  re-prioritizes and *then* the loop builds the new top. **Its output is the
-  prioritized queue plus the assessment** — it does **not** make breaking or
-  architectural changes itself (those stay with the human). To avoid churn it only
-  opens a PR when the ranking actually changes.
+- **Architect — every few days** (`.github/workflows/architecture-review.yml`).
+  Reviews the framework/harness against the thesis: API coherence, lifecycle
+  gaps, drift/sprawl. **Its output is an assessment plus scoped follow-up
+  issues** that feed the hourly increment loop — it does **not** make breaking or
+  architectural changes itself (those stay with the human).
 
-The two loops are coupled through `PRIORITIES.md`: the **architect decides *what***
-(roadmap + internal priorities, ranked, issue-linked) and the **hourly increment
-loop builds the top open item** — falling back to its own judgment only if the
-queue is empty. DevRel keeps the public story honest alongside. So work is
-roadmap-driven by default, not a fresh guess every hour. Cadence is tunable in each
-workflow's `cron`; the human can reorder `PRIORITIES.md` or its issues at any time
-to redirect. Codex is serial, so these passes queue behind any in-flight increment.
+Together they close the loop: the architect decides *what* should change and files
+issues, the increment loop *builds* them, and DevRel keeps the public story
+honest. Cadence is tunable in each workflow's `cron`. Codex is serial, so these
+passes queue behind any in-flight increment rather than running concurrently.
 
 ## Stop / redirect
 

internal/docs/PRIORITIES.md

@@ -1,40 +0,0 @@
-# Priorities
-
-The ranked work queue for the autonomous improvement loop. The
-**architecture-review** pass (the *architect*) owns this file: each run it turns
-the [roadmap](../../ROADMAP.md) plus an internal scan (gaps in the
-services → agents → workflows lifecycle, API coherence, drift, tech debt, test and
-DX friction) into a single ordered list — highest-value first — and links each
-item to a tracking issue. The hourly **continuous-improvement** pass works the
-**top item whose issue is still open**. So the architect decides *what*, and the
-increment loop *builds* it.
-
-**Reading / editing.** An item is done when its linked issue closes (the increment
-that builds it adds `Closes #<issue>`). Roadmap phase (Now → Next → Later) is the
-primary ordering; internal findings are interleaved by value, not kept in a
-separate list. The human can reorder this list — or the issues — at any time to
-redirect the loop; direction always wins.
-
-**Off-limits to the loop** (the architect proposes these as notes, never as queue
-items the loop can auto-merge): brand/positioning copy, breaking public-API
-changes, architectural rewrites. Those go to the human.
-
-## Now (ranked)
-
-1. **Streaming end to end** (#3012) — `ai.Stream` through `micro chat`, the agent
-   RPC, and A2A `message/stream`; scope to chat + one provider first. Roadmap →
-   *Next* and now the highest-value lifecycle seam after durable agent resume
-   shipped.
-2. **Registry disconnection detection** (#2956) — readiness/health when a service
-   silently loses its registry connection. Community-requested production
-   reliability; keeps the service substrate operable because agents depend on
-   discovery.
-3. **Agent observability spans** (#3182) — export `RunInfo` as OpenTelemetry spans
-   for agent runs, model calls, tool calls, delegation, and failures. Roadmap →
-   *Next*; makes the now-durable harness inspectable in production.
-4. **Execution lifecycle hooks & metadata** (#2980) — before/after-tool, retry,
-   and failure hooks; first check overlap with the shipped run-timeline /
-   OpenTelemetry work and scope to what's not already covered.
-
-_Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
-architecture-review pass._

internal/docs/THESIS.md

@@ -4,39 +4,6 @@ This is the North Star for the project and for the autonomous improvement loop
 (see `CONTINUOUS_IMPROVEMENT.md`). Every change should move toward it; work that
 doesn't isn't an improvement, however clean.
 
-## Mission — the problem we solve
-
-Go Micro started in 2015 because building distributed systems in Go was too hard:
-too much boilerplate, too many decisions before a single endpoint runs. The
-mission was to **make building distributed systems simple** — sane defaults,
-pluggable, out of the developer's way.
-
-Agents are distributed systems too. The moment an agent discovers services, calls
-them, holds state, and recovers from failure, it *is* a distributed system — the
-exact problem Go Micro already solved for services. So the mission hasn't
-changed, only extended:
-
-> **Make building agentic, distributed software in Go simple — make building an
-> agent as easy as building a service, on one runtime, because an agent is a
-> distributed system.**
-
-That is the problem we solve, and it is the question every priority is judged
-against: *does this make the services → agents → workflows lifecycle simpler, more
-cohesive, and more operable — or is it scope that doesn't serve that?* It is
-evolution, not a pivot: the decade of services work is the foundation, and the
-agent layer is that foundation leveraged for the AI era.
-
-## The canon
-
-The vision isn't only in this file. The years of focus and context live in the
-**corpus** — the [blog](../website/blog/) (the actual thinking, e.g. `/blog/14`
-"Going All In on AI" and `/blog/27` "Back from the Dead"), the
-[`README`](../../README.md), and the [website](../website/). Those are the canon;
-this North Star is their **distillation** and must stay faithful to them. When the
-two diverge, that's a signal — either the work has drifted from the mission, or the
-North Star has drifted from the lived story and needs re-grounding in the corpus.
-The architect re-derives alignment from the canon, not from this file alone.
-
 ## Thesis
 
 Go Micro is an **agent harness and service framework** — one runtime that, holistically,

internal/harness/plan-delegate/main.go

@@ -225,19 +225,22 @@ func providerKey(provider string) string {
 	return os.Getenv(env)
 }
 
-func runPlanDelegate(provider string) error {
+func main() {
+	provider := flag.String("provider", "mock", "LLM provider: mock (default), anthropic, openai, gemini, groq, mistral, together, atlascloud")
+	flag.Parse()
+
 	apiKey := ""
-	if provider == "mock" {
+	if *provider == "mock" {
 		ai.Register("mock", newMock)
 	} else {
-		apiKey = providerKey(provider)
+		apiKey = providerKey(*provider)
 		if apiKey == "" {
-			fmt.Printf("no API key for provider %q — set MICRO_AI_API_KEY or the provider's key env\n", provider)
-			return nil
+			fmt.Printf("no API key for provider %q — set MICRO_AI_API_KEY or the provider's key env\n", *provider)
+			return
 		}
 	}
 
-	fmt.Printf("\n\033[1mPlan & Delegate — live integration harness (provider: %s)\033[0m\n", provider)
+	fmt.Printf("\n\033[1mPlan & Delegate — live integration harness (provider: %s)\033[0m\n", *provider)
 	fmt.Print("Real services, registry, RPC, agent loop, store, delegation.\n\n")
 
 	reg := registry.NewMemoryRegistry()
@@ -248,14 +251,16 @@ func runPlanDelegate(provider string) error {
 	taskSvc := new(TaskService)
 	task := service.New(service.Name("task"), service.Address("127.0.0.1:0"), service.Registry(reg), service.Client(cl))
 	if err := task.Handle(taskSvc); err != nil {
-		return fmt.Errorf("task handle: %w", err)
+		fmt.Println("task handle:", err)
+		os.Exit(1)
 	}
 	go task.Run()
 
 	notifySvc := new(NotifyService)
 	notify := service.New(service.Name("notify"), service.Address("127.0.0.1:0"), service.Registry(reg), service.Client(cl))
 	if err := notify.Handle(notifySvc); err != nil {
-		return fmt.Errorf("notify handle: %w", err)
+		fmt.Println("notify handle:", err)
+		os.Exit(1)
 	}
 	go notify.Run()
 
@@ -265,7 +270,7 @@ func runPlanDelegate(provider string) error {
 		agent.Address("127.0.0.1:0"),
 		agent.Services("notify"),
 		agent.Prompt("You handle outbound notifications. Use the notify service."),
-		agent.Provider(provider), agent.APIKey(apiKey),
+		agent.Provider(*provider), agent.APIKey(apiKey),
 		agent.WithRegistry(reg), agent.WithClient(cl), agent.WithStore(mem),
 	)
 	go comms.Run()
@@ -277,27 +282,24 @@ func runPlanDelegate(provider string) error {
 		agent.Address("127.0.0.1:0"),
 		agent.Services("task"),
 		agent.Prompt("You coordinate launch work. Plan first, create tasks, and delegate notifications to the \"comms\" agent."),
-		agent.Provider(provider), agent.APIKey(apiKey),
+		agent.Provider(*provider), agent.APIKey(apiKey),
 		agent.WithRegistry(reg), agent.WithClient(cl), agent.WithStore(mem),
 	)
 	go conductor.Run()
 	defer conductor.Stop()
 
 	fmt.Println("waiting for services + agents to register...")
-	waitForService := func(name string) error {
+	waitForService := func(name string) {
 		deadline := time.Now().Add(5 * time.Second)
 		for time.Now().Before(deadline) {
 			if svcs, err := reg.GetService(name); err == nil && len(svcs) > 0 && len(svcs[0].Nodes) > 0 {
-				return nil
+				return
 			}
 			time.Sleep(20 * time.Millisecond)
 		}
-		return fmt.Errorf("service %q never registered", name)
 	}
 	for _, name := range []string{"task", "notify", "comms", "conductor"} {
-		if err := waitForService(name); err != nil {
-			return err
-		}
+		waitForService(name)
 	}
 
 	f := flow.New("zero-to-hero",
@@ -305,12 +307,14 @@ func runPlanDelegate(provider string) error {
 		flow.Prompt("Create three launch tasks (Design, Build, Ship), then make sure owner@acme.com is notified: {{.Data}}"),
 	)
 	if err := f.Register(reg, broker.DefaultBroker, cl); err != nil {
-		return fmt.Errorf("flow register: %w", err)
+		fmt.Println("flow register:", err)
+		os.Exit(1)
 	}
 
 	fmt.Print("\n\033[1m> flow:\033[0m services + agents + workflow + plan/delegate, no API key.\n\n")
 	if err := f.Execute(context.Background(), "launch readiness"); err != nil {
-		return fmt.Errorf("flow execute: %w", err)
+		fmt.Println("\033[31merror:\033[0m", err)
+		os.Exit(1)
 	}
 
 	if rs := f.Results(); len(rs) > 0 {
@@ -321,22 +325,13 @@ func runPlanDelegate(provider string) error {
 	if recs, _ := store.Scope(mem, "agent", "conductor").Read("plan"); len(recs) > 0 {
 		fmt.Printf("\n\033[1mstored plan (agent/conductor/plan):\033[0m %s\n", string(recs[0].Value))
 	} else {
-		return fmt.Errorf("plan was not persisted")
+		fmt.Println("\n\033[31m! plan was not persisted\033[0m")
+		os.Exit(1)
 	}
 	if taskSvc.count() != 3 || notifySvc.count() != 1 {
-		return fmt.Errorf("unexpected side effects: tasks=%d notify=%d", taskSvc.count(), notifySvc.count())
+		fmt.Printf("\n\033[31m! unexpected side effects: tasks=%d notify=%d\033[0m\n", taskSvc.count(), notifySvc.count())
+		os.Exit(1)
 	}
 
 	fmt.Println("\n\033[32m✓ 0→hero flow complete (services → agents → workflow)\033[0m")
-	return nil
-}
-
-func main() {
-	provider := flag.String("provider", "mock", "LLM provider: mock (default), anthropic, openai, gemini, groq, mistral, together, atlascloud")
-	flag.Parse()
-
-	if err := runPlanDelegate(*provider); err != nil {
-		fmt.Println("\033[31merror:\033[0m", err)
-		os.Exit(1)
-	}
 }

internal/harness/plan-delegate/main_test.go

@@ -206,16 +206,3 @@ func TestFlowDispatchesToAgentEndToEnd(t *testing.T) {
 		t.Errorf("notify called %d times, want 1 (flow->agent->delegate->comms chain broken)", n)
 	}
 }
-
-// TestZeroToHeroContract locks the roadmap's second golden path into the
-// ordinary Go test contract. It runs the same executable harness used by
-// `make harness`: services + agents + flow + plan/delegate, with only the
-// LLM replaced by the deterministic mock provider.
-func TestZeroToHeroContract(t *testing.T) {
-	if testing.Short() {
-		t.Skip("0→hero harness boots an end-to-end system; skipped with -short")
-	}
-	if err := runPlanDelegate("mock"); err != nil {
-		t.Fatalf("0→hero harness: %v", err)
-	}
-}

internal/website/docs/guides/a2a-protocol.md

@@ -132,10 +132,9 @@ yet terminal, it polls `tasks/get` until it completes.
 
 ## Scope
 
-This is the JSON-RPC binding for completed-task execution:
+This is the synchronous JSON-RPC binding:
 
 - **`message/send`** runs the agent and returns a completed `Task`.
-- **`message/stream`** streams the completed `Task` as an SSE `data:` event, giving A2A clients a streaming-compatible path while the underlying agent call remains synchronous.
 - **`tasks/get`** returns a recent task by id.
 - **Agent Card** discovery, generated from the registry.
 
@@ -143,11 +142,11 @@ Both directions work: the gateway exposes your agents, and `a2a.Client` (via `fl
 
 Not yet supported (advertised as such on the card, so clients negotiate correctly):
 
-- **`tasks/resubscribe`** for reconnecting to a live stream.
+- **`message/stream`** (SSE streaming) and `tasks/resubscribe`.
 - Multi-turn `input-required` tasks.
 - Push notifications.
 
-These are the natural follow-ups; the completed-task binding is what makes a Go Micro agent both reachable from, and able to reach, the A2A ecosystem today.
+These are the natural follow-ups; the synchronous binding is what makes a Go Micro agent both reachable from, and able to reach, the A2A ecosystem today.
 
 ## See also