feat: update task listing with project & tag lists

ROADMAP.md

···
 
 ## Core Task Management (TaskWarrior-inspired)
 
-- [x] `list` - Display tasks with filtering and sorting options
-- [ ] `projects` - List all project names
-- [ ] `tags` - List all tag names
+### Basic Operations
 
 - [x] `create|new` - Add new task with description and optional metadata
-
+- [x] `list` - Display tasks with filtering and sorting options
 - [x] `view` - View task by ID
+- [x] `update` - Edit task properties (description, priority, project, tags)
 - [x] `done` - Mark task as completed
-- [x] `update` - Edit task properties (description, priority, project, tags)
-- [ ] `start/stop` - Track active time on tasks
+- [x] `delete` - Remove task permanently
+
+### Organization & Metadata
+
+- [x] Project & context organization
+    - [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
+- [ ] Due dates & scheduling - Including recurring tasks
+- [ ] Task dependencies - Task A blocks task B relationships
+
+### Time Management
+
+- [ ] Time tracking functionality
+    - [ ] `start/stop` - Track active time on tasks
+    - [ ] `timesheet` - Show time tracking summaries
+    - [ ] `calendar` - Display tasks in calendar view
+
+### Advanced Task Features
+
 - [ ] `annotate` - Add notes/comments to existing tasks
+- [ ] Recurring tasks
+- [ ] Smart due date suggestions
+- [ ] Completion notifications
 
-- [x] `delete` - Remove task permanently
+## Content Queue Management
 
-- [ ] `calendar` - Display tasks in calendar view
-- [ ] `timesheet` - Show time tracking summaries
+### Reading Management
 
-## Todo.txt Compatibility
+- [x] `book add` - Add book to reading list
+- [x] `book list` - Show reading queue with progress
+- [x] `book reading` - Mark book as currently reading
+- [x] `book finished|read` - Mark book as completed
+- [x] `book remove|rm` - Remove from reading list
+- [x] `book progress` - Update reading progress percentage
 
-- [ ] `archive` - Move completed tasks to done.txt
-- [ ] `[con]texts` - List all contexts (@context)
-- [ ] `[proj]ects` - List all projects (+project)
-- [ ] `[pri]ority` - Set task priority (A-Z)
-- [ ] `[depri]oritize` - Remove priority from task
-- [ ] `[re]place` - Replace task text entirely
-- [ ] `prepend/append` - Add text to beginning/end of task
+#### Enhanced Reading Features
+
+- [ ] Articles, papers, blogs support (implement article parser)
+- [ ] Reading status: want-to-read, currently-reading, completed, abandoned
+- [ ] Source tracking (recommendation sources)
+- [ ] Ratings and personal notes
+- [ ] Genre/topic tagging
+- [ ] Progress tracking (pages/chapters read, completion %)
 
-## Media Queue Management
+### Watching Management
 
 - [ ] `movie add` - Add movie to watch queue
 - [ ] `movie list` - Show movie queue with ratings/metadata
···
 - [ ] `tv watched|seen` - Mark episodes/seasons as watched
 - [ ] `tv remove|rm` - Remove from TV queue
 
-## Reading List Management
+#### Enhanced Watching Features
+
+- [ ] Episode/season progress tracking
+- [ ] Watch status: queued, watching, completed, dropped
+- [ ] Platform tracking (Netflix, Amazon, etc.)
+- [ ] Ratings and reviews
+- [ ] Genre/mood tagging
+
+## Organization & Discovery Features
+
+### Smart Views & Filtering
+
+- [ ] Custom queries and saved searches
+- [ ] Context-aware suggestions
+- [ ] Overdue/urgent highlighting
+- [ ] Recently added/modified items
+- [ ] Seasonal/mood-based filtering
+- [ ] Full-text search across titles, notes, tags
+
+### Analytics & Insights
+
+- [ ] Reading/watching velocity tracking
+- [ ] Completion rates by content type
+- [ ] Time investment analysis
+- [ ] Personal productivity metrics
+- [ ] Content source analysis
+
+## Advanced Workflow Features
+
+### Integration & Import
+
+- [ ] `import` - Import from various formats (CSV, JSON, todo.txt)
+- [ ] `export` - Export to various formats
+- [ ] Goodreads import for books
+- [ ] IMDB/Letterboxd import for movies
+- [ ] Todo.txt format compatibility
+- [ ] TaskWarrior import/export
+- [ ] URL parsing for automatic metadata
+
+### Todo.txt Compatibility
 
-- [x] `book add` - Add book to reading list
-- [x] `book list` - Show reading queue with progress
-- [x] `book reading` - Mark book as currently reading
-- [x] `book finished|read` - Mark book as completed
-- [x] `book remove|rm` - Remove from reading list
-- [x] `book progress` - Update reading progress percentage
+- [ ] `archive` - Move completed tasks to done.txt
+- [ ] `[con]texts` - List all contexts (@context)
+- [ ] `[proj]ects` - List all projects (+project)
+- [ ] `[pri]ority` - Set task priority (A-Z)
+- [ ] `[depri]oritize` - Remove priority from task
+- [ ] `[re]place` - Replace task text entirely
+- [ ] `prepend/append` - Add text to beginning/end of task
+
+### Automation
+
+- [ ] Auto-categorization of new items
+- [ ] Smart due date suggestions
+- [ ] Recurring content (weekly podcast check-ins)
+- [ ] Completion notifications
 
 ## Data Management
+
+### Storage & Sync
 
 - [ ] `sync` - Synchronize with remote storage
 - [ ] `sync setup` - Setup remote storage
-
+- [ ] Local SQLite database with optional cloud sync
+- [ ] Multiple profile support
 - [ ] `backup` - Create local backup
+- [ ] Backup/restore functionality
 
-- [ ] `import` - Import from various formats (CSV, JSON, todo.txt)
-- [ ] `export` - Export to various formats
+### Configuration
 
 - [ ] `config` - Manage configuration settings
-
 - [ ] `undo` - Reverse last operation
+- [ ] Themes and personalization
+- [ ] Customizable output formats
 
-## Notes
+## Notes Management
+
+### Basic Operations
 
 - [x] `create|new` - Creates a new markdown note and optionally opens in configured editor
-    - Creates a note from existing markdown file content
 - [x] `list` - Opens interactive TUI browser for navigating and viewing notes
 - [x] `read|view` - Displays formatted note content with syntax highlighting
-- [x] `edit|update` - Opens configured editor OR Replaces note content with new markdown file
+- [x] `edit|update` - Opens configured editor OR replaces note content with new markdown file
 - [x] `remove|rm|delete|del` - Permanently removes the note file and metadata
 
+### Advanced Notes Features
+
 - [ ] `search` - Search notes by content, title, or tags
 - [ ] `tag` - Add/remove tags from notes
 - [ ] `recent` - Show recently created/modified notes
 - [ ] `templates` - Create notes from predefined templates
 - [ ] `archive` - Archive old notes
 - [ ] `export` - Export notes to various formats
+- [ ] Full-text search integration
+- [ ] Linking between notes and tasks/content
+
+## User Experience
+
+### Interface
+
+- [ ] Interactive TUI mode for browsing (likely using Bubbletea)
+- [ ] Quick-add commands for rapid entry
+- [ ] Progress tracking UI
+- [ ] Comprehensive help system
+
+### Technical Infrastructure
+
+- [ ] CI/CD pipeline -> pre-build binaries
+- [ ] Complete README/documentation
+- [ ] Installation instructions
+- [ ] Usage examples

cmd/commands.go

···
 			status, _ := cmd.Flags().GetString("status")
 			priority, _ := cmd.Flags().GetString("priority")
 			project, _ := cmd.Flags().GetString("project")
-			
+
 			return handlers.ListTasks(cmd.Context(), static, showAll, status, priority, project)
 		},
 	}
···
 		Short:   "List projects",
 		Aliases: []string{"proj"},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("Listing projects...")
-			return nil
+			return handlers.ListProjects(cmd.Context(), args)
 		},
 	})
 
···
 		Short:   "List tags",
 		Aliases: []string{"t"},
 		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("Listing tags...")
-			return nil
+			return handlers.ListTags(cmd.Context(), args)
 		},
 	})
 

go.mod

···
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/text v0.24.0 // indirect
+	golang.org/x/text v0.24.0
 )

internal/handlers/tasks.go

···
 		return fmt.Errorf("task ID required")
 	}
 
-	// Parse task ID (could be numeric ID or UUID)
 	taskID := args[0]
 	var task *models.Task
 	var err error
 
-	if id, parseErr := strconv.ParseInt(taskID, 10, 64); parseErr == nil {
-		// Numeric ID
+	if id, err_ := strconv.ParseInt(taskID, 10, 64); err_ == nil {
 		task, err = h.repos.Tasks.Get(ctx, id)
 	} else {
-		// Assume UUID
 		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
 	}
 
···
 		return fmt.Errorf("failed to find task: %w", err)
 	}
 
-	// Parse update arguments
 	for i := 1; i < len(args); i++ {
 		arg := args[i]
 		switch {
···
 	return nil
 }
 
+// ListProjects lists all projects with their task counts
+func ListProjects(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.listProjects(ctx)
+}
+
+func (h *TaskHandler) listProjects(ctx context.Context) error {
+	projectList := ui.NewProjectList(h.repos.Tasks, ui.ProjectListOptions{})
+	return projectList.Browse(ctx)
+}
+
+// ListTags lists all tags with their task counts
+func ListTags(ctx context.Context, args []string) error {
+	handler, err := NewTaskHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize task handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.listTags(ctx)
+}
+
+func (h *TaskHandler) listTags(ctx context.Context) error {
+	tagList := ui.NewTagList(h.repos.Tasks, ui.TagListOptions{})
+	return tagList.Browse(ctx)
+}
+
 func (h *TaskHandler) printTask(task *models.Task) {
 	fmt.Printf("[%d] %s", task.ID, task.Description)
 
···
 	}
 	return result
 }
+
+func pluralize(count int) string {
+	if count == 1 {
+		return ""
+	}
+	return "s"
+}

internal/handlers/tasks_test.go

···
 	})
 
 	t.Run("Helper", func(t *testing.T) {
-
 		t.Run("removeString function", func(t *testing.T) {
 			slice := []string{"a", "b", "c", "b"}
 			result := removeString(slice, "b")
···
 			}()
 
 			handler.printTaskDetail(task)
+		})
+	})
+
+	t.Run("ListProjects", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		tasks := []*models.Task{
+			{UUID: uuid.New().String(), Description: "Task 1", Status: "pending", Project: "web-app"},
+			{UUID: uuid.New().String(), Description: "Task 2", Status: "completed", Project: "web-app"},
+			{UUID: uuid.New().String(), Description: "Task 3", Status: "pending", Project: "mobile-app"},
+			{UUID: uuid.New().String(), Description: "Task 4", Status: "pending", Project: ""},
+		}
+
+		for _, task := range tasks {
+			_, err := handler.repos.Tasks.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
+		}
+
+		t.Run("lists projects successfully", func(t *testing.T) {
+			err := ListProjects(ctx, []string{})
+			if err != nil {
+				t.Errorf("ListProjects failed: %v", err)
+			}
+		})
+
+		t.Run("returns no projects when none exist", func(t *testing.T) {
+			_, cleanup2 := setupTaskTest(t)
+			defer cleanup2()
+
+			err := ListProjects(ctx, []string{})
+			if err != nil {
+				t.Errorf("ListProjects with no projects failed: %v", err)
+			}
+		})
+	})
+
+	t.Run("ListTags", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		tasks := []*models.Task{
+			{UUID: uuid.New().String(), Description: "Task 1", Status: "pending", Tags: []string{"frontend", "urgent"}},
+			{UUID: uuid.New().String(), Description: "Task 2", Status: "completed", Tags: []string{"backend", "database"}},
+			{UUID: uuid.New().String(), Description: "Task 3", Status: "pending", Tags: []string{"frontend", "ios"}},
+			{UUID: uuid.New().String(), Description: "Task 4", Status: "pending", Tags: []string{}},
+		}
+
+		for _, task := range tasks {
+			_, err := handler.repos.Tasks.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
+		}
+
+		t.Run("lists tags successfully", func(t *testing.T) {
+			err := ListTags(ctx, []string{})
+			if err != nil {
+				t.Errorf("ListTags failed: %v", err)
+			}
+		})
+
+		t.Run("returns no tags when none exist", func(t *testing.T) {
+			_, cleanup2 := setupTaskTest(t)
+			defer cleanup2()
+
+			err := ListTags(ctx, []string{})
+			if err != nil {
+				t.Errorf("ListTags with no tags failed: %v", err)
+			}
+		})
+	})
+
+	t.Run("Pluralize", func(t *testing.T) {
+		t.Run("returns empty string for singular", func(t *testing.T) {
+			result := pluralize(1)
+			if result != "" {
+				t.Errorf("Expected empty string for 1, got '%s'", result)
+			}
+		})
+
+		t.Run("returns 's' for plural", func(t *testing.T) {
+			result := pluralize(0)
+			if result != "s" {
+				t.Errorf("Expected 's' for 0, got '%s'", result)
+			}
+
+			result = pluralize(2)
+			if result != "s" {
+				t.Errorf("Expected 's' for 2, got '%s'", result)
+			}
+
+			result = pluralize(10)
+			if result != "s" {
+				t.Errorf("Expected 's' for 10, got '%s'", result)
+			}
 		})
 	})
 }

internal/repo/task_repository.go

···
 	"github.com/stormlightlabs/noteleaf/internal/models"
 )
 
+// TaskListOptions defines options for listing tasks
+type TaskListOptions struct {
+	Status    string
+	Priority  string
+	Project   string
+	DueAfter  time.Time
+	DueBefore time.Time
+	Search    string
+	SortBy    string
+	SortOrder string
+	Limit     int
+	Offset    int
+}
+
+// ProjectSummary represents a project with its task count
+type ProjectSummary struct {
+	Name      string `json:"name"`
+	TaskCount int    `json:"task_count"`
+}
+
+// TagSummary represents a tag with its task count
+type TagSummary struct {
+	Name      string `json:"name"`
+	TaskCount int    `json:"task_count"`
+}
+
 // TaskRepository provides database operations for tasks
 type TaskRepository struct {
 	db *sql.DB
···
 		args = append(args, opts.DueBefore)
 	}
 
