fix: resolve test failures and improve code quality

- Fix file handle leak in SetDebugLog by tracking and closing previous files
- Add stderr capture to all taskwarrior commands for better error messages
- Fix timezone issues in date handling tests by normalizing to UTC
- Change Update method to pointer receiver for consistency
- Update all test type assertions to handle pointer receivers correctly
- Remove unused imports and variables

All tests now pass successfully.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

9 files changed, 1807 insertions, 756 deletions

diff --git a/internal/task/operations_test.go b/internal/task/operations_test.go
new file mode 100644
index 0000000..7abd4bd
--- /dev/null
+++ b/internal/task/operations_test.go
@@ -0,0 +1,133 @@
+package task
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestModifyTask(t *testing.T) {
+	tests := []struct {
+		name    string
+		id      int
+		args    []string
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name:    "valid ID",
+			id:      1,
+			args:    []string{"status:pending"},
+			wantErr: false,
+		},
+		{
+			name:    "zero ID",
+			id:      0,
+			args:    []string{"status:pending"},
+			wantErr: true,
+			errMsg:  "invalid task ID: 0",
+		},
+		{
+			name:    "negative ID",
+			id:      -1,
+			args:    []string{"status:pending"},
+			wantErr: true,
+			errMsg:  "invalid task ID: -1",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := modifyTask(tt.id, tt.args...)
+			
+			// We can't test actual taskwarrior commands without it installed
+			// So we just test the validation
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("modifyTask() error = nil, wantErr %v", tt.wantErr)
+				} else if !strings.Contains(err.Error(), tt.errMsg) {
+					t.Errorf("modifyTask() error = %v, want error containing %v", err, tt.errMsg)
+				}
+			}
+		})
+	}
+}
+
+func TestSimpleTaskCommand(t *testing.T) {
+	tests := []struct {
+		name    string
+		id      int
+		command string
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name:    "valid ID",
+			id:      1,
+			command: "done",
+			wantErr: false,
+		},
+		{
+			name:    "zero ID",
+			id:      0,
+			command: "done",
+			wantErr: true,
+			errMsg:  "invalid task ID: 0",
+		},
+		{
+			name:    "negative ID",
+			id:      -5,
+			command: "done",
+			wantErr: true,
+			errMsg:  "invalid task ID: -5",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := simpleTaskCommand(tt.id, tt.command)
+			
+			// We can't test actual taskwarrior commands without it installed
+			// So we just test the validation
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("simpleTaskCommand() error = nil, wantErr %v", tt.wantErr)
+				} else if !strings.Contains(err.Error(), tt.errMsg) {
+					t.Errorf("simpleTaskCommand() error = %v, want error containing %v", err, tt.errMsg)
+				}
+			}
+		})
+	}
+}
+
+func TestTaskOperationsValidation(t *testing.T) {
+	// Test that all task operations validate IDs
+	invalidID := -1
+	
+	operations := []struct {
+		name string
+		fn   func() error
+	}{
+		{"SetStatus", func() error { return SetStatus(invalidID, "pending") }},
+		{"Start", func() error { return Start(invalidID) }},
+		{"Stop", func() error { return Stop(invalidID) }},
+		{"Done", func() error { return Done(invalidID) }},
+		{"Delete", func() error { return Delete(invalidID) }},
+		{"SetPriority", func() error { return SetPriority(invalidID, "H") }},
+		{"SetRecurrence", func() error { return SetRecurrence(invalidID, "daily") }},
+		{"SetDueDate", func() error { return SetDueDate(invalidID, "tomorrow") }},
+		{"SetDescription", func() error { return SetDescription(invalidID, "test") }},
+		{"Annotate", func() error { return Annotate(invalidID, "note") }},
+		{"Denotate", func() error { return Denotate(invalidID, "note") }},
+	}
+	
+	for _, op := range operations {
+		t.Run(op.name, func(t *testing.T) {
+			err := op.fn()
+			if err == nil {
+				t.Errorf("%s() with invalid ID = nil, want error", op.name)
+			} else if !strings.Contains(err.Error(), "invalid task ID") {
+				t.Errorf("%s() error = %v, want error containing 'invalid task ID'", op.name, err)
+			}
+		})
+	}
+}
\ No newline at end of file
diff --git a/internal/task/task.go b/internal/task/task.go
index be3b6ce..86c93f4 100644
--- a/internal/task/task.go
+++ b/internal/task/task.go
@@ -155,12 +155,25 @@ func run(args ...string) error {
 	return nil
 }
 
-// SetStatus changes the status of the task with the given id.
-func SetStatus(id int, status string) error {
+// modifyTask runs a modify command with validation
+func modifyTask(id int, args ...string) error {
 	if id <= 0 {
 		return fmt.Errorf("invalid task ID: %d", id)
 	}
-	return run(strconv.Itoa(id), "modify", "status:"+status)
+	return run(append([]string{strconv.Itoa(id), "modify"}, args...)...)
+}
+
+// simpleTaskCommand runs a simple command on a task with validation
+func simpleTaskCommand(id int, command string) error {
+	if id <= 0 {
+		return fmt.Errorf("invalid task ID: %d", id)
+	}
+	return run(strconv.Itoa(id), command)
+}
+
+// SetStatus changes the status of the task with the given id.
+func SetStatus(id int, status string) error {
+	return modifyTask(id, "status:"+status)
 }
 
 // SetStatusUUID changes the status of the task with the given UUID.
@@ -170,42 +183,27 @@ func SetStatusUUID(uuid, status string) error {
 
 // Start begins the task with the given id.
 func Start(id int) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "start")
+	return simpleTaskCommand(id, "start")
 }
 
 // Stop stops the task with the given id.
 func Stop(id int) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "stop")
+	return simpleTaskCommand(id, "stop")
 }
 
 // Done marks the task with the given id as completed.
 func Done(id int) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "done")
+	return simpleTaskCommand(id, "done")
 }
 
 // Delete removes the task with the given id.
 func Delete(id int) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "delete")
+	return simpleTaskCommand(id, "delete")
 }
 
 // SetPriority changes the priority of the task with the given id.
 func SetPriority(id int, priority string) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "modify", "priority:"+priority)
+	return modifyTask(id, "priority:"+priority)
 }
 
 // AddTags adds tags to the task with the given id.
@@ -287,26 +285,17 @@ func SetTags(id int, tags []string) error {
 
 // SetRecurrence sets the recurrence for the task with the given id.
 func SetRecurrence(id int, rec string) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "modify", "recur:"+rec)
+	return modifyTask(id, "recur:"+rec)
 }
 
 // SetDueDate sets the due date for the task with the given id.
 func SetDueDate(id int, due string) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "modify", "due:"+due)
+	return modifyTask(id, "due:"+due)
 }
 
 // SetDescription changes the description of the task with the given id.
 func SetDescription(id int, desc string) error {
-	if id <= 0 {
-		return fmt.Errorf("invalid task ID: %d", id)
-	}
-	return run(strconv.Itoa(id), "modify", "description:"+desc)
+	return modifyTask(id, "description:"+desc)
 }
 
 // Annotate adds an annotation to the task with the given id.
