Feature 18: Cook From What I Have and Quick Dinners (#155)

Co-authored-by: orchestrator-agent <20+orchestrator-agent@code.cubecraftcreations.com>

internal/server/aisettings_test.go

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

internal/server/dinners_test.go

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

internal/server/google_test.go

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

internal/server/ideaactions_test.go

@@ -0,0 +1,416 @@
+package server
+
+import (
+	"context"
+	"database/sql"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"testing"
+	"testing/fstest"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
+)
+
+// actionsZone is the household zone of newIdeaActionsRouter.
+const actionsZone = "America/New_York"
+
+// newIdeaActionsRouter returns a started router whose ideas, dinners and
+// plan services share one store, whose household settings are seeded, so
+// an idea's actions read the job, make the dinner and swap the plan of the
+// same household. The ideas service runs both skills through the real
+// harness with the scripted model and grounds with the scripted fakes.
+func newIdeaActionsRouter(t *testing.T, model, normalize *llm.Fake, search *recipestest.Search, pages *recipestest.Pages, images *recipestest.Images) (http.Handler, *store.Store) {
+	t.Helper()
+	st := newTestStore(t)
+	if err := household.SeedSettings(t.Context(), st, actionsZone); err != nil {
+		t.Fatal(err)
+	}
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	runner, err := jobs.NewRunner(st, logger, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := recipestest.NewGrounder(t, st, t.TempDir(), search, pages, images, normalize)
+	guard, err := harness.NewGuard(harness.DefaultMaxCalls)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := harness.Config{
+		Settings:    llm.Settings{Provider: "anthropic", Model: "claude-test", Temperature: 0.7},
+		NewProvider: func(llm.Settings, string) (llm.Provider, error) { return model, nil },
+		Store:       st,
+		Guard:       guard,
+	}
+	generate := func(ctx context.Context, scope string, in skills.IdeasRequest) (skills.Ideas, error) {
+		return skills.IdeasFromIngredients(ctx, cfg, scope, in)
+	}
+	quick := func(ctx context.Context, scope string, in skills.QuickIdeasRequest) (skills.QuickIdeaList, error) {
+		return skills.QuickIdeas(ctx, cfg, scope, in)
+	}
+	ideasSvc, err := ideas.NewService(st, g, generate, quick, runner, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dinnerSvc, err := dinners.NewService(st, g, runner, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	draft := func(context.Context, string, skills.WeekRequest) (skills.Week, error) {
+		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), &url.URL{Scheme: "https", Host: "mealquest.example"}, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	h, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t),
+		dinnerSvc, newTestSuggest(t), planSvc, newTestShopping(t), newTestGoogle(t), ideasSvc, runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	startRunner(t, runner)
+	return h, st
+}
+
+// finishedIdeasJob runs an ideas from ingredients job that keeps names, in
+// order, and returns the router, store, job id and its ideas' recipe ids.
+func finishedIdeasJob(t *testing.T, names ...string) (http.Handler, *store.Store, string, []string) {
+	t.Helper()
+	model, normalize, search, pages, images := scriptIdeas(t, names, names, nil)
+	h, st := newIdeaActionsRouter(t, model, normalize, search, pages, images)
+	id := startIdeasJob(t, h)
+	job := waitJob(t, h, id)
+	if job["status"] != "succeeded" {
+		t.Fatalf("ideas job = %v", job)
+	}
+	var recipeIDs []string
+	for _, i := range job["result"].(map[string]any)["ideas"].([]any) {
+		recipeIDs = append(recipeIDs, i.(map[string]any)["recipe_id"].(string))
+	}
+	if len(recipeIDs) != len(names) {
+		t.Fatalf("ideas job kept %d ideas, want %d", len(recipeIDs), len(names))
+	}
+	return h, st, id, recipeIDs
+}
+
+func ideaPath(jobID, i, action string) string {
+	return "/api/v1/ideas/" + jobID + "/items/" + i + "/" + action
+}
+
+// dinnerCount is how many dinners the store holds, archived or not.
+func dinnerCount(t *testing.T, st *store.Store) int {
+	t.Helper()
+	var n int
+	if err := st.Reader.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM dinners`).Scan(&n); err != nil {
+		t.Fatal(err)
+	}
+	return n
+}
+
+// thisWeek is today in the household's zone and the Monday of its week.
+func thisWeek(t *testing.T) (week, today store.LocalDate) {
+	t.Helper()
+	zone, err := household.LoadZone(actionsZone)
+	if err != nil {
+		t.Fatal(err)
+	}
+	today = household.Today(time.Now(), zone)
+	return household.WeekStart(today), today
+}
+
+// planThisWeek stores a plan of this week with a Regular on every day and
+// the given status, and returns the week's Monday and today.
+func planThisWeek(t *testing.T, st *store.Store, status string) (week, today store.LocalDate) {
+	t.Helper()
+	ctx := t.Context()
+	week, today = thisWeek(t)
+	days, err := household.WeekDays(week)
+	if err != nil {
+		t.Fatal(err)
+	}
+	q := db.New(st.Writer)
+	now := store.Now().String()
+	planID := store.NewID()
+	if err := q.CreateWeekPlan(ctx, db.CreateWeekPlanParams{ID: planID, WeekStart: week.String(), CreatedAt: now, UpdatedAt: now}); err != nil {
+		t.Fatal(err)
+	}
+	for _, date := range days {
+		name := "Regular " + date.String()
+		d, err := q.CreateDinner(ctx, db.CreateDinnerParams{
+			ID: store.NewID(), Name: name, NormalizedName: harness.Normalize(name), Status: "regular", Origin: "regular",
+			GroundingStatus: "manual", CreatedAt: now, UpdatedAt: now,
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := q.PutPlanDay(ctx, db.PutPlanDayParams{ID: store.NewID(), PlanID: planID, Date: date.String(),
+			DinnerID: sql.NullString{String: d.ID, Valid: true}, CreatedAt: now, UpdatedAt: now}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if _, err := st.Writer.ExecContext(ctx, `UPDATE week_plans SET status = ? WHERE id = ?`, status, planID); err != nil {
+		t.Fatal(err)
+	}
+	return week, today
+}
+
+// planRevision is the revision of the plan of week.
+func planRevision(t *testing.T, st *store.Store, week store.LocalDate) int64 {
+	t.Helper()
+	row, err := db.New(st.Reader).GetWeekPlan(t.Context(), week.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return row.Revision
+}
+
+// Adding an idea to the Quest log makes a quest_log dinner grounded in the
+// idea's own recipe, with origin ingredients, without grounding it again;
+// asking again answers the same dinner and makes no second one.
+func TestPostIdeaQuestLogAddsGroundedDinnerOnce(t *testing.T) {
+	t.Parallel()
+	h, st, id, recipeIDs := finishedIdeasJob(t, "Chicken Fried Rice", "Rice Pudding")
+
+	rec, d := callDinners(t, h, http.MethodPost, ideaPath(id, "1", "quest-log"), "")
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("POST quest-log = %d: %s", rec.Code, rec.Body)
+	}
+	if d["name"] != "Rice Pudding" || d["status"] != "quest_log" || d["origin"] != "ingredients" ||
+		d["grounding_status"] != "grounded" || d["recipe_id"] != recipeIDs[1] || d["photo_url"] == nil ||
+		d["method"] != "stovetop" || d["minutes_total"] != 25.0 || d["updated_by"] != testSession.Subject {
+		t.Fatalf("dinner = %v, want Rice Pudding in the Quest log grounded in %s", d, recipeIDs[1])
+	}
+
+	rec, again := callDinners(t, h, http.MethodPost, ideaPath(id, "1", "quest-log"), "")
+	if rec.Code != http.StatusOK || again["id"] != d["id"] || again["status"] != "quest_log" {
+		t.Fatalf("POST quest-log again = %d %v, want 200 with dinner %v", rec.Code, again, d["id"])
+	}
+	if n := dinnerCount(t, st); n != 1 {
+		t.Fatalf("dinners = %d, want 1", n)
+	}
+	if names := listNames(t, h, "quest_log"); len(names) != 1 || names[0] != "Rice Pudding" {
+		t.Fatalf("Quest log = %q", names)
+	}
+}
+
+// A Quick dinners idea makes a dinner with origin quick.
+func TestPostIdeaQuestLogQuickOrigin(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := newQuickFakes()
+	quickRecipe(t, normalize, search, pages, images, "Chicken Fried Rice", "Chicken Fried Rice", 25)
+	quickReply(model, [3]any{"Chicken Fried Rice", "stovetop", 20})
+	h, _ := newIdeaActionsRouter(t, model, normalize, search, pages, images)
+	rec, body := callDinners(t, h, http.MethodPost, quickPath, `{"kind": "under30", "exclude": []}`)
+	if rec.Code != http.StatusAccepted {
+		t.Fatalf("POST quick = %d: %s", rec.Code, rec.Body)
+	}
+	id := body["jobId"].(string)
+	if job := waitJob(t, h, id); job["status"] != "succeeded" {
+		t.Fatalf("quick job = %v", job)
+	}
+
+	rec, d := callDinners(t, h, http.MethodPost, ideaPath(id, "0", "quest-log"), "")
+	if rec.Code != http.StatusCreated || d["name"] != "Chicken Fried Rice" || d["status"] != "quest_log" || d["origin"] != "quick" {
+		t.Fatalf("POST quest-log = %d %v, want a quick Quest log dinner", rec.Code, d)
+	}
+}
+
+// An idea repeating a dinner the household already has is that dinner, as
+// it is: a Regular stays a Regular. One awaiting the household's choice
+// is refused and nothing changes.
+func TestPostIdeaQuestLogReusesExistingDinner(t *testing.T) {
+	t.Parallel()
+	h, st, id, _ := finishedIdeasJob(t, "Chicken Fried Rice", "Rice Pudding")
+	regular := createDinner(t, h, `{"name": "chicken fried rice"}`)
+
+	rec, d := callDinners(t, h, http.MethodPost, ideaPath(id, "0", "quest-log"), "")
+	if rec.Code != http.StatusOK || d["id"] != regular || d["status"] != "regular" || d["origin"] != "regular" {
+		t.Fatalf("POST quest-log = %d %v, want 200 with Regular %s as it is", rec.Code, d, regular)
+	}
+
+	now := store.Now().String()
+	if _, err := db.New(st.Writer).CreateDinner(t.Context(), db.CreateDinnerParams{
+		ID: store.NewID(), Name: "Rice pudding", NormalizedName: harness.Normalize("Rice pudding"), Status: "suggested",
+		Origin: "side_quest", GroundingStatus: "manual", CreatedAt: now, UpdatedAt: now,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	rec, body := callDinners(t, h, http.MethodPost, ideaPath(id, "1", "quest-log"), "")
+	if rec.Code != http.StatusConflict || errorCode(body) != "duplicate_dinner" {
+		t.Fatalf("POST quest-log of a suggested Side quest = %d %v, want 409 duplicate_dinner", rec.Code, body)
+	}
+	if n := dinnerCount(t, st); n != 2 {
+		t.Fatalf("dinners = %d, want the Regular and the Side quest only", n)
+	}
+}
+
+// Cook tonight puts the idea's dinner on today of this week's plan through
+// the plan's swap: the day is new, the plan's revision rises and a synced
+// plan becomes changed. Asking again plans the same dinner.
+func TestPostIdeaCookTonightSwapsToday(t *testing.T) {
+	t.Parallel()
+	h, st, id, recipeIDs := finishedIdeasJob(t, "Chicken Fried Rice")
+	week, today := planThisWeek(t, st, plan.StatusSynced)
+	before := planRevision(t, st, week)
+
+	rec, body := callDinners(t, h, http.MethodPost, ideaPath(id, "0", "cook-tonight"), "")
+	if rec.Code != http.StatusOK {
+		t.Fatalf("POST cook-tonight = %d: %s", rec.Code, rec.Body)
+	}
+	d := body["dinner"].(map[string]any)
+	if d["name"] != "Chicken Fried Rice" || d["status"] != "quest_log" || d["origin"] != "ingredients" || d["recipe_id"] != recipeIDs[0] {
+		t.Fatalf("dinner = %v", d)
+	}
+	assertTonight := func(body map[string]any) {
+		t.Helper()
+		p := body["plan"].(map[string]any)
+		if p["week_start"] != week.String() || p["status"] != plan.StatusChanged {
+			t.Fatalf("plan = %v, want week %s changed", p, week)
+		}
+		found := false
+		for _, day := range p["days"].([]any) {
+			day := day.(map[string]any)
+			planned := day["dinner"].(map[string]any)["id"] == d["id"]
+			if day["date"] == today.String() {
+				found = true
+				if !planned || day["is_new"] != true {
+					t.Fatalf("today %s = %v, want %v new", today, day, d["id"])
+				}
+			} else if planned {
+				t.Fatalf("dinner also on %v", day["date"])
+			}
+		}
+		if !found {
+			t.Fatalf("plan has no day %s", today)
+		}
+	}
+	assertTonight(body)
+	if after := planRevision(t, st, week); after != before+1 {
+		t.Fatalf("plan revision = %d, want %d", after, before+1)
+	}
+
+	rec, body = callDinners(t, h, http.MethodPost, ideaPath(id, "0", "cook-tonight"), "")
+	if rec.Code != http.StatusOK || body["dinner"].(map[string]any)["id"] != d["id"] {
+		t.Fatalf("POST cook-tonight again = %d %v", rec.Code, body)
+	}
+	assertTonight(body)
+	if n := dinnerCount(t, st); n != 8 {
+		t.Fatalf("dinners = %d, want the seven Regulars and one idea", n)
+	}
+}
+
+// Cook tonight reuses a dinner the household already has.
+func TestPostIdeaCookTonightReusesExistingDinner(t *testing.T) {
+	t.Parallel()
+	h, st, id, _ := finishedIdeasJob(t, "Chicken Fried Rice")
+	_, today := planThisWeek(t, st, plan.StatusDraft)
+	regular := createDinner(t, h, `{"name": "Chicken fried rice"}`)
+
+	rec, body := callDinners(t, h, http.MethodPost, ideaPath(id, "0", "cook-tonight"), "")
+	if rec.Code != http.StatusOK || body["dinner"].(map[string]any)["id"] != regular {
+		t.Fatalf("POST cook-tonight = %d %v, want Regular %s", rec.Code, body, regular)
+	}
+	for _, day := range body["plan"].(map[string]any)["days"].([]any) {
+		day := day.(map[string]any)
+		if day["date"] == today.String() && (day["dinner"].(map[string]any)["id"] != regular || day["is_new"] != false) {
+			t.Fatalf("today = %v, want Regular %s", day, regular)
+		}
+	}
+}
+
+// With no plan for this week, cook tonight answers 409 no_plan and changes
+// nothing: no dinner is made and no plan is drafted or stored.
+func TestPostIdeaCookTonightWithoutPlan(t *testing.T) {
+	t.Parallel()
+	h, st, id, _ := finishedIdeasJob(t, "Chicken Fried Rice")
+
+	rec, body := callDinners(t, h, http.MethodPost, ideaPath(id, "0", "cook-tonight"), "")
+	if rec.Code != http.StatusConflict || errorCode(body) != "no_plan" {
+		t.Fatalf("POST cook-tonight = %d %v, want 409 no_plan", rec.Code, body)
+	}
+	if n := dinnerCount(t, st); n != 0 {
+		t.Fatalf("dinners = %d, want none", n)
+	}
+	var plans, drafts int
+	if err := st.Reader.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM week_plans`).Scan(&plans); err != nil {
+		t.Fatal(err)
+	}
+	if err := st.Reader.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM jobs WHERE kind = ?`, plan.KindDraftWeek).Scan(&drafts); err != nil {
+		t.Fatal(err)
+	}
+	if plans != 0 || drafts != 0 {
+		t.Fatalf("plans = %d, drafts = %d, want none", plans, drafts)
+	}
+}
+
+// An idea that is not an index of a succeeded ideas job is refused.
+func TestPostIdeaActionsRefuse(t *testing.T) {
+	t.Parallel()
+	h, st, id, _ := finishedIdeasJob(t, "Chicken Fried Rice")
+	planThisWeek(t, st, plan.StatusDraft)
+	// A Regular's grounding job is a job, but finds no ideas.
+	rec, body := callDinners(t, h, http.MethodPost, dinnersPath, `{"name": "Beef Stew"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("POST /dinners = %d: %s", rec.Code, rec.Body)
+	}
+	other := body["grounding_job_id"].(string)
+
+	for _, action := range []string{"quest-log", "cook-tonight"} {
+		for _, tc := range []struct {
+			job, i string
+			status int
+			code   string
+		}{
+			{id, "x", http.StatusBadRequest, "invalid_request"},
+			{id, "-1", http.StatusBadRequest, "invalid_request"},
+			{id, "01", http.StatusBadRequest, "invalid_request"},
+			{id, "1", http.StatusNotFound, "not_found"},
+			{"unknown", "0", http.StatusNotFound, "not_found"},
+			{other, "0", http.StatusNotFound, "not_found"},
+		} {
+			rec, body := callDinners(t, h, http.MethodPost, ideaPath(tc.job, tc.i, action), "")
+			if rec.Code != tc.status || errorCode(body) != tc.code {
+				t.Errorf("POST %s %s/%s = %d %v, want %d %s", action, tc.job, tc.i, rec.Code, body, tc.status, tc.code)
+			}
+		}
+	}
+	if n := dinnerCount(t, st); n != 8 {
+		t.Fatalf("dinners = %d, want the plan's seven Regulars and Beef Stew only", n)
+	}
+}
+
+// While the job still finds ideas, an idea is not acted on: its index may
+// still move.
+func TestPostIdeaActionsWhileJobRuns(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := scriptIdeas(t, []string{"Chicken Fried Rice"}, []string{"Chicken Fried Rice"}, nil)
+	gate := make(chan struct{})
+	search.Gates = map[string]chan struct{}{"Chicken Fried Rice": gate}
+	h, st := newIdeaActionsRouter(t, model, normalize, search, pages, images)
+	id := startIdeasJob(t, h)
+
+	for _, action := range []string{"quest-log", "cook-tonight"} {
+		rec, body := callDinners(t, h, http.MethodPost, ideaPath(id, "0", action), "")
+		if rec.Code != http.StatusConflict || errorCode(body) != "ideas_not_ready" {
+			t.Errorf("POST %s = %d %v, want 409 ideas_not_ready", action, rec.Code, body)
+		}
+	}
+	close(gate)
+	waitJob(t, h, id)
+	if n := dinnerCount(t, st); n != 0 {
+		t.Fatalf("dinners = %d, want none", n)
+	}
+}

internal/server/ideas.go

@@ -0,0 +1,224 @@
+package server
+
+import (
+	"errors"
+	"log/slog"
+	"net/http"
+	"strconv"
+
+	"github.com/go-chi/chi/v5"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
+)
+
+// maxIdeasBody bounds a POST /ideas/from-ingredients or /ideas/quick body.
+const maxIdeasBody = 16 << 10
+
+// ideasFromIngredients is the POST /ideas/from-ingredients body. Both
+// fields are required.
+type ideasFromIngredients struct {
+	Ingredients []string `json:"ingredients"`
+	QuickOnly   *bool    `json:"quick_only"`
+}
+
+// postIdeasFromIngredients starts finding ideas from the ingredients on
+// hand and answers 202 with the jobId that GET /jobs/{id} reports on,
+// without waiting for the job. An ingredient list the household must
+// correct is 400.
+func postIdeasFromIngredients(logger *slog.Logger, svc *ideas.Service) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		body, err := decodePatch[ideasFromIngredients](http.MaxBytesReader(w, r.Body, maxIdeasBody))
+		if err != nil {
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", err.Error())
+			return
+		}
+		switch {
+		case body.Ingredients == nil:
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "ingredients: required")
+			return
+		case body.QuickOnly == nil:
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "quick_only: required")
+			return
+		}
+		started, err := svc.StartFromIngredients(r.Context(), body.Ingredients, *body.QuickOnly)
+		var invalid *ideas.InvalidError
+		switch {
+		case errors.As(err, &invalid):
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", invalid.Message)
+			return
+		case err != nil:
+			logger.ErrorContext(r.Context(), "start ideas from ingredients", "error", err)
+			writeError(w, r, logger, http.StatusInternalServerError, "internal", "internal error")
+			return
+		}
+		writeJSON(w, r, logger, http.StatusAccepted, started)
+	}
+}
+
+// ideasQuick is the POST /ideas/quick body. Both fields are required:
+// exclude is [] on a first page.
+type ideasQuick struct {
+	Kind    *string  `json:"kind"`
+	Exclude []string `json:"exclude"`
+}
+
+// postIdeasQuick starts finding a page of Quick dinner ideas of a kind,
+// crockpot or under30, none named in exclude, and answers 202 with the
+// jobId that GET /jobs/{id} reports on, without waiting for the job. A
+// missing or unknown kind, or an exclude list the household must correct,
+// is 400.
+func postIdeasQuick(logger *slog.Logger, svc *ideas.Service) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		body, err := decodePatch[ideasQuick](http.MaxBytesReader(w, r.Body, maxIdeasBody))
+		if err != nil {
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", err.Error())
+			return
+		}
+		switch {
+		case body.Kind == nil:
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "kind: required")
+			return
+		case body.Exclude == nil:
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "exclude: required")
+			return
+		}
+		started, err := svc.StartQuick(r.Context(), *body.Kind, body.Exclude)
+		var invalid *ideas.InvalidError
+		switch {
+		case errors.As(err, &invalid):
+			writeError(w, r, logger, http.StatusBadRequest, "invalid_request", invalid.Message)
+			return
+		case err != nil:
+			logger.ErrorContext(r.Context(), "start quick ideas", "error", err)
+			writeError(w, r, logger, http.StatusInternalServerError, "internal", "internal error")
+			return
+		}
+		writeJSON(w, r, logger, http.StatusAccepted, started)
+	}
+}
+
+// chosenIdeaOrFail returns the idea {i} of ideas job {jobId}, or answers
+// 400 invalid_request when i is not an index (0, 1, ...), 404 not_found
+// for an idea no succeeded ideas job shows, or 409 ideas_not_ready while
+// the job is still finding ideas.
+func chosenIdeaOrFail(w http.ResponseWriter, r *http.Request, logger *slog.Logger, svc *ideas.Service) (ideas.Chosen, bool) {
+	raw := chi.URLParam(r, "i")
+	i, err := strconv.Atoi(raw)
+	if err != nil || i < 0 || strconv.Itoa(i) != raw {
+		writeError(w, r, logger, http.StatusBadRequest, "invalid_request", "i: must be an idea's index, 0 or more")
+		return ideas.Chosen{}, false
+	}
+	idea, err := svc.Idea(r.Context(), chi.URLParam(r, "jobId"), i)
+	switch {
+	case errors.Is(err, ideas.ErrIdeaNotFound):
+		writeError(w, r, logger, http.StatusNotFound, "not_found", "idea not found")
+		return ideas.Chosen{}, false
+	case errors.Is(err, ideas.ErrIdeasNotReady):
+		writeError(w, r, logger, http.StatusConflict, "ideas_not_ready", err.Error())
+		return ideas.Chosen{}, false
+	case err != nil:
+		logger.ErrorContext(r.Context(), "read idea", "error", err)
+		writeError(w, r, logger, http.StatusInternalServerError, "internal", "internal error")
+		return ideas.Chosen{}, false
+	}
+	return idea, true
+}
+
+// postIdeaQuestLog adds idea {i} of ideas job {jobId} to the Quest log,
+// recording the session's actor as updated_by, as a dinner grounded in
+// the recipe the idea was grounded in, with origin ingredients or quick.
+// It answers 201 with the dinner made, or 200 with the dinner the idea
+// repeats (see dinners.Service.AddToQuestLog), so asking again answers the
+// same dinner. A repeated dinner awaiting the household's choice is 409
+// duplicate_dinner.
+func postIdeaQuestLog(logger *slog.Logger, ideasSvc *ideas.Service, dinnerSvc *dinners.Service) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		actor, ok := actorOrFail(w, r, logger)
+		if !ok {
+			return
+		}
+		idea, ok := chosenIdeaOrFail(w, r, logger, ideasSvc)
+		if !ok {
+			return
+		}
+		d, created, err := dinnerSvc.AddToQuestLog(r.Context(), dinners.NewQuestLog(idea), actor.Subject)
+		if err != nil {
+			writeDinnerError(w, r, logger, "add idea to Quest log", err)
+			return
+		}
+		status := http.StatusOK
+		if created {
+			status = http.StatusCreated
+		}
+		writeJSON(w, r, logger, status, d)
+	}
+}
+
+// cookedTonight is the POST /ideas/{jobId}/items/{i}/cook-tonight answer:
+// the idea's dinner and the week's plan with it tonight.
+type cookedTonight struct {
+	Dinner dinners.Dinner `json:"dinner"`
+	Plan   plan.Plan      `json:"plan"`
+}
+
+// postIdeaCookTonight plans idea {i} of ideas job {jobId} tonight: today,
+// in the household's zone, of the plan of today's week. The idea's dinner
+// is added or found as postIdeaQuestLog does, then swapped onto today
+// through plan.Service.Swap, exactly as a swap on the Draft board, so the
+// plan is marked edited and a synced plan becomes changed. It answers 200
+// with the dinner and the plan as swapped; asking again plans the same
+// dinner again.
+//
+// When today's week has no plan it answers 409 no_plan and changes
+// nothing: no dinner is added and no plan is made, since a plan holds all
+// seven days; the household plans the week first. The week is always
+// today's own, so no other day is ever written. A dinner already on
+// another day of the week is 409 dinner_already_planned, after the dinner
+// is added or found.
+func postIdeaCookTonight(logger *slog.Logger, ideasSvc *ideas.Service, dinnerSvc *dinners.Service, planSvc *plan.Service) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		actor, ok := actorOrFail(w, r, logger)
+		if !ok {
+			return
+		}
+		idea, ok := chosenIdeaOrFail(w, r, logger, ideasSvc)
+		if !ok {
+			return
+		}
+		week, today, err := planSvc.Tonight(r.Context())
+		if errors.Is(err, plan.ErrNotFound) {
+			writeNoPlan(w, r, logger)
+			return
+		}
+		if err != nil {
+			writePlanError(w, r, logger, "find tonight's plan", err)
+			return
+		}
+		d, _, err := dinnerSvc.AddToQuestLog(r.Context(), dinners.NewQuestLog(idea), actor.Subject)
+		if err != nil {
+			writeDinnerError(w, r, logger, "add idea to cook tonight", err)
+			return
+		}
+		p, err := planSvc.Swap(r.Context(), week, today.String(), d.ID)
+		if errors.Is(err, plan.ErrNotFound) {
+			// Plans are never deleted, so the plan Tonight found is still
+			// there; this is said loudly rather than answered as success.
+			logger.ErrorContext(r.Context(), "plan of tonight's week gone before the swap", "week", week.String())
+			writeNoPlan(w, r, logger)
+			return
+		}
+		if err != nil {
+			writePlanError(w, r, logger, "cook idea tonight", err)
+			return
+		}
+		writeJSON(w, r, logger, http.StatusOK, cookedTonight{Dinner: d, Plan: p})
+	}
+}
+
+// writeNoPlan answers 409 no_plan: today's week has no plan to put
+// tonight's dinner on, so the household plans the week first.
+func writeNoPlan(w http.ResponseWriter, r *http.Request, logger *slog.Logger) {
+	writeError(w, r, logger, http.StatusConflict, "no_plan", "this week has no plan yet; plan this week first")
+}

