fix: resolve all outstanding review issues

- Fix critical streaming bug: chat.go now chains tea.Cmd to drain all
  events from the channel, not just the first one
- Handle all ChatEvent types in TUI (ToolCallStart, ToolCallResult,
  Permission, AgentSpawned, AgentMessage) with ToolCallListModel
- Wire cancel function for Escape key to abort in-flight requests
- Wrap AddProvider in transaction (clear-defaults + insert atomic)
- Wire team CLI commands to daemon via gRPC (start, status)
- Add StartTeam/GetTeamStatus to gRPC client
- Fix release.yml go-version: 1.22 → 1.26 to match go.mod
- Remove dead code in skills.go (unused seen map)
- Fix hooks_test.go HOME env to avoid test pollution

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: intel352

.github/workflows/release.yml

@@ -13,7 +13,7 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-go@v5
         with:
-          go-version: "1.22"
+          go-version: "1.26"
       - uses: goreleaser/goreleaser-action@v6
         with:
           version: "~> v2"

cmd/ratchet/cmd_team.go

@@ -1,19 +1,66 @@
 package main
 
 import (
+	"context"
 	"fmt"
+	"os"
+
+	"github.com/GoCodeAlone/ratchet-cli/internal/client"
+	pb "github.com/GoCodeAlone/ratchet-cli/internal/proto"
 )
 
 func handleTeam(args []string) {
 	if len(args) == 0 {
-		fmt.Println("Usage: ratchet team <start|status>")
+		fmt.Println("Usage: ratchet team <start|status> [args...]")
 		return
 	}
+
+	c, err := client.EnsureDaemon()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		os.Exit(1)
+	}
+	defer c.Close()
+
 	switch args[0] {
 	case "start":
-		fmt.Println("team start: not yet implemented")
+		if len(args) < 2 {
+			fmt.Println("Usage: ratchet team start \"task description\"")
+			return
+		}
+		task := args[1]
+		stream, err := c.StartTeam(context.Background(), &pb.StartTeamReq{Task: task})
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error: %v\n", err)
+			os.Exit(1)
+		}
+		for event := range stream {
+			switch e := event.Event.(type) {
+			case *pb.TeamEvent_AgentSpawned:
+				fmt.Printf("[spawned] %s (%s)\n", e.AgentSpawned.AgentName, e.AgentSpawned.Role)
+			case *pb.TeamEvent_Token:
+				fmt.Print(e.Token.Content)
+			case *pb.TeamEvent_AgentMessage:
+				fmt.Printf("[%s → %s] %s\n", e.AgentMessage.FromAgent, e.AgentMessage.ToAgent, e.AgentMessage.Content)
+			case *pb.TeamEvent_Complete:
+				fmt.Printf("\nTeam complete: %s\n", e.Complete.Summary)
+			case *pb.TeamEvent_Error:
+				fmt.Fprintf(os.Stderr, "error: %s\n", e.Error.Message)
+			}
+		}
 	case "status":
-		fmt.Println("team status: not yet implemented")
+		resp, err := c.GetTeamStatus(context.Background(), "")
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error: %v\n", err)
+			os.Exit(1)
+		}
+		fmt.Printf("Team: %s  Status: %s  Task: %s\n", resp.TeamId, resp.Status, resp.Task)
+		if len(resp.Agents) > 0 {
+			fmt.Printf("%-20s %-10s %s\n", "NAME", "STATUS", "MODEL")
+			for _, a := range resp.Agents {
+				fmt.Printf("%-20s %-10s %s\n", a.Name, a.Status, a.Model)
+			}
+		}
 	default:
 		fmt.Printf("unknown team command: %s\n", args[0])
 	}

internal/client/client.go

@@ -164,3 +164,37 @@ func (c *Client) Shutdown(ctx context.Context) error {
 	_, err := c.daemon.Shutdown(ctx, &pb.Empty{})
 	return err
 }
+
+// StartTeam starts a team and returns a channel of TeamEvents.
+func (c *Client) StartTeam(ctx context.Context, req *pb.StartTeamReq) (<-chan *pb.TeamEvent, error) {
+	stream, err := c.daemon.StartTeam(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	ch := make(chan *pb.TeamEvent, 64)
+	go func() {
+		defer close(ch)
+		for {
+			event, err := stream.Recv()
+			if err == io.EOF {
+				return
+			}
+			if err != nil {
+				ch <- &pb.TeamEvent{
+					Event: &pb.TeamEvent_Error{
+						Error: &pb.ErrorEvent{Message: err.Error()},
+					},
+				}
+				return
+			}
+			ch <- event
+		}
+	}()
+	return ch, nil
+}
+
+// GetTeamStatus returns the status of the active team.
+func (c *Client) GetTeamStatus(ctx context.Context, teamID string) (*pb.TeamStatus, error) {
+	return c.daemon.GetTeamStatus(ctx, &pb.TeamStatusReq{TeamId: teamID})
+}

internal/daemon/service.go

@@ -110,36 +110,43 @@ func (s *Service) AddProvider(ctx context.Context, req *pb.AddProviderReq) (*pb.
 	id := uuid.New().String()
 	secretName := fmt.Sprintf("provider_%s", req.Alias)
 
-	// Clear existing default if this is the new default
+	isDefault := 0
 	if req.IsDefault {
-		if _, err := s.engine.DB.ExecContext(ctx, `UPDATE llm_providers SET is_default = 0`); err != nil {
-			return nil, status.Errorf(codes.Internal, "clear defaults: %v", err)
-		}
+		isDefault = 1
 	}
 
-	isDefault := 0
+	tx, err := s.engine.DB.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "begin transaction: %v", err)
+	}
+	defer tx.Rollback()
+
+	// Clear existing default if this is the new default
 	if req.IsDefault {
-		isDefault = 1
+		if _, err := tx.ExecContext(ctx, `UPDATE llm_providers SET is_default = 0`); err != nil {
+			return nil, status.Errorf(codes.Internal, "clear defaults: %v", err)
+		}
 	}
 
 	// DB insert before secret store to avoid orphaned secrets on constraint failure
