feat: add batch-cooking sessions (single "mega recipe" with dish sections)

New AI-generated batch-cooking flow: pick N dinners/lunches + servings,
get one unified recipe covering a full prep session — merged shopping
list, steps tagged per-dish (a step can advance several dishes at once,
e.g. a shared oven bake), and per-dish storage (fridge/freezer) + exact
day-of reheat/finishing instructions.

Schema: recipes.isBatchCook, recipeSteps.appliesTo (dish names), new
recipeBatchDishes table. Batch recipes are excluded from the normal
/recipes list and live under their own /batch-cooking section.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

apps/web/app/(app)/batch-cooking/page.tsx

@@ -0,0 +1,31 @@
+import type { Metadata } from "next";
+import { headers } from "next/headers";
+import { auth } from "@/lib/auth/server";
+import { db, recipes, eq, and, desc } from "@epicure/db";
+import { BatchCookingPageContent } from "@/components/recipe/batch-cooking-page-content";
+
+export const metadata: Metadata = {};
+
+export default async function BatchCookingPage() {
+  const session = await auth.api.getSession({ headers: await headers() });
+  if (!session) return null;
+
+  const sessions = await db.query.recipes.findMany({
+    where: and(eq(recipes.authorId, session.user.id), eq(recipes.isBatchCook, true)),
+    orderBy: desc(recipes.createdAt),
+    with: { batchDishes: true },
+  });
+
+  return (
+    <BatchCookingPageContent
+      sessions={sessions.map((r) => ({
+        id: r.id,
+        title: r.title,
+        description: r.description,
+        baseServings: r.baseServings,
+        createdAt: r.createdAt.toISOString(),
+        dishCount: r.batchDishes.length,
+      }))}
+    />
+  );
+}

apps/web/app/(app)/recipes/[id]/page.tsx

@@ -34,6 +34,8 @@ import { CommentsSection } from "@/components/social/comments-section";
 import { getPublicUrl } from "@/lib/storage";
 import { cn } from "@/lib/utils";
 import { RecipeChatPanel } from "@/components/recipe/recipe-chat-panel";
+import { BatchCookSteps } from "@/components/recipe/batch-cook-steps";
+import { BatchCookDishes } from "@/components/recipe/batch-cook-dishes";
 import { KeepScreenAwake } from "@/components/recipe/keep-screen-awake";
 import { ExportMarkdownButton } from "@/components/shared/export-markdown-button";
 import { recipeToMarkdown } from "@/lib/markdown/recipe";
@@ -71,6 +73,7 @@ export default async function RecipePage({ params }: Params) {
         steps: { orderBy: (t, { asc }) => asc(t.order) },
         photos: { orderBy: (t, { asc }) => asc(t.order) },
         author: { columns: { id: true, name: true, username: true, avatarUrl: true } },
+        batchDishes: { orderBy: (t, { asc }) => asc(t.order) },
       },
     }),
     db.select({ avgScore: avg(ratings.score), total: count() }).from(ratings).where(eq(ratings.recipeId, id)),
