cli.go

package cli

import (
	"bufio"
	"context"
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"runtime/debug"
	"strconv"
	"strings"
	"syscall"
	"time"

	"github.com/dlorenc/multiclaude/internal/agents"
	"github.com/dlorenc/multiclaude/internal/bugreport"
	"github.com/dlorenc/multiclaude/internal/daemon"
	"github.com/dlorenc/multiclaude/internal/errors"
	"github.com/dlorenc/multiclaude/internal/fork"
	"github.com/dlorenc/multiclaude/internal/format"
	"github.com/dlorenc/multiclaude/internal/hooks"
	"github.com/dlorenc/multiclaude/internal/messages"
	"github.com/dlorenc/multiclaude/internal/names"
	"github.com/dlorenc/multiclaude/internal/prompts"
	"github.com/dlorenc/multiclaude/internal/socket"
	"github.com/dlorenc/multiclaude/internal/state"
	"github.com/dlorenc/multiclaude/internal/templates"
	"github.com/dlorenc/multiclaude/internal/worktree"
	"github.com/dlorenc/multiclaude/pkg/claude"
	"github.com/dlorenc/multiclaude/pkg/config"
	"github.com/dlorenc/multiclaude/pkg/tmux"
)

// Version is the current version of multiclaude (set at build time via ldflags)
var Version = "dev"

// GetVersion returns the semver-formatted version string
func GetVersion() string {
	if Version != "dev" {
		return Version
	}

	// Try to get VCS info embedded by Go at build time
	info, ok := debug.ReadBuildInfo()
	if !ok {
		return "0.0.0-dev"
	}

	var commit string
	for _, setting := range info.Settings {
		if setting.Key == "vcs.revision" {
			commit = setting.Value
			if len(commit) > 7 {
				commit = commit[:7] // Short commit hash
			}
			break
		}
	}

	if commit == "" {
		return "0.0.0-dev"
	}

	return fmt.Sprintf("0.0.0+%s-dev", commit)
}

// IsDevVersion returns true if running a development build (not set via ldflags)
func IsDevVersion() bool {
	return Version == "dev"
}

// Command represents a CLI command
type Command struct {
	Name        string
	Description string
	Usage       string
	Run         func(args []string) error
	Subcommands map[string]*Command
}

// CLI manages the command-line interface
type CLI struct {
	rootCmd       *Command
	paths         *config.Paths
	documentation string // Auto-generated CLI documentation for prompts
}

// New creates a new CLI
func New() (*CLI, error) {
	paths, err := config.DefaultPaths()
	if err != nil {
		return nil, err
	}

	cli := &CLI{
		paths: paths,
		rootCmd: &Command{
			Name:        "multiclaude",
			Description: "repo-centric orchestrator for Claude Code",
			Subcommands: make(map[string]*Command),
		},
	}

	cli.registerCommands()

	// Generate documentation after commands are registered
	cli.documentation = cli.GenerateDocumentation()

	return cli, nil
}

// NewWithPaths creates a CLI with custom paths (for testing)
func NewWithPaths(paths *config.Paths) *CLI {
	cli := &CLI{
		paths: paths,
		rootCmd: &Command{
			Name:        "multiclaude",
			Description: "repo-centric orchestrator for Claude Code",
			Subcommands: make(map[string]*Command),
		},
	}

	cli.registerCommands()

	// Generate documentation after commands are registered
	cli.documentation = cli.GenerateDocumentation()

	return cli
}

// getClaudeBinary resolves the claude binary path
func (c *CLI) getClaudeBinary() (string, error) {
	binaryPath, err := exec.LookPath("claude")
	if err != nil {
		return "", errors.ClaudeNotFound(err)
	}
	return binaryPath, nil
}

// loadState loads the state file, wrapping errors with context
func (c *CLI) loadState() (*state.State, error) {
	st, err := state.Load(c.paths.StateFile)
	if err != nil {
		return nil, fmt.Errorf("failed to load state: %w", err)
	}
	return st, nil
}

// sendDaemonRequest sends a request to the daemon and handles common error cases.
// It returns the response if successful, or an error if communication fails or the daemon returns an error.
func (c *CLI) sendDaemonRequest(command string, args map[string]interface{}) (*socket.Response, error) {
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: command,
		Args:    args,
	})
	if err != nil {
		return nil, errors.DaemonCommunicationFailed(command, err)
	}
	if !resp.Success {
		return nil, fmt.Errorf("%s failed: %s", command, resp.Error)
	}
	return resp, nil
}

// removeDirectoryIfExists removes a directory and prints status messages.
// It prints a warning if removal fails, or a success message if it succeeds.
// If the directory doesn't exist, it does nothing.
func removeDirectoryIfExists(path, description string) {
	if _, err := os.Stat(path); err == nil {
		if err := os.RemoveAll(path); err != nil {
			fmt.Printf("  Warning: failed to remove %s: %v\n", description, err)
		} else {
			fmt.Printf("  Removed %s\n", path)
		}
	}
}

// tmuxSanitizer replaces problematic characters with hyphens for tmux session names.
// tmux has issues with dots, colons, spaces, and forward slashes in session names.
var tmuxSanitizer = strings.NewReplacer(
	".", "-",
	":", "-",
	" ", "-",
	"/", "-",
)

// sanitizeTmuxSessionName creates a tmux-safe session name from a repo name.
// tmux has issues with certain characters like dots, so we replace them.
func sanitizeTmuxSessionName(repoName string) string {
	// Strip control characters (ASCII 0-31) for safety
	sanitized := strings.Map(func(r rune) rune {
		if r < 32 {
			return -1 // drop the character
		}
		return r
	}, repoName)
	return fmt.Sprintf("mc-%s", tmuxSanitizer.Replace(sanitized))
}

// Execute executes the CLI with the given arguments
func (c *CLI) Execute(args []string) error {
	if len(args) == 0 {
		return c.showHelp()
	}

	// Check for --version or -v flag at top level
	if args[0] == "--version" || args[0] == "-v" {
		return c.showVersion()
	}

	return c.executeCommand(c.rootCmd, args)
}

// showVersion displays the version information
func (c *CLI) showVersion() error {
	fmt.Printf("multiclaude %s\n", GetVersion())
	return nil
}

// versionCommand displays version information with optional JSON output
func (c *CLI) versionCommand(args []string) error {
	flags, _ := ParseFlags(args)
	outputJSON := flags["json"] == "true"

	version := GetVersion()

	if outputJSON {
		output := map[string]interface{}{
			"version":    version,
			"isDev":      IsDevVersion(),
			"rawVersion": Version,
		}
		encoder := json.NewEncoder(os.Stdout)
		encoder.SetIndent("", "  ")
		return encoder.Encode(output)
	}

	fmt.Printf("multiclaude %s\n", version)
	return nil
}

// executeCommand recursively executes commands and subcommands
func (c *CLI) executeCommand(cmd *Command, args []string) error {
	if len(args) == 0 {
		if cmd.Run != nil {
			return cmd.Run([]string{})
		}
		return c.showCommandHelp(cmd)
	}

	// Check for --help or -h flag
	if args[0] == "--help" || args[0] == "-h" {
		return c.showCommandHelp(cmd)
	}

	// Check for subcommands
	if subcmd, exists := cmd.Subcommands[args[0]]; exists {
		return c.executeCommand(subcmd, args[1:])
	}

	// No subcommand found, run this command with args
	if cmd.Run != nil {
		return cmd.Run(args)
	}

	return errors.UnknownCommand(args[0])
}

// showHelp shows the main help message
func (c *CLI) showHelp() error {
	fmt.Println("multiclaude - repo-centric orchestrator for Claude Code")
	fmt.Println()
	fmt.Println("Usage: multiclaude <command> [options]")
	fmt.Println()
	fmt.Println("Commands:")

	for name, cmd := range c.rootCmd.Subcommands {
		fmt.Printf("  %-15s %s\n", name, cmd.Description)
	}

	fmt.Println()
	fmt.Println("Use 'multiclaude <command> --help' for more information about a command.")
	return nil
}

// showCommandHelp shows help for a specific command
func (c *CLI) showCommandHelp(cmd *Command) error {
	fmt.Printf("%s - %s\n", cmd.Name, cmd.Description)
	fmt.Println()
	if cmd.Usage != "" {
		fmt.Printf("Usage: %s\n", cmd.Usage)
		fmt.Println()
	}

	if len(cmd.Subcommands) > 0 {
		fmt.Println("Subcommands:")
		for name, subcmd := range cmd.Subcommands {
			// Skip internal commands (prefixed with _)
			if strings.HasPrefix(name, "_") {
				continue
			}
			fmt.Printf("  %-15s %s\n", name, subcmd.Description)
		}
		fmt.Println()
	}

	return nil
}

// registerCommands registers all CLI commands
func (c *CLI) registerCommands() {
	// Daemon commands
	// Root-level 'start' is kept as alias for backward compatibility
	c.rootCmd.Subcommands["start"] = &Command{
		Name:        "start",
		Description: "Start the daemon (alias for 'daemon start')",
		Usage:       "multiclaude start",
		Run:         c.startDaemon,
	}

	daemonCmd := &Command{
		Name:        "daemon",
		Description: "Manage the multiclaude daemon",
		Subcommands: make(map[string]*Command),
	}

	daemonCmd.Subcommands["start"] = &Command{
		Name:        "start",
		Description: "Start the daemon",
		Usage:       "multiclaude daemon start",
		Run:         c.startDaemon,
	}

	daemonCmd.Subcommands["stop"] = &Command{
		Name:        "stop",
		Description: "Stop the daemon",
		Usage:       "multiclaude daemon stop",
		Run:         c.stopDaemon,
	}

	daemonCmd.Subcommands["status"] = &Command{
		Name:        "status",
		Description: "Show daemon status",
		Usage:       "multiclaude daemon status",
		Run:         c.daemonStatus,
	}

	daemonCmd.Subcommands["logs"] = &Command{
		Name:        "logs",
		Description: "View daemon logs",
		Usage:       "multiclaude daemon logs [-f|--follow] [-n <lines>]",
		Run:         c.daemonLogs,
	}

	daemonCmd.Subcommands["_run"] = &Command{
		Name:        "_run",
		Description: "Internal: run daemon in foreground (used by daemon start)",
		Run:         c.runDaemon,
	}

	c.rootCmd.Subcommands["daemon"] = daemonCmd

	// Stop-all command (convenience for stopping everything)
	c.rootCmd.Subcommands["stop-all"] = &Command{
		Name:        "stop-all",
		Description: "Stop daemon and kill all multiclaude tmux sessions",
		Usage:       "multiclaude stop-all [--clean] [--yes]",
		Run:         c.stopAll,
	}

	// Repository commands (repo subcommand)
	repoCmd := &Command{
		Name:        "repo",
		Description: "Manage repositories",
		Subcommands: make(map[string]*Command),
	}

	repoCmd.Subcommands["init"] = &Command{
		Name:        "init",
		Description: "Initialize a repository",
		Usage:       "multiclaude repo init <github-url> [name] [--no-merge-queue] [--mq-track=all|author|assigned]",
		Run:         c.initRepo,
	}

	repoCmd.Subcommands["list"] = &Command{
		Name:        "list",
		Description: "List tracked repositories",
		Usage:       "multiclaude repo list",
		Run:         c.listRepos,
	}

	repoCmd.Subcommands["rm"] = &Command{
		Name:        "rm",
		Description: "Remove a tracked repository",
		Usage:       "multiclaude repo rm <name>",
		Run:         c.removeRepo,
	}

	repoCmd.Subcommands["use"] = &Command{
		Name:        "use",
		Description: "Set the default repository",
		Usage:       "multiclaude repo use <name>",
		Run:         c.setCurrentRepo,
	}

	repoCmd.Subcommands["current"] = &Command{
		Name:        "current",
		Description: "Show the default repository",
		Usage:       "multiclaude repo current",
		Run:         c.getCurrentRepo,
	}

	repoCmd.Subcommands["unset"] = &Command{
		Name:        "unset",
		Description: "Clear the default repository",
		Usage:       "multiclaude repo unset",
		Run:         c.clearCurrentRepo,
	}

	repoCmd.Subcommands["history"] = &Command{
		Name:        "history",
		Description: "Show task history for a repository",
		Usage:       "multiclaude repo history [--repo <repo>] [-n <count>] [--status <status>] [--search <query>] [--full]",
		Run:         c.showHistory,
	}

	c.rootCmd.Subcommands["repo"] = repoCmd

	// Backward compatibility aliases for root-level repo commands
	c.rootCmd.Subcommands["init"] = repoCmd.Subcommands["init"]
	c.rootCmd.Subcommands["list"] = repoCmd.Subcommands["list"]
	c.rootCmd.Subcommands["history"] = repoCmd.Subcommands["history"]

	// Worker commands
	workerCmd := &Command{
		Name:        "worker",
		Description: "Manage worker agents",
		Usage:       "multiclaude worker [<task>] [--repo <repo>] [--branch <branch>] [--push-to <branch>]",
		Subcommands: make(map[string]*Command),
	}

	workerCmd.Run = c.createWorker // Default action for 'worker' command (same as 'worker create')

	workerCmd.Subcommands["create"] = &Command{
		Name:        "create",
		Description: "Create a new worker agent",
		Usage:       "multiclaude worker create <task> [--repo <repo>] [--branch <branch>] [--push-to <branch>]",
		Run:         c.createWorker,
	}

	workerCmd.Subcommands["list"] = &Command{
		Name:        "list",
		Description: "List active workers",
		Usage:       "multiclaude worker list [--repo <repo>]",
		Run:         c.listWorkers,
	}

	workerCmd.Subcommands["rm"] = &Command{
		Name:        "rm",
		Description: "Remove a worker",
		Usage:       "multiclaude worker rm <worker-name>",
		Run:         c.removeWorker,
	}

	c.rootCmd.Subcommands["worker"] = workerCmd

	// 'work' is an alias for 'worker' (backward compatibility)
	c.rootCmd.Subcommands["work"] = workerCmd

	// Workspace commands
	workspaceCmd := &Command{
		Name:        "workspace",
		Description: "Manage workspaces",
		Usage:       "multiclaude workspace [<name>]",
		Subcommands: make(map[string]*Command),
	}

	workspaceCmd.Run = c.workspaceDefault // Default action: list or connect

	workspaceCmd.Subcommands["add"] = &Command{
		Name:        "add",
		Description: "Add a new workspace",
		Usage:       "multiclaude workspace add <name> [--branch <branch>]",
		Run:         c.addWorkspace,
	}

	workspaceCmd.Subcommands["rm"] = &Command{
		Name:        "rm",
		Description: "Remove a workspace",
		Usage:       "multiclaude workspace rm <name>",
		Run:         c.removeWorkspace,
	}

	workspaceCmd.Subcommands["list"] = &Command{
		Name:        "list",
		Description: "List workspaces",
		Usage:       "multiclaude workspace list",
		Run:         c.listWorkspaces,
	}

	workspaceCmd.Subcommands["connect"] = &Command{
		Name:        "connect",
		Description: "Connect to a workspace",
		Usage:       "multiclaude workspace connect <name>",
		Run:         c.connectWorkspace,
	}

	c.rootCmd.Subcommands["workspace"] = workspaceCmd

	// Agent commands (run from within Claude)
	agentCmd := &Command{
		Name:        "agent",
		Description: "Agent communication commands",
		Subcommands: make(map[string]*Command),
	}

	// Legacy message commands (aliases for backward compatibility)
	// Prefer: multiclaude message send/list/read/ack
	agentCmd.Subcommands["send-message"] = &Command{
		Name:        "send-message",
		Description: "Send a message to another agent (alias for 'message send')",
		Usage:       "multiclaude agent send-message <recipient> <message>",
		Run:         c.sendMessage,
	}

	agentCmd.Subcommands["list-messages"] = &Command{
		Name:        "list-messages",
		Description: "List pending messages (alias for 'message list')",
		Usage:       "multiclaude agent list-messages",
		Run:         c.listMessages,
	}

	agentCmd.Subcommands["read-message"] = &Command{
		Name:        "read-message",
		Description: "Read a specific message (alias for 'message read')",
		Usage:       "multiclaude agent read-message <message-id>",
		Run:         c.readMessage,
	}

	agentCmd.Subcommands["ack-message"] = &Command{
		Name:        "ack-message",
		Description: "Acknowledge a message (alias for 'message ack')",
		Usage:       "multiclaude agent ack-message <message-id>",
		Run:         c.ackMessage,
	}

	agentCmd.Subcommands["complete"] = &Command{
		Name:        "complete",
		Description: "Signal worker completion",
		Usage:       "multiclaude agent complete [--summary <text>] [--failure <reason>]",
		Run:         c.completeWorker,
	}

	agentCmd.Subcommands["restart"] = &Command{
		Name:        "restart",
		Description: "Restart a crashed or exited agent",
		Usage:       "multiclaude agent restart <name> [--repo <repo>] [--force]",
		Run:         c.restartAgentCmd,
	}

	agentCmd.Subcommands["attach"] = &Command{
		Name:        "attach",
		Description: "Attach to an agent's tmux window",
		Usage:       "multiclaude agent attach <agent-name> [--read-only]",
		Run:         c.attachAgent,
	}

	c.rootCmd.Subcommands["agent"] = agentCmd

	// Message commands (new noun group for message operations)
	// These are the preferred commands; agent *-message commands are kept as aliases
	messageCmd := &Command{
		Name:        "message",
		Description: "Manage inter-agent messages",
		Subcommands: make(map[string]*Command),
	}

	messageCmd.Subcommands["send"] = &Command{
		Name:        "send",
		Description: "Send a message to another agent",
		Usage:       "multiclaude message send <recipient> <message>",
		Run:         c.sendMessage,
	}

	messageCmd.Subcommands["list"] = &Command{
		Name:        "list",
		Description: "List pending messages",
		Usage:       "multiclaude message list",
		Run:         c.listMessages,
	}

	messageCmd.Subcommands["read"] = &Command{
		Name:        "read",
		Description: "Read a specific message",
		Usage:       "multiclaude message read <message-id>",
		Run:         c.readMessage,
	}

	messageCmd.Subcommands["ack"] = &Command{
		Name:        "ack",
		Description: "Acknowledge a message",
		Usage:       "multiclaude message ack <message-id>",
		Run:         c.ackMessage,
	}

	c.rootCmd.Subcommands["message"] = messageCmd

	// 'attach' is an alias for 'agent attach' (backward compatibility)
	c.rootCmd.Subcommands["attach"] = agentCmd.Subcommands["attach"]

	// Maintenance commands
	c.rootCmd.Subcommands["cleanup"] = &Command{
		Name:        "cleanup",
		Description: "Clean up orphaned resources",
		Usage:       "multiclaude cleanup [--dry-run] [--verbose] [--merged]",
		Run:         c.cleanup,
	}

	c.rootCmd.Subcommands["repair"] = &Command{
		Name:        "repair",
		Description: "Repair state after crash",
		Usage:       "multiclaude repair [--verbose]",
		Run:         c.repair,
	}

	// Claude restart command - for resuming Claude after exit
	c.rootCmd.Subcommands["claude"] = &Command{
		Name:        "claude",
		Description: "Restart Claude in current agent context",
		Usage:       "multiclaude claude",
		Run:         c.restartClaude,
	}

	// Debug command
	c.rootCmd.Subcommands["docs"] = &Command{
		Name:        "docs",
		Description: "Show generated CLI documentation",
		Usage:       "multiclaude docs",
		Run:         c.showDocs,
	}

	// Review command
	c.rootCmd.Subcommands["review"] = &Command{
		Name:        "review",
		Description: "Spawn a review agent for a PR",
		Usage:       "multiclaude review <pr-url>",
		Run:         c.reviewPR,
	}

	// Logs commands
	logsCmd := &Command{
		Name:        "logs",
		Description: "View and manage agent output logs",
		Usage:       "multiclaude logs [<agent-name>] [-f|--follow]",
		Subcommands: make(map[string]*Command),
	}

	logsCmd.Run = c.viewLogs // Default action: view logs for an agent

	logsCmd.Subcommands["list"] = &Command{
		Name:        "list",
		Description: "List log files",
		Usage:       "multiclaude logs list [--repo <repo>]",
		Run:         c.listLogs,
	}

	logsCmd.Subcommands["search"] = &Command{
		Name:        "search",
		Description: "Search across logs",
		Usage:       "multiclaude logs search <pattern> [--repo <repo>]",
		Run:         c.searchLogs,
	}

	logsCmd.Subcommands["clean"] = &Command{
		Name:        "clean",
		Description: "Remove old logs",
		Usage:       "multiclaude logs clean --older-than <duration>",
		Run:         c.cleanLogs,
	}

	c.rootCmd.Subcommands["logs"] = logsCmd

	// Config command
	c.rootCmd.Subcommands["config"] = &Command{
		Name:        "config",
		Description: "View or modify repository configuration",
		Usage:       "multiclaude config [repo] [--mq-enabled=true|false] [--mq-track=all|author|assigned] [--ps-enabled=true|false] [--ps-track=all|author|assigned]",
		Run:         c.configRepo,
	}

	// Bug report command
	c.rootCmd.Subcommands["bug"] = &Command{
		Name:        "bug",
		Description: "Generate a diagnostic bug report",
		Usage:       "multiclaude bug [--output <file>] [--verbose] [description]",
		Run:         c.bugReport,
	}

	// Version command
	c.rootCmd.Subcommands["version"] = &Command{
		Name:        "version",
		Description: "Show version information",
		Usage:       "multiclaude version [--json]",
		Run:         c.versionCommand,
	}

	// Agents command - for managing agent definitions
	agentsCmd := &Command{
		Name:        "agents",
		Description: "Manage agent definitions",
		Subcommands: make(map[string]*Command),
	}

	agentsCmd.Subcommands["list"] = &Command{
		Name:        "list",
		Description: "List available agent definitions for a repository",
		Usage:       "multiclaude agents list [--repo <repo>]",
		Run:         c.listAgentDefinitions,
	}

	agentsCmd.Subcommands["spawn"] = &Command{
		Name:        "spawn",
		Description: "Spawn an agent from a prompt file",
		Usage:       "multiclaude agents spawn --name <name> --class <class> --prompt-file <file> [--repo <repo>] [--task <task>]",
		Run:         c.spawnAgentFromFile,
	}

	agentsCmd.Subcommands["reset"] = &Command{
		Name:        "reset",
		Description: "Reset agent definitions to defaults (re-copy from templates)",
		Usage:       "multiclaude agents reset [--repo <repo>]",
		Run:         c.resetAgentDefinitions,
	}

	c.rootCmd.Subcommands["agents"] = agentsCmd
}

