# Task Recurrence + Detail Popup Editing Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** doot-native tasks get real recurrence (frequency/interval/weekdays), a server-owned mechanism that generates the next occurrence as a new row (on completion or once due, whichever comes first), and the Android widget's task-detail popup gets editable title/description, a linkified description, and independently-tappable date/recurrence/next-date chips.

**Architecture:** Go server: new `native_tasks` columns + a pure `ComputeNextOccurrence` function + a store-owned iteration-creation mechanism triggered from two places (completion, and a new periodic ticker) + four new/reused HTTP endpoints. Android: `TaskDetailActivity` does a live fetch on open (doot-only) instead of trusting cached widget data, with a toggleable edit mode and a small recurrence-editing dialog.

**Tech Stack:** Go (`database/sql`, `chi`), Kotlin (Jetpack Compose, OkHttp, kotlinx.serialization).

## Global Constraints

- Scope is doot-native tasks only. Trello/Google Tasks cards are completely unchanged — no edit UI, no recurrence, no live-fetch-on-open.
- `recurrence_series_id != ""` is the only recurring indicator. `models.Task.IsRecurring` stays in the struct (unrelated code in `atoms.go` reads it) but this feature does not set or read it.
- Iteration creation is server-owned: a new row is created either when the current occurrence is completed, or once its due date passes — independent triggers, whichever fires first wins, and "latest row in a series" (no newer `due_date`, ties broken by `created_at`) is how a trigger knows whether it should act.
- No transactions wrap the two-step complete-then-create-iteration sequence (matches this store's existing single-`Exec`-per-method style); the periodic ticker's `NOT EXISTS` check is the self-healing backstop for a partial failure.
- Monthly/yearly rollover uses Go's standard `AddDate` overflow behavior (accepted, documented drift for anchor days 29–31; days ≤28 never drift).
- No new automated UI test harness for Android Compose — verified by building and a manual on-device check, matching every other widget feature this session.

---

### Task 1: Recurrence columns, model fields, and store scan/query layer

**Files:**
- Create: `migrations/023_native_task_recurrence.sql`
- Modify: `internal/models/types.go:10-23` (`Task` struct)
- Modify: `internal/store/native_tasks.go` (imports, `scanNativeTasks`, all four `SELECT` queries)
- Modify: `internal/store/native_tasks_test.go` (`newNativeTasksTestStore`'s schema)
- Test: `internal/store/native_tasks_test.go` (new tests)

**Interfaces:**
- Consumes: nothing new.
- Produces: `models.Task` gains `RecurrenceFreq string`, `RecurrenceInterval int`, `RecurrenceWeekdays []int`, `RecurrenceSeriesID string`, `NextOccurrenceOverride *time.Time`. `parseWeekdays(s string) []int` and `formatWeekdays(weekdays []int) string` (both unexported, `internal/store` package) — later tasks in this package use `formatWeekdays`.

- [ ] **Step 1: Write the failing tests**

Add to `internal/store/native_tasks_test.go` (add `"task-dashboard/internal/models"` to the import block):

```go
func TestGetNativeTasks_ParsesRecurrenceFields(t *testing.T) {
	s := newNativeTasksTestStore(t)
	if _, err := s.db.Exec(`
		INSERT INTO native_tasks (id, content, due_date, recurrence_freq, recurrence_interval, recurrence_weekdays, recurrence_series_id, next_occurrence_override)
		VALUES ('rec-1', 'Recurring task', '2026-07-13', 'weekly', 2, '1,3,5', 'series-abc', '2026-07-27')
	`); err != nil {
		t.Fatal(err)
	}

	tasks, err := s.GetNativeTasks()
	if err != nil {
		t.Fatalf("GetNativeTasks: %v", err)
	}

	var found *models.Task
	for i := range tasks {
		if tasks[i].ID == "rec-1" {
			found = &tasks[i]
		}
	}
	if found == nil {
		t.Fatal("expected to find rec-1")
	}
	if found.RecurrenceFreq != "weekly" {
		t.Errorf("RecurrenceFreq = %q, want %q", found.RecurrenceFreq, "weekly")
	}
	if found.RecurrenceInterval != 2 {
		t.Errorf("RecurrenceInterval = %d, want 2", found.RecurrenceInterval)
	}
	if len(found.RecurrenceWeekdays) != 3 || found.RecurrenceWeekdays[0] != 1 || found.RecurrenceWeekdays[1] != 3 || found.RecurrenceWeekdays[2] != 5 {
		t.Errorf("RecurrenceWeekdays = %v, want [1 3 5]", found.RecurrenceWeekdays)
	}
	if found.RecurrenceSeriesID != "series-abc" {
		t.Errorf("RecurrenceSeriesID = %q, want %q", found.RecurrenceSeriesID, "series-abc")
	}
	if found.NextOccurrenceOverride == nil || found.NextOccurrenceOverride.Format("2006-01-02") != "2026-07-27" {
		t.Errorf("NextOccurrenceOverride = %v, want 2026-07-27", found.NextOccurrenceOverride)
	}
}

func TestGetNativeTasks_NonRecurringTask_HasEmptyRecurrenceFields(t *testing.T) {
	s := newNativeTasksTestStore(t)
	// "real-1" (inserted by newNativeTasksTestStore) has no recurrence columns set.
	tasks, err := s.GetNativeTasks()
	if err != nil {
		t.Fatalf("GetNativeTasks: %v", err)
	}
	var found *models.Task
	for i := range tasks {
		if tasks[i].ID == "real-1" {
			found = &tasks[i]
		}
	}
	if found == nil {
		t.Fatal("expected to find real-1")
	}
	if found.RecurrenceSeriesID != "" {
		t.Errorf("expected empty RecurrenceSeriesID for non-recurring task, got %q", found.RecurrenceSeriesID)
	}
	if found.RecurrenceWeekdays != nil {
		t.Errorf("expected nil RecurrenceWeekdays for non-recurring task, got %v", found.RecurrenceWeekdays)
	}
	if found.NextOccurrenceOverride != nil {
		t.Errorf("expected nil NextOccurrenceOverride for non-recurring task, got %v", found.NextOccurrenceOverride)
	}
}
```

- [ ] **Step 2: Run tests to verify they fail**

Run: `cd /workspace/doot && go test ./internal/store/... -run TestGetNativeTasks_ -v`
Expected: FAIL to compile — `recurrence_freq` etc. don't exist in the test schema yet, and `models.Task` has no `RecurrenceFreq` field.

- [ ] **Step 3: Add the migration**

Create `migrations/023_native_task_recurrence.sql`:

```sql
-- Recurrence support for doot-native tasks: a recurring task generates a
-- brand-new row per iteration (see Store.CreateNextIteration), linked by
-- recurrence_series_id. recurrence_freq empty means "not recurring."
ALTER TABLE native_tasks ADD COLUMN recurrence_freq TEXT DEFAULT '';
ALTER TABLE native_tasks ADD COLUMN recurrence_interval INTEGER DEFAULT 1;
ALTER TABLE native_tasks ADD COLUMN recurrence_weekdays TEXT DEFAULT '';
ALTER TABLE native_tasks ADD COLUMN recurrence_series_id TEXT DEFAULT '';
ALTER TABLE native_tasks ADD COLUMN next_occurrence_override TEXT DEFAULT '';

CREATE INDEX IF NOT EXISTS idx_native_tasks_recurrence_series ON native_tasks(recurrence_series_id);
```

- [ ] **Step 4: Add the `Task` struct fields**

In `internal/models/types.go`, replace:

```go
// Task represents a native task
type Task struct {
	ID          string     `json:"id"`
	Content     string     `json:"content"`
	Description string     `json:"description"`
	ProjectID   string     `json:"project_id"`
	ProjectName string     `json:"project_name"`
	DueDate     *time.Time `json:"due_date,omitempty"`
	Priority    int        `json:"priority"`
	Completed   bool       `json:"completed"`
	Labels      []string   `json:"labels"`
	URL         string     `json:"url"`
	CreatedAt   time.Time  `json:"created_at"`
	IsRecurring bool       `json:"is_recurring"`
}
```

with:

```go
// Task represents a native task
type Task struct {
	ID          string     `json:"id"`
	Content     string     `json:"content"`
	Description string     `json:"description"`
	ProjectID   string     `json:"project_id"`
	ProjectName string     `json:"project_name"`
	DueDate     *time.Time `json:"due_date,omitempty"`
	Priority    int        `json:"priority"`
	Completed   bool       `json:"completed"`
	Labels      []string   `json:"labels"`
	URL         string     `json:"url"`
	CreatedAt   time.Time  `json:"created_at"`
	IsRecurring bool       `json:"is_recurring"`

	// Recurrence (doot-native tasks only). RecurrenceSeriesID != "" is the
	// real "is this task recurring" indicator -- IsRecurring above predates
	// this feature and is never set by it.
	RecurrenceFreq         string     `json:"recurrence_freq,omitempty"`
	RecurrenceInterval     int        `json:"recurrence_interval,omitempty"`
	RecurrenceWeekdays     []int      `json:"recurrence_weekdays,omitempty"`
	RecurrenceSeriesID     string     `json:"recurrence_series_id,omitempty"`
	NextOccurrenceOverride *time.Time `json:"next_occurrence_override,omitempty"`
}
```

- [ ] **Step 5: Update `scanNativeTasks` and the four `SELECT` queries**

In `internal/store/native_tasks.go`, replace the import block:

```go
import (
	"database/sql"
	"encoding/json"
	"errors"
	"time"

	"task-dashboard/internal/models"
)
```

with:

```go
import (
	"database/sql"
	"encoding/json"
	"errors"
	"strconv"
	"strings"
	"time"

	"task-dashboard/internal/models"
)
```

Replace each of the four `SELECT` column lists (in `GetNativeTasks`, `GetNativeTasksByDateRange`, `GetOverdueNativeTasks`, `GetUndatedNativeTasks`) from:

```go
		SELECT id, content, description, project_name, due_date, priority, completed, labels, created_at
```

to:

```go
		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
```

(Four occurrences — one per function; the rest of each query, e.g. the `WHERE`/`ORDER BY` clauses, is unchanged.)

Replace `scanNativeTasks` in full:

```go
func scanNativeTasks(rows interface {
	Next() bool
	Scan(...interface{}) error
	Err() error
}) ([]models.Task, error) {
	var tasks []models.Task
	for rows.Next() {
		var t models.Task
		var labelsJSON string
		var dueDateStr *string
		var weekdaysStr string
		var nextOverrideStr string
		if err := rows.Scan(
			&t.ID, &t.Content, &t.Description, &t.ProjectName, &dueDateStr, &t.Priority, &t.Completed, &labelsJSON, &t.CreatedAt,
			&t.RecurrenceFreq, &t.RecurrenceInterval, &weekdaysStr, &t.RecurrenceSeriesID, &nextOverrideStr,
		); err != nil {
			return nil, err
		}
		if dueDateStr != nil {
			if parsed, err := time.Parse(time.RFC3339, *dueDateStr); err == nil {
				t.DueDate = &parsed
			} else if parsed, err := time.Parse("2006-01-02 15:04:05", *dueDateStr); err == nil {
				t.DueDate = &parsed
			} else if parsed, err := time.Parse("2006-01-02", *dueDateStr); err == nil {
				t.DueDate = &parsed
			}
		}
		if err := json.Unmarshal([]byte(labelsJSON), &t.Labels); err != nil {
			t.Labels = nil
		}
		t.RecurrenceWeekdays = parseWeekdays(weekdaysStr)
		if nextOverrideStr != "" {
			if parsed, err := time.Parse("2006-01-02", nextOverrideStr); err == nil {
				t.NextOccurrenceOverride = &parsed
			}
		}
		tasks = append(tasks, t)
	}
	return tasks, rows.Err()
}

// parseWeekdays parses a comma-separated list of 0-6 ints (e.g. "1,3,5"),
// returning nil for an empty string.
func parseWeekdays(s string) []int {
	if s == "" {
		return nil
	}
	parts := strings.Split(s, ",")
	weekdays := make([]int, 0, len(parts))
	for _, p := range parts {
		if n, err := strconv.Atoi(strings.TrimSpace(p)); err == nil {
			weekdays = append(weekdays, n)
		}
	}
	return weekdays
}

// formatWeekdays is the inverse of parseWeekdays.
func formatWeekdays(weekdays []int) string {
	if len(weekdays) == 0 {
		return ""
	}
	strs := make([]string, len(weekdays))
	for i, d := range weekdays {
		strs[i] = strconv.Itoa(d)
	}
	return strings.Join(strs, ",")
}
```

- [ ] **Step 6: Update the test schema helper**

In `internal/store/native_tasks_test.go`, add the import and update the schema. Replace:

```go
import (
	"database/sql"
	"errors"
	"path/filepath"
	"testing"
	"time"

	_ "github.com/mattn/go-sqlite3"
)
```

with:

```go
import (
	"database/sql"
	"errors"
	"path/filepath"
	"testing"
	"time"

	"task-dashboard/internal/models"

	_ "github.com/mattn/go-sqlite3"
)
```

Replace the `CREATE TABLE` statement inside `newNativeTasksTestStore`:

```go
	if _, err := db.Exec(`
		CREATE TABLE native_tasks (
			id TEXT PRIMARY KEY,
			content TEXT NOT NULL,
			description TEXT DEFAULT '',
			project_name TEXT DEFAULT '',
			due_date DATETIME,
			priority INTEGER DEFAULT 1,
			completed BOOLEAN DEFAULT 0,
			labels TEXT DEFAULT '[]',
			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
		)
	`); err != nil {
		t.Fatal(err)
	}
```

with:

```go
	if _, err := db.Exec(`
		CREATE TABLE native_tasks (
			id TEXT PRIMARY KEY,
			content TEXT NOT NULL,
			description TEXT DEFAULT '',
			project_name TEXT DEFAULT '',
			due_date DATETIME,
			priority INTEGER DEFAULT 1,
			completed BOOLEAN DEFAULT 0,
			labels TEXT DEFAULT '[]',
			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
			recurrence_freq TEXT DEFAULT '',
			recurrence_interval INTEGER DEFAULT 1,
			recurrence_weekdays TEXT DEFAULT '',
			recurrence_series_id TEXT DEFAULT '',
			next_occurrence_override TEXT DEFAULT ''
		)
	`); err != nil {
		t.Fatal(err)
	}
```

- [ ] **Step 7: Run tests to verify they pass**

Run: `cd /workspace/doot && go test ./internal/store/... -v`
Expected: PASS for all tests in the package, including the two new ones and the pre-existing `TestCompleteNativeTask_*`/`TestUncompleteNativeTask_*`/`TestRescheduleNativeTask_*` tests (unaffected by this change).

- [ ] **Step 8: Run the full Go build and handlers package test**

Run: `cd /workspace/doot && go build ./... && go test ./internal/handlers/...`
Expected: `go build` succeeds (the four `SELECT` column-list changes are internal to `store`, no caller signature changed). `go test` passes except the two pre-existing, unrelated failures (`TestHandleAgentTaskWriteOperations`, `TestHandleAgentCreateOperations` — confirmed broken before this entire feature, not yours to fix).

- [ ] **Step 9: Commit**

```bash
cd /workspace/doot
git add migrations/023_native_task_recurrence.sql internal/models/types.go internal/store/native_tasks.go internal/store/native_tasks_test.go
git commit -m "feat(tasks): add recurrence columns and model fields for native tasks

recurrence_series_id != \"\" is the real recurring indicator (IsRecurring
predates this feature and is never set). Adds parseWeekdays/formatWeekdays
for the comma-separated weekday-list column, and threads the five new
columns through scanNativeTasks and all four existing SELECT queries."
```

---

### Task 2: `ComputeNextOccurrence`

**Files:**
- Create: `internal/models/recurrence.go`
- Test: `internal/models/recurrence_test.go`

**Interfaces:**
- Consumes: nothing new.
- Produces: `ComputeNextOccurrence(due time.Time, freq string, interval int, weekdays []int) time.Time` — used by Task 3's `CreateNextIteration` and Task 5's task-detail endpoint.

- [ ] **Step 1: Write the failing tests**

Create `internal/models/recurrence_test.go`:

```go
package models

import (
	"testing"
	"time"
)

func TestComputeNextOccurrence(t *testing.T) {
	mustParse := func(t *testing.T, s string) time.Time {
		t.Helper()
		d, err := time.Parse("2006-01-02", s)
		if err != nil {
			t.Fatalf("bad fixture date %q: %v", s, err)
		}
		return d
	}

	tests := []struct {
		name     string
		due      string
		freq     string
		interval int
		weekdays []int
		want     string
	}{
		{"daily interval 1", "2026-07-13", "daily", 1, nil, "2026-07-14"},
		{"daily interval 3", "2026-07-13", "daily", 3, nil, "2026-07-16"},
		{"weekly no weekdays interval 1", "2026-07-13", "weekly", 1, nil, "2026-07-20"},
		{"weekly no weekdays interval 2", "2026-07-13", "weekly", 2, nil, "2026-07-27"},
		// 2026-07-13 is a Monday (weekday=1).
		{"weekly with weekdays same week", "2026-07-13", "weekly", 1, []int{1, 3, 5}, "2026-07-15"},
		{"weekly with weekdays wraps to next week", "2026-07-17", "weekly", 1, []int{1, 3, 5}, "2026-07-20"}, // due=Fri(5), wraps to Mon
		{"weekly with weekdays interval 2 wraps", "2026-07-13", "weekly", 2, []int{1}, "2026-07-27"},          // due=Mon, only Mon active, skip a week
		{"monthly interval 1", "2026-06-13", "monthly", 1, nil, "2026-07-13"},
		{"monthly rollover", "2026-01-31", "monthly", 1, nil, "2026-03-03"},
		{"monthly rollover locks in on the drifted day", "2026-03-03", "monthly", 1, nil, "2026-04-03"},
		{"yearly interval 1", "2026-07-13", "yearly", 1, nil, "2027-07-13"},
		{"unknown freq returns due unchanged", "2026-07-13", "bogus", 1, nil, "2026-07-13"},
		{"interval below 1 is treated as 1", "2026-07-13", "daily", 0, nil, "2026-07-14"},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got := ComputeNextOccurrence(mustParse(t, tc.due), tc.freq, tc.interval, tc.weekdays)
			want := mustParse(t, tc.want)
			if !got.Equal(want) {
				t.Errorf("ComputeNextOccurrence(%s, %s, %d, %v) = %s, want %s", tc.due, tc.freq, tc.interval, tc.weekdays, got.Format("2006-01-02"), tc.want)
			}
		})
	}
}
```

- [ ] **Step 2: Run tests to verify they fail**

Run: `cd /workspace/doot && go test ./internal/models/... -run TestComputeNextOccurrence -v`
Expected: FAIL to compile — `ComputeNextOccurrence` doesn't exist yet.

- [ ] **Step 3: Implement `ComputeNextOccurrence`**

Create `internal/models/recurrence.go`:

```go
package models

import (
	"sort"
	"time"
)

// ComputeNextOccurrence returns the next occurrence date after due, given a
// recurrence pattern. weekdays is only consulted when freq == "weekly"; nil
// or empty means "same weekday as due, every interval weeks." Unknown freq
// values return due unchanged. interval < 1 is treated as 1.
//
// Monthly/yearly rollover uses Go's standard AddDate overflow behavior (a
// due date of Jan 31 + 1 month becomes Mar 3, not clamped to Feb's last
// day) -- this is an accepted simplification, and the drift is permanent:
// each call computes from the previous call's actual result, not an
// original anchor day, so a drifted date locks onto its new day-of-month
// going forward. Only anchor days 29-31 are ever affected; every month has
// at least 28 days, so any anchor day <= 28 never drifts.
func ComputeNextOccurrence(due time.Time, freq string, interval int, weekdays []int) time.Time {
	if interval < 1 {
		interval = 1
	}
	switch freq {
	case "daily":
		return due.AddDate(0, 0, interval)
	case "weekly":
		return nextWeeklyOccurrence(due, interval, weekdays)
	case "monthly":
		return due.AddDate(0, interval, 0)
	case "yearly":
		return due.AddDate(interval, 0, 0)
	default:
		return due
	}
}

func nextWeeklyOccurrence(due time.Time, interval int, weekdays []int) time.Time {
	if len(weekdays) == 0 {
		return due.AddDate(0, 0, 7*interval)
	}
	sorted := append([]int(nil), weekdays...)
	sort.Ints(sorted)
	dueWeekday := int(due.Weekday())

	for _, wd := range sorted {
		if wd > dueWeekday {
			return due.AddDate(0, 0, wd-dueWeekday)
		}
	}
	// Wrapped past the last active weekday this week: land on the first
	// active weekday, (interval-1) whole weeks further out than the
	// immediate next week (interval=1 means "next week", interval=2 means
	// "skip a week", etc).
	daysToNextWeekStart := 7 - dueWeekday
	return due.AddDate(0, 0, daysToNextWeekStart+sorted[0]+7*(interval-1))
}
```

- [ ] **Step 4: Run tests to verify they pass**

Run: `cd /workspace/doot && go test ./internal/models/... -run TestComputeNextOccurrence -v`
Expected: PASS (13 test cases).

- [ ] **Step 5: Commit**

```bash
cd /workspace/doot
git add internal/models/recurrence.go internal/models/recurrence_test.go
git commit -m "feat(tasks): add ComputeNextOccurrence for recurring task scheduling"
```

---

### Task 3: Iteration creation (`CreateNextIteration`, completion trigger)

**Files:**
- Modify: `internal/store/native_tasks.go`
- Test: `internal/store/native_tasks_test.go`

**Interfaces:**
- Consumes: `models.ComputeNextOccurrence` (Task 2), `formatWeekdays`/`parseWeekdays` (Task 1).
- Produces: `(s *Store) GetNativeTaskByID(id string) (*models.Task, error)`, `(s *Store) CreateNextIteration(old models.Task) error`, `(s *Store) SetTaskRecurrence(id, freq string, interval int, weekdays []int) error`, `(s *Store) SetNextOccurrenceOverride(id string, date time.Time) error` — Task 4 and Task 5 call these. `CompleteNativeTask`'s existing signature/behavior for non-recurring tasks is unchanged (only recurring tasks get new behavior).

- [ ] **Step 1: Write the failing tests**

Add to `internal/store/native_tasks_test.go`:

```go
func TestGetNativeTaskByID_UnknownID_ReturnsErrNotFound(t *testing.T) {
	s := newNativeTasksTestStore(t)

	_, err := s.GetNativeTaskByID("does-not-exist")
	if !errors.Is(err, ErrNativeTaskNotFound) {
		t.Fatalf("expected ErrNativeTaskNotFound, got %v", err)
	}
}

func TestGetNativeTaskByID_RealID_ReturnsTask(t *testing.T) {
	s := newNativeTasksTestStore(t)

	task, err := s.GetNativeTaskByID("real-1")
	if err != nil {
		t.Fatalf("GetNativeTaskByID: %v", err)
	}
	if task.Content != "Real task" {
		t.Errorf("Content = %q, want %q", task.Content, "Real task")
	}
}

func TestCompleteNativeTask_NonRecurring_JustCompletes(t *testing.T) {
	s := newNativeTasksTestStore(t)

	if err := s.CompleteNativeTask("real-1"); err != nil {
		t.Fatalf("CompleteNativeTask: %v", err)
	}

	tasks, err := s.db.Query(`SELECT id FROM native_tasks`)
	if err != nil {
		t.Fatal(err)
	}
	defer tasks.Close()
	count := 0
	for tasks.Next() {
		count++
	}
	if count != 1 {
		t.Errorf("expected exactly 1 row (no iteration created for a non-recurring task), got %d", count)
	}
}

func TestCompleteNativeTask_LatestInSeries_CreatesNextIteration(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.CompleteNativeTask("rec-1"); err != nil {
		t.Fatalf("CompleteNativeTask: %v", err)
	}

	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 be marked completed")
	}

	var nextCount int
	var nextDue string
	if err := s.db.QueryRow(`
		SELECT COUNT(*), COALESCE(MAX(due_date), '') FROM native_tasks
		WHERE recurrence_series_id = 'series-1' AND id != 'rec-1'
	`).Scan(&nextCount, &nextDue); err != nil {
		t.Fatal(err)
	}
	if nextCount != 1 {
		t.Fatalf("expected exactly 1 new iteration, got %d", nextCount)
	}
	if nextDue[:10] != "2026-07-20" {
		t.Errorf("next iteration due_date = %q, want 2026-07-20", nextDue)
	}
}

func TestCompleteNativeTask_UsesNextOccurrenceOverride(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, next_occurrence_override)
		VALUES ('rec-1', 'Water plants', '2026-07-13', 'weekly', 1, 'series-1', '2026-08-01')
	`); err != nil {
		t.Fatal(err)
	}

	if err := s.CompleteNativeTask("rec-1"); err != nil {
		t.Fatalf("CompleteNativeTask: %v", err)
	}

	var nextDue string
	if err := s.db.QueryRow(`
		SELECT due_date FROM native_tasks WHERE recurrence_series_id = 'series-1' AND id != 'rec-1'
	`).Scan(&nextDue); err != nil {
		t.Fatal(err)
	}
	if nextDue[:10] != "2026-08-01" {
		t.Errorf("next iteration due_date = %q, want 2026-08-01 (the override)", nextDue)
	}
}