-	// Search args
 	if opts.Search != "" {
 		searchPattern := "%" + opts.Search + "%"
-		// Add search pattern for each search field
 		args = append(args, searchPattern, searchPattern, searchPattern)
 	}
 
···
 func (r *TaskRepository) scanTaskRow(rows *sql.Rows, task *models.Task) error {
 	var tags, annotations sql.NullString
 
-	err := rows.Scan(&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority,
-		&task.Project, &tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations)
-	if err != nil {
+	if err := rows.Scan(&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority,
+		&task.Project, &tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations); err != nil {
 		return fmt.Errorf("failed to scan task row: %w", err)
 	}
 
···
 	task := &models.Task{}
 	var tags, annotations sql.NullString
 
-	err := r.db.QueryRowContext(ctx, query, uuid).Scan(
+	if err := r.db.QueryRowContext(ctx, query, uuid).Scan(
 		&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority, &task.Project,
-		&tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations)
-	if err != nil {
+		&tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations); err != nil {
 		return nil, fmt.Errorf("failed to get task by UUID: %w", err)
 	}
 
···
 	return r.List(ctx, TaskListOptions{Project: project})
 }
 
-// TaskListOptions defines options for listing tasks
-type TaskListOptions struct {
-	Status    string
-	Priority  string
-	Project   string
-	DueAfter  time.Time
-	DueBefore time.Time
-	Search    string
-	SortBy    string
-	SortOrder string
-	Limit     int
-	Offset    int
+// GetProjects retrieves all unique project names with their task counts
+func (r *TaskRepository) GetProjects(ctx context.Context) ([]ProjectSummary, error) {
+	query := `
+		SELECT project, COUNT(*) as task_count
+		FROM tasks
+		WHERE project != '' AND project IS NOT NULL
+		GROUP BY project
+		ORDER BY project`
+
+	rows, err := r.db.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get projects: %w", err)
+	}
+	defer rows.Close()
+
+	var projects []ProjectSummary
+	for rows.Next() {
+		var project ProjectSummary
+		if err := rows.Scan(&project.Name, &project.TaskCount); err != nil {
+			return nil, fmt.Errorf("failed to scan project row: %w", err)
+		}
+		projects = append(projects, project)
+	}
+
+	return projects, rows.Err()
+}
+
+// GetTags retrieves all unique tags with their task counts
+func (r *TaskRepository) GetTags(ctx context.Context) ([]TagSummary, error) {
+	query := `
+		SELECT DISTINCT json_each.value as tag, COUNT(tasks.id) as task_count
+		FROM tasks, json_each(tasks.tags)
+		WHERE tasks.tags != '' AND tasks.tags IS NOT NULL
+		GROUP BY tag
+		ORDER BY tag`
+
+	rows, err := r.db.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get tags: %w", err)
+	}
+	defer rows.Close()
+
+	var tags []TagSummary
+	for rows.Next() {
+		var tag TagSummary
+		if err := rows.Scan(&tag.Name, &tag.TaskCount); err != nil {
+			return nil, fmt.Errorf("failed to scan tag row: %w", err)
+		}
+		tags = append(tags, tag)
+	}
+
+	return tags, rows.Err()
+}
+
+// GetTasksByTag retrieves all tasks with a specific tag
+func (r *TaskRepository) GetTasksByTag(ctx context.Context, tag string) ([]*models.Task, error) {
+	query := `
+		SELECT tasks.id, tasks.uuid, tasks.description, tasks.status, tasks.priority, tasks.project, tasks.tags, tasks.due, tasks.entry, tasks.modified, tasks.end, tasks.start, tasks.annotations
+		FROM tasks, json_each(tasks.tags)
+		WHERE tasks.tags != '' AND tasks.tags IS NOT NULL AND json_each.value = ?
+		ORDER BY tasks.modified DESC`
+
+	rows, err := r.db.QueryContext(ctx, query, tag)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get tasks by tag: %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()
 }

internal/repo/task_repository_test.go

···
 import (
 	"context"
 	"database/sql"
+	"slices"
 	"testing"
 	"time"
 
···
 
 func createSampleTask() *models.Task {
 	return &models.Task{
-		UUID:        uuid.New().String(),
+		UUID:        newUUID(),
 		Description: "Test task",
 		Status:      "pending",
 		Priority:    "H",
···
 	}
 }
 
-func TestTaskRepository_CRUD(t *testing.T) {
+func newUUID() string {
+	return uuid.New().String()
+}
+
+func TestTaskRepository(t *testing.T) {
 	db := createTaskTestDB(t)
 	repo := NewTaskRepository(db)
 	ctx := context.Background()
···
 			t.Error("Expected error when getting deleted task")
 		}
 	})
-}
 