// Daemon command implementations

func (c *CLI) startDaemon(args []string) error {
	return daemon.RunDetached()
}

func (c *CLI) runDaemon(args []string) error {
	return daemon.Run()
}

func (c *CLI) stopDaemon(args []string) error {
	_, err := c.sendDaemonRequest("stop", nil)
	if err != nil {
		return err
	}

	fmt.Println("Daemon stopped successfully")
	return nil
}

func (c *CLI) daemonStatus(args []string) error {
	// Check PID file first
	pidFile := daemon.NewPIDFile(c.paths.DaemonPID)
	running, pid, err := pidFile.IsRunning()
	if err != nil {
		return fmt.Errorf("failed to check daemon status: %w", err)
	}

	if !running {
		fmt.Println("Daemon is not running")
		return nil
	}

	// Try to connect to daemon
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "status",
	})
	if err != nil {
		fmt.Printf("Daemon PID file exists (PID: %d) but daemon is not responding\n", pid)
		return nil
	}

	if !resp.Success {
		return fmt.Errorf("status check failed: %s", resp.Error)
	}

	// Pretty print status
	fmt.Println("Daemon Status:")
	if statusMap, ok := resp.Data.(map[string]interface{}); ok {
		fmt.Printf("  Running: %v\n", statusMap["running"])
		fmt.Printf("  PID: %v\n", statusMap["pid"])
		fmt.Printf("  Repos: %v\n", statusMap["repos"])
		fmt.Printf("  Agents: %v\n", statusMap["agents"])
		fmt.Printf("  Socket: %v\n", statusMap["socket_path"])
	} else {
		// Fallback: print as JSON
		jsonData, _ := json.MarshalIndent(resp.Data, "  ", "  ")
		fmt.Println(string(jsonData))
	}

	return nil
}

func (c *CLI) daemonLogs(args []string) error {
	flags, _ := ParseFlags(args)

	// Check if we should follow logs
	follow := flags["follow"] == "true" || flags["f"] == "true"

	if follow {
		// Use tail -f to follow logs
		cmd := exec.Command("tail", "-f", c.paths.DaemonLog)
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		return cmd.Run()
	}

	// Show last 50 lines
	lines := "50"
	if n, ok := flags["n"]; ok {
		lines = n
	}

	cmd := exec.Command("tail", "-n", lines, c.paths.DaemonLog)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd.Run()
}

func (c *CLI) stopAll(args []string) error {
	flags, _ := ParseFlags(args)
	clean := flags["clean"] == "true"
	skipConfirm := flags["yes"] == "true"

	// Get list of repos (try daemon first, then state file)
	var repos []string
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{Command: "list_repos"})
	if err == nil && resp.Success {
		// Daemon is running, get repos from it
		if repoList, ok := resp.Data.([]interface{}); ok {
			for _, repo := range repoList {
				if repoStr, ok := repo.(string); ok {
					repos = append(repos, repoStr)
				}
			}
		}
	} else {
		// Daemon not running, try to load from state file
		st, err := state.Load(c.paths.StateFile)
		if err == nil {
			repos = st.ListRepos()
		}
	}

	// If --clean is specified, require confirmation
	if clean {
		fmt.Println("WARNING: This will permanently delete:")
		fmt.Println("  - All worktrees (~/.multiclaude/wts/)")
		fmt.Println("  - All agent state (state.json agents section)")
		fmt.Println("  - All message queues (~/.multiclaude/messages/)")
		fmt.Println("  - All output logs (~/.multiclaude/output/)")
		fmt.Println("  - All agent configs (~/.multiclaude/claude-config/)")
		fmt.Println("  - All prompts (~/.multiclaude/prompts/)")
		fmt.Println("  - Local branches (work/*, multiclaude/*)")
		fmt.Println()
		fmt.Println("The following will be PRESERVED:")
		fmt.Println("  - Cloned repositories (~/.multiclaude/repos/)")
		fmt.Println("  - Git credentials")
		fmt.Println()

		if !skipConfirm {
			fmt.Print("Type 'NUKE' to confirm: ")
			reader := bufio.NewReader(os.Stdin)
			input, err := reader.ReadString('\n')
			if err != nil {
				return fmt.Errorf("failed to read input: %w", err)
			}
			input = strings.TrimSpace(input)
			if input != "NUKE" {
				fmt.Println("Aborted.")
				return nil
			}
			fmt.Println()
		}
	}

	fmt.Println("Stopping all multiclaude sessions...")

	// Kill all multiclaude tmux sessions
	tmuxClient := tmux.NewClient()
	if tmuxClient.IsTmuxAvailable() {
		for _, repo := range repos {
			sessionName := fmt.Sprintf("mc-%s", repo)
			exists, err := tmuxClient.HasSession(context.Background(), sessionName)
			if err == nil && exists {
				fmt.Printf("Killing tmux session: %s\n", sessionName)
				if err := tmuxClient.KillSession(context.Background(), sessionName); err != nil {
					fmt.Printf("Warning: failed to kill session %s: %v\n", sessionName, err)
				}
			}
		}

		// Also check for any mc-* sessions we might have missed
		sessions, err := tmuxClient.ListSessions(context.Background())
		if err == nil {
			for _, session := range sessions {
				if strings.HasPrefix(session, "mc-") {
					exists := false
					for _, repo := range repos {
						if fmt.Sprintf("mc-%s", repo) == session {
							exists = true
							break
						}
					}
					if !exists {
						fmt.Printf("Killing orphaned tmux session: %s\n", session)
						if err := tmuxClient.KillSession(context.Background(), session); err != nil {
							fmt.Printf("Warning: failed to kill session %s: %v\n", session, err)
						}
					}
				}
			}
		}
	}

	// Stop the daemon
	fmt.Println("Stopping daemon...")
	resp, err = client.Send(socket.Request{Command: "stop"})
	if err != nil {
		fmt.Printf("Daemon already stopped or not responding\n")
	} else if resp.Success {
		fmt.Println("Daemon stopped")
	}

	// Full cleanup if --clean is specified
	if clean {
		// Remove worktrees directory
		fmt.Println("\nRemoving worktrees...")
		removeDirectoryIfExists(c.paths.WorktreesDir, "worktrees")

		// Remove messages directory
		fmt.Println("Removing messages...")
		removeDirectoryIfExists(c.paths.MessagesDir, "messages")

		// Remove output logs
		fmt.Println("Removing output logs...")
		removeDirectoryIfExists(c.paths.OutputDir, "output logs")

		// Remove claude config (per-agent settings)
		fmt.Println("Removing agent configs...")
		removeDirectoryIfExists(c.paths.ClaudeConfigDir, "agent configs")

		// Remove prompts directory
		fmt.Println("Removing prompts...")
		promptsDir := filepath.Join(c.paths.Root, "prompts")
		removeDirectoryIfExists(promptsDir, "prompts")

		// Clean up local branches in each repository
		fmt.Println("\nCleaning up local branches...")
		for _, repoName := range repos {
			repoPath := c.paths.RepoDir(repoName)
			if _, err := os.Stat(repoPath); os.IsNotExist(err) {
				continue
			}

			fmt.Printf("  Repository: %s\n", repoName)

			// Delete work/* and multiclaude/* branches
			wt := worktree.NewManager(repoPath)
			for _, prefix := range []string{"work/", "multiclaude/"} {
				branches, err := c.listBranchesWithPrefix(repoPath, prefix)
				if err != nil {
					fmt.Printf("    Warning: failed to list %s branches: %v\n", prefix, err)
					continue
				}
				for _, branch := range branches {
					// First remove any worktree associated with this branch
					if err := wt.Remove(branch, true); err != nil {
						// Ignore errors - worktree may not exist
					}
					// Delete the branch
					if err := c.deleteBranch(repoPath, branch); err != nil {
						fmt.Printf("    Warning: failed to delete branch %s: %v\n", branch, err)
					} else {
						fmt.Printf("    Deleted branch: %s\n", branch)
					}
				}
			}

			// Prune worktrees
			if err := wt.Prune(); err != nil {
				fmt.Printf("    Warning: failed to prune worktrees: %v\n", err)
			}
		}

		// Clear agent state but preserve repository entries
		fmt.Println("\nClearing agent state...")
		st, err := state.Load(c.paths.StateFile)
		if err == nil {
			st.ClearAllAgents()
			if err := st.Save(); err != nil {
				fmt.Printf("  Warning: failed to save state: %v\n", err)
			} else {
				fmt.Println("  Cleared all agents from state")
			}
		}

		// Remove daemon files (they'll be recreated on next start)
		fmt.Println("Cleaning up daemon files...")
		os.Remove(c.paths.DaemonPID)
		os.Remove(c.paths.DaemonSock)
		os.Remove(c.paths.DaemonLog)

		fmt.Println("\n✓ Full cleanup complete! Multiclaude has been reset to a clean state.")
		fmt.Println("Your repositories are preserved at:", c.paths.ReposDir)
		fmt.Println("\nRun 'multiclaude daemon start' to begin fresh.")
	} else {
		fmt.Println("\n✓ All multiclaude sessions stopped")
	}

	return nil
}

