Require Home minutes_total and Supply run label for every list (review H1)

parseTonight now rejects a tonight dinner without the minutes_total key
instead of reading it as null; an explicit null is still valid. The Home
API always emits the key. parseShoppingList checks the label against
weekStart for unready lists too, since the API supplies it regardless of
readiness.

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

Makefile

@@ -82,8 +82,7 @@ sqlc:
 	$(SQLC) generate
 
 # Fails on any difference from the committed generated code, including new
-# or deleted files. A failing git status is itself a failure: its empty
-# output would otherwise read as "no drift".
+# or deleted files.
 sqlc-check: sqlc
-	@drift="$$(git status --porcelain --untracked-files=all -- $(SQLC_OUT))" || { echo "git status failed; cannot check internal/db for drift"; exit 1; }; \
+	@drift="$$(git status --porcelain --untracked-files=all -- $(SQLC_OUT))"; \
 	if [ -n "$$drift" ]; then echo "internal/db is stale; run make sqlc and commit:"; echo "$$drift"; git diff -- $(SQLC_OUT); exit 1; fi

cmd/server/main.go

@@ -31,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"
@@ -131,12 +130,7 @@ func run(cfg config.Config, logger *slog.Logger) error {
 		return err
 	}
 
-	// The scheduler is made before the services whose changes wake it.
-	sched, err := scheduler.New(db, settings, logger)
-	if err != nil {
-		return err
-	}
-	dinnerSvc, err := dinners.NewService(db, grounder, runner, sched.Wake, logger)
+	dinnerSvc, err := dinners.NewService(db, grounder, runner, logger)
 	if err != nil {
 		return err
 	}
@@ -158,7 +152,7 @@ func run(cfg config.Config, logger *slog.Logger) error {
 		return err
 	}
 
-	planSvc, err := plan.NewService(db, weekDrafter(ai, guard), runner, googleSvc, notifier, sched.Wake, cfg.PublicURL, sched.Now, logger)
+	planSvc, err := plan.NewService(db, weekDrafter(ai, guard), runner, googleSvc, notifier, cfg.PublicURL, logger)
 	if err != nil {
 		return err
 	}
@@ -199,46 +193,17 @@ func run(cfg config.Config, logger *slog.Logger) error {
 		return err
 	}
 
-	if err := sched.Register(suggestSvc.WeeklySchedule()); err != nil {
-		return err
-	}
-	if err := sched.Register(planSvc.DraftSchedule()); err != nil {
-		return err
-	}
-	for _, sch := range planSvc.ReminderSchedules() {
-		if err := sched.Register(sch); err != nil {
-			return err
-		}
-	}
-	if err := sched.Register(planSvc.RotationCheckSchedule()); err != nil {
-		return err
-	}
-	if err := sched.Register(shopSvc.ChatAutosendSchedule()); err != nil {
-		return err
-	}
-	if err := sched.Register(shopSvc.RolloverSchedule()); err != nil {
-		return err
-	}
-	purge, err := harness.PurgeSchedule(db, logger)
-	if err != nil {
-		return err
-	}
-	if err := sched.Register(purge); 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, 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()
 	}()
@@ -254,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,

deploy/RUNBOOK.md

@@ -1,255 +0,0 @@
-# MealQuest deploy runbook
-
-The one way to deploy MealQuest to production: the docker compose project
-`mealquest` on office-srvr `10.60.1.14` (see
-[ARCHITECTURE.md](../docs/ARCHITECTURE.md#topology)). Production runs `main`
-or a release tag; only `overseer` merges `dev` → `main`. Every deploy builds
-on the host, from the checked-out commit, with `make docker`.
-
-Host setup (clone, firewall, the systemd unit, Traefik, DNS, Litestream) and
-the database restore are in CTXD project `mealquest`, `RUNBOOKS.MD`. This
-file is the build, restart, verification and rollback procedure; where it
-uses a CTXD section, it names it.
-
-All commands run on `10.60.1.14` as `overseer`, in bash, from the checkout
-`/home/overseer/mealquest`. A block that ends with `FAILED` or a non-zero
-`$?` stops the deploy: do not go on to the next step.
-
-## How the image carries its version
-
-`make docker` runs `docker build --build-arg VERSION=<version>` and tags the
-image `mealquest:<version>`, where `<version>` is
-`git describe --tags --always` of the checkout (a release tag such as
-`v1.0.0`, otherwise the short SHA), with `-dirty` added when a tracked file
-is modified. The [Dockerfile](../Dockerfile) links it into the binary, and
-`/health` reports it:
-
-```json
-{"status":"ok","version":"v1.0.0"}
-```
-
-Never pass `--build-arg VERSION` by hand, and never build with
-`docker compose build` or `docker compose up --build`: compose passes no
-version, so that image reports `dev`.
-
-The compose service `mealquest` runs the image named `mealquest-mealquest`
-(compose's name for the image it would build; check with
-`docker compose -f deploy/compose.yaml config --images mealquest`). It
-already exists, so `docker compose up` uses it and never builds. A deploy
-points that name at the `make docker` image with `docker tag`. Every
-`mealquest:<version>` image is kept for rollback; do not prune them.
-
-## Prerequisites
-
-- `make`, `git`, `curl`, `python3` and Docker Engine with Compose on the
-  host (`make` is not in the base install: `sudo apt-get install make`).
-- `deploy/.env` (git-ignored, owner `overseer`, mode 0600) sets every
-  variable [`deploy/.env.example`](.env.example) sets, with
-  `MEALQUEST_BIND_ADDRESS=10.60.1.14`. It must not set the variables
-  `deploy/compose.yaml` fixes (`MEALQUEST_HTTP_ADDR`, `MEALQUEST_DATA_DIR`,
-  `MEALQUEST_SEARXNG_URL` and the `*_FILE` variables). Creating it: CTXD
-  `RUNBOOKS.MD` "Stack and first deploy" > "3. Environment file".
-- `deploy/secrets/` (git-ignored, mode 0700) holds `secret_key`,
-  `oidc_client_secret`, `google_client_secret`, `vapid_private_key` and
-  `litestream_key`, each owned by `10001:10001` with mode 0600, and
-  `searxng.env`, owned by `overseer` with mode 0600. Creating them: CTXD
-  `RUNBOOKS.MD` "Stack and first deploy" > "4. Secrets".
-- The compose file is the checkout's [`deploy/compose.yaml`](compose.yaml);
-  the systemd unit [`mealquest.service`](systemd/mealquest.service) starts
-  and stops it and is the only way the stack starts.
-- DNS and Traefik already route `https://mealquest.cubecraftlabs.com` to
-  `10.60.1.14:8090` (CTXD `RUNBOOKS.MD` "Reverse proxy (Traefik)", "DNS").
-
-Check `deploy/.env` and the secrets before every deploy (a new release may
-add a variable; the service refuses to boot without it). Both commands must
-print nothing:
-
-```sh
-cd /home/overseer/mealquest
-comm -23 <(grep -oE '^MEALQUEST_[A-Z_]+' deploy/.env.example | sort -u) \
-         <(grep -oE '^MEALQUEST_[A-Z_]+' deploy/.env | sort -u)   # variables missing from deploy/.env
-sudo find deploy/secrets -type f ! -perm 600                       # secrets not mode 0600
-```
-
-## Deploy
-
-### 1. Build
-
-Record the release production is running now, check out the new release
-and build its image. Nothing restarts.
-
-The rollback target is the version the running service reports on
-`/health`, read before the checkout changes, never the checkout's `HEAD`:
-after a failed or deferred deploy the checkout can be ahead of production.
-The block resolves that version to a commit and prints it as the rollback
-SHA. A running version of `dev` or `*-dirty` names no commit: the block
-fails, and the rollback target must be established by hand before going on.
-
-The checkout must be clean (the same test as the Makefile's `GIT_DIRTY`:
-no modified tracked file outside the generated `internal/frontend/dist`).
-The block computes the image tag exactly as `make docker` does, `-dirty`
-included, and checks that image exists after the build.
-
-```sh
-cd /home/overseer/mealquest && (
-set -euo pipefail
-fail() { echo "$*" >&2; exit 1; }
-built=
-trap 'st=$?
-if [ "$st" -eq 0 ] && [ -n "$built" ]; then echo "built: $built"
-else [ "$st" -ne 0 ] || st=1; echo "build FAILED (status $st)" >&2; fi
-exit "$st"' EXIT
-bind=$(grep -E '^MEALQUEST_BIND_ADDRESS=' deploy/.env | cut -d = -f 2-)
-[ -n "$bind" ] || fail "deploy/.env sets no MEALQUEST_BIND_ADDRESS"
-running=$(curl -fsS "http://$bind:8090/health" | python3 -c 'import json, sys; print(json.load(sys.stdin)["version"])') \
-  || fail "http://$bind:8090/health did not return a version: no running release to roll back to"
-case "$running" in
-  dev|*-dirty) fail "the running release reports $running, which names no commit" ;;
-esac
-git fetch --tags origin
-rollback=$(git rev-parse --verify --quiet "$running^{commit}") \
-  || fail "running version $running is not a commit in this repository"
-echo "rollback SHA: $rollback (running version $running)"   # RECORD it for rollback
-git checkout --detach origin/main            # or the release tag, e.g. v1.0.0
-dirty=$(git status --porcelain --untracked-files=no -- . ':(exclude)internal/frontend/dist')
-[ -z "$dirty" ] || fail "the checkout has modified tracked files; clean it first:
-$dirty"
-v=$(git describe --tags --always)${dirty:+-dirty}   # the Makefile's VERSION
-make docker
-docker image inspect "mealquest:$v" > /dev/null 2>&1 || fail "no image mealquest:$v: the build failed"
-built="mealquest:$v"
-)
-```
-
-### 2. Ship and restart
-
-1. **Pre-restart gates.** Run CTXD `RUNBOOKS.MD` "Routine deploy and
-   rollback" > "Deploy" step 2 (a verified pre-deploy restore point; record
-   it with the rollback SHA) and step 3 (boot-required configuration). The
-   restart applies migrations the previous release refuses, so without that
-   restore point there is no rollback. If either fails, do not restart:
-   production stays on the previous release.
-2. **Point the stack at the new image and restart.** `docker compose pull`
-   fetches the pinned `litestream` and `searxng` images before anything
-   stops; `mealquest` is never pulled. The restart applies the firewall,
-   then runs `down` and `up -d`, and returns once `mealquest` passes its
-   healthcheck (`/health` inside the container).
-
-```sh
-cd /home/overseer/mealquest && (
-set -euo pipefail
-fail() { echo "$*" >&2; exit 1; }
-up=
-trap 'st=$?
-if [ "$st" -eq 0 ] && [ -n "$up" ]; then echo "restarted on: $up"
-else [ "$st" -ne 0 ] || st=1; echo "restart FAILED (status $st)" >&2; fi
-exit "$st"' EXIT
-v=$(git describe --tags --always)
-docker compose -f deploy/compose.yaml pull litestream searxng
-docker tag "mealquest:$v" mealquest-mealquest
-sudo systemctl restart mealquest
-for s in mealquest litestream searxng; do
-  id=$(docker compose -f deploy/compose.yaml ps --status running --quiet "$s")
-  [ -n "$id" ] || fail "$s is not running"
-done
-id=$(docker compose -f deploy/compose.yaml ps --quiet mealquest)
-health=$(docker inspect -f '{{.State.Health.Status}}' "$id")
-[ "$health" = healthy ] || fail "mealquest is $health, not healthy"
-up="mealquest:$v"
-)
-```
-
-On failure read `journalctl -u mealquest` and
-`docker compose -f deploy/compose.yaml logs mealquest`: a configuration
-error names the variable. Fix it or roll back.
-
-### 3. Verify the deployed version and a real screen
-
-A `/health` 200 alone proves only that some build is up. This step checks,
-on the LAN address and through Traefik, that:
-
-- `/health` reports exactly the checkout's `git describe --tags --always`;
-- `/` and the Plan screen's route `/plan` serve the built PWA shell (the
-  React root and a hashed `/assets/` script, not the placeholder page an
-  unbuilt embed serves);
-- that script is served as JavaScript.
-
-```sh
-cd /home/overseer/mealquest && (
-set -euo pipefail
-fail() { echo "$*" >&2; exit 1; }
-want=
-trap 'st=$?
-if [ "$st" -eq 0 ] && [ -n "$want" ]; then echo "deployed and verified: $want ($(git rev-parse HEAD))"
-else [ "$st" -ne 0 ] || st=1; echo "verification FAILED (status $st): the deploy is not verified" >&2; fi
-exit "$st"' EXIT
-v=$(git describe --tags --always)
-for base in http://10.60.1.14:8090 https://mealquest.cubecraftlabs.com; do
-  got=$(curl -fsS "$base/health" | python3 -c 'import json, sys; print(json.load(sys.stdin)["version"])') \
-    || fail "$base/health did not return a version"
-  [ "$got" = "$v" ] || fail "$base/health reports version $got, the checkout is $v"
-  for path in / /plan; do
-    page=$(curl -fsS "$base$path") || fail "$base$path did not return 200"
-    grep -q '<div id="root"></div>' <<< "$page" || fail "$base$path is not the PWA shell"
-    js=$(grep -oE 'src="/assets/[^"]+\.js"' <<< "$page" | head -n 1 | cut -d '"' -f 2) || true
-    [ -n "$js" ] || fail "$base$path references no built /assets/ script"
-    type=$(curl -fsS -o /dev/null -w '%{content_type}' "$base$js") || fail "$base$js did not return 200"
-    case "$type" in
-      text/javascript*) ;;
-      *) fail "$base$js is $type, not JavaScript" ;;
-    esac
-  done
-  echo "$base: version $got, PWA shell and $js served"
-done
-want=$v
-)
-```
-
-- `deployed and verified: <version> (<SHA>)` and `$?` = `0` → open
-  `https://mealquest.cubecraftlabs.com` in a browser: sign in and the Home
-  screen renders with the household's data. Then record the deployed
-  version and SHA, the rollback SHA, the pre-deploy restore point and the
-  date in the release's Maestro task.
-- `verification FAILED`, any error or a non-zero `$?` → the deploy is not
-  done. A version mismatch means the stack runs a different image than the
-  checkout: repeat step 2, or roll back.
-
-## Rollback to a previous release
-
-Rolling back points `mealquest-mealquest` at the previous release's
-`mealquest:<version>` image again; that release's checkout keeps the
-compose file and the version check consistent with it.
-
-1. **Check whether the rollback crosses a migration** with CTXD
-   `RUNBOOKS.MD` "Routine deploy and rollback" > "Rollback to a previous
-   SHA" (its first block), run against the rollback SHA that deploy step 1
-   recorded. If it prints versions unknown to the rollback SHA, restore the
-   database to the pre-deploy restore point first (CTXD `RUNBOOKS.MD`
-   "Restore the database", with `-timestamp <restore point>`); changes
-   since then are lost, so tell the household.
-2. **Check out the rollback SHA and retag its image.** An image built before
-   this runbook was not tagged `mealquest:<version>`; `make docker` builds
-   it from the same commit.
-
-```sh
-cd /home/overseer/mealquest && (
-set -euo pipefail
-fail() { echo "$*" >&2; exit 1; }
-P=<rollback SHA>   # recorded by step 1, from the running release's /health
-back=
-trap 'st=$?
-if [ "$st" -eq 0 ] && [ -n "$back" ]; then echo "rolled back to: $back"
-else [ "$st" -ne 0 ] || st=1; echo "rollback FAILED (status $st)" >&2; fi
-exit "$st"' EXIT
-git checkout --detach "$P"
-v=$(git describe --tags --always)
-docker image inspect "mealquest:$v" > /dev/null 2>&1 || make docker
-docker image inspect "mealquest:$v" > /dev/null 2>&1 || fail "no image mealquest:$v"
-docker tag "mealquest:$v" mealquest-mealquest
-sudo systemctl restart mealquest
-back="mealquest:$v"
-)
-```
-
-3. **Run step 3 above** unchanged. The rollback is done only when it prints
-   `deployed and verified:` with the previous release's version.

docs/A11Y.md

@@ -1,113 +0,0 @@
-# Accessibility pass
-
-A pass over every route the PWA serves (the routes in [STATES.md](STATES.md))
-for launch, on 2026-10-10. Each route was checked for:
-
-- **Keyboard** — every action reachable and operable with the keyboard alone.
-- **Focus** — a visible focus ring on everything that takes focus.
-- **Names and roles** — what a screen reader announces: switches, checkboxes,
-  the current nav item, dialogs and their labels.
-- **Contrast** — text at least 4.5:1 against its ground, for every token pair
-  used for text.
-- **Hit targets** — every tap target at least 44 × 44 px.
-- **Reduced motion** — what `prefers-reduced-motion: reduce` turns off.
-
-The pass read each screen's markup and stylesheets, computed contrast from
-[tokens.css](../web/src/styles/tokens.css), and checked the fixes' computed
-styles in Chrome. Severity: **high** blocks a task for keyboard or
-screen-reader users; **medium** fails a criterion above but leaves a way
-through; **low** is a gap outside the criteria above, or a polish item. High
-and medium findings are fixed in this pass with a regression test; low ones are
-follow-ups.
-
-## Shared building blocks
-
-Most of the criteria are met once, in the shared components every screen uses:
-
-| Concern | Where | Behaviour |
-| --- | --- | --- |
-| Focus ring | [base.css](../web/src/styles/base.css) | `:focus-visible` draws a 2 px grape (`--color-accent`) outline 2 px out, on every focusable element. |
-| Dialogs | [Sheet](../web/src/ui/Sheet.tsx) | `role="dialog"`, `aria-modal="true"`, and a required `aria-label` or `aria-labelledby` (the type will not compile without one). Opening moves focus in, Tab is trapped, Escape and the scrim close, the page behind is `inert`, and focus returns to the opener. Every sheet is labelled by its visible title. |
-| Toggles | [Toggle](../web/src/ui/Toggle.tsx) | A `<button role="switch" aria-checked>`; Space and Enter flip it; a 44 px hit box around the 40 × 24 track. |
-| Checkboxes | [Checkbox](../web/src/ui/Checkbox.tsx) | A native `<input type="checkbox">` inside its `<label>`; the label row is the 44 px target. |
-| Segmented controls | [Segmented](../web/src/ui/Segmented.tsx) | `role="radiogroup"` of `role="radio"` buttons with a roving tab stop; arrows, Home and End move the choice. |
-| Icon buttons | [IconButton](../web/src/ui/IconButton.tsx) | A required `label` names every icon-only button; the 40 px face sits in a 44 px hit box. |
-| Primary nav | [BottomBar](../web/src/shell/BottomBar.tsx), [Rail](../web/src/shell/Rail.tsx), [Sidebar](../web/src/shell/Sidebar.tsx) | `<nav aria-label="Primary">` of `NavLink`s; the current item has `aria-current="page"`, nested routes (`/plan/shopping`, `/settings/ai`) keep their section current. The bottom bar's inactive items keep their name in a visually hidden label. |
-| Status and errors | [ErrorBanner](../web/src/ui/ErrorBanner.tsx), `role="status"` / `role="alert"` lines | Loading regions are `aria-busy` and named; errors are announced. |
-| Reduced motion | `--motion-scale` in tokens.css; `@media (prefers-reduced-motion: reduce)` in each animated component; `matchMedia` before every Web Animations call | Sheets appear without rising, skeletons stop pulsing, buttons do not scale, toggles and checkboxes do not spring, the nav pill jumps rather than slides, and the Discover deck fades a decided card out with no throw, bump, wiggle or promotion. |
-
-## Routes
-
-| Route | Keyboard | Focus | Names and roles | Hit targets | Reduced motion |
-| --- | --- | --- | --- | --- | --- |
-| App shell (every route) | Nav is links in tab order. | Global ring; **the bottom bar's ring was 1.8:1 on the dark bar — fixed (M2).** | `nav "Primary"`, `aria-current="page"`. | Bottom bar items 62 px tall, ≥ 44 px wide; rail items 56 × 44. | Pill jumps; no label fade. |
-| `/` Home | All tiles, status rows, Recipe, the bell and the Rotation check are buttons or links. | Global ring; tiles, status rows and "We didn't make it" draw a 3 px ring, inside their cards' padding. | Tonight `section`, Status list; the bell is named "Recent updates" and its sheet is labelled by its title. | Recipe pill and "We didn't make it" kept at 44 px. | — |
-| `/onboarding` (all steps) | Buttons and form fields; Add Regular submits on Enter. | Global ring. | `h1` per step; progress bar hidden; "Add Regular" and "Add *pick*" named. | Covered by onboarding tests. | — |
-| `/plan` Draft board (mobile) | **Swap without drag:** each day tile is a button that opens the swap sheet; the sheet's rows are buttons. Previous/Next week, Rebuild week, Push to Calendar are buttons. | Global ring. | Week list "Dinners this week"; swap sheet labelled "Swap *Day*"; Quest log / Regulars radio group. | Tiles ≥ 86 px tall. | Sheet appears without rising. |
-| `/plan` plan manager (tablet, desktop) | **Swap without drag:** every day has a "Swap *Day*" button opening the swap sheet. Dragging also works by keyboard: Enter or Space picks a dinner up, arrows move between days, Enter drops, Escape cancels; a polite live region narrates each step and focus lands on the day's swap button. | Global ring. | Days named by weekday; the panel is "Quest log and Regulars"; each draggable row is described by the keys hint. | **The tablet-portrait Quest log chips were 38 px tall — fixed (M4).** | — |
-| `/plan/shopping` Supply run | Native checkboxes; links to the archive. | Global ring. | Groups named by dinner; native checkbox per item; read-only weeks say "have it" in text, not by colour alone. | Checkbox rows 44 px. | — |
-| `/plan/shopping/archive` | Period radio group; posts are links. | Posts draw a 3 px ring. | Periods named by heading. | — | — |
-| `/discover` | **← Pass, → Try it** anywhere on the page (not while typing, nor with a sheet open); Pass and Try it are also buttons; the Quest log pill opens its sheet. | Global ring. | Only the top card is exposed, labelled by its name; cards behind are `aria-hidden` and `inert`; Try it / Pass labels are shown under the buttons. | Pass and Try it 62 px; Quest log pill 44 px. | Card fades out; no throw, bump, wiggle, snap-back spring or promotion. |
-| `/quick` Quick dinners | Tab radio group; add buttons; More link. | Global ring; More draws a 3 px ring. | Rows named by idea; "Added" is a status. | Covered by Quick dinners tests. | — |
-| `/cook-from-pantry` | Field adds an ingredient on Enter; chips' remove buttons; Find ideas. | The field rings as a whole (`:focus-within`). | Ingredients list "Ingredients on hand"; idea cards named. | Chip remove buttons 44 px. | — |
-| `/dinner/:id` (phone) | Buttons for Favorite, Add to week, back. | Global ring. | Favorite is `aria-pressed`; Add to week sheet labelled. | Favorite 52 px. | — |
-| `/dinner/:id` Kitchen reading mode | ← / → move steps (not while typing, nor with a sheet open); Previous and Next step buttons; text size radio group; ingredient checkboxes. | **The text-size pill clipped its focus ring — fixed (M3).** | Keep screen on is a `role="switch"`; ingredients are native checkboxes; the current step is `aria-current="step"`. | Checkboxes 44 px rows. | — |
-| `/settings` | Rows are links; on tablet, a `tablist` with arrow keys. | Global ring. | Tabs `role="tab"` / `tabpanel`. | Covered by Settings tests. | — |
-| `/settings/notifications` | Every channel is a switch; reminder time button; webhook form. | Global ring. | Each switch named "*Event*: *Channel*"; the matrix is a named group; the webhook sheet is labelled. | Toggle hit box 44 px. | — |
-| `/settings/ai` | Selects, slider, Add/Replace key. | Global ring. | Native `select`s and range input with labels; key sheet labelled. | Covered by AI settings tests. | — |
-| `/settings/household` | Selects; time zone list of buttons. | Global ring. | The chosen time zone is `aria-pressed`. | Zone options 48 px. | — |
-| `/settings/regulars` | Add, edit and favourite buttons; method selects; recipe search. | Global ring. | Favourite is `aria-pressed`; edit sheet labelled. | Covered by Regulars tests. | — |
-| `/settings/calendar` | Connect link; calendar select. | Global ring. | Reconnect problems are `role="alert"`. | — | — |
-
-## Text contrast
-
-WCAG AA asks 4.5:1 for normal-size text. Every colour a stylesheet gives text,
-on every ground it is drawn on:
-
-| Text token | Grounds | Lowest ratio |
-| --- | --- | --- |
-| `--color-text` | bg, surface, neutral-100, neutral-200, accent-100, accent-200, accent-2-100, accent-2-200, accent-2-300 | 11.10 (on accent-2-300) |
-| `--color-neutral-700` | bg, surface, neutral-100, neutral-200, accent-100, accent-200, accent-2-100, accent-2-200 | 5.22 (on accent-200) |
-| `--color-neutral-800` | the same light grounds | 7.90 |
-| `--color-neutral-900` | the same light grounds | 11.18 |
-| `--color-accent` | the same light grounds | 7.16 |
-| `--color-accent-700` | the same light grounds | 5.76 |
-| `--color-accent-800` | the same light grounds | 8.69 |
-| `--color-accent-2-800` | the same light grounds | 7.51 |
-| `--color-accent-2-900` | the light grounds and accent-2-300 | 9.51 (on accent-2-300) |
-| `--on-accent` | accent, accent-800, neutral-800 | 8.39 (on accent) |
-| `--color-bg` | text, neutral-800 | 9.26 (on neutral-800) |
-| `--color-neutral-400` | text (the bottom bar's inactive items) | 8.28 |
-
-`--color-neutral-600` (3.5:1 on surface, 4.0:1 on bg) was used for muted text
-in five places and failed — fixed (M1). [contrast.test.ts](../web/src/contrast.test.ts)
-checks every pair above from tokens.css and fails if any stylesheet gives text a
-colour token not in this table.
-
-Non-text: the teal Try it button and teal "+" buttons draw a light icon on
-`--color-accent-2-600` at 3.73:1, which meets the 3:1 asked of icons; their
-names are text elsewhere (the shown label, or `aria-label`).
-
-## Findings
-
-### Fixed in this pass
-
-| # | Severity | Route | Finding | Fix | Regression test |
-| --- | --- | --- | --- | --- | --- |
-| M1 | Medium | `/plan`, `/dinner/:id`, `/cook-from-pantry` | Muted text in `--color-neutral-600` at 3.5–4.0:1: the swapping day's dinner and start-by time, Regulars already this week in the swap sheet, ingredients set out and steps done in Kitchen reading mode, and the ingredient field's placeholder. | `--color-neutral-700` (≥ 5.4:1 on bg and surface); still muted against `--color-text`, and set-out ingredients keep their strike-through. | [contrast.test.ts](../web/src/contrast.test.ts); the swapping-tile and done-step colour assertions in [PlanPage.test.tsx](../web/src/plan/PlanPage.test.tsx) and [KitchenReading.test.tsx](../web/src/dinners/KitchenReading.test.tsx). |
-| M2 | Medium | Every route (phone) | The bottom bar's focus ring was the global grape ring on the near-black bar: 1.8:1, nearly invisible. | The bar's items ring in `--on-accent` (15.4:1 on the bar). | "rings a focused item in on-accent ink" in [BottomBar.test.tsx](../web/src/shell/BottomBar.test.tsx). |
-| M3 | Medium | `/dinner/:id` Kitchen reading mode | The text-size pill hides overflow, so the focus ring of the chosen size — drawn outside it — was cut off top and bottom, and in grape on the grape fill. | The ring sits 4 px inside the size, in `--on-accent` (8.4:1 on grape). Only the chosen size takes focus (roving tab stop). | "rings the focused size inside the clipped pill" in [KitchenReading.test.tsx](../web/src/dinners/KitchenReading.test.tsx). |
-| M4 | Medium | `/plan` (tablet portrait, 768–1179 px) | The Quest log strip's draggable chips were 38 px tall (28 px photo, 3 px padding, 2 px border). | The chip button keeps a 44 × 44 px minimum. | The strip test's `expectMinHitArea` in [PlanPage.test.tsx](../web/src/plan/PlanPage.test.tsx). |
-
-No high findings.
-
-### Follow-ups (low)
-
-| # | Route | Finding | Suggested follow-up |
-| --- | --- | --- | --- |
-| L1 | Every route with a checkbox | An unchecked checkbox's `--color-neutral-400` border is 1.9:1 on bg — below the 3:1 WCAG asks of a control's boundary. Its label row still names and reveals it. | Darken the border (for example `--color-neutral-600`, 4.0:1) with the design owner. |
-| L2 | Settings, Kitchen reading mode | An off toggle's `--color-neutral-300` track is 1.4:1 on bg; the knob's position and the switch's name carry the state. | Give the off track a ≥ 3:1 edge with the design owner. |
-| L3 | `/discover` | The ← / → shortcuts are not announced to screen readers. | Add `aria-keyshortcuts` to Pass and Try it. |
-| L4 | `/discover` | Deciding the last card replaces Pass and Try it with "All caught up", and focus falls back to the page. | Move focus to "Get more now" when the deck empties. |
-| L5 | `/discover` | A decision is not announced; the next card's name appears silently. | A polite status ("Added to the Quest log" / "Passed") after each decision. |
-| L6 | `/plan` (mobile) | A day tile's name is its day and dinner ("MON Beef tacos"); it does not say it opens the swap sheet. | Add "Swap" to the tile's accessible name. |

docs/ARCHITECTURE.md

@@ -95,8 +95,8 @@ Columns ending in `_ct` hold AES-256-GCM ciphertext (via `secretbox`).
 | --- | --- |
 | `household_settings` | One row: timezone, dinner_time (17:30), reminder_time (16:30), review_time (09:00), plan_draft day/time (Fri 09:00), suggestions day/time (Sun 08:00), chat_autosend day/time (Sat 08:00), onboarding_completed_at, updates_seen_at. |
 | `recipes` | A real recipe page: source_url (unique), site_name, title, total/prep/cook minutes (the page's JSON-LD), yield, raw_jsonld, fetched_at; and its grounding: photo_id, method, difficulty, minutes_total (normalized prep to table). |
-| `recipe_ingredients` | recipe_id, position (unique per recipe: the recipe order), raw_text, name, qty, unit, note. |
-| `recipe_steps` | recipe_id, position (unique per recipe: the recipe order), text. |
+| `recipe_ingredients` | recipe_id, position, raw_text, name, qty, unit, note. |
+| `recipe_steps` | recipe_id, position, text. |
 | `photos` | source_url, local_path, width, height, sha256, fetched_at. |
 | `dinners` | The meal record and its lifecycle: name, normalized_name, status (`suggested` / `quest_log` / `tried` / `regular` / `archived`), origin, method, minutes_total, difficulty, cuisine, is_favorite, recipe_id, recipe_url (a pasted recipe link awaiting grounding), photo_id, grounding_status (`pending` / `grounded` / `failed` / `manual`), grounding_error (why grounding failed), grounding_revision (raised whenever a dinner is renamed, so only the latest `ground_dinner` job may write it and no candidate offered before the rename grounds it), updated_by. |
 | `suggestion_batches` | trigger, status, ai_run_id. |
@@ -105,7 +105,7 @@ Columns ending in `_ct` hold AES-256-GCM ciphertext (via `secretbox`).
 | `plan_days` | plan_id, date (unique per plan), dinner_id, is_new, calendar_event_id (set while the chosen calendar shows the day as planned; cleared when its dinner changes, another calendar is chosen or Google Calendar is disconnected). |
 | `rotation_reviews` | dinner_id + plan_date (unique), status, decision (`keep` / `drop` / `not_made`), name (set only by a drop: the dinner's name when dropped, kept whatever it is later renamed, so a drop stays among the passed names), decided_at, updated_by. |
 | `shopping_lists` | week_start (unique), plan_id, title (the AI-written post title; NULL until written or when the AI fails, when the week label is shown instead; never empty), status (`current` / `archived`), sent_to_chat_at, chat_send_unconfirmed_at (a send to Google Chat recorded as begun before posting and cleared once its outcome is known; left set when it may or may not have posted), frozen_at. |
-| `shopping_groups` / `shopping_items` | One group per plan day with ingredients: dinner_id, date, position (by date), frozen_dinner_name (the dinner's name when its list was frozen into the Supply archive, kept whatever it is later renamed; NULL while the list is current, which shows its dinners' names now; never empty). Item name, qty (the display quantity, NULL when the recipe gives none), needed (bool), position. Made by `shopping.Generate` from the plan, with no model call: an item is a grounded recipe ingredient's normalized name with qty and unit joined ("2 cups"), or a manual recipe's line as typed with no qty. Regenerating keeps the id and needed flag of an item whose (dinner_id, name) is unchanged. |
+| `shopping_groups` / `shopping_items` | One group per plan day with ingredients: dinner_id, date, position (by date). Item name, qty (the display quantity, NULL when the recipe gives none), needed (bool), position. Made by `shopping.Generate` from the plan, with no model call: an item is a grounded recipe ingredient's normalized name with qty and unit joined ("2 cups"), or a manual recipe's line as typed with no qty. Regenerating keeps the id and needed flag of an item whose (dinner_id, name) is unchanged. |
 | `ai_settings` | One row: provider, base_url, model, temperature, system_prompt, api_key_ct, api_key_last4, key_verified_at. |
 | `recipe_search_settings` | One row: provider (`searxng` / `brave`), base_url (the SearXNG instance), api_key_ct and api_key_last4 (Brave). |
 | `integrations_google` | One row: refresh_token_ct, calendar_id, calendar_name, connected_at, last_sync_error. |
@@ -121,16 +121,6 @@ Columns ending in `_ct` hold AES-256-GCM ciphertext (via `secretbox`).
 `recipes` holds a fetched recipe page; `dinners` holds the household's meal
 record and its lifecycle, optionally linked to a recipe and a photo.
 
-Migration `0018_recipe_item_position_unique` makes position unique per
-recipe and fails, so the service refuses to start, on a database already
-holding a duplicate. Before deploying it, check the database; both queries
-must return no rows:
-
-```sql
-SELECT recipe_id, position FROM recipe_ingredients GROUP BY 1, 2 HAVING count(*) > 1;
-SELECT recipe_id, position FROM recipe_steps GROUP BY 1, 2 HAVING count(*) > 1;
-```
-
 ## Dinner lifecycle
 
 ```
@@ -225,17 +215,17 @@ automatic** (D-021).
   raw_text}]` and `steps` the step texts, both in recipe position order and
   empty (`[]`) with no recipe, as for a dinner whose grounding is
   `pending` or `failed`; a recipe entered by hand has only `raw_text`.
-  `source` is `{site_name, url}` of the page the recipe was fetched from,
-  null for a manual recipe or none, as `dinners.SourceOf` gives it — the
-  one rule for every fetched recipe's source, also used by idea results
-  and recipe candidates. `url`
-  is the page's link only when it is free of secrets (https, no user,
-  query or fragment), else null. `site_name` is the name the page gives
-  its site (publisher or `og:site_name`), else the link's host without
-  "www." when `url` is shown, else null. Extraction never stores a host
-  as a site name, so a stored name is always the page's; migration 0020
-  cleared the host-shaped names stored before that. The detail screen
-  shows "Recipe from {site}" only when `site_name` is not null. `why_picked` is the reason of the
+  Two items at one position leave recipe order unknown, so such a recipe
+  is 500 rather than shown out of order. `source` is `{site_name}` of the
+  page the recipe was fetched from, null for a manual recipe or none; it
+  has no `url`, as the page's link may carry a personal token.
+  `site_name` is the name the page gives its site (publisher or
+  `og:site_name`) and null otherwise: a page naming no site is stored
+  under its host, which may be the pasted link's — a token in a
+  subdomain — or a redirect's, so any stored name that could be a host
+  (the link's host, an IP address or a dotted host name, even a real
+  name like "Food.com") is withheld. The detail screen shows "Recipe
+  from {site}" only when `site_name` is not null. `why_picked` is the reason of the
   suggestion that created the dinner — its pending or accepted one, as
   declining a suggestion archives its dinner — null for one no suggestion
   created; a dinner with more than one such suggestion is 500, as nothing
@@ -272,8 +262,7 @@ automatic** (D-021).
   `GET /api/v1/dinners/{id}/recipe-candidates`
   searches for the dinner's name and returns `{candidates: [{candidate_id,
   title, site_name, photo_url, minutes}]}`, at most 3, ranked as `Ground`
-  ranks them, with `site_name` as the recipe detail's (`dinners.SourceOf`,
-  null when the site cannot be named without leaking the link); it fetches pages but downloads no photo and runs no model,
+  ranks them; it fetches pages but downloads no photo and runs no model,
   so `photo_url` is set only for a page already stored. `candidate_id` is
   an opaque id the server resolves to the page it last offered that dinner
   (kept in memory, so a restart means fetching the candidates again) at
@@ -320,32 +309,21 @@ 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). A
-  notifying batch also rechecks the Side quests it holds after each round
-  and lets go of those no longer eligible, so a later round grounds a
-  spare in place of each; only a change committed between the last
-  recheck and the store can leave it short of 5 with spares unused. 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 `scheduled` or `manual` batch that fails before its final
-  store (the AI, grounding, or the store itself) has stored nothing; a
-  failed `replenish` batch's Side quests stored before the failure stay
-  in the deck. If
-  recording the batch's end fails, its job fails, even after the final
-  store committed: a notifying batch's Side quests and their
-  `new_suggestions` then stay; the job runner retries
+  `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
   not retried, and the next start fails the job as interrupted. Recording
@@ -502,13 +480,15 @@ automatic** (D-021).
   `changed`, and answers 200 with the plan. A date outside the week is 400 `invalid_date`, an unknown dinner or
   a week with no plan 404, any other dinner 409 `dinner_not_plannable`, and
   a dinner already on another day of the week 409 `dinner_already_planned`.
-- Rotation check (`plan.Service`, D-021). The `rotation_check` schedule
-  calls `MarkTried` for the household-local day just past (see Scheduler).
-  `MarkTried(date)` moves every `quest_log` dinner planned on that date, on a plan of any
-  status, to `tried`, opens a `pending` `rotation_reviews` row for it and
-  emits its `rotation_review`, in one transaction;
-  a dinner already checked for that date is left as it is and not
-  notified again, so it is idempotent. `GET /api/v1/rotation-reviews` returns `{reviews}`, the
+- Rotation check (`plan.Service`, D-021). This release provides the
+  `MarkTried` service method and the rotation review read and decide APIs
+  below. The `rotation_check` schedule that is to call `MarkTried` for the
+  household-local day just past is planned (Feature 20, the scheduler) and
+  not wired yet: nothing in production calls `MarkTried`, so no Rotation
+  check opens automatically. `MarkTried(date)` moves every `quest_log` dinner planned on that date, on a plan of any
+  status, to `tried` and opens a `pending` `rotation_reviews` row for it;
+  a dinner already checked for that date is left as it is, so it is
+  idempotent. `GET /api/v1/rotation-reviews` returns `{reviews}`, the
   pending checks whose dinner is still tried, oldest `plan_date` first,
   each `{dinner: {id, name, photo}, plan_date}`. `POST
   /api/v1/dinners/{id}/rotation-review` takes `{decision}`: `keep` makes
@@ -553,8 +533,8 @@ automatic** (D-021).
   received.
   `harness.Purge` deletes rows older than `harness.RunRetention` (30 days),
   clearing the `suggestion_batches` and `week_plans` references first. The
-  daily `ai_runs_purge` schedule (`harness.PurgeSchedule`) calls it with
-  its fire time less `RunRetention`.
+  harness does not call it: the scheduler's daily `ai_runs` purge
+  (Feature 20) must call `harness.Purge` with `now - RunRetention`.
 - **Concurrency guards** (`harness.Guard`, one per process): `harness.Run`
   takes a scope key, and concurrent runs of one skill with one scope share a
   single in-flight run and its result, error included (single-flight); runs
@@ -653,10 +633,7 @@ automatic** (D-021).
 
 `shopping.Freeze(weekStart)` moves a week's Supply run into the Supply
 archive: `status` becomes `archived` and `frozen_at` is set, after which
-generating the list or changing an item is 409 `archived`. In the same
-transaction each group keeps its dinner's name as `frozen_dinner_name`, so
-the frozen list and its post show the names they had when frozen, whatever
-a dinner is renamed later. It freezes only
+generating the list or changing an item is 409 `archived`. It freezes only
 a week that has ended in the household's time zone (its Monday is before
 the Monday of the household's current week), so a week not yet ended is
 `ErrWeekNotEnded` and a week with no list `ErrListNotFound`; freezing a
@@ -672,8 +649,7 @@ job failed, the freeze finds the list still untitled and makes its own
 `archive_title` attempt before freezing. A job that starts during a freeze
 waits for it, then finds the list titled (that title stands) or frozen
 untitled (the job fails `title_failed`), and stores nothing. The
-`week_rollover` schedule (`shopping.Service.RolloverSchedule`) calls
-`Freeze` for last week, judging the week ended by its fire time.
+`week_rollover` schedule is to call `Freeze` for last week.
 
 ## Recipe grounding
 
@@ -799,92 +775,16 @@ 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`). |
-| `shopping_chat_autosend` | Saturday 08:00 | Sends the coming week's Supply run to Google Chat (`shopping.Service.ChatAutosendSchedule`). |
-| `day_of_reminder` | Daily 16:30, and 15 minutes before a crock-pot start_by earlier than that | Tonight's dinner reminder and the crock-pot start reminder (`plan.Service.ReminderSchedules`). |
-| `rotation_check` | Daily 09:00 | Marks yesterday's Quest log dinners tried and asks "Keep it in rotation?" (`plan.Service.RotationCheckSchedule`). |
-| `week_rollover` | Monday 00:05 (fixed) | Freezes last week's Supply run into the Supply archive (`shopping.Service.RolloverSchedule`). |
-| `ai_runs_purge` | Daily 03:00 (fixed) | Calls `harness.Purge` to delete `ai_runs` rows past 30-day retention (`harness.PurgeSchedule`). |
+| `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. |
+| `week_rollover` | Monday 00:05 (fixed) | Freezes last week's Supply run into the Supply archive. |
+| `ai_runs` purge | Daily (fixed) | Calls `harness.Purge` to delete `ai_runs` rows past 30-day retention (Feature 20). |
 
 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`, or `DailyAt` for a time read from data) 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, and whenever the scheduler wakes late,
-every unclaimed fire time within 24 hours (`scheduler.CatchUpWindow`) is
-processed oldest first, each running once. A most recent fire time that
-passed longer ago is claimed without running (logged as missed) so it
-never runs later; older ones are not looked at. 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.
-`plan.Service.ReminderSchedules()` is `day_of_reminder`, two schedules
-of one name. The first is `Daily(reminder_time)`, period `YYYY-MM-DD`,
-and calls `EmitDayOfReminder(period.Date)`. The second has `Key` `start`,
-so its periods are `start:YYYY-MM-DD`, and a `scheduler.DailyAt` rule:
-for each date it reads the plan and fires 15 minutes
-(`plan.StartReminderLead`) before the day's `start_by` (the same
-computation the plan API shows) when the dinner is a crock-pot dinner
-whose `start_by` is earlier than that day's `reminder_time`; its run
-calls `EmitStartReminder(period.Date)`, which checks the same again. A
-date whose week has no plan emits neither and logs it. A `DailyAt` fire
-time is looked up from the data on every pass. A committed change that
-can move a `start_by` calls `Scheduler.Wake` (passed to `plan.NewService`
-and `dinners.NewService` as `wake`): a plan swap or stored draft, and a
-dinner's method or minutes changed by edit or grounding. The next pass
-comes at once, so a crock-pot dinner swapped in for tonight is still
-reminded 15 minutes before its `start_by`, not at the next hourly timer
-(`maxWait`); a lookup that fails is logged and repeated every
-`ClaimRetry`.
-`shopping.Service.ChatAutosendSchedule()` is `shopping_chat_autosend`,
-`WeeklyForNextWeek(chat_autosend_dow, chat_autosend_time)`, so its period
-names the coming week. Its run calls `Autosend(period.Week)`, which posts
-with `SendToChat(week, false)`, the household's own send, only when a
-webhook is stored, `list_ready`'s Chat channel is on
-(`notify.Service.ChannelOn`) and the week has a Supply run neither sent
-nor with a send unconfirmed; otherwise it posts nothing and logs why,
-with the key `list_ready:chat:{weekStart}`. It never resends; a send that
-fails is the period's error. `shopping.Service.RolloverSchedule()` is
-`week_rollover`, `Weekly(Monday, 00:05)`; its run freezes the week before
-the fire date's, and a week with no Supply run freezes nothing and logs
-it. `plan.Service.RotationCheckSchedule()` is `rotation_check`,
-`Daily(review_time)`, claimed as `rotation_check:YYYY-MM-DD` of the fire
-date (`Schedule.PeriodKey`). Its run calls `MarkTried` for the day before
-the fire date, which emits one `rotation_review` per Rotation check it
-opens; it never makes a dinner a Regular, and a day with no Quest log
-dinner planned opens none and logs the count.
-`harness.PurgeSchedule(store, logger)` is `ai_runs_purge`,
-`Daily(03:00)`, deleting rows created more than 30 days before the fire
-time.
-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`,
@@ -893,43 +793,25 @@ 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?week={weekStart}`) 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
     dinners Monday to Sunday.
-  - `list_ready:{weekStart}` (URL `/plan/shopping?week={weekStart}`) when a week's Supply
+  - `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)`, "Tonight: {dinner} · Recipe →",
-    naming the dinner planned on the date; it emits nothing for a week
-    with no plan. The `day_of_reminder` schedule calls it at
-    `reminder_time`.
-  - `day_of_reminder:start:{date}` (URL `/dinner/{id}`) through
-    `plan.Service.EmitStartReminder(date)`, "Start the crock pot by
-    {time}" with the dinner's name, only for a crock-pot dinner whose
-    `start_by` is earlier than `reminder_time`. The `day_of_reminder`
-    schedule calls it 15 minutes before `start_by`.
-  - `rotation_review:{dinnerId}:{planDate}` (URL `/`, where the Home card
-    asks) through `plan.Service.MarkTried(planDate)`, "How was {dinner}?
-    Keep it in rotation?", once per Rotation check it opens. The
-    `rotation_check` schedule calls it at `review_time` for yesterday.
+    `plan.Service.EmitDayOfReminder(date)`, which names the dinner planned
+    on the date and emits nothing for a week with no plan. The scheduler
+    calls it at `reminder_time` (Feature 20).
 - Delivery goes through `notification_outbox`.
 - Web Push uses VAPID (`webpush-go`). Google Chat uses the stored incoming
   webhook.
@@ -1141,10 +1023,7 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
   - The week's Supply run (Feature 17) is made from a pushed plan: after
     a successful `Push`, the handler runs `shopping.GeneratePushed` for
     the week at the plan revision `Push` pushed, and the 200 answer
-    carries `supply_run: {status, error, title_job_id}`. `title_job_id` is
-    the `title_supply_run` job titling a generated list, as for `POST
-    /shopping/{weekStart}/generate`; null when the list already has its
-    title or was not generated. `status` is `generated`;
+    carries `supply_run: {status, error}`. `status` is `generated`;
     `archived` when the week's Supply run is in the Supply archive and was
     left as it was; or `failed` — error `plan_changed` (retryable, logged
     as a warning) when the plan was edited between the push and
@@ -1167,12 +1046,8 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
   when the week has no Supply run, 400 `invalid_week`.
 - `POST /api/v1/shopping/{weekStart}/generate` makes or remakes the list
   through `shopping.Generate` and answers with the same shape plus
-  `skipped: [{date, dinner_id, dinner_name, reason}]` and
-  `title_job_id`, the `title_supply_run` job titling the list, which
-  `GET /api/v1/jobs/{id}` reports on (failed `title_failed` when the title
-  could not be written); null when the list already has its title. 404
-  when the week has no plan, 409 `archived` when its list is in the Supply
-  archive.
+  `skipped: [{date, dinner_id, dinner_name, reason}]`. 404 when the week
+  has no plan, 409 `archived` when its list is in the Supply archive.
 - `POST /api/v1/shopping/{weekStart}/send-chat` (CSRF-checked) takes
   `{}` or `{"resend": true}` and posts the Supply run to Google Chat
   through `chat.PostSupplyRun`, in the week's thread: "Supply run · " and
@@ -1193,7 +1068,7 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
   request. 404 when the week has no Supply run, 409
   `archived` when it is in the Supply archive, 400 `invalid_request` for a
   bad body. `shopping.SendToChat(weekStart, resend)` is what
-  `shopping_chat_autosend` calls, through `Autosend`.
+  `shopping_chat_autosend` calls (Feature 20).
 - `PATCH /api/v1/shopping/items/{id}` takes `{needed}` (a required
   boolean; it sets the flag, it does not flip it) and answers `{id,
   needed, needed_count, total_count}` with the list's counts after the
@@ -1208,8 +1083,7 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
   Monday is a household-local date, so the week of Monday 28 December
   is in December. `label` is the week label ("Week 41 · Oct 5 – 11"; the
   UI sets it in capitals), `title` null while untitled, `dinners` the
-  list's dinners in day order (as named when the list was frozen; the
-  current week's as named now) and `dinnerCount` their number,
+  list's dinners in day order and `dinnerCount` their number,
   `itemCount` all items, `onHandCount` the items marked "have it", and
   `current` true for the household's current week. 400 `invalid_request`
   for any other `by`. A frozen list is read through `GET
@@ -1224,7 +1098,6 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
   ```json
   {
     "dateLabel": "Friday, Oct 2",
-    "timezone": "America/Chicago",
     "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},
@@ -1234,41 +1107,15 @@ Fake-clock tests of a schedule live in `internal/scheduler`, where
 
   `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, so the PWA reads Home again at the next local midnight of
-  `timezone`, the household's IANA zone. `photo` and `minutes_total` are
-  null when unknown. `sideQuestCount` is the pending cards of the deck,
-  read without writing (`suggest.PendingCount`): a Home read never fails
-  orphaned batches the way a `suggest.Deck` read does.
+  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.
-- `GET /api/v1/updates` (`home.Service.Updates`, over `notify.Recent`)
-  answers the Recent updates sheet: the last 10 distinct events in
-  `notification_outbox`, newest first, one per event key whatever its
-  channels or delivery status (an event stored for push and Google Chat is
-  one update):
-
-  ```json
-  {"updates": [{"type": "plan_ready", "title": "…", "body": "…", "url": "/plan?week=2026-10-12", "created_at": "2026-10-09T14:00:00.000Z"}]}
-  ```
-
-  Every field comes from the stored payload, which never holds a webhook
-  URL or secret; `url` is the same-origin path the event opens.
-- `POST /api/v1/updates/seen` with `{"through": "<created_at>"}` (CSRF
-  header required) records that the household has seen its updates
-  through the newest one it was shown, and answers 204. The last-seen
-  instant is `household_settings.updates_seen_at` — the one place it is
-  stored. It only moves forward (`MarkUpdatesSeen`), so a `through` older
-  than the stored one is accepted and changes nothing, and an event
-  stored after `through` keeps `unread` true. It is not a settings edit:
-  `updated_by` and `updated_at` are left as they are and settings
-  subscribers are not told. 400 `invalid_request` for a body that is not
-  exactly that object, a `through` that is not RFC 3339, or one after
-  now.
+  never stored and never counts. Nothing writes `updates_seen_at` yet.
 
 ## Frontend
 

docs/STATES.md

@@ -1,50 +0,0 @@
-# Empty, loading and error states
-
-Every route the PWA serves — the handoff's routes plus the added Settings
-screens — with its empty, loading and error state. The handoff does not mock
-these states; it gives one pattern for each
-([handoff README](../design/MealQuest%20UI%20Designs/design_handoff_mealquest/README.md),
-"Empty / loading / error states"), and every screen uses the shared component
-for it:
-
-| State | Component | Pattern |
-| --- | --- | --- |
-| Loading | `Skeleton` ([web/src/ui/Skeleton.tsx](../web/src/ui/Skeleton.tsx)) | Pill-shaped skeletons in `--color-surface` with a 1.2 s opacity pulse (no pulse under reduced motion). |
-| Error | `ErrorBanner` ([web/src/ui/ErrorBanner.tsx](../web/src/ui/ErrorBanner.tsx)) | `--color-neutral-100` card, grape-700 (`--color-accent-700`) text, and a **Retry** button that reads or asks again. |
-| Empty | `EmptyState` ([web/src/ui/EmptyState.tsx](../web/src/ui/EmptyState.tsx)) | Bagel title, body text and an optional primary action — the Discover deck's "All caught up / New side quests arrive Sunday." with "Get more now" is the model. |
-
-[web/src/states.test.tsx](../web/src/states.test.tsx) renders the loading,
-empty and error variant of each route below against a stubbed API, asserting
-the copy and pressing Retry. Each screen's own test file covers its other
-states.
-
-The loading and error rows name the screen's main read. Smaller reads on a
-screen (a Quest log count, a calendar list, a webhook card) use the same
-`Skeleton` and `ErrorBanner` in place.
-
-## Handoff routes
-
-| Route | Screen | Empty | Loading | Error |
-| --- | --- | --- | --- | --- |
-| `/` | Home | `EmptyState` "No quest planned tonight" with **Plan this week**; rows that do not apply are hidden. | Skeletons for the date, Tonight card and status rows. | "Couldn't load tonight's quest. …" + Retry. |
-| `/onboarding` | Onboarding — Welcome step | None: the step reads nothing; it shows the welcome and the Regulars, Side quests and Quest log terms with **Let's start**. | None: nothing to read. | None: nothing to read. |
-| `/onboarding/regulars` | Onboarding — Regulars step | "Your regulars · 0" with the Common picks to add; **Next: notifications** stays disabled until enough Regulars are saved. | Skeleton under "Your regulars". | "Your Regulars could not load: …" + Retry. |
-| `/onboarding/notifications` | Onboarding — Notifications step | None: the step reads nothing. | While finishing, **Turn on notifications** and **Maybe later** are disabled. | "Could not finish setting up: …"; the buttons come back to try again, with **Add Regulars** when fewer than three Regulars are saved. |
-| `/plan` | Weekly plan (Draft board) | `EmptyState` "Nothing planned yet" with **Draft this week**. | Seven skeleton tiles ("Plan loading"; "Drafting this week" while the AI drafts). | "Couldn't load this week's plan. …" + Retry. |
-| `/plan/shopping` | Supply run | `EmptyState` "No shopping list yet" with **Make the shopping list**; an archived week with none shows "No shopping list". A list with no ingredients shows "Nothing to buy". | Skeleton title and dinner cards. | "Couldn't load the shopping list. …" + Retry. |
-| `/plan/shopping/archive` | Supply archive | `EmptyState` "Nothing archived yet" — "Each week's Supply run becomes a post here once it's made." | Skeleton posts. | "Couldn't load the Supply archive. …" + Retry. |
-| `/discover` | Side quests deck | `EmptyState` **"All caught up"** — "New side quests arrive Sunday." with **Get more now**. | Skeleton card stack (also while a batch finds more). | "Couldn't load your side quests. …" + Retry. |
-| `/quick` | Quick dinners | No ideas found: "Couldn't find Quick dinners. No ideas came back with a recipe to match." + Retry (an `ErrorBanner`, as no idea was found to show). | Six skeleton rows while the tab's ideas are found. | "Couldn't start looking for Quick dinners. …" + Retry. |
-| `/cook-from-pantry` | Cook from what I have | Before a search: no ingredient chips and **Find ideas** disabled. No ideas found: "Couldn't find ideas. No ideas came back with a recipe to match." + Retry. | Five skeleton cards ("Ideas loading"). | "Couldn't start looking for ideas. …" + Retry. |
-| `/dinner/:id` | Dinner detail | `EmptyState` "Dinner not found" — "This dinner isn't in our kitchen — it may have been removed." | Skeleton hero, title and lines. | "Couldn't load this dinner. …" + Retry. |
-| `/settings` | Settings home | Status lines "None on rotation yet", "Not connected", "Push off · Google Chat not connected". | A skeleton per status line. | "Settings could not load: …" + Retry, which reads every failed status again. |
-| `/settings/notifications` | Notifications & Google Chat | No webhook stored: the webhook form with **Save webhook**. | Skeletons for the channel matrix and the webhook card. | "Notification settings could not load: …" + Retry ("The Google Chat webhook could not load: …" for the webhook card). A failed webhook test says "Test message not sent: …" under the form. |
-| `/settings/ai` | Admin · AI assistant | No key stored: "No key stored" with **Add key**. | Skeleton. | "AI settings could not load: …" + Retry. |
-
-## Added Settings screens
-
-| Route | Screen | Empty | Loading | Error |
-| --- | --- | --- | --- | --- |
-| `/settings/household` | Household | None: the household's settings always exist, seeded on first start; the screen shows the seeded values. | Skeleton. | "Household settings could not load: …" + Retry. |
-| `/settings/regulars` | Regular dinners | "On rotation · 0" — "No Regulars yet. Add the dinners your household makes on repeat." | Skeleton. | "Your Regulars could not load: …" + Retry. |
-| `/settings/calendar` | Google Calendar | "Not connected" with **Connect Google Calendar**. | Skeleton (and one for the calendar picker). | "Google Calendar status could not load: …" + Retry ("Your calendars could not load: …" + Retry for the picker). |

internal/ai/harness/runs.go

@@ -34,8 +34,8 @@ const (
 	StatusProviderError RunStatus = "provider_error"
 )
 
-// RunRetention is how long ai_runs rows are kept. The daily purge,
-// PurgeSchedule, calls Purge with its fire time less RunRetention.
+// RunRetention is how long ai_runs rows are kept. The daily purge calls
+// Purge with time.Now().Add(-RunRetention).
 const RunRetention = 30 * 24 * time.Hour
 
 // runSaveTimeout bounds writing the ai_runs row of a run that has failed,
@@ -46,6 +46,9 @@ var runSaveTimeout = 5 * time.Second
 // Purge deletes the ai_runs rows created before olderThan and returns how
 // many it deleted. The suggestion_batches and week_plans references to
 // those rows are cleared first, in the same transaction.
+//
+// Nothing in this package calls Purge: the scheduler's daily ai_runs purge
+// (Feature 20) must call it with time.Now().Add(-RunRetention).
 func Purge(ctx context.Context, st *store.Store, olderThan time.Time) (int64, error) {
 	if olderThan.IsZero() {
 		return 0, errors.New("harness: purge ai_runs: zero cutoff")

internal/ai/harness/schedule.go

@@ -1,46 +0,0 @@
-package harness
-
-import (
-	"context"
-	"errors"
-	"log/slog"
-	"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"
-)
-
-// PurgeTime is when, every day in the household zone, ai_runs_purge runs.
-// It is fixed, not a setting.
-const PurgeTime = "03:00"
-
-// PurgeSchedule is the ai_runs_purge schedule over st: every day at
-// PurgeTime it deletes the ai_runs rows created more than RunRetention
-// before the fire time with Purge, its period scheduler.Daily keyed
-// ai_runs_purge:YYYY-MM-DD. A purge caught up late deletes no row younger
-// than RunRetention; one that fails is the period's error and is not
-// retried, and the next day's purge deletes what it left.
-func PurgeSchedule(st *store.Store, logger *slog.Logger) (scheduler.Schedule, error) {
-	if st == nil {
-		return scheduler.Schedule{}, errors.New("harness: purge schedule: nil store")
-	}
-	if logger == nil {
-		return scheduler.Schedule{}, errors.New("harness: purge schedule: nil logger")
-	}
-	return scheduler.Schedule{
-		Name: scheduler.AIRunsPurge,
-		Rule: func(household.Settings) scheduler.Rule {
-			return scheduler.Daily(PurgeTime)
-		},
-		Run: func(ctx context.Context, p scheduler.Period) error {
-			cutoff := p.FireAt.Add(-RunRetention)
-			n, err := Purge(ctx, st, cutoff)
-			if err != nil {
-				return err
-			}
-			logger.InfoContext(ctx, "ai_runs purged", "period", p.Key, "deleted", n, "created_before", cutoff.UTC().Format(time.RFC3339))
-			return nil
-		},
-	}, nil
-}

internal/auth/auth.go

@@ -79,7 +79,6 @@ type Auth struct {
 	provider *oidc.Provider
 	client   *http.Client
 	cookie   loginCookie
-	pending  *PendingStates
 	sessions Sessions
 	allowed  []string
 	// endSessionURL is the provider's end_session_endpoint; logout ends
@@ -158,7 +157,6 @@ func New(ctx context.Context, cfg Config, sessions Sessions, logger *slog.Logger
 		client:        client,
 		allowed:       slices.Clone(cfg.AllowedGroups),
 		cookie:        newLoginCookie(cfg.SecretKey),
-		pending:       NewPendingStates(loginCookieTTL),
 		sessions:      sessions,
 		endSessionURL: discovered.EndSessionURI,
 		logger:        logger,
@@ -252,13 +250,7 @@ func (a *Auth) login(w http.ResponseWriter, r *http.Request) {
 		Verifier: oauth2.GenerateVerifier(),
 		Return:   returnTo,
 	}
-	now := time.Now()
-	if err := a.pending.Add(state.State, now); err != nil {
-		a.logger.WarnContext(r.Context(), "login refused", "error", err)
-		http.Error(w, "too many sign-ins in progress; try again later", http.StatusServiceUnavailable)
-		return
-	}
-	if err := a.cookie.set(w, state, now); err != nil {
+	if err := a.cookie.set(w, state, time.Now()); err != nil {
 		a.logger.ErrorContext(r.Context(), "set login cookie", "error", err)
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
@@ -270,7 +262,7 @@ func (a *Auth) login(w http.ResponseWriter, r *http.Request) {
 }
 
 // callback completes the flow: it checks state against the login cookie,
-// consumes it, exchanges the code, verifies the ID token and nonce, then starts a session
+// exchanges the code, verifies the ID token and nonce, then starts a session
 // if the account is in an allowed group. Membership is checked on every
 // login, so an account removed from the group is refused at its next one.
 func (a *Auth) callback(w http.ResponseWriter, r *http.Request) {
@@ -291,13 +283,6 @@ func (a *Auth) callback(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "sign-in state mismatch; start again", http.StatusBadRequest)
 		return
 	}
-	// A copy of the cookie verifies until it expires, so the state is
-	// single-use only because it is consumed here.
-	if !a.pending.Consume(state.State) {
-		a.logger.WarnContext(ctx, "login callback state already used")
-		http.Error(w, "sign-in state mismatch; start again", http.StatusBadRequest)
-		return
-	}
 	if q.Get("error") != "" {
 		// error and error_description are provider-supplied text; only the
 		// fixed category is logged.

internal/auth/auth_test.go

@@ -497,59 +497,6 @@ func TestCallbackDefaultReturnPath(t *testing.T) {
 	}
 }
 
-// A saved copy of the login cookie still verifies until it expires, so a
-// replay with a second valid code is refused only because the server
-// consumed the state on first use.
-func TestCallbackRefusesReplayedLoginState(t *testing.T) {
-	t.Parallel()
-	h := newHarness(t)
-	l := h.login(t, LoginPath)
-	idToken := h.provider.signRS256(h.provider.claims(l.query.Get("nonce")))
-
-	if resp := h.callback(l, l.query.Get("state"), idToken); resp.StatusCode != http.StatusSeeOther {
-		t.Fatalf("first callback status = %d, want 303", resp.StatusCode)
-	}
-	resp := h.callback(l, l.query.Get("state"), idToken)
-	if resp.StatusCode != http.StatusBadRequest {
-		t.Errorf("replayed callback status = %d, want 400", resp.StatusCode)
-	}
-	if n := len(h.sessions.started()); n != 1 {
-		t.Errorf("%d sessions started, want 1", n)
-	}
-	assertLoginCookieCleared(t, resp)
-}
-
-// Pending login states live in memory, so a login started before a restart
-// fails closed after it even though its cookie still verifies.
-func TestCallbackRefusesLoginStartedBeforeRestart(t *testing.T) {
-	t.Parallel()
-	h := newHarness(t)
-	l := h.login(t, LoginPath)
-
-	restarted, err := New(context.Background(), Config{
-		Issuer:        h.provider.issuer(),
-		ClientID:      testClientID,
-		ClientSecret:  testClientSecret,
-		PublicURL:     testPublicURL,
-		SecretKey:     []byte("server-secret-key"),
-		AllowedGroups: testAllowedGroups,
-	}, h.sessions, slog.New(slog.DiscardHandler))
-	if err != nil {
-		t.Fatal(err)
-	}
-	r := chi.NewRouter()
-	restarted.Mount(r)
-	h.router = r
-
-	resp := h.callback(l, l.query.Get("state"), h.provider.signRS256(h.provider.claims(l.query.Get("nonce"))))
-	if resp.StatusCode != http.StatusBadRequest {
-		t.Errorf("callback after restart status = %d, want 400", resp.StatusCode)
-	}
-	if n := len(h.sessions.started()); n != 0 {
-		t.Errorf("%d sessions started, want none", n)
-	}
-}
-
 func TestCallbackRejected(t *testing.T) {
 	t.Parallel()
 
@@ -872,44 +819,6 @@ func TestLoginCookieExpires(t *testing.T) {
 	}
 }
 
-func TestPendingStates(t *testing.T) {
-	t.Parallel()
-	p := NewPendingStates(time.Minute)
-	now := time.Now()
-	if err := p.Add("first", now); err != nil {
-		t.Fatal(err)
-	}
-	if !p.Consume("first") {
-		t.Error("Consume of a pending state = false")
-	}
-	if p.Consume("first") {
-		t.Error("second Consume of a state = true")
-	}
-	if p.Consume("never-added") {
-		t.Error("Consume of an unknown state = true")
-	}
-
-	for i := range maxPendingStates - 1 {
-		if err := p.Add(fmt.Sprint("s", i), now); err != nil {
-			t.Fatalf("Add %d: %v", i, err)
-		}
-	}
-	// "first" was consumed but has not expired, so it still counts.
-	if err := p.Add("over", now); !errors.Is(err, ErrTooManyPending) {
-		t.Errorf("Add past the bound = %v, want ErrTooManyPending", err)
-	}
-	// Once the earlier states expire, they are forgotten and a new one fits.
-	if err := p.Add("later", now.Add(time.Minute)); err != nil {
-		t.Errorf("Add after expiry: %v", err)
-	}
-	if p.Consume("s0") {
-		t.Error("an expired state was still pending")
-	}
-	if !p.Consume("later") {
-		t.Error("the state added after expiry is not pending")
-	}
-}
-
 func TestLoginRejectsOffOriginReturn(t *testing.T) {
 	t.Parallel()
 	h := newHarness(t)

internal/auth/cookie.go

@@ -10,7 +10,6 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
-	"sync"
 	"time"
 )
 
@@ -154,73 +153,6 @@ func (c FlowCookie) Read(r *http.Request, v flowValue, now time.Time) error {
 	return nil
 }
 
-// maxPendingStates bounds each flow's pending states. The login route is
-// unauthenticated, so without a bound anyone could grow the set without
-// limit; one household never has close to this many flows in progress.
-const maxPendingStates = 10000
-
-// ErrTooManyPending means a flow's pending states are at maxPendingStates,
-// so a new flow is refused until older ones expire.
-var ErrTooManyPending = errors.New("too many sign-in flows in progress")
-
-// PendingStates holds the state of every redirect flow started and not yet
-// completed, until its flow cookie expires. A copy of a flow cookie verifies
-// until it expires, so a flow is single-use only because its callback
-// consumes the state here. The states live in memory — MealQuest runs as one
-// process — so a flow started before a restart fails closed after it.
-type PendingStates struct {
-	ttl    time.Duration
-	mu     sync.Mutex
-	states map[string]time.Time
-	// order is every added state in the order added. Every state is pending
-	// for the same ttl, so it is also expiry order and Add forgets expired
-	// states from its front.
-	order []pendingState
-}
-
-type pendingState struct {
-	state   string
-	expires time.Time
-}
-
-// NewPendingStates returns an empty set whose states are pending for ttl,
-// the flow cookie's lifetime.
-func NewPendingStates(ttl time.Duration) *PendingStates {
-	return &PendingStates{ttl: ttl, states: map[string]time.Time{}}
-}
-
-// Add records state, started at now, as pending and forgets expired ones.
-// It fails with ErrTooManyPending when maxPendingStates are pending.
-func (p *PendingStates) Add(state string, now time.Time) error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	expired := 0
-	for expired < len(p.order) && !now.Before(p.order[expired].expires) {
-		delete(p.states, p.order[expired].state)
-		expired++
-	}
-	p.order = p.order[expired:]
-	// The bound counts every unexpired state, consumed or not: a consumed
-	// state leaves states at once but order only when it expires.
-	if len(p.order) >= maxPendingStates {
-		return ErrTooManyPending
-	}
-	expires := now.Add(p.ttl)
-	p.states[state] = expires
-	p.order = append(p.order, pendingState{state: state, expires: expires})
-	return nil
-}
-
-// Consume removes state from the pending states, reporting whether it was
-// there.
-func (p *PendingStates) Consume(state string) bool {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	_, ok := p.states[state]
-	delete(p.states, state)
-	return ok
-}
-
 // returnPath validates the optional post-login return path. Empty means "/".
 // Only same-origin absolute paths are allowed: no scheme, host, protocol-
 // relative "//" prefix, backslashes or control characters.

internal/chat/chat_test.go

@@ -308,7 +308,7 @@ func TestSendThreadsByWeek(t *testing.T) {
 		ListReady(week, 19, 7),
 		DayOfReminder(mustDate(t, "2026-10-18"), "01J9DINNER", "Tacos"),
 		NewSuggestions("01J9BATCH", week, []string{"Pho"}),
-		RotationReview("01J9DINNER", "Pho", mustDate(t, "2026-10-14")),
+		RotationReview("01J9DINNER", "Pho", week),
 	}
 	for _, ev := range events {
 		if err := svc.Send(ctx, notify.Message{ID: "n1", EventKey: ev.Key, Channel: notify.ChannelChat, Payload: payloadOf(ev), Attempt: 1}); err != nil {
@@ -342,8 +342,8 @@ func TestSendThreadsByWeek(t *testing.T) {
 		t.Errorf("plan text = %q", reqs[0].Body["text"])
 	}
 
-	// The cards' "Open" buttons link under the public URL to the event's week.
-	for i, wantLink := range map[int]string{0: "https://mealquest.example/plan?week=2026-10-12", 1: "https://mealquest.example/plan/shopping?week=2026-10-12"} {
+	// The cards' "Open" buttons link under the public URL.
+	for i, wantLink := range map[int]string{0: "https://mealquest.example/plan", 1: "https://mealquest.example/plan/shopping"} {
 		data, _ := json.Marshal(reqs[i].Body["cardsV2"])
 		var cards []cardV2
 		if err := json.Unmarshal(data, &cards); err != nil || len(cards) != 1 {

internal/chat/messages.go

@@ -2,7 +2,6 @@ package chat
 
 import (
 	"fmt"
-	"net/url"
 	"strings"
 	"time"
 
@@ -47,7 +46,7 @@ func PlanReady(week, thisWeek store.LocalDate, dinners []string) notify.Event {
 		Key:   string(notify.PlanReady) + ":" + week.String(),
 		Title: planTitle(week, thisWeek),
 		Body:  nameList(dinners),
-		URL:   "/plan?" + url.Values{"week": {week.String()}}.Encode(),
+		URL:   "/plan",
 		Week:  week,
 	}
 }
@@ -60,65 +59,48 @@ func ListReady(week store.LocalDate, needed, dinners int) notify.Event {
 		Key:   string(notify.ListReady) + ":" + week.String(),
 		Title: "This week's Supply run is ready",
 		Body:  fmt.Sprintf("%s to buy for %s", count(needed, "item", "items"), count(dinners, "dinner", "dinners")),
-		URL:   "/plan/shopping?" + url.Values{"week": {week.String()}}.Encode(),
+		URL:   "/plan/shopping",
 		Week:  week,
 	}
 }
 
 // DayOfReminder is the day_of_reminder event of the dinner dinnerID, named
-// name, planned on date: "Tonight: Tacos · Recipe →", a title carrying its
-// own call to action.
+// name, planned on date.
 func DayOfReminder(date store.LocalDate, dinnerID, name string) notify.Event {
 	return notify.Event{
 		Type:  notify.DayOfReminder,
 		Key:   string(notify.DayOfReminder) + ":" + date.String(),
-		Title: "Tonight: " + name + " · Recipe →",
-		URL:   "/dinner/" + dinnerID,
-		Week:  household.WeekStart(date),
-	}
-}
-
-// StartReminder is the day_of_reminder event, keyed
-// day_of_reminder:start:{date}, reminding the household to start the
-// crock-pot dinner dinnerID, named name and planned on date, by startBy,
-// a time in the household zone: "Start the crock pot by 9:30 am".
-func StartReminder(date store.LocalDate, dinnerID, name string, startBy time.Time) notify.Event {
-	return notify.Event{
-		Type:  notify.DayOfReminder,
-		Key:   string(notify.DayOfReminder) + ":start:" + date.String(),
-		Title: "Start the crock pot by " + startBy.Format("3:04 pm"),
+		Title: "Tonight's dinner",
 		Body:  name,
 		URL:   "/dinner/" + dinnerID,
 		Week:  household.WeekStart(date),
 	}
 }
 
-// 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,
 	}
 }
 
-// RotationReview is the rotation_review event, keyed
-// rotation_review:{dinnerID}:{planDate}, of the Rotation check of the
-// dinner dinnerID, named name and tried on planDate: "How was Pho? Keep it
-// in rotation?". It opens Home, where the Rotation check card asks.
-func RotationReview(dinnerID, name string, planDate store.LocalDate) notify.Event {
+// RotationReview is the rotation_review event asking whether the dinner
+// dinnerID, named name and tried in the week starting on week, becomes a
+// Regular.
+func RotationReview(dinnerID, name string, week store.LocalDate) notify.Event {
 	return notify.Event{
 		Type:  notify.RotationReview,
-		Key:   string(notify.RotationReview) + ":" + dinnerID + ":" + planDate.String(),
-		Title: "How was " + name + "? Keep it in rotation?",
+		Key:   string(notify.RotationReview) + ":" + dinnerID,
+		Title: "Keep it in rotation?",
+		Body:  "You tried " + name + ". Make it a Regular?",
 		URL:   "/",
-		Week:  household.WeekStart(planDate),
+		Week:  week,
 	}
 }
 
@@ -189,13 +171,9 @@ func planTitle(week, thisWeek store.LocalDate) string {
 }
 
 // Text is the Google Chat message of p: its title, its body after a colon
-// and the event's call to action with an arrow. A title ending in an arrow,
-// with no body, carries its own call to action and is the message as it is.
+// and the event's call to action with an arrow.
 func Text(p notify.Payload) string {
 	text := p.Title
-	if p.Body == "" && strings.HasSuffix(text, "→") {
-		return text
-	}
 	if p.Body != "" {
 		if endsSentence(text) {
 			text += " "

internal/chat/messages_test.go

@@ -2,7 +2,6 @@ package chat
 
 import (
 	"testing"
-	"time"
 
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
@@ -39,7 +38,7 @@ func TestMessages(t *testing.T) {
 			name:  "plan ready",
 			ev:    PlanReady(week, week, []string{"Tacos", "Bolognese", "Tikka masala", "Lemon orzo", "Bibimbap", "Shakshuka", "Chili"}),
 			key:   "plan_ready:2026-10-12",
-			url:   "/plan?week=2026-10-12",
+			url:   "/plan",
 			week:  "2026-10-12",
 			title: "This week's plan is ready",
 			body:  "Tacos, Bolognese, Tikka masala + 4 more",
@@ -49,7 +48,7 @@ func TestMessages(t *testing.T) {
 			name:  "plan ready with three dinners",
 			ev:    PlanReady(week, week, []string{"Tacos", "Bolognese", "Tikka masala"}),
 			key:   "plan_ready:2026-10-12",
-			url:   "/plan?week=2026-10-12",
+			url:   "/plan",
 			week:  "2026-10-12",
 			title: "This week's plan is ready",
 			body:  "Tacos, Bolognese, Tikka masala",
@@ -59,7 +58,7 @@ func TestMessages(t *testing.T) {
 			name:  "plan ready for next week",
 			ev:    PlanReady(week, mustDate(t, "2026-10-05"), []string{"Tacos", "Bolognese", "Tikka masala", "Lemon orzo"}),
 			key:   "plan_ready:2026-10-12",
-			url:   "/plan?week=2026-10-12",
+			url:   "/plan",
 			week:  "2026-10-12",
 			title: "Next week's plan is ready",
 			body:  "Tacos, Bolognese, Tikka masala + 1 more",
@@ -69,7 +68,7 @@ func TestMessages(t *testing.T) {
 			name:  "plan ready for a later week",
 			ev:    PlanReady(mustDate(t, "2026-10-26"), mustDate(t, "2026-10-05"), []string{"Tacos"}),
 			key:   "plan_ready:2026-10-26",
-			url:   "/plan?week=2026-10-26",
+			url:   "/plan",
 			week:  "2026-10-26",
 			title: "The plan for the week of Oct 26 is ready",
 			body:  "Tacos",
@@ -79,7 +78,7 @@ func TestMessages(t *testing.T) {
 			name:  "list ready",
 			ev:    ListReady(week, 19, 7),
 			key:   "list_ready:2026-10-12",
-			url:   "/plan/shopping?week=2026-10-12",
+			url:   "/plan/shopping",
 			week:  "2026-10-12",
 			title: "This week's Supply run is ready",
 			body:  "19 items to buy for 7 dinners",
@@ -89,7 +88,7 @@ func TestMessages(t *testing.T) {
 			name:  "list ready singular",
 			ev:    ListReady(week, 1, 1),
 			key:   "list_ready:2026-10-12",
-			url:   "/plan/shopping?week=2026-10-12",
+			url:   "/plan/shopping",
 			week:  "2026-10-12",
 			title: "This week's Supply run is ready",
 			body:  "1 item to buy for 1 dinner",
@@ -101,19 +100,9 @@ func TestMessages(t *testing.T) {
 			key:   "day_of_reminder:2026-10-15",
 			url:   "/dinner/01J9Z8Y7X6W5V4T3S2R1Q0P9N8",
 			week:  "2026-10-12",
-			title: "Tonight: Tacos · Recipe →",
-			body:  "",
-			chatT: "Tonight: Tacos · Recipe →",
-		},
-		{
-			name:  "crock-pot start reminder",
-			ev:    StartReminder(mustDate(t, "2026-10-15"), "01J9Z8Y7X6W5V4T3S2R1Q0P9N8", "Beef Chili", time.Date(2026, 10, 15, 9, 30, 0, 0, time.FixedZone("CDT", -5*60*60))),
-			key:   "day_of_reminder:start:2026-10-15",
-			url:   "/dinner/01J9Z8Y7X6W5V4T3S2R1Q0P9N8",
-			week:  "2026-10-12",
-			title: "Start the crock pot by 9:30 am",
-			body:  "Beef Chili",
-			chatT: "Start the crock pot by 9:30 am: Beef Chili. Open the recipe →",
+			title: "Tonight's dinner",
+			body:  "Tacos",
+			chatT: "Tonight's dinner: Tacos. Open the recipe →",
 		},
 		{
 			name:  "new suggestions",
@@ -121,29 +110,19 @@ 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",
-			ev:    RotationReview("01J9DINNER", "Lemon orzo", mustDate(t, "2026-10-14")),
-			key:   "rotation_review:01J9DINNER:2026-10-14",
+			ev:    RotationReview("01J9DINNER", "Lemon orzo", week),
+			key:   "rotation_review:01J9DINNER",
 			url:   "/",
 			week:  "2026-10-12",
-			title: "How was Lemon orzo? Keep it in rotation?",
-			body:  "",
-			chatT: "How was Lemon orzo? Keep it in rotation? Open MealQuest →",
+			title: "Keep it in rotation?",
+			body:  "You tried Lemon orzo. Make it a Regular?",
+			chatT: "Keep it in rotation? You tried Lemon orzo. Make it a Regular? Open MealQuest →",
 		},
 	} {
 		ev := tc.ev

internal/db/models.go

@@ -255,14 +255,13 @@ type Session struct {
 }
 
 type ShoppingGroup struct {
-	ID               string
-	ListID           string
-	DinnerID         string
-	Date             string
-	Position         int64
-	CreatedAt        string
-	UpdatedAt        string
-	FrozenDinnerName sql.NullString
+	ID        string
+	ListID    string
+	DinnerID  string
+	Date      string
+	Position  int64
+	CreatedAt string
+	UpdatedAt string
 }
 
 type ShoppingItem struct {

internal/db/notifications.sql.go

@@ -182,53 +182,6 @@ func (q *Queries) ListNotificationPrefs(ctx context.Context) ([]NotificationPref
 	return items, nil
 }
 
-const listRecentNotifications = `-- name: ListRecentNotifications :many
-SELECT o.event_key, o.payload, o.created_at FROM notification_outbox o
-WHERE o.id = (
-	SELECT i.id FROM notification_outbox i
-	WHERE i.event_key = o.event_key
-	ORDER BY i.created_at DESC, i.id DESC
-	LIMIT 1
-)
-ORDER BY o.created_at DESC, o.event_key DESC
-LIMIT ?1
-`
-
-type ListRecentNotificationsRow struct {
-	EventKey  string
-	Payload   string
-	CreatedAt string
-}
-
-// Returns the last lim distinct events stored, newest first: one row per
-// event key, the last stored for it whatever its channel, so an event
-// stored for push and Google Chat is one row. The last, because a channel
-// switched on later can store the same event key again, and
-// HasNotificationSince counts that row: an event is as new as its newest
-// row, so marking it seen also covers that row.
-func (q *Queries) ListRecentNotifications(ctx context.Context, lim int64) ([]ListRecentNotificationsRow, error) {
-	rows, err := q.db.QueryContext(ctx, listRecentNotifications, lim)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []ListRecentNotificationsRow
-	for rows.Next() {
-		var i ListRecentNotificationsRow
-		if err := rows.Scan(&i.EventKey, &i.Payload, &i.CreatedAt); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
 const markNotificationSent = `-- name: MarkNotificationSent :execrows
 UPDATE notification_outbox
 SET status = 'sent', attempts = attempts + 1, next_attempt_at = NULL, updated_at = ?1

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
@@ -107,9 +104,6 @@ type Querier interface {
 	// Records a pending or running batch as done or failed; a batch already
 	// finished is left as it is (0 rows).
 	FinishSuggestionBatch(ctx context.Context, arg FinishSuggestionBatchParams) (int64, error)
-	// Keeps the name each dinner of list list_id has now as its group's
-	// frozen_dinner_name, as the list is frozen into the Supply archive.
-	FreezeShoppingGroupNames(ctx context.Context, listID string) error
 	// Freezes list id into the Supply archive at frozen_at, unless it is
 	// frozen already.
 	FreezeShoppingList(ctx context.Context, arg FreezeShoppingListParams) (int64, error)
@@ -218,21 +212,13 @@ type Querier interface {
 	// Every stored subscription with its keys, for the push sender, oldest
 	// first.
 	ListPushSubscriptions(ctx context.Context) ([]ListPushSubscriptionsRow, error)
-	// Returns the last lim distinct events stored, newest first: one row per
-	// event key, the last stored for it whatever its channel, so an event
-	// stored for push and Google Chat is one row. The last, because a channel
-	// switched on later can store the same event key again, and
-	// HasNotificationSince counts that row: an event is as new as its newest
-	// row, so marking it seen also covers that row.
-	ListRecentNotifications(ctx context.Context, lim int64) ([]ListRecentNotificationsRow, error)
 	// Reads for the AI household context block (internal/ai/harness).
 	// The most recent names the household turned down, newest first, as
 	// ListPassedNames has them.
 	ListRecentPassedNames(ctx context.Context, limit int64) ([]string, error)
 	ListRecipeIngredients(ctx context.Context, recipeID string) ([]RecipeIngredient, error)
 	ListRecipeSteps(ctx context.Context, recipeID string) ([]RecipeStep, error)
-	// The groups of list list_id with their dinner's name now, in list order.
-	// A group of a frozen list shows its frozen_dinner_name instead.
+	// The groups of list list_id with their dinner's name, in list order.
 	ListShoppingGroupDinners(ctx context.Context, listID string) ([]ListShoppingGroupDinnersRow, error)
 	// The groups of list list_id, in list order.
 	ListShoppingGroups(ctx context.Context, listID string) ([]ShoppingGroup, error)
@@ -268,10 +254,6 @@ type Querier interface {
 	// Records list id sent to Google Chat at sent_to_chat_at, its send
 	// confirmed, unless it is frozen into the Supply archive.
 	MarkShoppingListSentToChat(ctx context.Context, arg MarkShoppingListSentToChatParams) (int64, error)
-	// Moves updates_seen_at forward to seen_at; affects no row when it is
-	// already at or after seen_at, so it never moves back. It is not a settings
-	// edit: updated_by and updated_at are left as they are.
-	MarkUpdatesSeen(ctx context.Context, seenAt string) (int64, error)
 	// Records an edit of plan id, raising its revision: a synced plan becomes
 	// changed, any other keeps its status.
 	MarkWeekPlanEdited(ctx context.Context, arg MarkWeekPlanEditedParams) error

internal/db/recipes.sql.go

@@ -220,7 +220,7 @@ func (q *Queries) GetRecipeBySourceURL(ctx context.Context, sourceUrl string) (R
 const listRecipeIngredients = `-- name: ListRecipeIngredients :many
 SELECT id, recipe_id, position, raw_text, name, qty, unit, note, created_at, updated_at FROM recipe_ingredients
 WHERE recipe_id = ?
-ORDER BY position
+ORDER BY position, id
 `
 
 func (q *Queries) ListRecipeIngredients(ctx context.Context, recipeID string) ([]RecipeIngredient, error) {
@@ -260,7 +260,7 @@ func (q *Queries) ListRecipeIngredients(ctx context.Context, recipeID string) ([
 const listRecipeSteps = `-- name: ListRecipeSteps :many
 SELECT id, recipe_id, position, text, created_at, updated_at FROM recipe_steps
 WHERE recipe_id = ?
-ORDER BY position
+ORDER BY position, id
 `
 
 func (q *Queries) ListRecipeSteps(ctx context.Context, recipeID string) ([]RecipeStep, error) {

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/db/settings.sql.go

@@ -161,23 +161,6 @@ func (q *Queries) GetRecipeSearchSettings(ctx context.Context) (RecipeSearchSett
 	return i, err
 }
 
-const markUpdatesSeen = `-- name: MarkUpdatesSeen :execrows
-UPDATE household_settings
-SET updates_seen_at = CAST(?1 AS TEXT)
-WHERE id = 1 AND (updates_seen_at IS NULL OR updates_seen_at < CAST(?1 AS TEXT))
-`
-
-// Moves updates_seen_at forward to seen_at; affects no row when it is
-// already at or after seen_at, so it never moves back. It is not a settings
-// edit: updated_by and updated_at are left as they are.
-func (q *Queries) MarkUpdatesSeen(ctx context.Context, seenAt string) (int64, error) {
-	result, err := q.db.ExecContext(ctx, markUpdatesSeen, seenAt)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected()
-}
-
 const recordChatTest = `-- name: RecordChatTest :execrows
 UPDATE chat_settings
 SET last_test_at = ?, last_test_status = ?, updated_at = ?

internal/db/shopping.sql.go

@@ -155,19 +155,6 @@ func (q *Queries) DeleteShoppingItem(ctx context.Context, id string) error {
 	return err
 }
 
-const freezeShoppingGroupNames = `-- name: FreezeShoppingGroupNames :exec
-UPDATE shopping_groups
-SET frozen_dinner_name = (SELECT dinners.name FROM dinners WHERE dinners.id = shopping_groups.dinner_id)
-WHERE list_id = ?
-`
-
-// Keeps the name each dinner of list list_id has now as its group's
-// frozen_dinner_name, as the list is frozen into the Supply archive.
-func (q *Queries) FreezeShoppingGroupNames(ctx context.Context, listID string) error {
-	_, err := q.db.ExecContext(ctx, freezeShoppingGroupNames, listID)
-	return err
-}
-
 const freezeShoppingList = `-- name: FreezeShoppingList :execrows
 UPDATE shopping_lists
 SET status = 'archived', frozen_at = ?, updated_at = ?
@@ -248,7 +235,7 @@ func (q *Queries) GetShoppingList(ctx context.Context, weekStart string) (Shoppi
 }
 
 const listShoppingGroupDinners = `-- name: ListShoppingGroupDinners :many
-SELECT shopping_groups.id, shopping_groups.list_id, shopping_groups.dinner_id, shopping_groups.date, shopping_groups.position, shopping_groups.created_at, shopping_groups.updated_at, shopping_groups.frozen_dinner_name, dinners.name AS dinner_name
+SELECT shopping_groups.id, shopping_groups.list_id, shopping_groups.dinner_id, shopping_groups.date, shopping_groups.position, shopping_groups.created_at, shopping_groups.updated_at, dinners.name AS dinner_name
 FROM shopping_groups
 JOIN dinners ON dinners.id = shopping_groups.dinner_id
 WHERE shopping_groups.list_id = ?
@@ -260,8 +247,7 @@ type ListShoppingGroupDinnersRow struct {
 	DinnerName    string
 }
 
-// The groups of list list_id with their dinner's name now, in list order.
-// A group of a frozen list shows its frozen_dinner_name instead.
+// The groups of list list_id with their dinner's name, in list order.
 func (q *Queries) ListShoppingGroupDinners(ctx context.Context, listID string) ([]ListShoppingGroupDinnersRow, error) {
 	rows, err := q.db.QueryContext(ctx, listShoppingGroupDinners, listID)
 	if err != nil {
@@ -279,7 +265,6 @@ func (q *Queries) ListShoppingGroupDinners(ctx context.Context, listID string) (
 			&i.ShoppingGroup.Position,
 			&i.ShoppingGroup.CreatedAt,
 			&i.ShoppingGroup.UpdatedAt,
-			&i.ShoppingGroup.FrozenDinnerName,
 			&i.DinnerName,
 		); err != nil {
 			return nil, err
@@ -296,7 +281,7 @@ func (q *Queries) ListShoppingGroupDinners(ctx context.Context, listID string) (
 }
 
 const listShoppingGroups = `-- name: ListShoppingGroups :many
-SELECT id, list_id, dinner_id, date, position, created_at, updated_at, frozen_dinner_name FROM shopping_groups
+SELECT id, list_id, dinner_id, date, position, created_at, updated_at FROM shopping_groups
 WHERE list_id = ?
 ORDER BY position, id
 `
@@ -319,7 +304,6 @@ func (q *Queries) ListShoppingGroups(ctx context.Context, listID string) ([]Shop
 			&i.Position,
 			&i.CreatedAt,
 			&i.UpdatedAt,
-			&i.FrozenDinnerName,
 		); err != nil {
 			return nil, err
 		}

internal/dinners/detail.go

@@ -58,14 +58,14 @@ type Ingredient struct {
 	RawText string  `json:"raw_text"`
 }
 
-// Source is the site a recipe was fetched from, as SourceOf gives it.
-// SiteName is the name the page gives its site, else the host of URL when
-// URL is shown, else null. URL is the page's link only when it is
-// verifiably free of secrets (see safeSourceURL), and null otherwise: a
-// link pasted or offered as a candidate may carry a personal token, so a
-// client links the credit only when URL is not null. Source is set for
-// every fetched recipe, so a client always credits it: by SiteName, else
-// without naming the site.
+// Source is the site a recipe was fetched from. SiteName is the name the
+// page itself gives its site, and null when it gives none or the stored
+// name could have come from a link (see pageSiteName). URL is the page's
+// link only when it is verifiably free of secrets (see safeSourceURL), and
+// null otherwise: a link pasted or offered as a candidate may carry a
+// personal token, so a client links the credit only when URL is not null.
+// Source is set for every fetched recipe, so a client always credits it:
+// by SiteName, else by URL's host, else without naming the site.
 type Source struct {
 	SiteName *string `json:"site_name"`
 	URL      *string `json:"url"`
@@ -157,7 +157,10 @@ func readRecipe(ctx context.Context, q *db.Queries, recipeID string, d *Detail)
 	if err != nil {
 		return fmt.Errorf("ingredients: %w", err)
 	}
-	for _, ing := range ings {
+	for i, ing := range ings {
+		if i > 0 && ing.Position == ings[i-1].Position {
+			return duplicatePosition("ingredient", ing.Position)
+		}
 		d.Ingredients = append(d.Ingredients, Ingredient{
 			Name:    nullString(ing.Name),
 			Qty:     nullString(ing.Qty),
@@ -170,46 +173,52 @@ func readRecipe(ctx context.Context, q *db.Queries, recipeID string, d *Detail)
 	if err != nil {
 		return fmt.Errorf("steps: %w", err)
 	}
-	for _, step := range steps {
+	for i, step := range steps {
+		if i > 0 && step.Position == steps[i-1].Position {
+			return duplicatePosition("step", step.Position)
+		}
 		d.Steps = append(d.Steps, step.Text)
 	}
 	return nil
 }
 
 // SourceOf is the Source of a recipe fetched from sourceURL whose stored
-// site name is siteName, the name its page gave (recipes.Recipe.SiteName),
-// null when the page named none. It is the one rule by which a fetched
-// recipe's source reaches a client — the recipe detail, an idea and a
-// recipe candidate offered for a dinner alike:
-//
-//   - the link is shown only when it is free of secrets (see
-//     safeSourceURL);
-//   - a site name the page gave is shown as it stands, as the page
-//     publishes it to everyone who reads it;
-//   - otherwise the site is named by the link's host without a leading
-//     "www.", and only when the link itself is shown, so the name tells
-//     nothing the shown link does not; else it is null.
-//
-// A host is never stored as a site name, so a stored name is always the
-// page's: migration 0020 cleared the names stored before that, when a
-// page naming no site was stored under its host. A sourceURL that does not
-// parse is an error, whether or not a site name is 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")
 	}
-	src := Source{URL: safeSourceURL(sourceURL)}
-	switch {
-	case siteName.Valid && siteName.String != "":
-		name := siteName.String
-		src.SiteName = &name
-	case src.URL != nil:
-		host := strings.TrimPrefix(link.Hostname(), "www.")
-		src.SiteName = &host
+	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
+// subdomain), or that of a page the link redirected to, which is not
+// stored. Nothing records which a stored name is, so any name that could
+// be a host — the link's own host, an IP address, or a dotted host name —
+// 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, link *url.URL) *string {
+	if !stored.Valid {
+		return nil
 	}
-	return src, nil
+	name := stored.String
+	if strings.EqualFold(name, recipes.HostSiteName(link)) || net.ParseIP(name) != nil {
+		return nil
+	}
+	if u, err := url.Parse("https://" + name + "/"); err == nil && u.Host == name && strings.Contains(name, ".") {
+		return nil
+	}
+	return &name
 }
 
 // safeSourceURL is sourceURL when it is verifiably free of secrets — an
@@ -274,3 +283,11 @@ func browserHost(u *url.URL) bool {
 	}
 	return true
 }
+
+// duplicatePosition is the error for two recipe items of kind at position.
+// Position is the only record of recipe order, and the id that breaks the
+// tie says nothing about it, so a recipe with a duplicate is refused rather
+// than shown in an order nobody can trust.
+func duplicatePosition(kind string, position int64) error {
+	return fmt.Errorf("two %ss at position %d: recipe order is unknown", kind, position)
+}

internal/dinners/dinners.go

@@ -138,9 +138,6 @@ type Service struct {
 	grounder  *recipes.Grounder
 	logger    *slog.Logger
 	groundJob *jobs.Kind[GroundJob]
-	// wake is called after every committed change to a dinner's method or
-	// minutes, which can move its crock-pot start reminder.
-	wake func()
 
 	// groundingsMu guards groundings: the KindGroundDinner jobs running,
 	// by dinner id, so archiving or renaming a dinner can stop them.
@@ -160,11 +157,10 @@ type Service struct {
 	offerSearches map[string]map[*offerSearch]struct{}
 }
 
-// NewService returns a service over st that grounds dinners with grounder,
-// calls wake (the scheduler's Wake) after every committed change to a
-// dinner's method or minutes, and registers the KindGroundDinner job on
-// runner, which must not have started yet.
-func NewService(st *store.Store, grounder *recipes.Grounder, runner *jobs.Runner, wake func(), logger *slog.Logger) (*Service, error) {
+// NewService returns a service over st that grounds dinners with grounder
+// and registers the KindGroundDinner job on runner, which must not have
+// started yet.
+func NewService(st *store.Store, grounder *recipes.Grounder, runner *jobs.Runner, logger *slog.Logger) (*Service, error) {
 	switch {
 	case st == nil:
 		return nil, errors.New("dinners: nil store")
@@ -172,12 +168,10 @@ func NewService(st *store.Store, grounder *recipes.Grounder, runner *jobs.Runner
 		return nil, errors.New("dinners: nil grounder")
 	case runner == nil:
 		return nil, errors.New("dinners: nil job runner")
-	case wake == nil:
-		return nil, errors.New("dinners: nil wake")
 	case logger == nil:
 		return nil, errors.New("dinners: nil logger")
 	}
-	s := &Service{st: st, grounder: grounder, wake: wake, logger: logger, groundings: make(map[string]map[*runningGrounding]struct{}), offerKey: make([]byte, 32), offers: make(map[string]*offerSet), offerSearches: make(map[string]map[*offerSearch]struct{})}
+	s := &Service{st: st, grounder: grounder, logger: logger, groundings: make(map[string]map[*runningGrounding]struct{}), offerKey: make([]byte, 32), offers: make(map[string]*offerSet), offerSearches: make(map[string]map[*offerSearch]struct{})}
 	rand.Read(s.offerKey) // never fails: it crashes the program instead
 	kind, err := jobs.Register(runner, KindGroundDinner, s.runGroundJob, Reasons...)
 	if err != nil {
@@ -508,9 +502,6 @@ func (s *Service) Update(ctx context.Context, id string, p Patch, updatedBy stri
 	if err != nil {
 		return Dinner{}, err
 	}
-	if p.Method != nil || p.MinutesTotal != nil {
-		s.wake()
-	}
 	if renamed {
 		updateCommitted()
 		s.clearOffers(row.ID, row.GroundingRevision)

internal/dinners/dinners_test.go

@@ -76,40 +76,35 @@ func TestCreateRegularNeverNamesFromLink(t *testing.T) {
 	check("duplicate error", dup.Error())
 }
 
-// TestSourceOfSiteName: a site name the page gave is shown as it stands,
-// even one shaped like a host and even over a link that is withheld; a
-// recipe whose page named none is named by its link's host without "www."
-// only when the link itself is shown, and is unnamed otherwise.
-func TestSourceOfSiteName(t *testing.T) {
+// TestPageSiteNameWithholdsHosts: a stored site name that could be a host —
+// the link's own, in any case and without "www.", an IP address or a dotted
+// host name — is withheld; a name the page gave, dotless or with spaces, is
+// kept.
+func TestPageSiteNameWithholdsHosts(t *testing.T) {
 	t.Parallel()
-	const (
-		ordinary = "https://www.Kitchen.example/recipes/stew"
-		token    = "https://private-token.example.com/recipes/stew?access_token=abc123"
-	)
+	const link = "https://www.TokenHost/recipes/stew"
 	for _, tc := range []struct {
-		stored        string
-		valid         bool
-		link          string
-		want, wantURL *string
+		stored string
+		valid  bool
+		want   *string
 	}{
-		{"Delish", true, ordinary, ptr("Delish"), ptr(ordinary)},
-		{"Food.com", true, ordinary, ptr("Food.com"), ptr(ordinary)},
-		{"Bon Appétit", true, token, ptr("Bon Appétit"), nil},
-		{"", false, ordinary, ptr("Kitchen.example"), ptr(ordinary)},
-		{"", true, ordinary, ptr("Kitchen.example"), ptr(ordinary)},
-		{"", false, token, nil, nil},
-		{"", false, "https://203.0.113.7/stew", ptr("203.0.113.7"), ptr("https://203.0.113.7/stew")},
-		{"", false, "http://kitchen.example/stew", nil, nil},
+		{"", false, nil},
+		{"tokenhost", true, nil},
+		{"TOKENHOST", true, nil},
+		{"private-token.example.com", true, nil},
+		{"Food.com", true, nil},
+		{"203.0.113.7", true, nil},
+		{"2001:db8::1", true, nil},
+		{"Delish", true, ptr("Delish")},
+		{"Bon Appétit", true, ptr("Bon Appétit")},
+		{"Mr. Food Test Kitchen", true, ptr("Mr. Food Test Kitchen")},
 	} {
-		src, err := dinners.SourceOf(sql.NullString{String: tc.stored, Valid: tc.valid}, tc.link)
+		src, err := dinners.SourceOf(sql.NullString{String: tc.stored, Valid: tc.valid}, link)
 		if err != nil {
-			t.Fatalf("SourceOf(%q, %q): %v", tc.stored, tc.link, err)
+			t.Fatalf("SourceOf(%q): %v", tc.stored, err)
 		}
 		if got := src.SiteName; (got == nil) != (tc.want == nil) || (got != nil && *got != *tc.want) {
-			t.Errorf("SourceOf(%q, %q) site name = %v, want %v", tc.stored, tc.link, deref(got), deref(tc.want))
-		}
-		if got := src.URL; (got == nil) != (tc.wantURL == nil) || (got != nil && *got != *tc.wantURL) {
-			t.Errorf("SourceOf(%q, %q) url = %v, want %v", tc.stored, tc.link, deref(got), deref(tc.wantURL))
+			t.Errorf("SourceOf(%q) site name = %v, want %v", tc.stored, deref(got), deref(tc.want))
 		}
 	}
 	// A link that does not parse is an error with or without a site name.

internal/dinners/grounding.go

@@ -196,7 +196,6 @@ func (s *Service) runGroundJob(ctx context.Context, p GroundJob, _ func(groundRe
 	if n == 0 {
 		return s.currentGrounding(ctx, row.ID)
 	}
-	s.wake()
 	return groundResult{DinnerID: row.ID, GroundingStatus: GroundingGrounded}, nil
 }
 
@@ -304,9 +303,7 @@ type Candidate struct {
 	// may carry a token.
 	CandidateID string `json:"candidate_id"`
 	Title       string `json:"title"`
-	// SiteName is the page's site as SourceOf names it, null when it
-	// cannot be named without leaking the URL.
-	SiteName *string `json:"site_name"`
+	SiteName    string `json:"site_name"`
 	// PhotoURL is the cached photo of a page already grounded, else null.
 	PhotoURL *string `json:"photo_url"`
 	Minutes  *int    `json:"minutes"`
@@ -369,13 +366,9 @@ func (s *Service) Candidates(ctx context.Context, id string) ([]Candidate, error
 	out := make([]Candidate, len(offers))
 	urls := make(map[string]string, len(offers))
 	for i, o := range offers {
-		src, err := SourceOf(sql.NullString{String: o.SiteName, Valid: o.SiteName != ""}, o.URL)
-		if err != nil {
-			return nil, fmt.Errorf("%w: dinner %s: candidate %d: %w", ErrCandidatesFailed, id, i+1, err)
-		}
 		cid := s.candidateID(row.ID, o.URL)
 		urls[cid] = o.URL
-		out[i] = Candidate{CandidateID: cid, Title: o.Title, SiteName: src.SiteName, Minutes: o.Minutes}
+		out[i] = Candidate{CandidateID: cid, Title: o.Title, SiteName: o.SiteName, Minutes: o.Minutes}
 		if o.PhotoID != "" {
 			u := PhotoURL(o.PhotoID)
 			out[i].PhotoURL = &u
@@ -584,7 +577,6 @@ func (s *Service) Ground(ctx context.Context, id string, f Fix, updatedBy string
 	if err != nil {
 		return Dinner{}, fmt.Errorf("%w: dinner %s: record: %w", ErrGroundFailed, id, err)
 	}
-	s.wake()
 	s.clearOffers(cur.ID, math.MaxInt64)
 	return fromRow(row), nil
 }
@@ -708,7 +700,6 @@ func (s *Service) groundManual(ctx context.Context, id string, m ManualRecipe, u
 	if err != nil {
 		return Dinner{}, fmt.Errorf("%w: dinner %s: %w", ErrGroundFailed, id, err)
 	}
-	s.wake()
 	s.clearOffers(row.ID, math.MaxInt64)
 	return fromRow(row), nil
 }

internal/dinners/grounding_test.go

@@ -104,7 +104,7 @@ func newUnstartedEnvOn(t *testing.T, st *store.Store, dataDir string) *env {
 	if err != nil {
 		t.Fatal(err)
 	}
-	svc, err := dinners.NewService(st, g, runner, func() {}, logger)
+	svc, err := dinners.NewService(st, g, runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -718,11 +718,11 @@ func TestCandidates(t *testing.T) {
 	}
 	first, second := got[0], got[1]
 	wantPhoto := dinners.PhotoURL(e.dinner(t, c.ID).PhotoID.String)
-	if first.Title != "Chicken Curry" || deref(first.SiteName) != "Curry House" ||
+	if first.Title != "Chicken Curry" || first.SiteName != "Curry House" ||
 		first.PhotoURL == nil || *first.PhotoURL != wantPhoto || first.Minutes == nil || *first.Minutes != 40 {
 		t.Errorf("first = %+v, want the stored curryA with photo %s", first, wantPhoto)
 	}
-	if second.Title != "Easy Weeknight Curry" || deref(second.SiteName) != "B Kitchen" ||
+	if second.Title != "Easy Weeknight Curry" || second.SiteName != "B Kitchen" ||
 		second.PhotoURL != nil || second.Minutes == nil || *second.Minutes != 25 {
 		t.Errorf("second = %+v, want curryB without a photo", second)
 	}

internal/gcal/connect.go

@@ -137,9 +137,10 @@ type Service struct {
 	account sync.Mutex
 
 	// pending holds the state of every connect started and not yet
-	// completed. Complete consumes a state once, so a replayed cookie finds
-	// it gone.
-	pending *auth.PendingStates
+	// completed, with when it expires. Complete consumes a state once, so a
+	// replayed cookie finds it gone.
+	pendingMu sync.Mutex
+	pending   map[string]time.Time
 }
 
 // NewService returns the service over st, sealing refresh tokens with box.
@@ -174,7 +175,7 @@ func NewService(st *store.Store, box *secretbox.Box, cfg Config) (*Service, erro
 		cookie:      auth.NewFlowCookie(connectCookieName, connectCookieKeyLabel, connectCookieTTL, cfg.SecretKey),
 		retryDelay:  firstRetryDelay,
 		now:         time.Now,
-		pending:     auth.NewPendingStates(connectCookieTTL),
+		pending:     map[string]time.Time{},
 	}, nil
 }
 
@@ -209,12 +210,10 @@ func (s *Service) Connect(w http.ResponseWriter, session auth.Session) (string,
 		Session:  sessionBinding(session),
 	}
 	now := s.now()
-	if err := s.pending.Add(state.State, now); err != nil {
-		return "", fmt.Errorf("gcal: %w", err)
-	}
 	if err := s.cookie.Set(w, &state, now); err != nil {
 		return "", fmt.Errorf("gcal: set connect cookie: %w", err)
 	}
+	s.addPending(state.State, now)
 	return s.oauth.AuthCodeURL(state.State,
 		oauth2.AccessTypeOffline,
 		oauth2.ApprovalForce,
@@ -244,7 +243,7 @@ func (s *Service) Complete(w http.ResponseWriter, r *http.Request, session auth.
 	}
 	// A copy of the cookie verifies until it expires, so the state is
 	// single-use only because it is consumed here.
-	if !s.pending.Consume(state.State) {
+	if !s.consumePending(state.State) {
 		return fmt.Errorf("%w: already used", ErrBadState)
 	}
 	if q.Get("error") != "" {
@@ -277,6 +276,29 @@ func (s *Service) Complete(w http.ResponseWriter, r *http.Request, session auth.
 	return s.store(ctx, sealed)
 }
 
+// addPending records state, started at now, as pending until the connect
+// cookie expires, and forgets expired ones.
+func (s *Service) addPending(state string, now time.Time) {
+	s.pendingMu.Lock()
+	defer s.pendingMu.Unlock()
+	for k, expires := range s.pending {
+		if !now.Before(expires) {
+			delete(s.pending, k)
+		}
+	}
+	s.pending[state] = now.Add(connectCookieTTL)
+}
+
+// consumePending removes state from the pending states, reporting whether
+// it was there.
+func (s *Service) consumePending(state string) bool {
+	s.pendingMu.Lock()
+	defer s.pendingMu.Unlock()
+	_, ok := s.pending[state]
+	delete(s.pending, state)
+	return ok
+}
+
 // checkScopes fails with ErrScopes unless token's granted scopes include
 // every scope in Scopes. Google lets the household untick a permission on
 // the consent screen and reports what was granted in "scope".

internal/home/home.go

@@ -50,9 +50,6 @@ func NewService(settings *household.SettingsService, plans *plan.Service, sugges
 type Home struct {
 	// DateLabel is today in the household's zone, e.g. "Friday, Oct 2".
 	DateLabel string `json:"dateLabel"`
-	// Timezone is the household's IANA zone, whose next local midnight
-	// is when Home is read again for the new day.
-	Timezone string `json:"timezone"`
 	// Tonight is the dinner planned for today on the current week's plan;
 	// nil when the week has no plan.
 	Tonight *Dinner `json:"tonight"`
@@ -95,8 +92,7 @@ type RecentUpdates struct {
 	Unread bool `json:"unread"`
 }
 
-// Get reads the Home screen at the service's "now". It only reads: it
-// writes nothing, not even the batch bookkeeping a Deck read does.
+// 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 {
@@ -114,7 +110,7 @@ func (s *Service) Get(ctx context.Context) (Home, error) {
 	if err != nil {
 		return Home{}, err
 	}
-	sideQuests, err := s.suggest.PendingCount(ctx)
+	deck, err := s.suggest.Deck(ctx)
 	if err != nil {
 		return Home{}, fmt.Errorf("home: read deck: %w", err)
 	}
@@ -128,9 +124,8 @@ func (s *Service) Get(ctx context.Context) (Home, error) {
 	}
 	return Home{
 		DateLabel:      now.Format("Monday, Jan 2"),
-		Timezone:       settings.Timezone,
 		Tonight:        tonight,
-		SideQuestCount: sideQuests,
+		SideQuestCount: len(deck.Suggestions),
 		ShoppingList:   list,
 		RecentUpdates:  RecentUpdates{Unread: unread},
 	}, nil
@@ -200,54 +195,3 @@ func (s *Service) unread(ctx context.Context, seenAt *string) (bool, error) {
 	}
 	return unread, nil
 }
-
-// RecentLimit is how many events the Recent updates sheet lists.
-const RecentLimit = 10
-
-// Update is one event in the Recent updates sheet.
-type Update struct {
-	// Type is the event type, e.g. plan_ready.
-	Type  string `json:"type"`
-	Title string `json:"title"`
-	Body  string `json:"body"`
-	// URL is the path-absolute, same-origin path a tap on the update opens.
-	URL string `json:"url"`
-	// CreatedAt is when the event was stored, UTC RFC 3339 with
-	// milliseconds; it is what POST /updates/seen takes back.
-	CreatedAt string `json:"created_at"`
-}
-
-// Updates returns the last RecentLimit distinct notification events, newest
-// first, whatever channels they went to.
-func (s *Service) Updates(ctx context.Context) ([]Update, error) {
-	events, err := s.notifier.Recent(ctx, RecentLimit)
-	if err != nil {
-		return nil, fmt.Errorf("home: %w", err)
-	}
-	out := make([]Update, len(events))
-	for i, ev := range events {
-		out[i] = Update{
-			Type: string(ev.Type), Title: ev.Title, Body: ev.Body, URL: ev.URL,
-			CreatedAt: store.Timestamp{Time: ev.CreatedAt}.String(),
-		}
-	}
-	return out, nil
-}
-
-// ErrSeenInFuture is returned by MarkUpdatesSeen for a time after now.
-var ErrSeenInFuture = errors.New("home: updates cannot be seen through a time after now")
-
-// MarkUpdatesSeen records that the household has seen its updates through
-// through, the created_at of the newest update it was shown, so
-// recentUpdates.unread is false until an event is stored after it. A time
-// before the one already recorded changes nothing; one after now is
-// ErrSeenInFuture, since it would hide events not yet stored.
-func (s *Service) MarkUpdatesSeen(ctx context.Context, through time.Time) error {
-	if through.After(s.now()) {
-		return ErrSeenInFuture
-	}
-	if err := s.settings.MarkUpdatesSeen(ctx, through); err != nil {
-		return fmt.Errorf("home: %w", err)
-	}
-	return nil
-}

internal/home/home_test.go

@@ -4,9 +4,7 @@ import (
 	"context"
 	"database/sql"
 	"encoding/base64"
-	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"log/slog"
 	"net/http"
@@ -45,7 +43,6 @@ var weekDates = []string{"2026-10-12", "2026-10-13", "2026-10-14", "2026-10-15",
 type env struct {
 	svc      *home.Service
 	st       *store.Store
-	settings *household.SettingsService
 	notifier *notify.Service
 	loc      *time.Location
 }
@@ -94,7 +91,7 @@ func newEnv(t *testing.T) *env {
 	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, func() {}, pub, time.Now, logger)
+	plans, err := plan.NewService(st, draft, runner, googleSvc, notifier, pub, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -117,8 +114,7 @@ func newEnv(t *testing.T) *env {
 	if err != nil {
 		t.Fatal(err)
 	}
-	settings := household.NewSettingsService(st)
-	svc, err := home.NewService(settings, plans, suggestSvc, shop, notifier)
+	svc, err := home.NewService(household.NewSettingsService(st), plans, suggestSvc, shop, notifier)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -126,7 +122,7 @@ func newEnv(t *testing.T) *env {
 	if err != nil {
 		t.Fatal(err)
 	}
-	return &env{svc: svc, st: st, settings: settings, notifier: notifier, loc: loc}
+	return &env{svc: svc, st: st, notifier: notifier, loc: loc}
 }
 
 // at reads the Home screen with the clock at the household-local wall
@@ -222,44 +218,16 @@ func TestTonightSwitchesAtLocalMidnight(t *testing.T) {
 func TestTonightDinner(t *testing.T) {
 	t.Parallel()
 	e := newEnv(t)
-	ctx := t.Context()
-	planID := e.planWeek(t)
-	planned := func(date string) string {
-		t.Helper()
-		var id string
-		if err := e.st.Reader.QueryRowContext(ctx, `SELECT dinner_id FROM plan_days WHERE plan_id = ? AND date = ?`, planID, date).Scan(&id); err != nil {
-			t.Fatal(err)
-		}
-		return id
-	}
+	e.planWeek(t)
 
 	h := e.at(t, "2026-10-13 18:00")
-	if h.Tonight == nil || h.Tonight.ID != planned("2026-10-13") || h.Tonight.Origin != "regular" || h.Tonight.Photo != nil ||
+	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 %s with no photo", h.Tonight, planned("2026-10-13"))
+		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.ID != planned("2026-10-14") || h.Tonight.Origin != "side_quest" || h.Tonight.MinutesTotal != nil {
-		t.Errorf("tonight = %+v, want Wednesday's Side quest %s of unknown minutes", h.Tonight, planned("2026-10-14"))
-	}
-
-	// Thursday's dinner has a photo: Home serves its list-sized copy.
-	now := store.Now().String()
-	photo, err := db.New(e.st.Writer).CreatePhoto(ctx, db.CreatePhotoParams{
-		ID: store.NewID(), SourceUrl: "https://example.com/thursday.jpg", LocalPath: "photos/thursday.jpg",
-		Width: 800, Height: 600, Sha256: "thursday", FetchedAt: now, CreatedAt: now, UpdatedAt: now,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	thursday := planned("2026-10-15")
-	if _, err := e.st.Writer.ExecContext(ctx, `UPDATE dinners SET photo_id = ? WHERE id = ?`, photo.ID, thursday); err != nil {
-		t.Fatal(err)
-	}
-	h = e.at(t, "2026-10-15 18:00")
-	wantPhoto := "/media/photos/" + photo.ID + "-400.jpg"
-	if h.Tonight == nil || h.Tonight.ID != thursday || h.Tonight.Photo == nil || *h.Tonight.Photo != wantPhoto {
-		t.Errorf("tonight = %+v, want Thursday's dinner %s with photo %s", h.Tonight, thursday, wantPhoto)
+	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)
 	}
 }
 
@@ -273,7 +241,6 @@ func TestHomeEmpty(t *testing.T) {
 	h := e.at(t, "2026-10-13 23:59")
 	want := home.Home{
 		DateLabel: "Tuesday, Oct 13",
-		Timezone:  zone,
 		ShoppingList: home.ShoppingStatus{
 			WeekStart: "2026-10-12", Label: "Week 42 · Oct 12 – 18",
 		},
@@ -318,32 +285,6 @@ func TestSideQuestCount(t *testing.T) {
 	}
 }
 
-// Reading Home writes nothing: a batch still pending whose job is gone,
-// which a Deck read would fail, is left as it was, and the read succeeds.
-func TestGetDoesNotWriteBatches(t *testing.T) {
-	t.Parallel()
-	e := newEnv(t)
-	ctx := t.Context()
-	created := "2026-10-13T12:00:00.000Z"
-	batch, err := db.New(e.st.Writer).CreateSuggestionBatch(ctx, db.CreateSuggestionBatchParams{ID: store.NewID(), Trigger: "manual", CreatedAt: created, UpdatedAt: created})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if batch.Status != "pending" {
-		t.Fatalf("new batch status = %q, want pending", batch.Status)
-	}
-	if h := e.at(t, "2026-10-13 12:00"); h.SideQuestCount != 0 {
-		t.Errorf("sideQuestCount = %d, want 0", h.SideQuestCount)
-	}
-	var status, updatedAt string
-	if err := e.st.Reader.QueryRowContext(ctx, `SELECT status, updated_at FROM suggestion_batches WHERE id = ?`, batch.ID).Scan(&status, &updatedAt); err != nil {
-		t.Fatal(err)
-	}
-	if status != "pending" || updatedAt != created {
-		t.Errorf("batch after a Home read = %s at %s, want pending at %s", status, updatedAt, created)
-	}
-}
-
 // 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) {
@@ -429,198 +370,3 @@ func TestNewServiceRequiresServices(t *testing.T) {
 		t.Fatal("NewService accepted nil services")
 	}
 }
-
-// store stores event key of type typ in the outbox at instant at, for each
-// of channels, as notify stores an event.
-func (e *env) store(t *testing.T, typ notify.EventType, key string, at time.Time, channels ...notify.Channel) {
-	t.Helper()
-	payload, err := json.Marshal(notify.Payload{Event: typ, Title: "Title " + key, Body: "Body " + key, URL: "/u/" + key, Tag: key})
-	if err != nil {
-		t.Fatal(err)
-	}
-	ts := store.Timestamp{Time: at.UTC().Truncate(time.Millisecond)}.String()
-	for _, ch := range channels {
-		if _, err := db.New(e.st.Writer).InsertNotification(t.Context(), db.InsertNotificationParams{
-			ID: store.NewID(), EventKey: key, Channel: string(ch), Payload: string(payload),
-			NextAttemptAt: sql.NullString{String: ts, Valid: true}, Now: ts,
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
-// Updates are the last ten distinct events, newest first: an event stored
-// for push and Google Chat is listed once, whatever became of its delivery.
-func TestUpdates(t *testing.T) {
-	t.Parallel()
-	e := newEnv(t)
-	ctx := t.Context()
-
-	got, err := e.svc.Updates(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got == nil || len(got) != 0 {
-		t.Errorf("updates with no notifications = %#v, want an empty list", got)
-	}
-
-	base := time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)
-	for i := range 12 {
-		key := fmt.Sprintf("plan_ready:%02d", i)
-		e.store(t, notify.PlanReady, key, base.Add(time.Duration(i)*time.Minute), notify.ChannelPush, notify.ChannelChat)
-	}
-	// A delivered and a failed row of one event are still one event.
-	if _, err := e.st.Writer.ExecContext(ctx, `UPDATE notification_outbox SET status = 'sent' WHERE event_key = 'plan_ready:11' AND channel = 'push'`); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := e.st.Writer.ExecContext(ctx, `UPDATE notification_outbox SET status = 'failed' WHERE event_key = 'plan_ready:11' AND channel = 'chat'`); err != nil {
-		t.Fatal(err)
-	}
-
-	got, err = e.svc.Updates(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got) != home.RecentLimit {
-		t.Fatalf("updates = %d, want %d: %+v", len(got), home.RecentLimit, got)
-	}
-	for i, u := range got {
-		n := 11 - i
-		key := fmt.Sprintf("plan_ready:%02d", n)
-		want := home.Update{
-			Type: "plan_ready", Title: "Title " + key, Body: "Body " + key, URL: "/u/" + key,
-			CreatedAt: store.Timestamp{Time: base.Add(time.Duration(n) * time.Minute)}.String(),
-		}
-		if u != want {
-			t.Errorf("updates[%d] = %+v, want %+v", i, u, want)
-		}
-	}
-}
-
-// An event emitted to push and Google Chat is one update.
-func TestUpdatesEmittedToTwoChannels(t *testing.T) {
-	t.Parallel()
-	e := newEnv(t)
-	ctx := t.Context()
-	if err := e.notifier.Emit(ctx, notify.Event{Type: notify.PlanReady, Key: "plan_ready:2026-10-12", Title: "Your week is drafted", Body: "Take a look", URL: "/plan"}); err != nil {
-		t.Fatal(err)
-	}
-	var rows int
-	if err := e.st.Reader.QueryRowContext(ctx, `SELECT COUNT(*) FROM notification_outbox`).Scan(&rows); err != nil {
-		t.Fatal(err)
-	}
-	if rows != 2 {
-		t.Fatalf("outbox rows = %d, want push and chat", rows)
-	}
-	got, err := e.svc.Updates(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got) != 1 || got[0].Type != "plan_ready" || got[0].Title != "Your week is drafted" || got[0].Body != "Take a look" || got[0].URL != "/plan" {
-		t.Errorf("updates = %+v, want the one plan_ready event", got)
-	}
-}
-
-// Marking updates seen through the newest clears unread until a newer event
-// is stored; marking them seen through an older time does not move the
-// mark back, and a time after now is refused.
-func TestMarkUpdatesSeen(t *testing.T) {
-	t.Parallel()
-	e := newEnv(t)
-	ctx := t.Context()
-	unread := func() bool {
-		t.Helper()
-		return e.at(t, "2026-10-13 12:00").RecentUpdates.Unread
-	}
-	first := time.Date(2026, 10, 13, 16, 0, 0, 0, time.UTC)
-	e.store(t, notify.NewSuggestions, "new_suggestions:1", first, notify.ChannelPush)
-	if !unread() {
-		t.Fatal("not unread with an event never seen")
-	}
-	// The settings were last edited well before: marking updates seen must
-	// keep that time and tell no settings subscriber.
-	edited := (store.Timestamp{Time: time.Date(2026, 10, 1, 9, 0, 0, 0, time.UTC)}).String()
-	if _, err := e.st.Writer.ExecContext(ctx, `UPDATE household_settings SET updated_at = ?`, edited); err != nil {
-		t.Fatal(err)
-	}
-	var notified int
-	unsubscribe := e.settings.Subscribe(func(household.Settings) { notified++ })
-	defer unsubscribe()
-	if err := e.svc.MarkUpdatesSeen(ctx, first); err != nil {
-		t.Fatal(err)
-	}
-	if unread() {
-		t.Error("unread after marking the newest event seen")
-	}
-
-	second := first.Add(time.Millisecond)
-	e.store(t, notify.PlanReady, "plan_ready:2", second, notify.ChannelPush, notify.ChannelChat)
-	if !unread() {
-		t.Error("not unread with an event stored after the mark")
-	}
-	// Seen again through the older event, as a sheet opened before the
-	// newer one arrived would: nothing moves, so it stays unread.
-	if err := e.svc.MarkUpdatesSeen(ctx, first); err != nil {
-		t.Fatal(err)
-	}
-	if !unread() {
-		t.Error("an older mark hid the newer event")
-	}
-	if err := e.svc.MarkUpdatesSeen(ctx, second); err != nil {
-		t.Fatal(err)
-	}
-	if unread() {
-		t.Error("unread after marking the newer event seen")
-	}
-	if err := e.svc.MarkUpdatesSeen(ctx, first); err != nil {
-		t.Fatal(err)
-	}
-	settings, err := e.settings.Get(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if want := (store.Timestamp{Time: second}).String(); settings.UpdatesSeenAt == nil || *settings.UpdatesSeenAt != want {
-		t.Errorf("updates_seen_at = %v, want %s: an older mark moved it back", settings.UpdatesSeenAt, want)
-	}
-	if settings.UpdatedBy != nil {
-		t.Errorf("updated_by = %q, want unset: marking updates seen is not a settings edit", *settings.UpdatedBy)
-	}
-	if settings.UpdatedAt != edited {
-		t.Errorf("updated_at = %s, want %s: marking updates seen is not a settings edit", settings.UpdatedAt, edited)
-	}
-	if notified != 0 {
-		t.Errorf("settings subscribers told %d times, want none: marking updates seen is not a settings edit", notified)
-	}
-
-	// The clock reads 17:00 UTC.
-	if err := e.svc.MarkUpdatesSeen(ctx, first.Add(2*time.Hour)); !errors.Is(err, home.ErrSeenInFuture) {
-		t.Errorf("mark seen through an hour from now = %v, want ErrSeenInFuture", err)
-	}
-}
-
-// An event stored again for a channel switched on later is as new as that
-// row: the update shows its time, and marking it seen clears unread.
-func TestUpdateStoredAgainForAnotherChannel(t *testing.T) {
-	t.Parallel()
-	e := newEnv(t)
-	ctx := t.Context()
-	first := time.Date(2026, 10, 13, 15, 0, 0, 0, time.UTC)
-	later := first.Add(30 * time.Minute)
-	e.store(t, notify.PlanReady, "plan_ready:1", first, notify.ChannelPush)
-	e.store(t, notify.PlanReady, "plan_ready:1", later, notify.ChannelChat)
-
-	got, err := e.svc.Updates(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if want := (store.Timestamp{Time: later}).String(); len(got) != 1 || got[0].CreatedAt != want {
-		t.Fatalf("updates = %+v, want the one event at %s", got, want)
-	}
-	e.at(t, "2026-10-13 12:00")
-	if err := e.svc.MarkUpdatesSeen(ctx, later); err != nil {
-		t.Fatal(err)
-	}
-	if e.at(t, "2026-10-13 12:00").RecentUpdates.Unread {
-		t.Error("unread after the event was marked seen through its listed time")
-	}
-}

internal/household/settings.go

@@ -8,7 +8,6 @@ import (
 	"regexp"
 	"strings"
 	"sync"
-	"time"
 
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
@@ -201,21 +200,6 @@ func (s *SettingsService) Update(ctx context.Context, patch SettingsPatch, updat
 	return settings, nil
 }
 
-// MarkUpdatesSeen records that the household has seen its Recent updates
-// through seenAt: updates_seen_at moves forward to seenAt, and is left as it
-// is when it is already at or after it. It is not a settings edit, so
-// updated_by and updated_at are kept and subscribers are not told.
-func (s *SettingsService) MarkUpdatesSeen(ctx context.Context, seenAt time.Time) error {
-	if seenAt.IsZero() {
-		return errors.New("household: mark updates seen: zero time")
-	}
-	_, err := db.New(s.st.Writer).MarkUpdatesSeen(ctx, store.Timestamp{Time: seenAt.UTC().Truncate(time.Millisecond)}.String())
-	if err != nil {
-		return fmt.Errorf("household: mark updates seen: %w", err)
-	}
-	return nil
-}
-
 // applyPatch applies a validated patch to the household settings row in q's
 // transaction, recording updatedBy, and returns the new row.
 func applyPatch(ctx context.Context, q *db.Queries, patch SettingsPatch, updatedBy string) (db.HouseholdSetting, error) {

internal/ideas/ideas.go

@@ -486,8 +486,7 @@ func sourceOf(gr recipes.Grounded) (dinners.Source, error) {
 // 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, less any name that could be a
-// host, which migration 0020 cleared; a null link, which only a result
+// 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

internal/notify/notify.go

@@ -27,7 +27,6 @@ import (
 	"fmt"
 	"log/slog"
 	"net/url"
-	"slices"
 	"strings"
 	"sync"
 	"time"
@@ -206,45 +205,6 @@ func (s *Service) StoredSince(ctx context.Context, since *time.Time) (bool, erro
 	return found, nil
 }
 
-// Stored is one event as it was stored, whatever channels it went to.
-type Stored struct {
-	Type  EventType
-	Title string
-	Body  string
-	// URL is the path-absolute, same-origin path the event opens.
-	URL string
-	// CreatedAt is when the event was last stored, for any channel: the
-	// instant StoredSince must be given for it not to count.
-	CreatedAt time.Time
-}
-
-// Recent returns the last n distinct events stored, newest first. An event
-// stored for more than one channel is one event, as new as its newest row;
-// one whose preference switches every channel off is never stored and
-// never listed.
-func (s *Service) Recent(ctx context.Context, n int) ([]Stored, error) {
-	if n <= 0 {
-		return nil, fmt.Errorf("notify: list %d recent events: want a positive count", n)
-	}
-	rows, err := db.New(s.st.Reader).ListRecentNotifications(ctx, int64(n))
-	if err != nil {
-		return nil, fmt.Errorf("notify: list recent events: %w", err)
-	}
-	out := make([]Stored, 0, len(rows))
-	for _, r := range rows {
-		var p Payload
-		if err := json.Unmarshal([]byte(r.Payload), &p); err != nil {
-			return nil, fmt.Errorf("notify: decode payload of %s: %w", r.EventKey, err)
-		}
-		created, err := parseTimestamp(r.CreatedAt)
-		if err != nil {
-			return nil, fmt.Errorf("notify: created_at of %s: %w", r.EventKey, err)
-		}
-		out = append(out, Stored{Type: p.Event, Title: p.Title, Body: p.Body, URL: p.URL, CreatedAt: created})
-	}
-	return out, 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 {
@@ -294,19 +254,6 @@ func (s *Service) emitTx(ctx context.Context, tx *sql.Tx, ev Event, channels fun
 	return nil
 }
 
-// ChannelOn reports whether the preference of event type ev switches
-// channel ch on. A type with no preference row is an error.
-func (s *Service) ChannelOn(ctx context.Context, ev EventType, ch Channel) (bool, error) {
-	pref, err := db.New(s.st.Reader).GetNotificationPref(ctx, string(ev))
-	if errors.Is(err, sql.ErrNoRows) {
-		return false, fmt.Errorf("notify: no notification preference for %s", ev)
-	}
-	if err != nil {
-		return false, fmt.Errorf("notify: read notification preference for %s: %w", ev, err)
-	}
-	return slices.Contains(enabledChannels(pref), ch), nil
-}
-
 // enabledChannels returns the channels pref switches on.
 func enabledChannels(pref db.NotificationPref) []Channel {
 	var chs []Channel

internal/plan/draft.go

@@ -96,7 +96,7 @@ func (s *Service) revision(ctx context.Context, weekStart store.LocalDate) (int6
 // the household context, the pool, last week's dinners and the dinner
 // time.
 func (s *Service) request(ctx context.Context, weekStart store.LocalDate) (skills.WeekRequest, error) {
-	hctx, err := harness.BuildContext(ctx, s.st, s.now(), ContextBudget)
+	hctx, err := harness.BuildContext(ctx, s.st, time.Now(), ContextBudget)
 	if err != nil {
 		return skills.WeekRequest{}, fmt.Errorf("plan: %w", err)
 	}
@@ -234,7 +234,6 @@ func (s *Service) storeDraft(ctx context.Context, weekStart, thisWeek store.Loca
 		return "", err
 	}
 	s.notifier.Wake()
-	s.wake()
 	return planID, nil
 }
 

internal/plan/plan.go

@@ -141,27 +141,20 @@ type Service struct {
 	draft    Drafter
 	cal      Calendar
 	notifier *notify.Service
-	// wake is called after every committed change to a plan's days, which
-	// can move a crock-pot dinner's start reminder.
-	wake     func()
 	logger   *slog.Logger
 	draftJob *jobs.Kind[DraftJob]
 	// publicURL is MEALQUEST_PUBLIC_URL, under which a pushed event links
 	// to its dinner.
 	publicURL *url.URL
-	// now is the clock today is read from: the scheduler's.
-	now func() time.Time
 }
 
 // NewService returns a service over st that drafts with draft, pushes to
 // cal with links under publicURL, tells the household through notifier,
-// which must be over st, calls wake (the scheduler's Wake) after every
-// committed change to a plan's days, reads today from now (the scheduler's
-// Now) 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.
-func NewService(st *store.Store, draft Drafter, runner *jobs.Runner, cal Calendar, notifier *notify.Service, wake func(), publicURL *url.URL, now func() time.Time, logger *slog.Logger) (*Service, error) {
+// which must be over st, and registers the KindDraftWeek job on
+// runner, which must not have started yet. The kind is service-only:
+// 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:
 		return nil, errors.New("plan: nil store")
@@ -173,16 +166,12 @@ func NewService(st *store.Store, draft Drafter, runner *jobs.Runner, cal Calenda
 		return nil, errors.New("plan: nil calendar")
 	case notifier == nil:
 		return nil, errors.New("plan: nil notifier")
-	case wake == nil:
-		return nil, errors.New("plan: nil wake")
 	case publicURL == nil:
 		return nil, errors.New("plan: nil public URL")
-	case now == nil:
-		return nil, errors.New("plan: nil clock")
 	case logger == nil:
 		return nil, errors.New("plan: nil logger")
 	}
-	s := &Service{st: st, draft: draft, cal: cal, notifier: notifier, wake: wake, logger: logger, publicURL: publicURL, now: now}
+	s := &Service{st: st, draft: draft, cal: cal, notifier: notifier, logger: logger, publicURL: publicURL}
 	kind, err := jobs.Register(runner, KindDraftWeek, s.runDraft, Reasons...)
 	if err != nil {
 		return nil, err
@@ -244,10 +233,10 @@ func (s *Service) Get(ctx context.Context, weekStart store.LocalDate) (p Plan, e
 }
 
 // EmitDayOfReminder emits day_of_reminder for date, keyed by the date,
-// "Tonight: {dinner} · Recipe →" for the dinner planned on it, and reports
-// whether it did: a date whose week has no plan emits nothing. The
-// day_of_reminder schedule calls it at the household's reminder_time
-// (ReminderSchedules); emitting a date again stores no second notification.
+// naming the dinner planned on it, and reports whether it did: a date whose
+// week has no plan emits nothing. The scheduler calls it at the
+// household's reminder_time (Feature 20); emitting a date again stores no
+// second notification.
 func (s *Service) EmitDayOfReminder(ctx context.Context, date store.LocalDate) (bool, error) {
 	p, err := s.Get(ctx, household.WeekStart(date))
 	if errors.Is(err, ErrNotFound) {
@@ -256,14 +245,15 @@ func (s *Service) EmitDayOfReminder(ctx context.Context, date store.LocalDate) (
 	if err != nil {
 		return false, err
 	}
-	d, err := p.day(date)
-	if err != nil {
-		return false, err
+	for _, d := range p.Days {
+		if d.Date == date.String() {
+			if err := s.notifier.Emit(ctx, chat.DayOfReminder(date, d.Dinner.ID, d.Dinner.Name)); err != nil {
+				return false, fmt.Errorf("plan: %w", err)
+			}
+			return true, nil
+		}
 	}
-	if err := s.notifier.Emit(ctx, chat.DayOfReminder(date, d.Dinner.ID, d.Dinner.Name)); err != nil {
-		return false, fmt.Errorf("plan: %w", err)
-	}
-	return true, nil
+	return false, fmt.Errorf("plan: week %s has no day %s", p.WeekStart, date)
 }
 
 // readPlan reads the plan of the week starting weekStart through q, with
@@ -352,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())
@@ -380,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
 		}
@@ -405,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
@@ -480,7 +450,6 @@ func (s *Service) Swap(ctx context.Context, weekStart store.LocalDate, date, din
 	if err != nil {
 		return Plan{}, err
 	}
-	s.wake()
 	return p, nil
 }
 
@@ -506,7 +475,7 @@ func (s *Service) Tonight(ctx context.Context) (week, today store.LocalDate, err
 	if err != nil {
 		return store.LocalDate{}, store.LocalDate{}, fmt.Errorf("plan: household settings: %w", err)
 	}
-	today = household.Today(s.now(), zone)
+	today = household.Today(time.Now(), zone)
 	week = household.WeekStart(today)
 	_, err = q.GetWeekPlan(ctx, week.String())
 	if errors.Is(err, sql.ErrNoRows) {

internal/plan/plan_test.go

@@ -146,7 +146,7 @@ func newEnv(t *testing.T) *env {
 	if err != nil {
 		t.Fatal(err)
 	}
-	e.svc, err = plan.NewService(st, drafter, e.runner, e.gcal, notifytest.New(t, st), func() {}, publicURL, time.Now, logger)
+	e.svc, err = plan.NewService(st, drafter, e.runner, e.gcal, notifytest.New(t, st), publicURL, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -375,9 +375,9 @@ func TestDraftEmitsPlanReady(t *testing.T) {
 	}
 	for _, r := range rows {
 		p := r.Payload
-		if r.Key != "plan_ready:2026-10-12" || p.Tag != r.Key || p.URL != "/plan?week=2026-10-12" || p.Week != "2026-10-12" ||
+		if r.Key != "plan_ready:2026-10-12" || p.Tag != r.Key || p.URL != "/plan" || p.Week != "2026-10-12" ||
 			p.Title != want.Title || p.Body != "Beef Chili, Pot Roast, Pad Thai + 4 more" {
-			t.Errorf("%s row = %+v, want key plan_ready:2026-10-12, title %q, the drafted dinners and /plan?week=2026-10-12", r.Channel, r, want.Title)
+			t.Errorf("%s row = %+v, want key plan_ready:2026-10-12, title %q, the drafted dinners and /plan", r.Channel, r, want.Title)
 		}
 	}
 
@@ -428,8 +428,8 @@ func TestEmitDayOfReminder(t *testing.T) {
 		t.Fatalf("day_of_reminder rows = %+v, want one on push", rows)
 	}
 	r := rows[0]
-	if r.Key != "day_of_reminder:2026-10-14" || r.Channel != notify.ChannelPush || r.Payload.Title != "Tonight: Pad Thai · Recipe →" ||
-		r.Payload.Body != "" || r.Payload.URL != "/dinner/"+e.ids["Pad Thai"] || r.Payload.Week != "2026-10-12" {
+	if r.Key != "day_of_reminder:2026-10-14" || r.Channel != notify.ChannelPush || r.Payload.Title != "Tonight's dinner" ||
+		r.Payload.Body != "Pad Thai" || r.Payload.URL != "/dinner/"+e.ids["Pad Thai"] || r.Payload.Week != "2026-10-12" {
 		t.Errorf("day_of_reminder row = %+v", r)
 	}
 }

internal/plan/reminder.go

@@ -1,150 +0,0 @@
-package plan
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"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/household"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-)
-
-// StartReminderLead is how long before a crock-pot dinner's start_by its
-// start reminder fires.
-const StartReminderLead = 15 * time.Minute
-
-// StartReminderKey is the period key prefix of the crock-pot start
-// reminder: its periods are start:YYYY-MM-DD of the day_of_reminder
-// schedule.
-const StartReminderKey = "start"
-
-// ReminderSchedules are the day_of_reminder schedules. The first fires
-// every day at the household's reminder_time, period YYYY-MM-DD, and emits
-// day_of_reminder:YYYY-MM-DD for tonight's dinner (EmitDayOfReminder). The
-// second fires StartReminderLead before the start_by of a crock-pot dinner
-// whose start_by is earlier than that day's reminder_time, period
-// start:YYYY-MM-DD of the dinner's date, and emits
-// day_of_reminder:start:YYYY-MM-DD (EmitStartReminder). A date whose week
-// has no plan emits neither.
-func (s *Service) ReminderSchedules() []scheduler.Schedule {
-	return []scheduler.Schedule{
-		{
-			Name: scheduler.DayOfReminder,
-			Rule: func(settings household.Settings) scheduler.Rule {
-				return scheduler.Daily(settings.ReminderTime)
-			},
-			Run: func(ctx context.Context, p scheduler.Period) error {
-				sent, err := s.EmitDayOfReminder(ctx, p.Date)
-				if err != nil {
-					return err
-				}
-				if !sent {
-					s.logger.InfoContext(ctx, "day-of reminder not sent: the week has no plan",
-						"period", p.Key, "date", p.Date.String())
-				}
-				return nil
-			},
-		},
-		{
-			Name: scheduler.DayOfReminder,
-			Key:  StartReminderKey,
-			Rule: func(household.Settings) scheduler.Rule {
-				return scheduler.DailyAt(s.startReminderAt)
-			},
-			Run: func(ctx context.Context, p scheduler.Period) error {
-				sent, err := s.EmitStartReminder(ctx, p.Date)
-				if err != nil {
-					return err
-				}
-				if !sent {
-					s.logger.InfoContext(ctx, "start reminder not sent: no crock-pot dinner to start before the reminder",
-						"period", p.Key, "date", p.Date.String())
-				}
-				return nil
-			},
-		},
-	}
-}
-
-// EmitStartReminder emits day_of_reminder:start:{date}, "Start the crock
-// pot by {time}", for the crock-pot dinner planned on date, and reports
-// whether it did: it emits nothing unless date's dinner has a start_by
-// earlier than date's reminder_time. Emitting a date again stores no
-// second notification.
-func (s *Service) EmitStartReminder(ctx context.Context, date store.LocalDate) (bool, error) {
-	d, ok, err := s.startReminder(ctx, date)
-	if err != nil || !ok {
-		return false, err
-	}
-	if err := s.notifier.Emit(ctx, chat.StartReminder(date, d.Dinner.ID, d.Dinner.Name, *d.StartBy)); err != nil {
-		return false, fmt.Errorf("plan: %w", err)
-	}
-	return true, nil
-}
-
-// startReminderAt is the start reminder's scheduler.FireAt: the
-// StartReminderLead before start_by of the dinner date's start reminder,
-// if it has one.
-func (s *Service) startReminderAt(ctx context.Context, date store.LocalDate) (time.Time, bool, error) {
-	d, ok, err := s.startReminder(ctx, date)
-	if err != nil || !ok {
-		return time.Time{}, false, err
-	}
-	return d.StartBy.Add(-StartReminderLead), true, nil
-}
-
-// startReminder returns the plan day of date when it has a start reminder:
-// its dinner has a start_by (a crock-pot dinner of known minutes) earlier
-// than the household's reminder_time on date. The plan and the settings
-// come from one read transaction.
-func (s *Service) startReminder(ctx context.Context, date store.LocalDate) (d Day, ok bool, err error) {
-	tx, err := s.st.Reader.BeginTx(ctx, nil)
-	if err != nil {
-		return Day{}, false, fmt.Errorf("plan: begin read: %w", err)
-	}
-	defer func() {
-		err = errors.Join(err, tx.Rollback())
-	}()
-	q := db.New(tx)
-	p, err := readPlan(ctx, q, household.WeekStart(date))
-	if errors.Is(err, ErrNotFound) {
-		return Day{}, false, nil
-	}
-	if err != nil {
-		return Day{}, false, err
-	}
-	d, err = p.day(date)
-	if err != nil {
-		return Day{}, false, err
-	}
-	if d.StartBy == nil {
-		return Day{}, false, nil
-	}
-	settings, err := q.GetHouseholdSettings(ctx)
-	if err != nil {
-		return Day{}, false, fmt.Errorf("plan: read household settings: %w", err)
-	}
-	zone, err := household.LoadZone(settings.Timezone)
-	if err != nil {
-		return Day{}, false, fmt.Errorf("plan: household settings: %w", err)
-	}
-	remind, err := household.LocalTime(zone, date, settings.ReminderTime)
-	if err != nil {
-		return Day{}, false, fmt.Errorf("plan: reminder time of %s: %w", date, err)
-	}
-	return d, d.StartBy.Before(remind), nil
-}
-
-// day returns p's day on date; a plan holds all seven days of its week.
-func (p Plan) day(date store.LocalDate) (Day, error) {
-	for _, d := range p.Days {
-		if d.Date == date.String() {
-			return d, nil
-		}
-	}
-	return Day{}, fmt.Errorf("plan: week %s has no day %s", p.WeekStart, date)
-}

internal/plan/rotation.go

@@ -6,11 +6,8 @@ import (
 	"errors"
 	"fmt"
 
-	"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/dinners"
-	"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"
 )
 
@@ -82,40 +79,12 @@ type Decided struct {
 	UpdatedBy    string `json:"updated_by"`
 }
 
-// RotationCheckSchedule is the rotation_check schedule: every day at the
-// household's review_time it runs MarkTried for the day before, so each
-// Quest log dinner planned yesterday is tried and the household is asked
-// "Keep it in rotation?". Its period is the fire date, claimed as
-// rotation_check:YYYY-MM-DD. It never makes a dinner a Regular.
-func (s *Service) RotationCheckSchedule() scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.RotationCheck,
-		Rule: func(settings household.Settings) scheduler.Rule {
-			return scheduler.Daily(settings.ReviewTime)
-		},
-		PeriodKey: func(p scheduler.Period) string {
-			return scheduler.RotationCheck + ":" + p.Key
-		},
-		Run: func(ctx context.Context, p scheduler.Period) error {
-			yesterday := addDays(p.Date, -1)
-			n, err := s.MarkTried(ctx, yesterday)
-			if err != nil {
-				return err
-			}
-			s.logger.InfoContext(ctx, "Rotation check: Quest log dinners marked tried",
-				"period", p.Key, "plan_date", yesterday.String(), "tried", n)
-			return nil
-		},
-	}
-}
-
 // MarkTried moves every dinner in the Quest log planned on date, the
-// household-local day just past, on a plan of any status, to tried, opens
-// a pending Rotation check of it for date and emits its rotation_review
-// (chat.RotationReview), all in one transaction. It is idempotent: a
-// dinner already checked for date is left as it is and not notified of
-// again, so a later run never moves one returned to the Quest log ("We
-// didn't make it") again. It returns how many dinners it moved.
+// household-local day just past, on a plan of any status, to tried and
+// opens a pending Rotation check of it for date. It is idempotent: a
+// dinner already checked for date is left as it is, so a later run never
+// moves one returned to the Quest log ("We didn't make it") again. It
+// returns how many dinners it moved.
 func (s *Service) MarkTried(ctx context.Context, date store.LocalDate) (int, error) {
 	var n int
 	err := s.st.WithTx(ctx, func(tx *sql.Tx) error {
@@ -126,10 +95,6 @@ func (s *Service) MarkTried(ctx context.Context, date store.LocalDate) (int, err
 		}
 		now := store.Now().String()
 		for _, id := range ids {
-			d, err := q.GetDinner(ctx, id)
-			if err != nil {
-				return fmt.Errorf("plan: read dinner %s: %w", id, err)
-			}
 			moved, err := q.MarkDinnerTried(ctx, db.MarkDinnerTriedParams{UpdatedAt: now, ID: id})
 			if err != nil {
 				return fmt.Errorf("plan: mark %s tried: %w", id, err)
@@ -142,9 +107,6 @@ func (s *Service) MarkTried(ctx context.Context, date store.LocalDate) (int, err
 			}); err != nil {
 				return fmt.Errorf("plan: open Rotation check of %s for %s: %w", id, date, err)
 			}
-			if err := s.notifier.EmitTx(ctx, tx, chat.RotationReview(id, d.Name, date)); err != nil {
-				return fmt.Errorf("plan: %w", err)
-			}
 		}
 		n = len(ids)
 		return nil
@@ -152,9 +114,6 @@ func (s *Service) MarkTried(ctx context.Context, date store.LocalDate) (int, err
 	if err != nil {
 		return 0, err
 	}
-	if n > 0 {
-		s.notifier.Wake()
-	}
 	return n, nil
 }
 

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/recipes/extract.go

@@ -28,10 +28,8 @@ var (
 type Recipe struct {
 	// Title is the recipe's name.
 	Title string
-	// SiteName is the name the page gives its site: the publisher's name,
-	// else the page's og:site_name; empty when it names none. It is never
-	// taken from the page's URL, whose host may carry a personal token, so
-	// a stored site name is always one a page gave (see dinners.SourceOf).
+	// SiteName is the publisher's name, else the page's og:site_name, else
+	// HostSiteName of the page's URL.
 	SiteName string
 	// ImageURL is the largest image, absolute; empty when the recipe has
 	// none.
@@ -175,7 +173,7 @@ func recipeFrom(n map[string]any, g graph, base *url.URL, ogSiteName string) (Re
 	if r.Title = cleanText(name); !ok || r.Title == "" {
 		return Recipe{}, errors.New("name is missing")
 	}
-	if r.SiteName, err = siteName(n["publisher"], g, ogSiteName); err != nil {
+	if r.SiteName, err = siteName(n["publisher"], g, ogSiteName, base); err != nil {
 		return Recipe{}, err
 	}
 	if r.ImageURL, err = imageURL(n["image"], g, base); err != nil {
@@ -215,7 +213,7 @@ func cleanText(s string) string {
 	return strings.TrimSpace(html.UnescapeString(s))
 }
 
-func siteName(publisher any, g graph, ogSiteName string) (string, error) {
+func siteName(publisher any, g graph, ogSiteName string, base *url.URL) (string, error) {
 	pubs, ok := publisher.([]any)
 	if !ok {
 		pubs = []any{publisher}
@@ -231,7 +229,16 @@ func siteName(publisher any, g graph, ogSiteName string) (string, error) {
 			}
 		}
 	}
-	return ogSiteName, nil
+	if ogSiteName != "" {
+		return ogSiteName, nil
+	}
+	return HostSiteName(base), nil
+}
+
+// HostSiteName is the site name of a page that names none: its host
+// without a leading "www.".
+func HostSiteName(u *url.URL) string {
+	return strings.TrimPrefix(u.Hostname(), "www.")
 }
 
 // imageURL picks the largest of the recipe's images by width × height;

internal/recipes/extract_test.go

@@ -251,10 +251,10 @@ func TestExtractShapes(t *testing.T) {
 			},
 		},
 		{
-			name: "no site name without publisher or og:site_name, never the host",
+			name: "site name from host without publisher or og:site_name",
 			html: page("", `{"@type":"Recipe","name":"Stew"}`),
 			check: func(t *testing.T, r Recipe) {
-				if r.SiteName != "" {
+				if r.SiteName != "example.com" {
 					t.Errorf("SiteName = %q", r.SiteName)
 				}
 			},

internal/recipes/ground.go

@@ -65,9 +65,7 @@ type Grounded struct {
 	// Difficulty is easy, medium or hard.
 	Difficulty string `json:"difficulty"`
 	SourceURL  string `json:"source_url"`
-	// SiteName is the name the page gives its site, "" when it names none
-	// (see Recipe.SiteName).
-	SiteName string `json:"site_name"`
+	SiteName   string `json:"site_name"`
 }
 
 // SearchSource returns the household's current search provider;
@@ -202,10 +200,8 @@ func (g *Grounder) searchRanked(ctx context.Context, dishName, query string) (ra
 // Offer is a ranked candidate offered for the household to ground a dish
 // in, with GroundURL on its URL.
 type Offer struct {
-	URL   string
-	Title string
-	// SiteName is the name the page gives its site, "" when it names none
-	// (see Recipe.SiteName).
+	URL      string
+	Title    string
 	SiteName string
 	// PhotoID is the cached photo of a candidate already stored, "" for
 	// one that is not: a candidate's photo is cached only when it grounds.

internal/scheduler/day_of_reminder_test.go

@@ -1,328 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
-	"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/notify"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify/notifytest"
-	"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 day_of_reminder schedules on the fake
-// clock against the real plan service and notification outbox. The plan of
-// the week of Monday Oct 12 (w42) has poolNames Monday to Sunday: Beef
-// Chili on Monday, Pot Roast on Tuesday. The household's dinner time is the
-// seeded 17:30 and its reminder time the seeded 16:30, in Chicago.
-
-// w42 is the Monday of 2026-W42.
-var w42 = mustLocalDate("2026-10-12")
-
-// planWeek drafts the plan of the week starting weekStart and waits for it.
-func (p *planEnv) planWeek(weekStart store.LocalDate) {
-	p.e.t.Helper()
-	p.reply(weekStart)
-	if _, err := p.svc.StartDraft(context.Background(), weekStart, false); err != nil {
-		p.e.t.Fatal(err)
-	}
-	if jobs := p.e.drafts(); jobs[len(jobs)-1] != succeeded {
-		p.e.t.Fatalf("draft of %s = %+v, want succeeded", weekStart, jobs)
-	}
-}
-
-// crockPot makes the dinner name a crock-pot dinner of minutes.
-func (p *planEnv) crockPot(name string, minutes int) {
-	p.e.t.Helper()
-	if _, err := p.e.st.Writer.Exec(`UPDATE dinners SET method = 'crockpot', minutes_total = ? WHERE id = ?`, minutes, p.ids[name]); err != nil {
-		p.e.t.Fatal(err)
-	}
-}
-
-// reminders returns the day_of_reminder notifications stored, oldest
-// first. The seeded preference sends day_of_reminder to push only, so there
-// is one row per event.
-func (e *env) reminders() []notifytest.Row {
-	e.t.Helper()
-	rows := notifytest.Rows(e.t, e.st, notify.DayOfReminder)
-	for _, r := range rows {
-		if r.Channel != notify.ChannelPush {
-			e.t.Fatalf("day_of_reminder row %+v, want push only", r)
-		}
-	}
-	return rows
-}
-
-// reminderKeys returns the keys of e.reminders().
-func (e *env) reminderKeys() []string {
-	e.t.Helper()
-	var keys []string
-	for _, r := range e.reminders() {
-		keys = append(keys, r.Key)
-	}
-	return keys
-}
-
-// wantReminder fails unless the reminder keyed key was stored with title,
-// body and the link to the dinner name.
-func (p *planEnv) wantReminder(key, title, body, name string) {
-	p.e.t.Helper()
-	for _, r := range p.e.reminders() {
-		if r.Key != key {
-			continue
-		}
-		week := household.WeekStart(mustLocalDate(key[len(key)-len("YYYY-MM-DD"):]))
-		want := notify.Payload{Event: notify.DayOfReminder, Title: title, Body: body, URL: "/dinner/" + p.ids[name], Tag: key, Week: week.String()}
-		if r.Payload != want {
-			p.e.t.Errorf("reminder %s = %+v, want %+v", key, r.Payload, want)
-		}
-		return
-	}
-	p.e.t.Errorf("no reminder %s", key)
-}
-
-// TestDayOfReminderNormalNight: a night whose dinner is not a crock-pot
-// dinner gets exactly the daily reminder, at reminder_time 16:30, keyed
-// day_of_reminder:YYYY-MM-DD and linking to the dinner.
-func TestDayOfReminderNormalNight(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	p.planWeek(w42)
-
-	// Monday 08:00: the catch-up of Sunday 16:30 finds no plan for W41.
-	r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
-	r.runUntil(at(2026, 10, 12, 16, 29))
-	wantKeys(t, "before 16:30", e.reminderKeys(), nil)
-
-	r.runUntil(at(2026, 10, 12, 16, 30))
-	wantKeys(t, "at 16:30", e.reminderKeys(), []string{"day_of_reminder:2026-10-12"})
-	p.wantReminder("day_of_reminder:2026-10-12", "Tonight: Beef Chili · Recipe →", "", "Beef Chili")
-
-	r.runUntil(at(2026, 10, 13, 23, 59))
-	wantKeys(t, "Tuesday", e.reminderKeys(), []string{"day_of_reminder:2026-10-12", "day_of_reminder:2026-10-13"})
-	p.wantReminder("day_of_reminder:2026-10-13", "Tonight: Pot Roast · Recipe →", "", "Pot Roast")
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "2026-10-13"})
-}
-
-// TestDayOfReminderCrockPotNight: a crock-pot night whose start_by is
-// earlier than reminder_time gets the start reminder at start_by minus 15
-// minutes, keyed day_of_reminder:start:YYYY-MM-DD, and the daily reminder
-// at reminder_time. A crock-pot night whose start_by is not earlier than
-// reminder_time gets only the daily one.
-func TestDayOfReminderCrockPotNight(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	p.crockPot("Beef Chili", 480) // Monday: start by 09:30
-	p.crockPot("Pot Roast", 30)   // Tuesday: start by 17:00, after 16:30
-	p.planWeek(w42)
-
-	r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
-	r.runUntil(at(2026, 10, 12, 9, 14))
-	wantKeys(t, "before 09:15", e.reminderKeys(), nil)
-
-	r.runUntil(at(2026, 10, 12, 9, 15))
-	wantKeys(t, "at 09:15", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
-	p.wantReminder("day_of_reminder:start:2026-10-12", "Start the crock pot by 9:30 am", "Beef Chili", "Beef Chili")
-
-	r.runUntil(at(2026, 10, 12, 16, 29))
-	wantKeys(t, "before 16:30", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
-	r.runUntil(at(2026, 10, 12, 16, 30))
-	wantKeys(t, "at 16:30", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12"})
-	p.wantReminder("day_of_reminder:2026-10-12", "Tonight: Beef Chili · Recipe →", "", "Beef Chili")
-
-	r.runUntil(at(2026, 10, 13, 23, 59))
-	wantKeys(t, "Tuesday", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12", "day_of_reminder:2026-10-13"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "2026-10-13", "start:2026-10-12"})
-}
-
-// TestDayOfReminderEmptyNight: with no plan for tonight's week, here none
-// at all and then only next week's, nothing is emitted and nothing fails;
-// next week's crock-pot Monday is reminded on its own day.
-func TestDayOfReminderEmptyNight(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-
-	r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
-	r.runUntil(at(2026, 10, 13, 23, 59))
-	wantKeys(t, "with no plan", e.reminderKeys(), nil)
-
-	p.crockPot("Beef Chili", 480)
-	p.planWeek(w43)
-	r.runUntil(at(2026, 10, 18, 23, 59))
-	wantKeys(t, "with only next week's plan", e.reminderKeys(), nil)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder),
-		[]string{"2026-10-11", "2026-10-12", "2026-10-13", "2026-10-14", "2026-10-15", "2026-10-16", "2026-10-17", "2026-10-18"})
-	if logs := p.logs.String(); !strings.Contains(logs, "day-of reminder not sent: the week has no plan") || strings.Contains(logs, "level=ERROR") {
-		t.Errorf("logs = %s, want the empty nights logged and no error", logs)
-	}
-
-	r.runUntil(at(2026, 10, 19, 9, 15))
-	wantKeys(t, "next Monday", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-19"})
-	p.wantReminder("day_of_reminder:start:2026-10-19", "Start the crock pot by 9:30 am", "Beef Chili", "Beef Chili")
-}
-
-// TestDayOfReminderFollowsReminderTimeWithoutRestart: a reminder_time
-// change takes effect in the running scheduler. Moved from 16:30 to 18:00,
-// the daily reminder fires at 18:00, not 16:30, and a crock-pot start_by
-// of 17:00, now earlier than reminder_time, gets its start reminder at
-// 16:45.
-func TestDayOfReminderFollowsReminderTimeWithoutRestart(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	p.crockPot("Beef Chili", 30) // start by 17:00
-	p.planWeek(w42)
-
-	r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
-	e.update(household.SettingsPatch{ReminderTime: ptr("18:00")})
-	r.changed()
-	r.runUntil(at(2026, 10, 12, 16, 44))
-	wantKeys(t, "before 16:45", e.reminderKeys(), nil)
-	r.runUntil(at(2026, 10, 12, 16, 45))
-	wantKeys(t, "at 16:45", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
-	p.wantReminder("day_of_reminder:start:2026-10-12", "Start the crock pot by 5:00 pm", "Beef Chili", "Beef Chili")
-	r.runUntil(at(2026, 10, 12, 17, 59))
-	wantKeys(t, "before 18:00", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
-	r.runUntil(at(2026, 10, 12, 18, 0))
-	wantKeys(t, "at 18:00", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12"})
-}
-
-// TestDayOfReminderNoDuplicateAfterRestart: restarts after each reminder
-// of a crock-pot night, within the catch-up window, emit neither again:
-// each period is already claimed.
-func TestDayOfReminderNoDuplicateAfterRestart(t *testing.T) {
-	e := newEnv(t)
-	ids := e.pool()
-	p := e.plans(ids)
-	p.crockPot("Beef Chili", 480)
-	p.planWeek(w42)
-
-	r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
-	r.runUntil(at(2026, 10, 12, 9, 15))
-	r.stop()
-	p.stop()
-
-	p2 := e.plans(ids)
-	r2 := e.start(at(2026, 10, 12, 9, 20), p2.svc.ReminderSchedules()...)
-	wantKeys(t, "after the first restart", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
-	r2.runUntil(at(2026, 10, 12, 16, 30))
-	r2.stop()
-	p2.stop()
-
-	p3 := e.plans(ids)
-	r3 := e.start(at(2026, 10, 12, 16, 40), p3.svc.ReminderSchedules()...)
-	r3.runUntil(at(2026, 10, 13, 9, 0))
-	wantKeys(t, "after the second restart", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "start:2026-10-12"})
-}
-
-// TestDailyAtLookupFailureIsRetried: a DailyAt rule fires at the instant
-// its lookup gives, its period keyed by the schedule's Key and the date;
-// a lookup that fails fires nothing and is looked up again after
-// ClaimRetry, then fires its period once.
-func TestDailyAtLookupFailureIsRetried(t *testing.T) {
-	e := newEnv(t)
-	var rec recorder
-	var mu sync.Mutex
-	failing := false
-	at915 := func(ctx context.Context, d store.LocalDate) (time.Time, bool, error) {
-		mu.Lock()
-		defer mu.Unlock()
-		if failing {
-			return time.Time{}, false, errors.New("database down")
-		}
-		y, m, day := d.Date()
-		return at(y, m, day, 9, 15), true, nil
-	}
-	sch := scheduler.Schedule{
-		Name: scheduler.DayOfReminder,
-		Key:  "start",
-		Rule: func(household.Settings) scheduler.Rule { return scheduler.DailyAt(at915) },
-		Run:  rec.run,
-	}
-
-	r := e.start(at(2026, 10, 12, 8, 0), sch)
-	wantKeys(t, "catch-up", rec.keys(), []string{"start:2026-10-11"})
-	mu.Lock()
-	failing = true
-	mu.Unlock()
-	r.runUntil(at(2026, 10, 12, 9, 16))
-	wantKeys(t, "while the lookup fails", rec.keys(), []string{"start:2026-10-11"})
-
-	mu.Lock()
-	failing = false
-	mu.Unlock()
-	r.runUntil(at(2026, 10, 12, 9, 17))
-	wantKeys(t, "after the lookup recovers", rec.keys(), []string{"start:2026-10-11", "start:2026-10-12"})
-	if p := rec.periods()[1]; !p.FireAt.Equal(at(2026, 10, 12, 9, 15)) || p.Date.String() != "2026-10-12" {
-		t.Errorf("period = %+v, want fired at 09:15 for 2026-10-12", p)
-	}
-	r.runUntil(at(2026, 10, 13, 12, 0))
-	wantKeys(t, "next day", rec.keys(), []string{"start:2026-10-11", "start:2026-10-12", "start:2026-10-13"})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), rec.keys())
-}
-
-// questLog stores name as a Quest-log dinner, a crock-pot dinner of
-// minutes, and returns its id. It is not a Regular.
-func (p *planEnv) questLog(name string, minutes int) string {
-	p.e.t.Helper()
-	now := store.Now().String()
-	d, err := db.New(p.e.st.Writer).CreateDinner(context.Background(), db.CreateDinnerParams{
-		ID:              store.NewID(),
-		Name:            name,
-		NormalizedName:  harness.Normalize(name),
-		Status:          "quest_log",
-		Origin:          "side_quest",
-		GroundingStatus: "manual",
-		CreatedAt:       now,
-		UpdatedAt:       now,
-	})
-	if err != nil {
-		p.e.t.Fatal(err)
-	}
-	p.ids[name] = d.ID
-	p.crockPot(name, minutes)
-	return d.ID
-}
-
-// TestStartReminderAfterSwapFiresOnTime: swapping a crock-pot dinner in
-// for tonight wakes the scheduler, so its start reminder fires at start_by
-// minus 15 minutes, 09:15, and not at the next hourly check, 10:00. At
-// 09:00 tonight is Beef Chili, not a crock-pot dinner, and the scheduler's
-// next timer is 10:00; at 09:01 the household swaps in an eight-hour
-// crock-pot Quest-log dinner, start by 09:30. Each reminder fires once.
-func TestStartReminderAfterSwapFiresOnTime(t *testing.T) {
-	e := newEnv(t)
-	p := e.wakingPlans(e.pool())
-	stew := p.questLog("Crock Pot Stew", 480) // start by 09:30
-	p.planWeek(w42)
-
-	r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
-	r.runUntil(at(2026, 10, 12, 9, 0))
-	if next, _ := r.clock.nextDeadline(); !next.Equal(at(2026, 10, 12, 10, 0)) {
-		t.Fatalf("next wake at 09:00 = %s, want the hourly 10:00", next)
-	}
-
-	r.runUntil(at(2026, 10, 12, 9, 1))
-	if _, err := p.svc.Swap(context.Background(), w42, "2026-10-12", stew); err != nil {
-		t.Fatal(err)
-	}
-	r.changed()
-	r.runUntil(at(2026, 10, 12, 9, 14))
-	wantKeys(t, "before 09:15", e.reminderKeys(), nil)
-
-	r.runUntil(at(2026, 10, 12, 9, 15))
-	wantKeys(t, "at 09:15", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
-	p.wantReminder("day_of_reminder:start:2026-10-12", "Start the crock pot by 9:30 am", "Crock Pot Stew", "Crock Pot Stew")
-
-	r.runUntil(at(2026, 10, 13, 23, 59))
-	wantKeys(t, "Tuesday", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12", "day_of_reminder:2026-10-13"})
-	p.wantReminder("day_of_reminder:2026-10-12", "Tonight: Crock Pot Stew · Recipe →", "", "Crock Pot Stew")
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "2026-10-13", "start:2026-10-12"})
-}

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,469 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"net/url"
-	"slices"
-	"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).
-// Its changes do not wake the scheduler: a draft job's wake would add a
-// pass the fake clock's waits do not expect.
-func (e *env) plans(ids map[string]string) *planEnv {
-	e.t.Helper()
-	return e.newPlans(ids, func() {}, time.Now)
-}
-
-// scheduledPlans is plans whose today is read from the clock of the
-// scheduler start last started, as in the server, so a draft's plan_ready
-// title follows the fake clock. It drafts only once a scheduler started.
-func (e *env) scheduledPlans(ids map[string]string) *planEnv {
-	e.t.Helper()
-	return e.newPlans(ids, func() {}, func() time.Time {
-		s := e.sched.Load()
-		if s == nil {
-			panic("plan service read the clock before a scheduler started")
-		}
-		return s.Now()
-	})
-}
-
-// wakingPlans is plans whose changes wake the scheduler, as in the server.
-// A test using it changes plans only from its own goroutine and waits for
-// the wake's pass with changed.
-func (e *env) wakingPlans(ids map[string]string) *planEnv {
-	e.t.Helper()
-	return e.newPlans(ids, e.wake, time.Now)
-}
-
-// newPlans is plans whose service calls wake after a plan change and reads
-// today from now.
-func (e *env) newPlans(ids map[string]string, wake func(), now func() time.Time) *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), wake, publicURL, now, 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
-}
-
-// readyRow is a stored plan_ready notification as these tests check it.
-type readyRow struct {
-	Key     string
-	Channel notify.Channel
-	Title   string
-}
-
-// planReadyRows returns every plan_ready notification stored, oldest
-// first, each week's Google Chat row before its push row.
-func (e *env) planReadyRows() []readyRow {
-	e.t.Helper()
-	var out []readyRow
-	for _, r := range notifytest.Rows(e.t, e.st, notify.PlanReady) {
-		out = append(out, readyRow{Key: r.Key, Channel: r.Channel, Title: r.Payload.Title})
-	}
-	return out
-}
-
-// nextWeekReady is the plan_ready rows of a draft of the week starting
-// week, drafted the week before: one to Google Chat and one to push.
-func nextWeekReady(week string) []readyRow {
-	const title = "Next week's plan is ready"
-	key := string(notify.PlanReady) + ":" + week
-	return []readyRow{{key, notify.ChannelChat, title}, {key, notify.ChannelPush, title}}
-}
-
-// wantReady fails unless the plan_ready rows are got.
-func wantReady(t *testing.T, what string, got []readyRow, want ...[]readyRow) {
-	t.Helper()
-	all := slices.Concat(want...)
-	if !slices.Equal(got, all) {
-		t.Fatalf("%s: plan_ready rows = %+v, want %+v", what, got, all)
-	}
-}
-
-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.scheduledPlans(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"})
-	wantReady(t, "plan_ready rows of W43", e.planReadyRows(), nextWeekReady("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"})
-	wantReady(t, "plan_ready rows of W43 and W44", e.planReadyRows(), nextWeekReady("2026-10-19"), nextWeekReady("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.scheduledPlans(e.pool())
-	p.reply(w43)
-	p.reply(w43) // a second draft would succeed too
-	r := e.start(at(2026, 10, 16, 8, 0), p.svc.DraftSchedule())
-	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"})
-	wantReady(t, "plan_ready rows of the manual draft", e.planReadyRows(), nextWeekReady("2026-10-19"))
-	before, err := p.svc.Get(context.Background(), w43)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	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"})
-	wantReady(t, "plan_ready rows with a plan", e.planReadyRows(), nextWeekReady("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.scheduledPlans(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)
-	wantReady(t, "plan_ready rows of the first process", e.planReadyRows(), nextWeekReady("2026-10-19"))
-	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.scheduledPlans(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"})
-	wantReady(t, "plan_ready rows after restart", e.planReadyRows(), nextWeekReady("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.scheduledPlans(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)
-	wantReady(t, "plan_ready rows after the AI failed", e.planReadyRows())
-	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.scheduledPlans(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)
-	wantReady(t, "plan_ready rows after restart", e.planReadyRows())
-}
-
-// 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.scheduledPlans(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"})
-	wantReady(t, "plan_ready rows", e.planReadyRows(), nextWeekReady("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/rotation_check_test.go

@@ -1,204 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"testing"
-
-	"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/notify/notifytest"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
-)
-
-// The tests in this file run plan's rotation_check schedule on the fake
-// clock against the real plan service and notification outbox. The plan of
-// the week of Monday Oct 12 (w42) has poolNames, all Regulars, Monday to
-// Sunday; a test that needs a Quest-log dinner swaps Lemon Orzo in for
-// Monday. The household's review time is the seeded 09:00, in Chicago.
-
-// orzoDay is the Monday Lemon Orzo is planned on.
-var orzoDay = mustLocalDate("2026-10-12")
-
-// orzoWeek plans w42 with the Quest-log dinner Lemon Orzo on Monday in
-// place of Beef Chili, and returns its id.
-func (p *planEnv) orzoWeek() string {
-	p.e.t.Helper()
-	id := p.questLog("Lemon Orzo", 30)
-	p.planWeek(w42)
-	if _, err := p.svc.Swap(context.Background(), w42, orzoDay.String(), id); err != nil {
-		p.e.t.Fatal(err)
-	}
-	return id
-}
-
-// rotationReviews returns the keys of the rotation_review notifications
-// stored, oldest first. The seeded preference sends rotation_review to push
-// only, so there is one row per event.
-func (e *env) rotationReviews() []string {
-	e.t.Helper()
-	var keys []string
-	for _, r := range notifytest.Rows(e.t, e.st, notify.RotationReview) {
-		if r.Channel != notify.ChannelPush {
-			e.t.Fatalf("rotation_review row %+v, want push only", r)
-		}
-		keys = append(keys, r.Key)
-	}
-	return keys
-}
-
-// status returns the status of the dinner name.
-func (p *planEnv) status(name string) string {
-	p.e.t.Helper()
-	var s string
-	if err := p.e.st.Reader.QueryRow(`SELECT status FROM dinners WHERE id = ?`, p.ids[name]).Scan(&s); err != nil {
-		p.e.t.Fatal(err)
-	}
-	return s
-}
-
-// pendingReviews returns the plan dates of the pending Rotation checks of
-// the dinner name.
-func (p *planEnv) pendingReviews(name string) []string {
-	p.e.t.Helper()
-	rows, err := p.e.st.Reader.Query(`SELECT plan_date FROM rotation_reviews WHERE dinner_id = ? AND status = 'pending' ORDER BY plan_date`, p.ids[name])
-	if err != nil {
-		p.e.t.Fatal(err)
-	}
-	defer rows.Close()
-	var out []string
-	for rows.Next() {
-		var d string
-		if err := rows.Scan(&d); err != nil {
-			p.e.t.Fatal(err)
-		}
-		out = append(out, d)
-	}
-	if err := rows.Err(); err != nil {
-		p.e.t.Fatal(err)
-	}
-	return out
-}
-
-// wantOrzoTried fails unless Lemon Orzo, id, is tried with one pending
-// Rotation check for orzoDay and exactly one rotation_review asking about
-// it, which opens Home.
-func (p *planEnv) wantOrzoTried(id string) {
-	p.e.t.Helper()
-	if got := p.status("Lemon Orzo"); got != "tried" {
-		p.e.t.Errorf("Lemon Orzo status = %s, want tried", got)
-	}
-	wantKeys(p.e.t, "Lemon Orzo pending Rotation checks", p.pendingReviews("Lemon Orzo"), []string{orzoDay.String()})
-	key := "rotation_review:" + id + ":" + orzoDay.String()
-	wantKeys(p.e.t, "rotation_review", p.e.rotationReviews(), []string{key})
-	got := notifytest.Rows(p.e.t, p.e.st, notify.RotationReview)[0].Payload
-	want := notify.Payload{Event: notify.RotationReview, Title: "How was Lemon Orzo? Keep it in rotation?", URL: "/", Tag: key, Week: w42.String()}
-	if got != want {
-		p.e.t.Errorf("rotation_review = %+v, want %+v", got, want)
-	}
-}
-
-// TestRotationCheckMarksQuestLogDinnerTried: at review_time 09:00 the day
-// after a Quest-log dinner was planned, the schedule, period
-// rotation_check:YYYY-MM-DD, marks it tried, opens its Rotation check and
-// emits one rotation_review. It never makes the dinner a Regular.
-func TestRotationCheckMarksQuestLogDinnerTried(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	id := p.orzoWeek()
-
-	// Tuesday 08:00: the catch-up of Monday 09:00 checks Sunday, unplanned.
-	r := e.start(at(2026, 10, 13, 8, 0), p.svc.RotationCheckSchedule())
-	r.runUntil(at(2026, 10, 13, 8, 59))
-	wantKeys(t, "before 09:00", e.rotationReviews(), nil)
-	if got := p.status("Lemon Orzo"); got != "quest_log" {
-		t.Fatalf("Lemon Orzo status before 09:00 = %s, want quest_log", got)
-	}
-
-	r.runUntil(at(2026, 10, 13, 9, 0))
-	p.wantOrzoTried(id)
-
-	// Days later, still tried: only the household's keep makes a Regular.
-	r.runUntil(at(2026, 10, 16, 12, 0))
-	p.wantOrzoTried(id)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.RotationCheck), []string{
-		"rotation_check:2026-10-12", "rotation_check:2026-10-13", "rotation_check:2026-10-14",
-		"rotation_check:2026-10-15", "rotation_check:2026-10-16",
-	})
-}
-
-// TestRotationCheckLeavesRegulars: a day planning only Regulars marks
-// nothing tried, opens no Rotation check and emits nothing.
-func TestRotationCheckLeavesRegulars(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	p.planWeek(w42)
-
-	r := e.start(at(2026, 10, 13, 8, 0), p.svc.RotationCheckSchedule())
-	r.runUntil(at(2026, 10, 13, 9, 0))
-	wantKeys(t, "rotation_review", e.rotationReviews(), nil)
-	if got := p.status("Beef Chili"); got != "regular" {
-		t.Errorf("Beef Chili status = %s, want regular", got)
-	}
-	wantKeys(t, "Beef Chili pending Rotation checks", p.pendingReviews("Beef Chili"), nil)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.RotationCheck), []string{"rotation_check:2026-10-12", "rotation_check:2026-10-13"})
-}
-
-// TestRotationCheckNoDuplicateSameDay: a restart the same day finds the
-// period claimed, and MarkTried run again for the same day finds the
-// Rotation check open, so neither opens a second check or notification.
-func TestRotationCheckNoDuplicateSameDay(t *testing.T) {
-	e := newEnv(t)
-	ids := e.pool()
-	p := e.plans(ids)
-	id := p.orzoWeek()
-
-	r := e.start(at(2026, 10, 13, 8, 0), p.svc.RotationCheckSchedule())
-	r.runUntil(at(2026, 10, 13, 9, 0))
-	p.wantOrzoTried(id)
-	r.stop()
-	p.stop()
-
-	p2 := e.plans(ids)
-	r2 := e.start(at(2026, 10, 13, 9, 30), p2.svc.RotationCheckSchedule())
-	r2.runUntil(at(2026, 10, 13, 23, 59))
-	p2.wantOrzoTried(id)
-
-	if n, err := p2.svc.MarkTried(context.Background(), orzoDay); err != nil || n != 0 {
-		t.Fatalf("MarkTried(%s) again = %d, %v, want 0", orzoDay, n, err)
-	}
-	p2.wantOrzoTried(id)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.RotationCheck), []string{"rotation_check:2026-10-12", "rotation_check:2026-10-13"})
-}
-
-// TestRotationCheckCatchUpAtBoot: started 23 hours after a missed 09:00,
-// the scheduler runs that day's Rotation check once at boot.
-func TestRotationCheckCatchUpAtBoot(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	id := p.orzoWeek()
-
-	e.start(at(2026, 10, 14, 8, 0), p.svc.RotationCheckSchedule())
-	p.wantOrzoTried(id)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.RotationCheck), []string{"rotation_check:2026-10-13"})
-}
-
-// TestRotationCheckFollowsReviewTimeWithoutRestart: a review_time change
-// takes effect in the running scheduler. Moved from 09:00 to 10:30, the
-// Rotation check does not run at 09:00 and runs at 10:30.
-func TestRotationCheckFollowsReviewTimeWithoutRestart(t *testing.T) {
-	e := newEnv(t)
-	p := e.plans(e.pool())
-	id := p.orzoWeek()
-
-	r := e.start(at(2026, 10, 13, 8, 0), p.svc.RotationCheckSchedule())
-	e.update(household.SettingsPatch{ReviewTime: ptr("10:30")})
-	r.changed()
-	r.runUntil(at(2026, 10, 13, 10, 29))
-	wantKeys(t, "before 10:30", e.rotationReviews(), nil)
-	if got := p.status("Lemon Orzo"); got != "quest_log" {
-		t.Fatalf("Lemon Orzo status before 10:30 = %s, want quest_log", got)
-	}
-	r.runUntil(at(2026, 10, 13, 10, 30))
-	p.wantOrzoTried(id)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.RotationCheck), []string{"rotation_check:2026-10-12", "rotation_check:2026-10-13"})
-}

internal/scheduler/scheduler.go

@@ -1,751 +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 handles, oldest
-// first, every fire time of each schedule that passed within CatchUpWindow,
-// and the most recent fire time even when it passed longer ago. Each
-// unclaimed period within CatchUpWindow runs once. A most recent one that
-// passed longer ago 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. Other fire times older than CatchUpWindow 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.
-//
-// # Fire times from data
-//
-// A DailyAt rule fires at a time read from the household's data rather
-// than the settings: its function gives, for each household-local date,
-// the instant the date's period fires, or none. The period is that date
-// even when the instant falls on another day. The scheduler asks again on
-// every pass, and whoever changes that data calls Wake once the change is
-// committed, so the next pass comes at once and a fire time the change
-// moved fires on time rather than up to maxWait late; the claim still runs
-// a period at most once. A lookup that fails is logged and repeated every
-// ClaimRetry, as a failed claim is.
-//
-// # 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"
-	"slices"
-	"strings"
-	"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, or every day at the instant
-// At gives. Build one with Daily, Weekly, WeeklyForNextWeek or DailyAt.
-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
-	// At, instead of Time, gives the instant the period of a
-	// household-local date fires.
-	At FireAt
-}
-
-// FireAt gives the instant the period of household-local date fires, or
-// false when that date's period does not fire.
-type FireAt func(ctx context.Context, date store.LocalDate) (time.Time, bool, error)
-
-// 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}
-}
-
-// DailyAt fires at most once a day, at the instant at gives for the date;
-// its period is that date, wherever the instant falls.
-func DailyAt(at FireAt) Rule {
-	return Rule{At: at}
-}
-
-// 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")
-	}
-	if r.At != nil {
-		if r.Weekly || r.Time != "" {
-			return errors.New("a DailyAt rule has no weekday or time")
-		}
-		return nil
-	}
-	// 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
-	// Key, when set, prefixes the schedule's period keys with Key and a
-	// colon ("start:2026-10-14"), so two schedules of one Name claim
-	// different periods. Name and Key together are unique.
-	Key string
-	// PeriodKey, when set, gives the period key claimed for p in place of
-	// the rule's, such as "list_ready:chat:2026-10-19" for the week p.Week;
-	// p.Key is the rule's key. It must give each period its own key. A
-	// schedule sets Key or PeriodKey, not both.
-	PeriodKey func(p Period) 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
-}
-
-// label names sch in errors and logs: its Name, and its Key if set.
-func (sch Schedule) label() string {
-	if sch.Key == "" {
-		return sch.Name
-	}
-	return sch.Name + ":" + sch.Key
-}
-
-// 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 or the data a DailyAt rule
-	// reads changed since the loop last looked; pending is the settings
-	// 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.label())
-	}
-	if sch.Run == nil {
-		return fmt.Errorf("scheduler: register %s: nil run", sch.label())
-	}
-	if strings.Contains(sch.Key, ":") {
-		return fmt.Errorf("scheduler: register %s: key has a colon", sch.label())
-	}
-	if sch.Key != "" && sch.PeriodKey != nil {
-		return fmt.Errorf("scheduler: register %s: both key and period key", sch.label())
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.started {
-		return fmt.Errorf("scheduler: register %s: already started", sch.label())
-	}
-	for _, have := range s.schedules {
-		if have.Name == sch.Name && have.Key == sch.Key {
-			return fmt.Errorf("scheduler: register %s: already registered", sch.label())
-		}
-	}
-	s.schedules = append(s.schedules, sch)
-	return nil
-}
-
-// Start reads the settings and starts the scheduler, which first catches
-// up on each schedule's recent periods 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()
-	s.signal()
-}
-
-// Wake makes the scheduler look up its fire times again now rather than at
-// its next timer. Call it after committing a change to the data a DailyAt
-// rule reads, such as tonight's planned dinner. It never blocks.
-func (s *Scheduler) Wake() {
-	s.signal()
-}
-
-// Now is the time on the scheduler's clock, by which its schedules fire.
-func (s *Scheduler) Now() time.Time {
-	return s.now()
-}
-
-// signal leaves one token in wake for the loop.
-func (s *Scheduler) signal() {
-	select {
-	case s.wake <- struct{}{}:
-	default: // the loop already has a token and looks again 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.label(), 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:
-			next, ok, err := p.next(ctx, now)
-			switch {
-			case err != nil:
-				s.logger.ErrorContext(ctx, "scheduler: look up next fire time failed; retrying", "error", err, "retry_in", ClaimRetry.String())
-				timeout = s.after(ClaimRetry)
-			case 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 periods still to handle, oldest first, each
-// named by its fire time and the household-local date of its period. A
-// target whose fire times could not be looked up has lookup set instead,
-// with the stretch (done, until] to look them up in again.
-type target struct {
-	it    item
-	loc   *time.Location
-	fires []fireTime
-
-	lookup      bool
-	done, until time.Time
-}
-
-// fire handles, for every schedule, its catch-up fire times after done and
-// at or before until; now is the current instant. It returns the
-// targets whose lookup or claim failed, to be handled 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
-		}
-		if t, ok := s.fireItem(ctx, it, p.loc, done, until, now); !ok {
-			failed = append(failed, t)
-		}
-	}
-	return failed
-}
-
-// fireItem handles, oldest first, it's fire times after done and at or
-// before until that passed within CatchUpWindow of now, and the most recent
-// of them even when it passed longer ago. It reports false, with the target
-// to handle again, when the fire times could not be looked up or a period's
-// claim failed.
-func (s *Scheduler) fireItem(ctx context.Context, it item, loc *time.Location, done, until, now time.Time) (target, bool) {
-	fs, err := fireBetween(ctx, it.rule, loc, done, until)
-	if err != nil {
-		s.logger.ErrorContext(ctx, "scheduler: look up fire time failed; retrying",
-			"schedule", it.sch.label(), "error", err, "retry_in", ClaimRetry.String())
-		return target{it: it, loc: loc, lookup: true, done: done, until: until}, false
-	}
-	i := 0
-	for i < len(fs)-1 && now.Sub(fs[i].at) > CatchUpWindow {
-		i++
-	}
-	return s.handleAll(ctx, target{it: it, loc: loc, fires: fs[i:]}, now)
-}
-
-// handleAll handles the periods of t in order, stopping at the first whose
-// claim failed. It reports false, with that period and those after it,
-// when one did.
-func (s *Scheduler) handleAll(ctx context.Context, t target, now time.Time) (target, bool) {
-	for i, f := range t.fires {
-		if !s.handle(ctx, t.it, f, now) {
-			t.fires = t.fires[i:]
-			return t, false
-		}
-	}
-	return target{}, true
-}
-
-// retry handles targets again at now and returns those whose lookup or
-// 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 t.lookup {
-			if again, ok := s.fireItem(ctx, t.it, t.loc, t.done, t.until, now); !ok {
-				failed = append(failed, again)
-			}
-			continue
-		}
-		if again, ok := s.handleAll(ctx, t, now); !ok {
-			failed = append(failed, again)
-		}
-	}
-	return failed
-}
-
-// handle claims the period of it's fire time f and runs it, or records it
-// as missed when f 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, it item, f fireTime, now time.Time) bool {
-	at, date := f.at, f.date
-	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)
-	}
-	switch {
-	case it.sch.Key != "":
-		period.Key = it.sch.Key + ":" + period.Key
-	case it.sch.PeriodKey != nil:
-		period.Key = it.sch.PeriodKey(period)
-	}
-	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 none.
-func (p *plan) next(ctx context.Context, now time.Time) (time.Time, bool, error) {
-	var next time.Time
-	for _, it := range p.items {
-		f, ok, err := fireAfter(ctx, it.rule, p.loc, now)
-		if err != nil {
-			return time.Time{}, false, fmt.Errorf("%s: %w", it.sch.label(), err)
-		}
-		if ok && (next.IsZero() || f.at.Before(next)) {
-			next = f.at
-		}
-	}
-	return next, !next.IsZero(), nil
-}
-
-// window is how many days either side of a date fireBetween and fireAfter
-// search: more than a week, so a weekly rule always has a fire time on
-// each side.
-const window = 8
-
-// atWindow is how many days either side of a date fireBetween and fireAfter
-// look up a DailyAt rule's fire times. A period firing further off is
-// looked up on a later pass, which comes within maxWait.
-const atWindow = 2
-
-// fireTime is a fire time and the household-local date of its period.
-type fireTime struct {
-	at   time.Time
-	date store.LocalDate
-}
-
-// fireBetween returns the fire times of r in zone loc after from and at or
-// before t, oldest first.
-func fireBetween(ctx context.Context, r Rule, loc *time.Location, from, t time.Time) ([]fireTime, error) {
-	fs, err := fireTimes(ctx, r, loc, t)
-	if err != nil {
-		return nil, err
-	}
-	var out []fireTime
-	for _, f := range fs {
-		if f.at.After(from) && !f.at.After(t) {
-			out = append(out, f)
-		}
-	}
-	slices.SortFunc(out, func(a, b fireTime) int { return a.at.Compare(b.at) })
-	return out, nil
-}
-
-// fireAfter returns the earliest fire time of r in zone loc after t.
-func fireAfter(ctx context.Context, r Rule, loc *time.Location, t time.Time) (fireTime, bool, error) {
-	fs, err := fireTimes(ctx, r, loc, t)
-	if err != nil {
-		return fireTime{}, false, err
-	}
-	var best fireTime
-	for _, f := range fs {
-		if f.at.After(t) && (best.at.IsZero() || f.at.Before(best.at)) {
-			best = f
-		}
-	}
-	return best, !best.at.IsZero(), nil
-}
-
-// fireTimes returns r's fire times for the local dates within window days
-// of t's, or atWindow days for a DailyAt rule. A Time that fails to
-// resolve was validated at compile, so it cannot; a DailyAt lookup that
-// fails is an error.
-func fireTimes(ctx context.Context, r Rule, loc *time.Location, t time.Time) ([]fireTime, error) {
-	today := household.Today(t, loc)
-	span := window
-	if r.At != nil {
-		span = atWindow
-	}
-	var out []fireTime
-	for i := -span; i <= span; i++ {
-		d := addDays(today, i)
-		if r.Weekly && weekday(d) != r.Weekday {
-			continue
-		}
-		if r.At != nil {
-			at, ok, err := r.At(ctx, d)
-			if err != nil {
-				return nil, fmt.Errorf("fire time of %s: %w", d, err)
-			}
-			if ok {
-				out = append(out, fireTime{at: at, date: d})
-			}
-			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, fireTime{at: at, date: d})
-	}
-	return out, nil
-}
-
-// 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,805 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"errors"
-	"io"
-	"log/slog"
-	"slices"
-	"sync"
-	"sync/atomic"
-	"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
-}
-
-// After returns a timer that fires d from now. The scheduler waits on only
-// its latest timer, so this one replaces any still pending: a timer the
-// scheduler gave up on when a wake came first never fires.
-func (c *fakeClock) After(d time.Duration) <-chan time.Time {
-	c.mu.Lock()
-	ch := make(chan time.Time, 1)
-	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
-	// sched is the scheduler start last started, which wake wakes.
-	sched atomic.Pointer[scheduler.Scheduler]
-}
-
-// wake wakes the scheduler start last started, as the services' wake does
-// in the server; before the first start it does nothing.
-func (e *env) wake() {
-	if s := e.sched.Load(); s != nil {
-		s.Wake()
-	}
-}
-
-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)
-	}
-	e.sched.Store(s)
-	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, or to look
-// again after a wake.
-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 TestCatchUpEveryPeriodWithin24HoursAcrossSpringForward(t *testing.T) {
-	// Clocks in Chicago jump 02:00 CST → 03:00 CDT on Sunday 2026-03-08,
-	// so 01:30 on Mar 8 and 01:30 on Mar 9 are only 23 hours apart.
-	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 at Mar 9 01:35: Mar 9 01:30 passed 5 minutes ago and Mar 8
-	// 01:30 23h05m ago, so both run, oldest first; Mar 7 01:30, 47h05m
-	// ago, is not looked at.
-	r := e.start(at(2026, 3, 9, 1, 35), review)
-	wantKeys(t, "catch-up", rec.keys(), []string{"2026-03-08", "2026-03-09"})
-	wantFired(t, rec.periods(),
-		time.Date(2026, 3, 8, 7, 30, 0, 0, time.UTC), // 01:30 CST
-		time.Date(2026, 3, 9, 6, 30, 0, 0, time.UTC), // 01:30 CDT
-	)
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.RotationCheck), []string{"2026-03-08", "2026-03-09"})
-	r.stop()
-
-	// A restart within the window finds both periods claimed.
-	var again recorder
-	review.Run = again.run
-	r2 := e.start(at(2026, 3, 9, 1, 40), review)
-	r2.runUntil(at(2026, 3, 9, 23, 0))
-	wantKeys(t, "after restart", again.keys(), nil)
-}
-
-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},
-		{Name: scheduler.DayOfReminder, Key: "start", PeriodKey: func(p scheduler.Period) string { return p.Key }, Rule: reminder(&rec).Rule, Run: rec.run},
-	}
-	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/scheduler/weekly_automation_test.go

@@ -1,421 +0,0 @@
-package scheduler_test
-
-import (
-	"context"
-	"crypto/rand"
-	"database/sql"
-	"encoding/base64"
-	"errors"
-	"log/slog"
-	"strings"
-	"testing"
-	"time"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
-	"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/chat/chattest"
-	"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/notifytest"
-	"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/shopping"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-)
-
-// The tests in this file run shopping's shopping_chat_autosend and
-// week_rollover schedules, and harness's ai_runs_purge, on the fake clock
-// against the real shopping service, Google Chat client (posting to a fake
-// webhook), notification preferences and ai_runs purge. The seeded
-// autosend is Saturday 08:00 in Chicago.
-
-// w41 is the Monday of 2026-W41.
-var w41 = mustLocalDate("2026-10-05")
-
-// shopEnv is a shopping service over a scheduler env's store. Its job
-// runner never starts, so Generate's title jobs stay queued and every
-// Supply run stays untitled until Freeze titles it, which fails.
-type shopEnv struct {
-	e     *env
-	svc   *shopping.Service
-	chat  *chattest.Chat
-	cs    *chat.Service
-	plans *planEnv
-	logs  *syncBuffer
-}
-
-// shopping builds a shopping service over e, with Regulars to plan from.
-func (e *env) shopping() *shopEnv {
-	e.t.Helper()
-	s := &shopEnv{e: e, chat: chattest.New(e.t), plans: e.plans(e.pool()), logs: &syncBuffer{}}
-	key := make([]byte, secretbox.KeySize)
-	rand.Read(key)
-	box, err := secretbox.New(base64.StdEncoding.EncodeToString(key))
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	s.cs, err = chat.NewService(e.st, box, publicURL, s.chat.Transport())
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	logger := slog.New(slog.NewTextHandler(s.logs, nil))
-	runner, err := jobs.NewRunner(e.st, logger, 1)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	noTitle := func(context.Context, string, skills.ArchiveTitleRequest) (skills.ArchiveTitle, error) {
-		return skills.ArchiveTitle{}, errors.New("no AI in this test")
-	}
-	s.svc, err = shopping.NewService(e.st, noTitle, runner, notifytest.New(e.t, e.st), s.cs, logger)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	return s
-}
-
-// list plans the week starting weekStart and generates its Supply run.
-func (s *shopEnv) list(weekStart store.LocalDate) {
-	s.e.t.Helper()
-	s.plans.planWeek(weekStart)
-	if _, err := s.svc.Generate(context.Background(), weekStart); err != nil {
-		s.e.t.Fatal(err)
-	}
-}
-
-// webhook stores the fake Google Chat webhook.
-func (s *shopEnv) webhook() {
-	s.e.t.Helper()
-	if _, err := s.cs.Put(context.Background(), chattest.Webhook, "Family"); err != nil {
-		s.e.t.Fatal(err)
-	}
-}
-
-// get returns the Supply run of the week starting weekStart.
-func (s *shopEnv) get(weekStart store.LocalDate) shopping.List {
-	s.e.t.Helper()
-	l, err := s.svc.Get(context.Background(), weekStart)
-	if err != nil {
-		s.e.t.Fatal(err)
-	}
-	return l
-}
-
-// wantLogged fails unless the service logged want and logged no error.
-func (s *shopEnv) wantLogged(want string) {
-	s.e.t.Helper()
-	if logs := s.logs.String(); !strings.Contains(logs, want) || strings.Contains(logs, "level=ERROR") {
-		s.e.t.Errorf("logs = %s, want %q and no error", logs, want)
-	}
-}
-
-// TestChatAutosendSendsComingWeek: at the seeded Saturday 08:00 the
-// schedule posts the coming week's Supply run, W43's, to Google Chat
-// through SendToChat, in that week's thread, and records sent_to_chat_at;
-// its period is claimed in schedule_runs as list_ready:chat:2026-10-19,
-// the coming week's start. It posts once.
-func TestChatAutosendSendsComingWeek(t *testing.T) {
-	e := newEnv(t)
-	s := e.shopping()
-	s.list(w43)
-	s.webhook()
-
-	// Saturday 07:00: the previous Saturday's period is past the
-	// catch-up window, so it is recorded as missed.
-	r := e.start(at(2026, 10, 17, 7, 0), s.svc.ChatAutosendSchedule())
-	r.runUntil(at(2026, 10, 17, 7, 59))
-	if n := len(s.chat.Posts()); n != 0 || s.get(w43).SentToChatAt != nil {
-		t.Fatalf("before 08:00: %d posts, sent_to_chat_at %v, want none", n, s.get(w43).SentToChatAt)
-	}
-
-	r.runUntil(at(2026, 10, 17, 8, 0))
-	posts := s.chat.Posts()
-	if len(posts) != 1 {
-		t.Fatalf("at 08:00: %d posts, want 1", len(posts))
-	}
-	if !strings.HasPrefix(posts[0].Text(), "Supply run · Week 43 · Oct 19 – 25") {
-		t.Errorf("posted %q, want the W43 Supply run", posts[0].Text())
-	}
-	if got := posts[0].Query.Get("threadKey"); got != chat.ThreadKey(w43) {
-		t.Errorf("posted in thread %q, want %q", got, chat.ThreadKey(w43))
-	}
-	if s.get(w43).SentToChatAt == nil {
-		t.Error("sent_to_chat_at not recorded")
-	}
-	s.wantLogged("Supply run sent to Google Chat")
-	s.wantLogged("period=list_ready:chat:2026-10-19")
-
-	r.runUntil(at(2026, 10, 24, 7, 0))
-	if n := len(s.chat.Posts()); n != 1 {
-		t.Errorf("a week on: %d posts, want 1", n)
-	}
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.ShoppingChatAutosend), []string{"list_ready:chat:2026-10-12", "list_ready:chat:2026-10-19"})
-}
-
-// TestChatAutosendFollowsSettings: chat_autosend_dow and
-// chat_autosend_time move the send without a restart, here to Friday
-// 18:00, still for the coming week.
-func TestChatAutosendFollowsSettings(t *testing.T) {
-	e := newEnv(t)
-	s := e.shopping()
-	s.list(w43)
-	s.webhook()
-
-	r := e.start(at(2026, 10, 16, 12, 0), s.svc.ChatAutosendSchedule())
-	e.update(household.SettingsPatch{ChatAutosendDow: ptr(5), ChatAutosendTime: ptr("18:00")})
-	r.changed()
-	r.runUntil(at(2026, 10, 16, 17, 59))
-	if n := len(s.chat.Posts()); n != 0 {
-		t.Fatalf("before Friday 18:00: %d posts, want 0", n)
-	}
-	r.runUntil(at(2026, 10, 16, 18, 0))
-	if n := len(s.chat.Posts()); n != 1 || s.get(w43).SentToChatAt == nil {
-		t.Fatalf("at Friday 18:00: %d posts, sent_to_chat_at %v, want 1 and set", n, s.get(w43).SentToChatAt)
-	}
-	r.runUntil(at(2026, 10, 17, 9, 0))
-	if n := len(s.chat.Posts()); n != 1 {
-		t.Errorf("Saturday: %d posts, want still 1", n)
-	}
-}
-
-// TestChatAutosendSkips: the schedule posts nothing, records no send and
-// fails nothing when the coming week's Supply run was already sent, when
-// the week has no Supply run, when list_ready is switched off for Google
-// Chat, and when no webhook is stored. Each period is still claimed and
-// the reason logged.
-func TestChatAutosendSkips(t *testing.T) {
-	cases := []struct {
-		name  string
-		setup func(t *testing.T, s *shopEnv)
-		// posts is how many posts the setup itself made.
-		posts  int
-		reason string
-	}{
-		{
-			name: "already sent",
-			setup: func(t *testing.T, s *shopEnv) {
-				s.list(w43)
-				s.webhook()
-				if _, err := s.svc.SendToChat(context.Background(), w43, false); err != nil {
-					t.Fatal(err)
-				}
-			},
-			posts:  1,
-			reason: shopping.AutosendAlreadySent,
-		},
-		{
-			name: "no list",
-			setup: func(t *testing.T, s *shopEnv) {
-				s.list(w42)
-				s.webhook()
-			},
-			reason: shopping.AutosendNoList,
-		},
-		{
-			name: "chat off for list_ready",
-			setup: func(t *testing.T, s *shopEnv) {
-				s.list(w43)
-				s.webhook()
-				if _, err := s.e.st.Writer.Exec(`UPDATE notification_prefs SET chat = 0 WHERE event = 'list_ready'`); err != nil {
-					t.Fatal(err)
-				}
-			},
-			reason: shopping.AutosendChatOff,
-		},
-		{
-			name: "no webhook",
-			setup: func(t *testing.T, s *shopEnv) {
-				s.list(w43)
-			},
-			reason: shopping.AutosendNotConfigured,
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			e := newEnv(t)
-			s := e.shopping()
-			c.setup(t, s)
-			var sentBefore *string
-			if l, err := s.svc.Get(context.Background(), w43); err == nil {
-				sentBefore = l.SentToChatAt
-			}
-
-			r := e.start(at(2026, 10, 17, 7, 0), s.svc.ChatAutosendSchedule())
-			r.runUntil(at(2026, 10, 17, 9, 0))
-			if n := len(s.chat.Posts()); n != c.posts {
-				t.Errorf("posts = %d, want %d", n, c.posts)
-			}
-			if l, err := s.svc.Get(context.Background(), w43); err == nil && !equalPtr(l.SentToChatAt, sentBefore) {
-				t.Errorf("sent_to_chat_at = %v, want %v", l.SentToChatAt, sentBefore)
-			}
-			s.wantLogged("Supply run not sent to Google Chat: " + c.reason)
-			wantKeys(t, "schedule_runs", e.claimed(scheduler.ShoppingChatAutosend), []string{"list_ready:chat:2026-10-12", "list_ready:chat:2026-10-19"})
-		})
-	}
-}
-
-// TestChatAutosendFailureSurfaces: a send Google Chat refuses is the
-// period's error, logged as such; the period stays claimed and is not
-// retried, and sent_to_chat_at is not recorded.
-func TestChatAutosendFailureSurfaces(t *testing.T) {
-	e := newEnv(t)
-	s := e.shopping()
-	s.list(w43)
-	s.webhook()
-	s.chat.SetStatus(500)
-
-	var logs syncBuffer
-	sched, err := scheduler.New(e.st, e.settings, slog.New(slog.NewTextHandler(&logs, nil)))
-	if err != nil {
-		t.Fatal(err)
-	}
-	clock := newFakeClock(at(2026, 10, 17, 7, 0))
-	scheduler.SetClock(sched, clock.Now, clock.After)
-	if err := sched.Register(s.svc.ChatAutosendSchedule()); err != nil {
-		t.Fatal(err)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	t.Cleanup(func() {
-		cancel()
-		sched.Wait()
-	})
-	if err := sched.Start(ctx); err != nil {
-		t.Fatal(err)
-	}
-	r := &running{t: t, clock: clock, stop: cancel}
-	r.idle()
-	r.runUntil(at(2026, 10, 17, 9, 0))
-
-	if n := len(s.chat.Posts()); n != 1 {
-		t.Errorf("posts = %d, want the one refused", n)
-	}
-	if s.get(w43).SentToChatAt != nil {
-		t.Error("sent_to_chat_at recorded for a refused send")
-	}
-	if got := logs.String(); !strings.Contains(got, "level=ERROR") || !strings.Contains(got, "scheduler: run failed") || !strings.Contains(got, "schedule=shopping_chat_autosend") {
-		t.Errorf("scheduler logs = %s, want the refused send logged as a failed run", got)
-	}
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.ShoppingChatAutosend), []string{"list_ready:chat:2026-10-12", "list_ready:chat:2026-10-19"})
-}
-
-func equalPtr(a, b *string) bool {
-	return (a == nil && b == nil) || (a != nil && b != nil && *a == *b)
-}
-
-// TestWeekRolloverFreezesPreviousWeek: at Monday 00:05 the schedule
-// freezes exactly the week that has just ended into the Supply archive,
-// not the week before it nor the new week; the next Monday freezes the
-// next week; a Monday whose previous week has no Supply run freezes
-// nothing and fails nothing. Its periods are week_rollover:YYYY-Www of the
-// Monday.
-func TestWeekRolloverFreezesPreviousWeek(t *testing.T) {
-	e := newEnv(t)
-	s := e.shopping()
-	s.list(w41)
-	s.list(w42)
-	s.list(w43)
-
-	status := func() []string {
-		return []string{s.get(w41).Status, s.get(w42).Status, s.get(w43).Status}
-	}
-	cur, arc := shopping.StatusCurrent, shopping.StatusArchived
-
-	// Sunday 23:00: last Monday's rollover is past the catch-up window and
-	// recorded as missed, so W41 is never frozen by it.
-	r := e.start(at(2026, 10, 18, 23, 0), s.svc.RolloverSchedule())
-	r.runUntil(at(2026, 10, 19, 0, 4))
-	wantKeys(t, "before Monday 00:05", status(), []string{cur, cur, cur})
-
-	r.runUntil(at(2026, 10, 19, 0, 5))
-	wantKeys(t, "at Monday 00:05", status(), []string{cur, arc, cur})
-	if s.get(w42).Title != nil {
-		t.Errorf("W42 title = %q, want frozen untitled", *s.get(w42).Title)
-	}
-	if _, err := s.svc.Generate(context.Background(), w42); !errors.Is(err, shopping.ErrFrozen) {
-		t.Errorf("generate W42 after the rollover: %v, want ErrFrozen", err)
-	}
-
-	r.runUntil(at(2026, 10, 26, 0, 5))
-	wantKeys(t, "next Monday", status(), []string{cur, arc, arc})
-
-	r.runUntil(at(2026, 11, 2, 0, 5))
-	s.wantLogged("week rollover froze nothing: the week has no Supply run")
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.WeekRollover), []string{"2026-W42", "2026-W43", "2026-W44", "2026-W45"})
-}
-
-// aiRun stores an ai_runs row created at created and returns its id.
-func (e *env) aiRun(created time.Time) string {
-	e.t.Helper()
-	id := store.NewID()
-	ts := store.Timestamp{Time: created.UTC()}.String()
-	if err := db.New(e.st.Writer).CreateAIRun(context.Background(), db.CreateAIRunParams{
-		ID: id, Skill: "draft_week", SkillVersion: "1", Provider: "anthropic", Model: "claude-test",
-		Temperature: 0.7, Status: "ok", RequestRedacted: "{}", ResponseRedacted: sql.NullString{String: "{}", Valid: true},
-		CreatedAt: ts, UpdatedAt: ts,
-	}); err != nil {
-		e.t.Fatal(err)
-	}
-	return id
-}
-
-// aiRuns returns the ids of the ai_runs rows, oldest first.
-func (e *env) aiRuns() []string {
-	e.t.Helper()
-	rows, err := e.st.Reader.Query(`SELECT id FROM ai_runs ORDER BY created_at`)
-	if err != nil {
-		e.t.Fatal(err)
-	}
-	defer rows.Close()
-	var ids []string
-	for rows.Next() {
-		var id string
-		if err := rows.Scan(&id); err != nil {
-			e.t.Fatal(err)
-		}
-		ids = append(ids, id)
-	}
-	if err := rows.Err(); err != nil {
-		e.t.Fatal(err)
-	}
-	return ids
-}
-
-// TestAIRunsPurgeDaily: every day at 03:00 the schedule deletes the
-// ai_runs rows created more than 30 days before, and no younger row; its
-// periods are ai_runs_purge:YYYY-MM-DD.
-func TestAIRunsPurgeDaily(t *testing.T) {
-	e := newEnv(t)
-	e.aiRun(at(2026, 9, 10, 12, 0)) // older than Sep 11 03:00
-	edge := e.aiRun(at(2026, 9, 12, 2, 59))
-	young := e.aiRun(at(2026, 9, 12, 3, 1))
-	recent := e.aiRun(at(2026, 10, 11, 12, 0))
-
-	sch, err := harness.PurgeSchedule(e.st, slog.New(slog.NewTextHandler(&syncBuffer{}, nil)))
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Monday 02:00: the catch-up of Sunday 03:00 purges before Sep 11 03:00.
-	r := e.start(at(2026, 10, 12, 2, 0), sch)
-	wantKeys(t, "after the catch-up", e.aiRuns(), []string{edge, young, recent})
-
-	r.runUntil(at(2026, 10, 12, 2, 59))
-	wantKeys(t, "before 03:00", e.aiRuns(), []string{edge, young, recent})
-	r.runUntil(at(2026, 10, 12, 3, 0))
-	wantKeys(t, "at 03:00", e.aiRuns(), []string{young, recent})
-	r.runUntil(at(2026, 10, 13, 3, 0))
-	wantKeys(t, "next day", e.aiRuns(), []string{recent})
-	wantKeys(t, "schedule_runs", e.claimed(scheduler.AIRunsPurge), []string{"2026-10-11", "2026-10-12", "2026-10-13"})
-}
-
-// TestPurgeScheduleRejectsNil: the purge schedule needs a store and a
-// logger.
-func TestPurgeScheduleRejectsNil(t *testing.T) {
-	e := newEnv(t)
-	if _, err := harness.PurgeSchedule(nil, slog.Default()); err == nil {
-		t.Error("nil store accepted")
-	}
-	if _, err := harness.PurgeSchedule(e.st, nil); err == nil {
-		t.Error("nil logger accepted")
-	}
-}

internal/server/dinnerdetail_test.go

@@ -3,7 +3,6 @@ package server
 import (
 	"database/sql"
 	"encoding/json"
-	"io/fs"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -15,7 +14,6 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/migrations"
 )
 
 // getDetail answers GET /dinners/{id} for id, failing unless it is 200, and
@@ -72,8 +70,8 @@ func TestGetDinnerGroundedSideQuest(t *testing.T) {
 	}
 	for _, stmt := range []string{
 		`UPDATE dinners SET status = 'quest_log', origin = 'side_quest', is_favorite = 1 WHERE id = ?`,
-		`UPDATE recipe_ingredients SET position = 9 - position WHERE recipe_id = (SELECT recipe_id FROM dinners WHERE id = ?)`,
-		`UPDATE recipe_steps SET position = 9 - position WHERE recipe_id = (SELECT recipe_id FROM dinners WHERE id = ?)`,
+		`UPDATE recipe_ingredients SET position = 1 - position WHERE recipe_id = (SELECT recipe_id FROM dinners WHERE id = ?)`,
+		`UPDATE recipe_steps SET position = 1 - position WHERE recipe_id = (SELECT recipe_id FROM dinners WHERE id = ?)`,
 	} {
 		if _, err := e.st.Writer.Exec(stmt, id); err != nil {
 			t.Fatal(err)
@@ -330,33 +328,14 @@ func TestGetDinnerSourceURLOnlyWhenSafe(t *testing.T) {
 	}
 }
 
-// siteNameMigration is migration 0020, which clears the host-shaped site
-// names stored before extraction stopped storing hosts.
-const siteNameMigration = "0020_site_name_from_page.sql"
-
-// applySiteNameMigration runs siteNameMigration again over rows a test
-// stored as the code before it did, as upgrading a database holding them
-// does.
-func applySiteNameMigration(t *testing.T, st *store.Store) {
-	t.Helper()
-	body, err := fs.ReadFile(migrations.FS, siteNameMigration)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.Writer.ExecContext(t.Context(), string(body)); err != nil {
-		t.Fatalf("%s: %v", siteNameMigration, err)
-	}
-}
-
-// TestGetDinnerSiteNameProvenance: extraction stores only a site name the
-// page gave, never the URL's host, and the detail applies one rule to what
-// is stored. A name from page metadata is shown even over a token-bearing
-// link; a page naming no site stores no name, and is named by its link's
-// host only when the link is shown — so over a link with a token nothing
-// of the link reaches the client. A name stored before extraction stopped
-// storing hosts is read by the same rule once migration 0020 has cleared
-// it if it could be a host.
-func TestGetDinnerSiteNameProvenance(t *testing.T) {
+// TestGetDinnerSiteNameNeverFromLink: a page that names no site is stored
+// under its host, so a recipe grounded in a pasted link whose host carries a
+// token has site_name null and nothing from the link in its detail; a page
+// that names its site keeps that name, even on a token-bearing host; and a
+// stored name shaped like another host, as a redirect leaves, is withheld.
+// The links carry a query, so source.url is withheld too and nothing of the
+// link may appear.
+func TestGetDinnerSiteNameNeverFromLink(t *testing.T) {
 	t.Parallel()
 	e := newDinnersEnv(t)
 	const (
@@ -364,14 +343,11 @@ func TestGetDinnerSiteNameProvenance(t *testing.T) {
 		namedToken = "named-token-def456"
 		bare       = "https://" + bareToken + ".example.com/recipe?print=1"
 		named      = "https://www." + namedToken + ".example.com/recipe?print=1"
-		ordinary   = "https://www.kitchen.example/recipes/curry"
 	)
 	e.pages.Bodies[bare] = recipestest.RecipePage("Chicken Curry", "", "https://a.example/curry.jpg", 40)
 	e.pages.Bodies[named] = recipestest.RecipePage("Weeknight Curry", "Curry House", "https://b.example/curry.jpg", 25)
-	e.pages.Bodies[ordinary] = recipestest.RecipePage("Green Curry", "", "https://c.example/curry.jpg", 30)
 	e.images.JPEGs["https://a.example/curry.jpg"] = recipestest.JPEG(t, 400, 320, 1)
 	e.images.JPEGs["https://b.example/curry.jpg"] = recipestest.JPEG(t, 400, 320, 2)
-	e.images.JPEGs["https://c.example/curry.jpg"] = recipestest.JPEG(t, 400, 320, 3)
 	ground := func(dish, page string) (id, recipeID string) {
 		t.Helper()
 		id = createDinner(t, e.h, `{"name":"`+dish+`"}`) // runner not started: stays pending
@@ -384,18 +360,15 @@ func TestGetDinnerSiteNameProvenance(t *testing.T) {
 		}
 		return id, recipeID
 	}
-	storedSite := func(recipeID string) any {
+	storedSite := func(recipeID string) string {
 		t.Helper()
-		var site sql.NullString
+		var site string
 		if err := e.st.Reader.QueryRow(`SELECT site_name FROM recipes WHERE id = ?`, recipeID).Scan(&site); err != nil {
 			t.Fatal(err)
 		}
-		if !site.Valid {
-			return nil
-		}
-		return site.String
+		return site
 	}
-	check := func(what, id string, leaks []string, want map[string]any) {
+	check := func(what, id string, leaks []string, want any) {
 		t.Helper()
 		rec, _ := callDinners(t, e.h, http.MethodGet, dinnersPath+"/"+id, "")
 		if rec.Code != http.StatusOK {
@@ -407,48 +380,28 @@ func TestGetDinnerSiteNameProvenance(t *testing.T) {
 			}
 		}
 		raw, _ := getDetail(t, e.h, id)
-		if src, _ := raw["source"].(map[string]any); !reflect.DeepEqual(src, want) {
-			t.Errorf("source of %s = %v, want %v", what, raw["source"], want)
+		if src, _ := raw["source"].(map[string]any); !reflect.DeepEqual(src, map[string]any{"site_name": want, "url": nil}) {
+			t.Errorf("source of %s = %v, want site_name %v and url null", what, raw["source"], want)
 		}
 	}
 
+	bareID, bareRecipe := ground("Chicken curry", bare)
+	if got := storedSite(bareRecipe); got != bareToken+".example.com" {
+		t.Fatalf("stored site_name = %q, want the link's host", got)
+	}
+	check("a page naming no site", bareID, []string{bare, bareToken, "example.com"}, nil)
+
 	namedID, namedRecipe := ground("Weeknight curry", named)
 	if got := storedSite(namedRecipe); got != "Curry House" {
-		t.Fatalf("stored site_name = %v, want the page's", got)
+		t.Fatalf("stored site_name = %q, want the page's", got)
 	}
-	check("a metadata-derived name over a token-bearing link", namedID, []string{named, namedToken, "example.com"},
-		map[string]any{"site_name": "Curry House", "url": nil})
+	check("a page naming its site", namedID, []string{named, namedToken, "example.com"}, "Curry House")
 
-	bareID, bareRecipe := ground("Chicken curry", bare)
-	if got := storedSite(bareRecipe); got != nil {
-		t.Fatalf("stored site_name = %v, want null: the page names no site", got)
-	}
-	check("a hostname-derived name over a token-bearing link", bareID, []string{bare, bareToken, "example.com"},
-		map[string]any{"site_name": nil, "url": nil})
-
-	ordinaryID, ordinaryRecipe := ground("Green curry", ordinary)
-	if got := storedSite(ordinaryRecipe); got != nil {
-		t.Fatalf("stored site_name = %v, want null: the page names no site", got)
-	}
-	check("a hostname-derived name over an ordinary link", ordinaryID, nil,
-		map[string]any{"site_name": "kitchen.example", "url": ordinary})
-
-	// Rows as extraction stored them before it stopped storing hosts: the
-	// token-bearing link's own host, and a redirect's host under a page
-	// that named its site, are cleared by 0020; a page's own name stays.
 	const redirectHost = "redirect-token-ghi789.example.net"
-	for recipeID, site := range map[string]string{bareRecipe: bareToken + ".example.com", namedRecipe: redirectHost, ordinaryRecipe: "Green Kitchen"} {
-		if _, err := e.st.Writer.Exec(`UPDATE recipes SET site_name = ? WHERE id = ?`, site, recipeID); err != nil {
-			t.Fatal(err)
-		}
+	if _, err := e.st.Writer.Exec(`UPDATE recipes SET site_name = ? WHERE id = ?`, redirectHost, namedRecipe); err != nil {
+		t.Fatal(err)
 	}
-	applySiteNameMigration(t, e.st)
-	check("a row stored before, named by its token-bearing link's host", bareID, []string{bare, bareToken, "example.com"},
-		map[string]any{"site_name": nil, "url": nil})
-	check("a row stored before, named by a redirect's host", namedID, []string{redirectHost, "redirect-token", namedToken},
-		map[string]any{"site_name": nil, "url": nil})
-	check("a row stored before, named by its page", ordinaryID, nil,
-		map[string]any{"site_name": "Green Kitchen", "url": ordinary})
+	check("a page named by a redirect's host", namedID, []string{redirectHost, "redirect-token", namedToken}, nil)
 }
 
 // TestGetDinnerWhyPickedIsCreatingSuggestion: why_picked is the reason of
@@ -492,3 +445,25 @@ func TestGetDinnerWhyPickedIsCreatingSuggestion(t *testing.T) {
 		t.Errorf("why_picked = %v, want %q", got.WhyPicked, reason)
 	}
 }
+
+// TestGetDinnerDuplicatePositionFails: a recipe with two ingredients or two
+// steps at one position has no order anyone can trust, so its detail is a
+// 500 rather than the recipe in some order.
+func TestGetDinnerDuplicatePositionFails(t *testing.T) {
+	t.Parallel()
+	e := newDinnersEnv(t)
+	for _, table := range []string{"recipe_ingredients", "recipe_steps"} {
+		id := createDinner(t, e.h, `{"name":"Family chili `+table+`"}`)
+		if rec, _ := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground",
+			`{"manual":{"ingredients":["1 lb beef","1 can beans"],"steps":["Brown.","Simmer."],"minutes":240,"method":"crockpot"}}`); rec.Code != http.StatusOK {
+			t.Fatalf("POST ground = %d: %s", rec.Code, rec.Body)
+		}
+		if _, err := e.st.Writer.Exec(`UPDATE `+table+` SET position = 0 WHERE recipe_id = (SELECT recipe_id FROM dinners WHERE id = ?)`, id); err != nil {
+			t.Fatal(err)
+		}
+		rec, _ := callDinners(t, e.h, http.MethodGet, dinnersPath+"/"+id, "")
+		if rec.Code != http.StatusInternalServerError || strings.Contains(rec.Body.String(), "Simmer.") || strings.Contains(rec.Body.String(), "1 lb beef") {
+			t.Errorf("GET with duplicate %s positions = %d: %s, want 500 and no recipe", table, rec.Code, rec.Body)
+		}
+	}
+}

internal/server/dinners.go

@@ -72,11 +72,11 @@ func getDinners(logger *slog.Logger, svc *dinners.Service) http.HandlerFunc {
 
 // getDinner answers GET /dinners/{id} with the dinner, its recipe and the
 // reason it was suggested. An archived dinner is 404, like an unknown one,
-// not a 200 with its status: it has no detail to show. source is as
-// dinners.SourceOf gives it: the recipe page's link only when it is free of
-// secrets, and site_name the name the page gave its site, else the shown
-// link's host, else null — so the detail screen shows "Recipe from {site}"
-// only when site_name is not null.
+// not a 200 with its status: it has no detail to show. source never has the
+// recipe page's link, and source.site_name is null unless the page itself
+// named its site — a name that could be a host, the link's or a redirect's,
+// is withheld (dinners.Source) — so the detail screen shows "Recipe from
+// {site}" only when site_name is not null.
 func getDinner(logger *slog.Logger, svc *dinners.Service) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		d, err := svc.Get(r.Context(), chi.URLParam(r, "id"))
@@ -134,8 +134,7 @@ func patchDinner(logger *slog.Logger, svc *dinners.Service) http.HandlerFunc {
 }
 
 // getDinnerCandidates answers GET /dinners/{id}/recipe-candidates with up
-// to dinners.MaxCandidates recipe pages for the dinner's name, each
-// site_name as dinners.SourceOf gives it.
+// to dinners.MaxCandidates recipe pages for the dinner's name.
 func getDinnerCandidates(logger *slog.Logger, svc *dinners.Service) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		list, err := svc.Candidates(r.Context(), chi.URLParam(r, "id"))

internal/server/dinners_test.go

@@ -93,7 +93,7 @@ func newDinnersEnv(t *testing.T) *dinnersEnv {
 	if err != nil {
 		t.Fatal(err)
 	}
-	svc, err := dinners.NewService(st, g, runner, func() {}, logger)
+	svc, err := dinners.NewService(st, g, runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/grounding_test.go

@@ -184,51 +184,6 @@ func TestGetRecipeCandidates(t *testing.T) {
 	}
 }
 
-// TestGetRecipeCandidatesSiteNames: a candidate's site_name follows the
-// recipe detail's rule (dinners.SourceOf), not a hostname fallback of its
-// own: a name the page gave is offered as it stands, even over a link with
-// a token; a page naming no site is named by its link's host only when
-// the link is free of secrets, and is null over a token-bearing link, so
-// nothing of that link reaches the client.
-func TestGetRecipeCandidatesSiteNames(t *testing.T) {
-	t.Parallel()
-	e := newDinnersEnv(t)
-	const (
-		token    = "offer-token-abc123"
-		named    = "https://named.example/curry?access_token=" + token
-		bare     = "https://" + token + ".example.com/curry?print=1"
-		ordinary = "https://www.kitchen.example/recipes/curry"
-	)
-	e.search.Results["Chicken curry"] = []recipes.Candidate{{URL: named}, {URL: bare}, {URL: ordinary}}
-	e.pages.Bodies[named] = recipestest.RecipePage("Named Curry", "Curry House", "https://a.example/curry.jpg", 40)
-	e.pages.Bodies[bare] = recipestest.RecipePage("Bare Curry", "", "https://b.example/curry.jpg", 30)
-	e.pages.Bodies[ordinary] = recipestest.RecipePage("Ordinary Curry", "", "https://c.example/curry.jpg", 25)
-	id := createDinner(t, e.h, `{"name":"Chicken curry"}`) // runner not started: stays pending
-
-	rec, body := callDinners(t, e.h, http.MethodGet, dinnersPath+"/"+id+"/recipe-candidates", "")
-	if rec.Code != http.StatusOK {
-		t.Fatalf("GET = %d: %s", rec.Code, rec.Body)
-	}
-	for _, leak := range []string{token, "access_token", "example.com"} {
-		if strings.Contains(rec.Body.String(), leak) {
-			t.Errorf("candidates contain %q: %s", leak, rec.Body)
-		}
-	}
-	want := map[string]any{"Named Curry": "Curry House", "Bare Curry": nil, "Ordinary Curry": "kitchen.example"}
-	list, _ := body["candidates"].([]any)
-	if len(list) != len(want) {
-		t.Fatalf("candidates = %v, want %d", body, len(want))
-	}
-	for _, c := range list {
-		c := c.(map[string]any)
-		title, _ := c["title"].(string)
-		site, ok := c["site_name"]
-		if w, known := want[title]; !known || !ok || site != w {
-			t.Errorf("candidate %q site_name = %#v (present %v), want %#v", title, site, ok, w)
-		}
-	}
-}
-
 func TestGetRecipeCandidatesSearchFails(t *testing.T) {
 	t.Parallel()
 	e := newDinnersEnv(t)

internal/server/home.go

@@ -1,10 +1,8 @@
 package server
 
 import (
-	"errors"
 	"log/slog"
 	"net/http"
-	"time"
 
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/home"
 )
@@ -22,64 +20,3 @@ func getHome(logger *slog.Logger, svc *home.Service) http.HandlerFunc {
 		writeJSON(w, r, logger, http.StatusOK, h)
 	}
 }
-
-// updatesBody is the GET /updates answer.
-type updatesBody struct {
-	Updates []home.Update `json:"updates"`
-}
-
-// getUpdates answers GET /updates with the Recent updates: the last
-// home.RecentLimit distinct notification events, newest first.
-func getUpdates(logger *slog.Logger, svc *home.Service) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		updates, err := svc.Updates(r.Context())
-		if err != nil {
-			logger.ErrorContext(r.Context(), "read recent updates", "error", err)
-			writeError(w, r, logger, http.StatusInternalServerError, "internal", "internal error")
-			return
-		}
-		writeJSON(w, r, logger, http.StatusOK, updatesBody{Updates: updates})
-	}
-}
-
-// maxUpdatesSeenBody bounds a POST /updates/seen request body.
-const maxUpdatesSeenBody = 1 << 10
-
-// updatesSeenRequest is the POST /updates/seen body: through is the
-// created_at of the newest update the household was shown.
-type updatesSeenRequest struct {
-	Through *string `json:"through"`
-}
-
-// postUpdatesSeen answers POST /updates/seen by recording that the
-// household has seen its updates through the body's through, and answers
-// 204. A through before the one already recorded changes nothing.
-func postUpdatesSeen(logger *slog.Logger, svc *home.Service) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		req, err := decodePatch[updatesSeenRequest](http.MaxBytesReader(w, r.Body, maxUpdatesSeenBody))
-		if err != nil {
-			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", err.Error())
-			return
-		}
-		if req.Through == nil {
-			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "through: required")
-			return
-		}
-		through, err := time.Parse(time.RFC3339Nano, *req.Through)
-		if err != nil {
-			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "through: want an RFC 3339 timestamp")
-			return
-		}
-		err = svc.MarkUpdatesSeen(r.Context(), through)
-		if errors.Is(err, home.ErrSeenInFuture) {
-			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "through: must not be after now")
-			return
-		}
-		if err != nil {
-			logger.ErrorContext(r.Context(), "mark recent updates seen", "error", err)
-			writeError(w, r, logger, http.StatusInternalServerError, "internal", "internal error")
-			return
-		}
-		w.WriteHeader(http.StatusNoContent)
-	}
-}

internal/server/home_test.go

@@ -1,18 +1,13 @@
 package server
 
 import (
-	"database/sql"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
-	"strings"
 	"testing"
 	"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/notify"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
 )
 
 // GET /home answers the Home screen in its JSON shape; newTestHome's
@@ -35,7 +30,6 @@ func TestGetHome(t *testing.T) {
 		}
 		body, err := json.Marshal(map[string]any{
 			"dateLabel":      now.In(loc).Format("Monday, Jan 2"),
-			"timezone":       loc.String(),
 			"tonight":        nil,
 			"sideQuestCount": 0,
 			"shoppingList":   map[string]any{"weekStart": week.String(), "label": label, "ready": false, "sentToChatAt": nil},
@@ -73,173 +67,3 @@ func TestGetHomeNeedsSession(t *testing.T) {
 		t.Errorf("GET /api/v1/home without a session = %d, want 401", rec.Code)
 	}
 }
-
-// homeRouter returns a router whose Home reads st, and st.
-func homeRouter(t *testing.T) (http.Handler, *store.Store) {
-	t.Helper()
-	st := newTestStore(t)
-	svc := newTestHomeOn(t, st)
-	return newTestRouterWithHome(t, "dev", newTestSettings(t), newTestRunner(t), svc), st
-}
-
-// storeEvent stores event key in st's outbox at instant at for each of
-// channels, as notify stores an event, and returns at as stored.
-func storeEvent(t *testing.T, st *store.Store, typ notify.EventType, key, title string, at time.Time, channels ...notify.Channel) string {
-	t.Helper()
-	payload, err := json.Marshal(notify.Payload{Event: typ, Title: title, Body: "Body of " + key, URL: "/plan", Tag: key})
-	if err != nil {
-		t.Fatal(err)
-	}
-	ts := store.Timestamp{Time: at.UTC().Truncate(time.Millisecond)}.String()
-	for _, ch := range channels {
-		if _, err := db.New(st.Writer).InsertNotification(t.Context(), db.InsertNotificationParams{
-			ID: store.NewID(), EventKey: key, Channel: string(ch), Payload: string(payload),
-			NextAttemptAt: sql.NullString{String: ts, Valid: true}, Now: ts,
-		}); err != nil {
-			t.Fatal(err)
-		}
-	}
-	return ts
-}
-
-// unread reads recentUpdates.unread from GET /home.
-func unread(t *testing.T, h http.Handler) bool {
-	t.Helper()
-	rec, body := serve(t, h, signedIn(http.MethodGet, "/api/v1/home", nil))
-	if rec.Code != http.StatusOK {
-		t.Fatalf("GET /api/v1/home = %d: %s", rec.Code, rec.Body)
-	}
-	updates, ok := body["recentUpdates"].(map[string]any)
-	if !ok {
-		t.Fatalf("GET /api/v1/home has no recentUpdates: %s", rec.Body)
-	}
-	return updates["unread"] == true
-}
-
-// markSeen posts body to /updates/seen and returns the answer.
-func markSeen(t *testing.T, h http.Handler, body string) *httptest.ResponseRecorder {
-	t.Helper()
-	rec := httptest.NewRecorder()
-	h.ServeHTTP(rec, signedIn(http.MethodPost, "/api/v1/updates/seen", strings.NewReader(body)))
-	return rec
-}
-
-// GET /updates lists the last distinct events newest first, one per event
-// whatever its channels, in their JSON shape.
-func TestGetUpdates(t *testing.T) {
-	t.Parallel()
-	h, st := homeRouter(t)
-
-	rec := httptest.NewRecorder()
-	h.ServeHTTP(rec, signedIn(http.MethodGet, "/api/v1/updates", nil))
-	if rec.Code != http.StatusOK || rec.Body.String() != `{"updates":[]}` {
-		t.Errorf("GET /api/v1/updates with none = %d %s, want 200 {\"updates\":[]}", rec.Code, rec.Body)
-	}
-
-	now := time.Now()
-	older := storeEvent(t, st, notify.NewSuggestions, "new_suggestions:1", "New Side quests", now.Add(-2*time.Minute), notify.ChannelPush)
-	newer := storeEvent(t, st, notify.PlanReady, "plan_ready:2026-10-12", "Your week is drafted", now.Add(-time.Minute), notify.ChannelPush, notify.ChannelChat)
-
-	rec = httptest.NewRecorder()
-	h.ServeHTTP(rec, signedIn(http.MethodGet, "/api/v1/updates", nil))
-	want := `{"updates":[` +
-		`{"type":"plan_ready","title":"Your week is drafted","body":"Body of plan_ready:2026-10-12","url":"/plan","created_at":"` + newer + `"},` +
-		`{"type":"new_suggestions","title":"New Side quests","body":"Body of new_suggestions:1","url":"/plan","created_at":"` + older + `"}]}`
-	if rec.Code != http.StatusOK || rec.Body.String() != want {
-		t.Errorf("GET /api/v1/updates = %d %s, want 200 %s", rec.Code, rec.Body, want)
-	}
-}
-
-// Unread is true while an event newer than the last seen one exists,
-// clears once POST /updates/seen marks the newest seen, and returns when a
-// newer event is stored; marking an older one seen again moves nothing.
-func TestUpdatesSeen(t *testing.T) {
-	t.Parallel()
-	h, st := homeRouter(t)
-	now := time.Now()
-
-	if unread(t, h) {
-		t.Error("unread with no events")
-	}
-	first := storeEvent(t, st, notify.PlanReady, "plan_ready:1", "Drafted", now.Add(-2*time.Minute), notify.ChannelPush, notify.ChannelChat)
-	if !unread(t, h) {
-		t.Error("not unread with an event never seen")
-	}
-	if rec := markSeen(t, h, `{"through":"`+first+`"}`); rec.Code != http.StatusNoContent || rec.Body.Len() != 0 {
-		t.Fatalf("POST /api/v1/updates/seen = %d %s, want 204", rec.Code, rec.Body)
-	}
-	if unread(t, h) {
-		t.Error("unread after the newest event was marked seen")
-	}
-
-	second := storeEvent(t, st, notify.ListReady, "list_ready:2", "Supply run ready", now.Add(-time.Minute), notify.ChannelPush)
-	if !unread(t, h) {
-		t.Error("not unread with an event newer than the last seen")
-	}
-	// Already seen: marking the older event seen again is accepted and
-	// changes nothing.
-	if rec := markSeen(t, h, `{"through":"`+first+`"}`); rec.Code != http.StatusNoContent {
-		t.Fatalf("POST /api/v1/updates/seen of an older event = %d %s, want 204", rec.Code, rec.Body)
-	}
-	if !unread(t, h) {
-		t.Error("marking an older event seen hid a newer one")
-	}
-	if rec := markSeen(t, h, `{"through":"`+second+`"}`); rec.Code != http.StatusNoContent {
-		t.Fatalf("POST /api/v1/updates/seen = %d %s, want 204", rec.Code, rec.Body)
-	}
-	if unread(t, h) {
-		t.Error("unread after the newer event was marked seen")
-	}
-}
-
-// A malformed POST /updates/seen is 400 and records nothing.
-func TestUpdatesSeenRejectsMalformed(t *testing.T) {
-	t.Parallel()
-	h, st := homeRouter(t)
-	storeEvent(t, st, notify.PlanReady, "plan_ready:1", "Drafted", time.Now().Add(-time.Minute), notify.ChannelPush)
-
-	for _, body := range []string{
-		``,
-		`[]`,
-		`{}`,
-		`{"through":null}`,
-		`{"through":42}`,
-		`{"through":"yesterday"}`,
-		`{"through":"2026-10-13 12:00:00"}`,
-		`{"through":"2026-10-13T12:00:00.000Z","extra":true}`,
-		`{"through":"2026-10-13T12:00:00.000Z"} {}`,
-		`{"through":"` + time.Now().Add(time.Hour).UTC().Format(time.RFC3339Nano) + `"}`,
-	} {
-		rec := markSeen(t, h, body)
-		if rec.Code != http.StatusBadRequest || !strings.Contains(rec.Body.String(), `"invalid_request"`) {
-			t.Errorf("POST /api/v1/updates/seen %q = %d %s, want 400 invalid_request", body, rec.Code, rec.Body)
-		}
-	}
-	if !unread(t, h) {
-		t.Error("a malformed POST /updates/seen marked updates seen")
-	}
-}
-
-// Both endpoints need a session, and POST /updates/seen the CSRF token.
-func TestUpdatesNeedSessionAndCSRF(t *testing.T) {
-	t.Parallel()
-	h, _ := homeRouter(t)
-	body := `{"through":"2026-10-01T12:00:00.000Z"}`
-	for _, req := range []*http.Request{
-		httptest.NewRequest(http.MethodGet, "/api/v1/updates", nil),
-		httptest.NewRequest(http.MethodPost, "/api/v1/updates/seen", strings.NewReader(body)),
-	} {
-		rec := httptest.NewRecorder()
-		h.ServeHTTP(rec, req)
-		if rec.Code != http.StatusUnauthorized {
-			t.Errorf("%s %s without a session = %d, want 401", req.Method, req.URL.Path, rec.Code)
-		}
-	}
-	req := httptest.NewRequest(http.MethodPost, "/api/v1/updates/seen", strings.NewReader(body))
-	req.AddCookie(validSessionCookie)
-	rec := httptest.NewRecorder()
-	h.ServeHTTP(rec, req)
-	if rec.Code != http.StatusForbidden {
-		t.Errorf("POST /api/v1/updates/seen without the CSRF token = %d, want 403", rec.Code)
-	}
-}

internal/server/ideaactions_test.go

@@ -65,7 +65,7 @@ func newIdeaActionsRouter(t *testing.T, model, normalize *llm.Fake, search *reci
 	if err != nil {
 		t.Fatal(err)
 	}
-	dinnerSvc, err := dinners.NewService(st, g, runner, func() {}, logger)
+	dinnerSvc, err := dinners.NewService(st, g, runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -73,7 +73,7 @@ func newIdeaActionsRouter(t *testing.T, model, normalize *llm.Fake, search *reci
 		t.Error("draft_week ran: an idea action must never draft a plan")
 		return skills.Week{}, context.Canceled
 	}
-	planSvc, err := plan.NewService(st, draft, runner, newTestGoogle(t), notifytest.New(t, st), func() {}, &url.URL{Scheme: "https", Host: "mealquest.example"}, time.Now, logger)
+	planSvc, err := plan.NewService(st, draft, runner, newTestGoogle(t), notifytest.New(t, st), &url.URL{Scheme: "https", Host: "mealquest.example"}, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/ideasource_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 // sourceCase is a recipe page an idea grounds in: its link and the site
-// name its page gives (empty for none, so no name is stored).
+// 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.
@@ -33,7 +33,7 @@ const (
 
 // 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 no name is stored and, the links being unsafe, none is shown.
+// 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},
@@ -137,9 +137,8 @@ func legacyIdea(name, link, site string) map[string]any {
 }
 
 // A job of either idea kind whose result was stored before sources were
-// made safe, and upgraded by migration 0020, is served with the sources a
-// job stored now holds: neither a token-bearing link nor a name taken from
-// its host.
+// 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()
@@ -163,10 +162,7 @@ func TestJobServesLegacyIdeaResultsWithOnlySafeSources(t *testing.T) {
 			id, kind, string(js)); err != nil {
 			t.Fatal(err)
 		}
-	}
-	applySiteNameMigration(t, st)
-	for kind := range map[string]bool{ideas.KindFromIngredients: true, ideas.KindQuick: true} {
-		checkIdeaSources(t, h, "legacy-"+kind)
+		checkIdeaSources(t, h, id)
 	}
 }
 

internal/server/plans.go

@@ -111,13 +111,10 @@ type pushedPlan struct {
 // plan Calendar does not show and pushing again makes it; or
 // supply_run_failed when it could not be made, and POST
 // /shopping/{weekStart}/generate makes it again. error is null when status
-// is generated. title_job_id is the job titling a generated Supply run,
-// which GET /jobs/{id} reports on; null when it already has its title or
-// was not generated.
+// is generated.
 type pushedSupplyRun struct {
-	Status     string    `json:"status"`
-	Error      *apiError `json:"error"`
-	TitleJobID *string   `json:"title_job_id"`
+	Status string    `json:"status"`
+	Error  *apiError `json:"error"`
 }
 
 // postPlanPush pushes the week's plan to the chosen Google calendar
@@ -146,9 +143,7 @@ func postPlanPush(logger *slog.Logger, svc *plan.Service, shop *shopping.Service
 		// gone.
 		ctx := context.WithoutCancel(r.Context())
 		run := pushedSupplyRun{Status: "generated"}
-		if g, err := shop.GeneratePushed(ctx, week, revision); err == nil {
-			run.TitleJobID = g.TitleJobID
-		} else if errors.Is(err, shopping.ErrFrozen) {
+		if _, err := shop.GeneratePushed(ctx, week, revision); errors.Is(err, shopping.ErrFrozen) {
 			logger.InfoContext(ctx, "Supply run in the Supply archive left as it was after Push to Calendar", "week", week.String())
 			run = pushedSupplyRun{Status: "archived", Error: &apiError{Code: "archived", Message: err.Error()}}
 		} else if errors.Is(err, shopping.ErrPlanChanged) {
@@ -158,7 +153,7 @@ func postPlanPush(logger *slog.Logger, svc *plan.Service, shop *shopping.Service
 				Message:   "the plan is on Calendar as pushed, but it was edited before its Supply run was made, so no Supply run was made from it; push again",
 				Retryable: true,
 			}}
-		} else {
+		} else if err != nil {
 			logger.ErrorContext(ctx, "generate Supply run after Push to Calendar", "week", week.String(), "error", err)
 			run = pushedSupplyRun{Status: "failed", Error: &apiError{
 				Code:      "supply_run_failed",

internal/server/plans_test.go

@@ -14,7 +14,6 @@ import (
 	"sync"
 	"testing"
 	"testing/fstest"
-	"time"
 
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
@@ -94,7 +93,7 @@ func newPlansRouterTitled(t *testing.T, title shopping.Titler) plansEnv {
 		t.Fatal(err)
 	}
 	notifier := notifytest.New(t, st)
-	svc, err := plan.NewService(st, fail, runner, googleSvc, notifier, func() {}, pub, time.Now, logger)
+	svc, err := plan.NewService(st, fail, runner, googleSvc, notifier, pub, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -108,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,
-		newTestDinnersOn(t, st), newTestSuggest(t), svc, shop, googleSvc, newTestPush(t), newTestIdeas(t), newTestHome(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/server.go

@@ -67,8 +67,7 @@ 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; homeSvc serves GET /api/v1/home, GET
-// /api/v1/updates and POST /api/v1/updates/seen; 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.
@@ -143,8 +142,6 @@ func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, a
 	}
 	apiV1.Get("/me", me(logger))
 	apiV1.Get("/home", getHome(logger, homeSvc))
-	apiV1.Get("/updates", getUpdates(logger, homeSvc))
-	apiV1.Post("/updates/seen", postUpdatesSeen(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

@@ -15,7 +15,6 @@ import (
 	"strings"
 	"testing"
 	"testing/fstest"
-	"time"
 
 	"github.com/go-chi/chi/v5"
 	"golang.org/x/oauth2"
@@ -53,19 +52,13 @@ func newTestRouter(t *testing.T, version string) http.Handler {
 }
 
 func newTestRouterWith(t *testing.T, version string, settings *household.SettingsService, runner *jobs.Runner) http.Handler {
-	t.Helper()
-	return newTestRouterWithHome(t, version, settings, runner, newTestHome(t))
-}
-
-// newTestRouterWithHome is newTestRouterWith serving Home from homeSvc.
-func newTestRouterWithHome(t *testing.T, version string, settings *household.SettingsService, runner *jobs.Runner, homeSvc *home.Service) http.Handler {
 	t.Helper()
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	assets := fstest.MapFS{
 		"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), homeSvc, 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)
 	}
@@ -168,19 +161,14 @@ func newTestSearch(t *testing.T) *recipes.SearchSettingsService {
 // with its own unstarted job runner and a grounder that finds nothing.
 func newTestDinners(t *testing.T) *dinners.Service {
 	t.Helper()
-	return newTestDinnersOn(t, newTestStore(t))
-}
-
-// newTestDinnersOn is newTestDinners over st.
-func newTestDinnersOn(t *testing.T, st *store.Store) *dinners.Service {
-	t.Helper()
+	st := newTestStore(t)
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	runner, err := jobs.NewRunner(st, logger, 1)
 	if err != nil {
 		t.Fatal(err)
 	}
 	g := recipestest.NewGrounder(t, st, t.TempDir(), &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, &llm.Fake{})
-	svc, err := dinners.NewService(st, g, runner, func() {}, logger)
+	svc, err := dinners.NewService(st, g, runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -246,7 +234,7 @@ func newTestPlan(t *testing.T) *plan.Service {
 	fail := func(context.Context, string, skills.WeekRequest) (skills.Week, error) {
 		return skills.Week{}, errors.New("no model in this test")
 	}
-	svc, err := plan.NewService(st, fail, runner, newTestGoogle(t), notifytest.New(t, st), func() {}, &url.URL{Scheme: "https", Host: "mealquest.example"}, time.Now, logger)
+	svc, err := plan.NewService(st, fail, runner, newTestGoogle(t), notifytest.New(t, st), &url.URL{Scheme: "https", Host: "mealquest.example"}, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -277,13 +265,7 @@ func newTestShopping(t *testing.T) *shopping.Service {
 // connection. One database keeps the routers that never ask for Home cheap.
 func newTestHome(t *testing.T) *home.Service {
 	t.Helper()
-	return newTestHomeOn(t, newTestStore(t))
-}
-
-// newTestHomeOn returns a home service over st, a migrated database, which
-// it seeds with zone America/New_York and the seed notification preferences.
-func newTestHomeOn(t *testing.T, st *store.Store) *home.Service {
-	t.Helper()
+	st := newTestStore(t)
 	if err := household.SeedSettings(context.Background(), st, "America/New_York"); err != nil {
 		t.Fatal(err)
 	}
@@ -309,7 +291,7 @@ func newTestHomeOn(t *testing.T, st *store.Store) *home.Service {
 	if err != nil {
 		t.Fatal(err)
 	}
-	planSvc, err := plan.NewService(st, draft, runner, googleSvc, notifier, func() {}, pub, time.Now, logger)
+	planSvc, err := plan.NewService(st, draft, runner, googleSvc, notifier, pub, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/shopping.go

@@ -60,13 +60,10 @@ type supplyRunItem struct {
 }
 
 // generatedSupplyRun is the POST /shopping/{weekStart}/generate answer:
-// the Supply run as made, the plan days with nothing to shop for, and the
-// title_job_id of the job titling it, which GET /jobs/{id} reports on;
-// null when the Supply run already has its title.
+// the Supply run as made, and the plan days with nothing to shop for.
 type generatedSupplyRun struct {
 	supplyRun
-	Skipped    []shopping.SkippedDay `json:"skipped"`
-	TitleJobID *string               `json:"title_job_id"`
+	Skipped []shopping.SkippedDay `json:"skipped"`
 }
 
 // sendChatRequest is the POST /shopping/{weekStart}/send-chat body:
@@ -111,7 +108,7 @@ func getSupplyRun(logger *slog.Logger, svc *shopping.Service) http.HandlerFunc {
 }
 
 // postSupplyRunGenerate makes, or remakes, the week's Supply run from its
-// plan and answers with it, the plan days it skipped and its title job.
+// plan and answers with it and the plan days it skipped.
 func postSupplyRunGenerate(logger *slog.Logger, svc *shopping.Service) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		week, ok := weekStartOrFail(w, r, logger)
@@ -132,7 +129,7 @@ func postSupplyRunGenerate(logger *slog.Logger, svc *shopping.Service) http.Hand
 		if skipped == nil {
 			skipped = []shopping.SkippedDay{}
 		}
-		writeJSON(w, r, logger, http.StatusOK, generatedSupplyRun{supplyRun: out, Skipped: skipped, TitleJobID: g.TitleJobID})
+		writeJSON(w, r, logger, http.StatusOK, generatedSupplyRun{supplyRun: out, Skipped: skipped})
 	}
 }
 
@@ -222,9 +219,8 @@ type archivePeriod struct {
 }
 
 // archivePost is one week's Supply run in the Supply archive. label is
-// the week label, which stands in for title while it is null,
-// onHandCount counts the items marked "have it", and frozen is false
-// while the list can still be changed from the Supply run.
+// the week label, which stands in for title while it is null, and
+// onHandCount counts the items marked "have it".
 type archivePost struct {
 	WeekStart   string   `json:"weekStart"`
 	Label       string   `json:"label"`
@@ -234,7 +230,6 @@ type archivePost struct {
 	OnHandCount int      `json:"onHandCount"`
 	Dinners     []string `json:"dinners"`
 	Current     bool     `json:"current"`
-	Frozen      bool     `json:"frozen"`
 }
 
 // getSupplyArchive answers GET /shopping/archive?by=week|month|year with
@@ -264,7 +259,6 @@ func getSupplyArchive(logger *slog.Logger, svc *shopping.Service) http.HandlerFu
 					OnHandCount: post.OnHand,
 					Dinners:     post.Dinners,
 					Current:     post.Current,
-					Frozen:      post.Frozen,
 				}
 			}
 			out.Periods[i] = archivePeriod{Key: p.Key, Heading: p.Heading, Posts: posts}

internal/server/shopping_test.go

@@ -75,7 +75,7 @@ func (e plansEnv) groundWeek(t *testing.T) {
 func (e plansEnv) archive(t *testing.T) {
 	t.Helper()
 	if _, err := e.st.Writer.ExecContext(t.Context(),
-		`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'; UPDATE shopping_groups SET frozen_dinner_name = (SELECT name FROM dinners WHERE dinners.id = dinner_id) WHERE list_id IN (SELECT id FROM shopping_lists WHERE frozen_at IS NOT NULL)`); err != nil {
+		`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'`); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -186,7 +186,7 @@ func TestSupplyRunShape(t *testing.T) {
 	if status != http.StatusOK {
 		t.Fatalf("generate = %d %v", status, raw)
 	}
-	wantTop := []string{"chat_send_unconfirmed_at", "groups", "label", "needed_count", "sent_to_chat_at", "skipped", "status", "title", "title_job_id", "total_count", "weekStart"}
+	wantTop := []string{"chat_send_unconfirmed_at", "groups", "label", "needed_count", "sent_to_chat_at", "skipped", "status", "title", "total_count", "weekStart"}
 	if got := keys(raw); !reflect.DeepEqual(got, wantTop) {
 		t.Errorf("generate fields = %v, want %v", got, wantTop)
 	}
@@ -199,7 +199,7 @@ func TestSupplyRunShape(t *testing.T) {
 	if status != http.StatusOK {
 		t.Fatalf("GET = %d %v", status, raw)
 	}
-	if k := keys(raw); !reflect.DeepEqual(k, slices.DeleteFunc(slices.Clone(wantTop), func(s string) bool { return s == "skipped" || s == "title_job_id" })) {
+	if k := keys(raw); !reflect.DeepEqual(k, slices.DeleteFunc(slices.Clone(wantTop), func(s string) bool { return s == "skipped" })) {
 		t.Errorf("GET fields = %v", k)
 	}
 	group := raw["groups"].([]any)[0].(map[string]any)
@@ -376,12 +376,8 @@ func TestPushPlanMakesSupplyRun(t *testing.T) {
 	if rec.Code != http.StatusOK || body["status"] != "synced" {
 		t.Fatalf("push = %d %s", rec.Code, rec.Body)
 	}
-	run, _ := body["supply_run"].(map[string]any)
-	if k := keys(run); run["status"] != "generated" || run["error"] != nil || !reflect.DeepEqual(k, []string{"error", "status", "title_job_id"}) {
-		t.Errorf("supply_run = %v, want generated with no error", run)
-	}
-	if job := titleJob(t, e, run["title_job_id"]); job["status"] != "queued" {
-		t.Errorf("title job = %v, want queued: no runner in this test", job)
+	if want := map[string]any{"status": "generated", "error": nil}; !reflect.DeepEqual(body["supply_run"], want) {
+		t.Errorf("supply_run = %v, want %v", body["supply_run"], want)
 	}
 	var l supplyRunJSON
 	if status, got := callShopping(t, e, http.MethodGet, shoppingPath+"2026-10-12", "", &l); status != http.StatusOK {
@@ -471,11 +467,9 @@ func TestPushPlanDoesNotWaitForTitle(t *testing.T) {
 	if rec.Code != http.StatusOK || body["status"] != "synced" {
 		t.Fatalf("push = %d %s", rec.Code, rec.Body)
 	}
-	run, _ := body["supply_run"].(map[string]any)
-	if run["status"] != "generated" || run["error"] != nil {
-		t.Errorf("supply_run = %v, want generated with no error", run)
+	if want := map[string]any{"status": "generated", "error": nil}; !reflect.DeepEqual(body["supply_run"], want) {
+		t.Errorf("supply_run = %v, want %v", body["supply_run"], want)
 	}
-	titleJobID, _ := run["title_job_id"].(string)
 	held.waitEntered(t)
 	var l supplyRunJSON
 	callShopping(t, e, http.MethodGet, shoppingPath+"2026-10-12", "", &l)
@@ -484,7 +478,6 @@ func TestPushPlanDoesNotWaitForTitle(t *testing.T) {
 	}
 
 	close(held.release)
-	wantTitleJobSucceeded(t, e, titleJobID)
 	if got := e.waitTitled(t); got != "Chili and Friends" {
 		t.Errorf("title = %q, want the title job's", got)
 	}
@@ -500,8 +493,7 @@ func TestSupplyRunGenerateDoesNotWaitForTitle(t *testing.T) {
 	e.startRunner(t)
 
 	var l supplyRunJSON
-	status, body := callShopping(t, e, http.MethodPost, shoppingPath+"2026-10-12/generate", "", &l)
-	if status != http.StatusOK {
+	if status, body := callShopping(t, e, http.MethodPost, shoppingPath+"2026-10-12/generate", "", &l); status != http.StatusOK {
 		t.Fatalf("generate = %d %v", status, body)
 	}
 	if l.Title != nil {
@@ -510,66 +502,12 @@ func TestSupplyRunGenerateDoesNotWaitForTitle(t *testing.T) {
 	if !reflect.DeepEqual(l.render(), weekLines) {
 		t.Errorf("generated = %v, want %v", l.render(), weekLines)
 	}
-	titleJobID, _ := body["title_job_id"].(string)
 	held.waitEntered(t)
 
 	close(held.release)
-	wantTitleJobSucceeded(t, e, titleJobID)
 	if got := e.waitTitled(t); got != "Chili and Friends" {
 		t.Errorf("title = %q, want the title job's", got)
 	}
-	if _, body := callShopping(t, e, http.MethodPost, shoppingPath+"2026-10-12/generate", "", nil); body["title_job_id"] != nil {
-		t.Errorf("remake title_job_id = %v, want null: the Supply run has its title", body["title_job_id"])
-	}
-}
-
-// TestSupplyRunGenerateTitleJobFails: a title job that cannot title the
-// Supply run is reported failed with title_failed by GET /jobs/{id}, and
-// the week's next generation answers with a new title job.
-func TestSupplyRunGenerateTitleJobFails(t *testing.T) {
-	t.Parallel()
-	e := newPlansRouter(t)
-	e.groundWeek(t)
-	e.startRunner(t)
-
-	_, body := callShopping(t, e, http.MethodPost, shoppingPath+"2026-10-12/generate", "", nil)
-	first := titleJob(t, e, body["title_job_id"])
-	job := waitJob(t, e.h, first["id"].(string))
-	if job["status"] != "failed" || job["error"] != shopping.ReasonTitleFailed {
-		t.Errorf("title job = %v, want failed %s", job, shopping.ReasonTitleFailed)
-	}
-
-	_, body = callShopping(t, e, http.MethodPost, shoppingPath+"2026-10-12/generate", "", nil)
-	if second := titleJob(t, e, body["title_job_id"]); second["id"] == first["id"] {
-		t.Errorf("retry title_job_id = %v, want a new job", second["id"])
-	}
-}
-
-// titleJob returns the title_supply_run job id, as GET /jobs/{id} reports
-// it; id must be a job id string.
-func titleJob(t *testing.T, e plansEnv, id any) map[string]any {
-	t.Helper()
-	s, ok := id.(string)
-	if !ok || s == "" {
-		t.Fatalf("title_job_id = %v, want a job id", id)
-	}
-	rec, job := callDinners(t, e.h, http.MethodGet, "/api/v1/jobs/"+s, "")
-	if rec.Code != http.StatusOK || job["kind"] != shopping.KindTitleSupplyRun {
-		t.Fatalf("GET title job = %d %s, want a %s job", rec.Code, rec.Body, shopping.KindTitleSupplyRun)
-	}
-	return job
-}
-
-// wantTitleJobSucceeded waits for title job id to finish and fails t
-// unless GET /jobs/{id} reports it succeeded with the title written.
-func wantTitleJobSucceeded(t *testing.T, e plansEnv, id string) {
-	t.Helper()
-	titleJob(t, e, id)
-	job := waitJob(t, e.h, id)
-	result, _ := job["result"].(map[string]any)
-	if job["status"] != "succeeded" || result["title"] != "Chili and Friends" {
-		t.Errorf("title job = %v, want succeeded with the title", job)
-	}
 }
 
 // TestFailedPushMakesNoSupplyRun: a push Calendar refused makes no Supply
@@ -608,7 +546,7 @@ func TestPushPlanSupplyRunFails(t *testing.T) {
 		"code":      "supply_run_failed",
 		"message":   "the plan is on Calendar, but its Supply run could not be made; make it again from the Supply run",
 		"retryable": true,
-	}, "title_job_id": nil}
+	}}
 	if !reflect.DeepEqual(body["supply_run"], want) {
 		t.Errorf("supply_run = %v, want %v", body["supply_run"], want)
 	}
@@ -661,7 +599,7 @@ func TestPushPlanEditedBeforeSupplyRun(t *testing.T) {
 		"code":      "plan_changed",
 		"message":   "the plan is on Calendar as pushed, but it was edited before its Supply run was made, so no Supply run was made from it; push again",
 		"retryable": true,
-	}, "title_job_id": nil}
+	}}
 	if !reflect.DeepEqual(body["supply_run"], want) {
 		t.Errorf("supply_run = %v, want %v", body["supply_run"], want)
 	}
@@ -694,7 +632,7 @@ func TestPushPlanLeavesArchivedSupplyRun(t *testing.T) {
 		t.Fatalf("push = %d %s", rec.Code, rec.Body)
 	}
 	run, _ := body["supply_run"].(map[string]any)
-	if apiErr, _ := run["error"].(map[string]any); run["status"] != "archived" || apiErr["code"] != "archived" || run["title_job_id"] != nil {
+	if apiErr, _ := run["error"].(map[string]any); run["status"] != "archived" || apiErr["code"] != "archived" {
 		t.Errorf("supply_run = %v, want archived", body["supply_run"])
 	}
 	var l supplyRunJSON
@@ -720,7 +658,6 @@ type archiveJSON struct {
 			OnHandCount int      `json:"onHandCount"`
 			Dinners     []string `json:"dinners"`
 			Current     bool     `json:"current"`
-			Frozen      bool     `json:"frozen"`
 		} `json:"posts"`
 	} `json:"periods"`
 }
@@ -799,7 +736,7 @@ func TestSupplyArchive(t *testing.T) {
 	if k := keys(period); !reflect.DeepEqual(k, []string{"heading", "key", "posts"}) {
 		t.Errorf("period fields = %v", k)
 	}
-	wantPost := []string{"current", "dinnerCount", "dinners", "frozen", "itemCount", "label", "onHandCount", "title", "weekStart"}
+	wantPost := []string{"current", "dinnerCount", "dinners", "itemCount", "label", "onHandCount", "title", "weekStart"}
 	if k := keys(period["posts"].([]any)[0].(map[string]any)); !reflect.DeepEqual(k, wantPost) {
 		t.Errorf("post fields = %v, want %v", k, wantPost)
 	}
@@ -816,13 +753,13 @@ func TestSupplyArchive(t *testing.T) {
 			if post.Label != label || post.Title != nil {
 				t.Errorf("post %s: label %q title %v, want %q and null", post.WeekStart, post.Label, post.Title, label)
 			}
-			posts = append(posts, fmt.Sprintf("%s %d dinners %d items %d on hand %v current=%t frozen=%t",
-				post.WeekStart, post.DinnerCount, post.ItemCount, post.OnHandCount, post.Dinners, post.Current, post.Frozen))
+			posts = append(posts, fmt.Sprintf("%s %d dinners %d items %d on hand %v current=%t",
+				post.WeekStart, post.DinnerCount, post.ItemCount, post.OnHandCount, post.Dinners, post.Current))
 		}
 	}
 	want := []string{
-		thisWeek.String() + " 1 dinners 2 items 0 on hand [Lemon Chicken] current=true frozen=false",
-		lastWeek.String() + " 1 dinners 3 items 1 on hand [Beef Stew] current=false frozen=true",
+		thisWeek.String() + " 1 dinners 2 items 0 on hand [Lemon Chicken] current=true",
+		lastWeek.String() + " 1 dinners 3 items 1 on hand [Beef Stew] current=false",
 	}
 	if got.By != "week" || !reflect.DeepEqual(posts, want) {
 		t.Errorf("archive by %s =\n  %s\nwant\n  %s", got.By, strings.Join(posts, "\n  "), strings.Join(want, "\n  "))
@@ -853,137 +790,6 @@ func TestSupplyArchive(t *testing.T) {
 	}
 }
 
-// TestSupplyArchiveUnfrozenPastWeek: a past week's Supply run that
-// week_rollover has not frozen is in the Supply archive as not frozen for
-// as long as the Supply run route can still change it, and as frozen once
-// it cannot.
-func TestSupplyArchiveUnfrozenPastWeek(t *testing.T) {
-	t.Parallel()
-	e := newPlansRouter(t)
-	if _, err := e.st.Writer.ExecContext(t.Context(), `DELETE FROM plan_days; DELETE FROM week_plans`); err != nil {
-		t.Fatal(err)
-	}
-	zone, err := household.LoadZone("America/New_York") // the env's household zone
-	if err != nil {
-		t.Fatal(err)
-	}
-	thisWeek := household.WeekStart(household.Today(time.Now(), zone))
-	y, m, d := thisWeek.Date()
-	lastWeek := store.LocalDateOf(time.Date(y, m, d-7, 0, 0, 0, 0, time.UTC))
-	last := e.weekSupplyRun(t, lastWeek, "Beef Stew", shopIng{"stewing beef", "2", "lb"}, shopIng{"carrots", "4", ""})
-
-	// post is last week's post in the Supply archive.
-	post := func() (frozen bool) {
-		t.Helper()
-		var got archiveJSON
-		if status, raw := callShopping(t, e, http.MethodGet, shoppingPath+"archive?by=week", "", &got); status != http.StatusOK {
-			t.Fatalf("GET archive = %d %v", status, raw)
-		}
-		for _, p := range got.Periods {
-			for _, post := range p.Posts {
-				if post.WeekStart == lastWeek.String() {
-					if post.Current {
-						t.Errorf("last week's post is current")
-					}
-					return post.Frozen
-				}
-			}
-		}
-		t.Fatalf("archive %+v has no post for %s", got, lastWeek)
-		return false
-	}
-	// change marks carrots and reports whether the Supply run route took it.
-	change := func(needed bool) bool {
-		t.Helper()
-		status, body := callShopping(t, e, http.MethodPatch, shoppingPath+"items/"+last.itemID(t, "carrots"), fmt.Sprintf(`{"needed":%t}`, needed), nil)
-		switch {
-		case status == http.StatusOK:
-			return true
-		case status == http.StatusConflict && errorCode(body) == "archived":
-			return false
-		}
-		t.Fatalf("PATCH = %d %v, want 200 or 409 archived", status, body)
-		return false
-	}
-
-	if frozen, changed := post(), change(false); frozen || !changed {
-		t.Errorf("unfrozen past week: post frozen=%t, PATCH changed=%t; want a post not frozen for a list that changes", frozen, changed)
-	}
-	if err := e.shop.Freeze(t.Context(), lastWeek); err != nil {
-		t.Fatal(err)
-	}
-	if frozen, changed := post(), change(true); !frozen || changed {
-		t.Errorf("frozen past week: post frozen=%t, PATCH changed=%t; want a frozen post for a list that cannot change", frozen, changed)
-	}
-}
-
-// TestSupplyArchiveKeepsFrozenNames freezes last week's Supply run, then
-// renames its dinner and this week's through the dinners API: the frozen
-// post and list keep the name the dinner had when frozen, while this
-// week's list, not frozen, shows the new name.
-func TestSupplyArchiveKeepsFrozenNames(t *testing.T) {
-	t.Parallel()
-	e := newPlansRouter(t)
-	if _, err := e.st.Writer.ExecContext(t.Context(), `DELETE FROM plan_days; DELETE FROM week_plans`); err != nil {
-		t.Fatal(err)
-	}
-	zone, err := household.LoadZone("America/New_York") // the env's household zone
-	if err != nil {
-		t.Fatal(err)
-	}
-	thisWeek := household.WeekStart(household.Today(time.Now(), zone))
-	y, m, d := thisWeek.Date()
-	lastWeek := store.LocalDateOf(time.Date(y, m, d-7, 0, 0, 0, 0, time.UTC))
-
-	last := e.weekSupplyRun(t, lastWeek, "Beef Stew", shopIng{"stewing beef", "2", "lb"})
-	current := e.weekSupplyRun(t, thisWeek, "Lemon Chicken", shopIng{"lemon", "1", ""})
-	if err := e.shop.Freeze(t.Context(), lastWeek); err != nil {
-		t.Fatal(err)
-	}
-	for id, name := range map[string]string{
-		last.Groups[0].Dinner.ID:    "Sunday Beef Stew",
-		current.Groups[0].Dinner.ID: "Lemon Garlic Chicken",
-	} {
-		if status, body := callShopping(t, e, http.MethodPatch, dinnersPath+"/"+id, `{"name":"`+name+`"}`, nil); status != http.StatusOK {
-			t.Fatalf("PATCH dinner %s = %d %v", id, status, body)
-		}
-	}
-
-	var got archiveJSON
-	if status, raw := callShopping(t, e, http.MethodGet, shoppingPath+"archive?by=week", "", &got); status != http.StatusOK {
-		t.Fatalf("GET archive = %d %v", status, raw)
-	}
-	var posts []string
-	for _, p := range got.Periods {
-		for _, post := range p.Posts {
-			posts = append(posts, fmt.Sprintf("%s %v current=%t", post.WeekStart, post.Dinners, post.Current))
-		}
-	}
-	want := []string{
-		thisWeek.String() + " [Lemon Garlic Chicken] current=true",
-		lastWeek.String() + " [Beef Stew] current=false",
-	}
-	if !reflect.DeepEqual(posts, want) {
-		t.Errorf("archive after rename =\n  %s\nwant\n  %s", strings.Join(posts, "\n  "), strings.Join(want, "\n  "))
-	}
-
-	for _, tc := range []struct {
-		week store.LocalDate
-		want string
-	}{
-		{lastWeek, "Monday " + lastWeek.String() + " Beef Stew: stewing beef [2 lb] needed"},
-		{thisWeek, "Monday " + thisWeek.String() + " Lemon Garlic Chicken: lemon [1] needed"},
-	} {
-		var l supplyRunJSON
-		if status, body := callShopping(t, e, http.MethodGet, shoppingPath+tc.week.String(), "", &l); status != http.StatusOK {
-			t.Fatalf("GET %s = %d %v", tc.week, status, body)
-		}
-		if got := l.render(); !reflect.DeepEqual(got, []string{tc.want}) {
-			t.Errorf("list %s after rename = %v, want [%s]", tc.week, got, tc.want)
-		}
-	}
-}
-
 // TestSupplyRunSendChat posts the week's Supply run to Google Chat once,
 // records sent_to_chat_at, answers a second send with the status as it
 // is, and posts again only with resend.

internal/shopping/archive.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"strconv"
-	"time"
 
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
@@ -22,9 +21,7 @@ const (
 
 // Freeze moves the Supply run of the week starting weekStart into the
 // Supply archive: its status becomes archived and frozen_at is set, after
-// which it is read-only (Generate and SetNeeded are ErrFrozen). The list
-// keeps the names its dinners have as it is frozen, so its post in the
-// Supply archive shows them whatever a dinner is renamed later. Freezing a
+// which it is read-only (Generate and SetNeeded are ErrFrozen). Freezing a
 // frozen list does nothing and is no error.
 //
 // The week must have ended in the household's time zone: a week not yet
@@ -42,17 +39,11 @@ const (
 // only when no job is running it. A job that runs after the freeze finds
 // the list titled, or frozen untitled, and stores nothing.
 func (s *Service) Freeze(ctx context.Context, weekStart store.LocalDate) error {
-	return s.freeze(ctx, weekStart, s.now())
-}
-
-// freeze is Freeze with the week ended by instant now rather than by the
-// service's clock.
-func (s *Service) freeze(ctx context.Context, weekStart store.LocalDate, now time.Time) error {
 	if _, err := household.WeekDays(weekStart); err != nil {
 		return fmt.Errorf("shopping: freeze: %w", err)
 	}
 	q := db.New(s.st.Writer)
-	thisWeek, err := weekAt(ctx, q, now)
+	thisWeek, err := s.thisWeek(ctx, q)
 	if err != nil {
 		return err
 	}
@@ -81,25 +72,14 @@ func (s *Service) freeze(ctx context.Context, weekStart store.LocalDate, now tim
 				"week", list.WeekStart, "list", list.ID, "error", err)
 		}
 	}
-	// A list frozen meanwhile is left as it is, its names as they were
-	// frozen: the freeze is done.
-	stamp := store.Now().String()
-	return s.st.WithTx(ctx, func(tx *sql.Tx) error {
-		q := db.New(tx)
-		n, err := q.FreezeShoppingList(ctx, db.FreezeShoppingListParams{
-			FrozenAt: sql.NullString{String: stamp, Valid: true}, UpdatedAt: stamp, ID: list.ID,
-		})
-		if err != nil {
-			return fmt.Errorf("shopping: freeze %s: %w", weekStart, err)
-		}
-		if n == 0 {
-			return nil
-		}
-		if err := q.FreezeShoppingGroupNames(ctx, list.ID); err != nil {
-			return fmt.Errorf("shopping: freeze %s: keep dinner names: %w", weekStart, err)
-		}
-		return nil
-	})
+	// A list frozen meanwhile is left as it is: the freeze is done.
+	now := store.Now().String()
+	if _, err := q.FreezeShoppingList(ctx, db.FreezeShoppingListParams{
+		FrozenAt: sql.NullString{String: now, Valid: true}, UpdatedAt: now, ID: list.ID,
+	}); err != nil {
+		return fmt.Errorf("shopping: freeze %s: %w", weekStart, err)
+	}
+	return nil
 }
 
 // freezeTitleJob is the title job of list as Generate would enqueue it:
@@ -123,12 +103,6 @@ func freezeTitleJob(ctx context.Context, q *db.Queries, list db.ShoppingList) (T
 // thisWeek returns the Monday of the household's current week, in its
 // time zone, by the service's clock.
 func (s *Service) thisWeek(ctx context.Context, q *db.Queries) (store.LocalDate, error) {
-	return weekAt(ctx, q, s.now())
-}
-
-// weekAt returns the Monday of the household's week at instant t, in its
-// time zone.
-func weekAt(ctx context.Context, q *db.Queries, t time.Time) (store.LocalDate, error) {
 	settings, err := q.GetHouseholdSettings(ctx)
 	if err != nil {
 		return store.LocalDate{}, fmt.Errorf("shopping: read household settings: %w", err)
@@ -137,7 +111,7 @@ func weekAt(ctx context.Context, q *db.Queries, t time.Time) (store.LocalDate, e
 	if err != nil {
 		return store.LocalDate{}, fmt.Errorf("shopping: household settings: %w", err)
 	}
-	return household.WeekStart(household.Today(t, zone)), nil
+	return household.WeekStart(household.Today(s.now(), zone)), nil
 }
 
 // Period is one heading of the Supply archive and its posts, newest first.
@@ -158,19 +132,13 @@ type Post struct {
 	Label string
 	// Title is nil while the list is untitled, when Label stands in.
 	Title *string
-	// Dinners are the names of the list's dinners, in day order: as they
-	// were when the list was frozen, or as they are now while it is not.
+	// Dinners are the names of the list's dinners, in day order.
 	Dinners []string
 	// Items is how many items the list has, and OnHand how many of them
 	// the household marked "have it".
 	Items, OnHand int
 	// Current is true for the household's current week.
 	Current bool
-	// Frozen is true once the list is frozen into the Supply archive and
-	// can no longer change. A list not yet frozen — the current week's, or
-	// a past week's that week_rollover has not frozen — can still be
-	// changed from the Supply run.
-	Frozen bool
 }
 
 // Archive returns the Supply archive: the Supply run of every week up to
@@ -227,7 +195,7 @@ func (s *Service) Archive(ctx context.Context, by string) (out []Period, err err
 		if err != nil {
 			return nil, err
 		}
-		p, err := postOf(monday, l, monday == thisWeek, frozen(row))
+		p, err := postOf(monday, l, monday == thisWeek)
 		if err != nil {
 			return nil, err
 		}
@@ -242,7 +210,7 @@ func (s *Service) Archive(ctx context.Context, by string) (out []Period, err err
 
 // postOf is l, the Supply run of the week starting monday, as a post in
 // the Supply archive.
-func postOf(monday store.LocalDate, l List, current, isFrozen bool) (Post, error) {
+func postOf(monday store.LocalDate, l List, current bool) (Post, error) {
 	label, err := household.WeekLabel(monday)
 	if err != nil {
 		return Post{}, fmt.Errorf("shopping: Supply run %s: %w", l.ID, err)
@@ -260,6 +228,5 @@ func postOf(monday store.LocalDate, l List, current, isFrozen bool) (Post, error
 		Items:     c.Total,
 		OnHand:    c.Total - c.Needed,
 		Current:   current,
-		Frozen:    isFrozen,
 	}, nil
 }

internal/shopping/archive_test.go

@@ -381,9 +381,6 @@ func postLine(p shopping.Post) string {
 	if p.Current {
 		cur = " | current"
 	}
-	if !p.Frozen {
-		cur += " | open"
-	}
 	return p.WeekStart + " " + p.Label + " | " + title + " | " + strings.Join(p.Dinners, ", ") + " | " +
 		strconv.Itoa(p.Items) + " items, " + strconv.Itoa(p.OnHand) + " on hand" + cur
 }
@@ -425,12 +422,12 @@ func TestArchiveGroups(t *testing.T) {
 	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET title = 'Chili, Noodles & Co' WHERE week_start = '2026-12-28'`); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2027-01-03T11:05:00.000Z' WHERE week_start < '2027-01-04'; UPDATE shopping_groups SET frozen_dinner_name = (SELECT name FROM dinners WHERE dinners.id = dinner_id) WHERE list_id IN (SELECT id FROM shopping_lists WHERE frozen_at IS NOT NULL)`); err != nil {
+	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2027-01-03T11:05:00.000Z' WHERE week_start < '2027-01-04'`); err != nil {
 		t.Fatal(err)
 	}
 
 	posts := map[string]string{
-		"jan": "2027-01-04 Week 1 · Jan 4 – 10 | - | Pad Thai, Beef Chili | 5 items, 1 on hand | current | open",
+		"jan": "2027-01-04 Week 1 · Jan 4 – 10 | - | Pad Thai, Beef Chili | 5 items, 1 on hand | current",
 		"dec": "2026-12-28 Week 53 · Dec 28 – Jan 3 | Chili, Noodles & Co | Beef Chili, Pad Thai | 5 items, 2 on hand",
 		"d07": "2026-12-07 Week 50 · Dec 7 – 13 | - | Pad Thai | 2 items, 0 on hand",
 		"nov": "2026-11-30 Week 49 · Nov 30 – Dec 6 | - | Pot Roast | 1 items, 1 on hand",

internal/shopping/notify_test.go

@@ -37,9 +37,9 @@ func TestGenerateEmitsListReadyOnce(t *testing.T) {
 	}
 	for _, r := range rows {
 		p := r.Payload
-		if r.Key != "list_ready:2026-10-12" || p.URL != "/plan/shopping?week=2026-10-12" || p.Week != "2026-10-12" ||
+		if r.Key != "list_ready:2026-10-12" || p.URL != "/plan/shopping" || p.Week != "2026-10-12" ||
 			p.Title != "This week's Supply run is ready" || p.Body != "3 items to buy for 2 dinners" {
-			t.Errorf("%s row = %+v, want list_ready:2026-10-12, 3 items for 2 dinners, /plan/shopping?week=2026-10-12", r.Channel, r)
+			t.Errorf("%s row = %+v, want list_ready:2026-10-12, 3 items for 2 dinners, /plan/shopping", r.Channel, r)
 		}
 	}
 
@@ -152,7 +152,7 @@ func TestSendToChatFailuresRecordNothing(t *testing.T) {
 		t.Errorf("after failed sends sent_to_chat_at = %v, chat_send_unconfirmed_at = %v, %v, want both unset", l.SentToChatAt, l.ChatSendUnconfirmedAt, err)
 	}
 
-	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'; UPDATE shopping_groups SET frozen_dinner_name = (SELECT name FROM dinners WHERE dinners.id = dinner_id) WHERE list_id IN (SELECT id FROM shopping_lists WHERE frozen_at IS NOT NULL)`); err != nil {
+	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'`); err != nil {
 		t.Fatal(err)
 	}
 	posts := len(e.chat.Posts())

internal/shopping/schedule.go

@@ -1,133 +0,0 @@
-package shopping
-
-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/scheduler"
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
-)
-
-// RolloverTime is when, every Monday in the household zone, week_rollover
-// freezes the week that has just ended. It is fixed, not a setting.
-const RolloverTime = "00:05"
-
-// Reasons Autosend posts nothing.
-const (
-	AutosendNotConfigured = "no Google Chat webhook is configured"
-	AutosendChatOff       = "list_ready is switched off for Google Chat"
-	AutosendNoList        = "the week has no Supply run"
-	AutosendAlreadySent   = "the Supply run was already sent to Google Chat"
-	AutosendUnconfirmed   = "a send of the Supply run to Google Chat is unconfirmed"
-)
-
-// AutosendKey identifies the automatic send of the Supply run of the week
-// starting weekStart, list_ready:chat:YYYY-MM-DD: it is the
-// shopping_chat_autosend period key claimed in schedule_runs. The send
-// itself is recorded in the list's sent_to_chat_at.
-func AutosendKey(weekStart store.LocalDate) string {
-	return string(notify.ListReady) + ":" + string(notify.ChannelChat) + ":" + weekStart.String()
-}
-
-// ChatAutosendSchedule is the shopping_chat_autosend schedule: at the
-// household's chat_autosend_dow and chat_autosend_time it sends the Supply
-// run of the coming week, the week after the fire date's, to Google Chat
-// with Autosend. Its period is that week, scheduler.WeeklyForNextWeek's,
-// claimed under AutosendKey of the week's Monday. A send that fails is the
-// period's error and is not retried; the household can still send it from
-// the Supply run.
-func (s *Service) ChatAutosendSchedule() scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.ShoppingChatAutosend,
-		Rule: func(settings household.Settings) scheduler.Rule {
-			return scheduler.WeeklyForNextWeek(time.Weekday(settings.ChatAutosendDow), settings.ChatAutosendTime)
-		},
-		PeriodKey: func(p scheduler.Period) string {
-			return AutosendKey(p.Week)
-		},
-		Run: func(ctx context.Context, p scheduler.Period) error {
-			skipped, err := s.Autosend(ctx, p.Week)
-			if err != nil {
-				return err
-			}
-			log := s.logger.With("period", p.Key, "week_start", p.Week.String())
-			if skipped != "" {
-				log.InfoContext(ctx, "Supply run not sent to Google Chat: "+skipped)
-				return nil
-			}
-			log.InfoContext(ctx, "Supply run sent to Google Chat")
-			return nil
-		},
-	}
-}
-
-// Autosend sends the Supply run of the week starting weekStart to Google
-// Chat with SendToChat, as the household's send does, when a webhook is
-// stored, list_ready's Google Chat channel is switched on, and the week has
-// a Supply run not yet sent and with no send unconfirmed. Otherwise it
-// posts nothing and returns which of those reasons stopped it; it never
-// resends. A send that fails is SendToChat's error.
-func (s *Service) Autosend(ctx context.Context, weekStart store.LocalDate) (skipped string, err error) {
-	settings, err := s.chat.Get(ctx)
-	if err != nil {
-		return "", fmt.Errorf("shopping: autosend: %w", err)
-	}
-	if settings.URLMasked == nil {
-		return AutosendNotConfigured, nil
-	}
-	on, err := s.notifier.ChannelOn(ctx, notify.ListReady, notify.ChannelChat)
-	if err != nil {
-		return "", fmt.Errorf("shopping: autosend: %w", err)
-	}
-	if !on {
-		return AutosendChatOff, nil
-	}
-	l, err := s.Get(ctx, weekStart)
-	if errors.Is(err, ErrListNotFound) {
-		return AutosendNoList, nil
-	}
-	if err != nil {
-		return "", err
-	}
-	switch {
-	case l.SentToChatAt != nil:
-		return AutosendAlreadySent, nil
-	case l.ChatSendUnconfirmedAt != nil:
-		return AutosendUnconfirmed, nil
-	}
-	if _, err := s.SendToChat(ctx, weekStart, false); err != nil {
-		return "", err
-	}
-	return "", nil
-}
-
-// RolloverSchedule is the week_rollover schedule: every Monday at
-// RolloverTime it freezes the Supply run of the week before the fire
-// date's into the Supply archive with Freeze, the week ending by the fire
-// time. Its period scheduler.Weekly keys week_rollover:YYYY-Www for the
-// fire date's week. A week with no Supply run has nothing to freeze, and
-// the period says so; a freeze that fails is the period's error and is not
-// retried.
-func (s *Service) RolloverSchedule() scheduler.Schedule {
-	return scheduler.Schedule{
-		Name: scheduler.WeekRollover,
-		Rule: func(household.Settings) scheduler.Rule {
-			return scheduler.Weekly(time.Monday, RolloverTime)
-		},
-		Run: func(ctx context.Context, p scheduler.Period) error {
-			y, m, d := p.Week.Date()
-			last := store.LocalDateOf(time.Date(y, m, d-7, 0, 0, 0, 0, time.UTC))
-			err := s.freeze(ctx, last, p.FireAt)
-			if errors.Is(err, ErrListNotFound) {
-				s.logger.InfoContext(ctx, "week rollover froze nothing: the week has no Supply run",
-					"period", p.Key, "week_start", last.String())
-				return nil
-			}
-			return err
-		},
-	}
-}

internal/shopping/shopping.go

@@ -492,9 +492,7 @@ func (s *Service) Get(ctx context.Context, weekStart store.LocalDate) (l List, e
 	return readList(ctx, q, list)
 }
 
-// readList reads the groups and items of list through q. A group of a
-// frozen list is named as its dinner was when the list was frozen; one
-// with no such name is an error.
+// readList reads the groups and items of list through q.
 func readList(ctx context.Context, q *db.Queries, list db.ShoppingList) (List, error) {
 	rows, err := q.ListShoppingGroupDinners(ctx, list.ID)
 	if err != nil {
@@ -514,15 +512,8 @@ func readList(ctx context.Context, q *db.Queries, list db.ShoppingList) (List, e
 	groups := make([]Group, 0, len(rows))
 	for _, r := range rows {
 		g := r.ShoppingGroup
-		name := r.DinnerName
-		if frozen(list) {
-			if !g.FrozenDinnerName.Valid {
-				return List{}, fmt.Errorf("shopping: group %s of frozen list %s has no frozen dinner name", g.ID, list.WeekStart)
-			}
-			name = g.FrozenDinnerName.String
-		}
 		groups = append(groups, Group{
-			ID: g.ID, DinnerID: g.DinnerID, DinnerName: name, Date: g.Date, Position: int(g.Position),
+			ID: g.ID, DinnerID: g.DinnerID, DinnerName: r.DinnerName, Date: g.Date, Position: int(g.Position),
 			Items: byGroup[g.ID],
 		})
 	}

internal/shopping/shopping_test.go

@@ -516,7 +516,7 @@ func TestGenerateManualRecipe(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	dsvc, err := dinners.NewService(e.st, grounder, runner, func() {}, logger)
+	dsvc, err := dinners.NewService(e.st, grounder, runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -692,7 +692,7 @@ func TestGenerateRefusesFrozenList(t *testing.T) {
 	e.dinner(t, "Pad Thai", ing{"rice noodles", "8", "oz"})
 	e.plan(t, "Beef Chili")
 	e.generate(t)
-	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'; UPDATE shopping_groups SET frozen_dinner_name = (SELECT name FROM dinners WHERE dinners.id = dinner_id) WHERE list_id IN (SELECT id FROM shopping_lists WHERE frozen_at IS NOT NULL)`); err != nil {
+	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'`); err != nil {
 		t.Fatal(err)
 	}
 	e.swap(t, "2026-10-12", "Pad Thai")
@@ -834,7 +834,7 @@ func TestSetNeededRefusesFrozenList(t *testing.T) {
 	e.dinner(t, "Beef Chili", ing{"ground beef", "1", "lb"})
 	e.plan(t, "Beef Chili")
 	l := e.generate(t).List
-	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'; UPDATE shopping_groups SET frozen_dinner_name = (SELECT name FROM dinners WHERE dinners.id = dinner_id) WHERE list_id IN (SELECT id FROM shopping_lists WHERE frozen_at IS NOT NULL)`); err != nil {
+	if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'`); err != nil {
 		t.Fatal(err)
 	}
 

internal/shopping/title_test.go

@@ -239,7 +239,7 @@ func TestGenerateTitleNotStoredOnFrozenList(t *testing.T) {
 	e := titleWeek(t)
 	e.model.QueueGenerate(titled("Noodles, Tacos and Chili"))
 	e.beforeTitle = func() {
-		if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'; UPDATE shopping_groups SET frozen_dinner_name = (SELECT name FROM dinners WHERE dinners.id = dinner_id) WHERE list_id IN (SELECT id FROM shopping_lists WHERE frozen_at IS NOT NULL)`); err != nil {
+		if _, err := e.st.Writer.Exec(`UPDATE shopping_lists SET status = 'archived', frozen_at = '2026-10-19T04:05:00Z'`); err != nil {
 			t.Error(err)
 		}
 	}
@@ -311,38 +311,3 @@ func TestGenerateTitleOverlapAcrossRename(t *testing.T) {
 		t.Errorf("stored title = %v, want one of the two titles", deref(got))
 	}
 }
-
-// TestGenerateTitleNotStoredOnReplacedList: a list replaced by a new
-// untitled list of the same week once archive_title has answered, before
-// its title is stored, keeps the replacement untitled; the old list's
-// title job fails, and the failure is logged.
-func TestGenerateTitleNotStoredOnReplacedList(t *testing.T) {
-	e := titleWeek(t)
-	e.model.QueueGenerate(titled("Noodles, Tacos and Chili"))
-	e.afterTitle = func() {
-		for _, stmt := range []string{
-			`DELETE FROM shopping_items WHERE group_id IN (SELECT id FROM shopping_groups WHERE list_id IN (SELECT id FROM shopping_lists WHERE week_start = ?1))`,
-			`DELETE FROM shopping_groups WHERE list_id IN (SELECT id FROM shopping_lists WHERE week_start = ?1)`,
-			`UPDATE shopping_lists SET id = 'replacement' WHERE week_start = ?1`,
-		} {
-			if _, err := e.st.Writer.Exec(stmt, week.String()); err != nil {
-				t.Error(err)
-			}
-		}
-	}
-
-	g := e.generate(t)
-	wantJob(t, e.waitTitle(t, g), jobs.StatusFailed, shopping.ReasonTitleFailed)
-
-	var id string
-	if err := e.st.Reader.QueryRow(`SELECT id FROM shopping_lists WHERE week_start = ?`, week.String()).Scan(&id); err != nil {
-		t.Fatal(err)
-	}
-	if id != "replacement" || id == g.List.ID {
-		t.Fatalf("week's list = %s, want the replacement of %s", id, g.List.ID)
-	}
-	wantUntitled(t, "replacement's title", e.storedTitle(t))
-	if !strings.Contains(e.log.String(), "the Supply run was frozen or replaced before its title was stored") {
-		t.Errorf("log lacks the failure:\n%s", e.log.String())
-	}
-}

internal/store/migrate_test.go

@@ -2,7 +2,6 @@ package store
 
 import (
 	"context"
-	"fmt"
 	"io/fs"
 	"reflect"
 	"slices"
@@ -177,8 +176,8 @@ func TestMigrateEmbeddedMigrations(t *testing.T) {
 	if err := Migrate(context.Background(), s.Writer, migrations.FS); err != nil {
 		t.Fatal(err)
 	}
-	if got := versions(migrationRows(t, s)); got != "0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed,0018_recipe_item_position_unique,0019_shopping_group_frozen_name,0020_site_name_from_page" {
-		t.Errorf("versions = %q, want 0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed,0018_recipe_item_position_unique,0019_shopping_group_frozen_name,0020_site_name_from_page", got)
+	if got := versions(migrationRows(t, s)); got != "0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed" {
+		t.Errorf("versions = %q, want 0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed", got)
 	}
 }
 
@@ -198,8 +197,8 @@ func TestMigrateBootstrapThenEmbeddedInitApplies(t *testing.T) {
 	if err := Migrate(ctx, s.Writer, migrations.FS); err != nil {
 		t.Fatal(err)
 	}
-	if got := versions(migrationRows(t, s)); got != "0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed,0018_recipe_item_position_unique,0019_shopping_group_frozen_name,0020_site_name_from_page" {
-		t.Errorf("versions = %q, want 0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed,0018_recipe_item_position_unique,0019_shopping_group_frozen_name,0020_site_name_from_page", got)
+	if got := versions(migrationRows(t, s)); got != "0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed" {
+		t.Errorf("versions = %q, want 0000_bootstrap,0001_init,0002_household_settings_updated_by,0003_jobs_status,0004_ai_provider_presets,0005_ai_provider_xai,0006_ai_runs_status,0007_recipe_grounding,0008_dinner_recipe_url,0009_dinner_grounding_error,0010_dinner_grounding_revision,0011_ground_dinner_job_revision,0012_suggestion_name,0013_week_plan_revision,0014_rotation_review_name,0015_google_reconnect_required,0016_shopping_list_untitled,0017_shopping_list_chat_send_unconfirmed", got)
 	}
 	if !tableExists(t, s, "dinners") {
 		t.Error("table from 0001_init was not created")
@@ -923,227 +922,3 @@ func TestMigrateShoppingListChatSendUnconfirmed(t *testing.T) {
 		t.Errorf("shopping list after 0017 = %s, want %s", got, want)
 	}
 }
-
-// seedRecipeItems inserts two recipes, each with an ingredient and a step
-// at position 0, then the extra statements.
-func seedRecipeItems(t *testing.T, s *Store, extra ...string) {
-	t.Helper()
-	stmts := []string{
-		`INSERT INTO recipes (id, source_url, title, raw_jsonld, fetched_at, created_at, updated_at)
-			VALUES ('recipe-1', 'https://example.com/chili', 'Chili', '{}', 'f', 'c', 'u')`,
-		`INSERT INTO recipes (id, source_url, title, raw_jsonld, fetched_at, created_at, updated_at)
-			VALUES ('recipe-2', 'https://example.com/curry', 'Curry', '{}', 'f', 'c', 'u')`,
-		`INSERT INTO recipe_ingredients (id, recipe_id, position, raw_text, created_at, updated_at)
-			VALUES ('ing-1', 'recipe-1', 0, '1 onion', 'c', 'u'), ('ing-2', 'recipe-2', 0, '1 lime', 'c', 'u')`,
-		`INSERT INTO recipe_steps (id, recipe_id, position, text, created_at, updated_at)
-			VALUES ('step-1', 'recipe-1', 0, 'Chop.', 'c', 'u'), ('step-2', 'recipe-2', 0, 'Squeeze.', 'c', 'u')`,
-	}
-	for _, stmt := range append(stmts, extra...) {
-		if _, err := s.Writer.Exec(stmt); err != nil {
-			t.Fatalf("seed: %v", err)
-		}
-	}
-}
-
-// TestMigrateRecipeItemPositionUnique applies 0018 over two recipes with
-// items at the same position: each recipe keeps its items, and a second
-// ingredient or step at a position its recipe already uses is refused.
-func TestMigrateRecipeItemPositionUnique(t *testing.T) {
-	ctx := context.Background()
-	s := openTestStore(t)
-	migrateBefore(t, s, "0018")
-	seedRecipeItems(t, s)
-
-	if err := Migrate(ctx, s.Writer, migrations.FS); err != nil {
-		t.Fatal(err)
-	}
-
-	var got string
-	if err := s.Reader.QueryRowContext(ctx, `SELECT
-		(SELECT group_concat(id || '@' || recipe_id || ':' || position, ',') FROM (SELECT * FROM recipe_ingredients ORDER BY id)) || ' / ' ||
-		(SELECT group_concat(id || '@' || recipe_id || ':' || position, ',') FROM (SELECT * FROM recipe_steps ORDER BY id))`).Scan(&got); err != nil {
-		t.Fatal(err)
-	}
-	if want := "ing-1@recipe-1:0,ing-2@recipe-2:0 / step-1@recipe-1:0,step-2@recipe-2:0"; got != want {
-		t.Errorf("recipe items after 0018 = %s, want %s", got, want)
-	}
-
-	for _, tc := range []struct{ name, stmt string }{
-		{"second ingredient at a position", `INSERT INTO recipe_ingredients (id, recipe_id, position, raw_text, created_at, updated_at)
-			VALUES ('ing-3', 'recipe-1', 0, '2 onions', 'c', 'u')`},
-		{"second step at a position", `INSERT INTO recipe_steps (id, recipe_id, position, text, created_at, updated_at)
-			VALUES ('step-3', 'recipe-1', 0, 'Dice.', 'c', 'u')`},
-		{"ingredient moved onto another's position", `UPDATE recipe_ingredients SET recipe_id = 'recipe-1' WHERE id = 'ing-2'`},
-		{"step moved onto another's position", `UPDATE recipe_steps SET recipe_id = 'recipe-1' WHERE id = 'step-2'`},
-	} {
-		if _, err := s.Writer.Exec(tc.stmt); err == nil || !strings.Contains(err.Error(), "UNIQUE constraint failed") {
-			t.Errorf("%s: error %v, want UNIQUE constraint failed", tc.name, err)
-		}
-	}
-}
-
-// TestMigrateRecipeItemPositionUniqueRefusesDuplicate applies 0018 over a
-// recipe already holding two ingredients, or two steps, at one position:
-// its order is unknown, so the migration fails and is not recorded.
-func TestMigrateRecipeItemPositionUniqueRefusesDuplicate(t *testing.T) {
-	for _, tc := range []struct{ table, stmt string }{
-		{"recipe_ingredients", `INSERT INTO recipe_ingredients (id, recipe_id, position, raw_text, created_at, updated_at)
-			VALUES ('ing-3', 'recipe-1', 0, '2 onions', 'c', 'u')`},
-		{"recipe_steps", `INSERT INTO recipe_steps (id, recipe_id, position, text, created_at, updated_at)
-			VALUES ('step-3', 'recipe-1', 0, 'Dice.', 'c', 'u')`},
-	} {
-		t.Run(tc.table, func(t *testing.T) {
-			ctx := context.Background()
-			s := openTestStore(t)
-			migrateBefore(t, s, "0018")
-			seedRecipeItems(t, s, tc.stmt)
-
-			err := Migrate(ctx, s.Writer, migrations.FS)
-			if err == nil || !strings.Contains(err.Error(), "UNIQUE constraint failed: "+tc.table+".recipe_id, "+tc.table+".position") {
-				t.Fatalf("Migrate = %v, want the duplicate position refused", err)
-			}
-			var n int
-			if err := s.Reader.QueryRowContext(ctx, `SELECT count(*) FROM schema_migrations WHERE version = '0018_recipe_item_position_unique'`).Scan(&n); err != nil {
-				t.Fatal(err)
-			}
-			if n != 0 {
-				t.Error("0018 recorded as applied")
-			}
-		})
-	}
-}
-
-// TestMigrateShoppingGroupFrozenName applies 0019 over a frozen list and
-// a current one: the frozen list's group takes its dinner's name now, the
-// current list's group has none, and a frozen name is never empty.
-func TestMigrateShoppingGroupFrozenName(t *testing.T) {
-	ctx := context.Background()
-	s := openTestStore(t)
-	migrateBefore(t, s, "0019")
-	for _, stmt := range []string{
-		`INSERT INTO dinners (id, name, normalized_name, status, origin, is_favorite, grounding_status, created_at, updated_at)
-			VALUES ('dinner-1', 'Beef Stew', 'beef stew', 'regular', 'regular', 0, 'manual', 'c', 'u'),
-			       ('dinner-2', 'Lemon Chicken', 'lemon chicken', 'regular', 'regular', 0, 'manual', 'c', 'u')`,
-		`INSERT INTO week_plans (id, week_start, status, created_at, updated_at)
-			VALUES ('plan-1', '2026-10-05', 'synced', 'c', 'u'),
-			       ('plan-2', '2026-10-12', 'synced', 'c', 'u')`,
-		`INSERT INTO shopping_lists (id, week_start, plan_id, status, frozen_at, created_at, updated_at)
-			VALUES ('list-1', '2026-10-05', 'plan-1', 'archived', 'f', 'c', 'u'),
-			       ('list-2', '2026-10-12', 'plan-2', 'current', NULL, 'c', 'u')`,
-		`INSERT INTO shopping_groups (id, list_id, dinner_id, date, position, created_at, updated_at)
-			VALUES ('group-1', 'list-1', 'dinner-1', '2026-10-05', 0, 'c', 'u'),
-			       ('group-2', 'list-2', 'dinner-2', '2026-10-12', 0, 'c', 'u')`,
-	} {
-		if _, err := s.Writer.Exec(stmt); err != nil {
-			t.Fatalf("seed: %v", err)
-		}
-	}
-
-	if err := Migrate(ctx, s.Writer, migrations.FS); err != nil {
-		t.Fatal(err)
-	}
-
-	rows, err := s.Reader.QueryContext(ctx, `SELECT id || '|' || COALESCE(frozen_dinner_name, 'NULL') || '|' || updated_at FROM shopping_groups ORDER BY id`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer rows.Close()
-	var got []string
-	for rows.Next() {
-		var row string
-		if err := rows.Scan(&row); err != nil {
-			t.Fatal(err)
-		}
-		got = append(got, row)
-	}
-	if err := rows.Err(); err != nil {
-		t.Fatal(err)
-	}
-	if want := []string{"group-1|Beef Stew|u", "group-2|NULL|u"}; strings.Join(got, ",") != strings.Join(want, ",") {
-		t.Errorf("shopping groups after 0019 = %v, want %v", got, want)
-	}
-	if _, err := s.Writer.Exec(`UPDATE shopping_groups SET frozen_dinner_name = '' WHERE id = 'group-1'`); err == nil || !strings.Contains(err.Error(), "CHECK constraint failed") {
-		t.Errorf("empty frozen name: error %v, want CHECK constraint failed", err)
-	}
-}
-
-// TestMigrateSiteNameFromPage applies 0020 over recipes and idea job
-// results stored when a page naming no site was stored under its host: a
-// stored name that could be a host — one with no space that is dotted, an
-// IP address or spelled in the recipe's own link — is cleared, so every
-// stored name is one a page gave; a name with a space is kept, as is
-// everything else in the rows.
-func TestMigrateSiteNameFromPage(t *testing.T) {
-	ctx := context.Background()
-	s := openTestStore(t)
-	migrateBefore(t, s, "0020")
-	sites := []struct {
-		stored any
-		link   string
-		want   any
-	}{
-		{"private-token.example.com", "https://private-token.example.com/stew", nil},
-		{"redirect_token.example.net", "https://kitchen.example/stew", nil},
-		{"bücher.example", "https://kitchen.example/stew", nil},
-		{"Food.com", "https://www.food.com/stew", nil},
-		{"203.0.113.7", "https://203.0.113.7/stew", nil},
-		{"2001:db8::1", "https://[2001:db8::1]/stew", nil},
-		{"TokenHost", "https://www.tokenhost/stew", nil},
-		{"Delish", "https://www.delish.com/stew", nil},
-		{"Delish", "https://kitchen.example/stew", "Delish"},
-		{"Curry House", "https://curry-house.example/stew", "Curry House"},
-		{"Mr. Food Test Kitchen", "https://kitchen.example/stew", "Mr. Food Test Kitchen"},
-		{nil, "https://kitchen.example/stew", nil},
-	}
-	for i, c := range sites {
-		if _, err := s.Writer.ExecContext(ctx, `INSERT INTO recipes (id, source_url, site_name, title, raw_jsonld, fetched_at, created_at, updated_at)
-			VALUES (?, ?, ?, 'Stew', '{}', 'f', 'c', 'u')`, fmt.Sprintf("recipe-%d", i), fmt.Sprintf("%s?row=%d", c.link, i), c.stored); err != nil {
-			t.Fatal(err)
-		}
-	}
-	const (
-		legacy  = `{"stage":"done","ideas":[{"name":"A","site_name":"query-host.example","source_url":"https://query-host.example/a?t=1"},{"name":"B","site_name":"Curry House","source_url":"https://b.example/b"},{"name":"C","site_name":null,"source_url":null},{"name":"D","site_name":"Kitchen","source_url":"https://kitchen.example/d"}],"dropped":1}`
-		cleaned = `{"stage":"done","ideas":[{"name":"A","site_name":null,"source_url":"https://query-host.example/a?t=1"},{"name":"B","site_name":"Curry House","source_url":"https://b.example/b"},{"name":"C","site_name":null,"source_url":null},{"name":"D","site_name":null,"source_url":"https://kitchen.example/d"}],"dropped":1}`
-		other   = `{"ideas":[{"site_name":"host.example"}]}`
-	)
-	for _, j := range [][3]string{
-		{"job-ideas", "ideas_from_ingredients", legacy},
-		{"job-quick", "quick_ideas", legacy},
-		{"job-other", "ground_dinner", other},
-		{"job-empty", "quick_ideas", `{"stage":"searching","ideas":[]}`},
-	} {
-		if _, err := s.Writer.ExecContext(ctx, `INSERT INTO jobs (id, kind, status, payload, result, created_at, updated_at)
-			VALUES (?, ?, 'succeeded', '{}', ?, 'c', 'u')`, j[0], j[1], j[2]); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if _, err := s.Writer.ExecContext(ctx, `INSERT INTO jobs (id, kind, status, payload, created_at, updated_at)
-		VALUES ('job-running', 'quick_ideas', 'running', '{}', 'c', 'u')`); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := Migrate(ctx, s.Writer, migrations.FS); err != nil {
-		t.Fatal(err)
-	}
-
-	for i, c := range sites {
-		var got any
-		var title string
-		if err := s.Reader.QueryRowContext(ctx, `SELECT site_name, title FROM recipes WHERE id = ?`, fmt.Sprintf("recipe-%d", i)).Scan(&got, &title); err != nil {
-			t.Fatal(err)
-		}
-		if got != c.want || title != "Stew" {
-			t.Errorf("recipe stored with site_name %v: site_name %v, title %q after 0020; want %v, Stew", c.stored, got, title, c.want)
-		}
-	}
-	for id, want := range map[string]any{"job-ideas": cleaned, "job-quick": cleaned, "job-other": other,
-		"job-empty": `{"stage":"searching","ideas":[]}`, "job-running": nil} {
-		var got any
-		if err := s.Reader.QueryRowContext(ctx, `SELECT result FROM jobs WHERE id = ?`, id).Scan(&got); err != nil {
-			t.Fatal(err)
-		}
-		if got != want {
-			t.Errorf("%s result after 0020 = %v, want %v", id, got, want)
-		}
-	}
-}

internal/store/schema_test.go

@@ -408,8 +408,6 @@ func TestSchemaUniqueConstraintsRejectDuplicates(t *testing.T) {
 		{"notification_outbox", []string{"event_key", "channel"}},
 		{"schedule_runs", []string{"schedule", "period_key"}},
 		{"notification_prefs", []string{"event"}},
-		{"recipe_ingredients", []string{"recipe_id", "position"}},
-		{"recipe_steps", []string{"recipe_id", "position"}},
 	}
 	s := seededStore(t)
 	for _, c := range cases {
@@ -447,8 +445,6 @@ func TestSchemaCompositeUniqueAllowsPartialOverlap(t *testing.T) {
 		{"same plan_date, different dinner", "rotation_reviews", "plan_date", "dinners", map[string]any{"dinner_id": rowID("dinners", 1)}},
 		{"same event_key, different channel", "notification_outbox", "event_key", "", map[string]any{"channel": "chat"}},
 		{"same period_key, different schedule", "schedule_runs", "period_key", "", map[string]any{"schedule": "week_rollover"}},
-		{"same position, different recipe", "recipe_ingredients", "position", "recipes", map[string]any{"recipe_id": rowID("recipes", 1)}},
-		{"same position, different recipe", "recipe_steps", "position", "recipes", map[string]any{"recipe_id": rowID("recipes", 1)}},
 	}
 	s := seededStore(t)
 	for _, c := range cases {

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,28 +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, with what the batch stored, and any
-// new_suggestions it emitted, kept; 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. After each round it
-// rechecks every Side quest it holds (see eligible) and lets go of those
-// the household's changes made ineligible, so a later round grounds a
-// spare Side quest in place of each; only a change committed between the
-// last recheck and the store can still leave the batch short of
-// BatchSize while spare Side quests remain. 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 {
@@ -90,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
@@ -110,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
@@ -124,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 {
@@ -140,103 +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 {
-			// Recheck every held Side quest, not just this round's, so
-			// one the household's changes made ineligible while this
-			// round grounded is replaced by a later round, not dropped by
-			// the store once no round is left to replace it.
-			if held, err = s.recheck(ctx, &res, append(held, grounded...)); err != nil {
-				return batchResult{}, err
-			}
-		} 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
 }
 
-// recheck returns, in order, those of a notifying batch's held Side
-// quests that store would still keep (see eligible), adding those left
-// out to res.Dropped.
-func (s *Service) recheck(ctx context.Context, res *batchResult, held []groundedQuest) ([]groundedQuest, error) {
-	kept, err := s.eligible(ctx, db.New(s.st.Reader), res.BatchID, held)
-	if err != nil {
-		return nil, err
-	}
-	res.Dropped += len(held) - len(kept)
-	out := make([]groundedQuest, len(kept))
-	for i, k := range kept {
-		out[i] = k.groundedQuest
-	}
-	return out, 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.
@@ -305,31 +218,45 @@ func (s *Service) ground(ctx context.Context, quests []skills.SideQuest) ([]grou
 // store stores each grounded Side quest of batchID as a dinner with status
 // suggested and origin side_quest, grounded in its recipe, and a pending
 // suggestion citing its Regulars by id, all in one transaction, and
-// returns the suggestion ids. A Side quest eligible leaves out is not
-// stored: since suggest_side_quests ran, a dinner it repeats was added, a
-// suggestion it repeats passed or a Rotation check dropped, or a Regular
-// it cites renamed or archived. eligible reads in the same transaction as
-// the store, so a Pass or drop committed before it is never missed.
+// returns the suggestion ids. A Side quest is left out when, since
+// suggest_side_quests ran, a dinner it repeats was added, a suggestion it
+// repeats passed or a Rotation check dropped, or a Regular it cites renamed
+// 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 {
 		q := db.New(tx)
-		kept, err := s.eligible(ctx, q, batchID, quests)
+		existing, err := q.ListUnarchivedDinners(ctx)
 		if err != nil {
-			return err
+			return fmt.Errorf("suggest: list dinners for dedupe: %w", err)
 		}
-		for _, k := range kept {
-			gq := k.groundedQuest
-			citedJSON, err := json.Marshal(k.cited)
+		names, err := q.ListPassedNames(ctx)
+		if err != nil {
+			return fmt.Errorf("suggest: list passed names for dedupe: %w", err)
+		}
+		regulars := map[string][]string{}
+		for _, row := range existing {
+			names = append(names, row.Dinner.Name)
+			if row.Dinner.Status == dinners.StatusRegular {
+				regulars[row.Dinner.Name] = append(regulars[row.Dinner.Name], row.Dinner.ID)
+			}
+		}
+		for _, gq := range quests {
+			cited, ok := citedIDs(gq.quest.CitedRegulars, regulars)
+			if !ok || repeats(gq.quest.Name, names) {
+				s.logger.InfoContext(ctx, "suggested dinner dropped: changed while grounding", "batch_id", batchID)
+				continue
+			}
+			citedJSON, err := json.Marshal(cited)
 			if err != nil {
 				return fmt.Errorf("suggest: encode cited Regulars: %w", err)
 			}
@@ -367,67 +294,24 @@ func (s *Service) store(ctx context.Context, batchID string, note *notice, quest
 			}); err != nil {
 				return fmt.Errorf("suggest: create suggestion: %w", err)
 			}
+			names = append(names, d.Name)
 			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
 }
 
-// eligibleQuest is a Side quest store would keep, with the ids of the
-// Regulars it cites.
-type eligibleQuest struct {
-	groundedQuest
-	cited []string
-}
-
-// eligible returns, in order, those of batchID's quests that q's dinners
-// and passed names still allow, each with the ids of the Regulars it
-// cites. A Side quest is left out when a dinner it repeats is unarchived,
-// a suggestion it repeats passed or a Rotation check dropped, a Regular it
-// cites is renamed or archived, or an earlier Side quest of quests kept
-// repeats it. store checks with this in its transaction; a notifying
-// batch checks the Side quests it holds with it after each round (see
-// fill).
-func (s *Service) eligible(ctx context.Context, q *db.Queries, batchID string, quests []groundedQuest) ([]eligibleQuest, error) {
-	existing, err := q.ListUnarchivedDinners(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("suggest: list dinners for dedupe: %w", err)
-	}
-	names, err := q.ListPassedNames(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("suggest: list passed names for dedupe: %w", err)
-	}
-	regulars := map[string][]string{}
-	for _, row := range existing {
-		names = append(names, row.Dinner.Name)
-		if row.Dinner.Status == dinners.StatusRegular {
-			regulars[row.Dinner.Name] = append(regulars[row.Dinner.Name], row.Dinner.ID)
-		}
-	}
-	var kept []eligibleQuest
-	for _, gq := range quests {
-		cited, ok := citedIDs(gq.quest.CitedRegulars, regulars)
-		if !ok || repeats(gq.quest.Name, names) {
-			s.logger.InfoContext(ctx, "suggested dinner dropped: changed while grounding", "batch_id", batchID)
-			continue
-		}
-		names = append(names, gq.quest.Name)
-		kept = append(kept, eligibleQuest{groundedQuest: gq, cited: cited})
-	}
-	return kept, nil
-}
-
 // citedIDs returns the ids of the Regulars named cited, false when one
 // names no Regular or more than one.
 func citedIDs(cited []string, regulars map[string][]string) ([]string, bool) {

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)
 	}
@@ -366,17 +346,6 @@ func (s *Service) Deck(ctx context.Context) (Deck, error) {
 	return deck, nil
 }
 
-// PendingCount is how many Side quests are pending on the deck. Unlike
-// Deck it only reads: it does not fail orphaned batches, so a reader such
-// as Home never writes.
-func (s *Service) PendingCount(ctx context.Context) (int, error) {
-	rows, err := db.New(s.st.Reader).ListDeck(ctx)
-	if err != nil {
-		return 0, fmt.Errorf("suggest: list deck: %w", err)
-	}
-	return len(rows), nil
-}
-
 // Decision is a suggestion once decided, with the id of the replenish
 // batch's job when the decision called for one: the batch it started, or
 // the one already pending or running that it joined.
@@ -459,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)
 			}
 		})
 	}
@@ -660,74 +579,6 @@ func TestBatchKeepsAtMostBatchSize(t *testing.T) {
 	}
 }
 
-// TestBatchReplacesSideQuestMadeIneligibleWhileHeld: a notifying batch
-// holds each round's Side quests until its last round is done; when the
-// household adds a dinner repeating one held from an earlier round while a
-// later round grounds, the batch lets it go and grounds a spare Side quest
-// in its place, so it still stores BatchSize and announces them once.
-func TestBatchReplacesSideQuestMadeIneligibleWhileHeld(t *testing.T) {
-	for _, trigger := range []string{suggest.TriggerScheduled, suggest.TriggerManual} {
-		t.Run(trigger, func(t *testing.T) {
-			e := newEnv(t)
-			e.start(t)
-			// Fajita Dish B is ungroundable, so the first round holds
-			// BatchSize-1 and a second round grounds the next; the last is
-			// the spare a third round grounds in place of Fajita Dish A.
-			var quests, want []string
-			for i := range suggest.BatchSize + 2 {
-				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"))
-				if i > 1 {
-					want = append(want, name)
-				}
-			}
-			e.reply(quests...)
-			// The second round's search waits, so the household adds a
-			// dinner repeating Fajita Dish A, held from the first round,
-			// while that round grounds.
-			second := fmt.Sprintf("Fajita Dish %c", 'A'+suggest.BatchSize)
-			gate := make(chan struct{})
-			e.search.Gates = map[string]chan struct{}{second: gate}
-
-			b, key := e.startBatch(t, trigger)
-			deadline := time.Now().Add(10 * time.Second)
-			for !slices.Contains(e.search.Queries(), second) {
-				if time.Now().After(deadline) {
-					close(gate)
-					t.Fatalf("search for %s never ran", second)
-				}
-				time.Sleep(5 * time.Millisecond)
-			}
-			e.dinner(t, "Fajita Dish A", "regular")
-			close(gate)
-
-			job := e.waitJob(t, b.JobID)
-			if job.Status != jobs.StatusSucceeded {
-				t.Fatalf("batch job %s, error %v", job.Status, job.Error)
-			}
-			var res batchResult
-			if err := json.Unmarshal(job.Result, &res); err != nil {
-				t.Fatal(err)
-			}
-			if len(res.SuggestionIDs) != suggest.BatchSize || res.Dropped != 2 {
-				t.Errorf("batch result = %+v, want %d stored and 2 dropped", res, suggest.BatchSize)
-			}
-			if got := e.deckNames(t); !slices.Equal(got, want) {
-				t.Errorf("deck = %v, want %v", got, want)
-			}
-			rows := notifytest.Rows(t, e.st, notify.NewSuggestions)
-			title := fmt.Sprintf("%d new Side quests are in", suggest.BatchSize)
-			if len(rows) != 1 || rows[0].Key != key || rows[0].Payload.Title != title {
-				t.Errorf("new_suggestions rows = %+v, want one keyed %s titled %q", rows, key, title)
-			}
-		})
-	}
-}
-
 func TestDeckIsOldestFirst(t *testing.T) {
 	e := newEnv(t)
 	e.start(t)
@@ -1170,7 +1021,7 @@ func TestBatchNeverStoresDishPassedWhileRunning(t *testing.T) {
 func TestLaterBatchNeverResuggestsRenamedPass(t *testing.T) {
 	e := newEnv(t) // runner not started: the replenish batch waits for the rename
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	dinnerSvc, err := dinners.NewService(e.st, e.grounder, e.runner, func() {}, logger)
+	dinnerSvc, err := dinners.NewService(e.st, e.grounder, e.runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1218,14 +1069,14 @@ func TestLaterBatchNeverResuggestsRenamedDrop(t *testing.T) {
 	e := newEnv(t)
 	ctx := t.Context()
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	dinnerSvc, err := dinners.NewService(e.st, e.grounder, e.runner, func() {}, logger)
+	dinnerSvc, err := dinners.NewService(e.st, e.grounder, e.runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
 	fail := func(context.Context, string, skills.WeekRequest) (skills.Week, error) {
 		return skills.Week{}, errors.New("no draft in this test")
 	}
-	planSvc, err := plan.NewService(e.st, fail, e.runner, noCalendar{}, notifytest.New(t, e.st), func() {}, &url.URL{Scheme: "https", Host: "meals.example.com"}, time.Now, logger)
+	planSvc, err := plan.NewService(e.st, fail, e.runner, noCalendar{}, notifytest.New(t, e.st), &url.URL{Scheme: "https", Host: "meals.example.com"}, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1448,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)
 	}
 }
@@ -1623,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/0018_recipe_item_position_unique.sql

@@ -1,9 +0,0 @@
--- 0018_recipe_item_position_unique: position is the only record of recipe
--- order, so a recipe never has two ingredients or two steps at one
--- position. Writers replace a recipe's items whole, numbered from 0, and
--- the detail read orders by position alone. A database already holding a
--- duplicate fails this migration rather than keep an order nobody can
--- trust.
-
-CREATE UNIQUE INDEX recipe_ingredients_recipe_position ON recipe_ingredients (recipe_id, position);
-CREATE UNIQUE INDEX recipe_steps_recipe_position ON recipe_steps (recipe_id, position);

migrations/0019_shopping_group_frozen_name.sql

@@ -1,14 +0,0 @@
--- 0019_shopping_group_frozen_name: a Supply run frozen into the Supply
--- archive keeps the names its dinners had when it was frozen. A dinner can
--- be renamed at any time, so a frozen list reads each group's dinner name
--- from frozen_dinner_name, never from the dinner, as 0012 does for a Pass.
--- Only a group of a frozen list has one; a current list reads its dinners'
--- names live. A list frozen before this takes its dinners' names now.
-
-ALTER TABLE shopping_groups ADD COLUMN frozen_dinner_name TEXT CHECK (frozen_dinner_name <> '');
-
-UPDATE shopping_groups
-SET frozen_dinner_name = (SELECT dinners.name FROM dinners WHERE dinners.id = shopping_groups.dinner_id)
-WHERE list_id IN (
-	SELECT id FROM shopping_lists WHERE status = 'archived' OR frozen_at IS NOT NULL
-);

migrations/0020_site_name_from_page.sql

@@ -1,41 +0,0 @@
--- 0020_site_name_from_page: recipes.site_name now holds only the name a
--- recipe page gives its site (its publisher's name or og:site_name), and is
--- null when the page names none; a client is credited with the link's host
--- only when dinners.SourceOf finds the link safe to show. Before this, a
--- page naming no site was stored under the host of the URL it was served
--- from, which may carry a personal token, and nothing recorded which a
--- stored name was. A stored name that could be a host is cleared here, so
--- every stored name is one a page gave: one with no space (a host has
--- none) that is dotted or holds a colon — a host name or an IP address —
--- or that appears in the recipe's own link, as a dotless host does. This
--- clears every name the read rule before it withheld, and more: a site
--- that names itself as a domain, such as "Food.com", or by a word its link
--- spells, such as "Delish" on delish.com, loses its stored name until its
--- recipe is fetched again, and is credited by its link's host meanwhile
--- when the link is safe.
---
--- Idea job results stored before sources were made safe hold the grounded
--- recipe's site name and link as they were stored, and are cleared the
--- same way: an idea's stored site name is shown as it stands. The ideas
--- array is rebuilt from a plain scan of json_each, which yields its
--- elements in array order, so the ideas keep their order (sqlc's parser
--- refuses an ORDER BY inside json_group_array).
-
-UPDATE recipes SET site_name = NULL
-WHERE instr(site_name, ' ') = 0
-	AND (site_name GLOB '*[.:]*' OR instr(lower(source_url), lower(site_name)) > 0);
-
-UPDATE jobs SET result = json_set(result, '$.ideas', (
-	SELECT json_group_array(
-		CASE
-			WHEN instr(json_extract(idea.value, '$.site_name'), ' ') = 0
-				AND (json_extract(idea.value, '$.site_name') GLOB '*[.:]*'
-					OR instr(lower(json_extract(idea.value, '$.source_url')), lower(json_extract(idea.value, '$.site_name'))) > 0)
-			THEN json_set(idea.value, '$.site_name', json('null'))
-			ELSE json(idea.value)
-		END
-	)
-	FROM json_each(jobs.result, '$.ideas') AS idea
-))
-WHERE kind IN ('ideas_from_ingredients', 'quick_ideas')
-	AND json_type(result, '$.ideas') = 'array';

migrations/queries/notifications.sql

@@ -74,20 +74,3 @@ 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;
-
--- name: ListRecentNotifications :many
--- Returns the last lim distinct events stored, newest first: one row per
--- event key, the last stored for it whatever its channel, so an event
--- stored for push and Google Chat is one row. The last, because a channel
--- switched on later can store the same event key again, and
--- HasNotificationSince counts that row: an event is as new as its newest
--- row, so marking it seen also covers that row.
-SELECT o.event_key, o.payload, o.created_at FROM notification_outbox o
-WHERE o.id = (
-	SELECT i.id FROM notification_outbox i
-	WHERE i.event_key = o.event_key
-	ORDER BY i.created_at DESC, i.id DESC
-	LIMIT 1
-)
-ORDER BY o.created_at DESC, o.event_key DESC
-LIMIT sqlc.arg(lim);

migrations/queries/recipes.sql

@@ -48,7 +48,7 @@ INSERT INTO recipe_ingredients (
 -- name: ListRecipeIngredients :many
 SELECT * FROM recipe_ingredients
 WHERE recipe_id = ?
-ORDER BY position;
+ORDER BY position, id;
 
 -- name: DeleteRecipeIngredients :exec
 DELETE FROM recipe_ingredients
@@ -64,7 +64,7 @@ INSERT INTO recipe_steps (
 -- name: ListRecipeSteps :many
 SELECT * FROM recipe_steps
 WHERE recipe_id = ?
-ORDER BY position;
+ORDER BY position, id;
 
 -- name: DeleteRecipeSteps :exec
 DELETE FROM recipe_steps

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;

migrations/queries/settings.sql

@@ -154,11 +154,3 @@ RETURNING *;
 UPDATE chat_settings
 SET last_test_at = ?, last_test_status = ?, updated_at = ?
 WHERE id = 1 AND webhook_url_ct = ?;
-
--- name: MarkUpdatesSeen :execrows
--- Moves updates_seen_at forward to seen_at; affects no row when it is
--- already at or after seen_at, so it never moves back. It is not a settings
--- edit: updated_by and updated_at are left as they are.
-UPDATE household_settings
-SET updates_seen_at = CAST(sqlc.arg(seen_at) AS TEXT)
-WHERE id = 1 AND (updates_seen_at IS NULL OR updates_seen_at < CAST(sqlc.arg(seen_at) AS TEXT));

migrations/queries/shopping.sql

@@ -60,8 +60,7 @@ DELETE FROM shopping_items
 WHERE id = ?;
 
 -- name: ListShoppingGroupDinners :many
--- The groups of list list_id with their dinner's name now, in list order.
--- A group of a frozen list shows its frozen_dinner_name instead.
+-- The groups of list list_id with their dinner's name, in list order.
 SELECT sqlc.embed(shopping_groups), dinners.name AS dinner_name
 FROM shopping_groups
 JOIN dinners ON dinners.id = shopping_groups.dinner_id
@@ -118,13 +117,6 @@ UPDATE shopping_lists
 SET status = 'archived', frozen_at = ?, updated_at = ?
 WHERE id = ? AND frozen_at IS NULL;
 
--- name: FreezeShoppingGroupNames :exec
--- Keeps the name each dinner of list list_id has now as its group's
--- frozen_dinner_name, as the list is frozen into the Supply archive.
-UPDATE shopping_groups
-SET frozen_dinner_name = (SELECT dinners.name FROM dinners WHERE dinners.id = shopping_groups.dinner_id)
-WHERE list_id = ?;
-
 -- name: ListShoppingListsThrough :many
 -- The Supply runs of the weeks starting on or before week_start, newest
 -- week first.

web/src/App.test.tsx

@@ -88,7 +88,7 @@ describe('App routes', () => {
 
   it('/ renders the Home screen inside the shell', async () => {
     mockViewport(390)
-    stubFetchByPath({ ...SIGNED_IN, '/api/v1/home': () => jsonResponse(200, HOME), '/api/v1/rotation-reviews': () => jsonResponse(200, { reviews: [] }) })
+    stubFetchByPath({ ...SIGNED_IN, '/api/v1/home': () => jsonResponse(200, HOME) })
     renderAt('/')
     const heading = await screen.findByRole('heading', { level: 1, name: "Tonight's quest" })
     expect(screen.getByRole('main')).toContainElement(heading)
@@ -273,13 +273,7 @@ describe('App bootstrap', () => {
 
   it('reports a /me failure with a retry instead of rendering the routes', async () => {
     mockViewport(390)
-    const mes = [errorResponse(500, 'internal'), jsonResponse(200, ME)]
-    stubFetchByPath({
-      ...SIGNED_IN,
-      '/api/v1/me': () => mes.shift()!,
-      '/api/v1/home': () => jsonResponse(200, HOME),
-      '/api/v1/rotation-reviews': () => jsonResponse(200, { reviews: [] }),
-    })
+    stubFetch(errorResponse(500, 'internal'), jsonResponse(200, ME), jsonResponse(200, HOUSEHOLD_SETTINGS), jsonResponse(200, HOME))
     renderAt('/')
 
     expect(await screen.findByRole('alert')).toHaveTextContent('MealQuest could not load: internal message')
@@ -300,7 +294,7 @@ describe('App offline bootstrap', () => {
   // visitOnline is an earlier online visit on this device: /me answers with a
   // member, then the app is closed.
   async function visitOnline() {
-    stubFetchByPath({ ...SIGNED_IN, '/api/v1/home': () => jsonResponse(200, HOME), '/api/v1/rotation-reviews': () => jsonResponse(200, { reviews: [] }) })
+    stubFetchByPath({ ...SIGNED_IN, '/api/v1/home': () => jsonResponse(200, HOME) })
     const { unmount } = renderAt('/')
     expect(await screen.findByRole('heading', { name: 'Pizza night' })).toBeInTheDocument()
     unmount()

web/src/contrast.test.ts

@@ -1,86 +0,0 @@
-// Text contrast over the design tokens (docs/A11Y.md, "Text contrast"). Every
-// colour a stylesheet gives text must be a token listed in TEXT_GROUNDS, and
-// every pair listed there must reach WCAG AA's 4.5:1 for normal-size text.
-import { describe, expect, it } from 'vitest'
-import tokens from './styles/tokens.css?raw'
-
-const stylesheets = import.meta.glob<string>(['./**/*.css', '!./styles/tokens.css'], {
-  query: '?raw',
-  import: 'default',
-  eager: true,
-})
-
-// The grounds MealQuest's pages, cards, rows and tinted fills use.
-const LIGHT_GROUNDS = [
-  '--color-bg',
-  '--color-surface',
-  '--color-neutral-100',
-  '--color-neutral-200',
-  '--color-accent-100',
-  '--color-accent-200',
-  '--color-accent-2-100',
-  '--color-accent-2-200',
-]
-
-// Each text colour token, with every ground it is drawn on.
-const TEXT_GROUNDS: Record<string, string[]> = {
-  '--color-text': [...LIGHT_GROUNDS, '--color-accent-2-300'],
-  '--color-neutral-700': LIGHT_GROUNDS,
-  '--color-neutral-800': LIGHT_GROUNDS,
-  '--color-neutral-900': LIGHT_GROUNDS,
-  '--color-accent': LIGHT_GROUNDS,
-  '--color-accent-700': LIGHT_GROUNDS,
-  '--color-accent-800': LIGHT_GROUNDS,
-  '--color-accent-2-800': LIGHT_GROUNDS,
-  '--color-accent-2-900': [...LIGHT_GROUNDS, '--color-accent-2-300'],
-  // Light ink on the grape fills (buttons, the active nav pill, the chosen
-  // text size) and on the dark ones (the Offline pill).
-  '--on-accent': ['--color-accent', '--color-accent-800', '--color-neutral-800'],
-  // The dark pill button and the chosen settings tab.
-  '--color-bg': ['--color-text', '--color-neutral-800'],
-  // The bottom bar's inactive items, on the dark bar.
-  '--color-neutral-400': ['--color-text'],
-}
-
-function hex(name: string): string {
-  const value = new RegExp(`^\\s*${name}:\\s*(#[0-9a-fA-F]{6})\\b`, 'm').exec(tokens)?.[1]
-  if (value === undefined) throw new Error(`${name} is not a hex colour in tokens.css`)
-  return value
-}
-
-// Relative luminance, per WCAG 2.
-function luminance(colour: string): number {
-  const [r, g, b] = [1, 3, 5].map((i) => {
-    const c = Number.parseInt(colour.slice(i, i + 2), 16) / 255
-    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4
-  })
-  return 0.2126 * r! + 0.7152 * g! + 0.0722 * b!
-}
-
-function contrast(a: string, b: string): number {
-  const [light, dark] = [luminance(hex(a)), luminance(hex(b))].sort((x, y) => y - x)
-  return (light! + 0.05) / (dark! + 0.05)
-}
-
-describe('text contrast', () => {
-  const pairs = Object.entries(TEXT_GROUNDS).flatMap(([text, grounds]) => grounds.map((ground) => [text, ground] as const))
-
-  it.each(pairs)('%s on %s reaches 4.5:1', (text, ground) => {
-    expect(contrast(text, ground)).toBeGreaterThanOrEqual(4.5)
-  })
-
-  it('gives text only the colour tokens checked above', () => {
-    expect(Object.keys(stylesheets).length).toBeGreaterThan(0)
-    const unchecked = Object.entries(stylesheets).flatMap(([path, css]) =>
-      Array.from(css.matchAll(/(?<![\w-])color:\s*([^;}]+)/g))
-        .map((match) => match[1]!.trim())
-        .filter((value) => value !== 'inherit')
-        .filter((value) => {
-          const token = /^var\((--[\w-]+)\)$/.exec(value)?.[1]
-          return token === undefined || !(token in TEXT_GROUNDS)
-        })
-        .map((value) => `${path}: color: ${value}`),
-    )
-    expect(unchecked).toEqual([])
-  })
-})

web/src/dinners/DinnerDetailPage.module.css

@@ -341,13 +341,6 @@
   box-shadow: none;
 }
 
-/* The pill clips anything outside it, so the focus ring sits inside the
-   size, drawn in on-accent ink: only the chosen size takes focus. */
-.readingHeader .textSize > :focus-visible {
-  outline-color: var(--on-accent);
-  outline-offset: -4px;
-}
-
 .readingHeader .textSize > :nth-child(1) {
   font-size: 13px;
 }
@@ -440,7 +433,7 @@
 }
 
 .setOut {
-  color: var(--color-neutral-700);
+  color: var(--color-neutral-600);
   text-decoration: line-through;
 }
 
@@ -522,7 +515,7 @@
 }
 
 .stepDone {
-  color: var(--color-neutral-700);
+  color: var(--color-neutral-600);
 }
 
 .stepCurrent {

web/src/dinners/KitchenReading.test.tsx

@@ -325,7 +325,7 @@ describe('Kitchen reading mode', () => {
       // The step done is muted, its number a check.
       expect(steps()[0]!.textContent).toBe('Rinse the rice and start it cooking.')
       expect(steps()[0]!.querySelector('svg')).not.toBeNull()
-      expect(declaredStyle(steps()[0]!).color).toBe('var(--color-neutral-700)')
+      expect(declaredStyle(steps()[0]!).color).toBe('var(--color-neutral-600)')
       expect(declaredStyle(steps()[0]!).fontSize).toBe('calc(18px * var(--reading-scale))')
 
       fireEvent.click(next)
@@ -381,21 +381,6 @@ describe('Kitchen reading mode', () => {
   })
 
   describe('text size', () => {
-    it('rings the focused size inside the clipped pill, in on-accent ink on the grape', async () => {
-      serve()
-      await renderPage()
-      const medium = screen.getByRole('radio', { name: 'Medium text' })
-      // A key press makes the next focus a keyboard one, which
-      // :focus-visible matches.
-      fireEvent.keyDown(document.body, { key: 'Tab' })
-      medium.focus()
-      expect(medium.matches(':focus-visible')).toBe(true)
-      // The pill hides overflow, so a ring outside the size would be cut off.
-      expect(declaredStyle(medium).getPropertyValue('outline-offset')).toBe('-4px')
-      expect(declaredStyle(medium).getPropertyValue('outline-color')).toBe('var(--on-accent)')
-      expect(declaredStyle(medium).background).toBe('var(--color-accent)')
-    })
-
     it('is remembered on this device', async () => {
       serve()
       const view = await renderPage()

web/src/dinners/api.ts

@@ -54,9 +54,7 @@ export type RecipeFix = { candidate_id: string } | { recipe_url: string } | { ma
 export type RecipeCandidate = {
   candidate_id: string
   title: string
-  // site_name is null when the server cannot name the page's site without
-  // leaking its link (dinners.SourceOf).
-  site_name: string | null
+  site_name: string
   photo_id: string | undefined
   minutes: number | null
 }
@@ -132,7 +130,7 @@ function parseCandidate(where: string, body: unknown): RecipeCandidate {
     !isRecord(body) ||
     typeof body.candidate_id !== 'string' ||
     typeof body.title !== 'string' ||
-    (body.site_name !== null && typeof body.site_name !== 'string')
+    typeof body.site_name !== 'string'
   ) {
     throw new Error(`${where}: response is not a recipe candidate`)
   }

web/src/home/HomePage.test.tsx

@@ -1,13 +1,12 @@
-import { act, fireEvent, render, screen, within } from '@testing-library/react'
+import { fireEvent, render, screen, within } from '@testing-library/react'
 import { createMemoryRouter, RouterProvider, useLocation } from 'react-router'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { ApiProviders, HOME } from '../test/ApiProviders.tsx'
 import { declaredStyle } from '../test/cssRules.ts'
-import { errorResponse, jsonResponse, stubFetchByPath } from '../test/fetchStub.ts'
+import { errorResponse, jsonResponse, stubFetch, stubFetchByPath } from '../test/fetchStub.ts'
 import { expectMinHitArea } from '../test/hitArea.ts'
 import { HOME_PATH } from './api.ts'
 import { HomePage } from './HomePage.tsx'
-import { ROTATION_REVIEWS_PATH } from './rotation.ts'
 
 // NOTHING_YET is the home of a household with no plan, no Side quests, no
 // Supply run and nothing unread.
@@ -20,7 +19,6 @@ const NOTHING_YET = {
 }
 
 afterEach(() => {
-  vi.useRealTimers()
   vi.unstubAllGlobals()
 })
 
@@ -31,7 +29,7 @@ function Where() {
 }
 
 function renderHome(body: unknown) {
-  stubFetchByPath({ [HOME_PATH]: () => jsonResponse(200, body), [ROTATION_REVIEWS_PATH]: () => jsonResponse(200, { reviews: [] }) })
+  stubFetchByPath({ [HOME_PATH]: () => jsonResponse(200, body) })
   return renderRouter()
 }
 
@@ -73,31 +71,6 @@ describe('HomePage', () => {
     expect(screen.queryByRole('heading', { name: 'No quest planned tonight' })).not.toBeInTheDocument()
   })
 
-  it("reads Home again at the household's next local midnight, so a Home left open moves to the new day", async () => {
-    // setTimeout moves with real time, and the test jumps to midnight.
-    vi.useFakeTimers({ toFake: ['Date', 'setTimeout', 'clearTimeout'], shouldAdvanceTime: true })
-    // 23:58 on Friday Oct 2 in New York, the household's zone.
-    vi.setSystemTime(new Date('2026-10-03T03:58:00Z'))
-    const days = [HOME, { ...HOME, dateLabel: 'Saturday, Oct 3', tonight: null }]
-    let reads = 0
-    stubFetchByPath({
-      [HOME_PATH]: () => jsonResponse(200, days[Math.min(reads++, 1)]),
-      [ROTATION_REVIEWS_PATH]: () => jsonResponse(200, { reviews: [] }),
-    })
-    renderRouter()
-    expect(await screen.findByText('Friday, Oct 2')).toBeInTheDocument()
-    expect(reads).toBe(1)
-
-    // A minute before midnight Home is not read again.
-    await act(() => vi.advanceTimersByTimeAsync(60_000))
-    expect(reads).toBe(1)
-    // At midnight it is, and shows the new day.
-    await act(() => vi.advanceTimersByTimeAsync(60_000))
-    expect(await screen.findByText('Saturday, Oct 3')).toBeInTheDocument()
-    expect(reads).toBe(2)
-    expect(screen.getByRole('heading', { name: 'No quest planned tonight' })).toBeInTheDocument()
-  })
-
   it('shows the grape unread dot on the bell when there are unread updates', async () => {
     renderHome(HOME)
 
@@ -225,11 +198,7 @@ describe('HomePage', () => {
   })
 
   it('reports a failure with Retry, and no made-up content', async () => {
-    const homes = [errorResponse(500, 'internal'), jsonResponse(200, HOME)]
-    stubFetchByPath({
-      [HOME_PATH]: () => homes.shift()!,
-      [ROTATION_REVIEWS_PATH]: () => jsonResponse(200, { reviews: [] }),
-    })
+    stubFetch(errorResponse(500, 'internal'), jsonResponse(200, HOME))
     renderRouter()
 
     expect(await screen.findByRole('alert')).toHaveTextContent("Couldn't load tonight's quest. internal message")

web/src/home/HomePage.tsx

@@ -1,5 +1,4 @@
 import { Bell, ChevronRight, Compass, Search, ShoppingCart, Zap, type LucideIcon } from 'lucide-react'
-import { useState } from 'react'
 import { Link, useNavigate } from 'react-router'
 import { duration } from '../plan/PlanPage.tsx'
 import { supplyRunScreen } from '../shopping/api.ts'
@@ -12,8 +11,6 @@ import { Photo } from '../ui/Photo.tsx'
 import { Skeleton } from '../ui/Skeleton.tsx'
 import { useHome, type Home, type Origin, type Tonight } from './api.ts'
 import styles from './HomePage.module.css'
-import { RotationCheck } from './RotationCheck.tsx'
-import { UpdatesSheet } from './UpdatesSheet.tsx'
 
 const ORIGIN_LABEL: Record<Origin, string> = { regular: 'Regular', side_quest: 'Side quest' }
 
@@ -109,15 +106,13 @@ function Tiles() {
 // HomePage is mock 1g, Home: today's date over "Tonight's quest" and the
 // Recent updates bell, the Tonight card (or the way to plan the week), the
 // Quick dinner and Cook from what I have tiles, and the status rows, all
-// from GET /api/v1/home. Above the tiles is the Rotation check, "Keep it in
-// rotation?", while a tried dinner waits for the household's answer.
+// from GET /api/v1/home.
 //
-// The bell carries a grape dot while there are unread updates and opens the
-// Recent updates sheet, which marks them seen.
+// The bell only shows whether there are unread updates; the Recent updates
+// sheet it opens is still to come.
 export function HomePage() {
   const home = useHome()
   const data = home.data
-  const [updatesOpen, setUpdatesOpen] = useState(false)
   return (
     <div className={styles.page} aria-busy={home.isPending}>
       <header className={styles.header}>
@@ -129,11 +124,7 @@ export function HomePage() {
           )}
           <h1 className={styles.title}>Tonight's quest</h1>
         </div>
-        <IconButton
-          label={data?.unread ? 'Recent updates, unread' : 'Recent updates'}
-          className={styles.bell}
-          onClick={() => setUpdatesOpen(true)}
-        >
+        <IconButton label={data?.unread ? 'Recent updates, unread' : 'Recent updates'} className={styles.bell}>
           <Icon icon={Bell} className={styles.bellIcon} />
           {data?.unread && <span data-testid="unread-dot" className={styles.dot} />}
         </IconButton>
@@ -143,7 +134,6 @@ export function HomePage() {
         <ErrorBanner onRetry={() => void home.refetch()}>Couldn't load tonight's quest. {home.error.message}</ErrorBanner>
       )}
       {data !== undefined && (data.tonight === null ? <NoPlan /> : <TonightCard tonight={data.tonight} />)}
-      <RotationCheck />
       <Tiles />
       {home.isPending && (
         <div className={styles.statuses} aria-hidden="true">
@@ -152,7 +142,6 @@ export function HomePage() {
         </div>
       )}
       {data !== undefined && <StatusRows home={data} />}
-      <UpdatesSheet open={updatesOpen} onClose={() => setUpdatesOpen(false)} />
     </div>
   )
 }

web/src/home/RotationCheck.module.css

@@ -1,79 +0,0 @@
-/* The Rotation check on Home: "Keep it in rotation?" above the tiles. */
-.card {
-  display: flex;
-  flex-direction: column;
-  border-radius: 32px;
-  background: var(--color-surface);
-  overflow: hidden;
-}
-
-.photo {
-  height: 120px;
-}
-
-.body {
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
-  padding: 4px 18px 12px;
-}
-
-.kicker {
-  margin: 0;
-  font-family: var(--font-body);
-  font-size: 12px;
-  font-weight: 700;
-  color: var(--color-neutral-700);
-}
-
-.question {
-  margin: 0;
-  font-family: var(--font-heading);
-  font-size: 22px;
-  font-weight: 400;
-  line-height: 1.1;
-}
-
-.actions {
-  display: grid;
-  grid-template-columns: 1fr 1fr;
-  gap: 10px;
-  margin-top: 6px;
-}
-
-/* "We didn't make it": a text link at the 44 px tap minimum. */
-.notMade {
-  align-self: center;
-  min-width: 44px;
-  min-height: 44px;
-  padding: 0 4px;
-  border: 0;
-  background: transparent;
-  color: var(--color-accent-700);
-  font-family: var(--font-body);
-  font-size: 13px;
-  font-weight: 700;
-  text-decoration: underline;
-  cursor: pointer;
-}
-
-.notMade:disabled {
-  opacity: 0.45;
-  cursor: not-allowed;
-}
-
-.notMade:focus-visible {
-  outline: 3px solid var(--color-accent);
-  outline-offset: 2px;
-}
-
-.confirmation {
-  margin: 0;
-  padding: 12px 14px;
-  border-radius: 20px;
-  background: var(--color-accent-2-300);
-  color: var(--color-accent-2-900);
-  font-family: var(--font-body);
-  font-size: 13px;
-  font-weight: 700;
-}

web/src/home/RotationCheck.test.tsx

@@ -1,320 +0,0 @@
-import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
-import { createMemoryRouter, RouterProvider } from 'react-router'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { clickPath, openNotification, parsePushPayload, type ClickWindow } from '../push/notification.ts'
-import { QueryClientProvider } from '@tanstack/react-query'
-import { ApiProvider, createApiClient, createQueryClient, createVerifiedSession, ME_PATH } from '../api/index.ts'
-import { createNetworkStatus } from '../pwa/networkStatus.ts'
-import { HOME } from '../test/ApiProviders.tsx'
-import { errorResponse, fakeLocation, jsonResponse, ME } from '../test/fetchStub.ts'
-import { expectMinHitArea } from '../test/hitArea.ts'
-import { HOME_PATH } from './api.ts'
-import { HomePage } from './HomePage.tsx'
-import { rotationReviewPath, ROTATION_REVIEWS_PATH } from './rotation.ts'
-
-// SHAKSHUKA and RAMEN are pending Rotation checks, oldest first, as GET
-// /api/v1/rotation-reviews sends them.
-const SHAKSHUKA = { dinner: { id: 'd7', name: 'Shakshuka', photo: '/media/photos/p7-400.jpg' }, plan_date: '2026-10-01' }
-const RAMEN = { dinner: { id: 'd8', name: 'Miso ramen', photo: null }, plan_date: '2026-10-02' }
-
-afterEach(() => {
-  vi.unstubAllGlobals()
-  Reflect.deleteProperty(navigator, 'serviceWorker')
-})
-
-type Deferred = { resolve: (response: Response) => void; path: string; body: unknown }
-
-// stubApi answers Home's reads like the server: the pending Rotation checks
-// are reviews, and each POST /api/v1/dinners/{id}/rotation-review waits in
-// decisions until the test answers it; a 200 answer takes the check off the
-// server's list, as the server does.
-function stubApi(reviews: (typeof SHAKSHUKA | typeof RAMEN)[]) {
-  const server = [...reviews]
-  const decisions: Deferred[] = []
-  const fetchMock = vi.fn<typeof fetch>((input, init) => {
-    const path = String(input)
-    if (path === ME_PATH) return Promise.resolve(jsonResponse(200, ME))
-    if (path === HOME_PATH) return Promise.resolve(jsonResponse(200, HOME))
-    if (path === ROTATION_REVIEWS_PATH) return Promise.resolve(jsonResponse(200, { reviews: server }))
-    const review = server.find((r) => rotationReviewPath(r.dinner.id) === path)
-    if (init?.method === 'POST' && review !== undefined) {
-      expect(new Headers(init.headers).get('X-MealQuest-CSRF')).toBe(ME.csrfToken)
-      const body: unknown = JSON.parse(String(init.body))
-      return new Promise<Response>((resolve) =>
-        decisions.push({
-          path,
-          body,
-          resolve: (response) => {
-            if (response.ok) server.splice(server.indexOf(review), 1)
-            resolve(response)
-          },
-        }),
-      )
-    }
-    throw new Error(`unexpected fetch: ${init?.method ?? 'GET'} ${path}`)
-  })
-  vi.stubGlobal('fetch', fetchMock)
-  return { fetchMock, decisions, server }
-}
-
-// decided is the server's answer to a decision on review.
-function decided(review: typeof SHAKSHUKA | typeof RAMEN, decision: string, dinnerStatus: string) {
-  return jsonResponse(200, {
-    dinner: review.dinner,
-    plan_date: review.plan_date,
-    decision,
-    dinner_status: dinnerStatus,
-    decided_at: '2026-10-02T13:00:00Z',
-    updated_by: 'sub-1',
-  })
-}
-
-// renderHome loads /me (for the CSRF token an answer needs) and renders Home
-// at path.
-async function renderHome(path = '/') {
-  const api = createApiClient(fakeLocation(path), createNetworkStatus(window), createVerifiedSession(localStorage))
-  await api.loadMe()
-  const router = createMemoryRouter([{ path: '/', element: <HomePage /> }], { initialEntries: [path] })
-  render(
-    <ApiProvider client={api}>
-      <QueryClientProvider client={createQueryClient()}>
-        <RouterProvider router={router} />
-      </QueryClientProvider>
-    </ApiProvider>,
-  )
-}
-
-const card = () => screen.findByRole('region', { name: 'Keep it in rotation?' })
-const posts = (fetchMock: ReturnType<typeof stubApi>['fetchMock']) =>
-  fetchMock.mock.calls.filter(([, init]) => init?.method === 'POST')
-
-describe('RotationCheck', () => {
-  it('shows no card when nothing waits for an answer', async () => {
-    const { fetchMock } = stubApi([])
-    await renderHome()
-
-    expect(await screen.findByRole('heading', { name: 'Pizza night' })).toBeInTheDocument()
-    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(ROTATION_REVIEWS_PATH, expect.anything()))
-    expect(screen.queryByRole('region', { name: 'Keep it in rotation?' })).not.toBeInTheDocument()
-    expect(screen.queryByRole('status')).not.toBeInTheDocument()
-    expect(screen.getByRole('link', { name: 'Quick dinner' })).toBeInTheDocument()
-  })
-
-  it('asks about the oldest pending check above the tiles, and decides nothing by itself', async () => {
-    const { fetchMock } = stubApi([SHAKSHUKA, RAMEN])
-    await renderHome()
-
-    const check = await card()
-    expect(within(check).getByText('Last night: Shakshuka')).toBeInTheDocument()
-    expect(within(check).getByRole('heading', { level: 2, name: 'Keep it in rotation?' })).toBeInTheDocument()
-    expect(within(check).getByRole('img', { name: 'Shakshuka' })).toHaveAttribute('src', '/media/photos/p7-400.jpg')
-    expect(screen.queryByText('Last night: Miso ramen')).not.toBeInTheDocument()
-
-    const keep = within(check).getByRole('button', { name: 'Keep it' })
-    const drop = within(check).getByRole('button', { name: 'Not for us' })
-    const notMade = within(check).getByRole('button', { name: "We didn't make it" })
-    expect(keep.className).toMatch(/primary/)
-    expect(drop.className).toMatch(/outline/)
-    expect(notMade.className).toMatch(/notMade/)
-    for (const button of [keep, drop, notMade]) expectMinHitArea(button)
-
-    const tiles = screen.getByRole('link', { name: 'Quick dinner' })
-    expect(check.compareDocumentPosition(tiles) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy()
-    expect(screen.getByRole('region', { name: 'Tonight' }).compareDocumentPosition(check) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy()
-
-    // The card waits for the household: nothing is sent unasked.
-    await act(() => new Promise((resolve) => setTimeout(resolve, 50)))
-    expect(posts(fetchMock)).toHaveLength(0)
-    expect(await card()).toBeInTheDocument()
-  })
-
-  it.each([
-    ['Keep it', 'keep', 'regular', 'Added to your Regulars'],
-    ['Not for us', 'drop', 'archived', "Got it — we won't suggest it again"],
-    ["We didn't make it", 'not_made', 'quest_log', 'Back in your Quest log'],
-  ])('"%s" sends %s at once and confirms "%s"', async (label, decision, status, confirmation) => {
-    const { fetchMock, decisions } = stubApi([SHAKSHUKA])
-    await renderHome()
-
-    fireEvent.click(within(await card()).getByRole('button', { name: label }))
-
-    // Applied before the server answers.
-    expect(await screen.findByRole('status')).toHaveTextContent(confirmation)
-    expect(screen.queryByRole('region', { name: 'Keep it in rotation?' })).not.toBeInTheDocument()
-    await waitFor(() => expect(decisions).toHaveLength(1))
-    expect(decisions[0]).toMatchObject({ path: '/api/v1/dinners/d7/rotation-review', body: { decision } })
-    expect(posts(fetchMock)).toHaveLength(1)
-
-    act(() => decisions[0]!.resolve(decided(SHAKSHUKA, decision, status)))
-    // Rotation checks are read again once saved; none is left.
-    await waitFor(() =>
-      expect(fetchMock.mock.calls.filter(([path]) => path === ROTATION_REVIEWS_PATH).length).toBeGreaterThanOrEqual(2),
-    )
-    expect(screen.getByRole('status')).toHaveTextContent(confirmation)
-    expect(screen.queryByRole('region', { name: 'Keep it in rotation?' })).not.toBeInTheDocument()
-    expect(screen.queryByRole('alert')).not.toBeInTheDocument()
-  })
-
-  it('reveals the next pending check at once, its answers locked until the first is saved', async () => {
-    const { decisions } = stubApi([SHAKSHUKA, RAMEN])
-    await renderHome()
-
-    fireEvent.click(within(await card()).getByRole('button', { name: 'Keep it' }))
-
-    expect(await screen.findByText('Last night: Miso ramen')).toBeInTheDocument()
-    const next = await card()
-    expect(within(next).getByRole('img', { name: 'Miso ramen' })).toHaveTextContent('dish photo')
-    expect(screen.getByRole('status')).toHaveTextContent('Added to your Regulars')
-    for (const button of within(next).getAllByRole('button')) expect(button).toBeDisabled()
-
-    await waitFor(() => expect(decisions).toHaveLength(1))
-    act(() => decisions[0]!.resolve(decided(SHAKSHUKA, 'keep', 'regular')))
-    await waitFor(() => expect(within(next).getByRole('button', { name: 'Not for us' })).toBeEnabled())
-
-    fireEvent.click(within(next).getByRole('button', { name: 'Not for us' }))
-    expect(await screen.findByRole('status')).toHaveTextContent("Got it — we won't suggest it again")
-    await waitFor(() => expect(decisions).toHaveLength(2))
-    expect(decisions[1]).toMatchObject({ path: '/api/v1/dinners/d8/rotation-review', body: { decision: 'drop' } })
-    act(() => decisions[1]!.resolve(decided(RAMEN, 'drop', 'archived')))
-    await waitFor(() => expect(screen.queryByRole('region', { name: 'Keep it in rotation?' })).not.toBeInTheDocument())
-    expect(screen.queryByText(/Last night:/)).not.toBeInTheDocument()
-  })
-
-  it('puts the check back with an ErrorBanner when the answer fails', async () => {
-    const { decisions } = stubApi([SHAKSHUKA, RAMEN])
-    await renderHome()
-
-    fireEvent.click(within(await card()).getByRole('button', { name: 'Keep it' }))
-    expect(await screen.findByText('Last night: Miso ramen')).toBeInTheDocument()
-    await waitFor(() => expect(decisions).toHaveLength(1))
-
-    act(() => decisions[0]!.resolve(errorResponse(500, 'internal')))
-
-    expect(await screen.findByRole('alert')).toHaveTextContent("Couldn't save that answer. internal message")
-    const check = await card()
-    expect(within(check).getByText('Last night: Shakshuka')).toBeInTheDocument()
-    expect(screen.queryByRole('status')).not.toBeInTheDocument()
-    expect(within(check).getByRole('button', { name: 'Keep it' })).toBeEnabled()
-  })
-
-  it('reports an answer that is not that check decided that way, and shows what the server has', async () => {
-    const { decisions } = stubApi([SHAKSHUKA])
-    await renderHome()
-
-    fireEvent.click(within(await card()).getByRole('button', { name: 'Keep it' }))
-    await waitFor(() => expect(decisions).toHaveLength(1))
-    act(() => decisions[0]!.resolve(decided(SHAKSHUKA, 'drop', 'archived')))
-
-    expect(await screen.findByRole('alert')).toHaveTextContent('response is not the Rotation check decided keep')
-    expect(screen.queryByRole('status')).not.toBeInTheDocument()
-    // The server closed the check, so the list read again has none.
-    await waitFor(() => expect(screen.queryByRole('region', { name: 'Keep it in rotation?' })).not.toBeInTheDocument())
-  })
-
-  it('reports Rotation checks it cannot load, with Retry', async () => {
-    const answers = [errorResponse(500, 'internal'), jsonResponse(200, { reviews: [SHAKSHUKA] })]
-    vi.stubGlobal(
-      'fetch',
-      vi.fn<typeof fetch>((input) =>
-        Promise.resolve(
-          String(input) === ME_PATH
-            ? jsonResponse(200, ME)
-            : String(input) === HOME_PATH
-              ? jsonResponse(200, HOME)
-              : answers.shift()!,
-        ),
-      ),
-    )
-    await renderHome()
-
-    expect(await screen.findByRole('alert')).toHaveTextContent("Couldn't load the Rotation check. internal message")
-    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
-    expect(within(await card()).getByText('Last night: Shakshuka')).toBeInTheDocument()
-  })
-
-  it('keeps a card already shown, with an ErrorBanner beside it, when reading the checks again fails', async () => {
-    // navigator.serviceWorker is where the worker's postMessage to this
-    // window arrives; a notification tap there reads the checks again.
-    const container = new EventTarget()
-    Object.defineProperty(navigator, 'serviceWorker', { configurable: true, value: container })
-    const answers = [jsonResponse(200, { reviews: [SHAKSHUKA] }), errorResponse(500, 'internal')]
-    vi.stubGlobal(
-      'fetch',
-      vi.fn<typeof fetch>((input) =>
-        Promise.resolve(
-          String(input) === ME_PATH
-            ? jsonResponse(200, ME)
-            : String(input) === HOME_PATH
-              ? jsonResponse(200, HOME)
-              : answers.shift()!,
-        ),
-      ),
-    )
-    await renderHome()
-    expect(within(await card()).getByText('Last night: Shakshuka')).toBeInTheDocument()
-
-    const origin = 'https://mealquest.test'
-    const win = {
-      url: `${origin}/`,
-      focused: true,
-      focus: vi.fn(async () => {}),
-      navigate: vi.fn(async () => {}),
-      postMessage: (message) => container.dispatchEvent(new MessageEvent('message', { data: message })),
-    } satisfies ClickWindow
-    await act(() =>
-      openNotification({ url: '/' }, { matchAll: async () => [win], openWindow: vi.fn(async () => null) }, origin),
-    )
-
-    expect(await screen.findByRole('alert')).toHaveTextContent("Couldn't load the Rotation check. internal message")
-    const shown = screen.getByRole('region', { name: 'Keep it in rotation?' })
-    expect(within(shown).getByText('Last night: Shakshuka')).toBeInTheDocument()
-    expect(within(shown).getByRole('button', { name: 'Keep it' })).toBeEnabled()
-  })
-
-  it('opens Home with the card from a rotation_review push notification', async () => {
-    stubApi([SHAKSHUKA])
-    const origin = 'https://mealquest.test'
-    const { notice } = parsePushPayload(
-      JSON.stringify({ event: 'rotation_review', title: 'Keep it in rotation?', body: 'How was Shakshuka?', url: '/' }),
-      origin,
-    )
-    const path = clickPath({ url: notice.url }, origin)
-    expect(path).toBe('/')
-
-    await renderHome(path)
-    expect(within(await card()).getByText('Last night: Shakshuka')).toBeInTheDocument()
-  })
-
-  it('shows the card when a rotation_review notification focuses Home already open, without a remount', async () => {
-    // navigator.serviceWorker is where the worker's postMessage to this
-    // window arrives.
-    const container = new EventTarget()
-    Object.defineProperty(navigator, 'serviceWorker', { configurable: true, value: container })
-    const { fetchMock, server } = stubApi([])
-    const reads = () => fetchMock.mock.calls.filter(([path]) => path === ROTATION_REVIEWS_PATH).length
-    await renderHome('/')
-    const home = await screen.findByRole('heading', { name: 'Pizza night' })
-    await waitFor(() => expect(reads()).toBe(1))
-    expect(screen.queryByRole('region', { name: 'Keep it in rotation?' })).not.toBeInTheDocument()
-
-    // Within the cached list's staleTime the Rotation check comes due and
-    // its notification is tapped while Home is open at /.
-    server.push(SHAKSHUKA)
-    const origin = 'https://mealquest.test'
-    const win = {
-      url: `${origin}/`,
-      focused: true,
-      focus: vi.fn(async () => {}),
-      navigate: vi.fn(async () => {}),
-      postMessage: (message) => container.dispatchEvent(new MessageEvent('message', { data: message })),
-    } satisfies ClickWindow
-    await act(() =>
-      openNotification({ url: '/' }, { matchAll: async () => [win], openWindow: vi.fn(async () => null) }, origin),
-    )
-
-    expect(win.navigate).not.toHaveBeenCalled()
-    expect(within(await card()).getByText('Last night: Shakshuka')).toBeInTheDocument()
-    expect(reads()).toBe(2)
-    expect(screen.getByRole('heading', { name: 'Pizza night' })).toBe(home)
-  })
-})

web/src/home/RotationCheck.tsx

@@ -1,79 +0,0 @@
-import { Button } from '../ui/Button.tsx'
-import { ErrorBanner } from '../ui/ErrorBanner.tsx'
-import { Photo } from '../ui/Photo.tsx'
-import { useDecideRotationReview, useRotationReviews, type Decision, type RotationReview } from './rotation.ts'
-import styles from './RotationCheck.module.css'
-
-// CONFIRMATION is what Home says once the household has answered.
-const CONFIRMATION: Record<Decision, string> = {
-  keep: 'Added to your Regulars',
-  drop: "Got it — we won't suggest it again",
-  not_made: 'Back in your Quest log',
-}
-
-type RotationCardProps = { review: RotationReview; disabled: boolean; onDecide: (decision: Decision) => void }
-
-// RotationCard asks "Keep it in rotation?" about a tried dinner: its washed
-// photo, "Last night: {dinner}", and the three answers.
-function RotationCard({ review, disabled, onDecide }: RotationCardProps) {
-  const { dinner } = review
-  return (
-    <section aria-label="Keep it in rotation?" className={styles.card}>
-      <Photo id={dinner.photo_id} name={dinner.name} inset="10px" sizes="400px" className={styles.photo} />
-      <div className={styles.body}>
-        <p className={styles.kicker}>Last night: {dinner.name}</p>
-        <h2 className={styles.question}>Keep it in rotation?</h2>
-        <div className={styles.actions}>
-          <Button disabled={disabled} onClick={() => onDecide('keep')}>
-            Keep it
-          </Button>
-          <Button variant="outline" disabled={disabled} onClick={() => onDecide('drop')}>
-            Not for us
-          </Button>
-        </div>
-        <button type="button" className={styles.notMade} disabled={disabled} onClick={() => onDecide('not_made')}>
-          We didn't make it
-        </button>
-      </div>
-    </section>
-  )
-}
-
-// RotationCheck is the Rotation check on Home: the card for the oldest
-// pending check (GET /api/v1/rotation-reviews), which stays until the
-// household answers it — nothing is decided for them. An answer is applied
-// at once: Home confirms it and shows the next pending check, if any, while
-// the answer is saved; the answers are locked until it settles. A failed
-// answer puts its check back with an ErrorBanner. A failed read shows an
-// ErrorBanner, beside the checks last read: a card already shown stays
-// until it is answered.
-export function RotationCheck() {
-  const reviews = useRotationReviews()
-  const decide = useDecideRotationReview()
-  const deciding = decide.isPending ? decide.variables.review.dinner.id : null
-  const next = reviews.data?.find((review) => review.dinner.id !== deciding)
-  const answered = decide.isPending || decide.isSuccess ? decide.variables : undefined
-  return (
-    <>
-      {answered !== undefined && (
-        <p role="status" className={styles.confirmation}>
-          {CONFIRMATION[answered.decision]}
-        </p>
-      )}
-      {reviews.isError && (
-        <ErrorBanner onRetry={() => void reviews.refetch()}>
-          Couldn't load the Rotation check. {reviews.error.message}
-        </ErrorBanner>
-      )}
-      {decide.isError && <ErrorBanner>Couldn't save that answer. {decide.error.message}</ErrorBanner>}
-      {next !== undefined && (
-        <RotationCard
-          key={next.dinner.id}
-          review={next}
-          disabled={decide.isPending}
-          onDecide={(decision) => decide.mutate({ review: next, decision })}
-        />
-      )}
-    </>
-  )
-}

web/src/home/UpdatesSheet.module.css

@@ -1,49 +0,0 @@
-/* The Recent updates sheet the Home bell opens. */
-.sheet {
-  display: flex;
-  flex-direction: column;
-  gap: 14px;
-  max-width: 560px;
-  margin: 0 auto;
-}
-
-.title {
-  margin: 0;
-  font-family: var(--font-heading);
-  font-size: 22px;
-  font-weight: 400;
-}
-
-.rows {
-  margin: 0;
-  padding: 0;
-  list-style: none;
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-1);
-}
-
-.icon {
-  color: var(--color-accent-700);
-}
-
-.time {
-  font-family: var(--font-body);
-  font-size: 12px;
-  font-weight: 700;
-  color: var(--color-neutral-700);
-  white-space: nowrap;
-}
-
-.skeletonRow {
-  height: 56px;
-  border-radius: var(--radius-md);
-}
-
-.empty {
-  margin: 0;
-  font-family: var(--font-body);
-  font-size: 14px;
-  line-height: 1.45;
-  color: var(--color-neutral-700);
-}

web/src/home/UpdatesSheet.test.tsx

@@ -1,383 +0,0 @@
-import { QueryClientProvider } from '@tanstack/react-query'
-import { fireEvent, render, screen, waitFor, within } from '@testing-library/react'
-import { createMemoryRouter, RouterProvider, useLocation } from 'react-router'
-import { afterEach, describe, expect, it, vi, type Mock } from 'vitest'
-import { ApiProvider, createApiClient, createQueryClient, createVerifiedSession } from '../api/index.ts'
-import { createNetworkStatus } from '../pwa/networkStatus.ts'
-import { HOME } from '../test/ApiProviders.tsx'
-import { errorResponse, fakeLocation, jsonResponse, ME } from '../test/fetchStub.ts'
-import { HOME_KEY, HOME_PATH, UPDATES_PATH, UPDATES_SEEN_PATH } from './api.ts'
-import { ROTATION_REVIEWS_PATH } from './rotation.ts'
-import { HomePage } from './HomePage.tsx'
-
-afterEach(() => {
-  vi.unstubAllGlobals()
-})
-
-// minutesAgo is the stored form of the instant n minutes before now.
-function minutesAgo(n: number): string {
-  return new Date(Date.now() - n * 60_000).toISOString()
-}
-
-// UPDATES are a GET /api/v1/updates body, newest first: the week drafted
-// five minutes ago, new Side quests three hours ago and the Supply run two
-// days ago.
-const UPDATES = {
-  updates: [
-    {
-      type: 'plan_ready',
-      title: 'Your week is drafted',
-      body: 'Take a look at the Draft board.',
-      url: '/plan?week=2026-10-12',
-      created_at: minutesAgo(5),
-    },
-    { type: 'new_suggestions', title: '5 new Side quests', body: '', url: '/discover', created_at: minutesAgo(3 * 60) },
-    {
-      type: 'list_ready',
-      title: 'Supply run ready',
-      body: 'Week 41 · Oct 5 – 11',
-      url: '/plan/shopping?week=2026-10-05',
-      created_at: minutesAgo(2 * 24 * 60),
-    },
-  ],
-}
-
-type Responder = (init: RequestInit | undefined) => Response | Promise<Response>
-
-// stubServer answers "METHOD path" requests from responders, with /me; any
-// other request fails the test. Home is unread until the updates are marked
-// seen, as the server answers.
-function stubServer(responders: Record<string, Responder> = {}) {
-  let seen = false
-  const all: Record<string, Responder> = {
-    'GET /api/v1/me': () => jsonResponse(200, ME),
-    [`GET ${HOME_PATH}`]: () => jsonResponse(200, { ...HOME, recentUpdates: { unread: !seen } }),
-    [`GET ${UPDATES_PATH}`]: () => jsonResponse(200, UPDATES),
-    [`GET ${ROTATION_REVIEWS_PATH}`]: () => jsonResponse(200, { reviews: [] }),
-    [`POST ${UPDATES_SEEN_PATH}`]: () => {
-      seen = true
-      return new Response(null, { status: 204 })
-    },
-    ...responders,
-  }
-  const fetchMock = vi.fn<typeof fetch>((input, init) => {
-    const key = `${init?.method ?? 'GET'} ${String(input)}`
-    const respond = Object.hasOwn(all, key) ? all[key] : undefined
-    if (respond === undefined) throw new Error(`unexpected fetch: ${key}`)
-    return Promise.resolve(respond(init))
-  })
-  vi.stubGlobal('fetch', fetchMock)
-  return fetchMock
-}
-
-// posts lists the bodies of the POST /updates/seen requests sent, each of
-// which must carry the CSRF token.
-function posts(fetchMock: Mock<typeof fetch>) {
-  return fetchMock.mock.calls
-    .filter(([input, init]) => init?.method === 'POST' && String(input) === UPDATES_SEEN_PATH)
-    .map(([, init]) => {
-      expect(new Headers(init?.headers).get('X-MealQuest-CSRF')).toBe(ME.csrfToken)
-      return String(init?.body)
-    })
-}
-
-function homeReads(fetchMock: Mock<typeof fetch>) {
-  return fetchMock.mock.calls.filter(([input, init]) => String(input) === HOME_PATH && (init?.method ?? 'GET') === 'GET')
-    .length
-}
-
-function updatesReads(fetchMock: Mock<typeof fetch>) {
-  return fetchMock.mock.calls.filter(
-    ([input, init]) => String(input) === UPDATES_PATH && (init?.method ?? 'GET') === 'GET',
-  ).length
-}
-
-// Where shows the route a row went to.
-function Where() {
-  const location = useLocation()
-  return <p data-testid="where">{location.pathname + location.search}</p>
-}
-
-// renderHome loads /me (for the CSRF token the POST needs) and renders Home,
-// answering its query client.
-async function renderHome() {
-  const api = createApiClient(fakeLocation('/'), createNetworkStatus(window), createVerifiedSession(localStorage))
-  await api.loadMe()
-  const router = createMemoryRouter(
-    [
-      { path: '/', element: <HomePage /> },
-      { path: '*', element: <Where /> },
-    ],
-    { initialEntries: ['/'] },
-  )
-  const queryClient = createQueryClient()
-  render(
-    <ApiProvider client={api}>
-      <QueryClientProvider client={queryClient}>
-        <RouterProvider router={router} />
-      </QueryClientProvider>
-    </ApiProvider>,
-  )
-  return queryClient
-}
-
-// openSheet taps the unread bell and answers the open sheet.
-async function openSheet() {
-  fireEvent.click(await screen.findByRole('button', { name: 'Recent updates, unread' }))
-  return screen.getByRole('dialog', { name: 'Recent updates' })
-}
-
-async function rows(sheet: HTMLElement) {
-  return within(await within(sheet).findByRole('list', { name: 'Recent updates' })).getAllByRole('listitem')
-}
-
-describe('Recent updates sheet', () => {
-  it('lists the updates newest first with how long ago each came', async () => {
-    stubServer()
-    await renderHome()
-    const listed = await rows(await openSheet())
-
-    expect(listed).toHaveLength(3)
-    expect(listed[0]).toHaveTextContent('Your week is drafted')
-    expect(listed[0]).toHaveTextContent('Take a look at the Draft board.')
-    expect(listed[0]).toHaveTextContent('5 min ago')
-    expect(listed[1]).toHaveTextContent('5 new Side quests')
-    expect(listed[1]).toHaveTextContent('3 hr ago')
-    expect(listed[2]).toHaveTextContent('Supply run ready')
-    expect(listed[2]).toHaveTextContent('2 days ago')
-    expect(within(listed[0]!).getByText('5 min ago')).toHaveAttribute('dateTime', UPDATES.updates[0]!.created_at)
-  })
-
-  it('marks the updates seen through the newest, and the grape dot clears and stays cleared', async () => {
-    const fetchMock = stubServer()
-    await renderHome()
-    expect(await screen.findByTestId('unread-dot')).toBeInTheDocument()
-    await openSheet()
-
-    await waitFor(() => expect(posts(fetchMock)).toEqual([JSON.stringify({ through: UPDATES.updates[0]!.created_at })]))
-    expect(screen.queryByTestId('unread-dot')).not.toBeInTheDocument()
-    // Home is read again once the mark is saved, and the server says
-    // nothing is unread: the dot does not come back.
-    await waitFor(() => expect(homeReads(fetchMock)).toBe(2))
-    fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' })
-    expect(await screen.findByRole('button', { name: 'Recent updates' })).toBeInTheDocument()
-    expect(screen.queryByTestId('unread-dot')).not.toBeInTheDocument()
-  })
-
-  it('reads the updates afresh on each opening, so one stored since the last opening is listed and marked seen', async () => {
-    // The server holds the stored events, newest first, and says Home is
-    // unread while the newest is after the time marked seen.
-    const stored = [...UPDATES.updates]
-    let seenThrough = ''
-    const fetchMock = stubServer({
-      [`GET ${HOME_PATH}`]: () => jsonResponse(200, { ...HOME, recentUpdates: { unread: stored[0]!.created_at > seenThrough } }),
-      [`GET ${UPDATES_PATH}`]: () => jsonResponse(200, { updates: stored }),
-      [`POST ${UPDATES_SEEN_PATH}`]: (init) => {
-        seenThrough = (JSON.parse(String(init?.body)) as { through: string }).through
-        return new Response(null, { status: 204 })
-      },
-    })
-    const queryClient = await renderHome()
-    await rows(await openSheet())
-    await waitFor(() => expect(posts(fetchMock)).toHaveLength(1))
-    await waitFor(() => expect(homeReads(fetchMock)).toBe(2))
-    fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' })
-
-    // A new event is stored a moment later, well within the query client's
-    // staleTime, and Home is read again, as on coming back to it.
-    const reminder = {
-      type: 'day_of_reminder',
-      title: 'Tacos tonight',
-      body: 'Dinner at 6:00.',
-      url: '/plan',
-      created_at: new Date().toISOString(),
-    }
-    stored.unshift(reminder)
-    await queryClient.invalidateQueries({ queryKey: HOME_KEY })
-    expect(await screen.findByTestId('unread-dot')).toBeInTheDocument()
-
-    const listed = await rows(await openSheet())
-    expect(listed).toHaveLength(4)
-    expect(listed[0]).toHaveTextContent('Tacos tonight')
-    await waitFor(() =>
-      expect(posts(fetchMock)).toEqual([
-        JSON.stringify({ through: UPDATES.updates[0]!.created_at }),
-        JSON.stringify({ through: reminder.created_at }),
-      ]),
-    )
-    await waitFor(() => expect(homeReads(fetchMock)).toBe(4))
-    expect(screen.queryByTestId('unread-dot')).not.toBeInTheDocument()
-  })
-
-  it('on an immediate reopen waits for that opening’s read, and marks the newer event seen, not the list held from before', async () => {
-    const stored = [...UPDATES.updates]
-    let reads = 0
-    let answer: (() => void) | undefined
-    const fetchMock = stubServer({
-      [`GET ${UPDATES_PATH}`]: () => {
-        const body = { updates: [...stored] }
-        reads++
-        // Every reading after the first is held until the test answers it.
-        if (reads === 1) return jsonResponse(200, body)
-        return new Promise<Response>((resolve) => (answer = () => resolve(jsonResponse(200, body))))
-      },
-    })
-    await renderHome()
-    await rows(await openSheet())
-    await waitFor(() => expect(posts(fetchMock)).toHaveLength(1))
-
-    // Closed and opened again at once, before any cache-collection timer
-    // could run, with a new event stored in between.
-    fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' })
-    const reminder = {
-      type: 'day_of_reminder',
-      title: 'Tacos tonight',
-      body: 'Dinner at 6:00.',
-      url: '/plan',
-      created_at: new Date().toISOString(),
-    }
-    stored.unshift(reminder)
-    fireEvent.click(screen.getByRole('button', { name: /^Recent updates/ }))
-    const sheet = screen.getByRole('dialog', { name: 'Recent updates' })
-
-    // The list held from the first opening is neither shown nor marked
-    // seen while this opening's read is in flight.
-    await waitFor(() => expect(updatesReads(fetchMock)).toBe(2))
-    expect(within(sheet).getByLabelText('Updates loading')).toBeInTheDocument()
-    expect(within(sheet).queryByRole('list')).not.toBeInTheDocument()
-    expect(posts(fetchMock)).toHaveLength(1)
-
-    answer!()
-    const listed = await rows(sheet)
-    expect(listed).toHaveLength(4)
-    expect(listed[0]).toHaveTextContent('Tacos tonight')
-    await waitFor(() =>
-      expect(posts(fetchMock)).toEqual([
-        JSON.stringify({ through: UPDATES.updates[0]!.created_at }),
-        JSON.stringify({ through: reminder.created_at }),
-      ]),
-    )
-  })
-
-  it('closing the sheet while its first read is in flight cancels that read, and a reopen reads afresh', async () => {
-    const stored = [...UPDATES.updates]
-    let firstAborted = false
-    let answerFirst: (() => void) | undefined
-    let reads = 0
-    const fetchMock = stubServer({
-      [`GET ${UPDATES_PATH}`]: (init) => {
-        const body = { updates: [...stored] }
-        reads++
-        if (reads > 1) return jsonResponse(200, body)
-        // The first reading is held open, and fails as fetch does if it is
-        // aborted.
-        return new Promise<Response>((resolve, reject) => {
-          answerFirst = () => resolve(jsonResponse(200, body))
-          init?.signal?.addEventListener('abort', () => {
-            firstAborted = true
-            reject(init.signal!.reason as Error)
-          })
-        })
-      },
-    })
-    await renderHome()
-    await openSheet()
-    await waitFor(() => expect(updatesReads(fetchMock)).toBe(1))
-
-    // Closed before the first read answers, a new event stored, and opened
-    // again at once.
-    fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' })
-    const reminder = {
-      type: 'day_of_reminder',
-      title: 'Tacos tonight',
-      body: 'Dinner at 6:00.',
-      url: '/plan',
-      created_at: new Date().toISOString(),
-    }
-    stored.unshift(reminder)
-    fireEvent.click(screen.getByRole('button', { name: /^Recent updates/ }))
-    const sheet = screen.getByRole('dialog', { name: 'Recent updates' })
-
-    // The first read was cancelled, and the reopen sent its own.
-    await waitFor(() => expect(updatesReads(fetchMock)).toBe(2))
-    expect(firstAborted).toBe(true)
-    // Answering the cancelled read changes nothing.
-    answerFirst!()
-
-    const listed = await rows(sheet)
-    expect(listed).toHaveLength(4)
-    expect(listed[0]).toHaveTextContent('Tacos tonight')
-    await waitFor(() => expect(posts(fetchMock)).toEqual([JSON.stringify({ through: reminder.created_at })]))
-  })
-
-  it.each([
-    [0, '/plan?week=2026-10-12'],
-    [1, '/discover'],
-    [2, '/plan/shopping?week=2026-10-05'],
-  ])('row %i goes to %s and closes the sheet', async (i, to) => {
-    stubServer()
-    await renderHome()
-    const listed = await rows(await openSheet())
-
-    fireEvent.click(within(listed[i]!).getByRole('button'))
-    expect(await screen.findByTestId('where')).toHaveTextContent(to)
-    expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
-  })
-
-  it('says there are no updates yet, and marks nothing seen', async () => {
-    const fetchMock = stubServer({ [`GET ${UPDATES_PATH}`]: () => jsonResponse(200, { updates: [] }) })
-    await renderHome()
-    const sheet = await openSheet()
-
-    expect(await within(sheet).findByText(/No updates yet/)).toBeInTheDocument()
-    expect(within(sheet).queryByRole('list')).not.toBeInTheDocument()
-    expect(posts(fetchMock)).toEqual([])
-  })
-
-  it('puts the dot back and says so when marking the updates seen fails', async () => {
-    let refuse!: (response: Response) => void
-    const fetchMock = stubServer({
-      [`POST ${UPDATES_SEEN_PATH}`]: () => new Promise<Response>((resolve) => (refuse = resolve)),
-    })
-    await renderHome()
-    const sheet = await openSheet()
-
-    await waitFor(() => expect(posts(fetchMock)).toHaveLength(1))
-    // Cleared at once, while the mark is in flight.
-    expect(screen.queryByTestId('unread-dot')).not.toBeInTheDocument()
-
-    refuse(errorResponse(500, 'internal'))
-    expect(await within(sheet).findByRole('alert')).toHaveTextContent(
-      "Couldn't mark your updates as seen. internal message",
-    )
-    expect(screen.getByTestId('unread-dot')).toBeInTheDocument()
-    // The updates are still listed.
-    expect(within(sheet).getByRole('list', { name: 'Recent updates' })).toBeInTheDocument()
-  })
-
-  it('reports updates it cannot load, with Retry', async () => {
-    let fail = true
-    stubServer({ [`GET ${UPDATES_PATH}`]: () => (fail ? errorResponse(500, 'internal') : jsonResponse(200, UPDATES)) })
-    await renderHome()
-    const sheet = await openSheet()
-
-    expect(await within(sheet).findByRole('alert')).toHaveTextContent("Couldn't load your updates. internal message")
-    fail = false
-    fireEvent.click(within(sheet).getByRole('button', { name: 'Retry' }))
-    expect(await within(sheet).findByRole('list', { name: 'Recent updates' })).toBeInTheDocument()
-  })
-
-  it('reports an update that would open another site rather than listing it', async () => {
-    const fetchMock = stubServer({
-      [`GET ${UPDATES_PATH}`]: () => jsonResponse(200, { updates: [{ ...UPDATES.updates[0], url: '//evil.example/plan' }] }),
-    })
-    await renderHome()
-    const sheet = await openSheet()
-
-    expect(await within(sheet).findByRole('alert')).toHaveTextContent(
-      'update url "//evil.example/plan" is not a path on this app',
-    )
-    expect(within(sheet).queryByRole('list')).not.toBeInTheDocument()
-    expect(posts(fetchMock)).toEqual([])
-  })
-})

web/src/home/UpdatesSheet.tsx

@@ -1,117 +0,0 @@
-import { CalendarDays, ChefHat, Compass, Repeat, ShoppingCart, type LucideIcon } from 'lucide-react'
-import { useEffect, useId, useState } from 'react'
-import { useNavigate } from 'react-router'
-import { ago } from '../plan/PlanPage.tsx'
-import { ErrorBanner } from '../ui/ErrorBanner.tsx'
-import { Icon } from '../ui/Icon.tsx'
-import { ListRow } from '../ui/ListRow.tsx'
-import { Sheet } from '../ui/Sheet.tsx'
-import { Skeleton } from '../ui/Skeleton.tsx'
-import { useMarkUpdatesSeen, useUpdates, type Update, type UpdateType } from './api.ts'
-import styles from './UpdatesSheet.module.css'
-
-const ICONS: Record<UpdateType, LucideIcon> = {
-  plan_ready: CalendarDays,
-  list_ready: ShoppingCart,
-  day_of_reminder: ChefHat,
-  new_suggestions: Compass,
-  rotation_review: Repeat,
-}
-
-// UpdateRow is one update: its icon, title and body, and how long ago it
-// came. A tap opens its url.
-function UpdateRow({ update, now, onOpen }: { update: Update; now: Date; onOpen: (url: string) => void }) {
-  return (
-    <li>
-      <ListRow
-        leading={<Icon icon={ICONS[update.type]} className={styles.icon} />}
-        title={update.title}
-        meta={update.body === '' ? undefined : update.body}
-        trailing={
-          <time dateTime={update.created_at} className={styles.time}>
-            {ago(new Date(update.created_at), now)}
-          </time>
-        }
-        onClick={() => onOpen(update.url)}
-      />
-    </li>
-  )
-}
-
-// Updates lists the Recent updates, newest first, and marks them seen
-// through the newest once they are shown, so the bell's dot clears.
-function Updates({ onOpen }: { onOpen: (url: string) => void }) {
-  const updates = useUpdates()
-  const markSeen = useMarkUpdatesSeen()
-  const { mutate } = markSeen
-  // fresh says this opening's read has come back; until then a list still
-  // held from an earlier opening is neither shown nor marked seen.
-  const fresh = updates.isSuccess && updates.isFetchedAfterMount
-  const newest = fresh ? updates.data[0]?.created_at : undefined
-  // The instant the relative times count from, fixed while the sheet is
-  // open.
-  const [now] = useState(() => new Date())
-
-  useEffect(() => {
-    if (newest !== undefined) mutate(newest)
-  }, [newest, mutate])
-
-  if (updates.isError) {
-    return (
-      <ErrorBanner onRetry={() => void updates.refetch()}>Couldn't load your updates. {updates.error.message}</ErrorBanner>
-    )
-  }
-  if (!fresh) {
-    return (
-      <div aria-busy="true" aria-label="Updates loading" className={styles.rows}>
-        {Array.from({ length: 3 }, (_, i) => (
-          <Skeleton key={i} className={styles.skeletonRow} />
-        ))}
-      </div>
-    )
-  }
-  if (updates.data.length === 0) {
-    return <p className={styles.empty}>No updates yet. Plans, Supply runs and new Side quests show up here.</p>
-  }
-  return (
-    <>
-      {markSeen.isError && newest !== undefined && (
-        <ErrorBanner onRetry={() => mutate(newest)}>
-          Couldn't mark your updates as seen. {markSeen.error.message}
-        </ErrorBanner>
-      )}
-      <ul aria-label="Recent updates" className={styles.rows}>
-        {updates.data.map((update, i) => (
-          <UpdateRow key={`${i} ${update.created_at}`} update={update} now={now} onOpen={onOpen} />
-        ))}
-      </ul>
-    </>
-  )
-}
-
-export type UpdatesSheetProps = {
-  open: boolean
-  onClose: () => void
-}
-
-// UpdatesSheet is the Recent updates sheet the Home bell opens: the last
-// ten notification events with how long ago each came, each opening the
-// screen it is about. Opening it marks them seen.
-export function UpdatesSheet({ open, onClose }: UpdatesSheetProps) {
-  const titleId = useId()
-  const navigate = useNavigate()
-  const openUpdate = (url: string) => {
-    onClose()
-    void navigate(url)
-  }
-  return (
-    <Sheet open={open} onClose={onClose} aria-labelledby={titleId}>
-      <div className={styles.sheet}>
-        <h2 id={titleId} className={styles.title}>
-          Recent updates
-        </h2>
-        <Updates onOpen={openUpdate} />
-      </div>
-    </Sheet>
-  )
-}

web/src/home/api.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { HOME } from '../test/ApiProviders.tsx'
-import { parseHome, parseUpdates } from './api.ts'
-
-const origin = 'https://mealquest.example'
-const where = 'GET /api/v1/updates'
-
-// body is a GET /api/v1/updates body holding one update that opens url.
-function body(url: string) {
-  return {
-    updates: [{ type: 'plan_ready', title: 'Your week is drafted', body: '', url, created_at: '2026-10-10T16:00:00.000Z' }],
-  }
-}
-
-describe('parseUpdates', () => {
-  it('keeps a same-origin path with its query and fragment, as parsed', () => {
-    expect(parseUpdates(where, body('/plan/shopping?week=2026-10-05#tuesday'), origin)[0]!.url).toBe(
-      '/plan/shopping?week=2026-10-05#tuesday',
-    )
-    expect(parseUpdates(where, body('/plan/../discover'), origin)[0]!.url).toBe('/discover')
-  })
-
-  // Each of these would open another site, or run script, once parsed: URL
-  // parsing strips tabs and newlines and reads a backslash as a slash.
-  it.each([
-    ['a tab', '/\t/evil.example/x'],
-    ['a newline', '/\n/evil.example/x'],
-    ['a carriage return', '/\r/evil.example/x'],
-    ['a backslash', '/\\evil.example/x'],
-    ['dot segments', '/..//evil.example/x'],
-    ['a protocol-relative URL', '//evil.example/x'],
-    ['an absolute URL', 'https://evil.example/x'],
-    ['javascript:', 'javascript:alert(1)'],
-    ['a relative path', 'plan'],
-  ])('refuses an update url with %s', (_, url) => {
-    expect(() => parseUpdates(where, body(url), origin)).toThrow(
-      `${where}: update url ${JSON.stringify(url)} is not a path on this app`,
-    )
-  })
-})
-
-describe('parseHome', () => {
-  it("keeps the household's zone, and refuses one that is not an IANA zone", () => {
-    expect(parseHome('GET /api/v1/home', HOME).timezone).toBe('America/New_York')
-    expect(() => parseHome('GET /api/v1/home', { ...HOME, timezone: 'Mars/Olympus' })).toThrow(
-      'GET /api/v1/home: timezone "Mars/Olympus" is not an IANA zone',
-    )
-    expect(() => parseHome('GET /api/v1/home', { ...HOME, timezone: undefined })).toThrow(
-      'GET /api/v1/home: timezone undefined is not an IANA zone',
-    )
-  })
-})

web/src/home/api.ts

@@ -1,16 +1,11 @@
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
-import { useEffect } from 'react'
+import { useQuery } from '@tanstack/react-query'
 import { useApi } from '../api/index.ts'
 import { isRecord } from '../api/errors.ts'
 import { oneOf, photoId } from '../dinners/api.ts'
-import { untilLocalMidnight, weekLabel } from '../plan/week.ts'
-import { appPath } from '../push/notification.ts'
+import { weekLabel } from '../plan/week.ts'
 
 export const HOME_PATH = '/api/v1/home'
 export const HOME_KEY = ['home'] as const
-export const UPDATES_PATH = '/api/v1/updates'
-export const UPDATES_SEEN_PATH = '/api/v1/updates/seen'
-export const UPDATES_KEY = ['updates'] as const
 
 export const ORIGINS = ['regular', 'side_quest'] as const
 export type Origin = (typeof ORIGINS)[number]
@@ -28,13 +23,11 @@ export type Tonight = { id: string; name: string; photo_id: string | undefined;
 export type ShoppingListStatus = { weekStart: string; dates: string; ready: boolean }
 
 // Home is GET /api/v1/home: dateLabel is today, household-local, "Friday,
-// Oct 2"; timezone is the household's IANA zone, whose midnight starts the
-// next day; tonight is null when today has no plan; sideQuestCount is how
+// Oct 2"; tonight is null when today has no plan; sideQuestCount is how
 // many Side quests wait in the deck; unread says the Recent updates hold
 // something not yet seen.
 export type Home = {
   dateLabel: string
-  timezone: string
   tonight: Tonight | null
   sideQuestCount: number
   shoppingList: ShoppingListStatus
@@ -80,9 +73,6 @@ function parseShoppingList(where: string, list: unknown): ShoppingListStatus {
 // parseHome checks a GET /api/v1/home body.
 export function parseHome(where: string, body: unknown): Home {
   if (!isRecord(body) || typeof body.dateLabel !== 'string') throw new Error(`${where}: response is not the home`)
-  if (typeof body.timezone !== 'string' || !isZone(body.timezone)) {
-    throw new Error(`${where}: timezone ${JSON.stringify(body.timezone)} is not an IANA zone`)
-  }
   if (!Number.isInteger(body.sideQuestCount) || (body.sideQuestCount as number) < 0) {
     throw new Error(`${where}: sideQuestCount is not a count`)
   }
@@ -90,7 +80,6 @@ export function parseHome(where: string, body: unknown): Home {
   if (!isRecord(updates) || typeof updates.unread !== 'boolean') throw new Error(`${where}: recentUpdates has no unread flag`)
   return {
     dateLabel: body.dateLabel,
-    timezone: body.timezone,
     tonight: parseTonight(where, body.tonight),
     sideQuestCount: body.sideQuestCount as number,
     shoppingList: parseShoppingList(where, body.shoppingList),
@@ -98,133 +87,11 @@ export function parseHome(where: string, body: unknown): Home {
   }
 }
 
-// isZone says whether zone is an IANA zone this browser knows.
-function isZone(zone: string): boolean {
-  try {
-    new Intl.DateTimeFormat('en-US', { timeZone: zone })
-    return true
-  } catch {
-    return false
-  }
-}
-
-// useHome is the Home screen's summary (GET /api/v1/home). Home is read
-// again at the household's next local midnight, counted from each read, so
-// a Home left open does not keep yesterday's date and dinner.
+// useHome is the Home screen's summary (GET /api/v1/home).
 export function useHome() {
   const { apiFetch } = useApi()
-  const queryClient = useQueryClient()
-  const home = useQuery({
+  return useQuery({
     queryKey: HOME_KEY,
     queryFn: async () => parseHome(`GET ${HOME_PATH}`, await apiFetch<unknown>(HOME_PATH)),
   })
-  const zone = home.data?.timezone
-  const readAt = home.dataUpdatedAt
-  useEffect(() => {
-    if (zone === undefined) return
-    const timer = setTimeout(
-      () => void queryClient.invalidateQueries({ queryKey: HOME_KEY }),
-      untilLocalMidnight(zone, new Date()),
-    )
-    return () => clearTimeout(timer)
-  }, [queryClient, zone, readAt])
-  return home
-}
-
-export const UPDATE_TYPES = ['plan_ready', 'list_ready', 'day_of_reminder', 'new_suggestions', 'rotation_review'] as const
-export type UpdateType = (typeof UPDATE_TYPES)[number]
-
-// Update is one of the Recent updates: a notification event, whatever
-// channels it went to. url is the same-origin path it opens; created_at is
-// when it was stored, the UTC RFC 3339 instant POST /api/v1/updates/seen
-// takes back.
-export type Update = { type: UpdateType; title: string; body: string; url: string; created_at: string }
-
-// parseUpdate checks one update. Its url must stay on origin once parsed, as
-// the server only ever stores a path on the app's own origin; url is that
-// path as parsed.
-function parseUpdate(where: string, body: unknown, origin: string): Update {
-  if (
-    !isRecord(body) ||
-    typeof body.title !== 'string' ||
-    typeof body.body !== 'string' ||
-    typeof body.url !== 'string' ||
-    typeof body.created_at !== 'string'
-  ) {
-    throw new Error(`${where}: an update is not a notification event`)
-  }
-  const url = appPath(body.url, origin)
-  if (url === null) throw new Error(`${where}: update url ${JSON.stringify(body.url)} is not a path on this app`)
-  if (Number.isNaN(Date.parse(body.created_at))) {
-    throw new Error(`${where}: update created_at "${body.created_at}" is not a time`)
-  }
-  return {
-    type: oneOf(where, 'type', UPDATE_TYPES, body.type),
-    title: body.title,
-    body: body.body,
-    url,
-    created_at: body.created_at,
-  }
-}
-
-// parseUpdates checks a GET /api/v1/updates body, from the app at origin:
-// the updates, newest first.
-export function parseUpdates(where: string, body: unknown, origin: string): Update[] {
-  if (!isRecord(body) || !Array.isArray(body.updates)) throw new Error(`${where}: response is not the updates`)
-  return body.updates.map((update) => parseUpdate(where, update, origin))
-}
-
-// useUpdates is the Recent updates (GET /api/v1/updates): the last ten
-// notification events, newest first. Each opening of the sheet reads it
-// afresh (refetchOnMount 'always'), whatever the query client still holds;
-// the sheet shows, and marks seen, only the list that opening read. Closing
-// the sheet aborts a read still in flight, so a reopen sends its own rather
-// than adopt one sent before it.
-export function useUpdates() {
-  const { apiFetch } = useApi()
-  return useQuery({
-    queryKey: UPDATES_KEY,
-    queryFn: async ({ signal }) =>
-      parseUpdates(`GET ${UPDATES_PATH}`, await apiFetch<unknown>(UPDATES_PATH, { signal }), window.location.origin),
-    refetchOnMount: 'always',
-  })
-}
-
-const MARK_SEEN_KEY = ['updates', 'seen'] as const
-
-// useMarkUpdatesSeen records that the household has seen its updates
-// through the created_at of the newest one shown (POST
-// /api/v1/updates/seen). The bell's unread dot clears at once, and a Home
-// read in flight is stopped so it cannot bring it back; if the server
-// refuses, the dot is put back as it was before the first of the marks in
-// flight. Once the last mark in flight settles Home is read again, so the
-// dot shows only for an event stored since.
-export function useMarkUpdatesSeen() {
-  const { apiFetch } = useApi()
-  const queryClient = useQueryClient()
-  // alone says whether this is the only mark in flight; each counts itself
-  // until it has settled.
-  const alone = () => queryClient.isMutating({ mutationKey: MARK_SEEN_KEY }) === 1
-  return useMutation({
-    mutationKey: MARK_SEEN_KEY,
-    mutationFn: async (through: string) => {
-      await apiFetch<unknown>(UPDATES_SEEN_PATH, { method: 'POST', body: { through } })
-    },
-    onMutate: async () => {
-      // A mark sent while another is in flight would snapshot that one's
-      // optimistic answer, so only the first snapshots.
-      const unread = alone() ? queryClient.getQueryData<Home>(HOME_KEY)?.unread : undefined
-      await queryClient.cancelQueries({ queryKey: HOME_KEY })
-      queryClient.setQueryData<Home>(HOME_KEY, (home) => home && { ...home, unread: false })
-      return { unread }
-    },
-    onError: (_error, _through, context) => {
-      if (context?.unread === undefined || !alone()) return
-      const { unread } = context
-      queryClient.setQueryData<Home>(HOME_KEY, (home) => home && { ...home, unread })
-    },
-    onSettled: () => {
-      if (alone()) void queryClient.invalidateQueries({ queryKey: HOME_KEY })
-    },
-  })
 }

web/src/home/rotation.ts

@@ -1,107 +0,0 @@
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
-import { useEffect } from 'react'
-import { useApi } from '../api/index.ts'
-import { isRecord } from '../api/errors.ts'
-import { photoId } from '../dinners/api.ts'
-import { isNotificationOpened } from '../push/notification.ts'
-
-export const ROTATION_REVIEWS_PATH = '/api/v1/rotation-reviews'
-export const ROTATION_REVIEWS_KEY = ['rotation-reviews'] as const
-const DINNERS_KEY = ['dinners'] as const
-
-// rotationReviewPath is where the household answers "Keep it in rotation?"
-// for a tried dinner.
-export function rotationReviewPath(dinnerId: string): string {
-  return `/api/v1/dinners/${encodeURIComponent(dinnerId)}/rotation-review`
-}
-
-// Rotation check answers: keep makes the tried dinner a Regular, drop ("Not
-// for us") archives it so it is never suggested again, and not_made ("We
-// didn't make it") returns it to the Quest log. Keep is the only way a tried
-// dinner becomes a Regular; nothing decides one automatically.
-export const DECISIONS = ['keep', 'drop', 'not_made'] as const
-export type Decision = (typeof DECISIONS)[number]
-
-// RotationReview is a pending Rotation check: the dinner tried, photo_id its
-// stored photo's id, and the household-local plan date, YYYY-MM-DD, it was
-// planned on.
-export type RotationReview = { dinner: { id: string; name: string; photo_id: string | undefined }; plan_date: string }
-
-function parseReview(where: string, body: unknown): RotationReview {
-  if (!isRecord(body) || typeof body.plan_date !== 'string') throw new Error(`${where}: a review is not a Rotation check`)
-  const dinner = body.dinner
-  if (!isRecord(dinner) || typeof dinner.id !== 'string' || typeof dinner.name !== 'string') {
-    throw new Error(`${where}: a Rotation check has no dinner`)
-  }
-  return { dinner: { id: dinner.id, name: dinner.name, photo_id: photoId(where, dinner.photo) }, plan_date: body.plan_date }
-}
-
-// parseRotationReviews checks a GET /api/v1/rotation-reviews body: the
-// pending Rotation checks, oldest plan date first.
-export function parseRotationReviews(where: string, body: unknown): RotationReview[] {
-  if (!isRecord(body) || !Array.isArray(body.reviews)) throw new Error(`${where}: response is not the Rotation checks`)
-  return body.reviews.map((review) => parseReview(where, review))
-}
-
-// useRotationReviews is the pending Rotation checks (GET
-// /api/v1/rotation-reviews), oldest plan date first. Each mount of Home
-// reads them afresh, and so does a notification tap that focuses Home
-// already open (the service worker's NotificationOpened), so Home opened
-// from a rotation_review notification shows the check it is about.
-export function useRotationReviews() {
-  const { apiFetch } = useApi()
-  const query = useQuery({
-    queryKey: ROTATION_REVIEWS_KEY,
-    queryFn: async () =>
-      parseRotationReviews(`GET ${ROTATION_REVIEWS_PATH}`, await apiFetch<unknown>(ROTATION_REVIEWS_PATH)),
-    refetchOnMount: 'always',
-  })
-  const { refetch } = query
-  useEffect(() => {
-    // Without a service worker there are no notifications to tap.
-    if (!('serviceWorker' in navigator)) return
-    const container = navigator.serviceWorker
-    const onMessage = (event: MessageEvent<unknown>) => {
-      if (isNotificationOpened(event.data)) void refetch()
-    }
-    container.addEventListener('message', onMessage)
-    return () => container.removeEventListener('message', onMessage)
-  }, [refetch])
-  return query
-}
-
-// useDecideRotationReview answers "Keep it in rotation?" for a pending
-// Rotation check (POST /api/v1/dinners/{id}/rotation-review). The answer
-// must be that dinner, decided that way.
-//
-// Home leaves the check out while its answer is pending (the mutation's
-// variables say which), so the next one shows at once; a read in flight is
-// stopped so it cannot bring the check back meanwhile. Once saved, the check
-// leaves the cached list; once failed, it is shown again as the list has it.
-// Either way the Rotation checks and the dinners lists (the Regulars and the
-// Quest log the answer moved it to) are read again.
-export function useDecideRotationReview() {
-  const { apiFetch } = useApi()
-  const queryClient = useQueryClient()
-  return useMutation<void, Error, { review: RotationReview; decision: Decision }>({
-    mutationFn: async ({ review, decision }) => {
-      const path = rotationReviewPath(review.dinner.id)
-      const body = await apiFetch<unknown>(path, { method: 'POST', body: { decision } })
-      if (!isRecord(body) || !isRecord(body.dinner) || body.dinner.id !== review.dinner.id || body.decision !== decision) {
-        throw new Error(`POST ${path}: response is not the Rotation check decided ${decision}`)
-      }
-    },
-    onMutate: async () => {
-      await queryClient.cancelQueries({ queryKey: ROTATION_REVIEWS_KEY })
-    },
-    onSuccess: (_data, { review }) => {
-      queryClient.setQueryData<RotationReview[]>(ROTATION_REVIEWS_KEY, (reviews) =>
-        reviews?.filter((r) => r.dinner.id !== review.dinner.id),
-      )
-    },
-    onSettled: () => {
-      void queryClient.invalidateQueries({ queryKey: ROTATION_REVIEWS_KEY })
-      void queryClient.invalidateQueries({ queryKey: DINNERS_KEY })
-    },
-  })
-}