-func TestTaskRepository_List(t *testing.T) {
-	db := createTaskTestDB(t)
-	repo := NewTaskRepository(db)
-	ctx := context.Background()
-
-	tasks := []*models.Task{
-		{UUID: uuid.New().String(), Description: "Task 1", Status: "pending", Project: "proj1"},
-		{UUID: uuid.New().String(), Description: "Task 2", Status: "completed", Project: "proj1"},
-		{UUID: uuid.New().String(), Description: "Task 3", Status: "pending", Project: "proj2"},
-	}
-
-	for _, task := range tasks {
-		_, err := repo.Create(ctx, task)
-		if err != nil {
-			t.Fatalf("Failed to create task: %v", err)
+	t.Run("List", func(t *testing.T) {
+		tasks := []*models.Task{
+			{UUID: newUUID(), Description: "Task 1", Status: "pending", Project: "proj1"},
+			{UUID: newUUID(), Description: "Task 2", Status: "completed", Project: "proj1"},
+			{UUID: newUUID(), Description: "Task 3", Status: "pending", Project: "proj2"},
 		}
-	}
 
-	t.Run("List All Tasks", func(t *testing.T) {
-		results, err := repo.List(ctx, TaskListOptions{})
-		if err != nil {
-			t.Errorf("Failed to list tasks: %v", err)
+		for _, task := range tasks {
+			_, err := repo.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
 		}
 
-		if len(results) != 3 {
-			t.Errorf("Expected 3 tasks, got %d", len(results))
-		}
-	})
+		t.Run("List All Tasks", func(t *testing.T) {
+			results, err := repo.List(ctx, TaskListOptions{})
+			if err != nil {
+				t.Errorf("Failed to list tasks: %v", err)
+			}
 
-	t.Run("List Tasks with Filter", func(t *testing.T) {
-		results, err := repo.List(ctx, TaskListOptions{Status: "pending"})
-		if err != nil {
-			t.Errorf("Failed to list tasks: %v", err)
-		}
+			if len(results) < 3 {
+				t.Errorf("Expected at least 3 tasks, got %d", len(results))
+			}
+		})
+
+		t.Run("List Tasks with Filter", func(t *testing.T) {
+			results, err := repo.List(ctx, TaskListOptions{Status: "pending"})
+			if err != nil {
+				t.Errorf("Failed to list tasks: %v", err)
+			}
+
+			if len(results) < 2 {
+				t.Errorf("Expected at least 2 pending tasks, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Status != "pending" {
+					t.Errorf("Expected pending status, got %s", task.Status)
+				}
+			}
+		})
+
+		t.Run("List Tasks with Limit", func(t *testing.T) {
+			results, err := repo.List(ctx, TaskListOptions{Limit: 2})
+			if err != nil {
+				t.Errorf("Failed to list tasks: %v", err)
+			}
 
-		if len(results) != 2 {
-			t.Errorf("Expected 2 pending tasks, got %d", len(results))
-		}
+			if len(results) != 2 {
+				t.Errorf("Expected 2 tasks due to limit, got %d", len(results))
+			}
+		})
 
-		for _, task := range results {
-			if task.Status != "pending" {
-				t.Errorf("Expected pending status, got %s", task.Status)
+		t.Run("List Tasks with Search", func(t *testing.T) {
+			results, err := repo.List(ctx, TaskListOptions{Search: "Task 1"})
+			if err != nil {
+				t.Errorf("Failed to list tasks: %v", err)
 			}
-		}
+
+			if len(results) != 1 {
+				t.Errorf("Expected 1 task matching search, got %d", len(results))
+			}
+
+			if len(results) > 0 && results[0].Description != "Task 1" {
+				t.Errorf("Expected 'Task 1', got %s", results[0].Description)
+			}
+		})
 	})
 
-	t.Run("List Tasks with Limit", func(t *testing.T) {
-		results, err := repo.List(ctx, TaskListOptions{Limit: 2})
-		if err != nil {
-			t.Errorf("Failed to list tasks: %v", err)
+	t.Run("Special Methods", func(t *testing.T) {
+		task1 := &models.Task{UUID: newUUID(), Description: "Pending task", Status: "pending", Project: "test"}
+		task2 := &models.Task{UUID: newUUID(), Description: "Completed task", Status: "completed", Project: "test"}
+		task3 := &models.Task{UUID: newUUID(), Description: "Other project", Status: "pending", Project: "other"}
+
+		for _, task := range []*models.Task{task1, task2, task3} {
+			_, err := repo.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
 		}
 
-		if len(results) != 2 {
-			t.Errorf("Expected 2 tasks due to limit, got %d", len(results))
-		}
+		t.Run("GetPending", func(t *testing.T) {
+			results, err := repo.GetPending(ctx)
+			if err != nil {
+				t.Errorf("Failed to get pending tasks: %v", err)
+			}
+
+			if len(results) < 2 {
+				t.Errorf("Expected at least 2 pending tasks, got %d", len(results))
+			}
+		})
+
+		t.Run("GetCompleted", func(t *testing.T) {
+			results, err := repo.GetCompleted(ctx)
+			if err != nil {
+				t.Errorf("Failed to get completed tasks: %v", err)
+			}
+
+			if len(results) < 1 {
+				t.Errorf("Expected at least 1 completed task, got %d", len(results))
+			}
+		})
+
+		t.Run("GetByProject", func(t *testing.T) {
+			results, err := repo.GetByProject(ctx, "test")
+			if err != nil {
+				t.Errorf("Failed to get tasks by project: %v", err)
+			}
+
+			if len(results) < 2 {
+				t.Errorf("Expected at least 2 tasks in test project, got %d", len(results))
+			}
+
+			for _, task := range results {
+				if task.Project != "test" {
+					t.Errorf("Expected project 'test', got %s", task.Project)
+				}
+			}
+		})
+
+		t.Run("GetByUUID", func(t *testing.T) {
+			result, err := repo.GetByUUID(ctx, task1.UUID)
+			if err != nil {
+				t.Errorf("Failed to get task by UUID: %v", err)
+			}
+
+			if result.UUID != task1.UUID {
+				t.Errorf("Expected UUID %s, got %s", task1.UUID, result.UUID)
+			}
+			if result.Description != task1.Description {
+				t.Errorf("Expected description %s, got %s", task1.Description, result.Description)
+			}
+		})
 	})
 
-	t.Run("List Tasks with Search", func(t *testing.T) {
-		results, err := repo.List(ctx, TaskListOptions{Search: "Task 1"})
-		if err != nil {
-			t.Errorf("Failed to list tasks: %v", err)
+	t.Run("Count", func(t *testing.T) {
+		tasks := []*models.Task{
+			{UUID: newUUID(), Description: "Test 1", Status: "pending"},
+			{UUID: newUUID(), Description: "Test 2", Status: "pending"},
+			{UUID: newUUID(), Description: "Test 3", Status: "completed"},
 		}
 
-		if len(results) != 1 {
-			t.Errorf("Expected 1 task matching search, got %d", len(results))
+		for _, task := range tasks {
+			_, err := repo.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
 		}
 
-		if len(results) > 0 && results[0].Description != "Task 1" {
-			t.Errorf("Expected 'Task 1', got %s", results[0].Description)
-		}
-	})
-}
+		t.Run("Count all tasks", func(t *testing.T) {
+			count, err := repo.Count(ctx, TaskListOptions{})
+			if err != nil {
+				t.Errorf("Failed to count tasks: %v", err)
+			}
 
-func TestTaskRepository_SpecialMethods(t *testing.T) {
-	db := createTaskTestDB(t)
-	repo := NewTaskRepository(db)
-	ctx := context.Background()
+			if count < 3 {
+				t.Errorf("Expected at least 3 tasks, got %d", count)
+			}
+		})
 
-	task1 := &models.Task{UUID: uuid.New().String(), Description: "Pending task", Status: "pending", Project: "test"}
-	task2 := &models.Task{UUID: uuid.New().String(), Description: "Completed task", Status: "completed", Project: "test"}
-	task3 := &models.Task{UUID: uuid.New().String(), Description: "Other project", Status: "pending", Project: "other"}
+		t.Run("Count pending tasks", func(t *testing.T) {
+			count, err := repo.Count(ctx, TaskListOptions{Status: "pending"})
+			if err != nil {
+				t.Errorf("Failed to count pending tasks: %v", err)
+			}
 
-	for _, task := range []*models.Task{task1, task2, task3} {
-		_, err := repo.Create(ctx, task)
-		if err != nil {
-			t.Fatalf("Failed to create task: %v", err)
-		}
-	}
+			if count < 2 {
+				t.Errorf("Expected at least 2 pending tasks, got %d", count)
+			}
+		})
 
-	t.Run("GetPending", func(t *testing.T) {
-		results, err := repo.GetPending(ctx)
-		if err != nil {
-			t.Errorf("Failed to get pending tasks: %v", err)
-		}
+		t.Run("Count completed tasks", func(t *testing.T) {
+			count, err := repo.Count(ctx, TaskListOptions{Status: "completed"})
+			if err != nil {
+				t.Errorf("Failed to count completed tasks: %v", err)
+			}
 
-		if len(results) != 2 {
-			t.Errorf("Expected 2 pending tasks, got %d", len(results))
-		}
+			if count < 1 {
+				t.Errorf("Expected at least 1 completed task, got %d", count)
+			}
+		})
 	})
 
-	t.Run("GetCompleted", func(t *testing.T) {
-		results, err := repo.GetCompleted(ctx)
-		if err != nil {
-			t.Errorf("Failed to get completed tasks: %v", err)
+	t.Run("Projects & Tags", func(t *testing.T) {
+		tasks := []*models.Task{
+			{UUID: newUUID(), Description: "Task 1", Status: "pending", Project: "web-app", Tags: []string{"frontend", "urgent"}},
+			{UUID: newUUID(), Description: "Task 2", Status: "pending", Project: "web-app", Tags: []string{"backend", "database"}},
+			{UUID: newUUID(), Description: "Task 3", Status: "completed", Project: "mobile-app", Tags: []string{"frontend", "ios"}},
+			{UUID: newUUID(), Description: "Task 4", Status: "pending", Project: "mobile-app", Tags: []string{"android", "urgent"}},
+			{UUID: newUUID(), Description: "Task 5", Status: "pending", Project: "", Tags: []string{"documentation"}},
 		}
 
-		if len(results) != 1 {
-			t.Errorf("Expected 1 completed task, got %d", len(results))
+		for _, task := range tasks {
+			_, err := repo.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
 		}
-	})
 
-	t.Run("GetByProject", func(t *testing.T) {
-		results, err := repo.GetByProject(ctx, "test")
-		if err != nil {
-			t.Errorf("Failed to get tasks by project: %v", err)
-		}
+		t.Run("GetProjects", func(t *testing.T) {
+			projects, err := repo.GetProjects(ctx)
+			if err != nil {
+				t.Errorf("Failed to get projects: %v", err)
+			}
+
+			expectedProjectCount := 0
+			projectCounts := make(map[string]int)
+
+			for _, project := range projects {
+				if project.Name != "" {
+					expectedProjectCount++
+					projectCounts[project.Name] = project.TaskCount
+				}
+			}
+
+			if expectedProjectCount < 2 {
+				t.Errorf("Expected at least 2 projects, got %d", expectedProjectCount)
+			}
+
+			if count, exists := projectCounts["web-app"]; exists {
+				if count < 2 {
+					t.Errorf("Expected at least 2 tasks for web-app project, got %d", count)
+				}
+			} else {
+				t.Error("Expected web-app project to exist")
+			}
 
-		if len(results) != 2 {
-			t.Errorf("Expected 2 tasks in test project, got %d", len(results))
-		}
+			if count, exists := projectCounts["mobile-app"]; exists {
+				if count < 2 {
+					t.Errorf("Expected at least 2 tasks for mobile-app project, got %d", count)
+				}
+			} else {
+				t.Error("Expected mobile-app project to exist")
+			}
+		})
 
-		for _, task := range results {
-			if task.Project != "test" {
-				t.Errorf("Expected project 'test', got %s", task.Project)
+		t.Run("GetTags", func(t *testing.T) {
+			tags, err := repo.GetTags(ctx)
+			if err != nil {
+				t.Errorf("Failed to get tags: %v", err)
+			}
+
+			tagCounts := make(map[string]int)
+			for _, tag := range tags {
+				tagCounts[tag.Name] = tag.TaskCount
 			}
-		}
-	})
 
-	t.Run("GetByUUID", func(t *testing.T) {
-		result, err := repo.GetByUUID(ctx, task1.UUID)
-		if err != nil {
-			t.Errorf("Failed to get task by UUID: %v", err)
-		}
+			expectedMinCounts := map[string]int{
+				"android": 1, "backend": 1, "database": 1, "documentation": 1,
+				"frontend": 2, "ios": 1, "urgent": 2,
+			}
 
-		if result.UUID != task1.UUID {
-			t.Errorf("Expected UUID %s, got %s", task1.UUID, result.UUID)
-		}
-		if result.Description != task1.Description {
-			t.Errorf("Expected description %s, got %s", task1.Description, result.Description)
-		}
-	})
-}
+			for expectedTag, minCount := range expectedMinCounts {
+				if count, exists := tagCounts[expectedTag]; exists {
+					if count < minCount {
+						t.Errorf("Expected at least %d tasks for tag %s, got %d", minCount, expectedTag, count)
+					}
+				} else {
+					t.Errorf("Expected tag %s to exist", expectedTag)
+				}
+			}
 
-func TestTaskRepository_Count(t *testing.T) {
-	db := createTaskTestDB(t)
-	repo := NewTaskRepository(db)
-	ctx := context.Background()
+			if len(tags) < len(expectedMinCounts) {
+				t.Errorf("Expected at least %d tags, got %d", len(expectedMinCounts), len(tags))
+			}
+		})
 
-	tasks := []*models.Task{
-		{UUID: uuid.New().String(), Description: "Test 1", Status: "pending"},
-		{UUID: uuid.New().String(), Description: "Test 2", Status: "pending"},
-		{UUID: uuid.New().String(), Description: "Test 3", Status: "completed"},
-	}
+		t.Run("GetTasksByTag", func(t *testing.T) {
+			frontend, err := repo.GetTasksByTag(ctx, "frontend")
+			if err != nil {
+				t.Errorf("Failed to get tasks by tag: %v", err)
+			}
 
-	for _, task := range tasks {
-		_, err := repo.Create(ctx, task)
-		if err != nil {
-			t.Fatalf("Failed to create task: %v", err)
-		}
-	}
+			if len(frontend) < 2 {
+				t.Errorf("Expected at least 2 tasks with frontend tag, got %d", len(frontend))
+			}
 
-	t.Run("Count all tasks", func(t *testing.T) {
-		count, err := repo.Count(ctx, TaskListOptions{})
-		if err != nil {
-			t.Errorf("Failed to count tasks: %v", err)
-		}
+			for _, task := range frontend {
+				if !slices.Contains(task.Tags, "frontend") {
+					t.Errorf("Task %s should have frontend tag", task.Description)
+				}
+			}
 
-		if count != 3 {
-			t.Errorf("Expected 3 tasks, got %d", count)
-		}
-	})
+			urgent, err := repo.GetTasksByTag(ctx, "urgent")
+			if err != nil {
+				t.Errorf("Failed to get tasks by tag: %v", err)
+			}
 
-	t.Run("Count pending tasks", func(t *testing.T) {
-		count, err := repo.Count(ctx, TaskListOptions{Status: "pending"})
-		if err != nil {
-			t.Errorf("Failed to count pending tasks: %v", err)
-		}
+			if len(urgent) < 2 {
+				t.Errorf("Expected at least 2 tasks with urgent tag, got %d", len(urgent))
+			}
 
-		if count != 2 {
-			t.Errorf("Expected 2 pending tasks, got %d", count)
-		}
-	})
+			for _, task := range urgent {
+				if !slices.Contains(task.Tags, "urgent") {
+					t.Errorf("Task %s should have urgent tag", task.Description)
+				}
+			}
 
-	t.Run("Count completed tasks", func(t *testing.T) {
-		count, err := repo.Count(ctx, TaskListOptions{Status: "completed"})
-		if err != nil {
-			t.Errorf("Failed to count completed tasks: %v", err)
-		}
+			nonexistent, err := repo.GetTasksByTag(ctx, "nonexistent")
+			if err != nil {
+				t.Errorf("Failed to get tasks by nonexistent tag: %v", err)
+			}
 
-		if count != 1 {
-			t.Errorf("Expected 1 completed task, got %d", count)
-		}
+			if len(nonexistent) != 0 {
+				t.Errorf("Expected 0 tasks with nonexistent tag, got %d", len(nonexistent))
+			}
+		})
 	})
 }

internal/ui/project_list.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// Project list key bindings
+type projectKeyMap struct {
+	Up      key.Binding
+	Down    key.Binding
+	Enter   key.Binding
+	Refresh key.Binding
+	Quit    key.Binding
+	Back    key.Binding
+	Help    key.Binding
+	Numbers []key.Binding
+}
+
+func (k projectKeyMap) ShortHelp() []key.Binding {
+	return []key.Binding{k.Up, k.Down, k.Enter, k.Help, k.Quit}
+}
+
+func (k projectKeyMap) FullHelp() [][]key.Binding {
+	return [][]key.Binding{
+		{k.Up, k.Down, k.Enter, k.Refresh},
+		{k.Help, k.Quit, k.Back},
+	}
+}
+
+var projectKeys = projectKeyMap{
+	Up:      key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
+	Down:    key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
+	Enter:   key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select project")),
+	Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
+	Quit:    key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
+	Back:    key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
+	Help:    key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
+	Numbers: []key.Binding{
+		key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "jump to project 1")),
+		key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "jump to project 2")),
+		key.NewBinding(key.WithKeys("3"), key.WithHelp("3", "jump to project 3")),
+		key.NewBinding(key.WithKeys("4"), key.WithHelp("4", "jump to project 4")),
+		key.NewBinding(key.WithKeys("5"), key.WithHelp("5", "jump to project 5")),
+		key.NewBinding(key.WithKeys("6"), key.WithHelp("6", "jump to project 6")),
+		key.NewBinding(key.WithKeys("7"), key.WithHelp("7", "jump to project 7")),
+		key.NewBinding(key.WithKeys("8"), key.WithHelp("8", "jump to project 8")),
+		key.NewBinding(key.WithKeys("9"), key.WithHelp("9", "jump to project 9")),
+	},
+}
+
+// ProjectRepository interface for dependency injection in tests
+type ProjectRepository interface {
+	GetProjects(ctx context.Context) ([]repo.ProjectSummary, error)
+}
+
+// ProjectListOptions configures the project list UI behavior
+type ProjectListOptions struct {
+	// Output destination (stdout for interactive, buffer for testing)
+	Output io.Writer
+	// Input source (stdin for interactive, strings reader for testing)
+	Input io.Reader
+	// Enable static mode (no interactive components)
+	Static bool
+}
+
+// ProjectList handles project browsing UI
+type ProjectList struct {
+	repo ProjectRepository
+	opts ProjectListOptions
+}
+
+// NewProjectList creates a new project list UI component
+func NewProjectList(repo ProjectRepository, opts ProjectListOptions) *ProjectList {
+	if opts.Output == nil {
+		opts.Output = os.Stdout
+	}
+	if opts.Input == nil {
+		opts.Input = os.Stdin
+	}
+	return &ProjectList{repo: repo, opts: opts}
+}
+
+type (
+	projectsLoadedMsg []repo.ProjectSummary
+	errorProjectMsg   error
+	projectListModel  struct {
+		projects    []repo.ProjectSummary
+		selected    int
+		err         error
+		repo        ProjectRepository
+		opts        ProjectListOptions
+		keys        projectKeyMap
+		help        help.Model
+		showingHelp bool
+	}
+)
+
+func (m projectListModel) Init() tea.Cmd {
+	return m.loadProjects()
+}
+
+func (m projectListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if m.showingHelp {
+			switch {
+			case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
+				m.showingHelp = false
+				return m, nil
+			}
+			return m, nil
+		}
+
+		switch {
+		case key.Matches(msg, m.keys.Quit):
+			return m, tea.Quit
+		case key.Matches(msg, m.keys.Up):
+			if m.selected > 0 {
+				m.selected--
+			}
+		case key.Matches(msg, m.keys.Down):
+			if m.selected < len(m.projects)-1 {
+				m.selected++
+			}
+		case key.Matches(msg, m.keys.Enter):
+			if len(m.projects) > 0 && m.selected < len(m.projects) {
+				// TODO: navigate to tasks for that project
+				return m, tea.Quit
+			}
+		case key.Matches(msg, m.keys.Refresh):
+			return m, m.loadProjects()
+		case key.Matches(msg, m.keys.Help):
+			m.showingHelp = true
+			return m, nil
+		default:
+			for i, numKey := range m.keys.Numbers {
+				if key.Matches(msg, numKey) && i < len(m.projects) {
+					m.selected = i
+					break
+				}
+			}
+		}
+	case projectsLoadedMsg:
+		m.projects = []repo.ProjectSummary(msg)
+		if m.selected >= len(m.projects) && len(m.projects) > 0 {
+			m.selected = len(m.projects) - 1
+		}
+	case errorProjectMsg:
+		m.err = error(msg)
+	}
+	return m, nil
+}
+
+func (m projectListModel) View() string {
+	var s strings.Builder
+
+	style := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex()))
+
+	if m.showingHelp {
+		return m.help.View(m.keys)
+	}
+
+	s.WriteString(TitleColorStyle.Render("Projects"))
+	s.WriteString("\n\n")
+
+	if m.err != nil {
+		s.WriteString(fmt.Sprintf("Error: %s", m.err))
+		return s.String()
+	}
+
+	if len(m.projects) == 0 {
+		s.WriteString("No projects found")
+		s.WriteString("\n\n")
+		s.WriteString(style.Render("Press r to refresh, q to quit"))
+		return s.String()
+	}
+
+	headerLine := fmt.Sprintf("   %-30s %-15s", "Project Name", "Task Count")
+	s.WriteString(HeaderColorStyle.Render(headerLine))
+	s.WriteString("\n")
+	s.WriteString(HeaderColorStyle.Render(strings.Repeat("─", 50)))
+	s.WriteString("\n")
+
+	for i, project := range m.projects {
+		prefix := "   "
+		if i == m.selected {
+			prefix = " > "
+		}
+
+		projectName := project.Name
+		if len(projectName) > 28 {
+			projectName = projectName[:25] + "..."
+		}
+
+		taskCountStr := fmt.Sprintf("%d task%s", project.TaskCount, pluralizeCount(project.TaskCount))
+
+		line := fmt.Sprintf("%s%-30s %-15s", prefix, projectName, taskCountStr)
+
+		if i == m.selected {
+			s.WriteString(SelectedColorStyle.Render(line))
+		} else {
+			s.WriteString(style.Render(line))
+		}
+
+		s.WriteString("\n")
+	}
+
+	s.WriteString("\n")
+	s.WriteString(m.help.View(m.keys))
+
+	return s.String()
+}
+
+func (m projectListModel) loadProjects() tea.Cmd {
+	return func() tea.Msg {
+		projects, err := m.repo.GetProjects(context.Background())
+		if err != nil {
+			return errorProjectMsg(err)
+		}
+
+		return projectsLoadedMsg(projects)
+	}
+}
+
+// Browse opens an interactive TUI for navigating projects
+func (pl *ProjectList) Browse(ctx context.Context) error {
+	if pl.opts.Static {
+		return pl.staticList(ctx)
+	}
+
+	model := projectListModel{
+		repo: pl.repo,
+		opts: pl.opts,
+		keys: projectKeys,
+		help: help.New(),
+	}
+
+	program := tea.NewProgram(model, tea.WithInput(pl.opts.Input), tea.WithOutput(pl.opts.Output))
+
+	_, err := program.Run()
+	return err
+}
+
+func (pl *ProjectList) staticList(ctx context.Context) error {
+	projects, err := pl.repo.GetProjects(ctx)
+	if err != nil {
+		fmt.Fprintf(pl.opts.Output, "Error: %s\n", err)
+		return err
+	}
+
+	fmt.Fprintf(pl.opts.Output, "Projects\n\n")
+
+	if len(projects) == 0 {
+		fmt.Fprintf(pl.opts.Output, "No projects found\n")
+		return nil
+	}
+
+	fmt.Fprintf(pl.opts.Output, "%-30s %-15s\n", "Project Name", "Task Count")
+	fmt.Fprintf(pl.opts.Output, "%s\n", strings.Repeat("─", 50))
+
+	for _, project := range projects {
+		projectName := project.Name
+		if len(projectName) > 28 {
+			projectName = projectName[:25] + "..."
+		}
+
+		taskCountStr := fmt.Sprintf("%d task%s", project.TaskCount, pluralizeCount(project.TaskCount))
+
+		fmt.Fprintf(pl.opts.Output, "%-30s %-15s\n", projectName, taskCountStr)
+	}
+
+	return nil
+}
+
+func pluralizeCount(count int) string {
+	if count == 1 {
+		return ""
+	}
+	return "s"
+}

internal/ui/project_list_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// Mock project repository for testing
+type mockProjectRepository struct {
+	projects []repo.ProjectSummary
+	err      error
+}
+
+func (m *mockProjectRepository) GetProjects(ctx context.Context) ([]repo.ProjectSummary, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.projects, nil
+}
+
+func TestProjectList(t *testing.T) {
+	t.Run("NewProjectList", func(t *testing.T) {
+		t.Run("creates project list successfully", func(t *testing.T) {
+			mockRepo := &mockProjectRepository{}
+			opts := ProjectListOptions{}
+
+			projectList := NewProjectList(mockRepo, opts)
+
+			if projectList == nil {
+				t.Fatal("ProjectList should not be nil")
+			}
+			if projectList.repo != mockRepo {
+				t.Error("ProjectList repo should be set correctly")
+			}
+		})
+
+		t.Run("sets default options", func(t *testing.T) {
+			mockRepo := &mockProjectRepository{}
+			opts := ProjectListOptions{}
+
+			projectList := NewProjectList(mockRepo, opts)
+
+			if projectList.opts.Output == nil {
+				t.Error("Default output should be set")
+			}
+			if projectList.opts.Input == nil {
+				t.Error("Default input should be set")
+			}
+		})
+
+		t.Run("preserves custom options", func(t *testing.T) {
+			mockRepo := &mockProjectRepository{}
+			output := &bytes.Buffer{}
+			input := strings.NewReader("")
+			opts := ProjectListOptions{
+				Output: output,
+				Input:  input,
+				Static: true,
+			}
+
+			projectList := NewProjectList(mockRepo, opts)
+
+			if projectList.opts.Output != output {
+				t.Error("Custom output should be preserved")
+			}
+			if projectList.opts.Input != input {
+				t.Error("Custom input should be preserved")
+			}
+			if !projectList.opts.Static {
+				t.Error("Static option should be preserved")
+			}
+		})
+	})
+
+	t.Run("StaticList", func(t *testing.T) {
+		t.Run("displays projects correctly", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "web-app", TaskCount: 5},
+				{Name: "mobile-app", TaskCount: 3},
+				{Name: "documentation", TaskCount: 1},
+			}
+			mockRepo := &mockProjectRepository{projects: projects}
+			output := &bytes.Buffer{}
+			opts := ProjectListOptions{Output: output, Static: true}
+
+			projectList := NewProjectList(mockRepo, opts)
+			err := projectList.Browse(context.Background())
+
+			if err != nil {
+				t.Errorf("Browse should not return error: %v", err)
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "Projects") {
+				t.Error("Output should contain title")
+			}
+			if !strings.Contains(result, "web-app") {
+				t.Error("Output should contain web-app project")
+			}
+			if !strings.Contains(result, "mobile-app") {
+				t.Error("Output should contain mobile-app project")
+			}
+			if !strings.Contains(result, "5 tasks") {
+				t.Error("Output should show correct task count for web-app")
+			}
+			if !strings.Contains(result, "1 task") {
+				t.Error("Output should show singular task for documentation")
+			}
+		})
+
+		t.Run("handles empty project list", func(t *testing.T) {
+			mockRepo := &mockProjectRepository{projects: []repo.ProjectSummary{}}
+			output := &bytes.Buffer{}
+			opts := ProjectListOptions{Output: output, Static: true}
+
+			projectList := NewProjectList(mockRepo, opts)
+			err := projectList.Browse(context.Background())
+
+			if err != nil {
+				t.Errorf("Browse should not return error: %v", err)
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "No projects found") {
+				t.Error("Output should indicate no projects found")
+			}
+		})
+
+		t.Run("handles repository errors", func(t *testing.T) {
+			mockRepo := &mockProjectRepository{err: fmt.Errorf("database error")}
+			output := &bytes.Buffer{}
+			opts := ProjectListOptions{Output: output, Static: true}
+
+			projectList := NewProjectList(mockRepo, opts)
+			err := projectList.Browse(context.Background())
+
+			if err == nil {
+				t.Error("Browse should return error when repository fails")
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "Error:") {
+				t.Error("Output should contain error message")
+			}
+		})
+
+		t.Run("truncates long project names", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "this-is-a-very-long-project-name-that-should-be-truncated", TaskCount: 2},
+			}
+			mockRepo := &mockProjectRepository{projects: projects}
+			output := &bytes.Buffer{}
+			opts := ProjectListOptions{Output: output, Static: true}
+
+			projectList := NewProjectList(mockRepo, opts)
+			err := projectList.Browse(context.Background())
+
+			if err != nil {
+				t.Errorf("Browse should not return error: %v", err)
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "...") {
+				t.Error("Output should truncate long project names")
+			}
+		})
+	})
+
+	t.Run("ProjectListModel", func(t *testing.T) {
+		t.Run("initializes correctly", func(t *testing.T) {
+			model := projectListModel{
+				selected:    0,
+				showingHelp: false,
+			}
+
+			if model.selected != 0 {
+				t.Error("Initial selection should be 0")
+			}
+			if model.showingHelp {
+				t.Error("Should not be showing help initially")
+			}
+		})
+
+		t.Run("handles key navigation", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "project1", TaskCount: 1},
+				{Name: "project2", TaskCount: 2},
+				{Name: "project3", TaskCount: 3},
+			}
+
+			model := projectListModel{
+				projects: projects,
+				selected: 1,
+				keys:     projectKeys,
+			}
+
+			// Test down key
+			downMsg := tea.KeyMsg{Type: tea.KeyDown}
+			updatedModel, _ := model.Update(downMsg)
+			if updatedModel.(projectListModel).selected != 2 {
+				t.Error("Down key should move selection down")
+			}
+
+			// Test up key
+			upMsg := tea.KeyMsg{Type: tea.KeyUp}
+			updatedModel, _ = updatedModel.Update(upMsg)
+			if updatedModel.(projectListModel).selected != 1 {
+				t.Error("Up key should move selection up")
+			}
+
+			// Test boundary conditions
+			model.selected = 0
+			updatedModel, _ = model.Update(upMsg)
+			if updatedModel.(projectListModel).selected != 0 {
+				t.Error("Up key should not move selection below 0")
+			}
+
+			model.selected = len(projects) - 1
+			updatedModel, _ = model.Update(downMsg)
+			if updatedModel.(projectListModel).selected != len(projects)-1 {
+				t.Error("Down key should not move selection beyond list length")
+			}
+		})
+
+		t.Run("handles number key selection", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "project1", TaskCount: 1},
+				{Name: "project2", TaskCount: 2},
+				{Name: "project3", TaskCount: 3},
+			}
+
+			model := projectListModel{
+				projects: projects,
+				selected: 0,
+				keys:     projectKeys,
+			}
+
+			// Test number key 3 (index 2)
+			keyMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'3'}}
+			updatedModel, _ := model.Update(keyMsg)
+			if updatedModel.(projectListModel).selected != 2 {
+				t.Error("Number key 3 should select index 2")
+			}
+		})
+
+		t.Run("handles help toggle", func(t *testing.T) {
+			model := projectListModel{
+				keys: projectKeys,
+			}
+
+			// Toggle help on
+			helpMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'?'}}
+			updatedModel, _ := model.Update(helpMsg)
+			if !updatedModel.(projectListModel).showingHelp {
+				t.Error("Help key should show help")
+			}
+
+			// Toggle help off
+			updatedModel, _ = updatedModel.Update(helpMsg)
+			if updatedModel.(projectListModel).showingHelp {
+				t.Error("Help key should hide help when already showing")
+			}
+		})
+
+		t.Run("handles projects loaded message", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "new-project", TaskCount: 5},
+			}
+
+			model := projectListModel{
+				selected: 5, // Invalid selection
+			}
+
+			msg := projectsLoadedMsg(projects)
+			updatedModel, _ := model.Update(msg)
+			resultModel := updatedModel.(projectListModel)
+
+			if len(resultModel.projects) != 1 {
+				t.Error("Projects should be loaded correctly")
+			}
+			if resultModel.selected != 0 {
+				t.Error("Selection should be reset to valid range")
+			}
+		})
+
+		t.Run("handles error message", func(t *testing.T) {
+			model := projectListModel{}
+
+			errorMsg := errorProjectMsg(fmt.Errorf("test error"))
+			updatedModel, _ := model.Update(errorMsg)
+			resultModel := updatedModel.(projectListModel)
+
+			if resultModel.err == nil {
+				t.Error("Error should be set")
+			}
+			if resultModel.err.Error() != "test error" {
+				t.Errorf("Expected 'test error', got '%s'", resultModel.err.Error())
+			}
+		})
+
+		t.Run("view renders correctly", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "web-app", TaskCount: 5},
+				{Name: "mobile-app", TaskCount: 1},
+			}
+
+			model := projectListModel{
+				projects: projects,
+				selected: 0,
+				keys:     projectKeys,
+			}
+
+			view := model.View()
+			if !strings.Contains(view, "Projects") {
+				t.Error("View should contain title")
+			}
+			if !strings.Contains(view, "web-app") {
+				t.Error("View should contain project names")
+			}
+			if !strings.Contains(view, "5 tasks") {
+				t.Error("View should show task counts")
+			}
+			if !strings.Contains(view, "1 task") {
+				t.Error("View should show singular task count")
+			}
+		})
+
+		t.Run("view handles empty state", func(t *testing.T) {
+			model := projectListModel{
+				projects: []repo.ProjectSummary{},
+			}
+
+			view := model.View()
+			if !strings.Contains(view, "No projects found") {
+				t.Error("View should show empty state message")
+			}
+		})
+
+		t.Run("view handles error state", func(t *testing.T) {
+			model := projectListModel{
+				err: fmt.Errorf("test error"),
+			}
+
+			view := model.View()
+			if !strings.Contains(view, "Error:") {
+				t.Error("View should show error message")
+			}
+		})
+	})
+
+	t.Run("PluralizeCount", func(t *testing.T) {
+		t.Run("returns empty string for singular", func(t *testing.T) {
+			result := pluralizeCount(1)
+			if result != "" {
+				t.Errorf("Expected empty string for 1, got '%s'", result)
+			}
+		})
+
+		t.Run("returns 's' for plural", func(t *testing.T) {
+			testCases := []int{0, 2, 10, 100}
+			for _, count := range testCases {
+				result := pluralizeCount(count)
+				if result != "s" {
+					t.Errorf("Expected 's' for %d, got '%s'", count, result)
+				}
+			}
+		})
+	})
+}