internal/server/ideas_test.go

@@ -0,0 +1,350 @@
+package server
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"strings"
+	"testing"
+	"testing/fstest"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
+)
+
+const ideasPath = "/api/v1/ideas/from-ingredients"
+
+// newIdeasRouter returns a router whose ideas service runs
+// ideas_from_ingredients and quick_ideas through the real harness with the
+// scripted model and grounds with fake search, pages and images and the
+// scripted normalize, with its job runner and store, whose household
+// settings are seeded. The runner is started when start is set.
+func newIdeasRouter(t *testing.T, model, normalize *llm.Fake, search *recipestest.Search, pages *recipestest.Pages, images *recipestest.Images, start bool) (http.Handler, *jobs.Runner, *store.Store) {
+	t.Helper()
+	st := newTestStore(t)
+	if err := household.SeedSettings(t.Context(), st, "America/New_York"); err != nil {
+		t.Fatal(err)
+	}
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	runner, err := jobs.NewRunner(st, logger, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := recipestest.NewGrounder(t, st, t.TempDir(), search, pages, images, normalize)
+	guard, err := harness.NewGuard(harness.DefaultMaxCalls)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := harness.Config{
+		Settings:    llm.Settings{Provider: "anthropic", Model: "claude-test", Temperature: 0.7},
+		NewProvider: func(llm.Settings, string) (llm.Provider, error) { return model, nil },
+		Store:       st,
+		Guard:       guard,
+	}
+	generate := func(ctx context.Context, scope string, in skills.IdeasRequest) (skills.Ideas, error) {
+		return skills.IdeasFromIngredients(ctx, cfg, scope, in)
+	}
+	quick := func(ctx context.Context, scope string, in skills.QuickIdeasRequest) (skills.QuickIdeaList, error) {
+		return skills.QuickIdeas(ctx, cfg, scope, in)
+	}
+	svc, err := ideas.NewService(st, g, generate, quick, runner, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	h, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t),
+		newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), svc, runner, newTestPhotos(t), fstest.MapFS{"index.html": {Data: []byte(fixtureIndex)}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if start {
+		startRunner(t, runner)
+	}
+	return h, runner, st
+}
+
+// startRunner starts runner until the test ends.
+func startRunner(t *testing.T, runner *jobs.Runner) {
+	t.Helper()
+	ctx, cancel := context.WithCancel(context.Background())
+	if err := runner.Start(ctx); err != nil {
+		cancel()
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		cancel()
+		runner.Wait()
+	})
+}
+
+// scriptIdeas scripts ideas_from_ingredients to propose names, in order;
+// a recipe grounds those in grounds, the others ground none, and search
+// fails as fail says. It returns the router's fakes.
+func scriptIdeas(t *testing.T, names, grounds []string, fail map[string]error) (*llm.Fake, *llm.Fake, *recipestest.Search, *recipestest.Pages, *recipestest.Images) {
+	t.Helper()
+	model, normalize := &llm.Fake{}, &llm.Fake{}
+	search := &recipestest.Search{Results: map[string][]recipes.Candidate{}, Fail: fail}
+	pages := &recipestest.Pages{Bodies: map[string][]byte{}}
+	images := &recipestest.Images{JPEGs: map[string][]byte{}}
+	for i, name := range grounds {
+		page, photo := fmt.Sprintf("https://r.example/%d", i), fmt.Sprintf("https://r.example/%d.jpg", i)
+		search.Results[name] = []recipes.Candidate{{URL: page}}
+		pages.Bodies[page] = recipestest.RecipePage(name, "R Kitchen", photo, 25)
+		images.JPEGs[photo] = recipestest.JPEG(t, 400, 320, uint8(i+1))
+		normalize.QueueGenerate(recipestest.NormalizedReply("stovetop", 25))
+	}
+	list := make([]string, len(names))
+	for i, name := range names {
+		list[i] = fmt.Sprintf(`{"name":%q,"uses":["rice"],"missing":[],"est_minutes":30,"method":"stovetop","difficulty":"easy","search_query":%q}`, name, name)
+	}
+	js := `{"ideas":[` + strings.Join(list, ",") + `]}`
+	model.QueueGenerate(llm.GenerateResult{Response: llm.Response{Text: js, JSON: json.RawMessage(js)}})
+	return model, normalize, search, pages, images
+}
+
+// startIdeasJob posts a request for ideas from rice and returns the job id.
+func startIdeasJob(t *testing.T, h http.Handler) string {
+	t.Helper()
+	rec, body := callDinners(t, h, http.MethodPost, ideasPath, `{"ingredients": ["rice"], "quick_only": false}`)
+	if rec.Code != http.StatusAccepted {
+		t.Fatalf("POST = %d: %s", rec.Code, rec.Body)
+	}
+	return body["jobId"].(string)
+}
+
+// assertFailedWithoutIdeas checks that GET /jobs/{id} reports job failed
+// with code and a result showing no ideas.
+func assertFailedWithoutIdeas(t *testing.T, job map[string]any, code string) {
+	t.Helper()
+	if job["status"] != "failed" || job["error"] != code {
+		t.Fatalf("GET job = %v, want failed with %s", job, code)
+	}
+	res, _ := job["result"].(map[string]any)
+	if res == nil {
+		t.Fatalf("failed job result = %v, want one showing no ideas", job["result"])
+	}
+	if list, ok := res["ideas"].([]any); !ok || len(list) != 0 {
+		t.Fatalf("failed job ideas = %v, want none", res["ideas"])
+	}
+}
+
+// storedIdeas is how many ideas job id's stored result holds.
+func storedIdeas(t *testing.T, st *store.Store, id string) int {
+	t.Helper()
+	row, err := db.New(st.Reader).GetJob(t.Context(), id)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var res ideas.Result
+	if err := json.Unmarshal([]byte(row.Result.String), &res); err != nil {
+		t.Fatal(err)
+	}
+	return len(res.Ideas)
+}
+
+func TestPostIdeasFromIngredientsRefusesBadRequests(t *testing.T) {
+	t.Parallel()
+	h, _, _ := newIdeasRouter(t, &llm.Fake{}, &llm.Fake{}, &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, false)
+
+	for _, tc := range []struct{ body, message string }{
+		{`{"quick_only": false}`, "ingredients: required"},
+		{`{"ingredients": ["rice"]}`, "quick_only: required"},
+		{`{"ingredients": [], "quick_only": false}`, "ingredients: list at least one ingredient"},
+		{`{"ingredients": ["rice", " "], "quick_only": false}`, "ingredients: ingredient 2 is blank"},
+		{`{"ingredients": ["Rice", "rice"], "quick_only": false}`, `ingredients: ingredient 2, "rice", repeats "Rice"`},
+		{`{"ingredients": ["rice"], "quick_only": "yes"}`, "quick_only: want a JSON bool"},
+		{`{"ingredients": ["rice"], "quick_only": false, "extra": 1}`, `invalid request body: json: unknown field "extra"`},
+	} {
+		rec, body := callDinners(t, h, http.MethodPost, ideasPath, tc.body)
+		if rec.Code != http.StatusBadRequest || errorCode(body) != "invalid_request" {
+			t.Errorf("POST %s = %d %v, want 400 invalid_request", tc.body, rec.Code, body)
+			continue
+		}
+		if msg := body["error"].(map[string]any)["message"]; msg != tc.message {
+			t.Errorf("POST %s message = %q, want %q", tc.body, msg, tc.message)
+		}
+	}
+}
+
+func TestPostIdeasFromIngredientsRunsTheJob(t *testing.T) {
+	t.Parallel()
+	model, normalize := &llm.Fake{}, &llm.Fake{}
+	search := &recipestest.Search{Results: map[string][]recipes.Candidate{"chicken fried rice": {{URL: "https://r.example/fried-rice"}}}}
+	pages := &recipestest.Pages{Bodies: map[string][]byte{
+		"https://r.example/fried-rice": recipestest.RecipePage("Chicken Fried Rice", "R Kitchen", "https://r.example/fried-rice.jpg", 25),
+	}}
+	images := &recipestest.Images{JPEGs: map[string][]byte{"https://r.example/fried-rice.jpg": recipestest.JPEG(t, 400, 320, 1)}}
+	js := `{"ideas":[{"name":"Chicken Fried Rice","uses":["rice","chicken thighs","peas"],"missing":["2 eggs"],"est_minutes":25,"method":"stovetop","difficulty":"easy","search_query":"chicken fried rice"}]}`
+	model.QueueGenerate(llm.GenerateResult{Response: llm.Response{Text: js, JSON: json.RawMessage(js)}})
+	normalize.QueueGenerate(recipestest.NormalizedReply("stovetop", 25))
+	h, runner, _ := newIdeasRouter(t, model, normalize, search, pages, images, true)
+
+	rec, body := callDinners(t, h, http.MethodPost, ideasPath, `{"ingredients": ["Chicken thighs", "rice", "scallions"], "quick_only": true}`)
+	if rec.Code != http.StatusAccepted {
+		t.Fatalf("POST = %d: %s", rec.Code, rec.Body)
+	}
+	id, _ := body["jobId"].(string)
+	if id == "" || len(body) != 1 {
+		t.Fatalf("POST answered %v, want only a jobId", body)
+	}
+
+	deadline := time.Now().Add(10 * time.Second)
+	for {
+		job, err := runner.Get(t.Context(), id)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if job.Status == jobs.StatusSucceeded || job.Status == jobs.StatusFailed {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("job still %s", job.Status)
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	rec, job := callDinners(t, h, http.MethodGet, "/api/v1/jobs/"+id, "")
+	if rec.Code != http.StatusOK || job["status"] != "succeeded" || job["kind"] != "ideas_from_ingredients" {
+		t.Fatalf("GET job = %d %v", rec.Code, job)
+	}
+	res := job["result"].(map[string]any)
+	if res["stage"] != "done" || res["quick_only"] != true || res["dropped"] != 0.0 {
+		t.Fatalf("result = %v", res)
+	}
+	list := res["ideas"].([]any)
+	if len(list) != 1 {
+		t.Fatalf("ideas = %v, want 1", list)
+	}
+	got := list[0].(map[string]any)
+	for key, want := range map[string]any{
+		"name":          "Chicken Fried Rice",
+		"summary":       "Uses 2 of 3 · missing: 2 eggs",
+		"method":        "stovetop",
+		"minutes_total": 25.0,
+		"quick":         true,
+		"site_name":     "R Kitchen",
+		"source_url":    "https://r.example/fried-rice",
+	} {
+		if got[key] != want {
+			t.Errorf("idea %s = %v, want %v", key, got[key], want)
+		}
+	}
+	if uses, _ := json.Marshal(got["uses"]); string(uses) != `["Chicken thighs","rice"]` {
+		t.Errorf("idea uses = %s, want the household's two listed ingredients", uses)
+	}
+	if got["recipe_id"] == "" || got["photo_url"] == "" {
+		t.Errorf("idea = %v, want a recipe and photo", got)
+	}
+}
+
+func TestFailedIdeasJobShowsNoIdeas(t *testing.T) {
+	t.Parallel()
+	for _, tc := range []struct {
+		name string
+		// grounds are the ideas a recipe grounds; the others ground none.
+		grounds []string
+		ideas   []string
+		fail    map[string]error
+		code    string
+	}{
+		{"no idea kept", nil, []string{"Mystery Stew"}, nil, "no_ideas_found"},
+		{"a later round fails after ideas were shown",
+			[]string{"Fried Rice", "Rice Bowls", "Rice Soup", "Rice Salad"},
+			[]string{"Fried Rice", "Mystery Stew", "Rice Bowls", "Rice Soup", "Rice Salad", "Rice Pilaf"},
+			map[string]error{"Rice Pilaf": errors.New("boom")}, "search_failed"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			model, normalize, search, pages, images := scriptIdeas(t, tc.ideas, tc.grounds, tc.fail)
+			h, _, _ := newIdeasRouter(t, model, normalize, search, pages, images, true)
+			assertFailedWithoutIdeas(t, waitJob(t, h, startIdeasJob(t, h)), tc.code)
+		})
+	}
+}
+
+// A job left running with ideas shown is failed at the next start as
+// interrupted, without its handler running again; it still shows no ideas.
+func TestIdeasJobInterruptedByRestartShowsNoIdeas(t *testing.T) {
+	t.Parallel()
+	h, runner, st := newIdeasRouter(t, &llm.Fake{}, &llm.Fake{}, &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, false)
+	id := startIdeasJob(t, h)
+
+	// The previous process claimed the job and showed an idea, then stopped.
+	q := db.New(st.Writer)
+	now := store.Now().String()
+	if _, err := q.ClaimNextJob(t.Context(), sql.NullString{String: now, Valid: true}); err != nil {
+		t.Fatal(err)
+	}
+	partial, err := ideas.Result{
+		Stage:       ideas.StageGrounding,
+		Ingredients: []string{"rice"},
+		Ideas:       []ideas.Idea{{Name: "Fried Rice", Uses: []string{"rice"}, Missing: []string{}, Method: "stovetop", Difficulty: "easy"}},
+	}.PublicJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n, err := q.PublishJobResult(t.Context(), db.PublishJobResultParams{
+		Result: sql.NullString{String: string(partial), Valid: true}, UpdatedAt: now, ID: id,
+	}); err != nil || n != 1 {
+		t.Fatalf("publish partial result = %d, %v", n, err)
+	}
+
+	startRunner(t, runner)
+	_, job := callDinners(t, h, http.MethodGet, "/api/v1/jobs/"+id, "")
+	assertFailedWithoutIdeas(t, job, jobs.CodeInterrupted)
+	if res := job["result"].(map[string]any); res["stage"] != "grounding" {
+		t.Errorf("result = %v, want the rest of the partial result kept", res)
+	}
+	if n := storedIdeas(t, st, id); n != 1 {
+		t.Fatalf("stored ideas = %d, want the interrupted job's 1 still stored", n)
+	}
+}
+
+// When the write clearing a failed job's ideas itself fails, the job fails
+// with the runner's internal_error and its stored result keeps the ideas;
+// it still shows none.
+func TestIdeasJobWhoseClearingWriteFailsShowsNoIdeas(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := scriptIdeas(t,
+		[]string{"Fried Rice", "Mystery Stew", "Rice Bowls", "Rice Soup", "Rice Salad", "Rice Pilaf"},
+		[]string{"Fried Rice", "Rice Bowls", "Rice Soup", "Rice Salad"},
+		map[string]error{"Rice Pilaf": errors.New("boom")})
+	h, runner, st := newIdeasRouter(t, model, normalize, search, pages, images, false)
+	// Refuse any write that empties a running job's shown ideas.
+	if _, err := st.Writer.ExecContext(t.Context(), `
+		CREATE TRIGGER refuse_clearing_ideas BEFORE UPDATE OF result ON jobs
+		WHEN NEW.status = 'running'
+			AND json_array_length(OLD.result, '$.ideas') > 0
+			AND json_array_length(NEW.result, '$.ideas') = 0
+		BEGIN SELECT RAISE(ABORT, 'clearing refused'); END`); err != nil {
+		t.Fatal(err)
+	}
+	startRunner(t, runner)
+
+	id := startIdeasJob(t, h)
+	assertFailedWithoutIdeas(t, waitJob(t, h, id), jobs.CodeInternal)
+	if n := storedIdeas(t, st, id); n != 4 {
+		t.Fatalf("stored ideas = %d, want the 4 the refused write left", n)
+	}
+}
+
+func TestJobsEndpointRefusesIdeasKind(t *testing.T) {
+	t.Parallel()
+	h, _, _ := newIdeasRouter(t, &llm.Fake{}, &llm.Fake{}, &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, false)
+	rec, body := callDinners(t, h, http.MethodPost, "/api/v1/jobs", `{"kind": "ideas_from_ingredients", "payload": {"ingredients": [], "quick_only": false}}`)
+	if rec.Code != http.StatusBadRequest || errorCode(body) != "service_only_kind" {
+		t.Fatalf("POST /jobs = %d %v, want 400 service_only_kind", rec.Code, body)
+	}
+}

internal/server/login_test.go

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

internal/server/media_test.go

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

internal/server/origin_test.go

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

internal/server/plans_test.go

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

internal/server/quickideas_test.go

@@ -0,0 +1,181 @@
+package server
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
+)
+
+const quickPath = "/api/v1/ideas/quick"
+
+// quickRecipe makes the search for name find a page titled title with a
+// total time of minutes, and scripts the normalize_recipe reply grounding
+// it takes. "Slow Cooker" in title grounds the method as crockpot.
+func quickRecipe(t *testing.T, normalize *llm.Fake, search *recipestest.Search, pages *recipestest.Pages, images *recipestest.Images, name, title string, minutes int) {
+	t.Helper()
+	slug := strings.ReplaceAll(strings.ToLower(name), " ", "-")
+	page, photo := "https://r.example/"+slug, "https://r.example/"+slug+".jpg"
+	search.Results[name] = []recipes.Candidate{{URL: page}}
+	pages.Bodies[page] = recipestest.RecipePage(title, "R Kitchen", photo, minutes)
+	images.JPEGs[photo] = recipestest.JPEG(t, 400, 320, uint8(len(images.JPEGs)+1))
+	normalize.QueueGenerate(recipestest.NormalizedReply("stovetop", minutes))
+}
+
+// quickReply scripts one quick_ideas reply holding the ideas named, each
+// searched by its name.
+func quickReply(model *llm.Fake, ideas ...[3]any) {
+	list := make([]string, len(ideas))
+	for i, idea := range ideas {
+		list[i] = fmt.Sprintf(`{"name":%q,"est_minutes":%d,"method":%q,"difficulty":"medium","search_query":%q}`, idea[0], idea[2], idea[1], idea[0])
+	}
+	js := `{"ideas":[` + strings.Join(list, ",") + `]}`
+	model.QueueGenerate(llm.GenerateResult{Response: llm.Response{Text: js, JSON: json.RawMessage(js)}})
+}
+
+func newQuickFakes() (*llm.Fake, *llm.Fake, *recipestest.Search, *recipestest.Pages, *recipestest.Images) {
+	return &llm.Fake{}, &llm.Fake{}, &recipestest.Search{Results: map[string][]recipes.Candidate{}},
+		&recipestest.Pages{Bodies: map[string][]byte{}}, &recipestest.Images{JPEGs: map[string][]byte{}}
+}
+
+func TestPostIdeasQuickRefusesBadRequests(t *testing.T) {
+	t.Parallel()
+	h, _, _ := newIdeasRouter(t, &llm.Fake{}, &llm.Fake{}, &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, false)
+
+	for _, tc := range []struct{ body, message string }{
+		{`{"exclude": []}`, "kind: required"},
+		{`{"kind": "crockpot"}`, "exclude: required"},
+		{`{"kind": "", "exclude": []}`, `kind: kind "" is not one of crockpot, under30`},
+		{`{"kind": "quick", "exclude": []}`, `kind: kind "quick" is not one of crockpot, under30`},
+		{`{"kind": "Crockpot", "exclude": []}`, `kind: kind "Crockpot" is not one of crockpot, under30`},
+		{`{"kind": "under30", "exclude": ["Beef Stew", " "]}`, "exclude: excluded name 2 is blank"},
+		{`{"kind": "under30", "exclude": ["Beef Stew", "beef-stew"]}`, `exclude: excluded name 2, "beef-stew", repeats "Beef Stew"`},
+		{`{"kind": 30, "exclude": []}`, "kind: want a JSON string"},
+		{`{"kind": "under30", "exclude": [], "extra": 1}`, `invalid request body: json: unknown field "extra"`},
+	} {
+		rec, body := callDinners(t, h, http.MethodPost, quickPath, tc.body)
+		if rec.Code != http.StatusBadRequest || errorCode(body) != "invalid_request" {
+			t.Errorf("POST %s = %d %v, want 400 invalid_request", tc.body, rec.Code, body)
+			continue
+		}
+		if msg := body["error"].(map[string]any)["message"]; msg != tc.message {
+			t.Errorf("POST %s message = %q, want %q", tc.body, msg, tc.message)
+		}
+	}
+}
+
+// The job answers 202 at once and its result fills idea by idea: one
+// idea is shown while another still grounds. The kind is checked against
+// the grounded recipe and excluded names never come back.
+func TestPostIdeasQuickRunsTheJobWithProgressiveResults(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := newQuickFakes()
+	quickRecipe(t, normalize, search, pages, images, "Chicken Fried Rice", "Chicken Fried Rice", 25)
+	quickRecipe(t, normalize, search, pages, images, "Beef Stroganoff", "Beef Stroganoff", 45)
+	quickRecipe(t, normalize, search, pages, images, "Garlic Shrimp Pasta", "Garlic Shrimp Pasta", 30)
+	gate := make(chan struct{})
+	search.Gates = map[string]chan struct{}{"Garlic Shrimp Pasta": gate}
+	quickReply(model,
+		[3]any{"Easy Shrimp Tacos", "stovetop", 15},
+		[3]any{"Chicken Fried Rice", "stovetop", 20},
+		[3]any{"Beef Stroganoff", "stovetop", 25},
+		[3]any{"Garlic Shrimp Pasta", "stovetop", 20},
+	)
+	h, _, _ := newIdeasRouter(t, model, normalize, search, pages, images, true)
+
+	rec, body := callDinners(t, h, http.MethodPost, quickPath, `{"kind": "under30", "exclude": ["Shrimp Tacos"]}`)
+	if rec.Code != http.StatusAccepted {
+		t.Fatalf("POST = %d: %s", rec.Code, rec.Body)
+	}
+	id, _ := body["jobId"].(string)
+	if id == "" || len(body) != 1 {
+		t.Fatalf("POST answered %v, want only a jobId", body)
+	}
+
+	// While Garlic Shrimp Pasta still grounds, Chicken Fried Rice shows.
+	deadline := time.Now().Add(10 * time.Second)
+	for {
+		_, job := callDinners(t, h, http.MethodGet, "/api/v1/jobs/"+id, "")
+		if res, _ := job["result"].(map[string]any); res != nil {
+			if list, _ := res["ideas"].([]any); len(list) == 1 {
+				if job["status"] != "running" || res["stage"] != "grounding" || list[0].(map[string]any)["name"] != "Chicken Fried Rice" {
+					t.Fatalf("partial job = %v", job)
+				}
+				break
+			}
+		}
+		if time.Now().After(deadline) {
+			t.Fatal("no idea was shown while another still grounded")
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	close(gate)
+
+	job := waitJob(t, h, id)
+	if job["status"] != "succeeded" || job["kind"] != "quick_ideas" {
+		t.Fatalf("GET job = %v", job)
+	}
+	res := job["result"].(map[string]any)
+	if res["stage"] != "done" || res["kind"] != "under30" || res["dropped"] != 2.0 {
+		t.Fatalf("result = %v, want done with the excluded and the 45-minute ideas dropped", res)
+	}
+	if ex, _ := json.Marshal(res["exclude"]); string(ex) != `["Shrimp Tacos"]` {
+		t.Errorf("result exclude = %s", ex)
+	}
+	var names []string
+	for _, i := range res["ideas"].([]any) {
+		names = append(names, i.(map[string]any)["name"].(string))
+	}
+	if want := []string{"Chicken Fried Rice", "Garlic Shrimp Pasta"}; !reflect.DeepEqual(names, want) {
+		t.Fatalf("ideas = %q, want %q", names, want)
+	}
+	got := res["ideas"].([]any)[1].(map[string]any)
+	for key, want := range map[string]any{
+		"method":        "stovetop",
+		"minutes_total": 30.0,
+		"site_name":     "R Kitchen",
+		"source_url":    "https://r.example/garlic-shrimp-pasta",
+	} {
+		if got[key] != want {
+			t.Errorf("idea %s = %v, want %v", key, got[key], want)
+		}
+	}
+	if got["recipe_id"] == "" || got["photo_url"] == "" || got["difficulty"] == nil {
+		t.Errorf("idea = %v, want a recipe, photo and difficulty", got)
+	}
+}
+
+func TestFailedQuickJobShowsNoIdeas(t *testing.T) {
+	t.Parallel()
+	model, normalize, search, pages, images := newQuickFakes()
+	quickRecipe(t, normalize, search, pages, images, "Chicken Chili", "Slow Cooker Chicken Chili", 240)
+	search.Fail = map[string]error{"Lentil Soup": errors.New("boom")}
+	ideas := [][3]any{{"Chicken Chili", "crockpot", 240}}
+	for i := range 5 {
+		ideas = append(ideas, [3]any{fmt.Sprintf("Mystery Stew %d", i+1), "crockpot", 300})
+	}
+	quickReply(model, append(ideas, [3]any{"Lentil Soup", "crockpot", 300})...)
+	h, _, _ := newIdeasRouter(t, model, normalize, search, pages, images, true)
+	rec, body := callDinners(t, h, http.MethodPost, quickPath, `{"kind": "crockpot", "exclude": []}`)
+	if rec.Code != http.StatusAccepted {
+		t.Fatalf("POST = %d: %s", rec.Code, rec.Body)
+	}
+	assertFailedWithoutIdeas(t, waitJob(t, h, body["jobId"].(string)), "search_failed")
+}
+
+func TestJobsEndpointRefusesQuickKind(t *testing.T) {
+	t.Parallel()
+	h, _, _ := newIdeasRouter(t, &llm.Fake{}, &llm.Fake{}, &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, false)
+	rec, body := callDinners(t, h, http.MethodPost, "/api/v1/jobs", `{"kind": "quick_ideas", "payload": {"kind": "crockpot", "exclude": []}}`)
+	if rec.Code != http.StatusBadRequest || errorCode(body) != "service_only_kind" {
+		t.Fatalf("POST /jobs = %d %v, want 400 service_only_kind", rec.Code, body)
+	}
+}

internal/server/recipesearch_test.go

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

internal/server/server.go

@@ -16,6 +16,7 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/frontend"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
@@ -55,12 +56,15 @@ type RouteMounter interface {
 // /api/v1/shopping/items/{id}; googleSvc serves GET
 // /api/v1/integrations/google and its /connect, /callback and /calendars,
 // PUT /api/v1/integrations/google/calendar and DELETE
-// /api/v1/integrations/google; runner serves
+// /api/v1/integrations/google; ideasSvc serves POST
+// /api/v1/ideas/from-ingredients and POST /api/v1/ideas/quick, and with
+// dinnerSvc POST /api/v1/ideas/{jobId}/items/{i}/quest-log and, with
+// planSvc too, /cook-tonight; runner serves
 // POST /api/v1/jobs and GET /api/v1/jobs/{id}; photos serves
 // GET /media/photos/{id}-{size}.jpg; assets is the web build
 // served for every other GET. /health, /auth and the web build are public.
 // Requests to /api/v1 other than GET also need the session's CSRF token in CSRFHeader.
-func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, auth RouteMounter, sessions SessionLookup, settings *household.SettingsService, search *recipes.SearchSettingsService, ai *aisettings.Service, dinnerSvc *dinners.Service, suggestSvc *suggest.Service, planSvc *plan.Service, shopSvc *shopping.Service, googleSvc *gcal.Service, runner *jobs.Runner, photos PhotoFiles, assets fs.FS) (http.Handler, error) {
+func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, auth RouteMounter, sessions SessionLookup, settings *household.SettingsService, search *recipes.SearchSettingsService, ai *aisettings.Service, dinnerSvc *dinners.Service, suggestSvc *suggest.Service, planSvc *plan.Service, shopSvc *shopping.Service, googleSvc *gcal.Service, ideasSvc *ideas.Service, runner *jobs.Runner, photos PhotoFiles, assets fs.FS) (http.Handler, error) {
 	if settings == nil {
 		return nil, errors.New("server: nil household settings service")
 	}
@@ -85,6 +89,9 @@ func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, a
 	if googleSvc == nil {
 		return nil, errors.New("server: nil Google Calendar service")
 	}
+	if ideasSvc == nil {
+		return nil, errors.New("server: nil ideas service")
+	}
 	if runner == nil {
 		return nil, errors.New("server: nil job runner")
 	}
@@ -158,6 +165,10 @@ func NewRouter(logger *slog.Logger, version string, trusted forwarded.Trusted, a
 	apiV1.Delete("/integrations/google", deleteGoogle(logger, googleSvc))
 	apiV1.Get("/integrations/google/calendars", getGoogleCalendars(logger, googleSvc))
 	apiV1.Put("/integrations/google/calendar", putGoogleCalendar(logger, googleSvc))
+	apiV1.Post("/ideas/from-ingredients", postIdeasFromIngredients(logger, ideasSvc))
+	apiV1.Post("/ideas/quick", postIdeasQuick(logger, ideasSvc))
+	apiV1.Post("/ideas/{jobId}/items/{i}/quest-log", postIdeaQuestLog(logger, ideasSvc, dinnerSvc))
+	apiV1.Post("/ideas/{jobId}/items/{i}/cook-tonight", postIdeaCookTonight(logger, ideasSvc, dinnerSvc, planSvc))
 	apiV1.Post("/jobs", postJob(logger, runner))
 	apiV1.Get("/jobs/{id}", getJob(logger, runner))
 	media.Get("/photos/{name}", getPhoto(logger, photos))

internal/server/server_test.go

@@ -25,6 +25,7 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ideas"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/plan"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
@@ -54,7 +55,7 @@ func newTestRouterWith(t *testing.T, version string, settings *household.Setting
 		"index.html":             {Data: []byte(fixtureIndex)},
 		"assets/index-AbC123.js": {Data: []byte(fixtureAsset)},
 	}
-	r, err := NewRouter(logger, version, nil, stubAuth{}, stubSessions{}, settings, newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), runner, newTestPhotos(t), assets)
+	r, err := NewRouter(logger, version, nil, stubAuth{}, stubSessions{}, settings, newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), runner, newTestPhotos(t), assets)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -190,6 +191,30 @@ func newTestSuggest(t *testing.T) *suggest.Service {
 	return svc
 }
 
+// newTestIdeas returns an ideas service with its own unstarted job runner
+// and generators that always fail.
+func newTestIdeas(t *testing.T) *ideas.Service {
+	t.Helper()
+	st := newTestStore(t)
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	runner, err := jobs.NewRunner(st, logger, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := recipestest.NewGrounder(t, st, t.TempDir(), &recipestest.Search{}, &recipestest.Pages{}, &recipestest.Images{}, &llm.Fake{})
+	fail := func(context.Context, string, skills.IdeasRequest) (skills.Ideas, error) {
+		return skills.Ideas{}, errors.New("no model in this test")
+	}
+	failQuick := func(context.Context, string, skills.QuickIdeasRequest) (skills.QuickIdeaList, error) {
+		return skills.QuickIdeaList{}, errors.New("no model in this test")
+	}
+	svc, err := ideas.NewService(st, g, fail, failQuick, runner, logger)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return svc
+}
+
 // newTestPlan returns a plan service over a migrated temp database, with
 // its own unstarted job runner and a drafter that always fails.
 func newTestPlan(t *testing.T) *plan.Service {
@@ -287,7 +312,7 @@ func TestNewRouterRequiresAISettings(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), nil, newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), nil, newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil AI settings service")
 	}
 }
@@ -296,7 +321,7 @@ func TestNewRouterRequiresSearchSettings(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), nil, newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), nil, newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil recipe search settings service")
 	}
 }
