feat: status & priority tracking UI; edit view

ROADMAP.md

···
     - [x] `projects` - List all project names
 - [x] Tag management system
     - [x] `tags` - List all tag names
-- [ ] Status tracking - todo, in-progress, blocked, done, abandoned
-- [ ] Priority system - High/medium/low or numeric scales
+- [x] Status tracking - todo, in-progress, blocked, done, abandoned
+    - [x] Status indicators in task list view (colored unicode/non-emoji symbols)
+- [x] Priority system - High/medium/low or numeric scales
+    - [x] Priority indicators in task list view (★★★ visual + color coding)
+- [x] Edit View
+    - [x] Interactive status picker in task edit view
+    - [x] Priority system toggle in task edit view (Text/Numeric/Legacy modes)
 - [ ] Due dates & scheduling - Including recurring tasks
 - [ ] Task dependencies - Task A blocks task B relationships
 

cmd/commands.go

···
 	viewCmd.Flags().Bool("no-metadata", false, "Hide creation/modification timestamps")
 	root.AddCommand(viewCmd)
 
-	root.AddCommand(&cobra.Command{
-		Use:   "update [task-id] [options...]",
+	updateCmd := &cobra.Command{
+		Use:   "update [task-id]",
 		Short: "Update task properties",
-		Args:  cobra.MinimumNArgs(1),
+		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
+			taskID := args[0]
+			description, _ := cmd.Flags().GetString("description")
+			status, _ := cmd.Flags().GetString("status")
+			priority, _ := cmd.Flags().GetString("priority")
+			project, _ := cmd.Flags().GetString("project")
+			due, _ := cmd.Flags().GetString("due")
+			addTags, _ := cmd.Flags().GetStringSlice("add-tag")
+			removeTags, _ := cmd.Flags().GetStringSlice("remove-tag")
+			
 			handler, err := handlers.NewTaskHandler()
 			if err != nil {
 				return err
 			}
 			defer handler.Close()
-			return handler.Update(cmd.Context(), args)
+			return handler.Update(cmd.Context(), taskID, description, status, priority, project, due, addTags, removeTags)
 		},
-	})
+	}
+	updateCmd.Flags().String("description", "", "Update task description")
+	updateCmd.Flags().String("status", "", "Update task status")
+	updateCmd.Flags().StringP("priority", "p", "", "Update task priority")
+	updateCmd.Flags().String("project", "", "Update task project")
+	updateCmd.Flags().StringP("due", "d", "", "Update due date (YYYY-MM-DD)")
+	updateCmd.Flags().StringSlice("add-tag", []string{}, "Add tags to task")
+	updateCmd.Flags().StringSlice("remove-tag", []string{}, "Remove tags from task")
+	root.AddCommand(updateCmd)
+
+	editCmd := &cobra.Command{
+		Use:     "edit [task-id]",
+		Short:   "Edit task interactively with status picker and priority toggle",
+		Aliases: []string{"e"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			taskID := args[0]
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.EditInteractive(cmd.Context(), taskID)
+		},
+	}
+	root.AddCommand(editCmd)
 
 	root.AddCommand(&cobra.Command{
 		Use:   "delete [task-id]",

internal/handlers/tasks.go

···
 	return taskList.Browse(ctx)
 }
 
-func (h *TaskHandler) Update(ctx context.Context, args []string) error {
-	if len(args) < 1 {
-		return fmt.Errorf("task ID required")
-	}
-
-	taskID := args[0]
+// Update updates a task using parsed flag values
+func (h *TaskHandler) Update(ctx context.Context, taskID, description, status, priority, project, due string, addTags, removeTags []string) error {
 	var task *models.Task
 	var err error
 
···
 		return fmt.Errorf("failed to find task: %w", err)
 	}
 
-	for i := 1; i < len(args); i++ {
-		arg := args[i]
-		switch {
-		case arg == "--description" && i+1 < len(args):
-			task.Description = args[i+1]
-			i++
-		case arg == "--status" && i+1 < len(args):
-			task.Status = args[i+1]
-			i++
-		case arg == "--priority" && i+1 < len(args):
-			task.Priority = args[i+1]
-			i++
-		case arg == "--project" && i+1 < len(args):
-			task.Project = args[i+1]
-			i++
-		case arg == "--due" && i+1 < len(args):
-			if dueTime, err := time.Parse("2006-01-02", args[i+1]); err == nil {
-				task.Due = &dueTime
-			}
-			i++
-		case strings.HasPrefix(arg, "--add-tag="):
-			tag := strings.TrimPrefix(arg, "--add-tag=")
-			if !slices.Contains(task.Tags, tag) {
-				task.Tags = append(task.Tags, tag)
-			}
-		case strings.HasPrefix(arg, "--remove-tag="):
-			tag := strings.TrimPrefix(arg, "--remove-tag=")
-			task.Tags = removeString(task.Tags, tag)
+	if description != "" {
+		task.Description = description
+	}
+	if status != "" {
+		task.Status = status
+	}
+	if priority != "" {
+		task.Priority = priority
+	}
+	if project != "" {
+		task.Project = project
+	}
+	if due != "" {
+		if dueTime, err := time.Parse("2006-01-02", due); err == nil {
+			task.Due = &dueTime
+		} else {
+			return fmt.Errorf("invalid due date format, use YYYY-MM-DD: %w", err)
 		}
+	}
+
+	for _, tag := range addTags {
+		if !slices.Contains(task.Tags, tag) {
+			task.Tags = append(task.Tags, tag)
+		}
+	}
+
+	for _, tag := range removeTags {
+		task.Tags = removeString(task.Tags, tag)
 	}
 
 	err = h.repos.Tasks.Update(ctx, task)
···
 	}
 
 	fmt.Printf("Task updated (ID: %d): %s\n", task.ID, task.Description)
+	return nil
+}
+
+// EditInteractive opens an interactive task editor with status picker and priority toggle
+func (h *TaskHandler) EditInteractive(ctx context.Context, taskID string) error {
+	var task *models.Task
+	var err error
+
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
+		task, err = h.repos.Tasks.Get(ctx, id)
+	} else {
+		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to find task: %w", err)
+	}
+
+	editor := ui.NewTaskEditor(task, h.repos.Tasks, ui.TaskEditOptions{})
+	updated, err := editor.Edit(ctx)
+	if err != nil {
+		if err.Error() == "edit cancelled" {
+			fmt.Println("Task edit cancelled")
+			return nil
+		}
+		return fmt.Errorf("failed to edit task: %w", err)
+	}
+
+	fmt.Printf("Task updated (ID: %d): %s\n", updated.ID, updated.Description)
+	fmt.Printf("Status: %s\n", ui.FormatStatusWithText(updated.Status))
+	if updated.Priority != "" {
+		fmt.Printf("Priority: %s\n", ui.FormatPriorityWithText(updated.Priority))
+	}
+	if updated.Project != "" {
+		fmt.Printf("Project: %s\n", updated.Project)
+	}
+
 	return nil
 }
 

internal/handlers/tasks_test.go

···
 			ctx := context.Background()
 			args := []string{"Task", "with", "flags"}
 			priority := "A"
-			project := "test-project" 
+			project := "test-project"
 			due := "2024-12-31"
 			tags := []string{"urgent", "work"}
 
···
 				t.Fatalf("Failed to get pending tasks: %v", err)
 			}
 
-			// Should have 2 tasks now (previous test created one)
 			if len(tasks) < 1 {
 				t.Errorf("Expected at least 1 task, got %d", len(tasks))
 			}
 