@@ -388,7 +377,16 @@ func Edit(id int) error {
 // Started tasks are always placed before non-started ones. Tasks without a due
 // date are placed after tasks with a due date. Overdue tasks are placed at the
 // very top regardless of other properties.
+//
+// The sort order is:
+// 1. Overdue tasks (oldest due date first)
+// 2. Started tasks (not completed)
+// 3. High priority tasks
+// 4. Tasks with earlier due dates
+// 5. Tasks sorted alphabetically by tags
+// 6. Tasks sorted by ID (oldest first)
 func SortTasks(tasks []Task) {
+	// Helper to join tags in a consistent order for comparison
 	joinTags := func(tags []string) string {
 		if len(tags) == 0 {
 			return ""
@@ -398,6 +396,7 @@ func SortTasks(tasks []Task) {
 		return strings.Join(cpy, " ")
 	}
 
+	// Convert priority to numeric value for comparison (higher = more important)
 	priVal := func(p string) int {
 		switch p {
 		case "H":
@@ -411,6 +410,7 @@ func SortTasks(tasks []Task) {
 		}
 	}
 
+	// Parse due date string into time.Time
 	parseDue := func(s string) (time.Time, bool) {
 		if s == "" {
 			return time.Time{}, false
@@ -422,6 +422,7 @@ func SortTasks(tasks []Task) {
 		return t, true
 	}
 
+	// Check if a task is overdue
 	overdue := func(t Task) bool {
 		du, ok := parseDue(t.Due)
 		return ok && time.Now().After(du)
diff --git a/internal/ui/handlers.go b/internal/ui/handlers.go
new file mode 100644
index 0000000..7fc734b
--- /dev/null
+++ b/internal/ui/handlers.go
@@ -0,0 +1,437 @@
+package ui
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/x/ansi"
+
+	"codeberg.org/snonux/tasksamurai/internal/task"
+)
+
+// handleTextInput provides generic text input handling for all input modes
+func (m *Model) handleTextInput(msg tea.KeyMsg, input *textinput.Model, onEnter func(string) error, onExit func()) (tea.Model, tea.Cmd) {
+	switch msg.Type {
+	case tea.KeyEnter:
+		value := input.Value()
+		if err := onEnter(value); err != nil {
+			m.statusMsg = fmt.Sprintf("Error: %v", err)
+			cmd := tea.Tick(3*time.Second, func(time.Time) tea.Msg {
+				return struct{ clearStatus bool }{true}
+			})
+			return m, cmd
+		}
+		input.Blur()
+		onExit()
+		m.updateTableHeight()
+		return m, nil
+	case tea.KeyEsc:
+		input.Blur()
+		onExit()
+		m.updateTableHeight()
+		return m, nil
+	}
+	var cmd tea.Cmd
+	*input, cmd = input.Update(msg)
+	return m, cmd
+}
+
+// handleAnnotationMode handles keyboard input when in annotation mode
+func (m *Model) handleAnnotationMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	onEnter := func(value string) error {
+		// Annotation can be empty when replacing (to remove all)
+		if !m.replaceAnnotations && strings.TrimSpace(value) == "" {
+			return fmt.Errorf("annotation cannot be empty")
+		}
+		
+		if m.replaceAnnotations {
+			if err := task.ReplaceAnnotations(m.annotateID, value); err != nil {
+				return err
+			}
+			m.replaceAnnotations = false
+		} else {
+			if err := task.Annotate(m.annotateID, value); err != nil {
+				return err
+			}
+		}
+		m.reload()
+		return nil
+	}
+	
+	onExit := func() {
+		m.annotating = false
+		m.replaceAnnotations = false
+	}
+	
+	model, cmd := m.handleTextInput(msg, &m.annotateInput, onEnter, onExit)
+	if msg.Type == tea.KeyEnter && m.annotateInput.Value() != "" {
+		// Start blink after successful annotation
+		return model, m.startBlink(m.annotateID, false)
+	}
+	return model, cmd
+}
+
+// handleDescriptionMode handles keyboard input when editing description
+func (m *Model) handleDescriptionMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	onEnter := func(value string) error {
+		if err := validateDescription(value); err != nil {
+			return err
+		}
+		if err := task.SetDescription(m.descID, value); err != nil {
+			return err
+		}
+		m.reload()
+		return nil
+	}
+	
+	onExit := func() {
+		m.descEditing = false
+	}
+	
+	model, cmd := m.handleTextInput(msg, &m.descInput, onEnter, onExit)
+	if msg.Type == tea.KeyEnter {
+		return model, m.startBlink(m.descID, false)
+	}
+	return model, cmd
+}
+
+// handleTagsMode handles keyboard input when editing tags
+func (m *Model) handleTagsMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	onEnter := func(value string) error {
+		words := strings.Fields(value)
+		var adds, removes []string
+		for _, w := range words {
+			if strings.HasPrefix(w, "-") {
+				if len(w) > 1 {
+					tagName := w[1:]
+					if err := validateTagName(tagName); err != nil {
+						return fmt.Errorf("remove tag '%s': %w", tagName, err)
+					}
+					removes = append(removes, tagName)
+				}
+			} else {
+				if strings.HasPrefix(w, "+") {
+					w = w[1:]
+				}
+				if w != "" {
+					if err := validateTagName(w); err != nil {
+						return fmt.Errorf("add tag '%s': %w", w, err)
+					}
+					adds = append(adds, w)
+				}
+			}
+		}
+		if len(adds) > 0 {
+			if err := task.AddTags(m.tagsID, adds); err != nil {
+				return err
+			}
+		}
+		if len(removes) > 0 {
+			if err := task.RemoveTags(m.tagsID, removes); err != nil {
+				return err
+			}
+		}
+		m.reload()
+		return nil
+	}
+	
+	onExit := func() {
+		m.tagsEditing = false
+	}
+	
+	model, cmd := m.handleTextInput(msg, &m.tagsInput, onEnter, onExit)
+	if msg.Type == tea.KeyEnter {
+		return model, m.startBlink(m.tagsID, false)
+	}
+	return model, cmd
+}
+
+// handleDueEditMode handles due date editing
+func (m *Model) handleDueEditMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.Type {
+	case tea.KeyEnter:
+		if err := task.SetDueDate(m.dueID, m.dueDate.Format("2006-01-02")); err != nil {
+			m.statusMsg = fmt.Sprintf("Error: %v", err)
+			cmd := tea.Tick(3*time.Second, func(time.Time) tea.Msg {
+				return struct{ clearStatus bool }{true}
+			})
+			return m, cmd
+		}
+		m.dueEditing = false
+		m.reload()
+		cmd := m.startBlink(m.dueID, false)
+		m.updateTableHeight()
+		return m, cmd
+	case tea.KeyEsc:
+		m.dueEditing = false
+		m.updateTableHeight()
+		return m, nil
+	}
+	
+	switch msg.String() {
+	case "h", "left":
+		m.dueDate = m.dueDate.AddDate(0, 0, -1)
+	case "l", "right":
+		m.dueDate = m.dueDate.AddDate(0, 0, 1)
+	case "k", "up":
+		m.dueDate = m.dueDate.AddDate(0, 0, -7)
+	case "j", "down":
+		m.dueDate = m.dueDate.AddDate(0, 0, 7)
+	}
+	return m, nil
+}
+
+// handleRecurrenceMode handles recurrence editing
+func (m *Model) handleRecurrenceMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	onEnter := func(value string) error {
+		if err := validateRecurrence(value); err != nil {
+			return err
+		}
+		if err := task.SetRecurrence(m.recurID, value); err != nil {
+			return err
+		}
+		m.reload()
+		return nil
+	}
+	
+	onExit := func() {
+		m.recurEditing = false
+	}
+	
+	model, cmd := m.handleTextInput(msg, &m.recurInput, onEnter, onExit)
+	if msg.Type == tea.KeyEnter {
+		return model, m.startBlink(m.recurID, false)
+	}
+	return model, cmd
+}
+
+// handlePriorityMode handles priority selection
+func (m *Model) handlePriorityMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.Type {
+	case tea.KeyEnter:
+		priority := priorityOptions[m.priorityIndex]
+		if err := validatePriority(priority); err != nil {
+			m.statusMsg = fmt.Sprintf("Error: %v", err)
+			cmd := tea.Tick(3*time.Second, func(time.Time) tea.Msg {
+				return struct{ clearStatus bool }{true}
+			})
+			return m, cmd
+		}
+		if err := task.SetPriority(m.priorityID, priority); err != nil {
+			m.statusMsg = fmt.Sprintf("Error: %v", err)
+			cmd := tea.Tick(3*time.Second, func(time.Time) tea.Msg {
+				return struct{ clearStatus bool }{true}
+			})
+			return m, cmd
+		}
+		m.prioritySelecting = false
+		m.reload()
+		cmd := m.startBlink(m.priorityID, false)
+		m.updateTableHeight()
+		return m, cmd
+	case tea.KeyEsc:
+		m.prioritySelecting = false
+		m.updateTableHeight()
+		return m, nil
+	}
+	
+	switch msg.String() {
+	case "h", "left":
+		m.priorityIndex = (m.priorityIndex + len(priorityOptions) - 1) % len(priorityOptions)
+	case "l", "right":
+		m.priorityIndex = (m.priorityIndex + 1) % len(priorityOptions)
+	}
+	return m, nil
+}
+
+// handleFilterMode handles filter editing
+func (m *Model) handleFilterMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	onEnter := func(value string) error {
+		m.filters = strings.Fields(value)
+		m.reload()
+		return nil
+	}
+	
+	onExit := func() {
+		m.filterEditing = false
+	}
+	
+	return m.handleTextInput(msg, &m.filterInput, onEnter, onExit)
+}
+
+// handleAddTaskMode handles adding a new task
+func (m *Model) handleAddTaskMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.Type {
+	case tea.KeyEnter:
+		oldIDs := make(map[int]struct{})
+		for _, tsk := range m.tasks {
+			oldIDs[tsk.ID] = struct{}{}
+		}
+		
+		if err := task.AddLine(m.addInput.Value()); err != nil {
+			m.statusMsg = fmt.Sprintf("Error: %v", err)
+			cmd := tea.Tick(3*time.Second, func(time.Time) tea.Msg {
+				return struct{ clearStatus bool }{true}
+			})
+			return m, cmd
+		}
+		
+		m.addingTask = false
+		m.addInput.Blur()
+		m.reload()
+		
+		// Find the newly added task
+		var newID int
+		row := -1
+		for i, tsk := range m.tasks {
+			if _, ok := oldIDs[tsk.ID]; !ok {
+				newID = tsk.ID
+				row = i
+				break
+			}
+		}
+		
+		m.updateTableHeight()
+		if row >= 0 {
+			prevRow := m.tbl.Cursor()
+			prevCol := m.tbl.ColumnCursor()
+			m.tbl.SetCursor(row)
+			m.tbl.SetColumnCursor(7) // Description column
+			m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
+			return m, m.startBlink(newID, false)
+		}
+		return m, nil
+		
+	case tea.KeyEsc:
+		m.addingTask = false
+		m.addInput.Blur()
+		m.updateTableHeight()
+		return m, nil
+	}
+	
+	var cmd tea.Cmd
+	m.addInput, cmd = m.addInput.Update(msg)
+	return m, cmd
+}
+
+// handleSearchMode handles search input
+func (m *Model) handleSearchMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.Type {
+	case tea.KeyEnter:
+		pattern := m.searchInput.Value()
+		if pattern != "" {
+			// Check cache first
+			if cached, ok := searchRegexCache[pattern]; ok {
+				m.searchRegex = cached
+			} else {
+				// Compile and cache if not found
+				re, err := compileAndCacheRegex(pattern)
+				if err == nil {
+					m.searchRegex = re
+				} else {
+					m.searchRegex = nil
+					m.statusMsg = fmt.Sprintf("Invalid regex: %v", err)
+				}
+			}
+		} else {
+			m.searchRegex = nil
+		}
+		m.searching = false
+		m.searchInput.Blur()
+		m.reload()
+		m.updateTableHeight()
+		
+		if len(m.searchMatches) > 0 {
+			match := m.searchMatches[m.searchIndex]
+			prevRow := m.tbl.Cursor()
+			prevCol := m.tbl.ColumnCursor()
+			m.tbl.SetCursor(match.row)
+			m.tbl.SetColumnCursor(match.col)
+			m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
+		}
+		return m, nil
+		
+	case tea.KeyEsc:
+		m.searching = false
+		m.searchInput.Blur()
+		m.updateTableHeight()
+		return m, nil
+	}
+	
+	var cmd tea.Cmd
+	m.searchInput, cmd = m.searchInput.Update(msg)
+	return m, cmd
+}
+
+// handleBlinkingState handles input when a task is blinking
+func (m *Model) handleBlinkingState(msg tea.Msg) (tea.Model, tea.Cmd) {
+	if _, ok := msg.(tea.KeyMsg); ok {
+		// Only allow navigation while blinking
+		prevRow := m.tbl.Cursor()
+		prevCol := m.tbl.ColumnCursor()
+		var cmd tea.Cmd
+		m.tbl, cmd = m.tbl.Update(msg)
+		if prevRow != m.tbl.Cursor() || prevCol != m.tbl.ColumnCursor() {
+			m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
+		}
+		return m, cmd
+	}
+	return m, nil
+}
+
+// handleEditingModes checks if we're in any editing mode and handles it
+func (m *Model) handleEditingModes(msg tea.KeyMsg) (handled bool, model tea.Model, cmd tea.Cmd) {
+	switch {
+	case m.annotating:
+		model, cmd = m.handleAnnotationMode(msg)
+		return true, model, cmd
+	case m.descEditing:
+		model, cmd = m.handleDescriptionMode(msg)
+		return true, model, cmd
+	case m.tagsEditing:
+		model, cmd = m.handleTagsMode(msg)
+		return true, model, cmd
+	case m.dueEditing:
+		model, cmd = m.handleDueEditMode(msg)
+		return true, model, cmd
+	case m.recurEditing:
+		model, cmd = m.handleRecurrenceMode(msg)
+		return true, model, cmd
+	case m.prioritySelecting:
+		model, cmd = m.handlePriorityMode(msg)
+		return true, model, cmd
+	case m.filterEditing:
+		model, cmd = m.handleFilterMode(msg)
+		return true, model, cmd
+	case m.addingTask:
+		model, cmd = m.handleAddTaskMode(msg)
+		return true, model, cmd
+	case m.searching:
+		model, cmd = m.handleSearchMode(msg)
+		return true, model, cmd
+	}
+	return false, m, nil
+}
+
+// getSelectedTaskID extracts the task ID from the selected row
+func (m *Model) getSelectedTaskID() (int, error) {
+	row := m.tbl.SelectedRow()
+	if row == nil {
+		return 0, fmt.Errorf("no row selected")
+	}
+	idStr := ansi.Strip(row[1])
+	return strconv.Atoi(idStr)
+}
+
+// getTaskAtCursor returns the task at the current cursor position
+func (m *Model) getTaskAtCursor() *task.Task {
+	cursor := m.tbl.Cursor()
+	if cursor < 0 || cursor >= len(m.tasks) {
+		return nil
+	}
+	return &m.tasks[cursor]
+}
\ No newline at end of file
diff --git a/internal/ui/helpers.go b/internal/ui/helpers.go
new file mode 100644
index 0000000..71c21db
--- /dev/null
+++ b/internal/ui/helpers.go
@@ -0,0 +1,191 @@
+package ui
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+)
+
+// Date format used by Taskwarrior
+const taskDateFormat = "20060102T150405Z"
+
+// parseTaskDate parses a date string in Taskwarrior format
+func parseTaskDate(dateStr string) (time.Time, error) {
+	if dateStr == "" {
+		return time.Time{}, fmt.Errorf("empty date string")
+	}
+	return time.Parse(taskDateFormat, dateStr)
+}
+
+// formatTaskDate formats a time as a Taskwarrior date string
+func formatTaskDate(t time.Time) string {
+	return t.UTC().Format(taskDateFormat)
+}
+
+// daysSince returns the number of days since the given time
+func daysSince(t time.Time) int {
+	return int(time.Since(t).Hours() / 24)
+}
+
+// daysUntil returns the number of days until the given time
+func daysUntil(t time.Time) int {
+	now := time.Now()
+	// Normalize both times to midnight UTC to avoid timezone and fractional day issues
+	today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
+	target := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC)
+	return int(target.Sub(today).Hours() / 24)
+}
+
+// formatDueText returns a human-readable due date string
+func formatDueText(dueStr string) string {
+	if dueStr == "" {
+		return ""
+	}
+	
+	ts, err := parseTaskDate(dueStr)
+	if err != nil {
+		return dueStr
+	}
+	
+	days := daysUntil(ts)
+	switch days {
+	case 0:
+		return "today"
+	case 1:
+		return "tomorrow"
+	case -1:
+		return "yesterday"
+	default:
+		return fmt.Sprintf("%dd", days)
+	}
+}
+
+// compileAndCacheRegex compiles a regex and adds it to the cache
+func compileAndCacheRegex(pattern string) (*regexp.Regexp, error) {
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return nil, err
+	}
+	
+	// Limit cache size to prevent memory leak
+	if len(searchRegexCache) > 100 {
+		// Clear cache when it gets too large
+		searchRegexCache = make(map[string]*regexp.Regexp)
+	}
+	searchRegexCache[pattern] = re
+	
+	return re, nil
+}
+
+// Validation functions
+
+// validateTagName validates a tag name
+func validateTagName(tag string) error {
+	if tag == "" {
+		return fmt.Errorf("tag cannot be empty")
+	}
+	
+	// Remove leading + or - for validation
+	tag = strings.TrimPrefix(strings.TrimPrefix(tag, "+"), "-")
+	
+	// Check for invalid characters
+	if strings.ContainsAny(tag, " \t\n\r") {
+		return fmt.Errorf("tag cannot contain whitespace")
+	}
+	
+	return nil
+}
+
+// validateTags validates a list of tags
+func validateTags(tags []string) error {
+	for _, tag := range tags {
+		if err := validateTagName(tag); err != nil {
+			return fmt.Errorf("invalid tag '%s': %w", tag, err)
+		}
+	}
+	return nil
+}
+
+// validateDueDate validates a due date string
+func validateDueDate(due string) error {
+	if due == "" {
+		return nil // Empty due date is valid
+	}
+	
+	// Try common formats
+	formats := []string{
+		"2006-01-02",
+		"2006-01-02T15:04:05",
+		"2006-01-02T15:04:05Z",
+		taskDateFormat,
+	}
+	
+	for _, format := range formats {
+		if _, err := time.Parse(format, due); err == nil {
+			return nil
+		}
+	}
+	
+	// Check for relative dates that taskwarrior understands
+	relatives := []string{"now", "today", "tomorrow", "yesterday", "monday", "tuesday", 
+		"wednesday", "thursday", "friday", "saturday", "sunday", "eod", "eow", "eom", "eoy"}
+	
+	due = strings.ToLower(due)
+	for _, rel := range relatives {
+		if due == rel || strings.HasPrefix(due, rel+"+") || strings.HasPrefix(due, rel+"-") {
+			return nil
+		}
+	}
+	
+	return fmt.Errorf("invalid due date format: %s", due)
+}
+
+// validatePriority validates a priority value
+func validatePriority(priority string) error {
+	switch priority {
+	case "", "H", "M", "L":
+		return nil
+	default:
+		return fmt.Errorf("invalid priority: %s (must be H, M, L, or empty)", priority)
+	}
+}
+
+// validateRecurrence validates a recurrence string
+func validateRecurrence(recur string) error {
+	if recur == "" {
+		return nil // Empty recurrence is valid
+	}
+	
+	// Basic validation - taskwarrior will do the full validation
+	if len(recur) < 2 {
+		return fmt.Errorf("recurrence too short")
+	}
+	
+	// Check for common patterns
+	validPrefixes := []string{"daily", "weekly", "monthly", "yearly", "biweekly", "bimonthly"}
+	for _, prefix := range validPrefixes {
+		if strings.HasPrefix(strings.ToLower(recur), prefix) {
+			return nil
+		}
+	}
+	
+	// Check for duration format (e.g., "3d", "2w", "1m")
+	if len(recur) >= 2 {
+		last := recur[len(recur)-1]
+		if (last == 'd' || last == 'w' || last == 'm' || last == 'y') && 
+			recur[:len(recur)-1] != "" {
+			return nil
+		}
+	}
+	
+	return nil // Let taskwarrior handle complex validation
+}
+
+// validateDescription validates a task description
+func validateDescription(desc string) error {
+	if strings.TrimSpace(desc) == "" {
+		return fmt.Errorf("description cannot be empty")
+	}
+	return nil
+}
\ No newline at end of file
diff --git a/internal/ui/helpers_test.go b/internal/ui/helpers_test.go
new file mode 100644
index 0000000..9ba620c
--- /dev/null
+++ b/internal/ui/helpers_test.go
@@ -0,0 +1,363 @@
+package ui
+
+import (
+	"testing"
+	"time"
+)
+
+func TestParseTaskDate(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		wantErr bool
+	}{
+		{
+			name:    "valid date",
+			input:   "20250627T150405Z",
+			wantErr: false,
+		},
+		{
+			name:    "empty string",
+			input:   "",
+			wantErr: true,
+		},
+		{
+			name:    "invalid format",
+			input:   "2025-06-27",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := parseTaskDate(tt.input)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("parseTaskDate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestFormatDueText(t *testing.T) {
+	now := time.Now()
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "empty",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "today",
+			input:    now.UTC().Format("20060102T150405Z"),
+			expected: "today",
+		},
+		{
+			name:     "tomorrow",
+			input:    now.Add(24 * time.Hour).UTC().Format("20060102T150405Z"),
+			expected: "tomorrow",
+		},
+		{
+			name:     "yesterday",
+			input:    now.Add(-24 * time.Hour).UTC().Format("20060102T150405Z"),
+			expected: "yesterday",
+		},
+		{
+			name:     "future",
+			input:    now.Add(5 * 24 * time.Hour).UTC().Format("20060102T150405Z"),
+			expected: "5d",
+		},
+		{
+			name:     "past",
+			input:    now.Add(-3 * 24 * time.Hour).UTC().Format("20060102T150405Z"),
+			expected: "-3d",
+		},
+		{
+			name:     "invalid",
+			input:    "invalid",
+			expected: "invalid",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := formatDueText(tt.input)
+			if got != tt.expected {
+				t.Errorf("formatDueText() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestValidateTagName(t *testing.T) {
+	tests := []struct {
+		name    string
+		tag     string
+		wantErr bool
+	}{
+		{
+			name:    "valid tag",
+			tag:     "work",
+			wantErr: false,
+		},
+		{
+			name:    "valid with plus",
+			tag:     "+work",
+			wantErr: false,
+		},
+		{
+			name:    "valid with minus",
+			tag:     "-work",
+			wantErr: false,
+		},
+		{
+			name:    "empty tag",
+			tag:     "",
+			wantErr: true,
+		},
+		{
+			name:    "tag with space",
+			tag:     "my tag",
+			wantErr: true,
+		},
+		{
+			name:    "tag with tab",
+			tag:     "my\ttag",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateTagName(tt.tag)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validateTagName() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestValidatePriority(t *testing.T) {
+	tests := []struct {
+		name     string
+		priority string
+		wantErr  bool
+	}{
+		{
+			name:     "high",
+			priority: "H",
+			wantErr:  false,
+		},
+		{
+			name:     "medium",
+			priority: "M",
+			wantErr:  false,
+		},
+		{
+			name:     "low",
+			priority: "L",
+			wantErr:  false,
+		},
+		{
+			name:     "empty",
+			priority: "",
+			wantErr:  false,
+		},
+		{
+			name:     "invalid",
+			priority: "X",
+			wantErr:  true,
+		},
+		{
+			name:     "lowercase",
+			priority: "h",
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validatePriority(tt.priority)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validatePriority() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestValidateDescription(t *testing.T) {
+	tests := []struct {
+		name    string
+		desc    string
+		wantErr bool
+	}{
+		{
+			name:    "valid description",
+			desc:    "Fix the bug",
+			wantErr: false,
+		},
+		{
+			name:    "empty description",
+			desc:    "",
+			wantErr: true,
+		},
+		{
+			name:    "whitespace only",
+			desc:    "   ",
+			wantErr: true,
+		},
+		{
+			name:    "description with whitespace",
+			desc:    "  Fix the bug  ",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateDescription(tt.desc)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validateDescription() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestValidateDueDate(t *testing.T) {
+	tests := []struct {
+		name    string
+		due     string
+		wantErr bool
+	}{
+		{
+			name:    "empty",
+			due:     "",
+			wantErr: false,
+		},
+		{
+			name:    "ISO date",
+			due:     "2025-06-27",
+			wantErr: false,
+		},
+		{
+			name:    "ISO datetime",
+			due:     "2025-06-27T15:04:05",
+			wantErr: false,
+		},
+		{
+			name:    "ISO datetime with Z",
+			due:     "2025-06-27T15:04:05Z",
+			wantErr: false,
+		},
+		{
+			name:    "taskwarrior format",
+			due:     "20250627T150405Z",
+			wantErr: false,
+		},
+		{
+			name:    "relative - today",
+			due:     "today",
+			wantErr: false,
+		},
+		{
+			name:    "relative - tomorrow",
+			due:     "tomorrow",
+			wantErr: false,
+		},
+		{
+			name:    "relative - monday",
+			due:     "monday",
+			wantErr: false,
+		},
+		{
+			name:    "relative - eod",
+			due:     "eod",
+			wantErr: false,
+		},
+		{
+			name:    "relative - tomorrow+2d",
+			due:     "tomorrow+2d",
+			wantErr: false,
+		},
+		{
+			name:    "invalid format",
+			due:     "27/06/2025",
+			wantErr: true,
+		},
+		{
+			name:    "invalid relative",
+			due:     "someday",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateDueDate(tt.due)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validateDueDate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestValidateRecurrence(t *testing.T) {
+	tests := []struct {
+		name    string
+		recur   string
+		wantErr bool
+	}{
+		{
+			name:    "empty",
+			recur:   "",
+			wantErr: false,
+		},
+		{
+			name:    "daily",
+			recur:   "daily",
+			wantErr: false,
+		},
+		{
+			name:    "weekly",
+			recur:   "weekly",
+			wantErr: false,
+		},
+		{
+			name:    "3 days",
+			recur:   "3d",
+			wantErr: false,
+		},
+		{
+			name:    "2 weeks",
+			recur:   "2w",
+			wantErr: false,
+		},
+		{
+			name:    "1 month",
+			recur:   "1m",
+			wantErr: false,
+		},
+		{
+			name:    "too short",
+			recur:   "d",
+			wantErr: true,
+		},
+		{
+			name:    "single char",
+			recur:   "x",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateRecurrence(tt.recur)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validateRecurrence() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
\ No newline at end of file
diff --git a/internal/ui/keyhandlers.go b/internal/ui/keyhandlers.go
new file mode 100644
index 0000000..780ee8c
--- /dev/null
+++ b/internal/ui/keyhandlers.go
@@ -0,0 +1,493 @@
+package ui
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"codeberg.org/snonux/tasksamurai/internal/task"
+)
+
+// handleNormalMode handles keyboard input in normal mode (not editing)
+func (m *Model) handleNormalMode(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "H":
+		return m.handleToggleHelp()
+	case "q", "esc":
+		return m.handleQuitOrEscape()
+	case "e", "E":
+		return m.handleEditTask()
+	case "s":
+		return m.handleToggleStart()
+	case "d":
+		return m.handleMarkDone()
+	case "o":
+		return m.handleOpenURL()
+	case "U":
+		return m.handleUndo()
+	case "D":
+		return m.handleSetDueDate()
+	case "r":
+		return m.handleRandomDueDate()
+	case "R":
+		return m.handleSetRecurrence()
+	case "p":
+		return m.handleSetPriority()
+	case "a":
+		return m.handleAnnotate(false)
+	case "A":
+		return m.handleAnnotate(true)
+	case "f":
+		return m.handleFilter()
+	case "+":
+		return m.handleAddTask()
+	case "t":
+		return m.handleEditTags()
+	case "c":
+		return m.handleRandomTheme()
+	case "C":
+		return m.handleResetTheme()
+	case "x":
+		return m.handleToggleDisco()
+	case " ":
+		return m.handleRefresh()
+	case "/", "?":
+		return m.handleSearch()
+	case "n":
+		return m.handleNextSearchMatch()
+	case "N":
+		return m.handlePrevSearchMatch()
+	case "enter", "i":
+		return m.handleEnterOrEdit()
+	default:
+		// Pass through to table for navigation
+		return m.handleTableNavigation(msg)
+	}
+}
+
+func (m *Model) handleToggleHelp() (tea.Model, tea.Cmd) {
+	m.showHelp = true
+	return m, nil
+}
+
+func (m *Model) handleQuitOrEscape() (tea.Model, tea.Cmd) {
+	if m.cellExpanded {
+		m.cellExpanded = false
+		m.updateTableHeight()
+		return m, nil
+	}
+	if m.showHelp {
+		m.showHelp = false
+		return m, nil
+	}
+	if m.searchRegex != nil {
+		m.searchRegex = nil
+		m.searchMatches = nil
+		m.searchIndex = 0
+		m.reload()
+		return m, nil
+	}
+	return m, tea.Quit
+}
+
+func (m *Model) handleEditTask() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	m.editID = id
+	return m, editCmd(id)
+}
+
+func (m *Model) handleToggleStart() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	
+	// Check if task is started
+	started := false
+	for _, tsk := range m.tasks {
+		if tsk.ID == id {
+			started = tsk.Start != ""
+			break
+		}
+	}
+	
+	if started {
+		if err := task.Stop(id); err != nil {
+			m.showError(err)
+			return m, nil
+		}
+	} else {
+		if err := task.Start(id); err != nil {
+			m.showError(err)
+			return m, nil
+		}
+	}
+	
+	m.reload()
+	return m, m.startBlink(id, false)
+}
+
+func (m *Model) handleMarkDone() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	return m, m.startBlink(id, true)
+}
+
+func (m *Model) handleOpenURL() (tea.Model, tea.Cmd) {
+	task := m.getTaskAtCursor()
+	if task == nil {
+		return m, nil
+	}
+	
+	url := urlRegex.FindString(task.Description)
+	if url == "" {
+		return m, nil
+	}
+	
+	if err := exec.Command(m.browserCmd, url).Run(); err != nil {
+		m.showError(fmt.Errorf("opening browser: %w", err))
+		return m, nil
+	}
+	
+	return m, m.startBlink(task.ID, false)
+}
+
+func (m *Model) handleUndo() (tea.Model, tea.Cmd) {
+	if len(m.undoStack) == 0 {
+		return m, nil
+	}
+	
+	uuid := m.undoStack[len(m.undoStack)-1]
+	m.undoStack = m.undoStack[:len(m.undoStack)-1]
+	
+	if err := task.SetStatusUUID(uuid, "pending"); err != nil {
+		m.showError(err)
+		return m, nil
+	}
+	
+	m.reload()
+	
+	// Find the task ID for blinking
+	var id int
+	for _, tsk := range m.tasks {
+		if tsk.UUID == uuid {
+			id = tsk.ID
+			break
+		}
+	}
+	
+	return m, m.startBlink(id, false)
+}
+
+func (m *Model) handleSetDueDate() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	
+	m.clearEditingModes()
+	m.dueID = id
+	m.dueEditing = true
+	m.dueDate = time.Now()
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleRandomDueDate() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	
+	days := rng.Intn(31) + 7
+	due := time.Now().AddDate(0, 0, days).Format("2006-01-02")
+	
+	if err := task.SetDueDate(id, due); err != nil {
+		m.showError(err)
+		return m, nil
+	}
+	
+	m.reload()
+	return m, m.startBlink(id, false)
+}
+
+func (m *Model) handleSetRecurrence() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	
+	task := m.getTaskAtCursor()
+	if task == nil {
+		return m, nil
+	}
+	
+	m.clearEditingModes()
+	m.recurID = id
+	m.recurEditing = true
+	m.recurInput.SetValue(task.Recur)
+	m.recurInput.Focus()
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleSetPriority() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	
+	m.clearEditingModes()
+	m.priorityID = id
+	m.prioritySelecting = true
+	m.priorityIndex = 0
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleAnnotate(replace bool) (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	
+	m.clearEditingModes()
+	m.annotateID = id
+	m.annotating = true
+	m.replaceAnnotations = replace
+	m.annotateInput.SetValue("")
+	m.annotateInput.Focus()
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleFilter() (tea.Model, tea.Cmd) {
+	m.clearEditingModes()
+	m.filterEditing = true
+	m.filterInput.SetValue(strings.Join(m.filters, " "))
+	m.filterInput.Focus()
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleAddTask() (tea.Model, tea.Cmd) {
+	m.clearEditingModes()
+	m.addingTask = true
+	m.addInput.SetValue("")
+	m.addInput.Focus()
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleEditTags() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		return m, nil
+	}
+	
+	m.clearEditingModes()
+	m.tagsID = id
+	m.tagsEditing = true
+	m.tagsInput.SetValue("")
+	m.tagsInput.Focus()
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleRandomTheme() (tea.Model, tea.Cmd) {
+	m.theme = RandomTheme()
+	m.applyTheme()
+	return m, nil
+}
+
+func (m *Model) handleResetTheme() (tea.Model, tea.Cmd) {
+	m.theme = m.defaultTheme
+	m.applyTheme()
+	return m, nil
+}
+
+func (m *Model) handleToggleDisco() (tea.Model, tea.Cmd) {
+	m.disco = !m.disco
+	return m, nil
+}
+
+func (m *Model) handleRefresh() (tea.Model, tea.Cmd) {
+	m.reload()
+	return m, nil
+}
+
+func (m *Model) handleSearch() (tea.Model, tea.Cmd) {
+	m.clearEditingModes()
+	m.searching = true
+	m.searchIndex = 0
+	m.searchMatches = nil
+	m.searchInput.SetValue("")
+	m.searchInput.Focus()
+	m.updateTableHeight()
+	return m, nil
+}
+
+func (m *Model) handleNextSearchMatch() (tea.Model, tea.Cmd) {
+	if len(m.searchMatches) == 0 {
+		return m, nil
+	}
+	
+	m.searchIndex = (m.searchIndex + 1) % len(m.searchMatches)
+	match := m.searchMatches[m.searchIndex]
+	prevRow := m.tbl.Cursor()
+	prevCol := m.tbl.ColumnCursor()
+	m.tbl.SetCursor(match.row)
+	m.tbl.SetColumnCursor(match.col)
+	m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
+	return m, nil
+}
+
+func (m *Model) handlePrevSearchMatch() (tea.Model, tea.Cmd) {
+	if len(m.searchMatches) == 0 {
+		return m, nil
+	}
+	
+	m.searchIndex = (m.searchIndex - 1 + len(m.searchMatches)) % len(m.searchMatches)
+	match := m.searchMatches[m.searchIndex]
+	prevRow := m.tbl.Cursor()
+	prevCol := m.tbl.ColumnCursor()
+	m.tbl.SetCursor(match.row)
+	m.tbl.SetColumnCursor(match.col)
+	m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
+	return m, nil
+}
+
+func (m *Model) handleEnterOrEdit() (tea.Model, tea.Cmd) {
+	id, err := m.getSelectedTaskID()
+	if err != nil {
+		// No task selected, toggle cell expansion
+		m.cellExpanded = !m.cellExpanded
+		m.updateTableHeight()
+		return m, nil
+	}
+	
+	col := m.tbl.ColumnCursor()
+	switch col {
+	case 0: // Priority
+		m.clearEditingModes()
+		m.priorityID = id
+		m.prioritySelecting = true
+		
+		// Set current priority index
+		task := m.getTaskAtCursor()
+		if task != nil {
+			switch task.Priority {
+			case "H":
+				m.priorityIndex = 0
+			case "M":
+				m.priorityIndex = 1
+			case "L":
+				m.priorityIndex = 2
+			default:
+				m.priorityIndex = 3
+			}
+		}
+		m.updateTableHeight()
+		return m, nil
+		
+	case 3: // Due date
+		m.dueID = id
+		task := m.getTaskAtCursor()
+		if task != nil && task.Due != "" {
+			if ts, err := parseTaskDate(task.Due); err == nil {
+				m.dueDate = ts
+			} else {
+				m.dueDate = time.Now()
+			}
+		} else {
+			m.dueDate = time.Now()
+		}
+		m.clearEditingModes()
+		m.dueEditing = true
+		m.updateTableHeight()
+		return m, nil
+		
+	case 4: // Recurrence
+		m.clearEditingModes()
+		m.recurID = id
+		m.recurEditing = true
+		task := m.getTaskAtCursor()
+		if task != nil {
+			m.recurInput.SetValue(task.Recur)
+		}
+		m.recurInput.Focus()
+		m.updateTableHeight()
+		return m, nil
+		
+	case 5: // Tags
+		m.clearEditingModes()
+		m.tagsID = id
+		m.tagsEditing = true
+		m.tagsInput.SetValue("")
+		m.tagsInput.Focus()
+		m.updateTableHeight()
+		return m, nil
+		
+	case 6: // Annotations
+		m.clearEditingModes()
+		m.annotateID = id
+		m.annotating = true
+		m.replaceAnnotations = true
+		
+		// Get current annotations
+		task := m.getTaskAtCursor()
+		if task != nil {
+			var anns []string
+			for _, a := range task.Annotations {
+				anns = append(anns, a.Description)
+			}
+			m.annotateInput.SetValue(strings.Join(anns, "; "))
+		}
+		m.annotateInput.Focus()
+		m.updateTableHeight()
+		return m, nil
+		
+	case 7: // Description
+		m.clearEditingModes()
+		m.descID = id
+		m.descEditing = true
+		task := m.getTaskAtCursor()
+		if task != nil {
+			m.descInput.SetValue(task.Description)
+		}
+		m.descInput.Focus()
+		m.updateTableHeight()
+		return m, nil
+		
+	default:
+		// Toggle cell expansion for other columns
+		m.cellExpanded = !m.cellExpanded
+		m.updateTableHeight()
+		return m, nil
+	}
+}
+
+func (m *Model) handleTableNavigation(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	prevRow := m.tbl.Cursor()
+	prevCol := m.tbl.ColumnCursor()
+	var cmd tea.Cmd
+	m.tbl, cmd = m.tbl.Update(msg)
+	if prevRow != m.tbl.Cursor() || prevCol != m.tbl.ColumnCursor() {
+		m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
+	}
+	return m, cmd
+}
+
+// showError displays an error in the status bar
+func (m *Model) showError(err error) {
+	m.statusMsg = fmt.Sprintf("Error: %v", err)
+	// Note: we can't return a Cmd from here, so the error will stay until next update
+}
\ No newline at end of file
diff --git a/internal/ui/table.go b/internal/ui/table.go
index de1776a..a6bd9ad 100644
--- a/internal/ui/table.go
+++ b/internal/ui/table.go
@@ -3,7 +3,6 @@ package ui
 import (
 	"fmt"
 	"math/rand"
-	"os/exec"
 	"regexp"
 	"strconv"
 	"strings"
@@ -25,12 +24,9 @@ var priorityOptions = []string{"H", "M", "L", ""}
 var (
 	urlRegex         = regexp.MustCompile(`https?://\S+`)
 	searchRegexCache = make(map[string]*regexp.Regexp)
+	rng              = rand.New(rand.NewSource(time.Now().UnixNano()))
 )
 
-func init() {
-	rand.Seed(time.Now().UnixNano())
-}
-
 type cellMatch struct {
 	row int
 	col int
@@ -115,9 +111,9 @@ type Model struct {
 
 	theme        Theme
 	defaultTheme Theme
-	disco        bool
+	disco        bool   // disco mode changes theme on every task modification
 
-	statusMsg string
+	statusMsg string // temporary status message shown in status bar
 }
 
 // editDoneMsg is emitted when the external editor process finishes.
@@ -128,6 +124,9 @@ type blinkMsg struct{}
 // blinkInterval controls how quickly the row flashes when a task changes.
 // A shorter interval results in a faster blink.
 const blinkInterval = 150 * time.Millisecond
+
+// blinkCycles is the number of times to blink before stopping.
+// The total blink duration is blinkInterval * blinkCycles.
 const blinkCycles = 8
 
 // editCmd returns a command that edits the task and sends an
@@ -290,665 +289,99 @@ func (m *Model) reload() error {
 func (m Model) Init() tea.Cmd { return nil }
 
 // Update handles key and window events.
-func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
-		m.tbl.SetWidth(msg.Width)
-		m.windowHeight = msg.Height
-		m.computeColumnWidths()
-		m.updateTableHeight()
-		return m, nil
+		// Handle resize in all modes, including during input
+		return m.handleWindowResize(msg)
 	case editDoneMsg:
-		// Ignore any error and reload tasks once editing completes.
-		_ = msg.err
-		m.reload()
-		cmd := m.startBlink(m.editID, false)
-		m.editID = 0
-		return m, cmd
+		return m.handleEditDone(msg)
 	case blinkMsg:
-		if m.blinkID != 0 {
-			m.blinkOn = !m.blinkOn
-			m.blinkCount++
-			m.updateBlinkRow()
-			if m.blinkCount >= blinkCycles {
-				id := m.blinkID
-				mark := m.blinkMarkDone
-				m.blinkID = 0
-				m.blinkOn = false
-				m.blinkCount = 0
-				m.blinkMarkDone = false
-				if mark {
-					for _, tsk := range m.tasks {
-						if tsk.ID == id {
-							m.undoStack = append(m.undoStack, tsk.UUID)
-							break
-						}
-					}
-					task.Done(id)
-				}
-				m.reload()
-				return m, nil
-			}
-			return m, blinkCmd()
-		}
-		return m, nil
+		return m.handleBlinkMsg()
 	case struct{ clearStatus bool }:
 		m.statusMsg = ""
 		return m, nil
 	case tea.KeyMsg:
-		// Only allow navigation while a task row is blinking. This
-		// prevents accidental modifications to other tasks but still
-		// lets the user move around the table.
+		// Handle blinking state first
 		if m.blinkID != 0 {
-			prevRow := m.tbl.Cursor()
-			prevCol := m.tbl.ColumnCursor()
-			var cmd tea.Cmd
-			m.tbl, cmd = m.tbl.Update(msg)
-			if prevRow != m.tbl.Cursor() || prevCol != m.tbl.ColumnCursor() {
-				m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
-			}
-			return m, cmd
-		}
-		if m.annotating {
-			switch msg.Type {
-			case tea.KeyEnter:
-				if m.replaceAnnotations {
-					task.ReplaceAnnotations(m.annotateID, m.annotateInput.Value())
-					m.replaceAnnotations = false
-				} else {
-					task.Annotate(m.annotateID, m.annotateInput.Value())
-				}
-				m.annotating = false
-				m.annotateInput.Blur()
-				m.reload()
-				cmd := m.startBlink(m.annotateID, false)
-				m.updateTableHeight()
-				return m, cmd
-			case tea.KeyEsc:
-				m.annotating = false
-				m.replaceAnnotations = false
-				m.annotateInput.Blur()
-				m.updateTableHeight()
-				return m, nil
-			}
-			var cmd tea.Cmd
-			m.annotateInput, cmd = m.annotateInput.Update(msg)
-			return m, cmd
-		}
-		if m.descEditing {
-			switch msg.Type {
-			case tea.KeyEnter:
-				task.SetDescription(m.descID, m.descInput.Value())
-				m.descEditing = false
-				m.descInput.Blur()
-				m.reload()
-				cmd := m.startBlink(m.descID, false)
-				m.updateTableHeight()
-				return m, cmd
-			case tea.KeyEsc:
-				m.descEditing = false
-				m.descInput.Blur()
-				m.updateTableHeight()
-				return m, nil
-			}
-			var cmd tea.Cmd
-			m.descInput, cmd = m.descInput.Update(msg)
-			return m, cmd
-		}
-		if m.tagsEditing {
-			switch msg.Type {
-			case tea.KeyEnter:
-				words := strings.Fields(m.tagsInput.Value())
-				var adds, removes []string
-				for _, w := range words {
-					if strings.HasPrefix(w, "-") {
-						if len(w) > 1 {
-							removes = append(removes, w[1:])
-						}
-					} else {
-						if strings.HasPrefix(w, "+") {
-							w = w[1:]
-						}
-						if w != "" {
-							adds = append(adds, w)
-						}
-					}
-				}
-				if len(adds) > 0 {
-					task.AddTags(m.tagsID, adds)
-				}
-				if len(removes) > 0 {
-					task.RemoveTags(m.tagsID, removes)
-				}
-				m.tagsEditing = false
-				m.tagsInput.Blur()
-				m.reload()
-				cmd := m.startBlink(m.tagsID, false)
-				m.updateTableHeight()
-				return m, cmd
-			case tea.KeyEsc:
-				m.tagsEditing = false
-				m.tagsInput.Blur()
-				m.updateTableHeight()
-				return m, nil
-			}
-			var cmd tea.Cmd
-			m.tagsInput, cmd = m.tagsInput.Update(msg)
-			return m, cmd
-		}
-		if m.dueEditing {
-			switch msg.Type {
-			case tea.KeyEnter:
-				task.SetDueDate(m.dueID, m.dueDate.Format("2006-01-02"))
-				m.dueEditing = false
-				m.reload()
-				cmd := m.startBlink(m.dueID, false)
-				m.updateTableHeight()
-				return m, cmd
-			case tea.KeyEsc:
-				m.dueEditing = false
-				m.updateTableHeight()
-				return m, nil
-			}
-			switch msg.String() {
-			case "h", "left":
-				m.dueDate = m.dueDate.AddDate(0, 0, -1)
-			case "l", "right":
-				m.dueDate = m.dueDate.AddDate(0, 0, 1)
-			case "k", "up":
-				m.dueDate = m.dueDate.AddDate(0, 0, -7)
-			case "j", "down":
-				m.dueDate = m.dueDate.AddDate(0, 0, 7)
-			}
-			return m, nil
+			return m.handleBlinkingState(msg)
 		}
-		if m.recurEditing {
-			switch msg.Type {
-			case tea.KeyEnter:
-				task.SetRecurrence(m.recurID, m.recurInput.Value())
-				m.recurEditing = false
-				m.recurInput.Blur()
-				m.reload()
-				cmd := m.startBlink(m.recurID, false)
-				m.updateTableHeight()
-				return m, cmd
-			case tea.KeyEsc:
-				m.recurEditing = false
-				m.recurInput.Blur()
-				m.updateTableHeight()
-				return m, nil
-			}
-			var cmd tea.Cmd
-			m.recurInput, cmd = m.recurInput.Update(msg)
-			return m, cmd
-		}
-		if m.prioritySelecting {
-			switch msg.Type {
-			case tea.KeyEnter:
-				task.SetPriority(m.priorityID, priorityOptions[m.priorityIndex])
-				m.prioritySelecting = false
-				m.reload()
-				cmd := m.startBlink(m.priorityID, false)
-				m.updateTableHeight()
-				return m, cmd
-			case tea.KeyEsc:
-				m.prioritySelecting = false
-				m.updateTableHeight()
-				return m, nil
-			}
-			switch msg.String() {
-			case "h", "left":
-				m.priorityIndex = (m.priorityIndex + len(priorityOptions) - 1) % len(priorityOptions)
-			case "l", "right":
-				m.priorityIndex = (m.priorityIndex + 1) % len(priorityOptions)
-			}
-			return m, nil
-		}
-		if m.filterEditing {
-			switch msg.Type {
-			case tea.KeyEnter:
-				m.filters = strings.Fields(m.filterInput.Value())
-				m.filterEditing = false
-				m.filterInput.Blur()
-				m.reload()
-				m.updateTableHeight()
-				return m, nil
-			case tea.KeyEsc:
-				m.filterEditing = false
-				m.filterInput.Blur()
-				m.updateTableHeight()
-				return m, nil
-			}
-			var cmd tea.Cmd
-			m.filterInput, cmd = m.filterInput.Update(msg)
-			return m, cmd
-		}
-		if m.addingTask {
-			switch msg.Type {
-			case tea.KeyEnter:
-				oldIDs := make(map[int]struct{})
-				for _, tsk := range m.tasks {
-					oldIDs[tsk.ID] = struct{}{}
-				}
-				task.AddLine(m.addInput.Value())
-				m.addingTask = false
-				m.addInput.Blur()
-				m.reload()
-				var newID int
-				row := -1
-				for i, tsk := range m.tasks {
-					if _, ok := oldIDs[tsk.ID]; !ok {
-						newID = tsk.ID
-						row = i
-						break
-					}
-				}
-				m.updateTableHeight()
-				if row >= 0 {
-					prevRow := m.tbl.Cursor()
-					prevCol := m.tbl.ColumnCursor()
-					m.tbl.SetCursor(row)
-					m.tbl.SetColumnCursor(7)
-					m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
-					return m, m.startBlink(newID, false)
-				}
-				return m, nil
-			case tea.KeyEsc:
-				m.addingTask = false
-				m.addInput.Blur()
-				m.updateTableHeight()
-				return m, nil
-			}
-			var cmd tea.Cmd
-			m.addInput, cmd = m.addInput.Update(msg)
-			return m, cmd
-		}
-		if m.searching {
-			switch msg.Type {
-			case tea.KeyEnter:
-				pattern := m.searchInput.Value()
-				if pattern != "" {
-					// Check cache first
-					if cached, ok := searchRegexCache[pattern]; ok {
-						m.searchRegex = cached
-					} else {
-						// Compile and cache if not found
-						re, err := regexp.Compile(pattern)
-						if err == nil {
-							m.searchRegex = re
-							// Limit cache size to prevent memory leak
-							if len(searchRegexCache) > 100 {
-								// Clear cache when it gets too large
-								searchRegexCache = make(map[string]*regexp.Regexp)
-							}
-							searchRegexCache[pattern] = re
-						} else {
-							m.searchRegex = nil
-						}
-					}
-				} else {
-					m.searchRegex = nil
-				}
-				m.searching = false
-				m.searchInput.Blur()
-				m.reload()
-				m.updateTableHeight()
-				if len(m.searchMatches) > 0 {
-					match := m.searchMatches[m.searchIndex]
-					prevRow := m.tbl.Cursor()
-					prevCol := m.tbl.ColumnCursor()
-					m.tbl.SetCursor(match.row)
-					m.tbl.SetColumnCursor(match.col)
-					m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
-				}
-				return m, nil
-			case tea.KeyEsc:
-				m.searching = false
-				m.searchInput.Blur()
-				m.updateTableHeight()
-				return m, nil
-			}
-			var cmd tea.Cmd
-			m.searchInput, cmd = m.searchInput.Update(msg)
-			return m, cmd
-		}
-		switch msg.String() {
-		case "H":
-			m.showHelp = true
-			return m, nil
-		case "q", "esc":
-			if m.cellExpanded {
-				m.cellExpanded = false
-				m.updateTableHeight()
-				return m, nil
-			}
-			if m.showHelp {
-				m.showHelp = false
-				return m, nil
-			}
-			if m.searchRegex != nil {
-				m.searchRegex = nil
-				m.searchMatches = nil
-				m.searchIndex = 0
-				m.reload()
-				return m, nil
-			}
-			if msg.String() == "q" {
-				return m, tea.Quit
-			}
-			return m, nil
-		case "e", "E":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					m.editID = id
-					return m, editCmd(id)
-				}
-			}
-		case "s":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					started := false
-					for _, tsk := range m.tasks {
-						if tsk.ID == id {
-							started = tsk.Start != ""
-							break
-						}
-					}
-					if started {
-						task.Stop(id)
-					} else {
-						task.Start(id)
-					}
-					m.reload()
-					cmd := m.startBlink(id, false)
-					return m, cmd
-				}
-			}
-		case "d":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					return m, m.startBlink(id, true)
-				}
-			}
-		case "o":
-			if row := m.tbl.SelectedRow(); row != nil {
-				desc := m.tasks[m.tbl.Cursor()].Description
-				url := urlRegex.FindString(desc)
-				if url != "" {
-					if err := exec.Command(m.browserCmd, url).Run(); err != nil {
-						// Show error in status bar
-						m.statusMsg = fmt.Sprintf("Error opening browser: %v", err)
-						// Clear status message after delay
-						cmd := tea.Tick(3*time.Second, func(time.Time) tea.Msg {
-							return struct{ clearStatus bool }{true}
-						})
-						return m, cmd
-					} else {
-						idStr := ansi.Strip(row[1])
-						if id, err := strconv.Atoi(idStr); err == nil {
-							return m, m.startBlink(id, false)
-						}
-					}
-				}
-			}
-		case "U":
-			if n := len(m.undoStack); n > 0 {
-				uuid := m.undoStack[n-1]
-				m.undoStack = m.undoStack[:n-1]
-				task.SetStatusUUID(uuid, "pending")
-				m.reload()
-				var id int
-				for _, tsk := range m.tasks {
-					if tsk.UUID == uuid {
-						id = tsk.ID
-						break
-					}
-				}
-				cmd := m.startBlink(id, false)
-				return m, cmd
-			}
-		case "D":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					m.clearEditingModes()
-					m.dueID = id
-					m.dueEditing = true
-					m.dueDate = time.Now()
-					m.updateTableHeight()
-					return m, nil
-				}
-			}
-		case "r":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					days := rand.Intn(31) + 7
-					due := time.Now().AddDate(0, 0, days).Format("2006-01-02")
-					task.SetDueDate(id, due)
-					m.reload()
-					cmd := m.startBlink(id, false)
-					return m, cmd
-				}
-			}
-		case "R":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					m.clearEditingModes()
-					m.recurID = id
-					m.recurEditing = true
-					m.recurInput.SetValue(m.tasks[m.tbl.Cursor()].Recur)
-					m.recurInput.Focus()
-					m.updateTableHeight()
-					return m, nil
-				}
-			}
-		case "p":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					m.clearEditingModes()
-					m.priorityID = id
-					m.prioritySelecting = true
-					m.priorityIndex = 0
-					m.updateTableHeight()
-					return m, nil
-				}
-			}
-		case "a":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					m.clearEditingModes()
-					m.annotateID = id
-					m.annotating = true
-					m.replaceAnnotations = false
-					m.annotateInput.SetValue("")
-					m.annotateInput.Focus()
-					m.updateTableHeight()
-					return m, nil
-				}
-			}
-		case "A":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					m.clearEditingModes()
-					m.annotateID = id
-					m.annotating = true
-					m.replaceAnnotations = true
-					m.annotateInput.SetValue("")
-					m.annotateInput.Focus()
-					m.updateTableHeight()
-					return m, nil
-				}
-			}
-		case "f":
-			m.clearEditingModes()
-			m.filterEditing = true
-			m.filterInput.SetValue(strings.Join(m.filters, " "))
-			m.filterInput.Focus()
-			m.updateTableHeight()
-			return m, nil
-		case "+":
-			m.clearEditingModes()
-			m.addingTask = true
-			m.addInput.SetValue("")
-			m.addInput.Focus()
-			m.updateTableHeight()
-			return m, nil
-		case "t":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					m.clearEditingModes()
-					m.tagsID = id
-					m.tagsEditing = true
-					m.tagsInput.SetValue("")
-					m.tagsInput.Focus()
-					m.updateTableHeight()
-					return m, nil
-				}
-			}
-			return m, nil
-		case "c":
-			m.theme = RandomTheme()
-			m.applyTheme()
-			return m, nil
-		case "C":
-			m.theme = m.defaultTheme
-			m.applyTheme()
-			return m, nil
-		case "x":
-			m.disco = !m.disco
-			return m, nil
-		case " ":
-			m.reload()
-			return m, nil
-		case "/", "?":
-			m.clearEditingModes()
-			m.searching = true
-			m.searchInput.SetValue("")
-			m.searchInput.Focus()
-			m.updateTableHeight()
-			return m, nil
-		case "n":
-			if len(m.searchMatches) > 0 {
-				m.searchIndex = (m.searchIndex + 1) % len(m.searchMatches)
-				match := m.searchMatches[m.searchIndex]
-				prevRow := m.tbl.Cursor()
-				prevCol := m.tbl.ColumnCursor()
-				m.tbl.SetCursor(match.row)
-				m.tbl.SetColumnCursor(match.col)
-				m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
-				return m, nil
-			}
-		case "N":
-			if len(m.searchMatches) > 0 {
-				m.searchIndex = (m.searchIndex - 1 + len(m.searchMatches)) % len(m.searchMatches)
-				match := m.searchMatches[m.searchIndex]
-				prevRow := m.tbl.Cursor()
-				prevCol := m.tbl.ColumnCursor()
-				m.tbl.SetCursor(match.row)
-				m.tbl.SetColumnCursor(match.col)
-				m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
-				return m, nil
-			}
-		case "enter", "i":
-			if row := m.tbl.SelectedRow(); row != nil {
-				idStr := ansi.Strip(row[1])
-				if id, err := strconv.Atoi(idStr); err == nil {
-					col := m.tbl.ColumnCursor()
-					switch col {
-					case 0:
-						m.clearEditingModes()
-						m.priorityID = id
-						m.prioritySelecting = true
-						switch m.tasks[m.tbl.Cursor()].Priority {
-						case "H":
-							m.priorityIndex = 0
-						case "M":
-							m.priorityIndex = 1
-						case "L":
-							m.priorityIndex = 2
-						default:
-							m.priorityIndex = 3
-						}
-						m.updateTableHeight()
-						return m, nil
-					case 3:
-						m.dueID = id
-						if ts, err := time.Parse("20060102T150405Z", m.tasks[m.tbl.Cursor()].Due); err == nil {
-							m.dueDate = ts
-						} else {
-							m.dueDate = time.Now()
-						}
-						m.clearEditingModes()
-						m.dueEditing = true
-						m.updateTableHeight()
-						return m, nil
-					case 4:
-						m.clearEditingModes()
-						m.recurID = id
-						m.recurEditing = true
-						m.recurInput.SetValue(m.tasks[m.tbl.Cursor()].Recur)
-						m.recurInput.Focus()
-						m.updateTableHeight()
-						return m, nil
-					case 5:
-						m.tagsID = id
-						m.tagsEditing = true
-						m.tagsInput.SetValue("")
-						m.tagsInput.Focus()
-						m.updateTableHeight()
-						return m, nil
-					case 6:
-						m.annotateID = id
-						m.annotating = true
-						m.replaceAnnotations = true
-						var anns []string
-						for _, a := range m.tasks[m.tbl.Cursor()].Annotations {
-							anns = append(anns, a.Description)
-						}
-						m.annotateInput.SetValue(strings.Join(anns, "; "))
-						m.annotateInput.Focus()
-						m.updateTableHeight()
-						return m, nil
-					case 7:
-						m.clearEditingModes()
-						m.descID = id
-						m.descEditing = true
-						m.descInput.SetValue(m.tasks[m.tbl.Cursor()].Description)
-						m.descInput.Focus()
-						m.updateTableHeight()
-						return m, nil
-					}
-				}
-			}
-			m.cellExpanded = !m.cellExpanded
-			m.updateTableHeight()
-			return m, nil
+		
+		// Check if we're in any editing mode
+		if handled, model, cmd := m.handleEditingModes(msg); handled {
+			return model, cmd
 		}
