docs(phase-07): complete phase execution

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
docs(07-02): complete sort dropdown UI plan
2026-03-16 22:43:41 +01:00 · 2026-03-16 22:40:39 +01:00 · 2026-03-16 22:39:18 +01:00 · 2026-03-16 22:37:18 +01:00 · 2026-03-16 22:35:01 +01:00 · 2026-03-16 22:33:34 +01:00
31 changed files with 2170 additions and 73 deletions
--- a/.gitea/workflows/release.yaml
+++ b/.gitea/workflows/release.yaml
@@ -132,9 +132,27 @@ jobs:
          -mkdir dev/fdroid/repo
          SFTP

-          # Try to download the existing repo/ folder from Hetzner to keep older versions and the keystore.
+          # Try to download the entire fdroid/ directory from Hetzner to keep
+          # older APKs, the repo keystore, and config.yml across runs.
          # If it fails (first time), initialize a new local repo.
-          sshpass -p "$PASS" scp -o StrictHostKeyChecking=no -r "$USER@$HOST:dev/fdroid/repo" fdroid/ || (cd fdroid && fdroid init)
+          sshpass -p "$PASS" scp -o StrictHostKeyChecking=no -r "$USER@$HOST:dev/fdroid/." fdroid/ || (cd fdroid && fdroid init)
+
+      - name: Ensure F-Droid repo signing key and icon
+        run: |
+          cd fdroid
+
+          # Ensure repo icon exists (use app launcher icon)
+          mkdir -p repo/icons
+          if [ ! -f repo/icons/icon.png ]; then
+            cp ../android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png repo/icons/icon.png
+          fi
+
+          # If keystore doesn't exist, create the signing key.
+          # This only runs on the very first deployment; subsequent runs
+          # download the keystore from Hetzner via the scp step above.
+          if [ ! -f keystore.p12 ]; then
+            fdroid update --create-key
+          fi

      - name: Copy new APK to repo
        run: |
@@ -162,7 +180,6 @@ jobs:
          PASS: ${{ secrets.HETZNER_PASS }}
        run: |
          set -euo pipefail
-          REMOTE_REPO_DIR="dev/fdroid/repo"
          SSH_OPTS="-o StrictHostKeyChecking=no -o ConnectTimeout=20"

          # Create remote directory tree via SFTP batch (no exec channel needed).
@@ -173,5 +190,6 @@ jobs:
          -mkdir dev/fdroid/repo
          SFTP

-          # Upload all files from fdroid/repo into the remote directory.
-          sshpass -p "$PASS" scp $SSH_OPTS -r fdroid/repo/. "$USER@$HOST:$REMOTE_REPO_DIR/"
+          # Upload the entire fdroid/ directory (repo + keystore + config)
+          # so the signing key persists across runs.
+          sshpass -p "$PASS" scp $SSH_OPTS -r fdroid/. "$USER@$HOST:dev/fdroid/"
--- a/.planning/REQUIREMENTS.md
+++ b/.planning/REQUIREMENTS.md
@@ -17,14 +17,14 @@ Requirements for milestone v1.1 Calendar & Polish. Each maps to roadmap phases.

 ### Task History

- [ ] **HIST-01**: Each task completion is recorded with a timestamp
- [ ] **HIST-02**: User can view past completion dates for any individual task
+- [x] **HIST-01**: Each task completion is recorded with a timestamp
+- [x] **HIST-02**: User can view past completion dates for any individual task

 ### Task Sorting

- [ ] **SORT-01**: User can sort tasks alphabetically
- [ ] **SORT-02**: User can sort tasks by frequency interval
- [ ] **SORT-03**: User can sort tasks by effort level
+- [x] **SORT-01**: User can sort tasks alphabetically
+- [x] **SORT-02**: User can sort tasks by frequency interval
+- [x] **SORT-03**: User can sort tasks by effort level

 ## Future Requirements

@@ -65,11 +65,11 @@ Which phases cover which requirements. Updated during roadmap creation.
 | CAL-03 | Phase 5 | Complete |
 | CAL-04 | Phase 5 | Complete |
 | CAL-05 | Phase 5 | Complete |
-| HIST-01 | Phase 6 | Pending |
-| HIST-02 | Phase 6 | Pending |
-| SORT-01 | Phase 7 | Pending |
-| SORT-02 | Phase 7 | Pending |
-| SORT-03 | Phase 7 | Pending |
+| HIST-01 | Phase 6 | Complete |
+| HIST-02 | Phase 6 | Complete |
+| SORT-01 | Phase 7 | Complete |
+| SORT-02 | Phase 7 | Complete |
+| SORT-03 | Phase 7 | Complete |

 **Coverage:**
 - v1.1 requirements: 10 total
--- a/.planning/ROADMAP.md
+++ b/.planning/ROADMAP.md
@@ -22,8 +22,8 @@ See `milestones/v1.0-ROADMAP.md` for full phase details.
 **v1.1 Calendar & Polish (Phases 5-7):**

 - [x] **Phase 5: Calendar Strip** - Replace the stacked daily plan home screen with a horizontal scrollable date-strip and day-task list (completed 2026-03-16)
- [ ] **Phase 6: Task History** - Record every task completion with a timestamp and expose a per-task history view
- [ ] **Phase 7: Task Sorting** - Add alphabetical, interval, and effort sort options to task lists
+- [x] **Phase 6: Task History** - Record every task completion with a timestamp and expose a per-task history view (completed 2026-03-16)
+- [x] **Phase 7: Task Sorting** - Add alphabetical, interval, and effort sort options to task lists (completed 2026-03-16)

 ## Phase Details

@@ -50,7 +50,7 @@ Plans:
  1. Every task completion (tap done in any view) is recorded in the database with a precise timestamp — data persists across app restarts
  2. From a task's detail or context menu the user can open a history view listing all past completion dates for that task in reverse-chronological order
  3. The history view shows a meaningful empty state if the task has never been completed
-**Plans:** 1 plan
+**Plans:** 1/1 plans complete
 Plans:
 - [ ] 06-01-PLAN.md — DAO query + history bottom sheet + TaskFormScreen integration + CalendarTaskRow navigation

@@ -63,7 +63,10 @@ Plans:
  2. Selecting alphabetical sort orders tasks A-Z by name within the visible list
  3. Selecting interval sort orders tasks from most-frequent (daily) to least-frequent (yearly/custom) intervals
  4. Selecting effort sort orders tasks from lowest effort to highest effort level
-**Plans**: TBD
+**Plans:** 2/2 plans complete
+Plans:
+- [ ] 07-01-PLAN.md — Sort model, persistence notifier, localization, provider integration
+- [ ] 07-02-PLAN.md — Sort dropdown widget, HomeScreen AppBar, TaskListScreen integration, tests

 ## Progress

@@ -74,5 +77,5 @@ Plans:
 | 3. Daily Plan and Cleanliness | v1.0 | 3/3 | Complete | 2026-03-16 |
 | 4. Notifications | v1.0 | 3/3 | Complete | 2026-03-16 |
 | 5. Calendar Strip | 2/2 | Complete   | 2026-03-16 | - |
-| 6. Task History | v1.1 | 0/1 | Planned | - |
-| 7. Task Sorting | v1.1 | 0/? | Not started | - |
+| 6. Task History | 1/1 | Complete   | 2026-03-16 | - |
+| 7. Task Sorting | 2/2 | Complete   | 2026-03-16 | - |
--- a/.planning/STATE.md
+++ b/.planning/STATE.md
@@ -3,14 +3,14 @@ gsd_state_version: 1.0
 milestone: v1.0
 milestone_name: milestone
 status: completed
-stopped_at: Phase 6 context gathered
-last_updated: "2026-03-16T20:46:23.402Z"
-last_activity: 2026-03-16 — Completed Phase 5 Plan 02 (calendar strip UI)
+stopped_at: Completed 07-task-sorting/07-02-PLAN.md
+last_updated: "2026-03-16T21:43:23.009Z"
+last_activity: 2026-03-16 — Completed Phase 6 Plan 01 (task completion history)
 progress:
  total_phases: 3
-  completed_phases: 1
-  total_plans: 2
-  completed_plans: 2
+  completed_phases: 3
+  total_plans: 5
+  completed_plans: 5
  percent: 100
 ---

@@ -21,17 +21,17 @@ progress:
 See: .planning/PROJECT.md (updated 2026-03-16)

 **Core value:** Users can see what needs doing today, mark it done, and trust the app to schedule the next occurrence — without thinking about it.
-**Current focus:** v1.1 Calendar & Polish — Phase 5: Calendar Strip
+**Current focus:** v1.1 Calendar & Polish — Phase 6: Task History

 ## Current Position

-Phase: 5 — Calendar Strip
-Plan: 2/2 complete (Phase 5 done)
+Phase: 6 — Task History
+Plan: 1/1 complete (Phase 6 done)
 Status: Phase Complete
-Last activity: 2026-03-16 — Completed Phase 5 Plan 02 (calendar strip UI)
+Last activity: 2026-03-16 — Completed Phase 6 Plan 01 (task completion history)

 ```
-Progress: [██████████] 100% (2/2 plans in Phase 5)
+Progress: [██████████] 100% (1/1 plans in Phase 6)
 ```

 ## Performance Metrics
@@ -44,6 +44,9 @@ Progress: [██████████] 100% (2/2 plans in Phase 5)
 | Tests | 89 | TBD |
 | Phase 05-calendar-strip P01 | 5 | 2 tasks | 10 files |
 | Phase 05-calendar-strip P02 | 8 | 3 tasks | 9 files |
+| Phase 06-task-history P01 | 5 | 2 tasks | 9 files |
+| Phase 07-task-sorting P01 | 4 | 2 tasks | 9 files |
+| Phase 07-task-sorting P02 | 4 | 2 tasks | 5 files |

 ## Accumulated Context

@@ -60,6 +63,13 @@ Progress: [██████████] 100% (2/2 plans in Phase 5)
 | watchTasksForDate sorts alphabetically by task name | Same-day tasks have no meaningful time-based order; alpha sort is deterministic and user-friendly |
 | CalendarStripController as VoidCallback holder | Avoids GlobalKey for single imperative scroll-to-today action — simpler |
 | Tests use pump()+pump(Duration) instead of pumpAndSettle() | CalendarStrip animation controllers cause pumpAndSettle timeout — fixed-duration pump steps are reliable |
+| No separate Riverpod provider for history sheet | ref.read(appDatabaseProvider) directly in ConsumerWidget — one-shot modals do not need a dedicated provider |
+| CalendarTaskRow onTap navigates to task edit form | Makes history accessible in one tap from home screen, consistent with GoRouter route patterns |
+- [Phase 07-task-sorting]: Default sort is alphabetical — continuity with existing A-Z SQL sort in CalendarDayList
+- [Phase 07-task-sorting]: overdueTasks are NOT sorted — pinned at top in existing order per design decision
+- [Phase 07-task-sorting]: Sort preference stored as enum.name string in SharedPreferences (not intEnum) — enum reordering safe
+- [Phase 07-task-sorting]: Used PopupMenuButton for SortDropdown in AppBar — menu overlay vs inline expansion, Material 3 pattern
+- [Phase 07-task-sorting]: HomeScreen uses nested Scaffold for AppBar — standard StatefulShellRoute.indexedStack per-tab AppBar pattern

 ### Pending Todos

@@ -71,7 +81,7 @@ None.

 ## Session Continuity

