3 files changed, 177 insertions, 0 deletions
diff --git a/internal/scheduler/recurrence.go b/internal/scheduler/recurrence.go
new file mode 100644
index 0000000..3d48d8f
--- /dev/null
+++ b/internal/scheduler/recurrence.go
@@ -0,0 +1,33 @@
+package scheduler
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"task-dashboard/internal/config"
+	"task-dashboard/internal/store"
+)
+
+// RunRecurrenceCheck ticks every interval, calling AdvanceDueRecurringTasks
+// until ctx is cancelled. Errors are logged, not fatal -- one bad tick
+// shouldn't kill the loop; the next tick tries again.
+func RunRecurrenceCheck(ctx context.Context, s *store.Store, interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			n, err := s.AdvanceDueRecurringTasks(config.Now())
+			if err != nil {
+				log.Printf("ERROR [RecurrenceCheck]: %v", err)
+				continue
+			}
+			if n > 0 {
+				log.Printf("RecurrenceCheck: created %d next iteration(s)", n)
+			}
+		}
+	}
+}
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)
+	}
+}