docs(priorities): refresh architect queue

.github/workflows/harness.yml

@@ -27,8 +27,14 @@ jobs:
           cache: true
       - name: Build
         run: go build ./...
-      - name: 0→1 and 0→hero developer-flow harness
-        run: make harness
+      - name: 0→1 scaffold contract
+        run: go test ./cmd/micro/cli/new -run TestZeroToOneContract -count=1
+      - name: Universe end-to-end (asserts; exits non-zero on failure)
+        run: go run ./internal/harness/universe
+      - name: Agent-flow harness
+        run: go run ./internal/harness/agent-flow
+      - name: 0→hero run/chat/inspect reference scenario
+        run: ./internal/harness/zero-to-hero-ci/run.sh
 
   harness-live:
     name: Provider harnesses (live LLM conformance)
@@ -44,6 +50,17 @@ jobs:
         with:
           go-version: stable
           cache: true
+      - name: Agent provider conformance matrix
+        env:
+          GO_MICRO_AGENT_CONFORMANCE_LIVE: "1"
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
+          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
+          ATLASCLOUD_API_KEY: ${{ secrets.ATLASCLOUD_API_KEY }}
+        run: go test ./agent -run TestAgentProviderConformanceMatrix -count=1 -v
       - name: Provider conformance against live models
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Makefile

@@ -47,10 +47,9 @@ test-coverage:
 # This mirrors the default CI path so local dogfooding catches scaffold,
 # run/chat/inspect, and 0→hero regressions before a PR is opened.
 harness:
-	go test ./cmd/micro/cli/new -run TestZeroToOne -count=1
+	go test ./cmd/micro/cli/new -run TestZeroToOneContract -count=1
 	./internal/harness/zero-to-hero-ci/run.sh
 	go run ./internal/harness/agent-flow
-	go run ./internal/harness/provider-conformance -providers mock
 
 # Run the same harnesses against every configured live provider. Providers
 # without API keys are skipped; configured providers must pass.

README.md

