feat: add contexts to task domain

cmd/task_commands.go

···
 package main
 
 import (
-	"fmt"
-
 	"github.com/spf13/cobra"
 	"github.com/stormlightlabs/noteleaf/internal/handlers"
 )
···
 		RunE: func(c *cobra.Command, args []string) error {
 			priority, _ := c.Flags().GetString("priority")
 			project, _ := c.Flags().GetString("project")
+			context, _ := c.Flags().GetString("context")
 			due, _ := c.Flags().GetString("due")
 			tags, _ := c.Flags().GetStringSlice("tags")
 
 			defer h.Close()
-			return h.Create(c.Context(), args, priority, project, due, tags)
+			return h.Create(c.Context(), args, priority, project, context, due, tags)
 		},
 	}
 	cmd.Flags().StringP("priority", "p", "", "Set task priority")
 	cmd.Flags().String("project", "", "Set task project")
+	cmd.Flags().StringP("context", "c", "", "Set task context")
 	cmd.Flags().StringP("due", "d", "", "Set due date (YYYY-MM-DD)")
 	cmd.Flags().StringSliceP("tags", "t", []string{}, "Add tags to task")
 
···
 			status, _ := c.Flags().GetString("status")
 			priority, _ := c.Flags().GetString("priority")
 			project, _ := c.Flags().GetString("project")
+			context, _ := c.Flags().GetString("context")
 
 			defer h.Close()
-			return h.List(c.Context(), static, showAll, status, priority, project)
+			return h.List(c.Context(), static, showAll, status, priority, project, context)
 		},
 	}
 	cmd.Flags().BoolP("interactive", "i", false, "Force interactive mode (default)")
···
 	cmd.Flags().String("status", "", "Filter by status")
 	cmd.Flags().String("priority", "", "Filter by priority")
 	cmd.Flags().String("project", "", "Filter by project")
+	cmd.Flags().String("context", "", "Filter by context")
 
 	return cmd
 }
···
 			status, _ := cmd.Flags().GetString("status")
 			priority, _ := cmd.Flags().GetString("priority")
 			project, _ := cmd.Flags().GetString("project")
+			context, _ := cmd.Flags().GetString("context")
 			due, _ := cmd.Flags().GetString("due")
 			addTags, _ := cmd.Flags().GetStringSlice("add-tag")
 			removeTags, _ := cmd.Flags().GetStringSlice("remove-tag")
 
 			defer handler.Close()
-			return handler.Update(cmd.Context(), taskID, description, status, priority, project, due, addTags, removeTags)
+			return handler.Update(cmd.Context(), taskID, description, status, priority, project, context, due, addTags, removeTags)
 		},
 	}
 	updateCmd.Flags().String("description", "", "Update task description")
 	updateCmd.Flags().String("status", "", "Update task status")
 	updateCmd.Flags().StringP("priority", "p", "", "Update task priority")
 	updateCmd.Flags().String("project", "", "Update task project")
+	updateCmd.Flags().StringP("context", "c", "", "Update task context")
 	updateCmd.Flags().StringP("due", "d", "", "Update due date (YYYY-MM-DD)")
 	updateCmd.Flags().StringSlice("add-tag", []string{}, "Add tags to task")
 	updateCmd.Flags().StringSlice("remove-tag", []string{}, "Remove tags from task")
···
 	}
 }
 
