summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--docs/superpowers/plans/2026-07-16-task-budgets-and-availability.md2393
1 files changed, 2393 insertions, 0 deletions
diff --git a/docs/superpowers/plans/2026-07-16-task-budgets-and-availability.md b/docs/superpowers/plans/2026-07-16-task-budgets-and-availability.md
new file mode 100644
index 0000000..24f1d6a
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-16-task-budgets-and-availability.md
@@ -0,0 +1,2393 @@
+# Task Budgets and Availability Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Let a user mark doot-native projects/labels as "budget-tracked," give tasks time estimates, define a weekly availability template, and see a purely-informational "scheduled vs. available" flag on today's and this week's load — no auto-scheduling, no auto-reprioritization.
+
+**Architecture:** New `availability_blocks` table (manual weekly template) plus `estimated_minutes` on `native_tasks` and `budget_tracked` flags on `projects`/`labels`. A pure Go function subtracts overlapping calendar events from availability and sums estimates for tracked, due tasks — computed on read inside the existing `/api/widget` and web-timeline request paths, no new background job. Surfaced as a small indicator in the web timeline and a compact badge on the widget's TODAY header.
+
+**Tech Stack:** Go (chi router, `database/sql` + sqlite3), HTMX/Tailwind templates, Kotlin/Jetpack Glance (Android widget).
+
+## Global Constraints
+
+- doot-native tasks only — Trello cards, Google Tasks, and calendar events never participate in budget tracking.
+- Budget tracking is opt-in per project/label; untracked tasks are invisible to this feature (default experience unchanged).
+- No auto-scheduling, no auto-reprioritization — the flag is purely informational.
+- No new background job — computed on read at the same points `BuildTimeline`/`HandleWidgetGet`/`HandleTimeline` already run.
+- All schema changes go in `migrations/` as a new file; migrations run alphabetically by filename via `filepath.Glob` + `sort.Strings` (see `internal/store/sqlite.go`).
+- SQL: parameterized queries only (`?` placeholders), never string-interpolated values.
+- Validate with `go test ./...` (Go) after every task; Android tasks are validated by inspection since no Android test harness runs in this plan.
+
+---
+
+### Task 1: Migration — schema changes
+
+**Files:**
+- Create: `migrations/025_task_budgets_and_availability.sql`
+- Modify: `internal/store/sqlite_test.go:169-183` (`setupTestStoreWithNativeTasks` schema string)
+- Modify: `internal/store/native_tasks_test.go:27-67` (`newNativeTasksTestStore` schema strings)
+
+**Interfaces:**
+- Produces: table `availability_blocks(id, weekday, start_time, end_time, label)`; `native_tasks.estimated_minutes INTEGER DEFAULT 0`; `projects.budget_tracked BOOLEAN DEFAULT 0`; `labels.budget_tracked BOOLEAN DEFAULT 0`.
+
+- [ ] **Step 1: Write the migration**
+
+```sql
+-- migrations/025_task_budgets_and_availability.sql
+-- Opt-in time-budget visibility: a manual weekly availability template,
+-- per-task time estimates, and a budget-tracked flag on projects/labels so
+-- only tasks the user has opted in count against any budget calculation.
+CREATE TABLE availability_blocks (
+ id TEXT PRIMARY KEY,
+ weekday INTEGER NOT NULL, -- 0-6, Sun-Sat
+ start_time TEXT NOT NULL, -- "18:00"
+ end_time TEXT NOT NULL, -- "20:00"
+ label TEXT DEFAULT ''
+);
+
+ALTER TABLE native_tasks ADD COLUMN estimated_minutes INTEGER DEFAULT 0;
+ALTER TABLE projects ADD COLUMN budget_tracked BOOLEAN DEFAULT 0;
+ALTER TABLE labels ADD COLUMN budget_tracked BOOLEAN DEFAULT 0;
+```
+
+- [ ] **Step 2: Update the hand-rolled test schemas so store-level unit tests keep working**
+
+In `internal/store/sqlite_test.go`, `setupTestStoreWithNativeTasks` builds its own `CREATE TABLE native_tasks` (it doesn't run real migrations). This schema string is currently missing `project_id` (a pre-existing baseline bug from an earlier feature that was never backported here — `go test ./internal/store/...` currently fails two tests with "table native_tasks has no column named project_id"; confirm this yourself with that command before editing, so you're not chasing a regression you introduced). Fix that gap and add the new column in the same edit:
+
+```go
+ schema := `
+ CREATE TABLE IF NOT EXISTS native_tasks (
+ id TEXT PRIMARY KEY,
+ content TEXT NOT NULL,
+ description TEXT DEFAULT '',
+ project_name TEXT DEFAULT '',
+ project_id TEXT DEFAULT '',
+ due_date DATETIME,
+ priority INTEGER DEFAULT 1,
+ completed BOOLEAN DEFAULT 0,
+ labels TEXT DEFAULT '[]',
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+ updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+ recurrence_freq TEXT DEFAULT '',
+ recurrence_interval INTEGER DEFAULT 1,
+ recurrence_weekdays TEXT DEFAULT '',
+ recurrence_series_id TEXT DEFAULT '',
+ next_occurrence_override TEXT DEFAULT '',
+ estimated_minutes INTEGER DEFAULT 0
+ );
+ `
+```
+(this replaces the entire existing `schema := \`...\`` string in that function — same variable, same surrounding function, just the two added columns: `project_id` and `estimated_minutes`)
+
+In `internal/store/native_tasks_test.go`, `newNativeTasksTestStore` builds three tables by hand. Update all three:
+
+```go
+ if _, err := db.Exec(`
+ CREATE TABLE native_tasks (
+ id TEXT PRIMARY KEY,
+ content TEXT NOT NULL,
+ description TEXT DEFAULT '',
+ project_name TEXT DEFAULT '',
+ project_id TEXT DEFAULT '',
+ due_date DATETIME,
+ priority INTEGER DEFAULT 1,
+ completed BOOLEAN DEFAULT 0,
+ labels TEXT DEFAULT '[]',
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+ updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+ recurrence_freq TEXT DEFAULT '',
+ recurrence_interval INTEGER DEFAULT 1,
+ recurrence_weekdays TEXT DEFAULT '',
+ recurrence_series_id TEXT DEFAULT '',
+ next_occurrence_override TEXT DEFAULT '',
+ estimated_minutes INTEGER DEFAULT 0
+ )
+ `); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := db.Exec(`
+ CREATE TABLE projects (
+ id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ color TEXT DEFAULT '',
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+ archived BOOLEAN DEFAULT 0,
+ budget_tracked BOOLEAN DEFAULT 0
+ )
+ `); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := db.Exec(`
+ CREATE TABLE labels (
+ name TEXT PRIMARY KEY,
+ color TEXT NOT NULL,
+ budget_tracked BOOLEAN DEFAULT 0
+ )
+ `); err != nil {
+ t.Fatal(err)
+ }
+```
+
+- [ ] **Step 3: Add a minimal availability-only test store helper**
+
+Create `internal/store/availability_test.go` with just enough schema for the availability CRUD tests in Task 4 (kept separate since availability doesn't need native_tasks/projects/labels):
+
+```go
+package store
+
+import (
+ "database/sql"
+ "path/filepath"
+ "testing"
+
+ _ "github.com/mattn/go-sqlite3"
+)
+
+// newAvailabilityTestStore creates a Store backed by a fresh temp sqlite DB
+// with just the availability_blocks table.
+func newAvailabilityTestStore(t *testing.T) *Store {
+ t.Helper()
+ dbPath := filepath.Join(t.TempDir(), "test.db")
+ db, err := sql.Open("sqlite3", dbPath)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { db.Close() })
+ if _, err := db.Exec(`
+ CREATE TABLE availability_blocks (
+ id TEXT PRIMARY KEY,
+ weekday INTEGER NOT NULL,
+ start_time TEXT NOT NULL,
+ end_time TEXT NOT NULL,
+ label TEXT DEFAULT ''
+ )
+ `); err != nil {
+ t.Fatal(err)
+ }
+ return &Store{db: db}
+}
+```
+
+- [ ] **Step 4: Run the full suite to confirm nothing broke**
+
+Run: `go test ./internal/store/... -v`
+Expected: All existing tests still PASS (the new columns default harmlessly; no test yet references them).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add migrations/025_task_budgets_and_availability.sql internal/store/sqlite_test.go internal/store/native_tasks_test.go internal/store/availability_test.go
+git commit -m "Add schema for task budgets and availability blocks"
+```
+
+---
+
+### Task 2: Models
+
+**Files:**
+- Modify: `internal/models/types.go` (Task, Project, LabelColor structs)
+- Create: `internal/models/budget.go`
+
+**Interfaces:**
+- Consumes: nothing new.
+- Produces: `models.Task.EstimatedMinutes int`; `models.Project.BudgetTracked bool`; `models.LabelColor.BudgetTracked bool`; `models.AvailabilityBlock{ID, Weekday, StartTime, EndTime, Label}`; `models.BudgetPeriod{ScheduledMinutes, AvailableMinutes int}`; `models.BudgetStatus{Today, Week BudgetPeriod}`.
+
+- [ ] **Step 1: Add fields to existing structs**
+
+In `internal/models/types.go`, add `EstimatedMinutes` to `Task` (after `Labels`):
+
+```go
+ Labels []string `json:"labels"`
+ EstimatedMinutes int `json:"estimated_minutes,omitempty"`
+ URL string `json:"url"`
+```
+
+Add `BudgetTracked` to `Project` (after `Archived`):
+
+```go
+type Project struct {
+ ID string `json:"id"`
+ Name string `json:"name"`
+ Color string `json:"color"`
+ CreatedAt time.Time `json:"created_at"`
+ Archived bool `json:"archived"`
+ BudgetTracked bool `json:"budget_tracked"`
+}
+```
+
+Add `BudgetTracked` to `LabelColor`:
+
+```go
+type LabelColor struct {
+ Name string `json:"name"`
+ Color string `json:"color"`
+ BudgetTracked bool `json:"budget_tracked"`
+}
+```
+
+- [ ] **Step 2: Create the new budget model file**
+
+```go
+// internal/models/budget.go
+package models
+
+// AvailabilityBlock is one recurring weekly window of time the user has
+// manually declared as available (e.g. "weekday evenings 18:00-20:00").
+// Reduced by real calendar events at computation time -- see
+// handlers.ComputeBudgetPeriod.
+type AvailabilityBlock struct {
+ ID string `json:"id"`
+ Weekday int `json:"weekday"` // 0-6, Sun-Sat
+ StartTime string `json:"start_time"` // "18:00"
+ EndTime string `json:"end_time"` // "20:00"
+ Label string `json:"label"`
+}
+
+// BudgetPeriod is the scheduled-vs-available load for one window of time.
+// Purely informational -- no field here ever drives auto-scheduling.
+type BudgetPeriod struct {
+ ScheduledMinutes int `json:"scheduled_minutes"`
+ AvailableMinutes int `json:"available_minutes"`
+}
+
+// BudgetStatus bundles today's and this rolling week's load. Only present
+// on API responses when at least one budget-tracked task exists in the
+// wider (Week) window.
+type BudgetStatus struct {
+ Today BudgetPeriod `json:"today"`
+ Week BudgetPeriod `json:"week"`
+}
+```
+
+- [ ] **Step 3: Confirm it builds**
+
+Run: `go build ./...`
+Expected: no errors (nothing references the new fields yet, so this only checks syntax).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add internal/models/types.go internal/models/budget.go
+git commit -m "Add budget/availability model types"
+```
+
+---
+
+### Task 3: Store — estimated_minutes plumbing on native_tasks
+
+**Files:**
+- Modify: `internal/store/native_tasks.go`
+- Test: `internal/store/native_tasks_test.go`
+
+**Interfaces:**
+- Consumes: `models.Task.EstimatedMinutes` (Task 2).
+- Produces: `(s *Store) SetTaskEstimate(id string, minutes int) error`; every native-task read/write path now round-trips `EstimatedMinutes`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `internal/store/native_tasks_test.go`:
+
+```go
+func TestCreateNativeTask_PersistsEstimatedMinutes(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+
+ task := models.Task{ID: "t-est", Content: "Estimated task", EstimatedMinutes: 45}
+ if err := s.CreateNativeTask(task); err != nil {
+ t.Fatalf("CreateNativeTask: %v", err)
+ }
+
+ got, err := s.GetNativeTaskByID("t-est")
+ if err != nil {
+ t.Fatalf("GetNativeTaskByID: %v", err)
+ }
+ if got.EstimatedMinutes != 45 {
+ t.Errorf("EstimatedMinutes = %d, want 45", got.EstimatedMinutes)
+ }
+}
+
+func TestSetTaskEstimate_UpdatesMinutes(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+
+ if err := s.SetTaskEstimate("real-1", 30); err != nil {
+ t.Fatalf("SetTaskEstimate: %v", err)
+ }
+
+ got, err := s.GetNativeTaskByID("real-1")
+ if err != nil {
+ t.Fatalf("GetNativeTaskByID: %v", err)
+ }
+ if got.EstimatedMinutes != 30 {
+ t.Errorf("EstimatedMinutes = %d, want 30", got.EstimatedMinutes)
+ }
+}
+
+func TestSetTaskEstimate_UnknownID_ReturnsErrNotFound(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+
+ err := s.SetTaskEstimate("does-not-exist", 30)
+ if !errors.Is(err, ErrNativeTaskNotFound) {
+ t.Errorf("err = %v, want ErrNativeTaskNotFound", err)
+ }
+}
+
+func TestCreateNextIteration_CarriesEstimatedMinutesForward(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+
+ due := time.Now()
+ old := models.Task{
+ ID: "t-series", Content: "Weekly review", DueDate: &due,
+ EstimatedMinutes: 60,
+ RecurrenceFreq: "weekly",
+ RecurrenceInterval: 1,
+ RecurrenceSeriesID: "series-1",
+ CreatedAt: time.Now().Add(-time.Hour),
+ }
+ if err := s.CreateNativeTask(old); err != nil {
+ t.Fatalf("CreateNativeTask: %v", err)
+ }
+ if _, err := s.db.Exec(`UPDATE native_tasks SET recurrence_freq = ?, recurrence_interval = ?, recurrence_series_id = ? WHERE id = ?`,
+ old.RecurrenceFreq, old.RecurrenceInterval, old.RecurrenceSeriesID, old.ID); err != nil {
+ t.Fatal(err)
+ }
+ stored, err := s.GetNativeTaskByID("t-series")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := s.CreateNextIteration(*stored); err != nil {
+ t.Fatalf("CreateNextIteration: %v", err)
+ }
+
+ series, err := s.GetSeriesNeedingNextIteration(time.Now().Add(365 * 24 * time.Hour))
+ if err != nil {
+ t.Fatal(err)
+ }
+ var next *models.Task
+ for i := range series {
+ if series[i].ID != "t-series" {
+ next = &series[i]
+ }
+ }
+ if next == nil {
+ t.Fatal("expected a next iteration row")
+ }
+ if next.EstimatedMinutes != 60 {
+ t.Errorf("EstimatedMinutes = %d, want 60 (carried forward)", next.EstimatedMinutes)
+ }
+}
+```
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/store/... -run 'TestCreateNativeTask_PersistsEstimatedMinutes|TestSetTaskEstimate|TestCreateNextIteration_CarriesEstimatedMinutesForward' -v`
+Expected: FAIL — `SetTaskEstimate` undefined, and/or `EstimatedMinutes` always 0 (not selected/inserted yet).
+
+- [ ] **Step 3: Implement**
+
+In `internal/store/native_tasks.go`, add `estimated_minutes` to every `SELECT` column list (all 5 occurrences: `GetNativeTasks`, `GetNativeTasksByDateRange`, `GetOverdueNativeTasks`, `GetNativeTaskByID`, `GetSeriesNeedingNextIteration`) — change:
+
+```go
+ SELECT id, content, description, project_name, project_id, due_date, priority, completed, labels, created_at,
+ recurrence_freq, recurrence_interval, recurrence_weekdays, recurrence_series_id, next_occurrence_override
+```
+
+to:
+
+```go
+ SELECT id, content, description, project_name, project_id, due_date, priority, completed, labels, created_at,
+ recurrence_freq, recurrence_interval, recurrence_weekdays, recurrence_series_id, next_occurrence_override, estimated_minutes
+```
+
+Update `scanNativeTasks` to scan the extra column (add `&t.EstimatedMinutes` as the last `Scan` arg):
+
+```go
+ if err := rows.Scan(
+ &t.ID, &t.Content, &t.Description, &t.ProjectName, &t.ProjectID, &dueDateStr, &t.Priority, &t.Completed, &labelsJSON, &t.CreatedAt,
+ &t.RecurrenceFreq, &t.RecurrenceInterval, &weekdaysStr, &t.RecurrenceSeriesID, &nextOverrideStr, &t.EstimatedMinutes,
+ ); err != nil {
+ return nil, err
+ }
+```
+
+Update `CreateNativeTask`:
+
+```go
+func (s *Store) CreateNativeTask(task models.Task) error {
+ labelsJSON, _ := json.Marshal(task.Labels)
+ _, err := s.db.Exec(`
+ INSERT INTO native_tasks (id, content, description, project_name, project_id, due_date, priority, labels, estimated_minutes, created_at, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+ `, task.ID, task.Content, task.Description, task.ProjectName, task.ProjectID, task.DueDate, task.Priority, string(labelsJSON), task.EstimatedMinutes)
+ return err
+}
+```
+
+Update `CreateNextIteration`'s INSERT (add `estimated_minutes` after `labels` in both the column list and the `SELECT ?, ...` list, and pass `old.EstimatedMinutes` in the matching argument position):
+
+```go
+ _, err := s.db.Exec(`
+ INSERT INTO native_tasks (
+ id, content, description, project_name, project_id, due_date, priority, labels, estimated_minutes,
+ recurrence_freq, recurrence_interval, recurrence_weekdays, recurrence_series_id, next_occurrence_override,
+ created_at, updated_at
+ )
+ SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP
+ WHERE NOT EXISTS (
+ SELECT 1 FROM native_tasks
+ WHERE recurrence_series_id = ?
+ AND (due_date > ? OR (due_date = ? AND created_at > ?))
+ )
+ `, newTaskID(), old.Content, old.Description, old.ProjectName, old.ProjectID, nextDue, old.Priority, string(labelsJSON), old.EstimatedMinutes,
+ old.RecurrenceFreq, old.RecurrenceInterval, formatWeekdays(old.RecurrenceWeekdays), old.RecurrenceSeriesID,
+ old.RecurrenceSeriesID, old.DueDate, old.DueDate, old.CreatedAt)
+ return err
+```
+
+Add `SetTaskEstimate` (place near `RescheduleNativeTask`):
+
+```go
+// SetTaskEstimate sets a task's estimated duration in minutes. Returns
+// ErrNativeTaskNotFound if id doesn't match any row.
+func (s *Store) SetTaskEstimate(id string, minutes int) error {
+ result, err := s.db.Exec(`
+ UPDATE native_tasks SET estimated_minutes = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
+ `, minutes, id)
+ if err != nil {
+ return err
+ }
+ return checkRowsAffected(result)
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/store/... -run 'TestCreateNativeTask_PersistsEstimatedMinutes|TestSetTaskEstimate|TestCreateNextIteration_CarriesEstimatedMinutesForward|TestGetNativeTasks|TestGetOverdue|TestGetUndated|TestCompleteNativeTask|TestRescheduleNativeTask|TestSetTaskRecurrence' -v`
+Expected: PASS (including the pre-existing native-task tests, to confirm the new column didn't break scanning).
+
+- [ ] **Step 5: Run the full store suite**
+
+Run: `go test ./internal/store/...`
+Expected: PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/store/native_tasks.go internal/store/native_tasks_test.go
+git commit -m "Add estimated_minutes to native task read/write/recurrence paths"
+```
+
+---
+
+### Task 4: Store — availability_blocks CRUD
+
+**Files:**
+- Create: `internal/store/availability.go`
+- Test: `internal/store/availability_test.go` (extends the file created in Task 1)
+
+**Interfaces:**
+- Consumes: `models.AvailabilityBlock` (Task 2).
+- Produces: `(s *Store) CreateAvailabilityBlock(weekday int, startTime, endTime, label string) (*models.AvailabilityBlock, error)`; `(s *Store) GetAvailabilityBlocks() ([]models.AvailabilityBlock, error)`; `(s *Store) DeleteAvailabilityBlock(id string) error`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `internal/store/availability_test.go`:
+
+```go
+func TestCreateAvailabilityBlock_ReturnsCreatedBlock(t *testing.T) {
+ s := newAvailabilityTestStore(t)
+
+ block, err := s.CreateAvailabilityBlock(1, "18:00", "20:00", "evening focus")
+ if err != nil {
+ t.Fatalf("CreateAvailabilityBlock: %v", err)
+ }
+ if block.ID == "" {
+ t.Error("expected a generated ID")
+ }
+ if block.Weekday != 1 || block.StartTime != "18:00" || block.EndTime != "20:00" || block.Label != "evening focus" {
+ t.Errorf("block = %+v, unexpected field values", block)
+ }
+}
+
+func TestGetAvailabilityBlocks_ReturnsAllOrderedByWeekday(t *testing.T) {
+ s := newAvailabilityTestStore(t)
+
+ if _, err := s.CreateAvailabilityBlock(3, "09:00", "10:00", ""); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := s.CreateAvailabilityBlock(1, "18:00", "20:00", ""); err != nil {
+ t.Fatal(err)
+ }
+
+ blocks, err := s.GetAvailabilityBlocks()
+ if err != nil {
+ t.Fatalf("GetAvailabilityBlocks: %v", err)
+ }
+ if len(blocks) != 2 {
+ t.Fatalf("len(blocks) = %d, want 2", len(blocks))
+ }
+ if blocks[0].Weekday != 1 || blocks[1].Weekday != 3 {
+ t.Errorf("expected weekday-ascending order, got %d then %d", blocks[0].Weekday, blocks[1].Weekday)
+ }
+}
+
+func TestDeleteAvailabilityBlock_RemovesIt(t *testing.T) {
+ s := newAvailabilityTestStore(t)
+
+ block, err := s.CreateAvailabilityBlock(2, "07:00", "08:00", "")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := s.DeleteAvailabilityBlock(block.ID); err != nil {
+ t.Fatalf("DeleteAvailabilityBlock: %v", err)
+ }
+
+ blocks, err := s.GetAvailabilityBlocks()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(blocks) != 0 {
+ t.Errorf("expected no blocks after delete, got %d", len(blocks))
+ }
+}
+
+func TestDeleteAvailabilityBlock_UnknownID_ReturnsErrNotFound(t *testing.T) {
+ s := newAvailabilityTestStore(t)
+
+ err := s.DeleteAvailabilityBlock("does-not-exist")
+ if !errors.Is(err, ErrNativeTaskNotFound) {
+ t.Errorf("err = %v, want ErrNativeTaskNotFound", err)
+ }
+}
+```
+
+Add `"errors"` and `"testing"` to that file's imports if not already present (it already has `testing`; add `errors`).
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/store/... -run 'AvailabilityBlock' -v`
+Expected: FAIL — `CreateAvailabilityBlock`/`GetAvailabilityBlocks`/`DeleteAvailabilityBlock` undefined.
+
+- [ ] **Step 3: Implement**
+
+```go
+// internal/store/availability.go
+package store
+
+import (
+ "task-dashboard/internal/models"
+)
+
+// CreateAvailabilityBlock inserts a new weekly availability block and returns it.
+func (s *Store) CreateAvailabilityBlock(weekday int, startTime, endTime, label string) (*models.AvailabilityBlock, error) {
+ id := newTaskID()
+ if _, err := s.db.Exec(`
+ INSERT INTO availability_blocks (id, weekday, start_time, end_time, label) VALUES (?, ?, ?, ?, ?)
+ `, id, weekday, startTime, endTime, label); err != nil {
+ return nil, err
+ }
+ return &models.AvailabilityBlock{ID: id, Weekday: weekday, StartTime: startTime, EndTime: endTime, Label: label}, nil
+}
+
+// GetAvailabilityBlocks returns every availability block, ordered by weekday
+// then start time.
+func (s *Store) GetAvailabilityBlocks() ([]models.AvailabilityBlock, error) {
+ rows, err := s.db.Query(`
+ SELECT id, weekday, start_time, end_time, label FROM availability_blocks ORDER BY weekday ASC, start_time ASC
+ `)
+ if err != nil {
+ return nil, err
+ }
+ defer func() { _ = rows.Close() }()
+
+ var blocks []models.AvailabilityBlock
+ for rows.Next() {
+ var b models.AvailabilityBlock
+ if err := rows.Scan(&b.ID, &b.Weekday, &b.StartTime, &b.EndTime, &b.Label); err != nil {
+ return nil, err
+ }
+ blocks = append(blocks, b)
+ }
+ return blocks, rows.Err()
+}
+
+// DeleteAvailabilityBlock removes an availability block. Returns
+// ErrNativeTaskNotFound if id doesn't match any row (reusing the sentinel
+// already shared across native-task/project not-found cases).
+func (s *Store) DeleteAvailabilityBlock(id string) error {
+ result, err := s.db.Exec(`DELETE FROM availability_blocks WHERE id = ?`, id)
+ if err != nil {
+ return err
+ }
+ return checkRowsAffected(result)
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/store/... -run 'AvailabilityBlock' -v`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/store/availability.go internal/store/availability_test.go
+git commit -m "Add availability_blocks CRUD to the store layer"
+```
+
+---
+
+### Task 5: Store — budget-tracked toggles for projects/labels
+
+**Files:**
+- Modify: `internal/store/projects.go`
+- Modify: `internal/store/labels.go`
+- Test: `internal/store/projects_test.go`
+- Test: `internal/store/labels_test.go`
+
+**Interfaces:**
+- Consumes: `newNativeTasksTestStore` (Task 1, now includes `budget_tracked` columns).
+- Produces: `(s *Store) SetProjectBudgetTracked(id string, tracked bool) error`; `(s *Store) SetLabelBudgetTracked(name string, tracked bool) error`; `(s *Store) GetBudgetTrackedProjectIDs() (map[string]bool, error)`; `(s *Store) GetBudgetTrackedLabelNames() (map[string]bool, error)`. Also fixes `SetLabelColor` so it stops wiping `budget_tracked` on every color change.
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `internal/store/projects_test.go`:
+
+```go
+func TestSetProjectBudgetTracked_TogglesFlag(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+ project, err := s.CreateProject("Sailing prep", "#3B82F6")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := s.SetProjectBudgetTracked(project.ID, true); err != nil {
+ t.Fatalf("SetProjectBudgetTracked: %v", err)
+ }
+ got, err := s.GetProjectByID(project.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !got.BudgetTracked {
+ t.Error("expected BudgetTracked = true")
+ }
+
+ if err := s.SetProjectBudgetTracked(project.ID, false); err != nil {
+ t.Fatal(err)
+ }
+ got, err = s.GetProjectByID(project.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got.BudgetTracked {
+ t.Error("expected BudgetTracked = false after untoggling")
+ }
+}
+
+func TestSetProjectBudgetTracked_UnknownID_ReturnsErrNotFound(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+ if err := s.SetProjectBudgetTracked("does-not-exist", true); !errors.Is(err, ErrNativeTaskNotFound) {
+ t.Errorf("err = %v, want ErrNativeTaskNotFound", err)
+ }
+}
+
+func TestGetBudgetTrackedProjectIDs_ReturnsOnlyTracked(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+ tracked, err := s.CreateProject("Tracked", "#111111")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := s.CreateProject("Untracked", "#222222"); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.SetProjectBudgetTracked(tracked.ID, true); err != nil {
+ t.Fatal(err)
+ }
+
+ ids, err := s.GetBudgetTrackedProjectIDs()
+ if err != nil {
+ t.Fatalf("GetBudgetTrackedProjectIDs: %v", err)
+ }
+ if !ids[tracked.ID] {
+ t.Error("expected tracked project id present")
+ }
+ if len(ids) != 1 {
+ t.Errorf("len(ids) = %d, want 1", len(ids))
+ }
+}
+```
+
+Add `"errors"` to `projects_test.go`'s imports.
+
+Append to `internal/store/labels_test.go`:
+
+```go
+func TestSetLabelBudgetTracked_TogglesFlag(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+
+ if err := s.SetLabelBudgetTracked("errands", true); err != nil {
+ t.Fatalf("SetLabelBudgetTracked: %v", err)
+ }
+ names, err := s.GetBudgetTrackedLabelNames()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !names["errands"] {
+ t.Error("expected 'errands' to be tracked")
+ }
+}
+
+func TestSetLabelColor_PreservesExistingBudgetTracked(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+
+ if err := s.SetLabelBudgetTracked("errands", true); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.SetLabelColor("errands", "#00ff00"); err != nil {
+ t.Fatalf("SetLabelColor: %v", err)
+ }
+
+ names, err := s.GetBudgetTrackedLabelNames()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !names["errands"] {
+ t.Error("expected budget_tracked to survive a later SetLabelColor call")
+ }
+ colors, err := s.GetLabelColors()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(colors) != 1 || colors[0].Color != "#00ff00" {
+ t.Errorf("colors = %+v, want one entry with color #00ff00", colors)
+ }
+}
+
+func TestSetLabelBudgetTracked_PreservesExistingColor(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+
+ if err := s.SetLabelColor("errands", "#00ff00"); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.SetLabelBudgetTracked("errands", true); err != nil {
+ t.Fatal(err)
+ }
+
+ colors, err := s.GetLabelColors()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(colors) != 1 || colors[0].Color != "#00ff00" {
+ t.Errorf("colors = %+v, want color to survive SetLabelBudgetTracked", colors)
+ }
+}
+```
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/store/... -run 'BudgetTracked' -v`
+Expected: FAIL — new functions undefined; `TestSetLabelColor_PreservesExistingBudgetTracked` would also fail once implemented naively with `INSERT OR REPLACE` (documents the bug this task fixes).
+
+- [ ] **Step 3: Implement**
+
+In `internal/store/projects.go`, add after `SetTaskProject`:
+
+```go
+// SetProjectBudgetTracked marks a project as opted in (or out) of budget
+// tracking. Returns ErrNativeTaskNotFound if id doesn't match any row.
+func (s *Store) SetProjectBudgetTracked(id string, tracked bool) error {
+ result, err := s.db.Exec(`UPDATE projects SET budget_tracked = ? WHERE id = ?`, tracked, id)
+ if err != nil {
+ return err
+ }
+ return checkRowsAffected(result)
+}
+
+// GetBudgetTrackedProjectIDs returns the set of project IDs opted into budget tracking.
+func (s *Store) GetBudgetTrackedProjectIDs() (map[string]bool, error) {
+ rows, err := s.db.Query(`SELECT id FROM projects WHERE budget_tracked = 1`)
+ if err != nil {
+ return nil, err
+ }
+ defer func() { _ = rows.Close() }()
+
+ ids := make(map[string]bool)
+ for rows.Next() {
+ var id string
+ if err := rows.Scan(&id); err != nil {
+ return nil, err
+ }
+ ids[id] = true
+ }
+ return ids, rows.Err()
+}
+```
+
+Also update `GetProjects` and `GetProjectByID` in the same file to select/scan the new column:
+
+```go
+func (s *Store) GetProjects() ([]models.Project, error) {
+ rows, err := s.db.Query(`
+ SELECT id, name, color, created_at, archived, budget_tracked FROM projects WHERE archived = 0 ORDER BY name ASC
+ `)
+ if err != nil {
+ return nil, err
+ }
+ defer func() { _ = rows.Close() }()
+
+ var projects []models.Project
+ for rows.Next() {
+ var p models.Project
+ if err := rows.Scan(&p.ID, &p.Name, &p.Color, &p.CreatedAt, &p.Archived, &p.BudgetTracked); err != nil {
+ return nil, err
+ }
+ projects = append(projects, p)
+ }
+ return projects, rows.Err()
+}
+
+func (s *Store) GetProjectByID(id string) (*models.Project, error) {
+ var p models.Project
+ err := s.db.QueryRow(`
+ SELECT id, name, color, created_at, archived, budget_tracked FROM projects WHERE id = ?
+ `, id).Scan(&p.ID, &p.Name, &p.Color, &p.CreatedAt, &p.Archived, &p.BudgetTracked)
+ if err == sql.ErrNoRows {
+ return nil, ErrNativeTaskNotFound
+ }
+ if err != nil {
+ return nil, err
+ }
+ return &p, nil
+}
+```
+
+In `internal/store/labels.go`, replace `SetLabelColor` (the existing `INSERT OR REPLACE` silently resets `budget_tracked` to its default on every color change since REPLACE deletes-then-reinserts the whole row) and add the new functions:
+
+```go
+// SetLabelColor assigns (or reassigns) a label's display color, preserving
+// any existing budget_tracked flag -- a plain INSERT OR REPLACE would
+// delete-and-reinsert the row, silently resetting budget_tracked to 0.
+func (s *Store) SetLabelColor(name, color string) error {
+ _, err := s.db.Exec(`
+ INSERT INTO labels (name, color, budget_tracked) VALUES (?, ?, 0)
+ ON CONFLICT(name) DO UPDATE SET color = excluded.color
+ `, name, color)
+ return err
+}
+
+// SetLabelBudgetTracked marks a label as opted in (or out) of budget
+// tracking, preserving any existing color the same way SetLabelColor
+// preserves budget_tracked.
+func (s *Store) SetLabelBudgetTracked(name string, tracked bool) error {
+ _, err := s.db.Exec(`
+ INSERT INTO labels (name, color, budget_tracked) VALUES (?, '', ?)
+ ON CONFLICT(name) DO UPDATE SET budget_tracked = excluded.budget_tracked
+ `, name, tracked)
+ return err
+}
+
+// GetBudgetTrackedLabelNames returns the set of label names opted into budget tracking.
+func (s *Store) GetBudgetTrackedLabelNames() (map[string]bool, error) {
+ rows, err := s.db.Query(`SELECT name FROM labels WHERE budget_tracked = 1`)
+ if err != nil {
+ return nil, err
+ }
+ defer func() { _ = rows.Close() }()
+
+ names := make(map[string]bool)
+ for rows.Next() {
+ var name string
+ if err := rows.Scan(&name); err != nil {
+ return nil, err
+ }
+ names[name] = true
+ }
+ return names, rows.Err()
+}
+```
+
+Also update `GetLabelColors` to select/scan the new column:
+
+```go
+func (s *Store) GetLabelColors() ([]models.LabelColor, error) {
+ rows, err := s.db.Query(`SELECT name, color, budget_tracked FROM labels ORDER BY name ASC`)
+ if err != nil {
+ return nil, err
+ }
+ defer func() { _ = rows.Close() }()
+
+ var colors []models.LabelColor
+ for rows.Next() {
+ var c models.LabelColor
+ if err := rows.Scan(&c.Name, &c.Color, &c.BudgetTracked); err != nil {
+ return nil, err
+ }
+ colors = append(colors, c)
+ }
+ return colors, rows.Err()
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/store/... -run 'BudgetTracked|Project|Label' -v`
+Expected: PASS
+
+- [ ] **Step 5: Run the full store suite**
+
+Run: `go test ./internal/store/...`
+Expected: PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/store/projects.go internal/store/labels.go internal/store/projects_test.go internal/store/labels_test.go
+git commit -m "Add budget-tracked toggles for projects/labels; fix SetLabelColor wiping the flag"
+```
+
+---
+
+### Task 6: Store — same-project/label estimate averaging (inference)
+
+**Files:**
+- Create: `internal/store/estimate_inference.go`
+- Test: `internal/store/estimate_inference_test.go`
+
+**Interfaces:**
+- Consumes: `native_tasks.project_id`/`labels`/`estimated_minutes` (Task 3).
+- Produces: `(s *Store) AverageEstimateForProject(projectID string) (minutes int, ok bool, err error)`; `(s *Store) AverageEstimateForLabel(label string) (minutes int, ok bool, err error)`.
+
+- [ ] **Step 1: Write the failing tests**
+
+```go
+// internal/store/estimate_inference_test.go
+package store
+
+import (
+ "testing"
+ "time"
+
+ "task-dashboard/internal/models"
+)
+
+func TestAverageEstimateForProject_AveragesUserEnteredEstimates(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+ project, err := s.CreateProject("Sailing prep", "#3B82F6")
+ if err != nil {
+ t.Fatal(err)
+ }
+ due := time.Now()
+ for _, minutes := range []int{30, 60} {
+ task := models.Task{ID: newTaskID(), Content: "task", ProjectID: project.ID, EstimatedMinutes: minutes, DueDate: &due}
+ if err := s.CreateNativeTask(task); err != nil {
+ t.Fatal(err)
+ }
+ }
+ // An unestimated task under the same project must not skew the average.
+ if err := s.CreateNativeTask(models.Task{ID: "t-unestimated", Content: "no estimate", ProjectID: project.ID}); err != nil {
+ t.Fatal(err)
+ }
+
+ avg, ok, err := s.AverageEstimateForProject(project.ID)
+ if err != nil {
+ t.Fatalf("AverageEstimateForProject: %v", err)
+ }
+ if !ok {
+ t.Fatal("expected ok = true")
+ }
+ if avg != 45 {
+ t.Errorf("avg = %d, want 45", avg)
+ }
+}
+
+func TestAverageEstimateForProject_NoEstimatedTasks_ReturnsNotOK(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+ project, err := s.CreateProject("Empty", "#111111")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ _, ok, err := s.AverageEstimateForProject(project.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if ok {
+ t.Error("expected ok = false when no tasks have an estimate")
+ }
+}
+
+func TestAverageEstimateForLabel_AveragesUserEnteredEstimates(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+ for _, minutes := range []int{20, 40} {
+ task := models.Task{ID: newTaskID(), Content: "task", Labels: []string{"errands"}, EstimatedMinutes: minutes}
+ if err := s.CreateNativeTask(task); err != nil {
+ t.Fatal(err)
+ }
+ }
+ if err := s.CreateNativeTask(models.Task{ID: "t-other-label", Content: "other", Labels: []string{"unrelated"}, EstimatedMinutes: 100}); err != nil {
+ t.Fatal(err)
+ }
+
+ avg, ok, err := s.AverageEstimateForLabel("errands")
+ if err != nil {
+ t.Fatalf("AverageEstimateForLabel: %v", err)
+ }
+ if !ok {
+ t.Fatal("expected ok = true")
+ }
+ if avg != 30 {
+ t.Errorf("avg = %d, want 30", avg)
+ }
+}
+
+func TestAverageEstimateForLabel_NoMatches_ReturnsNotOK(t *testing.T) {
+ s := newNativeTasksTestStore(t)
+ _, ok, err := s.AverageEstimateForLabel("nonexistent")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if ok {
+ t.Error("expected ok = false")
+ }
+}
+```
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/store/... -run 'AverageEstimate' -v`
+Expected: FAIL — functions undefined.
+
+- [ ] **Step 3: Implement**
+
+```go
+// internal/store/estimate_inference.go
+package store
+
+import "encoding/json"
+
+// AverageEstimateForProject returns the rounded average estimated_minutes
+// across all user-estimated (estimated_minutes > 0) tasks under projectID.
+// ok is false when no such task exists -- there's no signal to infer from.
+func (s *Store) AverageEstimateForProject(projectID string) (int, bool, error) {
+ var sum, count int
+ rows, err := s.db.Query(`SELECT estimated_minutes FROM native_tasks WHERE project_id = ? AND estimated_minutes > 0`, projectID)
+ if err != nil {
+ return 0, false, err
+ }
+ defer func() { _ = rows.Close() }()
+ for rows.Next() {
+ var minutes int
+ if err := rows.Scan(&minutes); err != nil {
+ return 0, false, err
+ }
+ sum += minutes
+ count++
+ }
+ if err := rows.Err(); err != nil {
+ return 0, false, err
+ }
+ if count == 0 {
+ return 0, false, nil
+ }
+ return sum / count, true, nil
+}
+
+// AverageEstimateForLabel returns the rounded average estimated_minutes
+// across all user-estimated tasks carrying the given label. Labels are
+// stored as a JSON array column, not a joinable table, so this scans every
+// estimated task and filters in Go rather than risking a SQL substring
+// false-positive (e.g. LIKE '%"run"%' matching a task labeled "running").
+func (s *Store) AverageEstimateForLabel(label string) (int, bool, error) {
+ rows, err := s.db.Query(`SELECT labels, estimated_minutes FROM native_tasks WHERE estimated_minutes > 0`)
+ if err != nil {
+ return 0, false, err
+ }
+ defer func() { _ = rows.Close() }()
+
+ var sum, count int
+ for rows.Next() {
+ var labelsJSON string
+ var minutes int
+ if err := rows.Scan(&labelsJSON, &minutes); err != nil {
+ return 0, false, err
+ }
+ var labels []string
+ if err := json.Unmarshal([]byte(labelsJSON), &labels); err != nil {
+ continue
+ }
+ for _, l := range labels {
+ if l == label {
+ sum += minutes
+ count++
+ break
+ }
+ }
+ }
+ if err := rows.Err(); err != nil {
+ return 0, false, err
+ }
+ if count == 0 {
+ return 0, false, nil
+ }
+ return sum / count, true, nil
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/store/... -run 'AverageEstimate' -v`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/store/estimate_inference.go internal/store/estimate_inference_test.go
+git commit -m "Infer a default estimate from same-project/label averages"
+```
+
+---
+
+### Task 7: Pure computation — ComputeBudgetPeriod
+
+**Files:**
+- Create: `internal/handlers/budget_logic.go`
+- Test: `internal/handlers/budget_logic_test.go`
+
+**Interfaces:**
+- Consumes: `models.AvailabilityBlock`, `models.CalendarEvent`, `models.Task`, `models.BudgetPeriod` (Task 2).
+- Produces: `ComputeBudgetPeriod(blocks []models.AvailabilityBlock, events []models.CalendarEvent, tasks []models.Task, trackedProjects, trackedLabels map[string]bool, start, end time.Time) models.BudgetPeriod`.
+
+- [ ] **Step 1: Write the failing tests**
+
+```go
+// internal/handlers/budget_logic_test.go
+package handlers
+
+import (
+ "testing"
+ "time"
+
+ "task-dashboard/internal/models"
+)
+
+func mustParseInLoc(t *testing.T, layout, value string, loc *time.Location) time.Time {
+ t.Helper()
+ parsed, err := time.ParseInLocation(layout, value, loc)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return parsed
+}
+
+func TestComputeBudgetPeriod_SumsAvailabilityMinusOverlappingEvent(t *testing.T) {
+ loc := time.UTC
+ // A Wednesday: 2026-07-15 is a Wednesday.
+ day := mustParseInLoc(t, "2006-01-02", "2026-07-15", loc)
+ start := day
+ end := day.AddDate(0, 0, 1)
+
+ blocks := []models.AvailabilityBlock{
+ {ID: "b1", Weekday: int(day.Weekday()), StartTime: "18:00", EndTime: "20:00"}, // 120 min
+ }
+ events := []models.CalendarEvent{
+ {ID: "e1", Start: mustParseInLoc(t, "2006-01-02 15:04", "2026-07-15 18:30", loc), End: mustParseInLoc(t, "2006-01-02 15:04", "2026-07-15 19:00", loc)}, // 30 min overlap
+ }
+
+ status := ComputeBudgetPeriod(blocks, events, nil, nil, nil, start, end)
+ if status.AvailableMinutes != 90 {
+ t.Errorf("AvailableMinutes = %d, want 90 (120 - 30 overlap)", status.AvailableMinutes)
+ }
+}
+
+func TestComputeBudgetPeriod_EventFullyOutsideBlockDoesNotReduceIt(t *testing.T) {
+ loc := time.UTC
+ day := mustParseInLoc(t, "2006-01-02", "2026-07-15", loc)
+ start := day
+ end := day.AddDate(0, 0, 1)
+
+ blocks := []models.AvailabilityBlock{
+ {ID: "b1", Weekday: int(day.Weekday()), StartTime: "18:00", EndTime: "20:00"},
+ }
+ events := []models.CalendarEvent{
+ {ID: "e1", Start: mustParseInLoc(t, "2006-01-02 15:04", "2026-07-15 09:00", loc), End: mustParseInLoc(t, "2006-01-02 15:04", "2026-07-15 10:00", loc)},
+ }
+
+ status := ComputeBudgetPeriod(blocks, events, nil, nil, nil, start, end)
+ if status.AvailableMinutes != 120 {
+ t.Errorf("AvailableMinutes = %d, want 120 (event doesn't overlap the block)", status.AvailableMinutes)
+ }
+}
+
+func TestComputeBudgetPeriod_AvailableNeverGoesNegative(t *testing.T) {
+ loc := time.UTC
+ day := mustParseInLoc(t, "2006-01-02", "2026-07-15", loc)
+ start := day
+ end := day.AddDate(0, 0, 1)
+
+ blocks := []models.AvailabilityBlock{
+ {ID: "b1", Weekday: int(day.Weekday()), StartTime: "18:00", EndTime: "20:00"},
+ }
+ events := []models.CalendarEvent{
+ {ID: "e1", Start: mustParseInLoc(t, "2006-01-02 15:04", "2026-07-15 17:00", loc), End: mustParseInLoc(t, "2006-01-02 15:04", "2026-07-15 21:00", loc)},
+ }
+
+ status := ComputeBudgetPeriod(blocks, events, nil, nil, nil, start, end)
+ if status.AvailableMinutes != 0 {
+ t.Errorf("AvailableMinutes = %d, want 0 (event fully covers the block)", status.AvailableMinutes)
+ }
+}
+
+func TestComputeBudgetPeriod_OnlySumsTrackedIncompleteTasksDueInWindow(t *testing.T) {
+ loc := time.UTC
+ start := mustParseInLoc(t, "2006-01-02", "2026-07-15", loc)
+ end := start.AddDate(0, 0, 1)
+ due := mustParseInLoc(t, "2006-01-02 15:04", "2026-07-15 12:00", loc)
+ outsideWindow := end.AddDate(0, 0, 5)
+
+ tasks := []models.Task{
+ {ID: "t-tracked-project", ProjectID: "p1", EstimatedMinutes: 30, DueDate: &due},
+ {ID: "t-tracked-label", Labels: []string{"errands"}, EstimatedMinutes: 20, DueDate: &due},
+ {ID: "t-untracked", ProjectID: "p2", EstimatedMinutes: 999, DueDate: &due},
+ {ID: "t-completed", ProjectID: "p1", EstimatedMinutes: 999, DueDate: &due, Completed: true},
+ {ID: "t-outside-window", ProjectID: "p1", EstimatedMinutes: 999, DueDate: &outsideWindow},
+ }
+ trackedProjects := map[string]bool{"p1": true}
+ trackedLabels := map[string]bool{"errands": true}
+
+ status := ComputeBudgetPeriod(nil, nil, tasks, trackedProjects, trackedLabels, start, end)
+ if status.ScheduledMinutes != 50 {
+ t.Errorf("ScheduledMinutes = %d, want 50 (30 + 20, excluding untracked/completed/out-of-window)", status.ScheduledMinutes)
+ }
+}
+```
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/handlers/... -run 'TestComputeBudgetPeriod' -v`
+Expected: FAIL — `ComputeBudgetPeriod` undefined.
+
+- [ ] **Step 3: Implement**
+
+```go
+// internal/handlers/budget_logic.go
+package handlers
+
+import (
+ "time"
+
+ "task-dashboard/internal/models"
+)
+
+// ComputeBudgetPeriod is a pure function: given the weekly availability
+// template, calendar events, and candidate tasks, it returns the scheduled
+// (tracked, incomplete, due-in-window) load versus the available minutes
+// in [start, end) -- availability minus any overlapping calendar events.
+// Never mutates its inputs and never drives scheduling decisions; it only
+// answers "does this fit."
+func ComputeBudgetPeriod(
+ blocks []models.AvailabilityBlock,
+ events []models.CalendarEvent,
+ tasks []models.Task,
+ trackedProjects map[string]bool,
+ trackedLabels map[string]bool,
+ start, end time.Time,
+) models.BudgetPeriod {
+ available := 0
+ for day := start; day.Before(end); day = day.AddDate(0, 0, 1) {
+ weekday := int(day.Weekday())
+ for _, block := range blocks {
+ if block.Weekday != weekday {
+ continue
+ }
+ blockStart, blockEnd, ok := blockTimesOnDay(block, day)
+ if !ok {
+ continue
+ }
+ minutes := int(blockEnd.Sub(blockStart).Minutes())
+ for _, event := range events {
+ minutes -= overlapMinutes(blockStart, blockEnd, event.Start, event.End)
+ }
+ if minutes > 0 {
+ available += minutes
+ }
+ }
+ }
+
+ scheduled := 0
+ for _, task := range tasks {
+ if task.Completed || task.DueDate == nil {
+ continue
+ }
+ if !task.DueDate.Before(end) {
+ continue
+ }
+ if !isBudgetTracked(task, trackedProjects, trackedLabels) {
+ continue
+ }
+ scheduled += task.EstimatedMinutes
+ }
+
+ return models.BudgetPeriod{ScheduledMinutes: scheduled, AvailableMinutes: available}
+}
+
+// blockTimesOnDay resolves an availability block's "HH:MM" start/end
+// strings to concrete times on the given day. ok is false if either time
+// fails to parse (a malformed block is skipped rather than panicking).
+func blockTimesOnDay(block models.AvailabilityBlock, day time.Time) (time.Time, time.Time, bool) {
+ start, err := time.ParseInLocation("15:04", block.StartTime, day.Location())
+ if err != nil {
+ return time.Time{}, time.Time{}, false
+ }
+ end, err := time.ParseInLocation("15:04", block.EndTime, day.Location())
+ if err != nil {
+ return time.Time{}, time.Time{}, false
+ }
+ y, m, d := day.Date()
+ return time.Date(y, m, d, start.Hour(), start.Minute(), 0, 0, day.Location()),
+ time.Date(y, m, d, end.Hour(), end.Minute(), 0, 0, day.Location()), true
+}
+
+// overlapMinutes returns how many minutes [bStart, bEnd) and [eStart, eEnd) overlap.
+func overlapMinutes(bStart, bEnd, eStart, eEnd time.Time) int {
+ lo := bStart
+ if eStart.After(lo) {
+ lo = eStart
+ }
+ hi := bEnd
+ if eEnd.Before(hi) {
+ hi = eEnd
+ }
+ if hi.Before(lo) || hi.Equal(lo) {
+ return 0
+ }
+ return int(hi.Sub(lo).Minutes())
+}
+
+// isBudgetTracked reports whether task counts against any budget
+// calculation -- true if its project or any of its labels is opted in.
+func isBudgetTracked(task models.Task, trackedProjects, trackedLabels map[string]bool) bool {
+ if trackedProjects[task.ProjectID] {
+ return true
+ }
+ for _, label := range task.Labels {
+ if trackedLabels[label] {
+ return true
+ }
+ }
+ return false
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/handlers/... -run 'TestComputeBudgetPeriod' -v`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/handlers/budget_logic.go internal/handlers/budget_logic_test.go
+git commit -m "Add pure availability-minus-events and scheduled-load computation"
+```
+
+---
+
+### Task 8: Wire budget_status into GET /api/widget
+
+**Files:**
+- Modify: `internal/models/widget.go` (`WidgetResponse`)
+- Modify: `internal/handlers/widget.go` (new helper + `HandleWidgetGet`)
+- Test: `internal/handlers/widget_test.go`
+
+**Interfaces:**
+- Consumes: `ComputeBudgetPeriod` (Task 7), `s.GetAvailabilityBlocks`, `s.GetBudgetTrackedProjectIDs`, `s.GetBudgetTrackedLabelNames` (Tasks 4-5), `s.GetCalendarEventsByDateRange`, `s.GetNativeTasksByDateRange`, `s.GetOverdueNativeTasks` (existing).
+- Produces: `(h *Handler) computeBudgetStatus(now time.Time) (*models.BudgetStatus, error)`; `models.WidgetResponse.BudgetStatus *models.BudgetStatus`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `internal/handlers/widget_test.go`:
+
+```go
+func TestHandleWidgetGet_NoBudgetTrackedTasks_OmitsBudgetStatus(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+
+ req := httptest.NewRequest("GET", "/api/widget", nil)
+ w := httptest.NewRecorder()
+ h.HandleWidgetGet(w, req)
+
+ var resp models.WidgetResponse
+ if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+ t.Fatal(err)
+ }
+ if resp.BudgetStatus != nil {
+ t.Errorf("expected nil BudgetStatus with no tracked tasks, got %+v", resp.BudgetStatus)
+ }
+}
+
+func TestHandleWidgetGet_BudgetTrackedTaskDueToday_IncludesBudgetStatus(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+
+ project, err := h.store.CreateProject("Tracked", "#111111")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := h.store.SetProjectBudgetTracked(project.ID, true); err != nil {
+ t.Fatal(err)
+ }
+ due := time.Now()
+ if err := h.store.CreateNativeTask(models.Task{ID: "t-tracked", Content: "Tracked task", ProjectID: project.ID, DueDate: &due, EstimatedMinutes: 45}); err != nil {
+ t.Fatal(err)
+ }
+
+ req := httptest.NewRequest("GET", "/api/widget", nil)
+ w := httptest.NewRecorder()
+ h.HandleWidgetGet(w, req)
+
+ var resp models.WidgetResponse
+ if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+ t.Fatal(err)
+ }
+ if resp.BudgetStatus == nil {
+ t.Fatal("expected non-nil BudgetStatus")
+ }
+ if resp.BudgetStatus.Today.ScheduledMinutes != 45 {
+ t.Errorf("Today.ScheduledMinutes = %d, want 45", resp.BudgetStatus.Today.ScheduledMinutes)
+ }
+ if resp.BudgetStatus.Week.ScheduledMinutes != 45 {
+ t.Errorf("Week.ScheduledMinutes = %d, want 45", resp.BudgetStatus.Week.ScheduledMinutes)
+ }
+}
+```
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleWidgetGet_.*Budget' -v`
+Expected: FAIL — `resp.BudgetStatus` doesn't exist yet (compile error) or is always nil.
+
+- [ ] **Step 3: Implement**
+
+In `internal/models/widget.go`, add to `WidgetResponse` (this file is itself inside package `models`, so the new field references `BudgetStatus` directly — no import needed):
+
+```go
+type WidgetResponse struct {
+ Now time.Time `json:"now"`
+ Items []WidgetItem `json:"items"`
+ BudgetStatus *BudgetStatus `json:"budget_status,omitempty"`
+}
+```
+
+In `internal/handlers/widget.go`, add the helper (place near `HandleWidgetGet`):
+
+```go
+// computeBudgetStatus returns budget status for "today" and a rolling
+// 7-day "week" window starting today, or nil if no budget-tracked task
+// falls in the week window (per the spec: the field is absent unless
+// budget-tracked tasks exist, so an unconfigured user sees no new UI).
+func (h *Handler) computeBudgetStatus(now time.Time) (*models.BudgetStatus, error) {
+ tz := config.GetDisplayTimezone()
+ todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, tz)
+ todayEnd := todayStart.Add(24 * time.Hour)
+ weekEnd := todayStart.AddDate(0, 0, 7)
+
+ blocks, err := h.store.GetAvailabilityBlocks()
+ if err != nil {
+ return nil, err
+ }
+ trackedProjects, err := h.store.GetBudgetTrackedProjectIDs()
+ if err != nil {
+ return nil, err
+ }
+ trackedLabels, err := h.store.GetBudgetTrackedLabelNames()
+ if err != nil {
+ return nil, err
+ }
+ events, err := h.store.GetCalendarEventsByDateRange(todayStart, weekEnd)
+ if err != nil {
+ return nil, err
+ }
+ overdue, err := h.store.GetOverdueNativeTasks(todayStart)
+ if err != nil {
+ return nil, err
+ }
+ weekTasks, err := h.store.GetNativeTasksByDateRange(todayStart, weekEnd)
+ if err != nil {
+ return nil, err
+ }
+ allTasks := append(append([]models.Task{}, overdue...), weekTasks...)
+
+ hasTracked := false
+ for _, task := range allTasks {
+ if isBudgetTracked(task, trackedProjects, trackedLabels) && !task.Completed {
+ hasTracked = true
+ break
+ }
+ }
+ if !hasTracked {
+ return nil, nil
+ }
+
+ today := ComputeBudgetPeriod(blocks, events, allTasks, trackedProjects, trackedLabels, todayStart, todayEnd)
+ week := ComputeBudgetPeriod(blocks, events, allTasks, trackedProjects, trackedLabels, todayStart, weekEnd)
+ return &models.BudgetStatus{Today: today, Week: week}, nil
+}
+```
+
+Update `HandleWidgetGet` to populate it:
+
+```go
+func (h *Handler) HandleWidgetGet(w http.ResponseWriter, r *http.Request) {
+ now := config.Now()
+ tz := config.GetDisplayTimezone()
+ start := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, tz)
+ end := start.Add(48 * time.Hour)
+
+ items, err := BuildTimeline(r.Context(), h.store, start, end)
+ if err != nil {
+ http.Error(w, "internal error", http.StatusInternalServerError)
+ return
+ }
+
+ widgetItems := make([]models.WidgetItem, 0, len(items))
+ for _, item := range items {
+ if item.DaySection == models.DaySectionToday ||
+ item.DaySection == models.DaySectionTomorrow ||
+ item.IsOverdue {
+ widgetItems = append(widgetItems, TimelineItemToWidgetItem(item))
+ }
+ }
+
+ budgetStatus, err := h.computeBudgetStatus(now)
+ if err != nil {
+ log.Printf("Warning: failed to compute budget status: %v", err)
+ }
+
+ resp := models.WidgetResponse{
+ Now: now,
+ Items: widgetItems,
+ BudgetStatus: budgetStatus,
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(resp)
+}
+```
+
+Add `"log"` to `widget.go`'s imports if not already present (check first — several handler files already import it; `timeline_logic.go` does).
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleWidgetGet' -v`
+Expected: PASS (all `HandleWidgetGet` tests, old and new).
+
+- [ ] **Step 5: Run the full handlers suite**
+
+Run: `go test ./internal/handlers/...`
+Expected: PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/models/widget.go internal/handlers/widget.go internal/handlers/widget_test.go
+git commit -m "Surface budget_status on GET /api/widget when tracked tasks exist"
+```
+
+---
+
+### Task 9: HTTP endpoints — availability CRUD, task estimate, budget-tracked toggles
+
+**Files:**
+- Modify: `internal/handlers/widget.go`
+- Modify: `cmd/dashboard/main.go:376-391`
+- Test: `internal/handlers/widget_test.go`
+
+**Interfaces:**
+- Consumes: store functions from Tasks 3-5.
+- Produces: `GET /api/widget/availability`, `POST /api/widget/availability`, `POST /api/widget/availability/delete`, `POST /api/widget/task/estimate`, `POST /api/widget/projects/budget-tracked`, `POST /api/widget/labels/budget-tracked`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `internal/handlers/widget_test.go`:
+
+```go
+func TestHandleWidgetAvailabilityGet_ReturnsBlocks(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+ if _, err := h.store.CreateAvailabilityBlock(1, "18:00", "20:00", "evening"); err != nil {
+ t.Fatal(err)
+ }
+
+ req := httptest.NewRequest("GET", "/api/widget/availability", nil)
+ w := httptest.NewRecorder()
+ h.HandleWidgetAvailabilityGet(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ var blocks []models.AvailabilityBlock
+ if err := json.NewDecoder(w.Body).Decode(&blocks); err != nil {
+ t.Fatal(err)
+ }
+ if len(blocks) != 1 || blocks[0].Label != "evening" {
+ t.Errorf("blocks = %+v", blocks)
+ }
+}
+
+func TestHandleWidgetAvailabilityCreate_CreatesBlock(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+
+ body := `{"weekday":2,"start_time":"07:00","end_time":"08:00","label":"morning walk"}`
+ req := httptest.NewRequest("POST", "/api/widget/availability", strings.NewReader(body))
+ w := httptest.NewRecorder()
+ h.HandleWidgetAvailabilityCreate(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ blocks, err := h.store.GetAvailabilityBlocks()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(blocks) != 1 || blocks[0].Weekday != 2 {
+ t.Errorf("blocks = %+v", blocks)
+ }
+}
+
+func TestHandleWidgetAvailabilityDelete_RemovesBlock(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+ block, err := h.store.CreateAvailabilityBlock(3, "09:00", "10:00", "")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ body := `{"id":"` + block.ID + `"}`
+ req := httptest.NewRequest("POST", "/api/widget/availability/delete", strings.NewReader(body))
+ w := httptest.NewRecorder()
+ h.HandleWidgetAvailabilityDelete(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ blocks, err := h.store.GetAvailabilityBlocks()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(blocks) != 0 {
+ t.Errorf("expected block deleted, got %+v", blocks)
+ }
+}
+
+func TestHandleWidgetAvailabilityDelete_UnknownID_Returns404(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+
+ req := httptest.NewRequest("POST", "/api/widget/availability/delete", strings.NewReader(`{"id":"nope"}`))
+ w := httptest.NewRecorder()
+ h.HandleWidgetAvailabilityDelete(w, req)
+
+ if w.Code != http.StatusNotFound {
+ t.Errorf("status = %d, want 404", w.Code)
+ }
+}
+
+func TestHandleWidgetTaskEstimate_SetsEstimate(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+ if err := h.store.CreateNativeTask(models.Task{ID: "t-1", Content: "task"}); err != nil {
+ t.Fatal(err)
+ }
+
+ body := `{"id":"t-1","estimated_minutes":25}`
+ req := httptest.NewRequest("POST", "/api/widget/task/estimate", strings.NewReader(body))
+ w := httptest.NewRecorder()
+ h.HandleWidgetTaskEstimate(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ task, err := h.store.GetNativeTaskByID("t-1")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if task.EstimatedMinutes != 25 {
+ t.Errorf("EstimatedMinutes = %d, want 25", task.EstimatedMinutes)
+ }
+}
+
+func TestHandleWidgetProjectsBudgetTracked_SetsFlag(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+ project, err := h.store.CreateProject("P", "#111111")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ body := `{"id":"` + project.ID + `","tracked":true}`
+ req := httptest.NewRequest("POST", "/api/widget/projects/budget-tracked", strings.NewReader(body))
+ w := httptest.NewRecorder()
+ h.HandleWidgetProjectsBudgetTracked(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ got, err := h.store.GetProjectByID(project.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !got.BudgetTracked {
+ t.Error("expected BudgetTracked = true")
+ }
+}
+
+func TestHandleWidgetLabelsBudgetTracked_SetsFlag(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+
+ body := `{"name":"errands","tracked":true}`
+ req := httptest.NewRequest("POST", "/api/widget/labels/budget-tracked", strings.NewReader(body))
+ w := httptest.NewRecorder()
+ h.HandleWidgetLabelsBudgetTracked(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ names, err := h.store.GetBudgetTrackedLabelNames()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !names["errands"] {
+ t.Error("expected 'errands' tracked")
+ }
+}
+```
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleWidgetAvailability|TestHandleWidgetTaskEstimate|TestHandleWidgetProjectsBudgetTracked|TestHandleWidgetLabelsBudgetTracked' -v`
+Expected: FAIL — handlers undefined.
+
+- [ ] **Step 3: Implement**
+
+Append to `internal/handlers/widget.go`:
+
+```go
+type availabilityBlockResponse struct {
+ ID string `json:"id"`
+ Weekday int `json:"weekday"`
+ StartTime string `json:"start_time"`
+ EndTime string `json:"end_time"`
+ Label string `json:"label"`
+}
+
+func availabilityBlockToResponse(b models.AvailabilityBlock) availabilityBlockResponse {
+ return availabilityBlockResponse{ID: b.ID, Weekday: b.Weekday, StartTime: b.StartTime, EndTime: b.EndTime, Label: b.Label}
+}
+
+// HandleWidgetAvailabilityGet returns every configured availability block.
+func (h *Handler) HandleWidgetAvailabilityGet(w http.ResponseWriter, r *http.Request) {
+ blocks, err := h.store.GetAvailabilityBlocks()
+ if err != nil {
+ http.Error(w, "failed to load availability", http.StatusInternalServerError)
+ return
+ }
+ resp := make([]availabilityBlockResponse, 0, len(blocks))
+ for _, b := range blocks {
+ resp = append(resp, availabilityBlockToResponse(b))
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(resp)
+}
+
+type availabilityCreateRequest struct {
+ Weekday int `json:"weekday"`
+ StartTime string `json:"start_time"`
+ EndTime string `json:"end_time"`
+ Label string `json:"label"`
+}
+
+// HandleWidgetAvailabilityCreate creates a new weekly availability block.
+func (h *Handler) HandleWidgetAvailabilityCreate(w http.ResponseWriter, r *http.Request) {
+ var req availabilityCreateRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, "bad request", http.StatusBadRequest)
+ return
+ }
+ if req.Weekday < 0 || req.Weekday > 6 || req.StartTime == "" || req.EndTime == "" {
+ http.Error(w, "weekday (0-6), start_time, and end_time are required", http.StatusBadRequest)
+ return
+ }
+ block, err := h.store.CreateAvailabilityBlock(req.Weekday, req.StartTime, req.EndTime, req.Label)
+ if err != nil {
+ http.Error(w, "failed to create availability block", http.StatusInternalServerError)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(availabilityBlockToResponse(*block))
+}
+
+type availabilityDeleteRequest struct {
+ ID string `json:"id"`
+}
+
+// HandleWidgetAvailabilityDelete deletes an availability block.
+func (h *Handler) HandleWidgetAvailabilityDelete(w http.ResponseWriter, r *http.Request) {
+ var req availabilityDeleteRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, "bad request", http.StatusBadRequest)
+ return
+ }
+ if err := h.store.DeleteAvailabilityBlock(req.ID); err != nil {
+ if errors.Is(err, store.ErrNativeTaskNotFound) {
+ http.Error(w, "availability block not found", http.StatusNotFound)
+ return
+ }
+ http.Error(w, "failed to delete availability block", http.StatusInternalServerError)
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+}
+
+type taskEstimateRequest struct {
+ ID string `json:"id"`
+ EstimatedMinutes int `json:"estimated_minutes"`
+}
+
+// HandleWidgetTaskEstimate sets a task's estimated duration in minutes.
+func (h *Handler) HandleWidgetTaskEstimate(w http.ResponseWriter, r *http.Request) {
+ var req taskEstimateRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, "bad request", http.StatusBadRequest)
+ return
+ }
+ if req.ID == "" {
+ http.Error(w, "id is required", http.StatusBadRequest)
+ return
+ }
+ if err := h.store.SetTaskEstimate(req.ID, req.EstimatedMinutes); err != nil {
+ if errors.Is(err, store.ErrNativeTaskNotFound) {
+ http.Error(w, "task not found", http.StatusNotFound)
+ return
+ }
+ http.Error(w, "failed to set estimate", http.StatusInternalServerError)
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+}
+
+type projectBudgetTrackedRequest struct {
+ ID string `json:"id"`
+ Tracked bool `json:"tracked"`
+}
+
+// HandleWidgetProjectsBudgetTracked opts a project in or out of budget tracking.
+func (h *Handler) HandleWidgetProjectsBudgetTracked(w http.ResponseWriter, r *http.Request) {
+ var req projectBudgetTrackedRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, "bad request", http.StatusBadRequest)
+ return
+ }
+ if req.ID == "" {
+ http.Error(w, "id is required", http.StatusBadRequest)
+ return
+ }
+ if err := h.store.SetProjectBudgetTracked(req.ID, req.Tracked); err != nil {
+ if errors.Is(err, store.ErrNativeTaskNotFound) {
+ http.Error(w, "project not found", http.StatusNotFound)
+ return
+ }
+ http.Error(w, "failed to update project", http.StatusInternalServerError)
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+}
+
+type labelBudgetTrackedRequest struct {
+ Name string `json:"name"`
+ Tracked bool `json:"tracked"`
+}
+
+// HandleWidgetLabelsBudgetTracked opts a label in or out of budget tracking.
+func (h *Handler) HandleWidgetLabelsBudgetTracked(w http.ResponseWriter, r *http.Request) {
+ var req labelBudgetTrackedRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(w, "bad request", http.StatusBadRequest)
+ return
+ }
+ if req.Name == "" {
+ http.Error(w, "name is required", http.StatusBadRequest)
+ return
+ }
+ if err := h.store.SetLabelBudgetTracked(req.Name, req.Tracked); err != nil {
+ http.Error(w, "failed to update label", http.StatusInternalServerError)
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+}
+```
+
+Register the routes in `cmd/dashboard/main.go`, inside the `if cfg.WidgetToken != ""` block, right after the existing `HandleWidgetLabelsColorSet` line:
+
+```go
+ r.With(widgetAuth).Post("/api/widget/labels/color", h.HandleWidgetLabelsColorSet)
+ r.With(widgetAuth).Get("/api/widget/availability", h.HandleWidgetAvailabilityGet)
+ r.With(widgetAuth).Post("/api/widget/availability", h.HandleWidgetAvailabilityCreate)
+ r.With(widgetAuth).Post("/api/widget/availability/delete", h.HandleWidgetAvailabilityDelete)
+ r.With(widgetAuth).Post("/api/widget/task/estimate", h.HandleWidgetTaskEstimate)
+ r.With(widgetAuth).Post("/api/widget/projects/budget-tracked", h.HandleWidgetProjectsBudgetTracked)
+ r.With(widgetAuth).Post("/api/widget/labels/budget-tracked", h.HandleWidgetLabelsBudgetTracked)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleWidgetAvailability|TestHandleWidgetTaskEstimate|TestHandleWidgetProjectsBudgetTracked|TestHandleWidgetLabelsBudgetTracked' -v`
+Expected: PASS
+
+- [ ] **Step 5: Build and run the full suite**
+
+Run: `go build ./... && go test ./...`
+Expected: PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/handlers/widget.go internal/handlers/widget_test.go cmd/dashboard/main.go
+git commit -m "Add availability CRUD, task estimate, and budget-tracked toggle endpoints"
+```
+
+---
+
+### Task 10: Suggested estimate on task detail
+
+**Files:**
+- Modify: `internal/handlers/widget.go` (`taskDetailResponse`, `HandleWidgetTaskDetail`)
+- Test: `internal/handlers/widget_test.go`
+
+**Interfaces:**
+- Consumes: `s.AverageEstimateForProject`, `s.AverageEstimateForLabel` (Task 6).
+- Produces: `taskDetailResponse.EstimatedMinutes int`; `taskDetailResponse.SuggestedEstimateMinutes *int`.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `internal/handlers/widget_test.go`:
+
+```go
+func TestHandleWidgetTaskDetail_SuggestsEstimateFromProjectAverage(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+ project, err := h.store.CreateProject("Sailing prep", "#3B82F6")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := h.store.CreateNativeTask(models.Task{ID: "t-past", Content: "past", ProjectID: project.ID, EstimatedMinutes: 40}); err != nil {
+ t.Fatal(err)
+ }
+ if err := h.store.CreateNativeTask(models.Task{ID: "t-new", Content: "new", ProjectID: project.ID}); err != nil {
+ t.Fatal(err)
+ }
+
+ req := httptest.NewRequest("GET", "/api/widget/task?id=t-new", nil)
+ w := httptest.NewRecorder()
+ h.HandleWidgetTaskDetail(w, req)
+
+ var resp taskDetailResponse
+ if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+ t.Fatal(err)
+ }
+ if resp.SuggestedEstimateMinutes == nil || *resp.SuggestedEstimateMinutes != 40 {
+ t.Errorf("SuggestedEstimateMinutes = %v, want pointer to 40", resp.SuggestedEstimateMinutes)
+ }
+}
+
+func TestHandleWidgetTaskDetail_AlreadyEstimated_NoSuggestion(t *testing.T) {
+ db, cleanup := setupTestDB(t)
+ defer cleanup()
+ h := &Handler{store: db}
+ project, err := h.store.CreateProject("P", "#111111")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := h.store.CreateNativeTask(models.Task{ID: "t-past", Content: "past", ProjectID: project.ID, EstimatedMinutes: 40}); err != nil {
+ t.Fatal(err)
+ }
+ if err := h.store.CreateNativeTask(models.Task{ID: "t-estimated", Content: "already estimated", ProjectID: project.ID, EstimatedMinutes: 15}); err != nil {
+ t.Fatal(err)
+ }
+
+ req := httptest.NewRequest("GET", "/api/widget/task?id=t-estimated", nil)
+ w := httptest.NewRecorder()
+ h.HandleWidgetTaskDetail(w, req)
+
+ var resp taskDetailResponse
+ if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+ t.Fatal(err)
+ }
+ if resp.SuggestedEstimateMinutes != nil {
+ t.Errorf("expected no suggestion for an already-estimated task, got %v", *resp.SuggestedEstimateMinutes)
+ }
+ if resp.EstimatedMinutes != 15 {
+ t.Errorf("EstimatedMinutes = %d, want 15", resp.EstimatedMinutes)
+ }
+}
+```
+
+- [ ] **Step 2: Run to verify they fail**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleWidgetTaskDetail_Suggests|TestHandleWidgetTaskDetail_AlreadyEstimated' -v`
+Expected: FAIL — `SuggestedEstimateMinutes`/`EstimatedMinutes` don't exist on `taskDetailResponse` yet.
+
+- [ ] **Step 3: Implement**
+
+Read `internal/handlers/widget.go`'s current `HandleWidgetTaskDetail` (around line 569) before editing — it builds `taskDetailResponse` from a loaded `models.Task`. Add two fields to the struct:
+
+```go
+type taskDetailResponse struct {
+ ID string `json:"id"`
+ Title string `json:"title"`
+ Description string `json:"description"`
+ DueDate *time.Time `json:"due_date,omitempty"`
+ Completed bool `json:"completed"`
+ Recurrence *recurrenceResponse `json:"recurrence,omitempty"`
+ NextDate *time.Time `json:"next_date,omitempty"`
+ Project *projectResponse `json:"project,omitempty"`
+ Labels []string `json:"labels,omitempty"`
+ EstimatedMinutes int `json:"estimated_minutes,omitempty"`
+ SuggestedEstimateMinutes *int `json:"suggested_estimate_minutes,omitempty"`
+}
+```
+
+In `HandleWidgetTaskDetail`, after the task is loaded (same point the existing code reads `task.Content`/`task.Description`/etc. to populate the response) and before writing the JSON response, set the new fields:
+
+```go
+ resp.EstimatedMinutes = task.EstimatedMinutes
+ if task.EstimatedMinutes == 0 {
+ if task.ProjectID != "" {
+ if avg, ok, err := h.store.AverageEstimateForProject(task.ProjectID); err == nil && ok {
+ resp.SuggestedEstimateMinutes = &avg
+ }
+ }
+ if resp.SuggestedEstimateMinutes == nil {
+ for _, label := range task.Labels {
+ if avg, ok, err := h.store.AverageEstimateForLabel(label); err == nil && ok {
+ resp.SuggestedEstimateMinutes = &avg
+ break
+ }
+ }
+ }
+ }
+```
+
+Insert this block into the existing `HandleWidgetTaskDetail` right before its final `w.Header().Set("Content-Type", "application/json")` / `json.NewEncoder(w).Encode(resp)` lines — the function's existing response variable is named `resp`.
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleWidgetTaskDetail' -v`
+Expected: PASS (all task-detail tests, old and new)
+
+- [ ] **Step 5: Run the full handlers suite**
+
+Run: `go test ./internal/handlers/...`
+Expected: PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/handlers/widget.go internal/handlers/widget_test.go
+git commit -m "Suggest an estimate from same-project/label averages on task detail"
+```
+
+---
+
+### Task 11: Web timeline indicator
+
+**Files:**
+- Modify: `internal/handlers/timeline.go` (`TimelineData`, `HandleTimeline`)
+- Modify: `web/templates/partials/timeline-tab.html`
+- Test: `internal/handlers/handlers_test.go`
+
+**Interfaces:**
+- Consumes: `(h *Handler) computeBudgetStatus` (Task 8).
+- Produces: `TimelineData.BudgetStatus *models.BudgetStatus`; a small indicator line in the Today section header.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `internal/handlers/handlers_test.go`:
+
+```go
+func TestHandleTimeline_IncludesBudgetStatusWhenTrackedTaskExists(t *testing.T) {
+ h, cleanup := setupTestHandler(t)
+ defer cleanup()
+
+ project, err := h.store.CreateProject("Tracked", "#111111")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := h.store.SetProjectBudgetTracked(project.ID, true); err != nil {
+ t.Fatal(err)
+ }
+ due := time.Now()
+ if err := h.store.CreateNativeTask(models.Task{ID: "t-tracked", Content: "Tracked", ProjectID: project.ID, DueDate: &due, EstimatedMinutes: 30}); err != nil {
+ t.Fatal(err)
+ }
+
+ req := httptest.NewRequest("GET", "/tabs/timeline", nil)
+ w := httptest.NewRecorder()
+ h.HandleTimeline(w, req)
+
+ mock := h.renderer.(*MockRenderer)
+ lastCall := mock.Calls[len(mock.Calls)-1]
+ data, ok := lastCall.Data.(TimelineData)
+ if !ok {
+ t.Fatalf("expected TimelineData, got %T", lastCall.Data)
+ }
+ if data.BudgetStatus == nil {
+ t.Fatal("expected non-nil BudgetStatus")
+ }
+ if data.BudgetStatus.Today.ScheduledMinutes != 30 {
+ t.Errorf("Today.ScheduledMinutes = %d, want 30", data.BudgetStatus.Today.ScheduledMinutes)
+ }
+}
+```
+
+(Check `handlers_test.go`'s existing imports for `models` and `time` — both are almost certainly already imported given the file's size; add only if missing.)
+
+- [ ] **Step 2: Run to verify it fails**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleTimeline_IncludesBudgetStatus' -v`
+Expected: FAIL — `TimelineData.BudgetStatus` doesn't exist.
+
+- [ ] **Step 3: Implement**
+
+In `internal/handlers/timeline.go`, add to `TimelineData` (near the other top-level fields):
+
+```go
+ // Current time for "now" line
+ NowHour int
+ NowMinute int
+
+ // Opt-in budget/availability indicator for Today -- nil when no
+ // budget-tracked task exists (see computeBudgetStatus).
+ BudgetStatus *models.BudgetStatus
+```
+
+In `HandleTimeline`, right after `data := TimelineData{...}` is populated with labels/hours and before `HTMLResponse(...)` is called at the end:
+
+```go
+ budgetStatus, err := h.computeBudgetStatus(now)
+ if err != nil {
+ log.Printf("Warning: failed to compute budget status: %v", err)
+ }
+ data.BudgetStatus = budgetStatus
+
+ HTMLResponse(w, h.renderer, "timeline-tab", data)
+```
+
+In `web/templates/partials/timeline-tab.html`, add the indicator right after the existing items-count span (line 118):
+
+```html
+ <span>📅</span> {{.TodayLabel}}
+ <span class="text-sm font-normal text-white/50">({{len .TodayItems}} items)</span>
+ {{if .BudgetStatus}}
+ <span class="text-sm font-normal text-white/50">· {{.BudgetStatus.Today.ScheduledMinutes}}m scheduled / {{.BudgetStatus.Today.AvailableMinutes}}m available</span>
+ {{end}}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `go test ./internal/handlers/... -run 'TestHandleTimeline' -v`
+Expected: PASS (all `HandleTimeline` tests, old and new)
+
+- [ ] **Step 5: Run the full suite and build**
+
+Run: `go build ./... && go test ./...`
+Expected: PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add internal/handlers/timeline.go internal/handlers/handlers_test.go web/templates/partials/timeline-tab.html
+git commit -m "Show a scheduled-vs-available indicator on the web timeline's Today section"
+```
+
+---
+
+### Task 12: Android widget — TODAY header badge
+
+**Files:**
+- Modify: `android/app/src/main/java/org/terst/doot/widget/data/WidgetItem.kt`
+- Modify: `android/app/src/main/java/org/terst/doot/widget/data/DataStore.kt:13-21` (`Keys` object)
+- Modify: `android/app/src/main/java/org/terst/doot/widget/data/WidgetRepository.kt:54-63` (`fetchAndPersist`)
+- Modify: `android/app/src/main/java/org/terst/doot/widget/ui/DootWidget.kt:28-51` (`DootWidget.provideGlance`, `WidgetRoot` signature/call site, TODAY header `Row`)
+
+**Interfaces:**
+- Consumes: `budget_status` field on the JSON `/api/widget` response (Task 8).
+- Produces: `Keys.BUDGET_STATUS_JSON`; `WidgetRoot(items, now, isRefreshing, textSize, budgetStatus: BudgetStatus?)`; a small badge next to "TODAY" showing e.g. "30m/90m" when `budgetStatus?.today` has a nonzero load.
+
+- [ ] **Step 1: Add the Kotlin model**
+
+In `WidgetItem.kt`, add alongside the existing `WidgetResponse`, and add the new field to `WidgetResponse` itself:
+
+```kotlin
+@Serializable
+data class BudgetPeriod(
+ @SerialName("scheduled_minutes") val scheduledMinutes: Int,
+ @SerialName("available_minutes") val availableMinutes: Int
+)
+
+@Serializable
+data class BudgetStatus(
+ val today: BudgetPeriod,
+ val week: BudgetPeriod
+)
+
+@Serializable
+data class WidgetResponse(
+ val now: String,
+ val items: List<WidgetItem>,
+ @SerialName("budget_status") val budgetStatus: BudgetStatus? = null
+)
+```
+
+- [ ] **Step 2: Add a DataStore key for the persisted budget status**
+
+`DootWidget`'s `provideGlance` doesn't read the full `WidgetResponse` — `WidgetRepository.fetchAndPersist` (see Step 3) decomposes it into individual `Keys` prefs (`ITEMS_JSON`, `NOW`, ...), and `provideGlance` re-reads those individually. Add a matching key in `DataStore.kt`:
+
+```kotlin
+object Keys {
+ val SERVER_URL = stringPreferencesKey("server_url")
+ val TOKEN = stringPreferencesKey("token")
+ val ITEMS_JSON = stringPreferencesKey("items_json")
+ val NOW = stringPreferencesKey("now")
+ val LAST_UPDATED = longPreferencesKey("last_updated")
+ val IS_REFRESHING = booleanPreferencesKey("is_refreshing")
+ val TEXT_SIZE = stringPreferencesKey("text_size")
+ val BUDGET_STATUS_JSON = stringPreferencesKey("budget_status_json")
+}
+```
+
+- [ ] **Step 3: Persist budget_status in fetchAndPersist**
+
+In `WidgetRepository.kt`, update `fetchAndPersist`:
+
+```kotlin
+ /** Fetches and persists to DataStore. Call this from workers. */
+ suspend fun fetchAndPersist(context: Context): Result<WidgetResponse> {
+ return fetchRaw().onSuccess { resp ->
+ context.dataStore.edit { prefs ->
+ prefs[Keys.ITEMS_JSON] = json.encodeToString(resp.items)
+ prefs[Keys.NOW] = resp.now
+ prefs[Keys.LAST_UPDATED] = System.currentTimeMillis()
+ if (resp.budgetStatus != null) {
+ prefs[Keys.BUDGET_STATUS_JSON] = json.encodeToString(resp.budgetStatus)
+ } else {
+ prefs.remove(Keys.BUDGET_STATUS_JSON)
+ }
+ }
+ }
+ }
+```
+
+- [ ] **Step 4: Thread budgetStatus through provideGlance and WidgetRoot**
+
+In `DootWidget.kt`:
+
+```kotlin
+class DootWidget : GlanceAppWidget() {
+
+ override suspend fun provideGlance(context: Context, id: GlanceId) {
+ val prefs = context.dataStore.data.first()
+ val items = parseItems(prefs)
+ val now = prefs[Keys.NOW]?.let { runCatching { Instant.parse(it) }.getOrNull() }
+ ?: Instant.now()
+ val isRefreshing = prefs[Keys.IS_REFRESHING] ?: false
+ val textSize = WidgetTextSize.fromPref(prefs[Keys.TEXT_SIZE])
+ val budgetStatus = prefs[Keys.BUDGET_STATUS_JSON]?.let {
+ runCatching { json.decodeFromString<BudgetStatus>(it) }.getOrNull()
+ }
+
+ provideContent {
+ WidgetRoot(items, now, isRefreshing, textSize, budgetStatus)
+ }
+ }
+
+ private fun parseItems(prefs: Preferences): List<WidgetItem> {
+ val raw = prefs[Keys.ITEMS_JSON] ?: return emptyList()
+ return runCatching { json.decodeFromString<List<WidgetItem>>(raw) }.getOrDefault(emptyList())
+ }
+}
+
+@Composable
+fun WidgetRoot(items: List<WidgetItem>, now: Instant, isRefreshing: Boolean, textSize: WidgetTextSize, budgetStatus: BudgetStatus? = null) {
+```
+
+(Only the signature line of `WidgetRoot` changes here — its body is untouched except for the header `Row` in Step 5. The added `= null` default keeps any other existing call site, e.g. in tests/previews, compiling without changes.)
+
+- [ ] **Step 5: Render the badge**
+
+In the TODAY header `Row` inside `WidgetRoot` (currently: a "TODAY" `Text` with `defaultWeight()`, then `QuickAddButton`, then `RefreshButton`), add a small badge between the title and the buttons, only when there's a nonzero tracked load:
+
+```kotlin
+ item {
+ Row(
+ modifier = GlanceModifier.fillMaxWidth().padding(bottom = 4.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Text(
+ "TODAY",
+ style = TextStyle(
+ color = ColorProvider(Color(0x99FFFFFF)),
+ fontSize = textSize.scaledHeaderSize(11),
+ fontWeight = textSize.scaledHeaderWeight(FontWeight.Bold)
+ ),
+ modifier = GlanceModifier.defaultWeight()
+ )
+ budgetStatus?.today?.let { today ->
+ if (today.scheduledMinutes > 0) {
+ Text(
+ "${today.scheduledMinutes}m/${today.availableMinutes}m",
+ style = TextStyle(
+ color = ColorProvider(Color(0x99FFFFFF)),
+ fontSize = textSize.scaledHeaderSize(10)
+ ),
+ modifier = GlanceModifier.padding(end = 4.dp)
+ )
+ }
+ }
+ QuickAddButton()
+ Spacer(modifier = GlanceModifier.width(4.dp))
+ RefreshButton(isRefreshing)
+ }
+ }
+```
+
+- [ ] **Step 6: Build the Android app**
+
+Run: `cd android && ./gradlew assembleDebug`
+Expected: BUILD SUCCESSFUL
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add android/app/src/main/java/org/terst/doot/widget/data/WidgetItem.kt android/app/src/main/java/org/terst/doot/widget/data/DataStore.kt android/app/src/main/java/org/terst/doot/widget/data/WidgetRepository.kt android/app/src/main/java/org/terst/doot/widget/ui/DootWidget.kt
+git commit -m "Show scheduled/available badge on widget TODAY header"
+```
+
+## Out of Scope (per spec, do not implement)
+
+- Auto-scheduling tasks into specific time slots.
+- Auto-reprioritization or auto-deferral on overflow.
+- Real elapsed-time tracking (start/stop timers).
+- Any UI beyond the basic indicators built here (e.g. a dedicated availability-editing screen) — Tasks 9's endpoints exist for a future UI to call; this plan doesn't build that settings screen.
+- Non-project/label-scoped (global) budgets.
generated by cgit v1.2.3 (git 2.39.1) at 2026-09-14 10:10:13 +0000