@@ -64,14 +64,6 @@ curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
   -H 'Content-Type: application/json' -d '{"name":"World"}'
 ```
 
-This scaffold → run → call path is covered by the no-secret CI harness. To run
-the same local contract (including the 0→hero services → agents → workflows path,
-chat/inspect CLI boundaries, and deploy dry-run), use:
-
-```bash
-make harness
-```
-
 ### Generate from a prompt — with an LLM key
 
 Set a provider key, describe what you want, and the AI designs services, writes handlers, compiles, and starts them:

agent/builtin.go

@@ -113,14 +113,13 @@ func Builtins(opts ...Option) (tools []ai.Tool, handle func(name string, input m
 // prevents runaway recursion).
 func (a *agentImpl) toolHandler() ai.ToolHandler {
 	if a.ephemeral {
-		return a.toolTimeoutWrap(a.tools.Handler())
+		return a.tools.Handler()
 	}
 
 	// Innermost first: base, then guardrails (approve → loop → step →
 	// plan), then developer wrappers outermost. Wrapping reverses order,
 	// so the result runs plan → step → loop → approve → checkpoint → base.
 	h := a.baseHandler()
-	h = a.toolTimeoutWrap(h)
 	h = a.checkpointToolWrap(h)
 	h = a.approveWrap(h)
 	h = a.loopWrap(h)
@@ -149,21 +148,6 @@ func contextWrap(next ai.ToolHandler) ai.ToolHandler {
 	}
 }
 
-// toolTimeoutWrap gives each tool execution its own deadline while preserving
-// caller cancellation. Handlers still execute synchronously; tools that honor
-// context (custom tools, delegate RPC/A2A, and go-micro RPC clients) return
-// promptly with a bounded error result when the deadline expires.
-func (a *agentImpl) toolTimeoutWrap(next ai.ToolHandler) ai.ToolHandler {
-	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		if a.opts.ToolTimeout <= 0 {
-			return next(ctx, call)
-		}
-		toolCtx, cancel := context.WithTimeout(ctx, a.opts.ToolTimeout)
-		defer cancel()
-		return next(toolCtx, call)
-	}
-}
-
 // baseHandler executes a tool call: a developer custom tool, the built-in
 // delegate, or an RPC to the service. It is the innermost handler.
 func (a *agentImpl) baseHandler() ai.ToolHandler {
@@ -335,9 +319,6 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) ai.Too
 		WithRegistry(a.opts.Registry),
 		WithClient(a.opts.Client),
 		WithStore(a.opts.Store),
-		ModelCallTimeout(a.opts.ModelTimeout),
-		ModelRetry(a.opts.ModelMaxAttempts, a.opts.ModelRetryBackoff),
-		ToolCallTimeout(a.opts.ToolTimeout),
 		TraceProvider(a.opts.TraceProvider),
 	)
 	// Record lineage so the sub-agent's tool calls carry this run as parent.

agent/checkpoint.go

@@ -88,9 +88,6 @@ func (a *agentImpl) resume(ctx context.Context, runID string) (*Response, error)
 		}
 		return &resp, nil
 	}
-	if terminalAgentRunStatus(run.Status) {
-		return nil, fmt.Errorf("agent run %s is terminal with status %q", runID, run.Status)
-	}
 	message := string(run.State.Data)
 	parentID := run.ParentID
 	a.mu.Lock()
@@ -156,22 +153,13 @@ func (a *agentImpl) pending(ctx context.Context) ([]flow.Run, error) {
 	}
 	out := runs[:0]
 	for _, run := range runs {
-		if run.Flow == a.opts.Name && !terminalAgentRunStatus(run.Status) {
+		if run.Flow == a.opts.Name && run.Status != "done" {
 			out = append(out, run)
 		}
 	}
 	return out, nil
 }
 
-func terminalAgentRunStatus(status string) bool {
-	switch status {
-	case "done", "canceled", "expired":
-		return true
-	default:
-		return false
-	}
-}
-
 func (a *agentImpl) checkpointToolWrap(next ai.ToolHandler) ai.ToolHandler {
 	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 		if a.opts.Checkpoint == nil || a.currentRun == nil {

agent/checkpoint_test.go

@@ -185,35 +185,6 @@ func TestPendingReturnsUnfinishedAgentRuns(t *testing.T) {
 	}
 }
 
-func TestPendingSkipsTerminalCanceledAndExpiredAgentRuns(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewStore(), "terminal-agent")
-	for _, run := range []flow.Run{
-		{ID: "active", Flow: "terminal-agent", Status: "failed", State: flow.State{Stage: agentAskStep, Data: []byte("retry me")}},
-		{ID: "done", Flow: "terminal-agent", Status: "done", State: flow.State{Stage: agentAskStep, Data: []byte("done")}},
-		{ID: "canceled", Flow: "terminal-agent", Status: "canceled", State: flow.State{Stage: agentAskStep, Data: []byte("canceled")}},
-		{ID: "expired", Flow: "terminal-agent", Status: "expired", State: flow.State{Stage: agentAskStep, Data: []byte("expired")}},
-	} {
-		if err := cp.Save(ctx, run); err != nil {
-			t.Fatalf("Save(%s): %v", run.ID, err)
-		}
-	}
-
-	a := newTestAgent(Name("terminal-agent"), WithCheckpoint(cp))
-	runs, err := Pending(ctx, a)
-	if err != nil {
-		t.Fatalf("Pending: %v", err)
-	}
-	if len(runs) != 1 || runs[0].ID != "active" {
-		t.Fatalf("Pending = %#v, want only active failed run", runs)
-	}
-	for _, id := range []string{"canceled", "expired"} {
-		if _, err := Resume(ctx, a, id); err == nil || !strings.Contains(err.Error(), "terminal") {
-			t.Fatalf("Resume(%s) err = %v, want terminal status error", id, err)
-		}
-	}
-}
-
 func TestHumanInputPauseResumesSameRunWithInput(t *testing.T) {
 	ctx := context.Background()
 	cp := flow.StoreCheckpoint(store.NewStore(), "input-agent")
@@ -272,51 +243,6 @@ func TestHumanInputPauseResumesSameRunWithInput(t *testing.T) {
 	}
 }
 
-func TestHumanInputResumeHonorsCanceledContextAndLeavesRunPending(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewStore(), "input-cancel-agent")
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler != nil {
-			opts.ToolHandler(ctx, ai.ToolCall{ID: "input-1", Name: toolHumanInput, Input: map[string]any{"prompt": "Approve deploy?"}})
-		}
-		return &ai.Response{Reply: "waiting"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("input-cancel-agent"), WithCheckpoint(cp))
-	if _, err := a.Ask(ctx, "deploy the service"); err == nil {
-		t.Fatal("Ask succeeded, want input-required pause")
-	}
-	runs, err := Pending(ctx, a)
-	if err != nil {
-		t.Fatalf("Pending: %v", err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("Pending returned %d runs, want 1: %#v", len(runs), runs)
-	}
-
-	canceled, cancel := context.WithCancel(ctx)
-	cancel()
-	if _, err := ResumeInput(canceled, a, runs[0].ID, "yes"); !errors.Is(err, context.Canceled) {
-		t.Fatalf("ResumeInput canceled err = %v, want context.Canceled", err)
-	}
-
-	loaded, ok, err := cp.Load(ctx, runs[0].ID)
-	if err != nil || !ok {
-		t.Fatalf("Load paused run ok=%v err=%v", ok, err)
-	}
-	if loaded.Status != "paused" || loaded.State.Stage != agentInputStep {
-		t.Fatalf("run status/stage after canceled resume = %s/%s, want paused/%s", loaded.Status, loaded.State.Stage, agentInputStep)
-	}
-	var pause inputPause
-	if err := loaded.State.Scan(&pause); err != nil {
-		t.Fatalf("Scan pause after canceled resume: %v", err)
-	}
-	if pause.OriginalMessage != "deploy the service" || pause.Prompt != "Approve deploy?" {
-		t.Fatalf("pause after canceled resume = %#v", pause)
-	}
-}
-
 func TestApprovalDenialPausesCheckpointedRunAndResumeContinues(t *testing.T) {
 	ctx := context.Background()
 	cp := flow.StoreCheckpoint(store.NewStore(), "approval-agent")

agent/conformance_test.go

@@ -33,29 +33,14 @@ func TestAgentProviderConformanceMatrix(t *testing.T) {
 		{name: "together", key: "TOGETHER_API_KEY", model: "GO_MICRO_CONFORMANCE_TOGETHER_MODEL", live: true},
 	}
 
-	selected := selectedConformanceProviders(os.Getenv("GO_MICRO_AGENT_CONFORMANCE_PROVIDERS"))
 	for _, provider := range providers {
 		provider := provider
-		if len(selected) > 0 && !selected[provider.name] {
-			continue
-		}
 		t.Run(provider.name, func(t *testing.T) {
 			runAgentConformanceScenario(t, provider)
 		})
 	}
 }
 
-func selectedConformanceProviders(csv string) map[string]bool {
-	out := map[string]bool{}
-	for _, part := range strings.Split(csv, ",") {
-		part = strings.TrimSpace(part)
-		if part != "" {
-			out[part] = true
-		}
-	}
-	return out
-}
-
 func runAgentConformanceScenario(t *testing.T, provider conformanceProvider) {
 	t.Helper()
 	if provider.live {

agent/options.go

@@ -56,10 +56,6 @@ type Options struct {
 	// ModelRetryBackoff is the base delay between transient provider failures
 	// (grows exponentially per attempt when retries are enabled).
 	ModelRetryBackoff time.Duration
-	// ToolTimeout bounds each tool execution (0 disables). The timeout is
-	// applied before custom tools, delegate, and service RPC calls so context
-	// deadlines propagate consistently through the agent loop.
-	ToolTimeout time.Duration
 
 	// Memory is the agent's conversation memory. Nil = the default
 	// store-backed memory (durable across restarts).
@@ -116,7 +112,6 @@ func newOptions(opts ...Option) Options {
 		ModelTimeout:      30 * time.Second,
 		ModelMaxAttempts:  1, // retries opt-in via ModelRetry (see field doc)
 		ModelRetryBackoff: 100 * time.Millisecond,
-		ToolTimeout:       30 * time.Second,
 		// On by default and lenient: identical repeated calls are a
 		// no-progress loop, never useful. Set LoopLimit(0) to disable.
 		LoopLimit: 3,
@@ -209,14 +204,6 @@ func ModelCallTimeout(d time.Duration) Option {
 	return func(o *Options) { o.ModelTimeout = d }
 }
 
-// ToolCallTimeout sets the timeout for each tool execution. It bounds custom
-// tools, built-in delegate calls, and service RPC tools with the same context
-// deadline so mid-run cancellation and slow tools produce safe error results
-// instead of unbounded agent runs. Set 0 to disable.
-func ToolCallTimeout(d time.Duration) Option {
-	return func(o *Options) { o.ToolTimeout = d }
-}
-
 // ModelRetry sets the provider retry budget and backoff for transient failures.
 func ModelRetry(maxAttempts int, backoff time.Duration) Option {
 	return func(o *Options) {

agent/resilience_test.go

@@ -102,30 +102,3 @@ func TestCanceledAskContextSkipsToolExecution(t *testing.T) {
 		t.Fatalf("plan persisted after canceled tool context: %q", plan)
 	}
 }
-
-func TestToolCallTimeoutPropagatesDeadlineToCustomTool(t *testing.T) {
-	var sawDeadline bool
-	a := newTestAgent(
-		Name("tool-timeout"),
-		ToolCallTimeout(10*time.Millisecond),
-		WithTool("slow", "slow tool", nil, func(ctx context.Context, input map[string]any) (string, error) {
-			if _, ok := ctx.Deadline(); ok {
-				sawDeadline = true
-			}
-			<-ctx.Done()
-			return "", ctx.Err()
-		}),
-	)
-
-	start := time.Now()
-	content := toolContent(a.toolHandler(), "slow", nil)
-	if !sawDeadline {
-		t.Fatal("custom tool did not receive a deadline")
-	}
-	if !strings.Contains(content, context.DeadlineExceeded.Error()) {
-		t.Fatalf("tool result = %q, want deadline exceeded", content)
-	}
-	if elapsed := time.Since(start); elapsed > 200*time.Millisecond {
-		t.Fatalf("tool call took %s, want bounded timeout", elapsed)
-	}
-}

agent/stream.go

@@ -153,9 +153,6 @@ func (a *agentImpl) resumeWithStreamEvents(ctx context.Context, runID string, ev
 		}
 		return &resp, nil
 	}
-	if terminalAgentRunStatus(run.Status) {
-		return nil, errors.New("agent: checkpointed run is terminal with status " + run.Status)
-	}
 
 	a.mu.Lock()
 	defer a.mu.Unlock()

cmd/micro/cli/deploy/deploy.go

@@ -43,9 +43,6 @@ func Deploy(c *cli.Context) error {
 	}
 
 	target, remotePath := resolveDeployTarget(c, target, cfg)
-	if c.Bool("dry-run") {
-		return printDeployPlan(c, target, cfg, remotePath)
-	}
 
 	return deploySSH(c, target, cfg, remotePath)
 }
@@ -99,81 +96,6 @@ func showDeployTargets(cfg *config.Config) error {
 	return fmt.Errorf("%s", sb.String())
 }
 
-func printDeployPlan(c *cli.Context, target string, cfg *config.Config, remotePath string) error {
-	dir := c.Args().Get(1)
-	if dir == "" {
-		dir = "."
-	}
-
-	absDir, err := filepath.Abs(dir)
-	if err != nil {
-		return fmt.Errorf("failed to get absolute path: %w", err)
-	}
-
-	if cfg == nil {
-		cfg, _ = config.Load(absDir)
-	}
-	if remotePath == "" {
-		remotePath = defaultRemotePath
-	}
-
-	services, err := deployServices(absDir, cfg, c.String("service"))
-	if err != nil {
-		return err
-	}
-
-	fmt.Println()
-	fmt.Println("  \033[1mmicro deploy --dry-run\033[0m")
-	fmt.Println()
-	fmt.Printf("  Target      \033[36m%s\033[0m\n", target)
-	fmt.Printf("  Remote path %s\n", remotePath)
-	fmt.Printf("  Services    %s\n", strings.Join(services, ", "))
-	fmt.Println()
-	fmt.Println("  Plan:")
-	fmt.Println("    1. Build linux/amd64 service binaries")
-	fmt.Printf("    2. Copy binaries to %s/bin/\n", remotePath)
-	fmt.Println("    3. Enable and restart micro@<service> systemd units")
-	fmt.Println("    4. Check service health")
-	fmt.Println()
-	fmt.Println("  No SSH, rsync, systemd, or remote deployment was performed.")
-	return nil
-}
-
-func deployServices(absDir string, cfg *config.Config, filterService string) ([]string, error) {
-	if filterService != "" && cfg != nil {
-		found := false
-		for _, svc := range cfg.Services {
-			if svc.Name == filterService {
-				found = true
-				break
-			}
-		}
-		if !found && len(cfg.Services) > 0 {
-			return nil, fmt.Errorf("service '%s' not found in configuration", filterService)
-		}
-	}
-
-	if cfg != nil && len(cfg.Services) > 0 {
-		sorted, err := cfg.TopologicalSort()
-		if err != nil {
-			return nil, err
-		}
-		services := make([]string, 0, len(sorted))
-		for _, svc := range sorted {
-			if filterService == "" || svc.Name == filterService {
-				services = append(services, svc.Name)
-			}
-		}
-		return services, nil
-	}
-
-	services := []string{filepath.Base(absDir)}
-	if filterService != "" && filterService != services[0] {
-		return nil, fmt.Errorf("service '%s' not found (only '%s' available)", filterService, services[0])
-	}
-	return services, nil
-}
-
 func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath string) error {
 	dir := c.Args().Get(1)
 	if dir == "" {
@@ -199,10 +121,19 @@ func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath str
 	fmt.Println()
 	fmt.Printf("  Target     \033[36m%s\033[0m\n\n", target)
 
-	// Early validation: resolve services before SSH checks.
-	services, err := deployServices(absDir, cfg, c.String("service"))
-	if err != nil {
-		return err
+	// Early validation: Check if the requested service exists before SSH checks
+	filterService := c.String("service")
+	if filterService != "" && cfg != nil {
+		found := false
+		for _, svc := range cfg.Services {
+			if svc.Name == filterService {
+				found = true
+				break
+			}
+		}
+		if !found && len(cfg.Services) > 0 {
+			return fmt.Errorf("service '%s' not found in configuration", filterService)
+		}
 	}
 
 	// Step 1: Check SSH connectivity
@@ -222,6 +153,28 @@ func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath str
 	fmt.Println("\u2713")
 
 	// Step 3: Build binaries
+	var services []string
+	if cfg != nil && len(cfg.Services) > 0 {
+		sorted, err := cfg.TopologicalSort()
+		if err != nil {
+			return err
+		}
+		for _, svc := range sorted {
+			// If --service flag is provided, only include that service
+			if filterService == "" || svc.Name == filterService {
+				services = append(services, svc.Name)
+			}
+		}
+	} else {
+		// Single service project
+		services = []string{filepath.Base(absDir)}
+
+		// If --service flag was provided for a single-service project, validate it matches
+		if filterService != "" && filterService != services[0] {
+			return fmt.Errorf("service '%s' not found (only '%s' available)", filterService, services[0])
+		}
+	}
+
 	fmt.Printf("  Building binaries...       ")
 	if err := buildBinaries(absDir, cfg, c.Bool("build"), services); err != nil {
 		fmt.Println("\u2717")
@@ -540,10 +493,6 @@ The deploy process:
 				Name:  "service",
 				Usage: "Deploy only a specific service (for multi-service projects)",
 			},
-			&cli.BoolFlag{
-				Name:  "dry-run",
-				Usage: "Print the deployment plan without building, connecting, copying, or restarting services",
-			},
 		},
 	})
 }

cmd/micro/cli/deploy/deploy_test.go

@@ -17,7 +17,6 @@ func newDeployTestContext(t *testing.T, args ...string) *cli.Context {
 	set.String("ssh", "", "")
 	set.String("service", "", "")
 	set.Bool("build", false, "")
-	set.Bool("dry-run", false, "")
 	if err := set.Parse(args); err != nil {
 		t.Fatalf("parse flags: %v", err)
 	}
@@ -119,49 +118,3 @@ deploy prod
 		t.Fatalf("deploy target = %#v", prod)
 	}
 }
-
-func TestDeployDryRunPlansConfiguredTargetWithoutRemoteSideEffects(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(dir+"/micro.mu", []byte(`service api
-    path ./api
-
-deploy prod
-    ssh deploy@prod.example.com
-    path /srv/micro
-`), 0644); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	oldwd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("getwd: %v", err)
-	}
-	if err := os.Chdir(dir); err != nil {
-		t.Fatalf("chdir: %v", err)
-	}
-	t.Cleanup(func() {
-		if err := os.Chdir(oldwd); err != nil {
-			t.Errorf("restore cwd: %v", err)
-		}
-	})
-
-	ctx := newDeployTestContext(t, "--dry-run", "prod")
-	if err := Deploy(ctx); err != nil {
-		t.Fatalf("dry-run deploy: %v", err)
-	}
-}
-
-func TestDeployDryRunValidatesRequestedService(t *testing.T) {
-	ctx := newDeployTestContext(t, "--dry-run", "--service", "missing", "prod")
-	cfg := &config.Config{Services: map[string]*config.Service{
-		"api": {Name: "api", Path: "./api"},
-	}}
-
-	err := printDeployPlan(ctx, "deploy@prod.example.com", cfg, defaultRemotePath)
-	if err == nil {
-		t.Fatal("expected dry-run to validate service names")
-	}
-	if !strings.Contains(err.Error(), "service 'missing' not found in configuration") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}

cmd/micro/zero_to_hero_cli_test.go

@@ -19,7 +19,7 @@ func TestZeroToHeroCLIBoundaries(t *testing.T) {
 		}
 	}
 
-	for _, want := range []string{"run", "chat", "flow", "inspect", "deploy"} {
+	for _, want := range []string{"run", "chat", "flow", "inspect"} {
 		if !commands[want] {
 			t.Fatalf("missing %q command", want)
 		}
@@ -30,21 +30,4 @@ func TestZeroToHeroCLIBoundaries(t *testing.T) {
 	if !subcommands["inspect"]["agent"] || !subcommands["inspect"]["flow"] {
 		t.Fatal("missing inspect boundary: inspect agent/flow")
 	}
-
-	var hasDeployDryRun bool
-	for _, command := range microcmd.DefaultCmd.App().Commands {
-		if command.Name != "deploy" {
-			continue
-		}
-		for _, flag := range command.Flags {
-			for _, name := range flag.Names() {
-				if name == "dry-run" {
-					hasDeployDryRun = true
-				}
-			}
-		}
-	}
-	if !hasDeployDryRun {
-		t.Fatal("missing deploy boundary: deploy --dry-run")
-	}
 }

examples/README.md

@@ -80,11 +80,10 @@ A workflow as ordered, checkpointed steps that survives a crash and resumes wher
 - **Checkpoint** — each step is persisted; on `Resume`, completed steps are not re-run (no duplicate side effects)
 
 ### [support](./support/)
-A maintained 0-to-hero reference path in one runnable file:
-- **scaffold** typed `customers`, `tickets`, and `notify` services
-- **run/chat** with a support agent that uses those services as tools
-- **inspect** the event-driven `intake` flow and approval gate
-- **CI** keeps the deterministic mock-model journey runnable with `go test ./examples/support`
+A real-world support desk — the "zero to hero" shape in one runnable file:
+- **services** (`customers`, `tickets`, `notify`) become the agent's tools automatically
+- **flow** turns a `ticket.created` event into work for the agent (the event is the prompt)
+- **guardrail** — the agent triages freely but can't email a customer without passing the approval gate
 
 ## Coming Soon
 

examples/agent-human-input/README.md

@@ -34,11 +34,3 @@ calls that tool, Go Micro persists the run with status `paused` and stage
 `input-required`. Plain `agent.Resume` continues to support completed, failed,
 and approval-paused runs; input-required runs are resumed with
 `agent.ResumeInput` so the human response is explicit.
-
-## Cancellation and deadlines
-
-`ResumeInput` uses the caller's `context.Context` for checkpoint reads, writes,
-and the resumed model/tool turn. If the context is canceled or its deadline
-expires before the resume is committed, the call returns the context error and
-the checkpointed run remains `paused` at `input-required`; list it with
-`agent.Pending` and retry with a fresh context once the operator is ready.

examples/support/README.md

@@ -1,25 +1,9 @@
-# Zero-to-hero support desk
+# Support desk
 
-A maintained 0-to-hero reference for the Go Micro lifecycle: scaffold a few
-typed services, run them in one process, let an agent chat with those services
-as tools, then inspect the durable flow that triggered the work. It is one
-runnable file and one CI smoke test, so the reference path stays honest as the
-framework evolves.
-
-## The path
-
-1. **Scaffold services** — `customers`, `tickets`, and `notify` are ordinary
-   typed Go Micro services. Their request/response structs and method comments
-   become the tool contract the agent sees.
-2. **Run the harness** — the example starts an in-memory registry, broker,
-   client, store, services, agent, and flow in one process; no external
-   dependencies or API key are required for the default run.
-3. **Chat through an agent** — the `support` agent receives the ticket event as
-   a prompt and calls service tools to look up the customer, triage the ticket,
-   and draft a reply.
-4. **Inspect the workflow** — the `intake` flow records the event-driven run and
-   prints the agent result, showing the service → agent → workflow lifecycle as
-   one runtime.
+A real-world agent built the Go Micro way: a few services, an agent that
+manages them, an event that triggers it, and a human-in-the-loop gate on the
+one action that touches a customer. It's the "zero to hero" shape in one
+runnable file.
 
 ## The scenario
 
@@ -60,12 +44,6 @@ agent, which:
 go run main.go            # mock model — deterministic, no API key
 ```
 