-func taskContextsCmd(*handlers.TaskHandler) *cobra.Command {
-	return &cobra.Command{
+func taskContextsCmd(h *handlers.TaskHandler) *cobra.Command {
+	cmd := &cobra.Command{
 		Use:     "contexts",
 		Short:   "List contexts (locations)",
 		Aliases: []string{"loc", "ctx", "locations"},
 		RunE: func(c *cobra.Command, args []string) error {
-			fmt.Println("Listing task contexts...")
-			return nil
+			static, _ := c.Flags().GetBool("static")
+
+			defer h.Close()
+			return h.ListContexts(c.Context(), static)
 		},
 	}
+	cmd.Flags().Bool("static", false, "Use static text output instead of interactive")
+	return cmd
 }
 
 func taskCompleteCmd(h *handlers.TaskHandler) *cobra.Command {

internal/handlers/tasks.go

···
 }
 
 // Create creates a new task
-func (h *TaskHandler) Create(ctx context.Context, desc []string, priority, project, due string, tags []string) error {
+func (h *TaskHandler) Create(ctx context.Context, desc []string, priority, project, context, due string, tags []string) error {
 	if len(desc) < 1 {
 		return fmt.Errorf("task description required")
 	}
···
 		Status:      "pending",
 		Priority:    priority,
 		Project:     project,
+		Context:     context,
 		Tags:        tags,
 	}
 
···
 	}
 	if project != "" {
 		fmt.Printf("Project: %s\n", project)
+	}
+	if context != "" {
+		fmt.Printf("Context: %s\n", context)
 	}
 	if len(tags) > 0 {
 		fmt.Printf("Tags: %s\n", strings.Join(tags, ", "))
···
 }
 
 // List lists all tasks with optional filtering
-func (h *TaskHandler) List(ctx context.Context, static, showAll bool, status, priority, project string) error {
+func (h *TaskHandler) List(ctx context.Context, static, showAll bool, status, priority, project, context string) error {
 	if static {
-		return h.listTasksStatic(ctx, showAll, status, priority, project)
+		return h.listTasksStatic(ctx, showAll, status, priority, project, context)
 	}
 
-	return h.listTasksInteractive(ctx, showAll, status, priority, project)
+	return h.listTasksInteractive(ctx, showAll, status, priority, project, context)
 }
 
-func (h *TaskHandler) listTasksStatic(ctx context.Context, showAll bool, status, priority, project string) error {
+func (h *TaskHandler) listTasksStatic(ctx context.Context, showAll bool, status, priority, project, context string) error {
 	opts := repo.TaskListOptions{
 		Status:   status,
 		Priority: priority,
 		Project:  project,
+		Context:  context,
 	}
 
 	if !showAll && opts.Status == "" {
···
 	return nil
 }
 
-func (h *TaskHandler) listTasksInteractive(ctx context.Context, showAll bool, status, priority, project string) error {
+func (h *TaskHandler) listTasksInteractive(ctx context.Context, showAll bool, status, priority, project, context string) error {
 	taskList := ui.NewTaskList(h.repos.Tasks, ui.TaskListOptions{
 		ShowAll:  showAll,
 		Status:   status,
 		Priority: priority,
 		Project:  project,
+		Context:  context,
 		Static:   false,
 	})
 
···
 }
 
 // Update updates a task using parsed flag values
-func (h *TaskHandler) Update(ctx context.Context, taskID, description, status, priority, project, due string, addTags, removeTags []string) error {
+func (h *TaskHandler) Update(ctx context.Context, taskID, description, status, priority, project, context, due string, addTags, removeTags []string) error {
 	var task *models.Task
 	var err error
 
···
 	}
 	if project != "" {
 		task.Project = project
+	}
+	if context != "" {
+		task.Context = context
 	}
 	if due != "" {
 		if dueTime, err := time.Parse("2006-01-02", due); err == nil {
···
 	return h.listTagsInteractive(ctx)
 }
 
+// ListContexts lists all contexts with their task counts
+func (h *TaskHandler) ListContexts(ctx context.Context, static bool) error {
+	if static {
+		return h.listContextsStatic(ctx)
+	}
+	return h.listContextsInteractive(ctx)
+}
+
+func (h *TaskHandler) listContextsStatic(ctx context.Context) error {
+	tasks, err := h.repos.Tasks.List(ctx, repo.TaskListOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to list tasks for contexts: %w", err)
+	}
+
+	contextCounts := make(map[string]int)
+	for _, task := range tasks {
+		if task.Context != "" {
+			contextCounts[task.Context]++
+		}
+	}
+
+	if len(contextCounts) == 0 {
+		fmt.Printf("No contexts found\n")
+		return nil
+	}
+
+	contexts := make([]string, 0, len(contextCounts))
+	for context := range contextCounts {
+		contexts = append(contexts, context)
+	}
+	slices.Sort(contexts)
+
+	fmt.Printf("Found %d context(s):\n\n", len(contexts))
+	for _, context := range contexts {
+		count := contextCounts[context]
+		fmt.Printf("%s (%d task%s)\n", context, count, pluralize(count))
+	}
+
+	return nil
+}
+
+func (h *TaskHandler) listContextsInteractive(ctx context.Context) error {
+	fmt.Println("Interactive context listing not implemented yet - using static mode")
+	return h.listContextsStatic(ctx)
+}
+
 func (h *TaskHandler) listTagsStatic(ctx context.Context) error {
 	tasks, err := h.repos.Tasks.List(ctx, repo.TaskListOptions{})
 	if err != nil {
···
 		fmt.Printf(" +%s", task.Project)
 	}
 
+	if task.Context != "" {
+		fmt.Printf(" @%s", task.Context)
+	}
+
 	if len(task.Tags) > 0 {
-		fmt.Printf(" @%s", strings.Join(task.Tags, " @"))
+		fmt.Printf(" #%s", strings.Join(task.Tags, " #"))
 	}
 
 	if task.Due != nil {
···
 
 	if task.Project != "" {
 		fmt.Printf("Project: %s\n", task.Project)
+	}
+
+	if task.Context != "" {
+		fmt.Printf("Context: %s\n", task.Context)
 	}
 
 	if len(task.Tags) > 0 {

internal/handlers/tasks_test.go

···
 			ctx := context.Background()
 			args := []string{"Buy groceries", "and", "cook dinner"}
 
-			err := handler.Create(ctx, args, "", "", "", []string{})
+			err := handler.Create(ctx, args, "", "", "", "", []string{})
 			if err != nil {
 				t.Errorf("CreateTask failed: %v", err)
 			}
···
 			ctx := context.Background()
 			args := []string{}
 
-			err := handler.Create(ctx, args, "", "", "", []string{})
+			err := handler.Create(ctx, args, "", "", "", "", []string{})
 			if err == nil {
 				t.Error("Expected error for empty description")
 			}
···
 			due := "2024-12-31"
 			tags := []string{"urgent", "work"}
 
-			err := handler.Create(ctx, args, priority, project, due, tags)
+			err := handler.Create(ctx, args, priority, project, "test-context", due, tags)
 			if err != nil {
 				t.Errorf("CreateTask with flags failed: %v", err)
 			}
···
 			args := []string{"Task", "with", "invalid", "date"}
 			invalidDue := "invalid-date"
 
-			err := handler.Create(ctx, args, "", "", invalidDue, []string{})
+			err := handler.Create(ctx, args, "", "", "", invalidDue, []string{})
 			if err == nil {
 				t.Error("Expected error for invalid due date format")
 			}
···
 		}
 
 		t.Run("lists pending tasks by default (static mode)", func(t *testing.T) {
-			err := handler.List(ctx, true, false, "", "", "")
+			err := handler.List(ctx, true, false, "", "", "", "")
 			if err != nil {
 				t.Errorf("ListTasks failed: %v", err)
 			}
 		})
 
 		t.Run("filters by status (static mode)", func(t *testing.T) {
-			err := handler.List(ctx, true, false, "completed", "", "")
+			err := handler.List(ctx, true, false, "completed", "", "", "")
 			if err != nil {
 				t.Errorf("ListTasks with status filter failed: %v", err)
 			}
 		})
 
 		t.Run("filters by priority (static mode)", func(t *testing.T) {
-			err := handler.List(ctx, true, false, "", "A", "")
+			err := handler.List(ctx, true, false, "", "A", "", "")
 			if err != nil {
 				t.Errorf("ListTasks with priority filter failed: %v", err)
 			}
 		})
 
 		t.Run("filters by project (static mode)", func(t *testing.T) {
-			err := handler.List(ctx, true, false, "", "", "work")
+			err := handler.List(ctx, true, false, "", "", "work", "")
 			if err != nil {
 				t.Errorf("ListTasks with project filter failed: %v", err)
 			}
 		})
 
 		t.Run("show all tasks (static mode)", func(t *testing.T) {
-			err := handler.List(ctx, true, true, "", "", "")
+			err := handler.List(ctx, true, true, "", "", "", "")
 			if err != nil {
 				t.Errorf("ListTasks with show all failed: %v", err)
 			}
···
 		t.Run("updates task by ID", func(t *testing.T) {
 			taskID := strconv.FormatInt(id, 10)
 
-			err := handler.Update(ctx, taskID, "Updated description", "", "", "", "", []string{}, []string{})
+			err := handler.Update(ctx, taskID, "Updated description", "", "", "", "", "", []string{}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask failed: %v", err)
 			}
···
 		t.Run("updates task by UUID", func(t *testing.T) {
 			taskID := task.UUID
 
-			err := handler.Update(ctx, taskID, "", "completed", "", "", "", []string{}, []string{})
+			err := handler.Update(ctx, taskID, "", "completed", "", "", "", "", []string{}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask by UUID failed: %v", err)
 			}
···
 		t.Run("updates multiple fields", func(t *testing.T) {
 			taskID := strconv.FormatInt(id, 10)
 
-			err := handler.Update(ctx, taskID, "Multiple updates", "", "B", "test", "2024-12-31", []string{}, []string{})
+			err := handler.Update(ctx, taskID, "Multiple updates", "", "B", "test", "office", "2024-12-31", []string{}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask with multiple fields failed: %v", err)
 			}
···
 		t.Run("adds and removes tags", func(t *testing.T) {
 			taskID := strconv.FormatInt(id, 10)
 
-			err := handler.Update(ctx, taskID, "", "", "", "", "", []string{"work", "urgent"}, []string{})
+			err := handler.Update(ctx, taskID, "", "", "", "", "", "", []string{"work", "urgent"}, []string{})
 			if err != nil {
 				t.Errorf("UpdateTask with add tags failed: %v", err)
 			}
···
 
 			taskID = strconv.FormatInt(id, 10)
 
-			err = handler.Update(ctx, taskID, "", "", "", "", "", []string{}, []string{"urgent"})
+			err = handler.Update(ctx, taskID, "", "", "", "", "", "", []string{}, []string{"urgent"})
 			if err != nil {
 				t.Errorf("UpdateTask with remove tag failed: %v", err)
 			}
···
 		})
 
 		t.Run("fails with missing task ID", func(t *testing.T) {
-			err := handler.Update(ctx, "", "", "", "", "", "", []string{}, []string{})
+			err := handler.Update(ctx, "", "", "", "", "", "", "", []string{}, []string{})
 			if err == nil {
 				t.Error("Expected error for missing task ID")
 			}
···
 		t.Run("fails with invalid task ID", func(t *testing.T) {
 			taskID := "99999"
 
-			err := handler.Update(ctx, taskID, "test", "", "", "", "", []string{}, []string{})
+			err := handler.Update(ctx, taskID, "test", "", "", "", "", "", []string{}, []string{})
 			if err == nil {
 				t.Error("Expected error for invalid task ID")
 			}

internal/handlers/time_tracking_test.go

···
 			}
 		})
 	})
-}
 
-func TestFormatDuration(t *testing.T) {
-	tests := []struct {
-		duration time.Duration
-		expected string
-	}{
-		{30 * time.Second, "30s"},
-		{90 * time.Second, "2m"},
-		{30 * time.Minute, "30m"},
-		{90 * time.Minute, "1.5h"},
-		{2 * time.Hour, "2.0h"},
-		{25 * time.Hour, "1d 1.0h"},
-		{48 * time.Hour, "2d"},
-		{72 * time.Hour, "3d"},
-	}
+	t.Run("TestFormatDuration", func(t *testing.T) {
+		tests := []struct {
+			duration time.Duration
+			expected string
+		}{
+			{30 * time.Second, "30s"},
+			{90 * time.Second, "2m"},
+			{30 * time.Minute, "30m"},
+			{90 * time.Minute, "1.5h"},
+			{2 * time.Hour, "2.0h"},
+			{25 * time.Hour, "1d 1.0h"},
+			{48 * time.Hour, "2d"},
+			{72 * time.Hour, "3d"},
+		}
 
-	for _, test := range tests {
-		result := formatDuration(test.duration)
-		if result != test.expected {
-			t.Errorf("formatDuration(%v) = %q, expected %q", test.duration, result, test.expected)
+		for _, test := range tests {
+			result := formatDuration(test.duration)
+			if result != test.expected {
+				t.Errorf("formatDuration(%v) = %q, expected %q", test.duration, result, test.expected)
+			}
 		}
-	}
-}
+	})
 
-func TestTimeEntryMethods(t *testing.T) {
-	now := time.Now()
+	t.Run("TestTimeEntryMethods", func(t *testing.T) {
+		now := time.Now()
 
-	t.Run("IsActive returns true for entry without end time", func(t *testing.T) {
-		entry := &models.TimeEntry{
-			StartTime: now,
-			EndTime:   nil,
-		}
+		t.Run("IsActive returns true for entry without end time", func(t *testing.T) {
+			entry := &models.TimeEntry{
+				StartTime: now,
+				EndTime:   nil,
+			}
 
-		if !entry.IsActive() {
-			t.Error("Expected entry to be active")
-		}
-	})
+			if !entry.IsActive() {
+				t.Error("Expected entry to be active")
+			}
+		})
 
-	t.Run("IsActive returns false for entry with end time", func(t *testing.T) {
-		endTime := now.Add(time.Hour)
-		entry := &models.TimeEntry{
-			StartTime: now,
-			EndTime:   &endTime,
-		}
+		t.Run("IsActive returns false for entry with end time", func(t *testing.T) {
+			endTime := now.Add(time.Hour)
+			entry := &models.TimeEntry{
+				StartTime: now,
+				EndTime:   &endTime,
+			}
 
-		if entry.IsActive() {
-			t.Error("Expected entry to not be active")
-		}
-	})
+			if entry.IsActive() {
+				t.Error("Expected entry to not be active")
+			}
+		})
 
-	t.Run("Stop sets end time and calculates duration", func(t *testing.T) {
-		entry := &models.TimeEntry{
-			StartTime: now.Add(-time.Second), // Start 1 second ago
-			EndTime:   nil,
-		}
+		t.Run("Stop sets end time and calculates duration", func(t *testing.T) {
+			entry := &models.TimeEntry{
+				StartTime: now.Add(-time.Second), // Start 1 second ago
+				EndTime:   nil,
+			}
 
-		entry.Stop()
+			entry.Stop()
 
-		if entry.EndTime == nil {
-			t.Error("Expected EndTime to be set after stopping")
-		}
-		if entry.DurationSeconds <= 0 {
-			t.Error("Expected duration to be calculated and greater than 0")
-		}
-		if entry.IsActive() {
-			t.Error("Expected entry to not be active after stopping")
-		}
-	})
+			if entry.EndTime == nil {
+				t.Error("Expected EndTime to be set after stopping")
+			}
+			if entry.DurationSeconds <= 0 {
+				t.Error("Expected duration to be calculated and greater than 0")
+			}
+			if entry.IsActive() {
+				t.Error("Expected entry to not be active after stopping")
+			}
+		})
 
-	t.Run("GetDuration returns calculated duration for completed entry", func(t *testing.T) {
-		start := now
-		end := now.Add(2 * time.Hour)
-		entry := &models.TimeEntry{
-			StartTime:       start,
-			EndTime:         &end,
-			DurationSeconds: int64((2 * time.Hour).Seconds()),
-		}
+		t.Run("GetDuration returns calculated duration for completed entry", func(t *testing.T) {
+			start := now
+			end := now.Add(2 * time.Hour)
+			entry := &models.TimeEntry{
+				StartTime:       start,
+				EndTime:         &end,
+				DurationSeconds: int64((2 * time.Hour).Seconds()),
+			}
 
-		duration := entry.GetDuration()
-		expected := 2 * time.Hour
+			duration := entry.GetDuration()
+			expected := 2 * time.Hour
 
-		if duration != expected {
-			t.Errorf("Expected duration %v, got %v", expected, duration)
-		}
-	})
+			if duration != expected {
+				t.Errorf("Expected duration %v, got %v", expected, duration)
+			}
+		})
 
-	t.Run("GetDuration returns live duration for active entry", func(t *testing.T) {
-		start := time.Now().Add(-time.Minute)
-		entry := &models.TimeEntry{
-			StartTime: start,
-			EndTime:   nil,
-		}
+		t.Run("GetDuration returns live duration for active entry", func(t *testing.T) {
+			start := time.Now().Add(-time.Minute)
+			entry := &models.TimeEntry{
+				StartTime: start,
+				EndTime:   nil,
+			}
 
-		duration := entry.GetDuration()
+			duration := entry.GetDuration()
 
-		if duration < 59*time.Second || duration > 61*time.Second {
-			t.Errorf("Expected duration around 1 minute, got %v", duration)
-		}
+			if duration < 59*time.Second || duration > 61*time.Second {
+				t.Errorf("Expected duration around 1 minute, got %v", duration)
+			}
+		})
 	})
 }

internal/models/models.go

···
 	// A-Z or empty
 	Priority string     `json:"priority,omitempty"`
 	Project  string     `json:"project,omitempty"`
+	Context  string     `json:"context,omitempty"`
 	Tags     []string   `json:"tags,omitempty"`
 	Due      *time.Time `json:"due,omitempty"`
 	Entry    time.Time  `json:"entry"`

internal/repo/repositories_test.go

···
 			status TEXT DEFAULT 'pending',
 			priority TEXT,
 			project TEXT,
+			context TEXT,
 			tags TEXT,
 			due DATETIME,
 			entry DATETIME DEFAULT CURRENT_TIMESTAMP,

internal/repo/task_repository.go

···
 	Status    string
 	Priority  string
 	Project   string
+	Context   string
 	DueAfter  time.Time
 	DueBefore time.Time
 	Search    string
···
 
 // TagSummary represents a tag with its task count
 type TagSummary struct {
+	Name      string `json:"name"`
+	TaskCount int    `json:"task_count"`
+}
+
+// ContextSummary represents a context with its task count
+type ContextSummary struct {
 	Name      string `json:"name"`
 	TaskCount int    `json:"task_count"`
 }
···
 	}
 
 	query := `
-		INSERT INTO tasks (uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+		INSERT INTO tasks (uuid, description, status, priority, project, context, tags, due, entry, modified, end, start, annotations)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
 
 	result, err := r.db.ExecContext(ctx, query,
-		task.UUID, task.Description, task.Status, task.Priority, task.Project,
+		task.UUID, task.Description, task.Status, task.Priority, task.Project, task.Context,
 		tags, task.Due, task.Entry, task.Modified, task.End, task.Start, annotations)
 	if err != nil {
 		return 0, fmt.Errorf("failed to insert task: %w", err)
···
 // Get retrieves a task by ID
 func (r *TaskRepository) Get(ctx context.Context, id int64) (*models.Task, error) {
 	query := `
-		SELECT id, uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations
+		SELECT id, uuid, description, status, priority, project, context, tags, due, entry, modified, end, start, annotations
 		FROM tasks WHERE id = ?`
 
 	task := &models.Task{}
 	var tags, annotations sql.NullString
 
 	err := r.db.QueryRowContext(ctx, query, id).Scan(
-		&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority, &task.Project,
+		&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority, &task.Project, &task.Context,
 		&tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get task: %w", err)
···
 	}
 
 	query := `
-		UPDATE tasks SET uuid = ?, description = ?, status = ?, priority = ?, project = ?,
+		UPDATE tasks SET uuid = ?, description = ?, status = ?, priority = ?, project = ?, context = ?,
 		tags = ?, due = ?, modified = ?, end = ?, start = ?, annotations = ?
 		WHERE id = ?`
 
 	_, err = r.db.ExecContext(ctx, query,
-		task.UUID, task.Description, task.Status, task.Priority, task.Project,
+		task.UUID, task.Description, task.Status, task.Priority, task.Project, task.Context,
 		tags, task.Due, task.Modified, task.End, task.Start, annotations, task.ID)
 	if err != nil {
 		return fmt.Errorf("failed to update task: %w", err)
···
 }
 
 func (r *TaskRepository) buildListQuery(opts TaskListOptions) string {
-	query := "SELECT id, uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations FROM tasks"
+	query := "SELECT id, uuid, description, status, priority, project, context, tags, due, entry, modified, end, start, annotations FROM tasks"
 
 	var conditions []string
 
···
 	if opts.Project != "" {
 		conditions = append(conditions, "project = ?")
 	}
+	if opts.Context != "" {
+		conditions = append(conditions, "context = ?")
+	}
 	if !opts.DueAfter.IsZero() {
 		conditions = append(conditions, "due >= ?")
 	}
···
 		searchConditions := []string{
 			"description LIKE ?",
 			"project LIKE ?",
+			"context LIKE ?",
 			"tags LIKE ?",
 		}
 		conditions = append(conditions, fmt.Sprintf("(%s)", strings.Join(searchConditions, " OR ")))
···
 	if opts.Project != "" {
 		args = append(args, opts.Project)
 	}
+	if opts.Context != "" {
+		args = append(args, opts.Context)
+	}
 	if !opts.DueAfter.IsZero() {
 		args = append(args, opts.DueAfter)
 	}
···
 
 	if opts.Search != "" {
 		searchPattern := "%" + opts.Search + "%"
-		args = append(args, searchPattern, searchPattern, searchPattern)
+		args = append(args, searchPattern, searchPattern, searchPattern, searchPattern)
 	}
 
 	return args
···
 	var tags, annotations sql.NullString
 
 	if err := rows.Scan(&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority,
-		&task.Project, &tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations); err != nil {
+		&task.Project, &task.Context, &tags, &task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations); err != nil {
 		return fmt.Errorf("failed to scan task row: %w", err)
 	}
 
···
 	return r.List(ctx, TaskListOptions{Project: project})
 }
 
+// GetByContext retrieves all tasks for a specific context
+func (r *TaskRepository) GetByContext(ctx context.Context, context string) ([]*models.Task, error) {
+	return r.List(ctx, TaskListOptions{Context: context})
+}
+
 // GetProjects retrieves all unique project names with their task counts
 func (r *TaskRepository) GetProjects(ctx context.Context) ([]ProjectSummary, error) {
 	query := `
···
 	return tags, rows.Err()
 }
 
+// GetContexts retrieves all unique context names with their task counts
+func (r *TaskRepository) GetContexts(ctx context.Context) ([]ContextSummary, error) {
+	query := `
+		SELECT context, COUNT(*) as task_count
+		FROM tasks
+		WHERE context != '' AND context IS NOT NULL
+		GROUP BY context
+		ORDER BY context`
+
+	rows, err := r.db.QueryContext(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get contexts: %w", err)
+	}
+	defer rows.Close()
+
+	var contexts []ContextSummary
+	for rows.Next() {
+		var context ContextSummary
+		if err := rows.Scan(&context.Name, &context.TaskCount); err != nil {
+			return nil, fmt.Errorf("failed to scan context row: %w", err)
+		}
+		contexts = append(contexts, context)
+	}
+
+	return contexts, rows.Err()
+}
+
 // GetTasksByTag retrieves all tasks with a specific tag
 func (r *TaskRepository) GetTasksByTag(ctx context.Context, tag string) ([]*models.Task, error) {
 	query := `
-		SELECT tasks.id, tasks.uuid, tasks.description, tasks.status, tasks.priority, tasks.project, tasks.tags, tasks.due, tasks.entry, tasks.modified, tasks.end, tasks.start, tasks.annotations
+		SELECT tasks.id, tasks.uuid, tasks.description, tasks.status, tasks.priority, tasks.project, tasks.context, tasks.tags, tasks.due, tasks.entry, tasks.modified, tasks.end, tasks.start, tasks.annotations
 		FROM tasks, json_each(tasks.tags)
 		WHERE tasks.tags != '' AND tasks.tags IS NOT NULL AND json_each.value = ?
 		ORDER BY tasks.modified DESC`
···
 func (r *TaskRepository) GetByPriority(ctx context.Context, priority string) ([]*models.Task, error) {
 	if priority == "" {
 		query := `
-			SELECT id, uuid, description, status, priority, project, tags, due, entry, modified, end, start, annotations
+			SELECT id, uuid, description, status, priority, project, context, tags, due, entry, modified, end, start, annotations
 			FROM tasks
 			WHERE priority = '' OR priority IS NULL
 			ORDER BY modified DESC`

internal/repo/task_repository_test.go

···
 			status TEXT DEFAULT 'pending',
 			priority TEXT,
 			project TEXT,
+			context TEXT,
 			tags TEXT,
 			due DATETIME,
 			entry DATETIME DEFAULT CURRENT_TIMESTAMP,
···
 		Status:      "pending",
 		Priority:    "H",
 		Project:     "test-project",
+		Context:     "test-context",
 		Tags:        []string{"test", "important"},
 		Annotations: []string{"This is a test", "Another annotation"},
 	}
···
 		}
 		if retrieved.Project != original.Project {
 			t.Errorf("Expected project %s, got %s", original.Project, retrieved.Project)
+		}
+		if retrieved.Context != original.Context {
+			t.Errorf("Expected context %s, got %s", original.Context, retrieved.Context)
 		}
 
 		if len(retrieved.Tags) != len(original.Tags) {
···
 		})
 	})
 }
+
+func TestTaskRepository_GetContexts(t *testing.T) {
+	db := createTaskTestDB(t)
+	repo := NewTaskRepository(db)
+	ctx := context.Background()
+
+	// Create tasks with different contexts
+	task1 := createSampleTask()
+	task1.Context = "work"
+	_, err := repo.Create(ctx, task1)
+	if err != nil {
+		t.Fatalf("Failed to create task1: %v", err)
+	}
+
+	task2 := createSampleTask()
+	task2.Context = "home"
+	_, err = repo.Create(ctx, task2)
+	if err != nil {
+		t.Fatalf("Failed to create task2: %v", err)
+	}
+
+	task3 := createSampleTask()
+	task3.Context = "work"
+	_, err = repo.Create(ctx, task3)
+	if err != nil {
+		t.Fatalf("Failed to create task3: %v", err)
+	}
+
+	// Task with empty context should not be included
+	task4 := createSampleTask()
+	task4.Context = ""
+	_, err = repo.Create(ctx, task4)
+	if err != nil {
+		t.Fatalf("Failed to create task4: %v", err)
+	}
+
+	contexts, err := repo.GetContexts(ctx)
+	if err != nil {
+		t.Fatalf("Failed to get contexts: %v", err)
+	}
+
+	if len(contexts) != 2 {
+		t.Errorf("Expected 2 contexts, got %d", len(contexts))
+	}
+
+	expectedCounts := map[string]int{
+		"home": 1,
+		"work": 2,
+	}
+
+	for _, context := range contexts {
+		expected, exists := expectedCounts[context.Name]
+		if !exists {
+			t.Errorf("Unexpected context: %s", context.Name)
+		}
+		if context.TaskCount != expected {
+			t.Errorf("Expected %d tasks for context %s, got %d", expected, context.Name, context.TaskCount)
+		}
+	}
+}
+
+func TestTaskRepository_GetByContext(t *testing.T) {
+	db := createTaskTestDB(t)
+	repo := NewTaskRepository(db)
+	ctx := context.Background()
+
+	// Create tasks with different contexts
+	task1 := createSampleTask()
+	task1.Context = "work"
+	task1.Description = "Work task 1"
+	_, err := repo.Create(ctx, task1)
+	if err != nil {
+		t.Fatalf("Failed to create task1: %v", err)
+	}
+
+	task2 := createSampleTask()
+	task2.Context = "home"
+	task2.Description = "Home task 1"
+	_, err = repo.Create(ctx, task2)
+	if err != nil {
+		t.Fatalf("Failed to create task2: %v", err)
+	}
+
+	task3 := createSampleTask()
+	task3.Context = "work"
+	task3.Description = "Work task 2"
+	_, err = repo.Create(ctx, task3)
+	if err != nil {
+		t.Fatalf("Failed to create task3: %v", err)
+	}
+
+	// Get tasks by work context
+	workTasks, err := repo.GetByContext(ctx, "work")
+	if err != nil {
+		t.Fatalf("Failed to get tasks by context: %v", err)
+	}
+
+	if len(workTasks) != 2 {
+		t.Errorf("Expected 2 work tasks, got %d", len(workTasks))
+	}
+
+	for _, task := range workTasks {
+		if task.Context != "work" {
+			t.Errorf("Expected context 'work', got '%s'", task.Context)
+		}
+	}
+
+	// Get tasks by home context  
+	homeTasks, err := repo.GetByContext(ctx, "home")
+	if err != nil {
+		t.Fatalf("Failed to get tasks by context: %v", err)
+	}
+
+	if len(homeTasks) != 1 {
+		t.Errorf("Expected 1 home task, got %d", len(homeTasks))
+	}
+
+	if homeTasks[0].Context != "home" {
+		t.Errorf("Expected context 'home', got '%s'", homeTasks[0].Context)
+	}
+}

internal/store/sql/migrations/0005_add_context_to_tasks_down.sql

···
+-- Remove context field and index
+DROP INDEX IF EXISTS idx_tasks_context;
+ALTER TABLE tasks DROP COLUMN context;

internal/store/sql/migrations/0005_add_context_to_tasks_up.sql

···
+-- Add context field to tasks table
+ALTER TABLE tasks ADD COLUMN context TEXT;
+
+-- Add index for context queries
+CREATE INDEX IF NOT EXISTS idx_tasks_context ON tasks(context);

internal/ui/task_list.go

···
 	Status   string
 	Priority string
 	Project  string
+	Context  string
 	ShowAll  bool
 }