-			// Find the task we just created
 			var task *models.Task
 			for _, t := range tasks {
 				if t.Description == "Task with flags" {
···
 		}
 
 		t.Run("updates task by ID", func(t *testing.T) {
-			args := []string{strconv.FormatInt(id, 10), "--description", "Updated description"}
+			taskID := strconv.FormatInt(id, 10)
 
-			err := handler.Update(ctx, args)
+			err := handler.Update(ctx, taskID, "Updated description", "", "", "", "", []string{}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask failed: %v", err)
 			}
···
 		})
 
 		t.Run("updates task by UUID", func(t *testing.T) {
-			args := []string{task.UUID, "--status", "completed"}
+			taskID := task.UUID
 
-			err := handler.Update(ctx, args)
+			err := handler.Update(ctx, taskID, "", "completed", "", "", "", []string{}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask by UUID failed: %v", err)
 			}
···
 		})
 
 		t.Run("updates multiple fields", func(t *testing.T) {
-			args := []string{
-				strconv.FormatInt(id, 10),
-				"--description", "Multiple updates",
-				"--priority", "B",
-				"--project", "test",
-				"--due", "2024-12-31",
-			}
+			taskID := strconv.FormatInt(id, 10)
 
-			err := handler.Update(ctx, args)
+			err := handler.Update(ctx, taskID, "Multiple updates", "", "B", "test", "2024-12-31", []string{}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask with multiple fields failed: %v", err)
 			}
 
-			// Verify all updates
 			updatedTask, err := handler.repos.Tasks.Get(ctx, id)
 			if err != nil {
 				t.Fatalf("Failed to get updated task: %v", err)
···
 		})
 
 		t.Run("adds and removes tags", func(t *testing.T) {
-			args := []string{
-				strconv.FormatInt(id, 10),
-				"--add-tag=work",
-				"--add-tag=urgent",
-			}
+			taskID := strconv.FormatInt(id, 10)
 
-			err := handler.Update(ctx, args)
+			err := handler.Update(ctx, taskID, "", "", "", "", "", []string{"work", "urgent"}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask with add tags failed: %v", err)
 			}
···
 				t.Errorf("Expected 2 tags, got %d", len(updatedTask.Tags))
 			}
 
-			args = []string{
-				strconv.FormatInt(id, 10),
-				"--remove-tag=urgent",
-			}
+			taskID = strconv.FormatInt(id, 10)
 
-			err = handler.Update(ctx, args)
+			err = handler.Update(ctx, taskID, "", "", "", "", "", []string{}, []string{"urgent"})
 			if err != nil {
 				t.Errorf("UpdateTask with remove tag failed: %v", err)
 			}
···
 		})
 
 		t.Run("fails with missing task ID", func(t *testing.T) {
-			args := []string{}
-
-			err := handler.Update(ctx, args)
+			err := handler.Update(ctx, "", "", "", "", "", "", []string{}, []string{})
 			if err == nil {
 				t.Error("Expected error for missing task ID")
 			}
 
-			if !strings.Contains(err.Error(), "task ID required") {
-				t.Errorf("Expected error about required task ID, got: %v", err)
+			if !strings.Contains(err.Error(), "failed to find task") {
+				t.Errorf("Expected error about task not found, got: %v", err)
 			}
 		})
 
 		t.Run("fails with invalid task ID", func(t *testing.T) {
-			args := []string{"99999", "--description", "test"}
+			taskID := "99999"
 
-			err := handler.Update(ctx, args)
+			err := handler.Update(ctx, taskID, "test", "", "", "", "", []string{}, []string{})
 			if err == nil {
 				t.Error("Expected error for invalid task ID")
 			}

internal/models/models.go

···
 
 import (
 	"encoding/json"
+	"slices"
 	"time"
+)
+
+type TaskStatus string
+type TaskPriority string
+type TaskWeight int
+
+// TODO: Use [TaskStatus]
+const (
+	StatusTodo       = "todo"
+	StatusInProgress = "in-progress"
+	StatusBlocked    = "blocked"
+	StatusDone       = "done"
+	StatusAbandoned  = "abandoned"
+	StatusPending    = "pending"
+	StatusCompleted  = "completed"
+	StatusDeleted    = "deleted"
+)
+
+// TODO: Use [TaskPriority]
+const (
+	PriorityHigh   = "High"
+	PriorityMedium = "Medium"
+	PriorityLow    = "Low"
+)
+
+// TODO: Use [TaskWeight]
+const (
+	PriorityNumericMin = 1
+	PriorityNumericMax = 5
 )
 
 // Model defines the common interface that all domain models must implement
···
 // HasPriority returns true if the task has a priority set
 func (t *Task) HasPriority() bool {
 	return t.Priority != ""
+}
+
+// New status tracking methods
+func (t *Task) IsTodo() bool {
+	return t.Status == StatusTodo
+}
+
+func (t *Task) IsInProgress() bool {
+	return t.Status == StatusInProgress
+}
+
+func (t *Task) IsBlocked() bool {
+	return t.Status == StatusBlocked
+}
+
+func (t *Task) IsDone() bool {
+	return t.Status == StatusDone
+}
+
+func (t *Task) IsAbandoned() bool {
+	return t.Status == StatusAbandoned
+}
+
+// IsValidStatus returns true if the status is one of the defined valid statuses
+func (t *Task) IsValidStatus() bool {
+	validStatuses := []string{
+		StatusTodo, StatusInProgress, StatusBlocked, StatusDone, StatusAbandoned,
+		StatusPending, StatusCompleted, StatusDeleted, // legacy support
+	}
+	return slices.Contains(validStatuses, t.Status)
+}
+
+// IsValidPriority returns true if the priority is valid (text-based or numeric string)
+func (t *Task) IsValidPriority() bool {
+	if t.Priority == "" {
+		return true
+	}
+
+	textPriorities := []string{PriorityHigh, PriorityMedium, PriorityLow}
+	if slices.Contains(textPriorities, t.Priority) {
+		return true
+	}
+
+	if len(t.Priority) == 1 && t.Priority >= "A" && t.Priority <= "Z" {
+		return true
+	}
+
+	switch t.Priority {
+	case "1", "2", "3", "4", "5":
+		return true
+	}
+
+	return false
+}
+
+// GetPriorityWeight returns a numeric weight for sorting priorities
+//
+//	Higher numbers = higher priority
+func (t *Task) GetPriorityWeight() int {
+	switch t.Priority {
+	case PriorityHigh, "5":
+		return 5
+	case PriorityMedium, "4":
+		return 4
+	case PriorityLow, "3":
+		return 3
+	case "2":
+		return 2
+	case "1":
+		return 1
+	case "A":
+		return 26
+	case "B":
+		return 25
+	case "C":
+		return 24
+	default:
+		if len(t.Priority) == 1 && t.Priority >= "A" && t.Priority <= "Z" {
+			return int('Z' - t.Priority[0] + 1)
+		}
+		return 0
+	}
 }
 
 // IsWatched returns true if the movie has been watched

internal/models/models_test.go

···
 			}
 		})
 
+		t.Run("New Status Tracking Methods", func(t *testing.T) {
+			testCases := []struct {
+				status       string
+				isTodo       bool
+				isInProgress bool
+				isBlocked    bool
+				isDone       bool
+				isAbandoned  bool
+			}{
+				{StatusTodo, true, false, false, false, false},
+				{StatusInProgress, false, true, false, false, false},
+				{StatusBlocked, false, false, true, false, false},
+				{StatusDone, false, false, false, true, false},
+				{StatusAbandoned, false, false, false, false, true},
+				{"unknown", false, false, false, false, false},
+			}
+
+			for _, tc := range testCases {
+				task := &Task{Status: tc.status}
+
+				if task.IsTodo() != tc.isTodo {
+					t.Errorf("Status %s: expected IsTodo %v, got %v", tc.status, tc.isTodo, task.IsTodo())
+				}
+				if task.IsInProgress() != tc.isInProgress {
+					t.Errorf("Status %s: expected IsInProgress %v, got %v", tc.status, tc.isInProgress, task.IsInProgress())
+				}
+				if task.IsBlocked() != tc.isBlocked {
+					t.Errorf("Status %s: expected IsBlocked %v, got %v", tc.status, tc.isBlocked, task.IsBlocked())
+				}
+				if task.IsDone() != tc.isDone {
+					t.Errorf("Status %s: expected IsDone %v, got %v", tc.status, tc.isDone, task.IsDone())
+				}
+				if task.IsAbandoned() != tc.isAbandoned {
+					t.Errorf("Status %s: expected IsAbandoned %v, got %v", tc.status, tc.isAbandoned, task.IsAbandoned())
+				}
+			}
+		})
+
+		t.Run("Status Validation", func(t *testing.T) {
+			validStatuses := []string{
+				StatusTodo, StatusInProgress, StatusBlocked, StatusDone, StatusAbandoned,
+				StatusPending, StatusCompleted, StatusDeleted,
+			}
+
+			for _, status := range validStatuses {
+				task := &Task{Status: status}
+				if !task.IsValidStatus() {
+					t.Errorf("Status %s should be valid", status)
+				}
+			}
+
+			invalidStatuses := []string{"unknown", "invalid", ""}
+			for _, status := range invalidStatuses {
+				task := &Task{Status: status}
+				if task.IsValidStatus() {
+					t.Errorf("Status %s should be invalid", status)
+				}
+			}
+		})
+
 		t.Run("Priority Methods", func(t *testing.T) {
 			task := &Task{}
 
···
 			if !task.HasPriority() {
 				t.Error("Task with priority should return true for HasPriority")
 			}
+		})
+
+		t.Run("Priority System", func(t *testing.T) {
+			t.Run("Text-based Priority Validation", func(t *testing.T) {
+				validTextPriorities := []string{
+					PriorityHigh, PriorityMedium, PriorityLow,
+				}
+
+				for _, priority := range validTextPriorities {
+					task := &Task{Priority: priority}
+					if !task.IsValidPriority() {
+						t.Errorf("Priority %s should be valid", priority)
+					}
+				}
+			})
+
+			t.Run("Numeric Priority Validation", func(t *testing.T) {
+				validNumericPriorities := []string{"1", "2", "3", "4", "5"}
+
+				for _, priority := range validNumericPriorities {
+					task := &Task{Priority: priority}
+					if !task.IsValidPriority() {
+						t.Errorf("Numeric priority %s should be valid", priority)
+					}
+				}
+
+				invalidNumericPriorities := []string{"0", "6", "10", "-1"}
+				for _, priority := range invalidNumericPriorities {
+					task := &Task{Priority: priority}
+					if task.IsValidPriority() {
+						t.Errorf("Numeric priority %s should be invalid", priority)
+					}
+				}
+			})
+
+			t.Run("Legacy A-Z Priority Validation", func(t *testing.T) {
+				validLegacyPriorities := []string{"A", "B", "C", "D", "Z"}
+
+				for _, priority := range validLegacyPriorities {
+					task := &Task{Priority: priority}
+					if !task.IsValidPriority() {
+						t.Errorf("Legacy priority %s should be valid", priority)
+					}
+				}
+
+				invalidLegacyPriorities := []string{"AA", "a", "1A", ""}
+				for _, priority := range invalidLegacyPriorities {
+					task := &Task{Priority: priority}
+					if priority != "" && task.IsValidPriority() {
+						t.Errorf("Legacy priority %s should be invalid", priority)
+					}
+				}
+			})
+
+			t.Run("Empty Priority Validation", func(t *testing.T) {
+				task := &Task{Priority: ""}
+				if !task.IsValidPriority() {
+					t.Error("Empty priority should be valid")
+				}
+			})
+
+			t.Run("Priority Weight Calculation", func(t *testing.T) {
+				testCases := []struct {
+					priority string
+					weight   int
+				}{
+					{PriorityHigh, 5},
+					{PriorityMedium, 4},
+					{PriorityLow, 3},
+					{"5", 5},
+					{"4", 4},
+					{"3", 3},
+					{"2", 2},
+					{"1", 1},
+					{"A", 26},
+					{"B", 25},
+					{"C", 24},
+					{"Z", 1},
+					{"", 0},
+					{"invalid", 0},
+				}
+
+				for _, tc := range testCases {
+					task := &Task{Priority: tc.priority}
+					weight := task.GetPriorityWeight()
+					if weight != tc.weight {
+						t.Errorf("Priority %s: expected weight %d, got %d", tc.priority, tc.weight, weight)
+					}
+				}
+			})
+
+			t.Run("Priority Weight Ordering", func(t *testing.T) {
+				priorities := []string{PriorityHigh, PriorityMedium, PriorityLow}
+				weights := []int{}
+
+				for _, priority := range priorities {
+					task := &Task{Priority: priority}
+					weights = append(weights, task.GetPriorityWeight())
+				}
+
+				for i := 1; i < len(weights); i++ {
+					if weights[i-1] <= weights[i] {
+						t.Errorf("Priority weights should be in descending order: %v", weights)
+					}
+				}
+			})
 		})
 
 		t.Run("Tags Marshaling", func(t *testing.T) {
···
 					t.Errorf("Model %d: ID not set correctly", i)
 				}
 
-				// Test table name method
 				tableName := model.GetTableName()
 				if tableName == "" {
 					t.Errorf("Model %d: table name should not be empty", i)
 				}
 
-				// Test timestamp methods
 				now := time.Now()
 				model.SetCreatedAt(now)
 				model.SetUpdatedAt(now)
 
-				// Note: We don't test exact equality due to potential precision differences
+				// NOTE: We don't test exact equality due to potential precision differences
 				if model.GetCreatedAt().IsZero() {
 					t.Errorf("Model %d: created at should not be zero", i)
 				}

internal/repo/task_repository.go

···
 
 	return tasks, rows.Err()
 }
+
+// GetTodo retrieves all tasks with todo status
+func (r *TaskRepository) GetTodo(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Status: models.StatusTodo})
+}
+
+// GetInProgress retrieves all tasks with in-progress status
+func (r *TaskRepository) GetInProgress(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Status: models.StatusInProgress})
+}
+
+// GetBlocked retrieves all tasks with blocked status
+func (r *TaskRepository) GetBlocked(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Status: models.StatusBlocked})
+}
+
+// GetDone retrieves all tasks with done status
+func (r *TaskRepository) GetDone(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Status: models.StatusDone})
+}
+
+// GetAbandoned retrieves all tasks with abandoned status
+func (r *TaskRepository) GetAbandoned(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Status: models.StatusAbandoned})
+}
+
+// GetByPriority retrieves all tasks with a specific priority
+//
+//	We need special handling for empty priority by using raw SQL
+func (r *TaskRepository) GetByPriority(ctx context.Context, priority string) ([]*models.Task, error) {
+	if priority == "" {
+		query := `
+			SELECT id, uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations
+			FROM tasks
+			WHERE priority = '' OR priority IS NULL
+			ORDER BY modified DESC`
+
+		rows, err := r.db.QueryContext(ctx, query)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get tasks by empty priority: %w", err)
+		}
+		defer rows.Close()
+
+		var tasks []*models.Task
+		for rows.Next() {
+			task := &models.Task{}
+			if err := r.scanTaskRow(rows, task); err != nil {
+				return nil, err
+			}
+			tasks = append(tasks, task)
+		}
+
+		return tasks, rows.Err()
+	}
+
+	return r.List(ctx, TaskListOptions{Priority: priority})
+}
+
+// GetHighPriority retrieves all high priority tasks
+func (r *TaskRepository) GetHighPriority(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Priority: models.PriorityHigh})
+}
+
+// GetMediumPriority retrieves all medium priority tasks
+func (r *TaskRepository) GetMediumPriority(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Priority: models.PriorityMedium})
+}
+
+// GetLowPriority retrieves all low priority tasks
+func (r *TaskRepository) GetLowPriority(ctx context.Context) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Priority: models.PriorityLow})
+}
+
+// GetStatusSummary returns a summary of tasks by status
+func (r *TaskRepository) GetStatusSummary(ctx context.Context) (map[string]int64, error) {
+	query := `
+		SELECT status, COUNT(*) as count
+		FROM tasks
+		GROUP BY status
+		ORDER BY status`
+
+	rows, err := r.db.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get status summary: %w", err)
+	}
+	defer rows.Close()
+
+	summary := make(map[string]int64)
+	for rows.Next() {
+		var status string
+		var count int64
+		if err := rows.Scan(&status, &count); err != nil {
+			return nil, fmt.Errorf("failed to scan status summary row: %w", err)
+		}
+		summary[status] = count
+	}
+
+	return summary, rows.Err()
+}
+
+// GetPrioritySummary returns a summary of tasks by priority
+func (r *TaskRepository) GetPrioritySummary(ctx context.Context) (map[string]int64, error) {
+	query := `
+		SELECT
+			CASE
+				WHEN priority = '' OR priority IS NULL THEN 'No Priority'
+				ELSE priority
+			END as priority_group,
+			COUNT(*) as count
+		FROM tasks
+		GROUP BY priority_group
+		ORDER BY priority_group`
+
+	rows, err := r.db.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get priority summary: %w", err)
+	}
+	defer rows.Close()
+
+	summary := make(map[string]int64)
+	for rows.Next() {
+		var priority string
+		var count int64
+		if err := rows.Scan(&priority, &count); err != nil {
+			return nil, fmt.Errorf("failed to scan priority summary row: %w", err)
+		}
+		summary[priority] = count
+	}
+
+	return summary, rows.Err()
+}

internal/repo/task_repository_test.go

···
 			}
 		})
 	})