+		
+		// Otherwise handle normal mode
+		return m.handleNormalMode(msg)
 	}
-
+	
+	// Default case - pass through to table
 	if m.showHelp {
 		return m, nil
 	}
-
+	
 	var cmd tea.Cmd
-	prevRow := m.tbl.Cursor()
-	prevCol := m.tbl.ColumnCursor()
 	m.tbl, cmd = m.tbl.Update(msg)
-	if prevRow != m.tbl.Cursor() || prevCol != m.tbl.ColumnCursor() {
-		m.updateSelectionHighlight(prevRow, m.tbl.Cursor(), prevCol, m.tbl.ColumnCursor())
+	return m, cmd
+}
+
+// handleWindowResize handles window resize events
+func (m *Model) handleWindowResize(msg tea.WindowSizeMsg) (tea.Model, tea.Cmd) {
+	m.tbl.SetWidth(msg.Width)
+	m.windowHeight = msg.Height
+	m.computeColumnWidths()
+	m.updateTableHeight()
+	return m, nil
+}
+
+// handleEditDone handles completion of external editor
+func (m *Model) handleEditDone(msg editDoneMsg) (tea.Model, tea.Cmd) {
+	if msg.err != nil {
+		m.showError(fmt.Errorf("editor: %w", msg.err))
 	}
+	m.reload()
+	cmd := m.startBlink(m.editID, false)
+	m.editID = 0
 	return m, cmd
 }
 
