Merge pull request 'ci(release): publie les images Docker sur le registre Forgejo' (#145) from feat/release-push-docker-images into main

Reviewed-on: #145

.env.example

@@ -15,6 +15,14 @@ JWT_SECRET=changeme-generate-a-real-random-secret-at-least-32-chars
 # (docker-compose.yml), serving both the API and the built frontend.
 # APP_PORT=3000
 
+# Optional — tag of the prebuilt images the release CI pushes to the Forgejo
+# container registry (git.dev.kyuno.fr/kyuno/batchcooking-{app,intent-service,
+# llm-worker}). Used by `docker compose pull` and a pull-based Portainer
+# stack; leave it `latest` or pin a release tag (e.g. v0.2.4). Ignored when
+# building locally instead (`docker compose build`, or `up` with no image
+# present) — see docker-compose.yml's `image:`/`build:` comment.
+# IMAGE_TAG=latest
+
 # --- Admin surface (apps/web's /admin/* routes + the /admin/* API) --------
 # All optional: an instance that doesn't run the admin app needs none of
 # these. `requireAdmin` fails closed when ADMIN_JWT_SECRET is unset, so
@@ -32,6 +40,17 @@ JWT_SECRET=changeme-generate-a-real-random-secret-at-least-32-chars
 # ADMIN_INITIAL_EMAIL=ops@example.com
 # ADMIN_INITIAL_PASSWORD=changeme-at-least-8-chars
 # ADMIN_INITIAL_NAME=Ops
+#
+# Optional — lets an admin open a Forgejo ticket from a contact message
+# (apps/web's /admin/messages, issue #81). All three needed together: the
+# button stays hidden and the endpoint answers 503 unless all are set to a
+# non-empty value. docker-compose.yml forwards these into the "app"
+# container, so setting them here is enough (a blank value counts as
+# unset). FORGEJO_TOKEN is a personal access token with the write:issue
+# scope — generate it in Forgejo, never commit the real value.
+# FORGEJO_BASE_URL=https://git.example.com
+# FORGEJO_TOKEN=changeme-a-forgejo-personal-access-token
+# FORGEJO_REPO=owner/repo
 
 # Optional — only set this to false if THIS deployment is served over
 # plain HTTP (no TLS in front of it). Left unset, the session cookie

.github/workflows/ci.yml

@@ -39,6 +39,13 @@ env:
   # services/tech-step-intent-service/Dockerfile from this checkout.
   INTENT_SERVICE_BASE_URL: "http://localhost:8000"
   INTENT_SERVICE_SECRET: "ci-only-intent-secret-not-used-anywhere-else-32chars+"
+  # Same reasoning — lets forgejo.service.test.ts / admin-contact.test.ts
+  # exercise the "configured" path (issue #81). `globalThis.fetch` is stubbed
+  # in those tests, so no real request ever leaves CI; these values only need
+  # to parse (a valid URL and an `owner/repo`).
+  FORGEJO_BASE_URL: "https://forgejo.ci.invalid"
+  FORGEJO_TOKEN: "ci-only-forgejo-token-not-used-anywhere-else"
+  FORGEJO_REPO: "ci/batchcooking"
 
 jobs:
   # Five independent jobs, no needs: between them — each starts in parallel
@@ -61,17 +68,70 @@ jobs:
 
   test:
     runs-on: ubuntu-latest
+    # ~16-19 min of actual work (runs 117-124); the extra budget covers time
+    # spent queued in "Wait for any earlier test job" below. Also a runaway
+    # ceiling — Mocha has no `--exit` (`apps/api/.mocharc.json`), so one
+    # leaked handle would otherwise hang the job until the runner's global
+    # timeout (a `test` job zombied ~1h once). If a hung job hits this
+    # ceiling the runner removes its container, which unblocks the queue.
+    timeout-minutes: 45
     steps:
       - name: Install curl and the docker CLI
         run: |
           apt-get update && apt-get install -y curl docker.io
 
+      # Serialize `test` across every concurrent run. Two `test` jobs must
+      # never overlap: they share one `--name postgres` container on the
+      # runner's shared docker network (next step), so their `prisma migrate
+      # deploy` + `seedReferenceData` (root Mocha `beforeAll`) race —
+      # `Unique constraint failed on (key)` in `seedReferenceData`, "No
+      # pending migrations" when there should be some, `tech_step`/`diet` id
+      # shifts breaking unrelated assertions; and even past that they starve
+      # each other's RAM/CPU (each also trains a spaCy model) until
+      # `resetDatabase()` overruns Mocha's 10s hook timeout and cascades.
+      # Hit repeatedly (PRs #47, #53, #54), each needing an empty-commit
+      # re-trigger once the runner was idle.
+      #
+      # GitHub's `concurrency:` is the native fix but this Forgejo (9.0.3)
+      # predates Actions `concurrency` — it arrived in Forgejo v14 / Gitea
+      # 1.26 and is silently ignored here. A lock object (network, container,
+      # file) would leak: this runner (forgejo-runner v3.5.0) does NOT run a
+      # trailing `if: always()` step after an earlier step fails, so there is
+      # no reliable in-job release. Instead, key off the one thing the runner
+      # *does* always clean up — the job container itself (removed on pass,
+      # fail, and cancel alike): wait while any lower-numbered `test` job's
+      # container is still running. Lower task id goes first, so two jobs
+      # that start together can't deadlock; nothing to release.
+      - name: Wait for any earlier test job
+        run: |
+          my_id="$(printf '%s\n' "${JOB_CONTAINER_NAME:-}" | sed -n 's/.*TASK-\([0-9]\{1,\}\).*/\1/p')"
+          echo "this test job is task ${my_id:-<unknown, not serializing>}"
+          # ~25 min cap (75 * 20s): comfortably covers one earlier run
+          # (the realistic overlap is two runs); a rarer 3-way pile-up whose
+          # wait exceeds this just fails and gets an empty-commit re-run.
+          for attempt in $(seq 1 75); do
+            earlier="$(docker ps --format '{{.Names}}' 2>/dev/null \
+              | sed -n 's/.*TASK-\([0-9]\{1,\}\)_.*_JOB-test$/\1/p' \
+              | awk -v me="${my_id:-0}" 'NF && ($1 + 0) < (me + 0)')"
+            if [ -z "$earlier" ]; then
+              [ "$attempt" -gt 1 ] && echo "earlier test job(s) finished — proceeding"
+              exit 0
+            fi
+            echo "waiting for earlier test job(s): $(printf '%s ' $earlier)(attempt ${attempt})"
+            sleep 20
+          done
+          echo "still blocked by an earlier test job after ~25 min — giving up; a re-run should get through" >&2
+          exit 1
+
       # Postgres as a plain background container instead of a `services:`
       # block — see this workflow's top-level `env.DATABASE_URL` comment for
       # why. Reachable as `postgres` from this job (the runner mounts the
       # docker socket and runs jobs on a shared user-defined network, so a
       # `--name postgres` sibling resolves by name); the network is
-      # discovered from the job container itself rather than hardcoded.
+      # discovered from the job container itself rather than hardcoded. The
+      # `docker rm -f postgres` below also clears a container left behind by
+      # the previous run (this runner has no reliable post-job cleanup), and
+      # the serialization step above means no other run is using it now.
       - name: Start Postgres in the background
         run: |
           net="$(docker inspect "$(hostname)" \
@@ -79,6 +139,15 @@ jobs:
             | awk '{print $1}')"
           echo "job network: ${net:?could not determine the job container network}"
           docker rm -f postgres >/dev/null 2>&1 || true
+          # Also drop any `postgres-<suffix>` container. A since-reverted
+          # attempt at per-run Postgres naming on this branch left some
+          # running on this persistent runner (their `if: always()` teardown
+          # never fired — this runner skips trailing steps after a failure),
+          # and nothing else removes them. A second idle Postgres here starves
+          # the runner's RAM and slows every query ~5x → `resetDatabase()`
+          # blows Mocha's 10s hook timeout. Nothing creates `postgres-*` any
+          # more, so this only ever clears that debris.
+          docker ps -aq --filter 'name=^postgres-' | xargs -r docker rm -f >/dev/null 2>&1 || true
           docker run -d --name postgres --network "$net" \
             -e POSTGRES_USER=ci -e POSTGRES_PASSWORD=ci -e POSTGRES_DB=batchcooking_ci \
             postgres:16-alpine
@@ -203,3 +272,90 @@ jobs:
       # `component.devServer`), unlike `e2e` above which needs the real app
       # running first.
       - run: pnpm --filter web cy:run:component
+
+  # Builds and packages a signed, downloadable Android APK on every push to
+  # `main` — issue #64. `needs:` on every other job is what actually makes
+  # this "build, TEST, and package" rather than just "build and package in
+  # parallel with tests that might still be failing": Forgejo/GitHub Actions
+  # has no native way for a job in a *different* workflow file to block on
+  # one here, so this has to live in this same file to get a real dependency
+  # rather than a same-push coincidence. `if:` (not a separate trigger) keeps
+  # every other job running on every branch as today — only this one is
+  # main-only.
+  #
+  # No dedicated Android test suite exists (zero native code beyond the
+  # Capacitor-generated shell) — "testée" is satisfied by gating on the 5
+  # existing jobs, not by inventing an instrumented test suite for this.
+  #
+  # Unverified on this runner as of writing: no Android build has ever run
+  # on this self-hosted Forgejo `act` runner (unlike lint/test/build/e2e,
+  # exercised for months). If SDK installation turns out too slow/heavy here,
+  # cache `~/.android/sdk`/`~/.gradle` (same idea as the Cypress binary cache
+  # in `e2e` above) rather than accepting a slow job on every push.
+  build-android:
+    runs-on: ubuntu-latest
+    needs: [lint, test, intent-service-test, build, e2e]
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - uses: https://github.com/actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: https://github.com/actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - uses: https://github.com/actions/setup-java@v4
+        with:
+          distribution: temurin
+          # Matches what Android Gradle Plugin 8.x (bundled with the
+          # Capacitor-generated project, see apps/web/android/build.gradle)
+          # expects — bump alongside AGP if that version ever moves.
+          java-version: "21"
+
+      - uses: https://github.com/android-actions/setup-android@v3
+
+      - run: pnpm install --frozen-lockfile
+
+      # Unlike the normal web build (served same-origin as the API), a
+      # packaged Capacitor build runs from the WebView's own local origin and
+      # needs an absolute, public HTTPS URL baked in at build time — see
+      # apps/web/.env.capacitor.example's own comment on this.
+      - name: Build le bundle web pour Capacitor
+        env:
+          VITE_API_URL: ${{ secrets.MOBILE_API_URL }}
+        run: pnpm --filter web build:capacitor
+      - run: pnpm --filter web exec cap sync android
+
+      # Le keystore de release est un secret généré une fois à la main (voir
+      # le README, section "Application mobile") — jamais régénéré ici, un
+      # nouveau keystore casserait la mise à jour de l'appli déjà installée
+      # (Android refuse une signature différente de celle déjà installée).
+      - name: Décode le keystore de release
+        env:
+          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
+        run: echo "$ANDROID_KEYSTORE_BASE64" | base64 -d > apps/web/android/app/release.keystore
+
+      - name: Build l'APK signé
+        working-directory: apps/web/android
+        env:
+          ANDROID_KEYSTORE_PATH: release.keystore
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
+          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
+          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
+        # chmod défensif : le dev de ce repo se fait sous Windows, où le bit
+        # exécutable git de gradlew ne veut rien dire et peut être reperdu
+        # silencieusement par un futur commit — ne pas dépendre uniquement
+        # du mode suivi par git (voir aussi le fix de ce mode lui-même).
+        run: |
+          chmod +x ./gradlew
+          ./gradlew assembleRelease
+
+      # v4+ exige l'API "Results" de GitHub, que ce runner Forgejo self-hosted
+      # ne supporte pas ("GHESNotSupportedError") — v3 utilise encore
+      # l'ancienne API Artifacts (compatible), seule version utilisable ici.
+      - uses: https://github.com/actions/upload-artifact@v3
+        with:
+          name: batchcooking-release.apk
+          path: apps/web/android/app/build/outputs/apk/release/app-release.apk

.github/workflows/release.yml

@@ -1,44 +1,243 @@
 name: Release
 
-# No image registry involved: Portainer is wired to this repo's Git remote
+# On a `vX.Y.Z` tag: build the three service images and push them to this
-# and builds/redeploys apps/api/Dockerfile itself. This workflow sanity-checks
+# Forgejo instance's built-in container registry (git.dev.kyuno.fr/<owner>/
-# that the image actually builds at the tagged commit, publishes a GitHub
+# batchcooking-{app,intent-service,llm-worker}, tagged with the release tag
-# Release, then (best-effort) pings Portainer's deploy webhook so it doesn't
+# and `latest`), build+attach a signed Android APK, publish a Forgejo
-# have to wait for its own polling interval.
+# Release, then (best-effort) ping Portainer's deploy webhook. Portainer can
+# pull those prebuilt images (docker-compose.yml references them via
+# ${IMAGE_TAG}) or keep building from the Git remote — `docker-compose.yml`
+# keeps a `build:` fallback next to every `image:`.
 on:
   push:
     tags: ["v*.*.*"]
 
 permissions:
   contents: write
+  # Lets this workflow's GITHUB_TOKEN push to the Forgejo container registry
+  # (the `build-and-push-images` job below `docker login`s with it). If a
+  # future instance policy scopes the run token tighter, swap that login's
+  # password for a `write:package` PAT added as a repo secret.
+  packages: write
 
 jobs:
-  sanity-build:
+  # Build the three service images at the tagged commit and push them to the
+  # Forgejo container registry. A successful push also *is* the "does it
+  # still build" check the old `sanity-build` job did (which only covered
+  # apps/api). One sequential job, not a per-image matrix: three concurrent
+  # `docker build`s hammer this single persistent runner's Docker daemon
+  # (the contended resource per project memory `ci-forgejo-runner-constraints`)
+  # for no real gain on a release, which is rare and usually runs alone.
+  build-and-push-images:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      # This runner's job containers don't come with docker preinstalled —
+      # same reason ci.yml's `test` job has to do this before its own
+      # `docker run` calls.
+      - name: Install docker
+        run: apt-get update && apt-get install -y docker.io
 
-      # Build only, no push, no registry — just confirms Portainer will be
+      - uses: https://github.com/actions/checkout@v4
-      # able to build this same Dockerfile successfully at this tag before
-      # anyone points it at this ref.
-      - run: docker build -f apps/api/Dockerfile .
 