+
+	t.Run("New Status Tracking Methods", func(t *testing.T) {
+		statusTasks := []*models.Task{
+			{UUID: newUUID(), Description: "Todo task", Status: models.StatusTodo, Project: "test"},
+			{UUID: newUUID(), Description: "In progress task", Status: models.StatusInProgress, Project: "test"},
+			{UUID: newUUID(), Description: "Blocked task", Status: models.StatusBlocked, Project: "test"},
+			{UUID: newUUID(), Description: "Done task", Status: models.StatusDone, Project: "test"},
+			{UUID: newUUID(), Description: "Abandoned task", Status: models.StatusAbandoned, Project: "test"},
+		}
+
+		for _, task := range statusTasks {
+			_, err := repo.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
+		}
+
+		t.Run("GetTodo", func(t *testing.T) {
+			results, err := repo.GetTodo(ctx)
+			if err != nil {
+				t.Errorf("Failed to get todo tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 todo task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Status != models.StatusTodo {
+					t.Errorf("Expected status %s, got %s", models.StatusTodo, task.Status)
+				}
+			}
+		})
+
+		t.Run("GetInProgress", func(t *testing.T) {
+			results, err := repo.GetInProgress(ctx)
+			if err != nil {
+				t.Errorf("Failed to get in-progress tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 in-progress task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Status != models.StatusInProgress {
+					t.Errorf("Expected status %s, got %s", models.StatusInProgress, task.Status)
+				}
+			}
+		})
+
+		t.Run("GetBlocked", func(t *testing.T) {
+			results, err := repo.GetBlocked(ctx)
+			if err != nil {
+				t.Errorf("Failed to get blocked tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 blocked task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Status != models.StatusBlocked {
+					t.Errorf("Expected status %s, got %s", models.StatusBlocked, task.Status)
+				}
+			}
+		})
+
+		t.Run("GetDone", func(t *testing.T) {
+			results, err := repo.GetDone(ctx)
+			if err != nil {
+				t.Errorf("Failed to get done tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 done task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Status != models.StatusDone {
+					t.Errorf("Expected status %s, got %s", models.StatusDone, task.Status)
+				}
+			}
+		})
+
+		t.Run("GetAbandoned", func(t *testing.T) {
+			results, err := repo.GetAbandoned(ctx)
+			if err != nil {
+				t.Errorf("Failed to get abandoned tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 abandoned task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Status != models.StatusAbandoned {
+					t.Errorf("Expected status %s, got %s", models.StatusAbandoned, task.Status)
+				}
+			}
+		})
+	})
+
+	t.Run("Priority System Methods", func(t *testing.T) {
+		priorityTasks := []*models.Task{
+			{UUID: newUUID(), Description: "High priority task", Status: "pending", Priority: models.PriorityHigh},
+			{UUID: newUUID(), Description: "Medium priority task", Status: "pending", Priority: models.PriorityMedium},
+			{UUID: newUUID(), Description: "Low priority task", Status: "pending", Priority: models.PriorityLow},
+			{UUID: newUUID(), Description: "Numeric 5 priority", Status: "pending", Priority: "5"},
+			{UUID: newUUID(), Description: "Numeric 3 priority", Status: "pending", Priority: "3"},
+			{UUID: newUUID(), Description: "Numeric 1 priority", Status: "pending", Priority: "1"},
+			{UUID: newUUID(), Description: "Legacy A priority", Status: "pending", Priority: "A"},
+			{UUID: newUUID(), Description: "Legacy B priority", Status: "pending", Priority: "B"},
+			{UUID: newUUID(), Description: "No priority task", Status: "pending", Priority: ""},
+		}
+
+		for _, task := range priorityTasks {
+			_, err := repo.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
+		}
+
+		t.Run("GetHighPriority", func(t *testing.T) {
+			results, err := repo.GetHighPriority(ctx)
+			if err != nil {
+				t.Errorf("Failed to get high priority tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 high priority task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Priority != models.PriorityHigh {
+					t.Errorf("Expected priority %s, got %s", models.PriorityHigh, task.Priority)
+				}
+			}
+		})
+
+		t.Run("GetMediumPriority", func(t *testing.T) {
+			results, err := repo.GetMediumPriority(ctx)
+			if err != nil {
+				t.Errorf("Failed to get medium priority tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 medium priority task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Priority != models.PriorityMedium {
+					t.Errorf("Expected priority %s, got %s", models.PriorityMedium, task.Priority)
+				}
+			}
+		})
+
+		t.Run("GetLowPriority", func(t *testing.T) {
+			results, err := repo.GetLowPriority(ctx)
+			if err != nil {
+				t.Errorf("Failed to get low priority tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 low priority task, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Priority != models.PriorityLow {
+					t.Errorf("Expected priority %s, got %s", models.PriorityLow, task.Priority)
+				}
+			}
+		})
+
+		t.Run("GetByPriority", func(t *testing.T) {
+			// Test numeric priority
+			results, err := repo.GetByPriority(ctx, "5")
+			if err != nil {
+				t.Errorf("Failed to get tasks by priority 5: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 task with priority 5, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Priority != "5" {
+					t.Errorf("Expected priority 5, got %s", task.Priority)
+				}
+			}
+
+			// Test legacy priority
+			results, err = repo.GetByPriority(ctx, "A")
+			if err != nil {
+				t.Errorf("Failed to get tasks by priority A: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 task with priority A, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Priority != "A" {
+					t.Errorf("Expected priority A, got %s", task.Priority)
+				}
+			}
+
+			// Test empty priority - create a specific task with no priority for this test
+			noPriorityTask := &models.Task{
+				UUID:        newUUID(),
+				Description: "No priority task for test",
+				Status:      "pending",
+				Priority:    "",
+			}
+			_, err = repo.Create(ctx, noPriorityTask)
+			if err != nil {
+				t.Fatalf("Failed to create no priority task: %v", err)
+			}
+
+			results, err = repo.GetByPriority(ctx, "")
+			if err != nil {
+				t.Errorf("Failed to get tasks with no priority: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 task with no priority, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Priority != "" {
+					t.Errorf("Expected empty priority, got %s", task.Priority)
+				}
+			}
+		})
+	})
+
+	t.Run("Summary Methods", func(t *testing.T) {
+		summaryTasks := []*models.Task{
+			{UUID: newUUID(), Description: "Summary task 1", Status: models.StatusTodo, Priority: models.PriorityHigh},
+			{UUID: newUUID(), Description: "Summary task 2", Status: models.StatusTodo, Priority: models.PriorityMedium},
+			{UUID: newUUID(), Description: "Summary task 3", Status: models.StatusInProgress, Priority: models.PriorityHigh},
+			{UUID: newUUID(), Description: "Summary task 4", Status: models.StatusDone, Priority: models.PriorityLow},
+			{UUID: newUUID(), Description: "Summary task 5", Status: models.StatusBlocked, Priority: ""},
+			{UUID: newUUID(), Description: "Summary task 6", Status: models.StatusAbandoned, Priority: "5"},
+		}
+
+		for _, task := range summaryTasks {
+			_, err := repo.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create summary task: %v", err)
+			}
+		}
+
+		t.Run("GetStatusSummary", func(t *testing.T) {
+			summary, err := repo.GetStatusSummary(ctx)
+			if err != nil {
+				t.Errorf("Failed to get status summary: %v", err)
+			}
+
+			if len(summary) == 0 {
+				t.Error("Expected non-empty status summary")
+			}
+
+			// Check that we have expected statuses with counts
+			expectedStatuses := []string{
+				models.StatusTodo, models.StatusInProgress, models.StatusDone,
+				models.StatusBlocked, models.StatusAbandoned,
+			}
+
+			for _, status := range expectedStatuses {
+				if count, exists := summary[status]; exists {
+					if count < 1 {
+						t.Errorf("Expected at least 1 task with status %s, got %d", status, count)
+					}
+				} else {
+					t.Errorf("Expected status %s in summary", status)
+				}
+			}
+
+			if todoCount := summary[models.StatusTodo]; todoCount < 2 {
+				t.Errorf("Expected at least 2 todo tasks, got %d", todoCount)
+			}
+		})
+
+		t.Run("GetPrioritySummary", func(t *testing.T) {
+			summary, err := repo.GetPrioritySummary(ctx)
+			if err != nil {
+				t.Errorf("Failed to get priority summary: %v", err)
+			}
+
+			if len(summary) == 0 {
+				t.Error("Expected non-empty priority summary")
+			}
+
+			expectedPriorities := []string{models.PriorityHigh, models.PriorityMedium, models.PriorityLow, "5"}
+
+			for _, priority := range expectedPriorities {
+				if count, exists := summary[priority]; exists {
+					if count < 1 {
+						t.Errorf("Expected at least 1 task with priority %s, got %d", priority, count)
+					}
+				} else {
+					t.Errorf("Expected priority %s in summary", priority)
+				}
+			}
+
+			if noPriorityCount, exists := summary["No Priority"]; exists {
+				if noPriorityCount < 1 {
+					t.Errorf("Expected at least 1 task with no priority, got %d", noPriorityCount)
+				}
+			} else {
+				t.Error("Expected 'No Priority' group in summary")
+			}
+
+			if highCount := summary[models.PriorityHigh]; highCount < 2 {
+				t.Errorf("Expected at least 2 high priority tasks, got %d", highCount)
+			}
+		})
+	})
 }