internal/ui/tag_list.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// Tag list key bindings
+type tagKeyMap struct {
+	Up      key.Binding
+	Down    key.Binding
+	Enter   key.Binding
+	Refresh key.Binding
+	Quit    key.Binding
+	Back    key.Binding
+	Help    key.Binding
+	Numbers []key.Binding
+}
+
+func (k tagKeyMap) ShortHelp() []key.Binding {
+	return []key.Binding{k.Up, k.Down, k.Enter, k.Help, k.Quit}
+}
+
+func (k tagKeyMap) FullHelp() [][]key.Binding {
+	return [][]key.Binding{
+		{k.Up, k.Down, k.Enter, k.Refresh},
+		{k.Help, k.Quit, k.Back},
+	}
+}
+
+var tagKeys = tagKeyMap{
+	Up:      key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
+	Down:    key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
+	Enter:   key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select tag")),
+	Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
+	Quit:    key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
+	Back:    key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
+	Help:    key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
+	Numbers: []key.Binding{
+		key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "jump to tag 1")),
+		key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "jump to tag 2")),
+		key.NewBinding(key.WithKeys("3"), key.WithHelp("3", "jump to tag 3")),
+		key.NewBinding(key.WithKeys("4"), key.WithHelp("4", "jump to tag 4")),
+		key.NewBinding(key.WithKeys("5"), key.WithHelp("5", "jump to tag 5")),
+		key.NewBinding(key.WithKeys("6"), key.WithHelp("6", "jump to tag 6")),
+		key.NewBinding(key.WithKeys("7"), key.WithHelp("7", "jump to tag 7")),
+		key.NewBinding(key.WithKeys("8"), key.WithHelp("8", "jump to tag 8")),
+		key.NewBinding(key.WithKeys("9"), key.WithHelp("9", "jump to tag 9")),
+	},
+}
+
+type (
+	// TagRepository interface for dependency injection in tests
+	TagRepository interface {
+		GetTags(ctx context.Context) ([]repo.TagSummary, error)
+	}
+
+	// TagListOptions configures the tag list UI behavior
+	TagListOptions struct {
+		// Output destination (stdout for interactive, buffer for testing)
+		Output io.Writer
+		// Input source (stdin for interactive, strings reader for testing)
+		Input io.Reader
+		// Enable static mode (no interactive components)
+		Static bool
+	}
+
+	// TagList handles tag browsing UI
+	TagList struct {
+		repo TagRepository
+		opts TagListOptions
+	}
+)
+
+// NewTagList creates a new tag list UI component
+func NewTagList(repo TagRepository, opts TagListOptions) *TagList {
+	if opts.Output == nil {
+		opts.Output = os.Stdout
+	}
+	if opts.Input == nil {
+		opts.Input = os.Stdin
+	}
+	return &TagList{repo: repo, opts: opts}
+}
+
+type (
+	tagsLoadedMsg []repo.TagSummary
+	errorTagMsg   error
+	tagListModel  struct {
+		tags        []repo.TagSummary
+		selected    int
+		err         error
+		repo        TagRepository
+		opts        TagListOptions
+		keys        tagKeyMap
+		help        help.Model
+		showingHelp bool
+	}
+)
+
+func (m tagListModel) Init() tea.Cmd {
+	return m.loadTags()
+}
+
+func (m tagListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if m.showingHelp {
+			switch {
+			case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
+				m.showingHelp = false
+				return m, nil
+			}
+			return m, nil
+		}
+
+		switch {
+		case key.Matches(msg, m.keys.Quit):
+			return m, tea.Quit
+		case key.Matches(msg, m.keys.Up):
+			if m.selected > 0 {
+				m.selected--
+			}
+		case key.Matches(msg, m.keys.Down):
+			if m.selected < len(m.tags)-1 {
+				m.selected++
+			}
+		case key.Matches(msg, m.keys.Enter):
+			if len(m.tags) > 0 && m.selected < len(m.tags) {
+				// For now, just show the selected tag name
+				// In a real implementation, this might navigate to tasks with that tag
+				return m, tea.Quit
+			}
+		case key.Matches(msg, m.keys.Refresh):
+			return m, m.loadTags()
+		case key.Matches(msg, m.keys.Help):
+			m.showingHelp = true
+			return m, nil
+		default:
+			// Handle number keys for quick selection
+			for i, numKey := range m.keys.Numbers {
+				if key.Matches(msg, numKey) && i < len(m.tags) {
+					m.selected = i
+					break
+				}
+			}
+		}
+	case tagsLoadedMsg:
+		m.tags = []repo.TagSummary(msg)
+		if m.selected >= len(m.tags) && len(m.tags) > 0 {
+			m.selected = len(m.tags) - 1
+		}
+	case errorTagMsg:
+		m.err = error(msg)
+	}
+	return m, nil
+}
+
+func (m tagListModel) View() string {
+	var s strings.Builder
+
+	style := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex()))
+
+	if m.showingHelp {
+		return m.help.View(m.keys)
+	}
+
+	s.WriteString(TitleColorStyle.Render("Tags"))
+	s.WriteString("\n\n")
+
+	if m.err != nil {
+		s.WriteString(fmt.Sprintf("Error: %s", m.err))
+		return s.String()
+	}
+
+	if len(m.tags) == 0 {
+		s.WriteString("No tags found")
+		s.WriteString("\n\n")
+		s.WriteString(style.Render("Press r to refresh, q to quit"))
+		return s.String()
+	}
+
+	headerLine := fmt.Sprintf("   %-25s %-15s", "Tag Name", "Task Count")
+	s.WriteString(HeaderColorStyle.Render(headerLine))
+	s.WriteString("\n")
+	s.WriteString(HeaderColorStyle.Render(strings.Repeat("─", 45)))
+	s.WriteString("\n")
+
+	for i, tag := range m.tags {
+		prefix := "   "
+		if i == m.selected {
+			prefix = " > "
+		}
+
+		tagName := tag.Name
+		if len(tagName) > 23 {
+			tagName = tagName[:20] + "..."
+		}
+
+		taskCountStr := fmt.Sprintf("%d task%s", tag.TaskCount, pluralizeCount(tag.TaskCount))
+
+		line := fmt.Sprintf("%s%-25s %-15s", prefix, tagName, taskCountStr)
+
+		if i == m.selected {
+			s.WriteString(SelectedColorStyle.Render(line))
+		} else {
+			s.WriteString(style.Render(line))
+		}
+
+		s.WriteString("\n")
+	}
+
+	s.WriteString("\n")
+	s.WriteString(m.help.View(m.keys))
+
+	return s.String()
+}
+
+func (m tagListModel) loadTags() tea.Cmd {
+	return func() tea.Msg {
+		tags, err := m.repo.GetTags(context.Background())
+		if err != nil {
+			return errorTagMsg(err)
+		}
+
+		return tagsLoadedMsg(tags)
+	}
+}
+
+// Browse opens an interactive TUI for navigating tags
+func (tl *TagList) Browse(ctx context.Context) error {
+	if tl.opts.Static {
+		return tl.staticList(ctx)
+	}
+
+	model := tagListModel{
+		repo: tl.repo,
+		opts: tl.opts,
+		keys: tagKeys,
+		help: help.New(),
+	}
+
+	program := tea.NewProgram(model, tea.WithInput(tl.opts.Input), tea.WithOutput(tl.opts.Output))
+
+	_, err := program.Run()
+	return err
+}
+
+func (tl *TagList) staticList(ctx context.Context) error {
+	tags, err := tl.repo.GetTags(ctx)
+	if err != nil {
+		fmt.Fprintf(tl.opts.Output, "Error: %s\n", err)
+		return err
+	}
+
+	fmt.Fprintf(tl.opts.Output, "Tags\n\n")
+
+	if len(tags) == 0 {
+		fmt.Fprintf(tl.opts.Output, "No tags found\n")
+		return nil
+	}
+
+	fmt.Fprintf(tl.opts.Output, "%-25s %-15s\n", "Tag Name", "Task Count")
+	fmt.Fprintf(tl.opts.Output, "%s\n", strings.Repeat("─", 45))
+
+	for _, tag := range tags {
+		tagName := tag.Name
+		if len(tagName) > 23 {
+			tagName = tagName[:20] + "..."
+		}
+
+		taskCountStr := fmt.Sprintf("%d task%s", tag.TaskCount, pluralizeCount(tag.TaskCount))
+
+		fmt.Fprintf(tl.opts.Output, "%-25s %-15s\n", tagName, taskCountStr)
+	}
+
+	return nil
+}