@@ -109,7 +112,12 @@ export default async function RecipePage({ params }: Params) {
       <KeepScreenAwake />
       {/* Header */}
       <div className="space-y-4">
-        <h1 className="text-3xl font-bold tracking-tight">{recipe.title}</h1>
+        <div className="flex items-center gap-3">
+          <h1 className="text-3xl font-bold tracking-tight">{recipe.title}</h1>
+          {recipe.isBatchCook && (
+            <Badge variant="secondary" className="shrink-0">{m.recipe.batchCookBadge}</Badge>
+          )}
+        </div>
         {!isOwner && recipe.author.username && (
           <Link
             href={`/u/${recipe.author.username}`}
@@ -366,30 +374,41 @@ export default async function RecipePage({ params }: Params) {
           <Separator />
           <div className="space-y-6">
             <h2 className="text-xl font-semibold">{m.recipe.instructions}</h2>
-            <ol className="space-y-6">
-              {recipe.steps.map((step, i) => (
-                <li key={step.id} className="flex gap-4">
-                  <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-primary text-primary-foreground text-sm font-bold">
-                    {i + 1}
-                  </div>
-                  <div className="flex-1 space-y-1 pt-1">
-                    <p className="leading-relaxed">{step.instruction}</p>
-                    {step.timerSeconds && (
-                      <p className="text-xs text-muted-foreground flex items-center gap-1">
-                        <Clock className="h-3 w-3" />
-                        {step.timerSeconds >= 60
-                          ? `${Math.floor(step.timerSeconds / 60)}m ${step.timerSeconds % 60 > 0 ? `${step.timerSeconds % 60}s` : ""}`
-                          : `${step.timerSeconds}s`}
-                      </p>
-                    )}
-                  </div>
-                </li>
-              ))}
-            </ol>
+            {recipe.isBatchCook ? (
+              <BatchCookSteps steps={recipe.steps} />
+            ) : (
+              <ol className="space-y-6">
+                {recipe.steps.map((step, i) => (
+                  <li key={step.id} className="flex gap-4">
+                    <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-primary text-primary-foreground text-sm font-bold">
+                      {i + 1}
+                    </div>
+                    <div className="flex-1 space-y-1 pt-1">
+                      <p className="leading-relaxed">{step.instruction}</p>
+                      {step.timerSeconds && (
+                        <p className="text-xs text-muted-foreground flex items-center gap-1">
+                          <Clock className="h-3 w-3" />
+                          {step.timerSeconds >= 60
+                            ? `${Math.floor(step.timerSeconds / 60)}m ${step.timerSeconds % 60 > 0 ? `${step.timerSeconds % 60}s` : ""}`
+                            : `${step.timerSeconds}s`}
+                        </p>
+                      )}
+                    </div>
+                  </li>
+                ))}
+              </ol>
+            )}
           </div>
         </>
       )}
 
+      {recipe.isBatchCook && recipe.batchDishes.length > 0 && (
+        <>
+          <Separator />
+          <BatchCookDishes dishes={recipe.batchDishes} />
+        </>
+      )}
+
       {recipe.photos.length > 1 && (
         <>
           <Separator />

apps/web/app/(app)/recipes/page.tsx

@@ -54,6 +54,7 @@ export default async function RecipesPage({ searchParams }: { searchParams: Sear
 
   const where = and(
     eq(recipes.authorId, session.user.id),
+    eq(recipes.isBatchCook, false),
     query
       ? or(ilike(recipes.title, `%${query}%`), ilike(recipes.description, `%${query}%`))
       : undefined,

apps/web/app/api/v1/ai/batch-cook/generate/route.ts

@@ -0,0 +1,119 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, recipes, recipeIngredients, recipeSteps, recipeBatchDishes } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { applyRateLimit } from "@/lib/rate-limit";
+import { getDefaultProviderWithKey } from "@/lib/ai/resolve-user-key";
+import { withAiQuota, resolveAiConfigOrError } from "@/lib/ai/ai-error";
+import { generateBatchCook } from "@/lib/ai/features/generate-batch-cook";
+import { getUserPrivateBio } from "@/lib/ai/user-bio";
+import { parseQuantity } from "@/lib/parse-quantity";
+
+const Schema = z.object({
+  dinners: z.number().int().min(0).max(6).default(4),
+  lunches: z.number().int().min(0).max(6).default(0),
+  servings: z.number().int().min(1).max(12).default(4),
+  dietaryPrefs: z.string().max(200).optional(),
+  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+});
+
+export async function POST(req: NextRequest) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const body = await req.json() as unknown;
+  const parsed = Schema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ error: "Validation error", issues: parsed.error.issues }, { status: 400 });
+  }
+  if (parsed.data.dinners + parsed.data.lunches < 1) {
+    return NextResponse.json({ error: "Choose at least one dinner or lunch" }, { status: 400 });
+  }
+
+  const limited = await applyRateLimit(`rl:ai:${session!.user.id}`, 3, 60);
+  if (limited) return limited;
+
+  const userId = session!.user.id;
+  const locale = (session!.user as { locale?: string }).locale ?? "en";
+  const [configResult, privateBio] = await Promise.all([
+    resolveAiConfigOrError(() => getDefaultProviderWithKey(userId)),
+    getUserPrivateBio(userId),
+  ]);
+  if (!configResult.ok) return configResult.response;
+  const config = configResult.data;
+
+  const result = await withAiQuota(userId, session!.user.tier as "free" | "pro", () =>
+    generateBatchCook(
+      {
+        dinners: parsed.data.dinners,
+        lunches: parsed.data.lunches,
+        servings: parsed.data.servings,
+        dietaryPrefs: parsed.data.dietaryPrefs,
+        difficulty: parsed.data.difficulty,
+      },
+      { ...config, userContext: privateBio ?? undefined },
+      locale
+    )
+  );
+  if (!result.ok) return result.response;
+  const plan = result.data;
+
+  const recipeId = crypto.randomUUID();
+
+  await db.transaction(async (tx) => {
+    await tx.insert(recipes).values({
+      id: recipeId,
+      authorId: userId,
+      title: plan.title,
+      description: plan.description,
+      baseServings: parsed.data.servings,
+      visibility: "private",
+      aiGenerated: true,
+      isBatchCook: true,
+      language: locale,
+    });
+
+    if (plan.ingredients.length > 0) {
+      await tx.insert(recipeIngredients).values(
+        plan.ingredients.map((ing, i) => ({
+          id: crypto.randomUUID(),
+          recipeId,
+          rawName: ing.rawName,
+          quantity: parseQuantity(ing.quantity) ?? null,
+          unit: ing.unit ?? null,
+          order: i,
+        }))
+      );
+    }
+
+    if (plan.steps.length > 0) {
+      await tx.insert(recipeSteps).values(
+        plan.steps.map((step, i) => ({
+          id: crypto.randomUUID(),
+          recipeId,
+          instruction: step.instruction,
+          order: i,
+          appliesTo: step.appliesTo,
+        }))
+      );
+    }
+
+    if (plan.dishes.length > 0) {
+      await tx.insert(recipeBatchDishes).values(
+        plan.dishes.map((dish, i) => ({
+          id: crypto.randomUUID(),
+          recipeId,
+          name: dish.name,
+          description: dish.description,
+          order: i,
+          fridgeDays: dish.fridgeDays,
+          freezerFriendly: dish.freezerFriendly,
+          freezerNote: dish.freezerNote ?? null,
+          dayOfInstructions: dish.dayOfInstructions,
+        }))
+      );
+    }
+  });
+
+  return NextResponse.json({ id: recipeId });
+}