internal/ui/task_edit.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+type TaskEditOptions struct {
+	Output io.Writer
+	Input  io.Reader
+	Width  int
+	Height int
+}
+
+type TaskEditor struct {
+	task *models.Task
+	repo TaskRepository
+	opts TaskEditOptions
+}
+
+func NewTaskEditor(task *models.Task, repo TaskRepository, opts TaskEditOptions) *TaskEditor {
+	if opts.Output == nil {
+		opts.Output = os.Stdout
+	}
+	if opts.Input == nil {
+		opts.Input = os.Stdin
+	}
+	if opts.Width == 0 {
+		opts.Width = 80
+	}
+	if opts.Height == 0 {
+		opts.Height = 24
+	}
+	return &TaskEditor{
+		task: task,
+		repo: repo,
+		opts: opts,
+	}
+}
+
+type (
+	editMode     int
+	priorityMode int
+)
+
+const (
+	fieldNavigation editMode = iota
+	statusPicker
+	priorityPicker
+	textInput
+)
+
+const (
+	priorityModeText priorityMode = iota
+	priorityModeNumeric
+	priorityModeLegacy
+)
+
+var (
+	statusOptions = []string{
+		models.StatusTodo,
+		models.StatusInProgress,
+		models.StatusBlocked,
+		models.StatusDone,
+		models.StatusAbandoned,
+	}
+
+	textPriorityOptions = []string{
+		"",
+		models.PriorityLow,
+		models.PriorityMedium,
+		models.PriorityHigh,
+	}
+
+	numericPriorityOptions = []string{"", "1", "2", "3", "4", "5"}
+	legacyPriorityOptions  = []string{"", "A", "B", "C", "D", "E"}
+)
+
+type taskEditKeyMap struct {
+	Up           key.Binding
+	Down         key.Binding
+	Left         key.Binding
+	Right        key.Binding
+	Enter        key.Binding
+	Tab          key.Binding
+	ShiftTab     key.Binding
+	Escape       key.Binding
+	Save         key.Binding
+	Cancel       key.Binding
+	Help         key.Binding
+	StatusEdit   key.Binding
+	Priority     key.Binding
+	PriorityMode key.Binding
+}
+
+func (k taskEditKeyMap) ShortHelp() []key.Binding {
+	return []key.Binding{k.Up, k.Down, k.Enter, k.Save, k.Cancel, k.Help}
+}
+
+func (k taskEditKeyMap) FullHelp() [][]key.Binding {
+	return [][]key.Binding{
+		{k.Up, k.Down, k.Left, k.Right},
+		{k.Tab, k.ShiftTab, k.Enter},
+		{k.StatusEdit, k.Priority, k.PriorityMode},
+		{k.Save, k.Cancel, k.Help},
+	}
+}
+
+var taskEditKeys = taskEditKeyMap{
+	Up:           key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
+	Down:         key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
+	Left:         key.NewBinding(key.WithKeys("left", "h"), key.WithHelp("←/h", "previous")),
+	Right:        key.NewBinding(key.WithKeys("right", "l"), key.WithHelp("→/l", "next")),
+	Enter:        key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select/edit")),
+	Tab:          key.NewBinding(key.WithKeys("tab"), key.WithHelp("tab", "next field")),
+	ShiftTab:     key.NewBinding(key.WithKeys("shift+tab"), key.WithHelp("shift+tab", "prev field")),
+	Escape:       key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "cancel/back")),
+	Save:         key.NewBinding(key.WithKeys("ctrl+s"), key.WithHelp("ctrl+s", "save")),
+	Cancel:       key.NewBinding(key.WithKeys("ctrl+c", "q"), key.WithHelp("q", "quit")),
+	Help:         key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
+	StatusEdit:   key.NewBinding(key.WithKeys("s"), key.WithHelp("s", "edit status")),
+	Priority:     key.NewBinding(key.WithKeys("p"), key.WithHelp("p", "edit priority")),
+	PriorityMode: key.NewBinding(key.WithKeys("m"), key.WithHelp("m", "priority mode")),
+}
+
+type taskEditModel struct {
+	task         *models.Task
+	originalTask *models.Task
+	repo         TaskRepository
+	opts         TaskEditOptions
+	keys         taskEditKeyMap
+	help         help.Model
+
+	mode          editMode
+	currentField  int
+	statusIndex   int
+	priorityIndex int
+	priorityMode  priorityMode
+
+	descInput    textinput.Model
+	projectInput textinput.Model
+
+	showingHelp bool
+	saved       bool
+	cancelled   bool
+
+	fields []string
+}
+
+func (m taskEditModel) Init() tea.Cmd {
+	return textinput.Blink
+}
+
+func (m taskEditModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmds []tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if m.showingHelp {
+			switch {
+			case key.Matches(msg, m.keys.Escape) || key.Matches(msg, m.keys.Help):
+				m.showingHelp = false
+				return m, nil
+			}
+			return m, nil
+		}
+
+		switch m.mode {
+		case fieldNavigation:
+			return m.updateFieldNavigation(msg)
+		case statusPicker:
+			return m.updateStatusPicker(msg)
+		case priorityPicker:
+			return m.updatePriorityPicker(msg)
+		case textInput:
+			return m.updateTextInput(msg)
+		}
+
+	case tea.WindowSizeMsg:
+		m.opts.Width = msg.Width
+		m.opts.Height = msg.Height
+		m.descInput.Width = msg.Width - 20
+		m.projectInput.Width = msg.Width - 20
+	}
+
+	return m, tea.Batch(cmds...)
+}
+
+func (m taskEditModel) updateFieldNavigation(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch {
+	case key.Matches(msg, m.keys.Help):
+		m.showingHelp = true
+		return m, nil
+	case key.Matches(msg, m.keys.Cancel):
+		m.cancelled = true
+		return m, tea.Quit
+	case key.Matches(msg, m.keys.Save):
+		return m.saveTask()
+	case key.Matches(msg, m.keys.Up) || key.Matches(msg, m.keys.ShiftTab):
+		m.currentField = (m.currentField - 1 + len(m.fields)) % len(m.fields)
+	case key.Matches(msg, m.keys.Down) || key.Matches(msg, m.keys.Tab):
+		m.currentField = (m.currentField + 1) % len(m.fields)
+	case key.Matches(msg, m.keys.Enter):
+		return m.enterField()
+	case key.Matches(msg, m.keys.StatusEdit):
+		m.mode = statusPicker
+		return m, nil
+	case key.Matches(msg, m.keys.Priority):
+		m.mode = priorityPicker
+		return m, nil
+	case key.Matches(msg, m.keys.PriorityMode):
+		m.priorityMode = (m.priorityMode + 1) % 3
+		m.updatePriorityIndex()
+		return m, nil
+	}
+	return m, nil
+}
+
+func (m taskEditModel) updateStatusPicker(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch {
+	case key.Matches(msg, m.keys.Escape):
+		m.mode = fieldNavigation
+	case key.Matches(msg, m.keys.Up) || key.Matches(msg, m.keys.Left):
+		m.statusIndex = (m.statusIndex - 1 + len(statusOptions)) % len(statusOptions)
+	case key.Matches(msg, m.keys.Down) || key.Matches(msg, m.keys.Right):
+		m.statusIndex = (m.statusIndex + 1) % len(statusOptions)
+	case key.Matches(msg, m.keys.Enter):
+		m.task.Status = statusOptions[m.statusIndex]
+		m.mode = fieldNavigation
+	}
+	return m, nil
+}
+
+func (m taskEditModel) updatePriorityPicker(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	var options []string
+	switch m.priorityMode {
+	case priorityModeText:
+		options = textPriorityOptions
+	case priorityModeNumeric:
+		options = numericPriorityOptions
+	case priorityModeLegacy:
+		options = legacyPriorityOptions
+	}
+
+	switch {
+	case key.Matches(msg, m.keys.Escape):
+		m.mode = fieldNavigation
+	case key.Matches(msg, m.keys.Up) || key.Matches(msg, m.keys.Left):
+		m.priorityIndex = (m.priorityIndex - 1 + len(options)) % len(options)
+	case key.Matches(msg, m.keys.Down) || key.Matches(msg, m.keys.Right):
+		m.priorityIndex = (m.priorityIndex + 1) % len(options)
+	case key.Matches(msg, m.keys.Enter):
+		m.task.Priority = options[m.priorityIndex]
+		m.mode = fieldNavigation
+	case key.Matches(msg, m.keys.PriorityMode):
+		m.priorityMode = (m.priorityMode + 1) % 3
+		m.updatePriorityIndex()
+	}
+	return m, nil
+}
+
+func (m taskEditModel) updateTextInput(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+
+	switch {
+	case key.Matches(msg, m.keys.Escape):
+		m.mode = fieldNavigation
+		return m, nil
+	case key.Matches(msg, m.keys.Enter):
+		switch m.fields[m.currentField] {
+		case "Description":
+			m.task.Description = m.descInput.Value()
+		case "Project":
+			m.task.Project = m.projectInput.Value()
+		}
+		m.mode = fieldNavigation
+		return m, nil
+	}
+
+	switch m.fields[m.currentField] {
+	case "Description":
+		m.descInput, cmd = m.descInput.Update(msg)
+	case "Project":
+		m.projectInput, cmd = m.projectInput.Update(msg)
+	}
+
+	return m, cmd
+}
+
+func (m taskEditModel) enterField() (tea.Model, tea.Cmd) {
+	switch m.fields[m.currentField] {
+	case "Description":
+		m.mode = textInput
+		m.descInput.Focus()
+		return m, textinput.Blink
+	case "Status":
+		m.mode = statusPicker
+		return m, nil
+	case "Priority":
+		m.mode = priorityPicker
+		return m, nil
+	case "Project":
+		m.mode = textInput
+		m.projectInput.Focus()
+		return m, textinput.Blink
+	}
+	return m, nil
+}
+
+func (m *taskEditModel) updatePriorityIndex() {
+	var options []string
+	switch m.priorityMode {
+	case priorityModeText:
+		options = textPriorityOptions
+	case priorityModeNumeric:
+		options = numericPriorityOptions
+	case priorityModeLegacy:
+		options = legacyPriorityOptions
+	}
+
+	for i, opt := range options {
+		if opt == m.task.Priority {
+			m.priorityIndex = i
+			return
+		}
+	}
+	m.priorityIndex = 0
+}
+
+func (m taskEditModel) saveTask() (tea.Model, tea.Cmd) {
+	m.saved = true
+	return m, tea.Quit
+}
+
+func (m taskEditModel) View() string {
+	if m.showingHelp {
+		return m.help.View(m.keys)
+	}
+
+	var content strings.Builder
+
+	title := TitleColorStyle.Render("Edit Task")
+	content.WriteString(title + "\n\n")
+
+	for i, field := range m.fields {
+		fieldStyle := lipgloss.NewStyle()
+		if i == m.currentField && m.mode == fieldNavigation {
+			fieldStyle = SelectedColorStyle
+		}
+
+		switch field {
+		case "Description":
+			value := m.task.Description
+			if m.mode == textInput && i == m.currentField {
+				value = m.descInput.View()
+			}
+			content.WriteString(fieldStyle.Render(fmt.Sprintf("Description: %s", value)) + "\n")
+
+		case "Status":
+			statusStr := m.renderStatusField()
+			content.WriteString(fieldStyle.Render(fmt.Sprintf("Status: %s", statusStr)) + "\n")
+
+		case "Priority":
+			priorityStr := m.renderPriorityField()
+			content.WriteString(fieldStyle.Render(fmt.Sprintf("Priority: %s", priorityStr)) + "\n")
+
+		case "Project":
+			value := m.task.Project
+			if m.mode == textInput && i == m.currentField {
+				value = m.projectInput.View()
+			}
+			content.WriteString(fieldStyle.Render(fmt.Sprintf("Project: %s", value)) + "\n")
+		}
+		content.WriteString("\n")
+	}
+
+	switch m.mode {
+	case statusPicker:
+		content.WriteString(m.renderStatusPicker())
+	case priorityPicker:
+		content.WriteString(m.renderPriorityPicker())
+	}
+
+	help := m.help.View(m.keys)
+
+	return lipgloss.JoinVertical(lipgloss.Left, content.String(), help)
+}
+
+func (m taskEditModel) renderStatusField() string {
+	if m.mode == statusPicker {
+		return StatusLegend()
+	}
+	return FormatStatusWithText(m.task.Status)
+}
+
+func (m taskEditModel) renderPriorityField() string {
+	if m.mode == priorityPicker {
+		modeStr := ""
+		switch m.priorityMode {
+		case priorityModeText:
+			modeStr = "Text"
+		case priorityModeNumeric:
+			modeStr = "Numeric"
+		case priorityModeLegacy:
+			modeStr = "Legacy"
+		}
+		return fmt.Sprintf("%s (Mode: %s)", PriorityLegend(), modeStr)
+	}
+	return FormatPriorityWithText(m.task.Priority)
+}
+
+func (m taskEditModel) renderStatusPicker() string {
+	var content strings.Builder
+	content.WriteString("Select Status:\n")
+
+	for i, status := range statusOptions {
+		style := lipgloss.NewStyle()
+		if i == m.statusIndex {
+			style = SelectedColorStyle
+		}
+
+		line := fmt.Sprintf("%s %s", FormatStatusIndicator(status), status)
+		content.WriteString(style.Render(line) + "\n")
+	}
+
+	return content.String()
+}
+
+func (m taskEditModel) renderPriorityPicker() string {
+	var content strings.Builder
+
+	modeStr := ""
+	var options []string
+
+	switch m.priorityMode {
+	case priorityModeText:
+		modeStr = "Text"
+		options = textPriorityOptions
+	case priorityModeNumeric:
+		modeStr = "Numeric (1=Low, 5=High)"
+		options = numericPriorityOptions
+	case priorityModeLegacy:
+		modeStr = "Legacy (A=High, E=Low)"
+		options = legacyPriorityOptions
+	}
+
+	content.WriteString(fmt.Sprintf("Select Priority (%s - Press 'm' to switch modes):\n", modeStr))
+
+	for i, priority := range options {
+		style := lipgloss.NewStyle()
+		if i == m.priorityIndex {
+			style = SelectedColorStyle
+		}
+
+		var line string
+		if priority == "" {
+			line = fmt.Sprintf("%s None", FormatPriorityIndicator(priority))
+		} else {
+			line = fmt.Sprintf("%s %s - %s", FormatPriorityIndicator(priority), priority, GetPriorityDescription(priority))
+		}
+		content.WriteString(style.Render(line) + "\n")
+	}
+
+	return content.String()
+}
+
+func (te *TaskEditor) Edit(ctx context.Context) (*models.Task, error) {
+	descInput := textinput.New()
+	descInput.SetValue(te.task.Description)
+	descInput.Width = te.opts.Width - 20
+
+	projectInput := textinput.New()
+	projectInput.SetValue(te.task.Project)
+	projectInput.Width = te.opts.Width - 20
+
+	originalTask := *te.task
+
+	statusIndex := 0
+	for i, status := range statusOptions {
+		if status == te.task.Status {
+			statusIndex = i
+			break
+		}
+	}
+
+	priorityMode := priorityModeText
+	if te.task.Priority != "" {
+		switch GetPriorityDisplayType(te.task.Priority) {
+		case "numeric":
+			priorityMode = priorityModeNumeric
+		case "legacy":
+			priorityMode = priorityModeLegacy
+		}
+	}
+
+	model := taskEditModel{
+		task:         te.task,
+		originalTask: &originalTask,
+		repo:         te.repo,
+		opts:         te.opts,
+		keys:         taskEditKeys,
+		help:         help.New(),
+
+		mode:         fieldNavigation,
+		currentField: 0,
+		statusIndex:  statusIndex,
+		priorityMode: priorityMode,
+
+		descInput:    descInput,
+		projectInput: projectInput,
+
+		fields: []string{"Description", "Status", "Priority", "Project"},
+	}
+
+	model.updatePriorityIndex()
+
+	program := tea.NewProgram(model, tea.WithInput(te.opts.Input), tea.WithOutput(te.opts.Output))
+
+	finalModel, err := program.Run()
+	if err != nil {
+		return nil, fmt.Errorf("failed to run task editor: %w", err)
+	}
+
+	editModel := finalModel.(taskEditModel)
+
+	if editModel.cancelled {
+		return nil, fmt.Errorf("edit cancelled")
+	}
+
+	if editModel.saved {
+		err := te.repo.Update(ctx, te.task)
+		if err != nil {
+			return nil, fmt.Errorf("failed to save task: %w", err)
+		}
+	}
+
+	return te.task, nil
+}