-Last session: 2026-03-16T20:46:23.400Z
-Stopped at: Phase 6 context gathered
-Resume file: .planning/phases/06-task-history/06-CONTEXT.md
-Next action: `/gsd:plan-phase 5`
+Last session: 2026-03-16T21:40:24.556Z
+Stopped at: Completed 07-task-sorting/07-02-PLAN.md
+Resume file: None
+Next action: Phase 7 (task sorting) or release
--- a/.planning/phases/06-task-history/06-01-SUMMARY.md
+++ b/.planning/phases/06-task-history/06-01-SUMMARY.md
@@ -0,0 +1,131 @@
+---
+phase: 06-task-history
+plan: 01
+subsystem: database, ui
+tags: [drift, flutter, riverpod, go_router, intl, bottom-sheet, stream]
+
+# Dependency graph
+requires:
+  - phase: 05-calendar-strip
+    provides: CalendarTaskRow widget and CalendarDayList that render tasks in the home screen
+provides:
+  - watchCompletionsForTask(taskId) DAO stream on TasksDao — sorted newest-first
+  - task_history_sheet.dart with showTaskHistorySheet() function
+  - Verlauf ListTile in TaskFormScreen (edit mode) opening history bottom sheet
+  - CalendarTaskRow onTap navigation to TaskFormScreen for the tapped task
+affects: [07-task-sorting, future-phases-using-TaskFormScreen]
+
+# Tech tracking
+tech-stack:
+  added: []
+  patterns:
+    - "Bottom sheet follows icon_picker_sheet pattern: showModalBottomSheet with isScrollControlled, ConsumerWidget inside, SafeArea > Padding > Column(mainAxisSize.min)"
+    - "StreamBuilder on DAO stream directly accessed via ref.read(appDatabaseProvider).tasksDao.methodName (no separate Riverpod provider for one-shot modals)"
+    - "TDD: RED test commit followed by GREEN implementation commit"
+
+key-files:
+  created:
+    - lib/features/tasks/presentation/task_history_sheet.dart
+    - test/features/tasks/data/task_history_dao_test.dart
+  modified:
+    - lib/features/tasks/data/tasks_dao.dart
+    - lib/features/tasks/data/tasks_dao.g.dart
+    - lib/features/tasks/presentation/task_form_screen.dart
+    - lib/features/home/presentation/calendar_task_row.dart
+    - lib/l10n/app_de.arb
+    - lib/l10n/app_localizations.dart
+    - lib/l10n/app_localizations_de.dart
+
+key-decisions:
+  - "No separate Riverpod provider for history sheet — ref.read(appDatabaseProvider) directly in ConsumerWidget keeps it simple for a one-shot modal"
+  - "CalendarTaskRow onTap routes to /rooms/:roomId/tasks/:taskId so history is always one tap away from the home screen"
+  - "Count summary line shown above list when completions > 0; not shown for empty state"
+
+patterns-established:
+  - "History sheet: showModalBottomSheet returning Future<void>, ConsumerWidget sheet with StreamBuilder on DAO stream"
+  - "Edit-mode-only ListTile pattern: if (widget.isEditing) [...] in TaskFormScreen ListView children"
+
+requirements-completed: [HIST-01, HIST-02]
+
+# Metrics
+duration: 5min
+completed: 2026-03-16
+---
+
+# Phase 6 Plan 1: Task History Summary
+
+**Drift DAO stream for task completion history, bottom sheet with reverse-chronological German-formatted dates, wired from CalendarTaskRow tap through TaskFormScreen Verlauf button**
+
+## Performance
+
+- **Duration:** 5 min
+- **Started:** 2026-03-16T20:52:49Z
+- **Completed:** 2026-03-16T20:57:19Z
+- **Tasks:** 2 (Task 1 TDD: RED + GREEN + localization; Task 2: sheet + wiring + navigation)
+- **Files modified:** 9
+
+## Accomplishments
+- `watchCompletionsForTask(int taskId)` added to TasksDao: returns `Stream<List<TaskCompletion>>` sorted by completedAt DESC
+- Task history bottom sheet (`task_history_sheet.dart`) with StreamBuilder, empty state, German date/time formatting via intl
+- Verlauf ListTile added to TaskFormScreen edit mode, opens history sheet on tap
+- CalendarTaskRow gains `onTap` that navigates via GoRouter to the task edit form, making history one tap away from the calendar
+
+## Task Commits
+
+Each task was committed atomically:
+
+1. **RED - Failing DAO tests** - `2687f5e` (test)
+2. **Task 1: DAO method, localization** - `ceae7d7` (feat)
+3. **Task 2: History sheet, form wiring, navigation** - `9f902ff` (feat)
+
+**Plan metadata:** (docs commit — see below)
+
+_Note: TDD tasks have separate RED (test) and GREEN (feat) commits_
+
+## Files Created/Modified
+- `lib/features/tasks/data/tasks_dao.dart` - Added watchCompletionsForTask stream method
+- `lib/features/tasks/data/tasks_dao.g.dart` - Regenerated by build_runner
+- `lib/features/tasks/presentation/task_history_sheet.dart` - New: bottom sheet with StreamBuilder, empty state, completion list
+- `lib/features/tasks/presentation/task_form_screen.dart` - Added Verlauf ListTile in edit mode
+- `lib/features/home/presentation/calendar_task_row.dart` - Added onTap navigation to task edit form
+- `lib/l10n/app_de.arb` - Added taskHistoryTitle, taskHistoryEmpty, taskHistoryCount strings
+- `lib/l10n/app_localizations.dart` - Regenerated (abstract class updated)
+- `lib/l10n/app_localizations_de.dart` - Regenerated (German implementation updated)
+- `test/features/tasks/data/task_history_dao_test.dart` - New: 5 tests covering empty state, single/multiple completions, task isolation, stream reactivity
+
+## Decisions Made
+- No separate Riverpod provider for history sheet: `ref.read(appDatabaseProvider).tasksDao.watchCompletionsForTask(taskId)` directly in the ConsumerWidget. One-shot modals do not need a dedicated provider.
+- CalendarTaskRow navigation uses `context.go('/rooms/.../tasks/...')` consistent with existing GoRouter route patterns.
+- Removed unused `import 'package:drift/drift.dart'` from test file (Rule 1 auto-fix during GREEN verification).
+
+## Deviations from Plan
+
+### Auto-fixed Issues
+
+**1. [Rule 1 - Bug] Removed unused import from test file**
+- **Found during:** Task 1 (GREEN phase, flutter analyze)
+- **Issue:** `import 'package:drift/drift.dart'` was copied from the existing tasks_dao_test.dart pattern but not needed in the new history test file (no `Value()` usage)
+- **Fix:** Removed the unused import line
+- **Files modified:** test/features/tasks/data/task_history_dao_test.dart
+- **Verification:** flutter analyze reports zero issues
+- **Committed in:** ceae7d7 (Task 1 feat commit)
+
+---
+
+**Total deviations:** 1 auto-fixed (1 bug — unused import)
+**Impact on plan:** Trivial cleanup. No scope creep.
+
+## Issues Encountered
+None — plan executed smoothly. All 106 tests pass (101 pre-existing + 5 new DAO tests), zero analyze issues.
+
+## User Setup Required
+None - no external service configuration required.
+
+## Next Phase Readiness
+- Phase 6 Plan 1 complete. Task history is fully functional.
+- Phase 7 (task sorting) can proceed independently.
+- No blockers.
+
+---
+*Phase: 06-task-history*
+*Completed: 2026-03-16*
--- a/.planning/phases/06-task-history/6-VERIFICATION.md
+++ b/.planning/phases/06-task-history/6-VERIFICATION.md
@@ -0,0 +1,114 @@
+---
+phase: 06-task-history
+verified: 2026-03-16T22:15:00Z
+status: passed
+score: 3/3 must-haves verified
+re_verification: false
+---
+
+# Phase 6: Task History Verification Report
+
+**Phase Goal:** Users can see exactly when each task was completed in the past, building trust that the scheduling loop is working correctly
+**Verified:** 2026-03-16T22:15:00Z
+**Status:** PASSED
+**Re-verification:** No — initial verification
+
+---
+
+## Goal Achievement
+
+### Observable Truths
+
+| # | Truth | Status | Evidence |
+|---|-------|--------|----------|
+| 1 | Every task completion is recorded with a timestamp and persists across app restarts | VERIFIED | `watchCompletionsForTask` reads from `TaskCompletions` table (persistent SQLite); `completeTask` already wrote timestamps; 5 DAO tests confirm stream returns correct data including stream reactivity test |
+| 2 | User can open a history view from the task edit form showing all past completion dates in reverse-chronological order | VERIFIED | `task_form_screen.dart` lines 192-204: `if (widget.isEditing)` guard shows `ListTile` with `onTap: () => showTaskHistorySheet(...)`. Sheet uses `StreamBuilder` on `watchCompletionsForTask` with `..orderBy([(c) => OrderingTerm.desc(c.completedAt)])`, renders dates as `dd.MM.yyyy` + `HH:mm` via intl |
+| 3 | History view shows a meaningful empty state if the task has never been completed | VERIFIED | `task_history_sheet.dart` lines 70-87: `if (completions.isEmpty)` branch renders `Icon(Icons.history, size: 48)` + `Text(l10n.taskHistoryEmpty)` ("Noch nie erledigt") |
+
+**Score:** 3/3 truths verified
+
+---
+
+### Required Artifacts
+
+| Artifact | Provides | Status | Details |
+|----------|---------|--------|---------|
+| `lib/features/tasks/data/tasks_dao.dart` | `watchCompletionsForTask(int taskId)` stream method | VERIFIED | Method exists at line 85, returns `Stream<List<TaskCompletion>>`, ordered by `completedAt DESC`, 110 lines total |
+| `lib/features/tasks/presentation/task_history_sheet.dart` | Bottom sheet displaying task completion history | VERIFIED | 137 lines, exports top-level `showTaskHistorySheet()`, `_TaskHistorySheet` is a `ConsumerWidget` with full StreamBuilder, empty state, date list |
+| `lib/features/tasks/presentation/task_form_screen.dart` | Verlauf button in edit mode opening history sheet | VERIFIED | Imports `task_history_sheet.dart` (line 13), `showTaskHistorySheet` called at line 199, guarded by `if (widget.isEditing)` |
+| `lib/features/home/presentation/calendar_task_row.dart` | onTap navigation to task edit form | VERIFIED | `ListTile.onTap` at line 39 calls `context.go('/rooms/${taskWithRoom.roomId}/tasks/${taskWithRoom.task.id}')` |
+| `test/features/tasks/data/task_history_dao_test.dart` | Tests for completion history DAO query | VERIFIED | 158 lines, 5 tests: empty state, single completion, multiple reverse-chronological, task isolation, stream reactivity — all pass |
+| `lib/features/tasks/data/tasks_dao.g.dart` | Drift-generated mixin (build_runner output) | VERIFIED | Exists, 25 lines, regenerated with `taskCompletions` table accessor present |
+
+---
+
+### Key Link Verification
+
+| From | To | Via | Status | Details |
+|------|----|-----|--------|---------|
+| `task_form_screen.dart` | `task_history_sheet.dart` | `showTaskHistorySheet` call in Verlauf `onTap` | WIRED | Import at line 13; called at line 199 inside `if (widget.isEditing)` block |
+| `task_history_sheet.dart` | `tasks_dao.dart` | `watchCompletionsForTask` stream consumption | WIRED | `ref.read(appDatabaseProvider).tasksDao.watchCompletionsForTask(taskId)` at lines 59-62; stream result consumed by `StreamBuilder` builder |
+| `calendar_task_row.dart` | `TaskFormScreen` | GoRouter navigation on row tap | WIRED | `context.go('/rooms/${taskWithRoom.roomId}/tasks/${taskWithRoom.task.id}')` at line 39-41; route `/rooms/:roomId/tasks/:taskId` resolves to `TaskFormScreen` per router.dart |
+
+---
+
+### Requirements Coverage
+
+| Requirement | Source Plan | Description | Status | Evidence |
+|-------------|------------|-------------|--------|----------|
+| HIST-01 | 06-01-PLAN.md | Each task completion is recorded with a timestamp | SATISFIED | `TasksDao.completeTask()` inserts into `TaskCompletions` (pre-existing); `watchCompletionsForTask` surfaces data; 5 DAO tests confirm timestamps are stored and retrieved correctly |
+| HIST-02 | 06-01-PLAN.md | User can view past completion dates for any individual task | SATISFIED | Full UI chain: `CalendarTaskRow.onTap` -> `TaskFormScreen` (edit mode) -> "Verlauf" `ListTile` -> `showTaskHistorySheet` -> `_TaskHistorySheet` StreamBuilder showing reverse-chronological German-formatted dates |
+
+No orphaned requirements — REQUIREMENTS.md Traceability table shows only HIST-01 and HIST-02 mapped to Phase 6, both accounted for and marked Complete.
+
+---
+
+### Anti-Patterns Found
+
+None. No TODOs, FIXMEs, placeholder returns, empty handlers, or stub implementations found in any of the 5 modified source files.
+
+---
+
+### Human Verification Required
+
+#### 1. Tap-to-edit navigation in running app
+
+**Test:** Launch app, ensure at least one task exists on the calendar, tap the task row (not the checkbox).
+**Expected:** App navigates to `TaskFormScreen` in edit mode showing the task's fields and a "Verlauf" row at the bottom.
+**Why human:** GoRouter navigation with `context.go` cannot be verified by static analysis; requires runtime rendering.
+
+#### 2. History sheet opens with correct content
+
+**Test:** In `TaskFormScreen` edit mode, tap the "Verlauf" ListTile.
+**Expected:** Bottom sheet slides up showing either: (a) the empty state with a history icon and "Noch nie erledigt", or (b) a list of past completions with `dd.MM.yyyy` dates as titles and `HH:mm` times as subtitles, newest first.
+**Why human:** `showModalBottomSheet` rendering and visual layout cannot be verified by static analysis.
+
+#### 3. Live update after completing a task
+
+**Test:** Complete a task via checkbox in the calendar, then navigate to that task's edit form and tap "Verlauf".
+**Expected:** The newly recorded completion appears at the top of the history sheet with today's date and approximate current time.
+**Why human:** Real-time stream reactivity through the full UI stack (checkbox -> DAO write -> stream emit -> sheet UI update) requires runtime observation.
+
+---
+
+### Verification Summary
+
+All automated checks passed with no gaps found.
+
+**Test suite:** 106/106 tests pass (101 pre-existing + 5 new DAO tests covering all specified behaviors).
+**Static analysis:** `flutter analyze --no-fatal-infos` — zero issues.
+**Commits verified:** All three phase commits exist (`2687f5e`, `ceae7d7`, `9f902ff`) with expected file changes.
+
+The full feature chain is intact:
+- `TaskCompletions` table stores timestamps (HIST-01, pre-existing from data layer)
+- `watchCompletionsForTask` surfaces completions as a live Drift stream
+- `task_history_sheet.dart` renders them in German locale with reverse-chronological ordering and a meaningful empty state
+- `TaskFormScreen` (edit mode only) provides the "Verlauf" entry point
+- `CalendarTaskRow` onTap makes history reachable from the home calendar in two taps
+
+Three human-only items remain for final sign-off: tap navigation, sheet rendering, and live update after completion.
+
+---
+
+_Verified: 2026-03-16T22:15:00Z_
+_Verifier: Claude (gsd-verifier)_
--- a/.planning/phases/07-task-sorting/07-01-PLAN.md
+++ b/.planning/phases/07-task-sorting/07-01-PLAN.md
@@ -0,0 +1,276 @@
+---
+phase: 07-task-sorting
+plan: 01
+type: execute
+wave: 1
+depends_on: []
+files_modified:
+  - lib/features/tasks/domain/task_sort_option.dart
+  - lib/features/tasks/presentation/sort_preference_notifier.dart
+  - lib/features/tasks/presentation/sort_preference_notifier.g.dart
+  - lib/l10n/app_de.arb
+  - lib/l10n/app_localizations.dart
+  - lib/l10n/app_localizations_de.dart
+  - lib/features/home/presentation/calendar_providers.dart
+  - lib/features/tasks/presentation/task_providers.dart
+  - test/features/tasks/presentation/sort_preference_notifier_test.dart
+autonomous: true
+requirements: [SORT-01, SORT-02, SORT-03]
+
+must_haves:
+  truths:
+    - "Sort preference persists across app restarts"
+    - "CalendarDayList tasks are sorted according to the active sort preference"
+    - "TaskListScreen tasks are sorted according to the active sort preference"
+    - "Default sort is alphabetical (matches current CalendarDayList behavior)"
+  artifacts:
+    - path: "lib/features/tasks/domain/task_sort_option.dart"
+      provides: "TaskSortOption enum with alphabetical, interval, effort values"
+      exports: ["TaskSortOption"]
+    - path: "lib/features/tasks/presentation/sort_preference_notifier.dart"
+      provides: "SortPreferenceNotifier with SharedPreferences persistence"
+      exports: ["SortPreferenceNotifier", "sortPreferenceProvider"]
+    - path: "lib/features/home/presentation/calendar_providers.dart"
+      provides: "calendarDayProvider sorts dayTasks by active sort preference"
+      contains: "sortPreferenceProvider"
+    - path: "lib/features/tasks/presentation/task_providers.dart"
+      provides: "tasksInRoomProvider sorts tasks by active sort preference"
+      contains: "sortPreferenceProvider"
+    - path: "test/features/tasks/presentation/sort_preference_notifier_test.dart"
+      provides: "Unit tests for sort preference persistence and default"
+  key_links:
+    - from: "lib/features/home/presentation/calendar_providers.dart"
+      to: "sortPreferenceProvider"
+      via: "ref.watch in calendarDayProvider"
+      pattern: "ref\\.watch\\(sortPreferenceProvider\\)"
+    - from: "lib/features/tasks/presentation/task_providers.dart"
+      to: "sortPreferenceProvider"
+      via: "ref.watch in tasksInRoomProvider"
+      pattern: "ref\\.watch\\(sortPreferenceProvider\\)"
+---
+
+<objective>
+Create the task sort domain model, SharedPreferences-backed persistence provider, and integrate sort logic into both task list providers (calendarDayProvider and tasksInRoomProvider).
+
+Purpose: Establishes the data layer and sort logic so that task lists react to sort preference changes. The UI plan (07-02) will add the dropdown widget that writes to this provider.
+
+Output: TaskSortOption enum, SortPreferenceNotifier, updated calendarDayProvider and tasksInRoomProvider with in-memory sorting, German localization strings for sort labels.
+</objective>
+
+<execution_context>
+@/home/jlmak/.claude/get-shit-done/workflows/execute-plan.md
+@/home/jlmak/.claude/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+@.planning/phases/07-task-sorting/07-CONTEXT.md
+
+<interfaces>
+<!-- Key types and contracts the executor needs. Extracted from codebase. -->
+
+From lib/features/tasks/domain/effort_level.dart:
+```dart
+enum EffortLevel {
+  low, // 0
+  medium, // 1
+  high, // 2
+}
+```
+
+From lib/features/tasks/domain/frequency.dart:
+```dart
+enum IntervalType {
+  daily, // 0
+  everyNDays, // 1
+  weekly, // 2
+  biweekly, // 3
+  monthly, // 4
+  everyNMonths, // 5
+  quarterly, // 6
+  yearly, // 7
+}
+```
+
+From lib/features/home/domain/daily_plan_models.dart:
+```dart
+class TaskWithRoom {
+  final Task task;
+  final String roomName;
+  final int roomId;
+}
+```
+
+From lib/features/home/domain/calendar_models.dart:
+```dart
+class CalendarDayState {
+  final DateTime selectedDate;
+  final List<TaskWithRoom> dayTasks;
+  final List<TaskWithRoom> overdueTasks;
+  final int totalTaskCount;
+}
+```
+
+From lib/core/theme/theme_provider.dart (pattern to follow for SharedPreferences notifier):
+```dart
+@riverpod
+class ThemeNotifier extends _$ThemeNotifier {
+  @override
+  ThemeMode build() {
+    _loadPersistedThemeMode();
+    return ThemeMode.system; // sync default, async load overrides
+  }
+  Future<void> _loadPersistedThemeMode() async { ... }
+  Future<void> setThemeMode(ThemeMode mode) async {
+    state = mode;
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_themeModeKey, _themeModeToString(mode));
+  }
+}
+```
+
+From lib/features/home/presentation/calendar_providers.dart:
+```dart
+final calendarDayProvider = StreamProvider.autoDispose<CalendarDayState>((ref) {
+  final db = ref.watch(appDatabaseProvider);
+  final selectedDate = ref.watch(selectedDateProvider);
+  // ... fetches dayTasks, overdueTasks, totalTaskCount
+  // dayTasks come from watchTasksForDate which sorts alphabetically in SQL
+});
+```
+
+From lib/features/tasks/presentation/task_providers.dart:
+```dart
+final tasksInRoomProvider = StreamProvider.family.autoDispose<List<Task>, int>((ref, roomId) {
+  final db = ref.watch(appDatabaseProvider);
+  return db.tasksDao.watchTasksInRoom(roomId);
+  // watchTasksInRoom sorts by nextDueDate in SQL
+});
+```
+
+From lib/core/database/database.dart (Task table columns relevant to sorting):
+```dart
+class Tasks extends Table {
+  TextColumn get name => text().withLength(min: 1, max: 200)();
+  IntColumn get intervalType => intEnum<IntervalType>()();
+  IntColumn get intervalDays => integer().withDefault(const Constant(1))();
+  IntColumn get effortLevel => intEnum<EffortLevel>()();
+}
+```
+</interfaces>
+</context>
+
+<tasks>
+
+<task type="auto" tdd="true">
+  <name>Task 1: Create TaskSortOption enum, SortPreferenceNotifier, and localization strings</name>
+  <files>
+    lib/features/tasks/domain/task_sort_option.dart,
+    lib/features/tasks/presentation/sort_preference_notifier.dart,
+    lib/features/tasks/presentation/sort_preference_notifier.g.dart,
+    lib/l10n/app_de.arb,
+    lib/l10n/app_localizations.dart,
+    lib/l10n/app_localizations_de.dart,
+    test/features/tasks/presentation/sort_preference_notifier_test.dart
+  </files>
+  <behavior>
+    - Default sort preference is TaskSortOption.alphabetical
+    - setSortOption(TaskSortOption.interval) updates state to interval
+    - Sort preference persists: after setSortOption(effort), a fresh notifier reads back effort from SharedPreferences
+    - TaskSortOption enum has exactly 3 values: alphabetical, interval, effort
+  </behavior>
+  <action>
+    1. Create `lib/features/tasks/domain/task_sort_option.dart`:
+       - `enum TaskSortOption { alphabetical, interval, effort }` — three values only, no index stability concern since this is NOT stored as intEnum in drift (stored as string in SharedPreferences)
+
+    2. Create `lib/features/tasks/presentation/sort_preference_notifier.dart`:
+       - Follow the exact ThemeNotifier pattern from `lib/core/theme/theme_provider.dart`
+       - `@riverpod class SortPreferenceNotifier extends _$SortPreferenceNotifier`
+       - `build()` returns `TaskSortOption.alphabetical` synchronously (default = alphabetical per user decision for continuity with current A-Z sort in CalendarDayList), then calls `_loadPersisted()` async
+       - `_loadPersisted()` reads `SharedPreferences.getString('task_sort_option')` and maps to enum
+       - `setSortOption(TaskSortOption option)` sets state immediately then persists string to SharedPreferences
+       - Static helpers `_fromString` / `_toString` for serialization (use enum .name property)
+       - The generated provider will be named `sortPreferenceProvider` (Riverpod 3 naming convention, consistent with themeProvider)
+
+    3. Run `dart run build_runner build --delete-conflicting-outputs` to generate `.g.dart`
+
+    4. Add localization strings to `lib/l10n/app_de.arb`:
+       - `"sortAlphabetical": "A\u2013Z"` (A-Z with en-dash, concise label per user decision)
+       - `"sortInterval": "Intervall"` (German for interval/frequency)
+       - `"sortEffort": "Aufwand"` (German for effort, matches existing taskFormEffortLabel context)
+       - `"sortLabel": "Sortierung"` (label for accessibility/semantics on the dropdown)
+
+    5. Run `flutter gen-l10n` to regenerate localization files
+
+    6. Write tests in `test/features/tasks/presentation/sort_preference_notifier_test.dart`:
+       - Follow the pattern from notification_settings test: `makeContainer()` helper that creates ProviderContainer, awaits `Future.delayed(Duration.zero)` for async load
+       - `SharedPreferences.setMockInitialValues({})` in setUp
+       - Test: default is alphabetical
+       - Test: setSortOption updates state
+       - Test: persisted value is loaded on restart (set mock initial values with key, verify state after load)
+  </action>
+  <verify>
+    <automated>cd /home/jlmak/Projects/jlmak/HouseHoldKeaper && flutter test test/features/tasks/presentation/sort_preference_notifier_test.dart && flutter analyze --no-fatal-infos</automated>
+  </verify>
+  <done>TaskSortOption enum exists with 3 values. SortPreferenceNotifier persists to SharedPreferences. 3+ unit tests pass. ARB file has 4 new sort strings. dart analyze clean.</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Integrate sort logic into calendarDayProvider and tasksInRoomProvider</name>
+  <files>
+    lib/features/home/presentation/calendar_providers.dart,
+    lib/features/tasks/presentation/task_providers.dart
+  </files>
+  <action>
+    1. Edit `lib/features/home/presentation/calendar_providers.dart`:
+       - Add import for `sort_preference_notifier.dart` and `task_sort_option.dart`
+       - Inside `calendarDayProvider`, add `final sortOption = ref.watch(sortPreferenceProvider);`
+       - After constructing `CalendarDayState`, apply in-memory sort to `dayTasks` list before returning. Do NOT sort overdueTasks (overdue section stays pinned at top in its existing order per user discretion decision).
+       - Sort implementation — create a top-level helper function `List<TaskWithRoom> _sortTasks(List<TaskWithRoom> tasks, TaskSortOption sortOption)` that returns a new sorted list:
+         - `alphabetical`: sort by `task.name.toLowerCase()` (case-insensitive A-Z)
+         - `interval`: sort by `task.intervalType.index` ascending (daily=0 is most frequent, yearly=7 is least), then by `task.intervalDays` ascending as tiebreaker
+         - `effort`: sort by `task.effortLevel.index` ascending (low=0, medium=1, high=2)
+       - Apply: `dayTasks: _sortTasks(dayTasks, sortOption)` in the CalendarDayState constructor call
+       - Note: The SQL `orderBy([OrderingTerm.asc(tasks.name)])` in CalendarDao.watchTasksForDate still runs, but the in-memory sort overrides it. This is intentional — the SQL sort provides a stable baseline, the in-memory sort applies the user's preference.
+
+    2. Edit `lib/features/tasks/presentation/task_providers.dart`:
+       - Add import for `sort_preference_notifier.dart` and `task_sort_option.dart`
+       - In `tasksInRoomProvider`, add `final sortOption = ref.watch(sortPreferenceProvider);`
+       - Map the stream to apply in-memory sorting: `return db.tasksDao.watchTasksInRoom(roomId).map((tasks) => _sortTasksRaw(tasks, sortOption));`
+       - Create a top-level helper `List<Task> _sortTasksRaw(List<Task> tasks, TaskSortOption sortOption)` that sorts raw Task objects (not TaskWithRoom):
+         - `alphabetical`: sort by `task.name.toLowerCase()`
+         - `interval`: sort by `task.intervalType.index`, then `task.intervalDays`
+         - `effort`: sort by `task.effortLevel.index`
+       - Returns a new sorted list (do not mutate the original)
+
+    3. Verify both providers react to sort preference changes by running existing tests (they should still pass since default sort is alphabetical and current data is already alphabetically sorted or test data is single-item).
+  </action>
+  <verify>
+    <automated>cd /home/jlmak/Projects/jlmak/HouseHoldKeaper && flutter test && flutter analyze --no-fatal-infos</automated>
+  </verify>
+  <done>calendarDayProvider watches sortPreferenceProvider and sorts dayTasks accordingly. tasksInRoomProvider watches sortPreferenceProvider and sorts tasks accordingly. All 106+ existing tests pass. dart analyze clean.</done>
+</task>
+
+</tasks>
+
+<verification>
+- `flutter test` — all 106+ tests pass (existing + new sort preference tests)
+- `flutter analyze --no-fatal-infos` — zero issues
+- `sortPreferenceProvider` is watchable and defaults to alphabetical
+- Both calendarDayProvider and tasksInRoomProvider react to sort preference changes
+</verification>
+
+<success_criteria>
+- TaskSortOption enum exists with alphabetical, interval, effort values
+- SortPreferenceNotifier persists sort preference to SharedPreferences
+- Default sort is alphabetical (continuity with existing A-Z sort)
+- calendarDayProvider sorts dayTasks by active sort (overdue section unsorted)
+- tasksInRoomProvider sorts tasks by active sort
+- All tests pass, analyze clean
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/07-task-sorting/07-01-SUMMARY.md`
+</output>
--- a/.planning/phases/07-task-sorting/07-01-SUMMARY.md
+++ b/.planning/phases/07-task-sorting/07-01-SUMMARY.md
@@ -0,0 +1,138 @@
+---
+phase: 07-task-sorting
+plan: 01
+subsystem: ui
+tags: [flutter, riverpod, shared_preferences, sorting, localization]
+
+# Dependency graph
+requires:
+  - phase: 05-calendar-strip
+    provides: calendarDayProvider and CalendarDayState used by sort integration
+  - phase: 06-task-history
+    provides: task domain model and CalendarTaskRow context
+
+provides:
+  - TaskSortOption enum (alphabetical, interval, effort)
+  - SortPreferenceNotifier with SharedPreferences persistence
+  - sortPreferenceProvider (keepAlive Riverpod provider)
+  - calendarDayProvider with in-memory sort of dayTasks
+  - tasksInRoomProvider with in-memory sort via stream.map
+  - German localization strings: sortAlphabetical, sortInterval, sortEffort, sortLabel
+
+affects: [07-02-sort-ui, any phase using calendarDayProvider or tasksInRoomProvider]
+
+# Tech tracking
+tech-stack:
+  added: []
+  patterns:
+    - "SortPreferenceNotifier: sync default return, async _loadPersisted() — same pattern as ThemeNotifier"
+    - "In-memory sort helper functions (_sortTasks, _sortTasksRaw) applied after DB stream emit"
+    - "overdueTasks intentionally unsorted — only dayTasks sorted"
+
+key-files:
+  created:
+    - lib/features/tasks/domain/task_sort_option.dart
+    - lib/features/tasks/presentation/sort_preference_notifier.dart
+    - lib/features/tasks/presentation/sort_preference_notifier.g.dart
+    - test/features/tasks/presentation/sort_preference_notifier_test.dart
+  modified:
+    - lib/features/home/presentation/calendar_providers.dart
+    - lib/features/tasks/presentation/task_providers.dart
+    - lib/l10n/app_de.arb
+    - lib/l10n/app_localizations.dart
+    - lib/l10n/app_localizations_de.dart
+
+key-decisions:
+  - "Default sort is alphabetical — continuity with existing A-Z SQL sort in CalendarDayList"
+  - "overdueTasks are NOT sorted — they stay pinned at the top in existing order"
+  - "Sort stored as string (enum.name) in SharedPreferences — not intEnum, so reordering enum is safe"
+  - "SortPreferenceNotifier uses keepAlive: true — global preference should never be disposed"
+
+patterns-established:
+  - "SortPreferenceNotifier pattern: sync default + async _loadPersisted() — matches ThemeNotifier"
+  - "In-memory sort via stream.map in StreamProvider — DB SQL sort provides stable baseline, in-memory overrides"
+
+requirements-completed: [SORT-01, SORT-02, SORT-03]
+
+# Metrics
+duration: 4min
+completed: 2026-03-16
+---
+
+# Phase 07 Plan 01: Task Sort Domain and Provider Summary
+
+**TaskSortOption enum + SharedPreferences-backed SortPreferenceNotifier wired into calendarDayProvider and tasksInRoomProvider with in-memory alphabetical/interval/effort sorting**
+
+## Performance
+
+- **Duration:** 4 min
+- **Started:** 2026-03-16T21:29:32Z
+- **Completed:** 2026-03-16T21:33:37Z
+- **Tasks:** 2
+- **Files modified:** 9
+
+## Accomplishments
+
+- TaskSortOption enum (alphabetical, interval, effort) with SharedPreferences persistence via SortPreferenceNotifier
+- calendarDayProvider now watches sortPreferenceProvider and sorts dayTasks in-memory; overdueTasks intentionally unsorted
+- tasksInRoomProvider now watches sortPreferenceProvider and applies sort via stream.map
+- 7 new unit tests for SortPreferenceNotifier covering default, state update, persistence, and restart recovery
+- 4 German localization strings added (sortAlphabetical, sortInterval, sortEffort, sortLabel)
+
+## Task Commits
+
+Each task was committed atomically:
+
+1. **TDD RED: Failing sort preference tests** - `a9f2983` (test)
+2. **Task 1: TaskSortOption enum, SortPreferenceNotifier, localization** - `13c7d62` (feat)
+3. **Task 2: Sort integration into calendarDayProvider and tasksInRoomProvider** - `3697e4e` (feat)
+
+## Files Created/Modified
+
+- `lib/features/tasks/domain/task_sort_option.dart` - TaskSortOption enum with alphabetical/interval/effort values
+- `lib/features/tasks/presentation/sort_preference_notifier.dart` - SortPreferenceNotifier with SharedPreferences persistence
+- `lib/features/tasks/presentation/sort_preference_notifier.g.dart` - Generated Riverpod provider code
+- `lib/features/home/presentation/calendar_providers.dart` - Added sortPreferenceProvider watch + _sortTasks helper
+- `lib/features/tasks/presentation/task_providers.dart` - Added sortPreferenceProvider watch + _sortTasksRaw helper + stream.map
+- `lib/l10n/app_de.arb` - Added sortAlphabetical, sortInterval, sortEffort, sortLabel strings
+- `lib/l10n/app_localizations.dart` - Regenerated with sort string getters
+- `lib/l10n/app_localizations_de.dart` - Regenerated with German sort string implementations
+- `test/features/tasks/presentation/sort_preference_notifier_test.dart` - 7 unit tests for sort preference
+
+## Decisions Made
+
+- Default sort is alphabetical for continuity with existing SQL A-Z sort in CalendarDayList
+- overdueTasks section is explicitly NOT sorted — stays pinned at top in existing order
+- Sort preference stored as enum.name string in SharedPreferences (not intEnum) so enum reordering is always safe
+- SortPreferenceNotifier uses `keepAlive: true` — global app preference must not be disposed
+
+## Deviations from Plan
+
+None - plan executed exactly as written.
+
+## Issues Encountered
+
+None.
+
+## User Setup Required
+
+None - no external service configuration required.
+
+## Next Phase Readiness
+
+- sortPreferenceProvider is live and defaults to alphabetical
+- Both task list providers react to sort preference changes immediately
+- Ready for 07-02: sort UI (dropdown in AppBar) to write to sortPreferenceProvider
+
+---
+*Phase: 07-task-sorting*
+*Completed: 2026-03-16*
+
+## Self-Check: PASSED
+
+- FOUND: lib/features/tasks/domain/task_sort_option.dart
+- FOUND: lib/features/tasks/presentation/sort_preference_notifier.dart
+- FOUND: lib/features/tasks/presentation/sort_preference_notifier.g.dart
+- FOUND: test/features/tasks/presentation/sort_preference_notifier_test.dart
+- FOUND: .planning/phases/07-task-sorting/07-01-SUMMARY.md
+- Commits a9f2983, 13c7d62, 3697e4e all verified in git log
--- a/.planning/phases/07-task-sorting/07-02-PLAN.md
+++ b/.planning/phases/07-task-sorting/07-02-PLAN.md
@@ -0,0 +1,214 @@
+---
+phase: 07-task-sorting
+plan: 02
+type: execute
+wave: 2
+depends_on: ["07-01"]
+files_modified:
+  - lib/features/tasks/presentation/sort_dropdown.dart
+  - lib/features/home/presentation/home_screen.dart
+  - lib/features/tasks/presentation/task_list_screen.dart
+  - test/features/home/presentation/home_screen_test.dart
+autonomous: true
+requirements: [SORT-01, SORT-02, SORT-03]
+
+must_haves:
+  truths:
+    - "A sort dropdown is visible in the HomeScreen AppBar showing the current sort label"
+    - "A sort dropdown is visible in the TaskListScreen AppBar showing the current sort label"
+    - "Tapping the dropdown shows three options: A-Z, Intervall, Aufwand"
+    - "Selecting a sort option updates the task list order immediately"
+    - "The sort preference persists across screen navigations and app restarts"
+  artifacts:
+    - path: "lib/features/tasks/presentation/sort_dropdown.dart"
+      provides: "Reusable SortDropdown ConsumerWidget"
+      exports: ["SortDropdown"]
+    - path: "lib/features/home/presentation/home_screen.dart"
+      provides: "HomeScreen with AppBar containing SortDropdown"
+      contains: "SortDropdown"
+    - path: "lib/features/tasks/presentation/task_list_screen.dart"
+      provides: "TaskListScreen AppBar with SortDropdown alongside edit/delete"
+      contains: "SortDropdown"
+  key_links:
+    - from: "lib/features/tasks/presentation/sort_dropdown.dart"
+      to: "sortPreferenceProvider"
+      via: "ref.watch for display, ref.read for mutation"
+      pattern: "ref\\.watch\\(sortPreferenceProvider\\)"
+    - from: "lib/features/home/presentation/home_screen.dart"
+      to: "lib/features/tasks/presentation/sort_dropdown.dart"
+      via: "SortDropdown widget in AppBar actions"
+      pattern: "SortDropdown"
+    - from: "lib/features/tasks/presentation/task_list_screen.dart"
+      to: "lib/features/tasks/presentation/sort_dropdown.dart"
+      via: "SortDropdown widget in AppBar actions"
+      pattern: "SortDropdown"
+---
+
+<objective>
+Build the sort dropdown widget and wire it into both task list screens (HomeScreen and TaskListScreen), adding an AppBar to HomeScreen.
+
+Purpose: Gives users visible access to the sort controls. The data layer from Plan 01 already sorts reactively; this plan adds the UI trigger.
+
+Output: SortDropdown reusable widget, updated HomeScreen with AppBar, updated TaskListScreen with dropdown in existing AppBar, updated tests.
+</objective>
+
+<execution_context>
+@/home/jlmak/.claude/get-shit-done/workflows/execute-plan.md
+@/home/jlmak/.claude/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+@.planning/phases/07-task-sorting/07-CONTEXT.md
+@.planning/phases/07-task-sorting/07-01-SUMMARY.md
+
+<interfaces>
+<!-- Interfaces from Plan 01 that this plan depends on -->
+
+From lib/features/tasks/domain/task_sort_option.dart (created in 07-01):
+```dart
+enum TaskSortOption { alphabetical, interval, effort }
+```
+
+From lib/features/tasks/presentation/sort_preference_notifier.dart (created in 07-01):
+```dart
+@riverpod
+class SortPreferenceNotifier extends _$SortPreferenceNotifier {
+  TaskSortOption build(); // returns alphabetical by default
+  Future<void> setSortOption(TaskSortOption option);
+}
+// Generated as: sortPreferenceProvider
+```
+
+From lib/l10n/app_de.arb (strings added in 07-01):
+```
+sortAlphabetical: "A-Z"
+sortInterval: "Intervall"
+sortEffort: "Aufwand"
+sortLabel: "Sortierung"
+```
+
+<!-- Existing interfaces being modified -->
+
+From lib/features/home/presentation/home_screen.dart:
+```dart
+class HomeScreen extends ConsumerStatefulWidget {
+  // Currently: Stack with CalendarStrip + CalendarDayList + floating Today FAB
+  // No AppBar — body sits directly inside AppShell's Scaffold
+}
+```
+
+From lib/features/tasks/presentation/task_list_screen.dart:
+```dart
+class TaskListScreen extends ConsumerWidget {
+  // Has its own Scaffold with AppBar containing edit + delete IconButtons
+  // AppBar actions: [edit, delete]
+}
+```
+
+From lib/features/home/presentation/calendar_strip.dart:
+```dart
+class CalendarStrip extends StatefulWidget {
+  const CalendarStrip({super.key, required this.controller, this.onTodayVisibilityChanged});
+  final CalendarStripController controller;
+  final ValueChanged<bool>? onTodayVisibilityChanged;
+}
+```
+</interfaces>
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Build SortDropdown widget and integrate into HomeScreen and TaskListScreen</name>
+  <files>
+    lib/features/tasks/presentation/sort_dropdown.dart,
+    lib/features/home/presentation/home_screen.dart,
+    lib/features/tasks/presentation/task_list_screen.dart
+  </files>
+  <action>
+    1. Create `lib/features/tasks/presentation/sort_dropdown.dart`:
+       - A `ConsumerWidget` named `SortDropdown`
+       - Uses `PopupMenuButton<TaskSortOption>` (Material 3, better than DropdownButton for AppBar trailing actions — it opens a menu overlay rather than inline expansion)
+       - `ref.watch(sortPreferenceProvider)` to get current sort option
+       - The button child shows the current sort label as a Text widget using l10n strings:
+         - `alphabetical` -> `l10n.sortAlphabetical` (A-Z)
+         - `interval` -> `l10n.sortInterval` (Intervall)
+         - `effort` -> `l10n.sortEffort` (Aufwand)
+       - Style the button child as a Row with `Icon(Icons.sort)` + `SizedBox(width: 4)` + label Text. Use `theme.textTheme.labelLarge` for the text.
+       - `itemBuilder` returns 3 `PopupMenuItem<TaskSortOption>` entries with check marks: for each option, show a Row with `Icon(Icons.check, size: 18)` (visible only when selected, invisible when not via `Opacity(opacity: isSelected ? 1 : 0)`) + `SizedBox(width: 8)` + label Text
+       - `onSelected`: `ref.read(sortPreferenceProvider.notifier).setSortOption(value)`
+       - Helper method `String _label(TaskSortOption option, AppLocalizations l10n)` that maps enum to l10n string
+
+    2. Edit `lib/features/home/presentation/home_screen.dart`:
+       - HomeScreen currently returns a `Stack` with `Column(CalendarStrip, Expanded(CalendarDayList))` + optional floating Today button
+       - Wrap the entire current Stack in a `Scaffold` with an `AppBar`:
+         - `AppBar(title: Text(l10n.tabHome), actions: [const SortDropdown()])`
+         - The `tabHome` l10n string already exists ("Ubersicht") — reuse it as the AppBar title for the home screen
+         - body: the existing Stack content
+       - Keep CalendarStrip, CalendarDayList, and floating Today FAB exactly as they are
+       - Import `sort_dropdown.dart`
+       - Note: HomeScreen is inside AppShell's Scaffold body. Adding a nested Scaffold is fine and standard for per-tab AppBars in StatefulShellRoute.indexedStack. The AppShell Scaffold provides the bottom nav; the inner Scaffold provides the AppBar.
+
+    3. Edit `lib/features/tasks/presentation/task_list_screen.dart`:
+       - In the existing `AppBar.actions` list, add `const SortDropdown()` BEFORE the edit and delete IconButtons. Order: [SortDropdown, edit, delete].
+       - Import `sort_dropdown.dart`
+       - No other changes to TaskListScreen
+  </action>
+  <verify>
+    <automated>cd /home/jlmak/Projects/jlmak/HouseHoldKeaper && flutter analyze --no-fatal-infos</automated>
+  </verify>
+  <done>SortDropdown widget exists showing current sort label with sort icon. HomeScreen has AppBar with title "Ubersicht" and SortDropdown. TaskListScreen AppBar has SortDropdown before edit/delete buttons. dart analyze clean.</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Update tests for HomeScreen AppBar and sort dropdown</name>
+  <files>
+    test/features/home/presentation/home_screen_test.dart
+  </files>
+  <action>
+    1. Edit `test/features/home/presentation/home_screen_test.dart`:
+       - Add import for `sort_preference_notifier.dart` and `task_sort_option.dart`
+       - In the `_buildApp` helper, add a provider override for `sortPreferenceProvider`:
+         ```dart
+         sortPreferenceProvider.overrideWith(SortPreferenceNotifier.new),
+         ```
+         This will use the real notifier with mock SharedPreferences (already set up in setUp).
+       - Add a new test group `'HomeScreen sort dropdown'`:
+         - Test: "shows sort dropdown in AppBar" — pump the app with tasks, verify `find.byType(PopupMenuButton<TaskSortOption>)` findsOneWidget
+         - Test: "shows AppBar with title" — verify `find.text('Ubersicht')` findsOneWidget (the tabHome l10n string)
+       - Verify all existing tests still pass. The addition of an AppBar wrapping the existing content should not break existing assertions since they look for specific widgets/text within the tree.
+
+    2. Run full test suite to confirm no regressions.
+  </action>
+  <verify>
+    <automated>cd /home/jlmak/Projects/jlmak/HouseHoldKeaper && flutter test && flutter analyze --no-fatal-infos</automated>
+  </verify>
+  <done>Home screen tests verify AppBar with sort dropdown is present. All 108+ tests pass (106 existing + 2+ new). dart analyze clean.</done>
+</task>
+
+</tasks>
+
+<verification>
+- `flutter test` — all tests pass including new sort dropdown tests
+- `flutter analyze --no-fatal-infos` — zero issues
+- HomeScreen has AppBar with SortDropdown visible
+- TaskListScreen has SortDropdown in AppBar actions
+- Tapping dropdown shows 3 options with check mark on current selection
+- Selecting a different sort option reorders the task list reactively
+</verification>
+
+<success_criteria>
+- SortDropdown widget is reusable and shows current sort with icon
+- HomeScreen has AppBar titled "Ubersicht" with SortDropdown in trailing actions
+- TaskListScreen has SortDropdown before edit/delete buttons in AppBar
+- Sort selection updates task list order immediately (reactive via provider)
+- Sort preference persists (set in one screen, visible in another after navigation)
+- All tests pass, analyze clean
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/07-task-sorting/07-02-SUMMARY.md`
+</output>
--- a/.planning/phases/07-task-sorting/07-02-SUMMARY.md
+++ b/.planning/phases/07-task-sorting/07-02-SUMMARY.md
@@ -0,0 +1,125 @@
+---
+phase: 07-task-sorting
+plan: 02
+subsystem: ui
+tags: [flutter, riverpod, material3, popup-menu, sort-ui, localization]
+
+# Dependency graph
+requires:
+  - phase: 07-task-sorting
+    plan: 01
+    provides: sortPreferenceProvider, TaskSortOption enum, German sort l10n strings
+
+provides:
+  - SortDropdown ConsumerWidget (PopupMenuButton<TaskSortOption> with check marks)
+  - HomeScreen with AppBar (title: Übersicht, actions: SortDropdown)
+  - TaskListScreen AppBar with SortDropdown before edit/delete buttons
+
+affects: [home_screen_test.dart, app_shell_test.dart, any screen showing HomeScreen]
+
+# Tech tracking
+tech-stack:
+  added: []
+  patterns:
+    - "PopupMenuButton<TaskSortOption> with Opacity check mark — avoids layout shift vs conditional Icon"
+    - "Nested Scaffold inside AppShell tab body — standard pattern for per-tab AppBars in StatefulShellRoute"
+
+key-files:
+  created:
+    - lib/features/tasks/presentation/sort_dropdown.dart
+  modified:
+    - lib/features/home/presentation/home_screen.dart
+    - lib/features/tasks/presentation/task_list_screen.dart
+    - test/features/home/presentation/home_screen_test.dart
+    - test/shell/app_shell_test.dart
+
+key-decisions:
+  - "Used PopupMenuButton instead of DropdownButton for AppBar — menu overlay vs inline expansion, consistent with Material 3 AppBar action patterns"
+  - "Opacity(opacity: isSelected ? 1 : 0) for check mark — preserves item width alignment vs conditional show/hide"
+  - "HomeScreen Scaffold is nested inside AppShell Scaffold — standard StatefulShellRoute pattern for per-tab AppBars"
+
+# Metrics
+duration: 4min
+completed: 2026-03-16
+---
+
+# Phase 07 Plan 02: Sort Dropdown UI Summary
+
+**SortDropdown ConsumerWidget using PopupMenuButton wired into HomeScreen AppBar (title: Übersicht) and TaskListScreen AppBar before edit/delete actions**
+
+## Performance
+
+- **Duration:** 4 min
+- **Started:** 2026-03-16T21:35:56Z
+- **Completed:** 2026-03-16T21:39:24Z
+- **Tasks:** 2
+- **Files modified:** 5 (1 created, 4 modified)
+
+## Accomplishments
+
+- SortDropdown ConsumerWidget: PopupMenuButton<TaskSortOption> with sort icon, current label, and check mark on active option
+- HomeScreen wrapped in Scaffold with AppBar titled "Übersicht" and SortDropdown in trailing actions
+- TaskListScreen AppBar has SortDropdown before the existing edit/delete IconButtons
+- 2 new tests in HomeScreen test suite: verifies PopupMenuButton and AppBar title presence
+- Auto-fixed app_shell_test regression caused by "Übersicht" now appearing twice (AppBar + bottom nav)
+
+## Task Commits
+
+Each task was committed atomically:
+
+1. **Task 1: SortDropdown widget and HomeScreen/TaskListScreen integration** - `e5eccb7` (feat)
+2. **Task 2: Sort dropdown tests and AppShell test fix** - `a3e4d02` (feat)
+
+## Files Created/Modified
+
+- `lib/features/tasks/presentation/sort_dropdown.dart` - Reusable SortDropdown ConsumerWidget with PopupMenuButton<TaskSortOption>
+- `lib/features/home/presentation/home_screen.dart` - Added Scaffold with AppBar (Übersicht title + SortDropdown)
+- `lib/features/tasks/presentation/task_list_screen.dart` - Added SortDropdown before edit/delete in AppBar actions
+- `test/features/home/presentation/home_screen_test.dart` - Added sortPreferenceProvider override + 2 new sort dropdown tests
+- `test/shell/app_shell_test.dart` - Fixed findsOneWidget -> findsWidgets for 'Übersicht' (now in AppBar + bottom nav)
+
+## Decisions Made
+
+- Used PopupMenuButton instead of DropdownButton for AppBar actions — menu overlay is cleaner in AppBar context (Material 3)
+- Opacity trick for check mark: `Opacity(opacity: isSelected ? 1 : 0)` preserves item width so labels align regardless of selection
+- HomeScreen uses nested Scaffold for AppBar — standard pattern in StatefulShellRoute.indexedStack; AppShell provides bottom nav, HomeScreen provides AppBar
+
+## Deviations from Plan
+
+### Auto-fixed Issues
+
+**1. [Rule 1 - Bug] Fixed AppShell test regression from 'Übersicht' duplicate**
+- **Found during:** Task 2 test run
+- **Issue:** `app_shell_test.dart` expected `findsOneWidget` for 'Übersicht'. Adding the HomeScreen AppBar title caused the string to appear twice (AppBar + bottom nav label).
+- **Fix:** Changed `findsOneWidget` to `findsWidgets` in `app_shell_test.dart` line 67. Applied same fix to new `home_screen_test.dart` AppBar title test.
+- **Files modified:** `test/shell/app_shell_test.dart`, `test/features/home/presentation/home_screen_test.dart`
+- **Commit:** `a3e4d02`
+
+## Issues Encountered
+
+None beyond the auto-fixed regression.
+
+## User Setup Required
+
+None - no external service configuration required.
+
+## Next Phase Readiness
+
+- Phase 07 (task sorting) is now complete: data layer (07-01) + UI layer (07-02)
+- Sort dropdown is live in both HomeScreen and TaskListScreen AppBars
+- Selecting a sort option reactively reorders task lists via sortPreferenceProvider
+- Preference persists across app restarts via SharedPreferences
+
+---
+*Phase: 07-task-sorting*
+*Completed: 2026-03-16*
+
+## Self-Check: PASSED
+
+- FOUND: lib/features/tasks/presentation/sort_dropdown.dart
+- FOUND: lib/features/home/presentation/home_screen.dart (modified)
+- FOUND: lib/features/tasks/presentation/task_list_screen.dart (modified)
+- FOUND: test/features/home/presentation/home_screen_test.dart (modified)
+- FOUND: test/shell/app_shell_test.dart (modified)
+- Commits e5eccb7, a3e4d02 verified in git log
+- All 115 tests pass, dart analyze clean
--- a/.planning/phases/07-task-sorting/07-CONTEXT.md
+++ b/.planning/phases/07-task-sorting/07-CONTEXT.md
@@ -0,0 +1,91 @@
+# Phase 7: Task Sorting - Context
+
+**Gathered:** 2026-03-16
+**Status:** Ready for planning
+
+<domain>
+## Phase Boundary
+
+Add sort controls to task list screens so users can reorder tasks by name (alphabetical), frequency interval, or effort level. The sort preference persists across app restarts. Requirements: SORT-01, SORT-02, SORT-03.
+
+</domain>
+
+<decisions>
+## Implementation Decisions
+
+### Sort control widget
+- Dropdown button in the AppBar, right side (trailing actions position)
+- When collapsed, shows the current sort name as text (e.g., "A-Z", "Intervall", "Aufwand")
+- Expands to show the 3 sort options as a standard dropdown menu
+
+### Sort option labels
+- Claude's discretion — pick German labels that fit the app's existing localization style (concise but clear)
+
+### Sort scope
+- One global sort preference applies to all task list screens
+- Same dropdown appears in both the home screen (CalendarDayList) and per-room (TaskListScreen) AppBars
+
+### Persistence
+- Store the sort preference in SharedPreferences (simple key-value for a single enum)
+- No database schema change needed
+- Persists across app restarts per success criteria
+
+### Default sort
+- Claude's discretion — pick the least disruptive default (likely alphabetical to match current CalendarDayList behavior)
+
+### Claude's Discretion
+- Sort option label text (German, concise)
+- Default sort order (recommend alphabetical for continuity)
+- Whether TaskListScreen also gets the dropdown (recommend yes for consistency with global setting, since the success criteria says "task list screens" plural)
+- Sort direction (always ascending — A-Z, daily→yearly, low→high — no toggle needed for MVP)
+- Dropdown styling (Material 3 DropdownButton or PopupMenuButton variant)
+- Sort icon or visual indicator in the dropdown
+- How overdue section interacts with sorting (recommend: overdue section stays pinned at top regardless of sort, only day tasks are sorted)
+
+</decisions>
+
+<specifics>
+## Specific Ideas
+
+No specific requirements — open to standard approaches that match existing app patterns.
+
+</specifics>
+
+<code_context>
+## Existing Code Insights
+
+### Reusable Assets
+- `EffortLevel` enum (low/medium/high) with `.index` for ordering — directly usable for effort sort
+- `IntervalType` enum with `.index` ordered roughly by frequency (daily=0 through yearly=7) — usable for interval sort
+- `FrequencyInterval.presets` list ordered most-frequent to least — reference for sort order
+- `Task.name` field — direct alphabetical sort target
+- `CalendarDayList` and `TaskListScreen` — the two list widgets that need sort integration
+- `AppLocalizations` + `.arb` files — existing German localization pipeline
+
+### Established Patterns
+- Manual `StreamProvider.autoDispose` for drift types (riverpod_generator issue) — sort provider follows same pattern
+- `calendarDayProvider` watches `selectedDateProvider` — can also watch a sort preference provider
+- `tasksInRoomProvider` family provider — can be extended with sort parameter or read global sort
+- Feature folder structure: `features/home/`, `features/tasks/` — sort logic may live in a shared location or in each feature
+
+### Integration Points
+- `HomeScreen` AppBar — add dropdown to trailing actions
+- `TaskListScreen` AppBar — already has edit/delete actions; add dropdown alongside
+- `CalendarDao.watchTasksForDate()` — currently sorts alphabetically; needs sort-aware query or in-memory sort
+- `TasksDao.watchTasksInRoom()` — currently sorts by nextDueDate; needs sort-aware query or in-memory sort
+- `SharedPreferences` — not yet used in the app; needs package addition and provider setup
+- `app_de.arb` — add localization strings for sort labels
+
+</code_context>
+
+<deferred>
+## Deferred Ideas
+
+None — discussion stayed within phase scope
+
+</deferred>
+
+---
+
+*Phase: 07-task-sorting*
+*Context gathered: 2026-03-16*
--- a/.planning/phases/07-task-sorting/7-VERIFICATION.md
+++ b/.planning/phases/07-task-sorting/7-VERIFICATION.md
@@ -0,0 +1,135 @@
+---
+phase: 07-task-sorting
+verified: 2026-03-16T22:00:00Z
+status: passed
+score: 9/9 must-haves verified
+re_verification: false
+---
+
+# Phase 7: Task Sorting Verification Report
+
+**Phase Goal:** Users can reorder task lists by the dimension most useful to them — name, how often the task recurs, or how much effort it requires
+**Verified:** 2026-03-16T22:00:00Z
+**Status:** passed
+**Re-verification:** No — initial verification
+
+---
+
+## Goal Achievement
+
+### Observable Truths
+
+| #  | Truth                                                                          | Status     | Evidence                                                                                             |
+|----|--------------------------------------------------------------------------------|------------|------------------------------------------------------------------------------------------------------|
+| 1  | Sort preference persists across app restarts                                   | VERIFIED   | `SortPreferenceNotifier._loadPersisted()` reads `SharedPreferences.getString('task_sort_option')` on build; 2 restart-recovery tests pass |
+| 2  | CalendarDayList tasks are sorted according to the active sort preference       | VERIFIED   | `calendarDayProvider` calls `ref.watch(sortPreferenceProvider)` and applies `_sortTasks(dayTasks, sortOption)` before returning `CalendarDayState` |
+| 3  | TaskListScreen tasks are sorted according to the active sort preference        | VERIFIED   | `tasksInRoomProvider` calls `ref.watch(sortPreferenceProvider)` and applies `stream.map((tasks) => _sortTasksRaw(tasks, sortOption))` |
+| 4  | Default sort is alphabetical (matches current CalendarDayList behavior)        | VERIFIED   | `SortPreferenceNotifier.build()` returns `TaskSortOption.alphabetical` synchronously; test "build() returns default state of alphabetical" confirms |
+| 5  | A sort dropdown is visible in the HomeScreen AppBar showing the current label  | VERIFIED   | `HomeScreen.build()` returns `Scaffold(appBar: AppBar(actions: const [SortDropdown()]))` — wired and rendered |
+| 6  | A sort dropdown is visible in the TaskListScreen AppBar                        | VERIFIED   | `TaskListScreen.build()` AppBar actions list: `[const SortDropdown(), edit IconButton, delete IconButton]` |
+| 7  | Tapping the dropdown shows three options: A-Z, Intervall, Aufwand             | VERIFIED   | `SortDropdown` builds `PopupMenuButton` from `TaskSortOption.values` (3 items), labels map to `l10n.sortAlphabetical/sortInterval/sortEffort` |
+| 8  | Selecting a sort option updates the task list order immediately                | VERIFIED   | `onSelected` calls `ref.read(sortPreferenceProvider.notifier).setSortOption(value)`; providers watch `sortPreferenceProvider` and rebuild reactively |
+| 9  | The sort preference persists across screen navigations and app restarts        | VERIFIED   | `@Riverpod(keepAlive: true)` prevents disposal during navigation; SharedPreferences stores and reloads value |
+
+**Score:** 9/9 truths verified
+
+---
+
+## Required Artifacts
+
+### Plan 07-01 Artifacts
+
+| Artifact | Expected | Status | Details |
+|----------|----------|--------|---------|
+| `lib/features/tasks/domain/task_sort_option.dart` | `TaskSortOption` enum with alphabetical, interval, effort | VERIFIED | Exactly 3 values, comments match intent. No stubs. |
+| `lib/features/tasks/presentation/sort_preference_notifier.dart` | `SortPreferenceNotifier` with SharedPreferences persistence | VERIFIED | `build()` returns `alphabetical` synchronously, `_loadPersisted()` async, `setSortOption()` sets state + persists. Pattern matches `ThemeNotifier`. |
+| `lib/features/tasks/presentation/sort_preference_notifier.g.dart` | Generated Riverpod provider file | VERIFIED | Generated correctly; `sortPreferenceProvider` declared as `SortPreferenceNotifierProvider._()` with `isAutoDispose: false` (keepAlive). |
+| `lib/features/home/presentation/calendar_providers.dart` | `calendarDayProvider` sorts `dayTasks` by active sort preference | VERIFIED | `ref.watch(sortPreferenceProvider)` present. `_sortTasks()` helper implements all 3 sort modes. `overdueTasks` intentionally unsorted. |
+| `lib/features/tasks/presentation/task_providers.dart` | `tasksInRoomProvider` sorts tasks by active sort preference | VERIFIED | `ref.watch(sortPreferenceProvider)` present. `_sortTasksRaw()` helper + `stream.map()` applied correctly. |
+| `test/features/tasks/presentation/sort_preference_notifier_test.dart` | Unit tests for sort preference persistence and default | VERIFIED | 7 tests: default alphabetical, setSortOption interval, setSortOption effort, persist to SharedPreferences, restart recovery (effort), restart recovery (interval), unknown value fallback. |
+
+### Plan 07-02 Artifacts
+
+| Artifact | Expected | Status | Details |
+|----------|----------|--------|---------|
+| `lib/features/tasks/presentation/sort_dropdown.dart` | Reusable `SortDropdown` `ConsumerWidget` | VERIFIED | `ConsumerWidget`, `PopupMenuButton<TaskSortOption>`, Opacity check mark pattern, `ref.watch` for display, `ref.read` for mutation, `_label()` helper. |
+| `lib/features/home/presentation/home_screen.dart` | HomeScreen with AppBar containing `SortDropdown` | VERIFIED | `Scaffold(appBar: AppBar(title: Text(l10n.tabHome), actions: const [SortDropdown()]))`. Existing Stack body preserved. |
+| `lib/features/tasks/presentation/task_list_screen.dart` | TaskListScreen AppBar with `SortDropdown` before edit/delete | VERIFIED | `actions: [const SortDropdown(), IconButton(edit), IconButton(delete)]`. Correct order. |
+
+---
+
+## Key Link Verification
+
+### Plan 07-01 Key Links
+
+| From | To | Via | Status | Details |
+|------|----|-----|--------|---------|
+| `calendar_providers.dart` | `sortPreferenceProvider` | `ref.watch(sortPreferenceProvider)` in `calendarDayProvider` | WIRED | Line 77: `final sortOption = ref.watch(sortPreferenceProvider);`. Applied at line 101: `dayTasks: _sortTasks(dayTasks, sortOption)`. |
+| `task_providers.dart` | `sortPreferenceProvider` | `ref.watch(sortPreferenceProvider)` in `tasksInRoomProvider` | WIRED | Line 43: `final sortOption = ref.watch(sortPreferenceProvider);`. Applied at lines 44-46 via `stream.map`. |
+
+### Plan 07-02 Key Links
+
+| From | To | Via | Status | Details |
+|------|----|-----|--------|---------|
+| `sort_dropdown.dart` | `sortPreferenceProvider` | `ref.watch` for display, `ref.read` for mutation | WIRED | Line 21: `ref.watch(sortPreferenceProvider)`. Line 27: `ref.read(sortPreferenceProvider.notifier).setSortOption(value)`. |
+| `home_screen.dart` | `sort_dropdown.dart` | `SortDropdown` widget in AppBar actions | WIRED | Import on line 7. Used in `AppBar(actions: const [SortDropdown()])` on line 37. |
+| `task_list_screen.dart` | `sort_dropdown.dart` | `SortDropdown` widget in AppBar actions | WIRED | Import on line 7. Used in `actions: [const SortDropdown(), ...]` on line 31. |
+
+---
+
+## Requirements Coverage
+
+| Requirement | Source Plan | Description | Status | Evidence |
+|-------------|-------------|-------------|--------|----------|
+| SORT-01 | 07-01, 07-02 | User can sort tasks alphabetically | SATISFIED | `TaskSortOption.alphabetical` is the default. `_sortTasks()` and `_sortTasksRaw()` implement case-insensitive A-Z sort. `SortDropdown` displays "A–Z" label (l10n). |
+| SORT-02 | 07-01, 07-02 | User can sort tasks by frequency interval | SATISFIED | `TaskSortOption.interval` sort implemented: `intervalType.index` ascending with `intervalDays` tiebreaker. Displayed as "Intervall" in `SortDropdown`. |
+| SORT-03 | 07-01, 07-02 | User can sort tasks by effort level | SATISFIED | `TaskSortOption.effort` sort implemented: `effortLevel.index` ascending (low=0, medium=1, high=2). Displayed as "Aufwand" in `SortDropdown`. |
+
+No orphaned requirements. All three SORT requirements are claimed by both plans and fully implemented.
+
+---
+
+## Anti-Patterns Found
+
+None. All seven implementation files scanned — no TODO, FIXME, XXX, HACK, PLACEHOLDER, return null, return {}, return [], or empty arrow functions found.
+
+---
+
+## Human Verification Required
+
+### 1. Visual check: Sort dropdown appearance in AppBar
+
+**Test:** Launch the app, navigate to HomeScreen. Verify the AppBar shows a sort icon (Icons.sort) followed by the current sort label text "A–Z".
+**Expected:** Sort icon and "A–Z" text visible in the top-right AppBar area.
+**Why human:** Widget rendering and visual layout cannot be verified programmatically.
+
+### 2. Popup menu interaction: Check marks on active option
+
+**Test:** Tap the sort dropdown, verify three items appear with a check mark next to the currently selected option and no check mark on the other two.
+**Expected:** Check mark visible on "A–Z" (default), invisible (but space-preserving) on "Intervall" and "Aufwand".
+**Why human:** Opacity(0) vs Opacity(1) rendering and visual alignment cannot be verified with grep.
+
+### 3. Reactive reorder on selection
+
+**Test:** With tasks loaded in HomeScreen, tap the sort dropdown and select "Aufwand". Verify the task list reorders immediately without a page reload.
+**Expected:** Task list updates instantly, sorted low-effort first.
+**Why human:** Real-time Riverpod reactive rebuild requires a running app to observe.
+
+### 4. Cross-screen persistence of sort preference
+
+**Test:** Select "Intervall" in HomeScreen, then navigate to a room's TaskListScreen. Verify the sort dropdown there also shows "Intervall".
+**Expected:** Sort preference is shared across screens (same `sortPreferenceProvider`, `keepAlive: true`).
+**Why human:** Cross-screen navigation state cannot be verified statically.
+
+---
+
+## Gaps Summary
+
+None. All 9 observable truths verified. All artifacts exist, are substantive, and are correctly wired. All 3 requirements (SORT-01, SORT-02, SORT-03) are fully satisfied. All 5 commits (a9f2983, 13c7d62, 3697e4e, e5eccb7, a3e4d02) confirmed present in git log. No anti-patterns detected in implementation files.
+
+The phase delivers its stated goal: users can reorder task lists by name (A–Z), frequency interval, or effort level via a persistent, reactive sort preference accessible from both HomeScreen and TaskListScreen AppBars.
+
+---
+
+_Verified: 2026-03-16T22:00:00Z_
+_Verifier: Claude (gsd-verifier)_
--- a/lib/features/home/presentation/calendar_providers.dart
+++ b/lib/features/home/presentation/calendar_providers.dart
@@ -3,6 +3,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:household_keeper/core/providers/database_provider.dart';
 import 'package:household_keeper/features/home/domain/calendar_models.dart';
 import 'package:household_keeper/features/home/domain/daily_plan_models.dart';