func (c *CLI) initRepo(args []string) error {
	flags, posArgs := ParseFlags(args)

	if len(posArgs) < 1 {
		return errors.InvalidUsage("usage: multiclaude init <github-url> [name] [--no-merge-queue] [--mq-track=all|author|assigned]")
	}

	githubURL := strings.TrimRight(posArgs[0], "/")

	// Parse repository name from URL if not provided
	var repoName string
	if len(posArgs) >= 2 {
		repoName = posArgs[1]
	} else {
		// Extract repo name from URL (e.g., github.com/user/repo -> repo)
		// A valid GitHub URL has format: https://github.com/owner/repo
		// When split by "/": ["https:", "", "github.com", "owner", "repo"] - 5+ parts
		parts := strings.Split(githubURL, "/")
		if len(parts) < 5 {
			return errors.InvalidUsage("could not determine repository name from URL; please provide a name: multiclaude init <url> <name>")
		}
		repoName = strings.TrimSuffix(parts[len(parts)-1], ".git")
	}

	// Validate repository name before any operations
	if repoName == "" {
		return errors.InvalidUsage("could not determine repository name from URL; please provide a name: multiclaude init <url> <name>")
	}

	// Parse merge queue configuration flags
	mqEnabled := flags["no-merge-queue"] != "true"
	mqTrackMode := state.TrackModeAll
	if trackMode, ok := flags["mq-track"]; ok {
		switch trackMode {
		case "all":
			mqTrackMode = state.TrackModeAll
		case "author":
			mqTrackMode = state.TrackModeAuthor
		case "assigned":
			mqTrackMode = state.TrackModeAssigned
		default:
			return fmt.Errorf("invalid --mq-track value: %s (must be 'all', 'author', or 'assigned')", trackMode)
		}
	}

	mqConfig := state.MergeQueueConfig{
		Enabled:   mqEnabled,
		TrackMode: mqTrackMode,
	}

	fmt.Printf("Initializing repository: %s\n", repoName)
	fmt.Printf("GitHub URL: %s\n", githubURL)
	if mqEnabled {
		fmt.Printf("Merge queue: enabled (tracking: %s)\n", mqTrackMode)
	} else {
		fmt.Printf("Merge queue: disabled\n")
	}

	// Check if daemon is running
	client := socket.NewClient(c.paths.DaemonSock)
	_, err := client.Send(socket.Request{Command: "ping"})
	if err != nil {
		return errors.DaemonNotRunning()
	}

	// Clone repository
	repoPath := c.paths.RepoDir(repoName)
	fmt.Printf("Cloning to: %s\n", repoPath)

	cmd := exec.Command("git", "clone", githubURL, repoPath)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Run(); err != nil {
		return errors.GitOperationFailed("clone", err)
	}

	// Detect if this is a fork
	forkInfo, err := fork.DetectFork(repoPath)
	if err != nil {
		fmt.Printf("Warning: Failed to detect fork status: %v\n", err)
		forkInfo = &fork.ForkInfo{IsFork: false}
	}

	// Store fork config
	var forkConfig state.ForkConfig
	if forkInfo.IsFork {
		fmt.Printf("Detected fork of %s/%s\n", forkInfo.UpstreamOwner, forkInfo.UpstreamRepo)
		forkConfig = state.ForkConfig{
			IsFork:        true,
			UpstreamURL:   forkInfo.UpstreamURL,
			UpstreamOwner: forkInfo.UpstreamOwner,
			UpstreamRepo:  forkInfo.UpstreamRepo,
		}

		// Add upstream remote if not already present
		if !fork.HasUpstreamRemote(repoPath) {
			fmt.Printf("Adding upstream remote: %s\n", forkInfo.UpstreamURL)
			if err := fork.AddUpstreamRemote(repoPath, forkInfo.UpstreamURL); err != nil {
				fmt.Printf("Warning: Failed to add upstream remote: %v\n", err)
			}
		}

		// In fork mode, disable merge-queue and enable pr-shepherd by default
		mqConfig.Enabled = false
		mqEnabled = false
	}

	// PR Shepherd config (used in fork mode)
	psConfig := state.DefaultPRShepherdConfig()
	psEnabled := forkInfo.IsFork && psConfig.Enabled

	// Copy agent templates to per-repo agents directory
	agentsDir := c.paths.RepoAgentsDir(repoName)
	fmt.Printf("Copying agent templates to: %s\n", agentsDir)
	if err := templates.CopyAgentTemplates(agentsDir); err != nil {
		return fmt.Errorf("failed to copy agent templates: %w", err)
	}

	// Create tmux session
	tmuxSession := sanitizeTmuxSessionName(repoName)
	if tmuxSession == "mc-" {
		return fmt.Errorf("invalid tmux session name: repository name cannot be empty")
	}

	fmt.Printf("Creating tmux session: %s\n", tmuxSession)

	// Create session with supervisor window
	cmd = exec.Command("tmux", "new-session", "-d", "-s", tmuxSession, "-n", "supervisor", "-c", repoPath)
	if err := cmd.Run(); err != nil {
		return errors.TmuxOperationFailed("create session", err)
	}

	// Create merge-queue or pr-shepherd window based on mode
	if mqEnabled {
		cmd = exec.Command("tmux", "new-window", "-d", "-t", tmuxSession, "-n", "merge-queue", "-c", repoPath)
		if err := cmd.Run(); err != nil {
			return errors.TmuxOperationFailed("create merge-queue window", err)
		}
	} else if psEnabled {
		cmd = exec.Command("tmux", "new-window", "-d", "-t", tmuxSession, "-n", "pr-shepherd", "-c", repoPath)
		if err := cmd.Run(); err != nil {
			return errors.TmuxOperationFailed("create pr-shepherd window", err)
		}
	}

	// Generate session IDs for agents
	supervisorSessionID, err := claude.GenerateSessionID()
	if err != nil {
		return fmt.Errorf("failed to generate supervisor session ID: %w", err)
	}

	var mergeQueueSessionID, prShepherdSessionID string
	if mqEnabled {
		mergeQueueSessionID, err = claude.GenerateSessionID()
		if err != nil {
			return fmt.Errorf("failed to generate merge-queue session ID: %w", err)
		}
	} else if psEnabled {
		prShepherdSessionID, err = claude.GenerateSessionID()
		if err != nil {
			return fmt.Errorf("failed to generate pr-shepherd session ID: %w", err)
		}
	}

	// Write prompt files
	supervisorPromptFile, err := c.writePromptFile(repoPath, state.AgentTypeSupervisor, "supervisor")
	if err != nil {
		return fmt.Errorf("failed to write supervisor prompt: %w", err)
	}

	var mergeQueuePromptFile, prShepherdPromptFile string
	if mqEnabled {
		mergeQueuePromptFile, err = c.writeMergeQueuePromptFile(repoPath, "merge-queue", mqConfig)
		if err != nil {
			return fmt.Errorf("failed to write merge-queue prompt: %w", err)
		}
	} else if psEnabled {
		prShepherdPromptFile, err = c.writePRShepherdPromptFile(repoPath, "pr-shepherd", psConfig, forkConfig)
		if err != nil {
			return fmt.Errorf("failed to write pr-shepherd prompt: %w", err)
		}
	}

	// Copy hooks configuration if it exists (for supervisor and merge-queue)
	if err := hooks.CopyConfig(repoPath, repoPath); err != nil {
		fmt.Printf("Warning: failed to copy hooks config: %v\n", err)
	}

	// Start Claude in supervisor window (skip in test mode)
	var supervisorPID, mergeQueuePID, prShepherdPID int
	if os.Getenv("MULTICLAUDE_TEST_MODE") != "1" {
		// Resolve claude binary
		claudeBinary, err := c.getClaudeBinary()
		if err != nil {
			return fmt.Errorf("failed to resolve claude binary: %w", err)
		}

		fmt.Println("Starting Claude Code in supervisor window...")
		pid, err := c.startClaudeInTmux(claudeBinary, tmuxSession, "supervisor", repoPath, supervisorSessionID, supervisorPromptFile, repoName, "")
		if err != nil {
			return fmt.Errorf("failed to start supervisor Claude: %w", err)
		}
		supervisorPID = pid

		// Set up output capture for supervisor
		if err := c.setupOutputCapture(tmuxSession, "supervisor", repoName, "supervisor", "supervisor"); err != nil {
			fmt.Printf("Warning: failed to setup output capture for supervisor: %v\n", err)
		}

		// Start Claude in merge-queue window only if enabled
		if mqEnabled {
			fmt.Println("Starting Claude Code in merge-queue window...")
			pid, err = c.startClaudeInTmux(claudeBinary, tmuxSession, "merge-queue", repoPath, mergeQueueSessionID, mergeQueuePromptFile, repoName, "")
			if err != nil {
				return fmt.Errorf("failed to start merge-queue Claude: %w", err)
			}
			mergeQueuePID = pid

			// Set up output capture for merge-queue
			if err := c.setupOutputCapture(tmuxSession, "merge-queue", repoName, "merge-queue", "merge-queue"); err != nil {
				fmt.Printf("Warning: failed to setup output capture for merge-queue: %v\n", err)
			}
		} else if psEnabled {
			fmt.Println("Starting Claude Code in pr-shepherd window...")
			pid, err = c.startClaudeInTmux(claudeBinary, tmuxSession, "pr-shepherd", repoPath, prShepherdSessionID, prShepherdPromptFile, repoName, "")
			if err != nil {
				return fmt.Errorf("failed to start pr-shepherd Claude: %w", err)
			}
			prShepherdPID = pid

			// Set up output capture for pr-shepherd
			if err := c.setupOutputCapture(tmuxSession, "pr-shepherd", repoName, "pr-shepherd", "pr-shepherd"); err != nil {
				fmt.Printf("Warning: failed to setup output capture for pr-shepherd: %v\n", err)
			}
		}
	}

	// Add repository to daemon state (with merge queue and fork config)
	addRepoArgs := map[string]interface{}{
		"name":          repoName,
		"github_url":    githubURL,
		"tmux_session":  tmuxSession,
		"mq_enabled":    mqConfig.Enabled,
		"mq_track_mode": string(mqConfig.TrackMode),
		"ps_enabled":    psConfig.Enabled,
		"ps_track_mode": string(psConfig.TrackMode),
		"is_fork":       forkConfig.IsFork,
	}
	if forkConfig.IsFork {
		addRepoArgs["upstream_url"] = forkConfig.UpstreamURL
		addRepoArgs["upstream_owner"] = forkConfig.UpstreamOwner
		addRepoArgs["upstream_repo"] = forkConfig.UpstreamRepo
	}
	resp, err := client.Send(socket.Request{
		Command: "add_repo",
		Args:    addRepoArgs,
	})
	if err != nil {
		return fmt.Errorf("failed to register repository with daemon: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to register repository: %s", resp.Error)
	}

	// Add supervisor agent
	resp, err = client.Send(socket.Request{
		Command: "add_agent",
		Args: map[string]interface{}{
			"repo":          repoName,
			"agent":         "supervisor",
			"type":          "supervisor",
			"worktree_path": repoPath,
			"tmux_window":   "supervisor",
			"session_id":    supervisorSessionID,
			"pid":           supervisorPID,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to register supervisor: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to register supervisor: %s", resp.Error)
	}

	// Add merge-queue agent only if enabled (non-fork mode)
	if mqEnabled {
		resp, err = client.Send(socket.Request{
			Command: "add_agent",
			Args: map[string]interface{}{
				"repo":          repoName,
				"agent":         "merge-queue",
				"type":          "merge-queue",
				"worktree_path": repoPath,
				"tmux_window":   "merge-queue",
				"session_id":    mergeQueueSessionID,
				"pid":           mergeQueuePID,
			},
		})
		if err != nil {
			return fmt.Errorf("failed to register merge-queue: %w", err)
		}
		if !resp.Success {
			return fmt.Errorf("failed to register merge-queue: %s", resp.Error)
		}
	}

	// Add pr-shepherd agent only if enabled (fork mode)
	if psEnabled {
		resp, err = client.Send(socket.Request{
			Command: "add_agent",
			Args: map[string]interface{}{
				"repo":          repoName,
				"agent":         "pr-shepherd",
				"type":          "pr-shepherd",
				"worktree_path": repoPath,
				"tmux_window":   "pr-shepherd",
				"session_id":    prShepherdSessionID,
				"pid":           prShepherdPID,
			},
		})
		if err != nil {
			return fmt.Errorf("failed to register pr-shepherd: %w", err)
		}
		if !resp.Success {
			return fmt.Errorf("failed to register pr-shepherd: %s", resp.Error)
		}
	}

	// Create default workspace worktree
	wt := worktree.NewManager(repoPath)
	workspacePath := c.paths.AgentWorktree(repoName, "default")

	// Check for and migrate legacy "workspace" branch to "workspace/default"
	// This allows the new workspace/<name> naming convention to work
	migrated, err := wt.MigrateLegacyWorkspaceBranch()
	if err != nil {
		// Check if it's a conflict state that requires manual resolution
		hasConflict, suggestion, checkErr := wt.CheckWorkspaceBranchConflict()
		if checkErr == nil && hasConflict {
			return fmt.Errorf("workspace branch conflict detected:\n%s", suggestion)
		}
		return fmt.Errorf("failed to check workspace branch state: %w", err)
	}
	if migrated {
		fmt.Println("Migrated legacy 'workspace' branch to 'workspace/default'")
	}
	workspaceBranch := "workspace/default"

	fmt.Printf("Creating default workspace worktree at: %s\n", workspacePath)
	if err := wt.CreateNewBranch(workspacePath, workspaceBranch, "HEAD"); err != nil {
		return fmt.Errorf("failed to create default workspace worktree: %w", err)
	}

	// Create default workspace tmux window (detached so it doesn't switch focus)
	cmd = exec.Command("tmux", "new-window", "-d", "-t", tmuxSession, "-n", "default", "-c", workspacePath)
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("failed to create workspace window: %w", err)
	}

	// Generate session ID for workspace
	workspaceSessionID, err := claude.GenerateSessionID()
	if err != nil {
		return fmt.Errorf("failed to generate workspace session ID: %w", err)
	}

	// Write prompt file for default workspace
	workspacePromptFile, err := c.writePromptFile(repoPath, state.AgentTypeWorkspace, "default")
	if err != nil {
		return fmt.Errorf("failed to write default workspace prompt: %w", err)
	}

	// Copy hooks configuration if it exists
	if err := hooks.CopyConfig(repoPath, workspacePath); err != nil {
		fmt.Printf("Warning: failed to copy hooks config to default workspace: %v\n", err)
	}

	// Start Claude in default workspace window (skip in test mode)
	var workspacePID int
	if os.Getenv("MULTICLAUDE_TEST_MODE") != "1" {
		// Resolve claude binary
		claudeBinary, err := c.getClaudeBinary()
		if err != nil {
			return fmt.Errorf("failed to resolve claude binary: %w", err)
		}

		fmt.Println("Starting Claude Code in default workspace window...")
		pid, err := c.startClaudeInTmux(claudeBinary, tmuxSession, "default", workspacePath, workspaceSessionID, workspacePromptFile, repoName, "")
		if err != nil {
			return fmt.Errorf("failed to start default workspace Claude: %w", err)
		}
		workspacePID = pid

		// Set up output capture for default workspace
		if err := c.setupOutputCapture(tmuxSession, "default", repoName, "default", "workspace"); err != nil {
			fmt.Printf("Warning: failed to setup output capture for default workspace: %v\n", err)
		}
	}

	// Add default workspace agent
	resp, err = client.Send(socket.Request{
		Command: "add_agent",
		Args: map[string]interface{}{
			"repo":          repoName,
			"agent":         "default",
			"type":          "workspace",
			"worktree_path": workspacePath,
			"tmux_window":   "default",
			"session_id":    workspaceSessionID,
			"pid":           workspacePID,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to register default workspace: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to register default workspace: %s", resp.Error)
	}

	fmt.Println()
	fmt.Println("✓ Repository initialized successfully!")
	fmt.Printf("  Tmux session: %s\n", tmuxSession)
	if mqEnabled {
		fmt.Printf("  Agents: supervisor, merge-queue, default (workspace)\n")
	} else {
		fmt.Printf("  Agents: supervisor, default (workspace)\n")
	}
	fmt.Printf("\nAttach to session: tmux attach -t %s\n", tmuxSession)
	fmt.Printf("Or connect to your workspace: multiclaude workspace connect default\n")

	return nil
}

func (c *CLI) listRepos(args []string) error {
	resp, err := c.sendDaemonRequest("list_repos", map[string]interface{}{
		"rich": true,
	})
	if err != nil {
		return err
	}

	repos, ok := resp.Data.([]interface{})
	if !ok {
		return errors.New(errors.CategoryRuntime, "unexpected response format from daemon")
	}

	if len(repos) == 0 {
		fmt.Println("No repositories tracked")
		format.Dimmed("\nInitialize a repository with: multiclaude init <github-url>")
		return nil
	}

	format.Header("Tracked repositories (%d):", len(repos))
	fmt.Println()

	table := format.NewColoredTable("REPO", "MODE", "AGENTS", "STATUS", "SESSION")
	for _, repo := range repos {
		if repoMap, ok := repo.(map[string]interface{}); ok {
			name, _ := repoMap["name"].(string)
			totalAgents := 0
			if v, ok := repoMap["total_agents"].(float64); ok {
				totalAgents = int(v)
			}
			workerCount := 0
			if v, ok := repoMap["worker_count"].(float64); ok {
				workerCount = int(v)
			}
			sessionHealthy, _ := repoMap["session_healthy"].(bool)
			tmuxSession, _ := repoMap["tmux_session"].(string)

			// Get fork info
			isFork, _ := repoMap["is_fork"].(bool)
			upstreamOwner, _ := repoMap["upstream_owner"].(string)
			upstreamRepo, _ := repoMap["upstream_repo"].(string)

			// Format mode string
			var modeStr string
			if isFork {
				modeStr = fmt.Sprintf("fork of %s/%s", upstreamOwner, upstreamRepo)
			} else {
				modeStr = "upstream"
			}

			// Format agent count
			agentStr := fmt.Sprintf("%d total", totalAgents)
			if workerCount > 0 {
				agentStr = fmt.Sprintf("%d (%d workers)", totalAgents, workerCount)
			}

			// Format status
			var statusCell format.ColoredCell
			if sessionHealthy {
				statusCell = format.ColorCell(format.ColoredStatus(format.StatusHealthy), nil)
			} else {
				statusCell = format.ColorCell(format.ColoredStatus(format.StatusError), nil)
			}

			table.AddRow(
				format.Cell(name),
				format.ColorCell(modeStr, format.Dim),
				format.Cell(agentStr),
				statusCell,
				format.ColorCell(tmuxSession, format.Dim),
			)
		}
	}
	table.Print()

	return nil
}

func (c *CLI) removeRepo(args []string) error {
	var repoName string
	if len(args) > 0 {
		repoName = args[0]
	} else {
		// Interactive selection - list repos
		client := socket.NewClient(c.paths.DaemonSock)
		resp, err := client.Send(socket.Request{
			Command: "list_repos",
			Args: map[string]interface{}{
				"rich": true,
			},
		})
		if err != nil {
			return errors.DaemonCommunicationFailed("listing repositories", err)
		}
		if !resp.Success {
			return errors.Wrap(errors.CategoryRuntime, "failed to list repos", fmt.Errorf("%s", resp.Error))
		}

		repos, _ := resp.Data.([]interface{})
		items := reposToSelectableItems(repos)
		if len(items) == 0 {
			return errors.NoRepositoriesFound()
		}
		selected, err := SelectFromList("Select repository to remove:", items)
		if err != nil {
			return err
		}
		if selected == "" {
			fmt.Println("Cancelled")
			return nil
		}
		repoName = selected
	}

	fmt.Printf("Removing repository '%s'...\n", repoName)

	// Get repo info from daemon
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("getting repo info", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to get repo info", fmt.Errorf("%s", resp.Error))
	}

	// Get list of agents
	agents, _ := resp.Data.([]interface{})

	// Check for any workers with uncommitted changes
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			agentType, _ := agentMap["type"].(string)
			if agentType == "worker" || agentType == "review" {
				wtPath, _ := agentMap["worktree_path"].(string)
				if wtPath != "" {
					hasUncommitted, err := worktree.HasUncommittedChanges(wtPath)
					if err == nil && hasUncommitted {
						agentName, _ := agentMap["name"].(string)
						fmt.Printf("\nWarning: Agent '%s' has uncommitted changes!\n", agentName)
						fmt.Println("Files may be lost if you continue.")
						fmt.Print("Continue with removal? [y/N]: ")

						var response string
						fmt.Scanln(&response)
						if response != "y" && response != "Y" {
							fmt.Println("Removal cancelled")
							return nil
						}
						break // Only ask once
					}
				}
			}
		}
	}

	// Kill tmux session
	tmuxSession := sanitizeTmuxSessionName(repoName)
	tmuxClient := tmux.NewClient()
	if exists, err := tmuxClient.HasSession(context.Background(), tmuxSession); err == nil && exists {
		fmt.Printf("Killing tmux session: %s\n", tmuxSession)
		if err := tmuxClient.KillSession(context.Background(), tmuxSession); err != nil {
			fmt.Printf("Warning: failed to kill tmux session: %v\n", err)
		}
	}

	// Remove worktrees for all agents
	repoPath := c.paths.RepoDir(repoName)
	wt := worktree.NewManager(repoPath)
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			wtPath, _ := agentMap["worktree_path"].(string)
			agentName, _ := agentMap["name"].(string)
			if wtPath != "" && wtPath != repoPath {
				fmt.Printf("Removing worktree for '%s': %s\n", agentName, wtPath)
				if err := wt.Remove(wtPath, true); err != nil {
					fmt.Printf("Warning: failed to remove worktree: %v\n", err)
				}
			}
		}
	}

	// Remove the worktrees directory for this repo
	wtDir := c.paths.WorktreeDir(repoName)
	if _, err := os.Stat(wtDir); err == nil {
		fmt.Printf("Removing worktrees directory: %s\n", wtDir)
		if err := os.RemoveAll(wtDir); err != nil {
			fmt.Printf("Warning: failed to remove worktrees directory: %v\n", err)
		}
	}

	// Clean up messages directory for this repo
	msgDir := filepath.Join(c.paths.MessagesDir, repoName)
	if _, err := os.Stat(msgDir); err == nil {
		fmt.Printf("Removing messages directory: %s\n", msgDir)
		if err := os.RemoveAll(msgDir); err != nil {
			fmt.Printf("Warning: failed to remove messages directory: %v\n", err)
		}
	}

	// Unregister from daemon
	resp, err = client.Send(socket.Request{
		Command: "remove_repo",
		Args: map[string]interface{}{
			"name": repoName,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("removing repo", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to remove repo from state", fmt.Errorf("%s", resp.Error))
	}

	fmt.Println("✓ Repository removed successfully")
	fmt.Printf("\nNote: The cloned repository at '%s' was NOT deleted.\n", repoPath)
	fmt.Println("Delete it manually if you no longer need it.")
	return nil
}

func (c *CLI) setCurrentRepo(args []string) error {
	if len(args) < 1 {
		return errors.InvalidUsage("usage: multiclaude repo use <name>")
	}

	repoName := args[0]

	_, err := c.sendDaemonRequest("set_current_repo", map[string]interface{}{
		"name": repoName,
	})
	if err != nil {
		return err
	}

	fmt.Printf("Current repository set to: %s\n", repoName)
	return nil
}

func (c *CLI) getCurrentRepo(args []string) error {
	resp, err := c.sendDaemonRequest("get_current_repo", nil)
	if err != nil {
		return err
	}

	currentRepo, _ := resp.Data.(string)
	if currentRepo == "" {
		fmt.Println("No current repository set")
		fmt.Println("\nUse 'multiclaude repo use <name>' to set one")
	} else {
		fmt.Printf("Current repository: %s\n", currentRepo)
	}
	return nil
}

func (c *CLI) clearCurrentRepo(args []string) error {
	_, err := c.sendDaemonRequest("clear_current_repo", nil)
	if err != nil {
		return err
	}

	fmt.Println("Current repository cleared")
	return nil
}

func (c *CLI) configRepo(args []string) error {
	flags, posArgs := ParseFlags(args)

	// Determine repository
	var repoName string
	if len(posArgs) >= 1 {
		repoName = posArgs[0]
	} else {
		// Try to infer from current directory
		cwd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("failed to get current directory: %w", err)
		}

		// Check if we're in a tracked repo
		repos := c.getReposList()
		for _, repo := range repos {
			repoPath := c.paths.RepoDir(repo)
			if strings.HasPrefix(cwd, repoPath) {
				repoName = repo
				break
			}
		}

		if repoName == "" {
			// If only one repo exists, use it
			if len(repos) == 1 {
				repoName = repos[0]
			} else {
				return fmt.Errorf("please specify a repository name or run from within a tracked repository")
			}
		}
	}

	// Check if any config flags are provided
	hasMqEnabled := flags["mq-enabled"] != ""
	hasMqTrack := flags["mq-track"] != ""
	hasPsEnabled := flags["ps-enabled"] != ""
	hasPsTrack := flags["ps-track"] != ""

	if !hasMqEnabled && !hasMqTrack && !hasPsEnabled && !hasPsTrack {
		// No flags - just show current config
		return c.showRepoConfig(repoName)
	}

	// Apply config changes
	return c.updateRepoConfig(repoName, flags)
}

func (c *CLI) showRepoConfig(repoName string) error {
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "get_repo_config",
		Args: map[string]interface{}{
			"name": repoName,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to get repo config: %w (is daemon running?)", err)
	}

	if !resp.Success {
		return fmt.Errorf("failed to get repo config: %s", resp.Error)
	}

	// Parse response
	configMap, ok := resp.Data.(map[string]interface{})
	if !ok {
		return fmt.Errorf("unexpected response format")
	}

	fmt.Printf("Configuration for repository: %s\n\n", repoName)

	// Show fork info if this is a fork
	isFork, _ := configMap["is_fork"].(bool)
	if isFork {
		upstreamOwner, _ := configMap["upstream_owner"].(string)
		upstreamRepo, _ := configMap["upstream_repo"].(string)
		fmt.Printf("Fork Mode: Yes (fork of %s/%s)\n\n", upstreamOwner, upstreamRepo)
	} else {
		fmt.Println("Fork Mode: No (upstream/direct repository)")
		fmt.Println()
	}

	// Show merge queue config
	fmt.Println("Merge Queue:")
	mqEnabled := true
	if enabled, ok := configMap["mq_enabled"].(bool); ok {
		mqEnabled = enabled
	}
	mqTrackMode := "all"
	if trackMode, ok := configMap["mq_track_mode"].(string); ok {
		mqTrackMode = trackMode
	}
	if mqEnabled {
		fmt.Printf("  Enabled: true\n")
		fmt.Printf("  Track mode: %s\n", mqTrackMode)
	} else {
		fmt.Printf("  Enabled: false\n")
	}

	// Show PR shepherd config
	fmt.Println("\nPR Shepherd:")
	psEnabled := true
	if enabled, ok := configMap["ps_enabled"].(bool); ok {
		psEnabled = enabled
	}
	psTrackMode := "author"
	if trackMode, ok := configMap["ps_track_mode"].(string); ok {
		psTrackMode = trackMode
	}
	if psEnabled {
		fmt.Printf("  Enabled: true\n")
		fmt.Printf("  Track mode: %s\n", psTrackMode)
	} else {
		fmt.Printf("  Enabled: false\n")
	}

	fmt.Println("\nTo modify:")
	fmt.Printf("  multiclaude config %s --mq-enabled=true|false\n", repoName)
	fmt.Printf("  multiclaude config %s --mq-track=all|author|assigned\n", repoName)
	fmt.Printf("  multiclaude config %s --ps-enabled=true|false\n", repoName)
	fmt.Printf("  multiclaude config %s --ps-track=all|author|assigned\n", repoName)

	return nil
}

func (c *CLI) updateRepoConfig(repoName string, flags map[string]string) error {
	// Build update args
	updateArgs := map[string]interface{}{
		"name": repoName,
	}

	// Parse and validate flags
	if mqEnabled, ok := flags["mq-enabled"]; ok {
		switch mqEnabled {
		case "true":
			updateArgs["mq_enabled"] = true
		case "false":
			updateArgs["mq_enabled"] = false
		default:
			return fmt.Errorf("invalid --mq-enabled value: %s (must be 'true' or 'false')", mqEnabled)
		}
	}

	if mqTrack, ok := flags["mq-track"]; ok {
		switch mqTrack {
		case "all", "author", "assigned":
			updateArgs["mq_track_mode"] = mqTrack
		default:
			return fmt.Errorf("invalid --mq-track value: %s (must be 'all', 'author', or 'assigned')", mqTrack)
		}
	}

	// Parse PR shepherd flags
	if psEnabled, ok := flags["ps-enabled"]; ok {
		switch psEnabled {
		case "true":
			updateArgs["ps_enabled"] = true
		case "false":
			updateArgs["ps_enabled"] = false
		default:
			return fmt.Errorf("invalid --ps-enabled value: %s (must be 'true' or 'false')", psEnabled)
		}
	}

	if psTrack, ok := flags["ps-track"]; ok {
		switch psTrack {
		case "all", "author", "assigned":
			updateArgs["ps_track_mode"] = psTrack
		default:
			return fmt.Errorf("invalid --ps-track value: %s (must be 'all', 'author', or 'assigned')", psTrack)
		}
	}

	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "update_repo_config",
		Args:    updateArgs,
	})
	if err != nil {
		return fmt.Errorf("failed to update repo config: %w (is daemon running?)", err)
	}

	if !resp.Success {
		return fmt.Errorf("failed to update repo config: %s", resp.Error)
	}

	fmt.Printf("Configuration updated for repository: %s\n", repoName)

	// Show the updated config
	return c.showRepoConfig(repoName)
}