internal/ui/task_edit_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+type mockTaskRepo struct {
+	tasks   map[int64]*models.Task
+	updated []*models.Task
+}
+
+func (m *mockTaskRepo) List(ctx context.Context, opts repo.TaskListOptions) ([]*models.Task, error) {
+	var result []*models.Task
+	for _, task := range m.tasks {
+		result = append(result, task)
+	}
+	return result, nil
+}
+
+func (m *mockTaskRepo) Update(ctx context.Context, task *models.Task) error {
+	m.updated = append(m.updated, task)
+	if existing, exists := m.tasks[task.ID]; exists {
+		*existing = *task
+	}
+	return nil
+}
+
+func createTestTaskEditModel(task *models.Task) taskEditModel {
+	now := time.Now()
+	if task.Entry.IsZero() {
+		task.Entry = now
+	}
+	if task.Modified.IsZero() {
+		task.Modified = now
+	}
+
+	repo := &mockTaskRepo{tasks: map[int64]*models.Task{task.ID: task}}
+
+	model := taskEditModel{
+		task:         task,
+		originalTask: task,
+		repo:         repo,
+		opts:         TaskEditOptions{Output: &bytes.Buffer{}, Width: 80, Height: 24},
+		keys:         taskEditKeys,
+		help:         help.New(),
+
+		mode:         fieldNavigation,
+		currentField: 0,
+		priorityMode: priorityModeText,
+
+		fields: []string{"Description", "Status", "Priority", "Project"},
+	}
+
+	model.descInput = textinput.New()
+	model.descInput.SetValue(task.Description)
+	model.projectInput = textinput.New()
+	model.projectInput.SetValue(task.Project)
+
+	for i, status := range statusOptions {
+		if status == task.Status {
+			model.statusIndex = i
+			break
+		}
+	}
+
+	model.updatePriorityIndex()
+
+	return model
+}
+
+func TestTaskEditor(t *testing.T) {
+	t.Run("Creation", func(t *testing.T) {
+		task := &models.Task{
+			ID:          1,
+			Description: "Test task",
+			Status:      models.StatusTodo,
+			Priority:    models.PriorityHigh,
+			Project:     "test-project",
+		}
+
+		repo := &mockTaskRepo{tasks: map[int64]*models.Task{1: task}}
+		editor := NewTaskEditor(task, repo, TaskEditOptions{Width: 80, Height: 24})
+
+		if editor.task != task {
+			t.Error("Task should be set correctly")
+		}
+
+		if editor.repo != repo {
+			t.Error("Repository should be set correctly")
+		}
+
+		if editor.opts.Width != 80 {
+			t.Errorf("Expected width 80, got %d", editor.opts.Width)
+		}
+	})
+
+	t.Run("Default Options", func(t *testing.T) {
+		task := &models.Task{ID: 1}
+		repo := &mockTaskRepo{}
+		editor := NewTaskEditor(task, repo, TaskEditOptions{})
+
+		if editor.opts.Width != 80 {
+			t.Errorf("Expected default width 80, got %d", editor.opts.Width)
+		}
+
+		if editor.opts.Height != 24 {
+			t.Errorf("Expected default height 24, got %d", editor.opts.Height)
+		}
+	})
+}
+
+func TestTaskEditModel(t *testing.T) {
+	t.Run("Init", func(t *testing.T) {
+		task := &models.Task{
+			ID:          1,
+			Description: "Test task",
+			Status:      models.StatusInProgress,
+			Priority:    models.PriorityMedium,
+		}
+
+		model := createTestTaskEditModel(task)
+		cmd := model.Init()
+		if cmd == nil {
+			t.Error("Init should return a command")
+		}
+	})
+
+	t.Run("Field Navigation", func(t *testing.T) {
+		task := &models.Task{ID: 1, Description: "Test task", Status: models.StatusTodo}
+		model := createTestTaskEditModel(task)
+
+		if model.currentField != 0 {
+			t.Errorf("Expected initial field 0, got %d", model.currentField)
+		}
+
+		msg := tea.KeyMsg{Type: tea.KeyDown}
+		updatedModel, _ := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.currentField != 1 {
+			t.Errorf("Expected field 1 after down, got %d", model.currentField)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyUp}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.currentField != 0 {
+			t.Errorf("Expected field 0 after up, got %d", model.currentField)
+		}
+	})
+
+	t.Run("Status Picker", func(t *testing.T) {
+		task := &models.Task{ID: 1, Description: "Test task", Status: models.StatusTodo}
+		model := createTestTaskEditModel(task)
+		model.currentField = 1
+
+		msg := tea.KeyMsg{Type: tea.KeyEnter}
+		updatedModel, _ := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.mode != statusPicker {
+			t.Errorf("Expected statusPicker mode, got %d", model.mode)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyDown}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.statusIndex != 1 {
+			t.Errorf("Expected status index 1, got %d", model.statusIndex)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyEnter}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.task.Status != statusOptions[1] {
+			t.Errorf("Expected status %s, got %s", statusOptions[1], model.task.Status)
+		}
+
+		if model.mode != fieldNavigation {
+			t.Errorf("Expected fieldNavigation mode after selection, got %d", model.mode)
+		}
+	})
+
+	t.Run("Priority Picker", func(t *testing.T) {
+		task := &models.Task{ID: 1, Description: "Test task", Priority: ""}
+		model := createTestTaskEditModel(task)
+		model.currentField = 2
+
+		msg := tea.KeyMsg{Type: tea.KeyEnter}
+		updatedModel, _ := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.mode != priorityPicker {
+			t.Errorf("Expected priorityPicker mode, got %d", model.mode)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyDown}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.priorityIndex != 1 {
+			t.Errorf("Expected priority index 1, got %d", model.priorityIndex)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyEnter}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		expectedPriority := textPriorityOptions[1]
+		if model.task.Priority != expectedPriority {
+			t.Errorf("Expected priority %s, got %s", expectedPriority, model.task.Priority)
+		}
+	})
+
+	t.Run("Priority Mode Switch", func(t *testing.T) {
+		task := &models.Task{ID: 1, Priority: models.PriorityHigh}
+		model := createTestTaskEditModel(task)
+		model.mode = priorityPicker
+
+		if model.priorityMode != priorityModeText {
+			t.Errorf("Expected text priority mode initially, got %d", model.priorityMode)
+		}
+
+		msg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'m'}}
+		updatedModel, _ := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.priorityMode != priorityModeNumeric {
+			t.Errorf("Expected numeric priority mode, got %d", model.priorityMode)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'m'}}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.priorityMode != priorityModeLegacy {
+			t.Errorf("Expected legacy priority mode, got %d", model.priorityMode)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'m'}}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.priorityMode != priorityModeText {
+			t.Errorf("Expected text priority mode after full cycle, got %d", model.priorityMode)
+		}
+	})
+
+	t.Run("TextInput", func(t *testing.T) {
+		task := &models.Task{ID: 1, Description: "Original description", Project: "original-project"}
+
+		model := createTestTaskEditModel(task)
+		model.currentField = 0
+
+		msg := tea.KeyMsg{Type: tea.KeyEnter}
+		updatedModel, _ := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.mode != textInput {
+			t.Errorf("Expected textInput mode, got %d", model.mode)
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'X'}}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		msg = tea.KeyMsg{Type: tea.KeyEnter}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.mode != fieldNavigation {
+			t.Errorf("Expected fieldNavigation mode after text input, got %d", model.mode)
+		}
+
+		expected := "Original descriptionX"
+		if model.task.Description != expected {
+			t.Errorf("Expected description %s, got %s", expected, model.task.Description)
+		}
+	})
+
+	t.Run("Help", func(t *testing.T) {
+		task := &models.Task{ID: 1}
+		model := createTestTaskEditModel(task)
+
+		msg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'?'}}
+		updatedModel, _ := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if !model.showingHelp {
+			t.Error("Expected help to be shown")
+		}
+
+		msg = tea.KeyMsg{Type: tea.KeyEsc}
+		updatedModel, _ = model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if model.showingHelp {
+			t.Error("Expected help to be hidden")
+		}
+	})
+
+	t.Run("Save", func(t *testing.T) {
+		task := &models.Task{ID: 1}
+		model := createTestTaskEditModel(task)
+		msg := tea.KeyMsg{Type: tea.KeyCtrlS}
+		updatedModel, cmd := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if !model.saved {
+			t.Error("Expected saved flag to be set")
+		}
+
+		if cmd == nil {
+			t.Error("Expected quit command after save")
+		}
+	})
+
+	t.Run("Cancel", func(t *testing.T) {
+		task := &models.Task{ID: 1}
+		model := createTestTaskEditModel(task)
+		msg := tea.KeyMsg{Type: tea.KeyCtrlC}
+		updatedModel, cmd := model.Update(msg)
+		model = updatedModel.(taskEditModel)
+
+		if !model.cancelled {
+			t.Error("Expected cancelled flag to be set")
+		}
+
+		if cmd == nil {
+			t.Error("Expected quit command after cancel")
+		}
+	})
+
+	t.Run("View", func(t *testing.T) {
+		task := &models.Task{
+			ID:          1,
+			Description: "Test task",
+			Status:      models.StatusTodo,
+			Priority:    models.PriorityHigh,
+			Project:     "test-project",
+		}
+
+		model := createTestTaskEditModel(task)
+		view := model.View()
+
+		if !strings.Contains(view, "Edit Task") {
+			t.Error("View should contain title")
+		}
+
+		if !strings.Contains(view, "Test task") {
+			t.Error("View should contain task description")
+		}
+
+		if !strings.Contains(view, "test-project") {
+			t.Error("View should contain project")
+		}
+	})
+
+	t.Run("Status Picker View", func(t *testing.T) {
+		task := &models.Task{ID: 1, Status: models.StatusTodo}
+		model := createTestTaskEditModel(task)
+		model.mode = statusPicker
+
+		view := model.View()
+
+		if !strings.Contains(view, "Select Status:") {
+			t.Error("Status picker should show selection prompt")
+		}
+
+		for _, status := range statusOptions {
+			if !strings.Contains(view, status) {
+				t.Errorf("Status picker should contain %s", status)
+			}
+		}
+	})
+
+	t.Run("Priority Picker View", func(t *testing.T) {
+		task := &models.Task{ID: 1, Priority: ""}
+		model := createTestTaskEditModel(task)
+		model.mode = priorityPicker
+		model.priorityMode = priorityModeText
+
+		view := model.View()
+
+		if !strings.Contains(view, "Select Priority") {
+			t.Error("Priority picker should show selection prompt")
+		}
+
+		if !strings.Contains(view, "Text") {
+			t.Error("Priority picker should show current mode")
+		}
+	})
+
+	t.Run("KeyBindings", func(t *testing.T) {
+		keyMap := taskEditKeys
+
+		if keyMap.Up.Keys()[0] != "up" {
+			t.Error("Up key binding should be defined")
+		}
+
+		if keyMap.StatusEdit.Keys()[0] != "s" {
+			t.Error("Status edit key binding should be 's'")
+		}
+
+		if keyMap.Priority.Keys()[0] != "p" {
+			t.Error("Priority key binding should be 'p'")
+		}
+
+		if keyMap.PriorityMode.Keys()[0] != "m" {
+			t.Error("Priority mode key binding should be 'm'")
+		}
+	})
+}
+
+func TestUpdatePriorityIndex(t *testing.T) {
+	testCases := []struct {
+		priority    string
+		mode        priorityMode
+		expectedIdx int
+	}{
+		{models.PriorityHigh, priorityModeText, 3},
+		{models.PriorityMedium, priorityModeText, 2},
+		{models.PriorityLow, priorityModeText, 1},
+		{"", priorityModeText, 0},
+		{"3", priorityModeNumeric, 3},
+		{"A", priorityModeLegacy, 1},
+		{"unknown", priorityModeText, 0},
+	}
+
+	for _, tc := range testCases {
+		task := &models.Task{ID: 1, Priority: tc.priority}
+		model := createTestTaskEditModel(task)
+		model.priorityMode = tc.mode
+		model.updatePriorityIndex()
+
+		if model.priorityIndex != tc.expectedIdx {
+			t.Errorf("Priority %s in mode %d should have index %d, got %d",
+				tc.priority, tc.mode, tc.expectedIdx, model.priorityIndex)
+		}
+	}
+}
+
+func TestRenderStatusField(t *testing.T) {
+	task := &models.Task{ID: 1, Status: models.StatusInProgress}
+	model := createTestTaskEditModel(task)
+
+	result := model.renderStatusField()
+	if !strings.Contains(result, models.StatusInProgress) {
+		t.Error("Status field should contain the status")
+	}
+
+	model.mode = statusPicker
+	result = model.renderStatusField()
+	if !strings.Contains(result, models.StatusTodo) || !strings.Contains(result, models.StatusDone) {
+		t.Error("Status picker should show status legend")
+	}
+}
+
+func TestRenderPriorityField(t *testing.T) {
+	task := &models.Task{ID: 1, Priority: models.PriorityMedium}
+	model := createTestTaskEditModel(task)
+	result := model.renderPriorityField()
+	if !strings.Contains(result, models.PriorityMedium) {
+		t.Error("Priority field should contain the priority")
+	}
+
+	model.mode = priorityPicker
+	model.priorityMode = priorityModeNumeric
+	result = model.renderPriorityField()
+	if !strings.Contains(result, "Numeric") {
+		t.Error("Priority picker should show current mode")
+	}
+}

internal/ui/task_information.go

