feat(tasks): repeating tasks (daily, weekly, monthly, yearly)

- recurrence on tasks, set in the detail dialog; 🔁 on rows and Kanban cards
- Completing a repeating task (detail, list, Kanban drag to done, note
  checkbox) creates the next one: title, tags, priority, notes, list,
  assignees and rule copied, subtasks reset, first open column, due date
  one interval later (month end clamped); pushed live as TASK_CREATED
- Each task spawns at most once (re-open + complete makes no duplicate)
- Export/import keep the rule (Obsidian Tasks "🔁 every week", JSON field)

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

internal/api/server.go

@@ -43,6 +43,10 @@ func NewServer(cfg *config.Config, store *storage.Store, wsHub *ws.Hub, staticFS
 		notifier: collab.NewNotifier(),
 	}
 	wsHub.SetRoomAuthorizer(srv.canJoinRoom)
+	// Next occurrences of repeating tasks appear live on every connected client
+	store.OnTaskCreated = func(th *domain.Thought) {
+		srv.wsHub.BroadcastToUsers(srv.taskAudience(th), "TASK_CREATED", th)
+	}
 	go srv.startAlarmTicker()
 	go srv.startCompaction()
 	return srv
@@ -957,6 +961,7 @@ func (s *Server) handleUpdateThought(w http.ResponseWriter, r *http.Request) {
 		Subtasks     *[]domain.SubTask `json:"subtasks"`
 		Tags         *[]string         `json:"tags"`
 		Assignees    *[]string         `json:"assignees"`
+		Recurrence   *string           `json:"recurrence"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeError(w, http.StatusBadRequest, "Ungültiges JSON")
@@ -964,6 +969,13 @@ func (s *Server) handleUpdateThought(w http.ResponseWriter, r *http.Request) {
 	}
 
 	before, _ := s.store.GetThoughtByID(userID, thoughtID)
+	// The rule is set first, so completing a task in the same request already repeats it
+	if req.Recurrence != nil {
+		if err := s.store.SetTaskRecurrence(userID, thoughtID, strings.TrimSpace(*req.Recurrence)); err != nil {
+			writeStoreError(w, http.StatusBadRequest, err)
+			return
+		}
+	}
 	updated, err := s.store.UpdateThoughtDetails(userID, thoughtID, req.Content, req.IsCompleted, req.DueDate, req.Priority, req.TaskListID, req.KanbanStatus, req.Notes, req.Subtasks, req.Tags)
 	if err != nil {
 		writeStoreError(w, http.StatusBadRequest, err)

internal/domain/models.go

@@ -183,7 +183,8 @@ type Thought struct {
 	KanbanStatus   string        `json:"kanbanStatus,omitempty"` // todo | in_progress | done
 	Notes          string        `json:"notes,omitempty"`
 	Subtasks       []SubTask     `json:"subtasks"`
-	Assignees      []string      `json:"assignees"` // user IDs; only people with access to the task list
+	Assignees      []string      `json:"assignees"`            // user IDs; only people with access to the task list
+	Recurrence     string        `json:"recurrence,omitempty"` // "" | daily | weekly | monthly | yearly
 	AlarmSent      bool          `json:"alarmSent,omitempty"`
 	SortOrder      int           `json:"sortOrder"`
 	CreatedAt      string        `json:"createdAt"`

internal/storage/docsync.go

@@ -482,7 +482,7 @@ func (s *Store) ReconcileDocTaskLinks(docID string) []string {
 // GetThoughtByIDUnchecked loads a task without access check, for server-internal notifications.
 func (s *Store) GetThoughtByIDUnchecked(thoughtID string) (*domain.Thought, error) {
 	return scanThought(s.db.QueryRow(
-		`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order
+		`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order, recurrence
 		 FROM thoughts WHERE id = ?`, thoughtID))
 }
 

internal/storage/export_markdown.go

@@ -118,6 +118,9 @@ func (s *Store) writeVaultLists(zw *zip.Writer, userID string, names *vaultNames
 	return nil
 }
 
