feat: book handlers

cmd/cli/commands.go

···
 		Short: "Manage reading list",
 	}
 
+	// book add - Search and add book to reading list
+	addCmd := &cobra.Command{
+		Use:   "add [search query...]",
+		Short: "Search and add book to reading list",
+		Long: `Search for books and add them to your reading list.
+
+By default, shows search results in a simple list format where you can select by number.
+Use the -i flag for an interactive interface with navigation keys.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			interactive, _ := cmd.Flags().GetBool("interactive")
+			return handlers.SearchAndAddWithOptions(cmd.Context(), args, interactive)
+		},
+	}
+	addCmd.Flags().BoolP("interactive", "i", false, "Use interactive interface for book selection")
+	root.AddCommand(addCmd)
+
+	// book list - Show reading queue with progress
 	root.AddCommand(&cobra.Command{
-		Use:   "add [title]",
-		Short: "Add book to reading list",
-		Args:  cobra.MinimumNArgs(1),
+		Use:   "list [--all|--reading|--finished|--queued]",
+		Short: "Show reading queue with progress",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.ListBooks(cmd.Context(), args)
+		},
+	})
+
+	// book reading - Mark book as currently reading (alias for update status)
+	root.AddCommand(&cobra.Command{
+		Use:   "reading <id>",
+		Short: "Mark book as currently reading",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.UpdateBookStatus(cmd.Context(), []string{args[0], "reading"})
+		},
+	})
+
+	// book finished - Mark book as completed
+	root.AddCommand(&cobra.Command{
+		Use:     "finished <id>",
+		Short:   "Mark book as completed",
+		Aliases: []string{"read"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.UpdateBookStatus(cmd.Context(), []string{args[0], "finished"})
+		},
+	})
+
+	// book remove - Remove from reading list
+	root.AddCommand(&cobra.Command{
+		Use:     "remove <id>",
+		Short:   "Remove from reading list",
+		Aliases: []string{"rm"},
+		Args:    cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return handlers.UpdateBookStatus(cmd.Context(), []string{args[0], "removed"})
+		},
+	})
+
+	// book progress - Update reading progress percentage  
+	root.AddCommand(&cobra.Command{
+		Use:   "progress <id> <percentage>",
+		Short: "Update reading progress percentage (0-100)",
+		Args:  cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			title := args[0]
-			fmt.Printf("Adding book: %s\n", title)
-			// TODO: Implement book addition
-			return nil
+			return handlers.UpdateBookProgress(cmd.Context(), args)
 		},
 	})
 
+	// book update - Update book status
 	root.AddCommand(&cobra.Command{
-		Use:   "list",
-		Short: "List books in reading list",
+		Use:   "update <id> <status>",
+		Short: "Update book status (queued|reading|finished|removed)",
+		Args:  cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("Listing books...")
-			// TODO: Implement book listing
-			return nil
+			return handlers.UpdateBookStatus(cmd.Context(), args)
 		},
 	})
 

cmd/handlers/books.go

···
+package handlers
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"slices"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/services"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+	"github.com/stormlightlabs/noteleaf/internal/ui"
+)
+
+// BookHandler handles all book-related commands
+type BookHandler struct {
+	db      *store.Database
+	config  *store.Config
+	repos   *repo.Repositories
+	service *services.BookService
+}
+
+// NewBookHandler creates a new book handler
+func NewBookHandler() (*BookHandler, 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)
+	service := services.NewBookService()
+
+	return &BookHandler{
+		db:      db,
+		config:  config,
+		repos:   repos,
+		service: service,
+	}, nil
+}
+
+// Close cleans up resources
+func (h *BookHandler) Close() error {
+	if err := h.service.Close(); err != nil {
+		return fmt.Errorf("failed to close service: %w", err)
+	}
+	return h.db.Close()
+}
+
+// SearchAndAdd searches for books and allows user to select and add to queue
+func SearchAndAdd(ctx context.Context, args []string) error {
+	handler, err := NewBookHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize book handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.searchAndAdd(ctx, args)
+}
+
+// SearchAndAddWithOptions searches for books with interactive option
+func SearchAndAddWithOptions(ctx context.Context, args []string, interactive bool) error {
+	handler, err := NewBookHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize book handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.searchAndAddWithOptions(ctx, args, interactive)
+}
+
+func (h *BookHandler) searchAndAdd(ctx context.Context, args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("usage: book add <search query> [-i for interactive mode]")
+	}
+
+	interactive := false
+	searchArgs := args
+	if len(args) > 0 && args[len(args)-1] == "-i" {
+		interactive = true
+		searchArgs = args[:len(args)-1]
+	}
+
+	if len(searchArgs) == 0 {
+		return fmt.Errorf("search query cannot be empty")
+	}
+
+	query := searchArgs[0]
+	if len(searchArgs) > 1 {
+		for _, arg := range searchArgs[1:] {
+			query += " " + arg
+		}
+	}
+
+	return h.searchAndAddWithOptions(ctx, searchArgs, interactive)
+}
+
+func (h *BookHandler) searchAndAddWithOptions(ctx context.Context, args []string, interactive bool) error {
+	if len(args) == 0 {
+		return fmt.Errorf("usage: book add <search query>")
+	}
+
+	query := args[0]
+	if len(args) > 1 {
+		for _, arg := range args[1:] {
+			query += " " + arg
+		}
+	}
+
+	if interactive {
+		bookList := ui.NewBookList(h.service, h.repos.Books, ui.BookListOptions{
+			Output: os.Stdout,
+			Input:  os.Stdin,
+			Static: false,
+		})
+		return bookList.SearchAndSelect(ctx, query)
+	}
+
+	fmt.Printf("Searching for books: %s\n", query)
+	fmt.Print("Loading...")
+
+	results, err := h.service.Search(ctx, query, 1, 5)
+	if err != nil {
+		fmt.Println(" failed!")
+		return fmt.Errorf("search failed: %w", err)
+	}
+
+	fmt.Println(" done!")
+	fmt.Println()
+
+	if len(results) == 0 {
+		fmt.Println("No books found.")
+		return nil
+	}
+
+	fmt.Printf("Found %d result(s):\n\n", len(results))
+	for i, result := range results {
+		if book, ok := (*result).(*models.Book); ok {
+			fmt.Printf("[%d] %s", i+1, book.Title)
+			if book.Author != "" {
+				fmt.Printf(" by %s", book.Author)
+			}
+			if book.Notes != "" {
+				notes := book.Notes
+				if len(notes) > 80 {
+					notes = notes[:77] + "..."
+				}
+				fmt.Printf("\n    %s", notes)
+			}
+			fmt.Println()
+		}
+	}
+
+	fmt.Print("\nEnter number to add (1-", len(results), "), or 0 to cancel: ")
+
+	var choice int
+	if _, err := fmt.Scanf("%d", &choice); err != nil {
+		return fmt.Errorf("invalid input")
+	}
+
+	if choice == 0 {
+		fmt.Println("Cancelled.")
+		return nil
+	}
+
+	if choice < 1 || choice > len(results) {
+		return fmt.Errorf("invalid choice: %d", choice)
+	}
+
+	// Add selected book
+	selectedBook, ok := (*results[choice-1]).(*models.Book)
+	if !ok {
+		return fmt.Errorf("error processing selected book")
+	}
+
+	if _, err := h.repos.Books.Create(ctx, selectedBook); err != nil {
+		return fmt.Errorf("failed to add book: %w", err)
+	}
+
+	fmt.Printf("✓ Added book: %s", selectedBook.Title)
+	if selectedBook.Author != "" {
+		fmt.Printf(" by %s", selectedBook.Author)
+	}
+	fmt.Println()
+
+	return nil
+}
+
+// ListBooks lists all books in the queue
+func ListBooks(ctx context.Context, args []string) error {
+	handler, err := NewBookHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize book handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.listBooks(ctx, args)
+}
+
+func (h *BookHandler) listBooks(ctx context.Context, args []string) error {
+	status := "queued"
+	if len(args) > 0 {
+		switch args[0] {
+		case "all", "--all", "-a":
+			status = ""
+		case "reading", "--reading", "-r":
+			status = "reading"
+		case "finished", "--finished", "-f":
+			status = "finished"
+		case "queued", "--queued", "-q":
+			status = "queued"
+		}
+	}
+
+	var books []*models.Book
+	var err error
+
+	if status == "" {
+		books, err = h.repos.Books.List(ctx, repo.BookListOptions{})
+		if err != nil {
+			return fmt.Errorf("failed to list books: %w", err)
+		}
+	} else {
+		switch status {
+		case "queued":
+			books, err = h.repos.Books.GetQueued(ctx)
+		case "reading":
+			books, err = h.repos.Books.GetReading(ctx)
+		case "finished":
+			books, err = h.repos.Books.GetFinished(ctx)
+		}
+		if err != nil {
+			return fmt.Errorf("failed to get %s books: %w", status, err)
+		}
+	}
+
+	if len(books) == 0 {
+		if status == "" {
+			fmt.Println("No books found")
+		} else {
+			fmt.Printf("No %s books found\n", status)
+		}
+		return nil
+	}
+
+	fmt.Printf("Found %d book(s):\n\n", len(books))
+	for _, book := range books {
+		h.printBook(book)
+	}
+
+	return nil
+}
+
+func UpdateBookStatus(ctx context.Context, args []string) error {
+	handler, err := NewBookHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize book handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.updateBookStatus(ctx, args)
+}
+
+func (h *BookHandler) updateBookStatus(ctx context.Context, args []string) error {
+	if len(args) < 2 {
+		return fmt.Errorf("usage: book update <id> <status>")
+	}
+
+	var bookID int64
+	if _, err := fmt.Sscanf(args[0], "%d", &bookID); err != nil {
+		return fmt.Errorf("invalid book ID: %s", args[0])
+	}
+
+	status := args[1]
+	validStatuses := []string{"queued", "reading", "finished", "removed"}
+	valid := slices.Contains(validStatuses, status)
+	if !valid {
+		return fmt.Errorf("invalid status: %s (valid: %v)", status, validStatuses)
+	}
+
+	book, err := h.repos.Books.Get(ctx, bookID)
+	if err != nil {
+		return fmt.Errorf("failed to get book: %w", err)
+	}
+
+	book.Status = status
+	if status == "reading" && book.Started == nil {
+		now := time.Now()
+		book.Started = &now
+	}
+	if status == "finished" && book.Finished == nil {
+		now := time.Now()
+		book.Finished = &now
+		book.Progress = 100
+	}
+
+	if err := h.repos.Books.Update(ctx, book); err != nil {
+		return fmt.Errorf("failed to update book: %w", err)
+	}
+
+	fmt.Printf("Book status updated: %s -> %s\n", book.Title, status)
+	return nil
+}
+
+// UpdateBookProgress updates a book's reading progress percentage
+func UpdateBookProgress(ctx context.Context, args []string) error {
+	handler, err := NewBookHandler()
+	if err != nil {
+		return fmt.Errorf("failed to initialize book handler: %w", err)
+	}
+	defer handler.Close()
+
+	return handler.updateBookProgress(ctx, args)
+}
+
+func (h *BookHandler) updateBookProgress(ctx context.Context, args []string) error {
+	if len(args) < 2 {
+		return fmt.Errorf("usage: book progress <id> <percentage>")
+	}
+
+	var bookID int64
+	if _, err := fmt.Sscanf(args[0], "%d", &bookID); err != nil {
+		return fmt.Errorf("invalid book ID: %s", args[0])
+	}
+
+	var progress int
+	if _, err := fmt.Sscanf(args[1], "%d", &progress); err != nil {
+		return fmt.Errorf("invalid progress percentage: %s", args[1])
+	}
+
+	if progress < 0 || progress > 100 {
+		return fmt.Errorf("progress must be between 0 and 100, got %d", progress)
+	}
+
+	book, err := h.repos.Books.Get(ctx, bookID)
+	if err != nil {
+		return fmt.Errorf("failed to get book: %w", err)
+	}
+
+	book.Progress = progress
+
+	if progress == 0 && book.Status == "reading" {
+		book.Status = "queued"
+		book.Started = nil
+	} else if progress > 0 && book.Status == "queued" {
+		book.Status = "reading"
+		if book.Started == nil {
+			now := time.Now()
+			book.Started = &now
+		}
+	} else if progress == 100 {
+		book.Status = "finished"
+		if book.Finished == nil {
+			now := time.Now()
+			book.Finished = &now
+		}
+	}
+
+	if err := h.repos.Books.Update(ctx, book); err != nil {
+		return fmt.Errorf("failed to update book progress: %w", err)
+	}
+
+	fmt.Printf("Book progress updated: %s -> %d%%", book.Title, progress)
+	if book.Status != "queued" {
+		fmt.Printf(" (%s)", book.Status)
+	}
+	fmt.Println()
+	return nil
+}
+
+func (h *BookHandler) printBook(book *models.Book) {
+	fmt.Printf("[%d] %s", book.ID, book.Title)
+
+	if book.Author != "" {
+		fmt.Printf(" by %s", book.Author)
+	}
+
+	if book.Status != "queued" {
+		fmt.Printf(" (%s)", book.Status)
+	}
+
+	if book.Progress > 0 {
+		fmt.Printf(" [%d%%]", book.Progress)
+	}
+
+	if book.Rating > 0 {
+		fmt.Printf(" ★%.1f", book.Rating)
+	}
+
+	fmt.Println()
+
+	if book.Notes != "" {
+		notes := book.Notes
+		if len(notes) > 80 {
+			notes = notes[:77] + "..."
+		}
+		fmt.Printf("    %s\n", notes)
+	}
+
+	fmt.Println()
+}

cmd/handlers/books_test.go

···
+package handlers
+
+import (
+	"context"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+)
+
+func setupBookTest(t *testing.T) (string, func()) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-book-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 createTestBook(t *testing.T, handler *BookHandler, ctx context.Context) *models.Book {
+	t.Helper()
+	if handler == nil {
+		t.Fatal("handler provided to createTestBook is nil")
+	}
+	book := &models.Book{
+		Title:  "Test Book",
+		Author: "Test Author",
+		Status: "queued",
+		Added:  time.Now(),
+	}
+	id, err := handler.repos.Books.Create(ctx, book)
+	if err != nil {
+		t.Fatalf("Failed to create test book: %v", err)
+	}
+	book.ID = id
+	return book
+}
+
+func TestBookHandler(t *testing.T) {
+	t.Run("New", func(t *testing.T) {
+		t.Run("creates handler successfully", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			handler, err := NewBookHandler()
+			if err != nil {
+				t.Fatalf("NewBookHandler failed: %v", err)
+			}
+			if handler == nil {
+				t.Fatal("Handler should not be nil")
+			}
+			defer handler.Close()
+
+			if handler.db == nil {
+				t.Error("Handler database should not be nil")
+			}
+			if handler.config == nil {
+				t.Error("Handler config should not be nil")
+			}
+			if handler.repos == nil {
+				t.Error("Handler repos should not be nil")
+			}
+			if handler.service == nil {
+				t.Error("Handler service should not be nil")
+			}
+		})
+
+		t.Run("handles database initialization error", func(t *testing.T) {
+			originalXDG := os.Getenv("XDG_CONFIG_HOME")
+			originalHome := os.Getenv("HOME")
+
+			os.Unsetenv("XDG_CONFIG_HOME")
+			os.Unsetenv("HOME")
+			defer func() {
+				os.Setenv("XDG_CONFIG_HOME", originalXDG)
+				os.Setenv("HOME", originalHome)
+			}()
+
+			handler, err := NewBookHandler()
+			if err == nil {
+				if handler != nil {
+					handler.Close()
+				}
+				t.Error("Expected error when database initialization fails")
+			}
+		})
+	})
+
+	t.Run("Search & Add", func(t *testing.T) {
+		_, cleanup := setupBookTest(t)
+		defer cleanup()
+
+		t.Run("fails with empty args", func(t *testing.T) {
+			ctx := context.Background()
+			args := []string{}
+
+			err := SearchAndAdd(ctx, args)
+			if err == nil {
+				t.Error("Expected error for empty args")
+			}
+
+			if !strings.Contains(err.Error(), "usage: book add") {
+				t.Errorf("Expected usage error, got: %v", err)
+			}
+		})
+
+		t.Run("fails with empty search", func(t *testing.T) {
+			ctx := context.Background()
+			args := []string{"-i"}
+
+			err := SearchAndAdd(ctx, args)
+			if err == nil {
+				t.Error("Expected error for empty search query")
+			}
+
+			if !strings.Contains(err.Error(), "search query cannot be empty") {
+				t.Errorf("Expected empty search query error, got: %v", err)
+			}
+		})
+
+		t.Run("with options", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			t.Run("fails with empty args", func(t *testing.T) {
+				ctx := context.Background()
+				args := []string{}
+
+				err := SearchAndAddWithOptions(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error for empty args")
+				}
+
+				if !strings.Contains(err.Error(), "usage: book add") {
+					t.Errorf("Expected usage error, got: %v", err)
+				}
+			})
+
+			t.Run("handles search service errors", func(t *testing.T) {
+				ctx := context.Background()
+				args := []string{"test", "book"}
+
+				err := SearchAndAddWithOptions(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error due to mocked service")
+				}
+				if strings.Contains(err.Error(), "usage:") {
+					t.Error("Should not show usage error for valid args")
+				}
+			})
+
+		})
+	})
+
+	t.Run("List", func(t *testing.T) {
+		_, cleanup := setupBookTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewBookHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		_ = createTestBook(t, handler, ctx)
+
+		book2 := &models.Book{
+			Title:  "Reading Book",
+			Author: "Reading Author",
+			Status: "reading",
+			Added:  time.Now(),
+		}
+		id2, err := handler.repos.Books.Create(ctx, book2)
+		if err != nil {
+			t.Fatalf("Failed to create book2: %v", err)
+		}
+		book2.ID = id2
+
+		book3 := &models.Book{
+			Title:  "Finished Book",
+			Author: "Finished Author",
+			Status: "finished",
+			Added:  time.Now(),
+		}
+		id3, err := handler.repos.Books.Create(ctx, book3)
+		if err != nil {
+			t.Fatalf("Failed to create book3: %v", err)
+		}
+		book3.ID = id3
+
+		t.Run("lists queued books by default", func(t *testing.T) {
+			args := []string{}
+
+			err := ListBooks(ctx, args)
+			if err != nil {
+				t.Errorf("ListBooks failed: %v", err)
+			}
+		})
+
+		t.Run("filters by status - all", func(t *testing.T) {
+			args := []string{"all"}
+
+			err := ListBooks(ctx, args)
+			if err != nil {
+				t.Errorf("ListBooks with status all failed: %v", err)
+			}
+		})
+
+		t.Run("filters by status - reading", func(t *testing.T) {
+			args := []string{"reading"}
+
+			err := ListBooks(ctx, args)
+			if err != nil {
+				t.Errorf("ListBooks with status reading failed: %v", err)
+			}
+		})
+
+		t.Run("filters by status - finished", func(t *testing.T) {
+			args := []string{"finished"}
+
+			err := ListBooks(ctx, args)
+			if err != nil {
+				t.Errorf("ListBooks with status finished failed: %v", err)
+			}
+		})
+
+		t.Run("filters by status - queued", func(t *testing.T) {
+			args := []string{"queued"}
+
+			err := ListBooks(ctx, args)
+			if err != nil {
+				t.Errorf("ListBooks with status queued failed: %v", err)
+			}
+		})
+
+		t.Run("handles various flag formats", func(t *testing.T) {
+			statusVariants := [][]string{
+				{"--all"}, {"-a"},
+				{"--reading"}, {"-r"},
+				{"--finished"}, {"-f"},
+				{"--queued"}, {"-q"},
+			}
+
+			for _, args := range statusVariants {
+				err := ListBooks(ctx, args)
+				if err != nil {
+					t.Errorf("ListBooks with args %v failed: %v", args, err)
+				}
+			}
+		})
+	})
+
+	t.Run("Update", func(t *testing.T) {
+		t.Run("Update status", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			ctx := context.Background()
+
+			handler, err := NewBookHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
+			defer handler.Close()
+
+			book := createTestBook(t, handler, ctx)
+
+			t.Run("updates book status successfully", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10), "reading"}
+
+				err := UpdateBookStatus(ctx, args)
+				if err != nil {
+					t.Errorf("UpdateBookStatus failed: %v", err)
+				}
+
+				updatedBook, err := handler.repos.Books.Get(ctx, book.ID)
+				if err != nil {
+					t.Fatalf("Failed to get updated book: %v", err)
+				}
+
+				if updatedBook.Status != "reading" {
+					t.Errorf("Expected status 'reading', got '%s'", updatedBook.Status)
+				}
+
+				if updatedBook.Started == nil {
+					t.Error("Expected started time to be set")
+				}
+			})
+
+			t.Run("updates to finished status", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10), "finished"}
+
+				err := UpdateBookStatus(ctx, args)
+				if err != nil {
+					t.Errorf("UpdateBookStatus failed: %v", err)
+				}
+
+				updatedBook, err := handler.repos.Books.Get(ctx, book.ID)
+				if err != nil {
+					t.Fatalf("Failed to get updated book: %v", err)
+				}
+
+				if updatedBook.Status != "finished" {
+					t.Errorf("Expected status 'finished', got '%s'", updatedBook.Status)
+				}
+
+				if updatedBook.Finished == nil {
+					t.Error("Expected finished time to be set")
+				}
+
+				if updatedBook.Progress != 100 {
+					t.Errorf("Expected progress 100, got %d", updatedBook.Progress)
+				}
+			})
+
+			t.Run("fails with insufficient arguments", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10)}
+
+				err := UpdateBookStatus(ctx, args)
+				if err == nil {
+					t.Error("Expected error for insufficient arguments")
+				}
+
+				if !strings.Contains(err.Error(), "usage: book update") {
+					t.Errorf("Expected usage error, got: %v", err)
+				}
+			})
+
+			t.Run("fails with invalid book ID", func(t *testing.T) {
+				args := []string{"invalid-id", "reading"}
+
+				err := UpdateBookStatus(ctx, args)
+				if err == nil {
+					t.Error("Expected error for invalid book ID")
+				}
+
+				if !strings.Contains(err.Error(), "invalid book ID") {
+					t.Errorf("Expected invalid book ID error, got: %v", err)
+				}
+			})
+
+			t.Run("fails with invalid status", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10), "invalid-status"}
+
+				err := UpdateBookStatus(ctx, args)
+				if err == nil {
+					t.Error("Expected error for invalid status")
+				}
+
+				if !strings.Contains(err.Error(), "invalid status") {
+					t.Errorf("Expected invalid status error, got: %v", err)
+				}
+			})
+
+			t.Run("fails with non-existent book ID", func(t *testing.T) {
+				args := []string{"99999", "reading"}
+
+				err := UpdateBookStatus(ctx, args)
+				if err == nil {
+					t.Error("Expected error for non-existent book ID")
+				}
+
+				if !strings.Contains(err.Error(), "failed to get book") {
+					t.Errorf("Expected book not found error, got: %v", err)
+				}
+			})
+
+			t.Run("validates all status options", func(t *testing.T) {
+				validStatuses := []string{"queued", "reading", "finished", "removed"}
+
+				for _, status := range validStatuses {
+					args := []string{strconv.FormatInt(book.ID, 10), status}
+
+					err := UpdateBookStatus(ctx, args)
+					if err != nil {
+						t.Errorf("UpdateBookStatus with status %s failed: %v", status, err)
+					}
+				}
+			})
+		})
+
+		t.Run("progress", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			ctx := context.Background()
+
+			handler, err := NewBookHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
+			defer handler.Close()
+
+			book := createTestBook(t, handler, ctx)
+
+			t.Run("updates progress successfully", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10), "50"}
+
+				err := UpdateBookProgress(ctx, args)
+				if err != nil {
+					t.Errorf("UpdateBookProgress failed: %v", err)
+				}
+
+				updatedBook, err := handler.repos.Books.Get(ctx, book.ID)
+				if err != nil {
+					t.Fatalf("Failed to get updated book: %v", err)
+				}
+
+				if updatedBook.Progress != 50 {
+					t.Errorf("Expected progress 50, got %d", updatedBook.Progress)
+				}
+
+				if updatedBook.Status != "reading" {
+					t.Errorf("Expected status 'reading', got '%s'", updatedBook.Status)
+				}
+
+				if updatedBook.Started == nil {
+					t.Error("Expected started time to be set")
+				}
+			})
+
+			t.Run("auto-completes book at 100%", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10), "100"}
+
+				err := UpdateBookProgress(ctx, args)
+				if err != nil {
+					t.Errorf("UpdateBookProgress failed: %v", err)
+				}
+
+				updatedBook, err := handler.repos.Books.Get(ctx, book.ID)
+				if err != nil {
+					t.Fatalf("Failed to get updated book: %v", err)
+				}
+
+				if updatedBook.Progress != 100 {
+					t.Errorf("Expected progress 100, got %d", updatedBook.Progress)
+				}
+
+				if updatedBook.Status != "finished" {
+					t.Errorf("Expected status 'finished', got '%s'", updatedBook.Status)
+				}
+
+				if updatedBook.Finished == nil {
+					t.Error("Expected finished time to be set")
+				}
+			})
+
+			t.Run("resets to queued at 0%", func(t *testing.T) {
+				book.Status = "reading"
+				now := time.Now()
+				book.Started = &now
+				handler.repos.Books.Update(ctx, book)
+
+				args := []string{strconv.FormatInt(book.ID, 10), "0"}
+
+				err := UpdateBookProgress(ctx, args)
+				if err != nil {
+					t.Errorf("UpdateBookProgress failed: %v", err)
+				}
+
+				updatedBook, err := handler.repos.Books.Get(ctx, book.ID)
+				if err != nil {
+					t.Fatalf("Failed to get updated book: %v", err)
+				}
+
+				if updatedBook.Progress != 0 {
+					t.Errorf("Expected progress 0, got %d", updatedBook.Progress)
+				}
+
+				if updatedBook.Status != "queued" {
+					t.Errorf("Expected status 'queued', got '%s'", updatedBook.Status)
+				}
+
+				if updatedBook.Started != nil {
+					t.Error("Expected started time to be nil")
+				}
+			})
+
+			t.Run("fails with insufficient arguments", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10)}
+
+				err := UpdateBookProgress(ctx, args)
+				if err == nil {
+					t.Error("Expected error for insufficient arguments")
+				}
+
+				if !strings.Contains(err.Error(), "usage: book progress") {
+					t.Errorf("Expected usage error, got: %v", err)
+				}
+			})
+
+			t.Run("fails with invalid book ID", func(t *testing.T) {
+				args := []string{"invalid-id", "50"}
+
+				err := UpdateBookProgress(ctx, args)
+				if err == nil {
+					t.Error("Expected error for invalid book ID")
+				}
+
+				if !strings.Contains(err.Error(), "invalid book ID") {
+					t.Errorf("Expected invalid book ID error, got: %v", err)
+				}
+			})
+
+			t.Run("fails with invalid progress percentage", func(t *testing.T) {
+				args := []string{strconv.FormatInt(book.ID, 10), "invalid-progress"}
+
+				err := UpdateBookProgress(ctx, args)
+				if err == nil {
+					t.Error("Expected error for invalid progress percentage")
+				}
+
+				if !strings.Contains(err.Error(), "invalid progress percentage") {
+					t.Errorf("Expected invalid progress percentage error, got: %v", err)
+				}
+			})
+
+			t.Run("fails with progress out of range", func(t *testing.T) {
+				testCases := []string{"-1", "101", "150"}
+
+				for _, progress := range testCases {
+					args := []string{strconv.FormatInt(book.ID, 10), progress}
+
+					err := UpdateBookProgress(ctx, args)
+					if err == nil {
+						t.Errorf("Expected error for progress %s", progress)
+					}
+
+					if !strings.Contains(err.Error(), "progress must be between 0 and 100") {
+						t.Errorf("Expected range error for progress %s, got: %v", progress, err)
+					}
+				}
+			})
+
+			t.Run("fails with non-existent book ID", func(t *testing.T) {
+				args := []string{"99999", "50"}
+
+				err := UpdateBookProgress(ctx, args)
+				if err == nil {
+					t.Error("Expected error for non-existent book ID")
+				}
+
+				if !strings.Contains(err.Error(), "failed to get book") {
+					t.Errorf("Expected book not found error, got: %v", err)
+				}
+			})
+		})
+	})
+
+	t.Run("Close", func(t *testing.T) {
+		t.Run("closes handler resources", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			handler, err := NewBookHandler()
+			if err != nil {
+				t.Fatalf("NewBookHandler failed: %v", err)
+			}
+
+			err = handler.Close()
+			if err != nil {
+				t.Errorf("Close failed: %v", err)
+			}
+		})
+	})
+
+	t.Run("Print", func(t *testing.T) {
+		_, cleanup := setupBookTest(t)
+		defer cleanup()
+
+		handler, err := NewBookHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		now := time.Now()
+		book := &models.Book{
+			ID:       1,
+			Title:    "Test Book",
+			Author:   "Test Author",
+			Status:   "reading",
+			Progress: 75,
+			Rating:   4.5,
+			Notes:    "This is a test note that is longer than 80 characters to test the truncation functionality in the print method",
+			Added:    now,
+		}
+
+		t.Run("printBook doesn't panic", func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					t.Errorf("printBook panicked: %v", r)
+				}
+			}()
+
+			handler.printBook(book)
+		})
+
+		t.Run("handles book with minimal fields", func(t *testing.T) {
+			minimalBook := &models.Book{
+				ID:     2,
+				Title:  "Minimal Book",
+				Status: "queued",
+				Added:  now,
+			}
+
+			defer func() {
+				if r := recover(); r != nil {
+					t.Errorf("printBook panicked with minimal book: %v", r)
+				}
+			}()
+
+			handler.printBook(minimalBook)
+		})
+	})
+
+	t.Run("Error handling", func(t *testing.T) {
+		t.Run("handler creation fails with invalid environment", func(t *testing.T) {
+			originalXDG := os.Getenv("XDG_CONFIG_HOME")
+			originalHome := os.Getenv("HOME")
+
+			os.Unsetenv("XDG_CONFIG_HOME")
+			os.Unsetenv("HOME")
+			defer func() {
+				os.Setenv("XDG_CONFIG_HOME", originalXDG)
+				os.Setenv("HOME", originalHome)
+			}()
+
+			handler, err := NewBookHandler()
+			if err == nil {
+				if handler != nil {
+					handler.Close()
+				}
+				t.Error("Expected error when environment is invalid")
+			}
+		})
+
+	})
+
+	t.Run("Integration", func(t *testing.T) {
+		t.Run("full book lifecycle", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			ctx := context.Background()
+
+			handler, err := NewBookHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
+			defer handler.Close()
+
+			book := createTestBook(t, handler, ctx)
+
+			if book.Status != "queued" {
+				t.Errorf("Expected initial status 'queued', got '%s'", book.Status)
+			}
+
+			err = UpdateBookProgress(ctx, []string{strconv.FormatInt(book.ID, 10), "25"})
+			if err != nil {
+				t.Errorf("Failed to update progress: %v", err)
+			}
+
+			updatedBook, err := handler.repos.Books.Get(ctx, book.ID)
+			if err != nil {
+				t.Fatalf("Failed to get updated book: %v", err)
+			}
+
+			if updatedBook.Status != "reading" {
+				t.Errorf("Expected status 'reading', got '%s'", updatedBook.Status)
+			}
+
+			err = UpdateBookProgress(ctx, []string{strconv.FormatInt(book.ID, 10), "100"})
+			if err != nil {
+				t.Errorf("Failed to complete book: %v", err)
+			}
+
+			completedBook, err := handler.repos.Books.Get(ctx, book.ID)
+			if err != nil {
+				t.Fatalf("Failed to get completed book: %v", err)
+			}
+
+			if completedBook.Status != "finished" {
+				t.Errorf("Expected status 'finished', got '%s'", completedBook.Status)
+			}
+
+			if completedBook.Progress != 100 {
+				t.Errorf("Expected progress 100, got %d", completedBook.Progress)
+			}
+
+			if completedBook.Finished == nil {
+				t.Error("Expected finished time to be set")
+			}
+		})
+
+		t.Run("concurrent book operations", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			ctx := context.Background()
+
+			handler, err := NewBookHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
+			defer handler.Close()
+
+			book := createTestBook(t, handler, ctx)
+
+			done := make(chan error, 3)
+
+			go func() {
+				time.Sleep(time.Millisecond * 10)
+				done <- ListBooks(ctx, []string{})
+			}()
+
+			go func() {
+				time.Sleep(time.Millisecond * 15)
+				done <- UpdateBookProgress(ctx, []string{strconv.FormatInt(book.ID, 10), "50"})
+			}()
+
+			go func() {
+				time.Sleep(time.Millisecond * 20)
+				done <- UpdateBookStatus(ctx, []string{strconv.FormatInt(book.ID, 10), "finished"})
+			}()
+
+			for i := range 3 {
+				if err := <-done; err != nil {
+					t.Errorf("Concurrent operation %d failed: %v", i, err)
+				}
+			}
+		})
+	})
+}

cmd/handlers/notes_test.go

···
 	return filePath
 }
 
-func TestNoteHandler_NewNoteHandler(t *testing.T) {
-	t.Run("creates handler successfully", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+func TestNoteHandler(t *testing.T) {
+	t.Run("New", func(t *testing.T) {
+		t.Run("creates handler successfully", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		handler, err := NewNoteHandler()
-		if err != nil {
-			t.Errorf("NewNoteHandler failed: %v", err)
-		}
-		if handler == nil {
-			t.Error("Handler should not be nil")
-		}
-		defer handler.Close()
+			handler, err := NewNoteHandler()
+			if err != nil {
+				t.Fatalf("NewNoteHandler failed: %v", err)
+			}
+			if handler == nil {
+				t.Fatal("Handler should not be nil")
+			}
+			defer handler.Close()
 
-		if handler.db == nil {
-			t.Error("Handler database should not be nil")
-		}
-		if handler.config == nil {
-			t.Error("Handler config should not be nil")
-		}
-		if handler.repos == nil {
-			t.Error("Handler repos should not be nil")
-		}
-	})
+			if handler.db == nil {
+				t.Error("Handler database should not be nil")
+			}
+			if handler.config == nil {
+				t.Error("Handler config should not be nil")
+			}
+			if handler.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")
+		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")
-		}
+			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)
-		}()
+			defer func() {
+				os.Setenv("XDG_CONFIG_HOME", originalXDG)
+				os.Setenv("HOME", originalHome)
+			}()
 
-		_, err := NewNoteHandler()
-		if err == nil {
-			t.Error("NewNoteHandler should fail when database initialization fails")
-		}
-		if !strings.Contains(err.Error(), "failed to initialize database") {
-			t.Errorf("Expected database error, got: %v", err)
-		}
+			_, err := NewNoteHandler()
+			if err == nil {
+				t.Error("NewNoteHandler should fail when database initialization fails")
+			}
+			if !strings.Contains(err.Error(), "failed to initialize database") {
+				t.Errorf("Expected database error, got: %v", err)
+			}
+		})
 	})
-}
 
-func TestNoteHandler_parseNoteContent(t *testing.T) {
-	handler := &NoteHandler{}
+	t.Run("parse content", func(t *testing.T) {
+		handler := &NoteHandler{}
 
-	testCases := []struct {
-		name            string
-		input           string
-		expectedTitle   string
-		expectedContent string
-		expectedTags    []string
-	}{
-		{
-			name: "note with title and tags",
-			input: `# My Test Note
+		testCases := []struct {
+			name            string
+			input           string
+			expectedTitle   string
+			expectedContent string
+			expectedTags    []string
+		}{
+			{
+				name: "note with title and tags",
+				input: `# My Test Note
 
 This is the content.
 
 <!-- Tags: personal, work, important -->`,
-			expectedTitle: "My Test Note",
-			expectedContent: `# My Test Note
+				expectedTitle: "My Test Note",
+				expectedContent: `# My Test Note
 
 This is the content.
 
 <!-- Tags: personal, work, important -->`,
-			expectedTags: []string{"personal", "work", "important"},
-		},
-		{
-			name: "note without title",
-			input: `Just some content here.
+				expectedTags: []string{"personal", "work", "important"},
+			},
+			{
+				name: "note without title",
+				input: `Just some content here.
 
 No title heading.
 
 <!-- Tags: test -->`,
-			expectedTitle: "",
-			expectedContent: `Just some content here.
+				expectedTitle: "",
+				expectedContent: `Just some content here.
 
 No title heading.
 
 <!-- Tags: test -->`,
-			expectedTags: []string{"test"},
-		},
-		{
-			name: "note without tags",
-			input: `# Title Only
+				expectedTags: []string{"test"},
+			},
+			{
+				name: "note without tags",
+				input: `# Title Only
 
 Content without tags.`,
-			expectedTitle: "Title Only",
-			expectedContent: `# Title Only
+				expectedTitle: "Title Only",
+				expectedContent: `# Title Only
 
 Content without tags.`,
-			expectedTags: nil,
-		},
-		{
-			name: "empty tags comment",
-			input: `# Test Note
+				expectedTags: nil,
+			},
+			{
+				name: "empty tags comment",
+				input: `# Test Note
 
 Content here.
 
 <!-- Tags: -->`,
-			expectedTitle: "Test Note",
-			expectedContent: `# Test Note
+				expectedTitle: "Test Note",
+				expectedContent: `# Test Note
 
 Content here.
 
 <!-- Tags: -->`,
-			expectedTags: nil,
-		},
-		{
-			name: "malformed tags comment",
-			input: `# Test Note
+				expectedTags: nil,
+			},
+			{
+				name: "malformed tags comment",
+				input: `# Test Note
 
 Content here.
 
 <!-- Tags: tag1, , tag2,, tag3 -->`,
-			expectedTitle: "Test Note",
-			expectedContent: `# Test Note
+				expectedTitle: "Test Note",
+				expectedContent: `# Test Note
 
 Content here.
 
 <!-- Tags: tag1, , tag2,, tag3 -->`,
-			expectedTags: []string{"tag1", "tag2", "tag3"},
-		},
-		{
-			name: "multiple headings",
-			input: `## Secondary Heading
+				expectedTags: []string{"tag1", "tag2", "tag3"},
+			},
+			{
+				name: "multiple headings",
+				input: `## Secondary Heading
 
 # Main Title
 
 Content here.`,
-			expectedTitle: "Main Title",
-			expectedContent: `## Secondary Heading
+				expectedTitle: "Main Title",
+				expectedContent: `## Secondary Heading
 
 # Main Title
 
 Content here.`,
-			expectedTags: nil,
-		},
-	}
+				expectedTags: nil,
+			},
+		}
 
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			title, content, tags := handler.parseNoteContent(tc.input)
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				title, content, tags := handler.parseNoteContent(tc.input)
 
-			if title != tc.expectedTitle {
-				t.Errorf("Expected title %q, got %q", tc.expectedTitle, title)
-			}
+				if title != tc.expectedTitle {
+					t.Errorf("Expected title %q, got %q", tc.expectedTitle, title)
+				}
 
-			if content != tc.expectedContent {
-				t.Errorf("Expected content %q, got %q", tc.expectedContent, content)
-			}
+				if content != tc.expectedContent {
+					t.Errorf("Expected content %q, got %q", tc.expectedContent, content)
+				}
 
-			if len(tags) != len(tc.expectedTags) {
-				t.Errorf("Expected %d tags, got %d", len(tc.expectedTags), len(tags))
-			}
+				if len(tags) != len(tc.expectedTags) {
+					t.Errorf("Expected %d tags, got %d", len(tc.expectedTags), len(tags))
+				}
 
-			for i, expectedTag := range tc.expectedTags {
-				if i >= len(tags) || tags[i] != expectedTag {
-					t.Errorf("Expected tag %q at position %d, got %q", expectedTag, i, tags[i])
+				for i, expectedTag := range tc.expectedTags {
+					if i >= len(tags) || tags[i] != expectedTag {
+						t.Errorf("Expected tag %q at position %d, got %q", expectedTag, i, tags[i])
+					}
 				}
-			}
-		})
-	}
-}
+			})
+		}
+	})
 
-func TestIsFile(t *testing.T) {
-	testCases := []struct {
-		name     string
-		input    string
-		expected bool
-	}{
-		{"file with extension", "test.md", true},
-		{"file with multiple extensions", "test.tar.gz", true},
-		{"path with slash", "/path/to/file", true},
-		{"path with backslash", "path\\to\\file", true},
-		{"relative path", "./file", true},
-		{"just text", "hello", false},
-		{"empty string", "", false},
-	}
+	t.Run("IsFile helper", func(t *testing.T) {
+		testCases := []struct {
+			name     string
+			input    string
+			expected bool
+		}{
+			{"file with extension", "test.md", true},
+			{"file with multiple extensions", "test.tar.gz", true},
+			{"path with slash", "/path/to/file", true},
+			{"path with backslash", "path\\to\\file", true},
+			{"relative path", "./file", true},
+			{"just text", "hello", false},
+			{"empty string", "", false},
+		}
 
-	tempDir, err := os.MkdirTemp("", "isfile-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
+		tempDir, err := os.MkdirTemp("", "isfile-test-*")
+		if err != nil {
+			t.Fatalf("Failed to create temp dir: %v", err)
+		}
+		defer os.RemoveAll(tempDir)
 
-	existingFile := filepath.Join(tempDir, "existing")
-	err = os.WriteFile(existingFile, []byte("test"), 0644)
-	if err != nil {
-		t.Fatalf("Failed to create test file: %v", err)
-	}
+		existingFile := filepath.Join(tempDir, "existing")
+		err = os.WriteFile(existingFile, []byte("test"), 0644)
+		if err != nil {
+			t.Fatalf("Failed to create test file: %v", err)
+		}
 
-	testCases = append(testCases, struct {
-		name     string
-		input    string
-		expected bool
-	}{"existing file without extension", existingFile, true})
+		testCases = append(testCases, struct {
+			name     string
+			input    string
+			expected bool
+		}{"existing file without extension", existingFile, true})
 
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := isFile(tc.input)
-			if result != tc.expected {
-				t.Errorf("isFile(%q) = %v, expected %v", tc.input, result, tc.expected)
-			}
-		})
-	}
-}
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				result := isFile(tc.input)
+				if result != tc.expected {
+					t.Errorf("isFile(%q) = %v, expected %v", tc.input, result, tc.expected)
+				}
+			})
+		}
+	})
 
-func TestNoteHandler_getEditor(t *testing.T) {
-	handler := &NoteHandler{}
+	t.Run("getEditor", func(t *testing.T) {
+		handler := &NoteHandler{}
 
-	t.Run("uses EDITOR environment variable", func(t *testing.T) {
-		originalEditor := os.Getenv("EDITOR")
-		os.Setenv("EDITOR", "test-editor")
-		defer os.Setenv("EDITOR", originalEditor)
+		t.Run("uses EDITOR environment variable", func(t *testing.T) {
+			originalEditor := os.Getenv("EDITOR")
+			os.Setenv("EDITOR", "test-editor")
+			defer os.Setenv("EDITOR", originalEditor)
 
-		editor := handler.getEditor()
-		if editor != "test-editor" {
-			t.Errorf("Expected 'test-editor', got %q", editor)
-		}
-	})
+			editor := handler.getEditor()
+			if editor != "test-editor" {
+				t.Errorf("Expected 'test-editor', got %q", editor)
+			}
+		})
 
-	t.Run("finds available editor", func(t *testing.T) {
-		originalEditor := os.Getenv("EDITOR")
-		os.Unsetenv("EDITOR")
-		defer os.Setenv("EDITOR", originalEditor)
+		t.Run("finds available editor", func(t *testing.T) {
+			originalEditor := os.Getenv("EDITOR")
+			os.Unsetenv("EDITOR")
+			defer os.Setenv("EDITOR", originalEditor)
 
-		editor := handler.getEditor()
-		if editor == "" {
-			t.Skip("No common editors found on system, skipping test")
-		}
-	})
+			editor := handler.getEditor()
+			if editor == "" {
+				t.Skip("No common editors found on system, skipping test")
+			}
+		})
 
-	t.Run("returns empty when no editor available", func(t *testing.T) {
-		originalEditor := os.Getenv("EDITOR")
-		originalPath := os.Getenv("PATH")
+		t.Run("returns empty when no editor available", func(t *testing.T) {
+			originalEditor := os.Getenv("EDITOR")
+			originalPath := os.Getenv("PATH")
 
-		os.Unsetenv("EDITOR")
-		os.Setenv("PATH", "")
+			os.Unsetenv("EDITOR")
+			os.Setenv("PATH", "")
 
-		defer func() {
-			os.Setenv("EDITOR", originalEditor)
-			os.Setenv("PATH", originalPath)
-		}()
+			defer func() {
+				os.Setenv("EDITOR", originalEditor)
+				os.Setenv("PATH", originalPath)
+			}()
 
-		editor := handler.getEditor()
-		if editor != "" {
-			t.Errorf("Expected empty string when no editor available, got %q", editor)
-		}
+			editor := handler.getEditor()
+			if editor != "" {
+				t.Errorf("Expected empty string when no editor available, got %q", editor)
+			}
+		})
 	})
-}
 
-func TestNoteCreateErrorScenarios(t *testing.T) {
-	errorTests := []struct {
-		name        string
-		setupFunc   func(t *testing.T) (cleanup func())
-		args        []string
-		expectError bool
-		errorSubstr string
-	}{
-		{
-			name: "database initialization error",
-			setupFunc: func(t *testing.T) func() {
-				if runtime.GOOS == "windows" {
-					original := os.Getenv("APPDATA")
-					os.Unsetenv("APPDATA")
-					return func() { os.Setenv("APPDATA", original) }
-				} else {
-					originalXDG := os.Getenv("XDG_CONFIG_HOME")
-					originalHome := os.Getenv("HOME")
-					os.Unsetenv("XDG_CONFIG_HOME")
-					os.Unsetenv("HOME")
-					return func() {
-						os.Setenv("XDG_CONFIG_HOME", originalXDG)
-						os.Setenv("HOME", originalHome)
+	t.Run("Create Errors", func(t *testing.T) {
+		errorTests := []struct {
+			name        string
+			setupFunc   func(t *testing.T) (cleanup func())
+			args        []string
+			expectError bool
+			errorSubstr string
+		}{
+			{
+				name: "database initialization error",
+				setupFunc: func(t *testing.T) func() {
+					if runtime.GOOS == "windows" {
+						original := os.Getenv("APPDATA")
+						os.Unsetenv("APPDATA")
+						return func() { os.Setenv("APPDATA", original) }
+					} else {
+						originalXDG := os.Getenv("XDG_CONFIG_HOME")
+						originalHome := os.Getenv("HOME")
+						os.Unsetenv("XDG_CONFIG_HOME")
+						os.Unsetenv("HOME")
+						return func() {
+							os.Setenv("XDG_CONFIG_HOME", originalXDG)
+							os.Setenv("HOME", originalHome)
+						}
 					}
-				}
+				},
+				args:        []string{"Test Note"},
+				expectError: true,
+				errorSubstr: "failed to initialize database",
 			},
-			args:        []string{"Test Note"},
-			expectError: true,
-			errorSubstr: "failed to initialize database",
-		},
-		{
-			name: "note creation in database fails",
-			setupFunc: func(t *testing.T) func() {
-				tempDir, cleanup := setupNoteTest(t)
+			{
+				name: "note creation in database fails",
+				setupFunc: func(t *testing.T) func() {
+					tempDir, cleanup := setupNoteTest(t)
 
-				configDir := filepath.Join(tempDir, "noteleaf")
-				dbPath := filepath.Join(configDir, "noteleaf.db")
+					configDir := filepath.Join(tempDir, "noteleaf")
+					dbPath := filepath.Join(configDir, "noteleaf.db")
 
-				err := os.WriteFile(dbPath, []byte("invalid sqlite content"), 0644)
-				if err != nil {
-					t.Fatalf("Failed to corrupt database: %v", err)
-				}
+					err := os.WriteFile(dbPath, []byte("invalid sqlite content"), 0644)
+					if err != nil {
+						t.Fatalf("Failed to corrupt database: %v", err)
+					}
 
-				return cleanup
+					return cleanup
+				},
+				args:        []string{"Test Note"},
+				expectError: true,
+				errorSubstr: "failed to initialize database",
 			},
-			args:        []string{"Test Note"},
-			expectError: true,
-			errorSubstr: "failed to initialize database",
-		},
-	}
+		}
+
+		for _, tt := range errorTests {
+			t.Run(tt.name, func(t *testing.T) {
+				cleanup := tt.setupFunc(t)
+				defer cleanup()
+
+				oldStdin := os.Stdin
+				r, w, _ := os.Pipe()
+				os.Stdin = r
+				defer func() { os.Stdin = oldStdin }()
+
+				go func() {
+					w.WriteString("n\n")
+					w.Close()
+				}()
+
+				ctx := context.Background()
+				err := Create(ctx, tt.args)
+
+				if tt.expectError && err == nil {
+					t.Errorf("Expected error containing %q, got nil", tt.errorSubstr)
+				} else if !tt.expectError && err != nil {
+					t.Errorf("Expected no error, got: %v", err)
+				} else if tt.expectError && err != nil && !strings.Contains(err.Error(), tt.errorSubstr) {
+					t.Errorf("Expected error containing %q, got: %v", tt.errorSubstr, err)
+				}
+			})
+		}
+	})
 
-	for _, tt := range errorTests {
-		t.Run(tt.name, func(t *testing.T) {
-			cleanup := tt.setupFunc(t)
+	t.Run("Create (args)", func(t *testing.T) {
+		t.Run("creates note from title only", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
 			defer cleanup()
 
 			oldStdin := os.Stdin
···
 			}()
 
 			ctx := context.Background()
-			err := Create(ctx, tt.args)
-
-			if tt.expectError && err == nil {
-				t.Errorf("Expected error containing %q, got nil", tt.errorSubstr)
-			} else if !tt.expectError && err != nil {
-				t.Errorf("Expected no error, got: %v", err)
-			} else if tt.expectError && err != nil && !strings.Contains(err.Error(), tt.errorSubstr) {
-				t.Errorf("Expected error containing %q, got: %v", tt.errorSubstr, err)
+			err := Create(ctx, []string{"Test Note"})
+			if err != nil {
+				t.Errorf("Create failed: %v", err)
 			}
 		})
-	}
-}
 
-func TestCreate_WithArgs(t *testing.T) {
-	t.Run("creates note from title only", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("creates note from title and content", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		oldStdin := os.Stdin
-		r, w, _ := os.Pipe()
-		os.Stdin = r
-		defer func() { os.Stdin = oldStdin }()
+			oldStdin := os.Stdin
+			r, w, _ := os.Pipe()
+			os.Stdin = r
+			defer func() { os.Stdin = oldStdin }()
 
-		go func() {
-			w.WriteString("n\n")
-			w.Close()
-		}()
+			go func() {
+				w.WriteString("n\n")
+				w.Close()
+			}()
 
-		ctx := context.Background()
-		err := Create(ctx, []string{"Test Note"})
-		if err != nil {
-			t.Errorf("Create failed: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{"Test Note", "This", "is", "test", "content"})
+			if err != nil {
+				t.Errorf("Create failed: %v", err)
+			}
+		})
 
-	t.Run("creates note from title and content", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles database connection error", func(t *testing.T) {
+			tempDir, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		oldStdin := os.Stdin
-		r, w, _ := os.Pipe()
-		os.Stdin = r
-		defer func() { os.Stdin = oldStdin }()
+			configDir := filepath.Join(tempDir, "noteleaf")
+			dbPath := filepath.Join(configDir, "noteleaf.db")
+			os.Remove(dbPath)
 
-		go func() {
-			w.WriteString("n\n")
-			w.Close()
-		}()
+			os.MkdirAll(dbPath, 0755)
+			defer os.RemoveAll(dbPath)
 
-		ctx := context.Background()
-		err := Create(ctx, []string{"Test Note", "This", "is", "test", "content"})
-		if err != nil {
-			t.Errorf("Create failed: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{"Test Note"})
+			if err == nil {
+				t.Error("Create should fail when database is inaccessible")
+			}
+		})
 
-	t.Run("handles database connection error", func(t *testing.T) {
-		tempDir, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("New is alias for Create", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		configDir := filepath.Join(tempDir, "noteleaf")
-		dbPath := filepath.Join(configDir, "noteleaf.db")
-		os.Remove(dbPath)
+			oldStdin := os.Stdin
+			r, w, _ := os.Pipe()
+			os.Stdin = r
+			defer func() { os.Stdin = oldStdin }()
 
-		os.MkdirAll(dbPath, 0755)
-		defer os.RemoveAll(dbPath)
+			go func() {
+				w.WriteString("n\n")
+				w.Close()
+			}()
 
-		ctx := context.Background()
-		err := Create(ctx, []string{"Test Note"})
-		if err == nil {
-			t.Error("Create should fail when database is inaccessible")
-		}
+			ctx := context.Background()
+			err := New(ctx, []string{"Test Note via New"})
+			if err != nil {
+				t.Errorf("New failed: %v", err)
+			}
+		})
 	})
 
-	t.Run("New is alias for Create", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
-
-		oldStdin := os.Stdin
-		r, w, _ := os.Pipe()
-		os.Stdin = r
-		defer func() { os.Stdin = oldStdin }()
-
-		go func() {
-			w.WriteString("n\n")
-			w.Close()
-		}()
-
-		ctx := context.Background()
-		err := New(ctx, []string{"Test Note via New"})
-		if err != nil {
-			t.Errorf("New failed: %v", err)
-		}
-	})
-}
+	t.Run("Create from file", func(t *testing.T) {
+		t.Run("creates note from markdown file", func(t *testing.T) {
+			tempDir, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-func TestCreate_FromFile(t *testing.T) {
-	t.Run("creates note from markdown file", func(t *testing.T) {
-		tempDir, cleanup := setupNoteTest(t)
-		defer cleanup()
-
-		content := `# My Test Note
+			content := `# My Test Note
 
 This is the content of my test note.
 
···
 
 <!-- Tags: personal, work -->`
 
-		filePath := createTestMarkdownFile(t, tempDir, "test.md", content)
+			filePath := createTestMarkdownFile(t, tempDir, "test.md", content)
 
-		ctx := context.Background()
-		err := Create(ctx, []string{filePath})
-		if err != nil {
-			t.Errorf("Create from file failed: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{filePath})
+			if err != nil {
+				t.Errorf("Create from file failed: %v", err)
+			}
+		})
 
-	t.Run("handles non-existent file", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles non-existent file", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		ctx := context.Background()
-		err := Create(ctx, []string{"/non/existent/file.md"})
-		if err == nil {
-			t.Error("Create should fail for non-existent file")
-		}
-		if !strings.Contains(err.Error(), "file does not exist") {
-			t.Errorf("Expected file not found error, got: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{"/non/existent/file.md"})
+			if err == nil {
+				t.Error("Create should fail for non-existent file")
+			}
+			if !strings.Contains(err.Error(), "file does not exist") {
+				t.Errorf("Expected file not found error, got: %v", err)
+			}
+		})
 
-	t.Run("handles empty file", func(t *testing.T) {
-		tempDir, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles empty file", func(t *testing.T) {
+			tempDir, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		filePath := createTestMarkdownFile(t, tempDir, "empty.md", "")
+			filePath := createTestMarkdownFile(t, tempDir, "empty.md", "")
 
-		ctx := context.Background()
-		err := Create(ctx, []string{filePath})
-		if err == nil {
-			t.Error("Create should fail for empty file")
-		}
-		if !strings.Contains(err.Error(), "file is empty") {
-			t.Errorf("Expected empty file error, got: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{filePath})
+			if err == nil {
+				t.Error("Create should fail for empty file")
+			}
+			if !strings.Contains(err.Error(), "file is empty") {
+				t.Errorf("Expected empty file error, got: %v", err)
+			}
+		})
 
-	t.Run("handles whitespace-only file", func(t *testing.T) {
-		tempDir, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles whitespace-only file", func(t *testing.T) {
+			tempDir, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		filePath := createTestMarkdownFile(t, tempDir, "whitespace.md", "   \n\t  \n  ")
+			filePath := createTestMarkdownFile(t, tempDir, "whitespace.md", "   \n\t  \n  ")
 
-		ctx := context.Background()
-		err := Create(ctx, []string{filePath})
-		if err == nil {
-			t.Error("Create should fail for whitespace-only file")
-		}
-		if !strings.Contains(err.Error(), "file is empty") {
-			t.Errorf("Expected empty file error, got: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{filePath})
+			if err == nil {
+				t.Error("Create should fail for whitespace-only file")
+			}
+			if !strings.Contains(err.Error(), "file is empty") {
+				t.Errorf("Expected empty file error, got: %v", err)
+			}
+		})
 
-	t.Run("creates note without title in file", func(t *testing.T) {
-		tempDir, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("creates note without title in file", func(t *testing.T) {
+			tempDir, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		content := `This note has no title heading.
+			content := `This note has no title heading.
 
 Just some content here.`
 
-		filePath := createTestMarkdownFile(t, tempDir, "notitle.md", content)
+			filePath := createTestMarkdownFile(t, tempDir, "notitle.md", content)
 
-		ctx := context.Background()
-		err := Create(ctx, []string{filePath})
-		if err != nil {
-			t.Errorf("Create from file without title failed: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{filePath})
+			if err != nil {
+				t.Errorf("Create from file without title failed: %v", err)
+			}
+		})
 
-	t.Run("handles file read error", func(t *testing.T) {
-		tempDir, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles file read error", func(t *testing.T) {
+			tempDir, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		filePath := createTestMarkdownFile(t, tempDir, "unreadable.md", "test content")
-		err := os.Chmod(filePath, 0000)
-		if err != nil {
-			t.Fatalf("Failed to make file unreadable: %v", err)
-		}
-		defer os.Chmod(filePath, 0644)
+			filePath := createTestMarkdownFile(t, tempDir, "unreadable.md", "test content")
+			err := os.Chmod(filePath, 0000)
+			if err != nil {
+				t.Fatalf("Failed to make file unreadable: %v", err)
+			}
+			defer os.Chmod(filePath, 0644)
 
-		ctx := context.Background()
-		err = Create(ctx, []string{filePath})
-		if err == nil {
-			t.Error("Create should fail for unreadable file")
-		}
-		if !strings.Contains(err.Error(), "failed to read file") {
-			t.Errorf("Expected file read error, got: %v", err)
-		}
+			ctx := context.Background()
+			err = Create(ctx, []string{filePath})
+			if err == nil {
+				t.Error("Create should fail for unreadable file")
+			}
+			if !strings.Contains(err.Error(), "failed to read file") {
+				t.Errorf("Expected file read error, got: %v", err)
+			}
+		})
 	})
-}
 
-func TestCreate_Interactive(t *testing.T) {
-	t.Run("handles no editor configured", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+	t.Run("Interactive Create", func(t *testing.T) {
+		t.Run("handles no editor configured", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		originalPath := os.Getenv("PATH")
-		os.Unsetenv("EDITOR")
-		os.Setenv("PATH", "")
-		defer func() {
-			os.Setenv("EDITOR", originalEditor)
-			os.Setenv("PATH", originalPath)
-		}()
+			originalEditor := os.Getenv("EDITOR")
+			originalPath := os.Getenv("PATH")
+			os.Unsetenv("EDITOR")
+			os.Setenv("PATH", "")
+			defer func() {
+				os.Setenv("EDITOR", originalEditor)
+				os.Setenv("PATH", originalPath)
+			}()
 
-		ctx := context.Background()
-		err := Create(ctx, []string{})
-		if err == nil {
-			t.Error("Create should fail when no editor is configured")
-		}
-		if !strings.Contains(err.Error(), "no editor configured") {
-			t.Errorf("Expected no editor error, got: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{})
+			if err == nil {
+				t.Error("Create should fail when no editor is configured")
+			}
+			if !strings.Contains(err.Error(), "no editor configured") {
+				t.Errorf("Expected no editor error, got: %v", err)
+			}
+		})
 
-	t.Run("handles editor command failure", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles editor command failure", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		os.Setenv("EDITOR", "nonexistent-editor-12345")
-		defer os.Setenv("EDITOR", originalEditor)
+			originalEditor := os.Getenv("EDITOR")
+			os.Setenv("EDITOR", "nonexistent-editor-12345")
+			defer os.Setenv("EDITOR", originalEditor)
 
-		ctx := context.Background()
-		err := Create(ctx, []string{})
-		if err == nil {
-			t.Error("Create should fail when editor command fails")
-		}
-		if !strings.Contains(err.Error(), "failed to open editor") {
-			t.Errorf("Expected editor failure error, got: %v", err)
-		}
-	})
+			ctx := context.Background()
+			err := Create(ctx, []string{})
+			if err == nil {
+				t.Error("Create should fail when editor command fails")
+			}
+			if !strings.Contains(err.Error(), "failed to open editor") {
+				t.Errorf("Expected editor failure error, got: %v", err)
+			}
+		})
 
-	t.Run("creates note successfully with mocked editor", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("creates note successfully with mocked editor", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		os.Setenv("EDITOR", "test-editor")
-		defer os.Setenv("EDITOR", originalEditor)
+			originalEditor := os.Getenv("EDITOR")
+			os.Setenv("EDITOR", "test-editor")
+			defer os.Setenv("EDITOR", originalEditor)
 
-		handler, err := NewNoteHandler()
-		if err != nil {
-			t.Fatalf("NewNoteHandler failed: %v", err)
-		}
-		defer handler.Close()
+			handler, err := NewNoteHandler()
+			if err != nil {
+				t.Fatalf("NewNoteHandler failed: %v", err)
+			}
+			defer handler.Close()
 
-		handler.openInEditorFunc = func(editor, filePath string) error {
-			content := `# Test Note
+			handler.openInEditorFunc = func(editor, filePath string) error {
+				content := `# Test Note
 
 This is edited content.
 
 <!-- Tags: test, created -->`
-			return os.WriteFile(filePath, []byte(content), 0644)
-		}
+				return os.WriteFile(filePath, []byte(content), 0644)
+			}
+
+			ctx := context.Background()
+			err = handler.createInteractive(ctx)
+			if err != nil {
+				t.Errorf("Interactive create failed: %v", err)
+			}
+		})
+
+		t.Run("handles editor cancellation", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
+
+			originalEditor := os.Getenv("EDITOR")
+			os.Setenv("EDITOR", "test-editor")
+			defer os.Setenv("EDITOR", originalEditor)
+
+			handler, err := NewNoteHandler()
+			if err != nil {
+				t.Fatalf("NewNoteHandler failed: %v", err)
+			}
+			defer handler.Close()
+
+			handler.openInEditorFunc = func(editor, filePath string) error {
+				return nil
+			}
 
-		ctx := context.Background()
-		err = handler.createInteractive(ctx)
-		if err != nil {
-			t.Errorf("Interactive create failed: %v", err)
-		}
+			ctx := context.Background()
+			err = handler.createInteractive(ctx)
+			if err != nil {
+				t.Errorf("Interactive create should handle cancellation gracefully: %v", err)
+			}
+		})
 	})
 
-	t.Run("handles editor cancellation", func(t *testing.T) {
+	t.Run("Close", func(t *testing.T) {
 		_, cleanup := setupNoteTest(t)
 		defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		os.Setenv("EDITOR", "test-editor")
-		defer os.Setenv("EDITOR", originalEditor)
-
 		handler, err := NewNoteHandler()
 		if err != nil {
 			t.Fatalf("NewNoteHandler failed: %v", err)
 		}
-		defer handler.Close()
 
-		handler.openInEditorFunc = func(editor, filePath string) error {
-			return nil
+		err = handler.Close()
+		if err != nil {
+			t.Errorf("Close should not return error: %v", err)
 		}
 
-		ctx := context.Background()
-		err = handler.createInteractive(ctx)
+		handler.db = nil
+		err = handler.Close()
 		if err != nil {
-			t.Errorf("Interactive create should handle cancellation gracefully: %v", err)
+			t.Errorf("Close should handle nil database gracefully: %v", err)
 		}
 	})
-}
 
-func TestNoteHandlerClosesResources(t *testing.T) {
-	_, cleanup := setupNoteTest(t)
-	defer cleanup()
-
-	handler, err := NewNoteHandler()
-	if err != nil {
-		t.Fatalf("NewNoteHandler failed: %v", err)
-	}
-
-	err = handler.Close()
-	if err != nil {
-		t.Errorf("Close should not return error: %v", err)
-	}
-
-	handler.db = nil
-	err = handler.Close()
-	if err != nil {
-		t.Errorf("Close should handle nil database gracefully: %v", err)
-	}
-}
-
-func TestEdit(t *testing.T) {
-	t.Run("validates argument count", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+	t.Run("Edit", func(t *testing.T) {
+		t.Run("validates argument count", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		ctx := context.Background()
+			ctx := context.Background()
 
-		err := Edit(ctx, []string{})
-		if err == nil {
-			t.Error("Edit should fail with no arguments")
-		}
-		if !strings.Contains(err.Error(), "edit requires exactly one argument") {
-			t.Errorf("Expected argument count error, got: %v", err)
-		}
+			err := Edit(ctx, []string{})
+			if err == nil {
+				t.Error("Edit should fail with no arguments")
+			}
+			if !strings.Contains(err.Error(), "edit requires exactly one argument") {
+				t.Errorf("Expected argument count error, got: %v", err)
+			}
 
-		err = Edit(ctx, []string{"1", "2"})
-		if err == nil {
-			t.Error("Edit should fail with too many arguments")
-		}
-		if !strings.Contains(err.Error(), "edit requires exactly one argument") {
-			t.Errorf("Expected argument count error, got: %v", err)
-		}
-	})
+			err = Edit(ctx, []string{"1", "2"})
+			if err == nil {
+				t.Error("Edit should fail with too many arguments")
+			}
+			if !strings.Contains(err.Error(), "edit requires exactly one argument") {
+				t.Errorf("Expected argument count error, got: %v", err)
+			}
+		})
 
-	t.Run("validates note ID format", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("validates note ID format", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		ctx := context.Background()
+			ctx := context.Background()
 
-		err := Edit(ctx, []string{"invalid"})
-		if err == nil {
-			t.Error("Edit should fail with invalid note ID")
-		}
-		if !strings.Contains(err.Error(), "invalid note ID") {
-			t.Errorf("Expected invalid ID error, got: %v", err)
-		}
+			err := Edit(ctx, []string{"invalid"})
+			if err == nil {
+				t.Error("Edit should fail with invalid note ID")
+			}
+			if !strings.Contains(err.Error(), "invalid note ID") {
+				t.Errorf("Expected invalid ID error, got: %v", err)
+			}
 
-		err = Edit(ctx, []string{"-1"})
-		if err == nil {
-			t.Error("Edit should fail with negative note ID")
-		}
+			err = Edit(ctx, []string{"-1"})
+			if err == nil {
+				t.Error("Edit should fail with negative note ID")
+			}
 
-		if !strings.Contains(err.Error(), "failed to get note") {
-			t.Errorf("Expected note not found error for negative ID, got: %v", err)
-		}
-	})
+			if !strings.Contains(err.Error(), "failed to get note") {
+				t.Errorf("Expected note not found error for negative ID, got: %v", err)
+			}
+		})
 
-	t.Run("handles non-existent note", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles non-existent note", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		ctx := context.Background()
+			ctx := context.Background()
 
-		err := Edit(ctx, []string{"999"})
-		if err == nil {
-			t.Error("Edit should fail with non-existent note ID")
-		}
-		if !strings.Contains(err.Error(), "failed to get note") {
-			t.Errorf("Expected note not found error, got: %v", err)
-		}
-	})
+			err := Edit(ctx, []string{"999"})
+			if err == nil {
+				t.Error("Edit should fail with non-existent note ID")
+			}
+			if !strings.Contains(err.Error(), "failed to get note") {
+				t.Errorf("Expected note not found error, got: %v", err)
+			}
+		})
 
-	t.Run("handles no editor configured", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles no editor configured", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		originalPath := os.Getenv("PATH")
-		os.Setenv("EDITOR", "")
-		os.Setenv("PATH", "")
-		defer func() {
-			os.Setenv("EDITOR", originalEditor)
-			os.Setenv("PATH", originalPath)
-		}()
+			originalEditor := os.Getenv("EDITOR")
+			originalPath := os.Getenv("PATH")
+			os.Setenv("EDITOR", "")
+			os.Setenv("PATH", "")
+			defer func() {
+				os.Setenv("EDITOR", originalEditor)
+				os.Setenv("PATH", originalPath)
+			}()
 
-		ctx := context.Background()
+			ctx := context.Background()
 
-		err := Create(ctx, []string{"Test Note", "Test content"})
-		if err != nil {
-			t.Fatalf("Failed to create test note: %v", err)
-		}
+			err := Create(ctx, []string{"Test Note", "Test content"})
+			if err != nil {
+				t.Fatalf("Failed to create test note: %v", err)
+			}
 
-		err = Edit(ctx, []string{"1"})
-		if err == nil {
-			t.Error("Edit should fail when no editor is configured")
-		}
+			err = Edit(ctx, []string{"1"})
+			if err == nil {
+				t.Error("Edit should fail when no editor is configured")
+			}
 
-		if !strings.Contains(err.Error(), "no editor configured") && !strings.Contains(err.Error(), "failed to open editor") {
-			t.Errorf("Expected no editor or editor failure error, got: %v", err)
-		}
-	})
+			if !strings.Contains(err.Error(), "no editor configured") && !strings.Contains(err.Error(), "failed to open editor") {
+				t.Errorf("Expected no editor or editor failure error, got: %v", err)
+			}
+		})
 
-	t.Run("handles editor command failure", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles editor command failure", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		os.Setenv("EDITOR", "nonexistent-editor-12345")
-		defer os.Setenv("EDITOR", originalEditor)
+			originalEditor := os.Getenv("EDITOR")
+			os.Setenv("EDITOR", "nonexistent-editor-12345")
+			defer os.Setenv("EDITOR", originalEditor)
 
-		ctx := context.Background()
+			ctx := context.Background()
 
-		err := Create(ctx, []string{"Test Note", "Test content"})
-		if err != nil {
-			t.Fatalf("Failed to create test note: %v", err)
-		}
+			err := Create(ctx, []string{"Test Note", "Test content"})
+			if err != nil {
+				t.Fatalf("Failed to create test note: %v", err)
+			}
 
-		err = Edit(ctx, []string{"1"})
-		if err == nil {
-			t.Error("Edit should fail when editor command fails")
-		}
-		if !strings.Contains(err.Error(), "failed to open editor") {
-			t.Errorf("Expected editor failure error, got: %v", err)
-		}
-	})
+			err = Edit(ctx, []string{"1"})
+			if err == nil {
+				t.Error("Edit should fail when editor command fails")
+			}
+			if !strings.Contains(err.Error(), "failed to open editor") {
+				t.Errorf("Expected editor failure error, got: %v", err)
+			}
+		})
 