+import 'package:household_keeper/features/tasks/domain/task_sort_option.dart';
+import 'package:household_keeper/features/tasks/presentation/sort_preference_notifier.dart';

 /// Notifier that manages the currently selected date in the calendar strip.
 ///
@@ -27,17 +29,52 @@ final selectedDateProvider =
  SelectedDateNotifier.new,
 );

+/// Sort a list of [TaskWithRoom] by the given [sortOption].
+///
+/// Returns a new sorted list; never mutates the original.
+/// Only [dayTasks] are sorted — the overdue section stays in its existing
+/// order per user decision.
+List<TaskWithRoom> _sortTasks(
+  List<TaskWithRoom> tasks,
+  TaskSortOption sortOption,
+) {
+  final sorted = List<TaskWithRoom>.from(tasks);
+  switch (sortOption) {
+    case TaskSortOption.alphabetical:
+      sorted.sort((a, b) => a.task.name.toLowerCase().compareTo(
+            b.task.name.toLowerCase(),
+          ));
+    case TaskSortOption.interval:
+      sorted.sort((a, b) {
+        final cmp = a.task.intervalType.index.compareTo(
+          b.task.intervalType.index,
+        );
+        if (cmp != 0) return cmp;
+        return a.task.intervalDays.compareTo(b.task.intervalDays);
+      });
+    case TaskSortOption.effort:
+      sorted.sort((a, b) => a.task.effortLevel.index.compareTo(
+            b.task.effortLevel.index,
+          ));
+  }
+  return sorted;
+}
+
 /// Reactive calendar day state: tasks for the selected date + overdue tasks.
 ///
 /// Overdue tasks are only included when the selected date is today.
 /// Past and future dates show only tasks originally due on that day.
 ///
