feat(tasks): added reporting & additional task views

* extended task model for scoring, & dependencies

cmd/task_commands.go

···
 		&cobra.Group{ID: "task-ops", Title: "Basic Operations"},
 		&cobra.Group{ID: "task-meta", Title: "Metadata"},
 		&cobra.Group{ID: "task-tracking", Title: "Tracking"},
+		&cobra.Group{ID: "task-reports", Title: "Reports & Views"},
 	)
 
 	for _, init := range []func(*handlers.TaskHandler) *cobra.Command{
···
 		root.AddCommand(cmd)
 	}
 
+	for _, init := range []func(*handlers.TaskHandler) *cobra.Command{
+		nextActionsCmd, reportCompletedCmd, reportWaitingCmd, reportBlockedCmd, calendarCmd,
+	} {
+		cmd := init(c.handler)
+		cmd.GroupID = "task-reports"
+		root.AddCommand(cmd)
+	}
+
 	return root
 }
 
···
 			project, _ := c.Flags().GetString("project")
 			context, _ := c.Flags().GetString("context")
 			due, _ := c.Flags().GetString("due")
+			wait, _ := c.Flags().GetString("wait")
+			scheduled, _ := c.Flags().GetString("scheduled")
 			recur, _ := c.Flags().GetString("recur")
 			until, _ := c.Flags().GetString("until")
 			parent, _ := c.Flags().GetString("parent")
···
 			tags, _ := c.Flags().GetStringSlice("tags")
 
 			defer h.Close()
-			return h.Create(c.Context(), description, priority, project, context, due, recur, until, parent, dependsOn, tags)
+			// TODO: Make a CreateTask struct
+			return h.Create(c.Context(), description, priority, project, context, due, wait, scheduled, recur, until, parent, dependsOn, tags)
 		},
 	}
 	addCommonTaskFlags(cmd)
 	addDueDateFlag(cmd)
+	addWaitScheduledFlags(cmd)
 	addRecurrenceFlags(cmd)
 	addParentFlag(cmd)
 	addDependencyFlags(cmd)
···
 			priority, _ := c.Flags().GetString("priority")
 			project, _ := c.Flags().GetString("project")
 			context, _ := c.Flags().GetString("context")
+			sortBy, _ := c.Flags().GetString("sort")
 
 			defer h.Close()
-			return h.List(c.Context(), static, showAll, status, priority, project, context)
+			// TODO: TaskFilter struct
+			return h.List(c.Context(), static, showAll, status, priority, project, context, sortBy)
 		},
 	}
 	cmd.Flags().BoolP("interactive", "i", false, "Force interactive mode (default)")
···
 	cmd.Flags().String("priority", "", "Filter by priority")
 	cmd.Flags().String("project", "", "Filter by project")
 	cmd.Flags().String("context", "", "Filter by context")
+	cmd.Flags().String("sort", "", "Sort by (urgency)")
 
 	return cmd
 }
···
 
 	root.AddCommand(setCmd, clearCmd, showCmd)
 	return root