+// handleBlinkMsg handles the blinking animation timer
+func (m *Model) handleBlinkMsg() (tea.Model, tea.Cmd) {
+	if m.blinkID == 0 {
+		return m, nil
+	}
+	
+	m.blinkOn = !m.blinkOn
+	m.blinkCount++
+	m.updateBlinkRow()
+	
+	if m.blinkCount >= blinkCycles {
+		id := m.blinkID
+		mark := m.blinkMarkDone
+		m.blinkID = 0
+		m.blinkOn = false
+		m.blinkCount = 0
+		m.blinkMarkDone = false
+		
+		if mark {
+			for _, tsk := range m.tasks {
+				if tsk.ID == id {
+					m.undoStack = append(m.undoStack, tsk.UUID)
+					break
+				}
+			}
+			if err := task.Done(id); err != nil {
+				m.showError(err)
+			}
+		}
+		m.reload()
+		return m, nil
+	}
+	
+	return m, blinkCmd()
+}
+
 // View renders the table UI.
 func (m Model) View() string {
 	if m.showHelp {
diff --git a/internal/ui/table_test.go b/internal/ui/table_test.go
index 32891bb..8066a2c 100644
--- a/internal/ui/table_test.go
+++ b/internal/ui/table_test.go
@@ -46,14 +46,15 @@ func TestAnnotateHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'a'}})
-	m = mv.(Model)
+	mp := &m  // Get pointer to model
+	mv, _ := mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'a'}})
+	mp = mv.(*Model)
 	for _, r := range "note" {
-		mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
-		m = mv.(Model)
+		mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+		mp = mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	mp = mv.(*Model)
 
 	data, err := os.ReadFile(annoFile)
 	if err != nil {
@@ -102,14 +103,14 @@ func TestReplaceAnnotationHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'A'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'A'}})
+	m = *mv.(*Model)
 	for _, r := range "new" {
-		mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+		m = *mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(annoFile)
 	if err != nil {
@@ -162,11 +163,11 @@ func TestDoneHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'d'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'d'}})
+	m = *mv.(*Model)
 	for i := 0; i < blinkCycles; i++ {
-		mv, _ = m.Update(blinkMsg{})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(blinkMsg{})
+		m = *mv.(*Model)
 	}
 
 	data, err := os.ReadFile(doneFile)
