Fail sqlc-check when git status itself fails

An erroring git status printed nothing, which the drift check read as a
clean tree and passed.

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

cmd/server/main.go

@@ -158,7 +158,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, sched.Wake, cfg.PublicURL, logger)
 	if err != nil {
 		return err
 	}

docs/ARCHITECTURE.md

@@ -216,17 +216,16 @@ automatic** (D-021).
   empty (`[]`) with no recipe, as for a dinner whose grounding is
   `pending` or `failed`; a recipe entered by hand has only `raw_text`.
   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, 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
+  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
@@ -263,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
@@ -1122,10 +1120,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
@@ -1148,12 +1143,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

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/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"`
@@ -183,39 +183,42 @@ func readRecipe(ctx context.Context, q *db.Queries, recipeID string, d *Detail)
 }
 
 // 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

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

@@ -304,9 +304,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 +367,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

internal/dinners/grounding_test.go

@@ -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_test.go

@@ -94,7 +94,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, func() {}, pub, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -222,44 +222,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)
 	}
 }
 

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/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)
 	}

internal/plan/plan.go

@@ -149,19 +149,16 @@ type Service struct {
 	// 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:
+// committed change to a plan's days, 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) {
+func NewService(st *store.Store, draft Drafter, runner *jobs.Runner, cal Calendar, notifier *notify.Service, wake func(), publicURL *url.URL, logger *slog.Logger) (*Service, error) {
 	switch {
 	case st == nil:
 		return nil, errors.New("plan: nil store")
@@ -177,12 +174,10 @@ func NewService(st *store.Store, draft Drafter, runner *jobs.Runner, cal Calenda
 		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, wake: wake, logger: logger, publicURL: publicURL}
 	kind, err := jobs.Register(runner, KindDraftWeek, s.runDraft, Reasons...)
 	if err != nil {
 		return nil, err
@@ -506,7 +501,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), func() {}, publicURL, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

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/plan_draft_test.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"log/slog"
 	"net/url"
-	"slices"
 	"strings"
 	"sync"
 	"testing"
@@ -86,21 +85,7 @@ func (c noCalendar) PushEvents(context.Context, []gcal.Event, func() error) erro
 // 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()
-	})
+	return e.newPlans(ids, func() {})
 }
 
 // wakingPlans is plans whose changes wake the scheduler, as in the server.
@@ -108,12 +93,11 @@ func (e *env) scheduledPlans(ids map[string]string) *planEnv {
 // 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)
+	return e.newPlans(ids, e.wake)
 }
 
-// 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 {
+// newPlans is plans whose service calls wake after a plan change.
+func (e *env) newPlans(ids map[string]string, wake func()) *planEnv {
 	e.t.Helper()
 	p := &planEnv{e: e, model: &llm.Fake{}, ids: ids, logs: &syncBuffer{}}
 	guard, err := harness.NewGuard(harness.DefaultMaxCalls)
@@ -134,7 +118,7 @@ func (e *env) newPlans(ids map[string]string, wake func(), now func() time.Time)
 	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)
+	p.svc, err = plan.NewService(e.st, drafter, runner, noCalendar{e.t}, notifytest.New(e.t, e.st), wake, publicURL, logger)
 	if err != nil {
 		e.t.Fatal(err)
 	}
@@ -251,41 +235,6 @@ func (e *env) planReady() []string {
 	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}