-The maintained check is the same deterministic path:
-
-```bash
-go test ./examples/support
-```
-
 Against a live model, the agent reasons about the ticket itself instead of
 following the script:
 

examples/support/main_test.go

@@ -1,32 +1,9 @@
 package main
 
-import (
-	"os"
-	"strings"
-	"testing"
-)
+import "testing"
 
 func TestRunSupportMockSmoke(t *testing.T) {
 	if err := runSupport("mock"); err != nil {
 		t.Fatalf("support example failed: %v", err)
 	}
 }
-
-func TestZeroToHeroReadmeDocumentsLifecycle(t *testing.T) {
-	b, err := os.ReadFile("README.md")
-	if err != nil {
-		t.Fatalf("read README.md: %v", err)
-	}
-	doc := string(b)
-	for _, want := range []string{
-		"Scaffold services",
-		"Run the harness",
-		"Chat through an agent",
-		"Inspect the workflow",
-		"go test ./examples/support",
-	} {
-		if !strings.Contains(doc, want) {
-			t.Fatalf("README.md missing zero-to-hero step %q", want)
-		}
-	}
-}

gateway/a2a/a2a.go

@@ -28,7 +28,6 @@ package a2a
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -141,11 +140,8 @@ func (g *Gateway) Handler() http.Handler {
 	// Per-agent card (served at the agent's url and at its well-known path).
 	mux.HandleFunc("GET /agents/{name}", g.handleCard)
 	mux.HandleFunc("GET /agents/{name}/.well-known/agent.json", g.handleCard)
-	mux.HandleFunc("GET /agents/{name}/skills/{skill}", g.handleSkillCard)
-	mux.HandleFunc("GET /agents/{name}/skills/{skill}/.well-known/agent.json", g.handleSkillCard)
 	// Per-agent JSON-RPC endpoint.
 	mux.HandleFunc("POST /agents/{name}", g.handleRPC)
-	mux.HandleFunc("POST /agents/{name}/skills/{skill}", g.handleSkillRPC)
 	// Top-level well-known: serve the single agent's card if there's
 	// exactly one, otherwise point to the directory.
 	mux.HandleFunc("GET /.well-known/agent.json", g.handleWellKnown)
@@ -342,17 +338,23 @@ func Card(name, url, description string, services []string) AgentCard {
 			description = "Go Micro agent"
 		}
 	}
