chore: bump package.json + package-lock auf 1.4.2

Patch-Release: Einkaufsliste-Konsolidierung ueber Einheiten (500 g + 1 kg
Kartoffeln → 1,5 kg). Migration 015 fuer Check-Key-Family-Stabilitaet.
formatQuantity app-weit auf de-DE Komma-Dezimal.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

docs/superpowers/plans/2026-04-22-einkaufsliste-konsolidierung.md

@@ -0,0 +1,887 @@
+# Einkaufsliste Mengen-Konsolidierung Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Verschiedene Unit-Varianten derselben Zutat (500 g + 1 kg Kartoffeln) in der Einkaufsliste zu einer Zeile konsolidieren (→ 1,5 kg). Scope: g↔kg, ml↔l.
+
+**Architecture:** Zwei reine TS-Utilities (`unitFamily`, `consolidate`) kapseln die Logik. `listShoppingList()` lässt SQL weiterhin pro (name, unit) aggregieren, bündelt die Zeilen dann in TS pro `(name, unitFamily)` und konsolidiert. Migration 015 macht `shopping_cart_check.unit_key` zum Family-Key, damit Abhaks nicht verloren gehen wenn Display-Unit zwischen g und kg wechselt. `formatQuantity` wechselt app-weit auf `toLocaleString('de-DE')` (Komma als Dezimaltrennzeichen).
+
+**Tech Stack:** SvelteKit, better-sqlite3, Vitest. Keine neuen Deps.
+
+---
+
+## File Structure
+
+**Create:**
+- `src/lib/server/shopping/unit-consolidation.ts` — `unitFamily()` + `consolidate()`
+- `src/lib/server/db/migrations/015_shopping_check_family.sql` — Family-Key-Migration
+- `tests/unit/unit-consolidation.test.ts` — Unit-Tests
+
+**Modify:**
+- `src/lib/quantity-format.ts` — `toLocaleString('de-DE', …)` statt Punkt
+- `tests/unit/quantity-format.test.ts` — Erwartungen auf Komma anpassen
+- `src/lib/server/shopping/repository.ts` — `listShoppingList`, `toggleCheck`, `clearCheckedItems` auf Family-Key umstellen
+- `tests/integration/shopping-repository.test.ts` — neue Describe-Blöcke für Konsolidierung
+
+---
+
+### Task 1: Unit-Family-Utility
+
+**Files:**
+- Create: `src/lib/server/unit-consolidation.ts`
+- Test: `tests/unit/unit-consolidation.test.ts`
+
+Hinweis: Datei bewusst in `src/lib/server/` (nicht in `shopping/`), weil `unitFamily` auch vom Migration-Code referenziert wird — eine Ebene höher ist intuitiver.
+
+- [ ] **Step 1: Write failing tests for `unitFamily`**
+
+Create `tests/unit/unit-consolidation.test.ts`:
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { unitFamily } from '../../src/lib/server/unit-consolidation';
+
+describe('unitFamily', () => {
+  it('maps g and kg to weight', () => {
+    expect(unitFamily('g')).toBe('weight');
+    expect(unitFamily('kg')).toBe('weight');
+  });
+  it('maps ml and l to volume', () => {
+    expect(unitFamily('ml')).toBe('volume');
+    expect(unitFamily('l')).toBe('volume');
+  });
+  it('lowercases and trims unknown units', () => {
+    expect(unitFamily(' Bund ')).toBe('bund');
+    expect(unitFamily('TL')).toBe('tl');
+    expect(unitFamily('Stück')).toBe('stück');
+  });
+  it('is case-insensitive for weight/volume', () => {
+    expect(unitFamily('Kg')).toBe('weight');
+    expect(unitFamily('ML')).toBe('volume');
+  });
+  it('returns empty string for null/undefined/empty', () => {
+    expect(unitFamily(null)).toBe('');
+    expect(unitFamily(undefined)).toBe('');
+    expect(unitFamily('')).toBe('');
+    expect(unitFamily('   ')).toBe('');
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npm test -- tests/unit/unit-consolidation.test.ts`
+Expected: All fail with "Cannot find module …/unit-consolidation".
+
+- [ ] **Step 3: Implement `unitFamily`**
+
+Create `src/lib/server/unit-consolidation.ts`:
+
+```typescript
+export type UnitFamily = 'weight' | 'volume' | string;
+
+const WEIGHT_UNITS = new Set(['g', 'kg']);
+const VOLUME_UNITS = new Set(['ml', 'l']);
+
+export function unitFamily(unit: string | null | undefined): UnitFamily {
+  const u = (unit ?? '').trim().toLowerCase();
+  if (WEIGHT_UNITS.has(u)) return 'weight';
+  if (VOLUME_UNITS.has(u)) return 'volume';
+  return u;
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npm test -- tests/unit/unit-consolidation.test.ts`
+Expected: 5 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/server/unit-consolidation.ts tests/unit/unit-consolidation.test.ts
+git commit -m "feat(shopping): unitFamily-Utility fuer Konsolidierung"
+```
+
+---
+
+### Task 2: Consolidate-Funktion
+
+**Files:**
+- Modify: `src/lib/server/unit-consolidation.ts`
+- Modify: `tests/unit/unit-consolidation.test.ts`
+
+- [ ] **Step 1: Append failing tests for `consolidate` to the existing test file**
+
+Append to `tests/unit/unit-consolidation.test.ts` (after the `unitFamily` describe):
+
+```typescript
+import { consolidate } from '../../src/lib/server/unit-consolidation';
+
+describe('consolidate', () => {
+  it('kombiniert 500 g + 1 kg zu 1,5 kg', () => {
+    const out = consolidate([
+      { quantity: 500, unit: 'g' },
+      { quantity: 1, unit: 'kg' }
+    ]);
+    expect(out).toEqual({ quantity: 1.5, unit: 'kg' });
+  });
+
+  it('bleibt bei g wenn Summe < 1 kg', () => {
+    const out = consolidate([
+      { quantity: 200, unit: 'g' },
+      { quantity: 300, unit: 'g' }
+    ]);
+    expect(out).toEqual({ quantity: 500, unit: 'g' });
+  });
+
+  it('kombiniert ml + l analog (400 ml + 0,5 l → 900 ml)', () => {
+    const out = consolidate([
+      { quantity: 400, unit: 'ml' },
+      { quantity: 0.5, unit: 'l' }
+    ]);
+    expect(out).toEqual({ quantity: 900, unit: 'ml' });
+  });
+
+  it('promoted zu l ab 1000 ml (0,5 l + 0,8 l → 1,3 l)', () => {
+    const out = consolidate([
+      { quantity: 0.5, unit: 'l' },
+      { quantity: 0.8, unit: 'l' }
+    ]);
+    expect(out).toEqual({ quantity: 1.3, unit: 'l' });
+  });
+
+  it('summiert gleiche nicht-family-units (2 Bund + 1 Bund → 3 Bund)', () => {
+    const out = consolidate([
+      { quantity: 2, unit: 'Bund' },
+      { quantity: 1, unit: 'Bund' }
+    ]);
+    expect(out).toEqual({ quantity: 3, unit: 'Bund' });
+  });
+
+  it('behandelt quantity=null als 0', () => {
+    const out = consolidate([
+      { quantity: null, unit: 'TL' },
+      { quantity: 1, unit: 'TL' }
+    ]);
+    expect(out).toEqual({ quantity: 1, unit: 'TL' });
+  });
+
+  it('gibt null zurueck wenn alle quantities null sind', () => {
+    const out = consolidate([
+      { quantity: null, unit: 'Prise' },
+      { quantity: null, unit: 'Prise' }
+    ]);
+    expect(out).toEqual({ quantity: null, unit: 'Prise' });
+  });
+
+  it('rundet Float-Artefakte auf 2 Dezimalen (0,1 + 0,2 kg → 0,3 kg)', () => {
+    const out = consolidate([
+      { quantity: 0.1, unit: 'kg' },
+      { quantity: 0.2, unit: 'kg' }
+    ]);
+    // 0.1 + 0.2 in kg = 0.3 kg, in g = 300 → promoted? 300 < 1000 → 300 g
+    expect(out).toEqual({ quantity: 300, unit: 'g' });
+  });
+
+  it('nimmt unit vom ersten Eintrag bei unbekannter family', () => {
+    const out = consolidate([{ quantity: 5, unit: 'Stück' }]);
+    expect(out).toEqual({ quantity: 5, unit: 'Stück' });
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npm test -- tests/unit/unit-consolidation.test.ts`
+Expected: Fail with "consolidate is not a function" or similar (9 new tests fail).
+
+- [ ] **Step 3: Implement `consolidate`**
+
+Append to `src/lib/server/unit-consolidation.ts`:
+
+```typescript
+export interface QuantityInUnit {
+  quantity: number | null;
+  unit: string | null;
+}
+
+function round2(n: number): number {
+  return Math.round(n * 100) / 100;
+}
+
+/**
+ * Konsolidiert mehrere {quantity, unit}-Eintraege derselben Unit-Family
+ * zu einer gemeinsamen Menge + Display-Unit.
+ *
+ * - Gewicht (g, kg): summiert in g, promoted bei >=1000 g auf kg.
+ * - Volumen (ml, l): summiert in ml, promoted bei >=1000 ml auf l.
+ * - Andere: summiert quantity ohne Umrechnung, Display-Unit vom ersten
+ *   Eintrag.
+ *
+ * quantity=null wird als 0 behandelt. Wenn ALLE quantities null sind,
+ * ist die Gesamtmenge ebenfalls null.
+ */
+export function consolidate(rows: QuantityInUnit[]): QuantityInUnit {
+  if (rows.length === 0) return { quantity: null, unit: null };
+
+  const family = unitFamily(rows[0].unit);
+  const firstUnit = rows[0].unit;
+
+  const allNull = rows.every((r) => r.quantity === null);
+
+  if (family === 'weight') {
+    if (allNull) return { quantity: null, unit: firstUnit };
+    const grams = rows.reduce((sum, r) => {
+      const q = r.quantity ?? 0;
+      return sum + (unitFamily(r.unit) === 'weight' && r.unit?.toLowerCase().trim() === 'kg' ? q * 1000 : q);
+    }, 0);
+    if (grams >= 1000) return { quantity: round2(grams / 1000), unit: 'kg' };
+    return { quantity: round2(grams), unit: 'g' };
+  }
+
+  if (family === 'volume') {
+    if (allNull) return { quantity: null, unit: firstUnit };
+    const ml = rows.reduce((sum, r) => {
+      const q = r.quantity ?? 0;
+      return sum + (r.unit?.toLowerCase().trim() === 'l' ? q * 1000 : q);
+    }, 0);
+    if (ml >= 1000) return { quantity: round2(ml / 1000), unit: 'l' };
+    return { quantity: round2(ml), unit: 'ml' };
+  }
+
+  // Non-family: summiere quantity direkt
+  if (allNull) return { quantity: null, unit: firstUnit };
+  const sum = rows.reduce((acc, r) => acc + (r.quantity ?? 0), 0);
+  return { quantity: round2(sum), unit: firstUnit };
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npm test -- tests/unit/unit-consolidation.test.ts`
+Expected: 14 tests pass (5 from Task 1 + 9 new).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/server/unit-consolidation.ts tests/unit/unit-consolidation.test.ts
+git commit -m "feat(shopping): consolidate() fuer g/kg + ml/l Summierung"
+```
+
+---
+
+### Task 3: formatQuantity auf deutsches Locale
+
+**Files:**
+- Modify: `src/lib/quantity-format.ts`
+- Modify: `tests/unit/quantity-format.test.ts`
+
+- [ ] **Step 1: Update tests to expect comma decimal**
+
+Open `tests/unit/quantity-format.test.ts`. Jede Erwartung mit Dezimalpunkt auf Komma ändern, z. B.:
+
+```typescript
+// vorher: expect(formatQuantity(0.333)).toBe('0.33');
+// nachher:
+expect(formatQuantity(0.333)).toBe('0,33');
+```
+
+Betroffene Assertions (aus dem bestehenden Test-File):
+- `formatQuantity(0.333)` → `'0,33'`
+- `formatQuantity(0.5)` → `'0,5'`
+- `formatQuantity(1.25)` → `'1,25'`
+
+Ganze Zahlen (`formatQuantity(3)` → `'3'`) und null (`''`) bleiben gleich.
+
+- [ ] **Step 2: Run tests to verify they fail with current implementation**
+
+Run: `npm test -- tests/unit/quantity-format.test.ts`
+Expected: Tests with decimal values fail (`'0.33'` received, `'0,33'` expected).
+
+- [ ] **Step 3: Rewrite `formatQuantity` mit toLocaleString**
+
+Replace contents of `src/lib/quantity-format.ts`:
+
+```typescript
+export function formatQuantity(q: number | null): string {
+  if (q === null || q === undefined) return '';
+  return q.toLocaleString('de-DE', {
+    maximumFractionDigits: 2,
+    useGrouping: false
+  });
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npm test -- tests/unit/quantity-format.test.ts`
+Expected: Alle 5 Tests grün.
+
+- [ ] **Step 5: Run full suite to catch app-wide regressions**
+
+Run: `npm test`
+Expected: Alle Tests grün. Falls andere Tests (z. B. Rezept-Detail-Rendering) Erwartungen auf `'.'` haben und fehlschlagen, Assertions dort auf Komma anpassen und in denselben Commit nehmen.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/lib/quantity-format.ts tests/unit/quantity-format.test.ts
+git commit -m "feat(format): formatQuantity app-weit auf de-DE Komma-Dezimal"
+```
+
+---
+
+### Task 4: Migration 015 — Check-Keys auf Family
+
+**Files:**
+- Create: `src/lib/server/db/migrations/015_shopping_check_family.sql`
+
+Hinweis: Migrations werden via `import.meta.glob('./migrations/*.sql', {eager, query:'?raw'})` gebundelt (siehe CLAUDE.md) — kein Dockerfile-Copy nötig.
+
+- [ ] **Step 1: Write the migration**
+
+Create `src/lib/server/db/migrations/015_shopping_check_family.sql`:
+
+```sql
+-- Konsolidierung: unit_key in shopping_cart_check wird zum Family-Key, damit
+-- Abhaks stabil bleiben wenn Display-Unit zwischen g und kg wechselt.
+-- g/kg → 'weight', ml/l → 'volume', Rest bleibt unveraendert.
+UPDATE shopping_cart_check SET unit_key = 'weight' WHERE LOWER(TRIM(unit_key)) IN ('g', 'kg');
+UPDATE shopping_cart_check SET unit_key = 'volume' WHERE LOWER(TRIM(unit_key)) IN ('ml', 'l');
+
+-- Nach Relabeling koennen Duplikate entstehen (zwei Zeilen mit 'weight' pro
+-- name_key). Juengsten Eintrag behalten.
+DELETE FROM shopping_cart_check
+WHERE rowid NOT IN (
+  SELECT MAX(rowid)
+  FROM shopping_cart_check
+  GROUP BY name_key, unit_key
+);
+```
+
+- [ ] **Step 2: Verify migration runs (smoke test via any integration test)**
+
+Run: `npm test -- tests/integration/shopping-repository.test.ts`
+Expected: Alle bestehenden Tests grün (Migration läuft beim `openInMemoryForTest()`, bricht nichts weil Tabelle beim ersten Lauf leer ist).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/lib/server/db/migrations/015_shopping_check_family.sql
+git commit -m "feat(shopping): Migration 015 — Check-Keys auf Unit-Family"
+```
+
+---
+
+### Task 5: listShoppingList mit Family-Konsolidierung
+
+**Files:**
+- Modify: `src/lib/server/shopping/repository.ts:70-107`
+- Modify: `tests/integration/shopping-repository.test.ts`
+
+- [ ] **Step 1: Write failing integration test**
+
+Append to `tests/integration/shopping-repository.test.ts` (z. B. nach dem vorhandenen `addRecipeToCart`-Block, ein eigener Describe-Block):
+
+```typescript
+describe('listShoppingList — Konsolidierung ueber Einheiten', () => {
+  it('fasst 500 g + 1 kg Kartoffeln zu 1,5 kg zusammen', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'Kartoffelsuppe',
+        servings_default: 4,
+        ingredients: [
+          { position: 1, name: 'Kartoffeln', quantity: 500, unit: 'g', note: null, raw_text: null }
+        ]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'Kartoffelpuffer',
+        servings_default: 4,
+        ingredients: [
+          { position: 1, name: 'Kartoffeln', quantity: 1, unit: 'kg', note: null, raw_text: null }
+        ]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const snap = listShoppingList(db);
+    const kartoffeln = snap.rows.filter((r) => r.display_name.toLowerCase() === 'kartoffeln');
+    expect(kartoffeln).toHaveLength(1);
+    expect(kartoffeln[0].total_quantity).toBe(1.5);
+    expect(kartoffeln[0].display_unit).toBe('kg');
+  });
+
+  it('kombiniert ml + l korrekt (400 ml + 0,5 l → 900 ml)', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Milch', quantity: 400, unit: 'ml', note: null, raw_text: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Milch', quantity: 0.5, unit: 'l', note: null, raw_text: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const milch = listShoppingList(db).rows.filter((r) => r.display_name.toLowerCase() === 'milch');
+    expect(milch).toHaveLength(1);
+    expect(milch[0].total_quantity).toBe(900);
+    expect(milch[0].display_unit).toBe('ml');
+  });
+
+  it('laesst inkompatible Families getrennt (5 Stueck Eier + 500 g Eier = 2 Zeilen)', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Eier', quantity: 5, unit: 'Stück', note: null, raw_text: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Eier', quantity: 500, unit: 'g', note: null, raw_text: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const eier = listShoppingList(db).rows.filter((r) => r.display_name.toLowerCase() === 'eier');
+    expect(eier).toHaveLength(2);
+  });
+
+  it('summiert gleiche Unit-Family ohne Konversion (2 Bund + 1 Bund → 3 Bund)', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Petersilie', quantity: 2, unit: 'Bund', note: null, raw_text: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Petersilie', quantity: 1, unit: 'Bund', note: null, raw_text: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const petersilie = listShoppingList(db).rows.filter((r) => r.display_name.toLowerCase() === 'petersilie');
+    expect(petersilie).toHaveLength(1);
+    expect(petersilie[0].total_quantity).toBe(3);
+    expect(petersilie[0].display_unit?.toLowerCase()).toBe('bund');
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npm test -- tests/integration/shopping-repository.test.ts`
+Expected: 4 neue Tests fail (Konsolidierung existiert noch nicht).
+
+- [ ] **Step 3: Rewrite `listShoppingList` to use TS-side consolidation**
+
+Replace the `listShoppingList` body in `src/lib/server/shopping/repository.ts` (Zeilen 70-107):
+
+```typescript
+import { consolidate, unitFamily } from '../unit-consolidation';
+
+// (oben im File unter den bestehenden Imports einfuegen)
+
+export function listShoppingList(
+  db: Database.Database
+): ShoppingListSnapshot {
+  const recipes = db
+    .prepare(
+      `SELECT cr.recipe_id, r.title, r.image_path, cr.servings,
+              COALESCE(r.servings_default, cr.servings) AS servings_default
+         FROM shopping_cart_recipe cr
+         JOIN recipe r ON r.id = cr.recipe_id
+        ORDER BY cr.added_at ASC`
+    )
+    .all() as ShoppingCartRecipe[];
+
+  // SQL aggregiert weiterhin pro (name, raw-unit). Die family-Gruppierung
+  // + Konsolidierung macht TypeScript, damit SQL lesbar bleibt und die
+  // Logik Unit-testbar ist.
+  type RawRow = {
+    name_key: string;
+    unit_key: string;
+    display_name: string;
+    display_unit: string | null;
+    total_quantity: number | null;
+    from_recipes: string;
+  };
+
+  const raw = db
+    .prepare(
+      `SELECT
+         LOWER(TRIM(i.name)) AS name_key,
+         LOWER(TRIM(COALESCE(i.unit, ''))) AS unit_key,
+         MIN(i.name) AS display_name,
+         MIN(i.unit) AS display_unit,
+         SUM(i.quantity * cr.servings * 1.0 / NULLIF(COALESCE(r.servings_default, cr.servings), 0)) AS total_quantity,
+         GROUP_CONCAT(DISTINCT r.title) AS from_recipes
+       FROM shopping_cart_recipe cr
+       JOIN recipe r ON r.id = cr.recipe_id
+       JOIN ingredient i ON i.recipe_id = r.id
+       GROUP BY name_key, unit_key`
+    )
+    .all() as RawRow[];
+
+  // Check-Keys einmalig vorladen
+  const checkedSet = new Set(
+    (
+      db
+        .prepare('SELECT name_key, unit_key FROM shopping_cart_check')
+        .all() as { name_key: string; unit_key: string }[]
+    ).map((c) => `${c.name_key}|${c.unit_key}`)
+  );
+
+  // Gruppieren nach (name_key, unitFamily(unit_key))
+  const grouped = new Map<string, RawRow[]>();
+  for (const r of raw) {
+    const familyKey = unitFamily(r.unit_key);
+    const key = `${r.name_key}|${familyKey}`;
+    const arr = grouped.get(key) ?? [];
+    arr.push(r);
+    grouped.set(key, arr);
+  }
+
+  const rows: ShoppingListRow[] = [];
+  for (const [key, members] of grouped) {
+    const [nameKey, familyKey] = key.split('|');
+    const consolidated = consolidate(
+      members.map((m) => ({ quantity: m.total_quantity, unit: m.display_unit }))
+    );
+    // display_name: ersten nehmen (alle Member haben dasselbe name_key)
+    const displayName = members[0].display_name;
+    // from_recipes: alle unique Titel aus den Members kombinieren
+    const allRecipes = new Set<string>();
+    for (const m of members) {
+      for (const t of m.from_recipes.split(',')) allRecipes.add(t);
+    }
+    rows.push({
+      name_key: nameKey,
+      unit_key: familyKey, // wichtig: family-key, matched mit checked-Lookup
+      display_name: displayName,
+      display_unit: consolidated.unit,
+      total_quantity: consolidated.quantity,
+      from_recipes: [...allRecipes].join(','),
+      checked: checkedSet.has(`${nameKey}|${familyKey}`) ? 1 : 0
+    });
+  }
+
+  // Sort wie bisher: erst unchecked, dann alphabetisch by display_name
+  rows.sort((a, b) => {
+    if (a.checked !== b.checked) return a.checked - b.checked;
+    return a.display_name.localeCompare(b.display_name, 'de', { sensitivity: 'base' });
+  });
+
+  const uncheckedCount = rows.reduce((n, r) => n + (r.checked ? 0 : 1), 0);
+  return { recipes, rows, uncheckedCount };
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npm test -- tests/integration/shopping-repository.test.ts`
+Expected: Alle Tests grün (bestehende + 4 neue).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/lib/server/shopping/repository.ts tests/integration/shopping-repository.test.ts
+git commit -m "feat(shopping): listShoppingList konsolidiert g/kg + ml/l"
+```
+
+---
+
+### Task 6: toggleCheck + clearCheckedItems auf Family-Key
+
+**Files:**
+- Modify: `src/lib/server/shopping/repository.ts:109-188`
+- Modify: `tests/integration/shopping-repository.test.ts`
+
+- [ ] **Step 1: Write failing integration tests**
+
+Append to `tests/integration/shopping-repository.test.ts`:
+
+```typescript
+describe('toggleCheck — stabil ueber Unit-Family', () => {
+  it('haekchen bleibt erhalten wenn Gesamtmenge von kg auf g faellt', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Kartoffeln', quantity: 500, unit: 'g', note: null, raw_text: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Kartoffeln', quantity: 1, unit: 'kg', note: null, raw_text: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    // Abhaken der konsolidierten 1,5-kg-Zeile via family-key
+    const before = listShoppingList(db).rows[0];
+    toggleCheck(db, before.name_key, before.unit_key, true);
+    expect(listShoppingList(db).rows[0].checked).toBe(1);
+
+    // Ein Rezept rausnehmen → nur noch 500 g, display wechselt auf g
+    removeRecipeFromCart(db, b);
+    const after = listShoppingList(db).rows[0];
+    expect(after.display_unit).toBe('g');
+    expect(after.total_quantity).toBe(500);
+    // Haekchen bleibt: unit_key ist weiterhin 'weight'
+    expect(after.checked).toBe(1);
+  });
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `npm test -- tests/integration/shopping-repository.test.ts`
+Expected: Der neue Test failt, weil `toggleCheck` noch mit `unit_key` als raw unit arbeitet — der Check wird mit `'weight'` geschrieben, ABER das Schreiben selbst könnte fälschlich doch durchgehen (toggleCheck macht ja nur INSERT mit dem gegebenen Key). Der Failure entsteht beim zweiten `listShoppingList()`: der Lookup-Key matched noch nicht mit dem gespeicherten Check.
+
+Tatsächlich: Mit Task 5 schreibt `toggleCheck(db, name, 'weight', true)` einen Eintrag `(kartoffeln, 'weight')` in `shopping_cart_check`. `listShoppingList` liest den Check mit dem Family-Key — also passt. Der Test müsste grün sein _wenn_ toggleCheck unverändert funktioniert.
+
+Hmm — let me re-check. `toggleCheck(db, nameKey, unitKey, checked)` nimmt einfach den String, den der Caller übergibt, und speichert. Das ist agnostisch. Also wenn die UI `row.unit_key` durchreicht (was ja jetzt 'weight' ist), funktioniert das. Kein Code-Change nötig in toggleCheck.
+
+`clearCheckedItems` hingegen vergleicht Check-Keys mit der Ingredient-Tabelle via `LOWER(TRIM(COALESCE(i.unit, '')))` — das ist aber der RAW unit, nicht der Family-Key. Hier ist der Fix nötig.
+
+→ Step 2 wird daher beide Facetten prüfen: (1) toggleCheck/round-trip funktioniert bereits (Test grün), (2) clearCheckedItems dedupliziert korrekt.
+
+Ich füge daher einen expliziten clearCheckedItems-Test hinzu:
+
+Append weitere Test-Case in denselben Block:
+
+```typescript
+it('clearCheckedItems respektiert family-key beim Orphan-Cleanup', () => {
+  const db = openInMemoryForTest();
+  const a = insertRecipe(
+    db,
+    recipe({
+      title: 'R1',
+      servings_default: 4,
+      ingredients: [
+        { position: 1, name: 'Kartoffeln', quantity: 500, unit: 'g', note: null, raw_text: null },
+        { position: 2, name: 'Salz', quantity: 1, unit: 'Prise', note: null, raw_text: null }
+      ]
+    })
+  );
+  addRecipeToCart(db, a, null);
+  const rows = listShoppingList(db).rows;
+  // Alle abhaken
+  for (const r of rows) toggleCheck(db, r.name_key, r.unit_key, true);
+  clearCheckedItems(db);
+  // Das Rezept sollte raus sein
+  expect(listShoppingList(db).recipes).toHaveLength(0);
+  // Check-Tabelle sollte leer sein (keine Orphans)
+  const remaining = (db.prepare('SELECT COUNT(*) AS c FROM shopping_cart_check').get() as { c: number }).c;
+  expect(remaining).toBe(0);
+});
+```
+
+Run: `npm test -- tests/integration/shopping-repository.test.ts`
+Expected: Der clearCheckedItems-Test könnte failen weil der Orphan-Cleanup mit raw-unit vergleicht — der Check hat 'weight', das Ingredient hat 'g', Key-Match schlägt fehl, Check bleibt als Orphan.
+
+- [ ] **Step 3: Fix `clearCheckedItems` to use family-key for orphan comparison**
+
+In `src/lib/server/shopping/repository.ts`, in `clearCheckedItems` den Orphan-Cleanup-Block:
+
+Ersetzen (aktuell Zeilen 163-185):
+
+```typescript
+    // Orphan-Checks raeumen: alle Check-Keys, die jetzt in KEINEM Cart-Rezept
+    // mehr vorkommen.
+    const activeKeys = db
+      .prepare(
+        `SELECT DISTINCT
+           LOWER(TRIM(i.name)) AS name_key,
+           LOWER(TRIM(COALESCE(i.unit, ''))) AS unit_key
+         FROM shopping_cart_recipe cr
+         JOIN ingredient i ON i.recipe_id = cr.recipe_id`
+      )
+      .all() as { name_key: string; unit_key: string }[];
+    const activeSet = new Set(activeKeys.map((k) => `${k.name_key} ${k.unit_key}`));
+    const allChecks = db
+      .prepare('SELECT name_key, unit_key FROM shopping_cart_check')
+      .all() as { name_key: string; unit_key: string }[];
+    const del = db.prepare(
+      'DELETE FROM shopping_cart_check WHERE name_key = ? AND unit_key = ?'
+    );
+    for (const c of allChecks) {
+      if (!activeSet.has(`${c.name_key} ${c.unit_key}`)) {
+        del.run(c.name_key, c.unit_key);
+      }
+    }
+```
+
+durch:
+
+```typescript
+    // Orphan-Checks raeumen: Active-Keys nach (name_key, unitFamily(raw-unit))
+    // bauen, damit Checks mit family-key korrekt gematcht werden.
+    const activeRaw = db
+      .prepare(
+        `SELECT DISTINCT
+           LOWER(TRIM(i.name)) AS name_key,
+           LOWER(TRIM(COALESCE(i.unit, ''))) AS unit_key
+         FROM shopping_cart_recipe cr
+         JOIN ingredient i ON i.recipe_id = cr.recipe_id`
+      )
+      .all() as { name_key: string; unit_key: string }[];
+    const activeSet = new Set(
+      activeRaw.map((k) => `${k.name_key}|${unitFamily(k.unit_key)}`)
+    );
+    const allChecks = db
+      .prepare('SELECT name_key, unit_key FROM shopping_cart_check')
+      .all() as { name_key: string; unit_key: string }[];
+    const del = db.prepare(
+      'DELETE FROM shopping_cart_check WHERE name_key = ? AND unit_key = ?'
+    );
+    for (const c of allChecks) {
+      if (!activeSet.has(`${c.name_key}|${c.unit_key}`)) {
+        del.run(c.name_key, c.unit_key);
+      }
+    }
+```
+
+Analog den oberen Block in `clearCheckedItems` (perRecipe-Gruppierung, Zeilen 132-146), der `unit_key` mit `LOWER(TRIM(i.unit))` matched — da wird pro recipe_id gezählt, ob alle Zeilen abgehakt sind. Der Count-Vergleich mit `shopping_cart_check` erfolgt auch hier via unit_key. Anpassen:
+
+Ersetzen (aktuell Zeilen 132-147):
+
+```typescript
+    const allRows = db
+      .prepare(
+        `SELECT
+           cr.recipe_id,
+           LOWER(TRIM(i.name)) AS name_key,
+           LOWER(TRIM(COALESCE(i.unit, ''))) AS unit_key,
+           EXISTS(
+             SELECT 1 FROM shopping_cart_check c
+              WHERE c.name_key = LOWER(TRIM(i.name))
+                AND c.unit_key = LOWER(TRIM(COALESCE(i.unit, '')))
+           ) AS checked
+         FROM shopping_cart_recipe cr
+         JOIN ingredient i ON i.recipe_id = cr.recipe_id`
+      )
+      .all() as { recipe_id: number; name_key: string; unit_key: string; checked: 0 | 1 }[];
+```
+
+durch:
+
+```typescript
+    // Rohe (name, unit)-Zeilen holen, checked-Status per Family-Key-Lookup
+    // in JS entscheiden (SQL-CASE-Duplikation vermeiden).
+    const allRowsRaw = db
+      .prepare(
+        `SELECT
+           cr.recipe_id,
+           LOWER(TRIM(i.name)) AS name_key,
+           LOWER(TRIM(COALESCE(i.unit, ''))) AS unit_key
+         FROM shopping_cart_recipe cr
+         JOIN ingredient i ON i.recipe_id = cr.recipe_id`
+      )
+      .all() as { recipe_id: number; name_key: string; unit_key: string }[];
+
+    const checkSet = new Set(
+      (
+        db
+          .prepare('SELECT name_key, unit_key FROM shopping_cart_check')
+          .all() as { name_key: string; unit_key: string }[]
+      ).map((c) => `${c.name_key}|${c.unit_key}`)
+    );
+
+    const allRows = allRowsRaw.map((r) => ({
+      recipe_id: r.recipe_id,
+      name_key: r.name_key,
+      unit_key: r.unit_key,
+      checked: checkSet.has(`${r.name_key}|${unitFamily(r.unit_key)}`) ? (1 as const) : (0 as const)
+    }));
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npm test -- tests/integration/shopping-repository.test.ts`
+Expected: Alle Tests grün.
+
+- [ ] **Step 5: Run full suite + typecheck**
+
+Run: `npm test && npm run check`
+Expected: 
+- Tests: alle grün
+- svelte-check: `0 ERRORS 0 WARNINGS`
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/lib/server/shopping/repository.ts tests/integration/shopping-repository.test.ts
+git commit -m "feat(shopping): clearCheckedItems auf Family-Key umgestellt"
+```
+
+---
+
+### Task 7: End-to-End-Smoketest im Dev-Deployment
+
+**Files:** keine
+
+- [ ] **Step 1: Push und warten auf CI-Deploy**
+
+```bash
+git push
+```
+
+CI baut arm64-Image, deployt nach dev. ~5 Min.
+
+- [ ] **Step 2: Manuell auf `https://kochwas-dev.siegeln.net/shopping-list` prüfen**
+
+Check-Liste:
+- Zwei Rezepte mit 500 g + 1 kg gleicher Zutat in den Warenkorb → eine Zeile mit "1,5 kg".
+- 400 ml + 0,5 l → "900 ml".
+- Komma-Darstellung in Rezept-Detail überall ok (keine Regressionen).
+- Abhaken + Rezept rausnehmen → Haken bleibt.
+
+Wenn alle grün: Feature ist done. Kein separater Commit nötig.
+
+---
+
+## Self-Review Checklist
+
+- [x] Spec-Coverage: Alle Sektionen abgedeckt (Unit-Konsolidierung → Task 1+2, Migration → Task 4, Formatter → Task 3, listShoppingList-Integration → Task 5, Check-Stabilität → Task 6).
+- [x] Keine Placeholder: alle Tests und Implementierungen vollständig ausgeschrieben.
+- [x] Type-Konsistenz: `QuantityInUnit`, `ShoppingListRow` einheitlich referenziert. `unit_key` bleibt derselbe Feldname, semantisch jetzt Family-Key.
+- [x] Scope: eine einzelne Phase, atomic commits, TDD.

docs/superpowers/specs/2026-04-22-einkaufsliste-konsolidierung-design.md

@@ -0,0 +1,208 @@
+# Einkaufsliste: Mengen-Konsolidierung über Einheiten
+
+## Kontext
+
+Die Einkaufsliste (`/src/lib/server/shopping/repository.ts`, `listShoppingList()`) aggregiert
+Zutaten aus allen Warenkorb-Rezepten dynamisch per `GROUP BY LOWER(TRIM(name)), LOWER(TRIM(unit))`
+und summiert die skalierten Mengen. Verschiedene Einheiten für dieselbe Zutat bleiben separate
+Zeilen — typisches Beispiel: `500 g Kartoffeln` (Rezept A) und `1 kg Kartoffeln` (Rezept B)
+erscheinen als zwei Zeilen. Gewünscht: beides konsolidiert zu `1,5 kg Kartoffeln`.
+
+## Design-Entscheidungen (durch Brainstorming bestätigt)
+
+- **Scope**: nur Gewicht (g ↔ kg) und Volumen (ml ↔ l). TL/EL/Tasse/Stück bleiben unverändert.
+- **Anzeige-Einheit**: Auto-Promote ab ≥ 1000 in Basis-Einheit (500 g + 1 kg → "1,5 kg",
+  200 g + 300 g → "500 g", 400 ml + 0,5 l → "900 ml", 0,5 l + 0,8 l → "1,3 l").
+- **Formatter**: `formatQuantity` wechselt app-weit auf `toLocaleString('de-DE', …)` →
+  deutsches Komma als Dezimaltrennzeichen überall, kein Tausender-Grouping.
+- **Check-Stabilität**: der „abgehakt"-State hängt künftig an der Unit-Family (weight / volume /
+  raw-unit), nicht an einer Display-Einheit, damit Hin-und-her-Wechsel zwischen g und kg den
+  Haken nicht verlieren.
+
+## Sektion 1 — Unit-Konsolidierung
+
+### Neue Utility: `src/lib/server/shopping/unit-consolidation.ts`
+
+Zwei reine Funktionen, vollständig getestet per Unit-Tests:
+
+```ts
+export type UnitFamily = 'weight' | 'volume' | string;
+
+const WEIGHT_UNITS = new Set(['g', 'kg']);
+const VOLUME_UNITS = new Set(['ml', 'l']);
+
+export function unitFamily(unit: string | null | undefined): UnitFamily {
+  const u = (unit ?? '').trim().toLowerCase();
+  if (WEIGHT_UNITS.has(u)) return 'weight';
+  if (VOLUME_UNITS.has(u)) return 'volume';
+  return u; // leer bleibt leer → eigene Gruppe
+}
+
+export interface QuantityInUnit {
+  quantity: number | null;
+  unit: string | null;
+}
+
+export function consolidate(rows: QuantityInUnit[]): QuantityInUnit {
+  // Gewicht: in g summieren, ≥1000 → kg, sonst g
+  // Volumen: in ml summieren, ≥1000 → l, sonst ml
+  // Andere: quantity einfach summieren, unit vom ersten Eintrag
+  //   (alle rows einer Gruppe haben dieselbe Family = denselben unit-string)
+  // quantity=null wird als 0 behandelt (z. B. "etwas Salz" + "1 TL Salz" → "1 TL")
+}
+```
+
+**Rundung Promote-Schwelle**: Vergleich passiert auf summierter Basis-Einheit
+(z. B. 1500 g ≥ 1000 → kg). Ergebnis-Rundung: `Math.round(x * 100) / 100` (max.
+zwei Nachkommastellen), die finale Display-Formatierung macht `formatQuantity`.
+
+**Edge-Cases, die expliziter Test-Fall sind**:
+- `500 g + 1 kg` → `{quantity: 1.5, unit: 'kg'}`
+- `200 g + 300 g` → `{quantity: 500, unit: 'g'}`
+- `400 ml + 0.5 l` → `{quantity: 900, unit: 'ml'}`
+- `0.5 l + 0.8 l` → `{quantity: 1.3, unit: 'l'}`
+- `2 Bund + 1 Bund` → `{quantity: 3, unit: 'Bund'}` (unchanged family)
+- `5 Stück + 3 Stück` → `{quantity: 8, unit: 'Stück'}`
+- `null + 1 TL Salz` (eine Menge unbekannt) → `{quantity: 1, unit: 'TL'}`
+- `null + null` → `{quantity: null, unit: '<leer oder erster unit>'}`
+
+### Integration in `listShoppingList()`
+
+Die existierende SQL-Query liefert schon skalierte Mengen pro Zutat-Zeile
+(quantity * servings / servings_default). Änderung:
+
+1. **GROUP BY** der SQL-Query wechselt von `LOWER(TRIM(unit))` auf einen
+   Family-Key (inline per `CASE`):
+
+   ```sql
+   GROUP BY LOWER(TRIM(name)),
+     CASE LOWER(TRIM(unit))
+       WHEN 'g'  THEN 'weight'
+       WHEN 'kg' THEN 'weight'
+       WHEN 'ml' THEN 'volume'
+       WHEN 'l'  THEN 'volume'
+       ELSE LOWER(TRIM(unit))
+     END
+   ```
+
+2. **SUM()** wird nicht mehr blind über quantity gerechnet (500 + 1 ≠ 1500
+   in Basis). Stattdessen liefert SQL pro Gruppe eine Liste der einzelnen
+   `(quantity, unit)`-Paare — z. B. via `json_group_array(json_object('quantity', q, 'unit', u))`.
+   TypeScript ruft dann `consolidate()` pro Zeile auf.
+
+   Alternative: SQL liefert für Familien 'weight' und 'volume' schon die
+   summierten Basis-Werte (via `SUM(q * CASE WHEN unit='kg' THEN 1000 ELSE 1 END)`),
+   für andere Families die unveränderte `SUM(q)`. Spart den json_group_array-Trick,
+   ist aber in SQL hässlich. **Empfehlung**: json_group_array + consolidate in TS —
+   SQL bleibt lesbar, Logik testbar.
+
+3. Der Rückgabewert `ShoppingListItem` bekommt zwei zusätzliche Felder (wenn
+   nicht schon vorhanden):
+   - `quantity: number | null` (finaler Display-Wert)
+   - `unit: string | null` (finale Display-Einheit)
+   - `unitFamilyKey: string` (für den Check-Lookup clientseitig)
+
+## Sektion 2 — Check-Key-Stabilität
+
+Aktuelle Tabelle (aus `013_shopping_list.sql`):
+
+```sql
+CREATE TABLE shopping_cart_check (
+  name_key TEXT NOT NULL,
+  unit_key TEXT NOT NULL,
+  checked_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY (name_key, unit_key)
+);
+```
+
+### Neue Migration `015_shopping_check_family.sql`
+
+```sql
+-- Unit-Key wird zum Family-Key: g/kg → 'weight', ml/l → 'volume', sonst lowercased unit.
+-- Wir migrieren bestehende Einträge damit alte Abhaks gültig bleiben.
+UPDATE shopping_cart_check SET unit_key = 'weight' WHERE unit_key IN ('g', 'kg');
+UPDATE shopping_cart_check SET unit_key = 'volume' WHERE unit_key IN ('ml', 'l');
+
+-- Nach Umetikettierung können Duplikate entstehen (z. B. zwei Einträge mit
+-- 'weight' für dieselbe Zutat). Deduplizieren: jüngsten behalten.
+DELETE FROM shopping_cart_check
+WHERE rowid NOT IN (
+  SELECT MAX(rowid)
+  FROM shopping_cart_check
+  GROUP BY name_key, unit_key
+);
+```
+
+### Code-Änderungen
+
+- `listShoppingList()`: beim Joinen von `shopping_cart_check` mit den aggregierten
+  Zeilen matched jetzt `(name_key, unit_family_key)` statt `(name_key, unit_key)`.
+- `toggleCheck(name, unit, checked)`: speichert/löscht Check mit
+  `unitFamily(unit)` statt raw unit.
+
+## Sektion 3 — Display-Formatter
+
+### `src/lib/quantity-format.ts`
+
+```ts
+export function formatQuantity(q: number | null): string {
+  if (q === null || q === undefined) return '';
+  return q.toLocaleString('de-DE', {
+    maximumFractionDigits: 2,
+    useGrouping: false
+  });
+}
+```
+
+Kleinere Datei, dieselbe Semantik (max. 2 Dezimalen, ganze Zahlen ohne Dezimal),
+plus deutsches Dezimalkomma app-weit.
+
+### Test-Anpassung `tests/unit/quantity-format.test.ts`
+
+Erwartungswerte von `"0.33"` auf `"0,33"` etc. ziehen. Bestehende 5 Tests müssen mit.
+
+## Sektion 4 — Tests
+
+### Neu: `tests/unit/unit-consolidation.test.ts`
+
+Alle Edge-Cases aus Sektion 1 als expect-Assertions. Plus: `unitFamily`-Table-Tests.
+
+### Ergänzung: `tests/integration/shopping-repository.test.ts`
+
+Ein neuer `describe`-Block „konsolidiert über Einheiten":
+- Rezept A mit `500 g Kartoffeln`, Rezept B mit `1 kg Kartoffeln` → eine Zeile
+  `{name: 'kartoffeln', quantity: 1.5, unit: 'kg'}`.
+- Analog Volumen mit ml + l.
+- Gemischte Units wie `2 Bund Petersilie + 1 Bund Petersilie` → eine Zeile `3 Bund`.
+- `5 Stück Eier + 500 g Eier` → **zwei** Zeilen (verschiedene Families).
+- Abhaken einer konsolidierten kg-Zeile → nach Entfernung eines Rezepts (jetzt nur
+  noch 800 g) bleibt die Zeile abgehakt (Family = 'weight' stabil).
+
+### Ergänzung: Migration-Test
+
+Ein kleiner Test ähnlich dem Stil anderer Migration-Tests im Repo, der verifiziert:
+- Alt-Einträge `(milch, 'ml')` und `(milch, 'l')` kollabieren zu einem `(milch, 'volume')`.
+- Unveränderte Einträge wie `(petersilie, 'bund')` bleiben.
+
+## Was explizit NICHT dabei ist (YAGNI)
+
+- **Fuzzy-Name-Matching** (Kartoffel vs Kartoffeln, „Zwiebeln, rot" vs „rote Zwiebeln") —
+  ausgeschlossen, hohe Fehlerrate.
+- **Stück-zu-Gramm-Mappings** (1 Zwiebel ≈ 80 g) — semantisch fraglich, nicht deterministisch.
+- **TL/EL/Tasse-Konvertierung** — Einkauft man nicht in.
+- **User-editierbare Custom-Units** — Overkill für eine Familien-PWA.
+- **UI-Anzeige der zugrundeliegenden Einzelmengen** („1,5 kg — aus 500 g + 1 kg") — wäre
+  nett, aber nicht notwendig für die Hauptfunktion.
+
+## Phase-Gliederung (für die spätere writing-plans-Phase)
+
+Eine Phase reicht aus:
+1. `unit-consolidation.ts` + Unit-Tests
+2. `quantity-format.ts` auf `toLocaleString` umbauen + Tests updaten
+3. Migration `015_shopping_check_family.sql`
+4. `listShoppingList()` integriert Konsolidierung + Check-Join
+5. `toggleCheck()` auf Family-Key umstellen
+6. Integration-Tests
+
+Alles in einer Phase, weil Änderungen eng verzahnt sind (Migration + Repository + Formatter
+müssen zusammen deployt werden, sonst gibt es UI-Inkonsistenzen).

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "kochwas",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "kochwas",
-      "version": "1.4.1",
+      "version": "1.4.2",
       "dependencies": {
         "@google/generative-ai": "^0.24.1",
         "@types/archiver": "^7.0.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "kochwas",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "private": true,
   "type": "module",
   "scripts": {

src/lib/quantity-format.ts

@@ -1,7 +1,7 @@
 export function formatQuantity(q: number | null): string {
   if (q === null || q === undefined) return '';
-  const rounded = Math.round(q);
+  return q.toLocaleString('de-DE', {
-  if (Math.abs(q - rounded) < 0.01) return String(rounded);
+    maximumFractionDigits: 2,
-  // auf max. 2 Nachkommastellen, trailing Nullen raus
+    useGrouping: false
-  return q.toFixed(2).replace(/\.?0+$/, '');
+  });
 }

src/lib/server/db/migrations/015_shopping_check_family.sql

@@ -0,0 +1,14 @@
+-- Konsolidierung: unit_key in shopping_cart_check wird zum Family-Key, damit
+-- Abhaks stabil bleiben wenn Display-Unit zwischen g und kg wechselt.
+-- g/kg → 'weight', ml/l → 'volume', Rest bleibt unveraendert.
+UPDATE shopping_cart_check SET unit_key = 'weight' WHERE LOWER(TRIM(unit_key)) IN ('g', 'kg');
+UPDATE shopping_cart_check SET unit_key = 'volume' WHERE LOWER(TRIM(unit_key)) IN ('ml', 'l');
+
+-- Nach Relabeling koennen Duplikate entstehen (zwei Zeilen mit 'weight' pro
+-- name_key). Juengsten Eintrag behalten.
+DELETE FROM shopping_cart_check
+WHERE rowid NOT IN (
+  SELECT MAX(rowid)
+  FROM shopping_cart_check
+  GROUP BY name_key, unit_key
+);

src/lib/server/shopping/repository.ts

@@ -1,4 +1,5 @@
 import type Database from 'better-sqlite3';
+import { consolidate, unitFamily } from '../unit-consolidation';
 
 // Fallback when a recipe has no servings_default set — matches the default
 // used by RecipeEditor's "new recipe" template.
@@ -80,7 +81,18 @@ export function listShoppingList(
     )
     .all() as ShoppingCartRecipe[];
 
-  const rows = db
+  // SQL aggregates per (name, raw-unit). Family-grouping + consolidation is
+  // done in TypeScript so SQL stays readable and the logic is unit-testable.
+  type RawRow = {
+    name_key: string;
+    unit_key: string;
+    display_name: string;
+    display_unit: string | null;
+    total_quantity: number | null;
+    from_recipes: string;
+  };
+
+  const raw = db
     .prepare(
       `SELECT
          LOWER(TRIM(i.name)) AS name_key,
@@ -88,19 +100,61 @@ export function listShoppingList(
          MIN(i.name) AS display_name,
          MIN(i.unit) AS display_unit,
          SUM(i.quantity * cr.servings * 1.0 / NULLIF(COALESCE(r.servings_default, cr.servings), 0)) AS total_quantity,
-         GROUP_CONCAT(DISTINCT r.title) AS from_recipes,
+         GROUP_CONCAT(DISTINCT r.title) AS from_recipes
-         EXISTS(
-           SELECT 1 FROM shopping_cart_check c
-            WHERE c.name_key = LOWER(TRIM(i.name))
-              AND c.unit_key = LOWER(TRIM(COALESCE(i.unit, '')))
-         ) AS checked
        FROM shopping_cart_recipe cr
        JOIN recipe r ON r.id = cr.recipe_id
        JOIN ingredient i ON i.recipe_id = r.id
-       GROUP BY name_key, unit_key
+       GROUP BY name_key, unit_key`
-       ORDER BY checked ASC, display_name COLLATE NOCASE`
     )
-    .all() as ShoppingListRow[];
+    .all() as RawRow[];
+
+  // Load all checked keys up front
+  const checkedSet = new Set(
+    (
+      db
+        .prepare('SELECT name_key, unit_key FROM shopping_cart_check')
+        .all() as { name_key: string; unit_key: string }[]
+    ).map((c) => `${c.name_key}|${c.unit_key}`)
+  );
+
+  // Group by (name_key, unitFamily(unit_key))
+  const grouped = new Map<string, RawRow[]>();
+  for (const r of raw) {
+    const familyKey = unitFamily(r.unit_key);
+    const key = `${r.name_key}|${familyKey}`;
+    const arr = grouped.get(key) ?? [];
+    arr.push(r);
+    grouped.set(key, arr);
+  }
+
+  const rows: ShoppingListRow[] = [];
+  for (const members of grouped.values()) {
+    const nameKey = members[0].name_key;
+    const familyKey = unitFamily(members[0].unit_key);
+    const consolidated = consolidate(
+      members.map((m) => ({ quantity: m.total_quantity, unit: m.display_unit }))
+    );
+    const displayName = members[0].display_name;
+    const allRecipes = new Set<string>();
+    for (const m of members) {
+      for (const t of m.from_recipes.split(',')) allRecipes.add(t);
+    }
+    rows.push({
+      name_key: nameKey,
+      unit_key: familyKey,
+      display_name: displayName,
+      display_unit: consolidated.unit,
+      total_quantity: consolidated.quantity,
+      from_recipes: [...allRecipes].join(','),
+      checked: checkedSet.has(`${nameKey}|${familyKey}`) ? 1 : 0
+    });
+  }
+
+  // Sort: unchecked first, then alphabetically by display_name
+  rows.sort((a, b) => {
+    if (a.checked !== b.checked) return a.checked - b.checked;
+    return a.display_name.localeCompare(b.display_name, 'de', { sensitivity: 'base' });
+  });
 
   const uncheckedCount = rows.reduce((n, r) => n + (r.checked ? 0 : 1), 0);
   return { recipes, rows, uncheckedCount };
@@ -127,23 +181,33 @@ export function toggleCheck(
 
 export function clearCheckedItems(db: Database.Database): void {
   const tx = db.transaction(() => {
-    // Alle aggregierten Zeilen mit checked-Status holen, pro recipe_id gruppieren
+    // Rohe (name, unit)-Zeilen holen, checked-Status per Family-Key-Lookup
-    // und Rezepte finden, deren Zeilen ALLE abgehakt sind.
+    // in JS entscheiden. Rezepte mit ALLEN Zeilen abgehakt werden raus.
-    const allRows = db
+    const allRowsRaw = db
       .prepare(
         `SELECT
            cr.recipe_id,
            LOWER(TRIM(i.name)) AS name_key,
-           LOWER(TRIM(COALESCE(i.unit, ''))) AS unit_key,
+           LOWER(TRIM(COALESCE(i.unit, ''))) AS unit_key
-           EXISTS(
-             SELECT 1 FROM shopping_cart_check c
-              WHERE c.name_key = LOWER(TRIM(i.name))
-                AND c.unit_key = LOWER(TRIM(COALESCE(i.unit, '')))
-           ) AS checked
          FROM shopping_cart_recipe cr
          JOIN ingredient i ON i.recipe_id = cr.recipe_id`
       )
-      .all() as { recipe_id: number; name_key: string; unit_key: string; checked: 0 | 1 }[];
+      .all() as { recipe_id: number; name_key: string; unit_key: string }[];
+
+    const checkSet = new Set(
+      (
+        db
+          .prepare('SELECT name_key, unit_key FROM shopping_cart_check')
+          .all() as { name_key: string; unit_key: string }[]
+      ).map((c) => `${c.name_key}|${c.unit_key}`)
+    );
+
+    const allRows = allRowsRaw.map((r) => ({
+      recipe_id: r.recipe_id,
+      name_key: r.name_key,
+      unit_key: r.unit_key,
+      checked: checkSet.has(`${r.name_key}|${unitFamily(r.unit_key)}`) ? (1 as const) : (0 as const)
+    }));
 
     const perRecipe = new Map<number, { total: number; checked: number }>();
     for (const r of allRows) {
@@ -160,9 +224,9 @@ export function clearCheckedItems(db: Database.Database): void {
       db.prepare('DELETE FROM shopping_cart_recipe WHERE recipe_id = ?').run(id);
     }
 
-    // Orphan-Checks raeumen: alle Check-Keys, die jetzt in KEINEM Cart-Rezept
+    // Orphan-Checks raeumen: Active-Keys nach (name_key, unitFamily(raw-unit))
-    // mehr vorkommen.
+    // bauen, damit Checks mit family-key korrekt gematcht werden.
-    const activeKeys = db
+    const activeRaw = db
       .prepare(
         `SELECT DISTINCT
            LOWER(TRIM(i.name)) AS name_key,
@@ -171,7 +235,9 @@ export function clearCheckedItems(db: Database.Database): void {
          JOIN ingredient i ON i.recipe_id = cr.recipe_id`
       )
       .all() as { name_key: string; unit_key: string }[];
-    const activeSet = new Set(activeKeys.map((k) => `${k.name_key} ${k.unit_key}`));
+    const activeSet = new Set(
+      activeRaw.map((k) => `${k.name_key}|${unitFamily(k.unit_key)}`)
+    );
     const allChecks = db
       .prepare('SELECT name_key, unit_key FROM shopping_cart_check')
       .all() as { name_key: string; unit_key: string }[];
@@ -179,7 +245,7 @@ export function clearCheckedItems(db: Database.Database): void {
       'DELETE FROM shopping_cart_check WHERE name_key = ? AND unit_key = ?'
     );
     for (const c of allChecks) {
-      if (!activeSet.has(`${c.name_key} ${c.unit_key}`)) {
+      if (!activeSet.has(`${c.name_key}|${c.unit_key}`)) {
         del.run(c.name_key, c.unit_key);
       }
     }

src/lib/server/unit-consolidation.ts

@@ -0,0 +1,66 @@
+export type UnitFamily = 'weight' | 'volume' | string;
+
+const WEIGHT_UNITS = new Set(['g', 'kg']);
+const VOLUME_UNITS = new Set(['ml', 'l']);
+
+export function unitFamily(unit: string | null | undefined): UnitFamily {
+  const u = (unit ?? '').trim().toLowerCase();
+  if (WEIGHT_UNITS.has(u)) return 'weight';
+  if (VOLUME_UNITS.has(u)) return 'volume';
+  return u;
+}
+
+export interface QuantityInUnit {
+  quantity: number | null;
+  unit: string | null;
+}
+
+function round2(n: number): number {
+  return Math.round(n * 100) / 100;
+}
+
+/**
+ * Konsolidiert mehrere {quantity, unit}-Eintraege derselben Unit-Family
+ * zu einer gemeinsamen Menge + Display-Unit.
+ *
+ * - Gewicht (g, kg): summiert in g, promoted bei >=1000 g auf kg.
+ * - Volumen (ml, l): summiert in ml, promoted bei >=1000 ml auf l.
+ * - Andere: summiert quantity ohne Umrechnung, Display-Unit vom ersten
+ *   Eintrag.
+ *
+ * quantity=null wird als 0 behandelt. Wenn ALLE quantities null sind,
+ * ist die Gesamtmenge ebenfalls null.
+ */
+export function consolidate(rows: QuantityInUnit[]): QuantityInUnit {
+  if (rows.length === 0) return { quantity: null, unit: null };
+
+  const family = unitFamily(rows[0].unit);
+  const firstUnit = rows[0].unit;
+
+  const allNull = rows.every((r) => r.quantity === null);
+
+  if (family === 'weight') {
+    if (allNull) return { quantity: null, unit: firstUnit };
+    const grams = rows.reduce((sum, r) => {
+      const q = r.quantity ?? 0;
+      return sum + (r.unit?.toLowerCase().trim() === 'kg' ? q * 1000 : q);
+    }, 0);
+    if (grams >= 1000) return { quantity: round2(grams / 1000), unit: 'kg' };
+    return { quantity: round2(grams), unit: 'g' };
+  }
+
+  if (family === 'volume') {
+    if (allNull) return { quantity: null, unit: firstUnit };
+    const ml = rows.reduce((sum, r) => {
+      const q = r.quantity ?? 0;
+      return sum + (r.unit?.toLowerCase().trim() === 'l' ? q * 1000 : q);
+    }, 0);
+    if (ml >= 1000) return { quantity: round2(ml / 1000), unit: 'l' };
+    return { quantity: round2(ml), unit: 'ml' };
+  }
+
+  // Non-family: summiere quantity direkt
+  if (allNull) return { quantity: null, unit: firstUnit };
+  const sum = rows.reduce((acc, r) => acc + (r.quantity ?? 0), 0);
+  return { quantity: round2(sum), unit: firstUnit };
+}

tests/integration/shopping-repository.test.ts

@@ -123,7 +123,7 @@ describe('listShoppingList aggregation', () => {
     const rows = listShoppingList(db).rows;
     expect(rows).toHaveLength(1);
     expect(rows[0].name_key).toBe('mehl');
-    expect(rows[0].unit_key).toBe('g');
+    expect(rows[0].unit_key).toBe('weight');
     expect(rows[0].total_quantity).toBe(400);
     expect(rows[0].from_recipes).toContain('Carbonara');
     expect(rows[0].from_recipes).toContain('Lasagne');
@@ -201,15 +201,15 @@ describe('toggleCheck', () => {
 
   it('marks a row as checked', () => {
     const { db } = setupOneRowCart();
-    toggleCheck(db, 'mehl', 'g', true);
+    toggleCheck(db, 'mehl', 'weight', true);
     const rows = listShoppingList(db).rows;
     expect(rows[0].checked).toBe(1);
   });
 
   it('unchecks a row when passed false', () => {
     const { db } = setupOneRowCart();
-    toggleCheck(db, 'mehl', 'g', true);
+    toggleCheck(db, 'mehl', 'weight', true);
-    toggleCheck(db, 'mehl', 'g', false);
+    toggleCheck(db, 'mehl', 'weight', false);
     expect(listShoppingList(db).rows[0].checked).toBe(0);
   });
 
@@ -225,7 +225,7 @@ describe('toggleCheck', () => {
     }));
     addRecipeToCart(db, a, null);
     addRecipeToCart(db, b, null);
-    toggleCheck(db, 'mehl', 'g', true);
+    toggleCheck(db, 'mehl', 'weight', true);
     // Rezept A weg, Mehl kommt noch aus B — check bleibt, mit neuer Menge
     removeRecipeFromCart(db, a);
     const rows = listShoppingList(db).rows;
@@ -304,3 +304,178 @@ describe('clearCart', () => {
     expect(anyCheck).toBeUndefined();
   });
 });
+
+describe('toggleCheck — stabil ueber Unit-Family', () => {
+  it('haekchen bleibt erhalten wenn Gesamtmenge von kg auf g faellt', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Kartoffeln', quantity: 500, unit: 'g', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Kartoffeln', quantity: 1, unit: 'kg', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    // Abhaken der konsolidierten 1,5-kg-Zeile via family-key
+    const before = listShoppingList(db).rows[0];
+    toggleCheck(db, before.name_key, before.unit_key, true);
+    expect(listShoppingList(db).rows[0].checked).toBe(1);
+
+    // Ein Rezept rausnehmen → nur noch 500 g, display wechselt auf g
+    removeRecipeFromCart(db, b);
+    const after = listShoppingList(db).rows[0];
+    expect(after.display_unit).toBe('g');
+    expect(after.total_quantity).toBe(500);
+    // Haekchen bleibt: unit_key ist weiterhin 'weight'
+    expect(after.checked).toBe(1);
+  });
+
+  it('clearCheckedItems respektiert family-key beim Orphan-Cleanup', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [
+          { position: 1, name: 'Kartoffeln', quantity: 500, unit: 'g', note: null, raw_text: '', section_heading: null },
+          { position: 2, name: 'Salz', quantity: 1, unit: 'Prise', note: null, raw_text: '', section_heading: null }
+        ]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    const rows = listShoppingList(db).rows;
+    // Alle abhaken
+    for (const r of rows) toggleCheck(db, r.name_key, r.unit_key, true);
+    clearCheckedItems(db);
+    // Das Rezept sollte raus sein
+    expect(listShoppingList(db).recipes).toHaveLength(0);
+    // Check-Tabelle sollte leer sein (keine Orphans)
+    const remaining = (db.prepare('SELECT COUNT(*) AS c FROM shopping_cart_check').get() as { c: number }).c;
+    expect(remaining).toBe(0);
+  });
+});
+
+describe('listShoppingList — Konsolidierung ueber Einheiten', () => {
+  it('fasst 500 g + 1 kg Kartoffeln zu 1,5 kg zusammen', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'Kartoffelsuppe',
+        servings_default: 4,
+        ingredients: [
+          { position: 1, name: 'Kartoffeln', quantity: 500, unit: 'g', note: null, raw_text: '', section_heading: null }
+        ]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'Kartoffelpuffer',
+        servings_default: 4,
+        ingredients: [
+          { position: 1, name: 'Kartoffeln', quantity: 1, unit: 'kg', note: null, raw_text: '', section_heading: null }
+        ]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const snap = listShoppingList(db);
+    const kartoffeln = snap.rows.filter((r) => r.display_name.toLowerCase() === 'kartoffeln');
+    expect(kartoffeln).toHaveLength(1);
+    expect(kartoffeln[0].total_quantity).toBe(1.5);
+    expect(kartoffeln[0].display_unit).toBe('kg');
+  });
+
+  it('kombiniert ml + l korrekt (400 ml + 0,5 l → 900 ml)', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Milch', quantity: 400, unit: 'ml', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Milch', quantity: 0.5, unit: 'l', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const milch = listShoppingList(db).rows.filter((r) => r.display_name.toLowerCase() === 'milch');
+    expect(milch).toHaveLength(1);
+    expect(milch[0].total_quantity).toBe(900);
+    expect(milch[0].display_unit).toBe('ml');
+  });
+
+  it('laesst inkompatible Families getrennt (5 Stueck Eier + 500 g Eier = 2 Zeilen)', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Eier', quantity: 5, unit: 'Stück', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Eier', quantity: 500, unit: 'g', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const eier = listShoppingList(db).rows.filter((r) => r.display_name.toLowerCase() === 'eier');
+    expect(eier).toHaveLength(2);
+  });
+
+  it('summiert gleiche Unit-Family ohne Konversion (2 Bund + 1 Bund → 3 Bund)', () => {
+    const db = openInMemoryForTest();
+    const a = insertRecipe(
+      db,
+      recipe({
+        title: 'R1',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Petersilie', quantity: 2, unit: 'Bund', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    const b = insertRecipe(
+      db,
+      recipe({
+        title: 'R2',
+        servings_default: 4,
+        ingredients: [{ position: 1, name: 'Petersilie', quantity: 1, unit: 'Bund', note: null, raw_text: '', section_heading: null }]
+      })
+    );
+    addRecipeToCart(db, a, null);
+    addRecipeToCart(db, b, null);
+
+    const petersilie = listShoppingList(db).rows.filter((r) => r.display_name.toLowerCase() === 'petersilie');
+    expect(petersilie).toHaveLength(1);
+    expect(petersilie[0].total_quantity).toBe(3);
+    expect(petersilie[0].display_unit?.toLowerCase()).toBe('bund');
+  });
+});

tests/unit/quantity-format.test.ts

@@ -16,10 +16,10 @@ describe('formatQuantity', () => {
   });
 
   it('renders fractional with up to 2 decimals, trailing zeros trimmed', () => {
-    expect(formatQuantity(0.5)).toBe('0.5');
+    expect(formatQuantity(0.5)).toBe('0,5');
-    expect(formatQuantity(0.333333)).toBe('0.33');
+    expect(formatQuantity(0.333333)).toBe('0,33');
-    expect(formatQuantity(1.1)).toBe('1.1');
+    expect(formatQuantity(1.1)).toBe('1,1');
-    expect(formatQuantity(1.1)).toBe('1.1');
+    expect(formatQuantity(1.1)).toBe('1,1');
   });
 
   it('handles zero', () => {

tests/unit/unit-consolidation.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { unitFamily, consolidate } from '../../src/lib/server/unit-consolidation';
+
+describe('unitFamily', () => {
+  it('maps g and kg to weight', () => {
+    expect(unitFamily('g')).toBe('weight');
+    expect(unitFamily('kg')).toBe('weight');
+  });
+  it('maps ml and l to volume', () => {
+    expect(unitFamily('ml')).toBe('volume');
+    expect(unitFamily('l')).toBe('volume');
+  });
+  it('lowercases and trims unknown units', () => {
+    expect(unitFamily(' Bund ')).toBe('bund');
+    expect(unitFamily('TL')).toBe('tl');
+    expect(unitFamily('Stück')).toBe('stück');
+  });
+  it('is case-insensitive for weight/volume', () => {
+    expect(unitFamily('Kg')).toBe('weight');
+    expect(unitFamily('ML')).toBe('volume');
+  });
+  it('returns empty string for null/undefined/empty', () => {
+    expect(unitFamily(null)).toBe('');
+    expect(unitFamily(undefined)).toBe('');
+    expect(unitFamily('')).toBe('');
+    expect(unitFamily('   ')).toBe('');
+  });
+});
+
+describe('consolidate', () => {
+  it('kombiniert 500 g + 1 kg zu 1,5 kg', () => {
+    const out = consolidate([
+      { quantity: 500, unit: 'g' },
+      { quantity: 1, unit: 'kg' }
+    ]);
+    expect(out).toEqual({ quantity: 1.5, unit: 'kg' });
+  });
+
+  it('bleibt bei g wenn Summe < 1 kg', () => {
+    const out = consolidate([
+      { quantity: 200, unit: 'g' },
+      { quantity: 300, unit: 'g' }
+    ]);
+    expect(out).toEqual({ quantity: 500, unit: 'g' });
+  });
+
+  it('promoted bei exakt 1000 g (Boundary)', () => {
+    const out = consolidate([
+      { quantity: 1000, unit: 'g' }
+    ]);
+    expect(out).toEqual({ quantity: 1, unit: 'kg' });
+  });
+
+  it('kombiniert ml + l analog (400 ml + 0,5 l → 900 ml)', () => {
+    const out = consolidate([
+      { quantity: 400, unit: 'ml' },
+      { quantity: 0.5, unit: 'l' }
+    ]);
+    expect(out).toEqual({ quantity: 900, unit: 'ml' });
+  });
+
+  it('promoted zu l ab 1000 ml (0,5 l + 0,8 l → 1,3 l)', () => {
+    const out = consolidate([
+      { quantity: 0.5, unit: 'l' },
+      { quantity: 0.8, unit: 'l' }
+    ]);
+    expect(out).toEqual({ quantity: 1.3, unit: 'l' });
+  });
+
+  it('summiert gleiche nicht-family-units (2 Bund + 1 Bund → 3 Bund)', () => {
+    const out = consolidate([
+      { quantity: 2, unit: 'Bund' },
+      { quantity: 1, unit: 'Bund' }
+    ]);
+    expect(out).toEqual({ quantity: 3, unit: 'Bund' });
+  });
+
+  it('behandelt quantity=null als 0', () => {
+    const out = consolidate([
+      { quantity: null, unit: 'TL' },
+      { quantity: 1, unit: 'TL' }
+    ]);
+    expect(out).toEqual({ quantity: 1, unit: 'TL' });
+  });
+
+  it('gibt null zurueck wenn alle quantities null sind', () => {
+    const out = consolidate([
+      { quantity: null, unit: 'Prise' },
+      { quantity: null, unit: 'Prise' }
+    ]);
+    expect(out).toEqual({ quantity: null, unit: 'Prise' });
+  });
+
+  it('rundet Float-Artefakte auf 2 Dezimalen (0,1 + 0,2 kg → 0,3 kg)', () => {
+    const out = consolidate([
+      { quantity: 0.1, unit: 'kg' },
+      { quantity: 0.2, unit: 'kg' }
+    ]);
+    // 0.1 + 0.2 in kg = 0.3 kg, in g = 300 → promoted? 300 < 1000 → 300 g
+    expect(out).toEqual({ quantity: 300, unit: 'g' });
+  });
+
+  it('nimmt unit vom ersten Eintrag bei unbekannter family', () => {
+    const out = consolidate([{ quantity: 5, unit: 'Stück' }]);
+    expect(out).toEqual({ quantity: 5, unit: 'Stück' });
+  });
+});