@@ -211,14 +212,14 @@ func TestUndoHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'d'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'d'}})
+	m = *mv.(*Model)
 	for i := 0; i < blinkCycles; i++ {
-		mv, _ = m.Update(blinkMsg{})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(blinkMsg{})
+		m = *mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'U'}})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'U'}})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(logFile)
 	if err != nil {
@@ -274,8 +275,8 @@ func TestOpenURLHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'o'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'o'}})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(openFile)
 	if err != nil {
@@ -318,14 +319,14 @@ func TestDueDateHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'D'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'D'}})
+	m = *mv.(*Model)
 	for i := 0; i < 3; i++ {
-		mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRight})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRight})
+		m = *mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(dueFile)
 	if err != nil {
@@ -370,8 +371,8 @@ func TestRandomDueDateHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'r'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'r'}})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(dueFile)
 	if err != nil {
@@ -425,14 +426,14 @@ func TestRecurrenceHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'R'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'R'}})
+	m = *mv.(*Model)
 	for _, r := range "daily" {
-		mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+		m = *mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(recFile)
 	if err != nil {
@@ -476,10 +477,10 @@ func TestPriorityHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'p'}})
-	m = mv.(Model)
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'p'}})
+	m = *mv.(*Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(priFile)
 	if err != nil {
@@ -523,14 +524,14 @@ func TestAddHotkey(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'+'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'+'}})
+	m = *mv.(*Model)
 	for _, r := range "foo due:today" {
-		mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+		m = *mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	m = *mv.(*Model)
 
 	data, err := os.ReadFile(addFile)
 	if err != nil {
@@ -573,20 +574,20 @@ func TestNavigationHotkeys(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'j'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'j'}})
+	m = *mv.(*Model)
 	if m.tbl.Cursor() != 1 {
 		t.Fatalf("down: got cursor %d", m.tbl.Cursor())
 	}
 
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'0'}})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'0'}})
+	m = *mv.(*Model)
 	if m.tbl.Cursor() != 0 {
 		t.Fatalf("0 hotkey: expected 0 got %d", m.tbl.Cursor())
 	}
 
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'G'}})
-	m = mv.(Model)
+	mp = &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'G'}})
+	m = *mv.(*Model)
 	if m.tbl.Cursor() != 1 {
 		t.Fatalf("G hotkey: expected 1 got %d", m.tbl.Cursor())
 	}