func (c *CLI) createWorker(args []string) error {
	flags, posArgs := ParseFlags(args)

	// Get task description
	task := strings.Join(posArgs, " ")
	if task == "" {
		return errors.InvalidUsage("usage: multiclaude worker create <task description>")
	}

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Generate worker name (Docker-style)
	workerName := names.Generate()
	if name, ok := flags["name"]; ok {
		workerName = name
	}

	// Check for --push-to flag (for iterating on existing PRs)
	pushTo, hasPushTo := flags["push-to"]
	if hasPushTo {
		// --push-to requires --branch to specify the remote branch to start from
		if _, hasBranch := flags["branch"]; !hasBranch {
			return errors.InvalidUsage("--push-to requires --branch to specify the remote branch (e.g., --branch origin/work/jolly-hawk --push-to work/jolly-hawk)")
		}
	}

	// Get repository path
	repoPath := c.paths.RepoDir(repoName)

	// Fetch latest from origin before creating worktree
	// This ensures workers start from the latest code, not stale local refs
	// Note: We use "git fetch origin main" (not "main:main") because the latter
	// fails when main is checked out in the bare repo with:
	// "fatal: refusing to fetch into branch 'refs/heads/main' checked out at ..."
	fmt.Println("Fetching latest from origin...")
	fetchCmd := exec.Command("git", "fetch", "origin")
	fetchCmd.Dir = repoPath
	if err := fetchCmd.Run(); err != nil {
		// Best effort - don't fail if offline or fetch fails
		fmt.Printf("Warning: failed to fetch from origin: %v (continuing with local refs)\n", err)
	}

	// Determine branch to start from
	// Prefer origin/main if it exists (updated by fetch), otherwise fall back to HEAD
	// This handles both normal repos and test repos without remotes
	startBranch := "HEAD"
	checkOriginCmd := exec.Command("git", "rev-parse", "--verify", "origin/main")
	checkOriginCmd.Dir = repoPath
	if err := checkOriginCmd.Run(); err == nil {
		startBranch = "origin/main"
	}
	if branch, ok := flags["branch"]; ok {
		startBranch = branch
		if hasPushTo {
			fmt.Printf("Creating worker '%s' in repo '%s' to iterate on branch '%s'\n", workerName, repoName, pushTo)
		} else {
			fmt.Printf("Creating worker '%s' in repo '%s' from branch '%s'\n", workerName, repoName, branch)
		}
	} else {
		fmt.Printf("Creating worker '%s' in repo '%s'\n", workerName, repoName)
	}
	fmt.Printf("Task: %s\n", task)

	// Create worktree
	wt := worktree.NewManager(repoPath)
	wtPath := c.paths.AgentWorktree(repoName, workerName)

	var branchName string
	if hasPushTo {
		// When --push-to is specified, we're iterating on an existing PR branch
		// Create a worktree that checks out the remote branch into a local branch
		branchName = pushTo
		fmt.Printf("Creating worktree at: %s (checking out %s)\n", wtPath, startBranch)

		// Check if the local branch already exists
		branchExists, err := wt.BranchExists(branchName)
		if err != nil {
			return errors.WorktreeCreationFailed(err)
		}

		if branchExists {
			// Branch exists locally, check it out
			if err := wt.Create(wtPath, branchName); err != nil {
				return errors.WorktreeCreationFailed(err)
			}
		} else {
			// Branch doesn't exist, create it from the start point
			if err := wt.CreateNewBranch(wtPath, branchName, startBranch); err != nil {
				return errors.WorktreeCreationFailed(err)
			}
		}
	} else {
		// Normal case: create a new branch for this worker
		branchName = fmt.Sprintf("work/%s", workerName)
		fmt.Printf("Creating worktree at: %s\n", wtPath)
		if err := wt.CreateNewBranch(wtPath, branchName, startBranch); err != nil {
			return errors.WorktreeCreationFailed(err)
		}
	}

	// Get repository info to determine tmux session
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("getting repo info", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to get repo info", fmt.Errorf("%s", resp.Error))
	}

	// Get tmux session name (it's mc-<reponame>)
	tmuxSession := sanitizeTmuxSessionName(repoName)

	// Ensure tmux session exists before creating window
	// This handles cases where the session was killed or daemon didn't restore it
	tmuxClient := tmux.NewClient()
	hasSession, err := tmuxClient.HasSession(context.Background(), tmuxSession)
	if err != nil {
		return errors.TmuxOperationFailed("check session", err)
	}
	if !hasSession {
		fmt.Printf("Tmux session '%s' not found, creating it...\n", tmuxSession)
		if err := tmuxClient.CreateSession(context.Background(), tmuxSession, true); err != nil {
			return errors.TmuxOperationFailed("create session", err)
		}
	}

	// Create tmux window for worker (detached so it doesn't switch focus)
	fmt.Printf("Creating tmux window: %s\n", workerName)
	cmd := exec.Command("tmux", "new-window", "-d", "-t", tmuxSession, "-n", workerName, "-c", wtPath)
	if err := cmd.Run(); err != nil {
		return errors.TmuxOperationFailed("create window", err)
	}

	// Generate session ID for worker
	workerSessionID, err := claude.GenerateSessionID()
	if err != nil {
		return fmt.Errorf("failed to generate worker session ID: %w", err)
	}

	// Get fork config from daemon to include in worker prompt
	var forkConfig state.ForkConfig
	configResp, err := client.Send(socket.Request{
		Command: "get_repo_config",
		Args: map[string]interface{}{
			"name": repoName,
		},
	})
	if err == nil && configResp.Success {
		if configMap, ok := configResp.Data.(map[string]interface{}); ok {
			if isFork, ok := configMap["is_fork"].(bool); ok && isFork {
				forkConfig.IsFork = true
				forkConfig.UpstreamURL, _ = configMap["upstream_url"].(string)
				forkConfig.UpstreamOwner, _ = configMap["upstream_owner"].(string)
				forkConfig.UpstreamRepo, _ = configMap["upstream_repo"].(string)
			}
		}
	}

	// Write prompt file for worker (with push-to config and fork config if applicable)
	workerConfig := WorkerConfig{
		ForkConfig: forkConfig,
	}
	if hasPushTo {
		workerConfig.PushToBranch = pushTo
	}
	workerPromptFile, err := c.writeWorkerPromptFile(repoPath, workerName, workerConfig)
	if err != nil {
		return fmt.Errorf("failed to write worker prompt: %w", err)
	}

	// Copy hooks configuration if it exists
	if err := hooks.CopyConfig(repoPath, wtPath); err != nil {
		fmt.Printf("Warning: failed to copy hooks config: %v\n", err)
	}

	// Start Claude in worker window with initial task (skip in test mode)
	var workerPID int
	if os.Getenv("MULTICLAUDE_TEST_MODE") != "1" {
		// Resolve claude binary
		claudeBinary, err := c.getClaudeBinary()
		if err != nil {
			return fmt.Errorf("failed to resolve claude binary: %w", err)
		}

		fmt.Println("Starting Claude Code in worker window...")
		initialMessage := fmt.Sprintf("Task: %s", task)
		pid, err := c.startClaudeInTmux(claudeBinary, tmuxSession, workerName, wtPath, workerSessionID, workerPromptFile, repoName, initialMessage)
		if err != nil {
			return fmt.Errorf("failed to start worker Claude: %w", err)
		}
		workerPID = pid

		// Set up output capture for worker
		if err := c.setupOutputCapture(tmuxSession, workerName, repoName, workerName, "worker"); err != nil {
			fmt.Printf("Warning: failed to setup output capture for worker: %v\n", err)
		}
	}

	// Register worker with daemon
	resp, err = client.Send(socket.Request{
		Command: "add_agent",
		Args: map[string]interface{}{
			"repo":          repoName,
			"agent":         workerName,
			"type":          "worker",
			"worktree_path": wtPath,
			"tmux_window":   workerName,
			"task":          task,
			"session_id":    workerSessionID,
			"pid":           workerPID,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to register worker: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to register worker: %s", resp.Error)
	}

	fmt.Println()
	fmt.Println("✓ Worker created successfully!")
	fmt.Printf("  Name: %s\n", workerName)
	fmt.Printf("  Branch: %s\n", branchName)
	fmt.Printf("  Worktree: %s\n", wtPath)
	if hasPushTo {
		fmt.Printf("  Mode: Push to existing PR branch (%s)\n", pushTo)
	}
	fmt.Printf("\nAttach to worker: tmux select-window -t %s:%s\n", tmuxSession, workerName)
	fmt.Printf("Or use: multiclaude attach %s\n", workerName)

	return nil
}

func (c *CLI) listWorkers(args []string) error {
	flags, _ := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	resp, err := c.sendDaemonRequest("list_agents", map[string]interface{}{
		"repo": repoName,
		"rich": true,
	})
	if err != nil {
		return err
	}

	agents, ok := resp.Data.([]interface{})
	if !ok {
		return errors.New(errors.CategoryRuntime, "unexpected response format from daemon")
	}

	// Filter for workers and workspace
	workers := []map[string]interface{}{}
	var workspace map[string]interface{}
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			agentType, _ := agentMap["type"].(string)
			if agentType == "worker" {
				workers = append(workers, agentMap)
			} else if agentType == "workspace" {
				workspace = agentMap
			}
		}
	}

	// Show workspace first if it exists
	if workspace != nil {
		format.Header("Workspace in '%s':", repoName)
		status, _ := workspace["status"].(string)
		statusCell := formatAgentStatusCell(status)
		fmt.Printf("  workspace ")
		fmt.Print(statusCell.Text)
		fmt.Println()
		fmt.Println()
	}

	if len(workers) == 0 {
		fmt.Printf("No workers in repository '%s'\n", repoName)
		format.Dimmed("\nCreate a worker with: multiclaude worker create <task>")
		return nil
	}

	format.Header("Workers in '%s' (%d):", repoName, len(workers))
	fmt.Println()

	table := format.NewColoredTable("NAME", "STATUS", "BRANCH", "MSGS", "TASK")
	for _, worker := range workers {
		name, _ := worker["name"].(string)
		task, _ := worker["task"].(string)
		status, _ := worker["status"].(string)
		branch, _ := worker["branch"].(string)
		msgsTotal := 0
		if v, ok := worker["messages_total"].(float64); ok {
			msgsTotal = int(v)
		}
		msgsPending := 0
		if v, ok := worker["messages_pending"].(float64); ok {
			msgsPending = int(v)
		}

		// Format status with color
		statusCell := formatAgentStatusCell(status)

		// Format branch
		branchCell := format.ColorCell(branch, format.Cyan)
		if branch == "" {
			branchCell = format.ColorCell("-", format.Dim)
		}

		// Format message count
		msgStr := format.MessageBadge(msgsPending, msgsTotal)

		// Truncate task
		truncTask := format.Truncate(task, 40)

		table.AddRow(
			format.Cell(name),
			statusCell,
			branchCell,
			format.Cell(msgStr),
			format.Cell(truncTask),
		)
	}
	table.Print()

	return nil
}

// listAgentDefinitions lists available agent definitions for a repository
func (c *CLI) listAgentDefinitions(args []string) error {
	flags, _ := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Get paths to agent definition directories
	localAgentsDir := c.paths.RepoAgentsDir(repoName)
	repoPath := c.paths.RepoDir(repoName)

	// Read and merge agent definitions
	reader := agents.NewReader(localAgentsDir, repoPath)
	defs, err := reader.ReadAllDefinitions()
	if err != nil {
		return errors.Wrap(errors.CategoryRuntime, "failed to read agent definitions", err)
	}

	if len(defs) == 0 {
		fmt.Println("No agent definitions found.")
		fmt.Printf("\nAgent definitions are stored in:\n")
		fmt.Printf("  Local: %s\n", localAgentsDir)
		fmt.Printf("  Repo:  %s/.multiclaude/agents/\n", repoPath)
		return nil
	}

	fmt.Printf("Agent definitions for %s:\n\n", repoName)

	// Create colored table
	table := format.NewColoredTable("Name", "Source", "Title", "Description")

	for _, def := range defs {
		source := string(def.Source)
		title := def.ParseTitle()
		desc := def.ParseDescription()

		// Truncate description if too long
		desc = format.Truncate(desc, 50)

		// Color the source based on type
		sourceCell := format.Cell(source)
		if def.Source == agents.SourceRepo {
			sourceCell = format.ColorCell(source, format.Green)
		}

		table.AddRow(
			format.Cell(def.Name),
			sourceCell,
			format.Cell(title),
			format.Cell(desc),
		)
	}

	table.Print()

	return nil
}

// spawnAgentFromFile spawns an agent using a prompt file and the daemon's spawn_agent handler.
// This is the CLI command that connects supervisor orchestration with daemon agent spawning.
func (c *CLI) spawnAgentFromFile(args []string) error {
	flags, _ := ParseFlags(args)

	// Get required parameters
	agentName, ok := flags["name"]
	if !ok || agentName == "" {
		return errors.InvalidUsage("--name is required")
	}

	agentClass, ok := flags["class"]
	if !ok || agentClass == "" {
		return errors.InvalidUsage("--class is required (persistent or ephemeral)")
	}
	if agentClass != "persistent" && agentClass != "ephemeral" {
		return errors.InvalidUsage("--class must be 'persistent' or 'ephemeral'")
	}

	promptFile, ok := flags["prompt-file"]
	if !ok || promptFile == "" {
		return errors.InvalidUsage("--prompt-file is required")
	}

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Read prompt from file
	promptContent, err := os.ReadFile(promptFile)
	if err != nil {
		return errors.Wrap(errors.CategoryRuntime, "failed to read prompt file", err)
	}

	// Get optional task parameter
	task := flags["task"]

	// Send spawn_agent request to daemon
	client := socket.NewClient(c.paths.DaemonSock)
	reqArgs := map[string]interface{}{
		"repo":   repoName,
		"name":   agentName,
		"class":  agentClass,
		"prompt": string(promptContent),
	}
	if task != "" {
		reqArgs["task"] = task
	}

	resp, err := client.Send(socket.Request{
		Command: "spawn_agent",
		Args:    reqArgs,
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("spawning agent", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to spawn agent", fmt.Errorf("%s", resp.Error))
	}

	fmt.Printf("Agent '%s' spawned successfully (class: %s)\n", agentName, agentClass)
	return nil
}

// resetAgentDefinitions deletes the local agent definitions and re-copies from templates.
func (c *CLI) resetAgentDefinitions(args []string) error {
	flags, _ := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Get agents directory path
	agentsDir := c.paths.RepoAgentsDir(repoName)

	// Check if directory exists
	if _, err := os.Stat(agentsDir); os.IsNotExist(err) {
		fmt.Printf("No agent definitions found at %s\n", agentsDir)
		fmt.Println("Creating new definitions from templates...")
	} else {
		// Remove existing directory
		fmt.Printf("Removing existing agent definitions at %s...\n", agentsDir)
		if err := os.RemoveAll(agentsDir); err != nil {
			return errors.Wrap(errors.CategoryRuntime, "failed to remove agent definitions", err)
		}
	}

	// Copy templates
	if err := templates.CopyAgentTemplates(agentsDir); err != nil {
		return errors.Wrap(errors.CategoryRuntime, "failed to copy agent templates", err)
	}

	// List what was copied
	entries, err := os.ReadDir(agentsDir)
	if err != nil {
		return errors.Wrap(errors.CategoryRuntime, "failed to list agent definitions", err)
	}

	fmt.Printf("Reset complete. Agent definitions in %s:\n", agentsDir)
	for _, entry := range entries {
		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".md" {
			fmt.Printf("  - %s\n", entry.Name())
		}
	}

	return nil
}

func (c *CLI) showHistory(args []string) error {
	flags, _ := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Get limit from flags (default 10)
	limit := 10
	if n, ok := flags["n"]; ok {
		if v, err := strconv.Atoi(n); err == nil && v > 0 {
			limit = v
		}
	}

	// Get filter options
	statusFilter := flags["status"] // Filter by status (merged, open, closed, failed, no-pr)
	searchQuery := flags["search"]  // Search in task descriptions
	showFull := flags["full"] == "true"

	// Validate status filter if provided
	validStatuses := map[string]bool{
		"merged": true, "open": true, "closed": true, "failed": true, "no-pr": true,
	}
	if statusFilter != "" && !validStatuses[statusFilter] {
		return errors.InvalidUsage(fmt.Sprintf("invalid status filter: %s (valid values: merged, open, closed, failed, no-pr)", statusFilter))
	}

	// When filtering, fetch more history to ensure we get enough results
	fetchLimit := limit
	if statusFilter != "" || searchQuery != "" {
		fetchLimit = limit * 10 // Fetch more to allow for filtering
		if fetchLimit > 100 {
			fetchLimit = 100
		}
	}

	// Get task history from daemon
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "task_history",
		Args: map[string]interface{}{
			"repo":  repoName,
			"limit": fetchLimit,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("getting task history", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to get task history", fmt.Errorf("%s", resp.Error))
	}

	history, ok := resp.Data.([]interface{})
	if !ok || len(history) == 0 {
		fmt.Printf("No task history for repository '%s'\n", repoName)
		format.Dimmed("\nCreate workers with: multiclaude worker create <task>")
		return nil
	}

	// Query GitHub for PR status for each task with a branch
	repoPath := c.paths.RepoDir(repoName)

	// Build filtered header
	headerParts := []string{fmt.Sprintf("Task History for '%s'", repoName)}
	if statusFilter != "" {
		headerParts = append(headerParts, fmt.Sprintf("status=%s", statusFilter))
	}
	if searchQuery != "" {
		headerParts = append(headerParts, fmt.Sprintf("search=%q", searchQuery))
	}
	format.Header("%s:", strings.Join(headerParts, ", "))
	fmt.Println()

	// First pass: collect entries with details to show after table
	type entryDetails struct {
		name          string
		summary       string
		failureReason string
	}
	var detailsToShow []entryDetails

	table := format.NewColoredTable("NAME", "STATUS", "PR", "COMPLETED", "TASK")
	displayedCount := 0
	for _, item := range history {
		// Stop once we've displayed enough
		if displayedCount >= limit {
			break
		}

		entry, ok := item.(map[string]interface{})
		if !ok {
			continue
		}

		name, _ := entry["name"].(string)
		task, _ := entry["task"].(string)
		branch, _ := entry["branch"].(string)
		prURL, _ := entry["pr_url"].(string)
		completedAt, _ := entry["completed_at"].(string)
		summary, _ := entry["summary"].(string)
		failureReason, _ := entry["failure_reason"].(string)
		storedStatus, _ := entry["status"].(string)

		// Try to get PR status from GitHub if we have a branch
		prStatus, prLink := c.getPRStatusForBranch(repoPath, branch, prURL)

		// Use stored status if it indicates failure
		if storedStatus == "failed" {
			prStatus = "failed"
		}

		// Apply status filter
		if statusFilter != "" {
			effectiveStatus := prStatus
			if effectiveStatus == "" {
				effectiveStatus = "no-pr"
			}
			if effectiveStatus != statusFilter {
				continue
			}
		}

		// Apply search filter (case-insensitive)
		if searchQuery != "" {
			lowerQuery := strings.ToLower(searchQuery)
			lowerTask := strings.ToLower(task)
			lowerName := strings.ToLower(name)
			if !strings.Contains(lowerTask, lowerQuery) && !strings.Contains(lowerName, lowerQuery) {
				continue
			}
		}

		displayedCount++

		// Collect entries with summary or failure for detailed display
		if summary != "" || failureReason != "" {
			detailsToShow = append(detailsToShow, entryDetails{
				name:          name,
				summary:       summary,
				failureReason: failureReason,
			})
		}

		// Format status with color
		var statusCell format.ColoredCell
		switch prStatus {
		case "merged":
			statusCell = format.ColorCell("merged", format.Green)
		case "open":
			statusCell = format.ColorCell("open", format.Yellow)
		case "closed":
			statusCell = format.ColorCell("closed", format.Red)
		case "failed":
			statusCell = format.ColorCell("failed", format.Red)
		default:
			statusCell = format.ColorCell("no-pr", format.Dim)
		}

		// Format PR link
		prCell := format.ColorCell("-", format.Dim)
		if prLink != "" {
			// Extract just the PR number for display
			prCell = format.ColorCell(prLink, format.Cyan)
		}

		// Format completed time
		completedCell := format.ColorCell("-", format.Dim)
		if completedAt != "" {
			if t, err := time.Parse(time.RFC3339, completedAt); err == nil {
				completedCell = format.Cell(format.TimeAgo(t))
			}
		}

		// Format task - show full or truncate
		displayTask := task
		if !showFull {
			displayTask = format.Truncate(task, 50)
		}

		table.AddRow(
			format.Cell(name),
			statusCell,
			prCell,
			completedCell,
			format.Cell(displayTask),
		)
	}

	// Show message if no results after filtering
	if displayedCount == 0 {
		if statusFilter != "" || searchQuery != "" {
			fmt.Printf("No tasks match the filter criteria\n")
		}
		return nil
	}

	table.Print()

	// Print detailed summary/failure section if any entries have them
	if len(detailsToShow) > 0 {
		fmt.Println()
		format.Header("Details:")
		for _, d := range detailsToShow {
			format.Bold.Printf("\n%s:\n", d.name)
			if d.summary != "" {
				format.Dimmed("  Summary: %s", d.summary)
			}
			if d.failureReason != "" {
				format.Red.Printf("  Failure: %s\n", d.failureReason)
			}
		}
	}

	return nil
}

// getPRStatusForBranch queries GitHub for the PR status of a branch
func (c *CLI) getPRStatusForBranch(repoPath, branch, existingPRURL string) (status, prLink string) {
	// If we already have a PR URL, just return it formatted
	if existingPRURL != "" {
		// Extract PR number from URL for shorter display
		parts := strings.Split(existingPRURL, "/")
		if len(parts) > 0 {
			prNum := parts[len(parts)-1]
			return "unknown", "#" + prNum
		}
		return "unknown", existingPRURL
	}

	// If no branch, nothing to query
	if branch == "" {
		return "no-pr", ""
	}

	// Query GitHub for PR associated with this branch using gh CLI
	cmd := exec.Command("gh", "pr", "list", "--head", branch, "--state", "all", "--json", "number,state,url", "--limit", "1")
	cmd.Dir = repoPath
	output, err := cmd.Output()
	if err != nil {
		return "no-pr", ""
	}

	// Parse JSON output
	var prs []struct {
		Number int    `json:"number"`
		State  string `json:"state"`
		URL    string `json:"url"`
	}
	if err := json.Unmarshal(output, &prs); err != nil || len(prs) == 0 {
		return "no-pr", ""
	}

	pr := prs[0]
	prLink = fmt.Sprintf("#%d", pr.Number)

	switch strings.ToLower(pr.State) {
	case "merged":
		return "merged", prLink
	case "open":
		return "open", prLink
	case "closed":
		return "closed", prLink
	default:
		return "unknown", prLink
	}
}

func (c *CLI) removeWorker(args []string) error {
	flags, remainingArgs := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Get worker info
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("getting worker info", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to get worker info", fmt.Errorf("%s", resp.Error))
	}

	agents, _ := resp.Data.([]interface{})

	// Determine worker name - from args or interactive selection
	var workerName string
	if len(remainingArgs) > 0 {
		workerName = remainingArgs[0]
	} else {
		// Interactive selection
		items := agentsToSelectableItems(agents, []string{"worker"})
		if len(items) == 0 {
			return errors.NoWorkersFound(repoName)
		}
		selected, err := SelectFromList("Select worker to remove:", items)
		if err != nil {
			return err
		}
		if selected == "" {
			fmt.Println("Cancelled")
			return nil
		}
		workerName = selected
	}

	fmt.Printf("Removing worker '%s' from repo '%s'\n", workerName, repoName)

	// Find worker
	var workerInfo map[string]interface{}
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			if name, _ := agentMap["name"].(string); name == workerName {
				workerInfo = agentMap
				break
			}
		}
	}

	if workerInfo == nil {
		return errors.AgentNotFound("worker", workerName, repoName)
	}

	// Get worktree path
	wtPath := workerInfo["worktree_path"].(string)

	// Check for uncommitted changes
	hasUncommitted, err := worktree.HasUncommittedChanges(wtPath)
	if err != nil {
		fmt.Printf("Warning: failed to check for uncommitted changes: %v\n", err)
	} else if hasUncommitted {
		fmt.Println("\nWarning: Worker has uncommitted changes!")
		fmt.Println("Files may be lost if you continue with cleanup.")
		fmt.Print("Continue with cleanup? [y/N]: ")

		var response string
		fmt.Scanln(&response)
		if response != "y" && response != "Y" {
			fmt.Println("Cleanup cancelled")
			return nil
		}
	}

	// Check for unpushed commits
	if err := checkUnpushedCommits(wtPath, "Worker", "cleanup"); err != nil {
		return nil
	}

	// Kill tmux window
	tmuxSession := sanitizeTmuxSessionName(repoName)
	tmuxWindow := workerInfo["tmux_window"].(string)
	fmt.Printf("Killing tmux window: %s\n", tmuxWindow)
	cmd := exec.Command("tmux", "kill-window", "-t", fmt.Sprintf("%s:%s", tmuxSession, tmuxWindow))
	if err := cmd.Run(); err != nil {
		fmt.Printf("Warning: failed to kill tmux window: %v\n", err)
	}

	// Remove worktree
	repoPath := c.paths.RepoDir(repoName)
	wt := worktree.NewManager(repoPath)

	fmt.Printf("Removing worktree: %s\n", wtPath)
	if err := wt.Remove(wtPath, false); err != nil {
		fmt.Printf("Warning: failed to remove worktree: %v\n", err)
	}

	// Unregister from daemon
	resp, err = client.Send(socket.Request{
		Command: "remove_agent",
		Args: map[string]interface{}{
			"repo":  repoName,
			"agent": workerName,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to unregister worker: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to unregister worker: %s", resp.Error)
	}

	fmt.Println("✓ Worker removed successfully")
	return nil
}

// Workspace command implementations

// workspaceDefault handles `multiclaude workspace` with no subcommand or `multiclaude workspace <name>`
func (c *CLI) workspaceDefault(args []string) error {
	// If no args, list workspaces
	if len(args) == 0 {
		return c.listWorkspaces(args)
	}

	// If first arg looks like a workspace name (not a flag), treat as connect
	if !strings.HasPrefix(args[0], "-") {
		return c.connectWorkspace(args)
	}

	// Otherwise list with flags
	return c.listWorkspaces(args)
}

// addWorkspace creates a new workspace
func (c *CLI) addWorkspace(args []string) error {
	flags, posArgs := ParseFlags(args)

	if len(posArgs) < 1 {
		return errors.InvalidUsage("usage: multiclaude workspace add <name> [--branch <branch>]")
	}

	workspaceName := posArgs[0]

	// Validate workspace name (same restrictions as branch names)
	if err := validateWorkspaceName(workspaceName); err != nil {
		return err
	}

	// Determine repository using standard resolution chain
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return err
	}

	// Determine branch to start from
	startBranch := "HEAD" // Default to current branch/HEAD
	if branch, ok := flags["branch"]; ok {
		startBranch = branch
		fmt.Printf("Creating workspace '%s' in repo '%s' from branch '%s'\n", workspaceName, repoName, branch)
	} else {
		fmt.Printf("Creating workspace '%s' in repo '%s'\n", workspaceName, repoName)
	}

	// Check if workspace already exists
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("checking existing workspaces", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to check existing workspaces", fmt.Errorf("%s", resp.Error))
	}

	agents, _ := resp.Data.([]interface{})
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			agentType, _ := agentMap["type"].(string)
			name, _ := agentMap["name"].(string)
			if agentType == "workspace" && name == workspaceName {
				return fmt.Errorf("workspace '%s' already exists in repo '%s'", workspaceName, repoName)
			}
		}
	}

	// Get repository path
	repoPath := c.paths.RepoDir(repoName)

	// Create worktree
	wt := worktree.NewManager(repoPath)
	wtPath := c.paths.AgentWorktree(repoName, workspaceName)
	branchName := fmt.Sprintf("workspace/%s", workspaceName)

	fmt.Printf("Creating worktree at: %s\n", wtPath)
	if err := wt.CreateNewBranch(wtPath, branchName, startBranch); err != nil {
		return errors.WorktreeCreationFailed(err)
	}

	// Get tmux session name
	tmuxSession := sanitizeTmuxSessionName(repoName)

	// Create tmux window for workspace (detached so it doesn't switch focus)
	fmt.Printf("Creating tmux window: %s\n", workspaceName)
	cmd := exec.Command("tmux", "new-window", "-d", "-t", tmuxSession, "-n", workspaceName, "-c", wtPath)
	if err := cmd.Run(); err != nil {
		return errors.TmuxOperationFailed("create window", err)
	}

	// Generate session ID for workspace
	workspaceSessionID, err := claude.GenerateSessionID()
	if err != nil {
		return fmt.Errorf("failed to generate workspace session ID: %w", err)
	}

	// Write prompt file for workspace
	workspacePromptFile, err := c.writePromptFile(repoPath, state.AgentTypeWorkspace, workspaceName)
	if err != nil {
		return fmt.Errorf("failed to write workspace prompt: %w", err)
	}

	// Copy hooks configuration if it exists
	if err := hooks.CopyConfig(repoPath, wtPath); err != nil {
		fmt.Printf("Warning: failed to copy hooks config: %v\n", err)
	}

	// Start Claude in workspace window (skip in test mode)
	var workspacePID int
	if os.Getenv("MULTICLAUDE_TEST_MODE") != "1" {
		// Resolve claude binary
		claudeBinary, err := c.getClaudeBinary()
		if err != nil {
			return fmt.Errorf("failed to resolve claude binary: %w", err)
		}

		fmt.Println("Starting Claude Code in workspace window...")
		pid, err := c.startClaudeInTmux(claudeBinary, tmuxSession, workspaceName, wtPath, workspaceSessionID, workspacePromptFile, repoName, "")
		if err != nil {
			return fmt.Errorf("failed to start workspace Claude: %w", err)
		}
		workspacePID = pid

		// Set up output capture for workspace
		if err := c.setupOutputCapture(tmuxSession, workspaceName, repoName, workspaceName, "workspace"); err != nil {
			fmt.Printf("Warning: failed to setup output capture for workspace: %v\n", err)
		}
	}

	// Register workspace with daemon
	resp, err = client.Send(socket.Request{
		Command: "add_agent",
		Args: map[string]interface{}{
			"repo":          repoName,
			"agent":         workspaceName,
			"type":          "workspace",
			"worktree_path": wtPath,
			"tmux_window":   workspaceName,
			"session_id":    workspaceSessionID,
			"pid":           workspacePID,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to register workspace: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to register workspace: %s", resp.Error)
	}

	fmt.Println()
	fmt.Println("✓ Workspace created successfully!")
	fmt.Printf("  Name: %s\n", workspaceName)
	fmt.Printf("  Branch: %s\n", branchName)
	fmt.Printf("  Worktree: %s\n", wtPath)
	fmt.Printf("\nConnect to workspace: multiclaude workspace connect %s\n", workspaceName)
	fmt.Printf("Or use: multiclaude attach %s\n", workspaceName)

	return nil
}

// removeWorkspace removes a workspace
func (c *CLI) removeWorkspace(args []string) error {
	flags, remainingArgs := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Get workspace info
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("getting workspace info", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to get workspace info", fmt.Errorf("%s", resp.Error))
	}

	agents, _ := resp.Data.([]interface{})

	// Determine workspace name - from args or interactive selection
	var workspaceName string
	if len(remainingArgs) > 0 {
		workspaceName = remainingArgs[0]
	} else {
		// Interactive selection
		items := agentsToSelectableItems(agents, []string{"workspace"})
		if len(items) == 0 {
			return errors.NoWorkspacesFound(repoName)
		}
		selected, err := SelectFromList("Select workspace to remove:", items)
		if err != nil {
			return err
		}
		if selected == "" {
			fmt.Println("Cancelled")
			return nil
		}
		workspaceName = selected
	}

	fmt.Printf("Removing workspace '%s' from repo '%s'\n", workspaceName, repoName)

	// Find workspace
	var workspaceInfo map[string]interface{}
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			agentType, _ := agentMap["type"].(string)
			name, _ := agentMap["name"].(string)
			if agentType == "workspace" && name == workspaceName {
				workspaceInfo = agentMap
				break
			}
		}
	}

	if workspaceInfo == nil {
		return errors.AgentNotFound("workspace", workspaceName, repoName)
	}

	// Get worktree path
	wtPath := workspaceInfo["worktree_path"].(string)

	// Check for uncommitted changes
	hasUncommitted, err := worktree.HasUncommittedChanges(wtPath)
	if err != nil {
		fmt.Printf("Warning: failed to check for uncommitted changes: %v\n", err)
	} else if hasUncommitted {
		fmt.Println("\nWarning: Workspace has uncommitted changes!")
		fmt.Println("Files may be lost if you continue with removal.")
		fmt.Print("Continue with removal? [y/N]: ")

		var response string
		fmt.Scanln(&response)
		if response != "y" && response != "Y" {
			fmt.Println("Removal cancelled")
			return nil
		}
	}

	// Check for unpushed commits
	if err := checkUnpushedCommits(wtPath, "Workspace", "removal"); err != nil {
		return nil
	}

	// Kill tmux window
	tmuxSession := sanitizeTmuxSessionName(repoName)
	tmuxWindow := workspaceInfo["tmux_window"].(string)
	fmt.Printf("Killing tmux window: %s\n", tmuxWindow)
	cmd := exec.Command("tmux", "kill-window", "-t", fmt.Sprintf("%s:%s", tmuxSession, tmuxWindow))
	if err := cmd.Run(); err != nil {
		fmt.Printf("Warning: failed to kill tmux window: %v\n", err)
	}

	// Remove worktree
	repoPath := c.paths.RepoDir(repoName)
	wt := worktree.NewManager(repoPath)

	fmt.Printf("Removing worktree: %s\n", wtPath)
	if err := wt.Remove(wtPath, false); err != nil {
		fmt.Printf("Warning: failed to remove worktree: %v\n", err)
	}

	// Unregister from daemon
	resp, err = client.Send(socket.Request{
		Command: "remove_agent",
		Args: map[string]interface{}{
			"repo":  repoName,
			"agent": workspaceName,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to unregister workspace: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to unregister workspace: %s", resp.Error)
	}

	fmt.Println("✓ Workspace removed successfully")
	return nil
}

// listWorkspaces lists all workspaces in a repository
func (c *CLI) listWorkspaces(args []string) error {
	flags, _ := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
			"rich": true,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("listing workspaces", err)
	}

	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to list workspaces", fmt.Errorf("%s", resp.Error))
	}

	agents, ok := resp.Data.([]interface{})
	if !ok {
		return errors.New(errors.CategoryRuntime, "unexpected response format from daemon")
	}

	// Filter for workspaces
	workspaces := []map[string]interface{}{}
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			agentType, _ := agentMap["type"].(string)
			if agentType == "workspace" {
				workspaces = append(workspaces, agentMap)
			}
		}
	}

	if len(workspaces) == 0 {
		fmt.Printf("No workspaces in repository '%s'\n", repoName)
		format.Dimmed("\nCreate a workspace with: multiclaude workspace add <name>")
		return nil
	}

	format.Header("Workspaces in '%s' (%d):", repoName, len(workspaces))
	fmt.Println()

	table := format.NewColoredTable("NAME", "BRANCH", "STATUS")
	for _, ws := range workspaces {
		name, _ := ws["name"].(string)
		status, _ := ws["status"].(string)
		branch, _ := ws["branch"].(string)

		// Format status with color
		statusCell := formatAgentStatusCell(status)

		// Format branch
		branchCell := format.ColorCell(branch, format.Cyan)
		if branch == "" {
			branchCell = format.ColorCell("-", format.Dim)
		}

		table.AddRow(
			format.Cell(name),
			branchCell,
			statusCell,
		)
	}
	table.Print()

	return nil
}

