feat: interactive task viewing

cmd/commands.go

···
 )
 
 func rootCmd() *cobra.Command {
-	return &cobra.Command{
+	root := &cobra.Command{
 		Use:   "noteleaf",
 		Long:  ui.Georgia.ColoredInViewport(),
 		Short: "A TaskWarrior-inspired CLI with notes, media queues and reading lists",
···
 			return nil
 		},
 	}
+
+	root.SetHelpCommand(&cobra.Command{Hidden: true})
+	cobra.EnableCommandSorting = false
+
+	root.AddGroup(&cobra.Group{ID: "core", Title: "Core Commands:"})
+	root.AddGroup(&cobra.Group{ID: "management", Title: "Management Commands:"})
+
+	return root
 }
 
 func todoCmd() *cobra.Command {
 	root := &cobra.Command{
-		Use:   "todo",
-		Short: "task management",
+		Use:     "todo",
+		Aliases: []string{"task"},
+		Short:   "task management",
 	}
 
 	root.AddCommand(&cobra.Command{
···
 		},
 	})
 
-	root.AddCommand(&cobra.Command{
+	listCmd := &cobra.Command{
 		Use:     "list",
 		Short:   "List tasks",
 		Aliases: []string{"ls"},
+		Long: `List tasks with optional filtering and display modes.
+
+By default, shows tasks in an interactive TaskWarrior-like interface.
+Use --static to show a simple text list instead.
+Use --all to show all tasks, otherwise only pending tasks are shown.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.ListTasks(cmd.Context(), args)
+			static, _ := cmd.Flags().GetBool("static")
+			showAll, _ := cmd.Flags().GetBool("all")
+			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)
 		},
-	})
+	}
+	listCmd.Flags().BoolP("interactive", "i", false, "Force interactive mode (default)")
+	listCmd.Flags().Bool("static", false, "Use static text output instead of interactive")
+	listCmd.Flags().BoolP("all", "a", false, "Show all tasks (default: pending only)")
+	listCmd.Flags().String("status", "", "Filter by status")
+	listCmd.Flags().String("priority", "", "Filter by priority")
+	listCmd.Flags().String("project", "", "Filter by project")
+	root.AddCommand(listCmd)
 
 	root.AddCommand(&cobra.Command{
 		Use:   "view [task-id]",
···
 	return root
 }
 
-func movieCmd() *cobra.Command {
+func mediaCmd() *cobra.Command {
+	root := &cobra.Command{
+		Use:   "media",
+		Short: "Manage media queues (books, movies, TV shows)",
+	}
+
+	root.AddCommand(bookMediaCmd())
+	root.AddCommand(movieMediaCmd())
+	root.AddCommand(tvMediaCmd())
+
+	return root
+}
+
+func movieMediaCmd() *cobra.Command {
 	root := &cobra.Command{
 		Use:   "movie",
 		Short: "Manage movie watch queue",
···
 		},
 	})
 
+	root.AddCommand(&cobra.Command{
+		Use:     "watched [id]",
+		Short:   "Mark movie as watched",
+		Aliases: []string{"seen"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Printf("Marking movie %s as watched\n", args[0])
+			// TODO: Implement movie watched status
+			return nil
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:     "remove [id]",
+		Short:   "Remove movie from queue",
+		Aliases: []string{"rm"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Printf("Removing movie %s from queue\n", args[0])
+			// TODO: Implement movie removal
+			return nil
+		},
+	})
+
 	return root
 }
 
-func tvCmd() *cobra.Command {
+func tvMediaCmd() *cobra.Command {
 	root := &cobra.Command{
 		Use:   "tv",
 		Short: "Manage TV show watch queue",
···
 		},
 	})
 
+	root.AddCommand(&cobra.Command{
+		Use:     "watched [id]",
+		Short:   "Mark TV show/episodes as watched",
+		Aliases: []string{"seen"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Printf("Marking TV show %s as watched\n", args[0])
+			// TODO: Implement TV show watched status
+			return nil
+		},
+	})
+
+	root.AddCommand(&cobra.Command{
+		Use:     "remove [id]",
+		Short:   "Remove TV show from queue",
+		Aliases: []string{"rm"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Printf("Removing TV show %s from queue\n", args[0])
+			// TODO: Implement TV show removal
+			return nil
+		},
+	})
+
 	return root
 }
 
-func bookCmd() *cobra.Command {
+func bookMediaCmd() *cobra.Command {
 	root := &cobra.Command{
 		Use:   "book",
 		Short: "Manage reading list",
···
 }
 
 func setupCmd() *cobra.Command {
-	return &cobra.Command{
+	handler, err := handlers.NewSeedHandler()
+	if err != nil {
+		log.Fatalf("failed to instantiate seed handler: %v", err)
+	}
+
+	root := &cobra.Command{
 		Use:   "setup",
-		Short: "Initialize the application database and configuration",
+		Short: "Initialize and manage application setup",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return handlers.Setup(cmd.Context(), args)
 		},
 	}
+
+	seedCmd := &cobra.Command{
+		Use:   "seed",
+		Short: "Populate database with test data",
+		Long:  "Add sample tasks, books, and notes to the database for testing and demonstration purposes",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			force, _ := cmd.Flags().GetBool("force")
+			return handler.Seed(cmd.Context(), force)
+		},
+	}
+	seedCmd.Flags().BoolP("force", "f", false, "Clear existing data and re-seed")
+
+	root.AddCommand(seedCmd)
+	return root
 }
 
 func confCmd() *cobra.Command {

cmd/main.go

···
 	defer app.Close()
 
 	root := rootCmd()
-	commands := []func() *cobra.Command{
-		setupCmd, resetCmd, statusCmd, todoCmd,
-		movieCmd, noteCmd, tvCmd, bookCmd, confCmd,
+	core := []func() *cobra.Command{todoCmd, mediaCmd, noteCmd}
+	mgmt := []func() *cobra.Command{statusCmd, confCmd, setupCmd, resetCmd}
+
+	for _, cmdFunc := range core {
+		cmd := cmdFunc()
+		cmd.GroupID = "core"
+		root.AddCommand(cmd)
 	}
 
-	for _, cmdFunc := range commands {
+	for _, cmdFunc := range mgmt {
 		cmd := cmdFunc()
+		cmd.GroupID = "management"
 		root.AddCommand(cmd)
 	}
 
-	options := []fang.Option{
+	opts := []fang.Option{
 		fang.WithVersion("0.1.0"),
 		fang.WithoutCompletions(),
 		fang.WithColorSchemeFunc(ui.NoteleafColorScheme),
 	}
 
-	if err := fang.Execute(context.Background(), root, options...); err != nil {
+	if err := fang.Execute(context.Background(), root, opts...); err != nil {
 		os.Exit(1)
 	}
 }

go.sum

···
 github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
 github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
+github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
+github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
 github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
 github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
+github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
···
 github.com/charmbracelet/glamour v0.10.0/go.mod h1:f+uf+I/ChNmqo087elLnVdCiVgjSKWuXa/l6NU2ndYk=
 github.com/charmbracelet/huh v0.7.0 h1:W8S1uyGETgj9Tuda3/JdVkc3x7DBLZYPZc4c+/rnRdc=
 github.com/charmbracelet/huh v0.7.0/go.mod h1:UGC3DZHlgOKHvHC07a5vHag41zzhpPFj34U92sOmyuk=
-github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
-github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
 github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 h1:ZR7e0ro+SZZiIZD7msJyA+NjkCNNavuiPBLgerbOziE=
 github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834/go.mod h1:aKC/t2arECF6rNOnaKaVU6y4t4ZeHQzqfxedE/VkVhA=
 github.com/charmbracelet/lipgloss/v2 v2.0.0-beta1 h1:SOylT6+BQzPHEjn15TIzawBPVD0QmhKXbcb3jY0ZIKU=
···
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
 github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=

internal/handlers/seed.go

···
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+	"github.com/stormlightlabs/noteleaf/internal/ui"
+	"github.com/stormlightlabs/noteleaf/internal/utils"
+)
+
+// SeedHandler handles database seeding operations
+type SeedHandler struct {
+	db     *store.Database
+	config *store.Config
+	repos  *repo.Repositories
+}
+
+// NewSeedHandler creates a new seed handler
+func NewSeedHandler() (*SeedHandler, error) {
+	db, err := store.NewDatabase()
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize database: %w", err)
+	}
+
+	config, err := store.LoadConfig()
+	if err != nil {
+		return nil, fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	repos := repo.NewRepositories(db.DB)
+
+	return &SeedHandler{
+		db:     db,
+		config: config,
+		repos:  repos,
+	}, nil
+}
+
+// Close cleans up resources
+func (h *SeedHandler) Close() error {
+	if h.db != nil {
+		return h.db.Close()
+	}
+	return nil
+}
+
+// Seed populates the database with test data for demonstration and testing
+func (h *SeedHandler) Seed(ctx context.Context, force bool) error {
+	logger := utils.GetLogger()
+	logger.Info("Seeding database with test data")
+
+	if force {
+		fmt.Println("Clearing existing data...")
+		if err := h.clearAllData(); err != nil {
+			return fmt.Errorf("failed to clear existing data: %w", err)
+		}
+	}
+
+	fmt.Println("Seeding database with test data...")
+
+	// Seed tasks
+	tasks := []struct {
+		description string
+		project     string
+		priority    string
+		status      string
+	}{
+		{"Review quarterly report", "work", "high", "pending"},
+		{"Plan vacation itinerary", "personal", "medium", "pending"},
+		{"Fix bug in user authentication", "development", "high", "pending"},
+		{"Read \"Clean Code\" book", "learning", "low", "pending"},
+		{"Update project documentation", "work", "medium", "completed"},
+	}
+
+	for _, task := range tasks {
+		if err := h.seedTask(task.description, task.project, task.priority, task.status); err != nil {
+			logger.Warn("Failed to seed task", "description", task.description, "error", err)
+		}
+	}
+
+	// Seed books
+	books := []struct {
+		title    string
+		author   string
+		status   string
+		progress int
+	}{
+		{"The Go Programming Language", "Alan Donovan", "reading", 45},
+		{"Clean Code", "Robert Martin", "queued", 0},
+		{"Design Patterns", "Gang of Four", "finished", 100},
+		{"The Pragmatic Programmer", "Andy Hunt", "queued", 0},
+		{"Effective Go", "Various", "reading", 75},
+	}
+
+	for _, book := range books {
+		if err := h.seedBook(book.title, book.author, book.status, book.progress); err != nil {
+			logger.Warn("Failed to seed book", "title", book.title, "error", err)
+		}
+	}
+
+	fmt.Printf("Successfully seeded database with %d tasks and %d books\n", len(tasks), len(books))
+	fmt.Printf("\n%s\n", ui.Info.Render("Example commands to try:"))
+	fmt.Printf("  %s\n", ui.Success.Render("noteleaf todo list"))
+	fmt.Printf("  %s\n", ui.Success.Render("noteleaf media book list"))
+	fmt.Printf("  %s\n", ui.Success.Render("noteleaf todo view 1"))
+
+	return nil
+}
+
+func (h *SeedHandler) clearAllData() error {
+	queries := []string{
+		"DELETE FROM tasks",
+		"DELETE FROM books",
+		"DELETE FROM notes",
+		"DELETE FROM movies",
+		"DELETE FROM tv_shows",
+		"DELETE FROM sqlite_sequence WHERE name IN ('tasks', 'books', 'notes', 'movies', 'tv_shows')",
+	}
+
+	for _, query := range queries {
+		if _, err := h.db.Exec(query); err != nil {
+			return fmt.Errorf("failed to execute %s: %w", query, err)
+		}
+	}
+
+	return nil
+}
+
+func (h *SeedHandler) seedTask(description, project, priority, status string) error {
+	// Generate a simple UUID for the task (required field)
+	uuid := h.generateSimpleUUID()
+	query := `INSERT INTO tasks (uuid, description, project, priority, status, entry, modified)
+			  VALUES (?, ?, ?, ?, ?, datetime('now'), datetime('now'))`
+	_, err := h.db.Exec(query, uuid, description, project, priority, status)
+	return err
+}
+
+func (h *SeedHandler) seedBook(title, author, status string, progress int) error {
+	query := `INSERT INTO books (title, author, status, progress, added)
+			  VALUES (?, ?, ?, ?, datetime('now'))`
+	_, err := h.db.Exec(query, title, author, status, progress)
+	return err
+}
+
+// generateSimpleUUID creates a simple UUID for seeding (not cryptographically secure, but sufficient for test data)
+func (h *SeedHandler) generateSimpleUUID() string {
+	now := time.Now()
+	// Add random component to avoid collisions during rapid seeding
+	randomNum := rand.Intn(10000)
+	return fmt.Sprintf("seed-task-%d-%d-%d", now.Unix(), now.UnixNano()%1000000, randomNum)
+}

internal/handlers/seed_test.go

···
+package handlers
+
+import (
+	"context"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/stormlightlabs/noteleaf/internal/store"
+)
+
+func setupSeedTest(t *testing.T) (string, func()) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-seed-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+
+	oldConfigHome := os.Getenv("XDG_CONFIG_HOME")
+	os.Setenv("XDG_CONFIG_HOME", tempDir)
+
+	cleanup := func() {
+		os.Setenv("XDG_CONFIG_HOME", oldConfigHome)
+		os.RemoveAll(tempDir)
+	}
+
+	ctx := context.Background()
+	err = Setup(ctx, []string{})
+	if err != nil {
+		cleanup()
+		t.Fatalf("Failed to setup database: %v", err)
+	}
+
+	return tempDir, cleanup
+}
+
+func countRecords(t *testing.T, db *store.Database, table string) int {
+	t.Helper()
+
+	var count int
+	query := "SELECT COUNT(*) FROM " + table
+	err := db.QueryRow(query).Scan(&count)
+	if err != nil {
+		t.Fatalf("Failed to count records in %s: %v", table, err)
+	}
+	return count
+}
+
+func getTaskRecord(t *testing.T, db *store.Database, id int) (description, project, priority, status string) {
+	t.Helper()
+
+	query := "SELECT description, project, priority, status FROM tasks WHERE id = ?"
+	err := db.QueryRow(query, id).Scan(&description, &project, &priority, &status)
+	if err != nil {
+		t.Fatalf("Failed to get task record: %v", err)
+	}
+	return description, project, priority, status
+}
+
+func getBookRecord(t *testing.T, db *store.Database, id int) (title, author, status string, progress int) {
+	t.Helper()
+
+	query := "SELECT title, author, status, progress FROM books WHERE id = ?"
+	err := db.QueryRow(query, id).Scan(&title, &author, &status, &progress)
+	if err != nil {
+		t.Fatalf("Failed to get book record: %v", err)
+	}
+	return title, author, status, progress
+}
+
+func TestSeedHandler(t *testing.T) {
+	_, cleanup := setupSeedTest(t)
+	defer cleanup()
+
+	handler, err := NewSeedHandler()
+	if err != nil {
+		t.Fatalf("Failed to create seed handler: %v", err)
+	}
+	defer handler.Close()
+
+	ctx := context.Background()
+
+	t.Run("New", func(t *testing.T) {
+		t.Run("creates handler successfully", func(t *testing.T) {
+			testHandler, err := NewSeedHandler()
+			if err != nil {
+				t.Fatalf("NewSeedHandler failed: %v", err)
+			}
+			if testHandler == nil {
+				t.Fatal("Handler should not be nil")
+			}
+			defer testHandler.Close()
+
+			if testHandler.db == nil {
+				t.Error("Handler database should not be nil")
+			}
+			if testHandler.config == nil {
+				t.Error("Handler config should not be nil")
+			}
+			if testHandler.repos == nil {
+				t.Error("Handler repos should not be nil")
+			}
+		})
+
+		t.Run("handles database initialization error", func(t *testing.T) {
+			originalXDG := os.Getenv("XDG_CONFIG_HOME")
+			originalHome := os.Getenv("HOME")
+
+			if runtime.GOOS == "windows" {
+				originalAppData := os.Getenv("APPDATA")
+				os.Unsetenv("APPDATA")
+				defer os.Setenv("APPDATA", originalAppData)
+			} else {
+				os.Unsetenv("XDG_CONFIG_HOME")
+				os.Unsetenv("HOME")
+			}
+
+			defer func() {
+				os.Setenv("XDG_CONFIG_HOME", originalXDG)
+				os.Setenv("HOME", originalHome)
+			}()
+
+			_, err := NewSeedHandler()
+			if err == nil {
+				t.Error("NewSeedHandler should fail when database initialization fails")
+			}
+			if !strings.Contains(err.Error(), "failed to initialize database") {
+				t.Errorf("Expected database error, got: %v", err)
+			}
+		})
+	})
+
+	t.Run("Seed", func(t *testing.T) {
+		t.Run("seeds database with test data", func(t *testing.T) {
+			err := handler.Seed(ctx, false)
+			if err != nil {
+				t.Fatalf("Seed failed: %v", err)
+			}
+
+			taskCount := countRecords(t, handler.db, "tasks")
+			if taskCount != 5 {
+				t.Errorf("Expected 5 tasks, got %d", taskCount)
+			}
+
+			bookCount := countRecords(t, handler.db, "books")
+			if bookCount != 5 {
+				t.Errorf("Expected 5 books, got %d", bookCount)
+			}
+
+			desc, proj, prio, status := getTaskRecord(t, handler.db, 1)
+			if desc != "Review quarterly report" {
+				t.Errorf("Expected 'Review quarterly report', got '%s'", desc)
+			}
+			if proj != "work" {
+				t.Errorf("Expected 'work' project, got '%s'", proj)
+			}
+			if prio != "high" {
+				t.Errorf("Expected 'high' priority, got '%s'", prio)
+			}
+			if status != "pending" {
+				t.Errorf("Expected 'pending' status, got '%s'", status)
+			}
+
+			title, author, bookStatus, progress := getBookRecord(t, handler.db, 1)
+			if title != "The Go Programming Language" {
+				t.Errorf("Expected 'The Go Programming Language', got '%s'", title)
+			}
+			if author != "Alan Donovan" {
+				t.Errorf("Expected 'Alan Donovan', got '%s'", author)
+			}
+			if bookStatus != "reading" {
+				t.Errorf("Expected 'reading' status, got '%s'", bookStatus)
+			}
+			if progress != 45 {
+				t.Errorf("Expected 45%% progress, got %d", progress)
+			}
+		})
+
+		t.Run("seeds without force flag preserves existing data", func(t *testing.T) {
+			err := handler.Seed(ctx, false)
+			if err != nil {
+				t.Fatalf("First seed failed: %v", err)
+			}
+
+			initialTaskCount := countRecords(t, handler.db, "tasks")
+			initialBookCount := countRecords(t, handler.db, "books")
+
+			err = handler.Seed(ctx, false)
+			if err != nil {
+				t.Fatalf("Second seed failed: %v", err)
+			}
+
+			finalTaskCount := countRecords(t, handler.db, "tasks")
+			finalBookCount := countRecords(t, handler.db, "books")
+
+			expectedTasks := initialTaskCount + 5
+			expectedBooks := initialBookCount + 5
+
+			if finalTaskCount != expectedTasks {
+				t.Errorf("Expected %d tasks after second seed, got %d", expectedTasks, finalTaskCount)
+			}
+			if finalBookCount != expectedBooks {
+				t.Errorf("Expected %d books after second seed, got %d", expectedBooks, finalBookCount)
+			}
+		})
+
+		t.Run("force flag clears existing data before seeding", func(t *testing.T) {
+			err := handler.Seed(ctx, false)
+			if err != nil {
+				t.Fatalf("Initial seed failed: %v", err)
+			}
+
+			if countRecords(t, handler.db, "tasks") == 0 {
+				t.Fatal("No tasks found after initial seed")
+			}
+			if countRecords(t, handler.db, "books") == 0 {
+				t.Fatal("No books found after initial seed")
+			}
+
+			err = handler.Seed(ctx, true)
+			if err != nil {
+				t.Fatalf("Force seed failed: %v", err)
+			}
+
+			taskCount := countRecords(t, handler.db, "tasks")
+			bookCount := countRecords(t, handler.db, "books")
+
+			if taskCount != 5 {
+				t.Errorf("Expected exactly 5 tasks after force seed, got %d", taskCount)
+			}
+			if bookCount != 5 {
+				t.Errorf("Expected exactly 5 books after force seed, got %d", bookCount)
+			}
+
+			_, _, _, _ = getTaskRecord(t, handler.db, 1) // Should not error
+			_, _, _, _ = getBookRecord(t, handler.db, 1) // Should not error
+		})
+	})
+
+	t.Run("Close", func(t *testing.T) {
+		testHandler, err := NewSeedHandler()
+		if err != nil {
+			t.Fatalf("Failed to create test handler: %v", err)
+		}
+
+		if err = testHandler.Close(); err != nil {
+			t.Errorf("Close should succeed: %v", err)
+		}
+	})
+}

internal/handlers/tasks.go

···
 import (
 	"context"
 	"fmt"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
···
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
 	"github.com/stormlightlabs/noteleaf/internal/store"
+	"github.com/stormlightlabs/noteleaf/internal/ui"
 )
 
 // TaskHandler handles all task-related commands
···
 	}
 
 	description := strings.Join(args, " ")
-	
+
 	task := &models.Task{
 		UUID:        uuid.New().String(),
 		Description: description,
···
 }
 
 // ListTasks lists all tasks with optional filtering
-func ListTasks(ctx context.Context, args []string) error {
+func ListTasks(ctx context.Context, static, showAll bool, status, priority, project string) error {
 	handler, err := NewTaskHandler()
 	if err != nil {
 		return fmt.Errorf("failed to initialize task handler: %w", err)
 	}
 	defer handler.Close()
 
-	return handler.listTasks(ctx, args)
+	if static {
+		return handler.listTasksStatic(ctx, showAll, status, priority, project)
+	}
+
+	return handler.listTasksInteractive(ctx, showAll, status, priority, project)
 }
 
-func (h *TaskHandler) listTasks(ctx context.Context, args []string) error {
-	opts := repo.TaskListOptions{}
-	
-	// Parse arguments for filtering
-	for i, arg := range args {
-		switch {
-		case arg == "--status" && i+1 < len(args):
-			opts.Status = args[i+1]
-		case arg == "--priority" && i+1 < len(args):
-			opts.Priority = args[i+1]
-		case arg == "--project" && i+1 < len(args):
-			opts.Project = args[i+1]
-		case arg == "--search" && i+1 < len(args):
-			opts.Search = args[i+1]
-		case arg == "--limit" && i+1 < len(args):
-			if limit, err := strconv.Atoi(args[i+1]); err == nil {
-				opts.Limit = limit
-			}
-		}
+func (h *TaskHandler) listTasksStatic(ctx context.Context, showAll bool, status, priority, project string) error {
+	opts := repo.TaskListOptions{
+		Status:   status,
+		Priority: priority,
+		Project:  project,
 	}
 
-	// Default to showing pending tasks only
-	if opts.Status == "" {
+	// Default to showing pending tasks only unless --all is specified
+	if !showAll && opts.Status == "" {
 		opts.Status = "pending"
 	}
 
···
 	return nil
 }
 
+func (h *TaskHandler) listTasksInteractive(ctx context.Context, showAll bool, status, priority, project string) error {
+	taskList := ui.NewTaskList(h.repos.Tasks, ui.TaskListOptions{
+		ShowAll:  showAll,
+		Status:   status,
+		Priority: priority,
+		Project:  project,
+		Static:   false,
+	})
+
+	return taskList.Browse(ctx)
+}
+
 // UpdateTask updates an existing task
 func UpdateTask(ctx context.Context, args []string) error {
 	handler, err := NewTaskHandler()
···
 			i++
 		case strings.HasPrefix(arg, "--add-tag="):
 			tag := strings.TrimPrefix(arg, "--add-tag=")
-			if !contains(task.Tags, tag) {
+			if !slices.Contains(task.Tags, tag) {
 				task.Tags = append(task.Tags, tag)
 			}
 		case strings.HasPrefix(arg, "--remove-tag="):
···
 	var err error
 
 	if id, parseErr := strconv.ParseInt(taskID, 10, 64); parseErr == nil {
-		// Get task first to show what's being deleted
 		task, err = h.repos.Tasks.Get(ctx, id)
 		if err != nil {
 			return fmt.Errorf("failed to find task: %w", err)
 		}
-		
+
 		err = h.repos.Tasks.Delete(ctx, id)
 	} else {
-		// Get by UUID first
 		task, err = h.repos.Tasks.GetByUUID(ctx, taskID)
 		if err != nil {
 			return fmt.Errorf("failed to find task: %w", err)
 		}
-		
+
 		err = h.repos.Tasks.Delete(ctx, task.ID)
 	}
 
···
 	return nil
 }
 
-// Helper functions
 func (h *TaskHandler) printTask(task *models.Task) {
 	fmt.Printf("[%d] %s", task.ID, task.Description)
-	
+
 	if task.Status != "pending" {
 		fmt.Printf(" (%s)", task.Status)
 	}
-	
+
 	if task.Priority != "" {
 		fmt.Printf(" [%s]", task.Priority)
 	}
-	
+
 	if task.Project != "" {
 		fmt.Printf(" +%s", task.Project)
 	}
-	
+
 	if len(task.Tags) > 0 {
 		fmt.Printf(" @%s", strings.Join(task.Tags, " @"))
 	}
-	
+
 	if task.Due != nil {
 		fmt.Printf(" (due: %s)", task.Due.Format("2006-01-02"))
 	}
-	
+
 	fmt.Println()
 }
 
···
 	fmt.Printf("UUID: %s\n", task.UUID)
 	fmt.Printf("Description: %s\n", task.Description)
 	fmt.Printf("Status: %s\n", task.Status)
-	
+
 	if task.Priority != "" {
 		fmt.Printf("Priority: %s\n", task.Priority)
 	}
-	
+
 	if task.Project != "" {
 		fmt.Printf("Project: %s\n", task.Project)
 	}
-	
+
 	if len(task.Tags) > 0 {
 		fmt.Printf("Tags: %s\n", strings.Join(task.Tags, ", "))
 	}
-	
+
 	if task.Due != nil {
 		fmt.Printf("Due: %s\n", task.Due.Format("2006-01-02 15:04"))
 	}
-	
+
 	fmt.Printf("Created: %s\n", task.Entry.Format("2006-01-02 15:04"))
 	fmt.Printf("Modified: %s\n", task.Modified.Format("2006-01-02 15:04"))
-	
+
 	if task.Start != nil {
 		fmt.Printf("Started: %s\n", task.Start.Format("2006-01-02 15:04"))
 	}
-	
+
 	if task.End != nil {
 		fmt.Printf("Completed: %s\n", task.End.Format("2006-01-02 15:04"))
 	}
-	
+
 	if len(task.Annotations) > 0 {
 		fmt.Printf("Annotations:\n")
 		for _, annotation := range task.Annotations {
···
 	}
 }
 
-func contains(slice []string, item string) bool {
-	for _, s := range slice {
-		if s == item {
-			return true
-		}
-	}
-	return false
-}
-
 func removeString(slice []string, item string) []string {
 	var result []string
 	for _, s := range slice {
···
 		}
 	}
 	return result
-}
+}

internal/handlers/tasks_test.go

···
 	"context"
 	"os"
 	"runtime"
+	"slices"
 	"strconv"
 	"strings"
 	"testing"
···
 			t.Fatalf("Failed to create task2: %v", err)
 		}
 
-		t.Run("lists pending tasks by default", func(t *testing.T) {
-			args := []string{}
-
-			err := ListTasks(ctx, args)
+		t.Run("lists pending tasks by default (static mode)", func(t *testing.T) {
+			err := ListTasks(ctx, true, false, "", "", "")
 			if err != nil {
 				t.Errorf("ListTasks failed: %v", err)
 			}
 		})
 
-		t.Run("filters by status", func(t *testing.T) {
-			args := []string{"--status", "completed"}
-
-			err := ListTasks(ctx, args)
+		t.Run("filters by status (static mode)", func(t *testing.T) {
+			err := ListTasks(ctx, true, false, "completed", "", "")
 			if err != nil {
 				t.Errorf("ListTasks with status filter failed: %v", err)
 			}
 		})
 
-		t.Run("filters by priority", func(t *testing.T) {
-			args := []string{"--priority", "A"}
-
-			err := ListTasks(ctx, args)
+		t.Run("filters by priority (static mode)", func(t *testing.T) {
+			err := ListTasks(ctx, true, false, "", "A", "")
 			if err != nil {
 				t.Errorf("ListTasks with priority filter failed: %v", err)
 			}
 		})
 
-		t.Run("filters by project", func(t *testing.T) {
-			args := []string{"--project", "work"}
-
-			err := ListTasks(ctx, args)
+		t.Run("filters by project (static mode)", func(t *testing.T) {
+			err := ListTasks(ctx, true, false, "", "", "work")
 			if err != nil {
 				t.Errorf("ListTasks with project filter failed: %v", err)
 			}
 		})
 
-		t.Run("searches tasks", func(t *testing.T) {
-			args := []string{"--search", "Task"}
-
-			err := ListTasks(ctx, args)
-			if err != nil {
-				t.Errorf("ListTasks with search failed: %v", err)
-			}
-		})
-
-		t.Run("limits results", func(t *testing.T) {
-			args := []string{"--limit", "1"}
-
-			err := ListTasks(ctx, args)
+		t.Run("show all tasks (static mode)", func(t *testing.T) {
+			err := ListTasks(ctx, true, true, "", "", "")
 			if err != nil {
-				t.Errorf("ListTasks with limit failed: %v", err)
+				t.Errorf("ListTasks with show all failed: %v", err)
 			}
 		})
 	})
···
 	})
 
 	t.Run("Helper", func(t *testing.T) {
-		t.Run("contains function", func(t *testing.T) {
-			slice := []string{"a", "b", "c"}
-
-			if !contains(slice, "b") {
-				t.Error("Expected contains to return true for existing item")
-			}
-
-			if contains(slice, "d") {
-				t.Error("Expected contains to return false for non-existing item")
-			}
-		})
 
 		t.Run("removeString function", func(t *testing.T) {
 			slice := []string{"a", "b", "c", "b"}
···
 				t.Errorf("Expected 2 items after removing 'b', got %d", len(result))
 			}
 
-			if contains(result, "b") {
+			if slices.Contains(result, "b") {
 				t.Error("Expected 'b' to be removed from slice")
 			}
 
-			if !contains(result, "a") || !contains(result, "c") {
+			if !slices.Contains(result, "a") || !slices.Contains(result, "c") {
 				t.Error("Expected 'a' and 'c' to remain in slice")
 			}
 		})

internal/ui/task_list.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// TaskRepository interface for dependency injection in tests
+type TaskRepository interface {
+	List(ctx context.Context, opts repo.TaskListOptions) ([]*models.Task, error)
+	Update(ctx context.Context, task *models.Task) error
+}
+
+// TaskListOptions configures the task list UI behavior
+type TaskListOptions 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
+	Status   string
+	Priority string
+	Project  string
+	ShowAll  bool
+}
+
+// TaskList handles task browsing and viewing UI
+type TaskList struct {
+	repo TaskRepository
+	opts TaskListOptions
+}
+
+// NewTaskList creates a new task list UI component
+func NewTaskList(repo TaskRepository, opts TaskListOptions) *TaskList {
+	if opts.Output == nil {
+		opts.Output = os.Stdout
+	}
+	if opts.Input == nil {
+		opts.Input = os.Stdin
+	}
+	return &TaskList{repo: repo, opts: opts}
+}
+
+type taskListModel struct {
+	tasks       []*models.Task
+	selected    int
+	viewing     bool
+	viewContent string
+	err         error
+	repo        TaskRepository
+	opts        TaskListOptions
+	showAll     bool
+	// filter      string
+}
+
+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.viewing {
+			switch msg.String() {
+			case "q", "esc", "backspace":
+				m.viewing = false
+				m.viewContent = ""
+				return m, nil
+			}
+			return m, nil
+		}
+
+		switch msg.String() {
+		case "ctrl+c", "q":
+			return m, tea.Quit
+		case "up", "k":
+			if m.selected > 0 {
+				m.selected--
+			}
+		case "down", "j":
+			if m.selected < len(m.tasks)-1 {
+				m.selected++
+			}
+		case "enter", "v":
+			if len(m.tasks) > 0 && m.selected < len(m.tasks) {
+				return m, m.viewTask(m.tasks[m.selected])
+			}
+		case "r":
+			return m, m.loadTasks()
+		case "a":
+			m.showAll = !m.showAll
+			return m, m.loadTasks()
+		case "d":
+			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 tasksLoadedMsg:
+		m.tasks = []*models.Task(msg)
+		if m.selected >= len(m.tasks) && len(m.tasks) > 0 {
+			m.selected = len(m.tasks) - 1
+		}
+	case taskViewMsg:
+		m.viewContent = string(msg)
+		m.viewing = true
+	case errorTaskMsg:
+		m.err = error(msg)
+	}
+	return m, nil
+}
+
+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"))
+
+	if m.viewing {
+		s.WriteString(m.viewContent)
+		s.WriteString("\n\n")
+		s.WriteString(style.Render("Press q/esc/backspace to return to list"))
+		return s.String()
+	}
+
+	s.WriteString(titleStyle.Render("Tasks"))
+	if m.showAll {
+		s.WriteString(" (showing all)")
+	} else {
+		s.WriteString(" (pending only)")
+	}
+	s.WriteString("\n\n")
+
+	if m.err != nil {
+		s.WriteString(fmt.Sprintf("Error: %s", m.err))
+		return s.String()
+	}
+
+	if len(m.tasks) == 0 {
+		s.WriteString("No tasks found")
+		s.WriteString("\n\n")
+		s.WriteString(style.Render("Press r to refresh, q to quit"))
+		return s.String()
+	}
+
+	headerLine := fmt.Sprintf("%-3s %-4s %-40s %-10s %-10s %-15s", "", "ID", "Description", "Status", "Priority", "Project")
+	s.WriteString(headerStyle.Render(headerLine))
+	s.WriteString("\n")
+	s.WriteString(headerStyle.Render(strings.Repeat("─", 80)))
+	s.WriteString("\n")
+
+	for i, task := range m.tasks {
+		prefix := "   "
+		if i == m.selected {
+			prefix = " > "
+		}
+
+		description := task.Description
+		if len(description) > 38 {
+			description = description[:35] + "..."
+		}
+
+		status := task.Status
+		if len(status) > 8 {
+			status = status[:8]
+		}
+
+		priority := task.Priority
+		if priority == "" {
+			priority = "-"
+		}
+		if len(priority) > 8 {
+			priority = priority[:8]
+		}
+
+		project := task.Project
+		if project == "" {
+			project = "-"
+		}
+		if len(project) > 13 {
+			project = project[:10] + "..."
+		}
+
+		line := fmt.Sprintf("%s%-4d %-40s %-10s %-10s %-15s",
+			prefix, task.ID, description, status, priority, project)
+
+		if i == m.selected {
+			s.WriteString(selectedStyle.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))
+				}
+			}
+		}
+
+		// Add tags if any
+		if len(task.Tags) > 0 && i == m.selected {
+			s.WriteString(" @" + strings.Join(task.Tags, " @"))
+		}
+
+		s.WriteString("\n")
+	}
+
+	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"))
+
+	return s.String()
+}
+
+func (m taskListModel) loadTasks() tea.Cmd {
+	return func() tea.Msg {
+		opts := repo.TaskListOptions{}
+
+		// Set status filter
+		if m.showAll || m.opts.ShowAll {
+			// Show all tasks - no status filter
+		} else {
+			opts.Status = "pending"
+		}
+
+		// Apply other filters from options
+		if m.opts.Status != "" {
+			opts.Status = m.opts.Status
+		}
+		if m.opts.Priority != "" {
+			opts.Priority = m.opts.Priority
+		}
+		if m.opts.Project != "" {
+			opts.Project = m.opts.Project
+		}
+
+		opts.SortBy = "modified"
+		opts.SortOrder = "DESC"
+		opts.Limit = 50
+
+		tasks, err := m.repo.List(context.Background(), opts)
+		if err != nil {
+			return errorTaskMsg(err)
+		}
+
+		return tasksLoadedMsg(tasks)
+	}
+}
+
+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))
+		content.WriteString(fmt.Sprintf("**Status:** %s\n", task.Status))
+
+		if task.Priority != "" {
+			content.WriteString(fmt.Sprintf("**Priority:** %s\n", 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, ", ")))
+		}
+
+		if task.Due != nil {
+			content.WriteString(fmt.Sprintf("**Due:** %s\n", task.Due.Format("2006-01-02 15:04")))
+		}
+
+		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.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("\n**Annotations:**\n")
+			for _, annotation := range task.Annotations {
+				content.WriteString(fmt.Sprintf("- %s\n", annotation))
+			}
+		}
+
+		return taskViewMsg(content.String())
+	}
+}
+
+func (m taskListModel) markDone(task *models.Task) tea.Cmd {
+	return func() tea.Msg {
+		if task.Status == "completed" {
+			return errorTaskMsg(fmt.Errorf("task already completed"))
+		}
+
+		task.Status = "completed"
+		err := m.repo.Update(context.Background(), task)
+		if err != nil {
+			return errorTaskMsg(fmt.Errorf("failed to mark task done: %w", err))
+		}
+
+		// Reload tasks after marking done
+		return m.loadTasks()()
+	}
+}
+
+// Browse opens an interactive TUI for navigating and viewing tasks
+func (tl *TaskList) Browse(ctx context.Context) error {
+	if tl.opts.Static {
+		return tl.staticList(ctx)
+	}
+
+	model := taskListModel{
+		repo:    tl.repo,
+		opts:    tl.opts,
+		showAll: tl.opts.ShowAll,
+	}
+
+	program := tea.NewProgram(model, tea.WithInput(tl.opts.Input), tea.WithOutput(tl.opts.Output))
+
+	_, err := program.Run()
+	return err
+}
+
+func (tl *TaskList) staticList(ctx context.Context) error {
+	opts := repo.TaskListOptions{}
+
+	if tl.opts.ShowAll {
+		// Show all tasks - no status filter
+	} else {
+		opts.Status = "pending"
+	}
+
+	if tl.opts.Status != "" {
+		opts.Status = tl.opts.Status
+	}
+	if tl.opts.Priority != "" {
+		opts.Priority = tl.opts.Priority
+	}
+	if tl.opts.Project != "" {
+		opts.Project = tl.opts.Project
+	}
+
+	opts.SortBy = "modified"
+	opts.SortOrder = "DESC"
+
+	tasks, err := tl.repo.List(ctx, opts)
+	if err != nil {
+		fmt.Fprintf(tl.opts.Output, "Error: %s\n", err)
+		return err
+	}
+
+	fmt.Fprintf(tl.opts.Output, "Tasks")
+	if tl.opts.ShowAll {
+		fmt.Fprintf(tl.opts.Output, " (showing all)")
+	} else {
+		fmt.Fprintf(tl.opts.Output, " (pending only)")
+	}
+	fmt.Fprintf(tl.opts.Output, "\n\n")
+
+	if len(tasks) == 0 {
+		fmt.Fprintf(tl.opts.Output, "No tasks found\n")
+		return nil
+	}
+
+	fmt.Fprintf(tl.opts.Output, "%-4s %-40s %-10s %-10s %-15s\n", "ID", "Description", "Status", "Priority", "Project")
+	fmt.Fprintf(tl.opts.Output, "%s\n", strings.Repeat("─", 80))
+
+	for _, task := range tasks {
+		description := task.Description
+		if len(description) > 38 {
+			description = description[:35] + "..."
+		}
+
+		status := task.Status
+		if len(status) > 8 {
+			status = status[:8]
+		}
+
+		priority := task.Priority
+		if priority == "" {
+			priority = "-"
+		}
+		if len(priority) > 8 {
+			priority = priority[:8]
+		}
+
+		project := task.Project
+		if project == "" {
+			project = "-"
+		}
+		if len(project) > 13 {
+			project = project[:10] + "..."
+		}
+
+		fmt.Fprintf(tl.opts.Output, "%-4d %-40s %-10s %-10s %-15s", task.ID, description, status, priority, project)
+
+		if len(task.Tags) > 0 {
+			fmt.Fprintf(tl.opts.Output, " @%s", strings.Join(task.Tags, " @"))
+		}
+
+		fmt.Fprintf(tl.opts.Output, "\n")
+	}
+
+	return nil
+}

internal/ui/task_list_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// MockTaskRepository implements TaskRepository interface for testing
+type MockTaskRepository struct {
+	tasks       []*models.Task
+	listError   error
+	updateError error
+}
+
+func (m *MockTaskRepository) List(ctx context.Context, opts repo.TaskListOptions) ([]*models.Task, error) {
+	if m.listError != nil {
+		return nil, m.listError
+	}
+
+	var filteredTasks []*models.Task
+	for _, task := range m.tasks {
+		// Apply filters
+		if opts.Status != "" && task.Status != opts.Status {
+			continue
+		}
+		if opts.Priority != "" && task.Priority != opts.Priority {
+			continue
+		}
+		if opts.Project != "" && task.Project != opts.Project {
+			continue
+		}
+		if opts.Search != "" && !strings.Contains(strings.ToLower(task.Description), strings.ToLower(opts.Search)) {
+			continue
+		}
+		filteredTasks = append(filteredTasks, task)
+	}
+
+	// Apply limit
+	if opts.Limit > 0 && len(filteredTasks) > opts.Limit {
+		filteredTasks = filteredTasks[:opts.Limit]
+	}
+
+	return filteredTasks, nil
+}
+
+func (m *MockTaskRepository) Update(ctx context.Context, task *models.Task) error {
+	if m.updateError != nil {
+		return m.updateError
+	}
+	// Update the task in our mock data
+	for i, t := range m.tasks {
+		if t.ID == task.ID {
+			m.tasks[i] = task
+			break
+		}
+	}
+	return nil
+}
+
+// Create mock tasks for testing
+func createMockTasks() []*models.Task {
+	now := time.Now()
+	return []*models.Task{
+		{
+			ID:          1,
+			UUID:        "uuid-1",
+			Description: "Review quarterly report",
+			Status:      "pending",
+			Priority:    "high",
+			Project:     "work",
+			Tags:        []string{"urgent", "business"},
+			Entry:       now.Add(-24 * time.Hour),
+			Modified:    now.Add(-12 * time.Hour),
+		},
+		{
+			ID:          2,
+			UUID:        "uuid-2",
+			Description: "Plan vacation itinerary",
+			Status:      "pending",
+			Priority:    "medium",
+			Project:     "personal",
+			Tags:        []string{"travel"},
+			Entry:       now.Add(-48 * time.Hour),
+			Modified:    now.Add(-6 * time.Hour),
+		},
+		{
+			ID:          3,
+			UUID:        "uuid-3",
+			Description: "Fix authentication bug",
+			Status:      "completed",
+			Priority:    "high",
+			Project:     "development",
+			Tags:        []string{"bug", "security"},
+			Entry:       now.Add(-72 * time.Hour),
+			Modified:    now.Add(-1 * time.Hour),
+			End:         &now,
+		},
+		{
+			ID:          4,
+			UUID:        "uuid-4",
+			Description: "Read Clean Code book",
+			Status:      "pending",
+			Priority:    "low",
+			Project:     "learning",
+			Tags:        []string{"books", "development"},
+			Entry:       now.Add(-96 * time.Hour),
+			Modified:    now.Add(-3 * time.Hour),
+		},
+	}
+}
+
+func TestTaskListOptions(t *testing.T) {
+	t.Run("default options", func(t *testing.T) {
+		opts := TaskListOptions{}
+		if opts.Static {
+			t.Error("Static should default to false")
+		}
+		if opts.ShowAll {
+			t.Error("ShowAll should default to false")
+		}
+	})
+
+	t.Run("custom options", func(t *testing.T) {
+		var buf bytes.Buffer
+		opts := TaskListOptions{
+			Output:   &buf,
+			Static:   true,
+			ShowAll:  true,
+			Status:   "pending",
+			Priority: "high",
+			Project:  "work",
+		}
+
+		if !opts.Static {
+			t.Error("Static should be enabled")
+		}
+		if !opts.ShowAll {
+			t.Error("ShowAll should be enabled")
+		}
+		if opts.Output != &buf {
+			t.Error("Output should be set to buffer")
+		}
+		if opts.Status != "pending" {
+			t.Error("Status filter not set correctly")
+		}
+		if opts.Priority != "high" {
+			t.Error("Priority filter not set correctly")
+		}
+		if opts.Project != "work" {
+			t.Error("Project filter not set correctly")
+		}
+	})
+}
+
+func TestNewTaskList(t *testing.T) {
+	repo := &MockTaskRepository{tasks: createMockTasks()}
+
+	t.Run("with default options", func(t *testing.T) {
+		tl := NewTaskList(repo, TaskListOptions{})
+		if tl == nil {
+			t.Fatal("NewTaskList returned nil")
+		}
+		if tl.repo != repo {
+			t.Error("Repository not set correctly")
+		}
+		if tl.opts.Output == nil {
+			t.Error("Output should default to os.Stdout")
+		}
+		if tl.opts.Input == nil {
+			t.Error("Input should default to os.Stdin")
+		}
+	})
+
+	t.Run("with custom options", func(t *testing.T) {
+		var buf bytes.Buffer
+		opts := TaskListOptions{
+			Output:   &buf,
+			Static:   true,
+			ShowAll:  true,
+			Priority: "high",
+		}
+		tl := NewTaskList(repo, opts)
+		if tl.opts.Output != &buf {
+			t.Error("Custom output not set")
+		}
+		if !tl.opts.Static {
+			t.Error("Static mode not set")
+		}
+		if tl.opts.Priority != "high" {
+			t.Error("Priority filter not set")
+		}
+	})
+}
+
+func TestTaskListStaticMode(t *testing.T) {
+	t.Run("successful static list", func(t *testing.T) {
+		repo := &MockTaskRepository{tasks: createMockTasks()}
+		var buf bytes.Buffer
+
+		tl := NewTaskList(repo, TaskListOptions{
+			Output: &buf,
+			Static: true,
+		})
+
+		err := tl.Browse(context.Background())
+		if err != nil {
+			t.Fatalf("Browse failed: %v", err)
+		}
+
+		output := buf.String()
+		if !strings.Contains(output, "Tasks (pending only)") {
+			t.Error("Title not displayed correctly")
+		}
+		if !strings.Contains(output, "Review quarterly report") {
+			t.Error("First task not displayed")
+		}
+		if !strings.Contains(output, "Plan vacation itinerary") {
+			t.Error("Second task not displayed")
+		}
+		// Should not show completed task by default
+		if strings.Contains(output, "Fix authentication bug") {
+			t.Error("Completed task should not be shown by default")
+		}
+	})
+
+	t.Run("static list with all tasks", func(t *testing.T) {
+		repo := &MockTaskRepository{tasks: createMockTasks()}
+		var buf bytes.Buffer
+
+		tl := NewTaskList(repo, TaskListOptions{
+			Output:  &buf,
+			Static:  true,
+			ShowAll: true,
+		})
+
+		err := tl.Browse(context.Background())
+		if err != nil {
+			t.Fatalf("Browse failed: %v", err)
+		}
+
+		output := buf.String()
+		if !strings.Contains(output, "Tasks (showing all)") {
+			t.Error("All tasks title not displayed correctly")
+		}
+		if !strings.Contains(output, "Fix authentication bug") {
+			t.Error("Completed task should be shown with --all")
+		}
+	})
+
+	t.Run("static list with filters", func(t *testing.T) {
+		repo := &MockTaskRepository{tasks: createMockTasks()}
+		var buf bytes.Buffer
+
+		tl := NewTaskList(repo, TaskListOptions{
+			Output:   &buf,
+			Static:   true,
+			ShowAll:  true,
+			Priority: "high",
+		})
+
+		err := tl.Browse(context.Background())
+		if err != nil {
+			t.Fatalf("Browse failed: %v", err)
+		}
+
+		output := buf.String()
+		if !strings.Contains(output, "Review quarterly report") {
+			t.Error("High priority task not displayed")
+		}
+		if !strings.Contains(output, "Fix authentication bug") {
+			t.Error("High priority completed task not displayed")
+		}
+		if strings.Contains(output, "Plan vacation itinerary") {
+			t.Error("Medium priority task should not be displayed")
+		}
+	})
+
+	t.Run("static list with no results", func(t *testing.T) {
+		repo := &MockTaskRepository{tasks: []*models.Task{}}
+		var buf bytes.Buffer
+
+		tl := NewTaskList(repo, TaskListOptions{
+			Output: &buf,
+			Static: true,
+		})
+
+		err := tl.Browse(context.Background())
+		if err != nil {
+			t.Fatalf("Browse failed: %v", err)
+		}
+
+		output := buf.String()
+		if !strings.Contains(output, "No tasks found") {
+			t.Error("No tasks message not displayed")
+		}
+	})
+
+	t.Run("static list with repository error", func(t *testing.T) {
+		repo := &MockTaskRepository{
+			listError: errors.New("database error"),
+		}
+		var buf bytes.Buffer
+
+		tl := NewTaskList(repo, TaskListOptions{
+			Output: &buf,
+			Static: true,
+		})
+
+		err := tl.Browse(context.Background())
+		if err == nil {
+			t.Fatal("Expected error, got nil")
+		}
+
+		output := buf.String()
+		if !strings.Contains(output, "Error: database error") {
+			t.Error("Error message not displayed")
+		}
+	})
+}
+
+func TestTaskListModel(t *testing.T) {
+	repo := &MockTaskRepository{tasks: createMockTasks()}
+
+	t.Run("initial model state", func(t *testing.T) {
+		model := taskListModel{
+			opts: TaskListOptions{ShowAll: false},
+		}
+
+		if model.selected != 0 {
+			t.Error("Initial selected should be 0")
+		}
+		if model.viewing {
+			t.Error("Initial viewing should be false")
+		}
+		if model.showAll {
+			t.Error("Initial showAll should be false")
+		}
+	})
+
+	t.Run("load tasks command", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{ShowAll: false},
+		}
+
+		cmd := model.loadTasks()
+		if cmd == nil {
+			t.Fatal("loadTasks should return a command")
+		}
+
+		msg := cmd()
+		switch msg := msg.(type) {
+		case tasksLoadedMsg:
+			tasks := []*models.Task(msg)
+			if len(tasks) != 3 { // Only pending tasks
+				t.Errorf("Expected 3 pending tasks, got %d", len(tasks))
+			}
+		case errorTaskMsg:
+			t.Fatalf("Unexpected error: %v", error(msg))
+		default:
+			t.Fatalf("Unexpected message type: %T", msg)
+		}
+	})
+
+	t.Run("load all tasks", func(t *testing.T) {
+		model := taskListModel{
+			repo:    repo,
+			opts:    TaskListOptions{ShowAll: true},
+			showAll: true,
+		}
+
+		cmd := model.loadTasks()
+		msg := cmd()
+
+		switch msg := msg.(type) {
+		case tasksLoadedMsg:
+			tasks := []*models.Task(msg)
+			if len(tasks) != 4 { // All tasks
+				t.Errorf("Expected 4 tasks, got %d", len(tasks))
+			}
+		case errorTaskMsg:
+			t.Fatalf("Unexpected error: %v", error(msg))
+		}
+	})
+
+	t.Run("view task command", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		task := createMockTasks()[0]
+		cmd := model.viewTask(task)
+		if cmd == nil {
+			t.Fatal("viewTask should return a command")
+		}
+
+		msg := cmd()
+		switch msg := msg.(type) {
+		case taskViewMsg:
+			content := string(msg)
+			if !strings.Contains(content, "# Task 1") {
+				t.Error("Task title not in view content")
+			}
+			if !strings.Contains(content, "Review quarterly report") {
+				t.Error("Task description not in view content")
+			}
+			if !strings.Contains(content, "**Status:** pending") {
+				t.Error("Task status not in view content")
+			}
+			if !strings.Contains(content, "**Priority:** high") {
+				t.Error("Task priority not in view content")
+			}
+		default:
+			t.Fatalf("Unexpected message type: %T", msg)
+		}
+	})
+
+	t.Run("mark done command", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		task := createMockTasks()[0] // Pending task
+		cmd := model.markDone(task)
+		if cmd == nil {
+			t.Fatal("markDone should return a command")
+		}
+
+		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)
+			}
+		default:
+			t.Fatalf("Unexpected message type: %T", msg)
+		}
+	})
+
+	t.Run("mark done already completed task", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		task := createMockTasks()[2] // Already completed task
+		cmd := model.markDone(task)
+		msg := cmd()
+
+		switch msg := msg.(type) {
+		case errorTaskMsg:
+			err := error(msg)
+			if !strings.Contains(err.Error(), "already completed") {
+				t.Errorf("Expected 'already completed' error, got: %v", err)
+			}
+		default:
+			t.Fatalf("Expected errorTaskMsg for already completed task, got: %T", msg)
+		}
+	})
+}
+
+func TestTaskListModelKeyHandling(t *testing.T) {
+	repo := &MockTaskRepository{tasks: createMockTasks()}
+
+	t.Run("quit commands", func(t *testing.T) {
+		model := taskListModel{
+			repo:  repo,
+			tasks: createMockTasks()[:2], // First 2 tasks
+			opts:  TaskListOptions{},
+		}
+
+		quitKeys := []string{"ctrl+c", "q"}
+		for _, key := range quitKeys {
+			newModel, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
+			if cmd == nil {
+				t.Errorf("Key %s should return quit command", key)
+			}
+			_ = newModel // Model should be returned
+		}
+	})
+
+	t.Run("navigation keys", func(t *testing.T) {
+		model := taskListModel{
+			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
+			newModel, _ := testModel.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
+			if m, ok := newModel.(taskListModel); ok {
+				if m.selected != 0 {
+					t.Errorf("Key %s should move selection up to 0, got %d", key, m.selected)
+				}
+			}
+		}
+
+		// Test down navigation
+		downKeys := []string{"down", "j"}
+		for _, key := range downKeys {
+			testModel := model
+			newModel, _ := testModel.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
+			if m, ok := newModel.(taskListModel); ok {
+				if m.selected != 2 {
+					t.Errorf("Key %s should move selection down to 2, got %d", key, m.selected)
+				}
+			}
+		}
+	})
+
+	t.Run("view task keys", func(t *testing.T) {
+		model := taskListModel{
+			repo:     repo,
+			tasks:    createMockTasks()[:2],
+			selected: 0,
+			opts:     TaskListOptions{},
+		}
+
+		viewKeys := []string{"enter", "v"}
+		for _, key := range viewKeys {
+			testModel := model
+			_, cmd := testModel.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
+			if cmd == nil {
+				t.Errorf("Key %s should return view command", key)
+			}
+		}
+	})
+
+	t.Run("number shortcuts", func(t *testing.T) {
+		model := taskListModel{
+			repo:  repo,
+			tasks: createMockTasks()[:4],
+			opts:  TaskListOptions{},
+		}
+
+		for i := 1; i <= 4; i++ {
+			testModel := model
+			key := fmt.Sprintf("%d", i)
+			newModel, _ := testModel.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
+			if m, ok := newModel.(taskListModel); ok {
+				expectedIndex := i - 1
+				if m.selected != expectedIndex {
+					t.Errorf("Number key %s should select index %d, got %d", key, expectedIndex, m.selected)
+				}
+			}
+		}
+	})
+
+	t.Run("toggle all/pending", func(t *testing.T) {
+		model := taskListModel{
+			repo:    repo,
+			tasks:   createMockTasks()[:2],
+			showAll: false,
+			opts:    TaskListOptions{},
+		}
+
+		newModel, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("a")})
+		if m, ok := newModel.(taskListModel); ok {
+			if !m.showAll {
+				t.Error("Key 'a' should toggle showAll to true")
+			}
+		}
+		if cmd == nil {
+			t.Error("Toggle all should trigger task reload")
+		}
+	})
+
+	t.Run("mark done key", func(t *testing.T) {
+		model := taskListModel{
+			repo:     repo,
+			tasks:    createMockTasks()[:2],
+			selected: 0,
+			opts:     TaskListOptions{},
+		}
+
+		_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("d")})
+		if cmd == nil {
+			t.Error("Key 'd' should return mark done command")
+		}
+	})
+
+	t.Run("refresh key", func(t *testing.T) {
+		model := taskListModel{
+			repo:  repo,
+			tasks: createMockTasks()[:2],
+			opts:  TaskListOptions{},
+		}
+
+		_, cmd := model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("r")})
+		if cmd == nil {
+			t.Error("Key 'r' should return refresh command")
+		}
+	})
+
+	t.Run("viewing mode navigation", func(t *testing.T) {
+		model := taskListModel{
+			repo:        repo,
+			tasks:       createMockTasks()[:2],
+			viewing:     true,
+			viewContent: "Test content",
+			opts:        TaskListOptions{},
+		}
+
+		exitKeys := []string{"q", "esc", "backspace"}
+		for _, key := range exitKeys {
+			testModel := model
+			newModel, _ := testModel.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(key)})
+			if m, ok := newModel.(taskListModel); ok {
+				if m.viewing {
+					t.Errorf("Key %s should exit viewing mode", key)
+				}
+				if m.viewContent != "" {
+					t.Errorf("Key %s should clear view content", key)
+				}
+			}
+		}
+	})
+}
+
+func TestTaskListModelView(t *testing.T) {
+	repo := &MockTaskRepository{tasks: createMockTasks()}
+
+	t.Run("viewing mode", func(t *testing.T) {
+		model := taskListModel{
+			repo:        repo,
+			viewing:     true,
+			viewContent: "# Task Details\nTest content here",
+			opts:        TaskListOptions{},
+		}
+
+		view := model.View()
+		if !strings.Contains(view, "# Task Details") {
+			t.Error("View content not displayed in viewing mode")
+		}
+		if !strings.Contains(view, "Press q/esc/backspace to return to list") {
+			t.Error("Return instructions not displayed")
+		}
+	})
+
+	t.Run("error state", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			err:  errors.New("test error"),
+			opts: TaskListOptions{},
+		}
+
+		view := model.View()
+		if !strings.Contains(view, "Error: test error") {
+			t.Error("Error message not displayed")
+		}
+	})
+
+	t.Run("no tasks", func(t *testing.T) {
+		model := taskListModel{
+			repo:  repo,
+			tasks: []*models.Task{},
+			opts:  TaskListOptions{},
+		}
+
+		view := model.View()
+		if !strings.Contains(view, "No tasks found") {
+			t.Error("No tasks message not displayed")
+		}
+		if !strings.Contains(view, "Press r to refresh, q to quit") {
+			t.Error("Help text not displayed")
+		}
+	})
+
+	t.Run("with tasks", func(t *testing.T) {
+		tasks := createMockTasks()[:2] // First 2 tasks
+		model := taskListModel{
+			repo:     repo,
+			tasks:    tasks,
+			selected: 0,
+			showAll:  false,
+			opts:     TaskListOptions{},
+		}
+
+		view := model.View()
+		if !strings.Contains(view, "Tasks (pending only)") {
+			t.Error("Title not displayed correctly")
+		}
+		if !strings.Contains(view, "Review quarterly report") {
+			t.Error("First task not displayed")
+		}
+		if !strings.Contains(view, "Plan vacation itinerary") {
+			t.Error("Second task not displayed")
+		}
+		if !strings.Contains(view, "Controls:") {
+			t.Error("Control instructions not displayed")
+		}
+	})
+
+	t.Run("show all mode", func(t *testing.T) {
+		model := taskListModel{
+			repo:    repo,
+			tasks:   createMockTasks(),
+			showAll: true,
+			opts:    TaskListOptions{ShowAll: true},
+		}
+
+		view := model.View()
+		if !strings.Contains(view, "Tasks (showing all)") {
+			t.Error("Show all title not displayed correctly")
+		}
+	})
+
+	t.Run("selected task highlighting", func(t *testing.T) {
+		tasks := createMockTasks()[:2]
+		model := taskListModel{
+			repo:     repo,
+			tasks:    tasks,
+			selected: 0,
+			opts:     TaskListOptions{},
+		}
+
+		view := model.View()
+		// The selected task should have a ">" prefix
+		if !strings.Contains(view, " > 1   ") {
+			t.Error("Selected task not highlighted with '>' prefix")
+		}
+	})
+}
+
+func TestTaskListModelUpdate(t *testing.T) {
+	repo := &MockTaskRepository{tasks: createMockTasks()}
+
+	t.Run("tasks loaded message", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		tasks := createMockTasks()[:2]
+		newModel, _ := model.Update(tasksLoadedMsg(tasks))
+
+		if m, ok := newModel.(taskListModel); ok {
+			if len(m.tasks) != 2 {
+				t.Errorf("Expected 2 tasks, got %d", len(m.tasks))
+			}
+			if m.tasks[0].Description != "Review quarterly report" {
+				t.Error("Tasks not loaded correctly")
+			}
+		}
+	})
+
+	t.Run("task view message", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		content := "# Task Details\nTest content"
+		newModel, _ := model.Update(taskViewMsg(content))
+
+		if m, ok := newModel.(taskListModel); ok {
+			if !m.viewing {
+				t.Error("Viewing mode not activated")
+			}
+			if m.viewContent != content {
+				t.Error("View content not set correctly")
+			}
+		}
+	})
+
+	t.Run("error message", func(t *testing.T) {
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		testErr := errors.New("test error")
+		newModel, _ := model.Update(errorTaskMsg(testErr))
+
+		if m, ok := newModel.(taskListModel); ok {
+			if m.err == nil {
+				t.Error("Error not set")
+			}
+			if m.err.Error() != "test error" {
+				t.Errorf("Expected 'test error', got %v", m.err)
+			}
+		}
+	})
+
+	t.Run("selected index bounds", func(t *testing.T) {
+		model := taskListModel{
+			repo:     repo,
+			tasks:    createMockTasks()[:2],
+			selected: 5, // Out of bounds
+			opts:     TaskListOptions{},
+		}
+
+		// Load fewer tasks
+		newTasks := createMockTasks()[:1]
+		newModel, _ := model.Update(tasksLoadedMsg(newTasks))
+
+		if m, ok := newModel.(taskListModel); ok {
+			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
+				t.Errorf("Expected selected to be 0, got %d", m.selected)
+			}
+		}
+	})
+}
+
+func TestTaskListRepositoryError(t *testing.T) {
+	t.Run("list error in loadTasks", func(t *testing.T) {
+		repo := &MockTaskRepository{
+			listError: errors.New("database connection failed"),
+		}
+
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		cmd := model.loadTasks()
+		msg := cmd()
+
+		switch msg := msg.(type) {
+		case errorTaskMsg:
+			err := error(msg)
+			if !strings.Contains(err.Error(), "database connection failed") {
+				t.Errorf("Expected database error, got: %v", err)
+			}
+		default:
+			t.Fatalf("Expected errorTaskMsg, got: %T", msg)
+		}
+	})
+
+	t.Run("update error in markDone", func(t *testing.T) {
+		repo := &MockTaskRepository{
+			tasks:       createMockTasks(),
+			updateError: errors.New("update failed"),
+		}
+
+		model := taskListModel{
+			repo: repo,
+			opts: TaskListOptions{},
+		}
+
+		task := createMockTasks()[0]
+		cmd := model.markDone(task)
+		msg := cmd()
+
+		switch msg := msg.(type) {
+		case errorTaskMsg:
+			err := error(msg)
+			if !strings.Contains(err.Error(), "failed to mark task done") {
+				t.Errorf("Expected mark done error, got: %v", err)
+			}
+		default:
+			t.Fatalf("Expected errorTaskMsg, got: %T", msg)
+		}
+	})
+}