@@ -630,14 +631,14 @@ func TestEscClosesHelp(t *testing.T) {
 		t.Fatalf("New: %v", err)
 	}
 
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'H'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'H'}})
+	m = *mv.(*Model)
 	if !m.showHelp {
 		t.Fatalf("help not shown")
 	}
 
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEsc})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	m = *mv.(*Model)
 	if m.showHelp {
 		t.Fatalf("esc did not close help")
 	}
@@ -654,40 +655,40 @@ func TestSearchExitHotkeys(t *testing.T) {
 	}
 
 	// enter search mode
-	mv, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'/'}})
-	m = mv.(Model)
+	mv, _ := (&m).Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'/'}})
+	m = *mv.(*Model)
 	for _, r := range "alpha" {
-		mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+		m = *mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	m = *mv.(*Model)
 	if m.searchRegex == nil {
 		t.Fatalf("search regex not set")
 	}
 
 	// escape search results with ESC
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEsc})
-	m = mv.(Model)
+	mp = &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	m = *mv.(*Model)
 	if m.searchRegex != nil {
 		t.Fatalf("esc did not clear search")
 	}
 
 	// search again and exit with q
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'/'}})
-	m = mv.(Model)
+	mp = &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'/'}})
+	m = *mv.(*Model)
 	for _, r := range "beta" {
-		mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
-		m = mv.(Model)
+		mp := &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+		m = *mv.(*Model)
 	}
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	m = mv.(Model)
+	mp = &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	m = *mv.(*Model)
 	if m.searchRegex == nil {
 		t.Fatalf("search regex not set for q")
 	}
 
-	mv, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'q'}})
-	m = mv.(Model)
+	mp = &m; mv, _ = mp.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'q'}})
+	m = *mv.(*Model)
 	if m.searchRegex != nil {
 		t.Fatalf("q did not clear search")
 	}
diff --git a/internal/ui/theme.go b/internal/ui/theme.go
index 9d81aab..7faebf5 100644
--- a/internal/ui/theme.go
+++ b/internal/ui/theme.go
@@ -1,7 +1,6 @@
 package ui
 
 import (
-	"math/rand"
 	"strconv"
 )
 
@@ -64,7 +63,7 @@ func RandomTheme() Theme {
 }
 
 func randColor() string {
-	return strconv.Itoa(rand.Intn(256))
+	return strconv.Itoa(rng.Intn(256))
 }
 
 func contrastColor(bg string) string {