// connectWorkspace attaches to a workspace
func (c *CLI) connectWorkspace(args []string) error {
	flags, remainingArgs := ParseFlags(args)

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Get workspace info
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to get workspace info: %w (is daemon running?)", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to get workspace info: %s", resp.Error)
	}

	agents, _ := resp.Data.([]interface{})

	// Determine workspace name - from args or interactive selection
	var workspaceName string
	if len(remainingArgs) > 0 {
		workspaceName = remainingArgs[0]
	} else {
		// Interactive selection
		items := agentsToSelectableItems(agents, []string{"workspace"})
		if len(items) == 0 {
			return errors.NoWorkspacesFound(repoName)
		}
		selected, err := SelectFromList("Select workspace to connect:", items)
		if err != nil {
			return err
		}
		if selected == "" {
			fmt.Println("Cancelled")
			return nil
		}
		workspaceName = selected
	}

	// Find workspace
	var workspaceInfo map[string]interface{}
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			agentType, _ := agentMap["type"].(string)
			name, _ := agentMap["name"].(string)
			if agentType == "workspace" && name == workspaceName {
				workspaceInfo = agentMap
				break
			}
		}
	}

	if workspaceInfo == nil {
		return errors.WorkspaceNotFound(workspaceName, repoName)
	}

	// Get tmux session and window
	tmuxSession := sanitizeTmuxSessionName(repoName)
	tmuxWindow := workspaceInfo["tmux_window"].(string)

	// Attach to tmux
	target := fmt.Sprintf("%s:%s", tmuxSession, tmuxWindow)

	readOnly := flags["read-only"] == "true" || flags["r"] == "true"
	tmuxArgs := []string{"attach", "-t", target}
	if readOnly {
		tmuxArgs = append(tmuxArgs, "-r")
	}

	cmd := exec.Command("tmux", tmuxArgs...)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	return cmd.Run()
}

// validateWorkspaceName validates that a workspace name follows branch name restrictions
func validateWorkspaceName(name string) error {
	if name == "" {
		return fmt.Errorf("workspace name cannot be empty")
	}

	// Git branch name restrictions
	// - Cannot start with . or -
	// - Cannot contain consecutive dots ..
	// - Cannot contain \ or any of these characters: ~ ^ : ? * [ @ { } space
	// - Cannot end with . or /
	// - Cannot be "." or ".."

	if name == "." || name == ".." {
		return fmt.Errorf("workspace name cannot be '.' or '..'")
	}

	if strings.HasPrefix(name, ".") || strings.HasPrefix(name, "-") {
		return fmt.Errorf("workspace name cannot start with '.' or '-'")
	}

	if strings.HasSuffix(name, ".") || strings.HasSuffix(name, "/") {
		return fmt.Errorf("workspace name cannot end with '.' or '/'")
	}

	if strings.Contains(name, "..") {
		return fmt.Errorf("workspace name cannot contain '..'")
	}

	invalidChars := []string{"\\", "~", "^", ":", "?", "*", "[", "@", "{", "}", " ", "\t", "\n"}
	for _, char := range invalidChars {
		if strings.Contains(name, char) {
			return fmt.Errorf("workspace name cannot contain '%s'", char)
		}
	}

	return nil
}

// getReposList is a helper to get the list of repos
func (c *CLI) getReposList() []string {
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{Command: "list_repos"})
	if err != nil {
		return []string{}
	}

	if !resp.Success {
		return []string{}
	}

	repos, ok := resp.Data.([]interface{})
	if !ok {
		return []string{}
	}

	result := make([]string, 0, len(repos))
	for _, repo := range repos {
		if repoStr, ok := repo.(string); ok {
			result = append(result, repoStr)
		}
	}

	return result
}

func (c *CLI) sendMessage(args []string) error {
	if len(args) < 2 {
		return errors.InvalidUsage("usage: multiclaude agent send-message <to> <message>")
	}

	to := args[0]
	body := strings.Join(args[1:], " ")

	// Determine current agent and repo
	repoName, agentName, err := c.inferAgentContext()
	if err != nil {
		return err
	}

	// Create message manager
	msgMgr := messages.NewManager(c.paths.MessagesDir)

	// Send message
	msg, err := msgMgr.Send(repoName, agentName, to, body)
	if err != nil {
		return fmt.Errorf("failed to send message: %w", err)
	}

	// Trigger immediate routing (best-effort, polling is fallback)
	client := socket.NewClient(c.paths.DaemonSock)
	_, _ = client.Send(socket.Request{Command: "route_messages"})
	// Ignore errors - 2-minute polling fallback will catch it

	fmt.Printf("Message sent to %s (ID: %s)\n", to, msg.ID)
	return nil
}

func (c *CLI) listMessages(args []string) error {
	// Determine current agent and repo
	repoName, agentName, err := c.inferAgentContext()
	if err != nil {
		return err
	}

	msgMgr := messages.NewManager(c.paths.MessagesDir)

	// List messages
	msgs, err := msgMgr.List(repoName, agentName)
	if err != nil {
		return fmt.Errorf("failed to list messages: %w", err)
	}

	if len(msgs) == 0 {
		fmt.Println("No messages")
		return nil
	}

	fmt.Printf("Messages for %s (%d):\n", agentName, len(msgs))
	for _, msg := range msgs {
		status := msg.Status
		if msg.Status == messages.StatusAcked && msg.AckedAt != nil {
			status = messages.Status(fmt.Sprintf("acked (%s)", formatTime(*msg.AckedAt)))
		}
		fmt.Printf("  [%s] %s - From: %s - %s - %s\n",
			msg.ID,
			formatTime(msg.Timestamp),
			msg.From,
			status,
			truncateString(msg.Body, 60))
	}

	return nil
}

func (c *CLI) readMessage(args []string) error {
	if len(args) < 1 {
		return errors.InvalidUsage("usage: multiclaude agent read-message <message-id>")
	}

	messageID := args[0]

	// Determine current agent and repo
	repoName, agentName, err := c.inferAgentContext()
	if err != nil {
		return err
	}

	msgMgr := messages.NewManager(c.paths.MessagesDir)

	// Get message
	msg, err := msgMgr.Get(repoName, agentName, messageID)
	if err != nil {
		return fmt.Errorf("failed to read message: %w", err)
	}

	// Update status to read
	if msg.Status == messages.StatusPending || msg.Status == messages.StatusDelivered {
		if err := msgMgr.UpdateStatus(repoName, agentName, messageID, messages.StatusRead); err != nil {
			fmt.Printf("Warning: failed to update message status: %v\n", err)
		}
	}

	// Display message
	fmt.Printf("Message: %s\n", msg.ID)
	fmt.Printf("From: %s\n", msg.From)
	fmt.Printf("To: %s\n", msg.To)
	fmt.Printf("Time: %s\n", msg.Timestamp.Format(time.RFC3339))
	fmt.Printf("Status: %s\n", msg.Status)
	if msg.AckedAt != nil {
		fmt.Printf("Acked: %s\n", msg.AckedAt.Format(time.RFC3339))
	}
	fmt.Println()
	fmt.Println(msg.Body)

	return nil
}

func (c *CLI) ackMessage(args []string) error {
	if len(args) < 1 {
		return errors.InvalidUsage("usage: multiclaude agent ack-message <message-id>")
	}

	messageID := args[0]

	// Determine current agent and repo
	repoName, agentName, err := c.inferAgentContext()
	if err != nil {
		return err
	}

	msgMgr := messages.NewManager(c.paths.MessagesDir)

	// Ack message
	if err := msgMgr.Ack(repoName, agentName, messageID); err != nil {
		return fmt.Errorf("failed to acknowledge message: %w", err)
	}

	fmt.Printf("Message %s acknowledged\n", messageID)
	return nil
}

// inferRepoFromCwd infers just the repository name from the current working directory.
// Unlike inferAgentContext, it doesn't require determining the specific agent.
func (c *CLI) inferRepoFromCwd() (string, error) {
	cwd, err := os.Getwd()
	if err != nil {
		return "", fmt.Errorf("failed to get current directory: %w", err)
	}

	// Resolve symlinks in cwd for proper path comparison
	// This is especially important on macOS where /tmp -> /private/tmp
	if resolved, err := filepath.EvalSymlinks(cwd); err == nil {
		cwd = resolved
	}

	// Check if we're in a worktree path
	// Path format: ~/.multiclaude/wts/<repo>/<agent>
	if hasPathPrefix(cwd, c.paths.WorktreesDir) {
		rel, err := filepath.Rel(c.paths.WorktreesDir, cwd)
		if err == nil {
			parts := strings.SplitN(rel, string(filepath.Separator), 2)
			if len(parts) >= 1 && parts[0] != "" && parts[0] != "." {
				return parts[0], nil
			}
		}
	}

	// Check if we're in a main repo path
	// Path format: ~/.multiclaude/repos/<repo>
	if hasPathPrefix(cwd, c.paths.ReposDir) {
		rel, err := filepath.Rel(c.paths.ReposDir, cwd)
		if err == nil {
			parts := strings.SplitN(rel, string(filepath.Separator), 2)
			if len(parts) >= 1 && parts[0] != "" && parts[0] != "." {
				return parts[0], nil
			}
		}
	}

	return "", fmt.Errorf("not in a multiclaude directory")
}

// normalizeGitHubURL normalizes GitHub URLs to a common format for comparison.
// It handles both SSH (git@github.com:user/repo.git) and HTTPS (https://github.com/user/repo) formats.
// Returns lowercase "github.com/user/repo" format for comparison.
func normalizeGitHubURL(url string) string {
	url = strings.TrimSpace(url)
	lowerURL := strings.ToLower(url)

	// Handle SSH format: git@github.com:user/repo.git
	if strings.HasPrefix(lowerURL, "git@github.com:") {
		path := url[len("git@github.com:"):]
		path = strings.TrimSuffix(path, ".git")
		return strings.ToLower("github.com/" + path)
	}

	// Handle HTTPS format: https://github.com/user/repo or https://github.com/user/repo.git
	if strings.HasPrefix(lowerURL, "https://github.com/") {
		path := url[len("https://"):]
		path = strings.TrimSuffix(path, ".git")
		return strings.ToLower(path)
	}

	// Handle HTTP format: http://github.com/user/repo
	if strings.HasPrefix(lowerURL, "http://github.com/") {
		path := url[len("http://"):]
		path = strings.TrimSuffix(path, ".git")
		return strings.ToLower(path)
	}

	// Handle git:// protocol: git://github.com/user/repo.git
	if strings.HasPrefix(lowerURL, "git://github.com/") {
		path := url[len("git://"):]
		path = strings.TrimSuffix(path, ".git")
		return strings.ToLower(path)
	}

	// Return empty string for non-GitHub URLs
	return ""
}