internal/ui/tag_list_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// Mock tag repository for testing
+type mockTagRepository struct {
+	tags []repo.TagSummary
+	err  error
+}
+
+func (m *mockTagRepository) GetTags(ctx context.Context) ([]repo.TagSummary, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.tags, nil
+}
+
+func TestTagList(t *testing.T) {
+	t.Run("NewTagList", func(t *testing.T) {
+		t.Run("creates tag list successfully", func(t *testing.T) {
+			mockRepo := &mockTagRepository{}
+			opts := TagListOptions{}
+
+			tagList := NewTagList(mockRepo, opts)
+
+			if tagList == nil {
+				t.Fatal("TagList should not be nil")
+			}
+			if tagList.repo != mockRepo {
+				t.Error("TagList repo should be set correctly")
+			}
+		})
+
+		t.Run("sets default options", func(t *testing.T) {
+			mockRepo := &mockTagRepository{}
+			opts := TagListOptions{}
+
+			tagList := NewTagList(mockRepo, opts)
+
+			if tagList.opts.Output == nil {
+				t.Error("Default output should be set")
+			}
+			if tagList.opts.Input == nil {
+				t.Error("Default input should be set")
+			}
+		})
+
+		t.Run("preserves custom options", func(t *testing.T) {
+			mockRepo := &mockTagRepository{}
+			output := &bytes.Buffer{}
+			input := strings.NewReader("")
+			opts := TagListOptions{
+				Output: output,
+				Input:  input,
+				Static: true,
+			}
+
+			tagList := NewTagList(mockRepo, opts)
+
+			if tagList.opts.Output != output {
+				t.Error("Custom output should be preserved")
+			}
+			if tagList.opts.Input != input {
+				t.Error("Custom input should be preserved")
+			}
+			if !tagList.opts.Static {
+				t.Error("Static option should be preserved")
+			}
+		})
+	})
+
+	t.Run("StaticList", func(t *testing.T) {
+		t.Run("displays tags correctly", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "frontend", TaskCount: 5},
+				{Name: "backend", TaskCount: 3},
+				{Name: "urgent", TaskCount: 1},
+			}
+			mockRepo := &mockTagRepository{tags: tags}
+			output := &bytes.Buffer{}
+			opts := TagListOptions{Output: output, Static: true}
+
+			tagList := NewTagList(mockRepo, opts)
+			err := tagList.Browse(context.Background())
+
+			if err != nil {
+				t.Errorf("Browse should not return error: %v", err)
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "Tags") {
+				t.Error("Output should contain title")
+			}
+			if !strings.Contains(result, "frontend") {
+				t.Error("Output should contain frontend tag")
+			}
+			if !strings.Contains(result, "backend") {
+				t.Error("Output should contain backend tag")
+			}
+			if !strings.Contains(result, "5 tasks") {
+				t.Error("Output should show correct task count for frontend")
+			}
+			if !strings.Contains(result, "1 task") {
+				t.Error("Output should show singular task for urgent")
+			}
+		})
+
+		t.Run("handles empty tag list", func(t *testing.T) {
+			mockRepo := &mockTagRepository{tags: []repo.TagSummary{}}
+			output := &bytes.Buffer{}
+			opts := TagListOptions{Output: output, Static: true}
+
+			tagList := NewTagList(mockRepo, opts)
+			err := tagList.Browse(context.Background())
+
+			if err != nil {
+				t.Errorf("Browse should not return error: %v", err)
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "No tags found") {
+				t.Error("Output should indicate no tags found")
+			}
+		})
+
+		t.Run("handles repository errors", func(t *testing.T) {
+			mockRepo := &mockTagRepository{err: fmt.Errorf("database error")}
+			output := &bytes.Buffer{}
+			opts := TagListOptions{Output: output, Static: true}
+
+			tagList := NewTagList(mockRepo, opts)
+			err := tagList.Browse(context.Background())
+
+			if err == nil {
+				t.Error("Browse should return error when repository fails")
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "Error:") {
+				t.Error("Output should contain error message")
+			}
+		})
+
+		t.Run("truncates long tag names", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "this-is-a-very-long-tag-name-that-should-be-truncated", TaskCount: 2},
+			}
+			mockRepo := &mockTagRepository{tags: tags}
+			output := &bytes.Buffer{}
+			opts := TagListOptions{Output: output, Static: true}
+
+			tagList := NewTagList(mockRepo, opts)
+			err := tagList.Browse(context.Background())
+
+			if err != nil {
+				t.Errorf("Browse should not return error: %v", err)
+			}
+
+			result := output.String()
+			if !strings.Contains(result, "...") {
+				t.Error("Output should truncate long tag names")
+			}
+		})
+	})
+
+	t.Run("TagListModel", func(t *testing.T) {
+		t.Run("initializes correctly", func(t *testing.T) {
+			model := tagListModel{
+				selected:    0,
+				showingHelp: false,
+			}
+
+			if model.selected != 0 {
+				t.Error("Initial selection should be 0")
+			}
+			if model.showingHelp {
+				t.Error("Should not be showing help initially")
+			}
+		})
+
+		t.Run("handles key navigation", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "tag1", TaskCount: 1},
+				{Name: "tag2", TaskCount: 2},
+				{Name: "tag3", TaskCount: 3},
+			}
+
+			model := tagListModel{
+				tags:     tags,
+				selected: 1,
+				keys:     tagKeys,
+			}
+
+			// Test down key
+			downMsg := tea.KeyMsg{Type: tea.KeyDown}
+			updatedModel, _ := model.Update(downMsg)
+			if updatedModel.(tagListModel).selected != 2 {
+				t.Error("Down key should move selection down")
+			}
+
+			// Test up key
+			upMsg := tea.KeyMsg{Type: tea.KeyUp}
+			updatedModel, _ = updatedModel.Update(upMsg)
+			if updatedModel.(tagListModel).selected != 1 {
+				t.Error("Up key should move selection up")
+			}
+
+			// Test boundary conditions
+			model.selected = 0
+			updatedModel, _ = model.Update(upMsg)
+			if updatedModel.(tagListModel).selected != 0 {
+				t.Error("Up key should not move selection below 0")
+			}
+
+			model.selected = len(tags) - 1
+			updatedModel, _ = model.Update(downMsg)
+			if updatedModel.(tagListModel).selected != len(tags)-1 {
+				t.Error("Down key should not move selection beyond list length")
+			}
+		})
+
+		t.Run("handles number key selection", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "tag1", TaskCount: 1},
+				{Name: "tag2", TaskCount: 2},
+				{Name: "tag3", TaskCount: 3},
+			}
+
+			model := tagListModel{
+				tags:     tags,
+				selected: 0,
+				keys:     tagKeys,
+			}
+
+			// Test number key 3 (index 2)
+			keyMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'3'}}
+			updatedModel, _ := model.Update(keyMsg)
+			if updatedModel.(tagListModel).selected != 2 {
+				t.Error("Number key 3 should select index 2")
+			}
+		})
+
+		t.Run("handles help toggle", func(t *testing.T) {
+			model := tagListModel{
+				keys: tagKeys,
+			}
+
+			helpMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'?'}}
+			updatedModel, _ := model.Update(helpMsg)
+			if !updatedModel.(tagListModel).showingHelp {
+				t.Error("Help key should show help")
+			}
+
+			updatedModel, _ = updatedModel.Update(helpMsg)
+			if updatedModel.(tagListModel).showingHelp {
+				t.Error("Help key should hide help when already showing")
+			}
+		})
+
+		t.Run("handles tags loaded message", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "new-tag", TaskCount: 5},
+			}
+
+			model := tagListModel{
+				selected: 5, // Invalid selection
+			}
+
+			msg := tagsLoadedMsg(tags)
+			updatedModel, _ := model.Update(msg)
+			resultModel := updatedModel.(tagListModel)
+
+			if len(resultModel.tags) != 1 {
+				t.Error("Tags should be loaded correctly")
+			}
+			if resultModel.selected != 0 {
+				t.Error("Selection should be reset to valid range")
+			}
+		})
+
+		t.Run("handles error message", func(t *testing.T) {
+			model := tagListModel{}
+
+			errorMsg := errorTagMsg(fmt.Errorf("test error"))
+			updatedModel, _ := model.Update(errorMsg)
+			resultModel := updatedModel.(tagListModel)
+
+			if resultModel.err == nil {
+				t.Error("Error should be set")
+			}
+			if resultModel.err.Error() != "test error" {
+				t.Errorf("Expected 'test error', got '%s'", resultModel.err.Error())
+			}
+		})
+
+		t.Run("view renders correctly", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "frontend", TaskCount: 5},
+				{Name: "urgent", TaskCount: 1},
+			}
+
+			model := tagListModel{
+				tags:     tags,
+				selected: 0,
+				keys:     tagKeys,
+			}
+
+			view := model.View()
+			if !strings.Contains(view, "Tags") {
+				t.Error("View should contain title")
+			}
+			if !strings.Contains(view, "frontend") {
+				t.Error("View should contain tag names")
+			}
+			if !strings.Contains(view, "5 tasks") {
+				t.Error("View should show task counts")
+			}
+			if !strings.Contains(view, "1 task") {
+				t.Error("View should show singular task count")
+			}
+		})
+
+		t.Run("view handles empty state", func(t *testing.T) {
+			model := tagListModel{
+				tags: []repo.TagSummary{},
+			}
+
+			view := model.View()
+			if !strings.Contains(view, "No tags found") {
+				t.Error("View should show empty state message")
+			}
+		})
+
+		t.Run("view handles error state", func(t *testing.T) {
+			model := tagListModel{
+				err: fmt.Errorf("test error"),
+			}
+
+			view := model.View()
+			if !strings.Contains(view, "Error:") {
+				t.Error("View should show error message")
+			}
+		})
+	})
+}