@@ -308,7 +257,7 @@ func mustLocalDate(s string) store.LocalDate {
 // by its Monday once.
 func TestPlanDraftDraftsNextWeek(t *testing.T) {
 	e := newEnv(t)
-	p := e.scheduledPlans(e.pool())
+	p := e.plans(e.pool())
 	p.reply(w43)
 	p.reply(w44)
 
@@ -322,7 +271,6 @@ func TestPlanDraftDraftsNextWeek(t *testing.T) {
 	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)
@@ -335,7 +283,6 @@ func TestPlanDraftDraftsNextWeek(t *testing.T) {
 	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"})
 }
 
@@ -344,25 +291,23 @@ func TestPlanDraftDraftsNextWeek(t *testing.T) {
 // notifies no one and says so.
 func TestPlanDraftLeavesAnExistingPlan(t *testing.T) {
 	e := newEnv(t)
-	p := e.scheduledPlans(e.pool())
+	p := e.plans(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 := e.start(at(2026, 10, 16, 8, 0), p.svc.DraftSchedule())
 	r.runUntil(at(2026, 10, 16, 9, 0))
 	wantDrafts(t, "with a plan", e.drafts(), succeeded)
 	wantKeys(t, "plan_ready with a plan", e.planReady(), []string{"plan_ready:2026-10-19"})
-	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 {
@@ -382,25 +327,23 @@ func TestPlanDraftLeavesAnExistingPlan(t *testing.T) {
 func TestPlanDraftNoDuplicateAfterRestart(t *testing.T) {
 	e := newEnv(t)
 	ids := e.pool()
-	p := e.scheduledPlans(ids)
+	p := e.plans(ids)
 	p.reply(w43)
 	r := e.start(at(2026, 10, 16, 8, 0), p.svc.DraftSchedule())
 	r.runUntil(at(2026, 10, 16, 9, 0))
 	wantDrafts(t, "first process", e.drafts(), succeeded)
-	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 := e.plans(ids)
 	p2.reply(w43)
 	r2 := e.start(at(2026, 10, 16, 10, 0), p2.svc.DraftSchedule())
 	r2.runUntil(at(2026, 10, 23, 8, 59))
 	wantDrafts(t, "after restart", e.drafts(), succeeded)
 	wantKeys(t, "plans after restart", e.weekPlans(), []string{"2026-10-19"})
 	wantKeys(t, "plan_ready after restart", e.planReady(), []string{"plan_ready:2026-10-19"})
-	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"})
 }
 
@@ -411,7 +354,7 @@ func TestPlanDraftNoDuplicateAfterRestart(t *testing.T) {
 func TestPlanDraftAIFailureEmitsNothing(t *testing.T) {
 	e := newEnv(t)
 	ids := e.pool()
-	p := e.scheduledPlans(ids)
+	p := e.plans(ids)
 	p.model.QueueGenerate(llm.GenerateResult{Err: errors.New("provider down")})
 
 	r := e.start(at(2026, 10, 16, 8, 0), p.svc.DraftSchedule())
@@ -419,7 +362,6 @@ func TestPlanDraftAIFailureEmitsNothing(t *testing.T) {
 	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
@@ -435,12 +377,11 @@ func TestPlanDraftAIFailureEmitsNothing(t *testing.T) {
 
 	r.stop()
 	p.stop()
-	p2 := e.scheduledPlans(ids)
+	p2 := e.plans(ids)
 	p2.reply(w43)
 	e.start(at(2026, 10, 16, 10, 0), p2.svc.DraftSchedule())
 	wantDrafts(t, "after restart", e.drafts(), aiFailed)
 	wantKeys(t, "plan_ready after restart", e.planReady(), nil)
-	wantReady(t, "plan_ready rows after restart", e.planReadyRows())
 }
 
 // TestPlanDraftFollowsSettingsWithoutRestart: a plan_draft_dow and
@@ -449,7 +390,7 @@ func TestPlanDraftAIFailureEmitsNothing(t *testing.T) {
 // week.
 func TestPlanDraftFollowsSettingsWithoutRestart(t *testing.T) {
 	e := newEnv(t)
-	p := e.scheduledPlans(e.pool())
+	p := e.plans(e.pool())
 	p.reply(w43)
 
 	r := e.start(at(2026, 10, 12, 12, 0), p.svc.DraftSchedule()) // Monday
@@ -460,7 +401,6 @@ func TestPlanDraftFollowsSettingsWithoutRestart(t *testing.T) {
 	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))

internal/scheduler/scheduler.go

@@ -378,11 +378,6 @@ 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 {

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
@@ -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

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/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/ideaactions_test.go

@@ -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), func() {}, &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, func() {}, pub, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

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"
@@ -241,7 +240,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), func() {}, &url.URL{Scheme: "https", Host: "mealquest.example"}, logger)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -304,7 +303,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, func() {}, 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})
 	}
 }
 

internal/server/shopping_test.go

@@ -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

internal/shopping/title_test.go

@@ -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,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,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,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,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,84 +922,3 @@ func TestMigrateShoppingListChatSendUnconfirmed(t *testing.T) {
 		t.Errorf("shopping list after 0017 = %s, want %s", got, want)
 	}
 }
-
-// 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/suggest/suggest_test.go

@@ -1157,7 +1157,7 @@ func TestLaterBatchNeverResuggestsRenamedDrop(t *testing.T) {
 	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), func() {}, &url.URL{Scheme: "https", Host: "meals.example.com"}, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

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';

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/plan/PlanPage.test.tsx

@@ -1392,64 +1392,6 @@ describe('PlanPage', () => {
       expect(within(tile('FRI')).getByText('Pizza night')).toBeInTheDocument()
     })
 
-    it("still shows a swap's failure on coming back to the week, through another, and asks for the swap again only on Retry", async () => {
-      const fetchMock = stubServer({
-        [`GET ${THIS_WEEK}`]: () => jsonResponse(200, planBody('draft')),
-        [`GET ${NEXT_WEEK}`]: () => errorResponse(404, 'not_found'),
-        [`GET /api/v1/plans/2026-10-19`]: () => errorResponse(404, 'not_found'),
-        ...lists,
-        [`PUT ${FRIDAY}`]: () => errorResponse(409, 'dinner_not_plannable'),
-      })
-      await renderPage()
-
-      fireEvent.click(await within(await openFriday()).findByRole('button', { name: /Lemon orzo/ }))
-      expect(await screen.findByRole('alert')).toHaveTextContent("Couldn't swap Friday's dinner. dinner_not_plannable message")
-      fireEvent.click(screen.getByRole('button', { name: 'Next week' }))
-      expect(await screen.findByRole('button', { name: 'Draft this week' })).toBeInTheDocument()
-      fireEvent.click(screen.getByRole('button', { name: 'Next week' }))
-      await waitFor(() => expect(screen.getByTestId('search')).toHaveTextContent('?week=2026-10-19'))
-      expect(await screen.findByRole('button', { name: 'Draft this week' })).toBeInTheDocument()
-      fireEvent.click(screen.getByRole('button', { name: 'Previous week' }))
-      await waitFor(() => expect(screen.getByTestId('search')).toHaveTextContent('?week=2026-10-12'))
-      fireEvent.click(screen.getByRole('button', { name: 'Previous week' }))
-
-      expect(await screen.findByRole('alert')).toHaveTextContent("Couldn't swap Friday's dinner. dinner_not_plannable message")
-      expect(within(tile('FRI')).getByText('Pizza night')).toBeInTheDocument()
-      expect(puts(fetchMock)).toHaveLength(1)
-    })
-
-    it('reads the plan again when the dinner is already on another day, and offers to choose another rather than send it again', async () => {
-      // Meanwhile lemon orzo was planned on Wednesday.
-      let read = planBody('draft')
-      const fetchMock = stubServer({
-        [`GET ${THIS_WEEK}`]: () => jsonResponse(200, read),
-        ...lists,
-        [`PUT ${FRIDAY}`]: () => errorResponse(409, 'dinner_already_planned'),
-      })
-      await renderPage()
-
-      const sheet = await openFriday()
-      read = planBody('draft')
-      read.days[2] = { ...read.days[2]!, dinner: { ...read.days[2]!.dinner, id: 'q1', name: 'Lemon orzo' }, is_new: true }
-      fireEvent.click(await within(sheet).findByRole('button', { name: /Lemon orzo/ }))
-
-      const alert = await screen.findByRole('alert')
-      expect(alert).toHaveTextContent("Couldn't swap Friday's dinner. Lemon orzo is already on another day this week.")
-      expect(within(alert).queryByRole('button', { name: 'Retry' })).not.toBeInTheDocument()
-      await waitFor(() => expect(within(tile('WED · NEW')).getByText('Lemon orzo')).toBeInTheDocument())
-      expect(within(tile('FRI')).getByText('Pizza night')).toBeInTheDocument()
-
-      // Choosing again opens Friday's sheet on the plan read, where lemon
-      // orzo is already this week; nothing is sent again.
-      fireEvent.click(within(alert).getByRole('button', { name: 'Choose another dinner' }))
-      const again = screen.getByRole('dialog', { name: 'Swap Friday' })
-      expect(screen.queryByRole('alert')).not.toBeInTheDocument()
-      const orzo = within(within(again).getByRole('list', { name: 'Quest log' })).getByRole('listitem')
-      expect(within(orzo).getByText('Already this week')).toBeInTheDocument()
-      expect(within(orzo).queryByRole('button')).not.toBeInTheDocument()
-      expect(puts(fetchMock)).toHaveLength(1)
-    })
-
     it('waits for a pending swap before Rebuild week, keeping its failure', async () => {
       let refuse!: () => void
       const fetchMock = stubServer({

web/src/plan/PlanPage.tsx

@@ -127,12 +127,6 @@ export function ago(at: Date, now: Date): string {
   return days === 1 ? '1 day ago' : `${days} days ago`
 }
 
-// alreadyPlanned says whether a swap was refused because its dinner is
-// already on another day of the week: sending it again cannot succeed.
-function alreadyPlanned(error: Error): boolean {
-  return error instanceof ApiError && error.code === 'dinner_already_planned'
-}
-
 // pushedToCalendar says whether drafting over a plan of this status needs
 // confirm: it was pushed to Calendar.
 function pushedToCalendar(status: PlanStatus): boolean {
@@ -404,18 +398,9 @@ function WeekBoard({
       </ErrorBanner>
     )
   ) : swap.failed !== null ? (
-    alreadyPlanned(swap.failed.error) ? (
-      // The plan is read again (useSwapDay): the household chooses another
-      // dinner from it rather than sending the refused swap again.
-      <ErrorBanner onRetry={() => openSwap(swap.failed!.swap.date)} retryLabel="Choose another dinner">
-        Couldn't swap {weekdayName(swap.failed.swap.date)}'s dinner. {swap.failed.swap.dinner.name} is already on another day
-        this week.
-      </ErrorBanner>
-    ) : (
-      <ErrorBanner onRetry={() => swapIn(swap.failed!.swap)}>
-        Couldn't swap {weekdayName(swap.failed.swap.date)}'s dinner. {swap.failed.error.message}
-      </ErrorBanner>
-    )
+    <ErrorBanner onRetry={() => swapIn(swap.failed!.swap)}>
+      Couldn't swap {weekdayName(swap.failed.swap.date)}'s dinner. {swap.failed.error.message}
+    </ErrorBanner>
   ) : startDraft.isError ? (
     <ErrorBanner onRetry={rebuild}>Couldn't start drafting this week. {startDraft.error.message}</ErrorBanner>
   ) : result.error !== null ? (

web/src/plan/api.test.tsx

@@ -127,17 +127,6 @@ describe('usePlan', () => {
     ['a method it does not know', (body: ReturnType<typeof planBody>) => (body.days[0]!.dinner.method = 'microwave'), 'method "microwave"'],
     ['no method', (body: ReturnType<typeof planBody>) => Reflect.deleteProperty(body.days[0]!.dinner, 'method'), 'method undefined'],
     ['a sync time that is no instant', (body: ReturnType<typeof planBody>) => (body.calendar_synced_at = 'yesterday'), 'calendar_synced_at "yesterday"'],
-    // Date reads both, in this device's zone: neither says which instant.
-    [
-      'a sync time with no offset',
-      (body: ReturnType<typeof planBody>) => (body.calendar_synced_at = '2026-10-07T15:58:00'),
-      'calendar_synced_at "2026-10-07T15:58:00" is not an instant',
-    ],
-    [
-      'a sync date with no time',
-      (body: ReturnType<typeof planBody>) => (body.calendar_synced_at = '2026-10-07'),
-      'calendar_synced_at "2026-10-07" is not an instant',
-    ],
   ])('refuses a plan with %s', async (_, change, said) => {
     const body = planBody()
     change(body)
@@ -219,72 +208,6 @@ describe('useSwapDay', () => {
     expect(result.current.swap.failed?.error.message).toBe('dinner_not_plannable message')
   })
 
-  it('leaves a day a later plan read landed, the very day the swap wrote, when the swap of it fails', async () => {
-    const friday = deferred()
-    let read = planBody()
-    stubServer({
-      [`GET ${PLAN}`]: () => jsonResponse(200, read),
-      [`PUT ${FRIDAY}`]: () => friday.reply,
-    })
-    const { result, plan, queryClient } = await renderSwaps()
-
-    // The read finds Friday lemon orzo, field for field the day the swap
-    // wrote: the server has it, whatever this swap's PUT is answered with.
-    const swapped = { date: '2026-10-09', dinner: ORZO.dinner, is_new: true, start_by: null }
-    act(() => result.current.swap.mutate(ORZO))
-    await waitFor(() => expect(plan().days[4]).toEqual(swapped))
-    read = planBody({ 4: { id: 'q1', name: 'Lemon orzo', is_new: true } })
-    await act(() => result.current.plan.refetch())
-    await act(async () => friday.send(errorResponse(500, 'internal')))
-
-    await waitFor(() => expect(queryClient.isMutating()).toBe(0))
-    expect(plan().days[4]).toEqual(swapped)
-    expect(result.current.swap.failed?.error.message).toBe('internal message')
-  })
-
-  it('puts the day back when the swap of it fails with no plan read since, after a later swap of another day', async () => {
-    const friday = deferred()
-    const monday = deferred()
-    stubServer({
-      [`GET ${PLAN}`]: () => jsonResponse(200, planBody()),
-      [`PUT ${FRIDAY}`]: () => friday.reply,
-      [`PUT ${MONDAY}`]: () => monday.reply,
-    })
-    const { result, plan, queryClient } = await renderSwaps()
-
-    act(() => result.current.swap.mutate(ORZO))
-    act(() => result.current.swap.mutate(FISH))
-    await waitFor(() => expect(plan().days[0]!.dinner.name).toBe('Fish tacos'))
-    await act(async () => friday.send(errorResponse(500, 'internal')))
-
-    await waitFor(() => expect(plan().days[4]!.dinner.name).toBe('Dinner 4'))
-    expect(plan().days[0]!.dinner.name).toBe('Fish tacos')
-    await act(async () => monday.send(errorResponse(500, 'internal')))
-    await waitFor(() => expect(queryClient.isMutating()).toBe(0))
-    expect(plan().days.map((day) => day.dinner.name)).toEqual(planBody().days.map((day) => day.dinner.name))
-  })
-
-  it('reads the plan again when the dinner is already on another day of the week, and sends the swap only once', async () => {
-    let read = planBody()
-    stubServer({
-      [`GET ${PLAN}`]: () => jsonResponse(200, read),
-      [`PUT ${FRIDAY}`]: () => errorResponse(409, 'dinner_already_planned'),
-    })
-    const { result, plan, queryClient } = await renderSwaps()
-
-    // Meanwhile lemon orzo was planned on Wednesday.
-    read = planBody({ 2: { id: 'q1', name: 'Lemon orzo', is_new: true } })
-    act(() => result.current.swap.mutate(ORZO))
-
-    await waitFor(() => expect(plan().days[2]!.dinner.name).toBe('Lemon orzo'))
-    expect(plan().days[4]!.dinner.name).toBe('Dinner 4')
-    await waitFor(() => expect(queryClient.isMutating()).toBe(0))
-    expect(result.current.swap.failed?.error.message).toBe('dinner_already_planned message')
-    const sent = vi.mocked(fetch).mock.calls.map(([input, init]) => `${init?.method ?? 'GET'} ${String(input)}`)
-    expect(sent.filter((call) => call === `PUT ${FRIDAY}`)).toHaveLength(1)
-    expect(sent.filter((call) => call === `GET ${PLAN}`)).toHaveLength(2)
-  })
-
   it('refuses to dismiss a pending swap', async () => {
     const friday = deferred()
     stubServer({ [`GET ${PLAN}`]: () => jsonResponse(200, planBody()), [`PUT ${FRIDAY}`]: () => friday.reply })
@@ -430,61 +353,6 @@ describe('week mutations', () => {
     expect(weekMutations(queryClient, LATER)).toEqual([])
   })
 
-  it("leaves behind a week's settled swaps but for the failure that speaks for it, which stays until its week leaves it behind", async () => {
-    let refuse = true
-    stubServer({
-      [`GET ${PLAN}`]: () => jsonResponse(200, planBody()),
-      [`PUT ${FRIDAY}`]: () => (refuse ? errorResponse(409, 'dinner_not_plannable') : jsonResponse(200, planBody())),
-      [`PUT ${MONDAY}`]: () => jsonResponse(200, planBody({ 0: { id: 'r1', name: 'Fish tacos' } })),
-      [`GET /api/v1/plans/${NEXT}`]: () => errorResponse(404, 'not_found'),
-      [`GET /api/v1/plans/${LATER}`]: () => errorResponse(404, 'not_found'),
-    })
-    const api = createApiClient(fakeLocation('/plan'), createNetworkStatus(window), createVerifiedSession(localStorage))
-    await api.loadMe()
-    const queryClient = createQueryClient()
-    const wrapper = ({ children }: { children: ReactNode }) => (
-      <ApiProvider client={api}>
-        <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-      </ApiProvider>
-    )
-    const hook = renderHook(({ week }) => ({ plan: usePlan(week), swap: useSwapDay(week) }), {
-      wrapper,
-      initialProps: { week: WEEK },
-    })
-    await waitFor(() => expect(hook.result.current.plan.isSuccess).toBe(true))
-
-    // Two swaps settle while the week is shown: the earlier is needed for
-    // ordering no longer, and only the latest stays.
-    act(() => hook.result.current.swap.mutate(FISH))
-    act(() => hook.result.current.swap.mutate(ORZO))
-    await waitFor(() => expect(weekMutations(queryClient, WEEK)).toEqual(['swap error']))
-
-    // Leaving the week, through two others, keeps the failure alone.
-    for (const week of [NEXT, LATER, NEXT]) {
-      hook.rerender({ week })
-      await waitFor(() => expect(hook.result.current.plan.isSuccess).toBe(true))
-      expect(weekMutations(queryClient, WEEK)).toEqual(['swap error'])
-    }
-
-    // Coming back shows it; it fails again, and again one stays.
-    hook.rerender({ week: WEEK })
-    expect(hook.result.current.swap.failed?.error.message).toBe('dinner_not_plannable message')
-    act(() => hook.result.current.swap.dismiss())
-    act(() => hook.result.current.swap.mutate(ORZO))
-    await waitFor(() => expect(hook.result.current.swap.failed).not.toBeNull())
-    expect(weekMutations(queryClient, WEEK)).toEqual(['swap error'])
-
-    // A swap that succeeds is left behind once the week is.
-    refuse = false
-    act(() => hook.result.current.swap.dismiss())
-    act(() => hook.result.current.swap.mutate(ORZO))
-    await waitFor(() => expect(hook.result.current.swap.succeeded).not.toBeNull())
-    expect(weekMutations(queryClient, WEEK)).toEqual(['swap success'])
-    hook.rerender({ week: NEXT })
-    await waitFor(() => expect(hook.result.current.plan.isSuccess).toBe(true))
-    expect(weekMutations(queryClient, WEEK)).toEqual([])
-  })
-
   it('keeps a push whose Supply run was not made, settled in a week no longer shown, to be shown on coming back', async () => {
     const nextPush = deferred()
     stubServer({

web/src/plan/api.ts

@@ -1,14 +1,5 @@
 import { useEffect } from 'react'
-import {
-  useMutation,
-  useMutationState,
-  useQuery,
-  useQueryClient,
-  type Mutation,
-  type Query,
-  type QueryClient,
-  type QueryKey,
-} from '@tanstack/react-query'
+import { useMutation, useMutationState, useQuery, useQueryClient, type Mutation, type QueryClient } from '@tanstack/react-query'
 import { ApiError, useApi, type ApiRead } from '../api/index.ts'
 import { isRecord } from '../api/errors.ts'
 import { METHODS, oneOf, photoId, type Method } from '../dinners/api.ts'
@@ -92,16 +83,10 @@ function parseDay(where: string, body: unknown): PlanDay {
   return { date: body.date, dinner, is_new: body.is_new, start_by: body.start_by }
 }
 
-// RFC3339 is an RFC 3339 instant as the server writes it: a full date and
-// time, to the second or finer, and its offset, Z or ±hh:mm. A date alone,
-// or a time with no offset, which Date would read in this device's zone, is
-// not one.
-const RFC3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/
-
 // syncedAt reads calendar_synced_at, an RFC 3339 instant or null.
 function syncedAt(where: string, value: unknown): Date | null {
   if (value === null) return null
-  const at = typeof value === 'string' && RFC3339.test(value) ? new Date(value) : null
+  const at = typeof value === 'string' ? new Date(value) : null
   if (at === null || Number.isNaN(at.getTime())) {
     throw new Error(`${where}: calendar_synced_at ${JSON.stringify(value)} is not an instant`)
   }
@@ -279,54 +264,38 @@ const weeksShown = new WeakMap<QueryClient, WeeksShown>()
 // time a week is shown, and is never removed, so a swap or push that settles
 // after its Draft board, or the whole Plan, is gone is still collected.
 //
-// A swap or push pending is kept, with every other of its kind and week:
-// an earlier pending one must see those sent after it, across leaving its
-// week and coming back. Once none of a kind and week is pending, only the
-// latest is needed, and the rest are removed, whenever a week is shown or
-// one settles. The latest itself stays while its week is shown. In a week
-// not shown it is removed, unless:
-//
-//   - it is a failed swap: it stays, whatever is shown, until the week's
-//     board leaves it behind (useWeekSwap, Rebuild week, Push to Calendar),
-//     so coming back to the week shows the failure;
-//   - it is a push whose Supply run was not made: the week has no shopping
-//     list until one is made, which settles the push, or a push sent since
-//     replaces it, and making it may still be under way when the week is
-//     left;
-//   - it is a failed push that settled after its week was left: it stays
-//     until a week is next shown, so coming straight back shows it.
-//
-// So once none of its kind is pending, a week keeps at most one settled
-// swap and one settled push, and a week left keeps none but those above:
-// settled swaps and pushes never accumulate.
+// When a week is shown, the settled ones of every other week are removed,
+// unless that week still has one pending: a pending one, and those an
+// earlier pending one must see, stay across leaving its week and coming
+// back. When one settles, the same is done, except that a week's latest,
+// when it failed, stays until a week is next shown, so that coming straight
+// back to it shows the failure. A week's latest push whose Supply run was
+// not made stays whatever is shown: the week has no shopping list until one
+// is made, which settles the push, or a push sent since replaces it, and
+// making it may still be under way when the week is left. The cache holds
+// at most the weeks shown's, those of weeks left pending, one push of each
+// week whose Supply run was not made, and one failure of each week whose
+// last pending one settled since a week was last shown.
 function keepWeekMutations(queryClient: QueryClient): WeeksShown {
   const kept = weeksShown.get(queryClient)
   if (kept !== undefined) return kept
   const mutations = queryClient.getMutationCache()
   // How many times each week is shown at once.
   const shown = new Map<string, number>()
-  // keep says whether the latest of its kind and week, none of which is
-  // pending, stays; settled says a mutation settling swept, not a week
-  // shown.
-  function keep(mutation: Mutation, of: { kind: 'swap' | 'push'; week: string }, settled: boolean): boolean {
-    if (shown.has(of.week)) return true
-    if (of.kind === 'swap') return failed(mutation)
-    return unmade(mutation) || (settled && failed(mutation))
-  }
   function sweep(settled: boolean) {
-    // The mutations of each kind of each week, in the order sent.
-    const sent = new Map<string, { of: { kind: 'swap' | 'push'; week: string }; week: Mutation[] }>()
+    // The mutations of each kind of each week not shown, in the order sent.
+    const left = new Map<string, Mutation[]>()
     for (const mutation of mutations.getAll()) {
       const of = weekMutation(mutation)
-      if (of === null) continue
+      if (of === null || shown.has(of.week)) continue
       const id = `${of.kind} ${of.week}`
-      sent.set(id, { of, week: [...(sent.get(id)?.week ?? []), mutation] })
+      left.set(id, [...(left.get(id) ?? []), mutation])
     }
-    for (const { of, week } of sent.values()) {
+    for (const week of left.values()) {
       if (week.some((mutation) => mutation.state.status === 'pending')) continue
       const latest = week.at(-1)
       for (const mutation of week) {
-        if (mutation === latest && keep(mutation, of, settled)) continue
+        if (mutation === latest && (unmade(mutation) || (settled && failed(mutation)))) continue
         mutations.remove(mutation)
       }
     }
@@ -355,30 +324,6 @@ function useWeekShown(weekStart: string) {
   useEffect(() => keepWeekMutations(queryClient).show(weekStart), [queryClient, weekStart])
 }
 
-// swapWrites counts, for each plan query, its updates that were a swap's
-// own optimistic write or rollback, not a plan read from the server.
-const swapWrites = new WeakMap<Query, number>()
-
-// serverReads is how many plans read from the server have landed in the
-// plan query: its updates, less the swaps' own writes. A plan read lands
-// whether or not it differs from the plan shown.
-function serverReads(query: Query): number {
-  return query.state.dataUpdateCount - (swapWrites.get(query) ?? 0)
-}
-
-// writeSwap updates the plan query as a swap's own write, which serverReads
-// does not count.
-function writeSwap(queryClient: QueryClient, query: Query, update: (plan: Plan | null | undefined) => Plan | null | undefined) {
-  const before = query.state.dataUpdateCount
-  queryClient.setQueryData<Plan | null>(query.queryKey, update)
-  swapWrites.set(query, (swapWrites.get(query) ?? 0) + query.state.dataUpdateCount - before)
-}
-
-// planQuery is the plan query keyed key, if the query cache has it.
-function planQuery(queryClient: QueryClient, key: QueryKey): Query | undefined {
-  return queryClient.getQueryCache().find({ queryKey: key, exact: true })
-}
-
 // swapKey keys the swaps of the week starting on weekStart in the mutation
 // cache, where they outlive the Draft board that sent them.
 function swapKey(weekStart: string) {
@@ -400,13 +345,9 @@ export type SwapDay = {
 // (PUT /api/v1/plans/{weekStart}/days/{date}). The day shows the dinner at
 // once, NEW when it came from the Quest log, with no start-by time until the
 // server answers with the plan as swapped, which then replaces it. A refused
-// swap puts the day back as it was, unless it has changed again meanwhile:
-// another swap wrote over it, or any plan read from the server landed
-// since, even one with the very day the swap wrote. A swap refused because
-// the dinner is already on another day of the week (409
-// dinner_already_planned) reads the plan again, so the household chooses
-// again from the plan as it is. However the swap ends, the Quest log is
-// read again: the server leaves a dinner on the plan out of it.
+// swap puts the day back as it was, unless it has changed again meanwhile.
+// However the swap ends, the Quest log is read again: the server leaves a
+// dinner on the plan out of it.
 //
 // The week's swaps live in the mutation cache, not in the component, so
 // leaving the week and coming back keeps them: pending and failed are read
@@ -433,7 +374,7 @@ export function useSwapDay(weekStart: string): SwapDay {
   function mutate(chosen: Swap) {
     // isLatest says whether no swap of the week was sent after this one.
     const isLatest = () => mutations.findAll({ mutationKey }).every((other) => other.mutationId <= mutation.mutationId)
-    const mutation = mutations.build<Plan, Error, Swap, { previous: PlanDay; swapped: PlanDay; query: Query; reads: number }>(queryClient, {
+    const mutation = mutations.build<Plan, Error, Swap, { previous: PlanDay; swapped: PlanDay }>(queryClient, {
       mutationKey,
       // Kept until dismissed or settled in a week not shown
       // (keepWeekMutations): a later swap must stay in the cache while an
@@ -446,32 +387,24 @@ export function useSwapDay(weekStart: string): SwapDay {
       },
       onMutate: async ({ date, dinner, fromQuestLog }) => {
         await queryClient.cancelQueries({ queryKey: key })
-        const query = planQuery(queryClient, key)
-        const plan = query?.state.data as Plan | null | undefined
+        const plan = queryClient.getQueryData<Plan | null>(key)
         const previous = plan?.days.find((day) => day.date === date)
-        if (query === undefined || !plan || previous === undefined) {
-          throw new Error(`The week of ${weekStart} has no plan day ${date} to swap.`)
-        }
+        if (!plan || previous === undefined) throw new Error(`The week of ${weekStart} has no plan day ${date} to swap.`)
         const swapped: PlanDay = { date, dinner, is_new: fromQuestLog, start_by: null }
-        writeSwap(queryClient, query, () => ({ ...plan, days: plan.days.map((day) => (day.date === date ? swapped : day)) }))
-        return { previous, swapped, query, reads: serverReads(query) }
+        queryClient.setQueryData<Plan>(key, { ...plan, days: plan.days.map((day) => (day.date === date ? swapped : day)) })
+        return { previous, swapped }
       },
       onSuccess: (plan) => {
         if (isLatest()) queryClient.setQueryData<Plan>(key, plan)
       },
       // The day goes back only while it is still, field for field, the day
-      // this swap wrote, and no plan read from the server has landed since
-      // (serverReads): a later swap that replaced it, or a read that did,
-      // even with the same day, is left alone.
-      onError: (error, _swap, context) => {
-        if (context !== undefined && planQuery(queryClient, key) === context.query && serverReads(context.query) === context.reads) {
-          writeSwap(queryClient, context.query, (plan) =>
-            plan && { ...plan, days: plan.days.map((day) => (sameDay(day, context.swapped) ? context.previous : day)) },
-          )
-        }
-        if (error instanceof ApiError && error.code === 'dinner_already_planned') {
-          void queryClient.invalidateQueries({ queryKey: key })
-        }
+      // this swap wrote: a later swap or plan read that replaced it is left
+      // alone.
+      onError: (_error, _swap, context) => {
+        if (context === undefined) return
+        queryClient.setQueryData<Plan | null>(key, (plan) =>
+          plan && { ...plan, days: plan.days.map((day) => (sameDay(day, context.swapped) ? context.previous : day)) },
+        )
       },
       onSettled: () => queryClient.invalidateQueries({ queryKey: QUEST_LOG_KEY }),
     })

web/src/settings/RegularsSettingsPage.test.tsx

@@ -344,7 +344,7 @@ describe('RegularsSettingsPage', () => {
           minutes: 45,
         },
         { candidate_id: 'https://cook.test/pizza', title: 'Sheet-pan pizza', site_name: 'Cook Test', photo_url: null, minutes: null },
-        { candidate_id: 'https://food.test/p', title: 'Pizza margherita', site_name: null, photo_url: null, minutes: 30 },
+        { candidate_id: 'https://food.test/p', title: 'Pizza margherita', site_name: 'Food Test', photo_url: null, minutes: 30 },
       ],
     }
 
@@ -372,7 +372,7 @@ describe('RegularsSettingsPage', () => {
       expect(options.map((option) => option.getAttribute('aria-label'))).toEqual([
         'Use Weeknight pizza from Example Kitchen',
         'Use Sheet-pan pizza from Cook Test',
-        'Use Pizza margherita',
+        'Use Pizza margherita from Food Test',
       ])
       expect(within(options[0]!).getByRole('img', { name: 'Weeknight pizza' })).toHaveAttribute('src', '/media/photos/p7-400.jpg')
       expect(within(options[0]!).getByText('Example Kitchen')).toBeInTheDocument()

web/src/settings/RegularsSettingsPage.tsx

@@ -80,10 +80,7 @@ export function RegularsSettingsPage() {
 // Which sheet is open, for which Regular.
 type Open = { sheet: 'edit' | 'fix'; id: string } | null
 
-// RegularsManager lists, adds, edits and fixes the recipes of the
-// household's Regulars: this page's body, and the Settings "Regular
-// dinners" sub-tab at tablet and desktop widths.
-export function RegularsManager() {
+function RegularsManager() {
   const regulars = useRegulars()
   const add = useAddRegular()
   const remove = useRemoveRegular()
@@ -527,13 +524,13 @@ function PickCandidate({ id, onPick }: { id: string; onPick: (candidateId: strin
           <button
             type="button"
             className={styles.candidate}
-            aria-label={candidate.site_name === null ? `Use ${candidate.title}` : `Use ${candidate.title} from ${candidate.site_name}`}
+            aria-label={`Use ${candidate.title} from ${candidate.site_name}`}
             onClick={() => onPick(candidate.candidate_id)}
           >
             <Photo id={candidate.photo_id} name={candidate.title} radius="14px" sizes="56px" className={styles.candidatePhoto} />
             <span className={styles.candidateBody}>
               <span className={styles.candidateTitle}>{candidate.title}</span>
-              {candidate.site_name !== null && <span className={styles.candidateSite}>{candidate.site_name}</span>}
+              <span className={styles.candidateSite}>{candidate.site_name}</span>
             </span>
           </button>
         </li>

web/src/settings/SettingsPage.test.tsx

@@ -104,10 +104,7 @@ describe('SettingsPage', () => {
     expect(await screen.findByText('America/New_York · Dinner at 5:30 pm')).toBeInTheDocument()
     expect(within(row('AI assistant')).getByText('Anthropic · Claude Sonnet')).toBeInTheDocument()
     expect(within(row('Household')).getByText('America/New_York · Dinner at 5:30 pm')).toBeInTheDocument()
-    // The rotation count and the hidden Regular dinners sub-tab both read
-    // the Regulars.
     expect(fetchMock.mock.calls.map(([input]) => String(input)).sort()).toEqual([
-      REGULARS_PATH,
       REGULARS_PATH,
       CALENDAR_PATH,
       '/api/v1/settings/ai',
@@ -120,7 +117,7 @@ describe('SettingsPage', () => {
   })
 
   it('shows the not-yet-available states while the server has no endpoint for them', async () => {
-    stubSettings({ [REGULARS_PATH]: () => errorResponse(404, 'not_found') })
+    stubSettings()
     renderSettings()
     expect(await within(row('Regular dinners')).findByText('Rotation count unavailable')).toBeInTheDocument()
     expect(

web/src/settings/SettingsTabs.module.css

@@ -101,3 +101,24 @@
   padding: 24px;
   border-radius: 30px;
 }
+
+.placeholder {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.cardTitle {
+  margin: 0;
+  font-family: var(--font-heading);
+  font-size: 22px;
+  font-weight: 400;
+}
+
+.hint {
+  margin: 0;
+  font-family: var(--font-body);
+  font-size: 14px;
+  line-height: 1.45;
+  color: var(--color-neutral-700);
+}

web/src/settings/SettingsTabs.test.tsx

@@ -11,11 +11,9 @@ import {
   HOUSEHOLD_SETTINGS,
   NOTIFICATION_SETTINGS,
   RECIPE_SEARCH_SETTINGS,
-  SETTINGS_REGULARS,
 } from '../test/ApiProviders.tsx'
 import { InDataRouter } from '../test/dataRouter.tsx'
-import { dinnerBody, type DinnerBody } from '../test/dinners.ts'
-import { fakeLocation, jsonResponse, ME } from '../test/fetchStub.ts'
+import { errorResponse, fakeLocation, jsonResponse, ME } from '../test/fetchStub.ts'
 import { expectMinHitArea } from '../test/hitArea.ts'
 import { mockViewport } from '../test/matchMedia.ts'
 import { SettingsPage } from './SettingsPage.tsx'
@@ -34,7 +32,6 @@ function stubAPI(responders: Record<string, Responder> = {}): Mock<typeof fetch>
     'GET /api/v1/settings/recipe-search': () => jsonResponse(200, RECIPE_SEARCH_SETTINGS),
     'GET /api/v1/settings/notifications': () => jsonResponse(200, NOTIFICATION_SETTINGS),
     'GET /api/v1/settings/chat-webhook': () => jsonResponse(200, CHAT_WEBHOOK),
-    'GET /api/v1/dinners?status=regular': () => jsonResponse(200, SETTINGS_REGULARS),
     ...responders,
   }
   const fetchMock = vi.fn<typeof fetch>((input, init) => {
@@ -124,7 +121,7 @@ describe.each([1440, 1180])('SettingsPage at %i px (mock 2e)', (width) => {
     expect(tab('Regular dinners')).toHaveAttribute('aria-selected', 'true')
     expect(tab('Regular dinners')).toHaveFocus()
     expect(panel('Regular dinners')).toBeVisible()
-    expect(await within(panel('Regular dinners')).findByRole('heading', { name: 'On rotation · 1' })).toBeInTheDocument()
+    expect(within(panel('Regular dinners')).getByRole('region', { name: 'Regular dinners' })).toBeInTheDocument()
     expect(panel('Household')).not.toBeVisible()
 
     fireEvent.keyDown(tab('Regular dinners'), { key: 'End' })
@@ -168,123 +165,6 @@ describe.each([1440, 1180])('SettingsPage at %i px (mock 2e)', (width) => {
   })
 })
 
-const TACOS = dinnerBody('d1', 'Beef tacos', { method: 'stovetop', minutes_total: 40, difficulty: 'easy' })
-const PIZZA = dinnerBody('d3', 'Pizza night', { grounding_status: 'failed', grounding_error: 'no_recipe_found' })
-
-// stubRegulars answers the Regulars from server.regulars, so a write's
-// responder changes what the next read sees.
-function stubRegulars(regulars: DinnerBody[], responders: (server: { regulars: DinnerBody[] }) => Record<string, Responder>) {
-  const server = { regulars }
-  const fetchMock = stubAPI({
-    'GET /api/v1/dinners?status=regular': () => jsonResponse(200, { dinners: server.regulars }),
-    ...responders(server),
-  })
-  return { server, fetchMock }
-}
-
-// writes lists the requests other than GETs, as method, path and body.
-function writes(fetchMock: Mock<typeof fetch>) {
-  return fetchMock.mock.calls
-    .filter(([, init]) => (init?.method ?? 'GET') !== 'GET')
-    .map(([input, init]) => [init?.method, String(input), init?.body])
-}
-
-// openRegulars shows the Regular dinners tab once its Regulars have loaded.
-async function openRegulars() {
-  fireEvent.click(tab('Regular dinners'))
-  const regulars = within(panel('Regular dinners'))
-  await regulars.findByRole('heading', { level: 2, name: /^On rotation/ })
-  return regulars
-}
-
-function regularRow(name: string) {
-  const item = within(screen.getByRole('list', { name: 'Regulars' }))
-    .getAllByRole('listitem')
-    .find((li) => within(li).queryByText(name) !== null)
-  if (item === undefined) throw new Error(`no Regular row named ${name}`)
-  return within(item)
-}
-
-describe.each([1440, 1180])('SettingsPage Regular dinners tab at %i px (mock 2e)', (width) => {
-  it('lists the Regulars as /settings/regulars does, under the page title rather than its own', async () => {
-    stubRegulars([TACOS, PIZZA], () => ({}))
-    await renderAt(width)
-    const regulars = await openRegulars()
-    expect(regulars.getByRole('heading', { level: 2, name: 'On rotation · 2' })).toBeInTheDocument()
-    expect(regularRow('Beef tacos').getByText('Stovetop · 40 min')).toBeInTheDocument()
-    expect(regularRow('Beef tacos').getByText('Recipe found')).toBeInTheDocument()
-    expect(regularRow('Pizza night').getByText('Needs a recipe')).toBeInTheDocument()
-    expect(regulars.getByRole('textbox', { name: 'Add a Regular' })).toBeInTheDocument()
-    expect(screen.getAllByRole('heading', { level: 1 }).map((h) => h.textContent)).toEqual(['Settings'])
-    expect(regulars.queryByRole('button', { name: 'Back to Settings' })).not.toBeInTheDocument()
-  })
-
-  it('adds a Regular by name', async () => {
-    const { fetchMock } = stubRegulars([TACOS], (server) => ({
-      'POST /api/v1/dinners': (body) => {
-        const created = dinnerBody('d9', (body as { name: string }).name, { grounding_status: 'pending' })
-        server.regulars = [...server.regulars, created]
-        return jsonResponse(201, { ...created, grounding_job_id: 'job-1' })
-      },
-    }))
-    await renderAt(width)
-    const regulars = await openRegulars()
-    fireEvent.change(regulars.getByRole('textbox', { name: 'Add a Regular' }), { target: { value: 'Chicken enchiladas' } })
-    fireEvent.click(regulars.getByRole('button', { name: 'Add Regular' }))
-
-    expect(await regulars.findByRole('heading', { level: 2, name: 'On rotation · 2' })).toBeInTheDocument()
-    expect(regularRow('Chicken enchiladas').getByText('Finding recipe…')).toBeInTheDocument()
-    expect(writes(fetchMock)).toEqual([['POST', '/api/v1/dinners', JSON.stringify({ name: 'Chicken enchiladas' })]])
-  })
-
-  it('edits a Regular in its sheet', async () => {
-    const { fetchMock } = stubRegulars([TACOS], (server) => ({
-      'PATCH /api/v1/dinners/d1': (body) => {
-        const edited = { ...TACOS, ...(body as object) }
-        server.regulars = [edited]
-        return jsonResponse(200, edited)
-      },
-    }))
-    await renderAt(width)
-    await openRegulars()
-    fireEvent.click(regularRow('Beef tacos').getByRole('button', { name: /^Beef tacos/ }))
-    const sheet = within(screen.getByRole('dialog', { name: 'Edit Beef tacos' }))
-    fireEvent.change(sheet.getByLabelText('Minutes'), { target: { value: '25' } })
-    fireEvent.click(sheet.getByRole('button', { name: 'Save changes' }))
-
-    await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
-    expect(writes(fetchMock)).toEqual([['PATCH', '/api/v1/dinners/d1', JSON.stringify({ minutes_total: 25 })]])
-    expect(await regularRow('Beef tacos').findByText('Stovetop · 25 min')).toBeInTheDocument()
-  })
-
-  it('fixes the recipe of a Regular that needs one', async () => {
-    const { fetchMock } = stubRegulars([PIZZA], (server) => ({
-      'GET /api/v1/dinners/d3/recipe-candidates': () =>
-        jsonResponse(200, {
-          candidates: [
-            { candidate_id: 'https://example.com/pizza', title: 'Weeknight pizza', site_name: 'Example Kitchen', photo_url: null, minutes: 45 },
-          ],
-        }),
-      'POST /api/v1/dinners/d3/ground': () => {
-        const fixed = { ...PIZZA, grounding_status: 'grounded', grounding_error: null }
-        server.regulars = [fixed]
-        return jsonResponse(200, fixed)
-      },
-    }))
-    await renderAt(width)
-    await openRegulars()
-    fireEvent.click(regularRow('Pizza night').getByRole('button', { name: /^Pizza night/ }))
-    const sheet = within(screen.getByRole('dialog', { name: 'Fix recipe' }))
-    fireEvent.click(await sheet.findByRole('button', { name: 'Use Weeknight pizza from Example Kitchen' }))
-
-    await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
-    expect(writes(fetchMock)).toEqual([
-      ['POST', '/api/v1/dinners/d3/ground', JSON.stringify({ candidate_id: 'https://example.com/pizza' })],
-    ])
-    expect(await regularRow('Pizza night').findByText('Recipe found')).toBeInTheDocument()
-  })
-})
-
 describe('SettingsPage reminder time across tabs', () => {
   it('shows a reminder time saved on Notifications in the Household tab, keeping its draft', async () => {
     const saved = { ...HOUSEHOLD_SETTINGS }
@@ -315,7 +195,10 @@ describe('SettingsPage reminder time across tabs', () => {
 
 describe('SettingsPage across the 768 px breakpoint', () => {
   it('shows the mobile list below 768 px and the sub-tabs from 768 px', async () => {
-    stubAPI({ 'GET /api/v1/integrations/google': () => jsonResponse(200, GOOGLE_NOT_CONNECTED) })
+    stubAPI({
+      'GET /api/v1/dinners?status=regular': () => errorResponse(404, 'not_found'),
+      'GET /api/v1/integrations/google': () => jsonResponse(200, GOOGLE_NOT_CONNECTED),
+    })
     const resize = await renderAt(767)
     expect(screen.getByRole('link', { name: /^AI assistant/ })).toHaveAttribute('href', '/settings/ai')
     expect(screen.queryByRole('tablist')).not.toBeInTheDocument()
@@ -326,7 +209,10 @@ describe('SettingsPage across the 768 px breakpoint', () => {
   })
 
   it('keeps an unsaved draft and its leave guard across 1180 px, 390 px and back', async () => {
-    stubAPI({ 'GET /api/v1/integrations/google': () => jsonResponse(200, GOOGLE_NOT_CONNECTED) })
+    stubAPI({
+      'GET /api/v1/dinners?status=regular': () => errorResponse(404, 'not_found'),
+      'GET /api/v1/integrations/google': () => jsonResponse(200, GOOGLE_NOT_CONNECTED),
+    })
     const resize = await renderAt(1180)
     fireEvent.change(await screen.findByRole('textbox', { name: 'System prompt' }), {
       target: { value: 'A draft' },

web/src/settings/SettingsTabs.tsx

@@ -1,11 +1,11 @@
 import { useId, useRef, useState, type KeyboardEvent, type ReactNode } from 'react'
 import { useBreakpoint, useOrientation } from '../shell/useBreakpoint.ts'
+import { Card } from '../ui/Card.tsx'
 import { AIAssistantCard } from './AISettingsPage.tsx'
 import { HouseholdSettingsSections } from './HouseholdSettingsPage.tsx'
 import { LeaveGuard } from './LeaveGuard.tsx'
 import { ChatWebhookCard, NotificationsCard } from './NotificationsPage.tsx'
 import { RecipeSearchCard } from './RecipeSearchCard.tsx'
-import { RegularsManager } from './RegularsSettingsPage.tsx'
 import styles from './SettingsTabs.module.css'
 
 type Tab = 'household' | 'regulars' | 'notifications-ai'
@@ -101,7 +101,13 @@ export function SettingsTabs({ hidden = false }: { hidden?: boolean }) {
 
       {panel('household', styles.single, <HouseholdSettingsSections onDirtyChange={setHouseholdDirty} />)}
 
-      {panel('regulars', styles.single, <RegularsManager />)}
+      {panel(
+        'regulars',
+        styles.single,
+        // TODO(Feature 12): embed the Regular dinners screen here once Feature
+        // 12 builds it.
+        <Placeholder title="Regular dinners">Managing the household's Regulars arrives in a later update.</Placeholder>,
+      )}
 
       {panel(
         'notifications-ai',
@@ -122,3 +128,17 @@ export function SettingsTabs({ hidden = false }: { hidden?: boolean }) {
     </div>
   )
 }
+
+// Placeholder is a neutral card holding a section's place until the feature
+// that owns it renders it.
+function Placeholder({ title, children }: { title: string; children: ReactNode }) {
+  const titleId = useId()
+  return (
+    <Card className={styles.placeholder} aria-labelledby={titleId} role="region">
+      <h2 id={titleId} className={styles.cardTitle}>
+        {title}
+      </h2>
+      <p className={styles.hint}>{children}</p>
+    </Card>
+  )
+}

web/src/test/ApiProviders.tsx

@@ -2,8 +2,7 @@ import { QueryClientProvider } from '@tanstack/react-query'
 import { useState, type ReactNode } from 'react'
 import { ApiProvider, createApiClient, createQueryClient, createVerifiedSession } from '../api/index.ts'
 import { createNetworkStatus } from '../pwa/networkStatus.ts'
-import { dinnerBody } from './dinners.ts'
-import { fakeLocation, jsonResponse } from './fetchStub.ts'
+import { errorResponse, fakeLocation, jsonResponse } from './fetchStub.ts'
 
 // AI_SETTINGS is a GET /api/v1/settings/ai body: Anthropic with a verified key.
 export const AI_SETTINGS = {
@@ -100,16 +99,12 @@ export const CHAT_WEBHOOK = {
   last_test_status: null,
 }
 
-// SETTINGS_REGULARS is a GET /api/v1/dinners?status=regular body: one
-// Regular, its recipe found.
-export const SETTINGS_REGULARS = { dinners: [dinnerBody('r1', 'Beef tacos')] }
-
 // SETTINGS_API answers the settings home's requests, for stubFetchByPath, as
-// today's server does: one Regular on rotation, and neither Google Calendar
-// nor Google Chat connected. The home's sub-tabs stay mounted on mobile, so
-// it also reads the Regulars list, the AI models and recipe search settings.
+// today's server does: the dinners endpoint does not exist yet, and neither
+// Google Calendar nor Google Chat is connected. The home's sub-tabs stay mounted on mobile, so
+// it also reads the AI models and recipe search settings.
 export const SETTINGS_API = {
-  '/api/v1/dinners?status=regular': () => jsonResponse(200, SETTINGS_REGULARS),
+  '/api/v1/dinners?status=regular': () => errorResponse(404, 'not_found'),
   '/api/v1/integrations/google': () => jsonResponse(200, GOOGLE_NOT_CONNECTED),
   '/api/v1/settings/notifications': () => jsonResponse(200, NOTIFICATION_SETTINGS),
   '/api/v1/settings/chat-webhook': () => jsonResponse(200, CHAT_WEBHOOK_NONE),