// findRepoFromGitRemote looks for a git remote in the current directory
// and tries to match it against known repositories in state.
func (c *CLI) findRepoFromGitRemote() (string, error) {
	// Run git remote get-url origin
	cmd := exec.Command("git", "remote", "get-url", "origin")
	output, err := cmd.Output()
	if err != nil {
		return "", fmt.Errorf("failed to get git remote: %w", err)
	}

	remoteURL := strings.TrimSpace(string(output))
	if remoteURL == "" {
		return "", fmt.Errorf("git remote URL is empty")
	}

	normalizedRemote := normalizeGitHubURL(remoteURL)
	if normalizedRemote == "" {
		return "", fmt.Errorf("not a GitHub URL: %s", remoteURL)
	}

	// Load state to check against known repositories
	st, err := c.loadState()
	if err != nil {
		return "", err
	}

	// Iterate through repos and find a match
	for _, repoName := range st.ListRepos() {
		repo, exists := st.GetRepo(repoName)
		if !exists {
			continue
		}

		normalizedStateURL := normalizeGitHubURL(repo.GithubURL)
		if normalizedStateURL != "" && normalizedStateURL == normalizedRemote {
			return repoName, nil
		}
	}

	return "", fmt.Errorf("no matching repository found for remote: %s", remoteURL)
}

// resolveRepo determines the repository to use based on:
// 1. Explicit --repo flag (highest priority)
// 2. Git remote URL matching (if in a git repo with origin pointing to a tracked repo)
// 3. Current working directory (if in a multiclaude directory)
// 4. Current repo set via 'multiclaude repo use' (lowest priority)
func (c *CLI) resolveRepo(flags map[string]string) (string, error) {
	// 1. Check explicit --repo flag
	if r, ok := flags["repo"]; ok {
		return r, nil
	}

	// 2. Try to infer from git remote URL
	if repoName, err := c.findRepoFromGitRemote(); err == nil {
		return repoName, nil
	}

	// 3. Try to infer from current working directory
	if inferred, err := c.inferRepoFromCwd(); err == nil {
		return inferred, nil
	}

	// 4. Check current repo from daemon
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "get_current_repo",
	})
	if err == nil && resp.Success {
		if currentRepo, ok := resp.Data.(string); ok && currentRepo != "" {
			return currentRepo, nil
		}
	}

	return "", fmt.Errorf("could not determine repository; use --repo flag or run 'multiclaude repo use <name>'")
}

// inferAgentContext infers the current agent and repo from working directory
func (c *CLI) inferAgentContext() (repoName, agentName string, err error) {
	cwd, err := os.Getwd()
	if err != nil {
		return "", "", fmt.Errorf("failed to get current directory: %w", err)
	}

	// Resolve symlinks in cwd for proper path comparison
	// This is especially important on macOS where /tmp -> /private/tmp
	if resolved, err := filepath.EvalSymlinks(cwd); err == nil {
		cwd = resolved
	}

	// Check if we're in a worktree path
	// Path format: ~/.multiclaude/wts/<repo>/<agent>
	if hasPathPrefix(cwd, c.paths.WorktreesDir) {
		// Extract repo and agent from path
		rel, err := filepath.Rel(c.paths.WorktreesDir, cwd)
		if err == nil {
			parts := strings.SplitN(rel, string(filepath.Separator), 2)
			if len(parts) >= 2 {
				return parts[0], parts[1], nil
			}
			if len(parts) == 1 {
				// We're in the repo worktree dir itself
				return parts[0], "", fmt.Errorf("cannot determine agent - in repo worktree directory")
			}
		}
	}

	// Check if we're in a main repo path
	// Path format: ~/.multiclaude/repos/<repo>
	if hasPathPrefix(cwd, c.paths.ReposDir) {
		rel, err := filepath.Rel(c.paths.ReposDir, cwd)
		if err == nil {
			parts := strings.SplitN(rel, string(filepath.Separator), 2)
			if len(parts) >= 1 {
				// In main repo - could be supervisor or merge-queue
				// Try to get tmux window name
				tmuxWindow := os.Getenv("TMUX_PANE")
				if tmuxWindow != "" {
					// Get window name from tmux
					cmd := exec.Command("tmux", "display-message", "-p", "#{window_name}")
					output, err := cmd.Output()
					if err == nil {
						windowName := strings.TrimSpace(string(output))
						return parts[0], windowName, nil
					}
				}

				// Fallback: assume supervisor
				return parts[0], "supervisor", nil
			}
		}
	}

	return "", "", errors.NotInAgentContext()
}

// Helper functions

// hasPathPrefix checks if path starts with prefix using proper path semantics.
// Unlike strings.Contains or strings.HasPrefix, this ensures we're comparing
// complete path components (e.g., "/foo/bar" is under "/foo" but not under "/fo").
func hasPathPrefix(path, prefix string) bool {
	// Clean both paths to normalize them
	path = filepath.Clean(path)
	prefix = filepath.Clean(prefix)

	// Check if path equals or starts with prefix followed by separator
	if path == prefix {
		return true
	}
	// Ensure prefix ends with separator for proper prefix matching
	if !strings.HasSuffix(prefix, string(filepath.Separator)) {
		prefix += string(filepath.Separator)
	}
	return strings.HasPrefix(path, prefix)
}

func formatTime(t time.Time) string {
	if time.Since(t) < 24*time.Hour {
		return t.Format("15:04:05")
	}
	return t.Format("Jan 02 15:04")
}

func truncateString(s string, maxLen int) string {
	if len(s) <= maxLen {
		return s
	}
	return s[:maxLen-3] + "..."
}

// checkUnpushedCommits checks if a worktree has unpushed commits and prompts the user for confirmation.
// Returns nil if the user wants to continue, or an error to cancel the operation.
// The entityType parameter should be "Worker" or "Workspace" for appropriate messaging.
// The action parameter should be "cleanup" or "removal" for appropriate messaging.
func checkUnpushedCommits(wtPath, entityType, action string) error {
	hasUnpushed, err := worktree.HasUnpushedCommits(wtPath)
	if err != nil {
		// This is ok - might not have a tracking branch
		fmt.Printf("Note: Could not check for unpushed commits (no tracking branch?)\n")
		return nil
	}

	if !hasUnpushed {
		return nil
	}

	fmt.Printf("\nWarning: %s has unpushed commits!\n", entityType)
	branch, err := worktree.GetCurrentBranch(wtPath)
	if err == nil {
		fmt.Printf("Branch '%s' has commits not pushed to remote.\n", branch)
	}
	fmt.Printf("These commits may be lost if you continue with %s.\n", action)
	fmt.Printf("Continue with %s? [y/N]: ", action)

	var response string
	fmt.Scanln(&response)
	if response != "y" && response != "Y" {
		// Capitalize first letter of action for the message
		actionCapitalized := strings.ToUpper(action[:1]) + action[1:]
		fmt.Printf("%s cancelled\n", actionCapitalized)
		return fmt.Errorf("cancelled by user")
	}
	return nil
}

func (c *CLI) completeWorker(args []string) error {
	// Parse flags for optional summary and failure reason
	flags, _ := ParseFlags(args)

	// Determine current agent and repo
	repoName, agentName, err := c.inferAgentContext()
	if err != nil {
		return fmt.Errorf("failed to determine agent context: %w", err)
	}

	fmt.Printf("Marking agent '%s' as complete...\n", agentName)

	// Build request args
	reqArgs := map[string]interface{}{
		"repo":  repoName,
		"agent": agentName,
	}

	// Add optional summary
	if summary, ok := flags["summary"]; ok && summary != "" {
		reqArgs["summary"] = summary
		fmt.Printf("Summary: %s\n", summary)
	}

	// Add optional failure reason
	if failureReason, ok := flags["failure"]; ok && failureReason != "" {
		reqArgs["failure_reason"] = failureReason
		fmt.Printf("Failure reason: %s\n", failureReason)
	}

	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "complete_agent",
		Args:    reqArgs,
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("marking agent complete", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to mark agent complete", fmt.Errorf("%s", resp.Error))
	}

	fmt.Println("✓ Agent marked as complete")
	fmt.Println("The daemon will clean up this agent's resources shortly.")
	return nil
}

func (c *CLI) restartAgentCmd(args []string) error {
	// Parse flags
	flags, remaining := ParseFlags(args)

	// Get agent name from args
	if len(remaining) < 1 {
		return errors.InvalidUsage("usage: multiclaude agent restart <name> [--repo <repo>] [--force]")
	}
	agentName := remaining[0]

	// Get repo from flag or infer from cwd
	repoName := flags["repo"]
	if repoName == "" {
		// Try to infer from cwd
		inferred, err := c.inferRepoFromCwd()
		if err != nil {
			return errors.InvalidUsage("could not determine repository - use --repo flag or run from within a multiclaude worktree")
		}
		repoName = inferred
	}

	force := flags["force"] == "true"

	fmt.Printf("Restarting agent '%s' in repository '%s'...\n", agentName, repoName)

	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "restart_agent",
		Args: map[string]interface{}{
			"repo":  repoName,
			"agent": agentName,
			"force": force,
		},
	})
	if err != nil {
		return errors.DaemonCommunicationFailed("restarting agent", err)
	}
	if !resp.Success {
		return errors.Wrap(errors.CategoryRuntime, "failed to restart agent", fmt.Errorf("%s", resp.Error))
	}

	// Extract PID from response
	if data, ok := resp.Data.(map[string]interface{}); ok {
		if pid, ok := data["pid"].(float64); ok {
			fmt.Printf("✓ Agent '%s' restarted successfully (PID: %d)\n", agentName, int(pid))
		} else {
			fmt.Printf("✓ Agent '%s' restarted successfully\n", agentName)
		}
	} else {
		fmt.Printf("✓ Agent '%s' restarted successfully\n", agentName)
	}

	return nil
}

func (c *CLI) reviewPR(args []string) error {
	if len(args) < 1 {
		return errors.InvalidUsage("usage: multiclaude review <pr-url>")
	}

	prURL := args[0]

	// Parse PR URL to extract owner, repo, and PR number
	// Expected formats:
	// - https://github.com/owner/repo/pull/123
	// - github.com/owner/repo/pull/123
	prURL = strings.TrimPrefix(prURL, "https://")
	prURL = strings.TrimPrefix(prURL, "http://")
	parts := strings.Split(prURL, "/")

	if len(parts) < 5 || parts[3] != "pull" {
		return errors.InvalidPRURL()
	}

	prNumber := parts[4]
	fmt.Printf("Reviewing PR #%s\n", prNumber)

	// Determine repository from flag or current directory
	flags, _ := ParseFlags(args[1:])
	var repoName string
	if r, ok := flags["repo"]; ok {
		repoName = r
	} else {
		// Try to infer from current directory
		cwd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("failed to get current directory: %w", err)
		}

		// Check if we're in a tracked repo
		repos := c.getReposList()
		for _, repo := range repos {
			repoPath := c.paths.RepoDir(repo)
			if strings.HasPrefix(cwd, repoPath) {
				repoName = repo
				break
			}
		}

		if repoName == "" {
			return errors.NotInRepo()
		}
	}

	// Generate review agent name
	reviewerName := fmt.Sprintf("review-%s", prNumber)

	fmt.Printf("Creating review agent '%s' in repo '%s'\n", reviewerName, repoName)

	// Get repository path
	repoPath := c.paths.RepoDir(repoName)

	// Fetch the PR using GitHub's PR refs - this works for both same-repo and fork PRs
	// The refs/pull/<number>/head ref always exists and points to the PR's head commit
	fmt.Printf("Fetching PR #%s...\n", prNumber)
	prRef := fmt.Sprintf("refs/pull/%s/head", prNumber)
	localRef := fmt.Sprintf("refs/multiclaude/pr-%s", prNumber)
	cmd := exec.Command("git", "fetch", "origin", fmt.Sprintf("%s:%s", prRef, localRef))
	cmd.Dir = repoPath
	if output, err := cmd.CombinedOutput(); err != nil {
		return errors.Wrap(errors.CategoryRuntime, fmt.Sprintf("failed to fetch PR #%s: %s", prNumber, strings.TrimSpace(string(output))), err).
			WithSuggestion("ensure the PR exists and you have access to the repository")
	}

	// Create worktree for review
	wt := worktree.NewManager(repoPath)
	wtPath := c.paths.AgentWorktree(repoName, reviewerName)
	reviewBranch := fmt.Sprintf("review/%s", reviewerName)

	fmt.Printf("Creating worktree at: %s\n", wtPath)
	if err := wt.CreateNewBranch(wtPath, reviewBranch, localRef); err != nil {
		return fmt.Errorf("failed to create worktree: %w", err)
	}

	// Get tmux session name
	tmuxSession := sanitizeTmuxSessionName(repoName)

	// Create tmux window for reviewer (detached so it doesn't switch focus)
	fmt.Printf("Creating tmux window: %s\n", reviewerName)
	cmd = exec.Command("tmux", "new-window", "-d", "-t", tmuxSession, "-n", reviewerName, "-c", wtPath)
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("failed to create tmux window: %w", err)
	}

	// Generate session ID for reviewer
	reviewerSessionID, err := claude.GenerateSessionID()
	if err != nil {
		return fmt.Errorf("failed to generate reviewer session ID: %w", err)
	}

	// Write prompt file for reviewer
	reviewerPromptFile, err := c.writePromptFile(repoPath, state.AgentTypeReview, reviewerName)
	if err != nil {
		return fmt.Errorf("failed to write reviewer prompt: %w", err)
	}

	// Copy hooks configuration if it exists
	if err := hooks.CopyConfig(repoPath, wtPath); err != nil {
		fmt.Printf("Warning: failed to copy hooks config: %v\n", err)
	}

	// Start Claude in reviewer window with initial task (skip in test mode)
	var reviewerPID int
	if os.Getenv("MULTICLAUDE_TEST_MODE") != "1" {
		// Resolve claude binary
		claudeBinary, err := c.getClaudeBinary()
		if err != nil {
			return fmt.Errorf("failed to resolve claude binary: %w", err)
		}

		fmt.Println("Starting Claude Code in reviewer window...")
		initialMessage := fmt.Sprintf("Review PR #%s: https://github.com/%s/%s/pull/%s", prNumber, parts[1], parts[2], prNumber)
		pid, err := c.startClaudeInTmux(claudeBinary, tmuxSession, reviewerName, wtPath, reviewerSessionID, reviewerPromptFile, repoName, initialMessage)
		if err != nil {
			return fmt.Errorf("failed to start reviewer Claude: %w", err)
		}
		reviewerPID = pid

		// Set up output capture for reviewer
		if err := c.setupOutputCapture(tmuxSession, reviewerName, repoName, reviewerName, "review"); err != nil {
			fmt.Printf("Warning: failed to setup output capture for reviewer: %v\n", err)
		}
	}

	// Register reviewer with daemon
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "add_agent",
		Args: map[string]interface{}{
			"repo":          repoName,
			"agent":         reviewerName,
			"type":          "review",
			"worktree_path": wtPath,
			"tmux_window":   reviewerName,
			"task":          fmt.Sprintf("Review PR #%s", prNumber),
			"session_id":    reviewerSessionID,
			"pid":           reviewerPID,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to register reviewer: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to register reviewer: %s", resp.Error)
	}

	fmt.Println()
	fmt.Println("✓ Review agent created successfully!")
	fmt.Printf("  Name: %s\n", reviewerName)
	fmt.Printf("  Branch: %s\n", reviewBranch)
	fmt.Printf("  Worktree: %s\n", wtPath)
	fmt.Printf("\nAttach to reviewer: tmux select-window -t %s:%s\n", tmuxSession, reviewerName)
	fmt.Printf("Or use: multiclaude attach %s\n", reviewerName)

	return nil
}

// Logs command implementations

func (c *CLI) viewLogs(args []string) error {
	if len(args) < 1 {
		return fmt.Errorf("usage: multiclaude logs <agent> [--lines N] [--follow]")
	}

	agentName := args[0]
	flags, _ := ParseFlags(args[1:])

	// Determine repository
	var repoName string
	if r, ok := flags["repo"]; ok {
		repoName = r
	} else {
		repos := c.getReposList()
		if len(repos) == 0 {
			return fmt.Errorf("no repositories tracked")
		}
		if len(repos) == 1 {
			repoName = repos[0]
		} else {
			return fmt.Errorf("multiple repos exist. Use --repo flag to specify which one")
		}
	}

	// Determine if it's a worker or system agent by checking if it exists in workers dir
	workerLogFile := c.paths.AgentLogFile(repoName, agentName, true)
	systemLogFile := c.paths.AgentLogFile(repoName, agentName, false)

	var logFile string
	if _, err := os.Stat(workerLogFile); err == nil {
		logFile = workerLogFile
	} else if _, err := os.Stat(systemLogFile); err == nil {
		logFile = systemLogFile
	} else {
		return fmt.Errorf("no log file found for agent %s in repo %s", agentName, repoName)
	}

	// Check for --follow flag
	if _, ok := flags["follow"]; ok {
		// Use tail -f
		cmd := exec.Command("tail", "-f", logFile)
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		return cmd.Run()
	}

	// Determine number of lines
	lines := "100"
	if l, ok := flags["lines"]; ok {
		lines = l
	}

	// Use tail to get recent lines
	cmd := exec.Command("tail", "-n", lines, logFile)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd.Run()
}

func (c *CLI) listLogs(args []string) error {
	flags, _ := ParseFlags(args)

	// Determine repository
	var repoName string
	if r, ok := flags["repo"]; ok {
		repoName = r
	}

	if repoName != "" {
		// List logs for specific repo
		return c.listLogsForRepo(repoName)
	}

	// List logs for all repos
	repos := c.getReposList()
	if len(repos) == 0 {
		fmt.Println("No repositories tracked")
		return nil
	}

	for _, repo := range repos {
		if err := c.listLogsForRepo(repo); err != nil {
			fmt.Printf("Warning: failed to list logs for %s: %v\n", repo, err)
		}
	}
	return nil
}

func (c *CLI) listLogsForRepo(repoName string) error {
	repoOutputDir := c.paths.RepoOutputDir(repoName)

	// Check if directory exists
	if _, err := os.Stat(repoOutputDir); os.IsNotExist(err) {
		fmt.Printf("No logs for %s\n", repoName)
		return nil
	}

	fmt.Printf("\n%s:\n", repoName)

	// List system agent logs
	entries, err := os.ReadDir(repoOutputDir)
	if err != nil {
		return err
	}

	for _, entry := range entries {
		if entry.IsDir() && entry.Name() == "workers" {
			continue
		}
		if strings.HasSuffix(entry.Name(), ".log") {
			info, _ := entry.Info()
			agentName := strings.TrimSuffix(entry.Name(), ".log")
			if info != nil {
				fmt.Printf("  %s (%d bytes)\n", agentName, info.Size())
			} else {
				fmt.Printf("  %s\n", agentName)
			}
		}
	}

	// List worker logs
	workersDir := c.paths.WorkersOutputDir(repoName)
	if _, err := os.Stat(workersDir); err == nil {
		workerEntries, err := os.ReadDir(workersDir)
		if err == nil && len(workerEntries) > 0 {
			fmt.Println("  workers/")
			for _, entry := range workerEntries {
				if strings.HasSuffix(entry.Name(), ".log") {
					info, _ := entry.Info()
					workerName := strings.TrimSuffix(entry.Name(), ".log")
					if info != nil {
						fmt.Printf("    %s (%d bytes)\n", workerName, info.Size())
					} else {
						fmt.Printf("    %s\n", workerName)
					}
				}
			}
		}
	}

	return nil
}

func (c *CLI) searchLogs(args []string) error {
	if len(args) < 1 {
		return fmt.Errorf("usage: multiclaude logs search <pattern> [--repo <repo>]")
	}

	pattern := args[0]
	flags, _ := ParseFlags(args[1:])

	// Determine repository
	var repoName string
	if r, ok := flags["repo"]; ok {
		repoName = r
	}

	// Get search directories
	var searchPaths []string
	if repoName != "" {
		repoOutputDir := c.paths.RepoOutputDir(repoName)
		if _, err := os.Stat(repoOutputDir); err == nil {
			searchPaths = append(searchPaths, repoOutputDir)
		}
	} else {
		// Search all repos
		repos := c.getReposList()
		for _, repo := range repos {
			repoOutputDir := c.paths.RepoOutputDir(repo)
			if _, err := os.Stat(repoOutputDir); err == nil {
				searchPaths = append(searchPaths, repoOutputDir)
			}
		}
	}

	if len(searchPaths) == 0 {
		fmt.Println("No log directories found")
		return nil
	}

	// Use grep to search recursively
	grepArgs := []string{"-r", "-n", "--include=*.log", pattern}
	grepArgs = append(grepArgs, searchPaths...)

	cmd := exec.Command("grep", grepArgs...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	// Run grep (exit code 1 means no matches, which is fine)
	err := cmd.Run()
	if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 1 {
		fmt.Println("No matches found")
		return nil
	}
	return err
}

func (c *CLI) cleanLogs(args []string) error {
	flags, _ := ParseFlags(args)

	olderThan, ok := flags["older-than"]
	if !ok {
		return fmt.Errorf("usage: multiclaude logs clean --older-than <duration> (e.g., 7d, 24h)")
	}

	// Parse duration
	duration, err := parseDuration(olderThan)
	if err != nil {
		return fmt.Errorf("invalid duration: %v", err)
	}

	cutoff := time.Now().Add(-duration)
	fmt.Printf("Cleaning logs older than %s...\n", cutoff.Format(time.RFC3339))

	var deletedCount, deletedBytes int64

	// Walk output directory
	err = filepath.Walk(c.paths.OutputDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil // Skip errors
		}
		if info.IsDir() {
			return nil
		}
		if !strings.HasSuffix(path, ".log") {
			return nil
		}
		if info.ModTime().Before(cutoff) {
			deletedBytes += info.Size()
			if err := os.Remove(path); err != nil {
				fmt.Printf("Warning: failed to remove %s: %v\n", path, err)
			} else {
				deletedCount++
			}
		}
		return nil
	})

	if err != nil {
		return fmt.Errorf("failed to walk output directory: %w", err)
	}

	fmt.Printf("Deleted %d files (%.2f MB)\n", deletedCount, float64(deletedBytes)/(1024*1024))
	return nil
}