···
+package ui
+
+import (
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+const (
+	// U+25CF Black Circle
+	StatusTodoSymbol = "●"
+	// U+25D0 Circle with Left Half Black
+	StatusInProgressSymbol = "◐"
+	// U+25A0 Black Square
+	StatusBlockedSymbol = "■"
+	// U+2713 Check Mark
+	StatusDoneSymbol = "✓"
+	// U+26AB Medium Black Circle
+	StatusAbandonedSymbol = "⚫"
+	// U+25CB White Circle
+	StatusPendingSymbol = "○"
+	// U+2713 Check Mark
+	StatusCompletedSymbol = "✓"
+	// U+2717 Ballot X
+	StatusDeletedSymbol = "✗"
+	// U+2605 Black Star
+	PriorityHighSymbol = "★"
+	// U+2606 White Star
+	PriorityMediumSymbol = "☆"
+	// U+25E6 White Bullet
+	PriorityLowSymbol = "◦"
+	// U+25CB White Circle
+	PriorityNoneSymbol = "○"
+	// Three stars
+	PriorityHighPattern = "★★★"
+	// Two stars, one outline
+	PriorityMediumPattern = "★★☆"
+	// One star, two outline
+	PriorityLowPattern = "★☆☆"
+	// Three outline stars
+	PriorityNonePattern = "☆☆☆"
+)
+
+var (
+	// Gray
+	TodoStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
+	// Blue
+	InProgressStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("12"))
+	// Red
+	BlockedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("9"))
+	// Green
+	DoneStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("10"))
+	// Dark Gray
+	AbandonedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
+	// Light Gray
+	PendingStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("7"))
+	// Green
+	CompletedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("10"))
+	// Dark Red
+	DeletedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("1"))
+	// Bright Red - highest urgency
+	PriorityHighStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("196"))
+	// Yellow - medium urgency
+	PriorityMediumStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("11"))
+	// Cyan - low urgency
+	PriorityLowStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("14"))
+	// Gray - no priority
+	PriorityNoneStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
+	// For legacy A-Z and numeric priorities
+	PriorityLegacyStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("13")) // Magenta
+)
+
+// GetStatusSymbol returns the unicode symbol for a given status
+//
+//	Default to pending
+func GetStatusSymbol(status string) string {
+	switch status {
+	case models.StatusTodo:
+		return StatusTodoSymbol
+	case models.StatusInProgress:
+		return StatusInProgressSymbol
+	case models.StatusBlocked:
+		return StatusBlockedSymbol
+	case models.StatusDone:
+		return StatusDoneSymbol
+	case models.StatusAbandoned:
+		return StatusAbandonedSymbol
+	case models.StatusPending:
+		return StatusPendingSymbol
+	case models.StatusCompleted:
+		return StatusCompletedSymbol
+	case models.StatusDeleted:
+		return StatusDeletedSymbol
+	default:
+		return StatusPendingSymbol
+	}
+}
+
+// GetStatusStyle returns the color style for a given status
+//
+//	Defaults to pending style
+func GetStatusStyle(status string) lipgloss.Style {
+	switch status {
+	case models.StatusTodo:
+		return TodoStyle
+	case models.StatusInProgress:
+		return InProgressStyle
+	case models.StatusBlocked:
+		return BlockedStyle
+	case models.StatusDone:
+		return DoneStyle
+	case models.StatusAbandoned:
+		return AbandonedStyle
+	case models.StatusPending:
+		return PendingStyle
+	case models.StatusCompleted:
+		return CompletedStyle
+	case models.StatusDeleted:
+		return DeletedStyle
+	default:
+		return PendingStyle
+	}
+}
+
+// FormatStatusIndicator returns a styled status symbol and text
+func FormatStatusIndicator(status string) string {
+	symbol := GetStatusSymbol(status)
+	style := GetStatusStyle(status)
+	return style.Render(symbol)
+}
+
+// FormatStatusWithText returns a styled status symbol with status text
+func FormatStatusWithText(status string) string {
+	symbol := GetStatusSymbol(status)
+	style := GetStatusStyle(status)
+	return style.Render(fmt.Sprintf("%s %s", symbol, status))
+}
+
+// GetStatusDescription returns a human-friendly description of the status
+func GetStatusDescription(status string) string {
+	switch status {
+	case models.StatusTodo:
+		return "Ready to start"
+	case models.StatusInProgress:
+		return "Currently working"
+	case models.StatusBlocked:
+		return "Waiting on dependency"
+	case models.StatusDone:
+		return "Completed successfully"
+	case models.StatusAbandoned:
+		return "No longer relevant"
+	case models.StatusPending:
+		return "Pending (legacy)"
+	case models.StatusCompleted:
+		return "Completed (legacy)"
+	case models.StatusDeleted:
+		return "Deleted (legacy)"
+	default:
+		return "Unknown status"
+	}
+}
+
+// FormatTaskStatus returns a complete status display with symbol, status, and description
+func FormatTaskStatus(task *models.Task) string {
+	if task == nil {
+		return ""
+	}
+
+	symbol := GetStatusSymbol(task.Status)
+	style := GetStatusStyle(task.Status)
+	description := GetStatusDescription(task.Status)
+
+	return fmt.Sprintf("%s %s - %s", style.Render(symbol), style.Render(task.Status), description)
+}
+
+// StatusLegend returns a formatted legend showing all status symbols
+func StatusLegend() string {
+	var parts []string
+
+	statuses := []string{
+		models.StatusTodo,
+		models.StatusInProgress,
+		models.StatusBlocked,
+		models.StatusDone,
+		models.StatusAbandoned,
+	}
+
+	for _, status := range statuses {
+		parts = append(parts, FormatStatusWithText(status))
+	}
+
+	return strings.Join(parts, "  ")
+}
+
+// GetAllStatusSymbols returns a map of all status symbols for reference
+func GetAllStatusSymbols() map[string]string {
+	return map[string]string{
+		models.StatusTodo:       StatusTodoSymbol,
+		models.StatusInProgress: StatusInProgressSymbol,
+		models.StatusBlocked:    StatusBlockedSymbol,
+		models.StatusDone:       StatusDoneSymbol,
+		models.StatusAbandoned:  StatusAbandonedSymbol,
+		models.StatusPending:    StatusPendingSymbol,
+		models.StatusCompleted:  StatusCompletedSymbol,
+		models.StatusDeleted:    StatusDeletedSymbol,
+	}
+}
+
+// IsValidStatusTransition checks if a status transition is logically valid
+//
+//	From todo, can go to in-progress, blocked, done, or abandoned
+//	From in-progress, can go to blocked, done, abandoned, or back to todo
+//	From blocked, can go to todo, in-progress, done, or abandoned
+//	From done, can only be reopened to todo or in-progress
+//	From abandoned, can be reopened to todo or in-progress
+func IsValidStatusTransition(from, to string) bool {
+	if from == models.StatusTodo {
+		validTo := []string{models.StatusInProgress, models.StatusBlocked, models.StatusDone, models.StatusAbandoned}
+		return slices.Contains(validTo, to)
+	}
+
+	if from == models.StatusInProgress {
+		validTo := []string{models.StatusTodo, models.StatusBlocked, models.StatusDone, models.StatusAbandoned}
+		return slices.Contains(validTo, to)
+	}
+
+	if from == models.StatusBlocked {
+		validTo := []string{models.StatusTodo, models.StatusInProgress, models.StatusDone, models.StatusAbandoned}
+		return slices.Contains(validTo, to)
+	}
+
+	if from == models.StatusDone {
+		validTo := []string{models.StatusTodo, models.StatusInProgress}
+		return slices.Contains(validTo, to)
+	}
+
+	if from == models.StatusAbandoned {
+		validTo := []string{models.StatusTodo, models.StatusInProgress}
+		return slices.Contains(validTo, to)
+	}
+
+	if from == models.StatusPending {
+		return to == models.StatusTodo || to == models.StatusInProgress
+	}
+
+	if from == models.StatusCompleted {
+		return to == models.StatusDone
+	}
+
+	return false
+}
+
+// GetPrioritySymbol returns the unicode symbol for a given priority
+func GetPrioritySymbol(priority string) string {
+	switch priority {
+	case models.PriorityHigh:
+		return PriorityHighSymbol
+	case models.PriorityMedium:
+		return PriorityMediumSymbol
+	case models.PriorityLow:
+		return PriorityLowSymbol
+	case "":
+		return PriorityNoneSymbol
+	default:
+		if len(priority) == 1 && priority >= "A" && priority <= "Z" {
+			return PriorityHighSymbol
+		}
+		switch priority {
+		case "1":
+			return PriorityLowSymbol
+		case "2", "3":
+			return PriorityMediumSymbol
+		case "4", "5":
+			return PriorityHighSymbol
+		default:
+			return PriorityNoneSymbol
+		}
+	}
+}
+
+// GetPriorityPattern returns the star pattern for a given priority
+func GetPriorityPattern(priority string) string {
+	switch priority {
+	case models.PriorityHigh:
+		return PriorityHighPattern
+	case models.PriorityMedium:
+		return PriorityMediumPattern
+	case models.PriorityLow:
+		return PriorityLowPattern
+	case "":
+		return PriorityNonePattern
+	default:
+		if len(priority) == 1 && priority >= "A" && priority <= "Z" {
+			if priority <= "C" {
+				return PriorityHighPattern
+			} else if priority <= "M" {
+				return PriorityMediumPattern
+			} else {
+				return PriorityLowPattern
+			}
+		}
+		switch priority {
+		case "1":
+			return PriorityLowPattern
+		case "2", "3":
+			return PriorityMediumPattern
+		case "4", "5":
+			return PriorityHighPattern
+		default:
+			return PriorityNonePattern
+		}
+	}
+}
+
+// GetPriorityStyle returns the color style for a given priority
+func GetPriorityStyle(priority string) lipgloss.Style {
+	switch priority {
+	case models.PriorityHigh:
+		return PriorityHighStyle
+	case models.PriorityMedium:
+		return PriorityMediumStyle
+	case models.PriorityLow:
+		return PriorityLowStyle
+	case "":
+		return PriorityNoneStyle
+	default:
+		if len(priority) == 1 && priority >= "A" && priority <= "Z" {
+			return PriorityLegacyStyle
+		}
+		switch priority {
+		case "1", "2", "3", "4", "5":
+			return PriorityLegacyStyle
+		default:
+			return PriorityNoneStyle
+		}
+	}
+}
+
+// FormatPriorityIndicator returns a styled priority pattern
+func FormatPriorityIndicator(priority string) string {
+	pattern := GetPriorityPattern(priority)
+	style := GetPriorityStyle(priority)
+	return style.Render(pattern)
+}
+
+// FormatPriorityWithText returns a styled priority with text description
+func FormatPriorityWithText(priority string) string {
+	pattern := GetPriorityPattern(priority)
+	style := GetPriorityStyle(priority)
+
+	if priority == "" {
+		return style.Render(fmt.Sprintf("%s None", pattern))
+	}
+
+	return style.Render(fmt.Sprintf("%s %s", pattern, priority))
+}
+
+// GetPriorityDescription returns a human-friendly description of the priority
+func GetPriorityDescription(priority string) string {
+	switch priority {
+	case models.PriorityHigh:
+		return "Urgent - do first"
+	case models.PriorityMedium:
+		return "Important - schedule soon"
+	case models.PriorityLow:
+		return "Nice to have - when time permits"
+	case "":
+		return "No priority set"
+	default:
+		if len(priority) == 1 && priority >= "A" && priority <= "Z" {
+			return fmt.Sprintf("Priority %s (legacy)", priority)
+		}
+		switch priority {
+		case "1":
+			return "Priority 1 (lowest)"
+		case "2":
+			return "Priority 2 (low)"
+		case "3":
+			return "Priority 3 (medium)"
+		case "4":
+			return "Priority 4 (high)"
+		case "5":
+			return "Priority 5 (highest)"
+		default:
+			return "Unknown priority"
+		}
+	}
+}
+
+// FormatTaskPriority returns a complete priority display with pattern, priority, and description
+func FormatTaskPriority(task *models.Task) string {
+	if task == nil {
+		return ""
+	}
+
+	pattern := GetPriorityPattern(task.Priority)
+	style := GetPriorityStyle(task.Priority)
+	description := GetPriorityDescription(task.Priority)
+
+	if task.Priority == "" {
+		return fmt.Sprintf("%s %s", style.Render(pattern), description)
+	}
+
+	return fmt.Sprintf("%s %s - %s", style.Render(pattern), style.Render(task.Priority), description)
+}
+
+// PriorityLegend returns a formatted legend showing all priority patterns
+func PriorityLegend() string {
+	var parts []string
+
+	priorities := []string{
+		models.PriorityHigh, models.PriorityMedium, models.PriorityLow, "",
+	}
+
+	for _, priority := range priorities {
+		parts = append(parts, FormatPriorityWithText(priority))
+	}
+
+	return strings.Join(parts, "  ")
+}
+
+// GetAllPrioritySymbols returns a map of all priority symbols for reference
+func GetAllPrioritySymbols() map[string]string {
+	return map[string]string{
+		models.PriorityHigh:   PriorityHighSymbol,
+		models.PriorityMedium: PriorityMediumSymbol,
+		models.PriorityLow:    PriorityLowSymbol,
+		"":                    PriorityNoneSymbol,
+	}
+}
+
+// GetAllPriorityPatterns returns a map of all priority patterns for reference
+func GetAllPriorityPatterns() map[string]string {
+	return map[string]string{
+		models.PriorityHigh:   PriorityHighPattern,
+		models.PriorityMedium: PriorityMediumPattern,
+		models.PriorityLow:    PriorityLowPattern,
+		"":                    PriorityNonePattern,
+	}
+}
+
+// GetPriorityDisplayType returns the display type for a priority (text, numeric, or legacy)
+func GetPriorityDisplayType(priority string) string {
+	switch priority {
+	case models.PriorityHigh, models.PriorityMedium, models.PriorityLow:
+		return "text"
+	case "1", "2", "3", "4", "5":
+		return "numeric"
+	case "":
+		return "none"
+	default:
+		if len(priority) == 1 && priority >= "A" && priority <= "Z" {
+			return "legacy"
+		}
+		return "unknown"
+	}
+}