-  github-release:
+      - name: Build et push des 3 images vers le registre Forgejo
+        env:
+          # The per-run token Forgejo Actions mints — has `packages: write`
+          # via this workflow's `permissions:` block. `docker login` accepts
+          # it as the password for the actor who pushed the tag.
+          REGISTRY_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -eu
+          # $GITHUB_SERVER_URL is "https://git.dev.kyuno.fr" — the registry
+          # is that same host. $GITHUB_REPOSITORY is "<owner>/<repo>"; the
+          # registry namespace is the owner, lower-cased (Forgejo package
+          # names are case-insensitive but the CLI wants a stable form).
+          registry="${GITHUB_SERVER_URL#http*://}"
+          owner="$(printf '%s' "${GITHUB_REPOSITORY%%/*}" | tr '[:upper:]' '[:lower:]')"
+          tag="$GITHUB_REF_NAME"
+          echo "$REGISTRY_TOKEN" | docker login "$registry" -u "$GITHUB_ACTOR" --password-stdin
+
+          # Every Dockerfile's build context is the repo root (see
+          # docker-compose.yml's `build.context: .`), hence the trailing `.`.
+          build_push() {
+            image="$registry/$owner/$1"
+            echo "::group::$1"
+            docker build -f "$2" -t "$image:$tag" -t "$image:latest" .
+            docker push "$image:$tag"
+            docker push "$image:latest"
+            echo "::endgroup::"
+          }
+          build_push batchcooking-app            apps/api/Dockerfile
+          build_push batchcooking-intent-service services/tech-step-intent-service/Dockerfile
+          build_push batchcooking-llm-worker     services/tech-step-llm-worker/Dockerfile
+
+  # Builds the same signed APK as ci.yml's build-android job (issue #64),
+  # with one difference: the version baked into the APK is derived from the
+  # tag itself rather than left at build.gradle's default. Duplicated here
+  # rather than factored into a shared `workflow_call` reusable workflow —
+  # deliberate: reusable-workflow support on this self-hosted Forgejo/act
+  # runner is unverified, and this ~15-line recipe is proven working as-is
+  # in ci.yml; not worth risking a new class of runner-compatibility surprise
+  # (this repo has already hit several — see ci-forgejo-runner-constraints
+  # in project memory) to save a little duplication. Keep both copies in
+  # sync if the Android build steps ever change.
+  build-android-apk:
     runs-on: ubuntu-latest
-    needs: sanity-build
     steps:
-      - uses: actions/checkout@v4
+      - uses: https://github.com/actions/checkout@v4
 
-      - uses: softprops/action-gh-release@v2
+      - uses: pnpm/action-setup@v4
+
+      - uses: https://github.com/actions/setup-node@v4
         with:
-          # Auto-generated from merged PRs since the previous tag — no
+          node-version: 22
-          # changelog tooling to maintain, consistent with there being no
+          cache: pnpm
-          # versioning tooling elsewhere in the repo yet.
+
-          generate_release_notes: true
+      - uses: https://github.com/actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: "21"
+
+      - uses: https://github.com/android-actions/setup-android@v3
+
+      - run: pnpm install --frozen-lockfile
+
+      - name: Build le bundle web pour Capacitor
+        env:
+          VITE_API_URL: ${{ secrets.MOBILE_API_URL }}
+        run: pnpm --filter web build:capacitor
+      - run: pnpm --filter web exec cap sync android
+
+      - name: Décode le keystore de release
+        env:
+          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
+        run: echo "$ANDROID_KEYSTORE_BASE64" | base64 -d > apps/web/android/app/release.keystore
+
+      - name: Dérive versionName/versionCode depuis le tag
+        # GITHUB_REF_NAME = "v1.4.2" pour un tag `v1.4.2` — versionName =
+        # "1.4.2" (sans le `v`), versionCode = majeur*10000 + mineur*100 +
+        # correctif (ex. 1.4.2 -> 10402), un entier strictement croissant à
+        # chaque release comme Android l'exige (jamais réutilisé, jamais
+        # décroissant) tant que chaque partie reste sous 100 (largement
+        # suffisant ici). Exposé aux steps suivants via $GITHUB_ENV plutôt
+        # que recalculé.
+        run: |
+          tag="${GITHUB_REF_NAME#v}"
+          major="$(echo "$tag" | cut -d. -f1)"
+          minor="$(echo "$tag" | cut -d. -f2)"
+          patch="$(echo "$tag" | cut -d. -f3)"
+          # Préfixe 10# : force une lecture en base 10, sinon bash lirait
+          # un composant à zéro non significatif (ex. "08") comme de
+          # l'octal invalide et échouerait.
+          code=$((10#$major * 10000 + 10#$minor * 100 + 10#$patch))
+          echo "Version dérivée du tag $GITHUB_REF_NAME : versionName=$tag versionCode=$code"
+          echo "ANDROID_VERSION_NAME=$tag" >> "$GITHUB_ENV"
+          echo "ANDROID_VERSION_CODE=$code" >> "$GITHUB_ENV"
+
+      - name: Build l'APK signé
+        working-directory: apps/web/android
+        env:
+          ANDROID_KEYSTORE_PATH: release.keystore
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
+          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
+          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
+        run: |
+          chmod +x ./gradlew
+          ./gradlew assembleRelease -PandroidVersionName="$ANDROID_VERSION_NAME" -PandroidVersionCode="$ANDROID_VERSION_CODE"
+
+      # Nom de fichier stable, jamais versionné : la page d'accueil (#65)
+      # pointe vers /releases/latest (Forgejo n'a pas l'équivalent du
+      # raccourci GitHub /releases/latest/download/<fichier>, seul
+      # /releases/latest lui-même résout) — un nom stable évite au moins que
+      # l'utilisateur voie un nom de fichier différent à chaque release une
+      # fois sur la page.
+      - name: Renomme l'APK sous un nom stable
+        run: cp apps/web/android/app/build/outputs/apk/release/app-release.apk batchcooking.apk
+
+      # v4+ exige l'API "Results" de GitHub, non supportée par ce Forgejo
+      # self-hosted ("GHESNotSupportedError") — v3 (ancienne API Artifacts)
+      # est la seule utilisable ici, voir ci.yml's build-android pour la
+      # même contrainte déjà rencontrée.
+      - uses: https://github.com/actions/upload-artifact@v3
+        with:
+          name: batchcooking.apk
+          path: batchcooking.apk
+
+  forgejo-release:
+    runs-on: ubuntu-latest
+    needs: [build-and-push-images, build-android-apk]
+    steps:
+      # Ce runner ne fournit ni docker ni curl par défaut dans ses
+      # conteneurs de job — même constat déjà fait pour docker (voir
+      # build-and-push-images) et pour curl dans ci.yml's test job.
+      - name: Install curl
+        run: apt-get update && apt-get install -y curl
+
+      - uses: https://github.com/actions/checkout@v4
+
+      - uses: https://github.com/actions/download-artifact@v3
+        with:
+          name: batchcooking.apk
+
+      # softprops/action-gh-release (l'action GitHub habituelle pour ça)
+      # échoue systématiquement contre ce Forgejo : sa requête de création
+      # de release répond 405 (vérifié en conditions réelles, tag v0.2.0 —
+      # pas un souci de ref bare comme les autres actions de ce fichier,
+      # une vraie incompatibilité d'API entre les deux plateformes qui n'a
+      # pas de contournement connu côté configuration de l'action). Appelle
+      # directement l'API native de Forgejo plutôt qu'une action tierce
+      # dont la compatibilité GitHub-Forgejo n'est pas garantie.
+      #
+      # Pas d'équivalent à `generate_release_notes` ici (fonctionnalité
+      # propre à GitHub, pas répliquée par l'API Forgejo) — le corps de la
+      # release reste minimal, cohérent avec l'absence d'outillage de
+      # changelog ailleurs dans le repo.
+      - name: Crée (ou récupère) la Release Forgejo
+        id: create-release
+        env:
+          FORGEJO_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          api="$GITHUB_API_URL/repos/$GITHUB_REPOSITORY/releases"
+          body="$(printf '{"tag_name":"%s","name":"%s","draft":false,"prerelease":false}' "$GITHUB_REF_NAME" "$GITHUB_REF_NAME")"
+
+          # POST pour créer la release, code HTTP capturé à part. Si le tag est
+          # déjà connu de Forgejo (tag poussé à la main avant ce workflow, ou
+          # ré-exécution du job), l'API répond 409 : on réutilise alors la
+          # release existante au lieu d'échouer — idempotence, cf. l'incident
+          # du tag v0.2.2 poussé en avance qui a fait tomber ce job sur un 409.
+          code="$(curl -sS -o /tmp/release.json -w '%{http_code}' -X POST "$api" \
+            -H "Authorization: token $FORGEJO_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "$body")"
+
+          if [ "$code" = "409" ]; then
+            echo "Release $GITHUB_REF_NAME déjà existante (HTTP 409) — récupération de son id."
+            curl -fsS "$api/tags/$GITHUB_REF_NAME" \
+              -H "Authorization: token $FORGEJO_TOKEN" -o /tmp/release.json
+          elif [ "$code" -lt 200 ] || [ "$code" -ge 300 ]; then
+            echo "Échec de création de la Release (HTTP $code) : $(cat /tmp/release.json)" >&2
+            exit 1
+          fi
+
+          id="$(grep -o '"id":[0-9]*' /tmp/release.json | head -1 | cut -d: -f2)"
+          if [ -z "$id" ]; then
+            echo "Pas d'id de release trouvé : $(cat /tmp/release.json)" >&2
+            exit 1
+          fi
+          echo "Release $GITHUB_REF_NAME prête (id=$id)"
+          echo "release-id=$id" >> "$GITHUB_OUTPUT"
+
+      - name: Attache l'APK à la Release
+        env:
+          FORGEJO_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          api="$GITHUB_API_URL/repos/$GITHUB_REPOSITORY/releases/${{ steps.create-release.outputs.release-id }}/assets"
+          curl -fsS -X POST "$api?name=batchcooking.apk" \
+            -H "Authorization: token $FORGEJO_TOKEN" \
+            -F "attachment=@batchcooking.apk"
 
   notify-portainer:
     runs-on: ubuntu-latest
-    needs: github-release
+    needs: forgejo-release
     steps:
       - name: Trigger Portainer redeploy
         # Best-effort: does nothing (and doesn't fail the workflow) until

.gitignore

@@ -134,6 +134,11 @@ dist
 # Stores VSCode versions used for testing VSCode extensions
 .vscode-test
 
+# JetBrains IDEs (Android Studio opens this repo as a project once the
+# Capacitor Android app exists under apps/web/android — see that folder's own
+# .gitignore for the generated native project's build artefacts).
+/.idea/
+
 # pnpm
 .pnpm-store
 

README.md

@@ -207,10 +207,18 @@ depuis la même origine. Les deux autres services du fichier
 (`tech-step-intent-service`, `tech-step-llm-worker`) n'exposent eux aucun port
 au host — voir leurs propres README pour leur rôle.
 
-**Pas de registre d'image** dans cette configuration : l'instance **Portainer** de
+**Registre d'image** : la CI de release (voir plus bas) construit et pousse les
-production est reliée directement au dépôt Git et reconstruit elle-même
+trois images de service — `batchcooking-app`, `batchcooking-intent-service`,
-`docker-compose.yml`/`apps/api/Dockerfile` à chaque déploiement — la CI ne pousse
+`batchcooking-llm-worker` — sur le **registre de conteneurs intégré à Forgejo**
-donc aucune image nulle part.
+(`git.dev.kyuno.fr/kyuno/…`), taguées à la fois avec le tag de release (`vX.Y.Z`)
+et `latest`. `docker-compose.yml` référence ces images via `IMAGE_TAG` (variable
+d'environnement, défaut `latest` — voir `.env.example`), tout en gardant un bloc
+`build:` local à côté de chaque `image:` : `docker compose pull` récupère les
+images pré-construites, `docker compose up`/`build` retombe sur un build local si
+elles sont absentes. L'instance **Portainer** de production peut donc désormais
+tirer les images pré-construites (stack en mode *pull*, `IMAGE_TAG` pinné sur la
+release voulue) **ou** continuer à builder elle-même depuis le dépôt Git — les
+deux modes fonctionnent avec le même `docker-compose.yml`.
 
 ### Release (`.github/workflows/release.yml`)
 
@@ -221,14 +229,80 @@ git tag vX.Y.Z
 git push --tags
 ```
 
-Le pipeline enchaîne trois jobs : `sanity-build` (build de l'image Docker sans
+Le pipeline enchaîne quatre jobs : `build-and-push-images` (build des 3 images à
-push, juste pour vérifier qu'elle build encore à ce tag avant de laisser Portainer
+ce tag + push sur le registre Forgejo sous `vX.Y.Z` et `latest` — un push
-redéployer dessus), `github-release` (crée une Release GitHub avec changelog
+réussi vaut aussi vérification que tout build encore à ce commit),
-auto-généré à partir des PRs mergées), puis `notify-portainer` — envoie une requête
+`build-android-apk` (APK signé, `versionName` dérivé du tag), `forgejo-release`
-au webhook de redeploy de Portainer si le secret de dépôt `PORTAINER_WEBHOOK_URL`
+(crée la Release Forgejo `vX.Y.Z` et y attache `batchcooking.apk`), puis
-est configuré (sinon Portainer se resynchronise simplement à son prochain
+`notify-portainer` — envoie une requête au webhook de redeploy de Portainer si
-polling Git). Pour l'activer : récupérer l'URL du webhook depuis les réglages du
+le secret de dépôt `PORTAINER_WEBHOOK_URL` est configuré (sinon Portainer se
-stack Portainer, puis l'ajouter comme secret GitHub `PORTAINER_WEBHOOK_URL`.
+resynchronise à son prochain polling). Pour l'activer : récupérer l'URL du
+webhook depuis les réglages du stack Portainer, puis l'ajouter comme secret de
+dépôt `PORTAINER_WEBHOOK_URL`.
+
+## Application mobile (Android)
+
+`apps/web` est empaqueté dans une coquille [Capacitor](https://capacitorjs.com/)
+pour Android — le projet natif est versionné dans `apps/web/android/` (issue
+\#39). L'authentification passe par un jeton Bearer stocké dans le stockage
+sécurisé de Capacitor (le cookie de session `SameSite=Lax` ne part pas depuis
+l'origine interne d'une WebView), et `main.tsx` bascule sur `HashRouter` quand
+`Capacitor.isNativePlatform()` est vrai.
+
+**Prérequis** : Android Studio (SDK Android + un JDK ; le JBR fourni avec
+Android Studio suffit). Aucun serveur Postgres/Docker local n'est nécessaire —
+l'appli parle à l'API HTTPS publique.
+
+**Build** — depuis `apps/web/` :
+
+```bash
+# 1. URL publique de l'API, gravée dans le bundle empaqueté (le build web
+#    normal utilise une URL relative « même origine », impossible ici).
+cp .env.capacitor.example .env.capacitor   # puis renseigner VITE_API_URL
+
+# 2. Build web en mode capacitor + synchronisation dans le projet natif.
+pnpm build:capacitor
+npx cap sync android
+
+# 3. Ouvrir dans Android Studio (build/run/émulateur depuis l'IDE)…
+npx cap open android
+# …ou build/run en ligne de commande si un appareil/émulateur est prêt :
+npx cap run android
+```
+
+Le bundle web copié (`apps/web/android/app/src/main/assets/public/`) est
+git-ignoré : il est régénéré par `pnpm build:capacitor && npx cap sync android`.
+Les icônes et le splash sont générés depuis `apps/web/assets/logo.svg` (voir
+`apps/web/assets/README.md`). iOS est hors périmètre pour l'instant (nécessite
+Xcode/macOS).
+
+**CI — build automatique d'un APK signé** (`.github/workflows/ci.yml`, job
+`build-android`, issue #64) : à chaque push sur `main`, une fois les 5 autres
+jobs verts, un APK release signé est construit et déposé comme artefact de
+run téléchargeable. Secrets du dépôt Forgejo requis (Réglages du dépôt →
+Secrets) :
+
+| Secret | Contenu |
+|---|---|
+| `MOBILE_API_URL` | URL HTTPS publique de l'API — même valeur que `VITE_API_URL` dans `.env.capacitor` |
+| `ANDROID_KEYSTORE_BASE64` | Le keystore de release (`.jks`) encodé en base64 |
+| `ANDROID_KEYSTORE_PASSWORD` | Mot de passe du keystore |
+| `ANDROID_KEY_ALIAS` | Alias de la clé dans le keystore |
+| `ANDROID_KEY_PASSWORD` | Mot de passe de la clé |
+
+Le keystore doit être généré **une seule fois**, à la main, et rester stable
+pour toujours : Android refuse d'installer la mise à jour d'une appli signée
+par une clé différente de celle déjà installée.
+
+```bash
+keytool -genkeypair -v -keystore batchcooking-release.jks \
+  -alias batchcooking -keyalg RSA -keysize 2048 -validity 10000
+base64 -w0 batchcooking-release.jks   # → coller comme secret ANDROID_KEYSTORE_BASE64
+```
+
+Conserver le fichier `.jks` et ses mots de passe en lieu sûr en dehors du
+dépôt (jamais commité — voir `apps/web/android/.gitignore`) : le perdre
+empêche de publier toute future mise à jour de l'appli.
 
 ## Auth (apps/api)
 

apps/api/.env.example

@@ -11,7 +11,7 @@ JWT_SECRET=changeme-generate-a-real-random-secret-at-least-32-chars
 # Optional — defaults shown (see src/config/env.ts)
 # JWT_EXPIRES_IN=7d
 # AUTH_COOKIE_NAME=session
-# CORS_ORIGIN=http://localhost:5173
+# CORS_ORIGIN=http://localhost:5173,https://localhost
 # INTENT_SERVICE_BASE_URL=http://localhost:8000
 
 # Required — services/tech-step-intent-service must be running locally (see
@@ -35,3 +35,12 @@ INTENT_SERVICE_SECRET=changeme-generate-a-real-random-secret-at-least-32-chars
 # ADMIN_INITIAL_EMAIL=ops@example.com
 # ADMIN_INITIAL_PASSWORD=changeme-at-least-8-chars
 # ADMIN_INITIAL_NAME=Ops
+
+# Only needed to create a Forgejo issue from a contact message
+# (apps/web's /admin/messages, issue #81). The button is hidden and the
+# endpoint answers 503 while any of the three is unset. FORGEJO_TOKEN is a
+# personal access token with the write:issue scope — generate it in Forgejo,
+# never commit the real value.
+# FORGEJO_BASE_URL=https://git.example.com
+# FORGEJO_TOKEN=changeme-a-forgejo-personal-access-token
+# FORGEJO_REPO=owner/repo

apps/api/prisma/migrations/20260908120000_contact_message/migration.sql

@@ -0,0 +1,23 @@
+-- Contact-form messages (issue #80). New table only — nothing to backfill.
+-- `author_id` is nullable with ON DELETE SET NULL so a report survives its
+-- sender's account deletion (same as ingredients.created_by_id).
+
+-- CreateTable
+CREATE TABLE "contact_message" (
+    "id" SERIAL NOT NULL,
+    "author_id" INTEGER,
+    "type" TEXT NOT NULL,
+    "message" TEXT NOT NULL,
+    "page_url" TEXT,
+    "user_agent" TEXT,
+    "app_version" TEXT,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "contact_message_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "contact_message_created_at_idx" ON "contact_message"("created_at");
+
+-- AddForeignKey
+ALTER TABLE "contact_message" ADD CONSTRAINT "contact_message_author_id_fkey" FOREIGN KEY ("author_id") REFERENCES "user_profiles"("id") ON DELETE SET NULL ON UPDATE CASCADE;

apps/api/prisma/migrations/20260908130000_contact_message_forgejo_link/migration.sql

@@ -0,0 +1,8 @@
+-- Link a contact message to the Forgejo issue an admin created from it
+-- (issue #81). Two nullable columns, no backfill — existing rows have no
+-- linked issue.
+
+-- AlterTable
+ALTER TABLE "contact_message"
+    ADD COLUMN "forgejo_issue_number" INTEGER,
+    ADD COLUMN "forgejo_issue_url" TEXT;

apps/api/prisma/migrations/20260909120000_recipe_ingredient_quantity_optional/migration.sql

@@ -0,0 +1,8 @@
+-- Ingrédients d'assaisonnement « selon le goût » (issue #128, puce 1 de #3) :
+-- une ligne de recette peut désormais n'avoir ni quantité ni unité. Purement
+-- additif — toutes les lignes existantes gardent leurs valeurs, aucune n'est
+-- réécrite.
+
+-- AlterTable
+ALTER TABLE "recipe_ingredient" ALTER COLUMN "quantity" DROP NOT NULL;
+ALTER TABLE "recipe_ingredient" ALTER COLUMN "unit_id" DROP NOT NULL;

apps/api/prisma/migrations/20260909130000_drop_recipe_diet/migration.sql

@@ -0,0 +1,7 @@
+-- Régimes d'une recette calculés depuis ses ingrédients (issue #131, puce 4
+-- de #3) — `RecipeDiet` (tag manuel) est supprimé : `RecipeSummaryView.diets`
+-- est désormais dérivé de `IngredientDiet` + de l'allergène `gluten` côté
+-- lecture (voir `computeRecipeDietViews`). Aucune donnée à conserver.
+
+-- DropTable
+DROP TABLE "recipe_diet";

apps/api/prisma/migrations/20260909140000_tech_step_placeholder/migration.sql

@@ -0,0 +1,16 @@
+-- AlterTable: off-catalog technique "placeholder" rows (issue #130, puce 3
+-- de #3) — a user names a technique the catalog is missing while correcting a
+-- step. Every existing row is a real seeded catalog entry, so the flag
+-- defaults to false and the four new nullable columns stay NULL for them —
+-- no backfill needed. Mirrors the `ingredients` placeholder migration.
+ALTER TABLE "tech_step" ADD COLUMN "is_placeholder" BOOLEAN NOT NULL DEFAULT false;
+ALTER TABLE "tech_step" ADD COLUMN "display_name" TEXT;
+ALTER TABLE "tech_step" ADD COLUMN "created_by_id" INTEGER;
+ALTER TABLE "tech_step" ADD COLUMN "created_at" TIMESTAMP(3);
+ALTER TABLE "tech_step" ADD COLUMN "reviewed_at" TIMESTAMP(3);
+
+-- CreateIndex
+CREATE INDEX "tech_step_is_placeholder_idx" ON "tech_step"("is_placeholder");
+
+-- AddForeignKey
+ALTER TABLE "tech_step" ADD CONSTRAINT "tech_step_created_by_id_fkey" FOREIGN KEY ("created_by_id") REFERENCES "user_profiles"("id") ON DELETE SET NULL ON UPDATE CASCADE;

apps/api/prisma/schema.prisma

@@ -49,7 +49,6 @@ model Diet {
   key String @unique
 
   users       UserProfile[]
-  recipes     RecipeDiet[]
   ingredients IngredientDiet[]
 
   @@map("diet")
@@ -135,6 +134,11 @@ model UserProfile {
   /// Placeholder `Ingredient` rows this profile created by typing a free-text
   /// ingredient the catalog didn't cover — see `Ingredient.isPlaceholder`.
   createdIngredientPlaceholders Ingredient[] @relation("PlaceholderCreator")
+  /// Placeholder `TechStep` rows this profile proposed while correcting a step
+  /// — see `TechStep.isPlaceholder`.
+  createdTechStepPlaceholders   TechStep[]   @relation("TechStepPlaceholderCreator")
+  /// Contact-form messages this profile has sent — see {@link ContactMessage}.
+  contactMessages               ContactMessage[]
 
   @@map("user_profiles")
 }
@@ -373,7 +377,6 @@ model Recipe {
   steps         Step[]
   planningItems PlanningItem[]
   favoritedBy   RecipeFavorite[]
-  diets         RecipeDiet[]
 
   @@unique([sourceId, externalId])
   @@map("recipe")
@@ -394,21 +397,6 @@ model RecipeFavorite {
   @@map("recipe_favorite")
 }
 
-/// Explicit join table for the recipe <-> diet "associated regime" tags
-/// (e.g. a recipe can be tagged both `Végétarien` and `Sans gluten`) — a
-/// manual reminder set by whoever creates/edits the recipe, not computed
-/// from its ingredients.
-model RecipeDiet {
-  recipeId Int @map("recipe_id")
-  dietId   Int @map("diet_id")
-
-  recipe Recipe @relation(fields: [recipeId], references: [id], onDelete: Cascade)
-  diet   Diet   @relation(fields: [dietId], references: [id], onDelete: Cascade)
-
-  @@id([recipeId, dietId])
-  @@map("recipe_diet")
-}
-
 /// `key` is `@unique` — not in the original spec doc, added so the seed
 /// script (reference-seed-data.ts) can `upsert` by key and stay
 /// idempotent/safe to re-run, same reason as `Diet.key`/`Category.key`. A
@@ -698,12 +686,17 @@ model Unit {
 model RecipeIngredient {
   recipeId     Int      @map("recipe_id")
   ingredientId Int      @map("ingredient_id")
-  quantity     Decimal @db.Decimal(10, 2)
+  /// `null` (with `unitId` also `null`) = a "selon le goût" seasoning line —
-  unitId       Int     @map("unit_id")
+  /// salt, pepper… added to taste, with nothing to scale by portions or to
+  /// aggregate on a shopping list. The "both null or neither" invariant is
+  /// enforced service-side (and by `recipeIngredientInputSchema`), not by
+  /// the schema — same posture as this file's other cross-field invariants.
+  quantity     Decimal? @db.Decimal(10, 2)
+  unitId       Int?     @map("unit_id")
 
   recipe     Recipe     @relation(fields: [recipeId], references: [id], onDelete: Cascade)
   ingredient Ingredient @relation(fields: [ingredientId], references: [id], onDelete: Cascade)
-  unit       Unit       @relation(fields: [unitId], references: [id])
+  unit       Unit?      @relation(fields: [unitId], references: [id])
 
   @@id([recipeId, ingredientId])
   @@map("recipe_ingredient")
@@ -728,6 +721,33 @@ model TechStep {
   id  Int    @id @default(autoincrement())
   key String @unique
 
+  /// `true` = a "placeholder" technique: a free-text technique a user typed
+  /// while correcting a step, because nothing in the seeded catalog matched
+  /// (issue #131 for the ingredient precedent this mirrors — see
+  /// `Ingredient.isPlaceholder`). Such a row has `displayName` non-null, a
+  /// generated `key` (`placeholder:<uuid>`, never an i18n label), no
+  /// training data of its own, and is excluded from
+  /// `GET /reference/tech-steps`. It is still referenced by `StepTechStep`
+  /// like any other technique (the correction that created it applies
+  /// immediately), but a maintainer reviews it at
+  /// `/admin/catalogue` (Techniques tab) and promotes it into the real
+  /// catalog by hand (`reference-seed-data.ts` + `tech-step-training-data.ts`).
+  isPlaceholder Boolean   @default(false) @map("is_placeholder")
+  /// The exact text the user typed — `null` for a real catalog row (whose
+  /// label lives in i18n under `catalog.techSteps.<key>`). Non-null iff
+  /// `isPlaceholder`, enforced service-side.
+  displayName   String?   @map("display_name")
+  /// Profile that first proposed this technique — context for the admin
+  /// review. `onDelete: SetNull` so deleting an account never blocks on the
+  /// recipes still using its placeholder. `null` for a real catalog row.
+  createdById   Int?      @map("created_by_id")
+  /// When this placeholder was proposed. `null` for a real catalog row.
+  createdAt     DateTime? @map("created_at")
+  /// Stamped once a maintainer has triaged this proposal
+  /// (`PATCH /admin/api/catalog/tech-step-placeholders/mark-reviewed`).
+  /// `null` while pending / for a real catalog row.
+  reviewedAt    DateTime? @map("reviewed_at")
+
   steps                  StepTechStep[]
   /// Corrections where this technique was the *previous* (possibly wrong)
   /// match — see `StepTechStepCorrection.previousTechStepId`.
@@ -738,7 +758,10 @@ model TechStep {
   /// Training-corpus suggestions targeting this technique — see
   /// `TechStepTrainingSuggestion`.
   trainingSuggestions    TechStepTrainingSuggestion[]
+  /// The profile that proposed this row when it is a placeholder — see `createdById`.
+  createdBy              UserProfile?                @relation("TechStepPlaceholderCreator", fields: [createdById], references: [id], onDelete: SetNull)
 
+  @@index([isPlaceholder])
   @@map("tech_step")
 }
 
@@ -994,7 +1017,7 @@ model StepTechStepCorrection {
 ///
 /// `suggestedSynonyms`/`suggestedUtterances` are native Postgres arrays
 /// (`String[]`), not a join table — unlike this schema's other list-shaped
-/// data (`RecipeDiet`, `UserProfileAllergy`...), these strings are free text
+/// data (`RecipeIngredient`, `UserProfileAllergy`...), these strings are free text
 /// proposed once for a human to read, not ids referencing another catalog
 /// table, so there's nothing for a join table to normalize against.
 model TechStepTrainingSuggestion {
@@ -1189,3 +1212,47 @@ model TourProgress {
   @@id([userProfileId, scenarioId])
   @@map("tour_progress")
 }
+
+// -----------------------------------------------------------------------------
+// Contact
+// In-app "report a bug / suggestion" form — user-submitted, read-only for
+// admins at /admin/messages. See issues #80 (this) and #81 (turn a message
+// into a Forgejo issue).
+// -----------------------------------------------------------------------------
+
+/// A message sent via the app's contact form (bug, suggestion, other).
+/// Written once by a signed-in user, never edited afterwards — consulted
+/// read-only from the admin app. `authorId` is nullable + `onDelete: SetNull`
+/// (same choice as `Ingredient.createdById`): a bug report keeps its value
+/// even if the account that sent it is deleted in the meantime.
+model ContactMessage {
+  id         Int      @id @default(autoincrement())
+  authorId   Int?     @map("author_id")
+  /// "bug" | "suggestion" | "other" — a plain `String` backed by the shared
+  /// `CONTACT_MESSAGE_TYPES` const (same approach as
+  /// `TechStepTrainingSuggestion.status` / `AnalyticsEvent.type`): adding a
+  /// value is one line, no Postgres enum migration.
+  type       String
+  message    String
+  /// Technical context captured automatically at submit time, for triage —
+  /// all nullable (an older client, or a direct API call, can omit them).
+  pageUrl    String?  @map("page_url")
+  userAgent  String?  @map("user_agent")
+  appVersion String?  @map("app_version")
+  createdAt  DateTime @default(now()) @map("created_at")
+
+  /// Number of the Forgejo issue an admin created from this message via
+  /// `/admin/messages` (issue #81). `null` = no ticket yet. Non-null ⇒ the
+  /// "Créer un ticket" button disappears (one message links to at most one
+  /// issue).
+  forgejoIssueNumber Int?    @map("forgejo_issue_number")
+  /// The issue's html URL (`<base>/<owner>/<repo>/issues/<n>`) — stored
+  /// as-is rather than rebuilt from `FORGEJO_*` config, so the link stays
+  /// correct even if that config changes later.
+  forgejoIssueUrl    String? @map("forgejo_issue_url")
+
+  author UserProfile? @relation(fields: [authorId], references: [id], onDelete: SetNull)
+
+  @@index([createdAt])
+  @@map("contact_message")
+}

apps/api/src/app.ts

@@ -7,9 +7,11 @@ import { errorLogger } from "./middlewares/error-logger.js";
 import { requestLogger } from "./middlewares/request-logger.js";
 import { adminRouter } from "./modules/admin/admin.routes.js";
 import { authRouter } from "./modules/auth/auth.routes.js";
+import { contactRouter } from "./modules/contact/contact.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 { mobileRouter } from "./modules/mobile/mobile.routes.js";
 import { planningRouter } from "./modules/planning/planning.routes.js";
 import { preferencesRouter } from "./modules/preferences/preferences.routes.js";
 import { profileRouter } from "./modules/profile/profile.routes.js";
@@ -34,10 +36,11 @@ export function createServer(): ExpressServer {
   // pipeline (its "finish" listener still fires for a request that never
   // makes it past CORS/body-parsing, not just ones that reach a route).
   server.addMiddleware(requestLogger);
-  // One allowed origin: the app (`CORS_ORIGIN`). The admin surface
+  // Allowed origin(s) come from `CORS_ORIGIN` (see its own doc comment in
-  // (`/admin/*`) is served by this same API and consumed by `apps/web`'s
+  // config/env.ts for why the packaged Android app's origin must always be
-  // own `/admin/*` routes — same origin as the rest of the app, so no
+  // one of them). The admin surface (`/admin/*`) is served by this same API
-  // extra CORS entry.
+  // and consumed by `apps/web`'s own `/admin/*` routes — same origin as the
+  // rest of the app, so no extra CORS entry.
   server.setupCore({ corsOrigin: env.CORS_ORIGIN });
 
   server.addRoute("get", "/health", (_req: Request, res: Response) => {
@@ -58,12 +61,20 @@ export function createServer(): ExpressServer {
   // admin page path can ever collide with an admin API path again.
   server.mountRouter("/admin/api", adminRouter);
   server.mountRouter("/house", houseRouter);
+  // In-app "signaler un bug / suggestion" form (issue #80) — session
+  // required, one POST. Admins read these rows via `/admin/api/contact`,
+  // never this router.
+  server.mountRouter("/contact", contactRouter);
   // Not user-facing — `services/tech-step-llm-worker` only, guarded by
   // `requireInternalWorker` on every route within (see that router's own
   // doc comment), never `requireAuth`. Mounted alongside the other routers
   // rather than nested under one of them since it isn't scoped to a single
   // recipe/step the way `recipeRouter`'s own correction routes are.
   server.mountRouter("/internal/tech-steps", techStepWorkerRouter);
+  // Public proxy for Forgejo's Releases API (issues #65/#66) — see
+  // mobile.service.ts's doc comment for why this can't just be called
+  // directly from the browser.
+  server.mountRouter("/mobile", mobileRouter);
   server.mountRouter("/planning", planningRouter);
   server.mountRouter("/preferences", preferencesRouter);
   server.mountRouter("/profile", profileRouter);

apps/api/src/config/env.ts

@@ -13,12 +13,26 @@ import { z } from "zod";
 // separate test database this now requires.
 dotenv.config({ path: process.env.NODE_ENV === "test" ? ".env.test" : ".env" });
 
+/**
+ * Treats a blank env var (`FOO=`) as unset. `docker-compose.yml` passes
+ * every optional var through as `${FOO:-}`, which resolves to `""` (not an
+ * absent key) when the stack's `.env` leaves it empty — and a `.env` file
+ * is `.dockerignore`d, so that passthrough is the container's only source
+ * of these. Fields that must *fail closed* on a blank value rather than run
+ * their own format check against `""` (and crash `parse()` at boot) wrap
+ * their schema in this. Used for the `FORGEJO_*` trio below; `COOKIE_SECURE`
+ * folds the same `"" -> undefined` step into its own `.transform`.
+ */
+const blankAsUnset = (value: unknown): unknown => (value === "" ? undefined : value);
+
 /**
  * Schema for every environment variable the API reads. Parsing (below)
  * fails fast at startup if something required is missing/invalid, instead
- * of surfacing as a confusing runtime error later.
+ * of surfacing as a confusing runtime error later. Exported so the parsing
+ * rules (e.g. `blankAsUnset` on the `FORGEJO_*` trio) can be unit-tested
+ * without the process-wide `process.env` the singleton below parses.
  */
-const envSchema = z.object({
+export const envSchema = z.object({
   /** Runtime mode — also toggles test-only behavior (e.g. cheaper argon2 cost, see auth.service.ts). */
   NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
   /** Port the HTTP server listens on. */
@@ -34,8 +48,42 @@ const envSchema = z.object({
   JWT_EXPIRES_IN: z.string().default("7d"),
   /** Name of the httpOnly cookie carrying the session JWT. */
   AUTH_COOKIE_NAME: z.string().default("session"),
-  /** Origin allowed by CORS — must match wherever apps/web is served from. */
+  /**
-  CORS_ORIGIN: z.string().default("http://localhost:5173"),
+   * Origin(s) allowed by CORS, comma-separated — parsed below into a
+   * `string[]` for `ExpressServerCoreOptions.corsOrigin`
+   * (`app.ts`/`express-server.ts`, which passes it straight to the `cors`
+   * package) and reused as-is for the Socket.IO handshake's own CORS config
+   * (`server.ts`, which needs its own since the WS upgrade never runs
+   * through `setupCore`'s middleware).
+   *
+   * Must always include `https://localhost`: the packaged Android app's
+   * WebView is served from exactly that fixed origin (Capacitor's default
+   * for `androidScheme`/hostname — see `apps/web/capacitor.config.ts`'s own
+   * doc comment), and every request it makes to this API — `/auth/login`
+   * and `/auth/signup` included — is genuinely cross-origin, unlike
+   * apps/web's *browser* build, which is served from the very same origin
+   * as this API in production (see docker-compose.yml's `app` service) and
+   * so never needs an entry here at all. Missing this origin doesn't fail
+   * loudly: the `cors` package still answers a preflight `OPTIONS` with 204
+   * for an origin it's about to reject (it only *omits*
+   * `Access-Control-Allow-Origin`), so the request the app's WebView logs
+   * looks identical to a normal one right up until the browser silently
+   * drops the real `POST` — surfacing client-side as a generic "unexpected
+   * error" with no 401/403 anywhere to point at the actual cause. Default
+   * covers both the Vite dev server and the packaged app out of the box; a
+   * real deployment's own web origin (e.g. a production domain) never needs
+   * adding here for the reason above, but the env var still allows
+   * extending/overriding this list (comma-separated) if that ever changes.
+   */
+  CORS_ORIGIN: z
+    .string()
+    .default("http://localhost:5173,https://localhost")
+    .transform((value) =>
+      value
+        .split(",")
+        .map((origin) => origin.trim())
+        .filter((origin) => origin.length > 0),
+    ),
   /**
    * Absolute path to the built frontend (`apps/web/dist`), to serve
    * alongside the API. Optional, no default — only set inside the
@@ -109,6 +157,26 @@ const envSchema = z.object({
   ADMIN_INITIAL_EMAIL: z.string().optional(),
   ADMIN_INITIAL_PASSWORD: z.string().optional(),
   ADMIN_INITIAL_NAME: z.string().optional(),
+  /**
+   * Forgejo instance + credentials for "create an issue from a contact
+   * message" (`/admin/messages`, issue #81). All three `.optional()` and
+   * checked together by `ForgejoService.isConfigured()` — the feature
+   * **fails closed** when any is missing: the endpoint answers `503` and
+   * the admin UI hides the button (same posture as `ADMIN_JWT_SECRET` /
+   * `INTERNAL_WORKER_SECRET`). Only this one admin action reads them; the
+   * rest of the app never talks to Forgejo.
+   */
+  FORGEJO_BASE_URL: z.preprocess(blankAsUnset, z.string().url().optional()),
+  /** Forgejo personal access token with the `write:issue` (or `issue`) scope. Secret — `.env.example` shows only a `changeme`. */
+  FORGEJO_TOKEN: z.preprocess(blankAsUnset, z.string().optional()),
+  /** Target repo as `owner/repo` (e.g. `kyuno/batchCooking`) — issues are always created here, never a repo chosen at call time. */
+  FORGEJO_REPO: z.preprocess(
+    blankAsUnset,
+    z
+      .string()
+      .regex(/^[^/\s]+\/[^/\s]+$/, "FORGEJO_REPO must look like 'owner/repo'")
+      .optional(),
+  ),
 });
 
 /** Parsed, validated environment — import this instead of reading `process.env` directly anywhere else. */

apps/api/src/lib/forgejo/forgejo.service.ts

@@ -0,0 +1,102 @@
+import { HttpError } from "@batch-cooking/error-tools";
+import { ErrorCode } from "@batch-cooking/shared";
+import { env } from "../../config/env.js";
+import { logger } from "../logger.service.js";
+
+/** The slice of Forgejo's `POST .../issues` response this integration reads. */
+interface ForgejoIssueResponse {
+  number: number;
+  html_url: string;
+}
+
+/**
+ * The one place `apps/api` talks to Forgejo — creating an issue from a
+ * contact message (`/admin/messages`, issue #81). A class + singleton
+ * (`forgejo` below), same convention as `logger` / `analytics`.
+ *
+ * **Fail-closed**: every method is a no-op / typed error unless all three
+ * `FORGEJO_*` env vars are set (see `config/env.ts`). Callers check
+ * {@link isConfigured} first and answer `503` themselves; {@link createIssue}
+ * re-checks as a backstop.
+ */
+export class ForgejoService {
+  /** True once `FORGEJO_BASE_URL`, `FORGEJO_TOKEN` and `FORGEJO_REPO` are all set. */
+  public isConfigured(): boolean {
+    return (
+      env.FORGEJO_BASE_URL !== undefined &&
+      env.FORGEJO_TOKEN !== undefined &&
+      env.FORGEJO_REPO !== undefined
+    );
+  }
+
+  /**
+   * Creates an issue in `FORGEJO_REPO` with the given title/body (no labels
+   * — a deliberate #81 decision, the admin adds them in Forgejo). Returns
+   * the new issue's number and html URL.
+   *
+   * @throws {HttpError} `503 FORGEJO_NOT_CONFIGURED` if the env isn't set,
+   *   `502 FORGEJO_REQUEST_FAILED` on a network error or any non-2xx / non-JSON
+   *   response — the caller leaves the database untouched in that case.
+   */
+  public async createIssue(input: {
+    title: string;
+    body: string;
+  }): Promise<{ number: number; htmlUrl: string }> {
+    if (!this.isConfigured()) {
+      throw new HttpError(
+        503,
+        ErrorCode.FORGEJO_NOT_CONFIGURED,
+        "Forgejo integration is not configured",
+      );
+    }
+    const url = `${env.FORGEJO_BASE_URL}/api/v1/repos/${env.FORGEJO_REPO}/issues`;
+
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          // Forgejo/Gitea's PAT scheme — `token <pat>`, not `Bearer`.
+          Authorization: `token ${env.FORGEJO_TOKEN}`,
+        },
+        body: JSON.stringify({ title: input.title, body: input.body }),
+      });
+    } catch (err) {
+      logger.warn("Forgejo issue creation failed (network)", {
+        error: err instanceof Error ? err.message : String(err),
+      });
+      throw new HttpError(502, ErrorCode.FORGEJO_REQUEST_FAILED, "Forgejo request failed");
+    }
+
+    if (!response.ok) {
+      const detail = await response.text().catch(() => "");
+      logger.warn("Forgejo issue creation failed", {
+        status: response.status,
+        detail: detail.slice(0, 500),
+      });
+      throw new HttpError(
+        502,
+        ErrorCode.FORGEJO_REQUEST_FAILED,
+        `Forgejo issues API responded ${response.status}`,
+      );
+    }
+
+    try {
+      const data = (await response.json()) as ForgejoIssueResponse;
+      return { number: data.number, htmlUrl: data.html_url };
+    } catch (err) {
+      logger.warn("Forgejo issue creation failed (bad response)", {
+        error: err instanceof Error ? err.message : String(err),
+      });
+      throw new HttpError(
+        502,
+        ErrorCode.FORGEJO_REQUEST_FAILED,
+        "Forgejo response was not valid JSON",
+      );
+    }
+  }
+}
+
+/** Single shared instance — stateless, same reasoning as `logger` / `analytics`. */
+export const forgejo = new ForgejoService();

apps/api/src/modules/admin/admin-catalog.routes.ts

@@ -1,5 +1,10 @@
 import { wrapAsyncHandler } from "@batch-cooking/express-tools";
-import { listPlaceholdersQuerySchema, markPlaceholdersReviewedSchema } from "@batch-cooking/shared";
+import {
+  listPlaceholdersQuerySchema,
+  listTechStepPlaceholdersQuerySchema,
+  markPlaceholdersReviewedSchema,
+  markTechStepPlaceholdersReviewedSchema,
+} from "@batch-cooking/shared";
 import { Router } from "express";
 import { requireAdmin } from "../../middlewares/require-admin.js";
 import {
@@ -7,12 +12,17 @@ import {
   markPlaceholdersReviewed,
   pruneOrphanPlaceholders,
 } from "./admin-catalog.service.js";
+import {
+  listTechStepPlaceholders,
+  markTechStepPlaceholdersReviewed,
+} from "./admin-tech-step-catalog.service.js";
 
 /**
  * Router mounted at `/admin/api/catalog` (via `admin.routes.ts`) — every route
- * behind {@link requireAdmin}. Surfaces the off-catalog ingredient
+ * behind {@link requireAdmin}. Surfaces the off-catalog "placeholders" users
- * "placeholders" users typed when the seeded catalog fell short, so a
+ * typed when the seeded catalog fell short — free-text ingredients on a
- * maintainer can see what's missing and mark gaps as handled.
+ * recipe line, and free-text techniques while correcting a step (issue #130)
+ * — so a maintainer can see what's missing and mark gaps as handled.
  */
 export const adminCatalogRouter = Router();
 
@@ -42,3 +52,29 @@ adminCatalogRouter.post(
     res.status(200).json(await pruneOrphanPlaceholders());
   }),
 );
