feat(cooking): endpoint GET /cooking-session (plan de cuisine optimise)

Module cooking-session : charge le Planning couvrant ?date= (meme requete
"plage couvrante" + degradation "jamais null" que /shopping-list), mappe
chaque PlanningItem vers l'entree pure de optimizeCookingPlan (ingredients/
unites/techniques/ustensiles resolus via toIngredientView/toUnitView
reutilisees de recipe.service), renvoie OptimizedCookingPlanView.

- cookingSessionPlanningInclude reprend le sous-arbre steps de recipeInclude.
- Route requireAuth, contrat ?date= identique a /shopping-list.
- Monte /cooking-session dans app.ts.
- Tests d'integration Mocha (401, date invalide, plan vide sans foyer /
  sans planning, mutualisation d'une decoupe entre 2 recettes planifiees).
- specs/batch-cooking-architecture.md : module "Calcul batch-cooking" TODO
  -> v1 implementee ; nouvelle section dans backend-architecture.md.

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

apps/api/src/app.ts

@@ -6,6 +6,7 @@ import { env } from "./config/env.js";
 import { errorLogger } from "./middlewares/error-logger.js";
 import { requestLogger } from "./middlewares/request-logger.js";
 import { authRouter } from "./modules/auth/auth.routes.js";
+import { cookingSessionRouter } from "./modules/cooking-session/cooking-session.routes.js";
 import { houseRouter } from "./modules/house/house.routes.js";
 import { techStepWorkerRouter } from "./modules/internal/tech-step-worker.routes.js";
 import { planningRouter } from "./modules/planning/planning.routes.js";