+/// dayTasks are sorted in-memory according to the active [sortPreferenceProvider].
+/// overdueTasks retain their existing order (pinned at top, unsorted per design).
+///
 /// Defined manually (not @riverpod) because riverpod_generator has trouble
 /// with drift's generated [Task] type. Same pattern as [dailyPlanProvider].
 final calendarDayProvider =
    StreamProvider.autoDispose<CalendarDayState>((ref) {
  final db = ref.watch(appDatabaseProvider);
  final selectedDate = ref.watch(selectedDateProvider);
+  final sortOption = ref.watch(sortPreferenceProvider);

  final now = DateTime.now();
  final today = DateTime(now.year, now.month, now.day);
@@ -61,7 +98,7 @@ final calendarDayProvider =

    return CalendarDayState(
      selectedDate: selectedDate,
-      dayTasks: dayTasks,
+      dayTasks: _sortTasks(dayTasks, sortOption),
      overdueTasks: overdueTasks,
      totalTaskCount: totalTaskCount,
    );
--- a/lib/features/home/presentation/calendar_task_row.dart
+++ b/lib/features/home/presentation/calendar_task_row.dart
@@ -36,6 +36,9 @@ class CalendarTaskRow extends StatelessWidget {
    final task = taskWithRoom.task;

    return ListTile(
+      onTap: () => context.go(
+        '/rooms/${taskWithRoom.roomId}/tasks/${taskWithRoom.task.id}',
+      ),
      leading: Checkbox(
        value: false,
        onChanged: (_) => onCompleted(),
--- a/lib/features/home/presentation/home_screen.dart
+++ b/lib/features/home/presentation/home_screen.dart
@@ -4,6 +4,7 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:household_keeper/features/home/presentation/calendar_day_list.dart';
 import 'package:household_keeper/features/home/presentation/calendar_providers.dart';
 import 'package:household_keeper/features/home/presentation/calendar_strip.dart';
+import 'package:household_keeper/features/tasks/presentation/sort_dropdown.dart';
 import 'package:household_keeper/l10n/app_localizations.dart';

 /// The app's primary screen: a horizontal calendar strip at the top with a
@@ -30,40 +31,46 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
  Widget build(BuildContext context) {
    final l10n = AppLocalizations.of(context);

-    return Stack(
-      children: [
-        Column(
-          children: [
-            CalendarStrip(
-              controller: _stripController,
-              onTodayVisibilityChanged: (visible) {
-                setState(() => _showTodayButton = !visible);
-              },
-            ),
-            const Expanded(child: CalendarDayList()),
-          ],
-        ),
-        if (_showTodayButton)
-          Positioned(
-            bottom: 16,
-            left: 0,
-            right: 0,
-            child: Center(
-              child: FloatingActionButton.extended(
-                onPressed: () {
-                  final now = DateTime.now();
-                  final today = DateTime(now.year, now.month, now.day);
-                  ref
-                      .read(selectedDateProvider.notifier)
-                      .selectDate(today);
-                  _stripController.scrollToToday();
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(l10n.tabHome),
+        actions: const [SortDropdown()],
+      ),
+      body: Stack(
+        children: [
+          Column(
+            children: [
+              CalendarStrip(
+                controller: _stripController,
+                onTodayVisibilityChanged: (visible) {
+                  setState(() => _showTodayButton = !visible);
                },
-                icon: const Icon(Icons.today),
-                label: Text(l10n.calendarTodayButton),
+              ),
+              const Expanded(child: CalendarDayList()),
+            ],
+          ),
+          if (_showTodayButton)
+            Positioned(
+              bottom: 16,
+              left: 0,
+              right: 0,
+              child: Center(
+                child: FloatingActionButton.extended(
+                  onPressed: () {
+                    final now = DateTime.now();
+                    final today = DateTime(now.year, now.month, now.day);
+                    ref
+                        .read(selectedDateProvider.notifier)
+                        .selectDate(today);
+                    _stripController.scrollToToday();
+                  },
+                  icon: const Icon(Icons.today),
+                  label: Text(l10n.calendarTodayButton),
+                ),
              ),
            ),
-          ),
-      ],
+        ],
+      ),
    );
  }
 }
--- a/lib/features/tasks/data/tasks_dao.dart
+++ b/lib/features/tasks/data/tasks_dao.dart
@@ -81,6 +81,14 @@ class TasksDao extends DatabaseAccessor<AppDatabase> with _$TasksDaoMixin {
    });
  }

+  /// Watch all completions for a task, newest first.
+  Stream<List<TaskCompletion>> watchCompletionsForTask(int taskId) {
+    return (select(taskCompletions)
+          ..where((c) => c.taskId.equals(taskId))
+          ..orderBy([(c) => OrderingTerm.desc(c.completedAt)]))
+        .watch();
+  }
+
  /// Count overdue tasks in a room (nextDueDate before today).
  Future<int> getOverdueTaskCount(int roomId, {DateTime? today}) async {
    final now = today ?? DateTime.now();
--- a/lib/features/tasks/domain/task_sort_option.dart
+++ b/lib/features/tasks/domain/task_sort_option.dart
@@ -0,0 +1,9 @@
+/// Sort options for task lists.
+///
+/// Stored as a string in SharedPreferences (not as intEnum in the database),
+/// so reordering these values is safe.
+enum TaskSortOption {
+  alphabetical, // A–Z by task name
+  interval, // by frequency interval (most frequent first)
+  effort, // by effort level (low → medium → high)
+}
--- a/lib/features/tasks/presentation/sort_dropdown.dart
+++ b/lib/features/tasks/presentation/sort_dropdown.dart
@@ -0,0 +1,71 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import 'package:household_keeper/features/tasks/domain/task_sort_option.dart';
+import 'package:household_keeper/features/tasks/presentation/sort_preference_notifier.dart';
+import 'package:household_keeper/l10n/app_localizations.dart';
+
+/// A reusable sort dropdown widget for use in AppBar actions.
+///
+/// Displays the current sort option as a labelled button with a sort icon.
+/// Tapping opens a popup menu with three options: A–Z, Intervall, Aufwand.
+/// The active option is indicated with a visible check mark.
+///
+/// Reads sort state from [sortPreferenceProvider] and writes via
+/// [SortPreferenceNotifier.setSortOption].
+class SortDropdown extends ConsumerWidget {
+  const SortDropdown({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final current = ref.watch(sortPreferenceProvider);
+    final l10n = AppLocalizations.of(context);
+    final theme = Theme.of(context);
+
+    return PopupMenuButton<TaskSortOption>(
+      onSelected: (value) =>
+          ref.read(sortPreferenceProvider.notifier).setSortOption(value),
+      itemBuilder: (context) => TaskSortOption.values.map((option) {
+        final isSelected = option == current;
+        return PopupMenuItem<TaskSortOption>(
+          value: option,
+          child: Row(
+            children: [
+              Opacity(
+                opacity: isSelected ? 1.0 : 0.0,
+                child: const Icon(Icons.check, size: 18),
+              ),
+              const SizedBox(width: 8),
+              Text(_label(option, l10n)),
+            ],
+          ),
+        );
+      }).toList(),
+      child: Padding(
+        padding: const EdgeInsets.symmetric(horizontal: 8),
+        child: Row(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            const Icon(Icons.sort),
+            const SizedBox(width: 4),
+            Text(
+              _label(current, l10n),
+              style: theme.textTheme.labelLarge,
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  String _label(TaskSortOption option, AppLocalizations l10n) {
+    switch (option) {
+      case TaskSortOption.alphabetical:
+        return l10n.sortAlphabetical;
+      case TaskSortOption.interval:
+        return l10n.sortInterval;
+      case TaskSortOption.effort:
+        return l10n.sortEffort;
+    }
+  }
+}
--- a/lib/features/tasks/presentation/sort_preference_notifier.dart
+++ b/lib/features/tasks/presentation/sort_preference_notifier.dart
@@ -0,0 +1,57 @@
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import 'package:household_keeper/features/tasks/domain/task_sort_option.dart';
+
+part 'sort_preference_notifier.g.dart';
+
+const _sortOptionKey = 'task_sort_option';
+
+/// Notifier that manages the active task sort preference.
+///
+/// Defaults to [TaskSortOption.alphabetical] synchronously (matching the
+/// existing A-Z sort in CalendarDayList), then loads the persisted value
+/// asynchronously on first build.
+///
+/// Follows the same pattern as [ThemeNotifier] in
+/// `lib/core/theme/theme_provider.dart`.
+@Riverpod(keepAlive: true)
+class SortPreferenceNotifier extends _$SortPreferenceNotifier {
+  @override
+  TaskSortOption build() {
+    _loadPersisted();
+    return TaskSortOption.alphabetical;
+  }
+
+  Future<void> _loadPersisted() async {
+    final prefs = await SharedPreferences.getInstance();
+    final persisted = prefs.getString(_sortOptionKey);
+    if (persisted != null) {
+      state = _fromString(persisted);
+    }
+  }
+
+  /// Update the active sort preference and persist it.
+  Future<void> setSortOption(TaskSortOption option) async {
+    state = option;
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_sortOptionKey, _toString(option));
+  }
+
+  static TaskSortOption _fromString(String value) {
+    switch (value) {
+      case 'alphabetical':
+        return TaskSortOption.alphabetical;
+      case 'interval':
+        return TaskSortOption.interval;
+      case 'effort':
+        return TaskSortOption.effort;
+      default:
+        return TaskSortOption.alphabetical;
+    }
+  }
+
+  static String _toString(TaskSortOption option) {
+    return option.name;
+  }
+}
--- a/lib/features/tasks/presentation/sort_preference_notifier.g.dart
+++ b/lib/features/tasks/presentation/sort_preference_notifier.g.dart
@@ -0,0 +1,96 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'sort_preference_notifier.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+// GENERATED CODE - DO NOT MODIFY BY HAND
+// ignore_for_file: type=lint, type=warning
+/// Notifier that manages the active task sort preference.
+///
+/// Defaults to [TaskSortOption.alphabetical] synchronously (matching the
+/// existing A-Z sort in CalendarDayList), then loads the persisted value
+/// asynchronously on first build.
+///
+/// Follows the same pattern as [ThemeNotifier] in
+/// `lib/core/theme/theme_provider.dart`.
+
+@ProviderFor(SortPreferenceNotifier)
+final sortPreferenceProvider = SortPreferenceNotifierProvider._();
+
+/// Notifier that manages the active task sort preference.
+///
+/// Defaults to [TaskSortOption.alphabetical] synchronously (matching the
+/// existing A-Z sort in CalendarDayList), then loads the persisted value
+/// asynchronously on first build.
+///
+/// Follows the same pattern as [ThemeNotifier] in
+/// `lib/core/theme/theme_provider.dart`.
+final class SortPreferenceNotifierProvider
+    extends $NotifierProvider<SortPreferenceNotifier, TaskSortOption> {
+  /// Notifier that manages the active task sort preference.
+  ///
+  /// Defaults to [TaskSortOption.alphabetical] synchronously (matching the
+  /// existing A-Z sort in CalendarDayList), then loads the persisted value
+  /// asynchronously on first build.
+  ///
+  /// Follows the same pattern as [ThemeNotifier] in
+  /// `lib/core/theme/theme_provider.dart`.
+  SortPreferenceNotifierProvider._()
+    : super(
+        from: null,
+        argument: null,
+        retry: null,
+        name: r'sortPreferenceProvider',
+        isAutoDispose: false,
+        dependencies: null,
+        $allTransitiveDependencies: null,
+      );
+
+  @override
+  String debugGetCreateSourceHash() => _$sortPreferenceNotifierHash();
+
+  @$internal
+  @override
+  SortPreferenceNotifier create() => SortPreferenceNotifier();
+
+  /// {@macro riverpod.override_with_value}
+  Override overrideWithValue(TaskSortOption value) {
+    return $ProviderOverride(
+      origin: this,
+      providerOverride: $SyncValueProvider<TaskSortOption>(value),
+    );
+  }
+}
+
+String _$sortPreferenceNotifierHash() =>
+    r'5d7f2c5d06b82b4114262ee05cf890ebe717fe2a';
+
+/// Notifier that manages the active task sort preference.
+///
+/// Defaults to [TaskSortOption.alphabetical] synchronously (matching the
+/// existing A-Z sort in CalendarDayList), then loads the persisted value
+/// asynchronously on first build.
+///
+/// Follows the same pattern as [ThemeNotifier] in
+/// `lib/core/theme/theme_provider.dart`.
+
+abstract class _$SortPreferenceNotifier extends $Notifier<TaskSortOption> {
+  TaskSortOption build();
+  @$mustCallSuper
+  @override
+  void runBuild() {
+    final ref = this.ref as $Ref<TaskSortOption, TaskSortOption>;
+    final element =
+        ref.element
+            as $ClassProviderElement<
+              AnyNotifier<TaskSortOption, TaskSortOption>,
+              TaskSortOption,
+              Object?,
+              Object?
+            >;
+    element.handleCreate(ref, build);
+  }
+}
--- a/lib/features/tasks/presentation/task_form_screen.dart
+++ b/lib/features/tasks/presentation/task_form_screen.dart
@@ -10,6 +10,7 @@ import '../../../core/providers/database_provider.dart';
 import '../../../l10n/app_localizations.dart';
 import '../domain/effort_level.dart';
 import '../domain/frequency.dart';
+import 'task_history_sheet.dart';
 import 'task_providers.dart';

 /// Full-screen form for task creation and editing.
@@ -186,6 +187,21 @@ class _TaskFormScreenState extends ConsumerState<TaskFormScreen> {
            ),
            const SizedBox(height: 8),
            _buildDueDatePicker(theme),
+
+            // History section (edit mode only)
+            if (widget.isEditing) ...[
+              const SizedBox(height: 24),
+              const Divider(),
+              ListTile(
+                leading: const Icon(Icons.history),
+                title: Text(l10n.taskHistoryTitle),
+                trailing: const Icon(Icons.chevron_right),
+                onTap: () => showTaskHistorySheet(
+                  context: context,
+                  taskId: widget.taskId!,
+                ),
+              ),
+            ],
          ],
        ),
      ),
--- a/lib/features/tasks/presentation/task_history_sheet.dart
+++ b/lib/features/tasks/presentation/task_history_sheet.dart
@@ -0,0 +1,136 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:intl/intl.dart';
+
+import '../../../core/database/database.dart';
+import '../../../core/providers/database_provider.dart';
+import '../../../l10n/app_localizations.dart';
+
+/// Shows a modal bottom sheet displaying the completion history for a task.
+///
+/// The sheet displays all past completions in reverse-chronological order
+/// (newest first). If the task has never been completed, an empty state is shown.
+Future<void> showTaskHistorySheet({
+  required BuildContext context,
+  required int taskId,
+}) {
+  return showModalBottomSheet<void>(
+    context: context,
+    isScrollControlled: true,
+    builder: (context) => _TaskHistorySheet(taskId: taskId),
+  );
+}
+
+class _TaskHistorySheet extends ConsumerWidget {
+  const _TaskHistorySheet({required this.taskId});
+
+  final int taskId;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+    final l10n = AppLocalizations.of(context);
+
+    return SafeArea(
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            // Drag handle
+            Container(
+              width: 32,
+              height: 4,
+              margin: const EdgeInsets.only(bottom: 16),
+              decoration: BoxDecoration(
+                color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4),
+                borderRadius: BorderRadius.circular(2),
+              ),
+            ),
+            // Title
+            Text(
+              l10n.taskHistoryTitle,
+              style: theme.textTheme.titleMedium,
+            ),
+            const SizedBox(height: 16),
+            // Completion list via StreamBuilder
+            StreamBuilder<List<TaskCompletion>>(
+              stream: ref
+                  .read(appDatabaseProvider)
+                  .tasksDao
+                  .watchCompletionsForTask(taskId),
+              builder: (context, snapshot) {
+                if (!snapshot.hasData) {
+                  return const Center(child: CircularProgressIndicator());
+                }
+
+                final completions = snapshot.data!;
+
+                if (completions.isEmpty) {
+                  return Column(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      Icon(
+                        Icons.history,
+                        size: 48,
+                        color: colorScheme.onSurfaceVariant,
+                      ),
+                      const SizedBox(height: 8),
+                      Text(
+                        l10n.taskHistoryEmpty,
+                        style: theme.textTheme.bodyLarge?.copyWith(
+                          color: colorScheme.onSurfaceVariant,
+                        ),
+                      ),
+                    ],
+                  );
+                }
+
+                // Show count summary
+                return Column(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Text(
+                      l10n.taskHistoryCount(completions.length),
+                      style: theme.textTheme.bodyMedium?.copyWith(
+                        color: colorScheme.onSurfaceVariant,
+                      ),
+                    ),
+                    const SizedBox(height: 8),
+                    ConstrainedBox(
+                      constraints: BoxConstraints(
+                        maxHeight:
+                            MediaQuery.of(context).size.height * 0.4,
+                      ),
+                      child: ListView.builder(
+                        shrinkWrap: true,
+                        itemCount: completions.length,
+                        itemBuilder: (context, index) {
+                          final completion = completions[index];
+                          final dateStr = DateFormat('dd.MM.yyyy', 'de')
+                              .format(completion.completedAt);
+                          final timeStr = DateFormat('HH:mm', 'de')
+                              .format(completion.completedAt);
+                          return ListTile(
+                            leading: Icon(
+                              Icons.check_circle_outline,
+                              color: colorScheme.primary,
+                            ),
+                            title: Text(dateStr),
+                            subtitle: Text(timeStr),
+                          );
+                        },
+                      ),
+                    ),
+                  ],
+                );
+              },
+            ),
+            const SizedBox(height: 8),
+          ],
+        ),
+      ),
+    );
+  }
+}
--- a/lib/features/tasks/presentation/task_list_screen.dart
+++ b/lib/features/tasks/presentation/task_list_screen.dart
@@ -4,6 +4,7 @@ import 'package:go_router/go_router.dart';

 import 'package:household_keeper/core/database/database.dart';
 import 'package:household_keeper/core/providers/database_provider.dart';