internal/ui/task_information_test.go

···
+package ui
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func TestGetStatusSymbol(t *testing.T) {
+	testCases := []struct {
+		status   string
+		expected string
+	}{
+		{models.StatusTodo, StatusTodoSymbol},
+		{models.StatusInProgress, StatusInProgressSymbol},
+		{models.StatusBlocked, StatusBlockedSymbol},
+		{models.StatusDone, StatusDoneSymbol},
+		{models.StatusAbandoned, StatusAbandonedSymbol},
+		{models.StatusPending, StatusPendingSymbol},
+		{models.StatusCompleted, StatusCompletedSymbol},
+		{models.StatusDeleted, StatusDeletedSymbol},
+		{"unknown", StatusPendingSymbol},
+	}
+
+	for _, tc := range testCases {
+		t.Run("status_"+tc.status, func(t *testing.T) {
+			result := GetStatusSymbol(tc.status)
+			if result != tc.expected {
+				t.Errorf("Expected symbol %s for status %s, got %s", tc.expected, tc.status, result)
+			}
+		})
+	}
+}
+
+func TestGetStatusStyle(t *testing.T) {
+	testCases := []struct {
+		status string
+		style  lipgloss.Style
+	}{
+		{models.StatusTodo, TodoStyle},
+		{models.StatusInProgress, InProgressStyle},
+		{models.StatusBlocked, BlockedStyle},
+		{models.StatusDone, DoneStyle},
+		{models.StatusAbandoned, AbandonedStyle},
+		{models.StatusPending, PendingStyle},
+		{models.StatusCompleted, CompletedStyle},
+		{models.StatusDeleted, DeletedStyle},
+		{"unknown", PendingStyle},
+	}
+
+	for _, tc := range testCases {
+		t.Run("style_"+tc.status, func(t *testing.T) {
+			result := GetStatusStyle(tc.status)
+			expectedColor := tc.style.GetForeground()
+			resultColor := result.GetForeground()
+			if expectedColor != resultColor {
+				t.Errorf("Expected color %s for status %s, got %s", expectedColor, tc.status, resultColor)
+			}
+		})
+	}
+}
+
+func TestFormatStatusIndicator(t *testing.T) {
+	testCases := []string{
+		models.StatusTodo,
+		models.StatusInProgress,
+		models.StatusBlocked,
+		models.StatusDone,
+		models.StatusAbandoned,
+	}
+
+	for _, status := range testCases {
+		t.Run("format_indicator_"+status, func(t *testing.T) {
+			result := FormatStatusIndicator(status)
+			expectedSymbol := GetStatusSymbol(status)
+
+			if !strings.Contains(result, expectedSymbol) {
+				t.Errorf("Expected formatted indicator for %s to contain symbol %s", status, expectedSymbol)
+			}
+
+			if result == "" {
+				t.Errorf("Expected non-empty formatted indicator for status %s", status)
+			}
+		})
+	}
+}
+
+func TestFormatStatusWithText(t *testing.T) {
+	testCases := []string{
+		models.StatusTodo,
+		models.StatusInProgress,
+		models.StatusBlocked,
+		models.StatusDone,
+		models.StatusAbandoned,
+	}
+
+	for _, status := range testCases {
+		t.Run("format_with_text_"+status, func(t *testing.T) {
+			result := FormatStatusWithText(status)
+			expectedSymbol := GetStatusSymbol(status)
+
+			if !strings.Contains(result, expectedSymbol) {
+				t.Errorf("Expected formatted status for %s to contain symbol %s", status, expectedSymbol)
+			}
+			if !strings.Contains(result, status) {
+				t.Errorf("Expected formatted status for %s to contain status text", status)
+			}
+
+			if result == "" {
+				t.Errorf("Expected non-empty formatted status for %s", status)
+			}
+		})
+	}
+}
+
+func TestGetStatusDescription(t *testing.T) {
+	testCases := []struct {
+		status      string
+		description string
+	}{
+		{models.StatusTodo, "Ready to start"},
+		{models.StatusInProgress, "Currently working"},
+		{models.StatusBlocked, "Waiting on dependency"},
+		{models.StatusDone, "Completed successfully"},
+		{models.StatusAbandoned, "No longer relevant"},
+		{models.StatusPending, "Pending (legacy)"},
+		{models.StatusCompleted, "Completed (legacy)"},
+		{models.StatusDeleted, "Deleted (legacy)"},
+		{"unknown", "Unknown status"},
+	}
+
+	for _, tc := range testCases {
+		t.Run("description_"+tc.status, func(t *testing.T) {
+			result := GetStatusDescription(tc.status)
+			if result != tc.description {
+				t.Errorf("Expected description %s for status %s, got %s", tc.description, tc.status, result)
+			}
+		})
+	}
+}
+
+func TestFormatTaskStatus(t *testing.T) {
+	t.Run("nil_task", func(t *testing.T) {
+		result := FormatTaskStatus(nil)
+		if result != "" {
+			t.Errorf("Expected empty string for nil task, got %s", result)
+		}
+	})
+
+	testCases := []string{
+		models.StatusTodo,
+		models.StatusInProgress,
+		models.StatusBlocked,
+		models.StatusDone,
+		models.StatusAbandoned,
+	}
+
+	for _, status := range testCases {
+		t.Run("format_task_status_"+status, func(t *testing.T) {
+			task := &models.Task{
+				ID:     1,
+				Status: status,
+			}
+
+			result := FormatTaskStatus(task)
+			expectedSymbol := GetStatusSymbol(status)
+			expectedDescription := GetStatusDescription(status)
+
+			if !strings.Contains(result, expectedSymbol) {
+				t.Errorf("Expected task status format to contain symbol %s", expectedSymbol)
+			}
+			if !strings.Contains(result, status) {
+				t.Errorf("Expected task status format to contain status %s", status)
+			}
+			if !strings.Contains(result, expectedDescription) {
+				t.Errorf("Expected task status format to contain description %s", expectedDescription)
+			}
+
+			if result == "" {
+				t.Errorf("Expected non-empty formatted task status for %s", status)
+			}
+		})
+	}
+}
+
+func TestStatusLegend(t *testing.T) {
+	result := StatusLegend()
+
+	if result == "" {
+		t.Error("Expected non-empty status legend")
+	}
+
+	expectedStatuses := []string{
+		models.StatusTodo,
+		models.StatusInProgress,
+		models.StatusBlocked,
+		models.StatusDone,
+		models.StatusAbandoned,
+	}
+
+	for _, status := range expectedStatuses {
+		expectedSymbol := GetStatusSymbol(status)
+		if !strings.Contains(result, expectedSymbol) {
+			t.Errorf("Expected legend to contain symbol %s for status %s", expectedSymbol, status)
+		}
+		if !strings.Contains(result, status) {
+			t.Errorf("Expected legend to contain status text %s", status)
+		}
+	}
+}
+
+func TestGetAllStatusSymbols(t *testing.T) {
+	symbols := GetAllStatusSymbols()
+
+	expectedSymbols := map[string]string{
+		models.StatusTodo:       StatusTodoSymbol,
+		models.StatusInProgress: StatusInProgressSymbol,
+		models.StatusBlocked:    StatusBlockedSymbol,
+		models.StatusDone:       StatusDoneSymbol,
+		models.StatusAbandoned:  StatusAbandonedSymbol,
+		models.StatusPending:    StatusPendingSymbol,
+		models.StatusCompleted:  StatusCompletedSymbol,
+		models.StatusDeleted:    StatusDeletedSymbol,
+	}
+
+	if len(symbols) != len(expectedSymbols) {
+		t.Errorf("Expected %d status symbols, got %d", len(expectedSymbols), len(symbols))
+	}
+
+	for status, expectedSymbol := range expectedSymbols {
+		if symbol, exists := symbols[status]; !exists {
+			t.Errorf("Expected status %s to exist in symbols map", status)
+		} else if symbol != expectedSymbol {
+			t.Errorf("Expected symbol %s for status %s, got %s", expectedSymbol, status, symbol)
+		}
+	}
+}
+
+func TestIsValidStatusTransition(t *testing.T) {
+	testCases := []struct {
+		from     string
+		to       string
+		expected bool
+	}{
+		{models.StatusTodo, models.StatusInProgress, true},
+		{models.StatusTodo, models.StatusBlocked, true},
+		{models.StatusTodo, models.StatusDone, true},
+		{models.StatusTodo, models.StatusAbandoned, true},
+		{models.StatusTodo, models.StatusTodo, false},
+
+		{models.StatusInProgress, models.StatusTodo, true},
+		{models.StatusInProgress, models.StatusBlocked, true},
+		{models.StatusInProgress, models.StatusDone, true},
+		{models.StatusInProgress, models.StatusAbandoned, true},
+		{models.StatusInProgress, models.StatusInProgress, false},
+
+		{models.StatusBlocked, models.StatusTodo, true},
+		{models.StatusBlocked, models.StatusInProgress, true},
+		{models.StatusBlocked, models.StatusDone, true},
+		{models.StatusBlocked, models.StatusAbandoned, true},
+		{models.StatusBlocked, models.StatusBlocked, false},
+
+		{models.StatusDone, models.StatusTodo, true},
+		{models.StatusDone, models.StatusInProgress, true},
+		{models.StatusDone, models.StatusBlocked, false},
+		{models.StatusDone, models.StatusAbandoned, false},
+		{models.StatusDone, models.StatusDone, false},
+
+		{models.StatusAbandoned, models.StatusTodo, true},
+		{models.StatusAbandoned, models.StatusInProgress, true},
+		{models.StatusAbandoned, models.StatusBlocked, false},
+		{models.StatusAbandoned, models.StatusDone, false},
+		{models.StatusAbandoned, models.StatusAbandoned, false},
+
+		{models.StatusPending, models.StatusTodo, true},
+		{models.StatusPending, models.StatusInProgress, true},
+		{models.StatusPending, models.StatusBlocked, false},
+		{models.StatusCompleted, models.StatusDone, true},
+		{models.StatusCompleted, models.StatusTodo, false},
+
+		{"unknown", models.StatusTodo, false},
+		{models.StatusTodo, "unknown", false},
+	}
+
+	for _, tc := range testCases {
+		t.Run("transition_"+tc.from+"_to_"+tc.to, func(t *testing.T) {
+			result := IsValidStatusTransition(tc.from, tc.to)
+			if result != tc.expected {
+				t.Errorf("Expected transition from %s to %s to be %v, got %v",
+					tc.from, tc.to, tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestUnicodeSymbolConstants(t *testing.T) {
+	symbols := []struct {
+		name   string
+		symbol string
+		code   string
+	}{
+		{"TodoSymbol", StatusTodoSymbol, "●"},
+		{"InProgressSymbol", StatusInProgressSymbol, "◐"},
+		{"BlockedSymbol", StatusBlockedSymbol, "■"},
+		{"DoneSymbol", StatusDoneSymbol, "✓"},
+		{"AbandonedSymbol", StatusAbandonedSymbol, "⚫"},
+		{"PendingSymbol", StatusPendingSymbol, "○"},
+		{"CompletedSymbol", StatusCompletedSymbol, "✓"},
+		{"DeletedSymbol", StatusDeletedSymbol, "✗"},
+	}
+
+	for _, s := range symbols {
+		t.Run("symbol_"+s.name, func(t *testing.T) {
+			if s.symbol != s.code {
+				t.Errorf("Expected %s to be %s, got %s", s.name, s.code, s.symbol)
+			}
+		})
+	}
+
+	symbolMap := make(map[string][]string)
+	for _, s := range symbols {
+		symbolMap[s.symbol] = append(symbolMap[s.symbol], s.name)
+	}
+
+	for symbol, names := range symbolMap {
+		if len(names) > 1 && symbol != "✓" {
+			t.Errorf("Symbol %s is used by multiple constants: %v", symbol, names)
+		}
+	}
+}
+
+func TestStyleConstants(t *testing.T) {
+	styles := []struct {
+		name  string
+		style lipgloss.Style
+	}{
+		{"TodoStyle", TodoStyle},
+		{"InProgressStyle", InProgressStyle},
+		{"BlockedStyle", BlockedStyle},
+		{"DoneStyle", DoneStyle},
+		{"AbandonedStyle", AbandonedStyle},
+		{"PendingStyle", PendingStyle},
+		{"CompletedStyle", CompletedStyle},
+		{"DeletedStyle", DeletedStyle},
+	}
+
+	for _, s := range styles {
+		t.Run("style_"+s.name, func(t *testing.T) {
+			testText := "test"
+			rendered := s.style.Render(testText)
+			// In test environment without terminal, just check that rendering produces output
+			if rendered == "" {
+				t.Errorf("Expected %s to produce output when rendering text", s.name)
+			}
+		})
+	}
+}
+
+// Priority UI Tests
+
+func TestGetPrioritySymbol(t *testing.T) {
+	testCases := []struct {
+		priority string
+		expected string
+	}{
+		{models.PriorityHigh, PriorityHighSymbol},
+		{models.PriorityMedium, PriorityMediumSymbol},
+		{models.PriorityLow, PriorityLowSymbol},
+		{"", PriorityNoneSymbol},
+		{"A", PriorityHighSymbol},
+		{"Z", PriorityHighSymbol},
+		{"1", PriorityLowSymbol},
+		{"2", PriorityMediumSymbol},
+		{"3", PriorityMediumSymbol},
+		{"4", PriorityHighSymbol},
+		{"5", PriorityHighSymbol},
+		{"unknown", PriorityNoneSymbol},
+	}
+
+	for _, tc := range testCases {
+		t.Run("priority_symbol_"+tc.priority, func(t *testing.T) {
+			result := GetPrioritySymbol(tc.priority)
+			if result != tc.expected {
+				t.Errorf("Expected symbol %s for priority %s, got %s", tc.expected, tc.priority, result)
+			}
+		})
+	}
+}
+
+func TestGetPriorityPattern(t *testing.T) {
+	testCases := []struct {
+		priority string
+		expected string
+	}{
+		{models.PriorityHigh, PriorityHighPattern},
+		{models.PriorityMedium, PriorityMediumPattern},
+		{models.PriorityLow, PriorityLowPattern},
+		{"", PriorityNonePattern},
+		{"A", PriorityHighPattern},
+		{"C", PriorityHighPattern},
+		{"M", PriorityMediumPattern},
+		{"Z", PriorityLowPattern},
+		{"1", PriorityLowPattern},
+		{"2", PriorityMediumPattern},
+		{"3", PriorityMediumPattern},
+		{"4", PriorityHighPattern},
+		{"5", PriorityHighPattern},
+		{"unknown", PriorityNonePattern},
+	}
+
+	for _, tc := range testCases {
+		t.Run("priority_pattern_"+tc.priority, func(t *testing.T) {
+			result := GetPriorityPattern(tc.priority)
+			if result != tc.expected {
+				t.Errorf("Expected pattern %s for priority %s, got %s", tc.expected, tc.priority, result)
+			}
+		})
+	}
+}
+
+func TestGetPriorityStyle(t *testing.T) {
+	testCases := []struct {
+		priority string
+		style    lipgloss.Style
+	}{
+		{models.PriorityHigh, PriorityHighStyle},
+		{models.PriorityMedium, PriorityMediumStyle},
+		{models.PriorityLow, PriorityLowStyle},
+		{"", PriorityNoneStyle},
+		{"A", PriorityLegacyStyle},
+		{"1", PriorityLegacyStyle},
+		{"unknown", PriorityNoneStyle},
+	}
+
+	for _, tc := range testCases {
+		t.Run("priority_style_"+tc.priority, func(t *testing.T) {
+			result := GetPriorityStyle(tc.priority)
+			expectedColor := tc.style.GetForeground()
+			resultColor := result.GetForeground()
+			if expectedColor != resultColor {
+				t.Errorf("Expected color %s for priority %s, got %s", expectedColor, tc.priority, resultColor)
+			}
+		})
+	}
+}
+
+func TestFormatPriorityIndicator(t *testing.T) {
+	testCases := []string{models.PriorityHigh, models.PriorityMedium, models.PriorityLow, "", "A", "1"}
+
+	for _, priority := range testCases {
+		t.Run("format_priority_indicator_"+priority, func(t *testing.T) {
+			got := FormatPriorityIndicator(priority)
+			want := GetPriorityPattern(priority)
+
+			if !strings.Contains(got, want) {
+				t.Errorf("Expected formatted priority indicator for %s to contain pattern %s", priority, want)
+			}
+
+			if got == "" {
+				t.Errorf("Expected non-empty formatted priority indicator for priority %s", priority)
+			}
+		})
+	}
+}
+
+func TestFormatPriorityWithText(t *testing.T) {
+	testCases := []struct {
+		priority      string
+		shouldContain []string
+	}{
+		{models.PriorityHigh, []string{PriorityHighPattern, models.PriorityHigh}},
+		{models.PriorityMedium, []string{PriorityMediumPattern, models.PriorityMedium}},
+		{models.PriorityLow, []string{PriorityLowPattern, models.PriorityLow}},
+		{"", []string{PriorityNonePattern, "None"}},
+		{"A", []string{PriorityHighPattern, "A"}},
+		{"1", []string{PriorityLowPattern, "1"}},
+	}
+
+	for _, tc := range testCases {
+		t.Run("format_priority_with_text_"+tc.priority, func(t *testing.T) {
+			got := FormatPriorityWithText(tc.priority)
+
+			for _, want := range tc.shouldContain {
+				if !strings.Contains(got, want) {
+					t.Errorf("Expected formatted priority for %s to contain %s, got %s", tc.priority, want, got)
+				}
+			}
+
+			if got == "" {
+				t.Errorf("Expected non-empty formatted priority for %s", tc.priority)
+			}
+		})
+	}
+}
+
+func TestGetPriorityDescription(t *testing.T) {
+	testCases := []struct {
+		priority    string
+		description string
+	}{
+		{models.PriorityHigh, "Urgent - do first"},
+		{models.PriorityMedium, "Important - schedule soon"},
+		{models.PriorityLow, "Nice to have - when time permits"},
+		{"", "No priority set"},
+		{"A", "Priority A (legacy)"},
+		{"Z", "Priority Z (legacy)"},
+		{"1", "Priority 1 (lowest)"},
+		{"2", "Priority 2 (low)"},
+		{"3", "Priority 3 (medium)"},
+		{"4", "Priority 4 (high)"},
+		{"5", "Priority 5 (highest)"},
+		{"unknown", "Unknown priority"},
+	}
+
+	for _, tc := range testCases {
+		t.Run("priority_description_"+tc.priority, func(t *testing.T) {
+			got := GetPriorityDescription(tc.priority)
+			want := tc.description
+			if got != want {
+				t.Errorf("Expected description %s for priority %s, got %s", want, tc.priority, got)
+			}
+		})
+	}
+}
+
+func TestFormatTaskPriority(t *testing.T) {
+	t.Run("nil_task", func(t *testing.T) {
+		got := FormatTaskPriority(nil)
+		if got != "" {
+			t.Errorf("Expected empty string for nil task, got %s", got)
+		}
+	})
+
+	testCases := []struct {
+		priority      string
+		shouldContain []string
+	}{
+		{models.PriorityHigh, []string{PriorityHighPattern, models.PriorityHigh, "Urgent - do first"}},
+		{models.PriorityMedium, []string{PriorityMediumPattern, models.PriorityMedium, "Important - schedule soon"}},
+		{models.PriorityLow, []string{PriorityLowPattern, models.PriorityLow, "Nice to have - when time permits"}},
+		{"", []string{PriorityNonePattern, "No priority set"}},
+		{"A", []string{PriorityHighPattern, "A", "Priority A (legacy)"}},
+		{"1", []string{PriorityLowPattern, "1", "Priority 1 (lowest)"}},
+	}
+
+	for _, tc := range testCases {
+		t.Run("format_task_priority_"+tc.priority, func(t *testing.T) {
+			task := &models.Task{ID: 1, Priority: tc.priority}
+			got := FormatTaskPriority(task)
+
+			for _, want := range tc.shouldContain {
+				if !strings.Contains(got, want) {
+					t.Errorf("Expected task priority format to contain %s, got %s", want, got)
+				}
+			}
+
+			if got == "" {
+				t.Errorf("Expected non-empty formatted task priority for %s", tc.priority)
+			}
+		})
+	}
+}
+
+func TestPriorityLegend(t *testing.T) {
+	got := PriorityLegend()
+
+	if got == "" {
+		t.Error("Expected non-empty priority legend")
+	}
+
+	expectedPriorities := []string{models.PriorityHigh, models.PriorityMedium, models.PriorityLow, "None"}
+	expectedPatterns := []string{PriorityHighPattern, PriorityMediumPattern, PriorityLowPattern, PriorityNonePattern}
+
+	for _, want := range expectedPriorities {
+		if !strings.Contains(got, want) {
+			t.Errorf("Expected legend to contain priority text %s", want)
+		}
+	}
+
+	for _, want := range expectedPatterns {
+		if !strings.Contains(got, want) {
+			t.Errorf("Expected legend to contain pattern %s", want)
+		}
+	}
+}
+
+func TestGetAllPrioritySymbols(t *testing.T) {
+	symbols := GetAllPrioritySymbols()
+
+	expectedSymbols := map[string]string{
+		models.PriorityHigh:   PriorityHighSymbol,
+		models.PriorityMedium: PriorityMediumSymbol,
+		models.PriorityLow:    PriorityLowSymbol,
+		"":                    PriorityNoneSymbol,
+	}
+
+	if len(symbols) != len(expectedSymbols) {
+		t.Errorf("Expected %d priority symbols, got %d", len(expectedSymbols), len(symbols))
+	}
+
+	for priority, expectedSymbol := range expectedSymbols {
+		if symbol, exists := symbols[priority]; !exists {
+			t.Errorf("Expected priority %s to exist in symbols map", priority)
+		} else if symbol != expectedSymbol {
+			t.Errorf("Expected symbol %s for priority %s, got %s", expectedSymbol, priority, symbol)
+		}
+	}
+}
+
+func TestGetAllPriorityPatterns(t *testing.T) {
+	patterns := GetAllPriorityPatterns()
+
+	expectedPatterns := map[string]string{
+		models.PriorityHigh:   PriorityHighPattern,
+		models.PriorityMedium: PriorityMediumPattern,
+		models.PriorityLow:    PriorityLowPattern,
+		"":                    PriorityNonePattern,
+	}
+
+	if len(patterns) != len(expectedPatterns) {
+		t.Errorf("Expected %d priority patterns, got %d", len(expectedPatterns), len(patterns))
+	}
+
+	for priority, want := range expectedPatterns {
+		if got, exists := patterns[priority]; !exists {
+			t.Errorf("Expected priority %s to exist in patterns map", priority)
+		} else if got != want {
+			t.Errorf("Expected pattern %s for priority %s, got %s", want, priority, got)
+		}
+	}
+}
+
+func TestGetPriorityDisplayType(t *testing.T) {
+	testCases := []struct {
+		priority string
+		expected string
+	}{
+		{models.PriorityHigh, "text"},
+		{models.PriorityMedium, "text"},
+		{models.PriorityLow, "text"},
+		{"1", "numeric"},
+		{"2", "numeric"},
+		{"3", "numeric"},
+		{"4", "numeric"},
+		{"5", "numeric"},
+		{"A", "legacy"},
+		{"Z", "legacy"},
+		{"", "none"},
+		{"unknown", "unknown"},
+	}
+
+	for _, tc := range testCases {
+		t.Run("priority_display_type_"+tc.priority, func(t *testing.T) {
+			got := GetPriorityDisplayType(tc.priority)
+			if got != tc.expected {
+				t.Errorf("Expected display type %s for priority %s, got %s", tc.expected, tc.priority, got)
+			}
+		})
+	}
+}
+
+func TestPriorityUnicodeSymbolConstants(t *testing.T) {
+	symbols := []struct {
+		name   string
+		symbol string
+		code   string
+	}{
+		{"PriorityHighSymbol", PriorityHighSymbol, "★"},
+		{"PriorityMediumSymbol", PriorityMediumSymbol, "☆"},
+		{"PriorityLowSymbol", PriorityLowSymbol, "◦"},
+		{"PriorityNoneSymbol", PriorityNoneSymbol, "○"},
+	}
+
+	for _, s := range symbols {
+		t.Run("priority_symbol_"+s.name, func(t *testing.T) {
+			if s.symbol != s.code {
+				t.Errorf("Expected %s to be %s, got %s", s.name, s.code, s.symbol)
+			}
+		})
+	}
+}
+
+func TestPriorityPatternConstants(t *testing.T) {
+	patterns := []struct {
+		name    string
+		pattern string
+		code    string
+	}{
+		{"PriorityHighPattern", PriorityHighPattern, "★★★"},
+		{"PriorityMediumPattern", PriorityMediumPattern, "★★☆"},
+		{"PriorityLowPattern", PriorityLowPattern, "★☆☆"},
+		{"PriorityNonePattern", PriorityNonePattern, "☆☆☆"},
+	}
+
+	for _, p := range patterns {
+		t.Run("priority_pattern_"+p.name, func(t *testing.T) {
+			if p.pattern != p.code {
+				t.Errorf("Expected %s to be %s, got %s", p.name, p.code, p.pattern)
+			}
+		})
+	}
+}
+
+func TestPriorityStyleConstants(t *testing.T) {
+	styles := []struct {
+		name  string
+		style lipgloss.Style
+	}{
+		{"PriorityHighStyle", PriorityHighStyle},
+		{"PriorityMediumStyle", PriorityMediumStyle},
+		{"PriorityLowStyle", PriorityLowStyle},
+		{"PriorityNoneStyle", PriorityNoneStyle},
+		{"PriorityLegacyStyle", PriorityLegacyStyle},
+	}
+
+	for _, s := range styles {
+		t.Run("priority_style_"+s.name, func(t *testing.T) {
+			testText := "test"
+			rendered := s.style.Render(testText)
+			if rendered == "" {
+				t.Errorf("Expected %s to produce output when rendering text", s.name)
+			}
+		})
+	}
+}