+
+// --- Missing techniques (issue #130) --------------------------------------
+
+adminCatalogRouter.get(
+  "/tech-step-placeholders",
+  requireAdmin,
+  wrapAsyncHandler(async (req, res) => {
+    res
+      .status(200)
+      .json(await listTechStepPlaceholders(listTechStepPlaceholdersQuerySchema.parse(req.query)));
+  }),
+);
+
+adminCatalogRouter.patch(
+  "/tech-step-placeholders/mark-reviewed",
+  requireAdmin,
+  wrapAsyncHandler(async (req, res) => {
+    res
+      .status(200)
+      .json(
+        await markTechStepPlaceholdersReviewed(
+          markTechStepPlaceholdersReviewedSchema.parse(req.body),
+        ),
+      );
+  }),
+);

apps/api/src/modules/admin/admin-contact.routes.ts

@@ -0,0 +1,59 @@
+import { HttpError } from "@batch-cooking/error-tools";
+import { wrapAsyncHandler } from "@batch-cooking/express-tools";
+import {
+  createForgejoIssueSchema,
+  ErrorCode,
+  listContactMessagesQuerySchema,
+} from "@batch-cooking/shared";
+import { Router } from "express";
+import { requireAdmin } from "../../middlewares/require-admin.js";
+import {
+  createForgejoIssueFromMessage,
+  getForgejoStatus,
+  listContactMessages,
+} from "./admin-contact.service.js";
+
+/**
+ * Router mounted at `/admin/api/contact` (via `admin.routes.ts`) — behind
+ * {@link requireAdmin}. Backs the `/admin/messages` page: the read-only list
+ * of contact-form messages (issue #80), plus "create a Forgejo issue from
+ * this message" (issue #81). Still no message-mutation routes — the message
+ * itself stays read-only.
+ */
+export const adminContactRouter = Router();
+
+adminContactRouter.get(
+  "/",
+  requireAdmin,
+  wrapAsyncHandler(async (req, res) => {
+    res
+      .status(200)
+      .json(await listContactMessages(listContactMessagesQuerySchema.parse(req.query)));
+  }),
+);
+
+// Static path — declared before `/:id/...` so it's never parsed as an id.
+adminContactRouter.get(
+  "/forgejo/status",
+  requireAdmin,
+  wrapAsyncHandler(async (_req, res) => {
+    res.status(200).json(getForgejoStatus());
+  }),
+);
+
+adminContactRouter.post(
+  "/:id/forgejo-issue",
+  requireAdmin,
+  wrapAsyncHandler(async (req, res) => {
+    const id = Number(req.params.id);
+    if (!Number.isInteger(id) || id <= 0) {
+      throw new HttpError(
+        400,
+        ErrorCode.VALIDATION_ERROR,
+        `Not a valid contact message id: ${req.params.id}`,
+      );
+    }
+    const input = createForgejoIssueSchema.parse(req.body);
+    res.status(200).json(await createForgejoIssueFromMessage(id, input));
+  }),
+);

apps/api/src/modules/admin/admin-contact.service.ts

@@ -0,0 +1,133 @@
+import { HttpError } from "@batch-cooking/error-tools";
+import {
+  type ContactMessageAdminView,
+  type ContactMessageType,
+  type CreateForgejoIssueInput,
+  ErrorCode,
+  type ForgejoIntegrationStatus,
+  type ListContactMessagesQuery,
+} from "@batch-cooking/shared";
+import { prisma } from "../../db/prisma.js";
+import { forgejo } from "../../lib/forgejo/forgejo.service.js";
+
+/** How many messages `listContactMessages` returns per call — the page is a triage view, not an export (same cap/rationale as `CORRECTIONS_PAGE_SIZE`). */
+const CONTACT_MESSAGES_PAGE_SIZE = 200;
+
+const contactMessageInclude = {
+  author: { select: { id: true, firstName: true, lastName: true, email: true } },
+} as const;
+
+type ContactMessageRow = Awaited<
+  ReturnType<
+    typeof prisma.contactMessage.findFirstOrThrow<{ include: typeof contactMessageInclude }>
+  >
+>;
+
+/** Shapes one Prisma `ContactMessage` row (with {@link contactMessageInclude}) into its admin view. */
+function toContactMessageAdminView(row: ContactMessageRow): ContactMessageAdminView {
+  return {
+    id: row.id,
+    // Safe cast: `POST /contact` validates `type` against
+    // `CONTACT_MESSAGE_TYPES` before insert, so the column only ever holds
+    // one of those values.
+    type: row.type as ContactMessageType,
+    message: row.message,
+    pageUrl: row.pageUrl,
+    userAgent: row.userAgent,
+    appVersion: row.appVersion,
+    createdAt: row.createdAt.toISOString(),
+    // `null` when the sender's account was deleted after sending
+    // (`authorId` is `onDelete: SetNull`).
+    author: row.author,
+    forgejoIssueNumber: row.forgejoIssueNumber,
+    forgejoIssueUrl: row.forgejoIssueUrl,
+  };
+}
+
+/**
+ * Every `ContactMessage` for the admin read view (`/admin/messages`, issue
+ * #80) — newest first, capped at {@link CONTACT_MESSAGES_PAGE_SIZE}, with an
+ * optional single-`type` filter. Read-only: this first version has no
+ * triage workflow (status / assignment / notes), so there's no update
+ * counterpart.
+ */
+export async function listContactMessages(
+  query: ListContactMessagesQuery,
+): Promise<ContactMessageAdminView[]> {
+  try {
+    const rows = await prisma.contactMessage.findMany({
+      where: query.type ? { type: query.type } : {},
+      orderBy: { createdAt: "desc" },
+      take: CONTACT_MESSAGES_PAGE_SIZE,
+      include: contactMessageInclude,
+    });
+    return rows.map(toContactMessageAdminView);
+  } catch (err) {
+    // Rethrown as-is — see `admin-tech-steps.service.ts`'s equivalent catch.
+    throw err;
+  }
+}
+
+/** Whether the "create a Forgejo issue from a message" feature is usable (issue #81) — drives whether the admin UI shows the button. */
+export function getForgejoStatus(): ForgejoIntegrationStatus {
+  return { enabled: forgejo.isConfigured() };
+}
+
+/**
+ * Creates a Forgejo issue from contact message `messageId` and records the
+ * link on the row (issue #81). The `title`/`body` come from the admin's
+ * pre-filled, edited modal.
+ *
+ * Order matters: every precondition is checked before Forgejo is called,
+ * and the row is only touched *after* Forgejo succeeds — a failed call
+ * leaves no partial state (no linked issue, button still shown).
+ *
+ * @throws {HttpError} `503 FORGEJO_NOT_CONFIGURED` (env not set),
+ *   `404 CONTACT_MESSAGE_NOT_FOUND`, `409 CONTACT_MESSAGE_ALREADY_LINKED`
+ *   (already has an issue), or `502 FORGEJO_REQUEST_FAILED` (the Forgejo
+ *   call failed — DB untouched).
+ */
+export async function createForgejoIssueFromMessage(
+  messageId: number,
+  input: CreateForgejoIssueInput,
+): Promise<ContactMessageAdminView> {
+  try {
+    if (!forgejo.isConfigured()) {
+      throw new HttpError(
+        503,
+        ErrorCode.FORGEJO_NOT_CONFIGURED,
+        "Forgejo integration is not configured",
+      );
+    }
+
+    const existing = await prisma.contactMessage.findUnique({ where: { id: messageId } });
+    if (!existing) {
+      throw new HttpError(
+        404,
+        ErrorCode.CONTACT_MESSAGE_NOT_FOUND,
+        `Contact message ${messageId} not found`,
+      );
+    }
+    if (existing.forgejoIssueNumber !== null) {
+      throw new HttpError(
+        409,
+        ErrorCode.CONTACT_MESSAGE_ALREADY_LINKED,
+        `Contact message ${messageId} already links to Forgejo issue #${existing.forgejoIssueNumber}`,
+      );
+    }
+
+    // Throws `502 FORGEJO_REQUEST_FAILED` on any failure — propagated below,
+    // before the row is touched.
+    const issue = await forgejo.createIssue({ title: input.title, body: input.body });
+
+    const updated = await prisma.contactMessage.update({
+      where: { id: messageId },
+      data: { forgejoIssueNumber: issue.number, forgejoIssueUrl: issue.htmlUrl },
+      include: contactMessageInclude,
+    });
+    return toContactMessageAdminView(updated);
+  } catch (err) {
+    // Rethrown as-is — see `admin-tech-steps.service.ts`'s equivalent catch.
+    throw err;
+  }
+}

apps/api/src/modules/admin/admin-tech-step-catalog.service.ts

@@ -0,0 +1,87 @@
+import type {
+  ListTechStepPlaceholdersQuery,
+  MarkTechStepPlaceholdersReviewedInput,
+  TechStepPlaceholderView,
+} from "@batch-cooking/shared";
+import { prisma } from "../../db/prisma.js";
+
+/**
+ * The missing-technique review (issue #130) — the tech-step counterpart of
+ * `admin-catalog.service.ts`'s off-catalog *ingredient* review. Kept a flat
+ * list rather than grouping near-duplicate spellings the way that one does:
+ * correcting a technique — let alone typing one the catalog is missing — is
+ * rare enough that a handful of raw rows is all a maintainer ever sees here.
+ */
+
+/** Prisma `include` for the placeholder query — a bounded set of the `StepTechStep` rows pointing at this technique, each resolved to just its recipe id/name for the count + "seen in…" preview. */
+const placeholderInclude = {
+  steps: {
+    take: 50,
+    include: { step: { select: { recipe: { select: { id: true, name: true } } } } },
+  },
+} as const;
+
+/**
+ * Every placeholder `TechStep` (see `TechStep.isPlaceholder` in
+ * schema.prisma), most-impactful first (most distinct recipes, then name).
+ *
+ * `query.reviewed` selects which side to show: omitted / `"false"` drops
+ * rows already triaged (`reviewedAt` set) — the default working list;
+ * `"true"` keeps only those.
+ */
+export async function listTechStepPlaceholders(
+  query: ListTechStepPlaceholdersQuery,
+): Promise<TechStepPlaceholderView[]> {
+  try {
+    const rows = await prisma.techStep.findMany({
+      where: { isPlaceholder: true },
+      include: placeholderInclude,
+      orderBy: { createdAt: "asc" },
+    });
+
+    const wantReviewed = query.reviewed === "true";
+    return rows
+      .filter((row) => (row.reviewedAt !== null) === wantReviewed)
+      .map((row) => {
+        const recipeById = new Map<number, string>();
+        for (const link of row.steps) {
+          recipeById.set(link.step.recipe.id, link.step.recipe.name);
+        }
+        return {
+          id: row.id,
+          displayName: row.displayName ?? "",
+          createdAt: row.createdAt?.toISOString() ?? null,
+          reviewedAt: row.reviewedAt?.toISOString() ?? null,
+          recipeCount: recipeById.size,
+          sampleRecipes: [...recipeById.entries()].slice(0, 5).map(([id, name]) => ({ id, name })),
+        };
+      })
+      .sort(
+        (a, b) => b.recipeCount - a.recipeCount || a.displayName.localeCompare(b.displayName, "fr"),
+      );
+  } catch (err) {
+    throw err; // see recipe.service.ts's equivalent catch comment
+  }
+}
+
+/**
+ * Stamps `reviewedAt` on the given placeholder `TechStep` ids — a
+ * maintainer has seen this proposal (and, if it warranted it, promoted it
+ * into `reference-seed-data.ts` + `tech-step-training-data.ts` by hand; this
+ * endpoint never touches the catalog itself). Scoped to
+ * `isPlaceholder: true` so a stray real id is a silent no-op. Returns how
+ * many rows were actually stamped.
+ */
+export async function markTechStepPlaceholdersReviewed(
+  input: MarkTechStepPlaceholdersReviewedInput,
+): Promise<{ reviewed: number }> {
+  try {
+    const { count } = await prisma.techStep.updateMany({
+      where: { id: { in: input.techStepIds }, isPlaceholder: true },
+      data: { reviewedAt: new Date() },
+    });
+    return { reviewed: count };
+  } catch (err) {
+    throw err; // see recipe.service.ts's equivalent catch comment
+  }
+}

apps/api/src/modules/admin/admin-users.routes.ts

@@ -0,0 +1,31 @@
+import { wrapAsyncHandler } from "@batch-cooking/express-tools";
+import { adminCreateUserSchema } from "@batch-cooking/shared";
+import { Router } from "express";
+import { requireAdmin } from "../../middlewares/require-admin.js";
+import { createUserProfile, listUsers } from "./admin-users.service.js";
+
+/**
+ * Router mounted at `/admin/api/users` (via `admin.routes.ts`) — every route
+ * behind {@link requireAdmin}. Backs the `/admin/utilisateurs` page: a
+ * read-only list of end-user accounts and a "create an account by hand"
+ * form. The server generates a one-time temporary password on create and
+ * returns it in the response (see `admin-users.service.ts`).
+ */
+export const adminUsersRouter = Router();
+
+adminUsersRouter.get(
+  "/",
+  requireAdmin,
+  wrapAsyncHandler(async (_req, res) => {
+    res.status(200).json(await listUsers());
+  }),
+);
+
+adminUsersRouter.post(
+  "/",
+  requireAdmin,
+  wrapAsyncHandler(async (req, res) => {
+    const input = adminCreateUserSchema.parse(req.body);
+    res.status(201).json(await createUserProfile(input));
+  }),
+);

apps/api/src/modules/admin/admin-users.service.ts

@@ -0,0 +1,145 @@
+import { randomInt } from "node:crypto";
+import { HttpError } from "@batch-cooking/error-tools";
+import {
+  type AdminCreateUserInput,
+  type AdminUserCreatedView,
+  type AdminUserListItemView,
+  ErrorCode,
+} from "@batch-cooking/shared";
+import argon2 from "argon2";
+import { env } from "../../config/env.js";
+import { prisma } from "../../db/prisma.js";
+import { analytics } from "../../lib/analytics.service.js";
+
+/**
+ * How many accounts `listUsers` returns per call. Like `CONTACT_MESSAGES_PAGE_SIZE`
+ * this is a triage view, not an export — the admin creates/looks up a handful
+ * of accounts, it never needs the whole table paginated.
+ */
+const USERS_PAGE_SIZE = 200;
+
+// Same reasoning as `admin-auth.service.ts`'s / `auth.service.ts`'s `hashOptions`:
+// argon2's real defaults are deliberately expensive; the test suite hashes
+// against throwaway data many times per run, so a cheaper cost keeps it fast
+// without weakening anything real. Never applies outside NODE_ENV=test.
+const testHashOptions = { memoryCost: 8192, timeCost: 2, parallelism: 1 };
+const hashOptions = env.NODE_ENV === "test" ? testHashOptions : undefined;
+
+/**
+ * Charset for {@link generateTemporaryPassword} — upper/lower letters + digits,
+ * minus the visually ambiguous ones (`0`/`O`/`1`/`l`/`I`), same spirit as
+ * `house.service.ts`'s `INVITE_CODE_CHARS`: this string is read off one screen
+ * and typed into another (or pasted, but not always).
+ */
+const TEMP_PASSWORD_CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789";
+
+/** Length of a generated temporary password — comfortably above `signupSchema`'s 8-char floor. */
+const TEMP_PASSWORD_LENGTH = 16;
+
+/**
+ * A fresh random temporary password for an admin-created account. Uses
+ * `node:crypto`'s `randomInt` (not `Math.random`) exactly like
+ * `generateInviteCode()` — this value guards a real account until its owner
+ * changes it. Returned to the operator once and never stored in plain text.
+ */
+function generateTemporaryPassword(): string {
+  let password = "";
+  for (let i = 0; i < TEMP_PASSWORD_LENGTH; i++) {
+    password += TEMP_PASSWORD_CHARS[randomInt(TEMP_PASSWORD_CHARS.length)];
+  }
+  return password;
+}
+
+/** A `UserProfile` row with its household name joined in — the shape {@link toListItem} maps from. */
+type UserRow = Awaited<
+  ReturnType<
+    typeof prisma.userProfile.findFirstOrThrow<{
+      include: { house: { select: { name: true } } };
+    }>
+  >
+>;
+
+/** Shapes one Prisma `UserProfile` row (with its `house` name) into the admin list view — drops `passwordHash`/`tokenVersion`, resolves the household name. */
+function toListItem(row: UserRow): AdminUserListItemView {
+  return {
+    id: row.id,
+    firstName: row.firstName,
+    lastName: row.lastName,
+    email: row.email,
+    householdName: row.house?.name ?? null,
+    createdAt: row.createdAt.toISOString(),
+  };
+}
+
+/**
+ * Every end-user account for the admin `/admin/utilisateurs` list — newest
+ * first, capped at {@link USERS_PAGE_SIZE}. Read-only: this first version has
+ * no edit/disable/delete (deleting an account is irreversible and stays a
+ * deliberate self-service action in `AccountSettingsPage`).
+ */
+export async function listUsers(): Promise<AdminUserListItemView[]> {
+  try {
+    const rows = await prisma.userProfile.findMany({
+      // `id` as a tiebreaker so the order is total even if two accounts share
+      // a `createdAt` (bulk-provisioned in the same tick) — `id` ascends with
+      // `createdAt` anyway.
+      orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+      take: USERS_PAGE_SIZE,
+      include: { house: { select: { name: true } } },
+    });
+    return rows.map(toListItem);
+  } catch (err) {
+    // Rethrown as-is — `wrapAsyncHandler`/the error middleware handles it,
+    // this layer just isn't allowed a bare `await`. Same as `admin-contact.service.ts`.
+    throw err;
+  }
+}
+
+/**
+ * Provisions a new end-user account by hand and returns it together with the
+ * one-time temporary password the caller must relay to the user. Mirrors
+ * `auth.service.ts`'s `signup` for the parts that matter (email-uniqueness
+ * check, argon2 hash, `UserProfile` row with `houseId`/`dietId` left `null`)
+ * but issues **no session token** — the operator isn't logging in as this
+ * user — and generates the password instead of accepting one.
+ *
+ * @throws {HttpError} `409 EMAIL_ALREADY_IN_USE` if the email is already taken.
+ */
+export async function createUserProfile(
+  input: AdminCreateUserInput,
+): Promise<AdminUserCreatedView> {
+  try {
+    const existing = await prisma.userProfile.findUnique({ where: { email: input.email } });
+    if (existing) {
+      throw new HttpError(409, ErrorCode.EMAIL_ALREADY_IN_USE, "Email already in use");
+    }
+
+    const temporaryPassword = generateTemporaryPassword();
+    const passwordHash = await argon2.hash(temporaryPassword, hashOptions);
+
+    const profile = await prisma.userProfile.create({
+      // No household/diet here, same as `signup` — the user picks those in the
+      // onboarding wizard after their first login.
+      data: {
+        firstName: input.firstName,
+        lastName: input.lastName,
+        email: input.email,
+        passwordHash,
+      },
+      include: { house: { select: { name: true } } },
+    });
+
+    // Fire-and-forget, one line, no migration (see `analytics.service.ts`). A
+    // distinct type from `user.signup` so the dashboard can tell hand-provisioned
+    // accounts apart; `actorType: "system"` because the actor is an operator, not
+    // the new user (and `AnalyticsEvent.actorId` only ever means a `UserProfile.id`).
+    analytics.recordEvent("admin.user_created", {
+      actorType: "system",
+      context: { userId: profile.id },
+    });
+
+    return { user: toListItem(profile), temporaryPassword };
+  } catch (err) {
+    throw err; // see listUsers()'s catch comment
+  }
+}