+import 'package:household_keeper/features/tasks/presentation/sort_dropdown.dart';
 import 'package:household_keeper/features/tasks/presentation/task_providers.dart';
 import 'package:household_keeper/features/tasks/presentation/task_row.dart';
 import 'package:household_keeper/l10n/app_localizations.dart';
@@ -27,6 +28,7 @@ class TaskListScreen extends ConsumerWidget {
      appBar: AppBar(
        title: _RoomTitle(roomId: roomId),
        actions: [
+          const SortDropdown(),
          IconButton(
            icon: const Icon(Icons.edit),
            onPressed: () => context.go('/rooms/$roomId/edit'),
--- a/lib/features/tasks/presentation/task_providers.dart
+++ b/lib/features/tasks/presentation/task_providers.dart
@@ -6,17 +6,44 @@ import 'package:household_keeper/core/database/database.dart';
 import 'package:household_keeper/core/providers/database_provider.dart';
 import 'package:household_keeper/features/tasks/domain/effort_level.dart';
 import 'package:household_keeper/features/tasks/domain/frequency.dart';
+import 'package:household_keeper/features/tasks/domain/task_sort_option.dart';
+import 'package:household_keeper/features/tasks/presentation/sort_preference_notifier.dart';

 part 'task_providers.g.dart';

-/// Stream provider family for tasks in a specific room, sorted by due date.
+/// Sort a list of [Task] by the given [sortOption].
+///
+/// Returns a new sorted list; never mutates the original.
+List<Task> _sortTasksRaw(List<Task> tasks, TaskSortOption sortOption) {
+  final sorted = List<Task>.from(tasks);
+  switch (sortOption) {
+    case TaskSortOption.alphabetical:
+      sorted.sort((a, b) => a.name.toLowerCase().compareTo(
+            b.name.toLowerCase(),
+          ));
+    case TaskSortOption.interval:
+      sorted.sort((a, b) {
+        final cmp = a.intervalType.index.compareTo(b.intervalType.index);
+        if (cmp != 0) return cmp;
+        return a.intervalDays.compareTo(b.intervalDays);
+      });
+    case TaskSortOption.effort:
+      sorted.sort((a, b) => a.effortLevel.index.compareTo(b.effortLevel.index));
+  }
+  return sorted;
+}
+
+/// Stream provider family for tasks in a specific room, sorted by active sort preference.
 ///
 /// Defined manually because riverpod_generator has trouble with drift's
 /// generated [Task] type in family provider return types.
 final tasksInRoomProvider =
    StreamProvider.family.autoDispose<List<Task>, int>((ref, roomId) {
  final db = ref.watch(appDatabaseProvider);
-  return db.tasksDao.watchTasksInRoom(roomId);
+  final sortOption = ref.watch(sortPreferenceProvider);
+  return db.tasksDao
+      .watchTasksInRoom(roomId)
+      .map((tasks) => _sortTasksRaw(tasks, sortOption));
 });

 /// Notifier for task mutations: create, update, delete, complete.
--- a/lib/l10n/app_de.arb
+++ b/lib/l10n/app_de.arb
@@ -107,5 +107,17 @@
      "overdue": { "type": "int" }
    }
  },
-  "calendarTodayButton": "Heute"
+  "calendarTodayButton": "Heute",
+  "taskHistoryTitle": "Verlauf",
+  "taskHistoryEmpty": "Noch nie erledigt",
+  "taskHistoryCount": "{count} Mal erledigt",
+  "@taskHistoryCount": {
+    "placeholders": {
+      "count": { "type": "int" }
+    }
+  },
+  "sortAlphabetical": "A\u2013Z",
+  "sortInterval": "Intervall",
+  "sortEffort": "Aufwand",
+  "sortLabel": "Sortierung"
 }
--- a/lib/l10n/app_localizations.dart
+++ b/lib/l10n/app_localizations.dart
@@ -519,6 +519,48 @@ abstract class AppLocalizations {
  /// In de, this message translates to:
  /// **'Heute'**
  String get calendarTodayButton;
+
+  /// No description provided for @taskHistoryTitle.
+  ///
+  /// In de, this message translates to:
+  /// **'Verlauf'**
+  String get taskHistoryTitle;
+
+  /// No description provided for @taskHistoryEmpty.
+  ///
+  /// In de, this message translates to:
+  /// **'Noch nie erledigt'**
+  String get taskHistoryEmpty;
+
+  /// No description provided for @taskHistoryCount.
+  ///
+  /// In de, this message translates to:
+  /// **'{count} Mal erledigt'**
+  String taskHistoryCount(int count);
+
+  /// No description provided for @sortAlphabetical.
+  ///
+  /// In de, this message translates to:
+  /// **'A–Z'**
+  String get sortAlphabetical;
+
+  /// No description provided for @sortInterval.
+  ///
+  /// In de, this message translates to:
+  /// **'Intervall'**
+  String get sortInterval;
+
+  /// No description provided for @sortEffort.
+  ///
+  /// In de, this message translates to:
+  /// **'Aufwand'**
+  String get sortEffort;
+
+  /// No description provided for @sortLabel.
+  ///
+  /// In de, this message translates to:
+  /// **'Sortierung'**
+  String get sortLabel;
 }

 class _AppLocalizationsDelegate
--- a/lib/l10n/app_localizations_de.dart
+++ b/lib/l10n/app_localizations_de.dart
@@ -239,4 +239,27 @@ class AppLocalizationsDe extends AppLocalizations {

  @override
  String get calendarTodayButton => 'Heute';
+
+  @override
+  String get taskHistoryTitle => 'Verlauf';
+
+  @override
+  String get taskHistoryEmpty => 'Noch nie erledigt';
+
+  @override
+  String taskHistoryCount(int count) {
+    return '$count Mal erledigt';
+  }
+
+  @override
+  String get sortAlphabetical => 'A–Z';
+
+  @override
+  String get sortInterval => 'Intervall';
+
+  @override
+  String get sortEffort => 'Aufwand';
+
+  @override
+  String get sortLabel => 'Sortierung';
 }
--- a/test/features/home/presentation/home_screen_test.dart
+++ b/test/features/home/presentation/home_screen_test.dart
@@ -10,6 +10,8 @@ import 'package:household_keeper/features/home/presentation/calendar_providers.d
 import 'package:household_keeper/features/rooms/presentation/room_providers.dart';
 import 'package:household_keeper/features/tasks/domain/effort_level.dart';
 import 'package:household_keeper/features/tasks/domain/frequency.dart';
+import 'package:household_keeper/features/tasks/domain/task_sort_option.dart';
+import 'package:household_keeper/features/tasks/presentation/sort_preference_notifier.dart';
 import 'package:household_keeper/l10n/app_localizations.dart';
 import 'package:household_keeper/features/home/domain/daily_plan_models.dart';

@@ -65,6 +67,7 @@ Widget _buildApp(CalendarDayState dayState) {
    roomWithStatsListProvider.overrideWith(
      (ref) => Stream.value([]),
    ),
+    sortPreferenceProvider.overrideWith(SortPreferenceNotifier.new),
  ]);

  return UncontrolledProviderScope(
@@ -238,4 +241,38 @@ void main() {
      expect(find.byType(ListView), findsWidgets);
    });
  });