-	skills := skillsFromServices(services)
 	return AgentCard{
-		Name:               name,
-		Description:        description,
-		URL:                url,
-		Version:            "1.0.0",
-		ProtocolVersion:    protocolVersion,
-		Capabilities:       Capabilities{Streaming: true, PushNotifications: true},
+		Name:            name,
+		Description:     description,
+		URL:             url,
+		Version:         "1.0.0",
+		ProtocolVersion: protocolVersion,
+		Capabilities:    Capabilities{Streaming: true, PushNotifications: true},
+		// The agent converses over a single Chat endpoint; advertise that
+		// as one skill, tagged with the services it manages.
 		DefaultInputModes:  []string{"text/plain"},
 		DefaultOutputModes: []string{"text/plain"},
-		Skills:             skills,
+		Skills: []Skill{{
+			ID:          "chat",
+			Name:        "Chat",
+			Description: "Converse with the agent to operate its services.",
+			Tags:        services,
+		}},
 	}
 }
 
@@ -369,19 +371,6 @@ func (g *Gateway) lookupCard(name string) (AgentCard, bool) {
 	return g.card(name, meta), true
 }
 
-func (g *Gateway) lookupSkillCard(name, skillID string) (AgentCard, Skill, bool) {
-	card, ok := g.lookupCard(name)
-	if !ok {
-		return AgentCard{}, Skill{}, false
-	}
-	for _, skill := range card.Skills {
-		if skill.ID == skillID {
-			return card, skill, true
-		}
-	}
-	return AgentCard{}, Skill{}, false
-}
-
 // ---------------------------------------------------------------------------
 // HTTP handlers
 // ---------------------------------------------------------------------------
