fix: resolve type conflicts, wire team modules, remove stubs

- Remove team_scaling.go (stub returning errors, no real implementation)
- Fix type conflicts: use types.TeamEvent, types.MailboxMessage,
  types.TaskClaim, types.TeamTask everywhere instead of local duplicates
- Add CLI-specific response structs (cliEvent, cliMailboxMessage, cliTask)
  for JSON decoding, with conversion methods to canonical types
- Fix team_restart.go: remove stub error, use correct field names
  (WorkerID instead of Owner, TaskInProgress status check)
- Wire health/stall checks into teamcli.go monitorProcess() with
  periodic checkTeamHealthAndStall that detects and restarts dead workers
- Wire graceful shutdown into Stop()/Close() via gracefulShutdownWorkers
- Add heartbeat loop in coordinator executeTask() for stale detection
- Add stale worker monitoring goroutine in coordinator runExecPhase()
- Update all tests to use canonical types

Author: junhoyeo

internal/agent/team_events.go

@@ -4,10 +4,21 @@ import (
 	"context"
 	"fmt"
 	"time"
+
+	"github.com/junhoyeo/contrabass/internal/types"
 )
 
-// TeamEvent represents a team activity event
-type TeamEvent struct {
+// EventFilter defines filters for querying events.
+type EventFilter struct {
+	AfterEventID string
+	Type         string
+	Worker       string
+	TaskID       string
+	WakeableOnly bool
+}
+
+// cliEvent is the JSON shape returned by the team CLI event API.
+type cliEvent struct {
 	EventID   string                 `json:"event_id"`
 	Team      string                 `json:"team"`
 	Type      string                 `json:"type"`
@@ -21,25 +32,75 @@ type TeamEvent struct {
 	CreatedAt time.Time              `json:"created_at"`
 }
 
-// EventFilter defines filters for querying events
-type EventFilter struct {
-	AfterEventID string
-	Type         string
-	Worker       string
-	TaskID       string
-	WakeableOnly bool
+func (e *cliEvent) toTeamEvent() types.TeamEvent {
+	data := make(map[string]interface{})
+	if e.Worker != "" {
+		data["worker"] = e.Worker
+	}
+	if e.TaskID != "" {
+		data["task_id"] = e.TaskID
+	}
+	if e.MessageID != "" {
+		data["message_id"] = e.MessageID
+	}
+	if e.Reason != "" {
+		data["reason"] = e.Reason
+	}
+	if e.State != "" {
+		data["state"] = e.State
+	}
+	if e.PrevState != "" {
+		data["prev_state"] = e.PrevState
+	}
+	if e.EventID != "" {
+		data["event_id"] = e.EventID
+	}
+	for k, v := range e.Metadata {
+		data[k] = v
+	}
+	return types.TeamEvent{
+		Type:      e.Type,
+		TeamName:  e.Team,
+		Data:      data,
+		Timestamp: e.CreatedAt,
+	}
+}
+
+func teamEventToCLI(teamName string, event *types.TeamEvent) map[string]interface{} {
+	input := map[string]interface{}{
+		"team_name": teamName,
+		"type":      event.Type,
+	}
+	if w, ok := event.Data["worker"].(string); ok && w != "" {
+		input["worker"] = w
+	}
+	if t, ok := event.Data["task_id"].(string); ok && t != "" {
+		input["task_id"] = t
+	}
+	if m, ok := event.Data["message_id"].(string); ok && m != "" {
+		input["message_id"] = m
+	}
+	if r, ok := event.Data["reason"].(string); ok && r != "" {
+		input["reason"] = r
+	}
+	if s, ok := event.Data["state"].(string); ok && s != "" {
+		input["state"] = s
+	}
+	if p, ok := event.Data["prev_state"].(string); ok && p != "" {
+		input["prev_state"] = p
+	}
+	return input
 }
 
-// ReadEvents retrieves events from the team event log
-func (r *teamCLIRunner) ReadEvents(ctx context.Context, workspace, teamName string, filter *EventFilter) ([]TeamEvent, error) {
+// ReadEvents retrieves events from the team event log.
+func (r *teamCLIRunner) ReadEvents(ctx context.Context, workspace, teamName string, filter *EventFilter) ([]types.TeamEvent, error) {
 	if filter == nil {
 		filter = &EventFilter{}
 	}
 
 	input := map[string]interface{}{
 		"team_name": teamName,
 	}
-
 	if filter.AfterEventID != "" {
 		input["after_event_id"] = filter.AfterEventID
 	}
@@ -57,20 +118,24 @@ func (r *teamCLIRunner) ReadEvents(ctx context.Context, workspace, teamName stri
 	}
 
 	var resp struct {
-		Count  int         `json:"count"`
-		Cursor string      `json:"cursor"`
-		Events []TeamEvent `json:"events"`
+		Count  int        `json:"count"`
+		Cursor string     `json:"cursor"`
+		Events []cliEvent `json:"events"`
 	}
 
 	if err := r.runTeamAPI(ctx, workspace, "read-events", input, &resp); err != nil {
 		return nil, fmt.Errorf("read team events: %w", err)
 	}
 
-	return resp.Events, nil
+	events := make([]types.TeamEvent, len(resp.Events))
+	for i, e := range resp.Events {
+		events[i] = e.toTeamEvent()
+	}
+	return events, nil
 }
 
-// AwaitEvent waits for a specific event to occur
-func (r *teamCLIRunner) AwaitEvent(ctx context.Context, workspace, teamName string, filter *EventFilter, timeout time.Duration) (*TeamEvent, error) {
+// AwaitEvent waits for a specific event to occur.
+func (r *teamCLIRunner) AwaitEvent(ctx context.Context, workspace, teamName string, filter *EventFilter, timeout time.Duration) (*types.TeamEvent, error) {
 	if filter == nil {
 		filter = &EventFilter{}
 	}
@@ -79,7 +144,6 @@ func (r *teamCLIRunner) AwaitEvent(ctx context.Context, workspace, teamName stri
 		"team_name":  teamName,
 		"timeout_ms": timeout.Milliseconds(),
 	}
-
 	if filter.AfterEventID != "" {
 		input["after_event_id"] = filter.AfterEventID
 	}
@@ -97,9 +161,9 @@ func (r *teamCLIRunner) AwaitEvent(ctx context.Context, workspace, teamName stri
 	}
 
 	var resp struct {
-		Status string     `json:"status"`
-		Cursor string     `json:"cursor"`
-		Event  *TeamEvent `json:"event"`
+		Status string    `json:"status"`
+		Cursor string    `json:"cursor"`
+		Event  *cliEvent `json:"event"`
 	}
 
 	if err := r.runTeamAPI(ctx, workspace, "await-event", input, &resp); err != nil {
@@ -109,50 +173,31 @@ func (r *teamCLIRunner) AwaitEvent(ctx context.Context, workspace, teamName stri
 	if resp.Status == "timeout" {
 		return nil, fmt.Errorf("timeout waiting for event")
 	}
-
 	if resp.Event == nil {
 		return nil, fmt.Errorf("no event received")
 	}
 
-	return resp.Event, nil
+	event := resp.Event.toTeamEvent()
+	return &event, nil
 }
 
-// AppendEvent adds an event to the team event log
-func (r *teamCLIRunner) AppendEvent(ctx context.Context, workspace, teamName string, event *TeamEvent) (*TeamEvent, error) {
-	input := map[string]interface{}{
-		"team_name": teamName,
-		"type":      event.Type,
-		"worker":    event.Worker,
-	}
-
-	if event.TaskID != "" {
-		input["task_id"] = event.TaskID
-	}
-	if event.MessageID != "" {
-		input["message_id"] = event.MessageID
-	}
-	if event.Reason != "" {
-		input["reason"] = event.Reason
-	}
-	if event.State != "" {
-		input["state"] = event.State
-	}
-	if event.PrevState != "" {
-		input["prev_state"] = event.PrevState
-	}
+// AppendEvent adds an event to the team event log.
+func (r *teamCLIRunner) AppendEvent(ctx context.Context, workspace, teamName string, event *types.TeamEvent) (*types.TeamEvent, error) {
+	input := teamEventToCLI(teamName, event)
 
 	var resp struct {
-		Event TeamEvent `json:"event"`
+		Event cliEvent `json:"event"`
 	}
 
 	if err := r.runTeamAPI(ctx, workspace, "append-event", input, &resp); err != nil {
 		return nil, fmt.Errorf("append team event: %w", err)
 	}
 
-	return &resp.Event, nil
+	result := resp.Event.toTeamEvent()
+	return &result, nil
 }
 
-// IdleState represents the idle state of the team
+// IdleState represents the idle state of the team.
 type IdleState struct {
 	TeamName         string   `json:"team_name"`
 	WorkerCount      int      `json:"worker_count"`
@@ -167,20 +212,18 @@ type IdleState struct {
 	} `json:"last_all_workers_idle_event,omitempty"`
 }
 
-// ReadIdleState retrieves the current idle state of the team
+// ReadIdleState retrieves the current idle state of the team.
 func (r *teamCLIRunner) ReadIdleState(ctx context.Context, workspace, teamName string) (*IdleState, error) {
 	var state IdleState
-
 	if err := r.runTeamAPI(ctx, workspace, "read-idle-state", map[string]string{
 		"team_name": teamName,
 	}, &state); err != nil {
 		return nil, fmt.Errorf("read idle state: %w", err)
 	}
-
 	return &state, nil
 }
 
-// StallState represents whether the team is stalled
+// StallState represents whether the team is stalled.
 type StallState struct {
 	TeamName         string   `json:"team_name"`
 	TeamStalled      bool     `json:"team_stalled"`
@@ -193,15 +236,13 @@ type StallState struct {
 	Reasons          []string `json:"reasons"`
 }
 
-// ReadStallState retrieves the current stall state of the team
+// ReadStallState retrieves the current stall state of the team.
 func (r *teamCLIRunner) ReadStallState(ctx context.Context, workspace, teamName string) (*StallState, error) {
 	var state StallState
-
 	if err := r.runTeamAPI(ctx, workspace, "read-stall-state", map[string]string{
 		"team_name": teamName,
 	}, &state); err != nil {
 		return nil, fmt.Errorf("read stall state: %w", err)
 	}
-
 	return &state, nil
 }

internal/agent/team_events_test.go

@@ -4,10 +4,12 @@ import (
 	"encoding/json"
 	"testing"
 	"time"
+
+	"github.com/junhoyeo/contrabass/internal/types"
 )
 
-func TestTeamEventJSON(t *testing.T) {
-	event := &TeamEvent{
+func TestCLIEventToTeamEvent(t *testing.T) {
+	event := &cliEvent{
 		EventID:   "evt_123",
 		Team:      "test-team",
 		Type:      "task_completed",
@@ -16,39 +18,59 @@ func TestTeamEventJSON(t *testing.T) {
 		State:     "completed",
 		PrevState: "in_progress",
 		Metadata: map[string]interface{}{
-			"duration_ms": 1500,
+			"duration_ms": float64(1500),
 		},
 		CreatedAt: time.Now(),
 	}
 
+	teamEvent := event.toTeamEvent()
+
+	if teamEvent.Type != event.Type {
+		t.Errorf("Type mismatch: got %s, want %s", teamEvent.Type, event.Type)
+	}
+	if teamEvent.TeamName != event.Team {
+		t.Errorf("TeamName mismatch: got %s, want %s", teamEvent.TeamName, event.Team)
+	}
+	if teamEvent.Data["worker"] != event.Worker {
+		t.Errorf("Worker mismatch: got %v, want %s", teamEvent.Data["worker"], event.Worker)
+	}
+	if teamEvent.Data["state"] != event.State {
+		t.Errorf("State mismatch: got %v, want %s", teamEvent.Data["state"], event.State)
+	}
+	if teamEvent.Data["prev_state"] != event.PrevState {
+		t.Errorf("PrevState mismatch: got %v, want %s", teamEvent.Data["prev_state"], event.PrevState)
+	}
+	if teamEvent.Data["event_id"] != event.EventID {
+		t.Errorf("EventID mismatch: got %v, want %s", teamEvent.Data["event_id"], event.EventID)
+	}
+}
+
+func TestTeamEventJSON(t *testing.T) {
+	event := types.TeamEvent{
+		Type:     "task_completed",
+		TeamName: "test-team",
+		Data: map[string]interface{}{
+			"worker":  "worker-1",
+			"task_id": "task-1",
+		},
+		Timestamp: time.Now(),
+	}
+
 	data, err := json.Marshal(event)
 	if err != nil {
 		t.Fatalf("Failed to marshal event: %v", err)
 	}
 
-	var decoded TeamEvent
+	var decoded types.TeamEvent
 	if err := json.Unmarshal(data, &decoded); err != nil {
 		t.Fatalf("Failed to unmarshal event: %v", err)
 	}
 
-	if decoded.EventID != event.EventID {
-		t.Errorf("EventID mismatch: got %s, want %s", decoded.EventID, event.EventID)
-	}
-
 	if decoded.Type != event.Type {
 		t.Errorf("Type mismatch: got %s, want %s", decoded.Type, event.Type)
 	}
-
-	if decoded.Worker != event.Worker {
-		t.Errorf("Worker mismatch: got %s, want %s", decoded.Worker, event.Worker)
-	}
-
-	if decoded.State != event.State {
-		t.Errorf("State mismatch: got %s, want %s", decoded.State, event.State)
-	}
-
-	if decoded.PrevState != event.PrevState {
-		t.Errorf("PrevState mismatch: got %s, want %s", decoded.PrevState, event.PrevState)
+	if decoded.TeamName != event.TeamName {
+		t.Errorf("TeamName mismatch: got %s, want %s", decoded.TeamName, event.TeamName)
 	}
 }
 
@@ -63,11 +85,9 @@ func TestEventFilter(t *testing.T) {
 	if filter.AfterEventID != "evt_100" {
 		t.Errorf("AfterEventID mismatch: got %s, want evt_100", filter.AfterEventID)
 	}
-
 	if filter.Type != "worker_state_changed" {
 		t.Errorf("Type mismatch: got %s, want worker_state_changed", filter.Type)
 	}
-
 	if !filter.WakeableOnly {
 		t.Error("WakeableOnly should be true")
 	}
@@ -96,11 +116,9 @@ func TestIdleStateJSON(t *testing.T) {
 	if decoded.TeamName != state.TeamName {
 		t.Errorf("TeamName mismatch: got %s, want %s", decoded.TeamName, state.TeamName)
 	}
-
 	if decoded.IdleWorkerCount != state.IdleWorkerCount {
 		t.Errorf("IdleWorkerCount mismatch: got %d, want %d", decoded.IdleWorkerCount, state.IdleWorkerCount)
 	}
-
 	if decoded.AllWorkersIdle != state.AllWorkersIdle {
 		t.Errorf("AllWorkersIdle mismatch: got %v, want %v", decoded.AllWorkersIdle, state.AllWorkersIdle)
 	}
@@ -132,11 +150,9 @@ func TestStallStateJSON(t *testing.T) {
 	if decoded.TeamStalled != state.TeamStalled {
 		t.Errorf("TeamStalled mismatch: got %v, want %v", decoded.TeamStalled, state.TeamStalled)
 	}
-
 	if len(decoded.Reasons) != len(state.Reasons) {
 		t.Errorf("Reasons length mismatch: got %d, want %d", len(decoded.Reasons), len(state.Reasons))
 	}
-
 	if decoded.PendingTaskCount != state.PendingTaskCount {
 		t.Errorf("PendingTaskCount mismatch: got %d, want %d", decoded.PendingTaskCount, state.PendingTaskCount)
 	}