internal/ui/task_list.go

···
 	"os"
 	"strings"
 
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/utils"
 )
 
+var (
+	TitleColorStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color(Guac.Hex())).Bold(true)
+	SelectedColorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color(Salt.Hex())).Bold(true)
+	HeaderColorStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color(Malibu.Hex())).Bold(true)
+	StatusColorStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color(Julep.Hex()))
+)
+
+// Key bindings for task list navigation
+type keyMap struct {
+	Up        key.Binding
+	Down      key.Binding
+	Enter     key.Binding
+	View      key.Binding
+	Refresh   key.Binding
+	ToggleAll key.Binding
+	MarkDone  key.Binding
+	Quit      key.Binding
+	Back      key.Binding
+	Help      key.Binding
+	Numbers   []key.Binding
+}
+
+func (k keyMap) ShortHelp() []key.Binding {
+	return []key.Binding{k.Up, k.Down, k.Enter, k.MarkDone, k.Help, k.Quit}
+}
+
+func (k keyMap) FullHelp() [][]key.Binding {
+	return [][]key.Binding{
+		{k.Up, k.Down, k.Enter, k.View},
+		{k.MarkDone, k.Refresh, k.ToggleAll},
+		{k.Help, k.Quit, k.Back},
+	}
+}
+
+var keys = keyMap{
+	Up:        key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
+	Down:      key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
+	Enter:     key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "view task")),
+	View:      key.NewBinding(key.WithKeys("v"), key.WithHelp("v", "view task")),
+	Refresh:   key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
+	ToggleAll: key.NewBinding(key.WithKeys("a"), key.WithHelp("a", "toggle all/pending")),
+	MarkDone:  key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "mark done")),
+	Quit:      key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
+	Back:      key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
+	Help:      key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
+	Numbers: []key.Binding{
+		key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "jump to task 1")),
+		key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "jump to task 2")),
+		key.NewBinding(key.WithKeys("3"), key.WithHelp("3", "jump to task 3")),
+		key.NewBinding(key.WithKeys("4"), key.WithHelp("4", "jump to task 4")),
+		key.NewBinding(key.WithKeys("5"), key.WithHelp("5", "jump to task 5")),
+		key.NewBinding(key.WithKeys("6"), key.WithHelp("6", "jump to task 6")),
+		key.NewBinding(key.WithKeys("7"), key.WithHelp("7", "jump to task 7")),
+		key.NewBinding(key.WithKeys("8"), key.WithHelp("8", "jump to task 8")),
+		key.NewBinding(key.WithKeys("9"), key.WithHelp("9", "jump to task 9")),
+	},
+}
+
 // TaskRepository interface for dependency injection in tests
 type TaskRepository interface {
 	List(ctx context.Context, opts repo.TaskListOptions) ([]*models.Task, error)
···
 	return &TaskList{repo: repo, opts: opts}
 }
 
+type (
+	tasksLoadedMsg []*models.Task
+	taskViewMsg    string
+	errorTaskMsg   error
+)
+
 type taskListModel struct {
 	tasks       []*models.Task
 	selected    int
···
 	repo        TaskRepository
 	opts        TaskListOptions
 	showAll     bool
-	// filter      string
+	keys        keyMap
+	help        help.Model
+	showingHelp bool
 }
-
-type tasksLoadedMsg []*models.Task
-type taskViewMsg string
-type errorTaskMsg error
 
 func (m taskListModel) Init() tea.Cmd {
 	return m.loadTasks()
···
 func (m taskListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
+		if m.showingHelp {
+			switch {
+			case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
+				m.showingHelp = false
+				return m, nil
+			}
+			return m, nil
+		}
+
 		if m.viewing {
-			switch msg.String() {
-			case "q", "esc", "backspace":
+			switch {
+			case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit):
 				m.viewing = false
 				m.viewContent = ""
 				return m, nil
+			case key.Matches(msg, m.keys.Help):
+				m.showingHelp = true
+				return m, nil
 			}
 			return m, nil
 		}
 
-		switch msg.String() {
-		case "ctrl+c", "q":
+		switch {
+		case key.Matches(msg, m.keys.Quit):
 			return m, tea.Quit
-		case "up", "k":
+		case key.Matches(msg, m.keys.Up):
 			if m.selected > 0 {
 				m.selected--
 			}
-		case "down", "j":
+		case key.Matches(msg, m.keys.Down):
 			if m.selected < len(m.tasks)-1 {
 				m.selected++
 			}
-		case "enter", "v":
+		case key.Matches(msg, m.keys.Enter) || key.Matches(msg, m.keys.View):
 			if len(m.tasks) > 0 && m.selected < len(m.tasks) {
 				return m, m.viewTask(m.tasks[m.selected])
 			}
-		case "r":
+		case key.Matches(msg, m.keys.Refresh):
 			return m, m.loadTasks()
-		case "a":
+		case key.Matches(msg, m.keys.ToggleAll):
 			m.showAll = !m.showAll
 			return m, m.loadTasks()
-		case "d":
+		case key.Matches(msg, m.keys.MarkDone):
 			if len(m.tasks) > 0 && m.selected < len(m.tasks) {
 				return m, m.markDone(m.tasks[m.selected])
 			}
-		case "1", "2", "3", "4", "5", "6", "7", "8", "9":
-			if idx := int(msg.String()[0] - '1'); idx < len(m.tasks) {
-				m.selected = idx
+		case key.Matches(msg, m.keys.Help):
+			m.showingHelp = true
+			return m, nil
+		default:
+			for i, numKey := range m.keys.Numbers {
+				if key.Matches(msg, numKey) && i < len(m.tasks) {
+					m.selected = i
+					break
+				}
 			}
 		}
 	case tasksLoadedMsg:
···
 func (m taskListModel) View() string {
 	var s strings.Builder
 
-	style := lipgloss.NewStyle().Foreground(lipgloss.Color("86"))
-	titleStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("205")).Bold(true)
-	selectedStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("212")).Bold(true)
-	headerStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("39")).Bold(true)
-	priorityHighStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("196")).Bold(true)
-	priorityMediumStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("208"))
-	priorityLowStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("244"))
-	statusStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("28"))
+	style := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex()))
+
+	if m.showingHelp {
+		return m.help.View(m.keys)
+	}
 
 	if m.viewing {
 		s.WriteString(m.viewContent)
 		s.WriteString("\n\n")
-		s.WriteString(style.Render("Press q/esc/backspace to return to list"))
+		s.WriteString(style.Render("Press q/esc/backspace to return to list, ? for help"))
 		return s.String()
 	}
 
-	s.WriteString(titleStyle.Render("Tasks"))
+	s.WriteString(TitleColorStyle.Render("Tasks"))
 	if m.showAll {
 		s.WriteString(" (showing all)")
 	} else {
···
 		return s.String()
 	}
 
-	headerLine := fmt.Sprintf("%-3s %-4s %-40s %-10s %-10s %-15s", "", "ID", "Description", "Status", "Priority", "Project")
-	s.WriteString(headerStyle.Render(headerLine))
+	headerLine := fmt.Sprintf("   %-4s %-40s %-10s %-10s %-15s", "ID", "Description", "Status", "Priority", "Project")
+	s.WriteString(HeaderColorStyle.Render(headerLine))
 	s.WriteString("\n")
-	s.WriteString(headerStyle.Render(strings.Repeat("─", 80)))
+	s.WriteString(HeaderColorStyle.Render(strings.Repeat("─", 80)))
 	s.WriteString("\n")
 
 	for i, task := range m.tasks {
···
 			project = project[:10] + "..."
 		}
 
-		line := fmt.Sprintf("%s%-4d %-40s %-10s %-10s %-15s",
-			prefix, task.ID, description, status, priority, project)
+		priority = utils.Titlecase(priority)
+		padded := fmt.Sprintf("%-10s", priority)
+		var colored string
+		switch strings.ToLower(task.Priority) {
+		case "high", "urgent":
+			colored = PriorityHigh.Render(padded)
+		case "medium":
+			colored = PriorityMedium.Render(padded)
+		case "low":
+			colored = PriorityLow.Render(padded)
+		default:
+			colored = padded
+		}
+
+		line := fmt.Sprintf("%s%-4d %-40s %-10s %s %-15s", prefix, task.ID, description, status, colored, project)
 
 		if i == m.selected {
-			s.WriteString(selectedStyle.Render(line))
+			s.WriteString(SelectedColorStyle.Render(line))
 		} else {
-			// Color based on priority
-			switch strings.ToLower(task.Priority) {
-			case "high", "urgent":
-				s.WriteString(priorityHighStyle.Render(line))
-			case "medium":
-				s.WriteString(priorityMediumStyle.Render(line))
-			case "low":
-				s.WriteString(priorityLowStyle.Render(line))
-			default:
-				if task.Status == "completed" {
-					s.WriteString(statusStyle.Render(line))
-				} else {
-					s.WriteString(style.Render(line))
-				}
+			if task.Status == "completed" {
+				s.WriteString(StatusColorStyle.Render(line))
+			} else {
+				s.WriteString(style.Render(line))
 			}
 		}
 
-		// Add tags if any
 		if len(task.Tags) > 0 && i == m.selected {
 			s.WriteString(" @" + strings.Join(task.Tags, " @"))
 		}
···
 	}
 
 	s.WriteString("\n")
-	s.WriteString(style.Render("Controls: ↑/↓/k/j to navigate, Enter/v to view, d to mark done, a to toggle all/pending"))
-	s.WriteString("\n")
-	s.WriteString(style.Render("r to refresh, q to quit, 1-9 to jump to task"))
+	s.WriteString(m.help.View(m.keys))
 
 	return s.String()
 }