@@ -305,7 +330,7 @@ func TestNewRouterRequiresPhotoFiles(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestRunner(t), nil, fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), newTestRunner(t), nil, fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted nil photo files")
 	}
 }
@@ -314,7 +339,7 @@ func TestNewRouterRequiresSettings(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, nil, newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, nil, newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil settings service")
 	}
 }
@@ -323,7 +348,7 @@ func TestNewRouterRequiresDinners(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), nil, newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), nil, newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil dinners service")
 	}
 }
@@ -332,7 +357,7 @@ func TestNewRouterRequiresSuggestions(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), nil, newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), nil, newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil suggestions service")
 	}
 }
@@ -341,7 +366,7 @@ func TestNewRouterRequiresPlan(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), nil, newTestShopping(t), newTestGoogle(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), nil, newTestShopping(t), newTestGoogle(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil plan service")
 	}
 }
@@ -350,16 +375,25 @@ func TestNewRouterRequiresShopping(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), nil, newTestGoogle(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), nil, newTestGoogle(t), newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil shopping service")
 	}
 }
 
+func TestNewRouterRequiresIdeas(t *testing.T) {
+	t.Parallel()
+
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), nil, newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+		t.Fatal("NewRouter accepted a nil ideas service")
+	}
+}
+
 func TestNewRouterRequiresGoogle(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), nil, newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), nil, newTestIdeas(t), newTestRunner(t), newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil Google Calendar service")
 	}
 }
@@ -368,7 +402,7 @@ func TestNewRouterRequiresJobRunner(t *testing.T) {
 	t.Parallel()
 
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), nil, newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
+	if _, err := NewRouter(logger, "dev", nil, stubAuth{}, stubSessions{}, newTestSettings(t), newTestSearch(t), newTestAI(t), newTestDinners(t), newTestSuggest(t), newTestPlan(t), newTestShopping(t), newTestGoogle(t), newTestIdeas(t), nil, newTestPhotos(t), fstest.MapFS{"index.html": {}}); err == nil {
 		t.Fatal("NewRouter accepted a nil job runner")
 	}
 }

internal/server/settings_test.go

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

internal/server/suggestions_test.go

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