+}
+
+func nextActionsCmd(h *handlers.TaskHandler) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "next",
+		Short:   "Show next actions (actionable tasks sorted by urgency)",
+		Aliases: []string{"na"},
+		Long: `Display actionable tasks sorted by urgency score.
+
+Shows tasks that can be worked on now (not waiting, not blocked, not completed),
+ordered by their computed urgency based on priority, due date, age, and other factors.`,
+		RunE: func(c *cobra.Command, args []string) error {
+			limit, _ := c.Flags().GetInt("limit")
+			defer h.Close()
+			return h.NextActions(c.Context(), limit)
+		},
+	}
+	cmd.Flags().IntP("limit", "n", 10, "Limit number of tasks shown")
+	return cmd
+}
+
+func reportCompletedCmd(h *handlers.TaskHandler) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "completed",
+		Short: "Show completed tasks",
+		Long:  "Display tasks that have been completed, sorted by completion date.",
+		RunE: func(c *cobra.Command, args []string) error {
+			limit, _ := c.Flags().GetInt("limit")
+			defer h.Close()
+			return h.ReportCompleted(c.Context(), limit)
+		},
+	}
+	cmd.Flags().IntP("limit", "n", 20, "Limit number of tasks shown")
+	return cmd
+}
+
+func reportWaitingCmd(h *handlers.TaskHandler) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "waiting",
+		Short: "Show waiting tasks",
+		Long:  "Display tasks that are waiting for a specific date before becoming actionable.",
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.ReportWaiting(c.Context())
+		},
+	}
+	return cmd
+}
+
+func reportBlockedCmd(h *handlers.TaskHandler) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "blocked",
+		Short: "Show blocked tasks",
+		Long:  "Display tasks that are blocked by dependencies on other tasks.",
+		RunE: func(c *cobra.Command, args []string) error {
+			defer h.Close()
+			return h.ReportBlocked(c.Context())
+		},
+	}
+	return cmd
+}
+
+func calendarCmd(h *handlers.TaskHandler) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "calendar",
+		Short:   "Show tasks in calendar view",
+		Aliases: []string{"cal"},
+		Long: `Display tasks with due dates in a calendar format.
+
+Shows tasks organized by week and day, making it easy to see upcoming deadlines
+and plan your work schedule.`,
+		RunE: func(c *cobra.Command, args []string) error {
+			weeks, _ := c.Flags().GetInt("weeks")
+			defer h.Close()
+			return h.Calendar(c.Context(), weeks)
+		},
+	}
+	cmd.Flags().IntP("weeks", "w", 4, "Number of weeks to show")
+	return cmd
 }
 
 func taskDependCmd(h *handlers.TaskHandler) *cobra.Command {

cmd/task_flags.go

···
 func addDueDateFlag(cmd *cobra.Command) {
 	cmd.Flags().StringP("due", "d", "", "Set due date (YYYY-MM-DD)")
 }
+
+func addWaitScheduledFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("wait", "w", "", "Task not actionable until date (YYYY-MM-DD)")
+	cmd.Flags().StringP("scheduled", "s", "", "Task scheduled to start on date (YYYY-MM-DD)")
+}

internal/docs/ROADMAP.md

···
 
 ### Tasks
 
-- [ ] Model
-    - [ ] Dependencies
-    - [ ] Recurrence (`recur`, `until`, templates)
-    - [ ] Wait/scheduled dates
-    - [ ] Urgency scoring
+- [x] Model
+    - [x] Dependencies
+    - [x] Recurrence (`recur`, `until`, templates)
+    - [x] Wait/scheduled dates
+    - [x] Urgency scoring
 - [ ] Operations
     - [ ] `annotate`
     - [ ] Bulk edit and undo/history
     - [ ] `$EDITOR` integration
-- [ ] Reports and Views
-    - [ ] Next actions
-    - [ ] Completed/waiting/blocked reports
-    - [ ] Calendar view
-    - [ ] Sorting and urgency-based views
+- [x] Reports and Views
+    - [x] Next actions
+    - [x] Completed/waiting/blocked reports
+    - [x] Calendar view
+    - [x] Sorting and urgency-based views
 - [ ] Queries and Filters
     - [ ] Rich query language
     - [ ] Saved filters and aliases
···
 | Tasks        | Time tracking              | Complete  |
 | Tasks        | Dependencies               | Complete  |
 | Tasks        | Recurrence                 | Complete  |
-| Tasks        | Wait/scheduled             | Planned   |
-| Tasks        | Urgency scoring            | Planned   |
+| Tasks        | Wait/scheduled             | Complete  |
+| Tasks        | Urgency scoring            | Complete  |
+| Tasks        | Reports and views          | Complete  |
 | Notes        | CRUD                       | Complete  |
 | Notes        | Search/tagging             | Planned   |
 | Publications | AT Protocol sync           | Complete  |

internal/handlers/task_helpers.go

···
 	Context     string
 	Tags        []string
 	Due         string
+	Wait        string
+	Scheduled   string
 	Recur       string
 	Until       string
 	ParentUUID  string
···
 }
 
 // parseDescription extracts inline metadata from description text
-// Supports: +project @context #tag due:YYYY-MM-DD recur:RULE until:DATE parent:UUID depends:UUID1,UUID2
+// Supports: +project @context #tag due:YYYY-MM-DD wait:YYYY-MM-DD scheduled:YYYY-MM-DD recur:RULE until:DATE parent:UUID depends:UUID1,UUID2
 func parseDescription(text string) *ParsedTaskData {
 	parsed := &ParsedTaskData{Tags: []string{}, DependsOn: []string{}}
 	words := strings.Fields(text)
···
 			parsed.Tags = append(parsed.Tags, strings.TrimPrefix(word, "#"))
 		case strings.HasPrefix(word, "due:"):
 			parsed.Due = strings.TrimPrefix(word, "due:")
+		case strings.HasPrefix(word, "wait:"):
+			parsed.Wait = strings.TrimPrefix(word, "wait:")
+		case strings.HasPrefix(word, "scheduled:"):
+			parsed.Scheduled = strings.TrimPrefix(word, "scheduled:")
 		case strings.HasPrefix(word, "recur:"):
 			parsed.Recur = strings.TrimPrefix(word, "recur:")
 		case strings.HasPrefix(word, "until:"):

internal/handlers/tasks.go

···
 	"fmt"
 	"os"
 	"slices"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
···
 }
 
 // Create creates a new task
-func (h *TaskHandler) Create(ctx context.Context, description, priority, project, context, due, recur, until, parentUUID, dependsOn string, tags []string) error {
+func (h *TaskHandler) Create(ctx context.Context, description, priority, project, context, due, wait, scheduled, recur, until, parentUUID, dependsOn string, tags []string) error {
 	if description == "" {
 		return fmt.Errorf("task description required")
 	}
···
 	if due != "" {
 		parsed.Due = due
 	}
+	if wait != "" {
+		parsed.Wait = wait
+	}
+	if scheduled != "" {
+		parsed.Scheduled = scheduled
+	}
 	if recur != "" {
 		parsed.Recur = recur
 	}
···
 			task.Due = &dueTime
 		} else {
 			return fmt.Errorf("invalid due date format, use YYYY-MM-DD: %w", err)
+		}
+	}
+
+	if parsed.Wait != "" {
+		if waitTime, err := time.Parse("2006-01-02", parsed.Wait); err == nil {
+			task.Wait = &waitTime
+		} else {
+			return fmt.Errorf("invalid wait date format, use YYYY-MM-DD: %w", err)
+		}
+	}
+
+	if parsed.Scheduled != "" {
+		if scheduledTime, err := time.Parse("2006-01-02", parsed.Scheduled); err == nil {
+			task.Scheduled = &scheduledTime
+		} else {
+			return fmt.Errorf("invalid scheduled date format, use YYYY-MM-DD: %w", err)
 		}
 	}
 
···
 }
 
 // List lists all tasks with optional filtering
-func (h *TaskHandler) List(ctx context.Context, static, showAll bool, status, priority, project, context string) error {
+func (h *TaskHandler) List(ctx context.Context, static, showAll bool, status, priority, project, context, sortBy string) error {
 	if static {
-		return h.listTasksStatic(ctx, showAll, status, priority, project, context)
+		return h.listTasksStatic(ctx, showAll, status, priority, project, context, sortBy)
 	}
 
 	return h.listTasksInteractive(ctx, showAll, status, priority, project, context)
 }
 
-func (h *TaskHandler) listTasksStatic(ctx context.Context, showAll bool, status, priority, project, context string) error {
+func (h *TaskHandler) listTasksStatic(ctx context.Context, showAll bool, status, priority, project, context, sortBy string) error {
 	opts := repo.TaskListOptions{
 		Status:   status,
 		Priority: priority,
···
 		return fmt.Errorf("failed to list tasks: %w", err)
 	}
 
+	if sortBy == "urgency" {
+		now := time.Now()
+		sort.Slice(tasks, func(i, j int) bool {
+			return tasks[i].Urgency(now) > tasks[j].Urgency(now)
+		})
+	}
+
 	if len(tasks) == 0 {
 		fmt.Printf("No tasks found matching criteria\n")
 		return nil
 	}
 
-	fmt.Printf("Found %d task(s):\n\n", len(tasks))
+	fmt.Printf("Found %d task(s)", len(tasks))
+	if sortBy == "urgency" {
+		fmt.Printf(" (sorted by urgency)")
+	}
+	fmt.Printf(":\n\n")
+
 	for _, task := range tasks {
+		if sortBy == "urgency" {
+			urgency := task.Urgency(time.Now())
+			fmt.Printf("[%.1f] ", urgency)
+		}
 		printTask(task)
 	}
 
···
 
 	return nil
 }
+
+// NextActions shows actionable tasks sorted by urgency
+func (h *TaskHandler) NextActions(ctx context.Context, limit int) error {
+	opts := repo.TaskListOptions{
+		SortBy:    "urgency",
+		SortOrder: "desc",
+	}
+
+	tasks, err := h.repos.Tasks.List(ctx, opts)
+	if err != nil {
+		return fmt.Errorf("failed to list tasks: %w", err)
+	}
+
+	now := time.Now()
+	var actionable []*models.Task
+	for _, task := range tasks {
+		if task.IsActionable(now) {
+			actionable = append(actionable, task)
+		}
+	}
+
+	sort.Slice(actionable, func(i, j int) bool {
+		return actionable[i].Urgency(now) > actionable[j].Urgency(now)
+	})
+
+	if limit > 0 && len(actionable) > limit {
+		actionable = actionable[:limit]
+	}
+
+	if len(actionable) == 0 {
+		fmt.Println("No actionable tasks found")
+		return nil
+	}
+
+	fmt.Printf("Next Actions (%d tasks, sorted by urgency):\n\n", len(actionable))
+	for i, task := range actionable {
+		urgency := task.Urgency(now)
+		fmt.Printf("%d. [Urgency: %.1f] ", i+1, urgency)
+		printTask(task)
+	}
+
+	return nil
+}
+
+// ReportCompleted shows completed tasks
+func (h *TaskHandler) ReportCompleted(ctx context.Context, limit int) error {
+	opts := repo.TaskListOptions{
+		Status:    "done",
+		SortBy:    "modified",
+		SortOrder: "desc",
+		Limit:     limit,
+	}
+
+	tasks, err := h.repos.Tasks.List(ctx, opts)
+	if err != nil {
+		return fmt.Errorf("failed to list completed tasks: %w", err)
+	}
+
+	if len(tasks) == 0 {
+		fmt.Println("No completed tasks found")
+		return nil
+	}
+
+	fmt.Printf("Completed Tasks (%d):\n\n", len(tasks))
+	for _, task := range tasks {
+		fmt.Printf("  ")
+		printTask(task)
+		if task.End != nil {
+			fmt.Printf("    Completed: %s\n", task.End.Format("2006-01-02 15:04"))
+		}
+	}
+
+	return nil
+}
+
+// ReportWaiting shows tasks that are waiting
+func (h *TaskHandler) ReportWaiting(ctx context.Context) error {
+	opts := repo.TaskListOptions{
+		SortBy:    "wait",
+		SortOrder: "asc",
+	}
+
+	tasks, err := h.repos.Tasks.List(ctx, opts)
+	if err != nil {
+		return fmt.Errorf("failed to list tasks: %w", err)
+	}
+
+	now := time.Now()
+	var waiting []*models.Task
+	for _, task := range tasks {
+		if task.IsWaiting(now) {
+			waiting = append(waiting, task)
+		}
+	}
+
+	if len(waiting) == 0 {
+		fmt.Println("No waiting tasks found")
+		return nil
+	}
+
+	fmt.Printf("Waiting Tasks (%d):\n\n", len(waiting))
+	for _, task := range waiting {
+		fmt.Printf("  ")
+		printTask(task)
+		if task.Wait != nil {
+			daysUntil := int(task.Wait.Sub(now).Hours() / 24)
+			fmt.Printf("    Wait until: %s (%d days)\n", task.Wait.Format("2006-01-02"), daysUntil)
+		}
+	}
+
+	return nil
+}
+
+// ReportBlocked shows blocked tasks
+func (h *TaskHandler) ReportBlocked(ctx context.Context) error {
+	opts := repo.TaskListOptions{
+		Status: "blocked",
+	}
+
+	tasks, err := h.repos.Tasks.List(ctx, opts)
+	if err != nil {
+		return fmt.Errorf("failed to list blocked tasks: %w", err)
+	}
+
+	if len(tasks) == 0 {
+		fmt.Println("No blocked tasks found")
+		return nil
+	}
+
+	fmt.Printf("Blocked Tasks (%d):\n\n", len(tasks))
+	for _, task := range tasks {
+		fmt.Printf("  ")
+		printTask(task)
+
+		if len(task.DependsOn) > 0 {
+			fmt.Printf("    Depends on %d task(s)\n", len(task.DependsOn))
+		}
+	}
+
+	return nil
+}
+
+// Calendar shows tasks by due date in a calendar-like view
+func (h *TaskHandler) Calendar(ctx context.Context, weeks int) error {
+	if weeks <= 0 {
+		weeks = 4
+	}
+
+	now := time.Now()
+	startDate := now.Truncate(24 * time.Hour)
+	endDate := startDate.AddDate(0, 0, weeks*7)
+
+	opts := repo.TaskListOptions{
+		SortBy:    "due",
+		SortOrder: "asc",
+	}
+
+	tasks, err := h.repos.Tasks.List(ctx, opts)
+	if err != nil {
+		return fmt.Errorf("failed to list tasks: %w", err)
+	}
+
+	tasksByDate := make(map[string][]*models.Task)
+	overdue := []*models.Task{}
+
+	for _, task := range tasks {
+		if task.Due == nil || task.IsCompleted() || task.IsDone() {
+			continue
+		}
+
+		dueDate := task.Due.Truncate(24 * time.Hour)
+		if dueDate.Before(startDate) {
+			overdue = append(overdue, task)
+		} else if dueDate.Before(endDate) {
+			dateKey := dueDate.Format("2006-01-02")
+			tasksByDate[dateKey] = append(tasksByDate[dateKey], task)
+		}
+	}
+
+	fmt.Printf("Calendar View (Next %d weeks)\n", weeks)
+	fmt.Printf("Today: %s\n\n", now.Format("Monday, January 2, 2006"))
+
+	if len(overdue) > 0 {
+		fmt.Printf("OVERDUE (%d tasks):\n", len(overdue))
+		for _, task := range overdue {
+			daysOverdue := int(now.Sub(*task.Due).Hours() / 24)
+			fmt.Printf("  [%d days overdue] ", daysOverdue)
+			printTask(task)
+		}
+		fmt.Println()
+	}
+
+	currentDate := startDate
+	for currentDate.Before(endDate) {
+		weekStart := currentDate
+		weekEnd := currentDate.AddDate(0, 0, 6)
+
+		weekTasks := 0
+		for d := weekStart; !d.After(weekEnd); d = d.AddDate(0, 0, 1) {
+			dateKey := d.Format("2006-01-02")
+			weekTasks += len(tasksByDate[dateKey])
+		}
+
+		if weekTasks > 0 {
+			fmt.Printf("Week of %s (%d tasks):\n", weekStart.Format("Jan 2"), weekTasks)
+
+			for d := weekStart; !d.After(weekEnd); d = d.AddDate(0, 0, 1) {
+				dateKey := d.Format("2006-01-02")
+				dayTasks := tasksByDate[dateKey]
+
+				if len(dayTasks) > 0 {
+					dayName := d.Format("Monday, Jan 2")
+					if d.Format("2006-01-02") == now.Format("2006-01-02") {
+						dayName += " (TODAY)"
+					}
+					fmt.Printf("  %s:\n", dayName)
+					for _, task := range dayTasks {
+						fmt.Printf("    ")
+						printTask(task)
+					}
+				}
+			}
+			fmt.Println()
+		}
+
+		currentDate = currentDate.AddDate(0, 0, 7)
+	}
+
+	if len(overdue) == 0 && len(tasksByDate) == 0 {
+		fmt.Println("No tasks with due dates in the next", weeks, "weeks")
+	}
+
+	return nil
+}

internal/handlers/tasks_test.go

···
 
 		t.Run("creates task successfully", func(t *testing.T) {
 			desc := "Buy groceries and cook dinner"
-			err := handler.Create(ctx, desc, "", "", "", "", "", "", "", "", []string{})
+			err := handler.Create(ctx, desc, "", "", "", "", "", "", "", "", "", "", []string{})
 			shared.AssertNoError(t, err, "CreateTask should succeed")
 
 			tasks, err := handler.repos.Tasks.GetPending(ctx)
···
 
 		t.Run("fails with empty description", func(t *testing.T) {
 			desc := ""
-			err := handler.Create(ctx, desc, "", "", "", "", "", "", "", "", []string{})
+			err := handler.Create(ctx, desc, "", "", "", "", "", "", "", "", "", "", []string{})
 			shared.AssertError(t, err, "Expected error for empty description")
 			shared.AssertContains(t, err.Error(), "task description required", "Error message should mention required description")
 		})
···
 			due := "2024-12-31"
 			tags := []string{"urgent", "work"}
 
-			err := handler.Create(ctx, description, priority, project, "test-context", due, "", "", "", "", tags)
+			err := handler.Create(ctx, description, priority, project, "test-context", due, "", "", "", "", "", "", tags)
 			if err != nil {
 				t.Errorf("CreateTask with flags failed: %v", err)
 			}
···
 			desc := "Task with invalid date"
 			invalidDue := "invalid-date"
 
-			err := handler.Create(ctx, desc, "", "", "", invalidDue, "", "", "", "", []string{})
+			err := handler.Create(ctx, desc, "", "", "", invalidDue, "", "", "", "", "", "", []string{})
 			if err == nil {
 				t.Error("Expected error for invalid due date format")
 			}
···
 			ctx, cancel := context.WithCancel(ctx)
 			cancel()
 
-			err := handler.Create(ctx, "Test task", "", "", "", "", "", "", "", "", []string{})
+			err := handler.Create(ctx, "Test task", "", "", "", "", "", "", "", "", "", "", []string{})
 			if err == nil {
 				t.Error("Expected error when repository Create fails")
 			}
···
 		}
 
 		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)
 			}
···
 		}
 		defer handler.Close()
 
-		err = handler.Create(ctx, "Test Task 1", "high", "test-project", "test-context", "", "", "", "", "", []string{"tag1"})
+		err = handler.Create(ctx, "Test Task 1", "high", "test-project", "test-context", "", "", "", "", "", "", "", []string{"tag1"})
 		if err != nil {
 			t.Fatalf("Failed to create test task: %v", err)
 		}
 
-		err = handler.Create(ctx, "Test Task 2", "medium", "test-project", "test-context", "", "", "", "", "", []string{"tag2"})
+		err = handler.Create(ctx, "Test Task 2", "medium", "test-project", "test-context", "", "", "", "", "", "", "", []string{"tag2"})
 		if err != nil {
 			t.Fatalf("Failed to create test task: %v", err)
 		}

internal/models/models.go

···
 	Context     string     `json:"context,omitempty"`
 	Tags        []string   `json:"tags,omitempty"`
 	Due         *time.Time `json:"due,omitempty"`
+	Wait        *time.Time `json:"wait,omitempty"`      // Task is not actionable until this date
+	Scheduled   *time.Time `json:"scheduled,omitempty"` // Task is scheduled to start on this date
 	Entry       time.Time  `json:"entry"`
 	Modified    time.Time  `json:"modified"`
 	End         *time.Time `json:"end,omitempty"`   // Completion time
···
 // HasDueDate returns true if the task has a due date set.
 func (t *Task) HasDueDate() bool { return t.Due != nil }
 
+// IsWaiting returns true if the task has a wait date and it hasn't passed yet.
+func (t *Task) IsWaiting(now time.Time) bool {
+	return t.Wait != nil && now.Before(*t.Wait)
+}
+
+// HasWaitDate returns true if the task has a wait date set.
+func (t *Task) HasWaitDate() bool { return t.Wait != nil }
+
+// IsScheduled returns true if the task has a scheduled date.
+func (t *Task) IsScheduled() bool { return t.Scheduled != nil }
+
+// IsActionable returns true if the task can be worked on now.
+// A task is actionable if it's not waiting, not blocked, and not completed.
+func (t *Task) IsActionable(now time.Time) bool {
+	if t.IsCompleted() || t.IsDone() || t.IsAbandoned() || t.IsBlocked() {
+		return false
+	}
+	if t.IsWaiting(now) {
+		return false
+	}
+	return true
+}
+
 // IsRecurring returns true if the task has recurrence defined.
 func (t *Task) IsRecurring() bool { return t.Recur != "" }
 
···
 	return slices.Contains(other.DependsOn, t.UUID)
 }
 
-// Urgency computes a score based on priority, due date, and tags.
-// This can be expanded later with weights.
+// Urgency computes a comprehensive score based on multiple factors.
+// Higher score means more urgent. Score components:
+// - Priority: 0-10 based on priority weight
+// - Due date: 0-12 based on proximity (overdue gets highest)
+// - Scheduled: 0-4 if scheduled soon
+// - Age: 0-2 for old tasks
+// - Tags: 0.5 per tag (capped at 2.0)
+// - Waiting: -5.0 if not yet actionable
+// - Blocked: -3.0 if has incomplete dependencies
 func (t *Task) Urgency(now time.Time) float64 {
+	if !t.IsActionable(now) {
+		if t.IsWaiting(now) {
+			return -5.0
+		}
+		if t.IsBlocked() {
+			return -3.0
+		}
+		return -10.0
+	}
+
 	score := 0.0
-	if t.Priority != "" {
-		score += 1.0
+
+	if t.HasPriority() {
+		weight := t.GetPriorityWeight()
+		if weight >= 20 {
+			score += float64(weight-15) / 2.0
+		} else if weight > 0 {
+			score += float64(weight) * 2.0
+		}
+	}
+
+	if t.HasDueDate() {
+		daysUntilDue := t.Due.Sub(now).Hours() / 24.0
+		if daysUntilDue < 0 {
+			overdueDays := -daysUntilDue
+			score += 12.0 + min(overdueDays*0.5, 3.0)
+		} else if daysUntilDue <= 1 {
+			score += 10.0
+		} else if daysUntilDue <= 3 {
+			score += 8.0
+		} else if daysUntilDue <= 7 {
+			score += 6.0
+		} else if daysUntilDue <= 14 {
+			score += 4.0
+		} else if daysUntilDue <= 30 {
+			score += 2.0
+		}
 	}
-	if t.IsOverdue(now) {
+
+	if t.IsScheduled() {
+		daysUntilScheduled := t.Scheduled.Sub(now).Hours() / 24.0
+		if daysUntilScheduled <= 0 {
+			score += 4.0
+		} else if daysUntilScheduled <= 1 {
+			score += 3.0
+		} else if daysUntilScheduled <= 3 {
+			score += 2.0
+		} else if daysUntilScheduled <= 7 {
+			score += 1.0
+		}
+	}
+
+	age := now.Sub(t.Entry).Hours() / 24.0
+	if age > 90 {
 		score += 2.0
+	} else if age > 30 {
+		score += 1.5
+	} else if age > 14 {
+		score += 1.0
+	} else if age > 7 {
+		score += 0.5
 	}
+
 	if len(t.Tags) > 0 {
+		score += min(float64(len(t.Tags))*0.5, 2.0)
+	}
+
+	if t.Project != "" {
 		score += 0.5
 	}
+
 	return score
 }
 

internal/repo/queries.go

···
 )
 
 const (
-	taskColumns     = "id, uuid, description, status, priority, project, context, tags, due, entry, modified, end, start, annotations, recur, until, parent_uuid"
+	taskColumns     = "id, uuid, description, status, priority, project, context, tags, due, wait, scheduled, entry, modified, end, start, annotations, recur, until, parent_uuid"
 	queryTaskByID   = "SELECT " + taskColumns + " FROM tasks WHERE id = ?"
 	queryTaskByUUID = "SELECT " + taskColumns + " FROM tasks WHERE uuid = ?"
 	queryTaskInsert = `
 		INSERT INTO tasks (
 			uuid, description, status, priority, project, context,
-			tags, due, entry, modified, end, start, annotations,
+			tags, due, wait, scheduled, entry, modified, end, start, annotations,
 			recur, until, parent_uuid
 		)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
 	queryTaskUpdate = `
 		UPDATE tasks SET
 			uuid = ?, description = ?, status = ?, priority = ?, project = ?, context = ?,
-			tags = ?, due = ?, modified = ?, end = ?, start = ?, annotations = ?,
+			tags = ?, due = ?, wait = ?, scheduled = ?, modified = ?, end = ?, start = ?, annotations = ?,
 			recur = ?, until = ?, parent_uuid = ?
 		WHERE id = ?`
 	queryTaskDelete = "DELETE FROM tasks WHERE id = ?"

internal/repo/task_repository.go

···
 	if err := s.Scan(
 		&task.ID, &task.UUID, &task.Description, &task.Status, &priority,
 		&project, &context, &tags,
-		&task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations,
+		&task.Due, &task.Wait, &task.Scheduled, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations,
 		&task.Recur, &task.Until, &parentUUID,
 	); err != nil {
 		return nil, err
···
 
 	result, err := r.db.ExecContext(ctx, queryTaskInsert,
 		task.UUID, task.Description, task.Status, task.Priority, task.Project, task.Context,
-		tags, task.Due, task.Entry, task.Modified, task.End, task.Start, annotations,
+		tags, task.Due, task.Wait, task.Scheduled, task.Entry, task.Modified, task.End, task.Start, annotations,
 		task.Recur, task.Until, task.ParentUUID,
 	)
 	if err != nil {
···
 
 	if _, err = r.db.ExecContext(ctx, queryTaskUpdate,
 		task.UUID, task.Description, task.Status, task.Priority, task.Project, task.Context,
-		tags, task.Due, task.Modified, task.End, task.Start, annotations,
+		tags, task.Due, task.Wait, task.Scheduled, task.Modified, task.End, task.Start, annotations,
 		task.Recur, task.Until, task.ParentUUID,
 		task.ID,
 	); err != nil {
···
 func (r *TaskRepository) GetTasksByTag(ctx context.Context, tag string) ([]*models.Task, error) {
 	query := `
 		SELECT t.id, t.uuid, t.description, t.status, t.priority, t.project, t.context,
-		       t.tags, t.due, t.entry, t.modified, t.end, t.start, t.annotations,
+		       t.tags, t.due, t.wait, t.scheduled, t.entry, t.modified, t.end, t.start, t.annotations,
 		       t.recur, t.until, t.parent_uuid
 		FROM tasks t, json_each(t.tags)
 		WHERE t.tags != '' AND t.tags IS NOT NULL AND json_each.value = ?
···
 func (r *TaskRepository) GetDependents(ctx context.Context, blockingUUID string) ([]*models.Task, error) {
 	query := `
 		SELECT t.id, t.uuid, t.description, t.status, t.priority, t.project, t.context,
-		       t.tags, t.due, t.entry, t.modified, t.end, t.start, t.annotations, t.recur, t.until, t.parent_uuid
+		       t.tags, t.due, t.wait, t.scheduled, t.entry, t.modified, t.end, t.start, t.annotations, t.recur, t.until, t.parent_uuid
 		FROM tasks t JOIN task_dependencies d ON t.uuid = d.task_uuid WHERE d.depends_on_uuid = ?`
 
 	tasks, err := r.queryMany(ctx, query, blockingUUID)
···
 func (r *TaskRepository) GetBlockedTasks(ctx context.Context, blockingUUID string) ([]*models.Task, error) {
 	query := `
 		SELECT t.id, t.uuid, t.description, t.status, t.priority, t.project, t.context,
-		       t.tags, t.due, t.entry, t.modified, t.end, t.start, t.annotations, t.recur, t.until, t.parent_uuid
+		       t.tags, t.due, t.wait, t.scheduled, t.entry, t.modified, t.end, t.start, t.annotations, t.recur, t.until, t.parent_uuid
 		FROM tasks t
 		JOIN task_dependencies d ON t.uuid = d.task_uuid
 		WHERE d.depends_on_uuid = ?`

internal/store/sql/migrations/0009_add_wait_scheduled_to_tasks_down.sql

···
+ALTER TABLE tasks DROP COLUMN wait;
+ALTER TABLE tasks DROP COLUMN scheduled;

internal/store/sql/migrations/0009_add_wait_scheduled_to_tasks_up.sql

···
+ALTER TABLE tasks ADD COLUMN wait DATETIME;
+ALTER TABLE tasks ADD COLUMN scheduled DATETIME;