+
+  group('HomeScreen sort dropdown', () {
+    testWidgets('shows sort dropdown in AppBar', (tester) async {
+      await tester.pumpWidget(_buildApp(CalendarDayState(
+        selectedDate: today,
+        dayTasks: const [],
+        overdueTasks: const [],
+        totalTaskCount: 0,
+      )));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 500));
+
+      // SortDropdown wraps a PopupMenuButton<TaskSortOption>
+      expect(
+        find.byType(PopupMenuButton<TaskSortOption>),
+        findsOneWidget,
+      );
+    });
+
+    testWidgets('shows AppBar with title', (tester) async {
+      await tester.pumpWidget(_buildApp(CalendarDayState(
+        selectedDate: today,
+        dayTasks: const [],
+        overdueTasks: const [],
+        totalTaskCount: 0,
+      )));
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 500));
+
+      // tabHome l10n string is 'Übersicht'. It appears in the AppBar title
+      // and also in the bottom navigation bar label — use findsWidgets.
+      expect(find.text('\u00dcbersicht'), findsWidgets);
+    });
+  });
 }
--- a/test/features/tasks/data/task_history_dao_test.dart
+++ b/test/features/tasks/data/task_history_dao_test.dart
@@ -0,0 +1,157 @@
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:household_keeper/core/database/database.dart';
+import 'package:household_keeper/features/tasks/domain/effort_level.dart';
+import 'package:household_keeper/features/tasks/domain/frequency.dart';
+
+void main() {
+  late AppDatabase db;
+  late int roomId;
+
+  setUp(() async {
+    db = AppDatabase(NativeDatabase.memory());
+    roomId = await db.roomsDao.insertRoom(
+      RoomsCompanion.insert(name: 'Kueche', iconName: 'kitchen'),
+    );
+  });
+
+  tearDown(() async {
+    await db.close();
+  });
+
+  group('TasksDao.watchCompletionsForTask', () {
+    test('returns empty list when task has no completions', () async {
+      final taskId = await db.tasksDao.insertTask(
+        TasksCompanion.insert(
+          roomId: roomId,
+          name: 'Staubsaugen',
+          intervalType: IntervalType.weekly,
+          effortLevel: EffortLevel.medium,
+          nextDueDate: DateTime(2026, 3, 15),
+        ),
+      );
+
+      final completions =
+          await db.tasksDao.watchCompletionsForTask(taskId).first;
+
+      expect(completions, isEmpty);
+    });
+
+    test('returns completion after completeTask is called', () async {
+      final taskId = await db.tasksDao.insertTask(
+        TasksCompanion.insert(
+          roomId: roomId,
+          name: 'Abspuelen',
+          intervalType: IntervalType.daily,
+          effortLevel: EffortLevel.low,
+          nextDueDate: DateTime(2026, 3, 15),
+        ),
+      );
+
+      final completionTime = DateTime(2026, 3, 15, 10, 30);
+      await db.tasksDao.completeTask(taskId, now: completionTime);
+
+      final completions =
+          await db.tasksDao.watchCompletionsForTask(taskId).first;
+
+      expect(completions.length, 1);
+      expect(completions.first.taskId, taskId);
+      expect(completions.first.completedAt, completionTime);
+    });
+
+    test('returns multiple completions in reverse-chronological order', () async {
+      final taskId = await db.tasksDao.insertTask(
+        TasksCompanion.insert(
+          roomId: roomId,
+          name: 'Fenster putzen',
+          intervalType: IntervalType.monthly,
+          effortLevel: EffortLevel.high,
+          nextDueDate: DateTime(2026, 1, 1),
+        ),
+      );
+
+      // Complete multiple times with specific timestamps
+      final time1 = DateTime(2026, 1, 10, 9, 0);
+      final time2 = DateTime(2026, 2, 12, 14, 30);
+      final time3 = DateTime(2026, 3, 15, 8, 0);
+
+      // Insert out of order to verify ordering is enforced by query
+      await db.tasksDao.completeTask(taskId, now: time1);
+      await db.tasksDao.completeTask(taskId, now: time2);
+      await db.tasksDao.completeTask(taskId, now: time3);
+
+      final completions =
+          await db.tasksDao.watchCompletionsForTask(taskId).first;
+
+      expect(completions.length, 3);
+      // Newest first (reverse-chronological)
+      expect(completions[0].completedAt, time3);
+      expect(completions[1].completedAt, time2);
+      expect(completions[2].completedAt, time1);
+    });
+
+    test('completions for different tasks are isolated', () async {
+      final taskId1 = await db.tasksDao.insertTask(
+        TasksCompanion.insert(
+          roomId: roomId,
+          name: 'Task A',
+          intervalType: IntervalType.daily,
+          effortLevel: EffortLevel.low,
+          nextDueDate: DateTime(2026, 3, 15),
+        ),
+      );
+
+      final taskId2 = await db.tasksDao.insertTask(
+        TasksCompanion.insert(
+          roomId: roomId,
+          name: 'Task B',
+          intervalType: IntervalType.daily,
+          effortLevel: EffortLevel.low,
+          nextDueDate: DateTime(2026, 3, 15),
+        ),
+      );
+
+      await db.tasksDao.completeTask(taskId1, now: DateTime(2026, 3, 15));
+
+      final completionsForTask1 =
+          await db.tasksDao.watchCompletionsForTask(taskId1).first;
+      final completionsForTask2 =
+          await db.tasksDao.watchCompletionsForTask(taskId2).first;
+
+      expect(completionsForTask1.length, 1);
+      expect(completionsForTask1.first.taskId, taskId1);
+      expect(completionsForTask2, isEmpty);
+    });
+
+    test('stream emits updated list after new completion is added', () async {
+      final taskId = await db.tasksDao.insertTask(
+        TasksCompanion.insert(
+          roomId: roomId,
+          name: 'Bodenwischen',
+          intervalType: IntervalType.weekly,
+          effortLevel: EffortLevel.medium,
+          nextDueDate: DateTime(2026, 3, 15),
+        ),
+      );
+
+      // Collect stream emissions
+      final emissions = <List<TaskCompletion>>[];
+      final subscription = db.tasksDao
+          .watchCompletionsForTask(taskId)
+          .listen(emissions.add);
+
+      // Wait for initial empty emission
+      await Future<void>.delayed(const Duration(milliseconds: 50));
+      expect(emissions.isNotEmpty, isTrue);
+      expect(emissions.last, isEmpty);
+
+      // Complete the task
+      await db.tasksDao.completeTask(taskId, now: DateTime(2026, 3, 15, 9, 0));
+      await Future<void>.delayed(const Duration(milliseconds: 50));
+
+      expect(emissions.last.length, 1);
+
+      await subscription.cancel();
+    });
+  });
+}
--- a/test/features/tasks/presentation/sort_preference_notifier_test.dart
+++ b/test/features/tasks/presentation/sort_preference_notifier_test.dart
@@ -0,0 +1,101 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import 'package:household_keeper/features/tasks/domain/task_sort_option.dart';
+import 'package:household_keeper/features/tasks/presentation/sort_preference_notifier.dart';
+
+/// Helper: create a container and wait for the initial async _loadPersisted()
+/// to finish.
+Future<ProviderContainer> makeContainer() async {
+  final container = ProviderContainer();
+  // Trigger build
+  container.read(sortPreferenceProvider);
+  // Allow the async _loadPersisted() to complete
+  await Future<void>.delayed(Duration.zero);
+  return container;
+}
+
+void main() {
+  setUp(() {
+    SharedPreferences.setMockInitialValues({});
+  });
+
+  group('SortPreferenceNotifier', () {
+    test('build() returns default state of alphabetical', () async {
+      final container = ProviderContainer();
+      addTearDown(container.dispose);
+
+      final state = container.read(sortPreferenceProvider);
+
+      expect(state, TaskSortOption.alphabetical);
+    });
+
+    test('setSortOption(interval) updates state to interval', () async {
+      final container = await makeContainer();
+      addTearDown(container.dispose);
+
+      await container
+          .read(sortPreferenceProvider.notifier)
+          .setSortOption(TaskSortOption.interval);
+
+      expect(container.read(sortPreferenceProvider), TaskSortOption.interval);
+    });
+
+    test('setSortOption(effort) updates state to effort', () async {
+      final container = await makeContainer();
+      addTearDown(container.dispose);
+
+      await container
+          .read(sortPreferenceProvider.notifier)
+          .setSortOption(TaskSortOption.effort);
+
+      expect(container.read(sortPreferenceProvider), TaskSortOption.effort);
+    });
+
+    test('setSortOption persists to SharedPreferences', () async {
+      final container = await makeContainer();
+      addTearDown(container.dispose);
+
+      await container
+          .read(sortPreferenceProvider.notifier)
+          .setSortOption(TaskSortOption.effort);
+
+      final prefs = await SharedPreferences.getInstance();
+      expect(prefs.getString('task_sort_option'), 'effort');
+    });
+
+    test('persisted value is loaded on restart (effort)', () async {
+      SharedPreferences.setMockInitialValues({
+        'task_sort_option': 'effort',
+      });
+
+      final container = await makeContainer();
+      addTearDown(container.dispose);
+
+      expect(container.read(sortPreferenceProvider), TaskSortOption.effort);
+    });
+
+    test('persisted value is loaded on restart (interval)', () async {
+      SharedPreferences.setMockInitialValues({
+        'task_sort_option': 'interval',
+      });
+
+      final container = await makeContainer();
+      addTearDown(container.dispose);
+
+      expect(container.read(sortPreferenceProvider), TaskSortOption.interval);
+    });
+
+    test('unknown persisted value falls back to alphabetical', () async {
+      SharedPreferences.setMockInitialValues({
+        'task_sort_option': 'unknown_value',
+      });
+
+      final container = await makeContainer();
+      addTearDown(container.dispose);
+
+      expect(container.read(sortPreferenceProvider), TaskSortOption.alphabetical);
+    });
+  });
+}
--- a/test/shell/app_shell_test.dart
+++ b/test/shell/app_shell_test.dart
@@ -63,8 +63,9 @@ void main() {
      // Verify 3 NavigationDestination widgets are rendered
      expect(find.byType(NavigationDestination), findsNWidgets(3));

-      // Verify correct German labels from ARB (with umlauts)
-      expect(find.text('\u00dcbersicht'), findsOneWidget);
+      // Verify correct German labels from ARB (with umlauts).
+      // 'Übersicht' appears in both the bottom nav and the HomeScreen AppBar.
+      expect(find.text('\u00dcbersicht'), findsWidgets);
      expect(find.text('R\u00e4ume'), findsOneWidget);
      expect(find.text('Einstellungen'), findsOneWidget);
    });