-	t.Run("edits note successfully with mocked editor", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("edits note successfully with mocked editor", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		os.Setenv("EDITOR", "test-editor")
-		defer os.Setenv("EDITOR", originalEditor)
+			originalEditor := os.Getenv("EDITOR")
+			os.Setenv("EDITOR", "test-editor")
+			defer os.Setenv("EDITOR", originalEditor)
 
-		ctx := context.Background()
+			ctx := context.Background()
 
-		err := Create(ctx, []string{"Original Title", "Original content"})
-		if err != nil {
-			t.Fatalf("Failed to create test note: %v", err)
-		}
+			err := Create(ctx, []string{"Original Title", "Original content"})
+			if err != nil {
+				t.Fatalf("Failed to create test note: %v", err)
+			}
 
-		handler, err := NewNoteHandler()
-		if err != nil {
-			t.Fatalf("NewNoteHandler failed: %v", err)
-		}
-		defer handler.Close()
+			handler, err := NewNoteHandler()
+			if err != nil {
+				t.Fatalf("NewNoteHandler failed: %v", err)
+			}
+			defer handler.Close()
 
-		handler.openInEditorFunc = func(editor, filePath string) error {
-			newContent := `# Updated Title
+			handler.openInEditorFunc = func(editor, filePath string) error {
+				newContent := `# Updated Title
 
 This is updated content.
 
 <!-- Tags: updated, test -->`
-			return os.WriteFile(filePath, []byte(newContent), 0644)
-		}
+				return os.WriteFile(filePath, []byte(newContent), 0644)
+			}
 
-		err = handler.editNote(ctx, 1)
-		if err != nil {
-			t.Errorf("Edit should succeed with mocked editor: %v", err)
-		}
+			err = handler.editNote(ctx, 1)
+			if err != nil {
+				t.Errorf("Edit should succeed with mocked editor: %v", err)
+			}
 
-		note, err := handler.repos.Notes.Get(ctx, 1)
-		if err != nil {
-			t.Fatalf("Failed to get updated note: %v", err)
-		}
+			note, err := handler.repos.Notes.Get(ctx, 1)
+			if err != nil {
+				t.Fatalf("Failed to get updated note: %v", err)
+			}
 
-		if note.Title != "Updated Title" {
-			t.Errorf("Expected title 'Updated Title', got %q", note.Title)
-		}
+			if note.Title != "Updated Title" {
+				t.Errorf("Expected title 'Updated Title', got %q", note.Title)
+			}
 
-		if !strings.Contains(note.Content, "This is updated content") {
-			t.Errorf("Expected content to contain 'This is updated content', got %q", note.Content)
-		}
+			if !strings.Contains(note.Content, "This is updated content") {
+				t.Errorf("Expected content to contain 'This is updated content', got %q", note.Content)
+			}
 
-		expectedTags := []string{"updated", "test"}
-		if len(note.Tags) != len(expectedTags) {
-			t.Errorf("Expected %d tags, got %d", len(expectedTags), len(note.Tags))
-		}
-		for i, tag := range expectedTags {
-			if i >= len(note.Tags) || note.Tags[i] != tag {
-				t.Errorf("Expected tag %q at index %d, got %q", tag, i, note.Tags[i])
+			expectedTags := []string{"updated", "test"}
+			if len(note.Tags) != len(expectedTags) {
+				t.Errorf("Expected %d tags, got %d", len(expectedTags), len(note.Tags))
+			}
+			for i, tag := range expectedTags {
+				if i >= len(note.Tags) || note.Tags[i] != tag {
+					t.Errorf("Expected tag %q at index %d, got %q", tag, i, note.Tags[i])
+				}
 			}
-		}
-	})
+		})
 
-	t.Run("handles editor cancellation (no changes)", func(t *testing.T) {
-		_, cleanup := setupNoteTest(t)
-		defer cleanup()
+		t.Run("handles editor cancellation (no changes)", func(t *testing.T) {
+			_, cleanup := setupNoteTest(t)
+			defer cleanup()
 
-		originalEditor := os.Getenv("EDITOR")
-		os.Setenv("EDITOR", "test-editor")
-		defer os.Setenv("EDITOR", originalEditor)
+			originalEditor := os.Getenv("EDITOR")
+			os.Setenv("EDITOR", "test-editor")
+			defer os.Setenv("EDITOR", originalEditor)
 
-		ctx := context.Background()
+			ctx := context.Background()
 
-		err := Create(ctx, []string{"Test Note", "Test content"})
-		if err != nil {
-			t.Fatalf("Failed to create test note: %v", err)
-		}
+			err := Create(ctx, []string{"Test Note", "Test content"})
+			if err != nil {
+				t.Fatalf("Failed to create test note: %v", err)
+			}
 
-		handler, err := NewNoteHandler()
-		if err != nil {
-			t.Fatalf("NewNoteHandler failed: %v", err)
-		}
-		defer handler.Close()
+			handler, err := NewNoteHandler()
+			if err != nil {
+				t.Fatalf("NewNoteHandler failed: %v", err)
+			}
+			defer handler.Close()
 
-		handler.openInEditorFunc = func(editor, filePath string) error {
-			return nil
-		}
+			handler.openInEditorFunc = func(editor, filePath string) error {
+				return nil
+			}
 
-		err = handler.editNote(ctx, 1)
-		if err != nil {
-			t.Errorf("Edit should handle cancellation gracefully: %v", err)
-		}
+			err = handler.editNote(ctx, 1)
+			if err != nil {
+				t.Errorf("Edit should handle cancellation gracefully: %v", err)
+			}
 
-		note, err := handler.repos.Notes.Get(ctx, 1)
-		if err != nil {
-			t.Fatalf("Failed to get note: %v", err)
-		}
+			note, err := handler.repos.Notes.Get(ctx, 1)
+			if err != nil {
+				t.Fatalf("Failed to get note: %v", err)
+			}
 
-		if note.Title != "Test Note" {
-			t.Errorf("Expected title 'Test Note', got %q", note.Title)
-		}
+			if note.Title != "Test Note" {
+				t.Errorf("Expected title 'Test Note', got %q", note.Title)
+			}
 
-		if note.Content != "Test content" {
-			t.Errorf("Expected content 'Test content', got %q", note.Content)
-		}
+			if note.Content != "Test content" {
+				t.Errorf("Expected content 'Test content', got %q", note.Content)
+			}
+		})
 	})
 }

cmd/handlers/tasks_test.go

···
 	return tempDir, cleanup
 }
 
-func TestTaskHandler_NewTaskHandler(t *testing.T) {
-	t.Run("creates handler successfully", func(t *testing.T) {
-		_, cleanup := setupTaskTest(t)
-		defer cleanup()
+func TestTaskHandler(t *testing.T) {
+	t.Run("New", func(t *testing.T) {
+		t.Run("creates handler successfully", func(t *testing.T) {
+			_, cleanup := setupTaskTest(t)
+			defer cleanup()
 
-		handler, err := NewTaskHandler()
-		if err != nil {
-			t.Errorf("NewTaskHandler failed: %v", err)
-		}
-		if handler == nil {
-			t.Error("Handler should not be nil")
-		}
-		defer handler.Close()
+			handler, err := NewTaskHandler()
+			if err != nil {
+				t.Fatalf("NewTaskHandler failed: %v", err)
+			}
+			if handler == nil {
+				t.Fatal("Handler should not be nil")
+			}
+			defer handler.Close()
 
-		if handler.db == nil {
-			t.Error("Handler database should not be nil")
-		}
-		if handler.config == nil {
-			t.Error("Handler config should not be nil")
-		}
-		if handler.repos == nil {
-			t.Error("Handler repos should not be nil")
-		}
-	})
+			if handler.db == nil {
+				t.Error("Handler database should not be nil")
+			}
+			if handler.config == nil {
+				t.Error("Handler config should not be nil")
+			}
+			if handler.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")
+		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 os.Setenv("XDG_CONFIG_HOME", originalXDG)
-			defer os.Setenv("HOME", originalHome)
-		}
+			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 os.Setenv("XDG_CONFIG_HOME", originalXDG)
+				defer os.Setenv("HOME", originalHome)
+			}
 
-		handler, err := NewTaskHandler()
-		if err == nil {
-			if handler != nil {
-				handler.Close()
+			handler, err := NewTaskHandler()
+			if err == nil {
+				if handler != nil {
+					handler.Close()
+				}
+				t.Error("Expected error when database initialization fails")
 			}
-			t.Error("Expected error when database initialization fails")
-		}
+		})
 	})
-}
 
-func TestCreateTask(t *testing.T) {
-	_, cleanup := setupTaskTest(t)
-	defer cleanup()
+	t.Run("Create", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
 
-	t.Run("creates task successfully", func(t *testing.T) {
-		ctx := context.Background()
-		args := []string{"Buy groceries", "and", "cook dinner"}
+		t.Run("creates task successfully", func(t *testing.T) {
+			ctx := context.Background()
+			args := []string{"Buy groceries", "and", "cook dinner"}
 
-		err := CreateTask(ctx, args)
-		if err != nil {
-			t.Errorf("CreateTask failed: %v", err)
-		}
+			err := CreateTask(ctx, args)
+			if err != nil {
+				t.Errorf("CreateTask failed: %v", err)
+			}
 
-		// Verify task was created by listing tasks
-		handler, err := NewTaskHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
-		defer handler.Close()
+			handler, err := NewTaskHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
+			defer handler.Close()
 
-		tasks, err := handler.repos.Tasks.GetPending(ctx)
-		if err != nil {
-			t.Fatalf("Failed to get pending tasks: %v", err)
-		}
+			tasks, err := handler.repos.Tasks.GetPending(ctx)
+			if err != nil {
+				t.Fatalf("Failed to get pending tasks: %v", err)
+			}
 
-		if len(tasks) != 1 {
-			t.Errorf("Expected 1 task, got %d", len(tasks))
-		}
+			if len(tasks) != 1 {
+				t.Errorf("Expected 1 task, got %d", len(tasks))
+			}
 
-		task := tasks[0]
-		expectedDesc := "Buy groceries and cook dinner"
-		if task.Description != expectedDesc {
-			t.Errorf("Expected description '%s', got '%s'", expectedDesc, task.Description)
-		}
+			task := tasks[0]
+			expectedDesc := "Buy groceries and cook dinner"
+			if task.Description != expectedDesc {
+				t.Errorf("Expected description '%s', got '%s'", expectedDesc, task.Description)
+			}
 
-		if task.Status != "pending" {
-			t.Errorf("Expected status 'pending', got '%s'", task.Status)
-		}
+			if task.Status != "pending" {
+				t.Errorf("Expected status 'pending', got '%s'", task.Status)
+			}
 
-		if task.UUID == "" {
-			t.Error("Task should have a UUID")
-		}
-	})
+			if task.UUID == "" {
+				t.Error("Task should have a UUID")
+			}
+		})
 
-	t.Run("fails with empty description", func(t *testing.T) {
-		ctx := context.Background()
-		args := []string{}
+		t.Run("fails with empty description", func(t *testing.T) {
+			ctx := context.Background()
+			args := []string{}
 
-		err := CreateTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for empty description")
-		}
+			err := CreateTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for empty description")
+			}
 
-		if !strings.Contains(err.Error(), "task description required") {
-			t.Errorf("Expected error about required description, got: %v", err)
-		}
+			if !strings.Contains(err.Error(), "task description required") {
+				t.Errorf("Expected error about required description, got: %v", err)
+			}
+		})
 	})
-}
-
-func TestListTasks(t *testing.T) {
-	_, cleanup := setupTaskTest(t)
-	defer cleanup()
 
-	ctx := context.Background()
-
-	// Create test tasks
-	handler, err := NewTaskHandler()
-	if err != nil {
-		t.Fatalf("Failed to create handler: %v", err)
-	}
-	defer handler.Close()
-
-	// Create a pending task
-	task1 := &models.Task{
-		UUID:        uuid.New().String(),
-		Description: "Task 1",
-		Status:      "pending",
-		Priority:    "A",
-		Project:     "work",
-	}
-	_, err = handler.repos.Tasks.Create(ctx, task1)
-	if err != nil {
-		t.Fatalf("Failed to create task1: %v", err)
-	}
+	t.Run("List", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
 
-	// Create a completed task
-	task2 := &models.Task{
-		UUID:        uuid.New().String(),
-		Description: "Task 2",
-		Status:      "completed",
-	}
-	_, err = handler.repos.Tasks.Create(ctx, task2)
-	if err != nil {
-		t.Fatalf("Failed to create task2: %v", err)
-	}
+		ctx := context.Background()
 
-	t.Run("lists pending tasks by default", func(t *testing.T) {
-		args := []string{}
-
-		err := ListTasks(ctx, args)
+		handler, err := NewTaskHandler()
 		if err != nil {
-			t.Errorf("ListTasks failed: %v", err)
+			t.Fatalf("Failed to create handler: %v", err)
 		}
-	})
-
-	t.Run("filters by status", func(t *testing.T) {
-		args := []string{"--status", "completed"}
+		defer handler.Close()
 
-		err := ListTasks(ctx, args)
-		if err != nil {
-			t.Errorf("ListTasks with status filter failed: %v", err)
+		task1 := &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Task 1",
+			Status:      "pending",
+			Priority:    "A",
+			Project:     "work",
 		}
-	})
-
-	t.Run("filters by priority", func(t *testing.T) {
-		args := []string{"--priority", "A"}
-
-		err := ListTasks(ctx, args)
+		_, err = handler.repos.Tasks.Create(ctx, task1)
 		if err != nil {
-			t.Errorf("ListTasks with priority filter failed: %v", err)
+			t.Fatalf("Failed to create task1: %v", err)
 		}
-	})
 
-	t.Run("filters by project", func(t *testing.T) {
-		args := []string{"--project", "work"}
-
-		err := ListTasks(ctx, args)
+		task2 := &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Task 2",
+			Status:      "completed",
+		}
+		_, err = handler.repos.Tasks.Create(ctx, task2)
 		if err != nil {
-			t.Errorf("ListTasks with project filter failed: %v", err)
+			t.Fatalf("Failed to create task2: %v", err)
 		}
-	})
 
-	t.Run("searches tasks", func(t *testing.T) {
-		args := []string{"--search", "Task"}
+		t.Run("lists pending tasks by default", func(t *testing.T) {
+			args := []string{}
 
-		err := ListTasks(ctx, args)
-		if err != nil {
-			t.Errorf("ListTasks with search failed: %v", err)
-		}
-	})
+			err := ListTasks(ctx, args)
+			if err != nil {
+				t.Errorf("ListTasks failed: %v", err)
+			}
+		})
 
-	t.Run("limits results", func(t *testing.T) {
-		args := []string{"--limit", "1"}
+		t.Run("filters by status", func(t *testing.T) {
+			args := []string{"--status", "completed"}
 
-		err := ListTasks(ctx, args)
-		if err != nil {
-			t.Errorf("ListTasks with limit failed: %v", err)
-		}
-	})
-}
+			err := ListTasks(ctx, args)
+			if err != nil {
+				t.Errorf("ListTasks with status filter failed: %v", err)
+			}
+		})
 
-func TestUpdateTask(t *testing.T) {
-	_, cleanup := setupTaskTest(t)
-	defer cleanup()
+		t.Run("filters by priority", func(t *testing.T) {
+			args := []string{"--priority", "A"}
 
-	ctx := context.Background()
+			err := ListTasks(ctx, args)
+			if err != nil {
+				t.Errorf("ListTasks with priority filter failed: %v", err)
+			}
+		})
 
-	// Create test task
-	handler, err := NewTaskHandler()
-	if err != nil {
-		t.Fatalf("Failed to create handler: %v", err)
-	}
-	defer handler.Close()
+		t.Run("filters by project", func(t *testing.T) {
+			args := []string{"--project", "work"}
 
-	task := &models.Task{
-		UUID:        uuid.New().String(),
-		Description: "Original description",
-		Status:      "pending",
-	}
-	id, err := handler.repos.Tasks.Create(ctx, task)
-	if err != nil {
-		t.Fatalf("Failed to create task: %v", err)
-	}
+			err := ListTasks(ctx, args)
+			if err != nil {
+				t.Errorf("ListTasks with project filter failed: %v", err)
+			}
+		})
 
-	t.Run("updates task by ID", func(t *testing.T) {
-		args := []string{strconv.FormatInt(id, 10), "--description", "Updated description"}
+		t.Run("searches tasks", func(t *testing.T) {
+			args := []string{"--search", "Task"}
 
-		err := UpdateTask(ctx, args)
-		if err != nil {
-			t.Errorf("UpdateTask failed: %v", err)
-		}
+			err := ListTasks(ctx, args)
+			if err != nil {
+				t.Errorf("ListTasks with search failed: %v", err)
+			}
+		})
 
-		// Verify update
-		updatedTask, err := handler.repos.Tasks.Get(ctx, id)
-		if err != nil {
-			t.Fatalf("Failed to get updated task: %v", err)
-		}
+		t.Run("limits results", func(t *testing.T) {
+			args := []string{"--limit", "1"}
 
-		if updatedTask.Description != "Updated description" {
-			t.Errorf("Expected description 'Updated description', got '%s'", updatedTask.Description)
-		}
+			err := ListTasks(ctx, args)
+			if err != nil {
+				t.Errorf("ListTasks with limit failed: %v", err)
+			}
+		})
 	})
 
-	t.Run("updates task by UUID", func(t *testing.T) {
-		args := []string{task.UUID, "--status", "completed"}
+	t.Run("Update", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
 
-		err := UpdateTask(ctx, args)
+		// Create test task
+		handler, err := NewTaskHandler()
 		if err != nil {
-			t.Errorf("UpdateTask by UUID failed: %v", err)
+			t.Fatalf("Failed to create handler: %v", err)
 		}
+		defer handler.Close()
 
-		// Verify update
-		updatedTask, err := handler.repos.Tasks.GetByUUID(ctx, task.UUID)
+		task := &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Original description",
+			Status:      "pending",
+		}
+		id, err := handler.repos.Tasks.Create(ctx, task)
 		if err != nil {
-			t.Fatalf("Failed to get updated task by UUID: %v", err)
+			t.Fatalf("Failed to create task: %v", err)
 		}
 
-		if updatedTask.Status != "completed" {
-			t.Errorf("Expected status 'completed', got '%s'", updatedTask.Status)
-		}
-	})
+		t.Run("updates task by ID", func(t *testing.T) {
+			args := []string{strconv.FormatInt(id, 10), "--description", "Updated description"}
 
-	t.Run("updates multiple fields", func(t *testing.T) {
-		args := []string{
-			strconv.FormatInt(id, 10),
-			"--description", "Multiple updates",
-			"--priority", "B",
-			"--project", "test",
-			"--due", "2024-12-31",
-		}
+			err := UpdateTask(ctx, args)
+			if err != nil {
+				t.Errorf("UpdateTask failed: %v", err)
+			}
 
-		err := UpdateTask(ctx, args)
-		if err != nil {
-			t.Errorf("UpdateTask with multiple fields failed: %v", err)
-		}
+			updatedTask, err := handler.repos.Tasks.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated task: %v", err)
+			}
 
-		// Verify all updates
-		updatedTask, err := handler.repos.Tasks.Get(ctx, id)
-		if err != nil {
-			t.Fatalf("Failed to get updated task: %v", err)
-		}
+			if updatedTask.Description != "Updated description" {
+				t.Errorf("Expected description 'Updated description', got '%s'", updatedTask.Description)
+			}
+		})
 
-		if updatedTask.Description != "Multiple updates" {
-			t.Errorf("Expected description 'Multiple updates', got '%s'", updatedTask.Description)
-		}
-		if updatedTask.Priority != "B" {
-			t.Errorf("Expected priority 'B', got '%s'", updatedTask.Priority)
-		}
-		if updatedTask.Project != "test" {
-			t.Errorf("Expected project 'test', got '%s'", updatedTask.Project)
-		}
-		if updatedTask.Due == nil {
-			t.Error("Expected due date to be set")
-		}
-	})
+		t.Run("updates task by UUID", func(t *testing.T) {
+			args := []string{task.UUID, "--status", "completed"}
 
-	t.Run("adds and removes tags", func(t *testing.T) {
-		args := []string{
-			strconv.FormatInt(id, 10),
-			"--add-tag=work",
-			"--add-tag=urgent",
-		}
+			err := UpdateTask(ctx, args)
+			if err != nil {
+				t.Errorf("UpdateTask by UUID failed: %v", err)
+			}
 
-		err := UpdateTask(ctx, args)
-		if err != nil {
-			t.Errorf("UpdateTask with add tags failed: %v", err)
-		}
+			updatedTask, err := handler.repos.Tasks.GetByUUID(ctx, task.UUID)
+			if err != nil {
+				t.Fatalf("Failed to get updated task by UUID: %v", err)
+			}
 
-		// Verify tags added
-		updatedTask, err := handler.repos.Tasks.Get(ctx, id)
-		if err != nil {
-			t.Fatalf("Failed to get updated task: %v", err)
-		}
+			if updatedTask.Status != "completed" {
+				t.Errorf("Expected status 'completed', got '%s'", updatedTask.Status)
+			}
+		})
 
-		if len(updatedTask.Tags) != 2 {
-			t.Errorf("Expected 2 tags, got %d", len(updatedTask.Tags))
-		}
+		t.Run("updates multiple fields", func(t *testing.T) {
+			args := []string{
+				strconv.FormatInt(id, 10),
+				"--description", "Multiple updates",
+				"--priority", "B",
+				"--project", "test",
+				"--due", "2024-12-31",
+			}
 
-		// Remove a tag
-		args = []string{
-			strconv.FormatInt(id, 10),
-			"--remove-tag=urgent",
-		}
+			err := UpdateTask(ctx, args)
+			if err != nil {
+				t.Errorf("UpdateTask with multiple fields failed: %v", err)
+			}
 
-		err = UpdateTask(ctx, args)
-		if err != nil {
-			t.Errorf("UpdateTask with remove tag failed: %v", err)
-		}
+			// Verify all updates
+			updatedTask, err := handler.repos.Tasks.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated task: %v", err)
+			}
 
-		// Verify tag removed
-		updatedTask, err = handler.repos.Tasks.Get(ctx, id)
-		if err != nil {
-			t.Fatalf("Failed to get updated task: %v", err)
-		}
+			if updatedTask.Description != "Multiple updates" {
+				t.Errorf("Expected description 'Multiple updates', got '%s'", updatedTask.Description)
+			}
+			if updatedTask.Priority != "B" {
+				t.Errorf("Expected priority 'B', got '%s'", updatedTask.Priority)
+			}
+			if updatedTask.Project != "test" {
+				t.Errorf("Expected project 'test', got '%s'", updatedTask.Project)
+			}
+			if updatedTask.Due == nil {
+				t.Error("Expected due date to be set")
+			}
+		})
 
-		if len(updatedTask.Tags) != 1 {
-			t.Errorf("Expected 1 tag after removal, got %d", len(updatedTask.Tags))
-		}
+		t.Run("adds and removes tags", func(t *testing.T) {
+			args := []string{
+				strconv.FormatInt(id, 10),
+				"--add-tag=work",
+				"--add-tag=urgent",
+			}
 
-		if updatedTask.Tags[0] != "work" {
-			t.Errorf("Expected remaining tag 'work', got '%s'", updatedTask.Tags[0])
-		}
-	})
+			err := UpdateTask(ctx, args)
+			if err != nil {
+				t.Errorf("UpdateTask with add tags failed: %v", err)
+			}
 
-	t.Run("fails with missing task ID", func(t *testing.T) {
-		args := []string{}
+			updatedTask, err := handler.repos.Tasks.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated task: %v", err)
+			}
 
-		err := UpdateTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for missing task ID")
-		}
+			if len(updatedTask.Tags) != 2 {
+				t.Errorf("Expected 2 tags, got %d", len(updatedTask.Tags))
+			}
 
-		if !strings.Contains(err.Error(), "task ID required") {
-			t.Errorf("Expected error about required task ID, got: %v", err)
-		}
-	})
+			args = []string{
+				strconv.FormatInt(id, 10),
+				"--remove-tag=urgent",
+			}
 
-	t.Run("fails with invalid task ID", func(t *testing.T) {
-		args := []string{"99999", "--description", "test"}
+			err = UpdateTask(ctx, args)
+			if err != nil {
+				t.Errorf("UpdateTask with remove tag failed: %v", err)
+			}
 
-		err := UpdateTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for invalid task ID")
-		}
+			updatedTask, err = handler.repos.Tasks.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get updated task: %v", err)
+			}
 
-		if !strings.Contains(err.Error(), "failed to find task") {
-			t.Errorf("Expected error about task not found, got: %v", err)
-		}
-	})
-}
+			if len(updatedTask.Tags) != 1 {
+				t.Errorf("Expected 1 tag after removal, got %d", len(updatedTask.Tags))
+			}
 
-func TestDeleteTask(t *testing.T) {
-	_, cleanup := setupTaskTest(t)
-	defer cleanup()
+			if updatedTask.Tags[0] != "work" {
+				t.Errorf("Expected remaining tag 'work', got '%s'", updatedTask.Tags[0])
+			}
+		})
 
-	ctx := context.Background()
+		t.Run("fails with missing task ID", func(t *testing.T) {
+			args := []string{}
 
-	// Create test task
-	handler, err := NewTaskHandler()
-	if err != nil {
-		t.Fatalf("Failed to create handler: %v", err)
-	}
-	defer handler.Close()
+			err := UpdateTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for missing task ID")
+			}
 
-	task := &models.Task{
-		UUID:        uuid.New().String(),
-		Description: "Task to delete",
-		Status:      "pending",
-	}
-	id, err := handler.repos.Tasks.Create(ctx, task)
-	if err != nil {
-		t.Fatalf("Failed to create task: %v", err)
-	}
+			if !strings.Contains(err.Error(), "task ID required") {
+				t.Errorf("Expected error about required task ID, got: %v", err)
+			}
+		})
 
-	t.Run("deletes task by ID", func(t *testing.T) {
-		args := []string{strconv.FormatInt(id, 10)}
+		t.Run("fails with invalid task ID", func(t *testing.T) {
+			args := []string{"99999", "--description", "test"}
 
-		err := DeleteTask(ctx, args)
-		if err != nil {
-			t.Errorf("DeleteTask failed: %v", err)
-		}
+			err := UpdateTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for invalid task ID")
+			}
 
-		// Verify task was deleted
-		_, err = handler.repos.Tasks.Get(ctx, id)
-		if err == nil {
-			t.Error("Expected error when getting deleted task")
-		}
+			if !strings.Contains(err.Error(), "failed to find task") {
+				t.Errorf("Expected error about task not found, got: %v", err)
+			}
+		})
 	})
 
-	t.Run("deletes task by UUID", func(t *testing.T) {
-		// Create another task to delete by UUID
-		task2 := &models.Task{
+	t.Run("Delete", 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()
+
+		task := &models.Task{
 			UUID:        uuid.New().String(),
-			Description: "Task to delete by UUID",
+			Description: "Task to delete",
 			Status:      "pending",
 		}
-		_, err := handler.repos.Tasks.Create(ctx, task2)
+		id, err := handler.repos.Tasks.Create(ctx, task)
 		if err != nil {
-			t.Fatalf("Failed to create task2: %v", err)
+			t.Fatalf("Failed to create task: %v", err)
 		}
 
-		args := []string{task2.UUID}
+		t.Run("deletes task by ID", func(t *testing.T) {
+			args := []string{strconv.FormatInt(id, 10)}
 
-		err = DeleteTask(ctx, args)
-		if err != nil {
-			t.Errorf("DeleteTask by UUID failed: %v", err)
-		}
+			err := DeleteTask(ctx, args)
+			if err != nil {
+				t.Errorf("DeleteTask failed: %v", err)
+			}
 
-		// Verify task was deleted
-		_, err = handler.repos.Tasks.GetByUUID(ctx, task2.UUID)
-		if err == nil {
-			t.Error("Expected error when getting deleted task by UUID")
-		}
-	})
+			_, err = handler.repos.Tasks.Get(ctx, id)
+			if err == nil {
+				t.Error("Expected error when getting deleted task")
+			}
+		})
 
-	t.Run("fails with missing task ID", func(t *testing.T) {
-		args := []string{}
+		t.Run("deletes task by UUID", func(t *testing.T) {
+			task2 := &models.Task{
+				UUID:        uuid.New().String(),
+				Description: "Task to delete by UUID",
+				Status:      "pending",
+			}
+			_, err := handler.repos.Tasks.Create(ctx, task2)
+			if err != nil {
+				t.Fatalf("Failed to create task2: %v", err)
+			}
 
-		err := DeleteTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for missing task ID")
-		}
+			args := []string{task2.UUID}
 
-		if !strings.Contains(err.Error(), "task ID required") {
-			t.Errorf("Expected error about required task ID, got: %v", err)
-		}
-	})
+			err = DeleteTask(ctx, args)
+			if err != nil {
+				t.Errorf("DeleteTask by UUID failed: %v", err)
+			}
 
-	t.Run("fails with invalid task ID", func(t *testing.T) {
-		args := []string{"99999"}
+			_, err = handler.repos.Tasks.GetByUUID(ctx, task2.UUID)
+			if err == nil {
+				t.Error("Expected error when getting deleted task by UUID")
+			}
+		})
 
-		err := DeleteTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for invalid task ID")
-		}
+		t.Run("fails with missing task ID", func(t *testing.T) {
+			args := []string{}
 
-		if !strings.Contains(err.Error(), "failed to find task") {
-			t.Errorf("Expected error about task not found, got: %v", err)
-		}
-	})
-}
+			err := DeleteTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for missing task ID")
+			}
 
-func TestViewTask(t *testing.T) {
-	_, cleanup := setupTaskTest(t)
-	defer cleanup()
+			if !strings.Contains(err.Error(), "task ID required") {
+				t.Errorf("Expected error about required task ID, got: %v", err)
+			}
+		})
 
-	ctx := context.Background()
+		t.Run("fails with invalid task ID", func(t *testing.T) {
+			args := []string{"99999"}
 
-	// Create test task
-	handler, err := NewTaskHandler()
-	if err != nil {
-		t.Fatalf("Failed to create handler: %v", err)
-	}
-	defer handler.Close()
+			err := DeleteTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for invalid task ID")
+			}
 
-	now := time.Now()
-	task := &models.Task{
-		UUID:        uuid.New().String(),
-		Description: "Task to view",
-		Status:      "pending",
-		Priority:    "A",
-		Project:     "test",
-		Tags:        []string{"work", "important"},
-		Entry:       now,
-		Modified:    now,
-	}
-	id, err := handler.repos.Tasks.Create(ctx, task)
-	if err != nil {
-		t.Fatalf("Failed to create task: %v", err)
-	}
-
-	t.Run("views task by ID", func(t *testing.T) {
-		args := []string{strconv.FormatInt(id, 10)}
-
-		err := ViewTask(ctx, args)
-		if err != nil {
-			t.Errorf("ViewTask failed: %v", err)
-		}
+			if !strings.Contains(err.Error(), "failed to find task") {
+				t.Errorf("Expected error about task not found, got: %v", err)
+			}
+		})
 	})
 
-	t.Run("views task by UUID", func(t *testing.T) {
-		args := []string{task.UUID}
+	t.Run("View", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
 
-		err := ViewTask(ctx, args)
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
 		if err != nil {
-			t.Errorf("ViewTask by UUID failed: %v", err)
+			t.Fatalf("Failed to create handler: %v", err)
 		}
-	})
-
-	t.Run("fails with missing task ID", func(t *testing.T) {
-		args := []string{}
+		defer handler.Close()
 
-		err := ViewTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for missing task ID")
+		now := time.Now()
+		task := &models.Task{
+			UUID:        uuid.New().String(),
+			Description: "Task to view",
+			Status:      "pending",
+			Priority:    "A",
+			Project:     "test",
+			Tags:        []string{"work", "important"},
+			Entry:       now,
+			Modified:    now,
 		}
-
-		if !strings.Contains(err.Error(), "task ID required") {
-			t.Errorf("Expected error about required task ID, got: %v", err)
+		id, err := handler.repos.Tasks.Create(ctx, task)
+		if err != nil {
+			t.Fatalf("Failed to create task: %v", err)
 		}
-	})
 
-	t.Run("fails with invalid task ID", func(t *testing.T) {
-		args := []string{"99999"}
+		t.Run("views task by ID", func(t *testing.T) {
+			args := []string{strconv.FormatInt(id, 10)}
 
-		err := ViewTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for invalid task ID")
-		}
+			err := ViewTask(ctx, args)
+			if err != nil {
+				t.Errorf("ViewTask failed: %v", err)
+			}
+		})
 
-		if !strings.Contains(err.Error(), "failed to find task") {
-			t.Errorf("Expected error about task not found, got: %v", err)
-		}
-	})
-}
+		t.Run("views task by UUID", func(t *testing.T) {
+			args := []string{task.UUID}
 
-func TestDoneTask(t *testing.T) {
-	_, cleanup := setupTaskTest(t)
-	defer cleanup()
+			err := ViewTask(ctx, args)
+			if err != nil {
+				t.Errorf("ViewTask by UUID failed: %v", err)
+			}
+		})
 
-	ctx := context.Background()
+		t.Run("fails with missing task ID", func(t *testing.T) {
+			args := []string{}
 
-	// Create test task
-	handler, err := NewTaskHandler()
-	if err != nil {
-		t.Fatalf("Failed to create handler: %v", err)
-	}
-	defer handler.Close()
+			err := ViewTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for missing task ID")
+			}
 
-	task := &models.Task{
-		UUID:        uuid.New().String(),
-		Description: "Task to complete",
-		Status:      "pending",
-	}
-	id, err := handler.repos.Tasks.Create(ctx, task)
-	if err != nil {
-		t.Fatalf("Failed to create task: %v", err)
-	}
+			if !strings.Contains(err.Error(), "task ID required") {
+				t.Errorf("Expected error about required task ID, got: %v", err)
+			}
+		})
 
-	t.Run("marks task as done by ID", func(t *testing.T) {
-		args := []string{strconv.FormatInt(id, 10)}
+		t.Run("fails with invalid task ID", func(t *testing.T) {
+			args := []string{"99999"}
 
-		err := DoneTask(ctx, args)
-		if err != nil {
-			t.Errorf("DoneTask failed: %v", err)
-		}
+			err := ViewTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for invalid task ID")
+			}
 
-		// Verify task was marked as completed
-		completedTask, err := handler.repos.Tasks.Get(ctx, id)
-		if err != nil {
-			t.Fatalf("Failed to get completed task: %v", err)
-		}
-
-		if completedTask.Status != "completed" {
-			t.Errorf("Expected status 'completed', got '%s'", completedTask.Status)
-		}
-
-		if completedTask.End == nil {
-			t.Error("Expected end time to be set")
-		}
+			if !strings.Contains(err.Error(), "failed to find task") {
+				t.Errorf("Expected error about task not found, got: %v", err)
+			}
+		})
 	})
 
-	t.Run("handles already completed task", func(t *testing.T) {
-		// Create another task and complete it first
-		task2 := &models.Task{
-			UUID:        uuid.New().String(),
-			Description: "Already completed task",
-			Status:      "completed",
-		}
-		id2, err := handler.repos.Tasks.Create(ctx, task2)
-		if err != nil {
-			t.Fatalf("Failed to create task2: %v", err)
-		}
+	t.Run("Done", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
 
-		args := []string{strconv.FormatInt(id2, 10)}
+		ctx := context.Background()
 
-		err = DoneTask(ctx, args)
+		handler, err := NewTaskHandler()
 		if err != nil {
-			t.Errorf("DoneTask on completed task failed: %v", err)
+			t.Fatalf("Failed to create handler: %v", err)
 		}
-	})
+		defer handler.Close()
 
-	t.Run("marks task as done by UUID", func(t *testing.T) {
-		// Create another pending task
-		task3 := &models.Task{
+		task := &models.Task{
 			UUID:        uuid.New().String(),
-			Description: "Task to complete by UUID",
+			Description: "Task to complete",
 			Status:      "pending",
 		}
-		_, err := handler.repos.Tasks.Create(ctx, task3)
+		id, err := handler.repos.Tasks.Create(ctx, task)
 		if err != nil {
-			t.Fatalf("Failed to create task3: %v", err)
+			t.Fatalf("Failed to create task: %v", err)
 		}
 
-		args := []string{task3.UUID}
+		t.Run("marks task as done by ID", func(t *testing.T) {
+			args := []string{strconv.FormatInt(id, 10)}
 
-		err = DoneTask(ctx, args)
-		if err != nil {
-			t.Errorf("DoneTask by UUID failed: %v", err)
-		}
+			err := DoneTask(ctx, args)
+			if err != nil {
+				t.Errorf("DoneTask failed: %v", err)
+			}
 
-		// Verify task was marked as completed
-		completedTask, err := handler.repos.Tasks.GetByUUID(ctx, task3.UUID)
-		if err != nil {
-			t.Fatalf("Failed to get completed task by UUID: %v", err)
-		}
+			completedTask, err := handler.repos.Tasks.Get(ctx, id)
+			if err != nil {
+				t.Fatalf("Failed to get completed task: %v", err)
+			}
 
-		if completedTask.Status != "completed" {
-			t.Errorf("Expected status 'completed', got '%s'", completedTask.Status)
-		}
+			if completedTask.Status != "completed" {
+				t.Errorf("Expected status 'completed', got '%s'", completedTask.Status)
+			}
 
-		if completedTask.End == nil {
-			t.Error("Expected end time to be set")
-		}
-	})
+			if completedTask.End == nil {
+				t.Error("Expected end time to be set")
+			}
+		})
 
-	t.Run("fails with missing task ID", func(t *testing.T) {
-		args := []string{}
+		t.Run("handles already completed task", func(t *testing.T) {
+			task2 := &models.Task{
+				UUID:        uuid.New().String(),
+				Description: "Already completed task",
+				Status:      "completed",
+			}
+			id2, err := handler.repos.Tasks.Create(ctx, task2)
+			if err != nil {
+				t.Fatalf("Failed to create task2: %v", err)
+			}
 
-		err := DoneTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for missing task ID")
-		}
+			args := []string{strconv.FormatInt(id2, 10)}
 
-		if !strings.Contains(err.Error(), "task ID required") {
-			t.Errorf("Expected error about required task ID, got: %v", err)
-		}
-	})
+			err = DoneTask(ctx, args)
+			if err != nil {
+				t.Errorf("DoneTask on completed task failed: %v", err)
+			}
+		})
 
-	t.Run("fails with invalid task ID", func(t *testing.T) {
-		args := []string{"99999"}
+		t.Run("marks task as done by UUID", func(t *testing.T) {
+			task3 := &models.Task{
+				UUID:        uuid.New().String(),
+				Description: "Task to complete by UUID",
+				Status:      "pending",
+			}
+			_, err := handler.repos.Tasks.Create(ctx, task3)
+			if err != nil {
+				t.Fatalf("Failed to create task3: %v", err)
+			}
 
-		err := DoneTask(ctx, args)
-		if err == nil {
-			t.Error("Expected error for invalid task ID")
-		}
+			args := []string{task3.UUID}
 
-		if !strings.Contains(err.Error(), "failed to find task") {
-			t.Errorf("Expected error about task not found, got: %v", err)
-		}
-	})
-}
+			err = DoneTask(ctx, args)
+			if err != nil {
+				t.Errorf("DoneTask by UUID failed: %v", err)
+			}
 
-func TestHelperFunctions(t *testing.T) {
-	t.Run("contains function", func(t *testing.T) {
-		slice := []string{"a", "b", "c"}
+			completedTask, err := handler.repos.Tasks.GetByUUID(ctx, task3.UUID)
+			if err != nil {
+				t.Fatalf("Failed to get completed task by UUID: %v", err)
+			}
 
-		if !contains(slice, "b") {
-			t.Error("Expected contains to return true for existing item")
-		}
+			if completedTask.Status != "completed" {
+				t.Errorf("Expected status 'completed', got '%s'", completedTask.Status)
+			}
 
-		if contains(slice, "d") {
-			t.Error("Expected contains to return false for non-existing item")
-		}
-	})
+			if completedTask.End == nil {
+				t.Error("Expected end time to be set")
+			}
+		})
 
-	t.Run("removeString function", func(t *testing.T) {
-		slice := []string{"a", "b", "c", "b"}
-		result := removeString(slice, "b")
+		t.Run("fails with missing task ID", func(t *testing.T) {
+			args := []string{}
 
-		if len(result) != 2 {
-			t.Errorf("Expected 2 items after removing 'b', got %d", len(result))
-		}
+			err := DoneTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for missing task ID")
+			}
 
-		if contains(result, "b") {
-			t.Error("Expected 'b' to be removed from slice")
-		}
+			if !strings.Contains(err.Error(), "task ID required") {
+				t.Errorf("Expected error about required task ID, got: %v", err)
+			}
+		})
 
-		if !contains(result, "a") || !contains(result, "c") {
-			t.Error("Expected 'a' and 'c' to remain in slice")
-		}
+		t.Run("fails with invalid task ID", func(t *testing.T) {
+			args := []string{"99999"}
+
+			err := DoneTask(ctx, args)
+			if err == nil {
+				t.Error("Expected error for invalid task ID")
+			}
+
+			if !strings.Contains(err.Error(), "failed to find task") {
+				t.Errorf("Expected error about task not found, got: %v", err)
+			}
+		})
 	})
-}
 
-func TestPrintFunctions(t *testing.T) {
-	_, cleanup := setupTaskTest(t)
-	defer cleanup()
+	t.Run("Helper", func(t *testing.T) {
+		t.Run("contains function", func(t *testing.T) {
+			slice := []string{"a", "b", "c"}
 
-	handler, err := NewTaskHandler()
-	if err != nil {
-		t.Fatalf("Failed to create handler: %v", err)
-	}
-	defer handler.Close()
+			if !contains(slice, "b") {
+				t.Error("Expected contains to return true for existing item")
+			}
 
-	now := time.Now()
-	due := now.Add(24 * time.Hour)
+			if contains(slice, "d") {
+				t.Error("Expected contains to return false for non-existing item")
+			}
+		})
 
-	task := &models.Task{
-		ID:          1,
-		UUID:        uuid.New().String(),
-		Description: "Test task",
-		Status:      "pending",
-		Priority:    "A",
-		Project:     "test",
-		Tags:        []string{"work", "urgent"},
-		Due:         &due,
-		Entry:       now,
-		Modified:    now,
-	}
+		t.Run("removeString function", func(t *testing.T) {
+			slice := []string{"a", "b", "c", "b"}
+			result := removeString(slice, "b")
+
+			if len(result) != 2 {
+				t.Errorf("Expected 2 items after removing 'b', got %d", len(result))
+			}
 
-	// Test that print functions don't panic
-	t.Run("printTask doesn't panic", func(t *testing.T) {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Errorf("printTask panicked: %v", r)
+			if contains(result, "b") {
+				t.Error("Expected 'b' to be removed from slice")
 			}
-		}()
 
-		handler.printTask(task)
+			if !contains(result, "a") || !contains(result, "c") {
+				t.Error("Expected 'a' and 'c' to remain in slice")
+			}
+		})
 	})
 
-	t.Run("printTaskDetail doesn't panic", func(t *testing.T) {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Errorf("printTaskDetail panicked: %v", r)
-			}
-		}()
+	t.Run("Print", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		now := time.Now()
+		due := now.Add(24 * time.Hour)
+
+		task := &models.Task{
+			ID:          1,
+			UUID:        uuid.New().String(),
+			Description: "Test task",
+			Status:      "pending",
+			Priority:    "A",
+			Project:     "test",
+			Tags:        []string{"work", "urgent"},
+			Due:         &due,
+			Entry:       now,
+			Modified:    now,
+		}
+
+		t.Run("printTask doesn't panic", func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					t.Errorf("printTask panicked: %v", r)
+				}
+			}()
+
+			handler.printTask(task)
+		})
+
+		t.Run("printTaskDetail doesn't panic", func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					t.Errorf("printTaskDetail panicked: %v", r)
+				}
+			}()
 
-		handler.printTaskDetail(task)
+			handler.printTaskDetail(task)
+		})
 	})
-}
+}

internal/ui/book_list.go

···
 	"io"
 	"os"
 	"strings"
+	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/huh"
···
 
 // BookListOptions configures the book list UI behavior
 type BookListOptions struct {
-	Output     io.Writer // Output destination (stdout for interactive, buffer for testing)
-	Input      io.Reader // Input source (stdin for interactive, strings reader for testing)
-	StaticMode bool      // Enable static mode for testing (no interactive components)
+	// 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
 }
 
 // BookList handles book search and selection UI
···
 type bookAddedMsg *models.Book
 
 func (m searchModel) Init() tea.Cmd {
-	return nil
+	return m.searchBooks(m.query)
 }
 
 func (m searchModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
···
 	case bookAddedMsg:
 		m.addedBook = (*models.Book)(msg)
 		m.confirmed = true
-		return m, tea.Quit
+		return m, tea.Tick(2*time.Second, func(t time.Time) tea.Msg {
+			return tea.Quit()
+		})
 	}
 	return m, nil
 }
···
 
 // SearchAndSelect searches for books with the given query and allows selection
 func (bl *BookList) SearchAndSelect(ctx context.Context, query string) error {
-	if bl.opts.StaticMode {
-		return bl.searchAndSelectStatic(ctx, query)
+	if bl.opts.Static {
+		return bl.staticSelect(ctx, query)
 	}
 
 	model := searchModel{
···
 
 	program := tea.NewProgram(model, tea.WithInput(bl.opts.Input), tea.WithOutput(bl.opts.Output))
 
-	program.Send(tea.Cmd(model.searchBooks(query)))
-
 	_, err := program.Run()
 	return err
 }
 
-func (bl *BookList) searchAndSelectStatic(ctx context.Context, query string) error {
+func (bl *BookList) staticSelect(ctx context.Context, query string) error {
 	results, err := bl.service.Search(ctx, query, 1, 10)
 	if err != nil {
 		fmt.Fprintf(bl.opts.Output, "Error: %s\n", err)
···
 
 // InteractiveSearch provides an interactive search interface
 func (bl *BookList) InteractiveSearch(ctx context.Context) error {
-	if bl.opts.StaticMode {
-		return bl.interactiveSearchStatic(ctx)
+	if bl.opts.Static {
+		return bl.staticSearch(ctx)
 	}
 
 	var query string
···
 	return bl.SearchAndSelect(ctx, query)
 }
 
-func (bl *BookList) interactiveSearchStatic(ctx context.Context) error {
+func (bl *BookList) staticSearch(ctx context.Context) error {
 	fmt.Fprintf(bl.opts.Output, "Search for books: test query\n")
-	return bl.searchAndSelectStatic(ctx, "test query")
+	return bl.staticSelect(ctx, "test query")
 }

internal/ui/book_list_test.go

···
 	t.Run("Options", func(t *testing.T) {
 		t.Run("default options", func(t *testing.T) {
 			opts := BookListOptions{}
-			if opts.StaticMode {
+			if opts.Static {
 				t.Error("StaticMode should default to false")
 			}
 		})
···
 		t.Run("static mode enabled", func(t *testing.T) {
 			var buf bytes.Buffer
 			opts := BookListOptions{
-				Output:     &buf,
-				StaticMode: true,
+				Output: &buf,
+				Static: true,
 			}
 
-			if !opts.StaticMode {
+			if !opts.Static {
 				t.Error("StaticMode should be enabled")
 			}
 			if opts.Output != &buf {
···
 				service: service,
 				repo:    nil,
 				opts: BookListOptions{
-					Output:     &buf,
-					StaticMode: true,
+					Output: &buf,
+					Static: true,
 				},
 			}
 
-			err := bl.searchAndSelectStatic(context.Background(), "test query")
+			err := bl.staticSelect(context.Background(), "test query")
 			if err == nil {
 				t.Fatal("Expected error, got nil")
 			}
···
 				service: service,
 				repo:    nil,
 				opts: BookListOptions{
-					Output:     &buf,
-					StaticMode: true,
+					Output: &buf,
+					Static: true,
 				},
 			}
 
-			err := bl.searchAndSelectStatic(context.Background(), "nonexistent")
+			err := bl.staticSelect(context.Background(), "nonexistent")
 			if err != nil {
 				t.Fatalf("searchAndSelectStatic failed: %v", err)
 			}
···
 				// Skip repo operations for this test
 				// repo:    nil,
 				opts: BookListOptions{
-					Output:     &buf,
-					StaticMode: true,
+					Output: &buf,
+					Static: true,
 				},
 			}
 
···
 				service: service,
 				repo:    nil,
 				opts: BookListOptions{
-					Output:     &buf,
-					StaticMode: true,
+					Output: &buf,
+					Static: true,
 				},
 			}
 
-			err := bl.interactiveSearchStatic(context.Background())
+			err := bl.staticSearch(context.Background())
 			if err != nil {
 				t.Fatalf("InteractiveSearch failed: %v", err)
 			}