// parseDuration parses a duration string like "7d", "24h", "30m"
func parseDuration(s string) (time.Duration, error) {
	if len(s) < 2 {
		return 0, fmt.Errorf("duration too short")
	}

	unit := s[len(s)-1]
	valueStr := s[:len(s)-1]

	var value int
	if _, err := fmt.Sscanf(valueStr, "%d", &value); err != nil {
		return 0, err
	}

	switch unit {
	case 'd':
		return time.Duration(value) * 24 * time.Hour, nil
	case 'h':
		return time.Duration(value) * time.Hour, nil
	case 'm':
		return time.Duration(value) * time.Minute, nil
	default:
		return 0, fmt.Errorf("unknown unit: %c (use d, h, or m)", unit)
	}
}

func (c *CLI) attachAgent(args []string) error {
	flags, remainingArgs := ParseFlags(args)
	readOnly := flags["read-only"] == "true" || flags["r"] == "true"

	// Determine repository
	repoName, err := c.resolveRepo(flags)
	if err != nil {
		return errors.NotInRepo()
	}

	// Get agent info to find tmux session and window
	client := socket.NewClient(c.paths.DaemonSock)
	resp, err := client.Send(socket.Request{
		Command: "list_agents",
		Args: map[string]interface{}{
			"repo": repoName,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to get agent info: %w (is daemon running?)", err)
	}
	if !resp.Success {
		return fmt.Errorf("failed to get agent info: %s", resp.Error)
	}

	agents, _ := resp.Data.([]interface{})

	// Determine agent name - from args or interactive selection
	var agentName string
	if len(remainingArgs) > 0 {
		agentName = remainingArgs[0]
	} else {
		// Interactive selection - all agent types
		items := agentsToSelectableItems(agents, nil)
		if len(items) == 0 {
			return errors.NoAgentsFound(repoName)
		}
		selected, err := SelectFromList("Select agent to attach:", items)
		if err != nil {
			return err
		}
		if selected == "" {
			fmt.Println("Cancelled")
			return nil
		}
		agentName = selected
	}

	// Find agent
	var agentInfo map[string]interface{}
	for _, agent := range agents {
		if agentMap, ok := agent.(map[string]interface{}); ok {
			if name, _ := agentMap["name"].(string); name == agentName {
				agentInfo = agentMap
				break
			}
		}
	}

	if agentInfo == nil {
		return errors.AgentNotFound("agent", agentName, repoName)
	}

	// Get tmux session and window
	tmuxSession := sanitizeTmuxSessionName(repoName)
	tmuxWindow := agentInfo["tmux_window"].(string)

	// Attach to tmux
	target := fmt.Sprintf("%s:%s", tmuxSession, tmuxWindow)

	tmuxArgs := []string{"attach", "-t", target}
	if readOnly {
		tmuxArgs = append(tmuxArgs, "-r")
	}

	cmd := exec.Command("tmux", tmuxArgs...)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	return cmd.Run()
}

func (c *CLI) cleanup(args []string) error {
	flags, _ := ParseFlags(args)
	dryRun := flags["dry-run"] == "true"
	verbose := flags["verbose"] == "true" || flags["v"] == "true"
	cleanMerged := flags["merged"] == "true"

	if dryRun {
		fmt.Println("Running cleanup in dry-run mode (no changes will be made)...")
	} else {
		fmt.Println("Running cleanup...")
	}

	// If --merged flag is set, run merged branch cleanup
	if cleanMerged {
		return c.cleanupMergedBranches(dryRun, verbose)
	}

	client := socket.NewClient(c.paths.DaemonSock)

	// Check if daemon is running
	_, err := client.Send(socket.Request{Command: "ping"})
	if err != nil {
		fmt.Println("Daemon is not running. Running local cleanup...")
		return c.localCleanup(dryRun, verbose)
	}

	// Trigger daemon cleanup
	resp, err := client.Send(socket.Request{
		Command: "trigger_cleanup",
		Args: map[string]interface{}{
			"dry_run": dryRun,
		},
	})
	if err != nil {
		return fmt.Errorf("failed to trigger cleanup: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("cleanup failed: %s", resp.Error)
	}

	fmt.Println("Cleanup completed")
	return nil
}

// cleanupMergedBranches cleans up branches that have been merged upstream
func (c *CLI) cleanupMergedBranches(dryRun bool, verbose bool) error {
	fmt.Println("\nChecking for branches merged upstream...")

	// Load state to get repository list
	st, err := c.loadState()
	if err != nil {
		return err
	}

	totalDeleted := 0
	totalFound := 0

	// Process each repository
	repos := st.ListRepos()
	if len(repos) == 0 {
		fmt.Println("No repositories tracked. Nothing to clean up.")
		return nil
	}

	for _, repoName := range repos {
		repoPath := c.paths.RepoDir(repoName)

		// Check if repo exists
		if _, err := os.Stat(repoPath); os.IsNotExist(err) {
			if verbose {
				fmt.Printf("\nRepository %s: path does not exist, skipping\n", repoName)
			}
			continue
		}

		if verbose {
			fmt.Printf("\nRepository: %s\n", repoName)
		}

		wt := worktree.NewManager(repoPath)

		// Check for merged branches with common prefixes
		for _, prefix := range []string{"multiclaude/", "work/"} {
			mergedBranches, err := wt.FindMergedUpstreamBranches(prefix)
			if err != nil {
				if verbose {
					fmt.Printf("  Warning: failed to find merged branches with prefix %s: %v\n", prefix, err)
				}
				continue
			}

			if len(mergedBranches) == 0 {
				if verbose {
					fmt.Printf("  No merged branches with prefix %s\n", prefix)
				}
				continue
			}

			// Get worktrees to skip branches that are still checked out
			worktrees, err := wt.List()
			if err != nil {
				if verbose {
					fmt.Printf("  Warning: failed to list worktrees: %v\n", err)
				}
				continue
			}

			activeBranches := make(map[string]bool)
			for _, wtInfo := range worktrees {
				if wtInfo.Branch != "" {
					activeBranches[wtInfo.Branch] = true
				}
			}

			fmt.Printf("\nMerged branches with prefix %s for %s:\n", prefix, repoName)
			for _, branch := range mergedBranches {
				if activeBranches[branch] {
					if verbose {
						fmt.Printf("  Skipping %s (still checked out)\n", branch)
					}
					continue
				}

				totalFound++
				if dryRun {
					fmt.Printf("  Would delete: %s\n", branch)
				} else {
					// Delete local branch
					if err := wt.DeleteBranch(branch); err != nil {
						fmt.Printf("  Failed to delete %s: %v\n", branch, err)
						continue
					}
					fmt.Printf("  Deleted: %s\n", branch)
					totalDeleted++

					// Try to delete remote branch from origin (the fork)
					if err := wt.DeleteRemoteBranch("origin", branch); err != nil {
						if verbose {
							fmt.Printf("    (remote branch deletion failed: %v)\n", err)
						}
					} else if verbose {
						fmt.Printf("    (also deleted from origin)\n")
					}
				}
			}
		}
	}

	if dryRun {
		if totalFound > 0 {
			fmt.Printf("\nFound %d merged branch(es) that would be deleted\n", totalFound)
		} else {
			fmt.Println("\nNo merged branches found to clean up")
		}
	} else {
		if totalDeleted > 0 {
			fmt.Printf("\nDeleted %d merged branch(es)\n", totalDeleted)
		} else {
			fmt.Println("\nNo merged branches found to clean up")
		}
	}

	return nil
}

// cleanupOrphanedBranchesWithPrefix removes orphaned branches matching the given prefix
func (c *CLI) cleanupOrphanedBranchesWithPrefix(wt *worktree.Manager, branchPrefix, repoName string, dryRun, verbose bool) (removed int, issues int) {
	orphanedBranches, err := wt.FindOrphanedBranches(branchPrefix)
	if err != nil && verbose {
		fmt.Printf("  Warning: failed to find orphaned %s branches: %v\n", branchPrefix, err)
		return 0, 0
	}

	if len(orphanedBranches) == 0 {
		if verbose {
			branchType := "work"
			if branchPrefix == "workspace/" {
				branchType = "workspace"
			}
			fmt.Printf("  No orphaned %s branches\n", branchType)
		}
		return 0, 0
	}

	branchType := "work"
	if branchPrefix == "workspace/" {
		branchType = "workspace"
	}
	fmt.Printf("\nOrphaned %s branches (%d) for %s:\n", branchType, len(orphanedBranches), repoName)

	for _, branch := range orphanedBranches {
		if dryRun {
			fmt.Printf("  Would delete branch: %s\n", branch)
			issues++
		} else {
			if err := wt.DeleteBranch(branch); err != nil {
				fmt.Printf("  Failed to delete %s: %v\n", branch, err)
			} else {
				fmt.Printf("  Deleted branch: %s\n", branch)
				removed++
			}
		}
	}

	return removed, issues
}

func (c *CLI) localCleanup(dryRun bool, verbose bool) error {
	// Clean up orphaned worktrees, tmux sessions, and other resources
	fmt.Println("\nChecking for orphaned resources...")

	totalRemoved := 0
	totalIssues := 0

	// Load state for reference
	st, err := state.Load(c.paths.StateFile)
	if err != nil {
		fmt.Printf("Warning: could not load state file: %v\n", err)
		st = state.New(c.paths.StateFile)
	}

	// Check for orphaned tmux sessions (mc-* sessions not in state)
	tmuxClient := tmux.NewClient()
	if tmuxClient.IsTmuxAvailable() {
		sessions, err := tmuxClient.ListSessions(context.Background())
		if err == nil {
			repos := st.ListRepos()
			validSessions := make(map[string]bool)
			for _, repo := range repos {
				validSessions[fmt.Sprintf("mc-%s", repo)] = true
			}

			orphanedSessions := []string{}
			for _, session := range sessions {
				if strings.HasPrefix(session, "mc-") && !validSessions[session] {
					orphanedSessions = append(orphanedSessions, session)
				}
			}

			if len(orphanedSessions) > 0 {
				fmt.Printf("\nOrphaned tmux sessions (%d):\n", len(orphanedSessions))
				for _, session := range orphanedSessions {
					if dryRun {
						fmt.Printf("  Would kill: %s\n", session)
					} else {
						if err := tmuxClient.KillSession(context.Background(), session); err != nil {
							fmt.Printf("  Failed to kill %s: %v\n", session, err)
						} else {
							fmt.Printf("  Killed: %s\n", session)
							totalRemoved++
						}
					}
				}
			} else if verbose {
				fmt.Println("\nNo orphaned tmux sessions found")
			}
		}
	}

	// Check for orphaned worktree directories (in wts/ but not in any repo's git worktrees)
	entries, err := os.ReadDir(c.paths.WorktreesDir)
	if err != nil && !os.IsNotExist(err) {
		fmt.Printf("Warning: failed to read worktrees directory: %v\n", err)
	} else if err == nil {
		for _, entry := range entries {
			if !entry.IsDir() {
				continue
			}

			repoName := entry.Name()
			repoPath := c.paths.RepoDir(repoName)
			wtRootDir := c.paths.WorktreeDir(repoName)

			// Check if the repo still exists
			if _, err := os.Stat(repoPath); os.IsNotExist(err) {
				fmt.Printf("\nOrphaned worktree directory (repo missing): %s\n", wtRootDir)
				if !dryRun {
					if err := os.RemoveAll(wtRootDir); err != nil {
						fmt.Printf("  Failed to remove: %v\n", err)
					} else {
						fmt.Printf("  Removed\n")
						totalRemoved++
					}
				}
				continue
			}

			if verbose {
				fmt.Printf("\nRepository: %s\n", repoName)
			}

			wt := worktree.NewManager(repoPath)

			// Cleanup orphaned worktree directories
			if !dryRun {
				removed, err := worktree.CleanupOrphaned(wtRootDir, wt)
				if err != nil {
					fmt.Printf("  Warning: failed to cleanup worktrees: %v\n", err)
				} else if len(removed) > 0 {
					for _, path := range removed {
						fmt.Printf("  Removed: %s\n", path)
					}
					totalRemoved += len(removed)
				} else if verbose {
					fmt.Println("  No orphaned worktrees")
				}
			} else {
				// Dry run: just check what would be removed
				gitWorktrees, _ := wt.List()
				gitPaths := make(map[string]bool)
				for _, gwt := range gitWorktrees {
					absPath, _ := filepath.Abs(gwt.Path)
					evalPath, err := filepath.EvalSymlinks(absPath)
					if err != nil {
						evalPath = absPath
					}
					gitPaths[evalPath] = true
				}

				dirEntries, _ := os.ReadDir(wtRootDir)
				for _, de := range dirEntries {
					if !de.IsDir() {
						continue
					}
					path := filepath.Join(wtRootDir, de.Name())
					absPath, _ := filepath.Abs(path)
					evalPath, err := filepath.EvalSymlinks(absPath)
					if err != nil {
						evalPath = absPath
					}
					if !gitPaths[evalPath] {
						fmt.Printf("  Would remove: %s\n", path)
						totalIssues++
					}
				}
			}

			// Prune git worktree references
			if !dryRun {
				if err := wt.Prune(); err != nil && verbose {
					fmt.Printf("  Warning: failed to prune worktrees: %v\n", err)
				}
			}

			// Clean up orphaned work/* and workspace/* branches
			removed, issues := c.cleanupOrphanedBranchesWithPrefix(wt, "work/", repoName, dryRun, verbose)
			totalRemoved += removed
			totalIssues += issues

			removed, issues = c.cleanupOrphanedBranchesWithPrefix(wt, "workspace/", repoName, dryRun, verbose)
			totalRemoved += removed
			totalIssues += issues
		}
	}

	// Check for orphaned message directories
	msgEntries, err := os.ReadDir(c.paths.MessagesDir)
	if err != nil && !os.IsNotExist(err) {
		fmt.Printf("Warning: failed to read messages directory: %v\n", err)
	} else if err == nil {
		for _, entry := range msgEntries {
			if !entry.IsDir() {
				continue
			}

			repoName := entry.Name()
			validAgents, _ := st.ListAgents(repoName)

			msgMgr := messages.NewManager(c.paths.MessagesDir)

			if !dryRun {
				count, err := msgMgr.CleanupOrphaned(repoName, validAgents)
				if err != nil && verbose {
					fmt.Printf("Warning: failed to cleanup messages for %s: %v\n", repoName, err)
				} else if count > 0 {
					fmt.Printf("Cleaned up %d orphaned message dir(s) for %s\n", count, repoName)
					totalRemoved += count
				}
			} else {
				// Dry run check
				repoDir := filepath.Join(c.paths.MessagesDir, repoName)
				agentEntries, _ := os.ReadDir(repoDir)
				validAgentMap := make(map[string]bool)
				for _, a := range validAgents {
					validAgentMap[a] = true
				}
				for _, ae := range agentEntries {
					if ae.IsDir() && !validAgentMap[ae.Name()] {
						fmt.Printf("Would remove orphaned message dir: %s/%s\n", repoName, ae.Name())
						totalIssues++
					}
				}
			}
		}
	}

	// Check for stale socket and PID files (when daemon not running)
	pidFile := daemon.NewPIDFile(c.paths.DaemonPID)
	if running, _, _ := pidFile.IsRunning(); !running {
		// Daemon not running, check for stale files
		if _, err := os.Stat(c.paths.DaemonPID); err == nil {
			if dryRun {
				fmt.Printf("\nWould remove stale PID file: %s\n", c.paths.DaemonPID)
				totalIssues++
			} else {
				if err := os.Remove(c.paths.DaemonPID); err == nil {
					fmt.Printf("Removed stale PID file: %s\n", c.paths.DaemonPID)
					totalRemoved++
				}
			}
		}
		if _, err := os.Stat(c.paths.DaemonSock); err == nil {
			if dryRun {
				fmt.Printf("Would remove stale socket file: %s\n", c.paths.DaemonSock)
				totalIssues++
			} else {
				if err := os.Remove(c.paths.DaemonSock); err == nil {
					fmt.Printf("Removed stale socket file: %s\n", c.paths.DaemonSock)
					totalRemoved++
				}
			}
		}
	}

	fmt.Println()
	if dryRun {
		if totalIssues > 0 {
			fmt.Printf("✓ Dry run completed: would fix %d issue(s)\n", totalIssues)
		} else {
			fmt.Println("✓ Dry run completed: no issues found")
		}
	} else {
		if totalRemoved > 0 {
			fmt.Printf("✓ Cleanup completed: removed %d item(s)\n", totalRemoved)
		} else {
			fmt.Println("✓ Cleanup completed: no orphaned resources found")
		}
	}

	return nil
}

func (c *CLI) repair(args []string) error {
	flags, _ := ParseFlags(args)
	verbose := flags["verbose"] == "true" || flags["v"] == "true"

	fmt.Println("Repairing state...")

	// Check if daemon is running
	client := socket.NewClient(c.paths.DaemonSock)
	_, err := client.Send(socket.Request{Command: "ping"})
	if err != nil {
		// Daemon not running - do local repair
		fmt.Println("Daemon is not running. Performing local repair...")
		return c.localRepair(verbose)
	}

	// Trigger state repair via daemon
	resp, err := client.Send(socket.Request{
		Command: "repair_state",
	})
	if err != nil {
		return fmt.Errorf("failed to trigger repair: %w", err)
	}
	if !resp.Success {
		return fmt.Errorf("repair failed: %s", resp.Error)
	}

	fmt.Println("✓ State repaired successfully")
	if data, ok := resp.Data.(map[string]interface{}); ok {
		if removed, ok := data["agents_removed"].(float64); ok && removed > 0 {
			fmt.Printf("  Removed %d dead agent(s)\n", int(removed))
		}
		if fixed, ok := data["issues_fixed"].(float64); ok && fixed > 0 {
			fmt.Printf("  Fixed %d issue(s)\n", int(fixed))
		}
	}

	return nil
}

// localRepair performs state repair without the daemon running
func (c *CLI) localRepair(verbose bool) error {
	// Load state from disk
	st, err := c.loadState()
	if err != nil {
		return err
	}

	tmuxClient := tmux.NewClient()
	agentsRemoved := 0
	issuesFixed := 0

	// Track orphaned tmux sessions
	orphanedSessions := []string{}

	// Get all tmux sessions and find orphaned ones
	sessions, err := tmuxClient.ListSessions(context.Background())
	if err == nil {
		repos := st.ListRepos()
		validSessions := make(map[string]bool)
		for _, repo := range repos {
			validSessions[fmt.Sprintf("mc-%s", repo)] = true
		}
		for _, session := range sessions {
			if strings.HasPrefix(session, "mc-") && !validSessions[session] {
				orphanedSessions = append(orphanedSessions, session)
			}
		}
	}

	// Check each repo and its agents
	repos := st.GetAllRepos()
	for repoName, repo := range repos {
		if verbose {
			fmt.Printf("\nChecking repository: %s\n", repoName)
		}

		// Check if tmux session exists
		hasSession, err := tmuxClient.HasSession(context.Background(), repo.TmuxSession)
		if err != nil && verbose {
			fmt.Printf("  Warning: failed to check session %s: %v\n", repo.TmuxSession, err)
			continue
		}

		if !hasSession {
			if verbose {
				fmt.Printf("  Tmux session %s not found\n", repo.TmuxSession)
			}
			// Remove all agents for this repo
			for agentName := range repo.Agents {
				if verbose {
					fmt.Printf("  Removing agent %s (session gone)\n", agentName)
				}
				if err := st.RemoveAgent(repoName, agentName); err == nil {
					agentsRemoved++
				}
			}
			issuesFixed++
			continue
		}

		// Check each agent
		for agentName, agent := range repo.Agents {
			// Check if window exists
			hasWindow, _ := tmuxClient.HasWindow(context.Background(), repo.TmuxSession, agent.TmuxWindow)
			if !hasWindow {
				if verbose {
					fmt.Printf("  Removing agent %s (window %s not found)\n", agentName, agent.TmuxWindow)
				}
				if err := st.RemoveAgent(repoName, agentName); err == nil {
					agentsRemoved++
					issuesFixed++
				}
				continue
			}

			// Check if worktree exists (for workers)
			if agent.Type == state.AgentTypeWorker && agent.WorktreePath != "" {
				if _, err := os.Stat(agent.WorktreePath); os.IsNotExist(err) {
					if verbose {
						fmt.Printf("  Warning: worktree missing for %s: %s\n", agentName, agent.WorktreePath)
					}
					// Don't remove - window exists, user may have manually deleted worktree
				}
			}

			if verbose {
				fmt.Printf("  Agent %s: OK\n", agentName)
			}
		}
	}

	// Clean up orphaned worktrees
	for _, repoName := range st.ListRepos() {
		repoPath := c.paths.RepoDir(repoName)
		wtRootDir := c.paths.WorktreeDir(repoName)

		if _, err := os.Stat(wtRootDir); os.IsNotExist(err) {
			continue
		}

		wt := worktree.NewManager(repoPath)
		removed, err := worktree.CleanupOrphaned(wtRootDir, wt)
		if err != nil {
			if verbose {
				fmt.Printf("  Warning: failed to cleanup worktrees for %s: %v\n", repoName, err)
			}
			continue
		}

		if len(removed) > 0 {
			if verbose {
				fmt.Printf("  Cleaned up %d orphaned worktree(s) for %s\n", len(removed), repoName)
			}
			issuesFixed += len(removed)
		}

		// Prune git worktree references
		if err := wt.Prune(); err != nil && verbose {
			fmt.Printf("  Warning: failed to prune worktrees for %s: %v\n", repoName, err)
		}
	}

	// Clean up orphaned message directories
	msgMgr := messages.NewManager(c.paths.MessagesDir)
	for _, repoName := range st.ListRepos() {
		validAgents, _ := st.ListAgents(repoName)
		if count, err := msgMgr.CleanupOrphaned(repoName, validAgents); err == nil && count > 0 {
			if verbose {
				fmt.Printf("  Cleaned up %d orphaned message dir(s) for %s\n", count, repoName)
			}
			issuesFixed += count
		}
	}

	// Report orphaned tmux sessions
	if len(orphanedSessions) > 0 {
		fmt.Printf("\nFound %d orphaned tmux session(s) not in state:\n", len(orphanedSessions))
		for _, session := range orphanedSessions {
			fmt.Printf("  - %s\n", session)
		}
		fmt.Println("To remove these, run: tmux kill-session -t <session>")
		fmt.Println("Or use: multiclaude stop-all")
	}

	// Save updated state
	if err := st.Save(); err != nil {
		return fmt.Errorf("failed to save repaired state: %w", err)
	}

	fmt.Println("\n✓ Local repair completed")
	if agentsRemoved > 0 {
		fmt.Printf("  Removed %d dead agent(s)\n", agentsRemoved)
	}
	if issuesFixed > 0 {
		fmt.Printf("  Fixed %d issue(s)\n", issuesFixed)
	}
	if agentsRemoved == 0 && issuesFixed == 0 {
		fmt.Println("  No issues found")
	}

	return nil
}

// restartClaude restarts Claude in the current agent context.
// It checks if Claude is already running and provides helpful error messages if so.
// It auto-detects whether to use --resume or --session-id based on session history.
func (c *CLI) restartClaude(args []string) error {
	// Infer agent context from cwd
	repoName, agentName, err := c.inferAgentContext()
	if err != nil {
		return fmt.Errorf("cannot determine agent context: %w\n\nRun this command from within a multiclaude agent tmux window", err)
	}

	// Load state to get session ID
	st, err := state.Load(c.paths.StateFile)
	if err != nil {
		return fmt.Errorf("failed to load state: %w", err)
	}

	agent, exists := st.GetAgent(repoName, agentName)
	if !exists {
		return fmt.Errorf("agent '%s' not found in state for repo '%s'", agentName, repoName)
	}

	if agent.SessionID == "" {
		return fmt.Errorf("agent has no session ID - try removing and recreating the agent")
	}

	// Check if Claude is already running
	if agent.PID > 0 {
		// Check if the process is still alive
		process, err := os.FindProcess(agent.PID)
		if err == nil {
			// Send signal 0 to check if process exists (doesn't actually signal, just checks)
			err = process.Signal(syscall.Signal(0))
			if err == nil {
				// Process is still running - provide helpful error
				return fmt.Errorf("Claude is already running (PID %d) in this context.\n\nTo restart:\n  1. Exit Claude first (Ctrl+D or /exit)\n  2. Then run 'multiclaude claude' again\n\nOr attach to the running session:\n  multiclaude attach %s", agent.PID, agentName)
			}
		}
	}

	// Get repo for tmux session info
	repo, exists := st.GetRepo(repoName)
	if !exists {
		return fmt.Errorf("repo '%s' not found in state", repoName)
	}

	// Double-check: get the current PID in the tmux pane to detect any running process
	tmuxClient := tmux.NewClient()
	currentPID, err := tmuxClient.GetPanePID(context.Background(), repo.TmuxSession, agent.TmuxWindow)
	if err == nil && currentPID > 0 {
		// Check if this PID is alive and different from what we checked above
		if currentPID != agent.PID {
			if process, err := os.FindProcess(currentPID); err == nil {
				if err := process.Signal(syscall.Signal(0)); err == nil {
					// There's a different running process in the pane
					return fmt.Errorf("A process (PID %d) is already running in this tmux pane.\n\nTo restart:\n  1. Exit the current process first\n  2. Then run 'multiclaude claude' again\n\nOr attach to view:\n  multiclaude attach %s", currentPID, agentName)
				}
			}
		}
	}

	// Get the prompt file path (stored as ~/.multiclaude/prompts/<agent-name>.md)
	promptFile := filepath.Join(c.paths.Root, "prompts", agentName+".md")

	// Check if the session has history by looking for the .jsonl file
	// Claude stores sessions in ~/.claude/projects/<encoded-path>/<session-id>.jsonl
	claudeProjectsDir := filepath.Join(os.Getenv("HOME"), ".claude", "projects")
	hasHistory := false

	// The path encoding replaces / with - and prefixes with -
	// e.g., /Users/foo/bar becomes -Users-foo-bar
	encodedPath := strings.ReplaceAll(agent.WorktreePath, "/", "-")
	sessionFile := filepath.Join(claudeProjectsDir, encodedPath, agent.SessionID+".jsonl")

	if info, err := os.Stat(sessionFile); err == nil {
		// Check if file has content (not just empty)
		if info.Size() > 0 {
			hasHistory = true
		}
	}

	// Build the command
	var cmdArgs []string
	if hasHistory {
		// Session has history - use --resume to continue
		cmdArgs = []string{"--resume", agent.SessionID}
		fmt.Printf("Resuming Claude session %s...\n", agent.SessionID)
	} else {
		// New session - use --session-id
		cmdArgs = []string{"--session-id", agent.SessionID}
		fmt.Printf("Starting new Claude session %s...\n", agent.SessionID)
	}

	// Add common flags
	cmdArgs = append(cmdArgs, "--dangerously-skip-permissions")
	if _, err := os.Stat(promptFile); err == nil {
		cmdArgs = append(cmdArgs, "--append-system-prompt-file", promptFile)
	}

	// Exec claude
	claudePath := "claude"

	fmt.Printf("Running: %s %s\n\n", claudePath, strings.Join(cmdArgs, " "))

	// Run claude interactively
	cmd := exec.Command(claudePath, cmdArgs...)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.Dir = agent.WorktreePath

	return cmd.Run()
}

func (c *CLI) showDocs(args []string) error {
	fmt.Println(c.documentation)
	return nil
}

// GenerateDocumentation generates markdown documentation for all CLI commands
func (c *CLI) GenerateDocumentation() string {
	var sb strings.Builder

	sb.WriteString("# Multiclaude CLI Reference\n\n")
	sb.WriteString("This is an automatically generated reference for all multiclaude commands.\n\n")

	// Generate docs for each top-level command
	for name, cmd := range c.rootCmd.Subcommands {
		c.generateCommandDocs(&sb, name, cmd, 0)
	}

	return sb.String()
}

// generateCommandDocs recursively generates documentation for a command and its subcommands
func (c *CLI) generateCommandDocs(sb *strings.Builder, name string, cmd *Command, level int) {
	indent := strings.Repeat("#", level+2)

	// Command header
	sb.WriteString(fmt.Sprintf("%s %s\n\n", indent, name))

	// Description
	if cmd.Description != "" {
		sb.WriteString(fmt.Sprintf("%s\n\n", cmd.Description))
	}

	// Usage
	if cmd.Usage != "" {
		sb.WriteString(fmt.Sprintf("**Usage:** `%s`\n\n", cmd.Usage))
	}

	// Subcommands
	if len(cmd.Subcommands) > 0 {
		sb.WriteString("**Subcommands:**\n\n")
		for subName, subCmd := range cmd.Subcommands {
			// Skip internal commands
			if strings.HasPrefix(subName, "_") {
				continue
			}
			sb.WriteString(fmt.Sprintf("- `%s` - %s\n", subName, subCmd.Description))
		}
		sb.WriteString("\n")

		// Recursively document subcommands
		for subName, subCmd := range cmd.Subcommands {
			if !strings.HasPrefix(subName, "_") {
				c.generateCommandDocs(sb, subName, subCmd, level+1)
			}
		}
	}
}

// ParseFlags is a simple flag parser
func ParseFlags(args []string) (map[string]string, []string) {
	flags := make(map[string]string)
	var positional []string

	for i := 0; i < len(args); i++ {
		arg := args[i]
		if strings.HasPrefix(arg, "--") {
			// Long flag
			flag := strings.TrimPrefix(arg, "--")
			// Handle --flag=value format
			if idx := strings.Index(flag, "="); idx != -1 {
				flags[flag[:idx]] = flag[idx+1:]
			} else if i+1 < len(args) && !strings.HasPrefix(args[i+1], "-") {
				flags[flag] = args[i+1]
				i++
			} else {
				flags[flag] = "true"
			}
		} else if strings.HasPrefix(arg, "-") {
			// Short flag
			flag := strings.TrimPrefix(arg, "-")
			// Handle -f=value format
			if idx := strings.Index(flag, "="); idx != -1 {
				flags[flag[:idx]] = flag[idx+1:]
			} else if i+1 < len(args) && !strings.HasPrefix(args[i+1], "-") {
				flags[flag] = args[i+1]
				i++
			} else {
				flags[flag] = "true"
			}
		} else {
			positional = append(positional, arg)
		}
	}

	return flags, positional
}

// savePromptToFile writes prompt text to the prompts directory and returns the path.
// This is a common helper used by various prompt-writing functions.
func (c *CLI) savePromptToFile(agentName, promptText string) (string, error) {
	promptDir := filepath.Join(c.paths.Root, "prompts")
	if err := os.MkdirAll(promptDir, 0755); err != nil {
		return "", fmt.Errorf("failed to create prompt directory: %w", err)
	}

	promptPath := filepath.Join(promptDir, fmt.Sprintf("%s.md", agentName))
	if err := os.WriteFile(promptPath, []byte(promptText), 0644); err != nil {
		return "", fmt.Errorf("failed to write prompt file: %w", err)
	}

	return promptPath, nil
}

// getAgentDefinition finds an agent definition by name, copying templates if needed.
// Returns the prompt content or an error if not found.
func (c *CLI) getAgentDefinition(repoName, repoPath, agentDefName string) (string, error) {
	localAgentsDir := c.paths.RepoAgentsDir(repoName)
	reader := agents.NewReader(localAgentsDir, repoPath)
	definitions, err := reader.ReadAllDefinitions()
	if err != nil {
		return "", fmt.Errorf("failed to read agent definitions: %w", err)
	}

	// Find the definition
	for _, def := range definitions {
		if def.Name == agentDefName {
			return def.Content, nil
		}
	}

	// If not found, try to copy from templates and retry
	if _, err := os.Stat(localAgentsDir); os.IsNotExist(err) {
		if err := templates.CopyAgentTemplates(localAgentsDir); err != nil {
			return "", fmt.Errorf("failed to copy agent templates: %w", err)
		}
		// Re-read definitions
		definitions, err = reader.ReadAllDefinitions()
		if err != nil {
			return "", fmt.Errorf("failed to read agent definitions after template copy: %w", err)
		}
		for _, def := range definitions {
			if def.Name == agentDefName {
				return def.Content, nil
			}
		}
	}

	return "", fmt.Errorf("no %s agent definition found", agentDefName)
}

// appendDocsAndSlashCommands adds CLI documentation and slash commands to prompt text.
func (c *CLI) appendDocsAndSlashCommands(promptText string) string {
	if c.documentation != "" {
		promptText += fmt.Sprintf("\n\n---\n\n%s", c.documentation)
	}

	slashCommands := prompts.GetSlashCommandsPrompt()
	if slashCommands != "" {
		promptText += fmt.Sprintf("\n\n---\n\n%s", slashCommands)
	}

	return promptText
}

// writePromptFile writes the agent prompt to a temporary file and returns the path
func (c *CLI) writePromptFile(repoPath string, agentType state.AgentType, agentName string) (string, error) {
	// Get the complete prompt (default + custom + CLI docs)
	promptText, err := prompts.GetPrompt(repoPath, agentType, c.documentation)
	if err != nil {
		return "", fmt.Errorf("failed to get prompt: %w", err)
	}

	return c.savePromptToFile(agentName, promptText)
}

// writeMergeQueuePromptFile writes a merge-queue prompt file with tracking mode configuration.
// It reads the merge-queue prompt from agent definitions (configurable agent system).
func (c *CLI) writeMergeQueuePromptFile(repoPath string, agentName string, mqConfig state.MergeQueueConfig) (string, error) {
	repoName := filepath.Base(repoPath)

	promptText, err := c.getAgentDefinition(repoName, repoPath, "merge-queue")
	if err != nil {
		return "", err
	}

	// Add CLI documentation and slash commands
	promptText = c.appendDocsAndSlashCommands(promptText)

	// Add tracking mode configuration to the prompt
	trackingConfig := prompts.GenerateTrackingModePrompt(string(mqConfig.TrackMode))
	promptText = trackingConfig + "\n\n" + promptText

	return c.savePromptToFile(agentName, promptText)
}

// writePRShepherdPromptFile writes a pr-shepherd prompt file with fork context.
// It reads the pr-shepherd prompt from agent definitions (configurable agent system).
func (c *CLI) writePRShepherdPromptFile(repoPath string, agentName string, psConfig state.PRShepherdConfig, forkConfig state.ForkConfig) (string, error) {
	repoName := filepath.Base(repoPath)

	promptText, err := c.getAgentDefinition(repoName, repoPath, "pr-shepherd")
	if err != nil {
		return "", err
	}

	// Add CLI documentation and slash commands
	promptText = c.appendDocsAndSlashCommands(promptText)

	// Add fork workflow context
	forkContext := prompts.GenerateForkWorkflowPrompt(forkConfig.UpstreamOwner, forkConfig.UpstreamRepo, forkConfig.UpstreamOwner)
	promptText = forkContext + "\n\n" + promptText

	// Add tracking mode configuration to the prompt
	trackingConfig := prompts.GenerateTrackingModePrompt(string(psConfig.TrackMode))
	promptText = trackingConfig + "\n\n" + promptText

	return c.savePromptToFile(agentName, promptText)
}

// WorkerConfig holds configuration for creating worker prompts
type WorkerConfig struct {
	PushToBranch string           // Branch to push to instead of creating a new PR (for iterating on existing PRs)
	ForkConfig   state.ForkConfig // Fork configuration (if working in a fork)
}

// writeWorkerPromptFile writes a worker prompt file with optional configuration.
// It reads the worker prompt from agent definitions (configurable agent system).
func (c *CLI) writeWorkerPromptFile(repoPath string, agentName string, config WorkerConfig) (string, error) {
	repoName := filepath.Base(repoPath)

	promptText, err := c.getAgentDefinition(repoName, repoPath, "worker")
	if err != nil {
		return "", err
	}

	// Add CLI documentation and slash commands
	promptText = c.appendDocsAndSlashCommands(promptText)

	// Add fork workflow context if working in a fork
	if config.ForkConfig.IsFork {
		// Get the fork owner from the GitHub URL
		forkOwner := c.extractOwnerFromGitHubURL(repoPath)
		forkWorkflow := prompts.GenerateForkWorkflowPrompt(
			config.ForkConfig.UpstreamOwner,
			config.ForkConfig.UpstreamRepo,
			forkOwner,
		)
		promptText = forkWorkflow + "\n---\n\n" + promptText
	}

	// Add push-to configuration if specified
	if config.PushToBranch != "" {
		pushToConfig := fmt.Sprintf(`## PR Iteration Mode

**IMPORTANT: You are iterating on an existing PR, not creating a new one.**

Instead of creating a new PR, push your changes to the existing branch: %s

When your work is ready:
1. Commit your changes
2. Push to origin: git push origin %s
3. Signal completion with: multiclaude agent complete

Do NOT create a new PR. The existing PR will be updated automatically when you push.

---

`, config.PushToBranch, config.PushToBranch)
		promptText = pushToConfig + promptText
	}

	return c.savePromptToFile(agentName, promptText)
}

// setupOutputCapture sets up tmux pipe-pane to capture agent output to a log file.
// It creates the necessary directories and starts the pipe-pane command.
// The agentType should be "worker" for worker agents, anything else for system agents.
func (c *CLI) setupOutputCapture(tmuxSession, tmuxWindow, repoName, agentName, agentType string) error {
	// Determine log file path based on agent type
	isWorker := agentType == "worker" || agentType == "review"
	logFile := c.paths.AgentLogFile(repoName, agentName, isWorker)

	// Ensure directory exists
	logDir := filepath.Dir(logFile)
	if err := os.MkdirAll(logDir, 0755); err != nil {
		return fmt.Errorf("failed to create output directory: %w", err)
	}

	// Set up pipe-pane
	tmuxClient := tmux.NewClient()
	if err := tmuxClient.StartPipePane(context.Background(), tmuxSession, tmuxWindow, logFile); err != nil {
		return fmt.Errorf("failed to start output capture: %w", err)
	}

	return nil
}

// startClaudeInTmux starts Claude Code in a tmux window with the given configuration
// Returns the PID of the Claude process
func (c *CLI) startClaudeInTmux(binaryPath, tmuxSession, tmuxWindow, workDir, sessionID, promptFile, repoName string, initialMessage string) (int, error) {
	// Build Claude command - uses global ~/.claude/ for auth and slash commands are embedded in prompts
	claudeCmd := fmt.Sprintf("%s --session-id %s --dangerously-skip-permissions", binaryPath, sessionID)

	// Add prompt file if provided
	if promptFile != "" {
		claudeCmd += fmt.Sprintf(" --append-system-prompt-file %s", promptFile)
	}

	// Send command to tmux window
	target := fmt.Sprintf("%s:%s", tmuxSession, tmuxWindow)
	cmd := exec.Command("tmux", "send-keys", "-t", target, claudeCmd, "C-m")
	if err := cmd.Run(); err != nil {
		return 0, fmt.Errorf("failed to start Claude in tmux: %w", err)
	}

	// Wait a moment for Claude to start
	time.Sleep(500 * time.Millisecond)

	// Get the PID of the Claude process
	tmuxClient := tmux.NewClient()
	pid, err := tmuxClient.GetPanePID(context.Background(), tmuxSession, tmuxWindow)
	if err != nil {
		// Non-fatal - we'll just not have the PID
		fmt.Printf("Warning: failed to get Claude PID: %v\n", err)
		pid = 0
	}

	// If there's an initial message, send it after Claude is ready
	if initialMessage != "" {
		// Wait a bit more for Claude to fully initialize
		time.Sleep(1 * time.Second)

		// Send message using atomic method to avoid race conditions (issue #63)
		// The atomic method sends text + Enter in a single exec call
		if err := tmuxClient.SendKeysLiteralWithEnter(context.Background(), tmuxSession, tmuxWindow, initialMessage); err != nil {
			return pid, fmt.Errorf("failed to send initial message to Claude: %w", err)
		}
	}

	return pid, nil
}

// bugReport generates a diagnostic bug report with redacted sensitive information
func (c *CLI) bugReport(args []string) error {
	flags, positionalArgs := ParseFlags(args)

	// Check for verbose flag
	verbose := flags["verbose"] == "true" || flags["v"] == "true"

	// Get optional description from positional args
	description := ""
	if len(positionalArgs) > 0 {
		description = strings.Join(positionalArgs, " ")
	}

	// Create collector and generate report
	collector := bugreport.NewCollector(c.paths, Version)
	report, err := collector.Collect(description, verbose)
	if err != nil {
		return fmt.Errorf("failed to collect diagnostic information: %w", err)
	}

	// Format as Markdown
	markdown := bugreport.FormatMarkdown(report)

	// Check if output file specified
	if outputFile, ok := flags["output"]; ok {
		if err := os.WriteFile(outputFile, []byte(markdown), 0644); err != nil {
			return fmt.Errorf("failed to write report to %s: %w", outputFile, err)
		}
		fmt.Printf("Bug report written to: %s\n", outputFile)
		return nil
	}

	// Print to stdout
	fmt.Print(markdown)
	return nil
}

// listBranchesWithPrefix returns all local branches with the given prefix
func (c *CLI) listBranchesWithPrefix(repoPath, prefix string) ([]string, error) {
	cmd := exec.Command("git", "branch", "--list", prefix+"*")
	cmd.Dir = repoPath
	output, err := cmd.Output()
	if err != nil {
		return nil, err
	}

	var branches []string
	for _, line := range strings.Split(string(output), "\n") {
		branch := strings.TrimSpace(line)
		branch = strings.TrimPrefix(branch, "* ") // Remove current branch marker
		if branch != "" {
			branches = append(branches, branch)
		}
	}
	return branches, nil
}

// deleteBranch deletes a local git branch
func (c *CLI) deleteBranch(repoPath, branch string) error {
	cmd := exec.Command("git", "branch", "-D", branch)
	cmd.Dir = repoPath
	return cmd.Run()
}

// extractOwnerFromGitHubURL extracts the owner from a repository's origin URL.
// It first tries to get the origin URL from git remote, then parses it.
func (c *CLI) extractOwnerFromGitHubURL(repoPath string) string {
	cmd := exec.Command("git", "remote", "get-url", "origin")
	cmd.Dir = repoPath
	output, err := cmd.Output()
	if err != nil {
		return ""
	}

	originURL := strings.TrimSpace(string(output))
	owner, _, err := fork.ParseGitHubURL(originURL)
	if err != nil {
		return ""
	}
	return owner
}