+// Obsidian Tasks writes repeat rules as "🔁 every week"
+var recurrenceEvery = map[string]string{"daily": "day", "weekly": "week", "monthly": "month", "yearly": "year"}
+
 // taskMarkdownLine writes a task in the format of the Obsidian Tasks plugin (📅 due date, ⏫/🔺 priority)
 // with its subtasks and notes indented below.
 func taskMarkdownLine(t domain.Thought) string {
@@ -134,6 +137,9 @@ func taskMarkdownLine(t domain.Thought) string {
 	case "low":
 		line += " 🔽"
 	}
+	if every, ok := recurrenceEvery[t.Recurrence]; ok {
+		line += " 🔁 every " + every
+	}
 	if t.DueDate != "" {
 		line += " 📅 " + t.DueDate
 	}

internal/storage/import_markdown.go

@@ -60,9 +60,9 @@ type importDoc struct {
 }
 
 type importTask struct {
-	content, priority, due, notes string
-	done                          bool
-	subtasks                      []domain.SubTask
+	content, priority, due, notes, recurrence string
+	done                                      bool
+	subtasks                                  []domain.SubTask
 }
 
 type importTaskList struct {
@@ -393,7 +393,7 @@ func PlanMindSiftJSONImport(data []byte) (*ImportPlan, error) {
 		plan.TaskLists = append(plan.TaskLists, importTaskList{title: tl.Title, icon: tl.Icon})
 	}
 	for _, t := range exp.Thoughts {
-		task := importTask{content: t.Content, priority: t.Priority, due: t.DueDate, notes: t.Notes, done: t.IsCompleted, subtasks: t.Subtasks}
+		task := importTask{content: t.Content, priority: t.Priority, due: t.DueDate, notes: t.Notes, done: t.IsCompleted, subtasks: t.Subtasks, recurrence: t.Recurrence}
 		switch {
 		case t.Status == domain.StatusInbox:
 			plan.Inbox = append(plan.Inbox, task)
@@ -506,6 +506,10 @@ func (s *Store) importTaskInto(userID, listID string, t importTask, asTask bool)
 	if _, err := s.UpdateThoughtTriage(userID, th.ID, "keep", "task", "", t.due, listID); err != nil {
 		return fmt.Errorf("Aufgabe %q: %w", content, err)
 	}
+	if validRecurrence(t.recurrence) && t.recurrence != "" {
+		// Imported as already handled: completing a restored task must not create a second successor
+		_, _ = s.db.Exec(`UPDATE thoughts SET recurrence = ?, recurrence_spawned = ? WHERE id = ?`, t.recurrence, boolInt(t.done), th.ID)
+	}
 	if t.done || len(t.subtasks) > 0 {
 		var done *bool
 		if t.done {
@@ -754,6 +758,7 @@ func MarkdownToBlocks(md string) []domain.DocumentBlock {
 }
 
 var (
+	recurRe    = regexp.MustCompile(`(?i)[ \t]*🔁[ \t]*every[ \t]+(day|week|month|year)\b`)
 	dueRe      = regexp.MustCompile(`[ \t]*📅[ \t]*(\d{4}-\d{2}-\d{2})`)
 	priorityRe = regexp.MustCompile(`[ \t]*(🔺|⏫|🔼|🔽|⏬)`)
 )
@@ -790,6 +795,10 @@ func parseTaskFile(body string) []importTask {
 		if c := checkboxRe.FindStringSubmatch(m[2]); c != nil {
 			t.done, t.content = c[1] != " ", c[2]
 		}
+		if r := recurRe.FindStringSubmatch(t.content); r != nil {
+			t.recurrence = map[string]string{"day": "daily", "week": "weekly", "month": "monthly", "year": "yearly"}[strings.ToLower(r[1])]
+			t.content = recurRe.ReplaceAllString(t.content, "")
+		}
 		if d := dueRe.FindStringSubmatch(t.content); d != nil {
 			t.due = d[1]
 			t.content = dueRe.ReplaceAllString(t.content, "")

internal/storage/import_markdown_test.go

@@ -41,6 +41,7 @@ func seedAnna(t *testing.T, store *Store, anna *domain.User) {
 	_, _ = store.UpdateThoughtTriage(anna.ID, task.ID, "keep", "task", "", "2026-11-02", tl.ID)
 	subs := []domain.SubTask{{ID: "s1", Title: "Leiter holen", IsCompleted: true}}
 	_, _ = store.UpdateThoughtDetails(anna.ID, task.ID, nil, nil, nil, nil, nil, nil, nil, &subs, nil)
+	_ = store.SetTaskRecurrence(anna.ID, task.ID, "monthly")
 	list, _ := store.CreateList(anna.ID, "Einkauf", "🛒", "shopping")
 	item, _ := store.CreateListItem(list.ID, "Milch", "Kühlregal", "2L", 0, anna.ID)
 	_, _ = store.ToggleListItem(item.ID, true, anna.ID, "Anna")
@@ -66,7 +67,7 @@ func checkRestored(t *testing.T, store *Store, ben *domain.User) {
 		t.Fatalf("task list not restored: %+v / %+v", lists, tasks)
 	}
 	tk := tasks[0]
-	if tk.Content != "Fenster putzen" || tk.Priority != "urgent" || tk.DueDate != "2026-11-02" || tk.Notes != "Leiter im Keller" ||
+	if tk.Content != "Fenster putzen" || tk.Priority != "urgent" || tk.DueDate != "2026-11-02" || tk.Notes != "Leiter im Keller" || tk.Recurrence != "monthly" ||
 		len(tk.Subtasks) != 1 || !tk.Subtasks[0].IsCompleted || tk.TaskListID != lists[0].ID {
 		t.Errorf("task not restored: %+v", tk)
 	}
@@ -218,4 +219,3 @@ func TestImportBackupZip(t *testing.T) {
 	}
 	checkRestored(t, store, ben)
 }
-

internal/storage/recurrence.go

@@ -0,0 +1,129 @@
+package storage
+
+import (
+	"errors"
+	"time"
+
+	"github.com/sandrodach/mindsift/internal/domain"
+)
+
+// ErrInvalidRecurrence is returned for unknown repeat rules.
+var ErrInvalidRecurrence = errors.New("Unbekannte Wiederholung (erlaubt: täglich, wöchentlich, monatlich, jährlich)")
+
+func validRecurrence(r string) bool {
+	switch r {
+	case "", "daily", "weekly", "monthly", "yearly":
+		return true
+	}
+	return false
+}
+
+// NextDueDate moves a due date (YYYY-MM-DD, or today when empty) one interval forward. Months and years
+// keep the day where possible and fall back to the month's last day (31 Jan -> 28/29 Feb).
+func NextDueDate(due, rule string, today time.Time) string {
+	base, err := time.Parse("2006-01-02", due)
+	if err != nil {
+		base = time.Date(today.Year(), today.Month(), today.Day(), 0, 0, 0, 0, time.UTC)
+	}
+	switch rule {
+	case "daily":
+		base = base.AddDate(0, 0, 1)
+	case "weekly":
+		base = base.AddDate(0, 0, 7)
+	case "monthly":
+		base = addMonthsClamped(base, 1)
+	case "yearly":
+		base = addMonthsClamped(base, 12)
+	}
+	return base.Format("2006-01-02")
+}
+
+func addMonthsClamped(t time.Time, months int) time.Time {
+	first := time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, time.UTC).AddDate(0, months, 0)
+	last := first.AddDate(0, 1, -1).Day()
+	day := t.Day()
+	if day > last {
+		day = last
+	}
+	return time.Date(first.Year(), first.Month(), day, 0, 0, 0, 0, time.UTC)
+}
+
+// SetTaskRecurrence changes the repeat rule of a task (editors of its list or its owner).
+func (s *Store) SetTaskRecurrence(userID, taskID, rule string) error {
+	if !validRecurrence(rule) {
+		return ErrInvalidRecurrence
+	}
+	t, err := s.GetThoughtByID(userID, taskID)
+	if err != nil {
+		return err
+	}
+	if err := s.ensureTaskListWritable(userID, t.TaskListID); err != nil {
+		return err
+	}
+	_, err = s.db.Exec(`UPDATE thoughts SET recurrence = ? WHERE id = ?`, rule, taskID)
+	return err
+}
+
+func (s *Store) getThoughtRaw(id string) (*domain.Thought, error) {
+	t, err := scanThought(s.db.QueryRow(
+		`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order, recurrence
+		 FROM thoughts WHERE id = ?`, id))
+	if err != nil {
+		return nil, err
+	}
+	t.Assignees = s.getTaskAssignees(t.ID)
+	return t, nil
+}
+
+// spawnNextOccurrence creates the follow-up of a repeating task that was just completed: same title,
+// tags, priority, notes, list, assignees and rule, subtasks unchecked, due date one interval later,
+// in the list's first open column. Each task spawns at most once, so re-opening and completing it
+// again creates no duplicate. The new task goes to OnTaskCreated (live update for all clients).
+func (s *Store) spawnNextOccurrence(taskID string) {
+	t, err := s.getThoughtRaw(taskID)
+	if err != nil || t.Recurrence == "" || !t.IsCompleted {
+		return
+	}
+	res, err := s.db.Exec(`UPDATE thoughts SET recurrence_spawned = 1 WHERE id = ? AND recurrence_spawned = 0`, taskID)
+	if err != nil {
+		return
+	}
+	if n, _ := res.RowsAffected(); n == 0 {
+		return // already spawned its successor
+	}
+
+	column := "todo"
+	if t.TaskListID != "" {
+		if tl, err := s.GetTaskListByID(t.UserID, t.TaskListID); err == nil {
+			for _, c := range tl.Columns {
+				if !c.IsDone {
+					column = c.ID
+					break
+				}
+			}
+		}
+	}
+	due := NextDueDate(t.DueDate, t.Recurrence, time.Now())
+	next, err := s.CreateThoughtWithDetails(t.UserID, t.Content, t.Priority, t.Source, due, t.TaskListID, column, t.Notes)
+	if err != nil {
+		return
+	}
+	if _, err := s.UpdateThoughtTriage(t.UserID, next.ID, "keep", "task", "", due, t.TaskListID); err != nil {
+		return
+	}
+	subs := make([]domain.SubTask, len(t.Subtasks))
+	for i, st := range t.Subtasks {
+		subs[i] = domain.SubTask{ID: domain.NewID("st"), Title: st.Title, CreatedAt: domain.NowISO()}
+	}
+	tags := t.Tags
+	_, _ = s.UpdateThoughtDetails(t.UserID, next.ID, nil, nil, nil, nil, nil, &column, nil, &subs, &tags)
+	_, _ = s.db.Exec(`UPDATE thoughts SET recurrence = ?, sort_order = ? WHERE id = ?`, t.Recurrence, t.SortOrder, next.ID)
+	for _, uid := range t.Assignees {
+		_, _ = s.db.Exec(`INSERT OR IGNORE INTO task_assignees (task_id, user_id, created_at) VALUES (?, ?, ?)`, next.ID, uid, domain.NowISO())
+	}
+	s.PruneTaskAssignees()
+
+	if created, err := s.getThoughtRaw(next.ID); err == nil && s.OnTaskCreated != nil {
+		s.OnTaskCreated(created)
+	}
+}

internal/storage/recurrence_test.go

@@ -0,0 +1,97 @@
+package storage
+
+import (
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/sandrodach/mindsift/internal/domain"
+)
+
+func TestNextDueDate(t *testing.T) {
+	today := time.Date(2026, 10, 29, 15, 0, 0, 0, time.UTC)
+	cases := []struct{ due, rule, want string }{
+		{"2026-10-30", "daily", "2026-10-31"},
+		{"2026-10-30", "weekly", "2026-11-06"},
+		{"2026-01-31", "monthly", "2026-02-28"},
+		{"2026-03-15", "monthly", "2026-04-15"},
+		{"2028-02-29", "yearly", "2029-02-28"},
+		{"", "weekly", "2026-11-05"},
+	}
+	for _, c := range cases {
+		if got := NextDueDate(c.due, c.rule, today); got != c.want {
+			t.Errorf("NextDueDate(%q, %s) = %s, want %s", c.due, c.rule, got, c.want)
+		}
+	}
+}
+
+func TestRepeatingTaskSpawnsItsSuccessorOnce(t *testing.T) {
+	store, err := NewStore(filepath.Join(t.TempDir(), "recur.db"))
+	if err != nil {
+		t.Fatalf("NewStore: %v", err)
+	}
+	defer store.Close()
+	openSharing(t, store)
+	anna, _ := store.CreateUser("anna@example.com", "hash", "Anna", "member")
+	ben, _ := store.CreateUser("ben@example.com", "hash", "Ben", "member")
+	tl, _ := store.CreateTaskList(anna.ID, "", "", "Haushalt", "", "")
+	_, _ = store.AddTaskListShare(tl.ID, "user", ben.ID, "editor", anna.ID)
+
+	var pushed []*domain.Thought
+	store.OnTaskCreated = func(th *domain.Thought) { pushed = append(pushed, th) }
+
+	task, _ := store.CreateThoughtWithDetails(anna.ID, "Müll rausbringen #haushalt", "high", "manual", "2026-11-02", tl.ID, "todo", "Gelbe Tonne")
+	_, _ = store.UpdateThoughtTriage(anna.ID, task.ID, "keep", "task", "", "2026-11-02", tl.ID)
+	subs := []domain.SubTask{{ID: "s1", Title: "Tüten", IsCompleted: true}}
+	_, _ = store.UpdateThoughtDetails(anna.ID, task.ID, nil, nil, nil, nil, nil, nil, nil, &subs, nil)
+	_, _ = store.SetTaskAssignees(anna.ID, task.ID, []string{ben.ID})
+	if err := store.SetTaskRecurrence(anna.ID, task.ID, "weekly"); err != nil {
+		t.Fatalf("SetTaskRecurrence: %v", err)
+	}
+	if err := store.SetTaskRecurrence(anna.ID, task.ID, "stündlich"); err == nil {
+		t.Errorf("unknown rule must be rejected")
+	}
+
+	done := true
+	if _, err := store.UpdateThoughtDetails(ben.ID, task.ID, nil, &done, nil, nil, nil, nil, nil, nil, nil); err != nil {
+		t.Fatalf("complete: %v", err)
+	}
+	if len(pushed) != 1 {
+		t.Fatalf("expected one successor pushed live, got %d", len(pushed))
+	}
+	next := pushed[0]
+	if next.Content != "Müll rausbringen #haushalt" || next.Priority != "high" || next.Notes != "Gelbe Tonne" ||
+		next.DueDate != "2026-11-09" || next.Recurrence != "weekly" || next.IsCompleted || next.TaskListID != tl.ID ||
+		next.KanbanStatus != "todo" || len(next.Subtasks) != 1 || next.Subtasks[0].IsCompleted ||
+		len(next.Assignees) != 1 || next.Assignees[0] != ben.ID || next.UserID != anna.ID {
+		t.Errorf("successor wrong: %+v", next)
+	}
+	if orig, _ := store.GetThoughtByID(anna.ID, task.ID); !orig.IsCompleted {
+		t.Errorf("the completed task stays completed for the history")
+	}
+
+	// Re-opening and completing again creates no duplicate
+	open := false
+	_, _ = store.UpdateThoughtDetails(anna.ID, task.ID, nil, &open, nil, nil, nil, nil, nil, nil, nil)
+	_, _ = store.UpdateThoughtDetails(anna.ID, task.ID, nil, &done, nil, nil, nil, nil, nil, nil, nil)
+	if len(pushed) != 1 {
+		t.Fatalf("re-completing must not spawn again, got %d successors", len(pushed))
+	}
+
+	// Dragging the successor into "done" on the Kanban board repeats as well
+	status := "done"
+	if err := store.ReorderTasks(tl.ID, []domain.ThoughtReorderItem{{ID: next.ID, SortOrder: 0, KanbanStatus: &status}}); err != nil {
+		t.Fatalf("ReorderTasks: %v", err)
+	}
+	if len(pushed) != 2 || pushed[1].DueDate != "2026-11-16" {
+		t.Fatalf("Kanban completion should spawn the next week, got %+v", pushed)
+	}
+
+	// A task without rule never repeats
+	plain, _ := store.CreateThoughtWithDetails(anna.ID, "Einmalig", "normal", "manual", "", tl.ID, "todo", "")
+	_, _ = store.UpdateThoughtTriage(anna.ID, plain.ID, "keep", "task", "", "", tl.ID)
+	_, _ = store.UpdateThoughtDetails(anna.ID, plain.ID, nil, &done, nil, nil, nil, nil, nil, nil, nil)
+	if len(pushed) != 2 {
+		t.Errorf("non-repeating task must not spawn")
+	}
+}

internal/storage/sqlite.go

@@ -22,6 +22,10 @@ import (
 type Store struct {
 	db     *sql.DB
 	initMu sync.Mutex
+
+	// OnTaskCreated is told about tasks the store creates by itself (next occurrence of a repeating
+	// task), so the server can push them to connected clients.
+	OnTaskCreated func(*domain.Thought)
 }
 
 func NewStore(dbPath string) (*Store, error) {
@@ -454,6 +458,10 @@ func (s *Store) migrate() error {
 
 		// Who added an item to a (shopping) list
 		"ALTER TABLE list_items ADD COLUMN created_by TEXT NOT NULL DEFAULT '';",
+
+		// Repeating tasks: daily | weekly | monthly | yearly
+		"ALTER TABLE thoughts ADD COLUMN recurrence TEXT NOT NULL DEFAULT '';",
+		"ALTER TABLE thoughts ADD COLUMN recurrence_spawned INTEGER NOT NULL DEFAULT 0;",
 	}
 	for _, q := range columnMigrations {
 		_, _ = s.db.Exec(q)
@@ -938,7 +946,7 @@ func scanThought(rows interface {
 		&t.ID, &t.UserID, &t.Content, &tagsStr, &t.Priority, &t.Source,
 		&statusStr, &isCompleted, &t.ConvertedType, &t.ConvertedRefID,
 		&t.DueDate, &t.TaskListID, &t.KanbanStatus, &t.Notes, &alarmSent,
-		&t.CreatedAt, &t.TriagedAt, &subtasksStr, &sortOrder,
+		&t.CreatedAt, &t.TriagedAt, &subtasksStr, &sortOrder, &t.Recurrence,
 	)
 	if err != nil {
 		return nil, err
@@ -981,7 +989,7 @@ func (s *Store) accessibleTaskListIDsQuery() string {
 
 func (s *Store) GetThoughtByID(userID, thoughtID string) (*domain.Thought, error) {
 	row := s.db.QueryRow(
-		`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order
+		`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order, recurrence
 		 FROM thoughts WHERE id = ? AND (user_id = ? OR task_list_id IN (`+s.accessibleTaskListIDsQuery()+`))`,
 		thoughtID, userID, userID, userID, userID,
 	)
@@ -1002,14 +1010,14 @@ func (s *Store) GetThoughts(userID, statusFilter string, limit int) ([]domain.Th
 
 	if statusFilter != "" && statusFilter != "all" {
 		rows, err = s.db.Query(
-			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order
+			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order, recurrence
 			 FROM thoughts WHERE user_id = ? AND status = ?
 			 ORDER BY CASE priority WHEN 'urgent' THEN 1 WHEN 'high' THEN 2 WHEN 'normal' THEN 3 ELSE 4 END, sort_order ASC, created_at DESC LIMIT ?`,
 			userID, statusFilter, limit,
 		)
 	} else {
 		rows, err = s.db.Query(
-			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order
+			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order, recurrence
 			 FROM thoughts WHERE user_id = ?
 			 ORDER BY sort_order ASC, created_at DESC LIMIT ?`,
 			userID, limit,
@@ -1035,7 +1043,7 @@ func (s *Store) GetTasks(userID string, taskListID string) ([]domain.Thought, er
 	var err error
 	if taskListID != "" {
 		rows, err = s.db.Query(
-			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order
+			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order, recurrence
 			 FROM thoughts
 			 WHERE (user_id = ? OR task_list_id IN (`+s.accessibleTaskListIDsQuery()+`))
 			   AND task_list_id = ?
@@ -1045,7 +1053,7 @@ func (s *Store) GetTasks(userID string, taskListID string) ([]domain.Thought, er
 		)
 	} else {
 		rows, err = s.db.Query(
-			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order
+			`SELECT id, user_id, content, tags, priority, source, status, is_completed, converted_type, converted_ref_id, due_date, task_list_id, kanban_status, notes, alarm_sent, created_at, triaged_at, subtasks, sort_order, recurrence
 			 FROM thoughts
 			 WHERE (user_id = ? OR task_list_id IN (`+s.accessibleTaskListIDsQuery()+`))
 			   AND (status = 'kept' OR (status = 'converted' AND converted_type = 'task'))
@@ -1076,11 +1084,17 @@ func (s *Store) ReorderTasks(taskListID string, items []domain.ThoughtReorderIte
 	}
 	defer tx.Rollback()
 
+	var completed []string // tasks that move into "done" now (repeating ones spawn their successor)
 	for _, it := range items {
 		if it.KanbanStatus != nil && *it.KanbanStatus != "" {
 			isCompleted := 0
 			if *it.KanbanStatus == "done" {
 				isCompleted = 1
+				var was int
+				_ = tx.QueryRow(`SELECT is_completed FROM thoughts WHERE id = ?`, it.ID).Scan(&was)
+				if was == 0 {
+					completed = append(completed, it.ID)
+				}
 			}
 			_, err = tx.Exec(
 				`UPDATE thoughts SET sort_order = ?, kanban_status = ?, is_completed = ? WHERE id = ?`,
@@ -1097,7 +1111,13 @@ func (s *Store) ReorderTasks(taskListID string, items []domain.ThoughtReorderIte
 		}
 	}
 
-	return tx.Commit()
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+	for _, id := range completed {
+		s.spawnNextOccurrence(id)
+	}
+	return nil
 }
 
 // UpdateThoughtTriage handles swipe left (discard), swipe right (keep), restore, and conversion to task/document/list_item
@@ -1231,6 +1251,7 @@ func (s *Store) UpdateThoughtDetails(userID, thoughtID string, content *string,
 	if err != nil {
 		return nil, err
 	}
+	wasCompleted := thought.IsCompleted
 	if err := s.ensureTaskListWritable(userID, thought.TaskListID); err != nil {
 		return nil, err
 	}
@@ -1303,6 +1324,9 @@ func (s *Store) UpdateThoughtDetails(userID, thoughtID string, content *string,
 		s.PruneTaskAssignees()
 		thought.Assignees = s.getTaskAssignees(thoughtID)
 	}
+	if !wasCompleted && thought.IsCompleted {
+		s.spawnNextOccurrence(thoughtID)
+	}
 	return thought, nil
 }
 
@@ -3942,7 +3966,12 @@ func (s *Store) SyncTaskFromBlockCheck(userID, taskID string, checked bool) {
 		doneInt = 1
 		kanban = "done"
 	}
-	_, _ = s.db.Exec(`UPDATE thoughts SET is_completed = ?, kanban_status = ? WHERE id = ? AND user_id = ?`, doneInt, kanban, taskID, userID)
+	res, _ := s.db.Exec(`UPDATE thoughts SET is_completed = ?, kanban_status = ? WHERE id = ? AND user_id = ? AND is_completed != ?`, doneInt, kanban, taskID, userID, doneInt)
+	if checked && res != nil {
+		if n, _ := res.RowsAffected(); n > 0 {
+			s.spawnNextOccurrence(taskID)
+		}
+	}
 }
 
 func (s *Store) DeleteListItem(itemID string) (string, error) {