func TestCompleteNativeTask_AlreadySuperseded_DoesNotDoubleCreate(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)
	}
	// Simulate the periodic due-check having already created the successor
	// before the user got around to completing rec-1.
	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)
	}

	if err := s.CompleteNativeTask("rec-1"); err != nil {
		t.Fatalf("CompleteNativeTask: %v", err)
	}

	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.Errorf("expected still exactly 2 rows in the series (no double-create), got %d", count)
	}
}

func TestSetTaskRecurrence_FirstTimeGeneratesSeriesID(t *testing.T) {
	s := newNativeTasksTestStore(t)

	if err := s.SetTaskRecurrence("real-1", "weekly", 1, []int{1, 3}); err != nil {
		t.Fatalf("SetTaskRecurrence: %v", err)
	}

	task, err := s.GetNativeTaskByID("real-1")
	if err != nil {
		t.Fatal(err)
	}
	if task.RecurrenceFreq != "weekly" {
		t.Errorf("RecurrenceFreq = %q, want weekly", task.RecurrenceFreq)
	}
	if task.RecurrenceSeriesID == "" {
		t.Error("expected a generated RecurrenceSeriesID, got empty string")
	}
	if len(task.RecurrenceWeekdays) != 2 || task.RecurrenceWeekdays[0] != 1 || task.RecurrenceWeekdays[1] != 3 {
		t.Errorf("RecurrenceWeekdays = %v, want [1 3]", task.RecurrenceWeekdays)
	}
}