Author	SHA1	Message	Date
Jean-Luc Makiola	0ea79e0853	docs(phase-07): complete phase execution All checks were successful Build and Release to F-Droid / build-and-deploy (push) Successful in 10m29s Details Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-16 22:43:41 +01:00
Jean-Luc Makiola	772034cba1	docs(07-02): complete sort dropdown UI plan - 07-02-SUMMARY.md: SortDropdown widget wired into HomeScreen and TaskListScreen AppBars - STATE.md: updated metrics, decisions, session record - ROADMAP.md: Phase 7 complete (2/2 plans done)	2026-03-16 22:40:39 +01:00
Jean-Luc Makiola	a3e4d0224b	feat(07-02): add sort dropdown tests to HomeScreen and fix AppShell test regression - Add sortPreferenceProvider override to _buildApp test helper - Add 'HomeScreen sort dropdown' test group: verifies PopupMenuButton<TaskSortOption> and AppBar title - Fix app_shell_test: expect findsWidgets for 'Übersicht' since AppBar title now also shows it - 115 tests pass total (113 existing + 2 new)	2026-03-16 22:39:18 +01:00
Jean-Luc Makiola	e5eccb74e5	feat(07-02): build SortDropdown widget and integrate into HomeScreen and TaskListScreen - Create SortDropdown ConsumerWidget using PopupMenuButton<TaskSortOption> - Displays current sort label with sort icon in AppBar actions - Check mark shown on active option via Opacity widget - Add Scaffold with AppBar (title: Übersicht, actions: SortDropdown) to HomeScreen - Add SortDropdown before edit/delete IconButtons in TaskListScreen AppBar	2026-03-16 22:37:18 +01:00
Jean-Luc Makiola	9398193c1e	docs(07-01): complete task sort domain and provider plan	2026-03-16 22:35:01 +01:00
Jean-Luc Makiola	3697e4efc4	feat(07-01): integrate sort logic into calendarDayProvider and tasksInRoomProvider - calendarDayProvider watches sortPreferenceProvider and sorts dayTasks - overdueTasks intentionally unsorted (pinned at top per design decision) - tasksInRoomProvider watches sortPreferenceProvider and sorts via stream.map - _sortTasks helper (TaskWithRoom) and _sortTasksRaw helper (Task) both support: - alphabetical: case-insensitive A-Z by name - interval: by intervalType.index ascending, intervalDays as tiebreaker - effort: by effortLevel.index ascending (low→medium→high) - All 113 tests pass, analyze clean	2026-03-16 22:33:34 +01:00
Jean-Luc Makiola	13c7d623ba	feat(07-01): create TaskSortOption enum, SortPreferenceNotifier, and localization strings - TaskSortOption enum with alphabetical, interval, effort values - SortPreferenceNotifier persists sort preference to SharedPreferences - Follows ThemeNotifier pattern: sync default (alphabetical), async load - Generated sort_preference_notifier.g.dart via build_runner - Added sortAlphabetical/sortInterval/sortEffort/sortLabel to app_de.arb - Regenerated app_localizations.dart and app_localizations_de.dart	2026-03-16 22:32:06 +01:00
Jean-Luc Makiola	a9f298350e	test(07-01): add failing tests for SortPreferenceNotifier - Tests cover default state (alphabetical) - Tests cover setSortOption state update - Tests cover SharedPreferences persistence - Tests cover persisted value loaded on restart - Tests cover unknown persisted value fallback	2026-03-16 22:30:05 +01:00
Jean-Luc Makiola	a44f2b80b5	fix(07): remove invalid -x flag from Task 1 verify command	2026-03-16 22:26:50 +01:00
Jean-Luc Makiola	27f18d4f39	docs(07-task-sorting): create phase plan	2026-03-16 22:23:24 +01:00
Jean-Luc Makiola	a94d41b7f7	docs(state): record phase 7 context session	2026-03-16 22:14:31 +01:00
Jean-Luc Makiola	99358ed704	docs(07): capture phase context	2026-03-16 22:14:13 +01:00
Jean-Luc Makiola	2a4b14cb43	chore(release): improve F-Droid release workflow for repo persistence - Download entire `fdroid/` directory from Hetzner to retain older APKs, repo keystore, and config.yml. - Add steps to ensure repo signing key and icons during initialization. - Adjust SCP upload to include the entire `fdroid/` directory for better state continuity.	2026-03-16 22:13:32 +01:00
Jean-Luc Makiola	7a2c1b81de	docs(phase-06): complete phase execution	2026-03-16 22:02:03 +01:00
Jean-Luc Makiola	7344933278	docs(06-01): complete task history plan - Create 06-01-SUMMARY.md with full execution documentation - Update STATE.md: Phase 6 Plan 1 complete, decisions recorded - Update ROADMAP.md: Phase 6 marked complete (1/1 plans) - Mark HIST-01 and HIST-02 requirements complete	2026-03-16 21:59:00 +01:00
Jean-Luc Makiola	9f902ff2c7	feat(06-01): build task history sheet, wire into TaskFormScreen, add CalendarTaskRow navigation - Create task_history_sheet.dart: showTaskHistorySheet() modal bottom sheet - Sheet uses StreamBuilder on watchCompletionsForTask, shows dates in dd.MM.yyyy + HH:mm format - Empty state: Icons.history + 'Noch nie erledigt' message - Count summary shown above list when completions exist - Add Verlauf ListTile to TaskFormScreen (edit mode only) opening history sheet - Add onTap to CalendarTaskRow navigating to /rooms/:roomId/tasks/:taskId - All 106 tests pass, zero analyze issues	2026-03-16 21:57:11 +01:00
Jean-Luc Makiola	ceae7d7d61	feat(06-01): add watchCompletionsForTask DAO method and history localization strings - Add watchCompletionsForTask(taskId) to TasksDao: Stream<List<TaskCompletion>> sorted newest first - Regenerate tasks_dao.g.dart with build_runner - Add taskHistoryTitle, taskHistoryEmpty, taskHistoryCount to app_de.arb - Regenerate app_localizations.dart and app_localizations_de.dart - All 5 new DAO tests pass, zero analyze issues	2026-03-16 21:55:44 +01:00
Jean-Luc Makiola	2687f5e31e	test(06-01): add failing tests for watchCompletionsForTask DAO method - Tests cover empty state, single completion, multiple completions in reverse order - Tests cover task isolation (different taskIds do not cross-contaminate) - Tests cover stream reactivity (new completion triggers emission)	2026-03-16 21:53:21 +01:00