refactor: rewrite workflow system as agent team orchestration templates

Workflow is no longer a standalone execution engine that calls
RunClaude() sequentially. It now serves as a quick template for
creating agent teams, fully reusing the existing team infrastructure.

Key changes:
- Extract StartAgent/StartAllAgents from MCP handlers into agent pkg
- Replace Step/WorkflowRun/ApprovalDecision types with
  WorkflowAgent/WorkflowTask/WorkflowRunResult
- Rewrite runner as non-blocking: team_create → agent_add → task_create
  → StartAllAgents → return result
- Add workflow_create MCP tool for programmatic workflow creation
- Add --project flag to workflow run CLI command
- Auto-migrate old steps-based YAML to new agents+tasks format
- Delete approval.go and persistence.go (no longer needed)

Author: ourines

internal/agent/team.go

@@ -3,6 +3,7 @@ package agent
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"time"
 )
 
@@ -170,3 +171,83 @@ func IsAgentAlive(teamName, agentName string) bool {
 	}
 	return alive
 }
+
+// AgentStartResult holds the result of starting a single agent.
+type AgentStartResult struct {
+	Name    string `json:"name"`
+	Started bool   `json:"started"`
+	PID     int    `json:"pid,omitempty"`
+	Error   string `json:"error,omitempty"`
+}
+
+// StartAgent spawns an agent daemon as an independent subprocess.
+// Returns the PID of the spawned process.
+func StartAgent(teamName, agentName string) (int, error) {
+	// Verify the agent exists
+	if _, err := NewDaemon(teamName, agentName); err != nil {
+		return 0, err
+	}
+
+	// Check if already running
+	if IsAgentAlive(teamName, agentName) {
+		state, _ := GetAgentState(teamName, agentName)
+		pid := 0
+		if state != nil {
+			pid = state.PID
+		}
+		return 0, fmt.Errorf("agent %q is already running (pid %d)", agentName, pid)
+	}
+
+	exe, err := os.Executable()
+	if err != nil {
+		return 0, fmt.Errorf("cannot find executable: %w", err)
+	}
+
+	cmd := exec.Command(exe, "agent", "run", teamName, agentName)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Start(); err != nil {
+		return 0, fmt.Errorf("failed to start agent: %w", err)
+	}
+
+	pid := cmd.Process.Pid
+	cmd.Process.Release() // detach
+	return pid, nil
+}
+
+// StartAllAgents spawns all agents in a team, skipping those already running.
+func StartAllAgents(teamName string) ([]AgentStartResult, error) {
+	cfg, err := GetTeam(teamName)
+	if err != nil {
+		return nil, err
+	}
+
+	var results []AgentStartResult
+	for _, m := range cfg.Members {
+		r := AgentStartResult{Name: m.Name}
+
+		if IsAgentAlive(teamName, m.Name) {
+			state, _ := GetAgentState(teamName, m.Name)
+			if state != nil {
+				r.PID = state.PID
+			}
+			r.Error = "already running"
+			results = append(results, r)
+			continue
+		}
+
+		pid, err := StartAgent(teamName, m.Name)
+		if err != nil {
+			// StartAgent checks alive again; handle "already running" gracefully
+			r.Error = err.Error()
+			results = append(results, r)
+			continue
+		}
+
+		r.Started = true
+		r.PID = pid
+		results = append(results, r)
+	}
+
+	return results, nil
+}

internal/commands/workflow_cobra.go

@@ -27,7 +27,8 @@ var workflowRunCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		dir, _ := cmd.Flags().GetString("dir")
 		model, _ := cmd.Flags().GetString("model")
-		RunWorkflowRun(args[0], dir, model)
+		project, _ := cmd.Flags().GetString("project")
+		RunWorkflowRun(args[0], dir, model, project)
 	},
 }
 
