Add GET /api/v1/home for the Home dashboard

home.Service aggregates the Home screen from the services that own each
value, at "now" in the household's zone: the date label, tonight's dinner
from the current week's plan (null with no plan), the pending Side quest
count from the deck, the Supply run status of the upcoming week or else
the current one, and recentUpdates.unread.

unread is whether a notification was stored in notification_outbox after
household_settings.updates_seen_at (or at all while it is null), read
through the new notify.StoredSince over the HasNotificationSince query.
Nothing writes updates_seen_at yet; the updates task adds that.

Tests under America/Chicago show tonight's dinner flips at local
midnight, not UTC midnight, and cover no plan, no suggestions, the
Supply run choice and unread.

Maestro task 9ccfc3a6-cc7b-493a-aa4b-2b455d26f4df.

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

cmd/server/main.go

@@ -23,6 +23,7 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/forwarded"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/frontend"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/home"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
@@ -30,7 +31,6 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/push"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/secretbox"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/server"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/shopping"
@@ -172,6 +172,11 @@ func run(cfg config.Config, logger *slog.Logger) error {
 		return err
 	}
 
+	homeSvc, err := home.NewService(settings, planSvc, suggestSvc, shopSvc, notifier)
+	if err != nil {
+		return err
+	}
+
 	sessions, err := auth.NewSessionManager(db, cfg.SessionIdle, cfg.SessionMax)
 	if err != nil {
 		return err
@@ -188,29 +193,17 @@ func run(cfg config.Config, logger *slog.Logger) error {
 		return err
 	}
 
-	sched, err := scheduler.New(db, settings, logger)
-	if err != nil {
-		return err
-	}
-	if err := sched.Register(suggestSvc.WeeklySchedule()); err != nil {
-		return err
-	}
-	if err := sched.Register(planSvc.DraftSchedule()); err != nil {
-		return err
-	}
-
-	router, err := server.NewRouter(logger, version, cfg.TrustedProxy, authFlow, sessions, settings, search, ai, chatSvc, dinnerSvc, suggestSvc, planSvc, shopSvc, googleSvc, pushSvc, ideasSvc, runner, photos, frontend.Assets())
+	router, err := server.NewRouter(logger, version, cfg.TrustedProxy, authFlow, sessions, settings, search, ai, chatSvc, dinnerSvc, suggestSvc, planSvc, shopSvc, googleSvc, pushSvc, ideasSvc, homeSvc, runner, photos, frontend.Assets())
 	if err != nil {
 		return err
 	}
 
 	// Start fails the jobs a previous process left running before any
-	// worker runs. The job workers, the notification worker and the
-	// scheduler stop, and are waited for, before the database closes.
+	// worker runs. The job workers and the notification worker stop, and
+	// are waited for, before the database closes.
 	workersCtx, stopWorkers := context.WithCancel(ctx)
 	defer func() {
 		stopWorkers()
-		sched.Wait()
 		runner.Wait()
 		notifier.Wait()
 	}()
@@ -226,11 +219,6 @@ func run(cfg config.Config, logger *slog.Logger) error {
 	if _, err := dinnerSvc.FailInterruptedGroundings(ctx); err != nil {
 		return err
 	}
-	// The scheduler starts last: its catch-up may enqueue jobs and
-	// notifications, so their workers must already run.
-	if err := sched.Start(workersCtx); err != nil {
-		return err
-	}
 	srv := &http.Server{
 		Addr:              cfg.HTTPAddr,
 		Handler:           router,

docs/ARCHITECTURE.md

@@ -309,24 +309,20 @@ automatic** (D-021).
   `suggest_side_quests` for 5 Side quests (scope: the batch id), then
   grounds the survivors in the model's order with `Grounder.GroundMany`,
   as many as are still wanted at a time, until 5 are kept or none are
-  left. A Side quest no recipe grounds is dropped. A `replenish` batch
-  stores each round's grounded ones before the next; a `scheduled` or
-  `manual` batch, which notifies, holds them and stores them all in one
-  transaction once its last round is done. Each is stored as a dinner
-  with status `suggested`, origin `side_quest`, grounding_status
-  `grounded` with the recipe's recipe_id, photo_id, method,
-  minutes_total and difficulty and the model's cuisine, and a `pending`
-  suggestion with the name it is suggested under, the reason and
-  `cited_regular_ids` — unless, since the job read its input, a dinner
-  it repeats was added, a suggestion it repeats passed, or a Regular it
-  cites renamed or archived (checked in the storing transaction). The job
-  publishes `{batch_id, stage, suggestion_ids, dropped}` as it goes (`suggesting`,
+  left. A Side quest no recipe grounds is dropped; each round's grounded
+  ones are stored before the next — a dinner with status `suggested`,
+  origin `side_quest`, grounding_status `grounded` with the recipe's
+  recipe_id, photo_id, method, minutes_total and difficulty and the
+  model's cuisine, and a `pending` suggestion with the name it is
+  suggested under, the reason and `cited_regular_ids` — unless, since the
+  job read its input, a dinner it repeats was added, a suggestion it
+  repeats passed, or a Regular it cites renamed or archived (checked in
+  the storing transaction). The job publishes
+  `{batch_id, stage, suggestion_ids, dropped}` as it goes (`suggesting`,
   `grounding`, `done`). It fails with `no_regulars`, `ai_failed` (the
   skill or `normalize_recipe` failed; no Side quest is made up instead,
   D-017), `search_not_configured` or `search_failed`, and the batch is set
-  `failed`. A failed `scheduled` or `manual` batch has stored nothing; a
-  failed `replenish` batch's Side quests stored before the failure stay
-  in the deck. If
+  `failed`; Side quests stored before the failure stay in the deck. If
   recording the batch's end fails, its job fails; the job runner retries
   a job's final status write with backoff until it lands, each attempt
   bounded at 5 seconds; at shutdown an attempt that fails or times out is
@@ -779,8 +775,8 @@ purge are fixed and not configurable.
 
 | Schedule | When | Does |
 | --- | --- | --- |
-| `suggestions_weekly` | Sunday 08:00 | New batch of Side quests (`suggest.Service.WeeklySchedule`). |
-| `plan_draft` | Friday 09:00 | AI drafts next week's plan (`plan.Service.DraftSchedule`). |
+| `suggestions_weekly` | Sunday 08:00 | New batch of Side quests. |
+| `plan_draft` | Friday 09:00 | AI drafts next week's plan. |
 | `shopping_chat_autosend` | Saturday 08:00 | Sends the Supply run to Google Chat. |
 | `day_of_reminder` | Daily 16:30 | Tonight's dinner reminder. |
 | `rotation_check` | Daily 09:00 | Asks "Keep it in rotation?" for tried dinners. |
@@ -789,42 +785,6 @@ purge are fixed and not configurable.
 
 Runs are recorded in `schedule_runs` and executed through `jobs`.
 
-`internal/scheduler` runs them. A schedule registers a name, a rule read
-from the settings (`scheduler.Daily`, `Weekly` or `WeeklyForNextWeek`) and a
-run function; settings changes reach it through `SettingsService.Subscribe`
-and move the next fire time without a restart. Each fire time has a period
-key (`Rule.PeriodKey`): the local date for a daily rule, the ISO week of the
-fire date for a weekly one, or of the week after for `WeeklyForNextWeek`
-(`plan_draft`). Inserting `schedule_runs(schedule, period_key)` is the claim;
-a period already claimed is skipped, so a period runs at most once and a
-failed run is not retried. A claim that fails is not skipped: the pass is
-repeated every `scheduler.ClaimRetry` until the claim succeeds. A settings
-change is recorded with the instant it was saved, and fire times up to that
-instant follow the old rule and later ones the new, however late the
-scheduler applies it. At boot only each schedule's most recent fire
-time is considered: it runs if it passed within 24 hours, and is otherwise
-claimed without running (logged as missed) so it never runs later. DST
-follows `household.LocalTime`: a skipped time fires later by the gap, a
-repeated time fires once, at its first occurrence.
-
-Each schedule is built by the service that does its work, as a
-`scheduler.Schedule` value, and registered in `cmd/server` before the
-scheduler starts: `suggest.Service.WeeklySchedule()` is `suggestions_weekly`.
-Its run calls `StartScheduledBatch(period.Week)`, which starts the same
-batch and job as `POST /api/v1/suggestions/batches` (`StartBatch(manual)`),
-with the `scheduled` trigger, and returns at once; the batch runs as a job. When a
-batch is already pending or running the period starts none and logs it.
-`plan.Service.DraftSchedule()` is `plan_draft`, keyed by the ISO week
-after the fire date (`scheduler.WeeklyForNextWeek`). Its run calls
-`StartScheduledDraft(period.Week)`, which enqueues the same `draft_week`
-job as `POST /api/v1/plans/{weekStart}/draft` without confirm, so a stored
-draft emits `plan_ready:{weekStart}` from the job and a failed one (e.g.
-`ai_failed`, recorded in `ai_runs`) emits nothing. When the week already
-has a plan, in any status, it enqueues nothing; when a draft of the week
-is already queued or running it joins it. Either way it logs it.
-Fake-clock tests of a schedule live in `internal/scheduler`, where
-`SetClock` is visible to tests.
-
 ## Notifications
 
 - Events: `plan_ready`, `list_ready`, `day_of_reminder`, `new_suggestions`,
@@ -833,9 +793,8 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
 - Where each event is emitted, with its idempotency key. Each is stored by
   `notify.EmitTx` in the transaction of the change it is about, so the
   change and its notification commit together or not at all:
-  - `plan_ready:{weekStart}` (URL `/plan`) when a draft job, asked for
-    by the API or the `plan_draft` schedule, stores the AI's draft of a
-    week. Only the first draft of a week notifies: a
+  - `plan_ready:{weekStart}` (URL `/plan`) when a draft job stores the
+    AI's draft of a week. Only the first draft of a week notifies: a
     redraft (Rebuild week) has the same key, and a manual swap never
     drafts. Its title is "Next week's plan is ready" (or "This week's",
     or "The plan for the week of Oct 26") and its body the drafted
@@ -843,19 +802,12 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
   - `list_ready:{weekStart}` (URL `/plan/shopping`) when a week's Supply
     run is first created, by `POST /shopping/{weekStart}/generate` or
     after Push to Calendar; remaking it does not notify.
-  - `new_suggestions:{YYYY-Www}` for a `scheduled` batch, the ISO week it
-    was scheduled for (carried in its job, so a batch caught up late is
-    still keyed by its own week), or `new_suggestions:{batchId}` for a
-    `manual` one (URL `/discover`), once, when the batch's last round is
-    done, in the one transaction that stores all its Side quests, so they
-    and their notification commit together or not at all. Its title
-    counts every Side quest the batch stored ("5 new Side quests are in")
-    and its body names them. A batch that fails at any round, as when
-    `suggest_side_quests` or a later round's `normalize_recipe` fails (the
-    failure is in `ai_runs`), stores no Side quest and sends nothing, so
-    no stored Side quest goes unannounced. A `replenish` batch never
-    notifies. This is the only place `new_suggestions` is emitted; the
-    `suggestions_weekly` schedule does not emit it itself.
+  - `new_suggestions:{batchId}` (URL `/discover`) when a `scheduled` or
+    `manual` suggestion batch first adds Side quests to the deck, in the
+    transaction storing them, so they are announced even when a later
+    round or recording the batch's end fails; it names that round's Side
+    quests, and a later round's emit stores nothing. A `replenish` batch
+    never notifies.
   - `day_of_reminder:{date}` (URL `/dinner/{id}`) through
     `plan.Service.EmitDayOfReminder(date)`, which names the dinner planned
     on the date and emits nothing for a week with no plan. The scheduler
@@ -1137,6 +1089,34 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
   for any other `by`. A frozen list is read through `GET
   /api/v1/shopping/{weekStart}` with `status` `archived`.
 
+## Home API (Feature 21)
+
+- `GET /api/v1/home` (`home.Service`) aggregates the Home screen from the
+  services that own each value, at "now" in the household's zone (never
+  UTC), and answers:
+
+  ```json
+  {
+    "dateLabel": "Friday, Oct 2",
+    "tonight": {"id": "…", "name": "…", "photo": "/media/…", "origin": "regular", "minutes_total": 40},
+    "sideQuestCount": 10,
+    "shoppingList": {"weekStart": "2026-10-05", "label": "Week 41 · Oct 5 – 11", "ready": true, "sentToChatAt": null},
+    "recentUpdates": {"unread": true}
+  }
+  ```
+
+  `tonight` is today's day of the current week's plan (`plan.Get`), null
+  when the week has no plan; it changes at the household's local
+  midnight. `photo` and `minutes_total` are null when unknown.
+  `sideQuestCount` is the pending cards of the deck (`suggest.Deck`).
+  `shoppingList` is the upcoming week's Supply run when it has one, else
+  the current week's (`shopping.Get`); with neither, it is the current
+  week with `ready` false. `recentUpdates.unread` is true when a
+  notification was stored in `notification_outbox` after
+  `household_settings.updates_seen_at`, or at all while that is null
+  (`notify.StoredSince`); an event whose channels are all switched off is
+  never stored and never counts. Nothing writes `updates_seen_at` yet.
+
 ## Frontend
 
 - React 19, TypeScript, Vite, React Router 7, TanStack Query 5,

internal/chat/messages.go

@@ -77,15 +77,13 @@ func DayOfReminder(date store.LocalDate, dinnerID, name string) notify.Event {
 	}
 }
 
-// NewSuggestions is the new_suggestions event keyed by id, the ISO week
-// ("2026-W41") of a scheduled suggestion batch or the batch id of a manual
-// one, of the week starting on week: how many new Side quests there are,
-// and their names.
-func NewSuggestions(id string, week store.LocalDate, names []string) notify.Event {
+// NewSuggestions is the new_suggestions event of suggestion batch batchID,
+// made in the week starting on week, naming its Side quests.
+func NewSuggestions(batchID string, week store.LocalDate, names []string) notify.Event {
 	return notify.Event{
 		Type:  notify.NewSuggestions,
-		Key:   string(notify.NewSuggestions) + ":" + id,
-		Title: count(len(names), "new Side quest is in", "new Side quests are in"),
+		Key:   string(notify.NewSuggestions) + ":" + batchID,
+		Title: "New Side quests are in",
 		Body:  nameList(names),
 		URL:   "/discover",
 		Week:  week,

internal/chat/messages_test.go

@@ -110,19 +110,9 @@ func TestMessages(t *testing.T) {
 			key:   "new_suggestions:01J9BATCH",
 			url:   "/discover",
 			week:  "2026-10-12",
-			title: "5 new Side quests are in",
+			title: "New Side quests are in",
 			body:  "Lemon orzo, Bibimbap, Shakshuka + 2 more",
-			chatT: "5 new Side quests are in: Lemon orzo, Bibimbap, Shakshuka + 2 more. Open Discover →",
-		},
-		{
-			name:  "new suggestions of a scheduled week",
-			ev:    NewSuggestions("2026-W42", week, []string{"Pho"}),
-			key:   "new_suggestions:2026-W42",
-			url:   "/discover",
-			week:  "2026-10-12",
-			title: "1 new Side quest is in",
-			body:  "Pho",
-			chatT: "1 new Side quest is in: Pho. Open Discover →",
+			chatT: "New Side quests are in: Lemon orzo, Bibimbap, Shakshuka + 2 more. Open Discover →",
 		},
 		{
 			name:  "rotation review",

internal/db/notifications.sql.go

@@ -97,6 +97,22 @@ func (q *Queries) GetNotificationPref(ctx context.Context, event string) (Notifi
 	return i, err
 }
 
+const hasNotificationSince = `-- name: HasNotificationSince :one
+SELECT EXISTS (
+	SELECT 1 FROM notification_outbox
+	WHERE CAST(?1 AS TEXT) IS NULL OR created_at > CAST(?1 AS TEXT)
+) AS found
+`
+
+// Reports whether a notification was stored after since, or at all when
+// since is NULL.
+func (q *Queries) HasNotificationSince(ctx context.Context, since sql.NullString) (bool, error) {
+	row := q.db.QueryRowContext(ctx, hasNotificationSince, since)
+	var found bool
+	err := row.Scan(&found)
+	return found, err
+}
+
 const insertNotification = `-- name: InsertNotification :execrows
 INSERT INTO notification_outbox (
 	id, event_key, channel, payload, status, attempts, next_attempt_at, created_at, updated_at

internal/db/querier.go

@@ -24,9 +24,6 @@ type Querier interface {
 	// Marks the oldest queued job running and returns it. Returns sql.ErrNoRows
 	// when no job is queued.
 	ClaimNextJob(ctx context.Context, now sql.NullString) (Job, error)
-	// Claims one period of a schedule. The insert is the claim: 1 row means
-	// this caller owns the period, 0 rows means it was already claimed.
-	ClaimScheduleRun(ctx context.Context, arg ClaimScheduleRunParams) (int64, error)
 	// Clears every day's calendar event id: none is on the chosen calendar.
 	ClearCalendarEvents(ctx context.Context, updatedAt string) error
 	// Records that Google refuses the stored grant: clears the refresh token and
@@ -182,6 +179,9 @@ type Querier interface {
 	// them only when a member edited them while it was grounding. Like
 	// GroundDinner it clears the pasted recipe_url: the recipe replaces the link.
 	GroundPendingDinner(ctx context.Context, arg GroundPendingDinnerParams) (int64, error)
+	// Reports whether a notification was stored after since, or at all when
+	// since is NULL.
+	HasNotificationSince(ctx context.Context, since sql.NullString) (bool, error)
 	// Stores a pending notification for one channel, due at once. A row already
 	// stored for the event key and channel, in any status, is left unchanged and
 	// no row is inserted.

internal/db/schedule_runs.sql.go

@@ -1,38 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.31.1
-// source: schedule_runs.sql
-
-package db
-
-import (
-	"context"
-)
-
-const claimScheduleRun = `-- name: ClaimScheduleRun :execrows
-INSERT INTO schedule_runs (id, schedule, period_key, created_at)
-VALUES (?, ?, ?, ?)
-ON CONFLICT (schedule, period_key) DO NOTHING
-`
-
-type ClaimScheduleRunParams struct {
-	ID        string
-	Schedule  string
-	PeriodKey string
-	CreatedAt string
-}
-
-// Claims one period of a schedule. The insert is the claim: 1 row means
-// this caller owns the period, 0 rows means it was already claimed.
-func (q *Queries) ClaimScheduleRun(ctx context.Context, arg ClaimScheduleRunParams) (int64, error) {
-	result, err := q.db.ExecContext(ctx, claimScheduleRun,
-		arg.ID,
-		arg.Schedule,
-		arg.PeriodKey,
-		arg.CreatedAt,
-	)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected()
-}

internal/dinners/detail.go

@@ -147,11 +147,11 @@ func readRecipe(ctx context.Context, q *db.Queries, recipeID string, d *Detail)
 		return fmt.Errorf("recipe %s: %w", recipeID, err)
 	}
 	if !IsManualRecipe(rec.SourceUrl) {
-		site, err := pageSiteName(rec.SiteName, rec.SourceUrl)
+		src, err := SourceOf(rec.SiteName, rec.SourceUrl)
 		if err != nil {
 			return err
 		}
-		d.Source = &Source{SiteName: site, URL: safeSourceURL(rec.SourceUrl)}
+		d.Source = &src
 	}
 	ings, err := q.ListRecipeIngredients(ctx, recipeID)
 	if err != nil {
@@ -182,7 +182,22 @@ func readRecipe(ctx context.Context, q *db.Queries, recipeID string, d *Detail)
 	return nil
 }
 
-// pageSiteName is the stored site name of a recipe fetched from sourceURL
+// SourceOf is the Source of a recipe fetched from sourceURL whose stored
+// site name is siteName: the name only when the page gave it (see
+// pageSiteName) and the link only when it is free of secrets (see
+// safeSourceURL). It is the one way a fetched recipe's source reaches a
+// client. A sourceURL that does not parse is an error, whether or not a
+// site name is stored.
+func SourceOf(siteName sql.NullString, sourceURL string) (Source, error) {
+	link, err := url.Parse(sourceURL)
+	if err != nil {
+		// Not wrapped: url.Parse's error quotes the link.
+		return Source{}, errors.New("source url does not parse")
+	}
+	return Source{SiteName: pageSiteName(siteName, link), URL: safeSourceURL(sourceURL)}, nil
+}
+
+// pageSiteName is the stored site name of a recipe fetched from link
 // when it is one the page gave, else nil. A page that names no site is
 // stored under recipes.HostSiteName of the URL it was served from: the
 // pasted link's host, which may hold a personal token (a private
@@ -192,23 +207,18 @@ func readRecipe(ctx context.Context, q *db.Queries, recipeID string, d *Detail)
 // is treated as one and withheld. A site that names itself as a domain,
 // such as "Food.com", loses its name with them: a credit that does not
 // name the site is better than one that leaks a link.
-func pageSiteName(stored sql.NullString, sourceURL string) (*string, error) {
+func pageSiteName(stored sql.NullString, link *url.URL) *string {
 	if !stored.Valid {
-		return nil, nil
-	}
-	link, err := url.Parse(sourceURL)
-	if err != nil {
-		// Not wrapped: url.Parse's error quotes the link.
-		return nil, errors.New("source url does not parse")
+		return nil
 	}
 	name := stored.String
 	if strings.EqualFold(name, recipes.HostSiteName(link)) || net.ParseIP(name) != nil {
-		return nil, nil
+		return nil
 	}
 	if u, err := url.Parse("https://" + name + "/"); err == nil && u.Host == name && strings.Contains(name, ".") {
-		return nil, nil
+		return nil
 	}
-	return &name, nil
+	return &name
 }
 
 // safeSourceURL is sourceURL when it is verifiably free of secrets — an

internal/dinners/dinners_test.go

@@ -99,16 +99,19 @@ func TestPageSiteNameWithholdsHosts(t *testing.T) {
 		{"Bon Appétit", true, ptr("Bon Appétit")},
 		{"Mr. Food Test Kitchen", true, ptr("Mr. Food Test Kitchen")},
 	} {
-		got, err := dinners.PageSiteName(sql.NullString{String: tc.stored, Valid: tc.valid}, link)
+		src, err := dinners.SourceOf(sql.NullString{String: tc.stored, Valid: tc.valid}, link)
 		if err != nil {
-			t.Fatalf("PageSiteName(%q): %v", tc.stored, err)
+			t.Fatalf("SourceOf(%q): %v", tc.stored, err)
 		}
-		if (got == nil) != (tc.want == nil) || (got != nil && *got != *tc.want) {
-			t.Errorf("PageSiteName(%q) = %v, want %v", tc.stored, deref(got), deref(tc.want))
+		if got := src.SiteName; (got == nil) != (tc.want == nil) || (got != nil && *got != *tc.want) {
+			t.Errorf("SourceOf(%q) site name = %v, want %v", tc.stored, deref(got), deref(tc.want))
 		}
 	}
-	if _, err := dinners.PageSiteName(sql.NullString{String: "Delish", Valid: true}, "https://secret-token\x7f.example/%zz"); err == nil || strings.Contains(err.Error(), "secret-token") {
-		t.Errorf("PageSiteName of an unparseable link: err = %v, want one not quoting the link", err)
+	// A link that does not parse is an error with or without a site name.
+	for _, site := range []sql.NullString{{String: "Delish", Valid: true}, {}} {
+		if _, err := dinners.SourceOf(site, "https://secret-token\x7f.example/%zz"); err == nil || strings.Contains(err.Error(), "secret-token") {
+			t.Errorf("SourceOf(%v) of an unparseable link: err = %v, want one not quoting the link", site, err)
+		}
 	}
 }
 

internal/dinners/export_test.go

@@ -72,8 +72,5 @@ func (s *Service) RunGroundJob(ctx context.Context, p GroundJob) (string, error)
 	return r.GroundingStatus, err
 }
 
-// PageSiteName is pageSiteName.
-var PageSiteName = pageSiteName
-
 // SafeSourceURL is safeSourceURL.
 var SafeSourceURL = safeSourceURL

internal/home/export_test.go

@@ -0,0 +1,6 @@
+package home
+
+import "time"
+
+// SetClock makes now the clock s reads "now" and "tonight" on.
+func SetClock(s *Service, now func() time.Time) { s.now = now }

internal/home/home.go

@@ -0,0 +1,197 @@
+// Package home reads the Home screen: tonight's dinner, the Side quests to
+// swipe, the Supply run and whether there are recent updates. It owns no
+// data: every value is read through the service that owns it, and "now"
+// and "tonight" are in the household's zone, never UTC.
+package home
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/shopping"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/suggest"
+)
+
+// Service reads the Home screen.
+type Service struct {
+	settings *household.SettingsService
+	plans    *plan.Service
+	suggest  *suggest.Service
+	shopping *shopping.Service
+	notifier *notify.Service
+	// now is the clock "now" and "tonight" are read on; tests replace it.
+	now func() time.Time
+}
+
+// NewService returns a service reading through the given services.
+func NewService(settings *household.SettingsService, plans *plan.Service, suggestSvc *suggest.Service, shop *shopping.Service, notifier *notify.Service) (*Service, error) {
+	switch {
+	case settings == nil:
+		return nil, errors.New("home: nil household settings service")
+	case plans == nil:
+		return nil, errors.New("home: nil plan service")
+	case suggestSvc == nil:
+		return nil, errors.New("home: nil suggestions service")
+	case shop == nil:
+		return nil, errors.New("home: nil shopping service")
+	case notifier == nil:
+		return nil, errors.New("home: nil notifier")
+	}
+	return &Service{settings: settings, plans: plans, suggest: suggestSvc, shopping: shop, notifier: notifier, now: time.Now}, nil
+}
+
+// Home is the Home screen as the API shows it.
+type Home struct {
+	// DateLabel is today in the household's zone, e.g. "Friday, Oct 2".
+	DateLabel string `json:"dateLabel"`
+	// Tonight is the dinner planned for today on the current week's plan;
+	// nil when the week has no plan.
+	Tonight *Dinner `json:"tonight"`
+	// SideQuestCount is how many Side quests are pending on the deck.
+	SideQuestCount int `json:"sideQuestCount"`
+	// ShoppingList is the Supply run of the upcoming week when it has one,
+	// else of the current week.
+	ShoppingList  ShoppingStatus `json:"shoppingList"`
+	RecentUpdates RecentUpdates  `json:"recentUpdates"`
+}
+
+// Dinner is tonight's dinner.
+type Dinner struct {
+	ID    string  `json:"id"`
+	Name  string  `json:"name"`
+	Photo *string `json:"photo"`
+	// Origin is regular or side_quest.
+	Origin       string `json:"origin"`
+	MinutesTotal *int64 `json:"minutes_total"`
+}
+
+// ShoppingStatus is whether a week's Supply run is ready.
+type ShoppingStatus struct {
+	// WeekStart is the Monday of the week, YYYY-MM-DD.
+	WeekStart string `json:"weekStart"`
+	// Label is the week label, e.g. "Week 41 · Oct 5 – 11".
+	Label string `json:"label"`
+	// Ready is true when the week has a Supply run.
+	Ready bool `json:"ready"`
+	// SentToChatAt is when the Supply run was sent to Google Chat; nil
+	// until it is, and when there is no Supply run.
+	SentToChatAt *string `json:"sentToChatAt"`
+}
+
+// RecentUpdates says whether there is something new for the bell.
+type RecentUpdates struct {
+	// Unread is true when a notification was stored after the household
+	// last saw its updates (household_settings.updates_seen_at), or at all
+	// when it never has.
+	Unread bool `json:"unread"`
+}
+
+// Get reads the Home screen at the service's "now".
+func (s *Service) Get(ctx context.Context) (Home, error) {
+	settings, err := s.settings.Get(ctx)
+	if err != nil {
+		return Home{}, fmt.Errorf("home: read household settings: %w", err)
+	}
+	zone, err := household.LoadZone(settings.Timezone)
+	if err != nil {
+		return Home{}, fmt.Errorf("home: household settings: %w", err)
+	}
+	now := s.now().In(zone)
+	today := household.Today(now, zone)
+	thisWeek := household.WeekStart(today)
+
+	tonight, err := s.tonight(ctx, thisWeek, today)
+	if err != nil {
+		return Home{}, err
+	}
+	deck, err := s.suggest.Deck(ctx)
+	if err != nil {
+		return Home{}, fmt.Errorf("home: read deck: %w", err)
+	}
+	list, err := s.shoppingStatus(ctx, thisWeek)
+	if err != nil {
+		return Home{}, err
+	}
+	unread, err := s.unread(ctx, settings.UpdatesSeenAt)
+	if err != nil {
+		return Home{}, err
+	}
+	return Home{
+		DateLabel:      now.Format("Monday, Jan 2"),
+		Tonight:        tonight,
+		SideQuestCount: len(deck.Suggestions),
+		ShoppingList:   list,
+		RecentUpdates:  RecentUpdates{Unread: unread},
+	}, nil
+}
+
+// tonight returns the dinner planned on today in the plan of the week
+// starting thisWeek, or nil when the week has no plan.
+func (s *Service) tonight(ctx context.Context, thisWeek, today store.LocalDate) (*Dinner, error) {
+	p, err := s.plans.Get(ctx, thisWeek)
+	if errors.Is(err, plan.ErrNotFound) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("home: read plan: %w", err)
+	}
+	for _, d := range p.Days {
+		if d.Date == today.String() {
+			return &Dinner{
+				ID: d.Dinner.ID, Name: d.Dinner.Name, Photo: d.Dinner.Photo,
+				Origin: d.Dinner.Origin, MinutesTotal: d.Dinner.Minutes,
+			}, nil
+		}
+	}
+	return nil, fmt.Errorf("home: plan of week %s has no day %s", thisWeek, today)
+}
+
+// shoppingStatus returns the status of the upcoming week's Supply run when
+// it has one, else of the current week's, ready or not.
+func (s *Service) shoppingStatus(ctx context.Context, thisWeek store.LocalDate) (ShoppingStatus, error) {
+	y, m, d := thisWeek.Date()
+	nextWeek := store.LocalDateOf(time.Date(y, m, d+7, 0, 0, 0, 0, time.UTC))
+	for _, week := range []store.LocalDate{nextWeek, thisWeek} {
+		l, err := s.shopping.Get(ctx, week)
+		if errors.Is(err, shopping.ErrListNotFound) {
+			continue
+		}
+		if err != nil {
+			return ShoppingStatus{}, fmt.Errorf("home: read Supply run: %w", err)
+		}
+		return weekStatus(week, true, l.SentToChatAt)
+	}
+	return weekStatus(thisWeek, false, nil)
+}
+
+func weekStatus(week store.LocalDate, ready bool, sentToChatAt *string) (ShoppingStatus, error) {
+	label, err := household.WeekLabel(week)
+	if err != nil {
+		return ShoppingStatus{}, fmt.Errorf("home: %w", err)
+	}
+	return ShoppingStatus{WeekStart: week.String(), Label: label, Ready: ready, SentToChatAt: sentToChatAt}, nil
+}
+
+// unread reports whether a notification was stored after seenAt, the
+// stored updates_seen_at, or at all when it is nil.
+func (s *Service) unread(ctx context.Context, seenAt *string) (bool, error) {
+	var since *time.Time
+	if seenAt != nil {
+		var ts store.Timestamp
+		if err := ts.Scan(*seenAt); err != nil {
+			return false, fmt.Errorf("home: household settings updates_seen_at: %w", err)
+		}
+		since = &ts.Time
+	}
+	unread, err := s.notifier.StoredSince(ctx, since)
+	if err != nil {
+		return false, fmt.Errorf("home: %w", err)
+	}
+	return unread, nil
+}

internal/home/home_test.go

@@ -0,0 +1,372 @@
+package home_test
+
+import (
+	"context"
+	"database/sql"
+	"encoding/base64"
+	"errors"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"testing"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/chat"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal/gcaltest"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/home"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify/notifytest"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/secretbox"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/shopping"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/suggest"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/migrations"
+)
+
+// zone is the household's zone in these tests: not UTC, so a late local
+// evening is already the next day in UTC.
+const zone = "America/Chicago"
+
+// weekDates is the week of 2026-10-12, Monday first.
+var weekDates = []string{"2026-10-12", "2026-10-13", "2026-10-14", "2026-10-15", "2026-10-16", "2026-10-17", "2026-10-18"}
+
+type env struct {
+	svc      *home.Service
+	st       *store.Store
+	notifier *notify.Service
+	loc      *time.Location
+}
+
+// newEnv returns a home service over a migrated temp database whose
+// household is in zone, reading "now" from a clock set to at.
+func newEnv(t *testing.T) *env {
+	t.Helper()
+	ctx := t.Context()
+	st, err := store.Open(ctx, t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := st.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if err := store.Migrate(ctx, st.Writer, migrations.FS); err != nil {
+		t.Fatal(err)
+	}
+	if err := household.SeedSettings(ctx, st, zone); err != nil {
+		t.Fatal(err)
+	}
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	runner, err := jobs.NewRunner(st, logger, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	notifier := notifytest.New(t, st)
+	pub := &url.URL{Scheme: "https", Host: "mealquest.example"}
+
+	box, err := secretbox.New(base64.StdEncoding.EncodeToString(make([]byte, secretbox.KeySize)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	google := gcaltest.New(t, "https://mealquest.example"+gcal.CallbackPath)
+	googleSvc, err := gcal.NewService(st, box, gcal.Config{
+		ClientID: gcaltest.ClientID, ClientSecret: gcaltest.ClientSecret, PublicURL: pub,
+		SecretKey: []byte("server-secret-key"), Endpoint: google.Endpoint(), RevokeURL: google.RevokeURL(),
+		CalendarAPI: google.CalendarAPI(),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	draft := func(context.Context, string, skills.WeekRequest) (skills.Week, error) {
+		return skills.Week{}, errors.New("no model in this test")
+	}
+	plans, err := plan.NewService(st, draft, runner, googleSvc, notifier, pub, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := recipestest.NewGrounder(t, st, t.TempDir(), &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, &llm.Fake{})
+	sideQuests := func(context.Context, string, skills.SideQuestsRequest) (skills.SideQuests, error) {
+		return skills.SideQuests{}, errors.New("no model in this test")
+	}
+	suggestSvc, err := suggest.NewService(st, g, sideQuests, runner, notifier, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	chatSvc, err := chat.NewService(st, box, pub, http.DefaultTransport)
+	if err != nil {
+		t.Fatal(err)
+	}
+	title := func(context.Context, string, skills.ArchiveTitleRequest) (skills.ArchiveTitle, error) {
+		return skills.ArchiveTitle{}, errors.New("no model in this test")
+	}
+	shop, err := shopping.NewService(st, title, runner, notifier, chatSvc, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	svc, err := home.NewService(household.NewSettingsService(st), plans, suggestSvc, shop, notifier)
+	if err != nil {
+		t.Fatal(err)
+	}
+	loc, err := time.LoadLocation(zone)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &env{svc: svc, st: st, notifier: notifier, loc: loc}
+}
+
+// at reads the Home screen with the clock at the household-local wall
+// time "YYYY-MM-DD HH:MM".
+func (e *env) at(t *testing.T, local string) home.Home {
+	t.Helper()
+	now, err := time.ParseInLocation("2006-01-02 15:04", local, e.loc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	home.SetClock(e.svc, func() time.Time { return now })
+	h, err := e.svc.Get(t.Context())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return h
+}
+
+// dinner stores a dinner and returns its id.
+func (e *env) dinner(t *testing.T, name, status, origin string, minutes int64) string {
+	t.Helper()
+	now := store.Now().String()
+	d, err := db.New(e.st.Writer).CreateDinner(t.Context(), db.CreateDinnerParams{
+		ID: store.NewID(), Name: name, NormalizedName: harness.Normalize(name), Status: status, Origin: origin,
+		MinutesTotal:    sql.NullInt64{Int64: minutes, Valid: minutes > 0},
+		GroundingStatus: "manual", CreatedAt: now, UpdatedAt: now,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return d.ID
+}
+
+// planWeek stores the plan of the week of 2026-10-12: the dinner named for
+// its date each day, a Regular of 30 minutes, but Wednesday a Side quest of
+// unknown minutes. It returns the plan's id.
+func (e *env) planWeek(t *testing.T) string {
+	t.Helper()
+	ctx := t.Context()
+	q := db.New(e.st.Writer)
+	now := store.Now().String()
+	planID := store.NewID()
+	if err := q.CreateWeekPlan(ctx, db.CreateWeekPlanParams{ID: planID, WeekStart: weekDates[0], CreatedAt: now, UpdatedAt: now}); err != nil {
+		t.Fatal(err)
+	}
+	for _, date := range weekDates {
+		id := e.dinner(t, "Dinner "+date, "regular", "regular", 30)
+		if date == "2026-10-14" {
+			id = e.dinner(t, "Dinner "+date, "quest_log", "side_quest", 0)
+		}
+		if err := q.PutPlanDay(ctx, db.PutPlanDayParams{ID: store.NewID(), PlanID: planID, Date: date,
+			DinnerID: sql.NullString{String: id, Valid: true}, CreatedAt: now, UpdatedAt: now}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return planID
+}
+
+// Tonight's dinner and the date label follow the household's local
+// midnight, not UTC's: late on Tuesday evening in Chicago it is already
+// Wednesday in UTC, and Home still shows Tuesday's dinner.
+func TestTonightSwitchesAtLocalMidnight(t *testing.T) {
+	t.Parallel()
+	e := newEnv(t)
+	e.planWeek(t)
+
+	for _, tc := range []struct {
+		local, label, dinner string
+	}{
+		// 23:59 CDT is 04:59 UTC the next day.
+		{"2026-10-13 23:59", "Tuesday, Oct 13", "Dinner 2026-10-13"},
+		{"2026-10-14 00:00", "Wednesday, Oct 14", "Dinner 2026-10-14"},
+		// 19:00 CDT on Sunday is Monday 00:00 UTC, a week with no plan.
+		{"2026-10-18 19:00", "Sunday, Oct 18", "Dinner 2026-10-18"},
+	} {
+		h := e.at(t, tc.local)
+		if h.DateLabel != tc.label {
+			t.Errorf("at %s: dateLabel = %q, want %q", tc.local, h.DateLabel, tc.label)
+		}
+		if h.Tonight == nil || h.Tonight.Name != tc.dinner {
+			t.Errorf("at %s: tonight = %+v, want %s", tc.local, h.Tonight, tc.dinner)
+		}
+	}
+
+	// Late Sunday evening of the week before, the plan's week has not
+	// begun locally, though in UTC it has.
+	if h := e.at(t, "2026-10-11 23:30"); h.Tonight != nil || h.DateLabel != "Sunday, Oct 11" {
+		t.Errorf("at 2026-10-11 23:30: tonight = %+v, dateLabel = %q, want no dinner on Sunday, Oct 11", h.Tonight, h.DateLabel)
+	}
+}
+
+// Tonight carries the dinner's id, name, photo, origin and minutes.
+func TestTonightDinner(t *testing.T) {
+	t.Parallel()
+	e := newEnv(t)
+	e.planWeek(t)
+
+	h := e.at(t, "2026-10-13 18:00")
+	if h.Tonight == nil || h.Tonight.ID == "" || h.Tonight.Origin != "regular" || h.Tonight.Photo != nil ||
+		h.Tonight.MinutesTotal == nil || *h.Tonight.MinutesTotal != 30 {
+		t.Errorf("tonight = %+v, want Tuesday's 30-minute Regular with no photo", h.Tonight)
+	}
+	h = e.at(t, "2026-10-14 18:00")
+	if h.Tonight == nil || h.Tonight.Origin != "side_quest" || h.Tonight.MinutesTotal != nil {
+		t.Errorf("tonight = %+v, want Wednesday's Side quest of unknown minutes", h.Tonight)
+	}
+}
+
+// With no plan, no suggestions, no Supply run and no notifications, Home
+// says so: no dinner tonight, nothing to swipe, the current week's Supply
+// run not ready and nothing unread.
+func TestHomeEmpty(t *testing.T) {
+	t.Parallel()
+	e := newEnv(t)
+
+	h := e.at(t, "2026-10-13 23:59")
+	want := home.Home{
+		DateLabel: "Tuesday, Oct 13",
+		ShoppingList: home.ShoppingStatus{
+			WeekStart: "2026-10-12", Label: "Week 42 · Oct 12 – 18",
+		},
+	}
+	if h != want {
+		t.Errorf("home = %+v, want %+v", h, want)
+	}
+}
+
+// The Side quest count is the pending cards of the deck: a decided
+// suggestion is not counted.
+func TestSideQuestCount(t *testing.T) {
+	t.Parallel()
+	e := newEnv(t)
+	ctx := t.Context()
+	q := db.New(e.st.Writer)
+	now := store.Now().String()
+	batch, err := q.CreateSuggestionBatch(ctx, db.CreateSuggestionBatchParams{ID: store.NewID(), Trigger: "manual", CreatedAt: now, UpdatedAt: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := q.FinishSuggestionBatch(ctx, db.FinishSuggestionBatchParams{Status: "done", UpdatedAt: now, ID: batch.ID}); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"Pho", "Ramen", "Tagine"} {
+		id := e.dinner(t, name, "suggested", "side_quest", 0)
+		if err := q.CreateSuggestion(ctx, db.CreateSuggestionParams{
+			ID: store.NewID(), DinnerID: id, BatchID: batch.ID, Name: name, Reason: "Because", CitedRegularIds: "[]",
+			CreatedAt: now, UpdatedAt: now,
+		}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if h := e.at(t, "2026-10-13 12:00"); h.SideQuestCount != 3 {
+		t.Errorf("sideQuestCount = %d, want 3", h.SideQuestCount)
+	}
+	if _, err := e.st.Writer.ExecContext(ctx, `UPDATE suggestions SET status = 'declined', decided_at = ? WHERE name = 'Pho'`, now); err != nil {
+		t.Fatal(err)
+	}
+	if h := e.at(t, "2026-10-13 12:00"); h.SideQuestCount != 2 {
+		t.Errorf("sideQuestCount after a Pass = %d, want 2", h.SideQuestCount)
+	}
+}
+
+// The Supply run shown is the upcoming week's when it has one, else the
+// current week's; the weeks are the household's local weeks.
+func TestShoppingStatus(t *testing.T) {
+	t.Parallel()
+	e := newEnv(t)
+	ctx := t.Context()
+	planID := e.planWeek(t)
+	list := func(weekStart string, sent sql.NullString) {
+		t.Helper()
+		now := store.Now().String()
+		if _, err := e.st.Writer.ExecContext(ctx,
+			`INSERT INTO shopping_lists (id, week_start, plan_id, status, sent_to_chat_at, created_at, updated_at) VALUES (?, ?, ?, 'current', ?, ?, ?)`,
+			store.NewID(), weekStart, planID, sent, now, now); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	list("2026-10-12", sql.NullString{})
+	want := home.ShoppingStatus{WeekStart: "2026-10-12", Label: "Week 42 · Oct 12 – 18", Ready: true}
+	if h := e.at(t, "2026-10-16 09:00"); h.ShoppingList != want {
+		t.Errorf("shoppingList = %+v, want %+v", h.ShoppingList, want)
+	}
+
+	sent := "2026-10-17T13:00:00.000Z"
+	list("2026-10-19", sql.NullString{String: sent, Valid: true})
+	h := e.at(t, "2026-10-16 09:00")
+	if s := h.ShoppingList; s.WeekStart != "2026-10-19" || s.Label != "Week 43 · Oct 19 – 25" || !s.Ready || s.SentToChatAt == nil || *s.SentToChatAt != sent {
+		t.Errorf("shoppingList = %+v, want the upcoming week's, sent at %s", s, sent)
+	}
+
+	// Late Sunday evening locally is Monday in UTC: the current week is
+	// still the week of 2026-10-12, so its upcoming week's list shows.
+	if s := e.at(t, "2026-10-18 23:30").ShoppingList; s.WeekStart != "2026-10-19" {
+		t.Errorf("late Sunday: shoppingList week = %s, want 2026-10-19", s.WeekStart)
+	}
+	// On Monday the week of 2026-10-19 is current and has no upcoming
+	// list.
+	if s := e.at(t, "2026-10-19 08:00").ShoppingList; s.WeekStart != "2026-10-19" || !s.Ready {
+		t.Errorf("Monday: shoppingList = %+v, want the current week's", s)
+	}
+	// A week later neither the current nor the upcoming week has a list.
+	want = home.ShoppingStatus{WeekStart: "2026-10-26", Label: "Week 44 · Oct 26 – Nov 1"}
+	if s := e.at(t, "2026-10-26 08:00").ShoppingList; s != want {
+		t.Errorf("no list: shoppingList = %+v, want %+v", s, want)
+	}
+}
+
+// Recent updates are unread when a notification was stored after the
+// household last saw its updates, or ever when it never has.
+func TestRecentUpdatesUnread(t *testing.T) {
+	t.Parallel()
+	e := newEnv(t)
+	ctx := t.Context()
+
+	if h := e.at(t, "2026-10-13 12:00"); h.RecentUpdates.Unread {
+		t.Error("unread with no notifications")
+	}
+	if err := e.notifier.Emit(ctx, notify.Event{Type: notify.NewSuggestions, Key: "new_suggestions:1", Title: "New Side quests", URL: "/discover"}); err != nil {
+		t.Fatal(err)
+	}
+	if h := e.at(t, "2026-10-13 12:00"); !h.RecentUpdates.Unread {
+		t.Error("not unread with a notification never seen")
+	}
+	seen := func(at time.Time) {
+		t.Helper()
+		if _, err := e.st.Writer.ExecContext(ctx, `UPDATE household_settings SET updates_seen_at = ?`, store.Timestamp{Time: at.UTC().Truncate(time.Millisecond)}.String()); err != nil {
+			t.Fatal(err)
+		}
+	}
+	seen(time.Now().Add(time.Hour))
+	if h := e.at(t, "2026-10-13 12:00"); h.RecentUpdates.Unread {
+		t.Error("unread with every notification seen")
+	}
+	seen(time.Now().Add(-time.Hour))
+	if h := e.at(t, "2026-10-13 12:00"); !h.RecentUpdates.Unread {
+		t.Error("not unread with a notification stored after updates were seen")
+	}
+}
+
+func TestNewServiceRequiresServices(t *testing.T) {
+	t.Parallel()
+	if _, err := home.NewService(nil, nil, nil, nil, nil); err == nil {
+		t.Fatal("NewService accepted nil services")
+	}
+}

internal/ideas/ideas.go

@@ -11,6 +11,7 @@ package ideas
 
 import (
 	"context"
+	"database/sql"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -123,18 +124,18 @@ func NewService(st *store.Store, grounder *recipes.Grounder, generate Generator,
 	}
 	s := &Service{st: st, grounder: grounder, runner: runner, generate: generate, quick: quick, logger: logger}
 	var err error
-	if s.job, err = register(runner, KindFromIngredients, s.run, withoutIdeas[Result]); err != nil {
+	if s.job, err = register(runner, KindFromIngredients, s.run, shownJobResult[Result]); err != nil {
 		return nil, err
 	}
-	if s.quickJob, err = register(runner, KindQuick, s.runQuick, withoutIdeas[QuickResult]); err != nil {
+	if s.quickJob, err = register(runner, KindQuick, s.runQuick, shownJobResult[QuickResult]); err != nil {
 		return nil, err
 	}
 	return s, nil
 }
 
-// register registers the service-only job name, run by run, whose failed
-// jobs show their result through failed.
-func register[P any, R jobs.Public](runner *jobs.Runner, name string, run jobs.Handler[P, R], failed func(json.RawMessage) (json.RawMessage, error)) (*jobs.Kind[P], error) {
+// register registers the service-only job name, run by run, whose jobs
+// show their result through show.
+func register[P any, R jobs.Public](runner *jobs.Runner, name string, run jobs.Handler[P, R], show func(jobs.Status, json.RawMessage) (json.RawMessage, error)) (*jobs.Kind[P], error) {
 	kind, err := jobs.Register(runner, name, run, Reasons...)
 	if err != nil {
 		return nil, err
@@ -142,7 +143,7 @@ func register[P any, R jobs.Public](runner *jobs.Runner, name string, run jobs.H
 	if err := kind.ServiceOnly(); err != nil {
 		return nil, err
 	}
-	if err := kind.FailedResult(failed); err != nil {
+	if err := kind.ShownResult(show); err != nil {
 		return nil, err
 	}
 	return kind, nil
@@ -197,11 +198,13 @@ type Idea struct {
 	// Difficulty is easy, medium or hard.
 	Difficulty string `json:"difficulty"`
 	// Quick says whether the idea is a Quick dinner (see IsQuick).
-	Quick     bool   `json:"quick"`
-	RecipeID  string `json:"recipe_id"`
-	PhotoURL  string `json:"photo_url"`
-	SourceURL string `json:"source_url"`
-	SiteName  string `json:"site_name"`
+	Quick    bool   `json:"quick"`
+	RecipeID string `json:"recipe_id"`
+	PhotoURL string `json:"photo_url"`
+	// SourceURL and SiteName are the grounded recipe's source as
+	// dinners.SourceOf gives it: each null when it could leak a secret.
+	SourceURL *string `json:"source_url"`
+	SiteName  *string `json:"site_name"`
 }
 
 // Result is the KindFromIngredients result, published as the job goes:
@@ -251,6 +254,9 @@ type shownResult[R any] interface {
 	shown() int
 	// cleared is the result showing no ideas.
 	cleared() R
+	// withSafeSources is the result with each idea's source as
+	// shownSource gives it.
+	withSafeSources() (R, error)
 }
 
 func (r Result) shown() int { return len(r.Ideas) }
@@ -260,11 +266,25 @@ func (r Result) cleared() Result {
 	return r
 }
 
+func (r Result) withSafeSources() (Result, error) {
+	ideas := make([]Idea, len(r.Ideas))
+	for i, idea := range r.Ideas {
+		src, err := shownSource(idea.SourceURL, idea.SiteName)
+		if err != nil {
+			return Result{}, fmt.Errorf("ideas: idea %d: %w", i, err)
+		}
+		idea.SourceURL, idea.SiteName = src.URL, src.SiteName
+		ideas[i] = idea
+	}
+	r.Ideas = ideas
+	return r, nil
+}
+
 // finish ends a job whose work returned res and err. A job that failed
 // has its result published again with no ideas, to tidy the stored
 // result. That write is not what keeps a failed job from showing ideas,
 // since it may fail and a job interrupted by restart never makes it:
-// withoutIdeas, applied whenever a failed job is read, is.
+// shownJobResult, applied whenever a failed job is read, is.
 func finish[R shownResult[R]](ctx context.Context, logger *slog.Logger, what string, res R, err error, publish func(R) error) (R, error) {
 	var zero R
 	if err == nil {
@@ -312,9 +332,9 @@ func (s *Service) fill(ctx context.Context, p FromIngredientsJob, publish func(R
 	for i, idea := range out.Ideas {
 		reqs[i] = recipes.GroundRequest{DishName: idea.Name, Query: idea.SearchQuery}
 	}
-	err = keepGrounded(ctx, s.grounder, reqs, skills.IdeasKept, &res.Ideas, &res.Dropped, func(i int, gr recipes.Grounded) (Idea, bool) {
-		idea := ideaOf(out.Ideas[i], gr)
-		return idea, !p.QuickOnly || idea.Quick
+	err = keepGrounded(ctx, s.grounder, reqs, skills.IdeasKept, &res.Ideas, &res.Dropped, func(i int, gr recipes.Grounded) (Idea, bool, error) {
+		idea, err := ideaOf(out.Ideas[i], gr)
+		return idea, !p.QuickOnly || idea.Quick, err
 	}, func() error { return publish(res) })
 	if err != nil {
 		return res, err
@@ -333,9 +353,9 @@ func (s *Service) fill(ctx context.Context, p FromIngredientsJob, publish func(R
 // order (an idea that grounds sooner than one before it is shown first,
 // and the earlier one is put back in its place when it grounds) and
 // publish is called. An idea no recipe grounds, or that keep refuses,
-// counts in *dropped. Any other grounding failure, or publish failing, is
-// returned (see ground).
-func keepGrounded[T any](ctx context.Context, g *recipes.Grounder, reqs []recipes.GroundRequest, want int, shown *[]T, dropped *int, keep func(i int, gr recipes.Grounded) (T, bool), publish func() error) error {
+// counts in *dropped. Any other grounding failure, or keep or publish
+// failing, is returned (see ground).
+func keepGrounded[T any](ctx context.Context, g *recipes.Grounder, reqs []recipes.GroundRequest, want int, shown *[]T, dropped *int, keep func(i int, gr recipes.Grounded) (T, bool, error), publish func() error) error {
 	// order[k] is the index in reqs of (*shown)[k], so each idea is put in
 	// its place in reqs' order as it grounds.
 	var order []int
@@ -348,7 +368,10 @@ func keepGrounded[T any](ctx context.Context, g *recipes.Grounder, reqs []recipe
 				*dropped++
 				return nil
 			}
-			idea, ok := keep(first+i, *gr)
+			idea, ok, err := keep(first+i, *gr)
+			if err != nil {
+				return err
+			}
 			if !ok {
 				*dropped++
 				return nil
@@ -406,19 +429,32 @@ func ground(ctx context.Context, g *recipes.Grounder, reqs []recipes.GroundReque
 	return failed
 }
 
-// withoutIdeas is a failed job's stored result as the job shows it: with no
-// ideas, however the job failed, so a failed job never shows ideas kept
-// before the failure.
-func withoutIdeas[R shownResult[R]](stored json.RawMessage) (json.RawMessage, error) {
+// shownJobResult is a job's stored result as the job shows it. A failed
+// job's shows no ideas, however the job failed, so a failed job never
+// shows ideas kept before the failure. Any other job's shows each idea's
+// source as shownSource gives it, so a result stored before sources were
+// made safe never shows a link or name that could leak a secret.
+func shownJobResult[R shownResult[R]](status jobs.Status, stored json.RawMessage) (json.RawMessage, error) {
 	var res R
 	if err := json.Unmarshal(stored, &res); err != nil {
-		return nil, fmt.Errorf("ideas: decode failed job's result: %w", err)
+		return nil, fmt.Errorf("ideas: decode %s job's result: %w", status, err)
 	}
-	return res.cleared().PublicJSON()
+	if status == jobs.StatusFailed {
+		return res.cleared().PublicJSON()
+	}
+	safe, err := res.withSafeSources()
+	if err != nil {
+		return nil, err
+	}
+	return safe.PublicJSON()
 }
 
 // ideaOf is idea as grounded by gr.
-func ideaOf(idea skills.Idea, gr recipes.Grounded) Idea {
+func ideaOf(idea skills.Idea, gr recipes.Grounded) (Idea, error) {
+	src, err := sourceOf(gr)
+	if err != nil {
+		return Idea{}, err
+	}
 	return Idea{
 		Name:         idea.Name,
 		Uses:         idea.Uses,
@@ -430,9 +466,38 @@ func ideaOf(idea skills.Idea, gr recipes.Grounded) Idea {
 		Quick:        IsQuick(gr.Method, gr.MinutesTotal),
 		RecipeID:     gr.RecipeID,
 		PhotoURL:     dinners.PhotoURL(gr.PhotoID),
-		SourceURL:    gr.SourceURL,
-		SiteName:     gr.SiteName,
+		SourceURL:    src.URL,
+		SiteName:     src.SiteName,
+	}, nil
+}
+
+// sourceOf is gr's recipe source as a client may see it (see
+// dinners.SourceOf): a grounded recipe's site name is stored only when
+// not empty.
+func sourceOf(gr recipes.Grounded) (dinners.Source, error) {
+	src, err := dinners.SourceOf(sql.NullString{String: gr.SiteName, Valid: gr.SiteName != ""}, gr.SourceURL)
+	if err != nil {
+		return dinners.Source{}, fmt.Errorf("ideas: recipe %s: %w", gr.RecipeID, err)
 	}
+	return src, nil
+}
+
+// shownSource is the source of an idea as stored in a job's result, with
+// link sourceURL and site name siteName, as a client may see it (see
+// dinners.SourceOf). A result stored now already holds it, and one stored
+// before sources were made safe holds the grounded recipe's own, with ""
+// for no site name, as sourceOf reads it; a null link, which only a result
+// stored now holds, is checked as "".
+func shownSource(sourceURL, siteName *string) (dinners.Source, error) {
+	var link string
+	if sourceURL != nil {
+		link = *sourceURL
+	}
+	var site sql.NullString
+	if siteName != nil {
+		site = sql.NullString{String: *siteName, Valid: *siteName != ""}
+	}
+	return dinners.SourceOf(site, link)
 }
 
 // QuickJob is the KindQuick payload: the kind of Quick dinner wanted,
@@ -478,8 +543,9 @@ type QuickIdea struct {
 	Difficulty string `json:"difficulty"`
 	RecipeID   string `json:"recipe_id"`
 	PhotoURL   string `json:"photo_url"`
-	SourceURL  string `json:"source_url"`
-	SiteName   string `json:"site_name"`
+	// SourceURL and SiteName are as in Idea.
+	SourceURL *string `json:"source_url"`
+	SiteName  *string `json:"site_name"`
 }
 
 // QuickResult is the KindQuick result, published as the job goes: its
@@ -504,6 +570,20 @@ func (r QuickResult) cleared() QuickResult {
 	return r
 }
 
+func (r QuickResult) withSafeSources() (QuickResult, error) {
+	ideas := make([]QuickIdea, len(r.Ideas))
+	for i, idea := range r.Ideas {
+		src, err := shownSource(idea.SourceURL, idea.SiteName)
+		if err != nil {
+			return QuickResult{}, fmt.Errorf("ideas: idea %d: %w", i, err)
+		}
+		idea.SourceURL, idea.SiteName = src.URL, src.SiteName
+		ideas[i] = idea
+	}
+	r.Ideas = ideas
+	return r, nil
+}
+
 // OfQuickKind reports whether a recipe cooked by method in minutes (nil
 // when unknown) is a Quick dinner of kind: for skills.QuickCrockpot,
 // cooked in a crock pot (normalize_recipe writes a slow cooker as
@@ -564,8 +644,9 @@ func (s *Service) fillQuick(ctx context.Context, p QuickJob, publish func(QuickR
 	for i, idea := range out.Ideas {
 		reqs[i] = recipes.GroundRequest{DishName: idea.Name, Query: idea.SearchQuery}
 	}
-	err = keepGrounded(ctx, s.grounder, reqs, skills.QuickIdeasKept, &res.Ideas, &res.Dropped, func(i int, gr recipes.Grounded) (QuickIdea, bool) {
-		return quickIdeaOf(out.Ideas[i], gr), OfQuickKind(p.Kind, gr.Method, gr.MinutesTotal)
+	err = keepGrounded(ctx, s.grounder, reqs, skills.QuickIdeasKept, &res.Ideas, &res.Dropped, func(i int, gr recipes.Grounded) (QuickIdea, bool, error) {
+		idea, err := quickIdeaOf(out.Ideas[i], gr)
+		return idea, OfQuickKind(p.Kind, gr.Method, gr.MinutesTotal), err
 	}, func() error { return publish(res) })
 	if err != nil {
 		return res, err
@@ -578,7 +659,11 @@ func (s *Service) fillQuick(ctx context.Context, p QuickJob, publish func(QuickR
 }
 
 // quickIdeaOf is idea as grounded by gr.
-func quickIdeaOf(idea skills.QuickIdea, gr recipes.Grounded) QuickIdea {
+func quickIdeaOf(idea skills.QuickIdea, gr recipes.Grounded) (QuickIdea, error) {
+	src, err := sourceOf(gr)
+	if err != nil {
+		return QuickIdea{}, err
+	}
 	return QuickIdea{
 		Name:         idea.Name,
 		Method:       gr.Method,
@@ -586,9 +671,9 @@ func quickIdeaOf(idea skills.QuickIdea, gr recipes.Grounded) QuickIdea {
 		Difficulty:   gr.Difficulty,
 		RecipeID:     gr.RecipeID,
 		PhotoURL:     dinners.PhotoURL(gr.PhotoID),
-		SourceURL:    gr.SourceURL,
-		SiteName:     gr.SiteName,
-	}
+		SourceURL:    src.URL,
+		SiteName:     src.SiteName,
+	}, nil
 }
 
 // Origins of a dinner made from an idea (the dinners.origin column).

internal/ideas/quick_test.go

@@ -369,7 +369,7 @@ func TestStartQuickRunsTheJob(t *testing.T) {
 	if res.Stage != StageDone || res.Kind != skills.QuickCrockpot || !reflect.DeepEqual(res.Exclude, []string{"Beef Stew"}) || len(res.Ideas) != 1 {
 		t.Fatalf("result = %+v", res)
 	}
-	if got := res.Ideas[0]; got.Name != "Pulled Pork" || got.Method != "crockpot" || got.SiteName != "R Kitchen" {
+	if got := res.Ideas[0]; got.Name != "Pulled Pork" || got.Method != "crockpot" || got.SiteName == nil || *got.SiteName != "R Kitchen" {
 		t.Errorf("idea = %+v", got)
 	}
 }

internal/jobs/jobs.go

@@ -136,13 +136,13 @@ type runFunc func(ctx context.Context, payload string, publish func(json.RawMess
 
 // handler is a registered kind: run runs a job, check reports whether a
 // payload decodes into the kind's payload type, serviceOnly is set when
-// Runner.Enqueue refuses the kind, and failedResult, when set, is what Get
-// shows of a failed job's stored result (see Kind.FailedResult).
+// Runner.Enqueue refuses the kind, and shownResult, when set, is what Get
+// shows of a job's stored result (see Kind.ShownResult).
 type handler struct {
-	run          runFunc
-	check        func(payload []byte) bool
-	serviceOnly  bool
-	failedResult func(stored json.RawMessage) (json.RawMessage, error)
+	run         runFunc
+	check       func(payload []byte) bool
+	serviceOnly bool
+	shownResult func(status Status, stored json.RawMessage) (json.RawMessage, error)
 }
 
 // Runner owns the job handlers and the worker pool.
@@ -309,23 +309,24 @@ func (k *Kind[P]) ServiceOnly() error {
 	return nil
 }
 
-// FailedResult makes Get return, for a failed job of the kind with a
-// stored result, show's view of that result instead of the result itself.
-// It is applied on every read, so it holds however the job failed: by its
-// handler, as interrupted by restart, or after a write meant to tidy the
-// result failed. A show error fails Get. A kind that never calls it shows a
-// failed job's last result as stored. It must be called before Start.
-func (k *Kind[P]) FailedResult(show func(stored json.RawMessage) (json.RawMessage, error)) error {
+// ShownResult makes Get return, for a job of the kind with a stored
+// result, show's view of that result, given the job's status, instead of
+// the result itself. It is applied on every read, so it holds for every
+// stored result: however a job failed (by its handler, as interrupted by
+// restart, or after a write meant to tidy the result failed) and whatever
+// version of the kind stored it. A show error fails Get. A kind that never
+// calls it shows a job's result as stored. It must be called before Start.
+func (k *Kind[P]) ShownResult(show func(status Status, stored json.RawMessage) (json.RawMessage, error)) error {
 	if show == nil {
-		return fmt.Errorf("jobs: failed result %q: nil func", k.name)
+		return fmt.Errorf("jobs: shown result %q: nil func", k.name)
 	}
 	k.r.mu.Lock()
 	defer k.r.mu.Unlock()
 	if k.r.started {
-		return fmt.Errorf("jobs: failed result %q: runner already started", k.name)
+		return fmt.Errorf("jobs: shown result %q: runner already started", k.name)
 	}
 	h := k.r.handlers[k.name]
-	h.failedResult = show
+	h.shownResult = show
 	k.r.handlers[k.name] = h
 	return nil
 }
@@ -425,8 +426,8 @@ func (r *Runner) Wait() {
 	r.wg.Wait()
 }
 
-// Get returns the job with id, or ErrNotFound. A failed job's result is
-// shown through its kind's FailedResult, when the kind set one.
+// Get returns the job with id, or ErrNotFound. A job's result is shown
+// through its kind's ShownResult, when the kind set one.
 func (r *Runner) Get(ctx context.Context, id string) (Job, error) {
 	row, err := db.New(r.st.Reader).GetJob(ctx, id)
 	if errors.Is(err, sql.ErrNoRows) {
@@ -442,17 +443,17 @@ func (r *Runner) Get(ctx context.Context, id string) (Job, error) {
 	if row.Error.Valid {
 		job.Error = &row.Error.String
 	}
-	if job.Status == StatusFailed && job.Result != nil {
+	if job.Result != nil {
 		r.mu.Lock()
-		show := r.handlers[job.Kind].failedResult
+		show := r.handlers[job.Kind].shownResult
 		r.mu.Unlock()
 		if show != nil {
-			shown, err := show(job.Result)
+			shown, err := show(job.Status, job.Result)
 			if err != nil {
-				return Job{}, fmt.Errorf("jobs: show failed %s result: %w", job.Kind, err)
+				return Job{}, fmt.Errorf("jobs: show %s %s result: %w", job.Status, job.Kind, err)
 			}
 			if !json.Valid(shown) {
-				return Job{}, fmt.Errorf("jobs: show failed %s result: not one JSON value", job.Kind)
+				return Job{}, fmt.Errorf("jobs: show %s %s result: not one JSON value", job.Status, job.Kind)
 			}
 			job.Result = shown
 		}

internal/jobs/jobs_test.go

@@ -773,7 +773,7 @@ func TestServiceOnlyKind(t *testing.T) {
 	}
 }
 
-func TestFailedResultAppliesOnlyToItsKindsFailedJobs(t *testing.T) {
+func TestShownResultAppliesOnlyToItsKindsJobs(t *testing.T) {
 	t.Parallel()
 	st := migratedStore(t)
 	r := newRunner(t, st, 1)
@@ -788,17 +788,24 @@ func TestFailedResultAppliesOnlyToItsKindsFailedJobs(t *testing.T) {
 	}
 	hidden := register(t, r, "hidden", h, "stopped")
 	plain := register(t, r, "plain", h, "stopped")
-	if err := hidden.FailedResult(func(json.RawMessage) (json.RawMessage, error) {
-		return json.RawMessage(`{"done":0}`), nil
+	if err := hidden.ShownResult(func(status Status, stored json.RawMessage) (json.RawMessage, error) {
+		if status == StatusFailed {
+			return json.RawMessage(`{"done":0}`), nil
+		}
+		var res countResult
+		if err := json.Unmarshal(stored, &res); err != nil {
+			return nil, err
+		}
+		return json.Marshal(countResult{Done: res.Done * 10})
 	}); err != nil {
 		t.Fatal(err)
 	}
-	if err := hidden.FailedResult(nil); err == nil {
-		t.Error("FailedResult(nil) succeeded, want an error")
+	if err := hidden.ShownResult(nil); err == nil {
+		t.Error("ShownResult(nil) succeeded, want an error")
 	}
 	start(t, r)
-	if err := hidden.FailedResult(func(s json.RawMessage) (json.RawMessage, error) { return s, nil }); err == nil {
-		t.Error("FailedResult after Start succeeded, want an error")
+	if err := hidden.ShownResult(func(_ Status, s json.RawMessage) (json.RawMessage, error) { return s, nil }); err == nil {
+		t.Error("ShownResult after Start succeeded, want an error")
 	}
 
 	for _, tc := range []struct {
@@ -806,9 +813,10 @@ func TestFailedResultAppliesOnlyToItsKindsFailedJobs(t *testing.T) {
 		steps int
 		want  string
 	}{
-		{hidden, 0, `{"done":0}`}, // failed: shown through FailedResult
-		{hidden, 3, `{"done":3}`}, // succeeded: as stored
-		{plain, 0, `{"done":5}`},  // failed, kind without FailedResult: as stored
+		{hidden, 0, `{"done":0}`},  // failed: shown through ShownResult
+		{hidden, 3, `{"done":30}`}, // succeeded: shown through ShownResult
+		{plain, 0, `{"done":5}`},   // failed, kind without ShownResult: as stored
+		{plain, 3, `{"done":3}`},   // succeeded, kind without ShownResult: as stored
 	} {
 		job := waitFor(t, r, enqueue(t, tc.kind, countPayload{Steps: tc.steps}), finished)
 		if string(job.Result) != tc.want {

internal/notify/notify.go

@@ -189,6 +189,22 @@ func (s *Service) EmitTx(ctx context.Context, tx *sql.Tx, ev Event) error {
 	})
 }
 
+// StoredSince reports whether a notification was stored after since, or
+// at all when since is nil. An event counts once it is stored for any
+// channel, whatever became of its delivery; one whose preference switches
+// every channel off is never stored and never counts.
+func (s *Service) StoredSince(ctx context.Context, since *time.Time) (bool, error) {
+	var after sql.NullString
+	if since != nil {
+		after = sql.NullString{String: timestamp(*since), Valid: true}
+	}
+	found, err := db.New(s.st.Reader).HasNotificationSince(ctx, after)
+	if err != nil {
+		return false, fmt.Errorf("notify: read notifications since %s: %w", after.String, err)
+	}
+	return found, nil
+}
+
 // emitTx stores ev in tx for each channel that channels chooses from the
 // preference of ev's type.
 func (s *Service) emitTx(ctx context.Context, tx *sql.Tx, ev Event, channels func(db.NotificationPref) ([]Channel, error)) error {

internal/plan/plan.go

@@ -152,8 +152,8 @@ type Service struct {
 // cal with links under publicURL, tells the household through notifier,
 // which must be over st, and registers the KindDraftWeek job on
 // runner, which must not have started yet. The kind is service-only:
-// StartDraft and StartScheduledDraft, which keep one draft in flight per
-// week, are the only way to enqueue it.
+// StartDraft, which keeps one draft in flight per week, is the only way to
+// enqueue it.
 func NewService(st *store.Store, draft Drafter, runner *jobs.Runner, cal Calendar, notifier *notify.Service, publicURL *url.URL, logger *slog.Logger) (*Service, error) {
 	switch {
 	case st == nil:
@@ -342,27 +342,10 @@ type Draft struct {
 // enqueues nothing. Drafting over a synced or changed plan needs confirm,
 // else it fails with ErrConfirmRequired and enqueues nothing.
 func (s *Service) StartDraft(ctx context.Context, weekStart store.LocalDate, confirm bool) (Draft, error) {
-	d, _, err := s.startDraft(ctx, weekStart, confirm, false)
-	return d, err
-}
-
-// StartScheduledDraft is StartDraft, without confirm, for the plan_draft
-// schedule: it enqueues the same KindDraftWeek job, or returns the one
-// queued or running, only while the week starting weekStart has no plan.
-// A week that has a plan, in any status, is left as it is: nothing is
-// enqueued and planned is true.
-func (s *Service) StartScheduledDraft(ctx context.Context, weekStart store.LocalDate) (d Draft, planned bool, err error) {
-	return s.startDraft(ctx, weekStart, false, true)
-}
-
-// startDraft is StartDraft, and when onlyUnplanned is set it enqueues
-// nothing for a week that has a plan and reports planned true.
-func (s *Service) startDraft(ctx context.Context, weekStart store.LocalDate, confirm, onlyUnplanned bool) (Draft, bool, error) {
 	if _, err := household.WeekDays(weekStart); err != nil {
-		return Draft{}, false, &InvalidWeekError{Value: weekStart.String()}
+		return Draft{}, &InvalidWeekError{Value: weekStart.String()}
 	}
 	var d Draft
-	planned := false
 	err := s.st.WithTx(ctx, func(tx *sql.Tx) error {
 		q := db.New(tx)
 		cur, err := q.GetWeekPlan(ctx, weekStart.String())
@@ -370,9 +353,6 @@ func (s *Service) startDraft(ctx context.Context, weekStart store.LocalDate, con
 		case errors.Is(err, sql.ErrNoRows):
 		case err != nil:
 			return fmt.Errorf("plan: read week %s: %w", weekStart, err)
-		case onlyUnplanned:
-			planned = true
-			return nil
 		case cur.Status != StatusDraft && !confirm:
 			return ErrConfirmRequired
 		}
@@ -395,12 +375,12 @@ func (s *Service) startDraft(ctx context.Context, weekStart store.LocalDate, con
 		return nil
 	})
 	if err != nil {
-		return Draft{}, false, err
+		return Draft{}, err
 	}
 	if d.Created {
 		s.draftJob.Wake()
 	}
-	return d, planned, nil
+	return d, nil
 }
 
 // Swap plans dinnerID on date of the week starting weekStart, marking the

internal/plan/schedule.go

@@ -1,42 +0,0 @@
-package plan
-
-import (
-	"context"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
-)
-
-// DraftSchedule is the plan_draft schedule: at the household's
-// plan_draft_dow and plan_draft_time it drafts the week after the fire
-// date's, its period scheduler.WeeklyForNextWeek keys plan_draft:YYYY-Www
-// for that week. The draft is the KindDraftWeek job a manual draft runs
-// (StartScheduledDraft), so a stored draft emits plan_ready keyed
-// plan_ready:{weekStart} and a draft that fails, as when the AI fails,
-// stores no plan and emits nothing. A week that already has a plan is left
-// as it is, and so is a draft of it already queued or running; either way
-// the period says so.
-func (s *Service) DraftSchedule() scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.PlanDraft,
-		Rule: func(settings household.Settings) scheduler.Rule {
-			return scheduler.WeeklyForNextWeek(time.Weekday(settings.PlanDraftDow), settings.PlanDraftTime)
-		},
-		Run: func(ctx context.Context, p scheduler.Period) error {
-			d, planned, err := s.StartScheduledDraft(ctx, p.Week)
-			if err != nil {
-				return err
-			}
-			switch {
-			case planned:
-				s.logger.InfoContext(ctx, "scheduled week draft not started: the week already has a plan",
-					"period", p.Key, "week_start", p.Week.String())
-			case !d.Created:
-				s.logger.WarnContext(ctx, "scheduled week draft not started: a draft of the week is already under way",
-					"period", p.Key, "week_start", p.Week.String(), "job_id", d.JobID)
-			}
-			return nil
-		},
-	}
-}

internal/scheduler/export_test.go

@@ -1,9 +0,0 @@
-package scheduler
-
-import "time"
-
-// SetClock makes now the clock and after the timer s fires by.
-func SetClock(s *Scheduler, now func() time.Time, after func(time.Duration) <-chan time.Time) {
-	s.now = now
-	s.after = after
-}

internal/scheduler/plan_draft_test.go

@@ -1,393 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"net/url"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify/notifytest"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-)
-
-// The tests in this file run plan's plan_draft schedule on the fake clock
-// against the real plan service, job runner, harness, draft_week and
-// notification outbox, with the AI faked.
-
-// planEnv is a plan service over a scheduler env's store, the "process" a
-// scheduler runs it in. model answers draft_week.
-type planEnv struct {
-	e     *env
-	svc   *plan.Service
-	model *llm.Fake
-	ids   map[string]string
-	logs  *syncBuffer
-	stop  func()
-}
-
-// poolNames are the seven Regulars pool stores, enough for a week.
-var poolNames = []string{"Beef Chili", "Pot Roast", "Chicken Fajitas", "Spaghetti Bolognese", "Sheet Pan Salmon", "Tacos", "Pancakes"}
-
-// pool stores poolNames as Regulars and returns their ids by name.
-func (e *env) pool() map[string]string {
-	e.t.Helper()
-	ids := map[string]string{}
-	for _, name := range poolNames {
-		now := store.Now().String()
-		d, err := db.New(e.st.Writer).CreateDinner(context.Background(), db.CreateDinnerParams{
-			ID:              store.NewID(),
-			Name:            name,
-			NormalizedName:  harness.Normalize(name),
-			Status:          "regular",
-			Origin:          "regular",
-			GroundingStatus: "manual",
-			CreatedAt:       now,
-			UpdatedAt:       now,
-		})
-		if err != nil {
-			e.t.Fatal(err)
-		}
-		ids[name] = d.ID
-	}
-	return ids
-}
-
-// publicURL is MEALQUEST_PUBLIC_URL in these tests.
-var publicURL = &url.URL{Scheme: "https", Host: "meals.example.com"}
-
-// noCalendar is a Calendar the schedule must never push to.
-type noCalendar struct{ t *testing.T }
-
-func (c noCalendar) PushEvents(context.Context, []gcal.Event, func() error) error {
-	c.t.Error("plan_draft pushed to Calendar")
-	return errors.New("no calendar")
-}
-
-// plans builds a plan service drafting from the dinners ids over e with a
-// started job runner, which stop stops (and the test's end, if not before).
-func (e *env) plans(ids map[string]string) *planEnv {
-	e.t.Helper()
-	p := &planEnv{e: e, model: &llm.Fake{}, ids: ids, logs: &syncBuffer{}}
-	guard, err := harness.NewGuard(harness.DefaultMaxCalls)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	cfg := harness.Config{
-		Settings:    llm.Settings{Provider: "anthropic", Model: "claude-test", Temperature: 0.7},
-		NewProvider: func(llm.Settings, string) (llm.Provider, error) { return p.model, nil },
-		Store:       e.st,
-		Guard:       guard,
-	}
-	drafter := func(ctx context.Context, scope string, in skills.WeekRequest) (skills.Week, error) {
-		return skills.DraftWeek(ctx, cfg, scope, in)
-	}
-	logger := slog.New(slog.NewTextHandler(p.logs, nil))
-	runner, err := jobs.NewRunner(e.st, logger, 1)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	p.svc, err = plan.NewService(e.st, drafter, runner, noCalendar{e.t}, notifytest.New(e.t, e.st), publicURL, logger)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	if err := runner.Start(ctx); err != nil {
-		cancel()
-		e.t.Fatal(err)
-	}
-	var once sync.Once
-	p.stop = func() {
-		once.Do(func() {
-			cancel()
-			runner.Wait()
-		})
-	}
-	e.t.Cleanup(p.stop)
-	return p
-}
-
-// reply scripts the next draft_week answer: poolNames on the days of the
-// week starting weekStart, Monday to Sunday.
-func (p *planEnv) reply(weekStart store.LocalDate) {
-	p.e.t.Helper()
-	dates, err := household.WeekDays(weekStart)
-	if err != nil {
-		p.e.t.Fatal(err)
-	}
-	var days []string
-	for i, name := range poolNames {
-		days = append(days, fmt.Sprintf(`{"date":%q,"dinner_id":%q}`, dates[i], p.ids[name]))
-	}
-	js := fmt.Sprintf(`{"days":[%s],"note":""}`, strings.Join(days, ","))
-	p.model.QueueGenerate(llm.GenerateResult{Response: llm.Response{Text: js, JSON: json.RawMessage(js)}})
-}
-
-// draftJob is a draft_week jobs row.
-type draftJob struct {
-	Status, Error string
-}
-
-// drafts waits until no draft_week job is queued or running and returns
-// them all, oldest first.
-func (e *env) drafts() []draftJob {
-	e.t.Helper()
-	deadline := time.Now().Add(10 * time.Second)
-	for {
-		rows, err := e.st.Reader.Query(`SELECT status, COALESCE(error, '') FROM jobs WHERE kind = ? ORDER BY created_at, id`, plan.KindDraftWeek)
-		if err != nil {
-			e.t.Fatal(err)
-		}
-		var out []draftJob
-		busy := false
-		for rows.Next() {
-			var j draftJob
-			if err := rows.Scan(&j.Status, &j.Error); err != nil {
-				e.t.Fatal(err)
-			}
-			busy = busy || j.Status == string(jobs.StatusQueued) || j.Status == string(jobs.StatusRunning)
-			out = append(out, j)
-		}
-		if err := rows.Err(); err != nil {
-			e.t.Fatal(err)
-		}
-		rows.Close()
-		if !busy {
-			return out
-		}
-		if time.Now().After(deadline) {
-			e.t.Fatalf("draft jobs still under way: %+v", out)
-		}
-		time.Sleep(5 * time.Millisecond)
-	}
-}
-
-// wantDrafts fails unless the draft_week jobs are got.
-func wantDrafts(t *testing.T, what string, got []draftJob, want ...draftJob) {
-	t.Helper()
-	if fmt.Sprint(got) != fmt.Sprint(want) {
-		t.Fatalf("%s: draft jobs = %+v, want %+v", what, got, want)
-	}
-}
-
-// weekPlans returns the week_start of every plan, oldest first.
-func (e *env) weekPlans() []string {
-	e.t.Helper()
-	rows, err := e.st.Reader.Query(`SELECT week_start FROM week_plans ORDER BY week_start`)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	defer rows.Close()
-	var out []string
-	for rows.Next() {
-		var w string
-		if err := rows.Scan(&w); err != nil {
-			e.t.Fatal(err)
-		}
-		out = append(out, w)
-	}
-	if err := rows.Err(); err != nil {
-		e.t.Fatal(err)
-	}
-	return out
-}
-
-// planReady returns the distinct plan_ready keys stored, oldest first.
-func (e *env) planReady() []string {
-	e.t.Helper()
-	var keys []string
-	for _, r := range notifytest.Rows(e.t, e.st, notify.PlanReady) {
-		if len(keys) == 0 || keys[len(keys)-1] != r.Key {
-			keys = append(keys, r.Key)
-		}
-	}
-	return keys
-}
-
-var (
-	succeeded = draftJob{Status: string(jobs.StatusSucceeded)}
-	aiFailed  = draftJob{Status: string(jobs.StatusFailed), Error: plan.ReasonAIFailed}
-	// w43 is the Monday of 2026-W43, the week after Friday Oct 16.
-	w43 = mustLocalDate("2026-10-19")
-	w44 = mustLocalDate("2026-10-26")
-)
-
-func mustLocalDate(s string) store.LocalDate {
-	d, err := store.ParseLocalDate(s)
-	if err != nil {
-		panic(err)
-	}
-	return d
-}
-
-// TestPlanDraftDraftsNextWeek: at the seeded Friday 09:00 the schedule
-// drafts the next ISO week through the plan service's draft job, period
-// plan_draft:YYYY-Www of that week, and the draft emits plan_ready keyed
-// by its Monday once.
-func TestPlanDraftDraftsNextWeek(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	p.reply(w43)
-	p.reply(w44)
-
-	// Wednesday Oct 14: the Friday Oct 9 09:00 fire is days ago, missed.
-	r := e.start(at(2026, 10, 14, 12, 0), p.svc.DraftSchedule())
-	r.runUntil(at(2026, 10, 16, 8, 59))
-	wantDrafts(t, "before Friday 09:00", e.drafts())
-	wantKeys(t, "plans before Friday 09:00", e.weekPlans(), nil)
-
-	r.runUntil(at(2026, 10, 16, 9, 0))
-	wantDrafts(t, "at Friday 09:00", e.drafts(), succeeded)
-	wantKeys(t, "plans at Friday 09:00", e.weekPlans(), []string{"2026-10-19"})
-	wantKeys(t, "plan_ready of W43", e.planReady(), []string{"plan_ready:2026-10-19"})
-	got, err := p.svc.Get(context.Background(), w43)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got.Days) != 7 || got.Days[0].Dinner.Name != "Beef Chili" || got.Status != plan.StatusDraft {
-		t.Errorf("plan of W43 = %+v, want the drafted week", got)
-	}
-
-	r.runUntil(at(2026, 10, 23, 9, 0))
-	wantDrafts(t, "W44", e.drafts(), succeeded, succeeded)
-	wantKeys(t, "plans", e.weekPlans(), []string{"2026-10-19", "2026-10-26"})
-	wantKeys(t, "plan_ready of W43 and W44", e.planReady(), []string{"plan_ready:2026-10-19", "plan_ready:2026-10-26"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.PlanDraft), []string{"2026-W42", "2026-W43", "2026-W44"})
-}
-
-// TestPlanDraftLeavesAnExistingPlan: when next week already has a plan,
-// here one the household drafted by hand, the period drafts nothing,
-// notifies no one and says so.
-func TestPlanDraftLeavesAnExistingPlan(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	p.reply(w43)
-	p.reply(w43) // a second draft would succeed too
-	if _, err := p.svc.StartDraft(context.Background(), w43, false); err != nil {
-		t.Fatal(err)
-	}
-	wantDrafts(t, "manual draft", e.drafts(), succeeded)
-	wantKeys(t, "plan_ready of the manual draft", e.planReady(), []string{"plan_ready:2026-10-19"})
-	before, err := p.svc.Get(context.Background(), w43)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	r := e.start(at(2026, 10, 16, 8, 0), p.svc.DraftSchedule())
-	r.runUntil(at(2026, 10, 16, 9, 0))
-	wantDrafts(t, "with a plan", e.drafts(), succeeded)
-	wantKeys(t, "plan_ready with a plan", e.planReady(), []string{"plan_ready:2026-10-19"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.PlanDraft), []string{"2026-W42", "2026-W43"})
-	after, err := p.svc.Get(context.Background(), w43)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if fmt.Sprint(after) != fmt.Sprint(before) {
-		t.Errorf("plan of W43 = %+v, want it unchanged from %+v", after, before)
-	}
-	if logs := p.logs.String(); !strings.Contains(logs, "the week already has a plan") || !strings.Contains(logs, "period=2026-W43") {
-		t.Errorf("logs = %s, want the skipped period logged", logs)
-	}
-}
-
-// TestPlanDraftNoDuplicateAfterRestart: a restart after the week was
-// drafted, still within the catch-up window, drafts nothing more and sends
-// no second plan_ready: the period is already claimed.
-func TestPlanDraftNoDuplicateAfterRestart(t *testing.T) {
-	e := newEnv(t)
-	ids := e.pool()
-	p := e.plans(ids)
-	p.reply(w43)
-	r := e.start(at(2026, 10, 16, 8, 0), p.svc.DraftSchedule())
-	r.runUntil(at(2026, 10, 16, 9, 0))
-	wantDrafts(t, "first process", e.drafts(), succeeded)
-	r.stop()
-	p.stop()
-
-	// The restarted process has a new job runner, plan service and
-	// scheduler; it would answer a second draft if one were started.
-	p2 := e.plans(ids)
-	p2.reply(w43)
-	r2 := e.start(at(2026, 10, 16, 10, 0), p2.svc.DraftSchedule())
-	r2.runUntil(at(2026, 10, 23, 8, 59))
-	wantDrafts(t, "after restart", e.drafts(), succeeded)
-	wantKeys(t, "plans after restart", e.weekPlans(), []string{"2026-10-19"})
-	wantKeys(t, "plan_ready after restart", e.planReady(), []string{"plan_ready:2026-10-19"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.PlanDraft), []string{"2026-W42", "2026-W43"})
-}
-
-// TestPlanDraftAIFailureEmitsNothing: when draft_week fails the draft job
-// fails as ai_failed with the failure recorded in ai_runs, no plan is made
-// up and no one is notified; a restart within the catch-up window does not
-// draft the claimed period again.
-func TestPlanDraftAIFailureEmitsNothing(t *testing.T) {
-	e := newEnv(t)
-	ids := e.pool()
-	p := e.plans(ids)
-	p.model.QueueGenerate(llm.GenerateResult{Err: errors.New("provider down")})
-
-	r := e.start(at(2026, 10, 16, 8, 0), p.svc.DraftSchedule())
-	r.runUntil(at(2026, 10, 16, 9, 0))
-	wantDrafts(t, "after the AI failed", e.drafts(), aiFailed)
-	wantKeys(t, "plans after the AI failed", e.weekPlans(), nil)
-	wantKeys(t, "plan_ready after the AI failed", e.planReady(), nil)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.PlanDraft), []string{"2026-W42", "2026-W43"})
-
-	var status, msg string
-	if err := e.st.Reader.QueryRow(`SELECT status, COALESCE(error, '') FROM ai_runs WHERE skill = 'draft_week'`).Scan(&status, &msg); err != nil {
-		t.Fatalf("ai_runs row of draft_week: %v", err)
-	}
-	if status != string(harness.StatusProviderError) || msg == "" {
-		t.Errorf("ai_runs draft_week = %s %q, want %s with its message", status, msg, harness.StatusProviderError)
-	}
-	if logs := p.logs.String(); !strings.Contains(logs, "week draft failed") || !strings.Contains(logs, "reason="+plan.ReasonAIFailed) {
-		t.Errorf("logs = %s, want the draft failure with reason %s", logs, plan.ReasonAIFailed)
-	}
-
-	r.stop()
-	p.stop()
-	p2 := e.plans(ids)
-	p2.reply(w43)
-	e.start(at(2026, 10, 16, 10, 0), p2.svc.DraftSchedule())
-	wantDrafts(t, "after restart", e.drafts(), aiFailed)
-	wantKeys(t, "plan_ready after restart", e.planReady(), nil)
-}
-
-// TestPlanDraftFollowsSettingsWithoutRestart: a plan_draft_dow and
-// plan_draft_time change takes effect in the running scheduler; the old
-// Friday 09:00 no longer fires and the new Wednesday 18:30 drafts the next
-// week.
-func TestPlanDraftFollowsSettingsWithoutRestart(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	p.reply(w43)
-
-	r := e.start(at(2026, 10, 12, 12, 0), p.svc.DraftSchedule()) // Monday
-	e.update(household.SettingsPatch{PlanDraftDow: ptr(3), PlanDraftTime: ptr("18:30")})
-	r.changed()
-	r.runUntil(at(2026, 10, 14, 18, 29)) // Wednesday
-	wantDrafts(t, "before Wednesday 18:30", e.drafts())
-	r.runUntil(at(2026, 10, 14, 18, 30))
-	wantDrafts(t, "at Wednesday 18:30", e.drafts(), succeeded)
-	wantKeys(t, "plan_ready", e.planReady(), []string{"plan_ready:2026-10-19"})
-
-	// Friday 09:00, the old fire time, drafts nothing more.
-	r.runUntil(at(2026, 10, 16, 9, 0))
-	wantDrafts(t, "at Friday 09:00", e.drafts(), succeeded)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.PlanDraft), []string{"2026-W42", "2026-W43"})
-}

internal/scheduler/scheduler.go

@@ -1,587 +0,0 @@
-// Package scheduler runs the household's timed work: each registered
-// schedule fires once per period at a household-local time read from the
-// household settings.
-//
-// # Periods and the claim
-//
-// Every fire time belongs to one period, named by a period key derived in
-// the household zone from the schedule's cadence (see Rule.PeriodKey): the
-// local date "2026-10-09" for a daily rule, and the ISO week "2026-W41" of
-// the fire date, or of the week after it, for a weekly rule. Before running,
-// the scheduler inserts schedule_runs(schedule, period_key); the insert is
-// the claim, and a period already claimed, by an earlier run, an earlier
-// process or another instance, is skipped. A period therefore runs at most
-// once: a Run that fails is logged and its period is not retried.
-//
-// # Catch-up
-//
-// When the scheduler starts, and whenever it wakes late, it looks only at
-// each schedule's most recent fire time. If that time passed within
-// CatchUpWindow and the period is unclaimed, the period runs once. If it
-// passed longer ago, the period is claimed without running and logged as
-// missed, so it can never run later, not after a restart and not after a
-// settings change moves the fire time. Fire times before the most recent
-// one are never looked at.
-//
-// # Claim failures
-//
-// A claim that fails (the database refused the insert) is never skipped:
-// the scheduler logs it and keeps that period's fire time, and every
-// ClaimRetry claims that same period again until the claim succeeds. Only
-// then does it apply the catch-up rule to it, running it if its fire time
-// is within CatchUpWindow of the successful claim and recording it as
-// missed otherwise, and only then does it go on to later fire times, even
-// when one has passed meanwhile. Each period is claimed by its own fire
-// time, so the later period runs once as well.
-//
-// # Time zone and DST
-//
-// Fire times are wall-clock times in the household zone, never the process
-// zone, turned into instants by household.LocalTime. Its rule is the
-// scheduler's DST rule: a time that does not exist on a spring-forward day
-// fires later by the length of the gap (02:30 fires at 03:30 local), and a
-// time that occurs twice on a fall-back day fires once, at its first
-// occurrence. Either way the period key is that local date's, so the
-// period still runs exactly once.
-//
-// # Settings changes
-//
-// The scheduler subscribes to the household settings and records each change
-// with the instant it was saved. A change takes effect at once without a
-// restart: fire times up to that instant follow the old settings and later
-// ones the new, even when the scheduler gets to the change late. So moving
-// a fire time to earlier the same day does not fire the passed time, and a
-// new fire time that was still ahead when the change was saved fires.
-package scheduler
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"log/slog"
-	"sync"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-)
-
-// Schedule names, as the schedule_runs.schedule CHECK constraint allows.
-const (
-	SuggestionsWeekly    = "suggestions_weekly"
-	PlanDraft            = "plan_draft"
-	ShoppingChatAutosend = "shopping_chat_autosend"
-	DayOfReminder        = "day_of_reminder"
-	RotationCheck        = "rotation_check"
-	WeekRollover         = "week_rollover"
-	AIRunsPurge          = "ai_runs_purge"
-)
-
-// names are the schedule names Register accepts.
-var names = map[string]bool{
-	SuggestionsWeekly:    true,
-	PlanDraft:            true,
-	ShoppingChatAutosend: true,
-	DayOfReminder:        true,
-	RotationCheck:        true,
-	WeekRollover:         true,
-	AIRunsPurge:          true,
-}
-
-// CatchUpWindow is how long after its fire time a period that has not run
-// still runs. A period found later than that is recorded as missed.
-const CatchUpWindow = 24 * time.Hour
-
-// ClaimRetry is how long the scheduler waits before repeating a pass in
-// which a claim failed.
-const ClaimRetry = time.Minute
-
-// maxWait bounds one sleep, so the scheduler checks the wall clock at least
-// this often even if the host was suspended or its clock stepped.
-const maxWait = time.Hour
-
-// Rule is when a schedule fires: at household-local Time ("HH:MM") every
-// day, or on Weekday only when Weekly is set. Build one with Daily, Weekly
-// or WeeklyForNextWeek.
-type Rule struct {
-	Weekly  bool
-	Weekday time.Weekday
-	Time    string
-	// NextWeek keys a weekly period by the ISO week after the fire date,
-	// for work done ahead for the coming week.
-	NextWeek bool
-}
-
-// Daily fires every day at hhmm; its period is the local date.
-func Daily(hhmm string) Rule {
-	return Rule{Time: hhmm}
-}
-
-// Weekly fires on day at hhmm; its period is the ISO week of the fire date.
-func Weekly(day time.Weekday, hhmm string) Rule {
-	return Rule{Weekly: true, Weekday: day, Time: hhmm}
-}
-
-// WeeklyForNextWeek fires on day at hhmm; its period is the ISO week after
-// the fire date's.
-func WeeklyForNextWeek(day time.Weekday, hhmm string) Rule {
-	return Rule{Weekly: true, Weekday: day, Time: hhmm, NextWeek: true}
-}
-
-// PeriodKey returns the period key of a fire on household-local date
-// fireDate: the date ("2026-10-09") for a daily rule, the ISO week
-// ("2026-W53") for a weekly one, and the ISO week after that ("2027-W01")
-// when NextWeek is set. It panics if fireDate is the zero LocalDate.
-func (r Rule) PeriodKey(fireDate store.LocalDate) string {
-	if !r.Weekly {
-		return fireDate.String()
-	}
-	if r.NextWeek {
-		return household.PeriodKey(addDays(fireDate, 7))
-	}
-	return household.PeriodKey(fireDate)
-}
-
-// validate reports whether r can fire.
-func (r Rule) validate() error {
-	if r.Weekly && (r.Weekday < time.Sunday || r.Weekday > time.Saturday) {
-		return fmt.Errorf("invalid weekday %d (want 0-6, Sunday = 0)", r.Weekday)
-	}
-	if !r.Weekly && (r.Weekday != time.Sunday || r.NextWeek) {
-		return errors.New("a daily rule has no weekday or next week")
-	}
-	// Any date checks the time's form.
-	_, err := household.LocalTime(time.UTC, store.LocalDateOf(time.Unix(0, 0).UTC()), r.Time)
-	return err
-}
-
-// Period is one period of a schedule, as given to its Run.
-type Period struct {
-	// Key is the period key claimed in schedule_runs.
-	Key string
-	// FireAt is the instant the period fired, in the household zone.
-	FireAt time.Time
-	// Date is the household-local date of FireAt.
-	Date store.LocalDate
-	// Week is the ISO Monday of the week Key names; for a daily rule, of
-	// the week containing Date.
-	Week store.LocalDate
-}
-
-// Schedule is registered work that runs once per period.
-type Schedule struct {
-	// Name is one of the schedule name constants.
-	Name string
-	// Rule returns when the schedule fires under settings. It is called
-	// again after every settings change.
-	Rule func(settings household.Settings) Rule
-	// Run does the period's work. It runs on the scheduler's goroutine,
-	// one schedule at a time, so it must return promptly: long work is
-	// enqueued as a job. ctx is cancelled when the scheduler stops. An
-	// error is logged; the period stays claimed and is not retried.
-	Run func(ctx context.Context, p Period) error
-}
-
-// Settings is the household settings source: *household.SettingsService.
-type Settings interface {
-	Get(ctx context.Context) (household.Settings, error)
-	Subscribe(fn func(household.Settings)) (unsubscribe func())
-}
-
-// Scheduler runs the registered schedules.
-type Scheduler struct {
-	st       *store.Store
-	settings Settings
-	logger   *slog.Logger
-
-	// now is the clock and after the timer; tests replace both.
-	now   func() time.Time
-	after func(d time.Duration) <-chan time.Time
-
-	// wake holds one token when the settings changed since the loop last
-	// looked; pending is the changes to apply, oldest first.
-	wake      chan struct{}
-	pendingMu sync.Mutex
-	pending   []change
-
-	mu        sync.Mutex
-	schedules []Schedule
-	started   bool
-
-	wg sync.WaitGroup
-}
-
-// New returns a scheduler over st reading the household settings from
-// settings.
-func New(st *store.Store, settings Settings, logger *slog.Logger) (*Scheduler, error) {
-	if st == nil {
-		return nil, errors.New("scheduler: nil store")
-	}
-	if settings == nil {
-		return nil, errors.New("scheduler: nil settings")
-	}
-	if logger == nil {
-		return nil, errors.New("scheduler: nil logger")
-	}
-	return &Scheduler{
-		st:       st,
-		settings: settings,
-		logger:   logger,
-		now:      time.Now,
-		after:    time.After,
-		wake:     make(chan struct{}, 1),
-	}, nil
-}
-
-// Register adds sch. It must be called before Start, once per name.
-func (s *Scheduler) Register(sch Schedule) error {
-	if !names[sch.Name] {
-		return fmt.Errorf("scheduler: register: unknown schedule %q", sch.Name)
-	}
-	if sch.Rule == nil {
-		return fmt.Errorf("scheduler: register %s: nil rule", sch.Name)
-	}
-	if sch.Run == nil {
-		return fmt.Errorf("scheduler: register %s: nil run", sch.Name)
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.started {
-		return fmt.Errorf("scheduler: register %s: already started", sch.Name)
-	}
-	for _, have := range s.schedules {
-		if have.Name == sch.Name {
-			return fmt.Errorf("scheduler: register %s: already registered", sch.Name)
-		}
-	}
-	s.schedules = append(s.schedules, sch)
-	return nil
-}
-
-// Start reads the settings and starts the scheduler, which first catches
-// up on each schedule's most recent period and then fires schedules as
-// their times come. Settings whose zone or rules are invalid are an error
-// and nothing starts. The scheduler stops when ctx is cancelled; Wait waits
-// for it.
-func (s *Scheduler) Start(ctx context.Context) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.started {
-		return errors.New("scheduler: already started")
-	}
-	// Subscribing first means a change saved after the read below still
-	// wakes the loop.
-	unsubscribe := s.settings.Subscribe(s.changed)
-	settings, err := s.settings.Get(ctx)
-	if err != nil {
-		unsubscribe()
-		return fmt.Errorf("scheduler: %w", err)
-	}
-	p, err := compile(s.schedules, settings)
-	if err != nil {
-		unsubscribe()
-		return err
-	}
-	s.started = true
-	s.wg.Add(1)
-	go func() {
-		defer s.wg.Done()
-		defer unsubscribe()
-		s.loop(ctx, p)
-	}()
-	return nil
-}
-
-// Wait blocks until the scheduler has stopped.
-func (s *Scheduler) Wait() {
-	s.wg.Wait()
-}
-
-// change is a settings change and the instant it was saved.
-type change struct {
-	at       time.Time
-	settings household.Settings
-}
-
-// changed is the settings subscriber. It runs on the updating goroutine, so
-// it only records the change and wakes the loop.
-func (s *Scheduler) changed(settings household.Settings) {
-	s.pendingMu.Lock()
-	s.pending = append(s.pending, change{at: s.now(), settings: settings})
-	s.pendingMu.Unlock()
-	select {
-	case s.wake <- struct{}{}:
-	default: // the loop already has a token and reads pending then
-	}
-}
-
-// takeChanges returns and clears the pending changes.
-func (s *Scheduler) takeChanges() []change {
-	s.pendingMu.Lock()
-	defer s.pendingMu.Unlock()
-	out := s.pending
-	s.pending = nil
-	return out
-}
-
-// plan is the schedules compiled against one version of the settings.
-type plan struct {
-	loc   *time.Location
-	items []item
-}
-
-type item struct {
-	sch  Schedule
-	rule Rule
-}
-
-// compile builds the plan for settings.
-func compile(schedules []Schedule, settings household.Settings) (*plan, error) {
-	loc, err := household.LoadZone(settings.Timezone)
-	if err != nil {
-		return nil, fmt.Errorf("scheduler: household zone: %w", err)
-	}
-	p := &plan{loc: loc, items: make([]item, len(schedules))}
-	for i, sch := range schedules {
-		rule := sch.Rule(settings)
-		if err := rule.validate(); err != nil {
-			return nil, fmt.Errorf("scheduler: %s: %w", sch.Name, err)
-		}
-		p.items[i] = item{sch: sch, rule: rule}
-	}
-	return p, nil
-}
-
-// loop fires schedules until ctx is cancelled. done is the instant up to
-// which fire times have been handled; it starts at the zero time so the
-// first pass catches up. retry is the periods whose claim failed, each
-// with its own fire time. Each pass first claims retry again; while any
-// claim there still fails, the pass stops and is repeated after
-// ClaimRetry. Otherwise it applies the pending settings changes in order,
-// handling fire times up to a change under the plan it replaces, then
-// handles fire times up to now under the current plan, stopping after the
-// first stretch in which a claim failed.
-func (s *Scheduler) loop(ctx context.Context, p *plan) {
-	var done time.Time
-	var pending []change
-	var retry []target
-	for {
-		now := s.now()
-		pending = append(pending, s.takeChanges()...)
-		retry = s.retry(ctx, retry, now)
-		for len(retry) == 0 && len(pending) > 0 {
-			c := pending[0]
-			if c.at.After(done) {
-				if p != nil {
-					retry = s.fire(ctx, p, done, c.at, now)
-				}
-				done = c.at
-			}
-			p = s.compileChange(ctx, c.settings)
-			pending = pending[1:]
-		}
-		if len(retry) == 0 {
-			if p != nil {
-				retry = s.fire(ctx, p, done, now, now)
-			}
-			done = now
-		}
-		if ctx.Err() != nil {
-			return
-		}
-
-		var timeout <-chan time.Time
-		switch {
-		case len(retry) > 0:
-			timeout = s.after(ClaimRetry)
-		case p != nil:
-			if next, ok := p.next(now); ok {
-				timeout = s.after(min(next.Sub(now), maxWait))
-			}
-		}
-		select {
-		case <-ctx.Done():
-			return
-		case <-timeout:
-		case <-s.wake:
-		}
-	}
-}
-
-// compileChange returns the plan for changed settings, or nil when they
-// are unusable.
-func (s *Scheduler) compileChange(ctx context.Context, settings household.Settings) *plan {
-	p, err := compile(s.schedules, settings)
-	if err != nil {
-		// Settings are validated before they are saved, so this is a
-		// bug; firing at a guessed time would be worse than not firing
-		// until the settings are fixed.
-		s.logger.ErrorContext(ctx, "scheduler: settings unusable; no schedule fires until they change", "error", err)
-		return nil
-	}
-	return p
-}
-
-// target is one schedule's period, named by the fire time it belongs to.
-type target struct {
-	it  item
-	loc *time.Location
-	at  time.Time
-}
-
-// fire handles, for every schedule, its most recent fire time at or before
-// until if it is after done; now is the current instant. It returns the
-// targets whose claim failed, to be claimed again.
-func (s *Scheduler) fire(ctx context.Context, p *plan, done, until, now time.Time) []target {
-	var failed []target
-	for _, it := range p.items {
-		if ctx.Err() != nil {
-			return failed
-		}
-		at, due := fireBefore(it.rule, p.loc, until)
-		if !due || !at.After(done) {
-			continue
-		}
-		if t := (target{it: it, loc: p.loc, at: at}); !s.handle(ctx, t, now) {
-			failed = append(failed, t)
-		}
-	}
-	return failed
-}
-
-// retry handles targets again at now and returns those whose claim still
-// failed.
-func (s *Scheduler) retry(ctx context.Context, targets []target, now time.Time) []target {
-	var failed []target
-	for i, t := range targets {
-		if ctx.Err() != nil {
-			return append(failed, targets[i:]...)
-		}
-		if !s.handle(ctx, t, now) {
-			failed = append(failed, t)
-		}
-	}
-	return failed
-}
-
-// handle claims the period of t and runs it, or records it as missed when
-// its fire time is more than CatchUpWindow before now. It reports false
-// when the claim failed and the period is still unclaimed.
-func (s *Scheduler) handle(ctx context.Context, t target, now time.Time) bool {
-	it, at := t.it, t.at
-	date := household.Today(at, t.loc)
-	period := Period{Key: it.rule.PeriodKey(date), FireAt: at, Date: date}
-	if it.rule.NextWeek {
-		period.Week = household.WeekStart(addDays(date, 7))
-	} else {
-		period.Week = household.WeekStart(date)
-	}
-	log := s.logger.With("schedule", it.sch.Name, "period", period.Key, "fire_at", at.Format(time.RFC3339))
-
-	claimed, err := s.claim(ctx, it.sch.Name, period.Key, now)
-	if err != nil {
-		log.ErrorContext(ctx, "scheduler: claim period failed; retrying", "error", err, "retry_in", ClaimRetry.String())
-		return false
-	}
-	if !claimed {
-		return true
-	}
-	if late := now.Sub(at); late > CatchUpWindow {
-		log.WarnContext(ctx, "scheduler: period missed; recorded without running", "late", late.String())
-		return true
-	}
-	if err := it.sch.Run(ctx, period); err != nil {
-		log.ErrorContext(ctx, "scheduler: run failed", "error", err)
-		return true
-	}
-	log.InfoContext(ctx, "scheduler: ran")
-	return true
-}
-
-// claim inserts schedule_runs(name, key) and reports whether this call
-// inserted it.
-func (s *Scheduler) claim(ctx context.Context, name, key string, now time.Time) (bool, error) {
-	n, err := db.New(s.st.Writer).ClaimScheduleRun(ctx, db.ClaimScheduleRunParams{
-		ID:        store.NewID(),
-		Schedule:  name,
-		PeriodKey: key,
-		CreatedAt: store.Timestamp{Time: now.UTC().Truncate(time.Millisecond)}.String(),
-	})
-	if err != nil {
-		return false, err
-	}
-	return n == 1, nil
-}
-
-// next returns the earliest fire time of any schedule after now, or false
-// when there is no schedule.
-func (p *plan) next(now time.Time) (time.Time, bool) {
-	var next time.Time
-	for _, it := range p.items {
-		at, ok := fireAfter(it.rule, p.loc, now)
-		if ok && (next.IsZero() || at.Before(next)) {
-			next = at
-		}
-	}
-	return next, !next.IsZero()
-}
-
-// window is how many days either side of a date fireBefore and fireAfter
-// search: more than a week, so a weekly rule always has a fire time on
-// each side.
-const window = 8
-
-// fireBefore returns the latest fire time of r in zone loc at or before t.
-func fireBefore(r Rule, loc *time.Location, t time.Time) (time.Time, bool) {
-	var best time.Time
-	for _, at := range fireTimes(r, loc, t) {
-		if !at.After(t) && (best.IsZero() || at.After(best)) {
-			best = at
-		}
-	}
-	return best, !best.IsZero()
-}
-
-// fireAfter returns the earliest fire time of r in zone loc after t.
-func fireAfter(r Rule, loc *time.Location, t time.Time) (time.Time, bool) {
-	var best time.Time
-	for _, at := range fireTimes(r, loc, t) {
-		if at.After(t) && (best.IsZero() || at.Before(best)) {
-			best = at
-		}
-	}
-	return best, !best.IsZero()
-}
-
-// fireTimes returns r's fire times on the local dates within window days
-// of t's. A rule that fails to resolve was validated at compile, so it
-// cannot.
-func fireTimes(r Rule, loc *time.Location, t time.Time) []time.Time {
-	today := household.Today(t, loc)
-	var out []time.Time
-	for i := -window; i <= window; i++ {
-		d := addDays(today, i)
-		if r.Weekly && weekday(d) != r.Weekday {
-			continue
-		}
-		at, err := household.LocalTime(loc, d, r.Time)
-		if err != nil {
-			panic(fmt.Sprintf("scheduler: validated rule %+v: %v", r, err))
-		}
-		out = append(out, at)
-	}
-	return out
-}
-
-// addDays returns d plus n calendar days.
-func addDays(d store.LocalDate, n int) store.LocalDate {
-	y, m, day := d.Date()
-	return store.LocalDateOf(time.Date(y, m, day+n, 0, 0, 0, 0, time.UTC))
-}
-
-// weekday returns the day of the week of d.
-func weekday(d store.LocalDate) time.Weekday {
-	y, m, day := d.Date()
-	return time.Date(y, m, day, 0, 0, 0, 0, time.UTC).Weekday()
-}

internal/scheduler/scheduler_test.go

@@ -1,757 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"errors"
-	"io"
-	"log/slog"
-	"slices"
-	"sync"
-	"testing"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/migrations"
-)
-
-const zone = "America/Chicago"
-
-// chicago is the household zone of every test.
-var chicago = mustZone(zone)
-
-func mustZone(name string) *time.Location {
-	loc, err := household.LoadZone(name)
-	if err != nil {
-		panic(err)
-	}
-	return loc
-}
-
-// at returns the instant clocks in Chicago read the given time.
-func at(year int, month time.Month, day, hour, minute int) time.Time {
-	return time.Date(year, month, day, hour, minute, 0, 0, chicago)
-}
-
-// fakeClock is a clock whose time moves only when the test moves it.
-type fakeClock struct {
-	mu     sync.Mutex
-	now    time.Time
-	timers []fakeTimer
-	// waits receives one value per After call, so the test knows the
-	// scheduler finished a pass and is waiting.
-	waits chan struct{}
-}
-
-type fakeTimer struct {
-	deadline time.Time
-	ch       chan time.Time
-}
-
-func newFakeClock(now time.Time) *fakeClock {
-	return &fakeClock{now: now, waits: make(chan struct{}, 100)}
-}
-
-func (c *fakeClock) Now() time.Time {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.now
-}
-
-func (c *fakeClock) After(d time.Duration) <-chan time.Time {
-	c.mu.Lock()
-	ch := make(chan time.Time, 1)
-	c.timers = append(c.timers, fakeTimer{deadline: c.now.Add(d), ch: ch})
-	c.mu.Unlock()
-	c.waits <- struct{}{}
-	return ch
-}
-
-// set moves the clock to t and fires the timers due by then, reporting
-// whether any fired.
-func (c *fakeClock) set(t time.Time) bool {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	c.now = t
-	fired := false
-	kept := c.timers[:0]
-	for _, tm := range c.timers {
-		if tm.deadline.After(t) {
-			kept = append(kept, tm)
-			continue
-		}
-		tm.ch <- t
-		fired = true
-	}
-	c.timers = kept
-	return fired
-}
-
-// nextDeadline returns the earliest pending timer deadline.
-func (c *fakeClock) nextDeadline() (time.Time, bool) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	var next time.Time
-	for _, tm := range c.timers {
-		if next.IsZero() || tm.deadline.Before(next) {
-			next = tm.deadline
-		}
-	}
-	return next, !next.IsZero()
-}
-
-// recorder records the periods a schedule ran.
-type recorder struct {
-	mu   sync.Mutex
-	runs []scheduler.Period
-	err  error
-}
-
-func (r *recorder) run(_ context.Context, p scheduler.Period) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.runs = append(r.runs, p)
-	return r.err
-}
-
-func (r *recorder) periods() []scheduler.Period {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	return slices.Clone(r.runs)
-}
-
-func (r *recorder) keys() []string {
-	var keys []string
-	for _, p := range r.periods() {
-		keys = append(keys, p.Key)
-	}
-	return keys
-}
-
-// env is a migrated database with household settings in Chicago.
-type env struct {
-	t        *testing.T
-	st       *store.Store
-	settings *household.SettingsService
-}
-
-func newEnv(t *testing.T) *env {
-	t.Helper()
-	ctx := context.Background()
-	st, err := store.Open(ctx, t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() {
-		if err := st.Close(); err != nil {
-			t.Error(err)
-		}
-	})
-	if err := store.Migrate(ctx, st.Writer, migrations.FS); err != nil {
-		t.Fatal(err)
-	}
-	if err := household.SeedSettings(ctx, st, zone); err != nil {
-		t.Fatal(err)
-	}
-	return &env{t: t, st: st, settings: household.NewSettingsService(st)}
-}
-
-// update changes the household settings.
-func (e *env) update(patch household.SettingsPatch) {
-	e.t.Helper()
-	if _, err := e.settings.Update(context.Background(), patch, "member"); err != nil {
-		e.t.Fatal(err)
-	}
-}
-
-// claimed returns the period keys schedule_runs holds for name.
-func (e *env) claimed(name string) []string {
-	e.t.Helper()
-	rows, err := e.st.Reader.Query(`SELECT period_key FROM schedule_runs WHERE schedule = ? ORDER BY period_key`, name)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	defer rows.Close()
-	var keys []string
-	for rows.Next() {
-		var k string
-		if err := rows.Scan(&k); err != nil {
-			e.t.Fatal(err)
-		}
-		keys = append(keys, k)
-	}
-	if err := rows.Err(); err != nil {
-		e.t.Fatal(err)
-	}
-	return keys
-}
-
-// running is a started scheduler on a fake clock.
-type running struct {
-	t     *testing.T
-	clock *fakeClock
-	stop  func()
-}
-
-// start starts a scheduler on e at now with the schedules, and stops it
-// when the test ends. It returns once the first pass, the catch-up, is done.
-func (e *env) start(now time.Time, schedules ...scheduler.Schedule) *running {
-	e.t.Helper()
-	s, err := scheduler.New(e.st, e.settings, slog.New(slog.NewTextHandler(io.Discard, nil)))
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	clock := newFakeClock(now)
-	scheduler.SetClock(s, clock.Now, clock.After)
-	for _, sch := range schedules {
-		if err := s.Register(sch); err != nil {
-			e.t.Fatal(err)
-		}
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	if err := s.Start(ctx); err != nil {
-		cancel()
-		e.t.Fatal(err)
-	}
-	var once sync.Once
-	stop := func() {
-		once.Do(func() {
-			cancel()
-			s.Wait()
-		})
-	}
-	e.t.Cleanup(stop)
-	r := &running{t: e.t, clock: clock, stop: stop}
-	r.idle()
-	return r
-}
-
-// idle waits until the scheduler finished a pass and is waiting.
-func (r *running) idle() {
-	r.t.Helper()
-	select {
-	case <-r.clock.waits:
-	case <-time.After(10 * time.Second):
-		r.t.Fatal("scheduler did not finish its pass")
-	}
-}
-
-// runUntil moves the clock to to, stopping at every instant the scheduler
-// asked to wake at on the way, as a real clock would.
-func (r *running) runUntil(to time.Time) {
-	r.t.Helper()
-	for {
-		next, ok := r.clock.nextDeadline()
-		if !ok || next.After(to) {
-			if r.clock.set(to) {
-				r.idle()
-			}
-			return
-		}
-		if r.clock.set(next) {
-			r.idle()
-		}
-	}
-}
-
-// changed waits for the scheduler to apply a settings change.
-func (r *running) changed() {
-	r.t.Helper()
-	r.idle()
-}
-
-func reminder(rec *recorder) scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.DayOfReminder,
-		Rule: func(s household.Settings) scheduler.Rule { return scheduler.Daily(s.ReminderTime) },
-		Run:  rec.run,
-	}
-}
-
-func suggestions(rec *recorder) scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.SuggestionsWeekly,
-		Rule: func(s household.Settings) scheduler.Rule {
-			return scheduler.Weekly(time.Weekday(s.SuggestionsDow), s.SuggestionsTime)
-		},
-		Run: rec.run,
-	}
-}
-
-func planDraft(rec *recorder) scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.PlanDraft,
-		Rule: func(s household.Settings) scheduler.Rule {
-			return scheduler.WeeklyForNextWeek(time.Weekday(s.PlanDraftDow), s.PlanDraftTime)
-		},
-		Run: rec.run,
-	}
-}
-
-func ptr[T any](v T) *T { return &v }
-
-func wantKeys(t *testing.T, what string, got, want []string) {
-	t.Helper()
-	if !slices.Equal(got, want) {
-		t.Fatalf("%s = %q, want %q", what, got, want)
-	}
-}
-
-func TestFiresOncePerPeriod(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	// Seeded reminder time is 16:30; boot just after it on Oct 6 runs it.
-	r := e.start(at(2026, 10, 6, 16, 31), reminder(&rec))
-	wantKeys(t, "after boot", rec.keys(), []string{"2026-10-06"})
-
-	r.runUntil(at(2026, 10, 7, 16, 29))
-	wantKeys(t, "before the fire time", rec.keys(), []string{"2026-10-06"})
-	r.runUntil(at(2026, 10, 9, 23, 59))
-	wantKeys(t, "after three days", rec.keys(), []string{"2026-10-06", "2026-10-07", "2026-10-08", "2026-10-09"})
-
-	for i, p := range rec.periods()[1:] {
-		want := at(2026, 10, 7+i, 16, 30)
-		if !p.FireAt.Equal(want) {
-			t.Errorf("run %s fired at %s, want %s", p.Key, p.FireAt, want)
-		}
-		if p.FireAt.Location().String() != zone {
-			t.Errorf("run %s fired in zone %s, want %s", p.Key, p.FireAt.Location(), zone)
-		}
-	}
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), rec.keys())
-}
-
-func TestRestartMidPeriodDoesNotRerun(t *testing.T) {
-	e := newEnv(t)
-	var first recorder
-	r := e.start(at(2026, 10, 7, 12, 0), suggestions(&first)) // Wednesday
-	// The seeded Sunday 08:00 of Oct 4 is days ago: missed, not run.
-	wantKeys(t, "first boot", first.keys(), nil)
-	r.runUntil(at(2026, 10, 11, 9, 0))
-	wantKeys(t, "first process", first.keys(), []string{"2026-W41"})
-	r.stop()
-
-	// The restart is an hour after the Sunday 08:00 fire, mid-period.
-	var second recorder
-	r2 := e.start(at(2026, 10, 11, 9, 0), suggestions(&second))
-	wantKeys(t, "after restart", second.keys(), nil)
-	r2.runUntil(at(2026, 10, 18, 7, 59))
-	wantKeys(t, "rest of the period", second.keys(), nil)
-	r2.runUntil(at(2026, 10, 18, 8, 0))
-	wantKeys(t, "next period", second.keys(), []string{"2026-W42"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.SuggestionsWeekly), []string{"2026-W40", "2026-W41", "2026-W42"})
-}
-
-func TestCatchUpWithin24Hours(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	// Sunday Oct 11 08:00 passed 23h59m before boot.
-	e.start(at(2026, 10, 12, 7, 59), suggestions(&rec))
-	wantKeys(t, "catch-up", rec.keys(), []string{"2026-W41"})
-	if p := rec.periods()[0]; !p.FireAt.Equal(at(2026, 10, 11, 8, 0)) {
-		t.Errorf("caught-up period fired at %s, want its fire time", p.FireAt)
-	}
-}
-
-func TestNoCatchUpBeyond24Hours(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	// Sunday Oct 11 08:00 passed 24h01m before boot.
-	r := e.start(at(2026, 10, 12, 8, 1), suggestions(&rec))
-	wantKeys(t, "boot", rec.keys(), nil)
-	// The missed period is recorded, so it never runs later.
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.SuggestionsWeekly), []string{"2026-W41"})
-
-	// Moving the fire time to Sunday 23:00 puts that week's fire time
-	// within 24 h of now. The change itself never fires a passed time...
-	e.update(household.SettingsPatch{SuggestionsTime: ptr("23:00")})
-	r.changed()
-	wantKeys(t, "after a settings change", rec.keys(), nil)
-	r.stop()
-
-	// ...and the restart's catch-up finds the period already recorded.
-	var again recorder
-	r2 := e.start(at(2026, 10, 12, 8, 2), suggestions(&again))
-	wantKeys(t, "after restart", again.keys(), nil)
-	r2.runUntil(at(2026, 10, 18, 23, 0))
-	wantKeys(t, "next period", again.keys(), []string{"2026-W42"})
-}
-
-func TestCatchUpOnlyMostRecentPeriod(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	// Days of downtime: only Oct 9 16:30, 30 minutes ago, runs.
-	e.start(at(2026, 10, 9, 17, 0), reminder(&rec))
-	wantKeys(t, "catch-up", rec.keys(), []string{"2026-10-09"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-09"})
-}
-
-func TestSpringForward(t *testing.T) {
-	// Clocks in Chicago jump 02:00 CST → 03:00 CDT on Sunday 2026-03-08.
-	e := newEnv(t)
-	e.update(household.SettingsPatch{ReminderTime: ptr("08:00"), ReviewTime: ptr("02:30")})
-	var daily, skipped recorder
-	review := scheduler.Schedule{
-		Name: scheduler.RotationCheck,
-		Rule: func(s household.Settings) scheduler.Rule { return scheduler.Daily(s.ReviewTime) },
-		Run:  skipped.run,
-	}
-	r := e.start(at(2026, 3, 7, 9, 0), reminder(&daily), review)
-	r.runUntil(at(2026, 3, 9, 12, 0))
-
-	wantKeys(t, "08:00 runs", daily.keys(), []string{"2026-03-07", "2026-03-08", "2026-03-09"})
-	wantFired(t, daily.periods(),
-		time.Date(2026, 3, 7, 14, 0, 0, 0, time.UTC), // 08:00 CST
-		time.Date(2026, 3, 8, 13, 0, 0, 0, time.UTC), // 08:00 CDT
-		time.Date(2026, 3, 9, 13, 0, 0, 0, time.UTC),
-	)
-
-	// 02:30 does not exist on Mar 8: it fires once, an hour later at
-	// 03:30 CDT, keyed by Mar 8.
-	wantKeys(t, "02:30 runs", skipped.keys(), []string{"2026-03-07", "2026-03-08", "2026-03-09"})
-	wantFired(t, skipped.periods(),
-		time.Date(2026, 3, 7, 8, 30, 0, 0, time.UTC), // 02:30 CST
-		time.Date(2026, 3, 8, 8, 30, 0, 0, time.UTC), // 03:30 CDT
-		time.Date(2026, 3, 9, 7, 30, 0, 0, time.UTC), // 02:30 CDT
-	)
-	if got := skipped.periods()[1].FireAt.Format("15:04 MST"); got != "03:30 CDT" {
-		t.Errorf("skipped 02:30 fired at %s local, want 03:30 CDT", got)
-	}
-}
-
-func TestFallBack(t *testing.T) {
-	// Clocks in Chicago go back 02:00 CDT → 01:00 CST on Sunday 2026-11-01.
-	e := newEnv(t)
-	e.update(household.SettingsPatch{ReminderTime: ptr("08:00"), ReviewTime: ptr("01:30")})
-	var daily, repeated recorder
-	review := scheduler.Schedule{
-		Name: scheduler.RotationCheck,
-		Rule: func(s household.Settings) scheduler.Rule { return scheduler.Daily(s.ReviewTime) },
-		Run:  repeated.run,
-	}
-	r := e.start(at(2026, 10, 31, 9, 0), reminder(&daily), review)
-	r.runUntil(at(2026, 11, 2, 12, 0))
-
-	wantKeys(t, "08:00 runs", daily.keys(), []string{"2026-10-31", "2026-11-01", "2026-11-02"})
-	wantFired(t, daily.periods(),
-		time.Date(2026, 10, 31, 13, 0, 0, 0, time.UTC), // 08:00 CDT
-		time.Date(2026, 11, 1, 14, 0, 0, 0, time.UTC),  // 08:00 CST
-		time.Date(2026, 11, 2, 14, 0, 0, 0, time.UTC),
-	)
-
-	// 01:30 happens twice on Nov 1: it fires once, at the first (CDT).
-	wantKeys(t, "01:30 runs", repeated.keys(), []string{"2026-10-31", "2026-11-01", "2026-11-02"})
-	wantFired(t, repeated.periods(),
-		time.Date(2026, 10, 31, 6, 30, 0, 0, time.UTC), // 01:30 CDT
-		time.Date(2026, 11, 1, 6, 30, 0, 0, time.UTC),  // first 01:30, CDT
-		time.Date(2026, 11, 2, 7, 30, 0, 0, time.UTC),  // 01:30 CST
-	)
-}
-
-func TestFallBackSecondOccurrenceDoesNotRerun(t *testing.T) {
-	e := newEnv(t)
-	e.update(household.SettingsPatch{ReviewTime: ptr("01:30")})
-	var rec recorder
-	review := scheduler.Schedule{
-		Name: scheduler.RotationCheck,
-		Rule: func(s household.Settings) scheduler.Rule { return scheduler.Daily(s.ReviewTime) },
-		Run:  rec.run,
-	}
-	// Boot between the two 01:30s of Nov 1: the first ran in an earlier
-	// process, so the second is not a new period.
-	first := time.Date(2026, 11, 1, 6, 30, 0, 0, time.UTC)
-	r := e.start(first.Add(-time.Minute), review)
-	r.runUntil(first)
-	wantKeys(t, "first 01:30", rec.keys(), []string{"2026-10-31", "2026-11-01"})
-	r.stop()
-
-	var again recorder
-	review.Run = again.run
-	r2 := e.start(first.Add(30*time.Minute), review)
-	r2.runUntil(first.Add(2 * time.Hour)) // past the second 01:30, CST
-	wantKeys(t, "second 01:30", again.keys(), nil)
-}
-
-func wantFired(t *testing.T, got []scheduler.Period, want ...time.Time) {
-	t.Helper()
-	if len(got) != len(want) {
-		t.Fatalf("%d runs, want %d", len(got), len(want))
-	}
-	for i := range want {
-		if !got[i].FireAt.Equal(want[i]) {
-			t.Errorf("run %s fired at %s (%s), want %s", got[i].Key, got[i].FireAt.UTC(), got[i].FireAt, want[i])
-		}
-	}
-}
-
-func TestISOWeek53Boundary(t *testing.T) {
-	e := newEnv(t)
-	var sugg, draft recorder
-	// Suggestions Sunday 08:00 keys the ISO week ending that Sunday; the
-	// plan draft Friday 09:00 keys the week after.
-	r := e.start(at(2026, 12, 20, 9, 0), suggestions(&sugg), planDraft(&draft))
-	r.runUntil(at(2027, 1, 11, 0, 0))
-
-	wantKeys(t, "suggestions", sugg.keys(), []string{"2026-W51", "2026-W52", "2026-W53", "2027-W01"})
-	// Sunday 2027-01-03 is the last day of 2026-W53.
-	if p := sugg.periods()[2]; p.Date.String() != "2027-01-03" || p.Week.String() != "2026-12-28" {
-		t.Errorf("2026-W53 suggestions ran on %s for week %s, want 2027-01-03 for 2026-12-28", p.Date, p.Week)
-	}
-	// Friday Dec 18, two days before boot, was missed.
-	wantKeys(t, "plan drafts", draft.keys(), []string{"2026-W53", "2027-W01", "2027-W02"})
-	// Friday 2026-12-25 drafts 2026-W53; Friday 2027-01-01 drafts 2027-W01.
-	if p := draft.periods()[0]; p.Date.String() != "2026-12-25" || p.Week.String() != "2026-12-28" {
-		t.Errorf("2026-W53 draft ran on %s for week %s, want 2026-12-25 for 2026-12-28", p.Date, p.Week)
-	}
-	if p := draft.periods()[1]; p.Date.String() != "2027-01-01" || p.Week.String() != "2027-01-04" {
-		t.Errorf("2027-W01 draft ran on %s for week %s, want 2027-01-01 for 2027-01-04", p.Date, p.Week)
-	}
-}
-
-func TestPeriodKey(t *testing.T) {
-	date := func(s string) store.LocalDate {
-		d, err := store.ParseLocalDate(s)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return d
-	}
-	tests := []struct {
-		rule scheduler.Rule
-		date string
-		want string
-	}{
-		{scheduler.Daily("16:30"), "2026-12-31", "2026-12-31"},
-		{scheduler.Weekly(time.Monday, "00:00"), "2026-12-28", "2026-W53"},
-		{scheduler.Weekly(time.Sunday, "08:00"), "2027-01-03", "2026-W53"},
-		{scheduler.Weekly(time.Monday, "00:00"), "2027-01-04", "2027-W01"},
-		{scheduler.WeeklyForNextWeek(time.Friday, "09:00"), "2026-12-25", "2026-W53"},
-		{scheduler.WeeklyForNextWeek(time.Friday, "09:00"), "2027-01-01", "2027-W01"},
-	}
-	for _, tt := range tests {
-		if got := tt.rule.PeriodKey(date(tt.date)); got != tt.want {
-			t.Errorf("%+v.PeriodKey(%s) = %s, want %s", tt.rule, tt.date, got, tt.want)
-		}
-	}
-}
-
-func TestSettingsChangeMovesNextFire(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	r := e.start(at(2026, 10, 7, 12, 0), reminder(&rec))
-	wantKeys(t, "boot", rec.keys(), []string{"2026-10-06"})
-
-	// Earlier but still ahead: fires at the new time, not the old.
-	e.update(household.SettingsPatch{ReminderTime: ptr("13:00")})
-	r.changed()
-	if next, _ := r.clock.nextDeadline(); !next.Equal(at(2026, 10, 7, 13, 0)) {
-		t.Errorf("next wake %s, want the new 13:00", next)
-	}
-	r.runUntil(at(2026, 10, 7, 13, 0))
-	wantKeys(t, "at the new time", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-	r.runUntil(at(2026, 10, 7, 23, 0))
-	wantKeys(t, "at the old time", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-
-	// Moved to a time already passed today: nothing fires now, and
-	// tomorrow fires at the new time.
-	r.runUntil(at(2026, 10, 8, 12, 0))
-	e.update(household.SettingsPatch{ReminderTime: ptr("11:00")})
-	r.changed()
-	wantKeys(t, "moved into the past", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-	r.runUntil(at(2026, 10, 9, 10, 59))
-	wantKeys(t, "before the new time", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-	r.runUntil(at(2026, 10, 9, 11, 0))
-	wantKeys(t, "the new time", rec.keys(), []string{"2026-10-06", "2026-10-07", "2026-10-09"})
-}
-
-// A change saved at 12:00 moving the 16:30 reminder to 12:01 must fire it
-// even when the scheduler only gets to the change at 12:02, after the new
-// fire time has passed.
-func TestSettingsChangeAppliedLateStillFires(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	// blocker holds the scheduler in a Run at 12:00 on 2026-10-07 while
-	// the settings change and the clock moves on.
-	started := make(chan struct{})
-	release := make(chan struct{})
-	blocker := scheduler.Schedule{
-		Name: scheduler.RotationCheck,
-		Rule: func(household.Settings) scheduler.Rule { return scheduler.Daily("12:00") },
-		Run: func(_ context.Context, p scheduler.Period) error {
-			if p.Key == "2026-10-07" {
-				close(started)
-				<-release
-			}
-			return nil
-		},
-	}
-	r := e.start(at(2026, 10, 7, 11, 0), reminder(&rec), blocker)
-	wantKeys(t, "boot", rec.keys(), []string{"2026-10-06"})
-
-	r.clock.set(at(2026, 10, 7, 12, 0))
-	<-started
-	e.update(household.SettingsPatch{ReminderTime: ptr("12:01")})
-	r.clock.set(at(2026, 10, 7, 12, 2))
-	close(release)
-	r.idle() // the pass the blocker held
-	r.idle() // the pass that applies the change
-	wantKeys(t, "after the late change", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-
-	r.runUntil(at(2026, 10, 7, 23, 0))
-	wantKeys(t, "end of day", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-	wantKeys(t, "claims", e.claimed(scheduler.DayOfReminder), []string{"2026-10-06", "2026-10-07"})
-}
-
-// failClaims makes every claim fail until recover is called.
-func (e *env) failClaims() (recover func()) {
-	e.t.Helper()
-	for _, q := range []string{
-		`CREATE TABLE fail_claims (on_ INTEGER NOT NULL)`,
-		`INSERT INTO fail_claims VALUES (1)`,
-		`CREATE TRIGGER fail_claim BEFORE INSERT ON schedule_runs
-			WHEN (SELECT on_ FROM fail_claims) = 1
-			BEGIN SELECT RAISE(ABORT, 'injected claim failure'); END`,
-	} {
-		if _, err := e.st.Writer.Exec(q); err != nil {
-			e.t.Fatal(err)
-		}
-	}
-	return func() {
-		e.t.Helper()
-		if _, err := e.st.Writer.Exec(`UPDATE fail_claims SET on_ = 0`); err != nil {
-			e.t.Fatal(err)
-		}
-	}
-}
-
-// A claim that fails is retried, not skipped, and the period then runs once.
-func TestClaimFailureIsRetried(t *testing.T) {
-	e := newEnv(t)
-	recoverClaims := e.failClaims()
-	var rec recorder
-	r := e.start(at(2026, 10, 7, 12, 0), reminder(&rec))
-	wantKeys(t, "boot with failing claims", rec.keys(), nil)
-	wantKeys(t, "claims while failing", e.claimed(scheduler.DayOfReminder), nil)
-	if next, _ := r.clock.nextDeadline(); !next.Equal(at(2026, 10, 7, 12, 0).Add(scheduler.ClaimRetry)) {
-		t.Errorf("next wake %s, want a retry after %s", next, scheduler.ClaimRetry)
-	}
-
-	recoverClaims()
-	r.runUntil(at(2026, 10, 7, 12, 0).Add(scheduler.ClaimRetry))
-	wantKeys(t, "after the retry", rec.keys(), []string{"2026-10-06"})
-	r.runUntil(at(2026, 10, 7, 23, 0))
-	wantKeys(t, "end of day", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-	wantKeys(t, "claims", e.claimed(scheduler.DayOfReminder), []string{"2026-10-06", "2026-10-07"})
-}
-
-// A claim that keeps failing past the next daily fire is retried for its
-// own period, not the most recent one: that period, now more than
-// CatchUpWindow old, is recorded as missed, and the later period runs once.
-func TestClaimFailureRecoversAfterNextFire(t *testing.T) {
-	e := newEnv(t)
-	recoverClaims := e.failClaims()
-	var rec recorder
-	// The 7 October 16:30 reminder is due and its claim fails, past the
-	// 8 October 16:30 fire.
-	r := e.start(at(2026, 10, 7, 16, 45), reminder(&rec))
-	r.runUntil(at(2026, 10, 8, 17, 0))
-	wantKeys(t, "runs while failing", rec.keys(), nil)
-	wantKeys(t, "claims while failing", e.claimed(scheduler.DayOfReminder), nil)
-
-	// Claims recover 24h31m after the 7 October fire.
-	recoverClaims()
-	r.runUntil(at(2026, 10, 8, 17, 1))
-	wantKeys(t, "after recovery", rec.keys(), []string{"2026-10-08"})
-	wantKeys(t, "claims after recovery", e.claimed(scheduler.DayOfReminder), []string{"2026-10-07", "2026-10-08"})
-
-	r.runUntil(at(2026, 10, 9, 16, 0))
-	wantKeys(t, "next day", rec.keys(), []string{"2026-10-08"})
-}
-
-func TestSettingsChangeTimezone(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	r := e.start(at(2026, 10, 7, 12, 0), reminder(&rec))
-	e.update(household.SettingsPatch{Timezone: ptr("America/New_York")})
-	r.changed()
-	// 16:30 in New York is 15:30 in Chicago.
-	r.runUntil(at(2026, 10, 7, 15, 30))
-	wantKeys(t, "after the zone change", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-	if got := rec.periods()[1].FireAt.Location().String(); got != "America/New_York" {
-		t.Errorf("fired in zone %s, want America/New_York", got)
-	}
-}
-
-func TestRunErrorKeepsPeriodClaimed(t *testing.T) {
-	e := newEnv(t)
-	rec := recorder{err: errors.New("boom")}
-	r := e.start(at(2026, 10, 7, 16, 0), reminder(&rec))
-	r.runUntil(at(2026, 10, 7, 23, 0))
-	wantKeys(t, "runs", rec.keys(), []string{"2026-10-06", "2026-10-07"})
-	r.stop()
-	var again recorder
-	e.start(at(2026, 10, 7, 23, 0), reminder(&again))
-	wantKeys(t, "after restart", again.keys(), nil)
-}
-
-func TestRegister(t *testing.T) {
-	e := newEnv(t)
-	s, err := scheduler.New(e.st, e.settings, slog.New(slog.NewTextHandler(io.Discard, nil)))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var rec recorder
-	bad := []scheduler.Schedule{
-		{Name: "hourly", Rule: reminder(&rec).Rule, Run: rec.run},
-		{Name: scheduler.DayOfReminder, Run: rec.run},
-		{Name: scheduler.DayOfReminder, Rule: reminder(&rec).Rule},
-	}
-	for _, sch := range bad {
-		if err := s.Register(sch); err == nil {
-			t.Errorf("Register(%q) accepted an invalid schedule", sch.Name)
-		}
-	}
-	if err := s.Register(reminder(&rec)); err != nil {
-		t.Fatal(err)
-	}
-	if err := s.Register(reminder(&rec)); err == nil {
-		t.Error("Register accepted a second schedule with the same name")
-	}
-}
-
-func TestStartRejectsInvalidRule(t *testing.T) {
-	e := newEnv(t)
-	s, err := scheduler.New(e.st, e.settings, slog.New(slog.NewTextHandler(io.Discard, nil)))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var rec recorder
-	if err := s.Register(scheduler.Schedule{
-		Name: scheduler.WeekRollover,
-		Rule: func(household.Settings) scheduler.Rule { return scheduler.Weekly(7, "00:00") },
-		Run:  rec.run,
-	}); err != nil {
-		t.Fatal(err)
-	}
-	if err := s.Start(context.Background()); err == nil {
-		s.Wait()
-		t.Fatal("Start accepted weekday 7")
-	}
-}
-
-func TestStopEndsTheLoop(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	r := e.start(at(2026, 10, 7, 12, 0), reminder(&rec))
-	done := make(chan struct{})
-	go func() {
-		r.stop()
-		close(done)
-	}()
-	select {
-	case <-done:
-	case <-time.After(10 * time.Second):
-		t.Fatal("scheduler did not stop")
-	}
-}

internal/scheduler/suggestions_test.go

@@ -1,370 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify/notifytest"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/suggest"
-)
-
-// The tests in this file run suggest's suggestions_weekly schedule on the
-// fake clock against the real suggestion service, job runner, harness and
-// notification outbox, with the AI and recipe sources faked.
-
-// suggestEnv is a suggestion service over a scheduler env's store, the
-// "process" a scheduler runs it in. side answers suggest_side_quests and
-// model normalize_recipe while grounding.
-type suggestEnv struct {
-	e      *env
-	svc    *suggest.Service
-	side   *llm.Fake
-	model  *llm.Fake
-	search *recipestest.Search
-	pages  *recipestest.Pages
-	images *recipestest.Images
-	logs   *syncBuffer
-	stop   func()
-}
-
-// syncBuffer collects log output written by concurrent goroutines.
-type syncBuffer struct {
-	mu  sync.Mutex
-	buf strings.Builder
-}
-
-func (b *syncBuffer) Write(p []byte) (int, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.buf.Write(p)
-}
-
-func (b *syncBuffer) String() string {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.buf.String()
-}
-
-// regulars stores the Regulars Beef Chili and Chicken Fajitas, so a batch
-// has Regulars to suggest from.
-func (e *env) regulars() {
-	e.t.Helper()
-	for _, name := range []string{"Beef Chili", "Chicken Fajitas"} {
-		now := store.Now().String()
-		if _, err := db.New(e.st.Writer).CreateDinner(context.Background(), db.CreateDinnerParams{
-			ID:              store.NewID(),
-			Name:            name,
-			NormalizedName:  harness.Normalize(name),
-			Status:          "regular",
-			Origin:          "regular",
-			GroundingStatus: "manual",
-			CreatedAt:       now,
-			UpdatedAt:       now,
-		}); err != nil {
-			e.t.Fatal(err)
-		}
-	}
-}
-
-// suggestions builds a suggestion service over e with a started job
-// runner, which stop stops (and the test's end, if not before).
-func (e *env) suggestions() *suggestEnv {
-	e.t.Helper()
-	s := &suggestEnv{
-		e:      e,
-		side:   &llm.Fake{},
-		model:  &llm.Fake{},
-		search: &recipestest.Search{Results: map[string][]recipes.Candidate{}},
-		pages:  &recipestest.Pages{Bodies: map[string][]byte{}},
-		images: &recipestest.Images{JPEGs: map[string][]byte{}},
-		logs:   &syncBuffer{},
-	}
-	g := recipestest.NewGrounder(e.t, e.st, e.t.TempDir(), s.search, s.pages, s.images, s.model)
-	guard, err := harness.NewGuard(harness.DefaultMaxCalls)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	cfg := harness.Config{
-		Settings:    llm.Settings{Provider: "anthropic", Model: "claude-test", Temperature: 0.7},
-		NewProvider: func(llm.Settings, string) (llm.Provider, error) { return s.side, nil },
-		Store:       e.st,
-		Guard:       guard,
-	}
-	suggester := func(ctx context.Context, scope string, in skills.SideQuestsRequest) (skills.SideQuests, error) {
-		return skills.SuggestSideQuests(ctx, cfg, scope, in)
-	}
-	logger := slog.New(slog.NewTextHandler(s.logs, nil))
-	runner, err := jobs.NewRunner(e.st, logger, 1)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	s.svc, err = suggest.NewService(e.st, g, suggester, runner, notifytest.New(e.t, e.st), logger)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	if err := runner.Start(ctx); err != nil {
-		cancel()
-		e.t.Fatal(err)
-	}
-	var once sync.Once
-	s.stop = func() {
-		once.Do(func() {
-			cancel()
-			runner.Wait()
-		})
-	}
-	e.t.Cleanup(s.stop)
-	return s
-}
-
-// week scripts the next batch: suggest_side_quests answers with the
-// Side quests named names, each grounded by its own recipe.
-func (s *suggestEnv) week(names ...string) {
-	s.e.t.Helper()
-	var quests []string
-	for _, name := range names {
-		slug := strings.ReplaceAll(strings.ToLower(name), " ", "-")
-		page, photo := "https://r.example/"+slug, "https://r.example/"+slug+".jpg"
-		s.search.Results[name] = []recipes.Candidate{{URL: page}}
-		s.pages.Bodies[page] = recipestest.RecipePage(name, "R Kitchen", photo, 35)
-		s.images.JPEGs[photo] = recipestest.JPEG(s.e.t, 400, 320, uint8(len(s.images.JPEGs)+1))
-		s.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 35))
-		quests = append(quests, fmt.Sprintf(`{"name":%q,"cuisine":"Fusion","method":"stovetop","est_minutes":35,"difficulty":"easy","reason":"Like your Beef Chili.","cited_regulars":["Beef Chili"],"search_query":%q}`, name, name))
-	}
-	js := `{"suggestions":[` + strings.Join(quests, ",") + `]}`
-	s.side.QueueGenerate(llm.GenerateResult{Response: llm.Response{Text: js, JSON: json.RawMessage(js)}})
-}
-
-// batch is a suggestion_batches row.
-type batch struct {
-	ID, Trigger, Status string
-}
-
-// batches returns every suggestion batch, oldest first.
-func (e *env) batches() []batch {
-	e.t.Helper()
-	rows, err := e.st.Reader.Query(`SELECT id, trigger, status FROM suggestion_batches ORDER BY created_at, id`)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	defer rows.Close()
-	var out []batch
-	for rows.Next() {
-		var b batch
-		if err := rows.Scan(&b.ID, &b.Trigger, &b.Status); err != nil {
-			e.t.Fatal(err)
-		}
-		out = append(out, b)
-	}
-	if err := rows.Err(); err != nil {
-		e.t.Fatal(err)
-	}
-	return out
-}
-
-// settled waits until no batch is pending or running and returns the
-// batches.
-func (e *env) settled() []batch {
-	e.t.Helper()
-	deadline := time.Now().Add(10 * time.Second)
-	for {
-		bs := e.batches()
-		busy := false
-		for _, b := range bs {
-			busy = busy || b.Status == suggest.BatchPending || b.Status == suggest.BatchRunning
-		}
-		if !busy {
-			return bs
-		}
-		if time.Now().After(deadline) {
-			e.t.Fatalf("batches still under way: %+v", bs)
-		}
-		time.Sleep(5 * time.Millisecond)
-	}
-}
-
-// wantBatches fails unless the batches are scheduled with statuses want.
-func wantBatches(t *testing.T, what string, got []batch, want ...string) {
-	t.Helper()
-	ok := len(got) == len(want)
-	for i := 0; ok && i < len(got); i++ {
-		ok = got[i].Trigger == suggest.TriggerScheduled && got[i].Status == want[i]
-	}
-	if !ok {
-		t.Fatalf("%s: batches = %+v, want scheduled %q", what, got, want)
-	}
-}
-
-// notified returns the new_suggestions keys stored, oldest first, and
-// reports an error for any whose title is not the one titles gives it.
-func (e *env) notified(titles ...string) []string {
-	e.t.Helper()
-	var keys []string
-	rows := notifytest.Rows(e.t, e.st, notify.NewSuggestions)
-	for i, r := range rows {
-		keys = append(keys, r.Key)
-		if i < len(titles) && r.Payload.Title != titles[i] {
-			e.t.Errorf("new_suggestions %s title = %q, want %q", r.Key, r.Payload.Title, titles[i])
-		}
-	}
-	return keys
-}
-
-// TestSuggestionsWeeklyOneBatchAndNotificationPerWeek: at the seeded
-// Sunday 08:00 the schedule starts one scheduled batch a week, period
-// suggestions_weekly:YYYY-Www, and each tells the household once, with
-// new_suggestions:YYYY-Www counting its new Side quests.
-func TestSuggestionsWeeklyOneBatchAndNotificationPerWeek(t *testing.T) {
-	e := newEnv(t)
-	e.regulars()
-	s := e.suggestions()
-	s.week("Chili Verde", "Chicken Shawarma Bowls")
-	s.week("Lamb Kofta", "Black Bean Tostadas", "Pork Carnitas")
-
-	// Wednesday Oct 7: the Sunday Oct 4 08:00 fire is days ago, missed.
-	r := e.start(at(2026, 10, 7, 12, 0), s.svc.WeeklySchedule())
-	r.runUntil(at(2026, 10, 11, 7, 59))
-	wantBatches(t, "before Sunday 08:00", e.settled())
-	wantKeys(t, "new_suggestions before Sunday 08:00", e.notified(), nil)
-
-	r.runUntil(at(2026, 10, 11, 8, 0))
-	wantBatches(t, "at Sunday 08:00", e.settled(), suggest.BatchDone)
-	wantKeys(t, "new_suggestions of W41", e.notified("2 new Side quests are in"), []string{"new_suggestions:2026-W41"})
-
-	r.runUntil(at(2026, 10, 18, 7, 59))
-	wantBatches(t, "rest of W41", e.settled(), suggest.BatchDone)
-	r.runUntil(at(2026, 10, 18, 9, 0))
-	wantBatches(t, "W42", e.settled(), suggest.BatchDone, suggest.BatchDone)
-	wantKeys(t, "new_suggestions of W41 and W42", e.notified("2 new Side quests are in", "3 new Side quests are in"),
-		[]string{"new_suggestions:2026-W41", "new_suggestions:2026-W42"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.SuggestionsWeekly), []string{"2026-W40", "2026-W41", "2026-W42"})
-}
-
-// TestSuggestionsWeeklyFollowsSettings: the schedule fires at the
-// household's suggestions_dow and suggestions_time.
-func TestSuggestionsWeeklyFollowsSettings(t *testing.T) {
-	e := newEnv(t)
-	e.regulars()
-	e.update(household.SettingsPatch{SuggestionsDow: ptr(3), SuggestionsTime: ptr("18:30")})
-	s := e.suggestions()
-	s.week("Chili Verde")
-
-	r := e.start(at(2026, 10, 12, 12, 0), s.svc.WeeklySchedule()) // Monday
-	r.runUntil(at(2026, 10, 14, 18, 29))                          // Wednesday
-	wantBatches(t, "before Wednesday 18:30", e.settled())
-	r.runUntil(at(2026, 10, 14, 18, 30))
-	wantBatches(t, "at Wednesday 18:30", e.settled(), suggest.BatchDone)
-	wantKeys(t, "new_suggestions", e.notified("1 new Side quest is in"), []string{"new_suggestions:2026-W42"})
-}
-
-// TestSuggestionsWeeklyAIFailureSendsNothing: when suggest_side_quests
-// fails the batch fails with the failure logged and recorded in ai_runs,
-// and the household is not notified.
-func TestSuggestionsWeeklyAIFailureSendsNothing(t *testing.T) {
-	e := newEnv(t)
-	e.regulars()
-	s := e.suggestions()
-	s.side.QueueGenerate(llm.GenerateResult{Err: errors.New("provider down")})
-
-	r := e.start(at(2026, 10, 11, 7, 0), s.svc.WeeklySchedule())
-	r.runUntil(at(2026, 10, 11, 8, 0))
-	wantBatches(t, "after the AI failed", e.settled(), suggest.BatchFailed)
-	wantKeys(t, "new_suggestions after the AI failed", e.notified(), nil)
-	// W40 is the boot's missed period, recorded without running.
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.SuggestionsWeekly), []string{"2026-W40", "2026-W41"})
-
-	var status, msg string
-	if err := e.st.Reader.QueryRow(`SELECT status, COALESCE(error, '') FROM ai_runs WHERE skill = 'suggest_side_quests'`).Scan(&status, &msg); err != nil {
-		t.Fatalf("ai_runs row of suggest_side_quests: %v", err)
-	}
-	if status != string(harness.StatusProviderError) || msg == "" {
-		t.Errorf("ai_runs suggest_side_quests = %s %q, want %s with its message", status, msg, harness.StatusProviderError)
-	}
-	if logs := s.logs.String(); !strings.Contains(logs, "suggestion batch failed") || !strings.Contains(logs, "reason="+suggest.ReasonAIFailed) {
-		t.Errorf("logs = %s, want the batch failure with reason %s", logs, suggest.ReasonAIFailed)
-	}
-}
-
-// TestSuggestionsWeeklyNoDuplicateAfterRestart: a restart after the week's
-// batch ran, still within the catch-up window, starts no second batch and
-// sends no second notification: the period is already claimed.
-func TestSuggestionsWeeklyNoDuplicateAfterRestart(t *testing.T) {
-	e := newEnv(t)
-	e.regulars()
-	s := e.suggestions()
-	s.week("Chili Verde", "Chicken Shawarma Bowls")
-	r := e.start(at(2026, 10, 11, 7, 0), s.svc.WeeklySchedule())
-	r.runUntil(at(2026, 10, 11, 8, 0))
-	wantBatches(t, "first process", e.settled(), suggest.BatchDone)
-	r.stop()
-	s.stop()
-
-	// The restarted process has a new job runner, suggestion service and
-	// scheduler; it would answer a second batch if one were started.
-	s2 := e.suggestions()
-	s2.week("Lamb Kofta")
-	r2 := e.start(at(2026, 10, 11, 9, 0), s2.svc.WeeklySchedule())
-	r2.runUntil(at(2026, 10, 18, 7, 59))
-	wantBatches(t, "after restart", e.settled(), suggest.BatchDone)
-	wantKeys(t, "new_suggestions after restart", e.notified(), []string{"new_suggestions:2026-W41"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.SuggestionsWeekly), []string{"2026-W40", "2026-W41"})
-}
-
-// TestSuggestionsWeeklyCatchUpAfterTheWeekEnds: a Sunday fire caught up on
-// Monday, in the next ISO week, still runs W41's batch keyed by W41, and
-// the next Sunday's batch notifies for W42.
-func TestSuggestionsWeeklyCatchUpAfterTheWeekEnds(t *testing.T) {
-	e := newEnv(t)
-	e.regulars()
-	s := e.suggestions()
-	s.week("Chili Verde")
-	s.week("Lamb Kofta")
-
-	r := e.start(at(2026, 10, 12, 7, 0), s.svc.WeeklySchedule()) // Monday, 23h late
-	wantBatches(t, "after catch-up", e.settled(), suggest.BatchDone)
-	wantKeys(t, "new_suggestions after catch-up", e.notified(), []string{"new_suggestions:2026-W41"})
-	r.runUntil(at(2026, 10, 18, 8, 0))
-	wantBatches(t, "W42", e.settled(), suggest.BatchDone, suggest.BatchDone)
-	wantKeys(t, "new_suggestions", e.notified(), []string{"new_suggestions:2026-W41", "new_suggestions:2026-W42"})
-}
-
-// TestSuggestionsWeeklyStartsNoBatchWhileOneIsUnderWay: a period that
-// fires while a batch is pending starts no second one and says so.
-func TestSuggestionsWeeklyStartsNoBatchWhileOneIsUnderWay(t *testing.T) {
-	e := newEnv(t)
-	e.regulars()
-	s := e.suggestions()
-	s.stop() // the manual batch stays pending
-	manual, err := s.svc.StartBatch(context.Background(), suggest.TriggerManual)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	r := e.start(at(2026, 10, 11, 7, 0), s.svc.WeeklySchedule())
-	r.runUntil(at(2026, 10, 11, 8, 0))
-	if bs := e.batches(); len(bs) != 1 || bs[0].ID != manual.ID {
-		t.Fatalf("batches = %+v, want only the manual batch %s", bs, manual.ID)
-	}
-	if logs := s.logs.String(); !strings.Contains(logs, "scheduled suggestion batch not started") || !strings.Contains(logs, "period=2026-W41") {
-		t.Errorf("logs = %s, want the skipped period logged", logs)
-	}
-}

internal/server/aisettings_test.go

@@ -29,7 +29,7 @@ func newAIRouter(t *testing.T) http.Handler {
 	t.Helper()
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	r, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t),
-		newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/chat_test.go

@@ -86,7 +86,7 @@ func (b *lockedBuffer) String() string {
 func newChatRouter(t *testing.T, svc *chat.Service, logs io.Writer) http.Handler {
 	t.Helper()
 	logger := slog.New(slog.NewTextHandler(logs, &slog.HandlerOptions{Level: slog.LevelDebug}))
-	r, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), svc, newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t),
+	r, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), svc, newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t),
 		newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
@@ -233,7 +233,7 @@ func TestChatWebhookNeedsCSRF(t *testing.T) {
 func TestNewRouterRequiresChat(t *testing.T) {
 	t.Parallel()
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), nil, newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), nil, newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil Google Chat service")
 	}
 }

internal/server/dinners_test.go

@@ -98,7 +98,7 @@ func newDinnersEnv(t *testing.T) *dinnersEnv {
 		t.Fatal(err)
 	}
 	e.h, err = NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t),
-		svc, newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), runner, photos, fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		svc, newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), runner, photos, fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/google_test.go

@@ -69,7 +69,7 @@ func newGoogleEnv(t *testing.T) *googleEnv {
 	}
 	logger := slog.New(slog.NewJSONHandler(e.logs, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	e.h, err = NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t),
-		newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), svc, newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t),
+		newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), svc, newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t),
 		fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)

internal/server/home.go

@@ -0,0 +1,22 @@
+package server
+
+import (
+	"log/slog"
+	"net/http"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/home"
+)
+
+// getHome answers GET /home with the Home screen at the household's local
+// "now".
+func getHome(logger *slog.Logger, svc *home.Service) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		h, err := svc.Get(r.Context())
+		if err != nil {
+			logger.ErrorContext(r.Context(), "read home", "error", err)
+			writeError(w, r, logger, http.StatusInternalServerError, "internal", "internal error")
+			return
+		}
+		writeJSON(w, r, logger, http.StatusOK, h)
+	}
+}

internal/server/home_test.go

@@ -0,0 +1,69 @@
+package server
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
+)
+
+// GET /home answers the Home screen in its JSON shape; newTestHome's
+// household (America/New_York) has no plan, no suggestions, no Supply run
+// and no notifications.
+func TestGetHome(t *testing.T) {
+	t.Parallel()
+	h := newTestRouter(t, "dev")
+	loc, err := time.LoadLocation("America/New_York")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// want is the answer at instant now; the request is read between two
+	// instants, so it matches the answer at one of them.
+	want := func(now time.Time) string {
+		week := household.WeekStart(household.Today(now, loc))
+		label, err := household.WeekLabel(week)
+		if err != nil {
+			t.Fatal(err)
+		}
+		body, err := json.Marshal(map[string]any{
+			"dateLabel":      now.In(loc).Format("Monday, Jan 2"),
+			"tonight":        nil,
+			"sideQuestCount": 0,
+			"shoppingList":   map[string]any{"weekStart": week.String(), "label": label, "ready": false, "sentToChatAt": nil},
+			"recentUpdates":  map[string]any{"unread": false},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		return string(body)
+	}
+	before := time.Now()
+	rec, _ := serve(t, h, signedIn(http.MethodGet, "/api/v1/home", nil))
+	after := time.Now()
+	if rec.Code != http.StatusOK {
+		t.Fatalf("GET /api/v1/home = %d: %s", rec.Code, rec.Body)
+	}
+	var got any
+	if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	canonical, err := json.Marshal(got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(canonical) != want(before) && string(canonical) != want(after) {
+		t.Errorf("GET /api/v1/home = %s, want %s", canonical, want(after))
+	}
+}
+
+func TestGetHomeNeedsSession(t *testing.T) {
+	t.Parallel()
+	rec := httptest.NewRecorder()
+	newTestRouter(t, "dev").ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/v1/home", nil))
+	if rec.Code != http.StatusUnauthorized {
+		t.Errorf("GET /api/v1/home without a session = %d, want 401", rec.Code)
+	}
+}

internal/server/ideaactions_test.go

@@ -78,7 +78,7 @@ func newIdeaActionsRouter(t *testing.T, model, normalize *llm.Fake, search *reci
 		t.Fatal(err)
 	}
 	h, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t),
-		dinnerSvc, newTestSuggest(t), planSvc, newTestShopping(t), newTestGoogle(t), newTestPush(t), ideasSvc, runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		dinnerSvc, newTestSuggest(t), planSvc, newTestShopping(t), newTestGoogle(t), newTestPush(t), ideasSvc, newTestHome(t), runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/ideas_test.go

@@ -66,7 +66,7 @@ func newIdeasRouter(t *testing.T, model, normalize *llm.Fake, search *recipestes
 		t.Fatal(err)
 	}
 	h, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t),
-		newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), svc, runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), svc, newTestHome(t), runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/ideasource_test.go

@@ -0,0 +1,197 @@
+package server
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"reflect"
+	"strings"
+	"testing"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
+)
+
+// sourceCase is a recipe page an idea grounds in: its link and the site
+// name its page gives (empty for none, so the host is stored instead).
+type sourceCase struct {
+	dish, link, site string
+	// want is the idea's source_url and site_name; nil is null.
+	wantURL, wantSite any
+}
+
+const (
+	cleanSourceLink = "https://kitchen.example/recipes/chicken-curry"
+	queryToken      = "query-token-abc123"
+	queryHost       = "query-host-q1.example"
+	userinfoToken   = "user-token-def456"
+	userinfoHost    = "userinfo-host-u2.example"
+)
+
+// sourceCases are a clean link, credited by its page's name, and links
+// carrying a token in the query and the userinfo whose pages name no site,
+// so the stored name is the link's host.
+var sourceCases = []sourceCase{
+	{"Chicken Curry", cleanSourceLink, "Curry House", cleanSourceLink, "Curry House"},
+	{"Beef Stew", "https://" + queryHost + "/stew?access_token=" + queryToken, "", nil, nil},
+	{"Bean Chili", "https://" + userinfoToken + "@" + userinfoHost + "/chili", "", nil, nil},
+}
+
+// sourceSecrets are what no idea job response may contain.
+var sourceSecrets = []string{queryToken, "access_token", queryHost, userinfoToken, userinfoHost}
+
+// sourceFakes makes the search for each case's dish find its page and
+// scripts the normalize_recipe reply grounding it takes.
+func sourceFakes(t *testing.T, minutes int) (*llm.Fake, *llm.Fake, *recipestest.Search, *recipestest.Pages, *recipestest.Images) {
+	t.Helper()
+	model, normalize, search, pages, images := newQuickFakes()
+	for i, c := range sourceCases {
+		photo := fmt.Sprintf("https://img.example/%d.jpg", i)
+		search.Results[c.dish] = []recipes.Candidate{{URL: c.link}}
+		pages.Bodies[c.link] = recipestest.RecipePage(c.dish, c.site, photo, minutes)
+		images.JPEGs[photo] = recipestest.JPEG(t, 400, 320, uint8(i+1))
+		normalize.QueueGenerate(recipestest.NormalizedReply("stovetop", minutes))
+	}
+	return model, normalize, search, pages, images
+}
+
+// checkIdeaSources checks the finished job id: each idea shows its case's
+// safe source, and the response holds nothing of a token-bearing link.
+func checkIdeaSources(t *testing.T, h http.Handler, id string) {
+	t.Helper()
+	job := waitJob(t, h, id)
+	if job["status"] != "succeeded" {
+		t.Fatalf("GET job = %v", job)
+	}
+	rec, _ := callDinners(t, h, http.MethodGet, "/api/v1/jobs/"+id, "")
+	for _, secret := range sourceSecrets {
+		if strings.Contains(rec.Body.String(), secret) {
+			t.Errorf("job response contains %q: %s", secret, rec.Body)
+		}
+	}
+	list := job["result"].(map[string]any)["ideas"].([]any)
+	if len(list) != len(sourceCases) {
+		t.Fatalf("ideas = %v, want %d", list, len(sourceCases))
+	}
+	for i, c := range sourceCases {
+		idea := list[i].(map[string]any)
+		if idea["name"] != c.dish {
+			t.Fatalf("idea %d = %v, want %s", i, idea, c.dish)
+		}
+		for key, want := range map[string]any{"source_url": c.wantURL, "site_name": c.wantSite} {
+			got, ok := idea[key]
+			if !ok || !reflect.DeepEqual(got, want) {
+				t.Errorf("%s %s = %v (present %t), want %v", c.dish, key, got, ok, want)
+			}
+		}
+		if idea["recipe_id"] == "" || idea["photo_url"] == "" {
+			t.Errorf("idea %s = %v, want a recipe and photo", c.dish, idea)
+		}
+	}
+}
+
+// An ideas_from_ingredients job shows a clean link and its page's name,
+// and neither a token-bearing link nor a name taken from its host.
+func TestIdeasJobShowsOnlySafeSources(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := sourceFakes(t, 25)
+	list := make([]string, len(sourceCases))
+	for i, c := range sourceCases {
+		list[i] = fmt.Sprintf(`{"name":%q,"uses":["rice"],"missing":[],"est_minutes":25,"method":"stovetop","difficulty":"easy","search_query":%q}`, c.dish, c.dish)
+	}
+	js := `{"ideas":[` + strings.Join(list, ",") + `]}`
+	model.QueueGenerate(llm.GenerateResult{Response: llm.Response{Text: js, JSON: json.RawMessage(js)}})
+	h, _, _ := newIdeasRouter(t, model, normalize, search, pages, images, true)
+	checkIdeaSources(t, h, startIdeasJob(t, h))
+}
+
+// A quick_ideas job shows sources as an ideas_from_ingredients job does.
+func TestQuickJobShowsOnlySafeSources(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := sourceFakes(t, 25)
+	ideas := make([][3]any, len(sourceCases))
+	for i, c := range sourceCases {
+		ideas[i] = [3]any{c.dish, "stovetop", 20}
+	}
+	quickReply(model, ideas...)
+	h, _, _ := newIdeasRouter(t, model, normalize, search, pages, images, true)
+	rec, body := callDinners(t, h, http.MethodPost, quickPath, `{"kind": "under30", "exclude": []}`)
+	if rec.Code != http.StatusAccepted {
+		t.Fatalf("POST = %d: %s", rec.Code, rec.Body)
+	}
+	checkIdeaSources(t, h, body["jobId"].(string))
+}
+
+// legacyIdea is an idea as the result builders stored it before sources
+// were made safe: the grounded recipe's raw link and stored site name,
+// which is the link's host when its page named no site.
+func legacyIdea(name, link, site string) map[string]any {
+	return map[string]any{
+		"name": name, "method": "stovetop", "minutes_total": 25, "difficulty": "easy",
+		"recipe_id": "01JLEGACY" + strings.ToUpper(strings.ReplaceAll(name, " ", "")), "photo_url": "/api/v1/photos/legacy",
+		"source_url": link, "site_name": site,
+	}
+}
+
+// A job of either idea kind whose result was stored before sources were
+// made safe is served with the sources a job stored now holds: neither a
+// token-bearing link nor a name taken from its host.
+func TestJobServesLegacyIdeaResultsWithOnlySafeSources(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := newQuickFakes()
+	h, _, st := newIdeasRouter(t, model, normalize, search, pages, images, false)
+	legacy := []any{
+		legacyIdea("Chicken Curry", cleanSourceLink, "Curry House"),
+		legacyIdea("Beef Stew", "https://"+queryHost+"/stew?access_token="+queryToken, queryHost),
+		legacyIdea("Bean Chili", "https://"+userinfoToken+"@"+userinfoHost+"/chili", userinfoHost),
+	}
+	for kind, result := range map[string]map[string]any{
+		ideas.KindFromIngredients: {"stage": "done", "ingredients": []string{"rice"}, "quick_only": false, "ideas": legacy, "dropped": 0},
+		ideas.KindQuick:           {"stage": "done", "kind": "under30", "exclude": []string{}, "ideas": legacy, "dropped": 0},
+	} {
+		js, err := json.Marshal(result)
+		if err != nil {
+			t.Fatal(err)
+		}
+		id := "legacy-" + kind
+		if _, err := st.Writer.ExecContext(t.Context(),
+			`INSERT INTO jobs (id, kind, status, payload, result, created_at, updated_at) VALUES (?, ?, 'succeeded', '{}', ?, '2026-10-01T00:00:00Z', '2026-10-01T00:00:00Z')`,
+			id, kind, string(js)); err != nil {
+			t.Fatal(err)
+		}
+		checkIdeaSources(t, h, id)
+	}
+}
+
+// An idea job whose grounded recipe's stored link does not parse fails,
+// even when no site name is stored, rather than show the idea without a
+// source.
+func TestIdeaJobFailsOnUnparseableSourceWithoutSiteName(t *testing.T) {
+	t.Parallel()
+	const badLink = "https://kitchen.example/%zz"
+	model, normalize, search, pages, images := sourceFakes(t, 25)
+	idea := fmt.Sprintf(`{"name":%q,"uses":["rice"],"missing":[],"est_minutes":25,"method":"stovetop","difficulty":"easy","search_query":%q}`, sourceCases[0].dish, sourceCases[0].dish)
+	js := `{"ideas":[` + idea + `]}`
+	for range 2 {
+		model.QueueGenerate(llm.GenerateResult{Response: llm.Response{Text: js, JSON: json.RawMessage(js)}})
+	}
+	h, _, st := newIdeasRouter(t, model, normalize, search, pages, images, true)
+	if job := waitJob(t, h, startIdeasJob(t, h)); job["status"] != "succeeded" {
+		t.Fatalf("grounding job = %v", job)
+	}
+	// The recipe is now stored under badLink with no site name, and the
+	// search finds it there.
+	res, err := st.Writer.ExecContext(t.Context(), `UPDATE recipes SET source_url = ?, site_name = NULL WHERE source_url = ?`, badLink, cleanSourceLink)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n, err := res.RowsAffected(); err != nil || n != 1 {
+		t.Fatalf("updated %d recipes (%v), want 1", n, err)
+	}
+	search.Results[sourceCases[0].dish] = []recipes.Candidate{{URL: badLink}}
+	job := waitJob(t, h, startIdeasJob(t, h))
+	assertFailedWithoutIdeas(t, job, jobs.CodeInternal)
+}

internal/server/login_test.go

@@ -83,7 +83,7 @@ func newLoginRouter(t *testing.T, issuer string) http.Handler {
 		t.Fatal(err)
 	}
 	r, err := NewRouter(logger, "dev", trusted, flow, sessions, newTestSettings(t),
-		newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/media_test.go

@@ -51,7 +51,7 @@ func newMediaRouter(t *testing.T) (r http.Handler, id, orphan string) {
 		t.Fatal(err)
 	}
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	r, err = NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t),
+	r, err = NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t),
 		photos, fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)

internal/server/origin_test.go

@@ -45,7 +45,7 @@ func newOriginRouter(t *testing.T, logs io.Writer) http.Handler {
 	}
 	logger := slog.New(forwarded.LogHandler(slog.NewJSONHandler(logs, nil)))
 	r, err := NewRouter(logger, "dev", trusted, probeAuth{}, stubSessions{}, newTestSettings(t),
-		newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/plans_test.go

@@ -107,7 +107,7 @@ func newPlansRouterTitled(t *testing.T, title shopping.Titler) plansEnv {
 		t.Fatal(err)
 	}
 	h, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), chatSvc,
-		newTestDinners(t), newTestSuggest(t), svc, shop, googleSvc, newTestPush(t), newTestIdeas(t), runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		newTestDinners(t), newTestSuggest(t), svc, shop, googleSvc, newTestPush(t), newTestIdeas(t), newTestHome(t), runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/push_test.go

@@ -55,7 +55,7 @@ func newTestPushWith(t *testing.T) (*push.Service, *store.Store, vapid.KeyPair)
 func newPushRouter(t *testing.T, svc *push.Service) http.Handler {
 	t.Helper()
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	r, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), svc, newTestIdeas(t), newTestRunner(t),
+	r, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), svc, newTestIdeas(t), newTestHome(t), newTestRunner(t),
 		newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
@@ -103,7 +103,7 @@ func TestNewRouterRequiresPush(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), nil, newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), nil, newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil push service")
 	}
 }

internal/server/recipesearch_test.go

@@ -22,7 +22,7 @@ const (
 func newRecipeSearchRouter(t *testing.T, search *recipes.SearchSettingsService) http.Handler {
 	t.Helper()
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	r, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), search, newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t),
+	r, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), search, newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t),
 		newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)

internal/server/server.go

@@ -16,6 +16,7 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/forwarded"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/frontend"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/home"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
@@ -66,12 +67,12 @@ type RouteMounter interface {
 // /api/v1/settings/notifications/test-push; ideasSvc serves POST
 // /api/v1/ideas/from-ingredients and POST /api/v1/ideas/quick, and with
 // dinnerSvc POST /api/v1/ideas/{jobId}/items/{i}/quest-log and, with
-// planSvc too, /cook-tonight; runner serves
+// planSvc too, /cook-tonight; homeSvc serves GET /api/v1/home; runner serves
 // POST /api/v1/jobs and GET /api/v1/jobs/{id}; photos serves
 // GET /media/photos/{id}-{size}.jpg; assets is the web build
 // served for every other GET. /health, /auth and the web build are public.
 // Requests to /api/v1 other than GET also need the session's CSRF token in CSRFHeader.
-func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, auth RouteMounter, sessions SessionLookup, settings *household.SettingsService, search *recipes.SearchSettingsService, ai *aisettings.Service, chatSvc *chat.Service, dinnerSvc *dinners.Service, suggestSvc *suggest.Service, planSvc *plan.Service, shopSvc *shopping.Service, googleSvc *gcal.Service, pushSvc *push.Service, ideasSvc *ideas.Service, runner *jobs.Runner, photos PhotoFiles, assets fs.FS) (http.Handler, error) {
+func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, auth RouteMounter, sessions SessionLookup, settings *household.SettingsService, search *recipes.SearchSettingsService, ai *aisettings.Service, chatSvc *chat.Service, dinnerSvc *dinners.Service, suggestSvc *suggest.Service, planSvc *plan.Service, shopSvc *shopping.Service, googleSvc *gcal.Service, pushSvc *push.Service, ideasSvc *ideas.Service, homeSvc *home.Service, runner *jobs.Runner, photos PhotoFiles, assets fs.FS) (http.Handler, error) {
 	if settings == nil {
 		return nil, errors.New("server: nil household settings service")
 	}
@@ -105,6 +106,9 @@ func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, a
 	if ideasSvc == nil {
 		return nil, errors.New("server: nil ideas service")
 	}
+	if homeSvc == nil {
+		return nil, errors.New("server: nil home service")
+	}
 	if runner == nil {
 		return nil, errors.New("server: nil job runner")
 	}
@@ -137,6 +141,7 @@ func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, a
 		sub.NotFound(notFound)
 	}
 	apiV1.Get("/me", me(logger))
+	apiV1.Get("/home", getHome(logger, homeSvc))
 	apiV1.Get("/settings/household", getHouseholdSettings(logger, settings))
 	apiV1.Patch("/settings/household", patchHouseholdSettings(logger, settings))
 	apiV1.Get("/settings/notifications", getNotificationSettings(logger, settings))

internal/server/server_test.go

@@ -22,8 +22,10 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/aisettings"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/chat"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/home"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
@@ -56,7 +58,7 @@ func newTestRouterWith(t *testing.T, version string, settings *household.Setting
 		"index.html":             {Data: []byte(fixtureIndex)},
 		"assets/index-AbC123.js": {Data: []byte(fixtureAsset)},
 	}
-	r, err := NewRouter(logger, version, nil, stubAuth{}, stubSessions{}, settings, newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), runner, newTestPhotos(t), assets)
+	r, err := NewRouter(logger, version, nil, stubAuth{}, stubSessions{}, settings, newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), runner, newTestPhotos(t), assets)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -257,6 +259,65 @@ func newTestShopping(t *testing.T) *shopping.Service {
 	return svc
 }
 
+// newTestHome returns a home service whose services all share one
+// migrated temp database with zone America/New_York, with an unstarted job
+// runner, no model, and Google and Google Chat endpoints that refuse every
+// connection. One database keeps the routers that never ask for Home cheap.
+func newTestHome(t *testing.T) *home.Service {
+	t.Helper()
+	st := newTestStore(t)
+	if err := household.SeedSettings(context.Background(), st, "America/New_York"); err != nil {
+		t.Fatal(err)
+	}
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	runner, err := jobs.NewRunner(st, logger, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	notifier := notifytest.New(t, st)
+	draft := func(context.Context, string, skills.WeekRequest) (skills.Week, error) {
+		return skills.Week{}, errors.New("no model in this test")
+	}
+	pub := &url.URL{Scheme: "https", Host: "mealquest.example"}
+	googleSvc, err := gcal.NewService(st, newTestBox(t), gcal.Config{
+		ClientID:     "client-id",
+		ClientSecret: "client-secret",
+		PublicURL:    pub,
+		SecretKey:    []byte("server-secret-key"),
+		Endpoint:     oauth2.Endpoint{AuthURL: "http://127.0.0.1:1/auth", TokenURL: "http://127.0.0.1:1/token"},
+		RevokeURL:    "http://127.0.0.1:1/revoke",
+		CalendarAPI:  "http://127.0.0.1:1/calendar/v3",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	planSvc, err := plan.NewService(st, draft, runner, googleSvc, notifier, pub, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := recipestest.NewGrounder(t, st, t.TempDir(), &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, &llm.Fake{})
+	sideQuests := func(context.Context, string, skills.SideQuestsRequest) (skills.SideQuests, error) {
+		return skills.SideQuests{}, errors.New("no model in this test")
+	}
+	suggestSvc, err := suggest.NewService(st, g, sideQuests, runner, notifier, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	chatSvc, err := chat.NewService(st, newTestBox(t), pub, refuseTransport{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	shop, err := shopping.NewService(st, untitled, runner, notifier, chatSvc, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	svc, err := home.NewService(household.NewSettingsService(st), planSvc, suggestSvc, shop, notifier)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return svc
+}
+
 // untitled is a shopping.Titler with no model: every Supply run it is
 // asked to title stays untitled.
 func untitled(context.Context, string, skills.ArchiveTitleRequest) (skills.ArchiveTitle, error) {
@@ -317,7 +378,7 @@ func TestNewRouterRequiresAISettings(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), nil, newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), nil, newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil AI settings service")
 	}
 }
@@ -326,7 +387,7 @@ func TestNewRouterRequiresSearchSettings(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), nil, newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), nil, newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil recipe search settings service")
 	}
 }
@@ -335,7 +396,7 @@ func TestNewRouterRequiresPhotoFiles(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), nil, fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), nil, fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted nil photo files")
 	}
 }
@@ -344,7 +405,7 @@ func TestNewRouterRequiresSettings(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, nil, newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, nil, newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil settings service")
 	}
 }
@@ -353,7 +414,7 @@ func TestNewRouterRequiresDinners(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), nil, newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), nil, newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil dinners service")
 	}
 }
@@ -362,7 +423,7 @@ func TestNewRouterRequiresSuggestions(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), nil, newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), nil, newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil suggestions service")
 	}
 }
@@ -371,7 +432,7 @@ func TestNewRouterRequiresPlan(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), nil, newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), nil, newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil plan service")
 	}
 }
@@ -380,7 +441,7 @@ func TestNewRouterRequiresShopping(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), nil, newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), nil, newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil shopping service")
 	}
 }
@@ -389,16 +450,25 @@ func TestNewRouterRequiresIdeas(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), nil, newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), nil, newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil ideas service")
 	}
 }
 
+func TestNewRouterRequiresHome(t *testing.T) {
+	t.Parallel()
+
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), nil, newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+		t.Fatal("NewRouter accepted a nil home service")
+	}
+}
+
 func TestNewRouterRequiresGoogle(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), nil, newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), nil, newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil Google Calendar service")
 	}
 }
@@ -407,7 +477,7 @@ func TestNewRouterRequiresJobRunner(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), nil, newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), nil, newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil job runner")
 	}
 }

internal/server/settings_test.go

@@ -277,7 +277,7 @@ func TestHouseholdSettingsWithRealSession(t *testing.T) {
 	}
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	router, err := NewRouter(logger, "dev", nil, stubAuth{}, sessions, household.NewSettingsService(st),
-		newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		newTestSearch(t), newTestAI(t), newTestChat(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/suggestions_test.go

@@ -46,7 +46,7 @@ func newSuggestionsRouter(t *testing.T, names ...string) (http.Handler, *store.S
 		t.Fatal(err)
 	}
 	h, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestChat(t),
-		newTestDinners(t), svc, newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+		newTestDinners(t), svc, newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestPush(t), newTestIdeas(t), newTestHome(t), runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/suggest/batch.go

@@ -22,9 +22,6 @@ import (
 // BatchJob is the KindSuggestionBatch payload: the batch to run.
 type BatchJob struct {
 	BatchID string `json:"batch_id"`
-	// Week is the YYYY-MM-DD Monday of the ISO week a scheduled batch is
-	// for, which keys its new_suggestions; empty for any other trigger.
-	Week string `json:"week,omitempty"`
 }
 
 // Batch stages, as the job's result reports them.
@@ -53,22 +50,19 @@ func (r batchResult) PublicJSON() ([]byte, error) { return json.Marshal(r) }
 // wanted at a time, until BatchSize are kept or none are left. A Side quest
 // no recipe grounds is dropped; any other grounding failure fails the
 // batch, as does suggest_side_quests failing, with no Side quest made up
-// instead. The batch ends done or failed. When recording the batch's end
-// fails, so does the job; when it times out at shutdown, the job is left
-// running and the batch with it, for the next start to fail.
+// instead. Each round's grounded Side quests are stored before the next
+// round starts, so the deck fills as the batch goes. The batch ends done
+// or failed; Side quests stored before a failure stay in the deck. When
+// recording the batch's end fails, so does the job; when it times out at
+// shutdown, the job is left running and the batch with it, for the next
+// start to fail.
 //
-// When a batch stores its Side quests depends on whether it notifies (see
-// noticeOf). A scheduled or manual batch notifies: it holds every round's
-// grounded Side quests and, once the last round is done, stores them all
-// in one transaction with one new_suggestions counting and naming every
-// Side quest stored. So the household is told of exactly what the batch
-// added, once; and a batch that fails at any round, including a later
-// round's normalize_recipe, stores nothing and sends nothing, leaving no
-// Side quest in the deck that was never announced. A replenish batch,
-// which tops up the deck as the household swipes and never notifies,
-// stores each round's Side quests before the next round starts, so the
-// deck fills as it goes; those stored before a failure stay in the deck.
-// See store.
+// A scheduled or manual batch emits new_suggestions, keyed by the batch,
+// in the transaction that first adds Side quests to the deck, so the
+// household is told of every Side quest stored, whether or not the batch
+// then ends done: a later round, or recording the batch's end, may fail.
+// A replenish batch, which tops up the deck as the household swipes, never
+// notifies. See store.
 func (s *Service) runBatch(ctx context.Context, p BatchJob, publish func(batchResult) error) (batchResult, error) {
 	batch, err := db.New(s.st.Reader).GetSuggestionBatch(ctx, p.BatchID)
 	if err != nil {
@@ -84,7 +78,7 @@ func (s *Service) runBatch(ctx context.Context, p BatchJob, publish func(batchRe
 	if n == 0 {
 		return batchResult{}, fmt.Errorf("suggest: batch %s is not pending", p.BatchID)
 	}
-	res, err := s.fill(ctx, batch.Trigger, p, publish)
+	res, err := s.fill(ctx, p.BatchID, batch.Trigger != TriggerReplenish, publish)
 	if err == nil {
 		if err := s.finishBatch(ctx, p.BatchID, BatchDone); err != nil {
 			return batchResult{}, err
@@ -104,12 +98,10 @@ func (s *Service) runBatch(ctx context.Context, p BatchJob, publish func(batchRe
 	return batchResult{}, errors.Join(err, finishErr)
 }
 
-// fill does runBatch's work for job of a batch with trigger, returning a
-// *jobs.Failure for a failure the household may see. A batch with a notice
-// is stored once, when its last round is done; any other batch round by
-// round.
-func (s *Service) fill(ctx context.Context, trigger string, job BatchJob, publish func(batchResult) error) (batchResult, error) {
-	batchID := job.BatchID
+// fill does runBatch's work, returning a *jobs.Failure for a failure the
+// household may see. When notifies is true, store emits new_suggestions
+// with the Side quests it adds.
+func (s *Service) fill(ctx context.Context, batchID string, notifies bool, publish func(batchResult) error) (batchResult, error) {
 	res := batchResult{BatchID: batchID, Stage: StageSuggesting, SuggestionIDs: []string{}}
 	if err := publish(res); err != nil {
 		return batchResult{}, err
@@ -118,10 +110,6 @@ func (s *Service) fill(ctx context.Context, trigger string, job BatchJob, publis
 	if err != nil {
 		return batchResult{}, err
 	}
-	note, err := noticeOf(trigger, job, in.Context.Today)
-	if err != nil {
-		return batchResult{}, err
-	}
 	out, err := s.suggest(ctx, batchID, in)
 	if err != nil {
 		if ctx.Err() != nil {
@@ -134,81 +122,34 @@ func (s *Service) fill(ctx context.Context, trigger string, job BatchJob, publis
 	if err := publish(res); err != nil {
 		return batchResult{}, err
 	}
+	var week *store.LocalDate
+	if notifies {
+		w := household.WeekStart(in.Context.Today)
+		week = &w
+	}
 	left := out.Suggestions
-	// held are a notifying batch's grounded Side quests, not yet stored.
-	var held []groundedQuest
-	for len(res.SuggestionIDs)+len(held) < BatchSize && len(left) > 0 {
-		round := left[:min(BatchSize-len(res.SuggestionIDs)-len(held), len(left))]
+	for len(res.SuggestionIDs) < BatchSize && len(left) > 0 {
+		round := left[:min(BatchSize-len(res.SuggestionIDs), len(left))]
 		left = left[len(round):]
 		grounded, err := s.ground(ctx, round)
 		if err != nil {
 			return batchResult{}, err
 		}
 		res.Dropped += len(round) - len(grounded)
-		if note != nil {
-			held = append(held, grounded...)
-		} else if err := s.storeInto(ctx, &res, nil, grounded); err != nil {
+		ids, err := s.store(ctx, batchID, week, grounded)
+		if err != nil {
 			return batchResult{}, err
 		}
+		res.Dropped += len(grounded) - len(ids)
+		res.SuggestionIDs = append(res.SuggestionIDs, ids...)
 		if err := publish(res); err != nil {
 			return batchResult{}, err
 		}
 	}
-	if note != nil {
-		if err := s.storeInto(ctx, &res, note, held); err != nil {
-			return batchResult{}, err
-		}
-	}
 	res.Stage = StageDone
 	return res, nil
 }
 
-// storeInto stores quests for res's batch with note (see store) and adds
-// the suggestions stored, and the Side quests left out, to res.
-func (s *Service) storeInto(ctx context.Context, res *batchResult, note *notice, quests []groundedQuest) error {
-	ids, err := s.store(ctx, res.BatchID, note, quests)
-	if err != nil {
-		return err
-	}
-	res.Dropped += len(quests) - len(ids)
-	res.SuggestionIDs = append(res.SuggestionIDs, ids...)
-	return nil
-}
-
-// notice is how a batch's new_suggestions is keyed: by id, as
-// new_suggestions:{id}, for the week starting on week.
-type notice struct {
-	id   string
-	week store.LocalDate
-}
-
-// noticeOf returns the notice of job, run for a batch with trigger on
-// household-local date today, or nil for a replenish batch, which never
-// notifies. A scheduled batch is keyed by the ISO week it was scheduled
-// for ("2026-W41"), not the week it happens to run in, so each week's
-// schedule tells the household once even when its batch runs late; a
-// manual batch is keyed by its batch id, for the week of today. A job
-// whose week does not fit its trigger is an error.
-func noticeOf(trigger string, job BatchJob, today store.LocalDate) (*notice, error) {
-	if trigger != TriggerScheduled {
-		if job.Week != "" {
-			return nil, fmt.Errorf("suggest: %s batch %s has a week", trigger, job.BatchID)
-		}
-		if trigger == TriggerReplenish {
-			return nil, nil
-		}
-		return &notice{id: job.BatchID, week: household.WeekStart(today)}, nil
-	}
-	week, err := store.ParseLocalDate(job.Week)
-	if err != nil {
-		return nil, fmt.Errorf("suggest: scheduled batch %s week: %w", job.BatchID, err)
-	}
-	if household.WeekStart(week) != week {
-		return nil, fmt.Errorf("suggest: scheduled batch %s week %s is not a Monday", job.BatchID, week)
-	}
-	return &notice{id: household.PeriodKey(week), week: week}, nil
-}
-
 // request reads what suggest_side_quests is given: the household context,
 // the deck's names and every passed name (ListPassedNames). A household with no Regulars
 // fails with ReasonNoRegulars.
@@ -283,14 +224,13 @@ func (s *Service) ground(ctx context.Context, quests []skills.SideQuest) ([]grou
 // or archived. Passed names are read in the same transaction as the store,
 // so a Pass or drop committed before it is never missed.
 //
-// When note is not nil and a Side quest is stored, new_suggestions keyed by
-// note, counting and naming those stored, is emitted in the same
-// transaction, so the Side quests and their notification commit together
+// When week is not nil and a Side quest is stored, new_suggestions:{batchID}
+// naming those stored is emitted in the same transaction, for the week
+// starting week, so the Side quests and their notification commit together
 // or not at all: a notification that cannot be stored fails the store, and
-// the batch with it. A notifying batch calls store once, with all its
-// Side quests, so the count is the batch's (see runBatch). This is the
-// only place new_suggestions is emitted.
-func (s *Service) store(ctx context.Context, batchID string, note *notice, quests []groundedQuest) ([]string, error) {
+// the batch with it. The event's key makes the first round to store Side
+// quests the one that notifies; a later round's emit stores nothing.
+func (s *Service) store(ctx context.Context, batchID string, week *store.LocalDate, quests []groundedQuest) ([]string, error) {
 	ids := []string{}
 	var stored []string
 	err := s.st.WithTx(ctx, func(tx *sql.Tx) error {
@@ -358,15 +298,15 @@ func (s *Service) store(ctx context.Context, batchID string, note *notice, quest
 			ids = append(ids, id)
 			stored = append(stored, d.Name)
 		}
-		if note == nil || len(stored) == 0 {
+		if week == nil || len(stored) == 0 {
 			return nil
 		}
-		return s.notifier.EmitTx(ctx, tx, chat.NewSuggestions(note.id, note.week, stored))
+		return s.notifier.EmitTx(ctx, tx, chat.NewSuggestions(batchID, *week, stored))
 	})
 	if err != nil {
 		return nil, err
 	}
-	if note != nil && len(stored) > 0 {
+	if week != nil && len(stored) > 0 {
 		s.notifier.Wake()
 	}
 	return ids, nil

internal/suggest/schedule.go

@@ -1,36 +0,0 @@
-package suggest
-
-import (
-	"context"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
-)
-
-// WeeklySchedule is the suggestions_weekly schedule: at the household's
-// suggestions_dow and suggestions_time it starts a scheduled batch for the
-// ISO week of the fire date, its period scheduler.Weekly keys
-// suggestions_weekly:YYYY-Www. The batch tells the household of the Side
-// quests it adds with new_suggestions:YYYY-Www for that week, once; a batch
-// that fails before adding any, as when the AI fails, sends nothing. When a
-// batch is already pending or running the period starts none, and says so.
-func (s *Service) WeeklySchedule() scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.SuggestionsWeekly,
-		Rule: func(settings household.Settings) scheduler.Rule {
-			return scheduler.Weekly(time.Weekday(settings.SuggestionsDow), settings.SuggestionsTime)
-		},
-		Run: func(ctx context.Context, p scheduler.Period) error {
-			b, err := s.StartScheduledBatch(ctx, p.Week)
-			if err != nil {
-				return err
-			}
-			if !b.Created {
-				s.logger.WarnContext(ctx, "scheduled suggestion batch not started: a batch is already under way",
-					"period", p.Key, "batch_id", b.ID, "trigger", b.Trigger)
-			}
-			return nil
-		},
-	}
-}

internal/suggest/suggest.go

@@ -19,7 +19,6 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
@@ -155,35 +154,17 @@ type Batch struct {
 	Created bool `json:"-"`
 }
 
-// StartBatch creates a manual or replenish batch and enqueues the
+// StartBatch creates a batch with trigger and enqueues the
 // KindSuggestionBatch job that runs it, unless a batch is already pending
-// or running, which it returns instead with Created false. A scheduled
-// batch is started by StartScheduledBatch.
+// or running, which it returns instead with Created false.
 func (s *Service) StartBatch(ctx context.Context, trigger string) (Batch, error) {
-	if trigger == TriggerScheduled {
-		return Batch{}, errors.New("suggest: a scheduled batch is started by StartScheduledBatch")
-	}
 	if !slices.Contains(triggers, trigger) {
 		return Batch{}, fmt.Errorf("suggest: unknown batch trigger %q", trigger)
 	}
-	return s.start(ctx, trigger, "")
-}
-
-// StartScheduledBatch is StartBatch for a scheduled batch for the ISO week
-// starting on Monday week, which keys its new_suggestions (see noticeOf).
-func (s *Service) StartScheduledBatch(ctx context.Context, week store.LocalDate) (Batch, error) {
-	if week.IsZero() || household.WeekStart(week) != week {
-		return Batch{}, fmt.Errorf("suggest: scheduled batch week %s is not a Monday", week)
-	}
-	return s.start(ctx, TriggerScheduled, week.String())
-}
-
-// start does StartBatch's work for a batch with trigger and the job week.
-func (s *Service) start(ctx context.Context, trigger, week string) (Batch, error) {
 	var b Batch
 	err := s.st.WithTx(ctx, func(tx *sql.Tx) error {
 		var err error
-		b, err = s.startBatch(ctx, tx, trigger, week)
+		b, err = s.startBatch(ctx, tx, trigger)
 		return err
 	})
 	if err != nil {
@@ -247,11 +228,10 @@ func failedBatch(ctx context.Context, q *db.Queries) (*Batch, error) {
 	return &Batch{ID: cur.ID, JobID: jobID, Trigger: cur.Trigger, Status: cur.Status}, nil
 }
 
-// startBatch does StartBatch's work in tx, for a batch with trigger whose
-// job has week (BatchJob.Week): the batch and the job that runs it are
-// committed together, so a batch is never seen without its job. The caller
-// wakes the job runner once tx has committed and Created is true.
-func (s *Service) startBatch(ctx context.Context, tx *sql.Tx, trigger, week string) (Batch, error) {
+// startBatch does StartBatch's work in tx: the batch and the job that runs
+// it are committed together, so a batch is never seen without its job. The
+// caller wakes the job runner once tx has committed and Created is true.
+func (s *Service) startBatch(ctx context.Context, tx *sql.Tx, trigger string) (Batch, error) {
 	q := db.New(tx)
 	cur, err := s.activeBatch(ctx, q)
 	if err != nil {
@@ -270,7 +250,7 @@ func (s *Service) startBatch(ctx context.Context, tx *sql.Tx, trigger, week stri
 	if err != nil {
 		return Batch{}, fmt.Errorf("suggest: create batch: %w", err)
 	}
-	jobID, err := s.batchJob.EnqueueTx(ctx, tx, BatchJob{BatchID: row.ID, Week: week})
+	jobID, err := s.batchJob.EnqueueTx(ctx, tx, BatchJob{BatchID: row.ID})
 	if err != nil {
 		return Batch{}, fmt.Errorf("suggest: enqueue batch %s: %w", row.ID, err)
 	}
@@ -448,7 +428,7 @@ func (s *Service) decide(ctx context.Context, id, decision, dinnerStatus, update
 		if left >= ReplenishBelow {
 			return nil
 		}
-		b, err := s.startBatch(ctx, tx, TriggerReplenish, "")
+		b, err := s.startBatch(ctx, tx, TriggerReplenish)
 		if err != nil {
 			return err
 		}

internal/suggest/suggest_test.go

@@ -300,45 +300,6 @@ func (e *env) runBatch(t *testing.T) batchResult {
 	return res
 }
 
-// scheduledWeek is the week the tests' scheduled batches are for: the
-// Monday of 2026-W41.
-var scheduledWeek = mustDate("2026-10-05")
-
-func mustDate(s string) store.LocalDate {
-	d, err := store.ParseLocalDate(s)
-	if err != nil {
-		panic(err)
-	}
-	return d
-}
-
-func mustZone(t *testing.T, name string) *time.Location {
-	t.Helper()
-	loc, err := household.LoadZone(name)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return loc
-}
-
-// startBatch starts a batch with trigger, a scheduled one for
-// scheduledWeek, and returns it with the key its new_suggestions has.
-func (e *env) startBatch(t *testing.T, trigger string) (suggest.Batch, string) {
-	t.Helper()
-	if trigger == suggest.TriggerScheduled {
-		b, err := e.svc.StartScheduledBatch(t.Context(), scheduledWeek)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return b, "new_suggestions:2026-W41"
-	}
-	b, err := e.svc.StartBatch(t.Context(), trigger)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return b, "new_suggestions:" + b.ID
-}
-
 func (e *env) batchStatus(t *testing.T, id string) string {
 	t.Helper()
 	var status string
@@ -443,9 +404,8 @@ func TestBatchStoresGroundedSideQuests(t *testing.T) {
 }
 
 // TestBatchEmitsNewSuggestions: a scheduled or manual batch that adds Side
-// quests stores new_suggestions counting and naming them, keyed by the
-// scheduled ISO week or the manual batch, for that week or the current
-// one; a replenish batch, or one that adds none, stores nothing.
+// quests stores new_suggestions keyed by the batch, naming them; a
+// replenish batch, or one that adds none, stores nothing.
 func TestBatchEmitsNewSuggestions(t *testing.T) {
 	for _, tc := range []struct {
 		trigger string
@@ -468,7 +428,10 @@ func TestBatchEmitsNewSuggestions(t *testing.T) {
 				sideQuest("Chicken Shawarma Bowls", "Spiced chicken, like your Chicken Fajitas.", "Chicken Fajitas"),
 				sideQuest("Chili Verde", "Your Beef Chili gone green.", "Beef Chili"),
 			)
-			b, key := e.startBatch(t, tc.trigger)
+			b, err := e.svc.StartBatch(t.Context(), tc.trigger)
+			if err != nil {
+				t.Fatal(err)
+			}
 			if job := e.waitJob(t, b.JobID); job.Status != jobs.StatusSucceeded {
 				t.Fatalf("batch job %s", job.Status)
 			}
@@ -483,70 +446,64 @@ func TestBatchEmitsNewSuggestions(t *testing.T) {
 				t.Fatalf("new_suggestions rows = %+v, want one on push", rows)
 			}
 			r := rows[0]
-			week := household.WeekStart(store.LocalDateOf(time.Now().In(mustZone(t, "America/New_York")))).String()
-			if tc.trigger == suggest.TriggerScheduled {
-				week = scheduledWeek.String()
-			}
-			if r.Key != key || r.Channel != notify.ChannelPush || r.Payload.URL != "/discover" ||
-				r.Payload.Title != "2 new Side quests are in" || r.Payload.Body != "Chicken Shawarma Bowls, Chili Verde" || r.Payload.Week != week {
-				t.Errorf("new_suggestions row = %+v, want key %s counting and naming the Side quests, week %s, /discover", r, key, week)
+			if r.Key != "new_suggestions:"+b.ID || r.Channel != notify.ChannelPush || r.Payload.URL != "/discover" ||
+				r.Payload.Title != "New Side quests are in" || r.Payload.Body != "Chicken Shawarma Bowls, Chili Verde" || r.Payload.Week == "" {
+				t.Errorf("new_suggestions row = %+v, want key new_suggestions:%s naming the Side quests, /discover", r, b.ID)
 			}
 		})
 	}
 }
 
-// twoRoundBatch scripts a suggest_side_quests reply of BatchSize+1 Side
-// quests, Fajita Dish A to F, whose first round grounds all but B, so a
-// second round grounds F. Unless lastGrounds, normalize_recipe fails for
-// F.
-func (e *env) twoRoundBatch(t *testing.T, lastGrounds bool) {
-	t.Helper()
-	var quests []string
-	for i := range suggest.BatchSize + 1 {
-		name := fmt.Sprintf("Fajita Dish %c", 'A'+i)
-		e.search.Results[name] = nil
-		switch {
-		case i == suggest.BatchSize && !lastGrounds:
-			// A page is found, but no normalize_recipe reply is scripted
-			// for it, so the AI call grounding it fails.
-			slug := strings.ReplaceAll(strings.ToLower(name), " ", "-")
-			page, photo := "https://r.example/"+slug, "https://r.example/"+slug+".jpg"
-			e.search.Results[name] = []recipes.Candidate{{URL: page}}
-			e.pages.Bodies[page] = recipestest.RecipePage(name, "R Kitchen", photo, 35)
-			e.images.JPEGs[photo] = recipestest.JPEG(t, 400, 320, uint8(len(e.images.JPEGs)+1))
-		case i != 1:
-			e.recipe(t, name)
-		}
-		quests = append(quests, sideQuest(name, "Like your Chicken Fajitas.", "Chicken Fajitas"))
-	}
-	e.reply(quests...)
-}
-
-// TestBatchNotifiesOnceWithEverySideQuestStored: a batch that fills across
-// two grounding rounds stores new_suggestions once, when it completes,
-// counting and naming every Side quest it stored, not just the first
-// round's; a replenish batch notifies nothing.
-func TestBatchNotifiesOnceWithEverySideQuestStored(t *testing.T) {
+// TestBatchNotifiesAsSideQuestsAreStored: new_suggestions is stored with
+// the first round to add Side quests, so a batch whose later round fails
+// still tells the household of those in the deck, once; a later round that
+// succeeds adds no second notification; a replenish batch notifies nothing.
+func TestBatchNotifiesAsSideQuestsAreStored(t *testing.T) {
 	for _, tc := range []struct {
-		trigger string
-		notify  bool
+		trigger   string
+		lastFails bool
+		notify    bool
 	}{
-		{suggest.TriggerScheduled, true},
-		{suggest.TriggerManual, true},
-		{suggest.TriggerReplenish, false},
+		{suggest.TriggerScheduled, true, true},
+		{suggest.TriggerManual, true, true},
+		{suggest.TriggerManual, false, true},
+		{suggest.TriggerReplenish, true, false},
 	} {
-		t.Run(tc.trigger, func(t *testing.T) {
+		t.Run(fmt.Sprintf("%s last round fails %v", tc.trigger, tc.lastFails), func(t *testing.T) {
 			e := newEnv(t)
 			e.start(t)
-			e.twoRoundBatch(t, true)
-
-			b, key := e.startBatch(t, tc.trigger)
-			if job := e.waitJob(t, b.JobID); job.Status != jobs.StatusSucceeded {
-				t.Fatalf("batch job %s, want succeeded", job.Status)
+			// The first round grounds BatchSize Side quests but B; the
+			// second round grounds F.
+			var quests []string
+			for i := range suggest.BatchSize + 1 {
+				name := fmt.Sprintf("Fajita Dish %c", 'A'+i)
+				e.search.Results[name] = nil
+				if i != 1 {
+					e.recipe(t, name)
+				}
+				quests = append(quests, sideQuest(name, "Like your Chicken Fajitas.", "Chicken Fajitas"))
 			}
-			deck := e.deckNames(t)
-			if want := []string{"Fajita Dish A", "Fajita Dish C", "Fajita Dish D", "Fajita Dish E", "Fajita Dish F"}; !slices.Equal(deck, want) {
-				t.Fatalf("deck = %v, want %v", deck, want)
+			e.reply(quests...)
+			if tc.lastFails {
+				if _, err := e.st.Writer.ExecContext(t.Context(), `CREATE TRIGGER refuse_f BEFORE INSERT ON dinners WHEN NEW.name = 'Fajita Dish F' BEGIN SELECT RAISE(ABORT, 'F refused'); END`); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			b, err := e.svc.StartBatch(t.Context(), tc.trigger)
+			if err != nil {
+				t.Fatal(err)
+			}
+			job := e.waitJob(t, b.JobID)
+			want, deck := jobs.StatusSucceeded, suggest.BatchSize
+			if tc.lastFails {
+				want, deck = jobs.StatusFailed, suggest.BatchSize-1
+			}
+			if job.Status != want {
+				t.Fatalf("batch job %s, want %s", job.Status, want)
+			}
+			if got := e.deckNames(t); len(got) != deck {
+				t.Fatalf("deck = %v, want %d Side quests", got, deck)
 			}
 			rows := notifytest.Rows(t, e.st, notify.NewSuggestions)
 			if !tc.notify {
@@ -555,47 +512,9 @@ func TestBatchNotifiesOnceWithEverySideQuestStored(t *testing.T) {
 				}
 				return
 			}
-			want := fmt.Sprintf("%d new Side quests are in", len(deck))
-			if len(rows) != 1 || rows[0].Key != key || rows[0].Payload.Title != want ||
-				rows[0].Payload.Body != "Fajita Dish A, Fajita Dish C, Fajita Dish D + 2 more" {
-				t.Errorf("new_suggestions rows = %+v, want one keyed %s titled %q", rows, key, want)
-			}
-		})
-	}
-}
-
-// TestBatchFailingInALaterRoundStoresNothing: when normalize_recipe fails
-// in a batch's second grounding round, a scheduled or manual batch stores
-// none of the first round's Side quests and sends no new_suggestions, so
-// no Side quest is left in the deck unannounced; a replenish batch, which
-// never notifies, keeps the first round's in the deck.
-func TestBatchFailingInALaterRoundStoresNothing(t *testing.T) {
-	for _, tc := range []struct {
-		trigger string
-		deck    int
-	}{
-		{suggest.TriggerScheduled, 0},
-		{suggest.TriggerManual, 0},
-		{suggest.TriggerReplenish, suggest.BatchSize - 1},
-	} {
-		t.Run(tc.trigger, func(t *testing.T) {
-			e := newEnv(t)
-			e.start(t)
-			e.twoRoundBatch(t, false)
-
-			b, _ := e.startBatch(t, tc.trigger)
-			job := e.waitJob(t, b.JobID)
-			if job.Status != jobs.StatusFailed || job.Error == nil || *job.Error != suggest.ReasonAIFailed {
-				t.Fatalf("batch job %s, error %+v, want failed %s", job.Status, job.Error, suggest.ReasonAIFailed)
-			}
-			if got := e.batchStatus(t, b.ID); got != suggest.BatchFailed {
-				t.Errorf("batch status = %s, want failed", got)
-			}
-			if got := e.deckNames(t); len(got) != tc.deck {
-				t.Errorf("deck = %v, want %d Side quests", got, tc.deck)
-			}
-			if rows := notifytest.Rows(t, e.st, notify.NewSuggestions); len(rows) != 0 {
-				t.Errorf("new_suggestions rows = %+v, want none", rows)
+			if len(rows) != 1 || rows[0].Key != "new_suggestions:"+b.ID ||
+				rows[0].Payload.Body != "Fajita Dish A, Fajita Dish C, Fajita Dish D + 1 more" {
+				t.Errorf("new_suggestions rows = %+v, want one keyed by batch %s naming the first round", rows, b.ID)
 			}
 		})
 	}
@@ -1380,7 +1299,7 @@ func TestBatchJobFailsWhenRecordingItsEndFails(t *testing.T) {
 		t.Errorf("batch status = %s with its job failed, want failed", got)
 	}
 	// Its Side quests stay in the deck, and the household was told of them.
-	if rows := notifytest.Rows(t, e.st, notify.NewSuggestions); len(rows) != 1 || rows[0].Key != "new_suggestions:"+b.ID || rows[0].Payload.Title != "1 new Side quest is in" || rows[0].Payload.Body != "Chili Verde" {
+	if rows := notifytest.Rows(t, e.st, notify.NewSuggestions); len(rows) != 1 || rows[0].Key != "new_suggestions:"+b.ID || rows[0].Payload.Body != "Chili Verde" {
 		t.Errorf("new_suggestions rows of a batch whose end was not recorded = %+v, want one naming Chili Verde", rows)
 	}
 }
@@ -1555,47 +1474,6 @@ func TestStartBatchRefusesUnknownTrigger(t *testing.T) {
 	}
 }
 
-// TestScheduledBatchNeedsItsWeek: a scheduled batch is started only by
-// StartScheduledBatch, for a Monday.
-func TestScheduledBatchNeedsItsWeek(t *testing.T) {
-	e := newEnv(t)
-	if _, err := e.svc.StartBatch(t.Context(), suggest.TriggerScheduled); err == nil {
-		t.Error("StartBatch started a scheduled batch with no week")
-	}
-	for _, week := range []store.LocalDate{{}, mustDate("2026-10-06")} {
-		if _, err := e.svc.StartScheduledBatch(t.Context(), week); err == nil {
-			t.Errorf("StartScheduledBatch(%q) accepted a week that is not a Monday", week)
-		}
-	}
-	if n := e.activeBatches(t); n != 0 {
-		t.Errorf("%d active batches, want none", n)
-	}
-}
-
-// TestScheduledBatchKeyedByItsWeekWhenRunLate: a scheduled batch's
-// new_suggestions is keyed by the week it was scheduled for, not the week
-// it runs in, so a batch caught up after its week ended still tells the
-// household of that week's Side quests and leaves the next week's key free.
-func TestScheduledBatchKeyedByItsWeekWhenRunLate(t *testing.T) {
-	e := newEnv(t)
-	e.start(t)
-	e.recipe(t, "Chili Verde")
-	e.reply(sideQuest("Chili Verde", "Your Beef Chili gone green.", "Beef Chili"))
-	// A week long past: the batch runs today, weeks later.
-	b, err := e.svc.StartScheduledBatch(t.Context(), mustDate("2026-01-05"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if job := e.waitJob(t, b.JobID); job.Status != jobs.StatusSucceeded {
-		t.Fatalf("batch job %s", job.Status)
-	}
-	rows := notifytest.Rows(t, e.st, notify.NewSuggestions)
-	if len(rows) != 1 || rows[0].Key != "new_suggestions:2026-W02" || rows[0].Payload.Week != "2026-01-05" ||
-		rows[0].Payload.Title != "1 new Side quest is in" {
-		t.Errorf("new_suggestions rows = %+v, want one keyed new_suggestions:2026-W02 for 2026-01-05", rows)
-	}
-}
-
 // noCalendar is a plan.Calendar for tests that never push.
 type noCalendar struct{}
 

migrations/queries/notifications.sql

@@ -66,3 +66,11 @@ SELECT * FROM notification_prefs;
 UPDATE notification_prefs
 SET push = ?, chat = ?, updated_at = ?
 WHERE event = ?;
+
+-- name: HasNotificationSince :one
+-- Reports whether a notification was stored after since, or at all when
+-- since is NULL.
+SELECT EXISTS (
+	SELECT 1 FROM notification_outbox
+	WHERE CAST(sqlc.narg(since) AS TEXT) IS NULL OR created_at > CAST(sqlc.narg(since) AS TEXT)
+) AS found;

migrations/queries/schedule_runs.sql

@@ -1,6 +0,0 @@
--- name: ClaimScheduleRun :execrows
--- Claims one period of a schedule. The insert is the claim: 1 row means
--- this caller owns the period, 0 rows means it was already claimed.
-INSERT INTO schedule_runs (id, schedule, period_key, created_at)
-VALUES (?, ?, ?, ?)
-ON CONFLICT (schedule, period_key) DO NOTHING;

web/src/ideas/CookFromPantryPage.test.tsx

@@ -33,7 +33,9 @@ function idea(name: string, summary: string, minutes: number | null = 30) {
 
 // The ideas of mock 1i.
 const CURRY = idea('Coconut chicken curry', 'Uses all 5 · missing: 1 lime')
-const BOWLS = idea('Garlic spinach rice bowls', 'Uses 4 of 5 · nothing missing', 25)
+// BOWLS's source is withheld, as the server sends one whose link could
+// carry a secret: the card shows all the same.
+const BOWLS = { ...idea('Garlic spinach rice bowls', 'Uses 4 of 5 · nothing missing', 25), source_url: null, site_name: null }
 const ONE_PAN = idea('One-pan chicken & rice', 'Uses 3 of 5 · missing: onion')
 
 type JobBody = { status: string; result: unknown; error: string | null }

web/src/ideas/QuickDinnersPage.test.tsx

@@ -30,7 +30,9 @@ function idea(name: string, method: string, minutes: number | null, difficulty:
 
 // The ideas of mock 1j, and more for later pages and the Crock pot tab.
 const ORZO = idea('Lemon garlic shrimp orzo', 'stovetop', 25, 'medium')
-const QUESADILLAS = idea('Chicken quesadillas', 'stovetop', 20, 'easy')
+// QUESADILLAS's source is withheld, as the server sends one whose link
+// could carry a secret: the card shows all the same.
+const QUESADILLAS = { ...idea('Chicken quesadillas', 'stovetop', 20, 'easy'), source_url: null, site_name: null }
 const BROCCOLI = idea('Beef & broccoli', 'stovetop', 30, 'easy')
 const GNOCCHI = idea('Pesto gnocchi & peas', 'stovetop', 15, 'easy')
 const CHILI = idea('Crock pot chili', 'crockpot', 360, 'easy')