···
 func (m taskListModel) loadTasks() tea.Cmd {
 	return func() tea.Msg {
 		opts := repo.TaskListOptions{}
+		showAll := m.showAll || m.opts.ShowAll
 
-		// Set status filter
-		if m.showAll || m.opts.ShowAll {
-			// Show all tasks - no status filter
-		} else {
+		if !showAll {
 			opts.Status = "pending"
 		}
 
-		// Apply other filters from options
 		if m.opts.Status != "" {
 			opts.Status = m.opts.Status
 		}
···
 func (m taskListModel) viewTask(task *models.Task) tea.Cmd {
 	return func() tea.Msg {
 		var content strings.Builder
-
 		content.WriteString(fmt.Sprintf("# Task %d\n\n", task.ID))
 		content.WriteString(fmt.Sprintf("**UUID:** %s\n", task.UUID))
 		content.WriteString(fmt.Sprintf("**Description:** %s\n", task.Description))
···
 			return errorTaskMsg(fmt.Errorf("failed to mark task done: %w", err))
 		}
 
-		// Reload tasks after marking done
 		return m.loadTasks()()
 	}
 }
···
 		repo:    tl.repo,
 		opts:    tl.opts,
 		showAll: tl.opts.ShowAll,
+		keys:    keys,
+		help:    help.New(),
 	}
 
 	program := tea.NewProgram(model, tea.WithInput(tl.opts.Input), tea.WithOutput(tl.opts.Output))
···
 func (tl *TaskList) staticList(ctx context.Context) error {
 	opts := repo.TaskListOptions{}
 
-	if tl.opts.ShowAll {
-		// Show all tasks - no status filter
-	} else {
+	if !tl.opts.ShowAll {
 		opts.Status = "pending"
 	}
 

internal/ui/task_list_test.go

···
 	"testing"
 	"time"
 
+	"github.com/charmbracelet/bubbles/help"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
···
 
 	t.Run("load tasks command", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{ShowAll: false},
 		}
···
 
 	t.Run("load all tasks", func(t *testing.T) {
 		model := taskListModel{
+			keys:    keys,
 			repo:    repo,
 			opts:    TaskListOptions{ShowAll: true},
 			showAll: true,
···
 
 	t.Run("view task command", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}
···
 
 	t.Run("mark done command", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}
···
 		}
 
 		msg := cmd()
-		// Should return a loadTasks command after marking done
 		switch msg := msg.(type) {
 		case tasksLoadedMsg:
 			// Success - tasks reloaded
 		case errorTaskMsg:
-			// Check if it's the expected error for already completed task
 			err := error(msg)
 			if !strings.Contains(err.Error(), "completed") {
 				t.Fatalf("Unexpected error: %v", err)
···
 
 	t.Run("mark done already completed task", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}
 
-		task := createMockTasks()[2] // Already completed task
+		task := createMockTasks()[2]
 		cmd := model.markDone(task)
 		msg := cmd()
 
···
 
 	t.Run("quit commands", func(t *testing.T) {
 		model := taskListModel{
+			keys:  keys,
 			repo:  repo,
 			tasks: createMockTasks()[:2], // First 2 tasks
 			opts:  TaskListOptions{},
···
 
 	t.Run("navigation keys", func(t *testing.T) {
 		model := taskListModel{
+			keys:     keys,
 			repo:     repo,
 			tasks:    createMockTasks()[:3], // First 3 tasks
 			selected: 1,                     // Start in middle
 			opts:     TaskListOptions{},
 		}
 
-		// Test up navigation
 		upKeys := []string{"up", "k"}
 		for _, key := range upKeys {
 			testModel := model
···
 			}
 		}
 
-		// Test down navigation
 		downKeys := []string{"down", "j"}
 		for _, key := range downKeys {
 			testModel := model
···
 
 	t.Run("view task keys", func(t *testing.T) {
 		model := taskListModel{
+			keys:     keys,
 			repo:     repo,
 			tasks:    createMockTasks()[:2],
 			selected: 0,
···
 
 	t.Run("number shortcuts", func(t *testing.T) {
 		model := taskListModel{
+			keys:  keys,
 			repo:  repo,
 			tasks: createMockTasks()[:4],
 			opts:  TaskListOptions{},
···
 
 	t.Run("toggle all/pending", func(t *testing.T) {
 		model := taskListModel{
+			keys:    keys,
 			repo:    repo,
 			tasks:   createMockTasks()[:2],
 			showAll: false,
···
 
 	t.Run("mark done key", func(t *testing.T) {
 		model := taskListModel{
+			keys:     keys,
 			repo:     repo,
 			tasks:    createMockTasks()[:2],
 			selected: 0,
···
 
 	t.Run("refresh key", func(t *testing.T) {
 		model := taskListModel{
+			keys:  keys,
 			repo:  repo,
 			tasks: createMockTasks()[:2],
 			opts:  TaskListOptions{},
···
 
 	t.Run("viewing mode navigation", func(t *testing.T) {
 		model := taskListModel{
+			keys:        keys,
 			repo:        repo,
 			tasks:       createMockTasks()[:2],
 			viewing:     true,
···
 
 	t.Run("viewing mode", func(t *testing.T) {
 		model := taskListModel{
+			keys:        keys,
 			repo:        repo,
 			viewing:     true,
 			viewContent: "# Task Details\nTest content here",
···
 
 	t.Run("error state", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			err:  errors.New("test error"),
 			opts: TaskListOptions{},
···
 
 	t.Run("no tasks", func(t *testing.T) {
 		model := taskListModel{
+			keys:  keys,
 			repo:  repo,
 			tasks: []*models.Task{},
 			opts:  TaskListOptions{},
···
 	t.Run("with tasks", func(t *testing.T) {
 		tasks := createMockTasks()[:2] // First 2 tasks
 		model := taskListModel{
+			keys:     keys,
 			repo:     repo,
 			tasks:    tasks,
 			selected: 0,
···
 		if !strings.Contains(view, "Plan vacation itinerary") {
 			t.Error("Second task not displayed")
 		}
-		if !strings.Contains(view, "Controls:") {
-			t.Error("Control instructions not displayed")
+		if !strings.Contains(view, "help") {
+			t.Error("Help instructions not displayed")
 		}
 	})
 
 	t.Run("show all mode", func(t *testing.T) {
 		model := taskListModel{
+			keys:    keys,
 			repo:    repo,
 			tasks:   createMockTasks(),
 			showAll: true,
···
 	t.Run("selected task highlighting", func(t *testing.T) {
 		tasks := createMockTasks()[:2]
 		model := taskListModel{
+
+			keys:     keys,
 			repo:     repo,
 			tasks:    tasks,
 			selected: 0,
···
 		}
 
 		view := model.View()
-		// The selected task should have a ">" prefix
 		if !strings.Contains(view, " > 1   ") {
 			t.Error("Selected task not highlighted with '>' prefix")
 		}
···
 
 	t.Run("tasks loaded message", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}
···
 
 	t.Run("task view message", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}
···
 
 	t.Run("error message", func(t *testing.T) {
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}
···
 
 	t.Run("selected index bounds", func(t *testing.T) {
 		model := taskListModel{
+			keys:     keys,
 			repo:     repo,
 			tasks:    createMockTasks()[:2],
-			selected: 5, // Out of bounds
+			selected: 5,
 			opts:     TaskListOptions{},
 		}
 
-		// Load fewer tasks
 		newTasks := createMockTasks()[:1]
 		newModel, _ := model.Update(tasksLoadedMsg(newTasks))
 
···
 			if m.selected >= len(m.tasks) {
 				t.Error("Selected index should be adjusted to bounds")
 			}
-			if m.selected != 0 { // Should be adjusted to last valid index
+			if m.selected != 0 {
 				t.Errorf("Expected selected to be 0, got %d", m.selected)
 			}
 		}
···
 		}
 
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}
···
 		}
 
 		model := taskListModel{
+			keys: keys,
+			help: help.New(),
 			repo: repo,
 			opts: TaskListOptions{},
 		}

internal/ui/task_view.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/utils"
+)
+
+// TaskViewOptions configures the task view UI behavior
+type TaskViewOptions struct {
+	// Output destination (stdout for interactive, buffer for testing)
+	Output io.Writer
+	// Input source (stdin for interactive, strings reader for testing)
+	Input io.Reader
+	// Enable static mode (no interactive components)
+	Static bool
+	// Width and height for viewport sizing
+	Width  int
+	Height int
+}
+
+// TaskView handles task detail viewing UI
+type TaskView struct {
+	task *models.Task
+	opts TaskViewOptions
+}
+
+// NewTaskView creates a new task view UI component
+func NewTaskView(task *models.Task, opts TaskViewOptions) *TaskView {
+	if opts.Output == nil {
+		opts.Output = os.Stdout
+	}
+	if opts.Input == nil {
+		opts.Input = os.Stdin
+	}
+	// Set default dimensions if not provided
+	if opts.Width == 0 {
+		opts.Width = 80
+	}
+	if opts.Height == 0 {
+		opts.Height = 24
+	}
+	return &TaskView{task: task, opts: opts}
+}
+
+// Task view specific key bindings
+type taskViewKeyMap struct {
+	Up       key.Binding
+	Down     key.Binding
+	PageUp   key.Binding
+	PageDown key.Binding
+	Top      key.Binding
+	Bottom   key.Binding
+	Quit     key.Binding
+	Back     key.Binding
+	Help     key.Binding
+}
+
+func (k taskViewKeyMap) ShortHelp() []key.Binding {
+	return []key.Binding{k.Up, k.Down, k.Back, k.Help, k.Quit}
+}
+
+func (k taskViewKeyMap) FullHelp() [][]key.Binding {
+	return [][]key.Binding{
+		{k.Up, k.Down, k.PageUp, k.PageDown},
+		{k.Top, k.Bottom},
+		{k.Help, k.Back, k.Quit},
+	}
+}
+
+var taskViewKeys = taskViewKeyMap{
+	Up:       key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "scroll up")),
+	Down:     key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "scroll down")),
+	PageUp:   key.NewBinding(key.WithKeys("pgup", "b"), key.WithHelp("pgup/b", "page up")),
+	PageDown: key.NewBinding(key.WithKeys("pgdown", "f"), key.WithHelp("pgdown/f", "page down")),
+	Top:      key.NewBinding(key.WithKeys("home", "g"), key.WithHelp("home/g", "go to top")),
+	Bottom:   key.NewBinding(key.WithKeys("end", "G"), key.WithHelp("end/G", "go to bottom")),
+	Quit:     key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
+	Back:     key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
+	Help:     key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
+}
+
+type taskViewModel struct {
+	task        *models.Task
+	viewport    viewport.Model
+	keys        taskViewKeyMap
+	help        help.Model
+	showingHelp bool
+	opts        TaskViewOptions
+}
+
+func (m taskViewModel) Init() tea.Cmd {
+	return nil
+}
+
+func (m taskViewModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if m.showingHelp {
+			switch {
+			case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
+				m.showingHelp = false
+				return m, nil
+			}
+			return m, nil
+		}
+
+		switch {
+		case key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Back):
+			return m, tea.Quit
+		case key.Matches(msg, m.keys.Help):
+			m.showingHelp = true
+			return m, nil
+		case key.Matches(msg, m.keys.Up):
+			m.viewport.ScrollUp(1)
+		case key.Matches(msg, m.keys.Down):
+			m.viewport.ScrollDown(1)
+		case key.Matches(msg, m.keys.PageUp):
+			m.viewport.HalfPageUp()
+		case key.Matches(msg, m.keys.PageDown):
+			m.viewport.HalfPageDown()
+		case key.Matches(msg, m.keys.Top):
+			m.viewport.GotoTop()
+		case key.Matches(msg, m.keys.Bottom):
+			m.viewport.GotoBottom()
+		}
+
+	case tea.WindowSizeMsg:
+		headerHeight := 3 // Title + spacing
+		footerHeight := 3 // Help + spacing
+		verticalMarginHeight := headerHeight + footerHeight
+
+		if !m.opts.Static {
+			m.viewport.Width = msg.Width - 2 // Account for padding
+			m.viewport.Height = msg.Height - verticalMarginHeight
+		}
+	}
+
+	m.viewport, cmd = m.viewport.Update(msg)
+	return m, cmd
+}
+
+func (m taskViewModel) View() string {
+	if m.showingHelp {
+		return m.help.View(m.keys)
+	}
+
+	title := TitleColorStyle.Render(fmt.Sprintf("Task %d", m.task.ID))
+	content := m.viewport.View()
+	help := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex())).Render(m.help.View(m.keys))
+
+	return lipgloss.JoinVertical(lipgloss.Left, title, "", content, "", help)
+}
+
+func formatTaskContent(task *models.Task) string {
+	var content strings.Builder
+
+	content.WriteString(fmt.Sprintf("UUID: %s\n", task.UUID))
+	content.WriteString(fmt.Sprintf("Description: %s\n", task.Description))
+	content.WriteString(fmt.Sprintf("Status: %s\n", utils.Titlecase(task.Status)))
+
+	if task.Priority != "" {
+		content.WriteString(fmt.Sprintf("Priority: %s\n", utils.Titlecase(task.Priority)))
+	}
+
+	if task.Project != "" {
+		content.WriteString(fmt.Sprintf("Project: %s\n", task.Project))
+	}
+
+	if len(task.Tags) > 0 {
+		content.WriteString(fmt.Sprintf("Tags: %s\n", strings.Join(task.Tags, ", ")))
+	}
+
+	content.WriteString("\nDates:\n")
+	content.WriteString(fmt.Sprintf("- Created: %s\n", task.Entry.Format("2006-01-02 15:04")))
+	content.WriteString(fmt.Sprintf("- Modified: %s\n", task.Modified.Format("2006-01-02 15:04")))
+
+	if task.Due != nil {
+		content.WriteString(fmt.Sprintf("- Due: %s\n", task.Due.Format("2006-01-02 15:04")))
+	}
+
+	if task.Start != nil {
+		content.WriteString(fmt.Sprintf("- Started: %s\n", task.Start.Format("2006-01-02 15:04")))
+	}
+
+	if task.End != nil {
+		content.WriteString(fmt.Sprintf("- Completed: %s\n", task.End.Format("2006-01-02 15:04")))
+	}
+
+	if len(task.Annotations) > 0 {
+		content.WriteString("\nAnnotations:\n")
+		for i, annotation := range task.Annotations {
+			content.WriteString(fmt.Sprintf("%d. %s\n", i+1, annotation))
+		}
+	}
+
+	return content.String()
+}
+
+// Show displays the task in interactive mode
+func (tv *TaskView) Show(ctx context.Context) error {
+	if tv.opts.Static {
+		return tv.staticShow(ctx)
+	}
+
+	vp := viewport.New(tv.opts.Width-2, tv.opts.Height-6)
+	vp.SetContent(formatTaskContent(tv.task))
+
+	model := taskViewModel{
+		task:     tv.task,
+		viewport: vp,
+		keys:     taskViewKeys,
+		help:     help.New(),
+		opts:     tv.opts,
+	}
+
+	program := tea.NewProgram(model, tea.WithInput(tv.opts.Input), tea.WithOutput(tv.opts.Output))
+
+	_, err := program.Run()
+	return err
+}
+
+func (tv *TaskView) staticShow(context.Context) error {
+	content := formatTaskContent(tv.task)
+
+	title := fmt.Sprintf("Task %d\n\n", tv.task.ID)
+
+	fmt.Fprint(tv.opts.Output, title+content)
+	return nil
+}

internal/ui/task_view_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func createMockTask() *models.Task {
+	now := time.Now()
+	due := now.Add(24 * time.Hour)
+	start := now.Add(-2 * time.Hour)
+
+	return &models.Task{
+		ID:          1,
+		UUID:        "test-uuid-123",
+		Description: "Test task description",
+		Status:      "pending",
+		Priority:    "high",
+		Project:     "test-project",
+		Tags:        []string{"urgent", "test"},
+		Entry:       now.Add(-24 * time.Hour),
+		Modified:    now.Add(-1 * time.Hour),
+		Due:         &due,
+		Start:       &start,
+		Annotations: []string{"First annotation", "Second annotation"},
+	}
+}
+
+func createCompletedMockTask() *models.Task {
+	now := time.Now()
+	task := createMockTask()
+	task.Status = "completed"
+	task.End = &now
+	return task
+}
+
+func TestTaskView(t *testing.T) {
+	t.Run("View Options", func(t *testing.T) {
+		task := createMockTask()
+
+		t.Run("default options", func(t *testing.T) {
+			opts := TaskViewOptions{}
+			tv := NewTaskView(task, opts)
+
+			if tv.opts.Output == nil {
+				t.Error("Output should default to os.Stdout")
+			}
+			if tv.opts.Input == nil {
+				t.Error("Input should default to os.Stdin")
+			}
+			if tv.opts.Width != 80 {
+				t.Errorf("Width should default to 80, got %d", tv.opts.Width)
+			}
+			if tv.opts.Height != 24 {
+				t.Errorf("Height should default to 24, got %d", tv.opts.Height)
+			}
+		})
+
+		t.Run("custom options", func(t *testing.T) {
+			var buf bytes.Buffer
+			opts := TaskViewOptions{
+				Output: &buf,
+				Static: true,
+				Width:  100,
+				Height: 30,
+			}
+			tv := NewTaskView(task, opts)
+
+			if tv.opts.Output != &buf {
+				t.Error("Custom output not set")
+			}
+			if !tv.opts.Static {
+				t.Error("Static mode not set")
+			}
+			if tv.opts.Width != 100 {
+				t.Error("Custom width not set")
+			}
+			if tv.opts.Height != 30 {
+				t.Error("Custom height not set")
+			}
+		})
+	})
+
+	t.Run("New", func(t *testing.T) {
+		task := createMockTask()
+
+		t.Run("creates task view correctly", func(t *testing.T) {
+			opts := TaskViewOptions{Width: 60, Height: 20}
+			tv := NewTaskView(task, opts)
+
+			if tv.task != task {
+				t.Error("Task not set correctly")
+			}
+			if tv.opts.Width != 60 {
+				t.Error("Width not set correctly")
+			}
+			if tv.opts.Height != 20 {
+				t.Error("Height not set correctly")
+			}
+		})
+	})
+
+	t.Run("Static Mode", func(t *testing.T) {
+		t.Run("basic task display", func(t *testing.T) {
+			task := createMockTask()
+			var buf bytes.Buffer
+
+			tv := NewTaskView(task, TaskViewOptions{
+				Output: &buf,
+				Static: true,
+			})
+
+			err := tv.Show(context.Background())
+			if err != nil {
+				t.Fatalf("Show failed: %v", err)
+			}
+
+			output := buf.String()
+
+			if !strings.Contains(output, "Task 1") {
+				t.Error("Task title not displayed")
+			}
+
+			if !strings.Contains(output, "test-uuid-123") {
+				t.Error("UUID not displayed")
+			}
+			if !strings.Contains(output, "Test task description") {
+				t.Error("Description not displayed")
+			}
+			if !strings.Contains(output, "Pending") {
+				t.Error("Status not displayed with title case")
+			}
+			if !strings.Contains(output, "High") {
+				t.Error("Priority not displayed with title case")
+			}
+			if !strings.Contains(output, "test-project") {
+				t.Error("Project not displayed")
+			}
+			if !strings.Contains(output, "urgent, test") {
+				t.Error("Tags not displayed correctly")
+			}
+
+			if !strings.Contains(output, "Dates:") {
+				t.Error("Dates section not displayed")
+			}
+			if !strings.Contains(output, "Created:") {
+				t.Error("Created date not displayed")
+			}
+			if !strings.Contains(output, "Modified:") {
+				t.Error("Modified date not displayed")
+			}
+			if !strings.Contains(output, "Due:") {
+				t.Error("Due date not displayed")
+			}
+			if !strings.Contains(output, "Started:") {
+				t.Error("Start date not displayed")
+			}
+
+			if !strings.Contains(output, "Annotations:") {
+				t.Error("Annotations section not displayed")
+			}
+			if !strings.Contains(output, "First annotation") {
+				t.Error("First annotation not displayed")
+			}
+			if !strings.Contains(output, "Second annotation") {
+				t.Error("Second annotation not displayed")
+			}
+		})
+
+		t.Run("completed task display", func(t *testing.T) {
+			task := createCompletedMockTask()
+			var buf bytes.Buffer
+
+			tv := NewTaskView(task, TaskViewOptions{
+				Output: &buf,
+				Static: true,
+			})
+
+			err := tv.Show(context.Background())
+			if err != nil {
+				t.Fatalf("Show failed: %v", err)
+			}
+
+			output := buf.String()
+
+			if !strings.Contains(output, "Completed") {
+				t.Error("Completed status not displayed with title case")
+			}
+			if !strings.Contains(output, "Completed:") {
+				t.Error("Completion date not displayed")
+			}
+		})
+
+		t.Run("minimal task display", func(t *testing.T) {
+			now := time.Now()
+			task := &models.Task{
+				ID:          2,
+				UUID:        "minimal-uuid",
+				Description: "Minimal task",
+				Status:      "pending",
+				Entry:       now,
+				Modified:    now,
+			}
+
+			var buf bytes.Buffer
+			tv := NewTaskView(task, TaskViewOptions{
+				Output: &buf,
+				Static: true,
+			})
+
+			err := tv.Show(context.Background())
+			if err != nil {
+				t.Fatalf("Show failed: %v", err)
+			}
+
+			output := buf.String()
+
+			if !strings.Contains(output, "Task 2") {
+				t.Error("Task title not displayed")
+			}
+			if !strings.Contains(output, "minimal-uuid") {
+				t.Error("UUID not displayed")
+			}
+			if !strings.Contains(output, "Minimal task") {
+				t.Error("Description not displayed")
+			}
+
+			// Should not contain optional fields
+			if strings.Contains(output, "Priority:") {
+				t.Error("Priority should not be displayed for minimal task")
+			}
+			if strings.Contains(output, "Project:") {
+				t.Error("Project should not be displayed for minimal task")
+			}
+			if strings.Contains(output, "Tags:") {
+				t.Error("Tags should not be displayed for minimal task")
+			}
+			if strings.Contains(output, "Annotations:") {
+				t.Error("Annotations should not be displayed for minimal task")
+			}
+		})
+	})
+
+	t.Run("Format Content", func(t *testing.T) {
+		t.Run("formats task content correctly", func(t *testing.T) {
+			task := createMockTask()
+			content := formatTaskContent(task)
+
+			expectedStrings := []string{
+				"UUID: test-uuid-123",
+				"Description: Test task description",
+				"Status: Pending",
+				"Priority: High",
+				"Project: test-project",
+				"Tags: urgent, test",
+				"Dates:",
+				"Created:",
+				"Modified:",
+				"Due:",
+				"Started:",
+				"Annotations:",
+				"1. First annotation",
+				"2. Second annotation",
+			}
+
+			for _, expected := range expectedStrings {
+				if !strings.Contains(content, expected) {
+					t.Errorf("Expected content '%s' not found in formatted output", expected)
+				}
+			}
+		})
+
+		t.Run("handles empty optional fields", func(t *testing.T) {
+			now := time.Now()
+			task := &models.Task{
+				ID:          1,
+				UUID:        "test-uuid",
+				Description: "Test description",
+				Status:      "pending",
+				Entry:       now,
+				Modified:    now,
+			}
+
+			content := formatTaskContent(task)
+
+			if strings.Contains(content, "Priority:") {
+				t.Error("Priority should not appear when empty")
+			}
+			if strings.Contains(content, "Project:") {
+				t.Error("Project should not appear when empty")
+			}
+			if strings.Contains(content, "Tags:") {
+				t.Error("Tags should not appear when empty")
+			}
+			if strings.Contains(content, "Annotations:") {
+				t.Error("Annotations should not appear when empty")
+			}
+			if strings.Contains(content, "Due:") {
+				t.Error("Due date should not appear when nil")
+			}
+			if strings.Contains(content, "Started:") {
+				t.Error("Start date should not appear when nil")
+			}
+			if strings.Contains(content, "Completed:") {
+				t.Error("End date should not appear when nil")
+			}
+		})
+	})
+
+	t.Run("Model", func(t *testing.T) {
+		task := createMockTask()
+
+		t.Run("initial model state", func(t *testing.T) {
+			vp := viewport.New(80, 20)
+			vp.SetContent(formatTaskContent(task))
+
+			model := taskViewModel{task: task, opts: TaskViewOptions{Width: 80, Height: 24}}
+
+			if model.showingHelp {
+				t.Error("Initial showingHelp should be false")
+			}
+			if model.task != task {
+				t.Error("Task not set correctly")
+			}
+		})
+
+		t.Run("key handling - help toggle", func(t *testing.T) {
+			vp := viewport.New(80, 20)
+			model := taskViewModel{
+				task:     task,
+				viewport: vp,
+				keys:     taskViewKeys,
+				help:     help.New(),
+			}
+
+			newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("?")})
+			if m, ok := newModel.(taskViewModel); ok {
+				if !m.showingHelp {
+					t.Error("Help key should show help")
+				}
+			}
+
+			model.showingHelp = true
+			newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("?")})
+			if m, ok := newModel.(taskViewModel); ok {
+				if m.showingHelp {
+					t.Error("Help key should exit help when already showing")
+				}
+			}
+		})
+
+		t.Run("key handling - quit and back", func(t *testing.T) {
+			vp := viewport.New(80, 20)
+			model := taskViewModel{
+				task:     task,
+				viewport: vp,
+				keys:     taskViewKeys,
+				help:     help.New(),
+			}
+
+			quitKeys := []string{"q", "esc"}
+			for _, key := range quitKeys {
+				_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
+				if cmd == nil {
+					t.Errorf("Key %s should return quit command", key)
+				}
+			}
+		})
+
+		t.Run("viewport navigation", func(t *testing.T) {
+			vp := viewport.New(80, 20)
+			longContent := strings.Repeat("Line of content\n", 50) // Create content longer than viewport
+			vp.SetContent(longContent)
+
+			model := taskViewModel{
+				task:     task,
+				viewport: vp,
+				keys:     taskViewKeys,
+				help:     help.New(),
+			}
+
+			initialOffset := model.viewport.YOffset
+
+			newModel, _ := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
+			if m, ok := newModel.(taskViewModel); ok {
+				if m.viewport.YOffset <= initialOffset {
+					t.Error("Down key should scroll viewport down")
+				}
+			}
+
+			model.viewport.ScrollDown(5)
+			initialOffset = model.viewport.YOffset
+			newModel, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
+			if m, ok := newModel.(taskViewModel); ok {
+				if m.viewport.YOffset >= initialOffset {
+					t.Error("Up key should scroll viewport up")
+				}
+			}
+		})
+	})
+
+	t.Run("View Model", func(t *testing.T) {
+		task := createMockTask()
+
+		t.Run("normal view", func(t *testing.T) {
+			vp := viewport.New(80, 20)
+			vp.SetContent(formatTaskContent(task))
+
+			model := taskViewModel{
+				task:     task,
+				viewport: vp,
+				keys:     taskViewKeys,
+				help:     help.New(),
+			}
+
+			view := model.View()
+
+			if !strings.Contains(view, "Task 1") {
+				t.Error("Task title not displayed in view")
+			}
+			if !strings.Contains(view, "help") {
+				t.Error("Help information not displayed")
+			}
+		})
+
+		t.Run("help view", func(t *testing.T) {
+			vp := viewport.New(80, 20)
+			model := taskViewModel{
+				task:        task,
+				viewport:    vp,
+				keys:        taskViewKeys,
+				help:        help.New(),
+				showingHelp: true,
+			}
+
+			view := model.View()
+
+			if !strings.Contains(view, "scroll") {
+				t.Error("Help view should contain scroll instructions")
+			}
+		})
+	})
+
+	t.Run("Integration", func(t *testing.T) {
+		t.Run("creates and displays task view", func(t *testing.T) {
+			task := createMockTask()
+			var buf bytes.Buffer
+
+			tv := NewTaskView(task, TaskViewOptions{
+				Output: &buf,
+				Static: true,
+				Width:  80,
+				Height: 24,
+			})
+
+			if tv == nil {
+				t.Fatal("NewTaskView returned nil")
+			}
+
+			err := tv.Show(context.Background())
+			if err != nil {
+				t.Fatalf("Show failed: %v", err)
+			}
+
+			output := buf.String()
+			if len(output) == 0 {
+				t.Error("No output generated")
+			}
+
+			if !strings.Contains(output, task.Description) {
+				t.Error("Task description not displayed")
+			}
+			if !strings.Contains(output, task.UUID) {
+				t.Error("Task UUID not displayed")
+			}
+		})
+	})
+}

internal/utils/utils.go

···
 	"strings"
 
 	"github.com/charmbracelet/log"
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
 )
 
 // Logger is the global application logger
···
 	}
 	return Logger
 }
+
+func Titlecase(s string) string {
+	return cases.Title(language.Und, cases.NoLower).String(s)
+}

internal/utils/utils_test.go

···
 		}
 	})
 }
+
+func TestTitlecase(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "single word lowercase",
+			input:    "hello",
+			expected: "Hello",
+		},
+		{
+			name:     "single word uppercase",
+			input:    "HELLO",
+			expected: "HELLO",
+		},
+		{
+			name:     "multiple words",
+			input:    "hello world",
+			expected: "Hello World",
+		},
+		{
+			name:     "mixed case",
+			input:    "hELLo WoRLD",
+			expected: "HELLo WoRLD",
+		},
+		{
+			name:     "with punctuation",
+			input:    "hello, world!",
+			expected: "Hello, World!",
+		},
+		{
+			name:     "empty string",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "with numbers",
+			input:    "hello 123 world",
+			expected: "Hello 123 World",
+		},
+		{
+			name:     "with special characters",
+			input:    "hello-world_test",
+			expected: "Hello-World_test",
+		},
+		{
+			name:     "already title case",
+			input:    "Hello World",
+			expected: "Hello World",
+		},
+		{
+			name:     "single character",
+			input:    "a",
+			expected: "A",
+		},
+		{
+			name:     "apostrophes",
+			input:    "it's a beautiful day",
+			expected: "It's A Beautiful Day",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Titlecase(tt.input)
+			if result != tt.expected {
+				t.Errorf("Titlecase(%q) = %q, expected %q", tt.input, result, tt.expected)
+			}
+		})
+	}
+}