-	_, err := s.engine.DB.ExecContext(ctx,
+	if _, err := tx.ExecContext(ctx,
 		`INSERT INTO llm_providers (id, alias, type, model, secret_name, base_url, max_tokens, is_default) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
 		id, req.Alias, req.Type, req.Model, secretName, req.BaseUrl, req.MaxTokens, isDefault,
-	)
-	if err != nil {
+	); err != nil {
 		return nil, status.Errorf(codes.Internal, "insert provider: %v", err)
 	}
 
 	// Store API key after successful insert
 	if req.ApiKey != "" {
 		if err := s.engine.SecretsProvider.Set(ctx, secretName, req.ApiKey); err != nil {
-			// Best-effort rollback
-			s.engine.DB.ExecContext(ctx, `DELETE FROM llm_providers WHERE alias = ?`, req.Alias)
 			return nil, status.Errorf(codes.Internal, "store api key: %v", err)
 		}
 	}
 
+	if err := tx.Commit(); err != nil {
+		return nil, status.Errorf(codes.Internal, "commit: %v", err)
+	}
+
 	s.engine.ProviderRegistry.InvalidateCacheAlias(req.Alias)
 
 	return &pb.Provider{

internal/hooks/hooks_test.go

@@ -8,6 +8,7 @@ import (
 
 func TestLoadEmpty(t *testing.T) {
 	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
 	cfg, err := Load(tmp)
 	if err != nil {
 		t.Fatal(err)

internal/skills/skills.go

@@ -23,7 +23,6 @@ func Discover(workingDir string) []Skill {
 		filepath.Join(workingDir, ".ratchet", "skills"),
 	}
 
-	seen := make(map[string]bool)
 	var skills []Skill
 
 	for _, dir := range searchDirs {
@@ -48,16 +47,13 @@ func Discover(workingDir string) []Skill {
 			if err != nil {
 				continue
 			}
-			// Later paths (project-level) override earlier paths (global)
-			seen[name] = true
 			skills = append(skills, Skill{
 				Name:    name,
 				Path:    path,
 				Content: string(content),
 			})
 		}
 	}
-	_ = seen
 	return dedup(skills)
 }
 

internal/tui/pages/chat.go

@@ -14,10 +14,15 @@ import (
 )
 
 // ChatEventMsg wraps an incoming proto ChatEvent for the TUI.
+// The channel is carried so handleChatEvent can schedule the next read.
 type ChatEventMsg struct {
 	Event *pb.ChatEvent
+	ch    <-chan *pb.ChatEvent
 }
 
+// chatStreamDoneMsg signals the event channel was closed.
+type chatStreamDoneMsg struct{}
+
 type ChatModel struct {
 	client    *client.Client
 	sessionID string
@@ -27,6 +32,7 @@ type ChatModel struct {
 	viewport   viewport.Model
 	input      components.InputModel
 	statusBar  components.StatusBar
+	toolCalls  components.ToolCallListModel
 	messages   []components.Message
 	streaming  string // current streaming response
 	width      int
@@ -48,6 +54,7 @@ func NewChat(c *client.Client, sessionID string, t theme.Theme, dark bool) ChatM
 		viewport:  vp,
 		input:     input,
 		statusBar: statusBar,
+		toolCalls: components.NewToolCallList(),
 		ctx:       context.Background(),
 	}
 }
@@ -65,6 +72,13 @@ func (m ChatModel) Update(msg tea.Msg) (ChatModel, tea.Cmd) {
 		m.height = msg.Height
 		m.relayout()
 
+	case tea.KeyPressMsg:
+		// Cancel in-flight streaming with Escape
+		if msg.String() == "esc" && m.cancelChat != nil {
+			m.cancelChat()
+			m.cancelChat = nil
+		}
+
 	case components.SubmitMsg:
 		// Add user message and send to daemon
 		m.messages = append(m.messages, components.Message{
@@ -76,7 +90,19 @@ func (m ChatModel) Update(msg tea.Msg) (ChatModel, tea.Cmd) {
 		cmds = append(cmds, m.sendMessage(msg.Content))
 
 	case ChatEventMsg:
-		cmds = append(cmds, m.handleChatEvent(msg.Event))
+		cmds = append(cmds, m.handleChatEvent(msg)...)
+
+	case chatStreamDoneMsg:
+		// Stream channel closed without a Complete event
+		if m.streaming != "" {
+			m.messages = append(m.messages, components.Message{
+				Role:    components.RoleAssistant,
+				Content: m.streaming,
+			})
+			m.streaming = ""
+			m.refreshViewport()
+		}
+		m.cancelChat = nil
 	}
 
 	var inputCmd, vpCmd tea.Cmd
@@ -107,6 +133,11 @@ func (m *ChatModel) refreshViewport() {
 		sb.WriteString(msg.Render(m.theme, m.width, m.dark))
 		sb.WriteString("\n")
 	}
+	// Render any active tool calls
+	toolView := m.toolCalls.View(m.theme, m.width)
+	if toolView != "" {
+		sb.WriteString(toolView)
+	}
 	if m.streaming != "" {
 		assistantMsg := components.Message{
 			Role:    components.RoleAssistant,
@@ -124,7 +155,7 @@ func (m ChatModel) sendMessage(content string) tea.Cmd {
 			return nil
 		}
 		ctx, cancel := context.WithCancel(m.ctx)
-		_ = cancel // stored for potential cancellation
+		m.cancelChat = cancel
 
 		ch, err := m.client.SendMessage(ctx, m.sessionID, content)
 		if err != nil {
@@ -135,24 +166,69 @@ func (m ChatModel) sendMessage(content string) tea.Cmd {
 			}}
 		}
 
-		// Return first event; subsequent events come via streaming
+		// Read first event and carry channel for subsequent reads
 		event, ok := <-ch
 		if !ok {
-			return nil
+			return chatStreamDoneMsg{}
+		}
+		return ChatEventMsg{Event: event, ch: ch}
+	}
+}
+
+// nextEvent returns a Cmd that reads the next event from the channel.
+func nextEvent(ch <-chan *pb.ChatEvent) tea.Cmd {
+	return func() tea.Msg {
+		event, ok := <-ch
+		if !ok {
+			return chatStreamDoneMsg{}
 		}
-		return ChatEventMsg{Event: event}
+		return ChatEventMsg{Event: event, ch: ch}
 	}
 }
 
-func (m ChatModel) handleChatEvent(event *pb.ChatEvent) tea.Cmd {
+func (m *ChatModel) handleChatEvent(msg ChatEventMsg) []tea.Cmd {
+	event := msg.Event
 	if event == nil {
 		return nil
 	}
+
+	var cmds []tea.Cmd
+
 	switch e := event.Event.(type) {
 	case *pb.ChatEvent_Token:
 		m.streaming += e.Token.Content
 		m.refreshViewport()
-		return nil
+
+	case *pb.ChatEvent_ToolStart:
+		m.toolCalls.AddCard(e.ToolStart.CallId, e.ToolStart.ToolName, e.ToolStart.ArgumentsJson)
+		m.refreshViewport()
+
+	case *pb.ChatEvent_ToolResult:
+		m.toolCalls.UpdateResult(e.ToolResult.CallId, e.ToolResult.ResultJson, e.ToolResult.Success)
+		m.refreshViewport()
+
+	case *pb.ChatEvent_Permission:
+		// Show permission prompt inline
+		m.messages = append(m.messages, components.Message{
+			Role:    components.RoleTool,
+			Content: "Permission required: " + e.Permission.ToolName + " — " + e.Permission.Description,
+		})
+		m.refreshViewport()
+
+	case *pb.ChatEvent_AgentSpawned:
+		m.messages = append(m.messages, components.Message{
+			Role:    components.RoleTool,
+			Content: "Agent spawned: " + e.AgentSpawned.AgentName + " (" + e.AgentSpawned.Role + ")",
+		})
+		m.refreshViewport()
+
+	case *pb.ChatEvent_AgentMessage:
+		m.messages = append(m.messages, components.Message{
+			Role:    components.RoleTool,
+			Content: "[" + e.AgentMessage.FromAgent + "] " + e.AgentMessage.Content,
+		})
+		m.refreshViewport()
+
 	case *pb.ChatEvent_Complete:
 		if m.streaming != "" {
 			m.messages = append(m.messages, components.Message{
@@ -162,17 +238,25 @@ func (m ChatModel) handleChatEvent(event *pb.ChatEvent) tea.Cmd {
 			m.streaming = ""
 			m.refreshViewport()
 		}
-		return nil
+		m.cancelChat = nil
+		return cmds // don't schedule next read — stream is done
+
 	case *pb.ChatEvent_Error:
 		m.messages = append(m.messages, components.Message{
 			Role:    components.RoleTool,
 			Content: "error: " + e.Error.Message,
 		})
 		m.streaming = ""
 		m.refreshViewport()
-		return nil
+		m.cancelChat = nil
+		return cmds // don't schedule next read — stream is done
+	}
+
+	// Schedule read of next event from the channel
+	if msg.ch != nil {
+		cmds = append(cmds, nextEvent(msg.ch))
 	}
-	return nil
+	return cmds
 }
 
 func (m ChatModel) View(t theme.Theme) string {