@@ -52,6 +53,7 @@ export function createServer(): ExpressServer {
   server.mountRouter("/recipes", recipeRouter);
   server.mountRouter("/reference", referenceRouter);
   server.mountRouter("/shopping-list", shoppingListRouter);
+  server.mountRouter("/cooking-session", cookingSessionRouter);
   server.mountRouter("/sources", sourcesRouter);
 
   // Serves the built frontend (production Docker image only — see

apps/api/src/lib/recipe-matching/cooking-optimizer.ts

@@ -0,0 +1,511 @@
+import type {
+  CookingBackgroundTaskView,
+  CookingPhaseKind,
+  CookingPhaseView,
+  CookingSessionRecipeRef,
+  CookingTaskIngredientView,
+  CookingTaskView,
+  TechStepView,
+  UtensilView,
+} from "@batch-cooking/shared";
+
+/**
+ * The pure core of the "Calcul batch-cooking" module (`specs/batch-cooking-architecture.md`):
+ * takes the week's planned recipes — already resolved to reference views by
+ * `cooking-session.service.ts` — and reorganizes their steps into an ordered
+ * sequence of {@link CookingPhaseView}s that pools shared preparation and
+ * interleaves the recipes so passive cooks (simmer, braise, bake…) run in
+ * the background while the cook does active work from another recipe.
+ *
+ * Pure and synchronous, no database access — same `matchXxx()` pure /
+ * `loadXxx()` DB-backed split as `ingredient-matcher.ts` /
+ * `tech-step-matcher.ts` / `shopping-list.service.ts`'s
+ * `aggregateShoppingList`, so the whole optimization is unit-testable
+ * without a Postgres round-trip.
+ *
+ * v1 scope (see the plan / spec): preparation is the only thing *merged*
+ * across recipes — a `chop`/`peel`/… technique applied to the same
+ * ingredient by two or more recipes, in a step that does nothing but prep,
+ * collapses into a single {@link CookingTaskView} of `kind: "merged-prep"`.
+ * Cooking steps themselves are never merged (no "same oven, same
+ * temperature" reasoning yet); they're only *reordered* for parallelism.
+ */
+
+/**
+ * Technique keys (`TechStep.key`, see `reference-seed-data.ts`'s
+ * `TECH_STEPS`) that are pure knife/prep work on an ingredient — the only
+ * techniques v1 pools across recipes. A *step* counts as prep only when
+ * **every** technique it mentions is in here (see {@link isPurePrepStep}):
+ * "émincer les oignons" merges, "faire revenir les oignons émincés" does
+ * not (its `panFry` keeps it a cooking step).
+ */
+const PREP_TECHNIQUES: ReadonlySet<string> = new Set([
+  "chop",
+  "peel",
+  "mince",
+  "julienne",
+  "brunoise",
+  "concasse",
+  "paysanne",
+  "mirepoix",
+  "zest",
+  "score",
+  "pod",
+  "shellEgg",
+  "hollowOut",
+  "filet",
+  "disgorge",
+  "sift",
+  "dustWithFlour",
+  "peelBlanch",
+]);
+
+/**
+ * How much of the cook's attention a technique needs once it's under way —
+ * the axis that makes parallelism possible.
+ *
+ * - `"SETUP"` — a short active trigger, then it looks after itself: preheat
+ *   the oven, bring a pot of water to the boil. Pooled into the first
+ *   ("mise en place") phase so it's running before it's needed.
+ * - `"PASSIVE"` — unattended once started (simmer, braise, bake, marinate,
+ *   rest…). Scheduled, then floated into every following phase's
+ *   `background` until the step that consumes it comes up.
+ * - anything not listed here, or a step with no detected technique at all,
+ *   is treated as `"ACTIVE"` — hands-on, occupies the cook.
+ */
+const SETUP_TECHNIQUES: ReadonlySet<string> = new Set(["preheat", "boil", "bainMarie"]);
+
+/** See {@link SETUP_TECHNIQUES}. */
+const PASSIVE_TECHNIQUES: ReadonlySet<string> = new Set([
+  "simmer",
+  "bake",
+  "roast",
+  "braise",
+  "marinate",
+  "rest",
+  "proof",
+  "confit",
+  "reduce",
+  "blindBake",
+  "compote",
+  "smother",
+  "setGel",
+  "pasteurize",
+  "appertize",
+  "poach",
+  "sweat",
+  "glaze",
+]);
+
+/** Attention class of a single step — see {@link SETUP_TECHNIQUES}. */
+type Attention = "SETUP" | "PASSIVE" | "ACTIVE";
+
+/** One technique occurrence within a step, already scaled to the planned portions. */
+interface OptimizerTechStepInput {
+  techStep: TechStepView;
+  order: number;
+  ingredients: CookingTaskIngredientView[];
+  utensils: UtensilView[];
+}
+
+/** One recipe step, as handed to {@link optimizeCookingPlan}. */
+interface OptimizerStepInput {
+  stepId: number;
+  order: number;
+  description: string;
+  techSteps: OptimizerTechStepInput[];
+}
+
+/**
+ * One planned recipe, as handed to {@link optimizeCookingPlan}. `portions`
+ * is the planning slot's own count and `recipePortions` the recipe's
+ * as-written yield — quantities are scaled by `portions / recipePortions`
+ * (see {@link scaleOf}). The same recipe planned twice at different portion
+ * counts arrives as two entries with the same `recipeId`; that's
+ * intentional (two real cooking jobs), and merged-prep still pools their
+ * knife work back together.
+ */
+interface OptimizerRecipeInput {
+  recipeId: number;
+  name: string;
+  portions: number;
+  recipePortions: number;
+  steps: OptimizerStepInput[];
+}
+
+/** {@link optimizeCookingPlan}'s result — the date-range/legend wrapper is added by the service. */
+interface OptimizeCookingPlanResult {
+  recipes: CookingSessionRecipeRef[];
+  phases: CookingPhaseView[];
+}
+
+export type {
+  OptimizeCookingPlanResult,
+  OptimizerRecipeInput,
+  OptimizerStepInput,
+  OptimizerTechStepInput,
+};
+
+/** Portion scale factor for a recipe — guards a missing/zero as-written yield (bad data) by falling back to 1× rather than dividing by zero. */
+function scaleOf(recipe: OptimizerRecipeInput): number {
+  if (!recipe.recipePortions || recipe.recipePortions <= 0) return 1;
+  return recipe.portions / recipe.recipePortions;
+}
+
+/** A step normalized for scheduling — techniques scaled, attention resolved, ingredients/utensils unioned across its technique clauses. */
+interface NormalizedStep {
+  /** Stable within one response: `step:<recipeIndex>:<stepId>` (the index disambiguates the same recipe planned twice). */
+  taskId: string;
+  recipeIndex: number;
+  recipe: CookingSessionRecipeRef;
+  stepId: number;
+  order: number;
+  description: string;
+  techSteps: OptimizerTechStepInput[];
+  attention: Attention;
+  isPurePrep: boolean;
+  dominantTechnique: TechStepView | null;
+  ingredients: CookingTaskIngredientView[];
+  utensils: UtensilView[];
+  /** Set once merged-prep extraction absorbs this step wholesale (all its prep pooled elsewhere) — it then produces no standalone task. */
+  absorbed: boolean;
+}
+
+/** Sums two ingredient lines only when it's unambiguous — same unit id and both quantities known; otherwise the pooled line carries no number (see `ShoppingListItemView`'s "don't guess a conversion" rule). */
+function poolIngredient(lines: CookingTaskIngredientView[]): {
+  quantity: number | null;
+  unit: CookingTaskIngredientView["unit"];
+} {
+  const first = lines[0];
+  if (!first) return { quantity: null, unit: null };
+  const unitId = first.unit?.id ?? null;
+  let total = 0;
+  for (const line of lines) {
+    if (line.quantity === null || (line.unit?.id ?? null) !== unitId) {
+      return { quantity: null, unit: null };
+    }
+    total += line.quantity;
+  }
+  return { quantity: total, unit: first.unit };
+}
+
+/** Unions ingredient lines by `(ingredientId, unitId)`, summing quantities within a group the same careful way as {@link poolIngredient}. */
+function unionIngredients(lines: CookingTaskIngredientView[]): CookingTaskIngredientView[] {
+  const groups = new Map<string, CookingTaskIngredientView[]>();
+  for (const line of lines) {
+    const key = `${line.ingredient.id}:${line.unit?.id ?? "x"}`;
+    const group = groups.get(key);
+    if (group) group.push(line);
+    else groups.set(key, [line]);
+  }
+  const out: CookingTaskIngredientView[] = [];
+  for (const group of groups.values()) {
+    const head = group[0];
+    if (!head) continue;
+    const pooled = poolIngredient(group);
+    out.push({ ingredient: head.ingredient, quantity: pooled.quantity, unit: pooled.unit });
+  }
+  return out.sort((a, b) => a.ingredient.key.localeCompare(b.ingredient.key));
+}
+
+/** Unions utensils by id, keeping a stable order by key. */
+function unionUtensils(utensils: UtensilView[]): UtensilView[] {
+  const byId = new Map<number, UtensilView>();
+  for (const utensil of utensils) byId.set(utensil.id, utensil);
+  return [...byId.values()].sort((a, b) => a.key.localeCompare(b.key));
+}
+
+/** A step is pure prep only if it has techniques and every one of them is in {@link PREP_TECHNIQUES}. */
+function isPurePrepStep(techSteps: OptimizerTechStepInput[]): boolean {
+  return techSteps.length > 0 && techSteps.every((ts) => PREP_TECHNIQUES.has(ts.techStep.key));
+}
+
+/** Resolves a step's {@link Attention} — SETUP wins, then a *trailing* passive technique, else ACTIVE (see {@link SETUP_TECHNIQUES}). */
+function attentionOf(techSteps: OptimizerTechStepInput[]): Attention {
+  if (techSteps.some((ts) => SETUP_TECHNIQUES.has(ts.techStep.key))) return "SETUP";
+  const last = techSteps[techSteps.length - 1];
+  if (last && PASSIVE_TECHNIQUES.has(last.techStep.key)) return "PASSIVE";
+  return "ACTIVE";
+}
+
+/** Turns one recipe's raw steps into {@link NormalizedStep}s — scales quantities, resolves attention, unions per-clause ingredients/utensils up to the step. */
+function normalizeRecipe(recipe: OptimizerRecipeInput, recipeIndex: number): NormalizedStep[] {
+  const scale = scaleOf(recipe);
+  const recipeRef: CookingSessionRecipeRef = {
+    recipeId: recipe.recipeId,
+    name: recipe.name,
+    portions: recipe.portions,
+  };
+
+  return [...recipe.steps]
+    .sort((a, b) => a.order - b.order)
+    .map((step) => {
+      const techSteps: OptimizerTechStepInput[] = [...step.techSteps]
+        .sort((a, b) => a.order - b.order)
+        .map((ts) => ({
+          techStep: ts.techStep,
+          order: ts.order,
+          ingredients: ts.ingredients.map((line) => ({
+            ingredient: line.ingredient,
+            quantity: line.quantity === null ? null : line.quantity * scale,
+            unit: line.unit,
+          })),
+          utensils: ts.utensils,
+        }));
+
+      const lastTech = techSteps[techSteps.length - 1];
+      return {
+        taskId: `step:${recipeIndex}:${step.stepId}`,
+        recipeIndex,
+        recipe: recipeRef,
+        stepId: step.stepId,
+        order: step.order,
+        description: step.description,
+        techSteps,
+        attention: attentionOf(techSteps),
+        isPurePrep: isPurePrepStep(techSteps),
+        dominantTechnique: lastTech ? lastTech.techStep : null,
+        ingredients: unionIngredients(techSteps.flatMap((ts) => ts.ingredients)),
+        utensils: unionUtensils(techSteps.flatMap((ts) => ts.utensils)),
+        absorbed: false,
+      } satisfies NormalizedStep;
+    });
+}
+
+/** The prep signature of a pure-prep step — sorted `<techniqueKey>:<ingredientId>` pairs; two steps with the same signature do identical knife work and can be pooled. */
+function prepSignature(step: NormalizedStep): string {
+  const pairs: string[] = [];
+  for (const ts of step.techSteps) {
+    for (const line of ts.ingredients) {
+      pairs.push(`${ts.techStep.key}:${line.ingredient.id}`);
+    }
+  }
+  return [...new Set(pairs)].sort().join("+");
+}
+
+/** Builds one {@link CookingTaskView} from a normalized step run as written. */
+function stepToTask(step: NormalizedStep): CookingTaskView {
+  return {
+    id: step.taskId,
+    kind: "step",
+    technique: step.dominantTechnique,
+    description: step.description,
+    ingredients: step.ingredients,
+    utensils: step.utensils,
+    sourceRecipes: [step.recipe],
+    originalSteps: [
+      {
+        recipeId: step.recipe.recipeId,
+        recipeName: step.recipe.name,
+        description: step.description,
+      },
+    ],
+  };
+}
+
+/** Builds the running-in-the-background status line for a passive step already scheduled in an earlier phase. */
+function stepToBackground(step: NormalizedStep): CookingBackgroundTaskView {
+  return {
+    id: `bg:${step.taskId}`,
+    technique: step.dominantTechnique,
+    description: step.description,
+    recipeId: step.recipe.recipeId,
+    recipeName: step.recipe.name,
+  };
+}
+
+/**
+ * Pools pure-prep steps that do the *exact same* knife work (same
+ * {@link prepSignature}) in two or more distinct recipes into one
+ * `merged-prep` {@link CookingTaskView}, and marks every contributing step
+ * `absorbed` so it produces no standalone task. A pure-prep step whose
+ * signature is unique (only one recipe needs it) is left untouched — it
+ * still lands in the mise-en-place phase, just as its own step task.
+ *
+ * Returns the merged tasks in a stable order (by id).
+ */
+function extractMergedPrep(steps: NormalizedStep[]): CookingTaskView[] {
+  const bySignature = new Map<string, NormalizedStep[]>();
+  for (const step of steps) {
+    if (!step.isPurePrep) continue;
+    const signature = prepSignature(step);
+    if (signature === "") continue;
+    const group = bySignature.get(signature);
+    if (group) group.push(step);
+    else bySignature.set(signature, [step]);
+  }
+
+  const merged: CookingTaskView[] = [];
+  for (const [signature, group] of bySignature) {
+    const recipeIndexes = new Set(group.map((s) => s.recipeIndex));
+    if (recipeIndexes.size < 2) continue;
+
+    for (const step of group) step.absorbed = true;
+
+    // Every contributing clause's ingredient lines, pooled per ingredient.
+    const allLines = group.flatMap((s) => s.techSteps.flatMap((ts) => ts.ingredients));
+    const ingredients = unionIngredients(allLines);
+    const utensils = unionUtensils(group.flatMap((s) => s.utensils));
+
+    // Dominant technique of the pool = the first pair's technique (v1
+    // signatures are almost always a single `<technique>:<ingredient>`
+    // pair; a multi-pair signature just takes the earliest).
+    const firstTech = group[0]?.techSteps[0]?.techStep ?? null;
+    const firstIngredientKey = ingredients[0]?.ingredient.key ?? signature;
+
+    // Distinct source recipes / original step texts, in input order.
+    const sourceRecipes: CookingSessionRecipeRef[] = [];
+    const seenRecipe = new Set<number>();
+    const originalSteps: CookingTaskView["originalSteps"] = [];
+    for (const step of [...group].sort((a, b) => a.recipeIndex - b.recipeIndex)) {
+      if (!seenRecipe.has(step.recipeIndex)) {
+        seenRecipe.add(step.recipeIndex);
+        sourceRecipes.push(step.recipe);
+      }
+      originalSteps.push({
+        recipeId: step.recipe.recipeId,
+        recipeName: step.recipe.name,
+        description: step.description,
+      });
+    }
+
+    merged.push({
+      id: `prep:${firstTech ? firstTech.key : "prep"}:${firstIngredientKey}`,
+      kind: "merged-prep",
+      technique: firstTech,
+      description: null,
+      ingredients,
+      utensils,
+      sourceRecipes,
+      originalSteps,
+    });
+  }
+
+  return merged.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/** Maps the input recipe list to its display legend, de-duplicating an exact `(recipeId, portions)` repeat. */
+function toRecipeLegend(recipes: OptimizerRecipeInput[]): CookingSessionRecipeRef[] {
+  const seen = new Set<string>();
+  const out: CookingSessionRecipeRef[] = [];
+  for (const recipe of recipes) {
+    const key = `${recipe.recipeId}:${recipe.portions}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ recipeId: recipe.recipeId, name: recipe.name, portions: recipe.portions });
+  }
+  return out;
+}
+
+/** A phase is `"finishing"` when everything left in it is plating; otherwise it's a normal `"cooking"` phase. */
+function cookingPhaseKind(tasks: CookingTaskView[]): CookingPhaseKind {
+  return tasks.every((task) => task.technique?.key === "plate") ? "finishing" : "cooking";
+}
+
+/**
+ * See the file header. Given the week's planned recipes (already resolved
+ * to reference views), returns the display legend plus the ordered phases:
+ *
+ * 1. **Mise en place** (`"mise-en-place"`) — every `merged-prep` task, then
+ *    every leftover pure-prep step, then every `SETUP` step. Omitted
+ *    entirely if it would be empty.
+ * 2. **Cooking** (`"cooking"` / `"finishing"`) — the recipes interleaved:
+ *    each phase pops the next remaining step of every recipe that still has
+ *    one (passive-cook steps first, so long cooks start early). A passive
+ *    step scheduled in one phase is echoed in every later phase's
+ *    `background` until that recipe's next step is popped.
+ */
+export function optimizeCookingPlan(recipes: OptimizerRecipeInput[]): OptimizeCookingPlanResult {
+  const legend = toRecipeLegend(recipes);
+  const normalized = recipes.map((recipe, index) => normalizeRecipe(recipe, index));
+  const allSteps = normalized.flat();
+
+  const mergedPrep = extractMergedPrep(allSteps);
+
+  const phases: CookingPhaseView[] = [];
+
+  // Phase 0 — mise en place.
+  const miseTasks: CookingTaskView[] = [...mergedPrep];
+  for (const step of allSteps) {
+    if (step.absorbed) continue;
+    if (step.isPurePrep || step.attention === "SETUP") {
+      miseTasks.push(stepToTask(step));
+      step.absorbed = true; // consumed here, not again in the cooking loop
+    }
+  }
+  if (miseTasks.length > 0) {
+    phases.push({ index: 0, kind: "mise-en-place", tasks: miseTasks, background: [] });
+  }
+
+  // Cooking phases — one "next step of each recipe" per phase. `hold` keeps
+  // a recipe out of the *next* phase right after it starts a passive cook,
+  // so another recipe's active work fills that phase and the passive cook
+  // shows up as `background` there instead of being immediately followed by
+  // its own next step.
+  const queues = normalized.map((steps) => ({
+    remaining: steps.filter((s) => !s.absorbed),
+    cursor: 0,
+    hold: 0,
+  }));
+  /** Passive steps started in an earlier phase, keyed by recipe index, still "cooking". */
+  const runningPassive = new Map<number, NormalizedStep>();
+
+  while (queues.some((queue) => queue.cursor < queue.remaining.length)) {
+    const phaseSteps: NormalizedStep[] = [];
+    queues.forEach((queue, recipeIndex) => {
+      const next = queue.remaining[queue.cursor];
+      if (!next) return;
+      if (queue.hold > 0) {
+        // Still tending its passive cook this phase — leave it in
+        // `runningPassive` so it renders as background, don't advance.
+        queue.hold--;
+        return;
+      }
+      // This recipe is advancing — whatever passive cook it had going is
+      // now being tended to, so it stops showing as background.
+      runningPassive.delete(recipeIndex);
+      phaseSteps.push(next);
+      queue.cursor++;
+    });
+
+    // Every recipe with steps left is holding on a passive cook — break the
+    // stall by releasing all holds and letting the next iteration advance.
+    if (phaseSteps.length === 0) {
+      for (const queue of queues) queue.hold = 0;
+      continue;
+    }
+
+    // Background = passive cooks from earlier phases not yet resolved above.
+    const background = [...runningPassive.values()].map(stepToBackground);
+
+    // Start the long cooks first within the phase.
+    phaseSteps.sort((a, b) => {
+      const rank = (s: NormalizedStep) => (s.attention === "PASSIVE" ? 0 : 1);
+      return rank(a) - rank(b) || a.recipeIndex - b.recipeIndex;
+    });
+
+    const tasks = phaseSteps.map(stepToTask);
+    phases.push({
+      index: phases.length,
+      kind: cookingPhaseKind(tasks),
+      tasks,
+      background,
+    });
+
+    for (const step of phaseSteps) {
+      if (step.attention === "PASSIVE") {
+        runningPassive.set(step.recipeIndex, step);
+        const queue = queues[step.recipeIndex];
+        if (queue) queue.hold = 1;
+      }
+    }
+  }
+
+  // `index` was set from `phases.length` as we went; re-stamp so it always
+  // matches the final array position even if phase 0 was skipped.
+  phases.forEach((phase, index) => {
+    phase.index = index;
+  });
+
+  return { recipes: legend, phases };
+}

apps/api/src/modules/cooking-session/cooking-session.routes.ts

@@ -0,0 +1,37 @@
+import { parseDateOnly } from "@batch-cooking/date-tools";
+import { HttpError } from "@batch-cooking/error-tools";
+import { wrapAsyncHandler } from "@batch-cooking/express-tools";
+import { ErrorCode, getCookingSessionSchema } from "@batch-cooking/shared";
+import { Router } from "express";
+import { type AuthLocals, requireAuth } from "../../middlewares/require-auth.js";
+import { getCookingPlanForDate } from "./cooking-session.service.js";
+
+/** Router mounted at `/cooking-session` in app.ts. */
+export const cookingSessionRouter = Router();
+
+/**
+ * Returns the authenticated user's household's optimized cooking plan for
+ * the week covering `?date=` (`YYYY-MM-DD`) — every recipe planned that
+ * week reorganized into ordered phases (see {@link getCookingPlanForDate}).
+ * Always `200`, never `null` — no household or nothing planned that week
+ * both come back as a normal `OptimizedCookingPlanView` with empty
+ * `recipes`/`phases`. Same request contract as `GET /shopping-list`.
+ */
+cookingSessionRouter.get(
+  "/",
+  requireAuth,
+  wrapAsyncHandler<unknown, AuthLocals>(async (req, res) => {
+    const input = getCookingSessionSchema.parse(req.query);
+    const date = parseDateOnly(input.date);
+    if (date === null) {
+      throw new HttpError(
+        400,
+        ErrorCode.VALIDATION_ERROR,
+        `Not a real calendar date: ${input.date}`,
+      );
+    }
+
+    const plan = await getCookingPlanForDate(res.locals.userProfile.houseId, date);
+    res.status(200).json(plan);
+  }),
+);

apps/api/src/modules/cooking-session/cooking-session.service.ts

@@ -0,0 +1,168 @@
+import { type DateTime, getWeekStart, toDateOnly } from "@batch-cooking/date-tools";
+import type { CookingTaskIngredientView, OptimizedCookingPlanView } from "@batch-cooking/shared";
+import type { Prisma } from "@prisma/client";
+import { prisma } from "../../db/prisma.js";
+import {
+  type OptimizerRecipeInput,
+  type OptimizerStepInput,
+  optimizeCookingPlan,
+} from "../../lib/recipe-matching/cooking-optimizer.js";
+import { toIngredientView, toUnitView } from "../recipe/recipe.service.js";
+
+/**
+ * Prisma `include` for a `Planning` query that needs, for every item, its
+ * recipe's ordered steps with the full detected-technique tree — the raw
+ * material the optimizer works on (see `cooking-optimizer.ts`). It's the
+ * `steps` sub-tree of `recipe.service.ts`'s own `recipeInclude`, resolved
+ * the same way so {@link toIngredientView}/{@link toUnitView} can be reused
+ * as-is; deliberately narrower than a full `RecipeView` fetch (no
+ * diets/favorites/recipe-level ingredient list — the optimizer reads
+ * quantities off the technique clauses, not the recipe header).
+ */
+function cookingSessionPlanningInclude() {
+  return {
+    items: {
+      include: {
+        recipe: {
+          select: {
+            id: true,
+            name: true,
+            portions: true,
+            steps: {
+              orderBy: { order: "asc" },
+              include: {
+                techSteps: {
+                  orderBy: { order: "asc" },
+                  include: {
+                    techStep: true,
+                    ingredients: {
+                      include: {
+                        ingredient: {
+                          include: {
+                            allergies: { include: { allergy: { include: { category: true } } } },
+                            diets: { include: { diet: true } },
+                          },
+                        },
+                        unit: true,
+                      },
+                    },
+                    utensils: { include: { utensil: true } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  } satisfies Prisma.PlanningInclude;
+}
+
+type PlanningWithSteps = Prisma.PlanningGetPayload<{
+  include: ReturnType<typeof cookingSessionPlanningInclude>;
+}>;
+type PlanningItemWithSteps = PlanningWithSteps["items"][number];
+
+/**
+ * Maps one planning item's recipe (with {@link cookingSessionPlanningInclude})
+ * to the optimizer's pure input shape — ingredient/unit/technique/utensil
+ * rows resolved to their reference views here so the optimizer itself never
+ * touches Prisma. `Decimal` quantities become plain numbers (same
+ * `Number(...)` conversion as `recipe.service.ts`'s own view mappers); an
+ * unresolved-unit line keeps `unit: null`.
+ */
+function toOptimizerRecipe(item: PlanningItemWithSteps): OptimizerRecipeInput {
+  const steps: OptimizerStepInput[] = item.recipe.steps.map((step) => ({
+    stepId: step.id,
+    order: step.order,
+    description: step.description,
+    techSteps: step.techSteps.map((techStep) => {
+      const ingredients: CookingTaskIngredientView[] = techStep.ingredients.map((line) => ({
+        ingredient: toIngredientView(line.ingredient),
+        quantity: line.quantity === null ? null : Number(line.quantity),
+        unit: line.unit === null ? null : toUnitView(line.unit),
+      }));
+      return {
+        techStep: { id: techStep.techStep.id, key: techStep.techStep.key },
+        order: techStep.order,
+        ingredients,
+        utensils: techStep.utensils.map(({ utensil }) => ({ id: utensil.id, key: utensil.key })),
+      };
+    }),
+  }));
+
+  return {
+    recipeId: item.recipe.id,
+    name: item.recipe.name,
+    // The slot's own portion count vs. the recipe's as-written yield — the
+    // optimizer scales technique-clause quantities by the ratio, same
+    // reasoning as `shopping-list.service.ts`'s `aggregateShoppingList`.
+    portions: item.portions,
+    recipePortions: item.recipe.portions,
+    steps,
+  };
+}
+
+/**
+ * Builds the household's optimized cooking plan for the week covering
+ * `date` — every recipe planned that week, reorganized into ordered phases
+ * that pool shared prep and float passive cooks into the background (see
+ * `cooking-optimizer.ts`). `date` follows the same convention as
+ * `planning.service.ts`'s `getPlanningForDate` (a caller-parsed `?date=`,
+ * not necessarily a Monday).
+ *
+ * Like `getShoppingListForDate` and unlike `getPlanningForDate`, this
+ * **never** returns `null` — no household and "no planning covers this week
+ * yet" both degrade to an empty `phases`/`recipes` on an otherwise normal
+ * {@link OptimizedCookingPlanView} (the week's date range is always
+ * computable from `date` alone).
+ */
+export async function getCookingPlanForDate(
+  houseId: number | null,
+  date: DateTime,
+): Promise<OptimizedCookingPlanView> {
+  try {
+    const weekStart = getWeekStart(toDateOnly(date));
+    const weekFinish = weekStart.plus({ days: 6 });
+    const emptyPlan: OptimizedCookingPlanView = {
+      startDate: weekStart.toJSDate().toISOString(),
+      finishDate: weekFinish.toJSDate().toISOString(),
+      recipes: [],
+      phases: [],
+    };
+
+    if (houseId === null) {
+      return emptyPlan;
+    }
+
+    // Same "covering range" lookup as getShoppingListForDate — see
+    // getPlanningForDate's doc comment for the UTC-midnight `Date` rationale.
+    const dateOnly = toDateOnly(date).toJSDate();
+    const planning = await prisma.planning.findFirst({
+      where: {
+        houseId,
+        startDate: { lte: dateOnly },
+        finishDate: { gte: dateOnly },
+      },
+      orderBy: { startDate: "desc" },
+      include: cookingSessionPlanningInclude(),
+    });
+
+    if (!planning) {
+      return emptyPlan;
+    }
+
+    const { recipes, phases } = optimizeCookingPlan(planning.items.map(toOptimizerRecipe));
+    return {
+      startDate: planning.startDate.toISOString(),
+      finishDate: planning.finishDate.toISOString(),
+      recipes,
+      phases,
+    };
+  } catch (err) {
+    // Rethrown as-is — `wrapAsyncHandler`/the error middleware handles it,
+    // this service layer just isn't allowed a bare `await` per the repo's
+    // async/try-catch convention.
+    throw err;
+  }
+}

apps/api/test/cooking-session.test.ts

@@ -0,0 +1,204 @@
+import type { DateTime } from "@batch-cooking/date-tools";
+import { ErrorCode, type SignupInput } from "@batch-cooking/shared";
+import { faker } from "@faker-js/faker";
+import { expect } from "chai";
+import request from "supertest";
+import { createApp } from "../src/app.js";
+import { prisma } from "../src/db/prisma.js";
+import { TEST_REFERENCE_DATE } from "../test-support/reference-date.js";
+import { resetDatabase } from "../test-support/reset-db.js";
+
+/** See `auth.test.ts` — same rationale for generating rather than hardcoding. */
+function buildSignupPayload(): SignupInput {
+  const firstName = faker.person.firstName();
+  const lastName = faker.person.lastName();
+  return {
+    firstName,
+    lastName,
+    email: faker.internet.email({ firstName, lastName }).toLowerCase(),
+    password: faker.internet.password({ length: 16 }),
+  };
+}
+
+/** `toISODate()` only returns `null` for an invalid `DateTime` — never the always-valid values here. */
+function isoDate(date: DateTime): string {
+  const iso = date.toISODate();
+  if (iso === null) throw new Error("Unexpectedly invalid DateTime in a test helper");
+  return iso;
+}
+
+/** The fixed test "today", as the `YYYY-MM-DD` string the `?date=` query expects. */
+function today(): string {
+  return isoDate(TEST_REFERENCE_DATE);
+}
+
+/** Resolves a reference row's id by its `reference-seed-data.ts` uid (also its DB `key`) — same helpers as `recipe.test.ts`. */
+async function ingredientId(key: string): Promise<number> {
+  return (await prisma.ingredient.findFirstOrThrow({ where: { key } })).id;
+}
+async function unitId(key: string): Promise<number> {
+  return (await prisma.unit.findFirstOrThrow({ where: { key } })).id;
+}
+async function techStepId(key: string): Promise<number> {
+  return (await prisma.techStep.findFirstOrThrow({ where: { key } })).id;
+}
+
+describe("Cooking session", () => {
+  const app = createApp();
+
+  beforeEach(async () => {
+    await resetDatabase();
+  });
+
+  after(async () => {
+    await prisma.$disconnect();
+  });
+
+  describe("GET /cooking-session", () => {
+    it("rejects requests without a session cookie with 401 NOT_AUTHENTICATED", async () => {
+      const res = await request(app).get("/cooking-session").query({ date: today() });
+
+      expect(res.status).to.equal(401);
+      expect(res.body.code).to.equal(ErrorCode.NOT_AUTHENTICATED);
+    });
+
+    it("rejects a malformed date with 400 VALIDATION_ERROR", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+
+      const res = await agent.get("/cooking-session").query({ date: "not-a-date" });
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+    });
+
+    it("returns an empty plan when the profile has no household", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+
+      const res = await agent.get("/cooking-session").query({ date: today() });
+
+      expect(res.status).to.equal(200);
+      expect(res.body.recipes).to.deep.equal([]);
+      expect(res.body.phases).to.deep.equal([]);
+    });
+
+    it("returns an empty plan when no planning covers that week", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+      await agent.post("/house").send({ name: "Chez moi" });
+
+      const res = await agent.get("/cooking-session").query({ date: today() });
+
+      expect(res.status).to.equal(200);
+      expect(res.body.phases).to.deep.equal([]);
+    });
+
+    it("pools an identical prep step from two planned recipes into one merged-prep task", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+      const houseRes = await agent.post("/house").send({ name: "Chez moi" });
+      const houseId: number = houseRes.body.id;
+      const authorId: number = houseRes.body.adminId;
+
+      const onionId = await ingredientId("onion");
+      const pieceId = await unitId("piece");
+      const chopId = await techStepId("chop");
+      const simmerId = await techStepId("simmer");
+
+      /** A recipe: one pure-prep "chop onion" step, then one simmer step. */
+      async function makeRecipe(name: string, onionQty: number) {
+        return prisma.recipe.create({
+          data: {
+            name,
+            authorId,
+            portions: 4,
+            steps: {
+              create: [
+                {
+                  order: 0,
+                  description: "Émincer les oignons",
+                  techSteps: {
+                    create: [
+                      {
+                        techStepId: chopId,
+                        order: 0,
+                        ingredients: {
+                          create: [
+                            {
+                              ingredientId: onionId,
+                              quantity: onionQty,
+                              unitId: pieceId,
+                              start: 0,
+                              end: 1,
+                            },
+                          ],
+                        },
+                      },
+                    ],
+                  },
+                },
+                {
+                  order: 1,
+                  description: "Faire mijoter",
+                  techSteps: { create: [{ techStepId: simmerId, order: 0 }] },
+                },
+              ],
+            },
+          },
+        });
+      }
+
+      const soupe = await makeRecipe("Soupe", 2);
+      const tarte = await makeRecipe("Tarte", 3);
+
+      const planning = await prisma.planning.create({
+        data: {
+          houseId,
+          startDate: TEST_REFERENCE_DATE.minus({ days: 2 }).toJSDate(),
+          finishDate: TEST_REFERENCE_DATE.plus({ days: 2 }).toJSDate(),
+        },
+      });
+      await prisma.planningItem.createMany({
+        data: [
+          {
+            planningId: planning.id,
+            weekDay: "lundi",
+            meal: "dejeuner",
+            recipeId: soupe.id,
+            portions: 4,
+          },
+          {
+            planningId: planning.id,
+            weekDay: "mardi",
+            meal: "diner",
+            recipeId: tarte.id,
+            portions: 4,
+          },
+        ],
+      });
+
+      const res = await agent.get("/cooking-session").query({ date: today() });
+
+      expect(res.status).to.equal(200);
+      expect(res.body.recipes.map((r: { name: string }) => r.name)).to.have.members([
+        "Soupe",
+        "Tarte",
+      ]);
+
+      const mise = res.body.phases[0];
+      expect(mise.kind).to.equal("mise-en-place");
+      const merged = mise.tasks.filter((t: { kind: string }) => t.kind === "merged-prep");
+      expect(merged).to.have.length(1);
+      expect(merged[0].technique.key).to.equal("chop");
+      expect(merged[0].ingredients[0].ingredient.key).to.equal("onion");
+      expect(merged[0].ingredients[0].quantity).to.equal(5);
+      expect(merged[0].sourceRecipes).to.have.length(2);
+
+      // The simmer steps land in a later phase, and one shows as background.
+      const later = res.body.phases.slice(1);
+      const backgrounds = later.flatMap((p: { background: unknown[] }) => p.background);
+      expect(backgrounds.length).to.be.greaterThan(0);
+    });
+  });
+});

packages/shared/src/index.ts

@@ -8,6 +8,7 @@ export * from "./data/catalog-labels-fr.js";
 export * from "./errors/error-codes.js";
 export * from "./schemas/account.js";
 export * from "./schemas/auth.js";
+export * from "./schemas/cooking-session.js";
 export * from "./schemas/household.js";
 export * from "./schemas/planning.js";
 export * from "./schemas/preferences.js";
@@ -17,6 +18,7 @@ export * from "./schemas/shopping-list.js";
 export * from "./schemas/sources.js";
 export * from "./schemas/tech-step-worker.js";
 export * from "./tools/assert-is-never.js";
+export * from "./types/cooking-session.js";
 export * from "./types/household.js";
 export * from "./types/planning.js";
 export * from "./types/preferences.js";

packages/shared/src/schemas/cooking-session.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+// See schemas/auth.ts for the shared client/server validation rationale.
+
+/**
+ * Payload accepted by `GET /cooking-session`'s `?date=` query param — same
+ * shape/rationale as `schemas/shopping-list.ts`'s `getShoppingListSchema`
+ * (only the `YYYY-MM-DD` shape is checked here; real-calendar-date
+ * validation is service-side via `@batch-cooking/date-tools`'s
+ * `parseDateOnly`). Kept as its own schema rather than importing another
+ * module's near-identical one — each router owns its own request contract
+ * in this repo, even when two happen to share a shape.
+ */
+export const getCookingSessionSchema = z.object({
+  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date invalide"),
+});
+/** Inferred TS type for {@link getCookingSessionSchema}'s validated output. */
+export type GetCookingSessionInput = z.infer<typeof getCookingSessionSchema>;

packages/shared/src/types/cooking-session.ts

@@ -0,0 +1,120 @@
+import type { IngredientView, TechStepView, UnitView, UtensilView } from "./reference.js";
+
+/**
+ * A recipe that contributes to an optimized cooking plan, resolved to just
+ * enough for a display legend / provenance badge — same "resolve to
+ * `{id, name}` and nothing more" treatment as `PlanningItemView.recipe`.
+ * `portions` is this contribution's own portion count (the `PlanningItem`'s,
+ * not `Recipe.portions`), since the plan scales quantities to it.
+ */
+export interface CookingSessionRecipeRef {
+  recipeId: number;
+  name: string;
+  portions: number;
+}
+
+/**
+ * Which stage of the session a {@link CookingPhaseView} belongs to. Not a
+ * free-form title — the label is resolved client-side via
+ * `t(\`cookingSession.phase.${kind}\`)`, same "API sends a key, web owns the
+ * wording" split as every reference catalog:
+ *
+ * - `"mise-en-place"` — the first phase: all shared prep pooled together
+ *   (`chop`/`peel`/… the same ingredient across recipes = one task) plus
+ *   `SETUP` tasks (preheat the oven, bring water to a boil).
+ * - `"cooking"` — the interleaved middle phases, one "next ready step of
+ *   each recipe" per phase, with passive cooks floated into `background`.
+ * - `"finishing"` — the last phase when it only holds plating/`plate` work.
+ */
+export type CookingPhaseKind = "mise-en-place" | "cooking" | "finishing";
+
+/**
+ * One ingredient line attached to a {@link CookingTaskView} — the same
+ * `(ingredient, quantity, unit)` shape as `StepTechStepIngredientView`,
+ * carried through so the cook sees "3 oignons" next to "Émincer". Both
+ * `quantity` and `unit` are `null` when the source clause named the
+ * ingredient with no measurable amount ("ajouter le sel"), or when a
+ * merge pooled two incompatible units and no single total could be given
+ * (see {@link CookingTaskView.kind}).
+ */
+export interface CookingTaskIngredientView {
+  ingredient: IngredientView;
+  quantity: number | null;
+  unit: UnitView | null;
+}
+
+/**
+ * One actionable unit of work in a phase's `tasks` list.
+ *
+ * - `kind: "step"` — a single recipe step, run as written. `technique` is
+ *   its dominant detected technique (or `null` if it mentions none),
+ *   `description` is the original step text, `sourceRecipes` has exactly one
+ *   entry.
+ * - `kind: "merged-prep"` — shared preparation pooled across recipes: the
+ *   same prep technique applied to the same ingredient by two or more
+ *   recipes, collapsed into one task (the "mutualise the onions" case).
+ *   `description` is `null` (the web layer composes a label from
+ *   `technique` + `ingredients`), `sourceRecipes` lists every recipe it
+ *   covers, and `ingredients` holds the pooled quantity.
+ *
+ * `id` is stable within a single response (`"prep:<techniqueKey>:<ingredientKey>"`
+ * or `"step:<stepId>"`) so the frontend can key a checklist off it.
+ * `originalSteps` is the provenance trail — the exact step text(s) this
+ * task stands in for, so the UI can link back to "voir la recette".
+ */
+export interface CookingTaskView {
+  id: string;
+  kind: "merged-prep" | "step";
+  technique: TechStepView | null;
+  description: string | null;
+  ingredients: CookingTaskIngredientView[];
+  utensils: UtensilView[];
+  sourceRecipes: CookingSessionRecipeRef[];
+  originalSteps: { recipeId: number; recipeName: string; description: string }[];
+}
+
+/**
+ * A passive cook (simmer, braise, bake, marinate…) started in an earlier
+ * phase and still running — surfaced in every later phase's `background`
+ * until the step that consumes it comes up, so the cook is reminded "the
+ * beef is still braising" while doing active work from another recipe. Not
+ * something to act on now, just a status line, hence a thinner shape than
+ * {@link CookingTaskView}.
+ */
+export interface CookingBackgroundTaskView {
+  id: string;
+  technique: TechStepView | null;
+  description: string;
+  recipeId: number;
+  recipeName: string;
+}
+
+/**
+ * One phase of the optimized plan: a batch of work the cook does now
+ * (`tasks`), plus any passive cooks carried over from before (`background`).
+ * `index` is 0-based and matches the array position — carried explicitly so
+ * a caller rendering a single phase still knows where it sits.
+ */
+export interface CookingPhaseView {
+  index: number;
+  kind: CookingPhaseKind;
+  tasks: CookingTaskView[];
+  background: CookingBackgroundTaskView[];
+}
+
+/**
+ * A household's week of planned recipes, reorganized into an ordered
+ * sequence of cooking phases (see `apps/api`'s `cooking-optimizer.ts`).
+ *
+ * Like `ShoppingListView` and unlike `PlanningView`, this is **never**
+ * `null` — no household, or a household with nothing planned that week,
+ * both degrade to an empty `phases` array on an otherwise normal object
+ * (the week's date range is always computable), not a separate "nothing to
+ * show" state the frontend has to branch on.
+ */
+export interface OptimizedCookingPlanView {
+  startDate: string;
+  finishDate: string;
+  recipes: CookingSessionRecipeRef[];
+  phases: CookingPhaseView[];
+}

specs/backend-architecture.md

@@ -296,6 +296,57 @@ telles quelles par typage structurel.
 
 ---
 
+## Cooking session — optimisation des étapes planifiées
+
+Router `/cooking-session` (`cooking-session.routes.ts`/`.service.ts`),
+`requireAuth` — un seul endpoint : `GET /cooking-session?date=YYYY-MM-DD` →
+`getCookingPlanForDate` → `OptimizedCookingPlanView`. Même contrat `?date=`
+que `GET /shopping-list` (schéma shape-only + `parseDateOnly`), même requête
+"plage couvrante" que `getPlanningForDate`, et **jamais `null`** de la même
+façon que la liste de courses : pas de foyer / aucun `Planning` couvrant la
+semaine ⇒ `recipes: []`, `phases: []`.
+
+C'est la première brique du module « Calcul batch-cooking »
+([batch-cooking-architecture.md](./batch-cooking-architecture.md)),
+jusqu'ici `TODO`. Le service ne fait que **charger + façonner** : sa requête
+Prisma (`cookingSessionPlanningInclude`) reprend le sous-arbre `steps` de
+`recipe.service.ts`'s `recipeInclude` (steps ordonnés → `StepTechStep`
+ordonnés → `techStep` + `ingredients` résolus + `utensils`), puis
+`toOptimizerRecipe` mappe chaque `PlanningItem` vers l'entrée pure de
+l'optimiseur (ingrédients/unités/techniques/ustensiles déjà en vues de
+référence via `toIngredientView`/`toUnitView` réutilisées — même raison que
+`shopping-list.service.ts`). Un `PlanningItem` = une entrée d'optimiseur,
+même si deux créneaux pointent la même recette à des portions différentes
+(deux vraies préparations ; la mutualisation de la découpe les regroupe
+quand même).
+
+**`optimizeCookingPlan`** (`lib/recipe-matching/cooking-optimizer.ts`,
+pure/synchrone — testable sans base, même split que `ingredient-matcher.ts`
+/ `tech-step-matcher.ts`) réorganise les recettes en **phases ordonnées** :
+
+- **Mutualisation de la mise en place** : une technique de découpe
+  (`PREP_TECHNIQUES` : `chop`/`peel`/`mince`/`julienne`/…) appliquée au même
+  ingrédient dans une étape *purement prep* (toutes ses techniques sont des
+  `PREP_TECHNIQUES`) de **≥ 2 recettes** est regroupée en une tâche
+  `merged-prep` ; les étapes d'origine sont *absorbées* (ne produisent plus
+  de tâche). Une découpe présente dans une seule recette reste inline (juste
+  classée en mise en place). Les découpes à l'intérieur d'une étape de
+  cuisson ne sont pas mutualisées en v1.
+- **Parallélisme** : `TECHNIQUE_ATTENTION` classe chaque étape en `SETUP`
+  (préchauffage, eau à ébullition — poussé en mise en place), `PASSIVE`
+  (mijoter, braiser, cuire au four, mariner… — non surveillé une fois
+  lancé) ou `ACTIVE` (défaut). Les phases de cuisson interclassent les
+  recettes (une « prochaine étape de chaque recette » par phase) ; une
+  étape `PASSIVE` fait patienter sa recette une phase et s'affiche en
+  `background` des phases suivantes tant que sa consommatrice n'est pas
+  remontée.
+
+Quantités mises à l'échelle par `PlanningItem.portions / Recipe.portions`
+comme la liste de courses. Sommes d'ingrédients uniquement à unité
+identique (aucune conversion — même posture que `ShoppingListItemView`).
+
+---
+
 ## `reference` — catalogues publics (pas de session requise)
 
 Router `/reference` (`reference.routes.ts`/`.service.ts`) — **toutes les

specs/batch-cooking-architecture.md

@@ -16,7 +16,7 @@ L'application repose sur une architecture **client-serveur** classique :
 flowchart TB
   subgraph SERVER["Server"]
     API["API (REST)"]
-    CALC["Calcul batch-cooking<br/><i>(TODO)</i>"]
+    CALC["Calcul batch-cooking<br/><i>v1 implémentée (GET /cooking-session)</i>"]
     IMPORT["Import d'une recette<br/><i>implémenté</i>"]
     IMP1["Import depuis source<br/>(RecipeSourceAdapter)"]
     IMP2["Traduction en étapes<br/>(ingrédients + techniques)"]
@@ -38,8 +38,8 @@ flowchart TB
 ```
 
 *(Le canal websocket envisagé dans la conception d'origine pour le calcul
-batch-cooking temps réel n'existe pas encore — rien à documenter tant que ce
+batch-cooking temps réel n'existe pas encore — le module v1 est un `GET`
-module reste TODO ; voir la note plus bas.)*
+recalculé à chaque visite, pas de temps réel ; voir la note plus bas.)*
 
 ---
 
@@ -49,7 +49,7 @@ module reste TODO ; voir la note plus bas.)*
 Point d'entrée principal pour les échanges entre les clients et le serveur — REST classique, `requireAuth` (cookie JWT httpOnly) sur toute route qui n'est pas une donnée de référence publique. Détail complet des modules : [backend-architecture.md](./backend-architecture.md).
 
 ### Module « Calcul batch-cooking »
-Logique de calcul du batch-cooking (optimisation du planning/des recettes selon le planning). **Statut : TODO — reste à développer**, avec `packages/shared`'s `assertIsNever` déjà en place comme outil prêt à l'emploi pour ce futur module (voir [backend-architecture.md](./backend-architecture.md#packagesshared--assertisnever)).
+Logique de calcul du batch-cooking (optimisation des recettes entre elles selon le planning). **Statut : v1 implémentée** — `GET /cooking-session?date=` → `optimizeCookingPlan` (`apps/api/src/lib/recipe-matching/cooking-optimizer.ts`, pur) réorganise les recettes d'une semaine planifiée en **phases ordonnées** : une « mise en place » qui mutualise la découpe commune (même technique de découpe + même ingrédient dans une étape purement prep de ≥ 2 recettes = une seule tâche), puis des phases de cuisson qui interclassent les recettes en poussant les cuissons passives (mijotage, four…) en tâche de fond. v1 hors périmètre : fusion de cuissons, durées estimées, persistance/progression, canal websocket. Détail : [backend-architecture.md](./backend-architecture.md#cooking-session--optimisation-des-étapes-planifiées).
 
 ### Module « Import d'une recette »
 **Statut : implémenté.** Pipeline en trois étapes, comme prévu à la conception :
@@ -91,15 +91,15 @@ détectées, favoris, visibilité des recettes).
   [backend-architecture.md](./backend-architecture.md#liste-de-courses--agrégation-des-ingrédients-planifiés))
   — une simple **agrégation** des ingrédients déjà planifiés (somme par
   ingrédient/unité, mise à l'échelle par les portions de chaque créneau),
-  pas une optimisation. Le module « Calcul batch-cooking » lui-même reste
+  pas une optimisation. Le module « Calcul batch-cooking », lui, optimise les
-  `TODO` : il désigne quelque chose de plus ambitieux qu'une somme
+  recettes **entre elles** (mutualiser une préparation commune, paralléliser
-  d'ingrédients — optimiser le planning/les recettes entre elles (ex.
+  les cuissons passives) — **v1 implémentée** via `GET /cooking-session`
-  mutualiser une préparation entre plusieurs recettes de la semaine), pas
+  (voir [backend-architecture.md](./backend-architecture.md#cooking-session--optimisation-des-étapes-planifiées)).
-  encore défini plus précisément. C'est le principal chantier restant côté
-  serveur.
 - Le canal websocket envisagé pour la communication temps réel n'a pas encore
-  été construit — rien ne le remplace aujourd'hui (pas de polling), à
+  été construit — rien ne le remplace aujourd'hui (pas de polling). Le calcul
-  reconsidérer au moment d'attaquer le calcul batch-cooking.
+  batch-cooking v1 est un simple `GET` recalculé à chaque visite (comme la
+  liste de courses), pas de temps réel ; à reconsidérer si une session de
+  cuisine partagée/synchronisée est ajoutée.
 
 ---