apps/api/src/modules/admin/admin.routes.ts

@@ -1,9 +1,11 @@
 import { Router } from "express";
 import { adminAuthRouter } from "./admin-auth.routes.js";
 import { adminCatalogRouter } from "./admin-catalog.routes.js";
+import { adminContactRouter } from "./admin-contact.routes.js";
 import { adminMetricsRouter } from "./admin-metrics.routes.js";
 import { adminTechStepsRouter } from "./admin-tech-steps.routes.js";
 import { adminToursRouter } from "./admin-tours.routes.js";
+import { adminUsersRouter } from "./admin-users.routes.js";
 
 /**
  * Aggregator for the admin application's API surface, mounted at
@@ -26,3 +28,5 @@ adminRouter.use("/metrics", adminMetricsRouter);
 adminRouter.use("/tech-steps", adminTechStepsRouter);
 adminRouter.use("/catalog", adminCatalogRouter);
 adminRouter.use("/tours", adminToursRouter);
+adminRouter.use("/contact", adminContactRouter);
+adminRouter.use("/users", adminUsersRouter);

apps/api/src/modules/contact/contact.routes.ts

@@ -0,0 +1,34 @@
+import { wrapAsyncHandler } from "@batch-cooking/express-tools";
+import { submitContactMessageSchema } from "@batch-cooking/shared";
+import { Router } from "express";
+import { type AuthLocals, requireAuth } from "../../middlewares/require-auth.js";
+import { submitContactMessage } from "./contact.service.js";
+
+/**
+ * Router mounted at `/contact` in app.ts (issue #80). A single endpoint —
+ * `POST /` — for the in-app "signaler un bug / suggestion" form. Requires a
+ * session: only signed-in users can send a message, so every report is
+ * attributable (see `ContactMessage.authorId`). The admin-side read of
+ * these rows lives entirely in the admin router, not here.
+ */
+export const contactRouter = Router();
+
+contactRouter.post(
+  "/",
+  requireAuth,
+  wrapAsyncHandler<unknown, AuthLocals>(async (req, res) => {
+    const input = submitContactMessageSchema.parse(req.body);
+    // Read the UA from the request, never from the body — the schema omits
+    // it on purpose so it can't be spoofed. Header can be an array or
+    // absent; normalize to `string | null`.
+    const rawUserAgent = req.headers["user-agent"];
+    const userAgent =
+      typeof rawUserAgent === "string" && rawUserAgent.length > 0 ? rawUserAgent : null;
+    await submitContactMessage(res.locals.userProfile.id, input, userAgent);
+    // 204, not 201-with-a-body: the form has nothing to do with the stored
+    // row, and the shared `ApiClient._request` treats only 204 as bodyless
+    // (a 201 with an empty body makes its `response.json()` throw). Same
+    // "mutation returns nothing" shape as `POST /auth/logout`.
+    res.status(204).end();
+  }),
+);

apps/api/src/modules/contact/contact.service.ts

@@ -0,0 +1,50 @@
+import type { SubmitContactMessageInput } from "@batch-cooking/shared";
+import { prisma } from "../../db/prisma.js";
+import { analytics } from "../../lib/analytics.service.js";
+
+/**
+ * Persists one contact-form submission (issue #80). Write-only from the
+ * user's side — there is no read/update/delete counterpart here: admins
+ * consult these rows through the admin app (`admin-contact.service.ts`, PR
+ * 2), never this module.
+ *
+ * `userAgent` comes straight from the request header, never the body — the
+ * shared `submitContactMessageSchema` deliberately omits it so the client
+ * can't spoof it. `pageUrl` / `appVersion` are client-supplied context and
+ * default to `null` when the (older, or non-web) client didn't send them.
+ *
+ * Returns nothing: the form only needs to know the write succeeded (a
+ * `201`), not the stored row.
+ */
+export async function submitContactMessage(
+  authorId: number,
+  input: SubmitContactMessageInput,
+  userAgent: string | null,
+): Promise<void> {
+  try {
+    await prisma.contactMessage.create({
+      data: {
+        authorId,
+        type: input.type,
+        message: input.message,
+        pageUrl: input.pageUrl ?? null,
+        userAgent,
+        appVersion: input.appVersion ?? null,
+      },
+    });
+    // Fire-and-forget (see AnalyticsService's contract) — `admin-metrics`
+    // aggregates `AnalyticsEvent` by `type` generically, so this shows up in
+    // the dashboard series with no extra code; `context.type` lets it be
+    // broken down by bug/suggestion/other.
+    analytics.recordEvent("contact.submitted", {
+      actorType: "user",
+      actorId: authorId,
+      context: { type: input.type },
+    });
+  } catch (err) {
+    // Rethrown as-is — `wrapAsyncHandler` / the error middleware (which
+    // already logs it) handles it; this service layer just isn't allowed a
+    // bare `await` per the repo's async/try-catch convention.
+    throw err;
+  }
+}

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

@@ -89,7 +89,12 @@ function toOptimizerRecipe(item: PlanningItemWithSteps): OptimizerRecipeInput {
         unit: line.unit === null ? null : toUnitView(line.unit),
       }));
       return {
-        techStep: { id: techStep.techStep.id, key: techStep.techStep.key },
+        techStep: {
+          id: techStep.techStep.id,
+          key: techStep.techStep.key,
+          isPlaceholder: techStep.techStep.isPlaceholder,
+          displayName: techStep.techStep.displayName,
+        },
         order: techStep.order,
         ingredients,
         utensils: techStep.utensils.map(({ utensil }) => ({ id: utensil.id, key: utensil.key })),

apps/api/src/modules/mobile/mobile.routes.ts

@@ -0,0 +1,31 @@
+import { wrapAsyncHandler } from "@batch-cooking/express-tools";
+import { Router } from "express";
+import { getLatestApkUrl, getLatestVersion } from "./mobile.service.js";
+
+/**
+ * Router mounted at `/mobile` in app.ts. Both routes are deliberately
+ * public (no `requireAuth`): the landing page's download link is shown to
+ * logged-out visitors, and the native update check (issue #66) runs on
+ * every app start, session or not. Both exist purely to work around
+ * Forgejo's Releases API sending no CORS headers — see `mobile.service.ts`'s
+ * own doc comment for the full story.
+ */
+export const mobileRouter = Router();
+
+mobileRouter.get(
+  "/latest-release",
+  wrapAsyncHandler(async (_req, res) => {
+    res.status(200).json({ version: await getLatestVersion() });
+  }),
+);
+
+// A plain redirect, not JSON — lets any caller (the landing page's `<a>`,
+// the update banner's "Mettre à jour" link) use a static href with zero
+// client-side fetch, and always resolves to something useful even if
+// Forgejo is briefly unreachable (see getLatestApkUrl's fallback).
+mobileRouter.get(
+  "/download",
+  wrapAsyncHandler(async (_req, res) => {
+    res.redirect(302, await getLatestApkUrl());
+  }),
+);

apps/api/src/modules/mobile/mobile.service.ts

@@ -0,0 +1,75 @@
+import { HttpError } from "@batch-cooking/error-tools";
+import { ErrorCode } from "@batch-cooking/shared";
+
+/**
+ * Forgejo's own Releases API for this repo — public, unauthenticated (the
+ * same fact `local-verification-while-ci-disabled` already leans on for
+ * CI-status checks without a token). **Must be called server-side, not
+ * from the browser**: verified live that Forgejo sends no
+ * `Access-Control-Allow-Origin` header on it, so a direct `fetch()` from
+ * `apps/web` fails with an opaque CORS error even though the endpoint
+ * itself is perfectly reachable — this whole module exists to proxy it
+ * from a context CORS doesn't apply to.
+ */
+const LATEST_RELEASE_API_URL =
+  "https://git.dev.kyuno.fr/api/v1/repos/kyuno/batchCooking/releases/latest";
+
+/**
+ * Human-facing Forgejo release page — safe fallback for {@link getLatestApkUrl}
+ * when no matching asset is found (a release with nothing attached yet,
+ * Forgejo briefly unreachable, ...). Never a dead link, just a slightly
+ * less direct one: the visitor lands on the release itself and can find
+ * the asset from there.
+ */
+const LATEST_RELEASE_PAGE_URL = "https://git.dev.kyuno.fr/kyuno/batchCooking/releases/latest";
+
+/** Stable filename `release.yml` always attaches the signed APK under — see that workflow's own comment. */
+const APK_ASSET_NAME = "batchcooking.apk";
+
+interface ForgejoReleaseAsset {
+  name: string;
+  browser_download_url: string;
+}
+
+interface ForgejoRelease {
+  tag_name: string;
+  assets: ForgejoReleaseAsset[];
+}
+
+async function fetchLatestRelease(): Promise<ForgejoRelease> {
+  const response = await fetch(LATEST_RELEASE_API_URL);
+  if (!response.ok) {
+    throw new HttpError(
+      502,
+      ErrorCode.INTERNAL_ERROR,
+      `Forgejo releases API responded ${response.status}`,
+    );
+  }
+  return (await response.json()) as ForgejoRelease;
+}
+
+/**
+ * The latest tagged Android build's version (e.g. `"v1.4.2"`) — used by the
+ * native app's update check (issue #66, `useAppUpdateCheck.ts`).
+ */
+export async function getLatestVersion(): Promise<string> {
+  const release = await fetchLatestRelease();
+  return release.tag_name;
+}
+
+/**
+ * Where a "download the app" click should end up right now: the actual
+ * signed-APK asset of the latest release if one is attached, else
+ * {@link LATEST_RELEASE_PAGE_URL} as a safe fallback. Never throws — a
+ * download link must always go *somewhere* useful, even when Forgejo is
+ * briefly unreachable.
+ */
+export async function getLatestApkUrl(): Promise<string> {
+  try {
+    const release = await fetchLatestRelease();
+    const apk = release.assets.find((asset) => asset.name === APK_ASSET_NAME);
+    return apk?.browser_download_url ?? LATEST_RELEASE_PAGE_URL;
+  } catch {
+    return LATEST_RELEASE_PAGE_URL;
+  }
+}

apps/api/src/modules/recipe/recipe-tech-step-correction.service.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { HttpError } from "@batch-cooking/error-tools";
 import {
   ErrorCode,
@@ -380,10 +381,20 @@ function toCorrectionView(correction: CorrectionWithTechSteps): StepTechStepCorr
     start: correction.start,
     end: correction.end,
     previousTechStep: correction.previousTechStep
-      ? { id: correction.previousTechStep.id, key: correction.previousTechStep.key }
+      ? {
+          id: correction.previousTechStep.id,
+          key: correction.previousTechStep.key,
+          isPlaceholder: correction.previousTechStep.isPlaceholder,
+          displayName: correction.previousTechStep.displayName,
+        }
       : null,
     correctedTechStep: correction.correctedTechStep
-      ? { id: correction.correctedTechStep.id, key: correction.correctedTechStep.key }
+      ? {
+          id: correction.correctedTechStep.id,
+          key: correction.correctedTechStep.key,
+          isPlaceholder: correction.correctedTechStep.isPlaceholder,
+          displayName: correction.correctedTechStep.displayName,
+        }
       : null,
     createdAt: correction.createdAt.toISOString(),
   };
@@ -449,7 +460,32 @@ export async function submitTechStepCorrection(
     );
     await assertUtensilsExist((input.utensils ?? []).map((u) => u.utensilId));
 
-    const { correction, techSteps } = await prisma.$transaction(async (tx) => {
+    const { correction, techSteps, placeholderTechStepId } = await prisma.$transaction(
+      async (tx) => {
+        // A technique the catalog doesn't have (issue #130) — mint a
+        // placeholder `TechStep` for it, in the same transaction as the
+        // correction that references it, then proceed exactly as if its id had
+        // been sent as `correctedTechStepId`. Same shape as
+        // `recipe.service.ts`'s `resolveIngredientLines` does for a
+        // free-text ingredient.
+        const placeholderTechStepId =
+          input.correctedTechStepName !== undefined
+            ? (
+                await tx.techStep.create({
+                  data: {
+                    key: `placeholder:${randomUUID()}`,
+                    isPlaceholder: true,
+                    displayName: input.correctedTechStepName,
+                    createdById: correctorId,
+                    createdAt: new Date(),
+                  },
+                  select: { id: true },
+                })
+              ).id
+            : null;
+        const effectiveCorrectedTechStepId =
+          placeholderTechStepId ?? input.correctedTechStepId ?? null;
+
         const createdCorrection = await tx.stepTechStepCorrection.create({
           data: {
             stepId: step.id,
@@ -457,7 +493,7 @@ export async function submitTechStepCorrection(
             start: input.start,
             end: input.end,
             previousTechStepId: input.previousTechStepId ?? null,
-          correctedTechStepId: input.correctedTechStepId ?? null,
+            correctedTechStepId: effectiveCorrectedTechStepId,
           },
           include: correctionInclude,
         });
@@ -467,7 +503,7 @@ export async function submitTechStepCorrection(
           step.id,
           { start: input.start, end: input.end },
           input.previousTechStepId ?? null,
-        input.correctedTechStepId ?? null,
+          effectiveCorrectedTechStepId,
           input.ingredients === undefined &&
             input.utensils === undefined &&
             input.temperatures === undefined
@@ -524,8 +560,9 @@ export async function submitTechStepCorrection(
           },
         });
 
-      return { correction: createdCorrection, techSteps: freshTechSteps };
+        return { correction: createdCorrection, techSteps: freshTechSteps, placeholderTechStepId };
-    });
+      },
+    );
 
     analytics.recordEvent("tech_step.correction_submitted", {
       actorId: correctorId,
@@ -533,9 +570,20 @@ export async function submitTechStepCorrection(
         recipeId,
         stepId,
         previousTechStepId: input.previousTechStepId ?? null,
-        correctedTechStepId: input.correctedTechStepId ?? null,
+        correctedTechStepId: correction.correctedTechStepId,
       },
     });
+    if (placeholderTechStepId !== null) {
+      analytics.recordEvent("tech_step.placeholder_proposed", {
+        actorId: correctorId,
+        context: {
+          recipeId,
+          stepId,
+          techStepId: placeholderTechStepId,
+          name: input.correctedTechStepName ?? "",
+        },
+      });
+    }
 
     return { correction: toCorrectionView(correction), techSteps: toStepTechStepViews(techSteps) };
   } catch (err) {

apps/api/src/modules/recipe/recipe.service.ts

@@ -3,6 +3,7 @@ import { HttpError } from "@batch-cooking/error-tools";
 import {
   type AllergyView,
   type CreateRecipeInput,
+  computeRecipeDietViews,
   type DietView,
   ErrorCode,
   type IngredientView,
@@ -29,7 +30,7 @@ import { toStepTechStepCreateInputs } from "../../lib/recipe-matching/tech-step-
 // is a parameter rather than baked into that module.
 const DEFAULT_TECH_STEP_LOCALE = "fr";
 
-/** Prisma `include` for every query that needs a full {@link RecipeView} — ingredients resolved to their reference data + allergens, steps in order, diet tags, and whether `viewerId` has favorited it. Parameterized by viewer since `favoritedBy` is per-viewer, not a static shape. */
+/** Prisma `include` for every query that needs a full {@link RecipeView} — ingredients resolved to their reference data (name, allergens, diet compatibilities), steps in order, and whether `viewerId` has favorited it. Parameterized by viewer since `favoritedBy` is per-viewer, not a static shape. A recipe's own regimes are no longer stored (issue #131 dropped `RecipeDiet`) — they're computed from the ingredient views by {@link computeRecipeDietViews}. */
 function recipeInclude(viewerId: number) {
   return {
     ingredients: {
@@ -74,18 +75,38 @@ function recipeInclude(viewerId: number) {
         },
       },
     },
-    diets: { include: { diet: true } },
     favoritedBy: { where: { userProfileId: viewerId } },
   } satisfies Prisma.RecipeInclude;
 }
 
+/**
+ * Every reference `Diet` row (`{ id, key }`), loaded once and memoized —
+ * `Diet` is seeded reference data that never changes at runtime, so caching
+ * it for the process's lifetime is safe. Used to attach a real `DietView` to
+ * the derived gluten-free regime (see {@link loadGlutenFreeDiet}) and to
+ * resolve the planning picker's `dietIds` filter / a household's members'
+ * regimes for the post-filter in {@link listRecipes}.
+ */
+let referenceDietsPromise: Promise<DietView[]> | null = null;
+function loadReferenceDiets(): Promise<DietView[]> {
+  if (referenceDietsPromise === null) {
+    referenceDietsPromise = prisma.diet.findMany({ select: { id: true, key: true } });
+  }
+  return referenceDietsPromise;
+}
+
+/** The reference `glutenFree` {@link DietView} — {@link computeRecipeDietViews} needs it to give the derived gluten-free regime a real `{ id, key }` (no `IngredientDiet` row references it, unlike the other regimes). `undefined` only if the seed somehow lacks the row, in which case gluten-free is simply omitted. */
+async function loadGlutenFreeDiet(): Promise<DietView | undefined> {
+  return (await loadReferenceDiets()).find((diet) => diet.key === "glutenFree");
+}
+
 type RecipeWithDetails = Prisma.RecipeGetPayload<{
   include: ReturnType<typeof recipeInclude>;
 }>;
 /** Exported — `shopping-list.service.ts` fetches its own, narrower ingredient include (no need for a whole `RecipeWithDetails`) but shapes the same `allergies`/`diets` nesting, so it reuses {@link toIngredientView} directly instead of re-deriving this type. */
 export type IngredientWithDetails = RecipeWithDetails["ingredients"][number]["ingredient"];
-/** Exported — see {@link IngredientWithDetails}, same reuse by `shopping-list.service.ts`. */
+/** Exported — see {@link IngredientWithDetails}, same reuse by `shopping-list.service.ts`. `NonNullable` since a `RecipeIngredient.unit` is now `null` on a "selon le goût" line — callers guard that before calling {@link toUnitView}. */
-export type UnitWithDetails = RecipeWithDetails["ingredients"][number]["unit"];
+export type UnitWithDetails = NonNullable<RecipeWithDetails["ingredients"][number]["unit"]>;
 
 /** Shapes a Prisma `Unit` row into the public {@link UnitView} — same "Decimal → number" conversion `reference.service.ts`'s `getUnits` does. Exported — reused as-is by `shopping-list.service.ts` (a shopping list resolves the same reference data, no need for a second copy of this mapping). */
 export function toUnitView(unit: UnitWithDetails): UnitView {
@@ -121,10 +142,6 @@ export function toIngredientView(ingredient: IngredientWithDetails): IngredientV
   };
 }
 