func TestSetTaskRecurrence_ClearingKeepsSeriesID(t *testing.T) {
	s := newNativeTasksTestStore(t)
	if err := s.SetTaskRecurrence("real-1", "weekly", 1, nil); err != nil {
		t.Fatal(err)
	}
	task, err := s.GetNativeTaskByID("real-1")
	if err != nil {
		t.Fatal(err)
	}
	seriesID := task.RecurrenceSeriesID

	if err := s.SetTaskRecurrence("real-1", "", 1, nil); err != nil {
		t.Fatalf("SetTaskRecurrence (clear): %v", err)
	}

	task, err = s.GetNativeTaskByID("real-1")
	if err != nil {
		t.Fatal(err)
	}
	if task.RecurrenceFreq != "" {
		t.Errorf("RecurrenceFreq = %q, want empty after clearing", task.RecurrenceFreq)
	}
	if task.RecurrenceSeriesID != seriesID {
		t.Errorf("RecurrenceSeriesID = %q, want unchanged %q after clearing", task.RecurrenceSeriesID, seriesID)
	}
}

func TestSetNextOccurrenceOverride_UnknownID_ReturnsErrNotFound(t *testing.T) {
	s := newNativeTasksTestStore(t)
	err := s.SetNextOccurrenceOverride("does-not-exist", time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC))
	if !errors.Is(err, ErrNativeTaskNotFound) {
		t.Fatalf("expected ErrNativeTaskNotFound, got %v", err)
	}
}
```

- [ ] **Step 2: Run tests to verify they fail**

Run: `cd /workspace/doot && go test ./internal/store/... -run "TestGetNativeTaskByID|TestCompleteNativeTask_|TestSetTaskRecurrence|TestSetNextOccurrenceOverride" -v`
Expected: FAIL to compile — `GetNativeTaskByID`, `CreateNextIteration`, `SetTaskRecurrence`, `SetNextOccurrenceOverride` don't exist yet, and `CompleteNativeTask`'s recurrence-aware tests fail against the old implementation.

- [ ] **Step 3: Implement the new store methods and update `CompleteNativeTask`**

In `internal/store/native_tasks.go`, add these imports:

```go
import (
	"crypto/rand"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"task-dashboard/internal/models"
)
```

Add `GetNativeTaskByID` (place it right after `GetUndatedNativeTasks`):

```go
// GetNativeTaskByID returns a single native task by id, or ErrNativeTaskNotFound.
func (s *Store) GetNativeTaskByID(id string) (*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
		WHERE id = ?
	`, id)
	if err != nil {
		return nil, err
	}
	defer func() { _ = rows.Close() }()
	tasks, err := scanNativeTasks(rows)
	if err != nil {
		return nil, err
	}
	if len(tasks) == 0 {
		return nil, ErrNativeTaskNotFound
	}
	return &tasks[0], nil
}
```

Replace `CompleteNativeTask` in full:

```go
// CompleteNativeTask marks a task as completed. If it's the latest
// occurrence of a recurring series (no newer row exists yet), it also
// creates the next iteration. Returns ErrNativeTaskNotFound if id doesn't
// match any row.
func (s *Store) CompleteNativeTask(id string) error {
	task, err := s.GetNativeTaskByID(id)
	if err != nil {
		return err
	}

	result, err := s.db.Exec(`
		UPDATE native_tasks SET completed = 1, updated_at = CURRENT_TIMESTAMP WHERE id = ?
	`, id)
	if err != nil {
		return err
	}
	if err := checkRowsAffected(result); err != nil {
		return err
	}

	if task.RecurrenceSeriesID == "" {
		return nil
	}
	isLatest, err := s.isLatestInSeries(*task)
	if err != nil {
		return err
	}
	if !isLatest {
		return nil
	}
	return s.CreateNextIteration(*task)
}

// isLatestInSeries reports whether task is the row with the latest
// due_date in its recurrence series (i.e., no newer iteration has been
// created yet). Ties on due_date are broken by created_at: the
// more-recently-created row wins, so CreateNextIteration's freshly-inserted
// row always displaces the row it was generated from, never the reverse.
func (s *Store) isLatestInSeries(task models.Task) (bool, error) {
	var exists bool
	err := s.db.QueryRow(`
		SELECT EXISTS (
			SELECT 1 FROM native_tasks
			WHERE recurrence_series_id = ?
			  AND (due_date > ? OR (due_date = ? AND created_at > ?))
		)
	`, task.RecurrenceSeriesID, task.DueDate, task.DueDate, task.CreatedAt).Scan(&exists)
	if err != nil {
		return false, err
	}
	return !exists, nil
}

// CreateNextIteration copies old's content, description, project_name,
// priority, labels, and recurrence fields onto a brand-new row (new id,
// same recurrence_series_id, completed=false, next_occurrence_override=""),
// with due_date set to old.NextOccurrenceOverride if present, else
// ComputeNextOccurrence(old.DueDate, ...). old itself is left untouched.
func (s *Store) CreateNextIteration(old models.Task) error {
	var nextDue *time.Time
	switch {
	case old.NextOccurrenceOverride != nil:
		nextDue = old.NextOccurrenceOverride
	case old.DueDate != nil:
		computed := models.ComputeNextOccurrence(*old.DueDate, old.RecurrenceFreq, old.RecurrenceInterval, old.RecurrenceWeekdays)
		nextDue = &computed
	}

	labelsJSON, _ := json.Marshal(old.Labels)
	_, err := s.db.Exec(`
		INSERT INTO native_tasks (
			id, content, description, project_name, due_date, priority, labels,
			recurrence_freq, recurrence_interval, recurrence_weekdays, recurrence_series_id, next_occurrence_override,
			created_at, updated_at
		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
	`, newTaskID(), old.Content, old.Description, old.ProjectName, nextDue, old.Priority, string(labelsJSON),
		old.RecurrenceFreq, old.RecurrenceInterval, formatWeekdays(old.RecurrenceWeekdays), old.RecurrenceSeriesID)
	return err
}

// newTaskID generates a random hex id for a new native_tasks row -- the
// same format as handlers.newID(), duplicated here since store must not
// import handlers.
func newTaskID() string {
	b := make([]byte, 12)
	_, _ = rand.Read(b)
	return fmt.Sprintf("%x", b)
}

// SetTaskRecurrence sets or clears a task's recurrence pattern. freq == ""
// clears the pattern (recurrence_series_id is left untouched so history
// stays linkable -- a cleared task just stops generating new iterations).
// Setting a freq for the first time (existing recurrence_series_id is
// empty) generates a new series id. Returns ErrNativeTaskNotFound if id
// doesn't match any row.
func (s *Store) SetTaskRecurrence(id, freq string, interval int, weekdays []int) error {
	task, err := s.GetNativeTaskByID(id)
	if err != nil {
		return err
	}

	seriesID := task.RecurrenceSeriesID
	if freq != "" && seriesID == "" {
		seriesID = newTaskID()
	}

	result, err := s.db.Exec(`
		UPDATE native_tasks
		SET recurrence_freq = ?, recurrence_interval = ?, recurrence_weekdays = ?, recurrence_series_id = ?, updated_at = CURRENT_TIMESTAMP
		WHERE id = ?
	`, freq, interval, formatWeekdays(weekdays), seriesID, id)
	if err != nil {
		return err
	}
	return checkRowsAffected(result)
}

// SetNextOccurrenceOverride sets a one-shot override for a task's next
// occurrence, consumed (read, but not explicitly cleared -- the override
// column simply isn't copied onto the new row) the next time
// CreateNextIteration runs for its series. Returns ErrNativeTaskNotFound if
// id doesn't match any row.
func (s *Store) SetNextOccurrenceOverride(id string, date time.Time) error {
	result, err := s.db.Exec(`
		UPDATE native_tasks SET next_occurrence_override = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
	`, date.Format("2006-01-02"), id)
	if err != nil {
		return err
	}
	return checkRowsAffected(result)
}
```

- [ ] **Step 4: Run tests to verify they pass**

Run: `cd /workspace/doot && go test ./internal/store/... -v`
Expected: PASS for every test in the package.

- [ ] **Step 5: Run the full Go build and handlers package test**

Run: `cd /workspace/doot && go build ./... && go test ./internal/handlers/...`
Expected: same result as Task 1 Step 8 (build succeeds; only the two pre-existing unrelated failures remain).

- [ ] **Step 6: Commit**

```bash
cd /workspace/doot
git add internal/store/native_tasks.go internal/store/native_tasks_test.go
git commit -m "feat(tasks): create the next recurring iteration on completion

CompleteNativeTask now creates a new row for the next occurrence when
completing the latest iteration of a recurring series (using the
one-shot next_occurrence_override if set, else ComputeNextOccurrence).
Completing an already-superseded row (the periodic due-check beat it
to creating the successor) just marks it completed, no double-create."
```

---

### Task 4: Periodic due-date trigger

**Files:**
- Modify: `internal/store/native_tasks.go`
- Test: `internal/store/native_tasks_test.go`
- Create: `internal/scheduler/recurrence.go`
- Modify: `cmd/dashboard/main.go`

**Interfaces:**
- Consumes: `Store.CreateNextIteration` (Task 3).
- Produces: `(s *Store) GetSeriesNeedingNextIteration(now time.Time) ([]models.Task, error)`, `(s *Store) AdvanceDueRecurringTasks(now time.Time) (int, error)`, `scheduler.RunRecurrenceCheck(ctx context.Context, s *store.Store, interval time.Duration)`.

- [ ] **Step 1: Write the failing tests**

Add to `internal/store/native_tasks_test.go`:

```go
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)
	}
}
```

- [ ] **Step 2: Run tests to verify they fail**

Run: `cd /workspace/doot && go test ./internal/store/... -run TestAdvanceDueRecurringTasks -v`
Expected: FAIL to compile — `AdvanceDueRecurringTasks` doesn't exist yet.

- [ ] **Step 3: Implement `GetSeriesNeedingNextIteration` and `AdvanceDueRecurringTasks`**

In `internal/store/native_tasks.go`, add (after `SetNextOccurrenceOverride`):

```go
// 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
}
```

- [ ] **Step 4: Run tests to verify they pass**

Run: `cd /workspace/doot && go test ./internal/store/... -v`
Expected: PASS for every test in the package.

- [ ] **Step 5: Add the scheduler package**

Create `internal/scheduler/recurrence.go`:

```go
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)
			}
		}
	}
}
```

- [ ] **Step 6: Wire the scheduler into `main.go`**

In `cmd/dashboard/main.go`, find the graceful-shutdown section:

```go
	addr := ":" + cfg.Port
	srv := &http.Server{
		Addr:         addr,
		Handler:      r,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 15 * time.Second,
		IdleTimeout:  60 * time.Second,
	}

	// Graceful shutdown
	go func() {
		log.Printf("Starting server on http://localhost%s", addr)
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("Server failed: %v", err)
		}
	}()

	// Wait for interrupt signal
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit

	log.Println("Shutting down server...")
```

Replace with:

```go
	addr := ":" + cfg.Port
	srv := &http.Server{
		Addr:         addr,
		Handler:      r,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 15 * time.Second,
		IdleTimeout:  60 * time.Second,
	}

	// Periodic recurring-task due-date check (independent of the HTTP
	// server's own lifecycle, cancelled alongside it on shutdown below).
	schedulerCtx, cancelScheduler := context.WithCancel(context.Background())
	go scheduler.RunRecurrenceCheck(schedulerCtx, db, 15*time.Minute)

	// Graceful shutdown
	go func() {
		log.Printf("Starting server on http://localhost%s", addr)
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("Server failed: %v", err)
		}
	}()

	// Wait for interrupt signal
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit

	log.Println("Shutting down server...")
	cancelScheduler()
```

Add the import (`"task-dashboard/internal/scheduler"`) to `main.go`'s import block, alongside the other `task-dashboard/internal/...` imports.

- [ ] **Step 7: Run the full build**

Run: `cd /workspace/doot && go build ./...`
Expected: BUILD SUCCESSFUL.

- [ ] **Step 8: Commit**

```bash
cd /workspace/doot
git add internal/store/native_tasks.go internal/store/native_tasks_test.go internal/scheduler/recurrence.go cmd/dashboard/main.go
git commit -m "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."
```

---

### Task 5: HTTP endpoints

**Files:**
- Modify: `internal/handlers/widget.go`
- Modify: `cmd/dashboard/main.go`
- Test: `internal/handlers/widget_test.go`

**Interfaces:**
- Consumes: `Store.GetNativeTaskByID`, `Store.SetTaskRecurrence`, `Store.SetNextOccurrenceOverride` (Task 3), `models.ComputeNextOccurrence` (Task 2), existing `Store.UpdateNativeTask`.
- Produces: `GET /api/widget/task?id=&source=`, `POST /api/widget/task/update`, `POST /api/widget/task/recurrence`, `POST /api/widget/task/next-date` — consumed by Task 6's Android `WidgetRepository`.

- [ ] **Step 1: Write the failing tests**

Add to `internal/handlers/widget_test.go`:

```go
func TestHandleWidgetTaskDetail_ReturnsFullDetail(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	if _, err := s.DB().Exec(`
		INSERT INTO native_tasks (id, content, description, due_date, recurrence_freq, recurrence_interval, recurrence_weekdays, recurrence_series_id)
		VALUES ('rec-1', 'Water plants', 'Use the blue can', '2026-07-13', 'weekly', 1, '1,3,5', 'series-1')
	`); err != nil {
		t.Fatal(err)
	}

	req := httptest.NewRequest("GET", "/api/widget/task?id=rec-1&source=doot", nil)
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskDetail).ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	var resp taskDetailResponse
	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
		t.Fatalf("failed to decode response: %v", err)
	}
	if resp.Title != "Water plants" {
		t.Errorf("Title = %q, want %q", resp.Title, "Water plants")
	}
	if resp.Description != "Use the blue can" {
		t.Errorf("Description = %q, want %q", resp.Description, "Use the blue can")
	}
	if resp.Recurrence == nil {
		t.Fatal("expected non-nil Recurrence")
	}
	if resp.Recurrence.Freq != "weekly" || len(resp.Recurrence.Weekdays) != 3 {
		t.Errorf("Recurrence = %+v, want freq=weekly with 3 weekdays", resp.Recurrence)
	}
	if resp.NextDate == nil {
		t.Fatal("expected computed NextDate for a recurring task")
	}
}

func TestHandleWidgetTaskDetail_NonRecurring_NilRecurrenceAndNextDate(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	if _, err := s.DB().Exec(`INSERT INTO native_tasks (id, content) VALUES ('plain-1', 'Buy milk')`); err != nil {
		t.Fatal(err)
	}

	req := httptest.NewRequest("GET", "/api/widget/task?id=plain-1&source=doot", nil)
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskDetail).ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
	var resp taskDetailResponse
	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
		t.Fatalf("failed to decode response: %v", err)
	}
	if resp.Recurrence != nil {
		t.Errorf("expected nil Recurrence for a non-recurring task, got %+v", resp.Recurrence)
	}
	if resp.NextDate != nil {
		t.Errorf("expected nil NextDate for a non-recurring task, got %v", resp.NextDate)
	}
}

func TestHandleWidgetTaskDetail_UnknownID_Returns404(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	req := httptest.NewRequest("GET", "/api/widget/task?id=does-not-exist&source=doot", nil)
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskDetail).ServeHTTP(w, req)

	if w.Code != http.StatusNotFound {
		t.Errorf("expected 404, got %d", w.Code)
	}
}

func TestHandleWidgetTaskUpdate_UpdatesTitleAndDescription(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	if _, err := s.DB().Exec(`INSERT INTO native_tasks (id, content) VALUES ('plain-1', 'Old title')`); err != nil {
		t.Fatal(err)
	}

	body := `{"id":"plain-1","title":"New title","description":"New description"}`
	req := httptest.NewRequest("POST", "/api/widget/task/update", strings.NewReader(body))
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskUpdate).ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	task, err := s.GetNativeTaskByID("plain-1")
	if err != nil {
		t.Fatal(err)
	}
	if task.Content != "New title" || task.Description != "New description" {
		t.Errorf("task = %+v, want title/description updated", task)
	}
}

func TestHandleWidgetTaskRecurrence_SetsPattern(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	if _, err := s.DB().Exec(`INSERT INTO native_tasks (id, content) VALUES ('plain-1', 'Water plants')`); err != nil {
		t.Fatal(err)
	}

	body := `{"id":"plain-1","freq":"weekly","interval":2,"weekdays":[1,3]}`
	req := httptest.NewRequest("POST", "/api/widget/task/recurrence", strings.NewReader(body))
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskRecurrence).ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	task, err := s.GetNativeTaskByID("plain-1")
	if err != nil {
		t.Fatal(err)
	}
	if task.RecurrenceFreq != "weekly" || task.RecurrenceInterval != 2 || task.RecurrenceSeriesID == "" {
		t.Errorf("task = %+v, want recurrence set with a generated series id", task)
	}
}

func TestHandleWidgetTaskRecurrence_InvalidFreq_Returns400(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	body := `{"id":"plain-1","freq":"bogus","interval":1}`
	req := httptest.NewRequest("POST", "/api/widget/task/recurrence", strings.NewReader(body))
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskRecurrence).ServeHTTP(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("expected 400 for an invalid freq, got %d", w.Code)
	}
}

func TestHandleWidgetTaskNextDate_SetsOverride(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	if _, err := s.DB().Exec(`
		INSERT INTO native_tasks (id, content, due_date, recurrence_freq, recurrence_series_id)
		VALUES ('rec-1', 'Water plants', '2026-07-13', 'weekly', 'series-1')
	`); err != nil {
		t.Fatal(err)
	}

	body := `{"id":"rec-1","date":"2026-08-01"}`
	req := httptest.NewRequest("POST", "/api/widget/task/next-date", strings.NewReader(body))
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskNextDate).ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	task, err := s.GetNativeTaskByID("rec-1")
	if err != nil {
		t.Fatal(err)
	}
	if task.NextOccurrenceOverride == nil || task.NextOccurrenceOverride.Format("2006-01-02") != "2026-08-01" {
		t.Errorf("NextOccurrenceOverride = %v, want 2026-08-01", task.NextOccurrenceOverride)
	}
}

func TestHandleWidgetTaskNextDate_NonRecurringTask_Returns400(t *testing.T) {
	s, cleanup := setupTestDB(t)
	defer cleanup()
	h := &Handler{store: s}

	if _, err := s.DB().Exec(`INSERT INTO native_tasks (id, content) VALUES ('plain-1', 'Buy milk')`); err != nil {
		t.Fatal(err)
	}

	body := `{"id":"plain-1","date":"2026-08-01"}`
	req := httptest.NewRequest("POST", "/api/widget/task/next-date", strings.NewReader(body))
	w := httptest.NewRecorder()
	http.HandlerFunc(h.HandleWidgetTaskNextDate).ServeHTTP(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("expected 400 for a non-recurring task, got %d", w.Code)
	}
}
```

Check whether `setupTestDB` exposes the underlying `*sql.DB` (needed for the raw `INSERT` fixtures above) — search for `func (s *Store) DB()`:

```bash
grep -n "func (s \*Store) DB()" /workspace/doot/internal/store/sqlite.go
```

If it doesn't exist, add it to `internal/store/sqlite.go` (near the `Store` struct definition):

```go
// DB returns the underlying *sql.DB, for callers (tests, session store
// wiring) that need direct access.
func (s *Store) DB() *sql.DB {
	return s.db
}
```

(Check first — this accessor may already exist for the `sessionManager.Store = sqlite3store.New(db.DB())` call already present in `cmd/dashboard/main.go`; if so, skip this addition.)

- [ ] **Step 2: Run tests to verify they fail**

Run: `cd /workspace/doot && go test ./internal/handlers/... -run "TestHandleWidgetTaskDetail|TestHandleWidgetTaskUpdate|TestHandleWidgetTaskRecurrence|TestHandleWidgetTaskNextDate" -v`
Expected: FAIL to compile — none of the four handlers or the `taskDetailResponse`/`recurrenceResponse` types exist yet.

- [ ] **Step 3: Implement the four handlers**

In `internal/handlers/widget.go`, add (after `HandleWidgetAdd`, or any convenient point after the existing widget handlers):

```go
type recurrenceResponse struct {
	Freq     string `json:"freq"`
	Interval int    `json:"interval"`
	Weekdays []int  `json:"weekdays,omitempty"`
}

type taskDetailResponse struct {
	ID          string              `json:"id"`
	Title       string              `json:"title"`
	Description string              `json:"description"`
	DueDate     *time.Time          `json:"due_date,omitempty"`
	Completed   bool                `json:"completed"`
	Recurrence  *recurrenceResponse `json:"recurrence,omitempty"`
	NextDate    *time.Time          `json:"next_date,omitempty"`
}

// HandleWidgetTaskDetail returns full detail for a single doot-native task,
// including its recurrence pattern and computed next-occurrence date.
func (h *Handler) HandleWidgetTaskDetail(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	source := r.URL.Query().Get("source")
	if id == "" || source != "doot" {
		http.Error(w, "id required and source must be doot", http.StatusBadRequest)
		return
	}

	task, err := h.store.GetNativeTaskByID(id)
	if err != nil {
		if errors.Is(err, store.ErrNativeTaskNotFound) {
			http.Error(w, "task not found", http.StatusNotFound)
			return
		}
		http.Error(w, "failed to load task", http.StatusInternalServerError)
		return
	}

	resp := taskDetailResponse{
		ID:          task.ID,
		Title:       task.Content,
		Description: task.Description,
		DueDate:     task.DueDate,
		Completed:   task.Completed,
	}
	if task.RecurrenceSeriesID != "" {
		resp.Recurrence = &recurrenceResponse{
			Freq:     task.RecurrenceFreq,
			Interval: task.RecurrenceInterval,
			Weekdays: task.RecurrenceWeekdays,
		}
		if task.NextOccurrenceOverride != nil {
			resp.NextDate = task.NextOccurrenceOverride
		} else if task.DueDate != nil {
			next := models.ComputeNextOccurrence(*task.DueDate, task.RecurrenceFreq, task.RecurrenceInterval, task.RecurrenceWeekdays)
			resp.NextDate = &next
		}
	}

	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(resp)
}

type taskUpdateRequest struct {
	ID          string `json:"id"`
	Title       string `json:"title"`
	Description string `json:"description"`
}

// HandleWidgetTaskUpdate updates a doot-native task's title and description.
func (h *Handler) HandleWidgetTaskUpdate(w http.ResponseWriter, r *http.Request) {
	var req taskUpdateRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "bad request", http.StatusBadRequest)
		return
	}
	if req.ID == "" || req.Title == "" {
		http.Error(w, "id and title are required", http.StatusBadRequest)
		return
	}
	if err := h.store.UpdateNativeTask(req.ID, req.Title, req.Description); err != nil {
		http.Error(w, "failed to update task", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
}

type taskRecurrenceRequest struct {
	ID       string `json:"id"`
	Freq     string `json:"freq"`
	Interval int    `json:"interval"`
	Weekdays []int  `json:"weekdays"`
}

// HandleWidgetTaskRecurrence sets or clears a doot-native task's recurrence
// pattern. freq == "" clears recurrence.
func (h *Handler) HandleWidgetTaskRecurrence(w http.ResponseWriter, r *http.Request) {
	var req taskRecurrenceRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "bad request", http.StatusBadRequest)
		return
	}
	if req.ID == "" {
		http.Error(w, "id is required", http.StatusBadRequest)
		return
	}
	if req.Freq != "" && req.Freq != "daily" && req.Freq != "weekly" && req.Freq != "monthly" && req.Freq != "yearly" {
		http.Error(w, "invalid freq", http.StatusBadRequest)
		return
	}
	if err := h.store.SetTaskRecurrence(req.ID, req.Freq, req.Interval, req.Weekdays); err != nil {
		if errors.Is(err, store.ErrNativeTaskNotFound) {
			http.Error(w, "task not found", http.StatusNotFound)
			return
		}
		http.Error(w, "failed to update recurrence", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
}

type taskNextDateRequest struct {
	ID   string `json:"id"`
	Date string `json:"date"` // YYYY-MM-DD
}

// HandleWidgetTaskNextDate sets a one-shot override for a recurring task's
// next occurrence. 400 if the task has no active recurrence.
func (h *Handler) HandleWidgetTaskNextDate(w http.ResponseWriter, r *http.Request) {
	var req taskNextDateRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "bad request", http.StatusBadRequest)
		return
	}
	parsed, err := time.Parse("2006-01-02", req.Date)
	if err != nil {
		http.Error(w, "invalid date", http.StatusBadRequest)
		return
	}

	task, err := h.store.GetNativeTaskByID(req.ID)
	if err != nil {
		if errors.Is(err, store.ErrNativeTaskNotFound) {
			http.Error(w, "task not found", http.StatusNotFound)
			return
		}
		http.Error(w, "failed to load task", http.StatusInternalServerError)
		return
	}
	if task.RecurrenceSeriesID == "" {
		http.Error(w, "task has no active recurrence", http.StatusBadRequest)
		return
	}

	tz := config.GetDisplayTimezone()
	dueDate := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, tz)
	if err := h.store.SetNextOccurrenceOverride(req.ID, dueDate); err != nil {
		http.Error(w, "failed to set next date", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
}
```

Add `"task-dashboard/internal/models"` to `widget.go`'s import block if not already present (check first — `TimelineItemToWidgetItem` in the same file already references `models.WidgetItem`/`models.TimelineItem`, so this import should already exist).

- [ ] **Step 4: Register the four routes**

In `cmd/dashboard/main.go`, find:

```go
		r.With(widgetAuth).Get("/api/widget", h.HandleWidgetGet)
		r.With(widgetAuth).Post("/api/widget/complete", h.HandleWidgetComplete)
		r.With(widgetAuth).Post("/api/widget/reschedule", h.HandleWidgetReschedule)
		r.With(widgetAuth).Post("/api/widget/add", h.HandleWidgetAdd)
```

Replace with:

```go
		r.With(widgetAuth).Get("/api/widget", h.HandleWidgetGet)
		r.With(widgetAuth).Post("/api/widget/complete", h.HandleWidgetComplete)
		r.With(widgetAuth).Post("/api/widget/reschedule", h.HandleWidgetReschedule)
		r.With(widgetAuth).Post("/api/widget/add", h.HandleWidgetAdd)
		r.With(widgetAuth).Get("/api/widget/task", h.HandleWidgetTaskDetail)
		r.With(widgetAuth).Post("/api/widget/task/update", h.HandleWidgetTaskUpdate)
		r.With(widgetAuth).Post("/api/widget/task/recurrence", h.HandleWidgetTaskRecurrence)
		r.With(widgetAuth).Post("/api/widget/task/next-date", h.HandleWidgetTaskNextDate)
```

- [ ] **Step 5: Run tests to verify they pass**

Run: `cd /workspace/doot && go test ./internal/handlers/... -run "TestHandleWidgetTaskDetail|TestHandleWidgetTaskUpdate|TestHandleWidgetTaskRecurrence|TestHandleWidgetTaskNextDate" -v`
Expected: PASS for all 8 new tests.

- [ ] **Step 6: Run the full Go build and test suite**

Run: `cd /workspace/doot && go build ./... && go test ./internal/...`
Expected: `go build` succeeds. `go test` passes except the two pre-existing, unrelated `internal/handlers` failures and the pre-existing `internal/models` vet/build failure (`MealToAtom` undefined in `atom_test.go`) — all confirmed present before this entire body of work.

- [ ] **Step 7: Commit**

```bash
cd /workspace/doot
git add internal/handlers/widget.go cmd/dashboard/main.go internal/store/sqlite.go
git commit -m "feat(tasks): add HTTP endpoints for task detail, update, and recurrence

GET /api/widget/task, POST /api/widget/task/update,
POST /api/widget/task/recurrence, POST /api/widget/task/next-date.
Doot-only; the recurrence/next-date fields are null in the detail
response for a non-recurring task."
```

---

### Task 6: Android `WidgetRepository` data layer

**Files:**
- Create: `android/app/src/main/java/org/terst/doot/widget/data/TaskDetail.kt`
- Modify: `android/app/src/main/java/org/terst/doot/widget/data/WidgetRepository.kt`
- Test: `android/app/src/test/java/org/terst/doot/widget/WidgetRepositoryTest.kt`

**Interfaces:**
- Consumes: `GET /api/widget/task`, `POST /api/widget/task/update`, `POST /api/widget/task/recurrence`, `POST /api/widget/task/next-date` (Task 5).
- Produces: `TaskDetailResponse`, `TaskRecurrence` data classes; `WidgetRepository.fetchTaskDetail(id: String): Result<TaskDetailResponse>`, `.updateTask(id, title, description): Result<Unit>`, `.setTaskRecurrence(id, freq, interval, weekdays): Result<Unit>`, `.setTaskNextDate(id, dateISO): Result<Unit>` — consumed by Task 8's `TaskDetailActivity`.

- [ ] **Step 1: Write the failing test**

Add to `android/app/src/test/java/org/terst/doot/widget/WidgetRepositoryTest.kt` (append inside the `WidgetRepositoryTest` class, before the closing brace):

```kotlin
    @Test
    fun `fetchTaskDetail returns success with valid JSON`() = runTest {
        val json = """{"id":"rec-1","title":"Water plants","description":"Use the blue can","due_date":"2026-07-13T00:00:00-10:00","completed":false,"recurrence":{"freq":"weekly","interval":1,"weekdays":[1,3,5]},"next_date":"2026-07-15T00:00:00-10:00"}"""
        every { mockClient.newCall(any()) } returns mockCall
        every { mockCall.execute() } returns responseOf(200, json)

        val repo = WidgetRepository(mockClient, "https://doot.example.com", "token")
        val result = repo.fetchTaskDetail("rec-1")

        assertTrue(result.isSuccess)
        val detail = result.getOrThrow()
        assertEquals("Water plants", detail.title)
        assertEquals("weekly", detail.recurrence?.freq)
        assertEquals(listOf(1, 3, 5), detail.recurrence?.weekdays)
        assertEquals("2026-07-15T00:00:00-10:00", detail.nextDate)
    }

    @Test
    fun `fetchTaskDetail returns failure on non-200`() = runTest {
        every { mockClient.newCall(any()) } returns mockCall
        every { mockCall.execute() } returns responseOf(404, "not found")

        val repo = WidgetRepository(mockClient, "https://doot.example.com", "token")
        val result = repo.fetchTaskDetail("does-not-exist")

        assertTrue(result.isFailure)
    }

    @Test
    fun `fetchTaskDetail requests the given id with source=doot`() = runTest {
        val json = """{"id":"rec-1","title":"Water plants","description":"","completed":false}"""
        val capturedRequest = slot<Request>()
        every { mockClient.newCall(capture(capturedRequest)) } returns mockCall
        every { mockCall.execute() } returns responseOf(200, json)

        val repo = WidgetRepository(mockClient, "https://doot.example.com", "token")
        repo.fetchTaskDetail("rec-1")

        val url = capturedRequest.captured.url.toString()
        assertTrue("expected id=rec-1 in URL, got $url", url.contains("id=rec-1"))
        assertTrue("expected source=doot in URL, got $url", url.contains("source=doot"))
    }
```

- [ ] **Step 2: Run test to verify it fails**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest --tests "org.terst.doot.widget.WidgetRepositoryTest"`
Expected: FAILS to compile — `fetchTaskDetail`/`TaskDetailResponse`/`TaskRecurrence` don't exist yet.

- [ ] **Step 3: Add the data classes**

Create `android/app/src/main/java/org/terst/doot/widget/data/TaskDetail.kt`:

```kotlin
package org.terst.doot.widget.data

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class TaskDetailResponse(
    val id: String,
    val title: String,
    val description: String,
    @SerialName("due_date") val dueDate: String? = null,
    val completed: Boolean = false,
    val recurrence: TaskRecurrence? = null,
    @SerialName("next_date") val nextDate: String? = null
)

@Serializable
data class TaskRecurrence(
    val freq: String,
    val interval: Int,
    val weekdays: List<Int> = emptyList()
)
```

- [ ] **Step 4: Add the four `WidgetRepository` methods**

In `android/app/src/main/java/org/terst/doot/widget/data/WidgetRepository.kt`, add after `addTask` (before the closing `}` of the class):

```kotlin
    /** GETs full detail for a single doot-native task from /api/widget/task. */
    suspend fun fetchTaskDetail(id: String): Result<TaskDetailResponse> =
        withContext(Dispatchers.IO) {
            val encodedId = java.net.URLEncoder.encode(id, "UTF-8")
            val request = Request.Builder()
                .url("$serverUrl/api/widget/task?id=$encodedId&source=doot")
                .header("Authorization", "Bearer $token")
                .build()
            runCatching {
                val response = client.newCall(request).execute()
                check(response.isSuccessful) { "HTTP ${response.code}" }
                val body = checkNotNull(response.body?.string()) { "Empty body" }
                json.decodeFromString<TaskDetailResponse>(body)
            }
        }

    @Serializable
    private data class TaskUpdateRequest(val id: String, val title: String, val description: String)

    /** POSTs a title/description update to /api/widget/task/update. */
    suspend fun updateTask(id: String, title: String, description: String): Result<Unit> =
        withContext(Dispatchers.IO) {
            val body = json.encodeToString(TaskUpdateRequest(id, title, description))
                .toRequestBody("application/json".toMediaType())
            val request = Request.Builder()
                .url("$serverUrl/api/widget/task/update")
                .header("Authorization", "Bearer $token")
                .post(body)
                .build()
            runCatching {
                val response = client.newCall(request).execute()
                check(response.isSuccessful) { "HTTP ${response.code}" }
            }
        }

    @Serializable
    private data class TaskRecurrenceRequest(val id: String, val freq: String, val interval: Int, val weekdays: List<Int>)

    /** POSTs a recurrence pattern change to /api/widget/task/recurrence. freq="" clears it. */
    suspend fun setTaskRecurrence(id: String, freq: String, interval: Int, weekdays: List<Int>): Result<Unit> =
        withContext(Dispatchers.IO) {
            val body = json.encodeToString(TaskRecurrenceRequest(id, freq, interval, weekdays))
                .toRequestBody("application/json".toMediaType())
            val request = Request.Builder()
                .url("$serverUrl/api/widget/task/recurrence")
                .header("Authorization", "Bearer $token")
                .post(body)
                .build()
            runCatching {
                val response = client.newCall(request).execute()
                check(response.isSuccessful) { "HTTP ${response.code}" }
            }
        }

    @Serializable
    private data class TaskNextDateRequest(val id: String, val date: String)

    /** POSTs a one-shot next-occurrence override to /api/widget/task/next-date. */
    suspend fun setTaskNextDate(id: String, dateISO: String): Result<Unit> =
        withContext(Dispatchers.IO) {
            val body = json.encodeToString(TaskNextDateRequest(id, dateISO))
                .toRequestBody("application/json".toMediaType())
            val request = Request.Builder()
                .url("$serverUrl/api/widget/task/next-date")
                .header("Authorization", "Bearer $token")
                .post(body)
                .build()
            runCatching {
                val response = client.newCall(request).execute()
                check(response.isSuccessful) { "HTTP ${response.code}" }
            }
        }
```

- [ ] **Step 5: Run test to verify it passes**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest --tests "org.terst.doot.widget.WidgetRepositoryTest"`
Expected: PASS (all tests in the file, including the 3 new ones).

- [ ] **Step 6: Run the full Android unit test suite**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest`
Expected: BUILD SUCCESSFUL, all tests pass.

- [ ] **Step 7: Commit**

```bash
cd /workspace/doot
git add android/app/src/main/java/org/terst/doot/widget/data/TaskDetail.kt android/app/src/main/java/org/terst/doot/widget/data/WidgetRepository.kt android/app/src/test/java/org/terst/doot/widget/WidgetRepositoryTest.kt
git commit -m "feat(widget): add WidgetRepository methods for task detail/recurrence"
```

---

### Task 7: Description linkification

**Files:**
- Create: `android/app/src/main/java/org/terst/doot/widget/ui/LinkifiedText.kt`
- Test: `android/app/src/test/java/org/terst/doot/widget/ui/LinkifiedTextTest.kt`

**Interfaces:**
- Consumes: nothing new.
- Produces: `internal fun findLinks(text: String): List<TextLink>`, `enum class LinkKind { URL, PHONE }`, `data class TextLink(val range: IntRange, val kind: LinkKind, val target: String)`, `@Composable fun LinkifiedText(text: String, modifier: Modifier, onOpenUrl: (String) -> Unit, onDialPhone: (String) -> Unit)` — the Composable is consumed by Task 8.

- [ ] **Step 1: Write the failing tests**

Create `android/app/src/test/java/org/terst/doot/widget/ui/LinkifiedTextTest.kt`:

```kotlin
package org.terst.doot.widget.ui

import org.junit.Assert.assertEquals
import org.junit.Test

class LinkifiedTextTest {

    @Test
    fun `findLinks finds a plain URL`() {
        val links = findLinks("Check out https://example.com/path for details")
        assertEquals(1, links.size)
        assertEquals(LinkKind.URL, links[0].kind)
        assertEquals("https://example.com/path", links[0].target)
    }

    @Test
    fun `findLinks finds a phone number`() {
        val links = findLinks("Call me at 555-123-4567 tomorrow")
        assertEquals(1, links.size)
        assertEquals(LinkKind.PHONE, links[0].kind)
        assertEquals("555-123-4567", links[0].target)
    }

    @Test
    fun `findLinks finds both a URL and a phone number in the same text`() {
        val links = findLinks("See https://example.com or call 555-123-4567")
        assertEquals(2, links.size)
        assertEquals(LinkKind.URL, links[0].kind)
        assertEquals(LinkKind.PHONE, links[1].kind)
    }

    @Test
    fun `findLinks returns empty list for plain text`() {
        val links = findLinks("Just a regular description with no links.")
        assertEquals(0, links.size)
    }

    @Test
    fun `findLinks does not double-count phone-like digits inside a URL`() {
        val links = findLinks("https://example.com/555-123-4567")
        assertEquals(1, links.size)
        assertEquals(LinkKind.URL, links[0].kind)
    }
}
```

- [ ] **Step 2: Run tests to verify they fail**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest --tests "org.terst.doot.widget.ui.LinkifiedTextTest"`
Expected: FAILS to compile — `findLinks`/`LinkKind`/`TextLink` don't exist yet.

- [ ] **Step 3: Implement `LinkifiedText.kt`**

Create `android/app/src/main/java/org/terst/doot/widget/ui/LinkifiedText.kt`:

```kotlin
package org.terst.doot.widget.ui

import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.text.BasicText
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.TextLayoutResult
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.style.TextDecoration
import androidx.compose.ui.unit.sp

enum class LinkKind { URL, PHONE }

data class TextLink(val range: IntRange, val kind: LinkKind, val target: String)

private val URL_REGEX = Regex("""https?://[^\s<>"']+""")
private val PHONE_REGEX = Regex("""\+?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}""")

/**
 * Finds URL and phone-number spans in text. Phone matches that overlap an
 * already-found URL span are dropped (a URL's digits could coincidentally
 * match the phone pattern; the URL match wins). Intentionally simple --
 * US-style phone numbers, not a full i18n phone-number parser.
 */
internal fun findLinks(text: String): List<TextLink> {
    val links = mutableListOf<TextLink>()
    for (match in URL_REGEX.findAll(text)) {
        links.add(TextLink(match.range, LinkKind.URL, match.value))
    }
    for (match in PHONE_REGEX.findAll(text)) {
        val overlaps = links.any { it.range.first <= match.range.last && match.range.first <= it.range.last }
        if (!overlaps) {
            links.add(TextLink(match.range, LinkKind.PHONE, match.value))
        }
    }
    return links.sortedBy { it.range.first }
}

/**
 * Renders text with URLs and phone numbers underlined and tappable.
 * Doesn't use Compose's LinkAnnotation API (unconfirmed whether it's fully
 * wired into Text's click handling at this project's resolved Compose UI
 * version, 1.6.1) -- instead resolves taps manually via
 * TextLayoutResult.getOffsetForPosition, which works on any Compose version.
 */
@Composable
fun LinkifiedText(
    text: String,
    modifier: Modifier = Modifier,
    onOpenUrl: (String) -> Unit,
    onDialPhone: (String) -> Unit
) {
    val links = remember(text) { findLinks(text) }
    val annotated = remember(text, links) {
        buildAnnotatedString {
            append(text)
            for (link in links) {
                addStyle(
                    SpanStyle(color = Color(0xFF60A5FA), textDecoration = TextDecoration.Underline),
                    link.range.first,
                    link.range.last + 1
                )
            }
        }
    }
    var layoutResult by remember { mutableStateOf<TextLayoutResult?>(null) }
    BasicText(
        text = annotated,
        modifier = modifier.pointerInput(links) {
            detectTapGestures { offset ->
                val layout = layoutResult ?: return@detectTapGestures
                val charOffset = layout.getOffsetForPosition(offset)
                links.firstOrNull { charOffset in it.range }?.let { link ->
                    when (link.kind) {
                        LinkKind.URL -> onOpenUrl(link.target)
                        LinkKind.PHONE -> onDialPhone(link.target)
                    }
                }
            }
        },
        style = TextStyle(color = Color.White.copy(alpha = 0.85f), fontSize = 14.sp),
        onTextLayout = { layoutResult = it }
    )
}
```

- [ ] **Step 4: Run tests to verify they pass**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest --tests "org.terst.doot.widget.ui.LinkifiedTextTest"`
Expected: PASS (5 tests).

- [ ] **Step 5: Run the full Android unit test suite**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest`
Expected: BUILD SUCCESSFUL, all tests pass.

- [ ] **Step 6: Commit**

```bash
cd /workspace/doot
git add android/app/src/main/java/org/terst/doot/widget/ui/LinkifiedText.kt android/app/src/test/java/org/terst/doot/widget/ui/LinkifiedTextTest.kt
git commit -m "feat(widget): add description linkification for URLs and phone numbers"
```

---

### Task 8: `TaskDetailActivity` redesign

**Files:**
- Modify: `android/app/src/main/java/org/terst/doot/widget/ui/TaskDetailActivity.kt`
- Create: `android/app/src/main/java/org/terst/doot/widget/ui/RecurrenceEditDialog.kt`

**Interfaces:**
- Consumes: `WidgetRepository.fetchTaskDetail`/`.updateTask`/`.setTaskRecurrence`/`.setTaskNextDate` (Task 6), `LinkifiedText` (Task 7), `TaskRecurrence`/`TaskDetailResponse` (Task 6).
- Produces: nothing consumed by later tasks (this is the last Android task).

No dedicated test for this task — no Compose UI test harness in this project (established convention every prior widget UI task this session has followed). Verified by `./gradlew testDebugUnitTest` (compiles, no regressions) and a manual on-device check after Task 9's deploy.

- [ ] **Step 1: Create the recurrence-editing dialog**

Create `android/app/src/main/java/org/terst/doot/widget/ui/RecurrenceEditDialog.kt`:

```kotlin
package org.terst.doot.widget.ui

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FilterChip
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import org.terst.doot.widget.data.TaskRecurrence

internal fun weekdayAbbrev(day: Int): String = when (day) {
    0 -> "Sun"; 1 -> "Mon"; 2 -> "Tue"; 3 -> "Wed"; 4 -> "Thu"; 5 -> "Fri"; 6 -> "Sat"
    else -> "?"
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun RecurrenceEditDialog(
    initial: TaskRecurrence?,
    onDismiss: () -> Unit,
    onSave: (freq: String, interval: Int, weekdays: List<Int>) -> Unit,
    onClear: () -> Unit
) {
    var freq by remember { mutableStateOf(initial?.freq ?: "weekly") }
    var interval by remember { mutableStateOf((initial?.interval ?: 1).toString()) }
    var weekdays by remember { mutableStateOf(initial?.weekdays?.toSet() ?: emptySet()) }

    AlertDialog(
        onDismissRequest = onDismiss,
        title = { Text("Recurrence") },
        text = {
            Column {
                Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
                    listOf("daily", "weekly", "monthly", "yearly").forEach { option ->
                        FilterChip(
                            selected = freq == option,
                            onClick = { freq = option },
                            label = { Text(option.replaceFirstChar { it.uppercase() }) }
                        )
                    }
                }
                OutlinedTextField(
                    value = interval,
                    onValueChange = { if (it.all(Char::isDigit)) interval = it },
                    label = { Text("Every N ${freq}${if (interval != "1") "s" else ""}") },
                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
                    singleLine = true
                )
                if (freq == "weekly") {
                    Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
                        (0..6).forEach { day ->
                            FilterChip(
                                selected = weekdays.contains(day),
                                onClick = {
                                    weekdays = if (weekdays.contains(day)) weekdays - day else weekdays + day
                                },
                                label = { Text(weekdayAbbrev(day)) }
                            )
                        }
                    }
                }
            }
        },
        confirmButton = {
            TextButton(onClick = {
                onSave(freq, interval.toIntOrNull()?.coerceAtLeast(1) ?: 1, weekdays.sorted())
            }) { Text("Save") }
        },
        dismissButton = {
            Row {
                if (initial != null) {
                    TextButton(onClick = onClear) { Text("Clear") }
                }
                TextButton(onClick = onDismiss) { Text("Cancel") }
            }
        }
    )
}
```

- [ ] **Step 2: Replace `TaskDetailActivity.kt` in full**

Replace the entire contents of `android/app/src/main/java/org/terst/doot/widget/ui/TaskDetailActivity.kt` with:

```kotlin
package org.terst.doot.widget.ui

import android.content.Intent
import android.net.Uri
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.glance.appwidget.updateAll
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import okhttp3.OkHttpClient
import org.terst.doot.widget.data.Keys
import org.terst.doot.widget.data.TaskDetailResponse
import org.terst.doot.widget.data.TaskRecurrence
import org.terst.doot.widget.data.WidgetRepository
import org.terst.doot.widget.data.dataStore
import org.terst.doot.widget.work.CompleteWorker
import java.time.LocalDate
import java.time.format.DateTimeFormatter
import java.util.Calendar
import java.util.TimeZone

class TaskDetailActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val id = intent.getStringExtra(EXTRA_ID) ?: return finish()
        val source = intent.getStringExtra(EXTRA_SOURCE) ?: return finish()
        val initialTitle = intent.getStringExtra(EXTRA_TITLE) ?: ""
        val completable = intent.getBooleanExtra(EXTRA_COMPLETABLE, false)
        val initialDueDate = intent.getStringExtra(EXTRA_DUE_DATE)
        val isDoot = source == "doot"

        setContent {
            MaterialTheme(colorScheme = darkColorScheme()) {
                var title by remember { mutableStateOf(initialTitle) }
                var description by remember { mutableStateOf("") }
                var dueDate by remember { mutableStateOf(initialDueDate) }
                var recurrence by remember { mutableStateOf<TaskRecurrence?>(null) }
                var nextDate by remember { mutableStateOf<String?>(null) }

                suspend fun repo(): WidgetRepository? {
                    val prefs = this@TaskDetailActivity.dataStore.data.first()
                    val url = prefs[Keys.SERVER_URL]?.trimEnd('/') ?: return null
                    val token = prefs[Keys.TOKEN] ?: return null
                    return WidgetRepository(OkHttpClient(), url, token)
                }

                suspend fun refreshWidget() {
                    val r = repo() ?: return
                    r.fetchAndPersist(this@TaskDetailActivity)
                    DootWidget().updateAll(this@TaskDetailActivity)
                }

                if (isDoot) {
                    LaunchedEffect(id) {
                        repo()?.fetchTaskDetail(id)?.onSuccess { detail: TaskDetailResponse ->
                            title = detail.title
                            description = detail.description
                            dueDate = detail.dueDate
                            recurrence = detail.recurrence
                            nextDate = detail.nextDate
                        }
                    }
                }

                TaskDetailSheet(
                    title = title,
                    source = source,
                    completable = completable,
                    dueDate = dueDate,
                    isDoot = isDoot,
                    description = description,
                    recurrence = recurrence,
                    nextDate = nextDate,
                    onComplete = {
                        CompleteWorker.enqueue(this, id, source)
                        finish()
                    },
                    onReschedule = { dateISO ->
                        lifecycleScope.launch {
                            repo()?.reschedule(id, source, dateISO)?.onSuccess {
                                refreshWidget()
                                finish()
                            }
                        }
                    },
                    onSaveEdit = { newTitle, newDescription ->
                        lifecycleScope.launch {
                            repo()?.updateTask(id, newTitle, newDescription)?.onSuccess {
                                title = newTitle
                                description = newDescription
                                refreshWidget()
                            }
                        }
                    },
                    onSaveRecurrence = { freq, interval, weekdays ->
                        lifecycleScope.launch {
                            repo()?.setTaskRecurrence(id, freq, interval, weekdays)?.onSuccess {
                                repo()?.fetchTaskDetail(id)?.onSuccess { detail ->
                                    recurrence = detail.recurrence
                                    nextDate = detail.nextDate
                                }
                                refreshWidget()
                            }
                        }
                    },
                    onSaveNextDate = { dateISO ->
                        lifecycleScope.launch {
                            repo()?.setTaskNextDate(id, dateISO)?.onSuccess {
                                nextDate = dateISO
                                refreshWidget()
                            }
                        }
                    },
                    onOpenUrl = { url ->
                        startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
                    },
                    onDialPhone = { phone ->
                        startActivity(Intent(Intent.ACTION_DIAL, Uri.parse("tel:$phone")))
                    },
                    onDismiss = ::finish
                )
            }
        }
    }

    companion object {
        const val EXTRA_ID = "task_id"
        const val EXTRA_SOURCE = "task_source"
        const val EXTRA_TITLE = "task_title"
        const val EXTRA_COMPLETABLE = "task_completable"
        const val EXTRA_DUE_DATE = "task_due_date"
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun TaskDetailSheet(
    title: String,
    source: String,
    completable: Boolean,
    dueDate: String?,
    isDoot: Boolean,
    description: String,
    recurrence: TaskRecurrence?,
    nextDate: String?,
    onComplete: () -> Unit,
    onReschedule: (String) -> Unit,
    onSaveEdit: (title: String, description: String) -> Unit,
    onSaveRecurrence: (freq: String, interval: Int, weekdays: List<Int>) -> Unit,
    onSaveNextDate: (String) -> Unit,
    onOpenUrl: (String) -> Unit,
    onDialPhone: (String) -> Unit,
    onDismiss: () -> Unit
) {
    var isEditing by remember { mutableStateOf(false) }
    var editTitle by remember(title) { mutableStateOf(title) }
    var editDescription by remember(description) { mutableStateOf(description) }
    var showDatePicker by remember { mutableStateOf(false) }
    var showRecurrenceDialog by remember { mutableStateOf(false) }
    var showNextDatePicker by remember { mutableStateOf(false) }

    val datePickerState = rememberDatePickerState(initialSelectedDateMillis = System.currentTimeMillis())
    val nextDatePickerState = rememberDatePickerState(initialSelectedDateMillis = System.currentTimeMillis())

    if (showDatePicker) {
        DatePickerDialog(
            onDismissRequest = { showDatePicker = false },
            confirmButton = {
                TextButton(onClick = {
                    datePickerState.selectedDateMillis?.let { millis -> onReschedule(isoDateFromMillis(millis)) }
                    showDatePicker = false
                }) { Text("Set date") }
            },
            dismissButton = {
                TextButton(onClick = { showDatePicker = false }) { Text("Cancel") }
            }
        ) {
            DatePicker(state = datePickerState)
        }
    }

    if (showNextDatePicker) {
        DatePickerDialog(
            onDismissRequest = { showNextDatePicker = false },
            confirmButton = {
                TextButton(onClick = {
                    nextDatePickerState.selectedDateMillis?.let { millis -> onSaveNextDate(isoDateFromMillis(millis)) }
                    showNextDatePicker = false
                }) { Text("Set next date") }
            },
            dismissButton = {
                TextButton(onClick = { showNextDatePicker = false }) { Text("Cancel") }
            }
        ) {
            DatePicker(state = nextDatePickerState)
        }
    }

    if (showRecurrenceDialog) {
        RecurrenceEditDialog(
            initial = recurrence,
            onDismiss = { showRecurrenceDialog = false },
            onSave = { freq, interval, weekdays ->
                onSaveRecurrence(freq, interval, weekdays)
                showRecurrenceDialog = false
            },
            onClear = {
                onSaveRecurrence("", 1, emptyList())
                showRecurrenceDialog = false
            }
        )
    }

    ModalBottomSheet(
        onDismissRequest = onDismiss,
        sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true),
        containerColor = Color(0xFF1E293B),
        tonalElevation = 0.dp,
        dragHandle = {
            Box(
                modifier = Modifier
                    .padding(vertical = 12.dp)
                    .width(36.dp)
                    .height(4.dp)
                    .background(Color.White.copy(alpha = 0.25f), RoundedCornerShape(2.dp))
            )
        }
    ) {
        Column(
            modifier = Modifier
                .fillMaxWidth()
                .padding(horizontal = 20.dp)
                .navigationBarsPadding()
        ) {
            Row(verticalAlignment = androidx.compose.ui.Alignment.CenterVertically) {
                Box(
                    modifier = Modifier
                        .size(10.dp)
                        .background(sourceColor(source), RoundedCornerShape(5.dp))
                )
                Spacer(Modifier.width(10.dp))
                if (isEditing) {
                    OutlinedTextField(
                        value = editTitle,
                        onValueChange = { editTitle = it },
                        modifier = Modifier.weight(1f),
                        singleLine = true,
                        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done)
                    )
                } else {
                    Text(
                        text = title,
                        fontSize = 17.sp,
                        fontWeight = FontWeight.SemiBold,
                        color = Color.White,
                        modifier = Modifier.weight(1f)
                    )
                }
            }

            if (isDoot) {
                Spacer(Modifier.height(12.dp))
                Row(verticalAlignment = androidx.compose.ui.Alignment.CenterVertically) {
                    AssistChip(
                        onClick = { showDatePicker = true },
                        label = { Text(formatDueDateLabel(dueDate), fontSize = 13.sp) }
                    )
                    Spacer(Modifier.width(8.dp))
                    AssistChip(
                        onClick = { showRecurrenceDialog = true },
                        label = { Text(formatRecurrenceLabel(recurrence), fontSize = 13.sp) }
                    )
                    if (recurrence != null) {
                        Spacer(Modifier.width(8.dp))
                        AssistChip(
                            onClick = { showNextDatePicker = true },
                            label = { Text(formatNextDateLabel(nextDate), fontSize = 13.sp) }
                        )
                    }
                }

                Spacer(Modifier.height(16.dp))
                if (isEditing) {
                    OutlinedTextField(
                        value = editDescription,
                        onValueChange = { editDescription = it },
                        modifier = Modifier
                            .fillMaxWidth()
                            .heightIn(min = 100.dp),
                        placeholder = { Text("Description") }
                    )
                } else if (description.isNotEmpty()) {
                    LinkifiedText(
                        text = description,
                        modifier = Modifier.fillMaxWidth(),
                        onOpenUrl = onOpenUrl,
                        onDialPhone = onDialPhone
                    )
                }
            }

            Spacer(Modifier.height(20.dp))

            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                if (isDoot && isEditing) {
                    OutlinedButton(
                        onClick = {
                            editTitle = title
                            editDescription = description
                            isEditing = false
                        },
                        modifier = Modifier.weight(1f),
                        colors = ButtonDefaults.outlinedButtonColors(contentColor = Color.White),
                        border = androidx.compose.foundation.BorderStroke(1.dp, Color.White.copy(alpha = 0.3f))
                    ) { Text("Cancel") }
                    Button(
                        onClick = {
                            onSaveEdit(editTitle, editDescription)
                            isEditing = false
                        },
                        modifier = Modifier.weight(1f),
                        colors = ButtonDefaults.buttonColors(containerColor = Color(0xFF3B82F6)),
                        enabled = editTitle.isNotBlank()
                    ) { Text("Save") }
                } else {
                    if (isDoot) {
                        OutlinedButton(
                            onClick = { isEditing = true },
                            modifier = Modifier.weight(1f),
                            colors = ButtonDefaults.outlinedButtonColors(contentColor = Color.White),
                            border = androidx.compose.foundation.BorderStroke(1.dp, Color.White.copy(alpha = 0.3f))
                        ) { Text("Edit") }
                    }
                    if (completable) {
                        Button(
                            onClick = onComplete,
                            modifier = Modifier.weight(1f),
                            colors = ButtonDefaults.buttonColors(containerColor = Color(0xFF3B82F6))
                        ) { Text("Complete") }
                    }
                }
            }
            Spacer(Modifier.height(20.dp))
        }
    }
}

private fun formatDueDateLabel(dueDate: String?): String {
    if (dueDate == null) return "No due date · tap to schedule"
    return runCatching {
        val date = LocalDate.parse(dueDate.substring(0, 10))
        date.format(DateTimeFormatter.ofPattern("MMM d"))
    }.getOrDefault("No due date · tap to schedule")
}

private fun formatRecurrenceLabel(recurrence: TaskRecurrence?): String {
    if (recurrence == null) return "Set recurrence"
    val intervalPrefix = if (recurrence.interval > 1) "every ${recurrence.interval} " else ""
    val unit = when (recurrence.freq) {
        "daily" -> if (recurrence.interval > 1) "days" else "daily"
        "weekly" -> if (recurrence.interval > 1) "weeks" else "weekly"
        "monthly" -> if (recurrence.interval > 1) "months" else "monthly"
        "yearly" -> if (recurrence.interval > 1) "years" else "yearly"
        else -> recurrence.freq
    }
    val weekdaysSuffix = if (recurrence.freq == "weekly" && recurrence.weekdays.isNotEmpty()) {
        " on " + recurrence.weekdays.sorted().joinToString(", ") { weekdayAbbrev(it) }
    } else ""
    return "🔄 $intervalPrefix$unit$weekdaysSuffix"
}

private fun formatNextDateLabel(nextDate: String?): String {
    if (nextDate == null) return "Next: —"
    return runCatching {
        val date = LocalDate.parse(nextDate.substring(0, 10))
        "Next: " + date.format(DateTimeFormatter.ofPattern("MMM d"))
    }.getOrDefault("Next: —")
}

private fun isoDateFromMillis(millis: Long): String {
    val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
    cal.timeInMillis = millis
    return "%04d-%02d-%02d".format(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1, cal.get(Calendar.DAY_OF_MONTH))
}
```

- [ ] **Step 3: Run the full Android unit test suite**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest`
Expected: BUILD SUCCESSFUL, all tests pass (this task adds no new tests, but must not break any existing one — `formatDueDateLabel`/`isoDateFromMillis` are carried over unchanged from the original file).

- [ ] **Step 4: Commit**

```bash
cd /workspace/doot
git add android/app/src/main/java/org/terst/doot/widget/ui/TaskDetailActivity.kt android/app/src/main/java/org/terst/doot/widget/ui/RecurrenceEditDialog.kt
git commit -m "feat(widget): redesign task detail popup with editing and recurrence

Editable title/description (Edit -> Cancel/Save toggle), linkified
description, and independently-tappable date/recurrence/next-date
chips. Non-doot sources (Trello, Google Tasks) are unaffected --
same title + Complete button as before, no live fetch, no edit UI."
```

---

### Task 9: Build, test, deploy

**Files:** none (build/deploy/docs only).

- [ ] **Step 1: Run the full Go test suite**

Run: `cd /workspace/doot && go build ./... && go test ./internal/... ./cmd/...`
Expected: `go build` succeeds. `go test` passes except the two pre-existing, unrelated `internal/handlers` failures and the pre-existing `internal/models` build failure — all confirmed present before this feature.

- [ ] **Step 2: Run the full Android unit test suite**

Run: `cd /workspace/doot/android && ./gradlew testDebugUnitTest`
Expected: BUILD SUCCESSFUL.

- [ ] **Step 3: Deploy the Go server**

Run: `cd /workspace/doot && ./scripts/deploy`
Expected: script completes through "Deploy complete!" — this also runs the new migration (`023_native_task_recurrence.sql`) against the live database via the existing migration-runner startup path, and starts the new 15-minute recurrence-check goroutine.

- [ ] **Step 4: Build and deploy the Android APK**

Run: `cd /workspace/doot/android && ./gradlew assembleRelease`
Expected: BUILD SUCCESSFUL.

Confirm the build is actually fresh before deploying (this project's Gradle setup has intermittently served a stale cached APK this session without `--rerun-tasks`):

Run: `ls -la /workspace/doot/android/app/build/outputs/apk/release/app-release.apk` and note the timestamp is from *this* build, not an earlier one this session. If it looks stale, re-run with `./gradlew assembleRelease --rerun-tasks`.

Run: `md5sum /workspace/doot/android/app/build/outputs/apk/release/app-release.apk /site/static.terst.org/public/files/doot-widget.apk`
Expected: checksums differ (proves this is a new build).

Run: `cp /workspace/doot/android/app/build/outputs/apk/release/app-release.apk /site/static.terst.org/public/files/doot-widget.apk`

- [ ] **Step 5: Update the project worklog**

Per `.agent/config.md`'s Worklog Integrity mandate, append a short entry to `/workspace/doot/.agent/worklog.md`'s "Recently Completed" section describing the recurrence feature (server-owned iteration creation, two triggers) and the task-detail popup redesign (editable title/description, linkified URLs/phone numbers, tappable date/recurrence/next-date chips).

- [ ] **Step 6: Manual verification**

No `adb`/emulator in this environment. For the user, after Steps 3-4:
- Open a doot-native task's detail popup. Confirm the date/recurrence/next-date chips appear and are independently tappable.
- Set a weekly recurrence with specific weekdays (e.g. Mon/Wed/Fri). Confirm the chip updates to show it and a next-date chip appears.
- Tap Edit, change the title and description (include a URL and a phone number in the description), Save. Confirm the popup reflects the change and the underlined URL/phone number are tappable (URL opens a browser, phone number opens the dialer).
- Complete the recurring task. Confirm a new task appears with the due date advanced to the next occurrence, and the completed one stays completed in history.
- Confirm a Trello or Google Tasks card's popup is completely unchanged (no Edit button, no chips, no description) — this scope should never have been touched by this work.