@@ -52,6 +53,7 @@ var workflowDeleteCmd = &cobra.Command{
 func init() {
 	workflowRunCmd.Flags().StringP("dir", "d", "", "Working directory (default: current)")
 	workflowRunCmd.Flags().StringP("model", "m", "", "Claude model to use")
+	workflowRunCmd.Flags().StringP("project", "p", "", "Project name to execute in")
 
 	WorkflowCmd.AddCommand(workflowListCmd)
 	WorkflowCmd.AddCommand(workflowRunCmd)

internal/commands/workflow_commands.go

@@ -1,7 +1,6 @@
 package commands
 
 import (
-	"context"
 	"fmt"
 	"os"
 
@@ -32,13 +31,13 @@ func RunWorkflowList() {
 		if wf.Description != "" {
 			fmt.Printf("    %s\n", wf.Description)
 		}
-		fmt.Printf("    Steps: %d\n", len(wf.Steps))
+		fmt.Printf("    Agents: %d  Tasks: %d\n", len(wf.Agents), len(wf.Tasks))
 		fmt.Println()
 	}
 }
 
-// RunWorkflowRun executes a workflow by name.
-func RunWorkflowRun(name, dir, model string) {
+// RunWorkflowRun launches a workflow as an agent team (non-blocking).
+func RunWorkflowRun(name, dir, model, project string) {
 	wf, err := workflow.GetWorkflow(name)
 	if err != nil {
 		ui.ShowError("Workflow not found", err)
@@ -49,43 +48,27 @@ func RunWorkflowRun(name, dir, model string) {
 		dir, _ = os.Getwd()
 	}
 
-	fmt.Printf("Running workflow: %s (%d steps)\n", wf.Name, len(wf.Steps))
+	fmt.Printf("Launching workflow: %s (%d agents, %d tasks)\n", wf.Name, len(wf.Agents), len(wf.Tasks))
 	if wf.Description != "" {
 		fmt.Printf("  %s\n", wf.Description)
 	}
 	fmt.Println()
 
-	ctx := context.Background()
-	run, err := workflow.RunWorkflow(ctx, wf, workflow.RunWorkflowOptions{
+	result, err := workflow.RunWorkflow(wf, workflow.RunWorkflowOptions{
 		WorkDir: dir,
 		Model:   model,
+		Project: project,
 	})
 	if err != nil {
-		ui.ShowError("Workflow execution failed", err)
+		ui.ShowError("Workflow launch failed", err)
 		return
 	}
 
-	// Print results
-	for i, result := range run.Results {
-		status := "✓"
-		if result.Error != "" {
-			status = "✗"
-		}
-		fmt.Printf("  %s Step %d: %s\n", status, i+1, result.StepName)
-		if result.Error != "" {
-			fmt.Printf("    Error: %s\n", result.Error)
-		}
-		if result.Cost > 0 {
-			fmt.Printf("    Cost: $%.4f\n", result.Cost)
-		}
-		fmt.Println()
-	}
-
-	if run.Status == "completed" {
-		ui.ShowSuccess("Workflow completed successfully.")
-	} else {
-		ui.ShowError(fmt.Sprintf("Workflow %s", run.Status), nil)
-	}
+	ui.ShowSuccess("Workflow launched as team: %s", result.TeamName)
+	fmt.Printf("  Agents started: %d\n", result.Agents)
+	fmt.Printf("  Tasks created:  %d\n", result.Tasks)
+	fmt.Println()
+	fmt.Printf("Monitor progress: codes agent status %s\n", result.TeamName)
 }
 
 // RunWorkflowCreate creates a new workflow template file.
@@ -99,10 +82,14 @@ func RunWorkflowCreate(name string) {
 	wf := &workflow.Workflow{
 		Name:        name,
 		Description: "Custom workflow",
-		Steps: []workflow.Step{
+		Agents: []workflow.WorkflowAgent{
+			{Name: "worker", Role: "Execute workflow tasks"},
+		},
+		Tasks: []workflow.WorkflowTask{
 			{
-				Name:   "Step 1",
-				Prompt: "Describe what this step should do",
+				Subject: "Task 1",
+				Assign:  "worker",
+				Prompt:  "Describe what this task should do",
 			},
 		},
 	}
@@ -113,7 +100,7 @@ func RunWorkflowCreate(name string) {
 	}
 
 	fmt.Printf("Created workflow template: %s\n", workflow.WorkflowDir()+"/"+name+".yml")
-	fmt.Println("Edit the YAML file to customize steps.")
+	fmt.Println("Edit the YAML file to customize agents and tasks.")
 }
 
 // RunWorkflowDelete removes a workflow.

internal/mcp/agent_tools.go

@@ -3,8 +3,6 @@ package mcpserver
 import (
 	"context"
 	"fmt"
-	"os"
-	"os/exec"
 
 	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
 
@@ -201,38 +199,11 @@ type agentStartOutput struct {
 }
 
 func agentStartHandler(ctx context.Context, req *mcpsdk.CallToolRequest, input agentStartInput) (*mcpsdk.CallToolResult, agentStartOutput, error) {
-	// Verify the agent exists before spawning
-	_, err := agent.NewDaemon(input.Team, input.Name)
+	pid, err := agent.StartAgent(input.Team, input.Name)
 	if err != nil {
 		return nil, agentStartOutput{}, err
 	}
 
-	// Check if the agent is already alive
-	if agent.IsAgentAlive(input.Team, input.Name) {
-		state, _ := agent.GetAgentState(input.Team, input.Name)
-		pid := 0
-		if state != nil {
-			pid = state.PID
-		}
-		return nil, agentStartOutput{}, fmt.Errorf("agent %q is already running (pid %d)", input.Name, pid)
-	}
-
-	// Spawn as independent subprocess so it survives MCP server restarts
-	exe, err := os.Executable()
-	if err != nil {
-		return nil, agentStartOutput{}, fmt.Errorf("cannot find executable: %w", err)
-	}
-
-	cmd := exec.Command(exe, "agent", "run", input.Team, input.Name)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Start(); err != nil {
-		return nil, agentStartOutput{}, fmt.Errorf("failed to start agent: %w", err)
-	}
-
-	pid := cmd.Process.Pid
-	cmd.Process.Release() // detach
-
 	// Ensure background notification monitor is running
 	ensureMonitorRunning(mcpServer)
 
@@ -585,44 +556,19 @@ type teamStartAllOutput struct {
 }
 
 func teamStartAllHandler(ctx context.Context, req *mcpsdk.CallToolRequest, input teamStartAllInput) (*mcpsdk.CallToolResult, teamStartAllOutput, error) {
-	cfg, err := agent.GetTeam(input.Name)
+	agentResults, err := agent.StartAllAgents(input.Name)
 	if err != nil {
 		return nil, teamStartAllOutput{}, err
 	}
 
-	exe, err := os.Executable()
-	if err != nil {
-		return nil, teamStartAllOutput{}, fmt.Errorf("cannot find executable: %w", err)
-	}
-
 	var results []teamStartAllResult
-	for _, m := range cfg.Members {
-		r := teamStartAllResult{Name: m.Name}
-
-		// Skip already alive agents
-		if agent.IsAgentAlive(input.Name, m.Name) {
-			state, _ := agent.GetAgentState(input.Name, m.Name)
-			if state != nil {
-				r.PID = state.PID
-			}
-			r.Error = "already running"
-			results = append(results, r)
-			continue
-		}
-
-		cmd := exec.Command(exe, "agent", "run", input.Name, m.Name)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		if err := cmd.Start(); err != nil {
-			r.Error = err.Error()
-			results = append(results, r)
-			continue
-		}
-
-		r.Started = true
-		r.PID = cmd.Process.Pid
-		cmd.Process.Release()
-		results = append(results, r)
+	for _, ar := range agentResults {
+		results = append(results, teamStartAllResult{
+			Name:    ar.Name,
+			Started: ar.Started,
+			PID:     ar.PID,
+			Error:   ar.Error,
+		})
 	}
 
 	// Ensure background notification monitor is running