-function toDietView(diet: { id: number; key: string }): DietView {
-  return { id: diet.id, key: diet.key };
-}
-
 /** Deduplicates allergens (by id) across every ingredient of a recipe, for the aggregated "contains" badge — see {@link RecipeSummaryView.allergens}. */
 function aggregateAllergens(ingredients: IngredientView[]): AllergyView[] {
   const byId = new Map<number, AllergyView>();
@@ -136,10 +153,13 @@ function aggregateAllergens(ingredients: IngredientView[]): AllergyView[] {
   return [...byId.values()];
 }
 
-/** Shapes a Prisma `Recipe` (with {@link recipeInclude} included) into the lighter {@link RecipeSummaryView} used by the catalog table — everything `toRecipeView` also needs, factored out since the full detail view is a strict superset. */
+/** Shapes a Prisma `Recipe` (with {@link recipeInclude} included) into the lighter {@link RecipeSummaryView} used by the catalog table — everything `toRecipeView` also needs, factored out since the full detail view is a strict superset. `glutenFreeDiet` (see {@link loadGlutenFreeDiet}) is threaded through only so {@link computeRecipeDietViews} can attach a real `DietView` to the derived gluten-free regime. */
-function toRecipeSummaryView(recipe: RecipeWithDetails): RecipeSummaryView {
+function toRecipeSummaryView(
-  const allergens = aggregateAllergens(
+  recipe: RecipeWithDetails,
-    recipe.ingredients.map((recipeIngredient) => toIngredientView(recipeIngredient.ingredient)),
+  glutenFreeDiet: DietView | undefined,
+): RecipeSummaryView {
+  const ingredientViews = recipe.ingredients.map((recipeIngredient) =>
+    toIngredientView(recipeIngredient.ingredient),
   );
   return {
     id: recipe.id,
@@ -149,8 +169,9 @@ function toRecipeSummaryView(recipe: RecipeWithDetails): RecipeSummaryView {
     portions: recipe.portions,
     authorId: recipe.authorId,
     visibility: recipe.visibility,
-    allergens,
+    allergens: aggregateAllergens(ingredientViews),
-    diets: recipe.diets.map((recipeDiet) => toDietView(recipeDiet.diet)),
+    // Computed from the ingredients, not stored — see `RecipeSummaryView.diets`.
+    diets: computeRecipeDietViews(ingredientViews, glutenFreeDiet),
     isFavorite: recipe.favoritedBy.length > 0,
   };
 }
@@ -190,7 +211,12 @@ export function toStepTechStepViews(
     } = stepTechStep;
     if (start === null || end === null) continue;
     views.push({
-      techStep: { id: techStep.id, key: techStep.key },
+      techStep: {
+        id: techStep.id,
+        key: techStep.key,
+        isPlaceholder: techStep.isPlaceholder,
+        displayName: techStep.displayName,
+      },
       start,
       end,
       // `source` is a plain DB `String`, not a Prisma enum (see
@@ -240,15 +266,16 @@ export function toStepTechStepViews(
   return views;
 }
 
-/** Shapes a Prisma `Recipe` (with {@link recipeInclude} included) into the public {@link RecipeView}. */
+/** Shapes a Prisma `Recipe` (with {@link recipeInclude} included) into the public {@link RecipeView}. `glutenFreeDiet` — see {@link toRecipeSummaryView}. */
-function toRecipeView(recipe: RecipeWithDetails): RecipeView {
+function toRecipeView(recipe: RecipeWithDetails, glutenFreeDiet: DietView | undefined): RecipeView {
   const ingredients = recipe.ingredients.map((recipeIngredient) => ({
     ingredient: toIngredientView(recipeIngredient.ingredient),
-    quantity: Number(recipeIngredient.quantity),
+    // Both `null` on a "selon le goût" seasoning line — see `RecipeIngredientView`.
-    unit: toUnitView(recipeIngredient.unit),
+    quantity: recipeIngredient.quantity === null ? null : Number(recipeIngredient.quantity),
+    unit: recipeIngredient.unit === null ? null : toUnitView(recipeIngredient.unit),
   }));
   return {
-    ...toRecipeSummaryView(recipe),
+    ...toRecipeSummaryView(recipe, glutenFreeDiet),
     ingredients,
     steps: recipe.steps.map((step) => ({
       id: step.id,
@@ -301,54 +328,57 @@ function visibleToViewerWhere(
 }
 
 /**
- * `Recipe` rows that avoid every member of `houseId`'s declared allergens
+ * The two halves of the planning recipe picker's "convient à tout le foyer"
- * and, for every member with a declared regime, are tagged with that
+ * toggle (`suitableForHousehold` on `listRecipes`):
- * regime — the planning recipe picker's "convient à tout le foyer" toggle
+ *  - `allergenWhere` — a `Prisma.RecipeWhereInput` excluding any recipe that
- * (`suitableForHousehold` on `listRecipes`). Computed server-side (a small
+ *    contains an allergen declared by a member (still expressible in SQL).
- * extra query to gather the household's members' allergy/regime ids)
+ *  - `requiredDietKeys` — every regime declared by a member (`omnivore`
- * rather than exposed to the client as raw per-member data: a member's
+ *    dropped: it constrains nothing). A recipe must satisfy *all* of them —
- * allergies/regime are private the same way visibility already keeps a
+ *    a recipe suiting a vegetarian member doesn't automatically suit a
- * recipe's existence private (404, never 403) — nothing here should let
+ *    gluten-free one. Applied as a post-filter in {@link listRecipes} on the
- * one member infer another's medical/dietary info from the shape of a
+ *    *computed* `RecipeSummaryView.diets`, since regimes are no longer a
- * filtered list. Deliberately excludes `UserProfileDislikedIngredient` —
+ *    stored column to query (issue #131).
- * the schema already treats disliked ingredients as a taste preference,
+ *
- * not a safety constraint (see that model's doc comment), so it doesn't
+ * Computed server-side (a small extra query for the members' allergy/regime
- * belong in a filter framed around what's safe/appropriate to serve.
+ * data) rather than exposed to the client as raw per-member data: a
+ * member's allergies/regime are private the same way visibility already
+ * keeps a recipe's existence private. Deliberately excludes
+ * `UserProfileDislikedIngredient` — a taste preference, not a safety
+ * constraint (see that model's doc comment).
  */
-async function suitableForHouseholdWhere(houseId: number): Promise<Prisma.RecipeWhereInput> {
+async function suitableForHousehold(
+  houseId: number,
+): Promise<{ allergenWhere: Prisma.RecipeWhereInput; requiredDietKeys: string[] }> {
   try {
     const members = await prisma.userProfile.findMany({
       where: { houseId },
-      select: { dietId: true, allergies: { select: { allergyId: true } } },
+      select: {
+        diet: { select: { key: true } },
+        allergies: { select: { allergyId: true } },
+      },
     });
-    const requiredDietIds = [
+    const requiredDietKeys = [
-      ...new Set(members.map((m) => m.dietId).filter((id): id is number => id !== null)),
+      ...new Set(
+        members
+          .map((member) => member.diet?.key)
+          .filter((key): key is string => key !== undefined && key !== "omnivore"),
+      ),
     ];
     const excludedAllergyIds = [
-      ...new Set(members.flatMap((m) => m.allergies.map((a) => a.allergyId))),
+      ...new Set(members.flatMap((member) => member.allergies.map((allergy) => allergy.allergyId))),
     ];
 
-    const conditions: Prisma.RecipeWhereInput[] = [];
+    const allergenWhere: Prisma.RecipeWhereInput =
-    if (requiredDietIds.length > 0) {
+      excludedAllergyIds.length > 0
-      // Every diet declared by a member must be among this recipe's tags —
+        ? {
-      // not "at least one", since a recipe suiting a vegetarian member
-      // doesn't automatically suit a gluten-free one too.
-      conditions.push({
-        AND: requiredDietIds.map((dietId) => ({ diets: { some: { dietId } } })),
-      });
-    }
-    if (excludedAllergyIds.length > 0) {
-      conditions.push({
             ingredients: {
               none: {
-            ingredient: {
+                ingredient: { allergies: { some: { allergyId: { in: excludedAllergyIds } } } },
-              allergies: { some: { allergyId: { in: excludedAllergyIds } } },
               },
             },
-        },
-      });
           }
-    return { AND: conditions };
+        : {};
+    return { allergenWhere, requiredDietKeys };
   } catch (err) {
     // Rethrown as-is — `wrapAsyncHandler`/the error middleware (which
     // already logs it, see `error-logger.ts`) is what actually handles it,
@@ -382,7 +412,7 @@ async function sourceVisibilityWhere(houseId: number | null): Promise<Prisma.Rec
           ).map((row) => row.sourceId);
     return { OR: [{ sourceId: null }, { sourceId: { in: enabledSourceIds } }] };
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -396,11 +426,11 @@ async function sourceVisibilityWhere(houseId: number | null): Promise<Prisma.Rec
 export interface ListRecipesFilters {
   /** Case-insensitive name substring. */
   search?: string;
-  /** The planning recipe picker's "convient à tout le foyer" toggle — see {@link suitableForHouseholdWhere}. */
+  /** The planning recipe picker's "convient à tout le foyer" toggle — see {@link suitableForHousehold}. */
   suitableForHousehold?: boolean;
   /** Recipe must carry *every* one of these ingredient ids (AND, not "any of") — the planning recipe picker's ingredient filter. */
   ingredientIds?: number[];
-  /** Recipe must be tagged with *every* one of these diet ids (AND, same reasoning) — the planning recipe picker's regime filter. */
+  /** Recipe's *computed* regimes must include *every* one of these diet ids (AND, same reasoning) — the planning recipe picker's regime filter. Applied as a post-filter now that regimes aren't a stored column (issue #131). */
   dietIds?: number[];
 }
 
@@ -420,31 +450,32 @@ export async function listRecipes(
   filters: ListRecipesFilters = {},
 ): Promise<RecipeSummaryView[]> {
   try {
-    const { search, suitableForHousehold, ingredientIds, dietIds } = filters;
+    const { search, suitableForHousehold: suitable, ingredientIds, dietIds } = filters;
     const conditions: Prisma.RecipeWhereInput[] = [await sourceVisibilityWhere(viewerHouseId)];
     if (search) {
       conditions.push({ name: { contains: search, mode: "insensitive" } });
     }
+    // Regimes are computed from ingredients, not a stored column (issue
+    // #131), so the household-regime and `dietIds` filters can't be SQL
+    // anymore — they run as post-filters on the mapped summaries below.
+    // Everything that still *can* be a `where` stays one.
+    let requiredDietKeys: string[] = [];
     // No-op without a household — nothing to filter against, same posture as
     // the `foyer` tab returning everything it can rather than throwing.
-    if (suitableForHousehold && viewerHouseId !== null) {
+    if (suitable && viewerHouseId !== null) {
-      conditions.push(await suitableForHouseholdWhere(viewerHouseId));
+      const household = await suitableForHousehold(viewerHouseId);
+      conditions.push(household.allergenWhere);
+      requiredDietKeys = household.requiredDietKeys;
     }
     if (ingredientIds && ingredientIds.length > 0) {
       // One condition per required id (AND) — a recipe must carry all of
-      // them, not just one, same "every one, not any one" posture as
+      // them, not just one.
-      // suitableForHouseholdWhere's requiredDietIds.
       conditions.push({
         AND: ingredientIds.map((ingredientId) => ({
           ingredients: { some: { ingredientId } },
         })),
       });
     }
-    if (dietIds && dietIds.length > 0) {
-      conditions.push({
-        AND: dietIds.map((dietId) => ({ diets: { some: { dietId } } })),
-      });
-    }
 
     switch (tab) {
       case "favoris":
@@ -464,14 +495,38 @@ export async function listRecipes(
         break;
     }
 
-    const recipes = await prisma.recipe.findMany({
+    const [recipes, referenceDiets] = await Promise.all([
+      prisma.recipe.findMany({
         where: { AND: conditions },
         include: recipeInclude(viewerId),
         orderBy: { name: "asc" },
-    });
+      }),
-    return recipes.map(toRecipeSummaryView);
+      loadReferenceDiets(),
+    ]);
+    const glutenFreeDiet = referenceDiets.find((diet) => diet.key === "glutenFree");
+
+    let summaries = recipes.map((recipe) => toRecipeSummaryView(recipe, glutenFreeDiet));
+
+    // Post-filters on the *computed* `diets` (see the comment where the SQL
+    // conditions are built). "Every one, not any one" for both.
+    if (requiredDietKeys.length > 0) {
+      summaries = summaries.filter((summary) =>
+        requiredDietKeys.every((key) => summary.diets.some((diet) => diet.key === key)),
+      );
+    }
+    if (dietIds && dietIds.length > 0) {
+      // `omnivore` in the filter would match nothing (it's never emitted) —
+      // treat it as "no constraint" rather than silently returning an empty list.
+      const requiredIds = dietIds.filter(
+        (id) => referenceDiets.find((diet) => diet.id === id)?.key !== "omnivore",
+      );
+      summaries = summaries.filter((summary) =>
+        requiredIds.every((id) => summary.diets.some((diet) => diet.id === id)),
+      );
+    }
+    return summaries;
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -490,23 +545,23 @@ export async function getRecipe(
     if (!canView(recipe, viewerId, viewerHouseId)) {
       throw new HttpError(404, ErrorCode.RECIPE_NOT_FOUND, `Recipe ${id} not found`);
     }
-    return toRecipeView(recipe);
+    return toRecipeView(recipe, await loadGlutenFreeDiet());
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
 /**
- * Creates a recipe with its ingredients, ordered steps and diet tags in one
+ * Creates a recipe with its ingredients and ordered steps in one go —
- * go — steps' `order` is derived from their position in `input.steps`,
+ * steps' `order` is derived from their position in `input.steps`,
  * ingredients reference existing reference `Ingredient` rows by id (see
- * `GET /reference/ingredients`; there's no way to create one here).
+ * `GET /reference/ingredients`; there's no way to create one here). Its
- * `authorId`/`authorHouseId` are fixed at creation and never change on
+ * regimes aren't stored — they're computed from the ingredients on read
- * later edits (see {@link updateRecipe}).
+ * (issue #131). `authorId`/`authorHouseId` are fixed at creation and never
+ * change on later edits (see {@link updateRecipe}).
  *
  * @throws {HttpError} `404 INGREDIENT_NOT_FOUND` if any `ingredientId` doesn't match a reference ingredient.
  * @throws {HttpError} `404 UNIT_NOT_FOUND` if any `unitId` doesn't match a reference unit.
- * @throws {HttpError} `404 DIET_NOT_FOUND` if any `dietId` doesn't match a reference diet.
  */
 export async function createRecipe(
   input: CreateRecipeInput,
@@ -516,7 +571,7 @@ export async function createRecipe(
   try {
     return await createRecipeInternal(input, authorId, authorHouseId, null);
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -533,7 +588,6 @@ export async function createRecipe(
  *
  * @throws {HttpError} `404 INGREDIENT_NOT_FOUND` if any `ingredientId` doesn't match a reference ingredient.
  * @throws {HttpError} `404 UNIT_NOT_FOUND` if any `unitId` doesn't match a reference unit.
- * @throws {HttpError} `404 DIET_NOT_FOUND` if any `dietId` doesn't match a reference diet.
  */
 export async function createImportedRecipe(
   input: CreateRecipeInput,
@@ -544,7 +598,7 @@ export async function createImportedRecipe(
   try {
     return await createRecipeInternal(input, authorId, authorHouseId, source);
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -578,11 +632,11 @@ async function matchStepsTechSteps<T extends { description: string }>(
   );
 }
 
-/** One resolved ingredient line — every `placeholderName` has been turned into a real (placeholder) `ingredientId`, ready for a `RecipeIngredient` create. */
+/** One resolved ingredient line — every `placeholderName` has been turned into a real (placeholder) `ingredientId`, ready for a `RecipeIngredient` create. `quantity`/`unitId` are both `null` for a "selon le goût" seasoning line. */
 interface ResolvedIngredientLine {
   ingredientId: number;
-  quantity: number;
+  quantity: number | null;
-  unitId: number;
+  unitId: number | null;
 }
 
 /**
@@ -615,8 +669,8 @@ async function resolveIngredientLines(
       if (line.ingredientId !== undefined) {
         resolved.push({
           ingredientId: line.ingredientId,
-          quantity: line.quantity,
+          quantity: line.quantity ?? null,
-          unitId: line.unitId,
+          unitId: line.unitId ?? null,
         });
         continue;
       }
@@ -632,12 +686,16 @@ async function resolveIngredientLines(
         },
         select: { id: true },
       });
-      resolved.push({ ingredientId: placeholder.id, quantity: line.quantity, unitId: line.unitId });
+      resolved.push({
+        ingredientId: placeholder.id,
+        quantity: line.quantity ?? null,
+        unitId: line.unitId ?? null,
+      });
       createdPlaceholders.push({ id: placeholder.id, name });
     }
     return { resolved, createdPlaceholders };
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -651,8 +709,9 @@ async function createRecipeInternal(
     await assertIngredientsExist(
       input.ingredients.map((i) => i.ingredientId).filter((id): id is number => id !== undefined),
     );
-    await assertUnitsExist(input.ingredients.map((i) => i.unitId));
+    await assertUnitsExist(
-    await assertDietsExist(input.dietIds);
+      input.ingredients.flatMap((i) => (i.unitId === undefined ? [] : [i.unitId])),
+    );
     // Matched up front (one call per step, in parallel) rather than inline
     // inside the `steps.create` map below — `techStepClassifier` is async
     // (a trained model, not a pure regex test), so its result has to
@@ -702,7 +761,6 @@ async function createRecipeInternal(
               techSteps: { create: toStepTechStepCreateInputs(matches) },
             })),
           },
-          diets: { create: input.dietIds.map((dietId) => ({ dietId })) },
         },
         include: recipeInclude(authorId),
       });
@@ -720,24 +778,25 @@ async function createRecipeInternal(
       });
     }
 
-    return toRecipeView(created);
+    return toRecipeView(created, await loadGlutenFreeDiet());
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
 /**
  * Replaces a recipe's whole content — name/description/picture/visibility
- * and the complete ingredient/step/diet lists (not a partial merge: a line
+ * and the complete ingredient/step lists (not a partial merge: a line
  * missing from `input` is removed, same contract as `PATCH
- * /profile/allergies`). `authorId`/`authorHouseId` are untouched — editing
+ * /profile/allergies`). Regimes aren't part of the payload — they're
- * never transfers ownership.
+ * recomputed from the ingredients on the next read (issue #131).
+ * `authorId`/`authorHouseId` are untouched — editing never transfers
+ * ownership.
  *
  * @throws {HttpError} `404 RECIPE_NOT_FOUND` if `id` doesn't match any recipe visible to `viewerId`.
  * @throws {HttpError} `403 NOT_RECIPE_AUTHOR` if `viewerId` isn't this recipe's author.
  * @throws {HttpError} `404 INGREDIENT_NOT_FOUND` if any `ingredientId` doesn't match a reference ingredient.
  * @throws {HttpError} `404 UNIT_NOT_FOUND` if any `unitId` doesn't match a reference unit.
- * @throws {HttpError} `404 DIET_NOT_FOUND` if any `dietId` doesn't match a reference diet.
  */
 export async function updateRecipe(
   id: number,
@@ -752,8 +811,9 @@ export async function updateRecipe(
         .map((i) => i.ingredientId)
         .filter((ingredientId): ingredientId is number => ingredientId !== undefined),
     );
-    await assertUnitsExist(input.ingredients.map((i) => i.unitId));
+    await assertUnitsExist(
-    await assertDietsExist(input.dietIds);
+      input.ingredients.flatMap((i) => (i.unitId === undefined ? [] : [i.unitId])),
+    );
     const stepsWithTechSteps = await matchStepsTechSteps(input.steps, DEFAULT_TECH_STEP_LOCALE);
 
     // Interactive transaction (not the array form) so any new free-text
@@ -764,7 +824,6 @@ export async function updateRecipe(
     const createdPlaceholders = await prisma.$transaction(async (tx) => {
       await tx.recipeIngredient.deleteMany({ where: { recipeId: id } });
       await tx.step.deleteMany({ where: { recipeId: id } });
-      await tx.recipeDiet.deleteMany({ where: { recipeId: id } });
       const { resolved, createdPlaceholders } = await resolveIngredientLines(
         input.ingredients,
         viewerId,
@@ -799,7 +858,6 @@ export async function updateRecipe(
               techSteps: { create: toStepTechStepCreateInputs(matches) },
             })),
           },
-          diets: { create: input.dietIds.map((dietId) => ({ dietId })) },
         },
       });
       return createdPlaceholders;
@@ -812,9 +870,9 @@ export async function updateRecipe(
       });
     }
 
-    return toRecipeView(await findRecipeOrThrow(id, viewerId));
+    return toRecipeView(await findRecipeOrThrow(id, viewerId), await loadGlutenFreeDiet());
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -847,7 +905,7 @@ export async function deleteRecipe(
 
     await prisma.recipe.delete({ where: { id } });
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -875,7 +933,7 @@ export async function addFavorite(
       create: { userProfileId: viewerId, recipeId: id },
     });
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -886,7 +944,7 @@ export async function removeFavorite(id: number, viewerId: number): Promise<void
       where: { userProfileId: viewerId, recipeId: id },
     });
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -909,7 +967,7 @@ export async function assertRecipeVisible(
       throw new HttpError(404, ErrorCode.RECIPE_NOT_FOUND, `Recipe ${id} not found`);
     }
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -925,7 +983,7 @@ async function findRecipeOrThrow(id: number, viewerId: number): Promise<RecipeWi
     }
     return recipe;
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -944,7 +1002,7 @@ async function assertIsAuthor(
       throw new HttpError(403, ErrorCode.NOT_RECIPE_AUTHOR, "Only the recipe's author can do this");
     }
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -966,7 +1024,7 @@ async function assertIngredientsExist(ingredientIds: number[]): Promise<void> {
       );
     }
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
   }
 }
 
@@ -988,29 +1046,6 @@ async function assertUnitsExist(unitIds: number[]): Promise<void> {
       );
     }
   } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
+    throw err; // see suitableForHousehold()'s catch comment above
-  }
-}
-
-/** Throws `404 DIET_NOT_FOUND` if any of `dietIds` doesn't match a reference `Diet` row. */
-async function assertDietsExist(dietIds: number[]): Promise<void> {
-  try {
-    const uniqueIds = [...new Set(dietIds)];
-    if (uniqueIds.length === 0) return;
-    const found = await prisma.diet.findMany({
-      where: { id: { in: uniqueIds } },
-      select: { id: true },
-    });
-    if (found.length !== uniqueIds.length) {
-      const foundIds = new Set(found.map((diet) => diet.id));
-      const missing = uniqueIds.filter((id) => !foundIds.has(id));
-      throw new HttpError(
-        404,
-        ErrorCode.DIET_NOT_FOUND,
-        `Diet(s) not found: ${missing.join(", ")}`,
-      );
-    }
-  } catch (err) {
-    throw err; // see suitableForHouseholdWhere()'s catch comment above
   }
 }

apps/api/src/modules/reference/reference.service.ts

@@ -77,11 +77,21 @@ export async function getUnits(): Promise<UnitView[]> {
 /**
  * All reference cooking techniques, ordered by key (see {@link getDiets}
  * for why) — small, static list (see `reference-seed-data.ts`'s
- * `TECH_STEPS`). Not consumed by the recipe UI yet — see {@link TechStepView}.
+ * `TECH_STEPS`).
+ *
+ * Excludes placeholder rows (`TechStep.isPlaceholder` — the free-text
+ * techniques users propose when the catalog falls short, issue #130): this
+ * is the *browsable* catalog, and a placeholder is a per-correction
+ * stand-in, not a real entry anyone should pick again.
  */
 export async function getTechSteps(): Promise<TechStepView[]> {
   try {
-    return await prisma.techStep.findMany({ orderBy: { key: "asc" } });
+    const techSteps = await prisma.techStep.findMany({
+      where: { isPlaceholder: false },
+      select: { id: true, key: true },
+      orderBy: { key: "asc" },
+    });
+    return techSteps.map((techStep) => ({ ...techStep, isPlaceholder: false, displayName: null }));
   } catch (err) {
     throw err; // see getDiets()'s catch comment above
   }

apps/api/src/modules/shopping-list/shopping-list.service.ts

@@ -44,11 +44,11 @@ type PlanningWithIngredients = Prisma.PlanningGetPayload<{
   include: ReturnType<typeof shoppingListPlanningInclude>;
 }>;
 
-/** Accumulates a running sum per `(ingredientId, unitId)` pair while walking every planning item's ingredient lines — see {@link aggregateShoppingList}. */
+/** Accumulates a running sum per `(ingredientId, unitId)` pair while walking every planning item's ingredient lines — see {@link aggregateShoppingList}. `unit`/`quantity` are both `null` for a "selon le goût" seasoning line: nothing to sum, surfaced once. */
 interface RunningTotal {
   ingredient: IngredientView;
-  unit: UnitView;
+  unit: UnitView | null;
-  quantity: number;
+  quantity: number | null;
 }
 
 /**
@@ -70,16 +70,31 @@ function aggregateShoppingList(items: PlanningWithIngredients["items"]): Shoppin
   for (const item of items) {
     const scale = item.portions / item.recipe.portions;
     for (const recipeIngredient of item.recipe.ingredients) {
+      // A "selon le goût" seasoning line (no quantity/unit) — surfaced once
+      // per ingredient, never scaled or summed. Its key can't collide with a
+      // real `(ingredient, unit)` line for the same ingredient.
+      if (recipeIngredient.quantity === null) {
+        const seasoningKey = `${recipeIngredient.ingredientId}:toTaste`;
+        if (!totals.has(seasoningKey)) {
+          totals.set(seasoningKey, {
+            ingredient: toIngredientView(recipeIngredient.ingredient),
+            unit: null,
+            quantity: null,
+          });
+        }
+        continue;
+      }
+
       const key = `${recipeIngredient.ingredientId}:${recipeIngredient.unitId}`;
       const addedQuantity = Number(recipeIngredient.quantity) * scale;
 
       const existing = totals.get(key);
-      if (existing) {
+      if (existing && existing.quantity !== null) {
         existing.quantity += addedQuantity;
       } else {
         totals.set(key, {
           ingredient: toIngredientView(recipeIngredient.ingredient),
-          unit: toUnitView(recipeIngredient.unit),
+          unit: recipeIngredient.unit === null ? null : toUnitView(recipeIngredient.unit),
           quantity: addedQuantity,
         });
       }

apps/api/src/modules/sources/sources.service.ts

@@ -180,9 +180,20 @@ export async function previewSourceItem(
         ),
         loadIngredientCatalog(adapter.locale),
         loadUnitCatalog(adapter.locale),
-        prisma.techStep.findMany({ select: { id: true, key: true } }),
+        // Real catalog techniques only — a draft preview is never a saved
+        // recipe, so it can't carry a user-proposed placeholder technique
+        // (issue #130); `isPlaceholder`/`displayName` are the neutral values.
+        prisma.techStep.findMany({
+          where: { isPlaceholder: false },
+          select: { id: true, key: true },
+        }),
       ]);
-    const techStepById = new Map(techStepsByKey.map((techStep) => [techStep.id, techStep]));
+    const techStepById = new Map(
+      techStepsByKey.map((techStep) => [
+        techStep.id,
+        { ...techStep, isPlaceholder: false, displayName: null },
+      ]),
+    );
 
     const translatedIngredients = translateRecipeIngredients(
       parsed.ingredients,

apps/api/src/sources/manger-bouger.ts

@@ -18,11 +18,13 @@ const SOURCE_KEY = "mangerBouger";
 // all (unlike marmiton.ts's search page) — but it's server-rendered, and a
 // plain GET carries the exact same Redux state the client hydrates from as
 // a `__NEXT_DATA__` script tag (see `extractNextData` below), which already
-// has everything `list()` needs. Verified live: `?query=<free text>` really
+// has everything `list()` needs. Verified live for the *search* path
-// filters server-side (not just a client-side URL update over an
+// (`?diet=ALL&page=N&query=<free text>`): `query` really filters
-// already-fetched page), and `page`/`hasMorePages` behave as real,
+// server-side (not just a client-side URL update over an already-fetched
-// consistent pagination — the best-behaved of this adapter family's three
+// page), and `page`/`hasMorePages` behave as real, consistent pagination.
-// sources on that front.
+// The *catalogue browse* path (no `query` term) must be the bare
+// `?diet=ALL&page=N` — a trailing empty `&query=` made the deployed server
+// repeat page 1 for every page (issue #78); `list()` below now omits it.
 const LIST_URL = "https://www.mangerbouger.fr/manger-mieux/la-fabrique-a-menus/recettes";
 const DETAIL_BASE_URL = "https://www.mangerbouger.fr/manger-mieux/la-fabrique-a-menus/recettes/";
 
@@ -42,7 +44,7 @@ interface MangerBougerListPageData {
     initialState?: {
       recipes?: {
         list?: MangerBougerListEntry[];
-        /** Whether a further page exists for the current `page`/`query`/`diet` combination — verified live: an out-of-range page comes back `false` with an empty `list` rather than repeating the last page or erroring, a cleaner end-of-results signal than either `marmiton.ts` (infers it from a 404) or `750g.ts` (this search has no real pagination at all). */
+        /** Whether a further page exists for the current `page`/`query`/`diet` combination — verified live on the `query`-term path: an out-of-range page comes back `false` with an empty `list` rather than repeating the last page or erroring, a cleaner end-of-results signal than either `marmiton.ts` (infers it from a 404) or `750g.ts` (this search has no real pagination at all). The catalogue-browse path (no `query`) only paginates when the request URL omits `&query=` entirely — see `LIST_URL` and issue #78. */
         hasMorePages?: boolean;
       };
     };
@@ -284,8 +286,18 @@ export const mangerBougerAdapter: RecipeSourceAdapter<{ html: string; url: strin
   async list(params: RecipeSourceListParams): Promise<RecipeSourceListResult> {
     try {
       const page = params.cursor ? Number(params.cursor) : 1;
-      const query = params.query ?? "";
+      // Only append `&query=` when there's an actual search term. A trailing
-      const listUrl = `${LIST_URL}?diet=ALL&page=${page}&query=${encodeURIComponent(query)}`;
+      // empty `&query=` on the "browse everything" path (filter absent) made
+      // the *deployed* server serve page 1 for every `page=N` — the
+      // infinite scroll then stopped after 9 recipes (issue #38's
+      // "0 new externalIds ⇒ end of list" guard cutting in). The bare
+      // `?diet=ALL&page=N` catalogue request paginates correctly. The
+      // sibling adapters (marmiton/quitoque/ohmonbento) already make their
+      // search param conditional; this one didn't.
+      const query = (params.query ?? "").trim();
+      const listUrl = `${LIST_URL}?diet=ALL&page=${page}${
+        query ? `&query=${encodeURIComponent(query)}` : ""
+      }`;
 
       let response: Response;
       try {

apps/api/test-support/reset-db.ts

@@ -49,6 +49,7 @@ export async function resetDatabase() {
       "recipe", "ingredients", "sources", "unit",
       "user_profiles", "diet", "house",
       "tour_progress", "tour_scenario_step", "tour_scenario", "tour_target",
+      "contact_message",
       "admin_users", "analytics_events", "worker_heartbeats", "backfill_state"
     RESTART IDENTITY CASCADE;
   `);

apps/api/test/admin-catalog.test.ts

@@ -139,3 +139,118 @@ describe("Admin catalog — off-catalog ingredients", () => {
     expect(await prisma.ingredient.count({ where: { isPlaceholder: true } })).to.equal(1);
   });
 });
+
+/**
+ * `/admin/api/catalog/tech-step-placeholders` — the missing-technique review
+ * (issue #130). Flat list, `mark-reviewed` stamps `reviewedAt`; every route
+ * behind `requireAdmin`.
+ */
+describe("Admin catalog — missing techniques", () => {
+  const app = createApp();
+
+  beforeEach(async () => {
+    await resetDatabase();
+  });
+
+  after(async () => {
+    await prisma.$disconnect();
+  });
+
+  async function adminAgent() {
+    const { email, password } = await seedAdmin();
+    const agent = request.agent(app);
+    await agent.post("/admin/api/auth/login").send({ email, password });
+    return agent;
+  }
+
+  /** A `PUBLIC` recipe whose single step carries a placeholder technique named `name`. Returns the placeholder `TechStep` id. */
+  async function seedPlaceholderTechnique(name: string): Promise<number> {
+    const author = await prisma.userProfile.create({
+      data: {
+        firstName: "T",
+        lastName: "A",
+        email: `${faker.string.uuid()}@example.test`,
+        passwordHash: "x",
+      },
+    });
+    const techStep = await prisma.techStep.create({
+      data: {
+        key: `placeholder:${faker.string.uuid()}`,
+        isPlaceholder: true,
+        displayName: name,
+        createdById: author.id,
+        createdAt: new Date(),
+      },
+    });
+    await prisma.recipe.create({
+      data: {
+        name: faker.lorem.words(3),
+        authorId: author.id,
+        portions: 2,
+        visibility: "PUBLIC",
+        steps: {
+          create: [
+            {
+              description: "Une étape.",
+              order: 0,
+              techSteps: {
+                create: [{ techStepId: techStep.id, order: 0, start: 0, end: 4, source: "manual" }],
+              },
+            },
+          ],
+        },
+      },
+    });
+    return techStep.id;
+  }
+
+  it("rejects both routes without an admin session", async () => {
+    expect((await request(app).get("/admin/api/catalog/tech-step-placeholders")).status).to.equal(
+      401,
+    );
+    expect(
+      (
+        await request(app)
+          .patch("/admin/api/catalog/tech-step-placeholders/mark-reviewed")
+          .send({ techStepIds: [1] })
+      ).status,
+    ).to.equal(401);
+  });
+
+  it("lists proposed techniques with their recipe count, impact-ordered", async () => {
+    await seedPlaceholderTechnique("Flamber au chalumeau");
+    await seedPlaceholderTechnique("Confire à basse température");
+
+    const agent = await adminAgent();
+    const res = await agent.get("/admin/api/catalog/tech-step-placeholders");
+
+    expect(res.status).to.equal(200);
+    expect(res.body).to.have.length(2);
+    expect(res.body.map((r: { displayName: string }) => r.displayName)).to.have.members([
+      "Flamber au chalumeau",
+      "Confire à basse température",
+    ]);
+    expect(res.body[0].recipeCount).to.equal(1);
+    expect(res.body[0].reviewedAt).to.equal(null);
+  });
+
+  it("mark-reviewed stamps reviewedAt and moves the row to the reviewed list", async () => {
+    const id = await seedPlaceholderTechnique("Snacker à la plancha");
+    const agent = await adminAgent();
+
+    const patched = await agent
+      .patch("/admin/api/catalog/tech-step-placeholders/mark-reviewed")
+      .send({ techStepIds: [id] });
+    expect(patched.status).to.equal(200);
+    expect(patched.body.reviewed).to.equal(1);
+    expect(
+      (await prisma.techStep.findUniqueOrThrow({ where: { id } })).reviewedAt,
+    ).to.be.an.instanceOf(Date);
+
+    expect((await agent.get("/admin/api/catalog/tech-step-placeholders")).body).to.have.length(0);
+    const reviewed = await agent
+      .get("/admin/api/catalog/tech-step-placeholders")
+      .query({ reviewed: "true" });
+    expect(reviewed.body).to.have.length(1);
+  });
+});

apps/api/test/admin-contact.test.ts

@@ -0,0 +1,346 @@
+import { ErrorCode } 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 { env } from "../src/config/env.js";
+import { prisma } from "../src/db/prisma.js";
+import { hashAdminPassword } from "../src/modules/admin/admin-auth.service.js";
+import { resetDatabase } from "../test-support/reset-db.js";
+
+async function seedAdmin(): Promise<{ email: string; password: string }> {
+  const email = faker.internet.email().toLowerCase();
+  const password = faker.internet.password({ length: 16 });
+  await prisma.adminUser.create({
+    data: { email, name: faker.person.fullName(), passwordHash: await hashAdminPassword(password) },
+  });
+  return { email, password };
+}
+
+/** Creates a `UserProfile` to attribute contact messages to. */
+async function seedUser() {
+  return prisma.userProfile.create({
+    data: {
+      firstName: faker.person.firstName(),
+      lastName: faker.person.lastName(),
+      email: `${faker.string.uuid()}@example.test`,
+      passwordHash: "x",
+    },
+  });
+}
+
+/** One `ContactMessage`, `createdAt` overridable so ordering is deterministic. */
+async function seedMessage(overrides: {
+  authorId: number | null;
+  type?: string;
+  message?: string;
+  createdAt?: Date;
+}) {
+  return prisma.contactMessage.create({
+    data: {
+      authorId: overrides.authorId,
+      type: overrides.type ?? "bug",
+      message: overrides.message ?? faker.lorem.sentence(),
+      pageUrl: "/",
+      userAgent: "test-agent/1.0",
+      appVersion: "0.2.1",
+      ...(overrides.createdAt ? { createdAt: overrides.createdAt } : {}),
+    },
+  });
+}
+
+const adminSecretConfigured = env.ADMIN_JWT_SECRET !== undefined;
+const forgejoConfigured =
+  env.FORGEJO_BASE_URL !== undefined &&
+  env.FORGEJO_TOKEN !== undefined &&
+  env.FORGEJO_REPO !== undefined;
+
+describe("Admin contact messages", () => {
+  const app = createApp();
+
+  beforeEach(async () => {
+    await resetDatabase();
+  });
+
+  after(async () => {
+    await prisma.$disconnect();
+  });
+
+  async function adminAgent() {
+    const { email, password } = await seedAdmin();
+    const agent = request.agent(app);
+    await agent.post("/admin/api/auth/login").send({ email, password });
+    return agent;
+  }
+
+  it("rejects the route without an admin session", async () => {
+    const res = await request(app).get("/admin/api/contact");
+    expect(res.status).to.equal(401);
+  });
+
+  it("returns messages newest first, with the author resolved", async function () {
+    if (!adminSecretConfigured) {
+      // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+      (this as any).skip();
+      return;
+    }
+    const user = await seedUser();
+    await seedMessage({
+      authorId: user.id,
+      message: "le plus ancien",
+      createdAt: new Date("2026-01-01T00:00:00.000Z"),
+    });
+    await seedMessage({
+      authorId: user.id,
+      message: "le plus récent",
+      createdAt: new Date("2026-06-01T00:00:00.000Z"),
+    });
+
+    const agent = await adminAgent();
+    const res = await agent.get("/admin/api/contact");
+
+    expect(res.status).to.equal(200);
+    expect(res.body.map((row: { message: string }) => row.message)).to.deep.equal([
+      "le plus récent",
+      "le plus ancien",
+    ]);
+    expect(res.body[0].author).to.deep.equal({
+      id: user.id,
+      firstName: user.firstName,
+      lastName: user.lastName,
+      email: user.email,
+    });
+  });
+
+  it("filters by type", async function () {
+    if (!adminSecretConfigured) {
+      // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+      (this as any).skip();
+      return;
+    }
+    const user = await seedUser();
+    await seedMessage({ authorId: user.id, type: "bug" });
+    await seedMessage({ authorId: user.id, type: "suggestion" });
+    await seedMessage({ authorId: user.id, type: "suggestion" });
+
+    const agent = await adminAgent();
+    const res = await agent.get("/admin/api/contact").query({ type: "suggestion" });
+
+    expect(res.status).to.equal(200);
+    expect(res.body).to.have.lengthOf(2);
+    expect(res.body.every((row: { type: string }) => row.type === "suggestion")).to.equal(true);
+  });
+
+  it("rejects an unknown type filter with 400", async function () {
+    if (!adminSecretConfigured) {
+      // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+      (this as any).skip();
+      return;
+    }
+    const agent = await adminAgent();
+    const res = await agent.get("/admin/api/contact").query({ type: "complaint" });
+    expect(res.status).to.equal(400);
+  });
+
+  it("caps the page at 200 rows", async function () {
+    if (!adminSecretConfigured) {
+      // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+      (this as any).skip();
+      return;
+    }
+    const user = await seedUser();
+    await prisma.contactMessage.createMany({
+      data: Array.from({ length: 205 }, () => ({
+        authorId: user.id,
+        type: "bug",
+        message: faker.lorem.sentence(),
+      })),
+    });
+
+    const agent = await adminAgent();
+    const res = await agent.get("/admin/api/contact");
+
+    expect(res.status).to.equal(200);
+    expect(res.body).to.have.lengthOf(200);
+  });
+
+  it("reports author: null once the sender's account is deleted", async function () {
+    if (!adminSecretConfigured) {
+      // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+      (this as any).skip();
+      return;
+    }
+    const user = await seedUser();
+    await seedMessage({ authorId: user.id, message: "signalé puis compte supprimé" });
+    await prisma.userProfile.delete({ where: { id: user.id } });
+
+    const agent = await adminAgent();
+    const res = await agent.get("/admin/api/contact");
+
+    expect(res.status).to.equal(200);
+    expect(res.body).to.have.lengthOf(1);
+    expect(res.body[0].message).to.equal("signalé puis compte supprimé");
+    expect(res.body[0].author).to.equal(null);
+  });
+
+  describe("Forgejo issue creation (#81)", () => {
+    let originalFetch: typeof fetch;
+
+    beforeEach(() => {
+      originalFetch = globalThis.fetch;
+    });
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch;
+    });
+
+    /** Makes `forgejo.createIssue`'s `fetch` return `body` with `status`. */
+    function stubForgejoFetch(body: unknown, status = 201) {
+      globalThis.fetch = (async () =>
+        new Response(JSON.stringify(body), { status })) as typeof fetch;
+    }
+
+    it("returns 401 without an admin session", async () => {
+      const res = await request(app).post("/admin/api/contact/1/forgejo-issue").send({
+        title: "t",
+        body: "b",
+      });
+      expect(res.status).to.equal(401);
+    });
+
+    it("exposes the integration status", async function () {
+      if (!adminSecretConfigured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      const agent = await adminAgent();
+      const res = await agent.get("/admin/api/contact/forgejo/status");
+      expect(res.status).to.equal(200);
+      expect(res.body).to.deep.equal({ enabled: forgejoConfigured });
+    });
+
+    it("responds 503 FORGEJO_NOT_CONFIGURED when the env isn't set", async function () {
+      if (!adminSecretConfigured || forgejoConfigured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      const user = await seedUser();
+      const message = await seedMessage({ authorId: user.id });
+      const agent = await adminAgent();
+
+      const res = await agent
+        .post(`/admin/api/contact/${message.id}/forgejo-issue`)
+        .send({ title: "Titre", body: "Corps du ticket" });
+
+      expect(res.status).to.equal(503);
+      expect(res.body.code).to.equal(ErrorCode.FORGEJO_NOT_CONFIGURED);
+    });
+
+    it("creates the issue and records the link on the message", async function () {
+      if (!adminSecretConfigured || !forgejoConfigured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      stubForgejoFetch({ number: 77, html_url: "https://forge.example/ci/repo/issues/77" });
+      const user = await seedUser();
+      const message = await seedMessage({ authorId: user.id, message: "un bug précis" });
+      const agent = await adminAgent();
+
+      const res = await agent
+        .post(`/admin/api/contact/${message.id}/forgejo-issue`)
+        .send({ title: "[Bug] un bug précis", body: "un bug précis\n\n---\ncontexte" });
+
+      expect(res.status).to.equal(200);
+      expect(res.body.forgejoIssueNumber).to.equal(77);
+      expect(res.body.forgejoIssueUrl).to.equal("https://forge.example/ci/repo/issues/77");
+
+      const row = await prisma.contactMessage.findFirstOrThrow({ where: { id: message.id } });
+      expect(row.forgejoIssueNumber).to.equal(77);
+      expect(row.forgejoIssueUrl).to.equal("https://forge.example/ci/repo/issues/77");
+    });
+
+    it("responds 404 for an unknown message id", async function () {
+      if (!adminSecretConfigured || !forgejoConfigured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      stubForgejoFetch({ number: 1, html_url: "x" });
+      const agent = await adminAgent();
+
+      const res = await agent
+        .post("/admin/api/contact/999999/forgejo-issue")
+        .send({ title: "Titre", body: "Corps" });
+
+      expect(res.status).to.equal(404);
+      expect(res.body.code).to.equal(ErrorCode.CONTACT_MESSAGE_NOT_FOUND);
+    });
+
+    it("responds 409 when the message already links to an issue", async function () {
+      if (!adminSecretConfigured || !forgejoConfigured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      stubForgejoFetch({ number: 2, html_url: "x" });
+      const user = await seedUser();
+      const message = await seedMessage({ authorId: user.id });
+      await prisma.contactMessage.update({
+        where: { id: message.id },
+        data: { forgejoIssueNumber: 5, forgejoIssueUrl: "https://forge.example/ci/repo/issues/5" },
+      });
+      const agent = await adminAgent();
+
+      const res = await agent
+        .post(`/admin/api/contact/${message.id}/forgejo-issue`)
+        .send({ title: "Titre", body: "Corps" });
+
+      expect(res.status).to.equal(409);
+      expect(res.body.code).to.equal(ErrorCode.CONTACT_MESSAGE_ALREADY_LINKED);
+    });
+
+    it("leaves the message untouched when the Forgejo call fails (502)", async function () {
+      if (!adminSecretConfigured || !forgejoConfigured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      stubForgejoFetch("upstream boom", 500);
+      const user = await seedUser();
+      const message = await seedMessage({ authorId: user.id });
+      const agent = await adminAgent();
+
+      const res = await agent
+        .post(`/admin/api/contact/${message.id}/forgejo-issue`)
+        .send({ title: "Titre", body: "Corps" });
+
+      expect(res.status).to.equal(502);
+      expect(res.body.code).to.equal(ErrorCode.FORGEJO_REQUEST_FAILED);
+
+      const row = await prisma.contactMessage.findFirstOrThrow({ where: { id: message.id } });
+      expect(row.forgejoIssueNumber).to.equal(null);
+      expect(row.forgejoIssueUrl).to.equal(null);
+    });
+
+    it("rejects an empty title with 400", async function () {
+      if (!adminSecretConfigured || !forgejoConfigured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      const user = await seedUser();
+      const message = await seedMessage({ authorId: user.id });
+      const agent = await adminAgent();
+
+      const res = await agent
+        .post(`/admin/api/contact/${message.id}/forgejo-issue`)
+        .send({ title: "   ", body: "Corps" });
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+    });
+  });
+});

apps/api/test/admin-users.test.ts

@@ -0,0 +1,160 @@
+import { ErrorCode } 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 { hashAdminPassword } from "../src/modules/admin/admin-auth.service.js";
+import { resetDatabase } from "../test-support/reset-db.js";
+
+async function seedAdmin(): Promise<{ email: string; password: string }> {
+  const email = faker.internet.email().toLowerCase();
+  const password = faker.internet.password({ length: 16 });
+  await prisma.adminUser.create({
+    data: { email, name: faker.person.fullName(), passwordHash: await hashAdminPassword(password) },
+  });
+  return { email, password };
+}
+
+/** A fresh, fake (never real-looking) create-user payload — same rationale as `auth.test.ts`'s `buildSignupPayload`. */
+function buildCreateUserPayload() {
+  const firstName = faker.person.firstName();
+  const lastName = faker.person.lastName();
+  return {
+    firstName,
+    lastName,
+    email: faker.internet.email({ firstName, lastName }).toLowerCase(),
+  };
+}
+
+/**
+ * `/admin/api/users/*` — the admin surface for provisioning end-user
+ * accounts by hand (`/admin/utilisateurs` page). Every route behind
+ * `requireAdmin`. Creation generates a one-time temporary password and
+ * returns it in the response; the account starts with no household, exactly
+ * like a self-service signup.
+ */
+describe("Admin users — account provisioning", () => {
+  const app = createApp();
+
+  beforeEach(async () => {
+    await resetDatabase();
+  });
+
+  after(async () => {
+    await prisma.$disconnect();
+  });
+
+  async function adminAgent() {
+    const { email, password } = await seedAdmin();
+    const agent = request.agent(app);
+    await agent.post("/admin/api/auth/login").send({ email, password });
+    return agent;
+  }
+
+  it("rejects every route without an admin session", async () => {
+    expect((await request(app).get("/admin/api/users")).status).to.equal(401);
+    expect(
+      (await request(app).post("/admin/api/users").send(buildCreateUserPayload())).status,
+    ).to.equal(401);
+  });
+
+  it("creates a profile with no household and returns a one-time temporary password", async () => {
+    const agent = await adminAgent();
+    const payload = buildCreateUserPayload();
+
+    const res = await agent.post("/admin/api/users").send(payload);
+
+    expect(res.status).to.equal(201);
+    expect(res.body.user).to.include({
+      firstName: payload.firstName,
+      lastName: payload.lastName,
+      email: payload.email,
+      householdName: null,
+    });
+    expect(res.body.user).to.not.have.property("passwordHash");
+    expect(res.body.user).to.not.have.property("tokenVersion");
+    expect(res.body.temporaryPassword).to.be.a("string").with.length.greaterThan(8);
+
+    const stored = await prisma.userProfile.findUnique({ where: { email: payload.email } });
+    expect(stored?.houseId).to.equal(null);
+    expect(stored?.dietId).to.equal(null);
+  });
+
+  it("issues a password the new account can actually log in with", async () => {
+    const agent = await adminAgent();
+    const payload = buildCreateUserPayload();
+
+    const created = await agent.post("/admin/api/users").send(payload);
+    const login = await request(app)
+      .post("/auth/login")
+      .send({ email: payload.email, password: created.body.temporaryPassword });
+
+    expect(login.status).to.equal(200);
+    expect(login.body.email).to.equal(payload.email);
+  });
+
+  it("rejects a duplicate email with 409 EMAIL_ALREADY_IN_USE", async () => {
+    const agent = await adminAgent();
+    const payload = buildCreateUserPayload();
+    await agent.post("/admin/api/users").send(payload);
+
+    const res = await agent
+      .post("/admin/api/users")
+      .send({ ...buildCreateUserPayload(), email: payload.email });
+
+    expect(res.status).to.equal(409);
+    expect(res.body.code).to.equal(ErrorCode.EMAIL_ALREADY_IN_USE);
+  });
+
+  it("rejects an invalid body with 400 VALIDATION_ERROR", async () => {
+    const agent = await adminAgent();
+
+    const badEmail = await agent
+      .post("/admin/api/users")
+      .send({ ...buildCreateUserPayload(), email: "not-an-email" });
+    expect(badEmail.status).to.equal(400);
+    expect(badEmail.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+
+    const noFirstName = await agent
+      .post("/admin/api/users")
+      .send({ ...buildCreateUserPayload(), firstName: "" });
+    expect(noFirstName.status).to.equal(400);
+  });
+
+  it("lists accounts newest-first with their household name resolved, never the password", async () => {
+    const agent = await adminAgent();
+    const first = buildCreateUserPayload();
+    const second = buildCreateUserPayload();
+    const firstRes = await agent.post("/admin/api/users").send(first);
+    await agent.post("/admin/api/users").send(second);
+
+    // Put the first account in a household so `householdName` has something to
+    // resolve — `House.adminId` is required, so the account is its own admin.
+    const house = await prisma.house.create({
+      data: {
+        name: "Le Foyer Test",
+        adminId: firstRes.body.user.id,
+        inviteCode: faker.string.alphanumeric(8).toUpperCase(),
+      },
+    });
+    await prisma.userProfile.update({
+      where: { email: first.email },
+      data: { houseId: house.id },
+    });
+
+    const res = await agent.get("/admin/api/users");
+
+    expect(res.status).to.equal(200);
+    expect(res.body).to.have.length(2);
+    // Newest first: `second` was created after `first`.
+    expect(res.body[0].email).to.equal(second.email);
+    expect(res.body[1].email).to.equal(first.email);
+    expect(res.body[1].householdName).to.equal("Le Foyer Test");
+    expect(res.body[0].householdName).to.equal(null);
+    for (const row of res.body) {
+      expect(row).to.not.have.property("temporaryPassword");
+      expect(row).to.not.have.property("passwordHash");
+    }
+  });
+});

apps/api/test/contact.test.ts

@@ -0,0 +1,143 @@
+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 { 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 }),
+  };
+}
+
+/** A valid `POST /contact` body — message comfortably over the 10-char minimum. */
+function buildContactPayload() {
+  return {
+    type: "bug" as const,
+    message: "Le bouton « Envoyer » ne réagit pas sur la page planning.",
+    pageUrl: "/",
+    appVersion: "0.2.1",
+  };
+}
+
+describe("Contact", () => {
+  const app = createApp();
+
+  beforeEach(async () => {
+    await resetDatabase();
+  });
+
+  after(async () => {
+    await prisma.$disconnect();
+  });
+
+  describe("POST /contact", () => {
+    it("rejects requests without a session with 401 NOT_AUTHENTICATED", async () => {
+      const res = await request(app).post("/contact").send(buildContactPayload());
+
+      expect(res.status).to.equal(401);
+      expect(res.body.code).to.equal(ErrorCode.NOT_AUTHENTICATED);
+      expect(await prisma.contactMessage.count()).to.equal(0);
+    });
+
+    it("stores the message with its fields, attributed to the caller, and captures the user-agent from the header", async () => {
+      const agent = request.agent(app);
+      const signup = buildSignupPayload();
+      await agent.post("/auth/signup").send(signup);
+      const author = await prisma.userProfile.findFirstOrThrow({ where: { email: signup.email } });
+
+      const res = await agent
+        .post("/contact")
+        .set("User-Agent", "BatchCookingApp/0.2.1 (Android 14)")
+        .send(buildContactPayload());
+
+      expect(res.status).to.equal(204);
+
+      const rows = await prisma.contactMessage.findMany();
+      expect(rows).to.have.lengthOf(1);
+      const [row] = rows;
+      expect(row.authorId).to.equal(author.id);
+      expect(row.type).to.equal("bug");
+      expect(row.message).to.equal(buildContactPayload().message);
+      expect(row.pageUrl).to.equal("/");
+      expect(row.appVersion).to.equal("0.2.1");
+      // Read from the request header, never the body.
+      expect(row.userAgent).to.equal("BatchCookingApp/0.2.1 (Android 14)");
+    });
+
+    it("ignores any user-agent sent in the body — the header is the only source", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+
+      const res = await agent
+        .post("/contact")
+        .set("User-Agent", "real-agent/1.0")
+        .send({ ...buildContactPayload(), userAgent: "spoofed-agent/9.9" });
+
+      expect(res.status).to.equal(204);
+      const row = await prisma.contactMessage.findFirstOrThrow();
+      expect(row.userAgent).to.equal("real-agent/1.0");
+    });
+
+    it("keeps pageUrl / appVersion null when the client omits them", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+
+      const res = await agent.post("/contact").send({
+        type: "suggestion",
+        message: "Ajoutez un mode hors-ligne pour la liste de courses.",
+      });
+
+      expect(res.status).to.equal(204);
+      const row = await prisma.contactMessage.findFirstOrThrow();
+      expect(row.type).to.equal("suggestion");
+      expect(row.pageUrl).to.equal(null);
+      expect(row.appVersion).to.equal(null);
+    });
+
+    it("rejects a message shorter than 10 characters with 400 VALIDATION_ERROR", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+
+      // 5 chars — and the schema trims before counting, so leading/trailing
+      // whitespace can't pad it to the minimum.
+      const res = await agent.post("/contact").send({ type: "bug", message: "  court  " });
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+      expect(await prisma.contactMessage.count()).to.equal(0);
+    });
+
+    it("rejects a message longer than 5000 characters with 400 VALIDATION_ERROR", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+
+      const res = await agent.post("/contact").send({ type: "bug", message: "a".repeat(5001) });
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+      expect(await prisma.contactMessage.count()).to.equal(0);
+    });
+
+    it("rejects an unknown type with 400 VALIDATION_ERROR", async () => {
+      const agent = request.agent(app);
+      await agent.post("/auth/signup").send(buildSignupPayload());
+
+      const res = await agent
+        .post("/contact")
+        .send({ type: "complaint", message: "Ceci est un message de test suffisamment long." });
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+      expect(await prisma.contactMessage.count()).to.equal(0);
+    });
+  });
+});

apps/api/test/env.test.ts

@@ -0,0 +1,59 @@
+import { expect } from "chai";
+import { envSchema } from "../src/config/env.js";
+
+/**
+ * Pure schema test — no DB, no `process.env`. Covers `blankAsUnset` on the
+ * `FORGEJO_*` trio: `docker-compose.yml` forwards every optional var as
+ * `${FOO:-}`, which the container receives as `""` (not an absent key) when
+ * the stack's `.env` leaves it blank. Those three must read a blank value
+ * as "not configured" and still boot, rather than trip `FORGEJO_BASE_URL`'s
+ * `.url()` / `FORGEJO_REPO`'s regex and abort `parse()` at startup.
+ */
+describe("envSchema — FORGEJO_* blank handling", () => {
+  // The only two vars with no default and no `.optional()`.
+  const base = {
+    JWT_SECRET: "x".repeat(32),
+    INTENT_SERVICE_SECRET: "y".repeat(32),
+  };
+
+  it("treats blank FORGEJO_* values as unset instead of failing validation", () => {
+    const parsed = envSchema.parse({
+      ...base,
+      FORGEJO_BASE_URL: "",
+      FORGEJO_TOKEN: "",
+      FORGEJO_REPO: "",
+    });
+
+    expect(parsed.FORGEJO_BASE_URL).to.equal(undefined);
+    expect(parsed.FORGEJO_TOKEN).to.equal(undefined);
+    expect(parsed.FORGEJO_REPO).to.equal(undefined);
+  });
+
+  it("treats a fully absent FORGEJO_* trio the same way", () => {
+    const parsed = envSchema.parse({ ...base });
+    expect(parsed.FORGEJO_BASE_URL).to.equal(undefined);
+    expect(parsed.FORGEJO_TOKEN).to.equal(undefined);
+    expect(parsed.FORGEJO_REPO).to.equal(undefined);
+  });
+
+  it("still passes through and validates non-blank FORGEJO_* values", () => {
+    const parsed = envSchema.parse({
+      ...base,
+      FORGEJO_BASE_URL: "https://git.example.com",
+      FORGEJO_TOKEN: "a-token",
+      FORGEJO_REPO: "owner/repo",
+    });
+
+    expect(parsed.FORGEJO_BASE_URL).to.equal("https://git.example.com");
+    expect(parsed.FORGEJO_TOKEN).to.equal("a-token");
+    expect(parsed.FORGEJO_REPO).to.equal("owner/repo");
+  });
+
+  it("still rejects a non-blank but malformed FORGEJO_BASE_URL", () => {
+    expect(() => envSchema.parse({ ...base, FORGEJO_BASE_URL: "git.example.com" })).to.throw();
+  });
+
+  it("still rejects a non-blank but malformed FORGEJO_REPO", () => {
+    expect(() => envSchema.parse({ ...base, FORGEJO_REPO: "not-a-repo" })).to.throw();
+  });
+});

apps/api/test/forgejo.service.test.ts

@@ -0,0 +1,113 @@
+import { HttpError } from "@batch-cooking/error-tools";
+import { ErrorCode } from "@batch-cooking/shared";
+import { expect } from "chai";
+import { env } from "../src/config/env.js";
+import { forgejo } from "../src/lib/forgejo/forgejo.service.js";
+
+/**
+ * Stubs `globalThis.fetch` for one test — same approach as
+ * `recipe-sources/the-meal-db.test.ts` (no HTTP-mock library in this repo).
+ * `capture` collects the `(url, init)` each call was made with, so a test
+ * can assert the request shape. Restored by `afterEach`.
+ */
+function stubFetch(
+  responder: (url: string, init: RequestInit | undefined) => Response | Promise<Response>,
+  capture: { url: string; init: RequestInit | undefined }[],
+) {
+  globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input.toString();
+    capture.push({ url, init });
+    return responder(url, init);
+  }) as typeof fetch;
+}
+
+const configured = forgejo.isConfigured();
+
+describe("ForgejoService", () => {
+  let originalFetch: typeof fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("isConfigured() reports whether all three FORGEJO_* vars are set", () => {
+    expect(forgejo.isConfigured()).to.equal(
+      env.FORGEJO_BASE_URL !== undefined &&
+        env.FORGEJO_TOKEN !== undefined &&
+        env.FORGEJO_REPO !== undefined,
+    );
+  });
+
+  describe("createIssue", () => {
+    it("POSTs to the repo's issues endpoint with a `token` auth header and { title, body }", async function () {
+      if (!configured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      const calls: { url: string; init: RequestInit | undefined }[] = [];
+      stubFetch(
+        () =>
+          new Response(JSON.stringify({ number: 42, html_url: "https://forge/x/y/issues/42" }), {
+            status: 201,
+          }),
+        calls,
+      );
+
+      const result = await forgejo.createIssue({ title: "Un titre", body: "Un corps" });
+
+      expect(result).to.deep.equal({ number: 42, htmlUrl: "https://forge/x/y/issues/42" });
+      expect(calls).to.have.lengthOf(1);
+      const [call] = calls;
+      expect(call.url).to.equal(`${env.FORGEJO_BASE_URL}/api/v1/repos/${env.FORGEJO_REPO}/issues`);
+      expect(call.init?.method).to.equal("POST");
+      const headers = call.init?.headers as Record<string, string>;
+      expect(headers.Authorization).to.equal(`token ${env.FORGEJO_TOKEN}`);
+      expect(JSON.parse(String(call.init?.body))).to.deep.equal({
+        title: "Un titre",
+        body: "Un corps",
+      });
+    });
+
+    it("throws 502 FORGEJO_REQUEST_FAILED on a non-2xx response", async function () {
+      if (!configured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      stubFetch(() => new Response("nope", { status: 403 }), []);
+
+      try {
+        await forgejo.createIssue({ title: "t", body: "b" });
+        expect.fail("expected createIssue to throw");
+      } catch (err) {
+        expect(err).to.be.instanceOf(HttpError);
+        expect((err as HttpError).status).to.equal(502);
+        expect((err as HttpError).code).to.equal(ErrorCode.FORGEJO_REQUEST_FAILED);
+      }
+    });
+
+    it("throws 502 FORGEJO_REQUEST_FAILED on a network error", async function () {
+      if (!configured) {
+        // biome-ignore lint/suspicious/noExplicitAny: mocha's `this.skip()` isn't typed here.
+        (this as any).skip();
+        return;
+      }
+      stubFetch(() => {
+        throw new Error("ECONNREFUSED");
+      }, []);
+
+      try {
+        await forgejo.createIssue({ title: "t", body: "b" });
+        expect.fail("expected createIssue to throw");
+      } catch (err) {
+        expect(err).to.be.instanceOf(HttpError);
+        expect((err as HttpError).code).to.equal(ErrorCode.FORGEJO_REQUEST_FAILED);
+      }
+    });
+  });
+});

apps/api/test/recipe-diets.test.ts

@@ -0,0 +1,86 @@
+import { computeRecipeDietViews, type DietView, type IngredientView } from "@batch-cooking/shared";
+import { expect } from "chai";
+
+/**
+ * Pure regime derivation from `@batch-cooking/shared` — no DB, so this suite
+ * skips `resetDatabase`. `recipe.service.ts`'s `toRecipeSummaryView` calls
+ * it for every recipe read (issue #131 dropped the hand-tagged `RecipeDiet`).
+ */
+
+const VEGETARIAN: DietView = { id: 1, key: "vegetarian" };
+const VEGAN: DietView = { id: 2, key: "vegan" };
+const PESCATARIAN: DietView = { id: 3, key: "pescatarian" };
+const GLUTEN_FREE: DietView = { id: 4, key: "glutenFree" };
+
+/** A minimal ingredient fixture — only the fields `computeRecipeDietViews` reads. */
+function ingredient(
+  diets: DietView[],
+  opts: { gluten?: boolean; placeholder?: boolean } = {},
+): Pick<IngredientView, "diets" | "allergens" | "isPlaceholder"> {
+  return {
+    diets,
+    allergens: opts.gluten ? [{ id: 9, key: "gluten", kind: "INTOLERANCE" }] : [],
+    isPlaceholder: opts.placeholder ?? false,
+  };
+}
+
+describe("computeRecipeDietViews", () => {
+  it("keeps only the regimes every ingredient is compatible with", () => {
+    const result = computeRecipeDietViews(
+      [
+        ingredient([VEGETARIAN, VEGAN, PESCATARIAN]),
+        ingredient([VEGETARIAN, PESCATARIAN]), // e.g. egg — not vegan
+      ],
+      GLUTEN_FREE,
+    );
+    expect(result.map((d) => d.key)).to.deep.equal(["vegetarian", "pescatarian", "glutenFree"]);
+  });
+
+  it("drops every ingredient-derived regime when one ingredient is compatible with none", () => {
+    const result = computeRecipeDietViews(
+      [ingredient([VEGETARIAN, VEGAN, PESCATARIAN]), ingredient([])],
+      GLUTEN_FREE,
+    );
+    // Still gluten-free — nothing carries the allergen.
+    expect(result.map((d) => d.key)).to.deep.equal(["glutenFree"]);
+  });
+
+  it("is not gluten-free when any ingredient carries the gluten allergen", () => {
+    const result = computeRecipeDietViews(
+      [
+        ingredient([VEGETARIAN, VEGAN, PESCATARIAN]),
+        ingredient([VEGETARIAN, VEGAN, PESCATARIAN], { gluten: true }),
+      ],
+      GLUTEN_FREE,
+    );
+    expect(result.map((d) => d.key)).to.deep.equal(["vegetarian", "vegan", "pescatarian"]);
+  });
+
+  it("returns [] for a recipe with any placeholder (off-catalog) ingredient", () => {
+    const result = computeRecipeDietViews(
+      [ingredient([VEGETARIAN, VEGAN, PESCATARIAN]), ingredient([], { placeholder: true })],
+      GLUTEN_FREE,
+    );
+    expect(result).to.deep.equal([]);
+  });
+
+  it("returns [] when there are no ingredients", () => {
+    expect(computeRecipeDietViews([], GLUTEN_FREE)).to.deep.equal([]);
+  });
+
+  it("omits gluten-free entirely when no glutenFree DietView is supplied", () => {
+    const result = computeRecipeDietViews(
+      [ingredient([VEGAN, VEGETARIAN, PESCATARIAN])],
+      undefined,
+    );
+    expect(result.map((d) => d.key)).to.deep.equal(["vegetarian", "vegan", "pescatarian"]);
+  });
+
+  it("borrows each regime's DietView (id + key) from the ingredients themselves", () => {
+    const result = computeRecipeDietViews(
+      [ingredient([VEGETARIAN]), ingredient([VEGETARIAN])],
+      undefined,
+    );
+    expect(result).to.deep.equal([VEGETARIAN]);
+  });
+});

apps/api/test/recipe-placeholder.test.ts

@@ -62,7 +62,6 @@ describe("Recipes — off-catalog placeholder ingredients", () => {
     const res = await agent.post("/recipes").send({
       name: "Poulet basquaise",
       portions: 4,
-      dietIds: [],
       ingredients: [
         { ingredientId: tomato, quantity: 3, unitId: piece },
         { placeholderName: "Piment d'Espelette", quantity: 1, unitId: piece },
@@ -99,7 +98,6 @@ describe("Recipes — off-catalog placeholder ingredients", () => {
     await agent.post("/recipes").send({
       name: "Test",
       portions: 2,
-      dietIds: [],
       ingredients: [{ placeholderName: "Feuille de combava", quantity: 1, unitId: piece }],
       steps: [{ description: "x" }],
     });
@@ -122,7 +120,6 @@ describe("Recipes — off-catalog placeholder ingredients", () => {
     const created = await agent.post("/recipes").send({
       name: "Édition",
       portions: 2,
-      dietIds: [],
       ingredients: [{ placeholderName: "Sumac", quantity: 1, unitId: piece }],
       steps: [{ description: "x" }],
     });
@@ -132,7 +129,6 @@ describe("Recipes — off-catalog placeholder ingredients", () => {
     const edited = await agent.patch(`/recipes/${created.body.id}`).send({
       name: "Édition",
       portions: 2,
-      dietIds: [],
       ingredients: [
         { ingredientId: placeholderId, quantity: 2, unitId: piece },
         { ingredientId: tomato, quantity: 1, unitId: piece },
@@ -146,7 +142,6 @@ describe("Recipes — off-catalog placeholder ingredients", () => {
     await agent.patch(`/recipes/${created.body.id}`).send({
       name: "Édition",
       portions: 2,
-      dietIds: [],
       ingredients: [{ ingredientId: tomato, quantity: 1, unitId: piece }],
       steps: [{ description: "x" }],
     });
@@ -163,7 +158,6 @@ describe("Recipes — off-catalog placeholder ingredients", () => {
     const res = await agent.post("/recipes").send({
       name: "Invalide",
       portions: 2,
-      dietIds: [],
       ingredients: [
         { ingredientId: tomato, placeholderName: "Tomate", quantity: 1, unitId: piece },
       ],
@@ -181,7 +175,6 @@ describe("Recipes — off-catalog placeholder ingredients", () => {
     const res = await agent.post("/recipes").send({
       name: "Doublons libres",
       portions: 2,
-      dietIds: [],
       ingredients: [
         { placeholderName: "Herbes de garrigue", quantity: 1, unitId: piece },
         { placeholderName: "Herbes de garrigue", quantity: 2, unitId: piece },

apps/api/test/recipe-sources/manger-bouger.test.ts

@@ -132,6 +132,59 @@ describe("mangerBougerAdapter", () => {
       expect(requestedUrl).to.include("query=cr%C3%A8me%20br%C3%BBl%C3%A9e");
     });
 
+    it("omits the query param entirely on the catalogue-browse path (no filter) — issue #78", async () => {
+      let requestedUrl: string | undefined;
+      globalThis.fetch = (async (url: string) => {
+        requestedUrl = url;
+        return new Response(htmlWithListNextData({ list: [], hasMorePages: true }), {
+          status: 200,
+        });
+      }) as typeof fetch;
+
+      await mangerBougerAdapter.list({});
+
+      expect(requestedUrl).to.equal(
+        "https://www.mangerbouger.fr/manger-mieux/la-fabrique-a-menus/recettes?diet=ALL&page=1",
+      );
+      expect(requestedUrl).not.to.include("query=");
+    });
+
+    it("treats a blank/whitespace query the same as no filter (no query param)", async () => {
+      let requestedUrl: string | undefined;
+      globalThis.fetch = (async (url: string) => {
+        requestedUrl = url;
+        return new Response(htmlWithListNextData({ list: [], hasMorePages: false }), {
+          status: 200,
+        });
+      }) as typeof fetch;
+
+      await mangerBougerAdapter.list({ query: "   " });
+
+      expect(requestedUrl).not.to.include("query=");
+    });
+
+    it("still paginates the catalogue-browse path (nextCursor set when hasMorePages)", async () => {
+      stubFetchHtml(htmlWithListNextData({ list: [], hasMorePages: true }));
+
+      const result = await mangerBougerAdapter.list({});
+
+      expect(result.nextCursor).to.equal("2");
+    });
+
+    it("still appends the query param when a real search term is given", async () => {
+      let requestedUrl: string | undefined;
+      globalThis.fetch = (async (url: string) => {
+        requestedUrl = url;
+        return new Response(htmlWithListNextData({ list: [], hasMorePages: false }), {
+          status: 200,
+        });
+      }) as typeof fetch;
+
+      await mangerBougerAdapter.list({ query: "salade" });
+
+      expect(requestedUrl).to.include("&query=salade");
+    });
+
     it("skips a list entry missing a slug or a name", async () => {
       stubFetchHtml(
         htmlWithListNextData({

apps/api/test/recipe.test.ts

@@ -312,20 +312,16 @@ describe("Recipes", () => {
   });
 
   describe("POST /recipes", () => {
-    it("creates a recipe with its ingredients, ordered steps and diet tags", async () => {
+    it("creates a recipe with its ingredients and ordered steps, and computes its regimes from the ingredients", async () => {
       const { agent } = await signup();
       const tomate = await ingredientId("tomato");
       const oeuf = await ingredientId("egg");
       const piece = await unitId("piece");
-      const vegetarien = await prisma.diet.findFirstOrThrow({
-        where: { key: "vegetarian" },
-      });
 
       const res = await agent.post("/recipes").send({
         name: "Omelette provençale",
         description: "Rapide et savoureuse",
         portions: 2,
-        dietIds: [vegetarien.id],
         ingredients: [
           { ingredientId: tomate, quantity: 2, unitId: piece },
           { ingredientId: oeuf, quantity: 3, unitId: piece },
@@ -343,7 +339,84 @@ describe("Recipes", () => {
       ).to.deep.equal([0, 1]);
       // Allergens aggregated across ingredients — "Œuf" carries "Œufs".
       expect(res.body.allergens.map((a: { key: string }) => a.key)).to.include("eggs");
-      expect(res.body.diets.map((d: { key: string }) => d.key)).to.deep.equal(["vegetarian"]);
+      // Regimes computed (issue #131), not tagged: tomato is vegetarian/
+      // vegan/pescatarian, egg is vegetarian/pescatarian (not vegan) — the
+      // intersection is vegetarian + pescatarian; neither carries gluten, so
+      // glutenFree too.
+      expect(res.body.diets.map((d: { key: string }) => d.key)).to.deep.equal([
+        "vegetarian",
+        "pescatarian",
+        "glutenFree",
+      ]);
+    });
+
+    it("drops a regime the moment one ingredient is incompatible, keeps glutenFree if nothing carries gluten (issue #131)", async () => {
+      const { agent } = await signup();
+      const tomate = await ingredientId("tomato");
+      const poulet = await ingredientId("chicken");
+      const piece = await unitId("piece");
+
+      const res = await agent.post("/recipes").send({
+        name: "Poulet aux tomates",
+        portions: 2,
+        ingredients: [
+          { ingredientId: tomate, quantity: 2, unitId: piece },
+          { ingredientId: poulet, quantity: 1, unitId: piece },
+        ],
+        steps: [{ description: "Cuire le poulet" }],
+      });
+
+      expect(res.status).to.equal(201);
+      // Chicken is compatible with none of vegetarian/vegan/pescatarian, so
+      // the recipe qualifies for none of them — but it has no gluten.
+      expect(res.body.diets.map((d: { key: string }) => d.key)).to.deep.equal(["glutenFree"]);
+    });
+
+    it("is not glutenFree when an ingredient carries the gluten allergen (issue #131)", async () => {
+      const { agent } = await signup();
+      const tomate = await ingredientId("tomato");
+      const farine = await ingredientId("wheatFlour");
+      const piece = await unitId("piece");
+      const gram = await unitId("gram");
+
+      const res = await agent.post("/recipes").send({
+        name: "Galette de tomates",
+        portions: 2,
+        ingredients: [
+          { ingredientId: tomate, quantity: 2, unitId: piece },
+          { ingredientId: farine, quantity: 100, unitId: gram },
+        ],
+        steps: [{ description: "Mélanger" }],
+      });
+
+      expect(res.status).to.equal(201);
+      // Both ingredients are vegetarian/vegan/pescatarian, but wheat flour
+      // carries `gluten` — no glutenFree.
+      expect(res.body.diets.map((d: { key: string }) => d.key)).to.deep.equal([
+        "vegetarian",
+        "vegan",
+        "pescatarian",
+      ]);
+    });
+
+    it("has no regimes at all when a recipe contains a placeholder ingredient (issue #131)", async () => {
+      const { agent } = await signup();
+      const tomate = await ingredientId("tomato");
+      const piece = await unitId("piece");
+
+      const res = await agent.post("/recipes").send({
+        name: "Recette incomplète",
+        portions: 2,
+        ingredients: [
+          { ingredientId: tomate, quantity: 2, unitId: piece },
+          { placeholderName: "Épice mystère", quantity: 1, unitId: piece },
+        ],
+        steps: [{ description: "Assembler" }],
+      });
+
+      expect(res.status).to.equal(201);
+      // An off-catalog ingredient can't certify anything.
+      expect(res.body.diets).to.deep.equal([]);
     });
 
     it("defaults to PERSONAL visibility, and stamps the author's current household", async () => {
@@ -355,7 +428,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Test",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Étape" }],
       });
@@ -367,7 +439,6 @@ describe("Recipes", () => {
         name: "Foyer",
         visibility: "HOUSE",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Étape" }],
       });
@@ -386,7 +457,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Ragoût",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description }],
       });
@@ -399,7 +469,12 @@ describe("Recipes", () => {
       // response itself carries exactly what to highlight, not just the id.
       const resStep = res.body.steps[0];
       expect(resStep.techSteps).to.have.length(1);
-      expect(resStep.techSteps[0].techStep).to.deep.equal({ id: simmer, key: "simmer" });
+      expect(resStep.techSteps[0].techStep).to.deep.equal({
+        id: simmer,
+        key: "simmer",
+        isPlaceholder: false,
+        displayName: null,
+      });
       const { start, end } = resStep.techSteps[0];
       expect(description.slice(start, end).toLowerCase()).to.equal("mijoter");
     });
@@ -413,7 +488,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Gratin",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description }],
       });
@@ -448,7 +522,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Test",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Servir immédiatement" }],
       });
@@ -467,7 +540,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Ragoût",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [
           { description: "Hacher les oignons" },
@@ -497,7 +569,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Gratin",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         // Matches both `cook` (weight 10) and `bake` (weight 25, "au four").
         steps: [{ description: "Cuire au four pendant 30 minutes" }],
@@ -519,7 +590,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Poêlée",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         // The case that motivated the sequence model: one instruction, two techniques.
         steps: [{ description }],
@@ -550,7 +620,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Test",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: 999_999, quantity: 1, unitId: piece }],
         steps: [{ description: "Étape" }],
       });
@@ -566,7 +635,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Test",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: 999_999 }],
         steps: [{ description: "Étape" }],
       });
@@ -575,30 +643,12 @@ describe("Recipes", () => {
       expect(res.body.code).to.equal(ErrorCode.UNIT_NOT_FOUND);
     });
 
-    it("rejects an unknown dietId with 404 DIET_NOT_FOUND", async () => {
-      const { agent } = await signup();
-      const tomate = await ingredientId("tomato");
-      const piece = await unitId("piece");
-
-      const res = await agent.post("/recipes").send({
-        name: "Test",
-        portions: 4,
-        dietIds: [999_999],
-        ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
-        steps: [{ description: "Étape" }],
-      });
-
-      expect(res.status).to.equal(404);
-      expect(res.body.code).to.equal(ErrorCode.DIET_NOT_FOUND);
-    });
-
     it("rejects an empty ingredients or steps list with 400 VALIDATION_ERROR", async () => {
       const { agent } = await signup();
 
       const res = await agent.post("/recipes").send({
         name: "Test",
         portions: 4,
-        dietIds: [],
         ingredients: [],
         steps: [{ description: "Étape" }],
       });
@@ -621,7 +671,6 @@ describe("Recipes", () => {
       const res = await agent.post("/recipes").send({
         name: "Test",
         portions: 4,
-        dietIds: [],
         ingredients: [
           { ingredientId: tomate, quantity: 1, unitId: piece },
           { ingredientId: tomate, quantity: 2, unitId: piece },
@@ -639,7 +688,6 @@ describe("Recipes", () => {
       const piece = await unitId("piece");
       const basePayload = {
         name: "Test",
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Étape" }],
       };
@@ -652,6 +700,55 @@ describe("Recipes", () => {
       expect(zero.status).to.equal(400);
       expect(zero.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
     });
+
+    it("creates a « selon le goût » seasoning line with no quantity or unit (issue #128)", async () => {
+      const { agent } = await signup();
+      const tomate = await ingredientId("tomato");
+      const sel = await ingredientId("salt");
+      const gram = await unitId("gram");
+
+      const res = await agent.post("/recipes").send({
+        name: "Tomates au sel",
+        portions: 2,
+        ingredients: [
+          { ingredientId: tomate, quantity: 200, unitId: gram },
+          { ingredientId: sel }, // selon le goût — no quantity/unit
+        ],
+        steps: [{ description: "Saler les tomates" }],
+      });
+
+      expect(res.status).to.equal(201);
+      const seasoning = res.body.ingredients.find(
+        (line: { ingredient: { key: string } }) => line.ingredient.key === "salt",
+      );
+      expect(seasoning.quantity).to.equal(null);
+      expect(seasoning.unit).to.equal(null);
+    });
+
+    it("rejects an ingredient line with a quantity but no unit (or vice versa) with 400 VALIDATION_ERROR", async () => {
+      const { agent } = await signup();
+      const tomate = await ingredientId("tomato");
+      const gram = await unitId("gram");
+      const base = {
+        name: "Test",
+        portions: 2,
+        steps: [{ description: "Étape" }],
+      };
+
+      const quantityOnly = await agent.post("/recipes").send({
+        ...base,
+        ingredients: [{ ingredientId: tomate, quantity: 100 }],
+      });
+      const unitOnly = await agent.post("/recipes").send({
+        ...base,
+        ingredients: [{ ingredientId: tomate, unitId: gram }],
+      });
+
+      expect(quantityOnly.status).to.equal(400);
+      expect(quantityOnly.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+      expect(unitOnly.status).to.equal(400);
+      expect(unitOnly.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+    });
   });
 
   describe("GET /recipes/:id", () => {
@@ -671,7 +768,6 @@ describe("Recipes", () => {
       const created = await agent.post("/recipes").send({
         name: "Salade",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Couper" }],
       });
@@ -757,7 +853,6 @@ describe("Recipes", () => {
       const created = await agent.post("/recipes").send({
         name: "Salade",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Couper" }],
       });
@@ -766,7 +861,6 @@ describe("Recipes", () => {
         name: "Salade composée",
         portions: 6,
         visibility: "PUBLIC",
-        dietIds: [],
         ingredients: [{ ingredientId: oignon, quantity: 2, unitId: gram }],
         steps: [{ description: "Émincer" }, { description: "Mélanger" }],
       });
@@ -781,6 +875,36 @@ describe("Recipes", () => {
       expect(res.body.steps).to.have.length(2);
     });
 
+    it("carries a « selon le goût » seasoning line through an edit (issue #128)", async () => {
+      const { agent } = await signup();
+      const tomate = await ingredientId("tomato");
+      const poivre = await ingredientId("blackPepper");
+      const gram = await unitId("gram");
+      const created = await agent.post("/recipes").send({
+        name: "Salade",
+        portions: 4,
+        ingredients: [{ ingredientId: tomate, quantity: 100, unitId: gram }],
+        steps: [{ description: "Couper" }],
+      });
+
+      const res = await agent.patch(`/recipes/${created.body.id}`).send({
+        name: "Salade poivrée",
+        portions: 4,
+        ingredients: [
+          { ingredientId: tomate, quantity: 100, unitId: gram },
+          { ingredientId: poivre }, // selon le goût
+        ],
+        steps: [{ description: "Couper" }, { description: "Poivrer" }],
+      });
+
+      expect(res.status).to.equal(200);
+      const seasoning = res.body.ingredients.find(
+        (line: { ingredient: { key: string } }) => line.ingredient.key === "blackPepper",
+      );
+      expect(seasoning.quantity).to.equal(null);
+      expect(seasoning.unit).to.equal(null);
+    });
+
     it("recomputes each replaced step's technique sequence", async () => {
       const { agent } = await signup();
       const tomate = await ingredientId("tomato");
@@ -789,7 +913,6 @@ describe("Recipes", () => {
       const created = await agent.post("/recipes").send({
         name: "Salade",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Servir immédiatement" }],
       });
@@ -797,7 +920,6 @@ describe("Recipes", () => {
       const res = await agent.patch(`/recipes/${created.body.id}`).send({
         name: "Salade",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Émincer les tomates" }],
       });
@@ -820,7 +942,6 @@ describe("Recipes", () => {
       const created = await agent.post("/recipes").send({
         name: "Ragoût",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [
           { description: "Hacher les oignons" }, // chop
@@ -849,7 +970,6 @@ describe("Recipes", () => {
       const res = await agent.patch(`/recipes/${created.body.id}`).send({
         name: "Ragoût",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: editedDescription }, { description: addedDescription }],
       });
@@ -890,7 +1010,6 @@ describe("Recipes", () => {
       const created = await agent.post("/recipes").send({
         name: "Gratin",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Servir immédiatement" }],
       });
@@ -907,7 +1026,6 @@ describe("Recipes", () => {
       const res = await agent.patch(`/recipes/${created.body.id}`).send({
         name: "Gratin",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: editedDescription }],
       });
@@ -942,7 +1060,6 @@ describe("Recipes", () => {
       const res = await agent.patch("/recipes/999999").send({
         name: "Test",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Étape" }],
       });
@@ -951,30 +1068,6 @@ describe("Recipes", () => {
       expect(res.body.code).to.equal(ErrorCode.RECIPE_NOT_FOUND);
     });
 
-    it("rejects an unknown dietId with 404 DIET_NOT_FOUND", async () => {
-      const { agent } = await signup();
-      const tomate = await ingredientId("tomato");
-      const piece = await unitId("piece");
-      const created = await agent.post("/recipes").send({
-        name: "Salade",
-        portions: 4,
-        dietIds: [],
-        ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
-        steps: [{ description: "Couper" }],
-      });
-
-      const res = await agent.patch(`/recipes/${created.body.id}`).send({
-        name: "Salade",
-        portions: 4,
-        dietIds: [999_999],
-        ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
-        steps: [{ description: "Couper" }],
-      });
-
-      expect(res.status).to.equal(404);
-      expect(res.body.code).to.equal(ErrorCode.DIET_NOT_FOUND);
-    });
-
     it("rejects an edit from anyone other than the recipe's author with 403 NOT_RECIPE_AUTHOR", async () => {
       const { profileId } = await signup();
       const { agent: otherAgent } = await signup();
@@ -987,7 +1080,6 @@ describe("Recipes", () => {
       const res = await otherAgent.patch(`/recipes/${recipe.id}`).send({
         name: "Hack",
         portions: 4,
-        dietIds: [],
         ingredients: [{ ingredientId: tomate, quantity: 1, unitId: piece }],
         steps: [{ description: "Étape" }],
       });

apps/api/test/recipe/recipe-tech-step-correction.test.ts

@@ -109,7 +109,12 @@ describe("Recipe tech-step corrections", () => {
 
       expect(res.status).to.equal(201);
       expect(res.body.correction.previousTechStep).to.equal(null);
-      expect(res.body.correction.correctedTechStep).to.deep.equal({ id: simmerId, key: "simmer" });
+      expect(res.body.correction.correctedTechStep).to.deep.equal({
+        id: simmerId,
+        key: "simmer",
+        isPlaceholder: false,
+        displayName: null,
+      });
       expect(res.body.correction.start).to.equal(6);
       expect(res.body.correction.end).to.equal(13);
       // The step's real technique sequence reflects the correction right
@@ -117,7 +122,7 @@ describe("Recipe tech-step corrections", () => {
       // `applyManualCorrection`, `recipe-tech-step-correction.service.ts`).
       expect(res.body.techSteps).to.deep.equal([
         {
-          techStep: { id: simmerId, key: "simmer" },
+          techStep: { id: simmerId, key: "simmer", isPlaceholder: false, displayName: null },
           start: 6,
           end: 13,
           source: "manual",
@@ -128,6 +133,56 @@ describe("Recipe tech-step corrections", () => {
       ]);
     });
 
+    it("proposes a placeholder technique via correctedTechStepName when the catalog is missing one (issue #130)", async () => {
+      const { agent, profileId } = await signup();
+      const { recipeId, stepId } = await createPublicRecipeWithStep(profileId);
+
+      const res = await agent
+        .post(`/recipes/${recipeId}/steps/${stepId}/corrections`)
+        .send({ start: 6, end: 13, correctedTechStepName: "Flamber au chalumeau" });
+
+      expect(res.status).to.equal(201);
+      // A placeholder `TechStep` was minted and the correction points at it.
+      expect(res.body.correction.correctedTechStep.isPlaceholder).to.equal(true);
+      expect(res.body.correction.correctedTechStep.displayName).to.equal("Flamber au chalumeau");
+      // ...and the step's live sequence carries it straight away.
+      expect(res.body.techSteps).to.have.length(1);
+      expect(res.body.techSteps[0].techStep.isPlaceholder).to.equal(true);
+      expect(res.body.techSteps[0].techStep.displayName).to.equal("Flamber au chalumeau");
+      expect(res.body.techSteps[0].source).to.equal("manual");
+
+      const row = await prisma.techStep.findUniqueOrThrow({
+        where: { id: res.body.techSteps[0].techStep.id },
+      });
+      expect(row.isPlaceholder).to.equal(true);
+      expect(row.key).to.match(/^placeholder:/);
+      expect(row.createdById).to.equal(profileId);
+      expect(row.createdAt).to.be.an.instanceOf(Date);
+      expect(row.reviewedAt).to.equal(null);
+      // It never leaks into the browsable catalog.
+      const reference = await agent.get("/reference/tech-steps");
+      expect(
+        reference.body.some(
+          (t: { displayName?: string }) => t.displayName === "Flamber au chalumeau",
+        ),
+      ).to.equal(false);
+    });
+
+    it("rejects sending both correctedTechStepId and correctedTechStepName with 400 VALIDATION_ERROR", async () => {
+      const { agent, profileId } = await signup();
+      const { recipeId, stepId } = await createPublicRecipeWithStep(profileId);
+
+      const res = await agent.post(`/recipes/${recipeId}/steps/${stepId}/corrections`).send({
+        start: 6,
+        end: 13,
+        correctedTechStepId: await techStepId("simmer"),
+        correctedTechStepName: "Autre chose",
+      });
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+    });
+
     it("records a correction relabeling an existing match (both ids set), updating the existing techSteps entry in place", async () => {
       const { agent, profileId } = await signup();
       const { recipeId, stepId } = await createPublicRecipeWithStep(profileId);
@@ -145,13 +200,23 @@ describe("Recipe tech-step corrections", () => {
         .send({ start: 6, end: 13, previousTechStepId: simmerId, correctedTechStepId: boilId });
 
       expect(res.status).to.equal(201);
-      expect(res.body.correction.previousTechStep).to.deep.equal({ id: simmerId, key: "simmer" });
+      expect(res.body.correction.previousTechStep).to.deep.equal({
-      expect(res.body.correction.correctedTechStep).to.deep.equal({ id: boilId, key: "boil" });
+        id: simmerId,
+        key: "simmer",
+        isPlaceholder: false,
+        displayName: null,
+      });
+      expect(res.body.correction.correctedTechStep).to.deep.equal({
+        id: boilId,
+        key: "boil",
+        isPlaceholder: false,
+        displayName: null,
+      });
       // Still exactly one entry — the relabel updated the existing row
       // rather than adding a second one alongside it.
       expect(res.body.techSteps).to.deep.equal([
         {
-          techStep: { id: boilId, key: "boil" },
+          techStep: { id: boilId, key: "boil", isPlaceholder: false, displayName: null },
           start: 6,
           end: 13,
           source: "manual",
@@ -299,7 +364,7 @@ describe("Recipe tech-step corrections", () => {
       expect(res.status).to.equal(201);
       expect(res.body.techSteps).to.deep.equal([
         {
-          techStep: { id: simmerId, key: "simmer" },
+          techStep: { id: simmerId, key: "simmer", isPlaceholder: false, displayName: null },
           start: 6,
           end: 13,
           source: "manual",
@@ -535,7 +600,7 @@ describe("Recipe tech-step corrections", () => {
       expect(res.status).to.equal(201);
       expect(res.body.techSteps).to.deep.equal([
         {
-          techStep: { id: preheatId, key: "preheat" },
+          techStep: { id: preheatId, key: "preheat", isPlaceholder: false, displayName: null },
           start: 0,
           end: 11,
           source: "manual",
@@ -721,8 +786,18 @@ describe("Recipe tech-step corrections", () => {
 
       expect(res.status).to.equal(200);
       expect(res.body).to.have.length(2);
-      expect(res.body[0].correctedTechStep).to.deep.equal({ id: boilId, key: "boil" });
+      expect(res.body[0].correctedTechStep).to.deep.equal({
-      expect(res.body[1].correctedTechStep).to.deep.equal({ id: simmerId, key: "simmer" });
+        id: boilId,
+        key: "boil",
+        isPlaceholder: false,
+        displayName: null,
+      });
+      expect(res.body[1].correctedTechStep).to.deep.equal({
+        id: simmerId,
+        key: "simmer",
+        isPlaceholder: false,
+        displayName: null,
+      });
     });
 
     it("returns an empty list when nothing has been submitted yet", async () => {

apps/api/test/reference.test.ts

@@ -148,7 +148,30 @@ describe("Reference data", () => {
       // number — this catalog has grown since (26 -> 74) and will again.
       expect(res.body).to.have.length(TECH_STEPS.length);
       expect(res.body.map((t: { key: string }) => t.key)).to.include("simmer");
-      expect(res.body[0]).to.have.keys(["id", "key"]);
+      expect(res.body[0]).to.have.keys(["id", "key", "isPlaceholder", "displayName"]);
+      expect(res.body.every((t: { isPlaceholder: boolean }) => t.isPlaceholder === false)).to.equal(
+        true,
+      );
+    });
+
+    it("excludes placeholder techniques users proposed while correcting a step (issue #130)", async () => {
+      await prisma.techStep.create({
+        data: {
+          key: "placeholder:test-1",
+          isPlaceholder: true,
+          displayName: "Flamber au chalumeau",
+        },
+      });
+
+      const res = await request(app).get("/reference/tech-steps");
+
+      expect(res.status).to.equal(200);
+      expect(res.body).to.have.length(TECH_STEPS.length);
+      expect(
+        res.body.some(
+          (t: { displayName: string | null }) => t.displayName === "Flamber au chalumeau",
+        ),
+      ).to.equal(false);
     });
 
     it("orders techniques alphabetically by key", async () => {

apps/api/test/shopping-list.test.ts

@@ -214,6 +214,76 @@ describe("Shopping list", () => {
       expect(res.body.items[0].quantity).to.equal(300);
     });
 
+    it("lists a « selon le goût » seasoning ingredient once, with no quantity, never summed (issue #128)", 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 tomatoId = await ingredientId("tomato");
+      const saltId = await ingredientId("salt");
+      const gramId = await unitId("gram");
+
+      // 100g tomato + salt "selon le goût" (quantity/unit null), planned
+      // twice at 4 portions each (recipe yields 2): tomato scales to 400g,
+      // salt stays a single unquantified line.
+      const recipe = await prisma.recipe.create({
+        data: {
+          name: "Tomates au sel",
+          authorId,
+          portions: 2,
+          ingredients: {
+            create: [
+              { ingredientId: tomatoId, quantity: 100, unitId: gramId },
+              { ingredientId: saltId, quantity: null, unitId: null },
+            ],
+          },
+        },
+      });
+      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: recipe.id,
+            portions: 4,
+            portionsRequested: 4,
+          },
+          {
+            planningId: planning.id,
+            weekDay: "mercredi",
+            meal: "diner",
+            recipeId: recipe.id,
+            portions: 4,
+            portionsRequested: 4,
+          },
+        ],
+      });
+
+      const res = await agent.get("/shopping-list").query({ date: today() });
+
+      expect(res.status).to.equal(200);
+      const salt = res.body.items.filter(
+        (item: { ingredient: { key: string } }) => item.ingredient.key === "salt",
+      );
+      expect(salt).to.have.length(1);
+      expect(salt[0].quantity).to.equal(null);
+      expect(salt[0].unit).to.equal(null);
+      const tomato = res.body.items.find(
+        (item: { ingredient: { key: string } }) => item.ingredient.key === "tomato",
+      );
+      expect(tomato.quantity).to.equal(400);
+    });
+
     it("sums the same ingredient across two different recipes sharing a unit", async () => {
       const agent = request.agent(app);
       await agent.post("/auth/signup").send(buildSignupPayload());

apps/api/test/sources/sources.test.ts

@@ -339,7 +339,12 @@ describe("Sources", () => {
       const [step] = res.body.steps;
       expect(step.description).to.equal("Chop the onions finely");
       expect(step.techSteps).to.have.length(1);
-      expect(step.techSteps[0].techStep).to.deep.equal({ id: chop.id, key: "chop" });
+      expect(step.techSteps[0].techStep).to.deep.equal({
+        id: chop.id,
+        key: "chop",
+        isPlaceholder: false,
+        displayName: null,
+      });
       expect(
         step.description.slice(step.techSteps[0].start, step.techSteps[0].end).toLowerCase(),
       ).to.equal("chop");
@@ -382,6 +387,8 @@ describe("Sources", () => {
       expect(res.body.steps[0].techSteps[0].techStep).to.deep.equal({
         id: simmer.id,
         key: "simmer",
+        isPlaceholder: false,
+        displayName: null,
       });
     });
 
@@ -426,7 +433,6 @@ describe("Sources", () => {
       return {
         name: "Fake recipe 1 (revue)",
         portions: 4,
-        dietIds: [],
         ingredients: [
           { ingredientId: await ingredientId("onion"), quantity: 1, unitId: await unitId("piece") },
         ],

apps/web/android/.gitignore

@@ -0,0 +1,103 @@
+# Using Android gitignore template: https://github.com/github/gitignore/blob/HEAD/Android.gitignore
+
+# Built application files
+*.apk
+*.aar
+*.ap_
+*.aab
+
+# Files for the ART/Dalvik VM
+*.dex
+
+# Java class files
+*.class
+
+# Generated files
+bin/
+gen/
+out/
+#  Uncomment the following line in case you need and you don't have the release build type files in your app
+# release/
+
+# Gradle files
+.gradle/
+build/
+
+# Local configuration file (sdk path, etc)
+local.properties
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+*.log
+
+# Android Studio Navigation editor temp files
+.navigation/
+
+# Android Studio captures folder
+captures/
+
+# IntelliJ
+*.iml
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/gradle.xml
+.idea/assetWizardSettings.xml
+.idea/dictionaries
+.idea/libraries
+# Android Studio 3 in .gitignore file.
+.idea/caches
+.idea/modules.xml
+# Comment next line if keeping position of elements in Navigation Editor is relevant for you
+.idea/navEditor.xml
+
+# Keystore files — jamais commités : le keystore de release est un secret
+# généré une fois à la main (voir la doc du README, section "Application
+# mobile"), décodé depuis le secret CI ANDROID_KEYSTORE_BASE64 à chaque build
+# de release, jamais versionné ici (issue #64).
+*.jks
+*.keystore
+
+# External native build folder generated in Android Studio 2.2 and later
+.externalNativeBuild
+.cxx/
+
+# Google Services (e.g. APIs or Firebase)
+# google-services.json
+
+# Freeline
+freeline.py
+freeline/
+freeline_project_description.json
+
+# fastlane
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots
+fastlane/test_output
+fastlane/readme.md
+
+# Version control
+vcs.xml
+
+# lint
+lint/intermediates/
+lint/generated/
+lint/outputs/
+lint/tmp/
+# lint/reports/
+
+# Android Profiling
+*.hprof
+
+# Cordova plugins for Capacitor
+capacitor-cordova-android-plugins
+
+# Copied web assets
+app/src/main/assets/public
+
+# Generated Config files
+app/src/main/assets/capacitor.config.json
+app/src/main/assets/capacitor.plugins.json
+app/src/main/res/xml/config.xml

apps/web/android/app/.gitignore

@@ -0,0 +1,2 @@
+/build/*
+!/build/.npmkeep

apps/web/android/app/build.gradle

@@ -0,0 +1,81 @@
+apply plugin: 'com.android.application'
+
+android {
+    namespace = "fr.kyuno.batchcooking"
+    compileSdk = rootProject.ext.compileSdkVersion
+    defaultConfig {
+        applicationId "fr.kyuno.batchcooking"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        // Surchargeables depuis la CI via `-PandroidVersionCode=... -PandroidVersionName=...`
+        // (release.yml, dérivés du tag `vX.Y.Z` poussé) — la valeur par
+        // défaut ci-dessous ne sert qu'aux builds locaux/CI qui ne passent
+        // pas ces propriétés (Android Studio, le job build-android de
+        // ci.yml sur un simple push main), jamais à une vraie release.
+        versionCode (project.hasProperty("androidVersionCode") ? (project.androidVersionCode as Integer) : 1)
+        versionName (project.hasProperty("androidVersionName") ? project.androidVersionName : "1.0")
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        aaptOptions {
+             // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.
+             // Default: https://android.googlesource.com/platform/frameworks/base/+/282e181b58cf72b6ca770dc7ca5f91f135444502/tools/aapt/AaptAssets.cpp#61
+            ignoreAssetsPattern = '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~'
+        }
+    }
+    // Lu depuis l'environnement, jamais codé en dur — même règle que les
+    // secrets de apps/api (JWT_SECRET, etc.) : aucune valeur par défaut
+    // devinable. Le keystore lui-même (ANDROID_KEYSTORE_PATH) est un fichier
+    // décodé à la volée depuis le secret CI ANDROID_KEYSTORE_BASE64, jamais
+    // commité (voir apps/web/android/.gitignore) — généré une fois à la main,
+    // voir la doc du README "Application mobile". N'affecte que
+    // `assembleRelease` : `assembleDebug` continue d'utiliser le keystore de
+    // debug généré automatiquement par Android, sans configuration.
+    signingConfigs {
+        release {
+            storeFile System.getenv("ANDROID_KEYSTORE_PATH") ? file(System.getenv("ANDROID_KEYSTORE_PATH")) : null
+            storePassword System.getenv("ANDROID_KEYSTORE_PASSWORD")
+            keyAlias System.getenv("ANDROID_KEY_ALIAS")
+            keyPassword System.getenv("ANDROID_KEY_PASSWORD")
+        }
+    }
+    buildTypes {
+        release {
+            // `signingConfig` reste posé même quand les variables d'environnement
+            // ci-dessus sont absentes (dev local) : Gradle accepte une
+            // signingConfig aux champs `null`, la build échoue seulement au
+            // moment de la signature effective (assembleRelease), jamais à la
+            // configuration — un `assembleDebug` local n'en a jamais besoin.
+            signingConfig signingConfigs.release
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+repositories {
+    flatDir{
+        dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs'
+    }
+}
+
+dependencies {
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion"
+    implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion"
+    implementation project(':capacitor-android')
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+    implementation project(':capacitor-cordova-android-plugins')
+}
+
+apply from: 'capacitor.build.gradle'
+
+try {
+    def servicesJSON = file('google-services.json')
+    if (servicesJSON.text) {
+        apply plugin: 'com.google.gms.google-services'
+    }
+} catch(Exception e) {
+    logger.info("google-services.json not found, google-services plugin not applied. Push Notifications won't work")
+}

apps/web/android/app/capacitor.build.gradle

@@ -0,0 +1,19 @@
+// DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN
+
+android {
+  compileOptions {
+      sourceCompatibility JavaVersion.VERSION_21
+      targetCompatibility JavaVersion.VERSION_21
+  }
+}
+
+apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle"
+dependencies {
+    implementation project(':capacitor-preferences')
+
+}
+
+
+if (hasProperty('postBuildExtras')) {
+  postBuildExtras()
+}

apps/web/android/app/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

apps/web/android/app/src/androidTest/java/com/getcapacitor/myapp/ExampleInstrumentedTest.java

@@ -0,0 +1,26 @@
+package com.getcapacitor.myapp;
+
+import static org.junit.Assert.*;
+
+import android.content.Context;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+
+    @Test
+    public void useAppContext() throws Exception {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+        assertEquals("com.getcapacitor.app", appContext.getPackageName());
+    }
+}

apps/web/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme">
+        <activity
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode|navigation|density"
+            android:name=".MainActivity"
+            android:label="@string/title_activity_main"
+            android:theme="@style/AppTheme.NoActionBarLaunch"
+            android:launchMode="singleTask"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <!-- Custom scheme for the web app's "open the installed app"
+                 redirect (see apps/web/src/lib/mobile-app-redirect.ts) —
+                 additive, does not touch the launcher filter above. No
+                 android:host/android:path restriction, so any
+                 batchcooking://... URL matches. -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="batchcooking" />
+            </intent-filter>
+        </activity>
+
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/file_paths" />
+        </provider>
+    </application>
+
+    <!-- Permissions -->
+
+    <uses-permission android:name="android.permission.INTERNET" />
+</manifest>

apps/web/android/app/src/main/java/fr/kyuno/batchcooking/MainActivity.java

@@ -0,0 +1,5 @@
+package fr.kyuno.batchcooking;
+
+import com.getcapacitor.BridgeActivity;
+
+public class MainActivity extends BridgeActivity {}

apps/web/android/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".MainActivity">
+
+    <WebView
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</androidx.coordinatorlayout.widget.CoordinatorLayout>

apps/web/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background>
+        <inset android:drawable="@mipmap/ic_launcher_background" android:inset="16.7%" />
+    </background>
+    <foreground>
+        <inset android:drawable="@mipmap/ic_launcher_foreground" android:inset="16.7%" />
+    </foreground>
+</adaptive-icon>

apps/web/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background>
+        <inset android:drawable="@mipmap/ic_launcher_background" android:inset="16.7%" />
+    </background>
+    <foreground>
+        <inset android:drawable="@mipmap/ic_launcher_foreground" android:inset="16.7%" />
+    </foreground>
+</adaptive-icon>