@@ -404,17 +393,6 @@ func (g *Gateway) handleCard(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, card)
 }
 
-func (g *Gateway) handleSkillCard(w http.ResponseWriter, r *http.Request) {
-	card, skill, ok := g.lookupSkillCard(r.PathValue("name"), r.PathValue("skill"))
-	if !ok {
-		http.NotFound(w, r)
-		return
-	}
-	card.URL = g.opts.BaseURL + "/agents/" + r.PathValue("name") + "/skills/" + skill.ID
-	card.Skills = []Skill{skill}
-	writeJSON(w, http.StatusOK, card)
-}
-
 func (g *Gateway) handleWellKnown(w http.ResponseWriter, r *http.Request) {
 	cards, err := g.cards()
 	if err != nil {
@@ -443,18 +421,6 @@ func (g *Gateway) handleRPC(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-func (g *Gateway) handleSkillRPC(w http.ResponseWriter, r *http.Request) {
-	name := r.PathValue("name")
-	_, skill, ok := g.lookupSkillCard(name, r.PathValue("skill"))
-	if !ok {
-		writeRPC(w, nil, nil, &rpcError{Code: errInvalidParams, Message: "unknown agent skill: " + name + "/" + r.PathValue("skill")})
-		return
-	}
-	g.disp.serve(w, r, func(ctx context.Context, text string) (string, error) {
-		return g.callAgent(ctx, name, skillPrompt(skill, text))
-	})
-}
-
 // dispatcher handles A2A JSON-RPC requests against an Invoke function and
 // retains recent tasks for tasks/get. It is shared by the gateway (one
 // per registry) and embedded agents (one per agent).
@@ -490,7 +456,7 @@ func (d *dispatcher) serveWithStream(w http.ResponseWriter, r *http.Request, inv
 		d.send(requestContext(r.Context()), w, req, invoke)
 	case "message/stream":
 		if streamInvoke != nil {
-			d.streamChunks(requestContext(r.Context()), w, req, streamInvoke, invoke)
+			d.streamChunks(requestContext(r.Context()), w, req, streamInvoke)
 			return
 		}
 		d.stream(requestContext(r.Context()), w, req, invoke)
@@ -539,7 +505,7 @@ func (d *dispatcher) stream(ctx context.Context, w http.ResponseWriter, req rpcR
 	}
 }
 
-func (d *dispatcher) streamChunks(ctx context.Context, w http.ResponseWriter, req rpcRequest, invoke StreamInvoke, fallback Invoke) {
+func (d *dispatcher) streamChunks(ctx context.Context, w http.ResponseWriter, req rpcRequest, invoke StreamInvoke) {
 	var p sendParams
 	if err := json.Unmarshal(req.Params, &p); err != nil {
 		writeRPC(w, req.ID, nil, &rpcError{Code: errInvalidParams, Message: "invalid params"})
@@ -552,10 +518,6 @@ func (d *dispatcher) streamChunks(ctx context.Context, w http.ResponseWriter, re
 	}
 	stream, err := invoke(ctx, text)
 	if err != nil {
-		if errors.Is(err, ai.ErrStreamingUnsupported) && fallback != nil {
-			d.stream(ctx, w, req, fallback)
-			return
-		}
 		writeRPC(w, req.ID, nil, &rpcError{Code: errInternal, Message: err.Error()})
 		return
 	}
@@ -891,68 +853,6 @@ func (d *dispatcher) deliverPush(taskID string, task *Task) {
 	}
 }
 
-func skillsFromServices(services []string) []Skill {
-	if len(services) == 0 {
-		return []Skill{{ID: "chat", Name: "Chat", Description: "Converse with the agent to operate its services."}}
-	}
-	seen := map[string]bool{}
-	var skills []Skill
-	for _, service := range services {
-		service = strings.TrimSpace(service)
-		if service == "" {
-			continue
-		}
-		id := skillID(service)
-		if id == "" || seen[id] {
-			continue
-		}
-		seen[id] = true
-		skills = append(skills, Skill{
-			ID:          id,
-			Name:        skillName(service),
-			Description: fmt.Sprintf("Operate the %s service through this agent.", service),
-			Tags:        []string{service},
-		})
-	}
-	if len(skills) == 0 {
-		return []Skill{{ID: "chat", Name: "Chat", Description: "Converse with the agent to operate its services."}}
-	}
-	return skills
-}
-
-func skillID(service string) string {
-	service = strings.ToLower(strings.TrimSpace(service))
-	var b strings.Builder
-	dash := false
-	for _, r := range service {
-		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
-			b.WriteRune(r)
-			dash = false
-			continue
-		}
-		if !dash && b.Len() > 0 {
-			b.WriteByte('-')
-			dash = true
-		}
-	}
-	return strings.Trim(b.String(), "-")
-}
-
-func skillName(service string) string {
-	parts := strings.FieldsFunc(service, func(r rune) bool { return r == '-' || r == '_' || r == '.' || r == '/' || r == ' ' })
-	for i, part := range parts {
-		if part == "" {
-			continue
-		}
-		parts[i] = strings.ToUpper(part[:1]) + part[1:]
-	}
-	return strings.Join(parts, " ")
-}
-
-func skillPrompt(skill Skill, text string) string {
-	return fmt.Sprintf("Use the %q skill (%s) for this request.\n\n%s", skill.Name, skill.ID, text)
-}
-
 func textOf(parts []Part) string {
 	var b strings.Builder
 	for _, p := range parts {

gateway/a2a/a2a_test.go

@@ -51,7 +51,7 @@ func newGatewayWithAgent(t *testing.T) (*httptest.Server, func()) {
 		server.Name("echo"),
 		server.Address("127.0.0.1:0"),
 		server.Registry(reg),
-		server.Metadata(map[string]string{"type": "agent", "services": "task,project"}),
+		server.Metadata(map[string]string{"type": "agent", "services": ""}),
 	)
 	if err := pb.RegisterAgentHandler(srv, echoAgent{}); err != nil {
 		t.Fatalf("register agent handler: %v", err)
@@ -88,40 +88,8 @@ func TestAgentCardFromRegistry(t *testing.T) {
 	if card.URL != "http://gw/agents/echo" {
 		t.Errorf("card url = %q", card.URL)
 	}
-	if card.ProtocolVersion == "" {
-		t.Errorf("card missing protocolVersion: %+v", card)
-	}
-	if got := skillIDs(card.Skills); strings.Join(got, ",") != "task,project" {
-		t.Errorf("skill IDs = %v, want [task project]", got)
-	}
-}
-
-func TestSkillEndpointServesFocusedCardAndRoutesRPC(t *testing.T) {
-	ts, cleanup := newGatewayWithAgent(t)
-	defer cleanup()
-
-	resp, err := http.Get(ts.URL + "/agents/echo/skills/task/.well-known/agent.json")
-	if err != nil {
-		t.Fatalf("get skill card: %v", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("skill card status = %d", resp.StatusCode)
-	}
-	var card AgentCard
-	if err := json.NewDecoder(resp.Body).Decode(&card); err != nil {
-		t.Fatalf("decode skill card: %v", err)
-	}
-	if card.URL != "http://gw/agents/echo/skills/task" || len(card.Skills) != 1 || card.Skills[0].ID != "task" {
-		t.Fatalf("skill card = %+v, want task-only card at skill URL", card)
-	}
-
-	task := rpcTask(t, ts.URL+"/agents/echo/skills/task", `{
-		"jsonrpc":"2.0","id":1,"method":"message/send",
-		"params":{"message":{"role":"user","kind":"message","messageId":"m1",
-			"parts":[{"kind":"text","text":"ping"}]}}}`)
-	if task.Status.State != stateCompleted || textOf(task.Artifacts[0].Parts) != "pong" {
-		t.Fatalf("skill task = %+v, want completed pong", task)
+	if card.ProtocolVersion == "" || len(card.Skills) == 0 {
+		t.Errorf("card missing protocolVersion or skills: %+v", card)
 	}
 }
 
@@ -465,61 +433,6 @@ func TestMessageStreamChunksPropagatesCancellationAndClosesStream(t *testing.T)
 	}
 }
 
-func TestMessageStreamChunksFallsBackWhenUnsupported(t *testing.T) {
-	d := newDispatcher()
-	body := `{"jsonrpc":"2.0","id":1,"method":"message/stream","params":{"message":{"role":"user","parts":[{"kind":"text","text":"ping"}],"kind":"message"}}}`
-	req := httptest.NewRequest(http.MethodPost, "/", bytes.NewBufferString(body))
-	rr := httptest.NewRecorder()
-	var streamed bool
-	var fallbackText string
-
-	d.serveWithStream(rr, req, func(ctx context.Context, text string) (string, error) {
-		fallbackText = text
-		return "pong", nil
-	}, func(ctx context.Context, text string) (ai.Stream, error) {
-		streamed = true
-		return nil, fmt.Errorf("%w: test provider", ai.ErrStreamingUnsupported)
-	})
-
-	if !streamed {
-		t.Fatal("stream invoke was not attempted")
-	}
-	if fallbackText != "ping" {
-		t.Fatalf("fallback text = %q, want ping", fallbackText)
-	}
-	if ct := rr.Result().Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/event-stream") {
-		t.Fatalf("content-type = %q, want text/event-stream", ct)
-	}
-	var events []struct {
-		Result Task      `json:"result"`
-		Error  *rpcError `json:"error"`
-	}
-	for _, line := range strings.Split(strings.TrimSpace(rr.Body.String()), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" {
-			continue
-		}
-		line = strings.TrimPrefix(line, "data: ")
-		var event struct {
-			Result Task      `json:"result"`
-			Error  *rpcError `json:"error"`
-		}
-		if err := json.Unmarshal([]byte(line), &event); err != nil {
-			t.Fatalf("decode event %q: %v", line, err)
-		}
-		events = append(events, event)
-	}
-	if len(events) != 1 {
-		t.Fatalf("events = %d, want 1; body %s", len(events), rr.Body.String())
-	}
-	if events[0].Error != nil {
-		t.Fatalf("fallback event error: %+v", events[0].Error)
-	}
-	if events[0].Result.Status.State != stateCompleted || textOf(events[0].Result.Artifacts[0].Parts) != "pong" {
-		t.Fatalf("fallback task = %+v, want completed pong", events[0].Result)
-	}
-}
-
 func TestTasksResubscribeStreamsCurrentAndSubsequentEvents(t *testing.T) {
 	d := newDispatcher()
 	initial := &Task{ID: "task-1", ContextID: "ctx-1", Kind: "task", Status: TaskStatus{State: stateWorking, Timestamp: time.Now().UTC().Format(time.RFC3339)}}
@@ -731,11 +644,3 @@ func rpcTask(t *testing.T, url, body string) Task {
 	}
 	return resp.Result
 }
-
-func skillIDs(skills []Skill) []string {
-	ids := make([]string, 0, len(skills))
-	for _, skill := range skills {
-		ids = append(ids, skill.ID)
-	}
-	return ids
-}

internal/docs/PRIORITIES.md

@@ -21,8 +21,9 @@ changes, architectural rewrites. Those go to the human.
 
 ## Work queue (ranked)
 
-1. **Broaden end-to-end agent streaming coverage** ([#3402](https://github.com/micro/go-micro/issues/3402)) — with durable agent checkpoint/resume guarded by #3406, streaming is now the highest-value Next-phase developer-visible seam: provider tokens need to move consistently through `ai.Stream`, `micro chat`, `Agent.Chat`, and A2A streaming. CI-safe local coverage plus provider-gated conformance should lock down chunk ordering, terminal/error events, and fallback behavior.
-2. **Emit OpenTelemetry spans for agent runs** ([#3403](https://github.com/micro/go-micro/issues/3403)) — once long runs can resume and stream, operators need the same run story in traces that developers see via `micro runs`: lifecycle boundaries, model/tool calls, approvals, retries, failures, and cancellation correlated by run ID without leaking sensitive payloads.
+1. **Add human-in-the-loop pause and resume for agent workflows** ([#3329](https://github.com/micro/go-micro/issues/3329)) — the highest-value remaining Later-phase operability gap now that provider conformance, failure hardening, the getting-started contract, streaming, durable resume/checkpoints, A2A task lifecycle, and `RunInfo` tracing have shipped. Scheduled and looping work still needs durable pending-input states that let humans approve, correct, or add context and then resume the same service/agent/workflow runtime.
+2. **gateway/a2a: multiple typed skills per agent card** ([#3342](https://github.com/micro/go-micro/issues/3342)) — the A2A gateway now has the full task lifecycle (send/stream/get/cancel/resubscribe, push config, multi-turn, input-required); the remaining interop gap is skill granularity. `Card` only ever advertises one synthetic "chat" skill with services flattened into tags. Let an agent advertise N typed skills and route per skill, so domain-routing agents expose their real capabilities over A2A through the gateway instead of a hand-rolled handler.
+3. **Add a maintained 0-to-hero reference example** ([#3368](https://github.com/micro/go-micro/issues/3368)) — keep the mission legible in code, not only docs: one CI-verifiable example should walk scaffold → run → chat → inspect across typed services, an agent, and a durable flow. This closes the remaining DX/coherence seam between the README promise, website roadmap, and the lived developer inner loop.
 
 _Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
 architecture-review pass._

internal/harness/provider-conformance/README.md

@@ -7,10 +7,9 @@ suite is safe for local development, forks, and scheduled CI.
 
 ## What it exercises
 
-`go run ./internal/harness/provider-conformance` fans out over the provider-facing
-agent test and the harnesses in `internal/harness`:
+`go run ./internal/harness/provider-conformance` fans out over the harnesses in
+`internal/harness`:
 
-- `agent` — provider tool-call conformance through `agent.Ask`, including run metadata propagation.
 - `universe` — service discovery plus agent tool calls over the real runtime.
 - `agent-flow` — a workflow event that drives an agent to call services.
 - `plan-delegate` — plan persistence plus agent-to-agent delegation and service
@@ -60,14 +59,13 @@ go run ./internal/harness/provider-conformance \
 ## Scheduled CI behavior
 
 The `Harness (E2E)` workflow runs on pushes and pull requests with deterministic
-mock LLMs, including `provider-conformance -providers mock`. On the daily schedule and manual dispatch it also runs the live
+mock LLMs. On the daily schedule and manual dispatch it also runs the live
 provider conformance job. That job:
 
-1. runs the same `agent`, `universe`, `agent-flow`, and `plan-delegate` harness list,
-2. reads the provider keys from repository secrets,
-3. skips providers whose secrets are absent,
-4. fails when any configured provider fails a harness, and
-5. uploads JSON and Markdown coverage artifacts for the run.
+1. reads the provider keys from repository secrets,
+2. skips providers whose secrets are absent,
+3. fails when any configured provider fails a harness, and
+4. uploads JSON and Markdown coverage artifacts for the run.
 
 The job also appends the Markdown summary and capability matrix to the GitHub
 Actions step summary, making configured, skipped, and failed provider coverage

internal/harness/provider-conformance/main.go

@@ -46,7 +46,7 @@ var providerEnv = map[string]string{
 
 func main() {
 	providersFlag := flag.String("providers", "anthropic,openai,gemini,groq,mistral,together,atlascloud", "comma-separated providers to check; use mock for deterministic local checks")
-	harnessesFlag := flag.String("harnesses", "agent,universe,agent-flow,plan-delegate", "comma-separated harness names under internal/harness; agent runs the provider tool-call conformance test")
+	harnessesFlag := flag.String("harnesses", "universe,agent-flow,plan-delegate", "comma-separated harness names under internal/harness")
 	timeoutFlag := flag.Duration("timeout", 10*time.Minute, "timeout per provider/harness run")
 	requireConfiguredFlag := flag.Bool("require-configured", false, "fail when a selected live provider is missing an API key")
 	capabilitiesFlag := flag.Bool("capabilities", true, "print the registered provider capability matrix before running conformance")
@@ -244,9 +244,6 @@ func validateSelection(providers, harnesses []string) error {
 	}
 
 	for _, harness := range harnesses {
-		if harness == "agent" {
-			continue
-		}
 		if strings.Contains(harness, string(os.PathSeparator)) || harness == "." || harness == ".." {
 			return fmt.Errorf("invalid harness name %q", harness)
 		}
@@ -326,10 +323,6 @@ func localRPCEnv(env []string) []string {
 }
 
 func runHarness(provider, harness string, timeout time.Duration) error {
-	if harness == "agent" {
-		return runAgentConformance(provider, timeout)
-	}
-
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
@@ -365,28 +358,3 @@ func runHarness(provider, harness string, timeout time.Duration) error {
 	}
 	return nil
 }
-
-func runAgentConformance(provider string, timeout time.Duration) error {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	testProvider := provider
-	if provider == "mock" {
-		testProvider = "fake"
-	}
-	cmd := exec.CommandContext(ctx, "go", "test", "./agent", "-run", "TestAgentProviderConformanceMatrix", "-count=1", "-v")
-	cmd.Dir = repoRoot()
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Env = localRPCEnv(append(os.Environ(),
-		"GO_MICRO_AGENT_CONFORMANCE_LIVE=1",
-		"GO_MICRO_AGENT_CONFORMANCE_PROVIDERS="+testProvider,
-	))
-	if err := cmd.Run(); err != nil {
-		if ctx.Err() == context.DeadlineExceeded {
-			return fmt.Errorf("timed out after %s", timeout)
-		}
-		return err
-	}
-	return nil
-}

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

@@ -4,22 +4,17 @@ This directory owns the no-secret reference scenario for the Go Micro
 services → agents → workflows lifecycle. It is intentionally small and
 scripted so CI can run it on every push without external services or model keys.
 
-`run.sh` verifies four boundaries together:
+`run.sh` verifies three boundaries together:
 
 1. **Run** — `micro run` remains available as the local development entry point.
 2. **Chat** — `micro chat` remains available as the interactive agent entry point.
 3. **Inspect** — `micro inspect agent <name>` and `micro inspect flow <name>`
    remain available as the local run-history inspection step, with `micro flow
    runs` preserving durable workflow history inspection.
-4. **Deploy** — `micro deploy --dry-run <target>` remains available as the
-   deployment-boundary checkpoint. The dry run resolves configured deploy targets
-   and services and prints the remote build/copy/systemd/health plan without
-   building binaries, opening SSH connections, running `rsync`, or touching
-   remote infrastructure.
 
 After the CLI boundary smoke checks, the script runs the deterministic harnesses
-that boot real services, agents, workflows, store-backed run history, plan/delegate,
-and A2A with only the LLM mocked.
+that boot real services, agents, workflows, store-backed run history, and A2A
+with only the LLM mocked.
 
 ## Local and CI entry points
 
@@ -31,8 +26,7 @@ contract locally with:
 make harness
 ```
 
-That target intentionally exercises both 0→1 scaffold variants, the 0→hero
-scenario, the event-driven agent-flow harness, and mock provider conformance, so
-the public scaffold → run/chat → inspect → deploy lifecycle stays executable
-outside CI as well. Live provider checks remain separate and gated by configured
-API keys (`make provider-conformance` or the scheduled/manual CI job).
+That target intentionally exercises the documented getting-started path before
+the 0→hero scenario, so the public scaffold → run/chat → inspect lifecycle stays
+executable outside CI as well. Live provider checks remain separate and gated by
+configured API keys (`make provider-conformance` or the scheduled/manual CI job).

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

@@ -7,7 +7,6 @@ cd "$ROOT"
 # Keep the developer inner-loop boundaries executable and discoverable in CI
 # without secrets or long-running daemons.
 go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1
-go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1
 
 # Deterministic no-secret reference scenarios. These use the real Go Micro
 # runtime and mock only the LLM provider.

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

@@ -69,18 +69,10 @@ A card looks like:
   "capabilities": { "streaming": true, "pushNotifications": true },
   "defaultInputModes": ["text/plain"],
   "defaultOutputModes": ["text/plain"],
-  "skills": [
-    { "id": "task", "name": "Task", "tags": ["task"] },
-    { "id": "project", "name": "Project", "tags": ["project"] }
-  ]
+  "skills": [{ "id": "chat", "name": "Chat", "tags": ["task", "project"] }]
 }
 ```
 
-Each managed service is advertised as its own typed skill. Clients can call the
-whole agent at `/agents/task-mgr`, or address one skill directly at
-`/agents/task-mgr/skills/task`; the skill endpoint serves a focused card and
-routes the request to the same agent with that skill selected.
-
 ## Calling an agent
 
 A2A uses JSON-RPC 2.0 over HTTP. Send a message with `message/send`; the gateway runs the agent and returns a completed `Task`: