feat(tasks): add periodic due-date check for recurring tasks

A recurring task's successor now also gets created once its due date
passes, independent of completion -- an ignored/overdue recurring task
no longer blocks the next occurrence from appearing. Runs every 15
minutes via a new goroutine in main.go, cancelled on shutdown.

2 files changed, 144 insertions, 0 deletions

diff --git a/internal/store/native_tasks.go b/internal/store/native_tasks.go
index 501c0bc..d4cc896 100644
--- a/internal/store/native_tasks.go
+++ b/internal/store/native_tasks.go
@@ -298,6 +298,49 @@ func (s *Store) SetNextOccurrenceOverride(id string, date time.Time) error {
 	return checkRowsAffected(result)
 }
 
+// GetSeriesNeedingNextIteration returns the latest row of every recurring
+// series whose due_date has arrived (<= now) and which has no newer row
+// yet in its series -- regardless of completed state, so a series whose
+// synchronous CreateNextIteration call (from CompleteNativeTask) somehow
+// failed still gets healed on the next tick, and so an uncompleted,
+// ignored recurring task doesn't block its successor from appearing.
+func (s *Store) GetSeriesNeedingNextIteration(now time.Time) ([]models.Task, error) {
+	rows, err := s.db.Query(`
+		SELECT id, content, description, project_name, due_date, priority, completed, labels, created_at,
+		       recurrence_freq, recurrence_interval, recurrence_weekdays, recurrence_series_id, next_occurrence_override
+		FROM native_tasks t1
+		WHERE recurrence_series_id != ''
+		  AND due_date IS NOT NULL AND due_date <= ?
+		  AND NOT EXISTS (
+		    SELECT 1 FROM native_tasks t2
+		    WHERE t2.recurrence_series_id = t1.recurrence_series_id
+		      AND (t2.due_date > t1.due_date
+		           OR (t2.due_date = t1.due_date AND t2.created_at > t1.created_at))
+		  )
+	`, now)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = rows.Close() }()
+	return scanNativeTasks(rows)
+}
+
+// AdvanceDueRecurringTasks creates the next iteration for every recurring
+// series whose latest row is due (or overdue) and has no successor yet.
+// Returns the number of iterations created.
+func (s *Store) AdvanceDueRecurringTasks(now time.Time) (int, error) {
+	series, err := s.GetSeriesNeedingNextIteration(now)
+	if err != nil {
+		return 0, err
+	}
+	for _, task := range series {
+		if err := s.CreateNextIteration(task); err != nil {
+			return 0, err
+		}
+	}
+	return len(series), nil
+}
+
 // checkRowsAffected returns ErrNativeTaskNotFound if the update matched no
 // rows -- mirrors the RowsAffected() check already used in sqlite.go's
 // ApproveAgentSession/DenyAgentSession for the same "silent 0-row update"
diff --git a/internal/store/native_tasks_test.go b/internal/store/native_tasks_test.go
index fae7e90..a299ac6 100644
--- a/internal/store/native_tasks_test.go
+++ b/internal/store/native_tasks_test.go
@@ -358,3 +358,104 @@ func TestSetNextOccurrenceOverride_UnknownID_ReturnsErrNotFound(t *testing.T) {
 		t.Fatalf("expected ErrNativeTaskNotFound, got %v", err)
 	}
 }
+
+func TestAdvanceDueRecurringTasks_DueUncompleted_CreatesSuccessor(t *testing.T) {
+	s := newNativeTasksTestStore(t)
+	if _, err := s.db.Exec(`
+		INSERT INTO native_tasks (id, content, due_date, recurrence_freq, recurrence_interval, recurrence_series_id)
+		VALUES ('rec-1', 'Water plants', '2026-07-13', 'weekly', 1, 'series-1')
+	`); err != nil {
+		t.Fatal(err)
+	}
+	now := time.Date(2026, 7, 14, 0, 0, 0, 0, time.UTC) // one day after due, still uncompleted
+
+	n, err := s.AdvanceDueRecurringTasks(now)
+	if err != nil {
+		t.Fatalf("AdvanceDueRecurringTasks: %v", err)
+	}
+	if n != 1 {
+		t.Fatalf("expected 1 iteration created, got %d", n)
+	}
+
+	var completed bool
+	if err := s.db.QueryRow(`SELECT completed FROM native_tasks WHERE id = 'rec-1'`).Scan(&completed); err != nil {
+		t.Fatal(err)
+	}
+	if completed {
+		t.Error("expected rec-1 to remain uncompleted -- due-date passing doesn't complete it, just spawns the successor")
+	}
+
+	var count int
+	if err := s.db.QueryRow(`SELECT COUNT(*) FROM native_tasks WHERE recurrence_series_id = 'series-1'`).Scan(&count); err != nil {
+		t.Fatal(err)
+	}
+	if count != 2 {
+		t.Fatalf("expected 2 rows in the series (original + successor), got %d", count)
+	}
+}
+
+func TestAdvanceDueRecurringTasks_NotYetDue_LeavesAlone(t *testing.T) {
+	s := newNativeTasksTestStore(t)
+	if _, err := s.db.Exec(`
+		INSERT INTO native_tasks (id, content, due_date, recurrence_freq, recurrence_interval, recurrence_series_id)
+		VALUES ('rec-1', 'Water plants', '2026-07-13', 'weekly', 1, 'series-1')
+	`); err != nil {
+		t.Fatal(err)
+	}
+	now := time.Date(2026, 7, 10, 0, 0, 0, 0, time.UTC) // before the due date
+
+	n, err := s.AdvanceDueRecurringTasks(now)
+	if err != nil {
+		t.Fatalf("AdvanceDueRecurringTasks: %v", err)
+	}
+	if n != 0 {
+		t.Errorf("expected 0 iterations created for a not-yet-due task, got %d", n)
+	}
+}
+
+func TestAdvanceDueRecurringTasks_AlreadyHasSuccessor_SkipsIt(t *testing.T) {
+	s := newNativeTasksTestStore(t)
+	if _, err := s.db.Exec(`
+		INSERT INTO native_tasks (id, content, due_date, recurrence_freq, recurrence_interval, recurrence_series_id)
+		VALUES ('rec-1', 'Water plants', '2026-07-13', 'weekly', 1, 'series-1')
+	`); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.db.Exec(`
+		INSERT INTO native_tasks (id, content, due_date, recurrence_freq, recurrence_interval, recurrence_series_id)
+		VALUES ('rec-2', 'Water plants', '2026-07-20', 'weekly', 1, 'series-1')
+	`); err != nil {
+		t.Fatal(err)
+	}
+	now := time.Date(2026, 7, 21, 0, 0, 0, 0, time.UTC)
+
+	n, err := s.AdvanceDueRecurringTasks(now)
+	if err != nil {
+		t.Fatalf("AdvanceDueRecurringTasks: %v", err)
+	}
+	if n != 1 {
+		t.Fatalf("expected only rec-2 (the latest, now also due) to spawn a successor, got n=%d", n)
+	}
+
+	var count int
+	if err := s.db.QueryRow(`SELECT COUNT(*) FROM native_tasks WHERE recurrence_series_id = 'series-1'`).Scan(&count); err != nil {
+		t.Fatal(err)
+	}
+	if count != 3 {
+		t.Fatalf("expected 3 rows total (rec-1, rec-2, and rec-2's new successor), got %d", count)
+	}
+}
+
+func TestAdvanceDueRecurringTasks_NonRecurringTask_NeverTouched(t *testing.T) {
+	s := newNativeTasksTestStore(t)
+	// "real-1" (from newNativeTasksTestStore) has no due_date and no recurrence.
+	now := time.Date(2026, 7, 14, 0, 0, 0, 0, time.UTC)
+
+	n, err := s.AdvanceDueRecurringTasks(now)
+	if err != nil {
+		t.Fatalf("AdvanceDueRecurringTasks: %v", err)
+	}
+	if n != 0 {
+		t.Errorf("expected 0 iterations created (no recurring tasks in fixture), got %d", n)
+	}
+}