Function bodies 590 total

func NewInputCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "input",
		Short: "Manage phase input artifacts",
		Long: `Manage phase input artifacts.

Input commands allow you to add, modify, remove, and list input artifacts
for project phases. Artifacts are managed using zero-based indices.`,
	}

	cmd.AddCommand(newInputAddCmd())
	cmd.AddCommand(newInputSetCmd())
	cmd.AddCommand(newInputRemoveCmd())
	cmd.AddCommand(newInputListCmd())

	return cmd
}

func newInputAddCmd() *cobra.Command {
	var phaseName, artifactType, path string
	var approved bool

	cmd := &cobra.Command{
		Use:   "add",
		Short: "Add input artifact to phase",
		Long: `Add an input artifact to a phase.

Creates a new input artifact with the specified type and path.
The artifact is appended to the phase's input list.

Examples:
  # Add context artifact to planning phase
  sow input add --type context --path context/research.md --phase planning

  # Add with approval flag
  sow input add --type context --path context/doc.md --approved --phase planning

  # Use active phase (defaults to current state)
  sow input add --type context --path context/design.md`,
		RunE: func(cmd *cobra.Command, _ []string) error {
			return runInputAdd(cmd, phaseName, artifactType, path, approved)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")
	cmd.Flags().StringVar(&artifactType, "type", "", "Artifact type (required)")
	cmd.Flag

func newInputSetCmd() *cobra.Command {
	var phaseName string
	var index int

	cmd := &cobra.Command{
		Use:   "set <field-path> <value>",
		Short: "Set field on input artifact by index",
		Long: `Set a field on an input artifact using its index.

Supports both direct fields and metadata fields using dot notation:
  - Direct fields: type, path, approved
  - Metadata fields: metadata.* (any custom field)

Examples:
  # Set approved field
  sow input set --index 0 approved true --phase planning

  # Set metadata field
  sow input set --index 0 metadata.source external --phase planning

  # Set nested metadata
  sow input set --index 0 metadata.reviewer.name orchestrator --phase planning`,
		Args: cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			return runInputSet(cmd, args, phaseName, index)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")
	cmd.Flags().IntVar(&index, "index", -1, "Artifact index (requir

func newInputRemoveCmd() *cobra.Command {
	var phaseName string
	var index int

	cmd := &cobra.Command{
		Use:   "remove",
		Short: "Remove input artifact by index",
		Long: `Remove an input artifact from a phase by its index.

The artifact at the specified index is removed from the phase's input list.
Indices of subsequent artifacts are shifted down.

Examples:
  # Remove first input
  sow input remove --index 0 --phase planning

  # Remove from active phase
  sow input remove --index 1`,
		RunE: func(cmd *cobra.Command, _ []string) error {
			return runInputRemove(cmd, phaseName, index)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")
	cmd.Flags().IntVar(&index, "index", -1, "Artifact index (required)")

	_ = cmd.MarkFlagRequired("index")

	return cmd
}

func newInputListCmd() *cobra.Command {
	var phaseName string

	cmd := &cobra.Command{
		Use:   "list",
		Short: "List input artifacts for phase",
		Long: `List all input artifacts for a phase.

Displays artifacts with their indices and details including type, path,
approval status, and metadata.

Examples:
  # List inputs for planning phase
  sow input list --phase planning

  # List inputs for active phase
  sow input list`,
		RunE: func(cmd *cobra.Command, _ []string) error {
			return runInputList(cmd, phaseName)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")

	return cmd
}

func runInputAdd(cmd *cobra.Command, phaseName, artifactType, path string, approved bool) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Create artifact
	artifact := project.ArtifactState{
		Type:       artifactType,
		Path:       path,
		Approved:   approved,
		Created_at: time.Now(),
		Metadata: 

func runInputSet(cmd *cobra.Command, args []string, phaseName string, index int) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Get field path and value from args
	fieldPath := args[0]
	value := args[1]

	// Wrap artifacts in state.Artifact for field path mutation
	artifacts := make([]state.Artifac

func runInputRemove(cmd *cobra.Command, phaseName string, index int) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Validate index
	if err := cmdutil.IndexInRange(len(phaseState.Inputs), index); err != nil {
		return err
	}

	// Remove artifact by index
	phaseState.Inputs = append(phaseState.Inputs

func runInputList(cmd *cobra.Command, phaseName string) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Convert to state.Artifact for formatting
	artifacts := make([]state.Artifact, len(phaseState.Inputs))
	for i, a := range phaseState.Inputs {
		artifacts[i] = state.Artifact{ArtifactState: a}
	}

	

func newCheckCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "check <number>",
		Short: "Check if an issue has linked branches (claimed or available)",
		Long: `Check if an issue has linked branches to determine if it's available or claimed.

Issues with linked branches are considered "claimed" - someone is already
working on them. Issues without linked branches are "available" for claiming.

Examples:
  # Check if issue #123 is available
  sow issue check 123`,
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			number, err := strconv.Atoi(args[0])
			if err != nil {
				return fmt.Errorf("invalid issue number: %s", args[0])
			}

			// Create GitHub client
			gh, err := git.NewGitHubClient()
			if err != nil {
				return err
			}

			// Get issue details
			issue, err := gh.GetIssue(number)
			if err != nil {
				return err
			}

			// Check for sow label
			if !issue.HasLabel("sow") {
				cmd.Printf("⚠️  Warning: Issue #%d does not have the

func printCheckStatus(cmd *cobra.Command, issue *git.Issue, branches []git.LinkedBranch) {
	out := cmd.OutOrStdout()

	_, _ = fmt.Fprintf(out, "Issue #%d: %s\n", issue.Number, issue.Title)
	_, _ = fmt.Fprintf(out, "State: %s\n", issue.State)
	_, _ = fmt.Fprintf(out, "URL: %s\n\n", issue.URL)

	if len(branches) == 0 {
		// Available
		_, _ = fmt.Fprintf(out, "Status: ✓ Available\n")
		_, _ = fmt.Fprintf(out, "No linked branches found. This issue is available for claiming.\n\n")
		_, _ = fmt.Fprintf(out, "To create a project from this issue:\n")
		_, _ = fmt.Fprintf(out, "  sow project init --issue %d\n", issue.Number)
	} else {
		// Claimed
		_, _ = fmt.Fprintf(out, "Status: ✗ Claimed\n")
		_, _ = fmt.Fprintf(out, "This issue has %d linked branch(es):\n\n", len(branches))

		for i, branch := range branches {
			_, _ = fmt.Fprintf(out, "%d. Branch: %s\n", i+1, branch.Name)
			_, _ = fmt.Fprintf(out, "   URL: %s\n", branch.URL)
		}

		_, _ = fmt.Fprintf(out, "\nTo work on this project:\n"

func NewIssueCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "issue",
		Short: "Manage GitHub issues as sow projects",
		Long: `Manage GitHub issues as sow projects.

Issues with the 'sow' label represent potential sow projects. This command
provides tools to discover, check, and manage these issues.

GitHub CLI Integration:
  Requires the GitHub CLI (gh) to be installed and authenticated.
  Install: https://cli.github.com/
  Authenticate: gh auth login

Commands:
  list   - List issues with 'sow' label
  show   - Show details of a specific issue
  check  - Check if an issue has linked branches (claimed or available)`,
	}

	// Add subcommands
	cmd.AddCommand(newListCmd())
	cmd.AddCommand(newShowCmd())
	cmd.AddCommand(newCheckCmd())

	return cmd
}

func newListCmd() *cobra.Command {
	var state string

	cmd := &cobra.Command{
		Use:   "list",
		Short: "List issues with 'sow' label",
		Long: `List all issues with the 'sow' label.

These issues represent available sow projects. To check if a specific issue
has already been claimed, use 'sow issue check <number>'.

Examples:
  # List all open sow issues
  sow issue list

  # List all sow issues (open and closed)
  sow issue list --state all

  # List only closed sow issues
  sow issue list --state closed`,
		RunE: func(cmd *cobra.Command, _ []string) error {
			// Create GitHub client
			gh, err := git.NewGitHubClient()
			if err != nil {
				return err
			}

			issues, err := gh.ListIssues("sow", state)
			if err != nil {
				return err
			}

			if len(issues) == 0 {
				cmd.Printf("No %s issues with 'sow' label found.\n", state)
				return nil
			}

			printIssuesTable(cmd, issues)
			return nil
		},
	}

	cmd.Flags().StringVar(&state, "state", "open", "Filter by state: open, closed

func printIssuesTable(cmd *cobra.Command, issues []git.Issue) {
	out := cmd.OutOrStdout()

	// Header
	_, _ = fmt.Fprintf(out, "%-8s %-6s %s\n", "NUMBER", "STATE", "TITLE")
	_, _ = fmt.Fprintf(out, "%-8s %-6s %s\n",
		strings.Repeat("─", 8),
		strings.Repeat("─", 6),
		strings.Repeat("─", 50),
	)

	// Rows
	for _, issue := range issues {
		_, _ = fmt.Fprintf(out, "%-8d %-6s %s\n", issue.Number, issue.State, issue.Title)
	}

	_, _ = fmt.Fprintf(out, "\nTotal: %d issue(s)\n", len(issues))
	_, _ = fmt.Fprintf(out, "Use 'sow issue check <number>' to see if an issue is available or claimed.\n")
}

func newShowCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "show <number>",
		Short: "Show details of a specific issue",
		Long: `Show detailed information about a GitHub issue.

Displays the issue title, state, labels, and body. Useful for reviewing
an issue before creating a project from it.

Examples:
  # Show issue #123
  sow issue show 123`,
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			number, err := strconv.Atoi(args[0])
			if err != nil {
				return fmt.Errorf("invalid issue number: %s", args[0])
			}

			// Create GitHub client
			gh, err := git.NewGitHubClient()
			if err != nil {
				return err
			}

			issue, err := gh.GetIssue(number)
			if err != nil {
				return err
			}

			printIssueDetails(cmd, issue)
			return nil
		},
	}

	return cmd
}

func printIssueDetails(cmd *cobra.Command, issue *git.Issue) {
	out := cmd.OutOrStdout()

	// Header
	_, _ = fmt.Fprintf(out, "Issue #%d: %s\n", issue.Number, issue.Title)
	_, _ = fmt.Fprintf(out, "%s\n\n", strings.Repeat("=", 60))

	// State
	_, _ = fmt.Fprintf(out, "State: %s\n", issue.State)

	// Labels
	var labels []string
	for _, l := range issue.Labels {
		labels = append(labels, l.Name)
	}
	_, _ = fmt.Fprintf(out, "Labels: %s\n", strings.Join(labels, ", "))

	// URL
	_, _ = fmt.Fprintf(out, "URL: %s\n\n", issue.URL)

	// Body
	if issue.Body != "" {
		_, _ = fmt.Fprintf(out, "Description:\n")
		_, _ = fmt.Fprintf(out, "%s\n", strings.Repeat("-", 60))
		_, _ = fmt.Fprintf(out, "%s\n", issue.Body)
	} else {
		_, _ = fmt.Fprintf(out, "Description: (none)\n")
	}

	// Check for sow label
	if !issue.HasLabel("sow") {
		_, _ = fmt.Fprintf(out, "\n⚠️  Warning: This issue does not have the 'sow' label.\n")
		_, _ = fmt.Fprintf(out, "   Add it via: gh issue edit %d --add-label sow\n", issu

func NewOutputCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "output",
		Short: "Manage phase output artifacts",
		Long: `Manage phase output artifacts.

Output commands allow you to add, modify, remove, and list output artifacts
for project phases. Artifacts are managed using zero-based indices.`,
	}

	cmd.AddCommand(newOutputAddCmd())
	cmd.AddCommand(newOutputSetCmd())
	cmd.AddCommand(newOutputRemoveCmd())
	cmd.AddCommand(newOutputListCmd())

	return cmd
}

func newOutputAddCmd() *cobra.Command {
	var phaseName, artifactType, path string
	var approved bool

	cmd := &cobra.Command{
		Use:   "add",
		Short: "Add output artifact to phase",
		Long: `Add an output artifact to a phase.

Creates a new output artifact with the specified type and path.
The artifact is appended to the phase's output list.

Examples:
  # Add task_list artifact to planning phase
  sow output add --type task_list --path planning/tasks.md --phase planning

  # Add with approval flag
  sow output add --type review --path review/report.md --approved --phase review

  # Use active phase (defaults to current state)
  sow output add --type task_list --path planning/breakdown.md`,
		RunE: func(cmd *cobra.Command, _ []string) error {
			return runOutputAdd(cmd, phaseName, artifactType, path, approved)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")
	cmd.Flags().StringVar(&artifactType, "type", "", "Artifact type (requi

func newOutputSetCmd() *cobra.Command {
	var phaseName string
	var index int

	cmd := &cobra.Command{
		Use:   "set <field-path> <value>",
		Short: "Set field on output artifact by index",
		Long: `Set a field on an output artifact using its index.

Supports both direct fields and metadata fields using dot notation:
  - Direct fields: type, path, approved
  - Metadata fields: metadata.* (any custom field)

Examples:
  # Set approved field
  sow output set --index 0 approved true --phase planning

  # Set metadata field
  sow output set --index 0 metadata.assessment pass --phase review

  # Set nested metadata
  sow output set --index 0 metadata.reviewer.name orchestrator --phase review`,
		Args: cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			return runOutputSet(cmd, args, phaseName, index)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")
	cmd.Flags().IntVar(&index, "index", -1, "Artifact index (req

func newOutputRemoveCmd() *cobra.Command {
	var phaseName string
	var index int

	cmd := &cobra.Command{
		Use:   "remove",
		Short: "Remove output artifact by index",
		Long: `Remove an output artifact from a phase by its index.

The artifact at the specified index is removed from the phase's output list.
Indices of subsequent artifacts are shifted down.

Examples:
  # Remove first output
  sow output remove --index 0 --phase planning

  # Remove from active phase
  sow output remove --index 1`,
		RunE: func(cmd *cobra.Command, _ []string) error {
			return runOutputRemove(cmd, phaseName, index)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")
	cmd.Flags().IntVar(&index, "index", -1, "Artifact index (required)")

	_ = cmd.MarkFlagRequired("index")

	return cmd
}

func newOutputListCmd() *cobra.Command {
	var phaseName string

	cmd := &cobra.Command{
		Use:   "list",
		Short: "List output artifacts for phase",
		Long: `List all output artifacts for a phase.

Displays artifacts with their indices and details including type, path,
approval status, and metadata.

Examples:
  # List outputs for planning phase
  sow output list --phase planning

  # List outputs for active phase
  sow output list`,
		RunE: func(cmd *cobra.Command, _ []string) error {
			return runOutputList(cmd, phaseName)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "", "Target phase (defaults to active phase)")

	return cmd
}

func runOutputAdd(cmd *cobra.Command, phaseName, artifactType, path string, approved bool) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Create artifact
	artifact := project.ArtifactState{
		Type:       artifactType,
		Path:       path,
		Approved:   approved,
		Created_at: time.Now(),
		Metadata:

func runOutputSet(cmd *cobra.Command, args []string, phaseName string, index int) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Get field path and value from args
	fieldPath := args[0]
	value := args[1]

	// Wrap artifacts in state.Artifact for field path mutation
	artifacts := make([]state.Artifa

func runOutputRemove(cmd *cobra.Command, phaseName string, index int) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Validate index
	if err := cmdutil.IndexInRange(len(phaseState.Outputs), index); err != nil {
		return err
	}

	// Remove artifact by index
	phaseState.Outputs = append(phaseState.Out

func runOutputList(cmd *cobra.Command, phaseName string) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(proj)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := proj.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Convert to state.Artifact for formatting
	artifacts := make([]state.Artifact, len(phaseState.Outputs))
	for i, a := range phaseState.Outputs {
		artifacts[i] = state.Artifact{ArtifactState: a}
	}

func NewPhaseCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "phase",
		Short: "Manage project phases",
		Long: `Manage project phases.

Phase commands allow you to inspect and modify phase state, including
direct fields (status, enabled) and metadata fields used by state machine
guards.`,
	}

	cmd.AddCommand(newPhaseSetCmd())

	return cmd
}

func newPhaseSetCmd() *cobra.Command {
	var phaseName string

	cmd := &cobra.Command{
		Use:   "set <field-path> <value>",
		Short: "Set phase field value",
		Long: `Set a phase field value using dot notation.

Supports:
  - Direct fields: status, enabled
  - Metadata fields: metadata.* (any custom field)

The --phase flag specifies which phase to modify. If omitted, defaults to
the currently active phase based on the state machine state.

Examples:
  # Set direct field on active phase
  sow phase set status in_progress

  # Set direct field with explicit phase
  sow phase set enabled false --phase planning

  # Set metadata field (used by state machine guards)
  sow phase set metadata.tasks_approved true --phase implementation

  # Set nested metadata
  sow phase set metadata.complexity.level high`,
		Args: cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			return runPhaseSet(cmd, args, phaseName)
		},
	}

	cmd.Flags().StringVarP(&phaseName, "phase", "p", "

func runPhaseSet(cmd *cobra.Command, args []string, phaseName string) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if sow is initialized
	if !ctx.IsInitialized() {
		return fmt.Errorf("sow not initialized. Run 'sow init' first")
	}

	// Load project
	project, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		if strings.Contains(err.Error(), "no such file") {
			return fmt.Errorf("no active project found")
		}
		return fmt.Errorf("failed to load project: %w", err)
	}

	// Determine target phase
	if phaseName == "" {
		phaseName = getActivePhase(project)
		if phaseName == "" {
			return fmt.Errorf("could not determine active phase")
		}
	}

	// Get phase from map
	phaseState, exists := project.Phases[phaseName]
	if !exists {
		return fmt.Errorf("phase not found: %s", phaseName)
	}

	// Wrap in Phase type for field path mutation
	phase := &state.Phase{
		PhaseState: phaseState,
	}

	// Set field using field path parser
	fieldPath := args[0]
	value := args[1

func getActivePhase(project *state.Project) string {
	// Find the phase with status="in_progress"
	// The state machine design ensures only one phase is in_progress at a time
	for phaseName, phase := range project.Phases {
		if phase.Status == "in_progress" {
			return phaseName
		}
	}
	return ""
}

func newDeleteCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "delete",
		Short: "Delete the current project",
		Long: `Delete the project directory (.sow/project).

This removes all project state, tasks, and artifacts. Use this when:
  - Project is complete and PR is merged
  - Project is abandoned
  - Starting over from scratch

Note: This does not delete the worktree or branch. Use git commands for that.

Example:
  sow project delete`,
		RunE: runDelete,
	}
}

func runDelete(cmd *cobra.Command, _ []string) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Check if project exists
	projectDir := filepath.Join(ctx.RepoRoot(), ".sow", "project")
	if _, err := os.Stat(projectDir); os.IsNotExist(err) {
		return fmt.Errorf("no project exists")
	}

	// Delete project directory
	if err := os.RemoveAll(projectDir); err != nil {
		return fmt.Errorf("failed to delete project: %w", err)
	}

	fmt.Fprintln(os.Stderr, "✓ Deleted project")
	return nil
}

func NewProjectCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "project [-- <claude-flags>...]",
		Short: "Create or continue a project (interactive)",
		Long: `Interactive wizard for creating or continuing projects.

The wizard guides you through:
  - Creating new projects from GitHub issues or branch names
  - Continuing existing projects
  - Selecting project types and providing descriptions

Claude Code Flags:
  Pass additional flags to Claude Code using -- separator.
  All flags after -- are forwarded directly to the claude CLI.

Examples:
  sow project                                    # Launch interactive wizard
  sow project -- --model opus                    # Use specific model
  sow project -- --verbose                       # Enable verbose output
  sow project -- --model opus --verbose          # Multiple flags
  sow project -- --dangerously-skip-permissions  # Advanced flags`,
		RunE: runWizard,
		// No Args validator - allows pass-through flags after --
	}

	// 

func newSetCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "set <field-path> <value>",
		Short: "Set project field value",
		Long: `Set a project field using dot notation.

Supports both direct fields and metadata fields:
  - Direct fields: description, name, branch
  - Metadata fields: metadata.key or metadata.nested.key

Examples:
  sow project set description "Updated description"
  sow project set metadata.custom_field custom_value
  sow project set metadata.priority high
  sow project set metadata.score 42`,
		Args: cobra.ExactArgs(2),
		RunE: runSet,
	}
}

func runSet(cmd *cobra.Command, args []string) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Load project
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		return fmt.Errorf("failed to load project: %w", err)
	}

	fieldPath := args[0]
	value := args[1]

	// Use field path parser from Task 010
	// SetField works on the embedded ProjectState
	if err := cmdutil.SetField(&proj.ProjectState, fieldPath, value); err != nil {
		return fmt.Errorf("failed to set field: %w", err)
	}

	// Save project
	if err := proj.Save(cmd.Context()); err != nil {
		return fmt.Errorf("failed to save project: %w", err)
	}

	fmt.Fprintf(os.Stderr, "✓ Set %s = %s\n", fieldPath, value)
	return nil
}

func initializeProject(
	ctx *sow.Context,
	branch string,
	description string,
	issue *git.Issue,
	knowledgeFiles []string,
) (*state.Project, error) {
	// Get the worktree root path
	worktreePath := ctx.RepoRoot()

	// Ensure .sow/project directory exists in worktree
	projectDir := filepath.Join(worktreePath, ".sow", "project")
	if err := os.MkdirAll(projectDir, 0755); err != nil {
		return nil, fmt.Errorf("failed to create project directory: %w", err)
	}

	// Always create context directory for project files
	contextDir := filepath.Join(projectDir, "context")
	if err := os.MkdirAll(contextDir, 0755); err != nil {
		return nil, fmt.Errorf("failed to create context directory: %w", err)
	}

	// Recreate context now that .sow directory exists
	// This ensures ctx.FS() is properly initialized before calling state.Create
	ctx, err := sow.NewContext(worktreePath)
	if err != nil {
		return nil, fmt.Errorf("failed to recreate context after directory creation: %w", err)
	}

	// Prepare initia

func generateNewProjectPrompt(proj *state.Project, initialPrompt string) (string, error) {
	var buf strings.Builder

	// Layer 1: Base Orchestrator Introduction
	baseOrch, err := templates.Render(prompts.FS, "templates/greet/orchestrator.md", nil)
	if err != nil {
		return "", fmt.Errorf("failed to render base orchestrator prompt: %w", err)
	}
	buf.WriteString(baseOrch)
	buf.WriteString("\n\n---\n\n")

	// Layer 2: Project Type Orchestrator Prompt
	projectTypePrompt := proj.Config().OrchestratorPrompt(proj)
	if projectTypePrompt != "" {
		buf.WriteString(projectTypePrompt)
		buf.WriteString("\n\n---\n\n")
	}

	// Layer 3: Initial State Prompt
	initialState := proj.Statechart.Current_state
	statePrompt := proj.Config().GetStatePrompt(initialState, proj)
	if statePrompt != "" {
		buf.WriteString(statePrompt)
		buf.WriteString("\n\n---\n\n")
	}

	// Add initial user prompt if provided
	if initialPrompt != "" {
		buf.WriteString("## User's Initial Request\n\n")
		buf.WriteString(initialPro

func generateContinuePrompt(proj *state.Project) (string, error) {
	var buf strings.Builder

	// Layer 1: Base Orchestrator Introduction
	baseOrch, err := templates.Render(prompts.FS, "templates/greet/orchestrator.md", nil)
	if err != nil {
		return "", fmt.Errorf("failed to render base orchestrator prompt: %w", err)
	}
	buf.WriteString(baseOrch)
	buf.WriteString("\n\n---\n\n")

	// Layer 2: Project Type Orchestrator Prompt
	projectTypePrompt := proj.Config().OrchestratorPrompt(proj)
	if projectTypePrompt != "" {
		buf.WriteString(projectTypePrompt)
		buf.WriteString("\n\n---\n\n")
	}

	// Layer 3: Current State Prompt
	currentState := proj.Statechart.Current_state
	statePrompt := proj.Config().GetStatePrompt(currentState, proj)
	if statePrompt != "" {
		buf.WriteString(statePrompt)
		buf.WriteString("\n")
	}

	return buf.String(), nil
}

func launchClaudeCode(
	cmd *cobra.Command,
	ctx *sow.Context,
	prompt string,
	claudeFlags []string,
) error {

func newStatusCmd() *cobra.Command {
	return &cobra.Command{
		Use:   "status",
		Short: "Show current project status",
		Long: `Display the current project state in a readable format.

Shows:
  - Project header (name, branch, type, state)
  - Phase list with status and task progress
  - Task list for the current/active phase

Example:
  sow project status`,
		RunE: runStatus,
	}
}

func runStatus(cmd *cobra.Command, _ []string) error {
	ctx := cmdutil.GetContext(cmd.Context())

	// Load project state
	proj, err := cmdutil.LoadProject(cmd.Context(), ctx)
	if err != nil {
		return fmt.Errorf("no active project")
	}

	// Output to stdout
	out := cmd.OutOrStdout()

	// Project header
	_, _ = fmt.Fprintf(out, "Project: %s\n", proj.Name)
	_, _ = fmt.Fprintf(out, "Branch: %s\n", proj.Branch)
	_, _ = fmt.Fprintf(out, "Type: %s\n", proj.Type)
	_, _ = fmt.Fprintln(out)
	_, _ = fmt.Fprintf(out, "State: %s\n", proj.Statechart.Current_state)
	_, _ = fmt.Fprintln(out)

	// Phases section
	_, _ = fmt.Fprintln(out, "Phases:")
	phaseOrder := []string{"implementation", "review", "finalize"}
	for _, phaseName := range phaseOrder {
		phase, exists := proj.Phases[phaseName]
		if !exists {
			continue
		}

		// Count completed tasks
		completed, total := countTasksByStatus(phase)

		_, _ = fmt.Fprint(out, formatPhaseLine(phaseName, phase.Status, completed, total))
	}
	_, _ = fmt.Fprin

func countTasksByStatus(phase projschema.PhaseState) (completed, total int) {
	for _, task := range phase.Tasks {
		total++
		if task.Status == "completed" {
			completed++
		}
	}
	return
}

func inferCurrentPhase(stateName string) string {
	// Check for known prefixes
	prefixes := map[string]string{
		"Implementation": "implementation",
		"Review":         "review",
		"Finalize":       "finalize",
	}

	for prefix, phase := range prefixes {
		if len(stateName) >= len(prefix) && stateName[:len(prefix)] == prefix {
			return phase
		}
	}

	// Default to implementation
	return "implementation"
}

func newWizardCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "wizard",
		Short: "Create or continue a project (interactive)",
		Long: `Launch the interactive project wizard to create or continue a project.

The wizard will guide you through:
- Creating a new project from an issue or branch
- Continuing an existing project
- Configuring project settings

Claude Code Flags:
  Use -- to pass additional flags to the Claude Code CLI:
    sow project wizard -- --model opus --verbose`,
		Args: cobra.NoArgs,
		RunE: runWizard,
	}

	return cmd
}

func runWizard(cmd *cobra.Command, args []string) error {
	mainCtx := cmdutil.GetContext(cmd.Context())

	if !mainCtx.IsInitialized() {
		fmt.Fprintln(os.Stderr, "Error: sow not initialized in this repository")
		fmt.Fprintln(os.Stderr, "Run: sow init")
		return fmt.Errorf("not initialized")
	}

	// Extract Claude Code flags (everything after --)
	// When -- is used, all args after it are passed through in args parameter
	var claudeFlags []string
	if cmd.ArgsLenAtDash() >= 0 {
		// Everything in args after the dash index is a Claude flag
		claudeFlags = args[cmd.ArgsLenAtDash():]
	}

	wizard := NewWizard(cmd, mainCtx, claudeFlags)
	return wizard.Run()
}

func debugLog(component, format string, args ...interface{}) {
	if os.Getenv("SOW_DEBUG") == "1" {
		message := fmt.Sprintf(format, args...)
		fmt.Fprintf(os.Stderr, "[DEBUG] %s: %s\n", component, message)
	}
}

func normalizeName(name string) string {
	// 1. Trim leading/trailing whitespace
	name = strings.TrimSpace(name)

	// 2. Convert to lowercase
	name = strings.ToLower(name)

	// 3. Replace spaces with hyphens
	name = strings.ReplaceAll(name, " ", "-")

	// 4. Remove invalid characters (keep only: a-z, 0-9, -, _)
	// This regex matches anything that is NOT alphanumeric, hyphen, or underscore
	invalidCharsRegex := regexp.MustCompile(`[^a-z0-9\-_]+`)
	name = invalidCharsRegex.ReplaceAllString(name, "")

	// 5. Collapse multiple consecutive hyphens into single hyphen
	multipleHyphensRegex := regexp.MustCompile(`-+`)
	name = multipleHyphensRegex.ReplaceAllString(name, "-")

	// 6. Remove leading/trailing hyphens
	name = strings.Trim(name, "-")

	// 7. Return normalized name
	return name
}

func getTypePrefix(projectType string) string {
	if config, exists := projectTypes[projectType]; exists {
		return config.Prefix
	}
	return "feat/" // Default fallback
}

func getTypeOptions() []huh.Option[string] {
	// Return options in consistent order
	return []huh.Option[string]{
		huh.NewOption(projectTypes["standard"].Description, "standard"),
		huh.NewOption(projectTypes["exploration"].Description, "exploration"),
		huh.NewOption(projectTypes["design"].Description, "design"),
		huh.NewOption(projectTypes["breakdown"].Description, "breakdown"),
		huh.NewOption("Cancel", "cancel"),
	}
}

func showError(message string) error {
	// Skip interactive prompts in test mode
	if os.Getenv("SOW_TEST") == "1" {
		debugLog("Error", "%s", message)
		return nil
	}

	form := huh.NewForm(
		huh.NewGroup(
			huh.NewNote().
				Title("Error").
				Description(message),
		),
	)

	// Run the form (user presses Enter to acknowledge)
	_ = form.Run()

	// Return nil - error is shown, not propagated
	return nil
}

func withSpinner(title string, action func() error) error {
	// Skip spinner in test mode - just run action directly
	if os.Getenv("SOW_TEST") == "1" {
		debugLog("Spinner", "%s", title)
		return action()
	}

	var err error

	_ = spinner.New().
		Title(title).
		Action(func() {
			err = action()
		}).
		Run()

	return err
}