@flowselections/logistiek-engine 1.0.238 → 1.0.240

package/db/schema/logistiek-engine.sql

@@ -26892,7 +26892,8 @@ BEGIN
        AND coalesce(o.order_source, '') <> 'floriday'
        AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
        AND coalesce(o.status, '') <> 'geannuleerd'
-       AND public.logistics_order_date(o.delivery_date) >= current_date - 1
+       AND public.logistics_order_date(o.delivery_date::text)::date
+           >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 1  -- type-vast: werkt bij text, date en timestamptz
      GROUP BY o.id, o.order_number, o.customer_id, oi.product_id
      LIMIT greatest(1, p_limit)
   LOOP
@@ -28390,7 +28391,8 @@ BEGIN
          AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
          AND coalesce(o.status, '') <> 'geannuleerd'
          AND oi.quarantined_at IS NULL
-         AND public.logistics_order_date(o.delivery_date) >= current_date - 1
+         AND public.logistics_order_date(o.delivery_date::text)::date
+           >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 1  -- type-vast: werkt bij text, date en timestamptz
     )
     SELECT g.*,
            (SELECT min(x.regelnaam) FROM regels x WHERE x.order_id = g.order_id AND coalesce(x.crates, 0) <= 0) AS onbekende_regel
@@ -28439,7 +28441,7 @@ BEGIN
      SET status = 'niet_printen', reden = 'Fust hoort niet meer bij deze kar of order vervallen.', updated_at = now()
    WHERE p.soort = 'eigen_traysticker' AND p.status IN ('wacht_op_moment', 'geblokkeerd', 'klaar')
      AND NOT (p.bron_id = ANY (v_keep))
-     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE public.logistics_order_date(o.delivery_date) >= current_date - 1);
+     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE public.logistics_order_date(o.delivery_date::text)::date >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 1);
   GET DIAGNOSTICS n_uit = ROW_COUNT;
 
   UPDATE public.logistics_sticker_prints p
@@ -28673,7 +28675,7 @@ BEGIN
       FROM public.orders o
       JOIN public.floriday_salesorders_cache s ON s.floriday_id = o.floriday_sales_order_id AND NOT coalesce(s.is_deleted,false)
       CROSS JOIN LATERAL jsonb_array_elements(CASE WHEN jsonb_typeof(s.data->'additionalServices') = 'array' THEN s.data->'additionalServices' ELSE '[]'::jsonb END) e
-     WHERE o.deleted_at IS NULL AND public.logistics_order_date(o.delivery_date) >= current_date - 2
+     WHERE o.deleted_at IS NULL AND public.logistics_order_date(o.delivery_date::text)::date >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 2
        AND upper(coalesce(e->>'unit','')) = 'LABEL' AND (e->>'numberOfUnits') ~ '^\d+$'
        AND nullif(btrim(coalesce(e->>'stickerId','')),'') IS NOT NULL
        AND NOT EXISTS (SELECT 1 FROM public.floriday_customer_stickers_cache c WHERE c.floriday_id = e->>'stickerId')
@@ -28707,7 +28709,7 @@ BEGIN
       SELECT o.id, o.order_number, nullif(btrim(o.floriday_sales_order_id),'') AS sales
         FROM public.orders o
        WHERE o.deleted_at IS NULL AND nullif(btrim(o.floriday_sales_order_id),'') IS NOT NULL
-         AND public.logistics_order_date(o.delivery_date) >= current_date - 2
+         AND public.logistics_order_date(o.delivery_date::text)::date >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 2
          AND EXISTS (SELECT 1 FROM logistics_active.order_carts oc WHERE oc.order_id = o.id)
        ORDER BY o.delivery_date LIMIT greatest(p_limit,1)
     LOOP
@@ -32233,7 +32235,8 @@ BEGIN
        AND coalesce(o.order_source, '') <> 'floriday'
        AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
        AND coalesce(o.status, '') <> 'geannuleerd'
-       AND public.logistics_order_date(o.delivery_date) >= current_date - 1
+       AND public.logistics_order_date(o.delivery_date::text)::date
+           >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 1  -- type-vast: werkt bij text, date en timestamptz
      GROUP BY o.id, o.order_number, o.customer_id, oi.product_id
      LIMIT greatest(1, p_limit)
   LOOP
@@ -32352,7 +32355,8 @@ BEGIN
          AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
          AND coalesce(o.status, '') <> 'geannuleerd'
          AND oi.quarantined_at IS NULL
-         AND public.logistics_order_date(o.delivery_date) >= current_date - 1
+         AND public.logistics_order_date(o.delivery_date::text)::date
+           >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 1  -- type-vast: werkt bij text, date en timestamptz
     )
     SELECT g.*,
            (SELECT min(x.regelnaam) FROM regels x WHERE x.order_id = g.order_id AND coalesce(x.crates, 0) <= 0) AS onbekende_regel
@@ -32401,7 +32405,7 @@ BEGIN
      SET status = 'niet_printen', reden = 'Fust hoort niet meer bij deze kar of order vervallen.', updated_at = now()
    WHERE p.soort = 'eigen_traysticker' AND p.status IN ('wacht_op_moment', 'geblokkeerd', 'klaar')
      AND NOT (p.bron_id = ANY (v_keep))
-     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE public.logistics_order_date(o.delivery_date) >= current_date - 1);
+     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE public.logistics_order_date(o.delivery_date::text)::date >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 1);
   GET DIAGNOSTICS n_uit = ROW_COUNT;
 
   UPDATE public.logistics_sticker_prints p
@@ -32569,7 +32573,7 @@ BEGIN
       FROM public.orders o
       JOIN public.floriday_salesorders_cache s ON s.floriday_id = o.floriday_sales_order_id AND NOT coalesce(s.is_deleted,false)
       CROSS JOIN LATERAL jsonb_array_elements(CASE WHEN jsonb_typeof(s.data->'additionalServices') = 'array' THEN s.data->'additionalServices' ELSE '[]'::jsonb END) e
-     WHERE o.deleted_at IS NULL AND public.logistics_order_date(o.delivery_date) >= current_date - 2
+     WHERE o.deleted_at IS NULL AND public.logistics_order_date(o.delivery_date::text)::date >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 2
        AND upper(coalesce(e->>'unit','')) = 'LABEL' AND (e->>'numberOfUnits') ~ '^\d+$'
        AND nullif(btrim(coalesce(e->>'stickerId','')),'') IS NOT NULL
        AND NOT EXISTS (SELECT 1 FROM public.floriday_customer_stickers_cache c WHERE c.floriday_id = e->>'stickerId')
@@ -32603,7 +32607,7 @@ BEGIN
       SELECT o.id, o.order_number, nullif(btrim(o.floriday_sales_order_id),'') AS sales
         FROM public.orders o
        WHERE o.deleted_at IS NULL AND nullif(btrim(o.floriday_sales_order_id),'') IS NOT NULL
-         AND public.logistics_order_date(o.delivery_date) >= current_date - 2
+         AND public.logistics_order_date(o.delivery_date::text)::date >= (now() AT TIME ZONE 'Europe/Amsterdam')::date - 2
          AND EXISTS (SELECT 1 FROM logistics_active.order_carts oc WHERE oc.order_id = o.id)
        ORDER BY o.delivery_date LIMIT greatest(p_limit,1)
     LOOP
@@ -41085,3 +41089,2424 @@ BEGIN
   END IF;
   RETURN v_res;
 END $function$;
+
+
+-- ============================================================================
+-- Functies die alleen in de installatiecontrole of in andere functies voorkwamen,
+-- maar hier nergens werden aangemaakt. Volgorde: pickup_at vóór pickup_ts.
+-- ============================================================================
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_at(p_value text, p_delivery_date date)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v text := btrim(coalesce(p_value, ''));
+  v_tz text;
+  m text[];
+  v_parts text[];
+  v_date date;
+  v_time time;
+  v_pick timestamptz;
+  v_sign timestamptz;
+BEGIN
+  IF v = '' THEN
+    RETURN jsonb_build_object('ok', false, 'bron', 'leeg', 'reden', 'Het ophaalmoment ontbreekt.');
+  END IF;
+  v_tz := public.logistics_tz();
+  IF v_tz IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'bron', 'onbekend',
+      'reden', 'De tijdzone van de vestiging ontbreekt. Stel die in bij Werktijden.');
+  END IF;
+
+  -- Momentsleutel van de vervoerder: ophalen n@HH:MM, optioneel aanmelden m@HH:MM.
+  m := regexp_match(v, '^(\d{1,2})@(\d{1,2}:\d{2})(?::\d{2})?(?:\|(\d{1,2})@(\d{1,2}:\d{2})(?::\d{2})?)?$');
+  IF m IS NOT NULL THEN
+    IF p_delivery_date IS NULL THEN
+      RETURN jsonb_build_object('ok', false, 'bron', 'momentsleutel',
+        'reden', 'De leverdatum ontbreekt, daardoor is het ophaalmoment niet te bepalen.');
+    END IF;
+    BEGIN
+      v_pick := (public.logistics_subtract_pick_workdays(p_delivery_date, m[1]::int)::timestamp + m[2]::time) AT TIME ZONE v_tz;
+      IF m[3] IS NOT NULL THEN
+        v_sign := (public.logistics_subtract_pick_workdays(p_delivery_date, m[3]::int)::timestamp + m[4]::time) AT TIME ZONE v_tz;
+      END IF;
+    EXCEPTION WHEN invalid_datetime_format OR datetime_field_overflow THEN
+      RETURN jsonb_build_object('ok', false, 'bron', 'momentsleutel',
+        'reden', 'De tijd in het ophaalmoment is ongeldig.');
+    END;
+    RETURN jsonb_build_object('ok', true, 'bron', 'momentsleutel', 'pickupAt', v_pick, 'signupAt', v_sign);
+  END IF;
+
+  -- "YYYY-MM-DD|HH:MM[|HH:MM]"
+  IF v ~ '^\d{4}-\d{2}-\d{2}\|' THEN
+    v_parts := string_to_array(v, '|');
+    BEGIN
+      v_date := v_parts[1]::date;
+      v_time := NULLIF(btrim(v_parts[2]), '')::time;
+    EXCEPTION WHEN invalid_datetime_format OR datetime_field_overflow THEN
+      RETURN jsonb_build_object('ok', false, 'bron', 'datum_tijd', 'reden', 'De datum of tijd in het ophaalmoment is ongeldig.');
+    END;
+    IF v_time IS NULL THEN
+      RETURN jsonb_build_object('ok', false, 'bron', 'datum_tijd', 'pickupDate', v_date,
+        'reden', 'De ophaaltijd ontbreekt.');
+    END IF;
+    RETURN jsonb_build_object('ok', true, 'bron', 'datum_tijd',
+      'pickupAt', (v_date + v_time) AT TIME ZONE v_tz, 'signupAt', NULL);
+  END IF;
+
+  -- Alleen een datum: geen tijd, dus geen ophaalmoment.
+  IF v ~ '^\d{4}-\d{2}-\d{2}$' THEN
+    RETURN jsonb_build_object('ok', false, 'bron', 'datum', 'pickupDate', v,
+      'reden', 'De ophaaltijd ontbreekt.');
+  END IF;
+
+  -- Volledige tijdstempel.
+  BEGIN
+    v_pick := v::timestamptz;
+    RETURN jsonb_build_object('ok', true, 'bron', 'tijdstempel', 'pickupAt', v_pick, 'signupAt', NULL);
+  EXCEPTION WHEN others THEN
+    RETURN jsonb_build_object('ok', false, 'bron', 'onbekend',
+      'reden', 'Het ophaalmoment heeft een onbekende vorm.');
+  END;
+END;
+$function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_pickup_at(text, date) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_at(text, date) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_ts(p_value text, p_delivery_date date)
+ RETURNS timestamp with time zone
+ LANGUAGE sql
+ STABLE
+ SET search_path TO 'public'
+AS $function$
+  SELECT CASE WHEN coalesce((r->>'ok')::boolean, false) THEN (r->>'pickupAt')::timestamptz END
+    FROM (SELECT public.logistics_pickup_at(p_value, p_delivery_date) AS r) x
+$function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_pickup_ts(text, date) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_ts(text, date) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_herbereken()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  r record;
+  v_tz text := public.logistics_tz();
+  v_today date;
+  v_total int := 0; v_key int := 0; v_dt int := 0; v_fout int := 0; v_err int := 0;
+  v_pk jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_pickup_herbereken');
+  IF v_tz IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'reden', 'De tijdzone van de vestiging ontbreekt. Stel die in bij Werktijden.');
+  END IF;
+  v_today := (now() AT TIME ZONE v_tz)::date;
+  FOR r IN
+    SELECT o.id, o.order_number, o.delivery_date, o.custom_fields->>'pickup_moment' AS pm
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND o.plan_locked_at IS NULL
+       AND nullif(btrim(o.custom_fields->>'pickup_moment'), '') IS NOT NULL
+       AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}'
+       AND left(o.delivery_date, 10)::date >= v_today
+       AND NOT public.logistics_order_geannuleerd(o.id)
+  LOOP
+    v_total := v_total + 1;
+    v_pk := public.logistics_pickup_at(r.pm, left(r.delivery_date, 10)::date);
+    IF NOT coalesce((v_pk->>'ok')::boolean, false) THEN v_fout := v_fout + 1;
+    ELSIF v_pk->>'bron' = 'momentsleutel' THEN v_key := v_key + 1;
+    ELSE v_dt := v_dt + 1; END IF;
+    BEGIN
+      PERFORM public.logistics_plan_enqueue(r.id, 'ophaalmoment herberekend');
+    EXCEPTION WHEN others THEN
+      v_err := v_err + 1;
+      INSERT INTO public.logistics_planner_trace(order_id, message)
+      VALUES (r.id, 'herberekenen ophaalmoment mislukt: ' || SQLERRM);
+    END;
+  END LOOP;
+  RETURN jsonb_build_object('ok', v_err = 0, 'orders', v_total, 'momentsleutel', v_key,
+    'datumTijd', v_dt, 'zonderLeesbaarMoment', v_fout, 'fouten', v_err);
+END;
+$function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_pickup_herbereken() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_herbereken() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.process_logistics_event(p_event_id uuid)
+ RETURNS uuid
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  ev public.logistics_events%ROWTYPE;
+  cfg public.logistics_rule_configs%ROWTYPE;
+  s jsonb; pl jsonb; carriers jsonb; c jsonb; base jsonb; child jsonb;
+  snap_version integer; snap_hash text; warn_list jsonb := '[]'::jsonb;
+  prio integer;
+  checkin_at timestamptz; pickup_at timestamptz;
+  buffer_on boolean; buffer_close timestamptz; buffer_release text;
+  staff integer; total_minutes numeric := 0; pick_minutes integer;
+  start_mode text; reserve_minutes integer := 0; lead_minutes numeric;
+  pick_start timestamptz; pick_end timestamptz; pick_start_raw timestamptz;
+  fill_mode text; scanner text;
+  control_mode text; control_notice timestamptz; control_owner text;
+  shipping_choice text; shipping_at timestamptz;
+  run_id uuid; seq integer := 0; created integer := 0; revised integer := 0;
+  outcome text; default_minutes numeric; keep text[] := ARRAY[]::text[]; stale integer := 0;
+  cancelled_count integer := 0; child_count integer := 0; child_ref text;
+  v_pk_dd date;
+BEGIN
+  SELECT * INTO ev FROM public.logistics_events WHERE id = p_event_id FOR UPDATE;
+  IF NOT FOUND THEN RETURN NULL; END IF;
+
+  pl := COALESCE(ev.payload, '{}'::jsonb);
+  prio := COALESCE(NULLIF(pl ->> 'priority', '')::integer, NULLIF(ev.priority, 0), 0);
+  IF ev.event_type = 'order.changed' AND lower(btrim(coalesce(pl->>'reason', ''))) = 'afgehandeld in floriday' THEN
+    RETURN public.logistics_apply_external_fulfillment(p_event_id);
+  END IF;
+
+  IF ev.event_type IN ('order.cancelled', 'order.canceled') THEN
+    INSERT INTO public.logistics_plan_runs (
+      user_id, order_ref, source_module, strategy_id, trigger, input, status
+    ) VALUES (
+      ev.user_id, ev.order_ref, ev.source_module, ev.strategy_id, ev.event_type, pl, 'ok'
+    ) RETURNING id INTO run_id;
+
+    cancelled_count := public.logistics_cancel_order(
+      ev.order_ref, COALESCE(pl ->> 'reason', 'order geannuleerd'), ev.user_id);
+
+    UPDATE public.logistics_plan_runs
+       SET input = input || jsonb_build_object('tasksCancelled', cancelled_count), updated_at = now()
+     WHERE id = run_id;
+
+    UPDATE public.logistics_events
+       SET status = 'processed', plan_run_id = run_id, error = NULL,
+           processed_at = now(), updated_at = now()
+     WHERE id = p_event_id;
+    RETURN run_id;
+  END IF;
+
+  IF ev.event_type = 'order.split' THEN
+    INSERT INTO public.logistics_plan_runs (
+      user_id, order_ref, source_module, strategy_id, trigger, input, status
+    ) VALUES (
+      ev.user_id, ev.order_ref, ev.source_module, ev.strategy_id, ev.event_type, pl, 'ok'
+    ) RETURNING id INTO run_id;
+
+    cancelled_count := public.logistics_cancel_order(ev.order_ref, 'order gesplitst', ev.user_id);
+
+    FOR child IN SELECT * FROM jsonb_array_elements(COALESCE(pl -> 'children', '[]'::jsonb)) LOOP
+      child_ref := child ->> 'orderRef';
+      CONTINUE WHEN child_ref IS NULL OR child_ref = '';
+      INSERT INTO public.logistics_events (
+        user_id, source_module, event_type, order_ref, strategy_id, shadow, priority,
+        idempotency_key, payload
+      ) VALUES (
+        ev.user_id, ev.source_module, 'order.received', child_ref, ev.strategy_id, ev.shadow, prio,
+        'split:' || ev.id::text || ':' || child_ref,
+        (pl - 'children') || child || jsonb_build_object('splitFrom', ev.order_ref, 'priority', prio)
+      )
+      ON CONFLICT (user_id, idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING;
+      child_count := child_count + 1;
+    END LOOP;
+
+    UPDATE public.logistics_plan_runs
+       SET input = input || jsonb_build_object(
+             'tasksCancelled', cancelled_count, 'childOrders', child_count), updated_at = now()
+     WHERE id = run_id;
+
+    UPDATE public.logistics_events
+       SET status = 'processed', plan_run_id = run_id, error = NULL,
+           processed_at = now(), updated_at = now()
+     WHERE id = p_event_id;
+    RETURN run_id;
+  END IF;
+
+  -- Ophaalmoment: een gewone tijdstempel blijft werken zoals altijd; anders (momentsleutel
+  -- "n@HH:MM|m@HH:MM" of "datum|tijd") lezen via logistics_pickup_ts met de leverdatum.
+  SELECT CASE WHEN coalesce(x.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' THEN left(x.delivery_date, 10)::date END
+    INTO v_pk_dd
+    FROM public.orders x
+   WHERE (x.id = public.logistics_try_uuid(pl ->> 'orderId') OR x.order_number = ev.order_ref)
+     AND x.deleted_at IS NULL
+   ORDER BY (x.id = public.logistics_try_uuid(pl ->> 'orderId')) DESC NULLS LAST, x.created_at DESC
+   LIMIT 1;
+  BEGIN
+    checkin_at := NULLIF(pl ->> 'checkinAt', '')::timestamptz;
+  EXCEPTION WHEN others THEN
+    checkin_at := public.logistics_pickup_ts(pl ->> 'checkinAt', v_pk_dd);
+  END;
+  checkin_at := COALESCE(checkin_at, now());
+  BEGIN
+    pickup_at := NULLIF(pl ->> 'pickupAt', '')::timestamptz;
+  EXCEPTION WHEN others THEN
+    pickup_at := public.logistics_pickup_ts(pl ->> 'pickupAt', v_pk_dd);
+  END;
+  pickup_at := COALESCE(pickup_at, checkin_at);
+  pl := pl || jsonb_build_object('checkinAt', checkin_at, 'pickupAt', pickup_at);
+  carriers := COALESCE(pl -> 'loadCarriers', '[]'::jsonb);
+
+  IF ev.strategy_id IS NOT NULL THEN
+    SELECT * INTO cfg FROM public.logistics_rule_configs
+     WHERE strategy_id = ev.strategy_id AND user_id = ev.user_id
+     ORDER BY is_active DESC, updated_at DESC LIMIT 1;
+  END IF;
+  IF cfg.id IS NULL THEN
+    SELECT * INTO cfg FROM public.logistics_rule_configs
+     WHERE user_id = ev.user_id ORDER BY is_active DESC, updated_at DESC LIMIT 1;
+  END IF;
+
+  BEGIN
+    snap_version := NULLIF(pl ->> 'ruleVersion', '')::integer;
+  EXCEPTION WHEN others THEN snap_version := NULL; END;
+
+  IF snap_version IS NOT NULL AND cfg.id IS NOT NULL THEN
+    s := public.logistics_resolve_settings(ev.user_id, cfg.id, snap_version);
+    IF NOT EXISTS (SELECT 1 FROM public.logistics_rule_versions
+                    WHERE config_id = cfg.id AND user_id = ev.user_id AND version = snap_version) THEN
+      warn_list := warn_list || jsonb_build_array(jsonb_build_object(
+        'code', 'rule_version_not_found', 'requestedVersion', snap_version));
+      snap_version := cfg.current_version;
+    END IF;
+  ELSE
+    s := COALESCE(cfg.settings, '{}'::jsonb);
+    snap_version := cfg.current_version;
+  END IF;
+  s := COALESCE(s, '{}'::jsonb);
+  snap_hash := md5(s::text);
+
+  IF cfg.id IS NULL THEN
+    warn_list := warn_list || jsonb_build_array(jsonb_build_object('code', 'no_rule_config'));
+  END IF;
+
+  INSERT INTO public.logistics_plan_runs (
+    user_id, order_ref, source_module, strategy_id, rule_config_id, rule_version, trigger, input,
+    settings_snapshot, settings_hash
+  ) VALUES (
+    ev.user_id, ev.order_ref, ev.source_module, ev.strategy_id, cfg.id, snap_version, ev.event_type, pl,
+    s, snap_hash
+  ) RETURNING id INTO run_id;
+
+  base := jsonb_build_object(
+    'orderRef', ev.order_ref,
+    'customerRef', pl -> 'customerRef',
+    'checkinAt', checkin_at,
+    'pickupAt', pickup_at,
+    'shadow', ev.shadow,
+    'strategyId', ev.strategy_id,
+    'ruleVersion', snap_version,
+    'settingsHash', snap_hash,
+    'priority', prio,
+    'splitFrom', pl -> 'splitFrom'
+  );
+
+  buffer_on := public.logistics_rule_bool(s, 'order_verwerking', 'buffer_enabled', true);
+  buffer_release := public.logistics_rule_text(s, 'order_verwerking', 'buffer_release', 'auto');
+  IF buffer_on THEN
+    buffer_close := CASE
+      WHEN public.logistics_rule_text(s, 'order_verwerking', 'buffer_close_reference', 'checkin') = 'pick_start'
+       AND public.logistics_pick_start_estimate(s, pl) IS NOT NULL
+      THEN public.logistics_pick_start_estimate(s, pl)
+      ELSE checkin_at
+    END - make_interval(mins =>
+      public.logistics_rule_num(s, 'order_verwerking', 'buffer_close_before_minutes', 60)::int);
+  END IF;
+
+  staff := GREATEST(1, ROUND(public.logistics_rule_num(s, 'pickstations', 'avg_staff', 5))::int);
+  FOR c IN SELECT * FROM jsonb_array_elements(carriers) LOOP
+    default_minutes := CASE c ->> 'type'
+      WHEN 'trolley' THEN 15 WHEN 'danish_container' THEN 15 WHEN 'dense_container' THEN 12
+      WHEN 'pallet' THEN 20 WHEN 'box' THEN 3 WHEN 'loose' THEN 5 ELSE 10 END;
+    total_minutes := total_minutes + GREATEST(0, COALESCE((c ->> 'count')::numeric, 0)) *
+      public.logistics_rule_num(s, 'pickstations', 'pick_time_' || (c ->> 'type'), default_minutes);
+  END LOOP;
+  pick_minutes := CEIL(total_minutes / staff)::int;
+
+  start_mode := public.logistics_rule_text(s, 'order_picken', 'pick_start_mode', 'as_late_as_possible');
+  IF start_mode = 'as_late_as_possible' THEN
+    IF public.logistics_rule_text(s, 'order_picken', 'pick_reserve_type', 'fixed') = 'percentage' THEN
+      reserve_minutes := CEIL(pick_minutes *
+        public.logistics_rule_num(s, 'order_picken', 'pick_reserve_percentage', 20) / 100)::int;
+    ELSE
+      reserve_minutes := public.logistics_rule_num(s, 'order_picken', 'pick_reserve_minutes', 30)::int;
+    END IF;
+  END IF;
+
+  IF start_mode = 'window_before_checkin' THEN
+    IF public.logistics_rule_text(s, 'order_picken', 'pick_window_unit', 'hours') = 'days' THEN
+      lead_minutes := public.logistics_rule_num(s, 'order_picken', 'pick_window_days', 1) * 24 * 60;
+    ELSE
+      lead_minutes := public.logistics_rule_num(s, 'order_picken', 'pick_window_hours', 4) * 60;
+    END IF;
+    pick_start := checkin_at - make_interval(mins => lead_minutes::int);
+    pick_end := checkin_at;
+  ELSE
+    pick_end := pickup_at - make_interval(mins => reserve_minutes);
+    pick_start := pick_end - make_interval(mins => pick_minutes);
+  END IF;
+
+  pick_start_raw := pick_start;
+  pick_start := public.logistics_not_past(pick_start);
+  IF pick_start_raw < now() THEN
+    warn_list := warn_list || jsonb_build_array(jsonb_build_object(
+      'code', 'pick_start_in_past', 'plannedStart', pick_start_raw, 'shiftedTo', pick_start));
+  END IF;
+  IF pick_end IS NOT NULL AND pick_end < pick_start THEN
+    pick_end := pick_start + make_interval(mins => GREATEST(pick_minutes, 1));
+    warn_list := warn_list || jsonb_build_array(jsonb_build_object('code', 'pick_window_too_short'));
+  END IF;
+  IF pickup_at < now() THEN
+    warn_list := warn_list || jsonb_build_array(jsonb_build_object('code', 'pickup_in_past', 'pickupAt', pickup_at));
+  END IF;
+  IF buffer_close IS NOT NULL AND buffer_close < now() THEN
+    warn_list := warn_list || jsonb_build_array(jsonb_build_object('code', 'buffer_close_in_past', 'closeAt', buffer_close));
+    buffer_close := public.logistics_not_past(buffer_close);
+  END IF;
+
+  fill_mode := public.logistics_rule_text(s, 'kar_vullen', 'fill_mode', 'generated');
+  scanner := public.logistics_rule_text(s, 'order_picken', 'scanner', 'required');
+
+  IF buffer_on AND buffer_close IS NOT NULL THEN
+    outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+      cfg.id, snap_version, 'buffer.close', 'verkoop', seq, buffer_close, buffer_close, ev.shadow,
+      base || jsonb_build_object('bufferRef', pl -> 'bufferRef', 'release', buffer_release,
+        'matchCriteria', COALESCE(public.logistics_rule_value(s, 'order_verwerking', 'buffer_match'), '[]'::jsonb)));
+    keep := array_append(keep, 'buffer.close'); seq := seq + 1;
+    IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+  END IF;
+
+  outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+    cfg.id, snap_version, 'stock.reserve', 'voorraad', seq,
+    public.logistics_not_past(COALESCE(buffer_close, pick_start)),
+    public.logistics_not_past(COALESCE(buffer_close, pick_start)), ev.shadow,
+    base || jsonb_build_object('loadCarriers', carriers));
+  keep := array_append(keep, 'stock.reserve'); seq := seq + 1;
+  IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+
+  outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+    cfg.id, snap_version, 'load.compose', 'afhandeling', seq,
+    public.logistics_not_past(pick_start - interval '10 minutes'), pick_start, ev.shadow,
+    base || jsonb_build_object('loadCarriers', carriers, 'fillMode', fill_mode));
+  keep := array_append(keep, 'load.compose'); seq := seq + 1;
+  IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+
+  outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+    cfg.id, snap_version, 'pick.execute', 'pickschermen', seq, pick_start, pick_end, ev.shadow,
+    base || jsonb_build_object(
+      'pickMode', public.logistics_rule_text(s, 'order_picken', 'pick_mode', 'cart'),
+      'pickStartMode', start_mode, 'pickMinutes', pick_minutes, 'staff', staff,
+      'reserveMinutes', reserve_minutes, 'scanner', scanner, 'loadCarriers', carriers));
+  keep := array_append(keep, 'pick.execute'); seq := seq + 1;
+  IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+
+  IF fill_mode = 'manual_scan' THEN
+    outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+      cfg.id, snap_version, 'scan.verify', 'scanners', seq, pick_end, pick_end, ev.shadow,
+      base || jsonb_build_object('reason', 'kar_vullen_manual_scan'));
+    keep := array_append(keep, 'scan.verify'); seq := seq + 1;
+    IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+  ELSIF scanner = 'required' THEN
+    outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+      cfg.id, snap_version, 'scan.verify', 'scanners', seq, pick_start, pick_end, ev.shadow,
+      base || jsonb_build_object('reason', 'pick_scanner_required'));
+    keep := array_append(keep, 'scan.verify'); seq := seq + 1;
+    IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+  END IF;
+
+  control_mode := public.logistics_rule_text(s, 'controle', 'control_mode', 'scanner');
+  IF control_mode <> 'skip' THEN
+    control_notice := public.logistics_not_past(pickup_at - make_interval(mins =>
+      public.logistics_rule_num(s, 'controle', 'control_notice_minutes', 60)::int));
+    control_owner := CASE WHEN control_mode = 'scanner' THEN 'scanners' ELSE 'afhandeling' END;
+
+    outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+      cfg.id, snap_version, 'control.execute', control_owner, seq, control_notice,
+      GREATEST(pickup_at, control_notice), ev.shadow,
+      base || jsonb_build_object('controlMode', control_mode, 'noticeAt', control_notice));
+    keep := array_append(keep, 'control.execute'); seq := seq + 1;
+    IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+
+    IF control_mode = 'paper' THEN
+      outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+        cfg.id, snap_version, 'print.control_note', 'afhandeling', seq, control_notice, control_notice, ev.shadow,
+        base || jsonb_build_object('printItems',
+          public.logistics_rule_text(s, 'controle', 'control_print_items', 'control_note')));
+      keep := array_append(keep, 'print.control_note'); seq := seq + 1;
+      IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+    END IF;
+  END IF;
+
+  IF fill_mode = 'generated' THEN
+    shipping_choice := public.logistics_rule_text(s, 'kar_vullen', 'shipping_note_print_generated', 'with_packing_slip');
+  ELSE
+    shipping_choice := public.logistics_rule_text(s, 'kar_vullen', 'shipping_note_print_manual', 'after_control');
+  END IF;
+  shipping_at := CASE shipping_choice
+    WHEN 'with_packing_slip' THEN pick_start
+    WHEN 'with_control' THEN COALESCE(control_notice, pick_end)
+    WHEN 'after_control' THEN COALESCE(control_notice, pick_end)
+    ELSE pick_end END;
+  shipping_at := public.logistics_not_past(shipping_at);
+
+  outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+    cfg.id, snap_version, 'print.shipping_note', 'afhandeling', seq, shipping_at, shipping_at, ev.shadow,
+    base || jsonb_build_object('moment', shipping_choice));
+  keep := array_append(keep, 'print.shipping_note'); seq := seq + 1;
+  IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+
+  outcome := public.logistics_upsert_task(ev.user_id, run_id, ev.order_ref, pl ->> 'bufferRef', ev.strategy_id,
+    cfg.id, snap_version, 'transport.dispatch', 'afhandeling', seq,
+    public.logistics_not_past(pickup_at), public.logistics_not_past(pickup_at), ev.shadow, base);
+  keep := array_append(keep, 'transport.dispatch');
+  IF outcome = 'created' THEN created := created + 1; ELSIF outcome = 'revised' THEN revised := revised + 1; END IF;
+
+  stale := public.logistics_supersede_stale_tasks(ev.user_id, ev.order_ref, run_id, keep);
+
+  UPDATE public.logistics_tasks
+     SET priority = prio, updated_at = now()
+   WHERE user_id = ev.user_id AND order_ref = ev.order_ref
+     AND status NOT IN ('cancelled','superseded','done')
+     AND priority IS DISTINCT FROM prio;
+
+  UPDATE public.logistics_plan_runs
+     SET tasks_created = created, tasks_revised = revised, status = 'ok',
+         warnings = warn_list,
+         input = input || jsonb_build_object('tasksSuperseded', stale, 'priority', prio),
+         updated_at = now()
+   WHERE id = run_id;
+
+  UPDATE public.logistics_events
+     SET status = 'processed', plan_run_id = run_id, error = NULL, processed_at = now(), updated_at = now()
+   WHERE id = p_event_id;
+
+  RETURN run_id;
+END; $function$;
+REVOKE EXECUTE ON FUNCTION public.process_logistics_event(uuid) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.process_logistics_event(uuid) TO authenticated, service_role;
+
+-- Laatste uitkomst van de stickerstappen in de Engine-ronde (voor de Engine-status).
+CREATE OR REPLACE FUNCTION public.logistics_sticker_sync_status()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_sticker_sync_status');
+  SELECT value INTO v FROM public.logistics_tick_state WHERE key = 'sticker_sync';
+  IF v IS NULL THEN
+    RETURN jsonb_build_object('bekend', false, 'fouten', '[]'::jsonb);
+  END IF;
+  RETURN jsonb_build_object('bekend', true, 'op', v->'at',
+    'fouten', CASE WHEN jsonb_typeof(v->'fouten') = 'array' THEN v->'fouten' ELSE '[]'::jsonb END);
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_sticker_sync_status() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_sticker_sync_status() TO authenticated, service_role;
+
+-- 1.0.238: logistics_trace_event, veilige beladingsovername, leverdatum altijd als datum (Nederlandse tijd), labels installatiecontrole.
+-- Orderverloopregel; mag nooit falen.
+CREATE OR REPLACE FUNCTION public.logistics_trace_event(p_order_id uuid, p_step text, p_status text, p_reason text)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+BEGIN
+  BEGIN
+    PERFORM public.logistics_trace_order_step(p_order_id, p_step, p_step, p_status, NULL, p_reason);
+  EXCEPTION WHEN OTHERS THEN
+    RAISE WARNING 'logistiek-engine: orderverloop schrijven mislukt (order %, stap %): %', p_order_id, p_step, SQLERRM;
+  END;
+END;
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_trace_event(uuid, text, text, text) FROM PUBLIC, anon;
+REVOKE EXECUTE ON FUNCTION public.logistics_trace_event(uuid, text, text, text) FROM authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_trace_event(uuid, text, text, text) TO service_role;
+
+-- Automatische beladingsovername: alleen volledige Floriday-verpakking, nooit op handmatig vastgezette regels,
+-- en elke wijziging met oude en nieuwe belading in het orderverloop.
+CREATE OR REPLACE FUNCTION public.logistics_packing_autofix(p_limit integer DEFAULT 100)
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE r record; v_reden text; v_aantal integer := 0; v_ppc int; v_cpl int; v_lpc int;
+  v_oud record; v_tekst text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_packing_autofix');
+  FOR r IN
+    SELECT d.* FROM public.logistics_packing_deviations d
+     WHERE d.resolved_at IS NULL AND d.scope = 'order_line' AND d.needs_human = false
+       AND d.order_id IS NOT NULL AND d.order_item_id IS NOT NULL
+     ORDER BY d.first_seen_at
+     LIMIT GREATEST(1, LEAST(p_limit, 500))
+  LOOP
+    v_reden := public.logistics_packing_block_reason(r.order_id, r.order_item_id);
+    IF v_reden IS NOT NULL THEN
+      UPDATE public.logistics_packing_deviations SET needs_human = true, human_reason = v_reden WHERE id = r.id;
+      CONTINUE;
+    END IF;
+    v_ppc := nullif(greatest(coalesce((r.floriday_packing->>'pieces_per_package')::numeric, 0), 0), 0)::int;
+    v_cpl := nullif(greatest(coalesce((r.floriday_packing->>'packages_per_layer')::numeric, 0), 0), 0)::int;
+    v_lpc := nullif(greatest(coalesce((r.floriday_packing->>'layers_per_load_carrier')::numeric, 0), 0), 0)::int;
+    IF v_ppc IS NULL OR v_cpl IS NULL OR v_lpc IS NULL THEN
+      UPDATE public.logistics_packing_deviations
+         SET needs_human = true,
+             human_reason = 'Floriday-verpakking onvolledig (0 of leeg = onbekend); niet automatisch overgenomen.'
+       WHERE id = r.id;
+      CONTINUE;
+    END IF;
+    SELECT oi.plants_per_crate, oi.crates_per_layer, oi.layers_per_cart, oi.packing_locked_at
+      INTO v_oud FROM public.order_items oi WHERE oi.id = r.order_item_id FOR UPDATE;
+    IF NOT FOUND THEN CONTINUE; END IF;
+    IF v_oud.packing_locked_at IS NOT NULL THEN
+      -- Handmatig vastgezet: nooit aanpassen; één keer ter beoordeling, niet elke ronde opnieuw.
+      UPDATE public.logistics_packing_deviations
+         SET needs_human = true, human_reason = 'handmatig vastgezet, niet automatisch aangepast'
+       WHERE id = r.id;
+      CONTINUE;
+    END IF;
+    UPDATE public.order_items oi
+       SET plants_per_crate = v_ppc, crates_per_layer = v_cpl, layers_per_cart = v_lpc
+     WHERE oi.id = r.order_item_id AND oi.packing_locked_at IS NULL;
+    IF FOUND THEN
+      v_aantal := v_aantal + 1;
+      v_tekst := format('belading %s/%s/%s → %s/%s/%s (stuks per fust / fusten per laag / lagen per kar), automatisch naar de Floriday-stand',
+        coalesce(v_oud.plants_per_crate::text, '?'), coalesce(v_oud.crates_per_layer::text, '?'), coalesce(v_oud.layers_per_cart::text, '?'),
+        v_ppc, v_cpl, v_lpc);
+      UPDATE public.logistics_packing_deviations
+         SET auto_fixed_at = now(), resolved_at = now(), human_reason = v_tekst
+       WHERE id = r.id;
+      PERFORM public.logistics_trace_event(r.order_id, 'stap:belading_synchronisatie', 'ok', v_tekst);
+    END IF;
+  END LOOP;
+  RETURN v_aantal;
+END;
+$function$;
+CREATE OR REPLACE FUNCTION public.logistics_shipping_note_ensure_accepted(p_order_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 100)
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE r record; v_cart uuid; v_n int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_shipping_note_ensure_accepted');
+  FOR r IN
+    SELECT o.id, o.order_number FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND (p_order_id IS NULL OR o.id = p_order_id OR o.buffer_id = (SELECT buffer_id FROM public.orders WHERE id = p_order_id))
+       AND (nullif(o.floriday_sales_order_id,'') IS NOT NULL OR lower(coalesce(o.order_source,'')) LIKE '%floriday%')
+       AND coalesce(o.status,'') <> 'geannuleerd'
+       AND o.delivery_date ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date - 7
+       AND EXISTS (SELECT 1 FROM unnest(public.logistics_order_cart_ids(o.id)) c
+                    WHERE NOT EXISTS (SELECT 1 FROM public.logistics_slip_shipping_note s WHERE s.cart_id = c))
+     ORDER BY o.updated_at DESC
+     LIMIT greatest(coalesce(p_limit,100),1)
+  LOOP
+    IF NOT coalesce((public.logistics_afhandeling_fulfillment_order(r.id)->>'verstuurd')::boolean, false) THEN CONTINUE; END IF;
+    FOREACH v_cart IN ARRAY public.logistics_order_cart_ids(r.id) LOOP
+      IF EXISTS (SELECT 1 FROM public.logistics_slip_shipping_note s WHERE s.cart_id = v_cart) THEN CONTINUE; END IF;
+      INSERT INTO public.logistics_slip_shipping_note(slip_job_id, cart_id, order_id, order_number, status, batch_key, next_attempt_at)
+      VALUES (v_cart, v_cart, r.id, r.order_number, 'wachtend', 'na-acceptatie:' || r.id::text, now())
+      ON CONFLICT (slip_job_id) DO NOTHING;
+      IF FOUND THEN
+        v_n := v_n + 1;
+        BEGIN
+          PERFORM public.logistics_trace_order_step(r.id, 'stap:verzendbrief', 'verzendbrief klaargezet', 'ok',
+            'na acceptatie belading', 'Floriday accepteerde de belading; verzendbrief voor kar ' || v_cart::text || ' klaargezet.', 'Verzendbrief');
+        EXCEPTION WHEN others THEN NULL; END;
+      END IF;
+    END LOOP;
+  END LOOP;
+  RETURN v_n;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_carrier_status()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE s record; v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_carrier_status');
+  IF auth.uid() IS NULL AND coalesce(auth.role(), '') <> 'service_role' THEN RAISE EXCEPTION 'Niet ingelogd'; END IF;
+  SELECT * INTO s FROM public.logistics_carrier_settings_ensure();
+  WITH open_orders AS (
+    SELECT o.id, o.order_number, o.delivery_date, o.carrier_source, o.carrier_reason, o.created_at
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+  )
+  SELECT jsonb_build_object(
+    'zonderVervoerder', count(*) FILTER (WHERE carrier_source = 'geen' OR (carrier_source IS NULL AND created_at >= s.installed_at)),
+    'viaFavoriet', count(*) FILTER (WHERE carrier_source = 'favoriet'),
+    'nogNietBerekend', count(*) FILTER (WHERE carrier_source IS NULL AND created_at < s.installed_at),
+    'bronOud', count(*) FILTER (WHERE carrier_source = 'oud'),
+    'lijstZonder', coalesce(jsonb_agg(jsonb_build_object('orderId', id, 'orderNumber', order_number, 'deliveryDate', delivery_date,
+        'reden', coalesce(carrier_reason, 'Nog niet berekend.')) ORDER BY delivery_date, order_number)
+        FILTER (WHERE carrier_source = 'geen' OR (carrier_source IS NULL AND created_at >= s.installed_at)), '[]'::jsonb),
+    'lijstFavoriet', coalesce(jsonb_agg(jsonb_build_object('orderId', id, 'orderNumber', order_number, 'deliveryDate', delivery_date,
+        'reden', carrier_reason) ORDER BY delivery_date, order_number) FILTER (WHERE carrier_source = 'favoriet'), '[]'::jsonb))
+    INTO v FROM open_orders;
+  RETURN v || jsonb_build_object('bufferFouten', (SELECT count(*) FROM public.logistics_carrier_events e
+      WHERE e.soort = 'fout' AND e.created_at > now() - interval '7 days'), 'bestaandeOrders', coalesce(s.backfill_existing, false),
+    'installedAt', s.installed_at, 'schakelaarGezetDoor', s.backfill_set_by, 'schakelaarGezetOp', s.backfill_set_at);
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_carrier_preview_existing(p_limit integer DEFAULT 1000)
+ RETURNS TABLE(order_id uuid, order_number text, order_source text, delivery_date text, huidig_custom_carrier text, carrier_id uuid, carrier_name text, carrier_kind text, bron text, reden text, bevroren text)
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_carrier_preview_existing');
+  IF auth.uid() IS NOT NULL AND NOT public.logistics_is_beheer() THEN
+    RAISE EXCEPTION 'Alleen beheer mag deze lijst bekijken.';
+  END IF;
+  RETURN QUERY
+  SELECT o.id, o.order_number, o.order_source, o.delivery_date, o.custom_fields->>'carrier',
+         public.logistics_try_uuid(v.r->>'carrier_id'), v.r->>'carrier_name', v.r->>'carrier_kind', v.r->>'bron', v.r->>'reden',
+         public.logistics_carrier_frozen_reason(o.id)
+    FROM public.orders o
+    CROSS JOIN LATERAL (SELECT public.logistics_resolve_carrier_core(to_jsonb(o), false) AS r) v
+   WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL AND o.carrier_source IS NULL
+     AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+   ORDER BY o.delivery_date, o.order_number
+   LIMIT greatest(1, coalesce(p_limit, 1000));
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE c text; f text; t text; v_fav text; n bigint; s record;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check');
+  -- Alleen bestaan controleren: herberekenen nooit tijdens installatie uitvoeren.
+  FOREACH f IN ARRAY ARRAY['logistics_pickup_at(text,date)',
+      'logistics_pickup_ts(text,date)', 'logistics_pickup_herbereken()'] LOOP
+    onderdeel := 'functie ' || f;
+    ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+    RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY[
+      'f:logistics_try_uuid','f:logistics_tz','f:logistics_is_beheer','f:logistics_buffer_payload','f:logistics_apply_order_buffer',
+      'f:logistics_apply_buffer_decision','f:logistics_rebuffer_pending','f:logistics_departure_calc','f:logistics_own_transport_departure',
+      'f:logistics_order_departure','f:logistics_brief_transport','f:logistics_order_frozen','f:logistics_order_is_frozen',
+      'f:logistics_order_finalize_run','f:run_logistics_tasks_dispatch','f:enqueue_cart_replan_if_unlocked','f:logistics_tick',
+      't:logistics_tick_runs',
+      'f:logistics_belading_bevestig','f:logistics_cart_seq_dubbel','f:logistics_plan_retry_later','f:logistics_own_traysticker_sync',
+      't:logistics_belading_bevestigingen',
+      'f:logistics_sticker_copies','f:logistics_sticker_etiket_status','f:logistics_sticker_order_counts','f:logistics_sticker_sync',
+      'c:logistics_sticker_prints.kopieen_bron',
+      'f:logistics_carrier_settings_ensure','t:logistics_carrier_settings','t:logistics_carrier_recalc_queue','t:logistics_carrier_events',
+      'f:logistics_carrier_status','f:logistics_carrier_set_backfill','f:logistics_carrier_preview_existing','c:control_get_todays_carts.carrier_name',
+      'f:logistics_plan_fail_log'] LOOP
+    onderdeel := CASE substr(f, 3) WHEN 'run_logistics_tasks_dispatch' THEN 'Voorraad: ' WHEN 'enqueue_cart_replan_if_unlocked' THEN 'Verkoop: ' ELSE 'Engine: ' END || substr(f, 3);
+    ok := CASE left(f, 1)
+      WHEN 'f' THEN EXISTS (SELECT 1 FROM pg_proc p WHERE p.pronamespace = 'public'::regnamespace AND p.proname = substr(f, 3))
+      WHEN 't' THEN to_regclass('public.' || substr(f, 3)) IS NOT NULL
+      ELSE CASE WHEN split_part(substr(f, 3), '.', 1) = 'control_get_todays_carts'
+             THEN coalesce(pg_get_function_result(to_regprocedure('public.control_get_todays_carts()')), '') LIKE '%carrier_name%'
+             ELSE EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public'
+                           AND table_name = split_part(substr(f, 3), '.', 1) AND column_name = split_part(substr(f, 3), '.', 2)) END
+    END;
+    toelichting := CASE WHEN ok THEN 'aanwezig' WHEN substr(f, 3) = 'run_logistics_tasks_dispatch' THEN 'ontbreekt: hoort bij Voorraad; werk Voorraad bij' WHEN substr(f, 3) = 'enqueue_cart_replan_if_unlocked' THEN 'ontbreekt: hoort bij Verkoop; werk Verkoop bij' ELSE 'ontbreekt: Engine-migratie (1.0.182 t/m 1.0.188) in dev uitvoeren en via schemasync verspreiden' END;
+    RETURN NEXT;
+  END LOOP;
+  FOREACH c IN ARRAY ARRAY['carrier_id','carrier_source','carrier_reason','carrier_resolved_at','carrier_set_by','carrier_set_at'] LOOP
+    onderdeel := 'orders.' || c;
+    ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='orders' AND column_name=c);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY['logistics_resolve_carrier(uuid)','logistics_resolve_carrier_many(uuid[])',
+      'logistics_resolve_carrier_for_location(uuid,uuid)','logistics_resolve_carrier_for_location_many(uuid[],uuid)',
+      'logistics_resolve_carrier_for_location_many(jsonb)',
+      'logistics_set_order_carrier(uuid,uuid)','logistics_carrier_recalc_run(integer)'] LOOP
+    onderdeel := 'functie ' || f; ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  FOREACH t IN ARRAY ARRAY['orders:trg_logistics_orders_carrier_fill','orders:trg_logistics_orders_carrier_changed',
+      'carriers:trg_logistics_carriers_enqueue','customer_delivery_locations:trg_logistics_locations_enqueue'] LOOP
+    onderdeel := 'trigger ' || split_part(t, ':', 2);
+    ok := EXISTS (SELECT 1 FROM pg_trigger g WHERE g.tgname = split_part(t, ':', 2)
+                   AND g.tgrelid = to_regclass('public.' || split_part(t, ':', 1)));
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  onderdeel := 'minuutronde rekent vervoerders';
+  ok := EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'logistics_tick' AND prosrc LIKE '%logistics_carrier_recalc_run%');
+  toelichting := CASE WHEN ok THEN 'ja' ELSE 'nee' END; RETURN NEXT;
+  FOREACH c IN ARRAY ARRAY['carrier_kind','is_favorite','archived_at','delivery_location_glns'] LOOP
+    onderdeel := 'Afhandeling: carriers.' || c;
+    ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='carriers' AND column_name=c);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Afhandeling' END; RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY['afh_favorite_carrier','afh_city_code','afh_normalize_country','afh_normalize_nl_province'] LOOP
+    onderdeel := 'Afhandeling: ' || f || '()';
+    ok := EXISTS (SELECT 1 FROM pg_proc p WHERE p.pronamespace = 'public'::regnamespace AND p.proname = f);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Afhandeling' END; RETURN NEXT;
+  END LOOP;
+  onderdeel := 'Favoriete vervoerder ingesteld en bruikbaar';
+  IF to_regprocedure('public.afh_favorite_carrier()') IS NULL THEN ok := false; toelichting := 'functie ontbreekt';
+  ELSE
+    BEGIN v_fav := public.logistics_carrier_favorite_id()::text; EXCEPTION WHEN OTHERS THEN v_fav := NULL; END;
+    ok := public.logistics_try_uuid(v_fav) IS NOT NULL AND public.logistics_carrier_skip_reason(public.logistics_try_uuid(v_fav)) IS NULL;
+    toelichting := CASE WHEN ok THEN 'ja' WHEN v_fav IS NULL THEN 'geen favoriet ingesteld (Afhandeling → Vervoerders)'
+                        ELSE public.logistics_carrier_skip_reason(public.logistics_try_uuid(v_fav)) END;
+  END IF;
+  RETURN NEXT;
+  onderdeel := 'Klanten: customers.default_carrier_id';
+  ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='customers' AND column_name='default_carrier_id');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Klanten' END; RETURN NEXT;
+  IF to_regclass('public.logistics_carrier_settings') IS NOT NULL AND to_regclass('public.orders') IS NOT NULL
+     AND EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='orders' AND column_name='carrier_source') THEN
+    SELECT * INTO s FROM public.logistics_carrier_settings_ensure();
+    EXECUTE $q$SELECT count(*) FROM public.orders o
+      WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+        AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+        AND (o.carrier_source = 'geen' OR (o.carrier_source IS NULL AND o.created_at >= $1))$q$ INTO n USING s.installed_at;
+    onderdeel := 'Open orders zonder vervoerder'; ok := n = 0; toelichting := n || ' order(s)'; RETURN NEXT;
+    onderdeel := 'Schakelaar bestaande orders'; ok := true;
+    toelichting := CASE WHEN coalesce(s.backfill_existing, false) THEN 'aan' ELSE 'uit (bestaande orders wachten op akkoord)' END; RETURN NEXT;
+  END IF;
+  SELECT count(*) INTO n FROM public.logistics_trace_events e
+   WHERE e.actor IN ('trg_logistics_plan_order_items', 'trg_logistics_plan_orders')
+     AND e.status = 'mislukt' AND e.created_at > now() - interval '24 hours';
+  onderdeel := 'Mislukte herplanning (laatste 24 uur)'; ok := n = 0;
+  toelichting := CASE WHEN n = 0 THEN 'geen' ELSE n || ' keer; laatste: ' || coalesce((SELECT coalesce(e.order_ref, '?') || ': ' || coalesce(e.error, '') FROM public.logistics_trace_events e
+     WHERE e.actor IN ('trg_logistics_plan_order_items', 'trg_logistics_plan_orders') AND e.status = 'mislukt'
+     ORDER BY e.created_at DESC LIMIT 1), '') END;
+  RETURN NEXT;
+  RETURN QUERY SELECT * FROM public.logistics_install_check_194();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_196();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_197();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_198();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();
+  RETURN QUERY SELECT * FROM public.logistics_overload_check();
+  RETURN QUERY SELECT * FROM public.logistics_check_190();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_productiebon();
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_carrier_enqueue(p_order_ids uuid[], p_reden text)
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE n int;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_carrier_enqueue');
+  PERFORM public.logistics_carrier_settings_ensure();
+  INSERT INTO public.logistics_carrier_recalc_queue AS q (order_id, reden)
+  SELECT o.id, p_reden FROM public.orders o
+    JOIN public.logistics_carrier_settings s ON s.id
+   WHERE o.id = ANY (p_order_ids)
+     AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+     AND o.carrier_source IS DISTINCT FROM 'handmatig'
+     AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+     AND (s.backfill_existing OR o.created_at >= s.installed_at)
+  ON CONFLICT (order_id) DO UPDATE SET processed_at = NULL, queued_at = now(), reden = EXCLUDED.reden;
+  GET DIAGNOSTICS n = ROW_COUNT;
+  RETURN n;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_carrier_recalc_run(p_limit integer DEFAULT 200)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE s record; r record; o jsonb; v jsonb; v_fr text;
+  n_chk int := 0; n_upd int := 0; n_frozen int := 0; n_hand int := 0; n_err int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_carrier_recalc_run');
+  SELECT * INTO s FROM public.logistics_carrier_settings_ensure();
+  IF NOT FOUND THEN RETURN jsonb_build_object('overgeslagen', 'instellingen vervoerder ontbreken'); END IF;
+  FOR r IN
+    WITH kand_open AS (
+      SELECT o.id FROM public.orders o
+       WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+         AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+         AND (s.backfill_existing OR o.created_at >= s.installed_at)
+    ), cand AS (
+      SELECT q.order_id AS id, 1 AS prio, q.queued_at AS t
+        FROM public.logistics_carrier_recalc_queue q JOIN kand_open ON kand_open.id = q.order_id
+       WHERE q.processed_at IS NULL
+      UNION ALL
+      SELECT kand_open.id, 2, coalesce(q.last_checked_at, '-infinity'::timestamptz)
+        FROM kand_open LEFT JOIN public.logistics_carrier_recalc_queue q ON q.order_id = kand_open.id
+       WHERE q.order_id IS NULL OR (q.processed_at IS NOT NULL
+             AND (q.last_checked_at IS NULL OR q.last_checked_at < now() - interval '24 hours'))
+    )
+    SELECT c.id FROM (SELECT DISTINCT ON (cand.id) cand.id, cand.prio, cand.t FROM cand ORDER BY cand.id, cand.prio) c
+     ORDER BY c.prio, c.t LIMIT greatest(1, least(coalesce(p_limit, 200), 1000))
+  LOOP
+    BEGIN
+      SELECT to_jsonb(x) INTO o FROM public.orders x WHERE x.id = r.id FOR UPDATE SKIP LOCKED;
+      IF o IS NULL THEN CONTINUE; END IF;
+      n_chk := n_chk + 1;
+      IF o->>'carrier_source' = 'handmatig' THEN
+        n_hand := n_hand + 1;
+      ELSE
+        v_fr := public.logistics_carrier_frozen_reason(r.id);
+        IF v_fr IS NOT NULL THEN
+          n_frozen := n_frozen + 1;
+        ELSE
+          v := public.logistics_resolve_carrier_core(o, false);
+          IF (v->>'carrier_id') IS DISTINCT FROM (o->>'carrier_id')
+             OR (v->>'bron') IS DISTINCT FROM (o->>'carrier_source')
+             OR (v->>'reden') IS DISTINCT FROM (o->>'carrier_reason') THEN
+            PERFORM set_config('logistics.carrier_writer', 'engine', true);
+            UPDATE public.orders
+               SET carrier_id = public.logistics_try_uuid(v->>'carrier_id'), carrier_source = v->>'bron',
+                   carrier_reason = v->>'reden', carrier_resolved_at = now()
+             WHERE id = r.id;
+            PERFORM set_config('logistics.carrier_writer', '', true);
+            n_upd := n_upd + 1;
+          END IF;
+        END IF;
+      END IF;
+      INSERT INTO public.logistics_carrier_recalc_queue AS q (order_id, reden, processed_at, last_checked_at)
+      VALUES (r.id, 'Vangnet', now(), now())
+      ON CONFLICT (order_id) DO UPDATE SET processed_at = now(), last_checked_at = now();
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM set_config('logistics.carrier_writer', '', true);
+      n_err := n_err + 1;
+    END;
+  END LOOP;
+  RETURN jsonb_build_object('gecontroleerd', n_chk, 'gewijzigd', n_upd, 'bevroren', n_frozen,
+    'handmatig', n_hand, 'fouten', n_err, 'bestaandeOrders', s.backfill_existing);
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_carriers_enqueue_orders()
+ RETURNS trigger
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+BEGIN
+  BEGIN
+    PERFORM public.logistics_carrier_enqueue(ARRAY(
+      SELECT o.id FROM public.orders o
+       WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+         AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date),
+      'Vervoerdersinstellingen gewijzigd');
+  EXCEPTION WHEN OTHERS THEN NULL; END;
+  RETURN NULL;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_scan_delays()
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  rec record;
+  cnt integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_scan_delays');
+  FOR rec IN
+    SELECT o.id
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND o.delivery_date IS NOT NULL
+       AND public.logistics_order_date(o.delivery_date::text) < (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+       AND COALESCE(o.status::text, '') NOT IN ('delivered', 'cancelled', 'Geleverd', 'Geannuleerd')
+       AND NOT EXISTS (
+         SELECT 1 FROM public.logistics_delay_alerts d
+          WHERE d.order_id = o.id AND d.status = 'open')
+     LIMIT 200
+  LOOP
+    PERFORM public.logistics_report_delay(p_order_id => rec.id, p_reason => 'Geplande leverdatum is verstreken', p_expected_date => NULL::date, p_force_customer_email => false);
+    cnt := cnt + 1;
+  END LOOP;
+  RETURN cnt;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_housekeeping()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_resolved int := 0; v_archived int := 0; v_nieuw int := 0; v_alerts int := 0; v_gone int := 0; v_refs text;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_housekeeping');
+  UPDATE public.logistics_plan_queue q SET status='opgelost', error='opgelost: order is al verzonden',
+         claimed_at=NULL, updated_at=now()
+    FROM public.orders o
+   WHERE o.id = q.order_id AND q.status IN ('geblokkeerd','failed')
+     AND o.status IN ('Verzonden','Gereed voor facturatie');
+  GET DIAGNOSTICS v_resolved = ROW_COUNT;
+  UPDATE public.logistics_plan_queue q SET status='opgelost', error='order bestaat niet meer', claimed_at=NULL, updated_at=now()
+   WHERE q.status IN ('geblokkeerd','failed')
+     AND NOT EXISTS (SELECT 1 FROM public.orders o WHERE o.id = q.order_id AND o.deleted_at IS NULL);
+
+  WITH kand AS (
+    SELECT q.id, q.order_id, o.order_number, public.logistics_plan_inhoud_fp(o.id) AS fp
+      FROM public.logistics_plan_queue q JOIN public.orders o ON o.id = q.order_id
+     WHERE q.status IN ('geblokkeerd','failed')
+       AND o.deleted_at IS NULL
+       AND COALESCE(o.status,'') NOT IN ('Verzonden','Gereed voor facturatie','geannuleerd')
+       AND o.delivery_date IS NOT NULL AND public.logistics_order_date(o.delivery_date::text) < (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date - 2
+  ), a AS (
+    UPDATE public.logistics_plan_queue q SET status='gearchiveerd', error=COALESCE(q.error, q.reason),
+           order_fp = k.fp, claimed_at=NULL, updated_at=now()
+      FROM kand k WHERE q.id = k.id
+    RETURNING q.id, k.order_id, k.order_number, k.fp
+  ), nieuw AS (
+    SELECT DISTINCT a.order_number FROM a
+     WHERE NOT EXISTS (SELECT 1 FROM public.logistics_plan_queue e
+                        WHERE e.order_id = a.order_id AND e.status = 'gearchiveerd' AND e.id <> a.id
+                          AND (e.order_fp IS NULL OR e.order_fp = a.fp))
+  )
+  SELECT (SELECT count(*) FROM a), (SELECT count(*) FROM nieuw), (SELECT string_agg(order_number, ', ' ORDER BY order_number) FROM nieuw)
+    INTO v_archived, v_nieuw, v_refs;
+
+  IF v_nieuw > 0 THEN
+    INSERT INTO public.notifications(user_id, title, message, read)
+    SELECT DISTINCT ur.user_id, 'Niet geleverd en gearchiveerd',
+           v_nieuw || ' geblokkeerde order(s) gearchiveerd (leverdatum voorbij): ' || v_refs ||
+           '. Zie Engine › Wachtrij; "Opnieuw aanbieden" zet ze terug.', false
+      FROM public.user_roles ur WHERE ur.role IN ('planner','admin');
+  END IF;
+
+  UPDATE public.logistics_stock_alerts a SET status='resolved', resolved_at=now(),
+         resolution_reason='automatisch opgelost: order verzonden/afgerond', updated_at=now()
+    FROM public.orders o
+   WHERE o.id = a.order_id AND a.status='open'
+     AND o.status IN ('Verzonden','Gereed voor facturatie','geannuleerd');
+  GET DIAGNOSTICS v_alerts = ROW_COUNT;
+
+  UPDATE public.logistics_stock_alerts a SET status='resolved', resolved_at=now(),
+         resolution_reason='order bestaat niet meer', updated_at=now()
+   WHERE a.status='open' AND a.order_id IS NOT NULL
+     AND NOT EXISTS (SELECT 1 FROM public.orders o WHERE o.id = a.order_id AND o.deleted_at IS NULL);
+  GET DIAGNOSTICS v_gone = ROW_COUNT;
+
+  RETURN jsonb_build_object('blokkadesOpgelost', v_resolved, 'gearchiveerd', v_archived, 'gemeld', v_nieuw,
+                            'meldingenOpgelost', v_alerts, 'meldingenZonderOrder', v_gone);
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_plan_overview(p_days integer DEFAULT 2)
+ RETURNS TABLE(order_ref text, delivery_date date, plan_ready boolean, cart_total integer, released boolean, reason text)
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_days integer := GREATEST(COALESCE(p_days, 2), 1);
+  r record;
+  v_status jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_cart_plan_overview');
+  FOR r IN
+    SELECT o.order_number, public.logistics_order_date(o.delivery_date::text) AS ddate
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+       AND public.logistics_order_date(o.delivery_date::text) < (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date + v_days
+     ORDER BY 2, 1
+  LOOP
+    v_status := public.logistics_cart_plan_status(r.order_number);
+    order_ref := r.order_number;
+    delivery_date := r.ddate;
+    plan_ready := COALESCE((v_status->>'ready')::boolean, false);
+    cart_total := COALESCE((v_status->>'cartTotal')::integer, 0);
+    released := COALESCE((v_status->>'released')::boolean, false);
+    reason := v_status->>'reason';
+    RETURN NEXT;
+  END LOOP;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_products_trg()
+ RETURNS trigger
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE r record;
+BEGIN
+  IF NEW.plant_height_cm IS NOT DISTINCT FROM OLD.plant_height_cm
+     AND NEW.fust_type_id IS NOT DISTINCT FROM OLD.fust_type_id
+     AND NEW.plants_per_crate IS NOT DISTINCT FROM OLD.plants_per_crate
+     AND NEW.crates_per_layer IS NOT DISTINCT FROM OLD.crates_per_layer
+     AND NEW.layers_per_cart IS NOT DISTINCT FROM OLD.layers_per_cart
+     AND NEW.is_layer IS NOT DISTINCT FROM OLD.is_layer THEN
+    RETURN NEW;
+  END IF;
+
+  FOR r IN
+    SELECT DISTINCT o.id
+      FROM logistics_active.order_items oi
+      JOIN public.orders o ON o.id = oi.order_id
+     WHERE oi.product_id = NEW.id
+       AND o.deleted_at IS NULL
+       AND COALESCE(o.is_reservation, false) = false
+       AND o.plan_locked_at IS NULL
+       AND (o.delivery_date IS NULL OR public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date)
+  LOOP
+    PERFORM public.logistics_plan_enqueue(r.id, 'product');
+  END LOOP;
+
+  RETURN NEW;
+END;
+$function$;
+
+-- Productiecheck 2026-11-09: versiemarkering, samenvoeggroepen met vaste karren
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$ SELECT '2026-11-09'::text $$;
+REVOKE ALL ON FUNCTION public.logistics_schema_versie() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_schema_versie() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public._logistics_order_karren_vast(p_order_id uuid)
+RETURNS boolean LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT EXISTS (SELECT 1 FROM logistics_active.order_carts oc
+                  WHERE oc.order_id = p_order_id
+                    AND (public.logistics_cart_is_frozen(oc.id)
+                         OR EXISTS (SELECT 1 FROM public.logistics_control_scan s WHERE s.cart_id = oc.id AND s.status <> 'geannuleerd')
+                         OR EXISTS (SELECT 1 FROM public.logistics_slip_shipping_note n
+                                     WHERE n.cart_id = oc.id AND (n.status IN ('in_printwachtrij','geprint') OR n.fulfillment_order_id IS NOT NULL))))
+$$;
+REVOKE ALL ON FUNCTION public._logistics_order_karren_vast(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public._logistics_order_karren_vast(uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public._logistics_buffers_vervallen_herstel(p_order_id uuid)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record; v_groepen uuid[] := '{}'; v_orders int := 0; v_vast int := 0; v_oud text; v_stand jsonb;
+BEGIN
+  v_oud := current_setting('logistics.buffer_writer', true);
+  FOR r IN
+    SELECT o.id, o.order_number, o.buffer_id,
+           CASE WHEN o.deleted_at IS NOT NULL THEN 'verwijderd' ELSE 'geannuleerd' END AS reden
+      FROM public.orders o
+     WHERE o.buffer_id IS NOT NULL AND (p_order_id IS NULL OR o.id = p_order_id)
+       AND public.logistics_order_vervallen(o.id)
+     ORDER BY o.order_number
+     FOR UPDATE OF o
+  LOOP
+    IF public._logistics_order_karren_vast(r.id) THEN
+      v_vast := v_vast + 1;
+      CONTINUE;
+    END IF;
+    PERFORM set_config('logistics.buffer_writer', 'engine', true);
+    UPDATE public.orders SET buffer_id = NULL WHERE id = r.id AND buffer_id = r.buffer_id;
+    INSERT INTO public.logistics_correctie_log (correctie, object_id, omschrijving, oud, nieuw)
+    VALUES ('buffers_geannuleerd', r.id, coalesce(r.order_number, r.id::text) || ' (' || r.reden || ') losgemaakt uit samenvoeggroep',
+            jsonb_build_object('buffer_id', r.buffer_id), jsonb_build_object('buffer_id', NULL));
+    v_orders := v_orders + 1;
+    IF NOT r.buffer_id = ANY (v_groepen) THEN v_groepen := v_groepen || r.buffer_id; END IF;
+  END LOOP;
+  PERFORM set_config('logistics.buffer_writer', coalesce(v_oud, ''), true);
+
+  IF cardinality(v_groepen) > 0 THEN
+    FOR r IN SELECT x.id, x.order_number FROM public.orders x
+              WHERE x.buffer_id = ANY (v_groepen) AND x.deleted_at IS NULL AND x.cancelled_at IS NULL LOOP
+      BEGIN
+        PERFORM public.logistics_plan_enqueue(r.id, 'correctie_buffers_geannuleerd');
+      EXCEPTION WHEN others THEN
+        INSERT INTO public.logistics_correctie_log (correctie, object_id, omschrijving)
+        VALUES ('buffers_geannuleerd_fout', r.id, 'Opnieuw plannen van ' || coalesce(r.order_number, r.id::text) || ' mislukt: ' || SQLERRM);
+      END;
+    END LOOP;
+  END IF;
+  IF p_order_id IS NULL OR cardinality(v_groepen) > 0 THEN
+    SELECT value::jsonb INTO v_stand FROM public.logistics_plan_settings WHERE key = 'buffers_geannuleerd_herstel';
+    v_stand := jsonb_build_object(
+      'totaalGroepen', coalesce((v_stand->>'totaalGroepen')::int, 0) + cardinality(v_groepen),
+      'totaalOrders', coalesce((v_stand->>'totaalOrders')::int, 0) + v_orders,
+      'laatsteGroepen', cardinality(v_groepen), 'laatsteOrders', v_orders,
+      'laatsteOp', CASE WHEN cardinality(v_groepen) > 0 THEN to_jsonb(now()) ELSE coalesce(v_stand->'laatsteOp', 'null'::jsonb) END,
+      'gecontroleerdOp', now());
+    INSERT INTO public.logistics_plan_settings (key, value) VALUES ('buffers_geannuleerd_herstel', v_stand::text)
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  END IF;
+  RETURN jsonb_build_object('groepen', cardinality(v_groepen), 'orders', v_orders, 'blijvenStaan', v_vast);
+END $$;
+REVOKE ALL ON FUNCTION public._logistics_buffers_vervallen_herstel(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public._logistics_buffers_vervallen_herstel(uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_buffers_herstel_status()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_nog int; v_vast int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_buffers_herstel_status');
+  SELECT count(*), count(*) FILTER (WHERE public._logistics_order_karren_vast(o.id))
+    INTO v_nog, v_vast
+    FROM public.orders o WHERE o.buffer_id IS NOT NULL AND public.logistics_order_vervallen(o.id);
+  RETURN jsonb_build_object(
+    'stand', (SELECT value::jsonb FROM public.logistics_plan_settings WHERE key = 'buffers_geannuleerd_herstel'),
+    'nogInGroep', v_nog,
+    'blijvenStaan', v_vast,
+    'wachten', v_nog - v_vast,
+    'fouten', coalesce((SELECT jsonb_agg(jsonb_build_object('op', l.created_at, 'melding', l.omschrijving) ORDER BY l.created_at DESC)
+                          FROM (SELECT * FROM public.logistics_correctie_log WHERE correctie = 'buffers_geannuleerd_fout'
+                                 AND created_at > now() - interval '7 days' ORDER BY created_at DESC LIMIT 5) l), '[]'::jsonb));
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_buffers_herstel_status() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_buffers_herstel_status() TO authenticated, service_role;
+-- Ingehaalde orders (backfill) 2026-11-10
+-- Ingehaalde orders (custom_fields.backfill): nooit kar, reservering, wachtrij of melding.
+CREATE OR REPLACE FUNCTION public.logistics_order_is_backfill(p_order_id uuid)
+ RETURNS boolean
+ LANGUAGE sql
+ STABLE
+ SET search_path TO 'public'
+AS $function$
+  SELECT COALESCE((
+    SELECT CASE
+             WHEN NOT (o.custom_fields ? 'backfill') THEN false
+             WHEN jsonb_typeof(o.custom_fields->'backfill') = 'null' THEN false
+             WHEN jsonb_typeof(o.custom_fields->'backfill') = 'boolean' THEN (o.custom_fields->>'backfill')::boolean
+             ELSE lower(btrim(o.custom_fields->>'backfill')) NOT IN ('', 'false', '0', 'nee', 'no')
+           END
+      FROM public.orders o
+     WHERE o.id = p_order_id AND jsonb_typeof(o.custom_fields) = 'object'), false);
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_order_is_backfill(uuid) FROM PUBLIC;
+REVOKE ALL ON FUNCTION public.logistics_order_is_backfill(uuid) FROM anon;
+GRANT EXECUTE ON FUNCTION public.logistics_order_is_backfill(uuid) TO authenticated, service_role;
+
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_enqueue(p_order_id uuid, p_reason text DEFAULT 'change'::text)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_ok boolean;
+  v_id uuid;
+  v_status text;
+  v_decision text;
+  v_target uuid := p_order_id;
+  v_wacht jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_plan_enqueue');
+  IF COALESCE(current_setting('logistics.merging', true), '') <> '1' THEN
+    BEGIN
+      PERFORM set_config('logistics.merging', '1', true);
+      v_target := COALESCE(public.logistics_merge_floriday_lines(p_order_id), p_order_id);
+      PERFORM set_config('logistics.merging', '0', true);
+    EXCEPTION WHEN OTHERS THEN
+      v_target := p_order_id;
+    END;
+  END IF;
+
+  IF public.logistics_order_is_backfill(v_target) THEN
+    BEGIN
+      PERFORM public.logistics_trace_order_step(
+        v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+        'niet aangemeld', 'Ingehaalde order: krijgt geen kar, reservering of documenten', NULL);
+    EXCEPTION WHEN OTHERS THEN
+      RAISE WARNING 'logistiek-engine: trace ingehaalde order mislukt: %', SQLERRM;
+    END;
+    RETURN;
+  END IF;
+  -- A2: wachttijd na een mislukte indeling respecteren bij automatische meldingen.
+  v_wacht := public.logistics_plan_wachttijd(v_target, p_reason);
+  IF COALESCE((v_wacht->>'wacht')::boolean, false) THEN
+    PERFORM public.logistics_plan_wachttijd_melden(v_target, p_reason, v_wacht);
+    RETURN;
+  END IF;
+
+  SELECT (o.deleted_at IS NULL AND COALESCE(o.is_reservation, false) = false AND o.plan_locked_at IS NULL)
+    INTO v_ok FROM public.orders o WHERE o.id = v_target;
+  -- 1.0.194: geannuleerde orders niet opnieuw indelen (alleen als de kolommen bestaan).
+  IF COALESCE(v_ok, false) AND public.logistics_order_geannuleerd(v_target) THEN
+    PERFORM public.logistics_trace_order_step(
+      v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+      'niet aangemeld', 'Order is geannuleerd', NULL);
+    RETURN;
+  END IF;
+  IF NOT COALESCE(v_ok, false) THEN
+    PERFORM public.logistics_trace_order_step(
+      v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+      'niet aangemeld', 'Order is verwijderd, samengevoegd, een reservering of de indeling staat vast', NULL);
+    RETURN;
+  END IF;
+
+  SELECT q.id, q.status INTO v_id, v_status
+    FROM public.logistics_plan_queue q
+   WHERE q.order_id = v_target
+     AND q.status IN ('pending', 'running', 'geblokkeerd')
+   ORDER BY q.updated_at DESC
+   LIMIT 1
+   FOR UPDATE;
+
+  IF v_id IS NULL THEN
+    BEGIN
+      INSERT INTO public.logistics_plan_queue(order_id, reason) VALUES (v_target, p_reason);
+      v_decision := 'nieuw aangemeld voor indeling';
+    EXCEPTION WHEN unique_violation THEN
+      v_decision := 'stond al in de wachtrij';
+    END;
+  ELSIF v_status = 'geblokkeerd' THEN
+    UPDATE public.logistics_plan_queue
+       SET status = 'pending', attempts = 0, reason = p_reason, reason_code = NULL,
+           error = NULL, claimed_at = NULL, next_attempt_at = now(), updated_at = now()
+     WHERE id = v_id;
+    v_decision := 'blokkade opgeheven, opnieuw aangemeld';
+  ELSE
+    UPDATE public.logistics_plan_queue
+       SET reason = p_reason, next_attempt_at = LEAST(next_attempt_at, now()), updated_at = now()
+     WHERE id = v_id;
+    v_decision := 'opnieuw aangemeld';
+  END IF;
+
+  PERFORM public.logistics_trace_order_step(
+    v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'geslaagd',
+    v_decision, p_reason, 'Karrenindeling');
+
+  PERFORM public.logistics_plan_kick();
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_changed(p_order_id uuid, p_reason text DEFAULT 'wijziging'::text)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_number text; v_ok boolean; v_wacht jsonb; v_fp text;
+  v_reason text := COALESCE(NULLIF(btrim(p_reason), ''), 'wijziging');
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_changed');
+  IF p_order_id IS NULL THEN RETURN; END IF;
+  IF COALESCE(current_setting('logistics.replanning', true), '') = '1' THEN RETURN; END IF;
+  IF public.logistics_order_is_backfill(p_order_id) THEN
+    BEGIN
+      PERFORM public.logistics_trace_order_step(
+        p_order_id, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+        'niet aangemeld', 'Ingehaalde order: krijgt geen kar, reservering of documenten', NULL);
+    EXCEPTION WHEN OTHERS THEN
+      RAISE WARNING 'logistiek-engine: trace ingehaalde order mislukt: %', SQLERRM;
+    END;
+    RETURN;
+  END IF;
+  v_fp := public.logistics_order_fp(p_order_id);
+  IF v_reason = 'order_gewijzigd' THEN
+    IF EXISTS (SELECT 1 FROM public.logistics_order_change_fp f WHERE f.order_id = p_order_id AND f.fp = v_fp) THEN RETURN; END IF;
+    INSERT INTO public.logistics_order_change_fp(order_id, fp, updated_at) VALUES (p_order_id, v_fp, now())
+      ON CONFLICT (order_id) DO UPDATE SET fp = EXCLUDED.fp, updated_at = now();
+  END IF;
+  IF public.logistics_order_afgemeld(p_order_id)
+     OR EXISTS (SELECT 1 FROM public.logistics_shared_cart_peers(p_order_id) p
+                 WHERE public.logistics_order_afgemeld(p.peer_order_id)) THEN
+    IF EXISTS (SELECT 1 FROM public.logistics_order_change_fp f WHERE f.order_id = p_order_id AND f.frozen_fp = v_fp) THEN RETURN; END IF;
+    INSERT INTO public.logistics_order_change_fp(order_id, frozen_fp, updated_at) VALUES (p_order_id, v_fp, now())
+      ON CONFLICT (order_id) DO UPDATE SET frozen_fp = EXCLUDED.frozen_fp, updated_at = now();
+    BEGIN
+      PERFORM public.logistics_trace_order_step(p_order_id, 'stap:orders_combineren', 'wijziging na afmelding', 'overgeslagen',
+        'niet opnieuw ingedeeld', 'order al afgemeld; kar bevroren (' || v_reason || ')', 'Karrenindeling');
+    EXCEPTION WHEN OTHERS THEN NULL; END;
+    RETURN;
+  END IF;
+  v_wacht := public.logistics_plan_wachttijd(p_order_id, v_reason);
+  IF COALESCE((v_wacht->>'wacht')::boolean, false) THEN
+    PERFORM public.logistics_plan_wachttijd_melden(p_order_id, v_reason, v_wacht);
+    RETURN;
+  END IF;
+  SELECT o.order_number, (o.deleted_at IS NULL AND COALESCE(o.is_reservation, false) = false AND o.plan_locked_at IS NULL)
+    INTO v_number, v_ok FROM public.orders o WHERE o.id = p_order_id;
+  IF v_number IS NULL OR NOT COALESCE(v_ok, false) THEN
+    PERFORM public.logistics_plan_enqueue(p_order_id, v_reason); RETURN;
+  END IF;
+  IF public.logistics_order_frozen(p_order_id) THEN
+    BEGIN
+      PERFORM public.logistics_trace_order_step(p_order_id, 'stap:orders_combineren', 'wijziging uit een andere module', 'waarschuwing',
+        'niet opnieuw ingedeeld',
+        'De order is gewijzigd (' || v_reason || '), maar er zijn al geprinte, gescande of gecontroleerde karren. Die blijven staan.',
+        'Karrenindeling');
+    EXCEPTION WHEN OTHERS THEN NULL; END;
+    PERFORM public.logistics_plan_enqueue(p_order_id, v_reason); RETURN;
+  END IF;
+  BEGIN
+    PERFORM set_config('logistics.replanning', '1', true);
+    PERFORM public.logistics_replan_order_journey(v_number, v_reason);
+    PERFORM set_config('logistics.replanning', '0', true);
+  EXCEPTION WHEN OTHERS THEN
+    PERFORM set_config('logistics.replanning', '0', true);
+    PERFORM public.logistics_plan_enqueue(p_order_id, v_reason);
+  END;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_reserved_order_excluded(p_order_id uuid)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE r record; a jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_reserved_order_excluded');
+  SELECT o.deleted_at, o.cancelled_at, o.status INTO r FROM public.orders o WHERE o.id = p_order_id;
+  IF NOT FOUND THEN RETURN false; END IF;
+  IF public.logistics_order_is_backfill(p_order_id) THEN RETURN true; END IF;
+  IF r.deleted_at IS NOT NULL OR r.cancelled_at IS NOT NULL
+     OR lower(coalesce(r.status, '')) IN ('geannuleerd', 'cancelled') THEN
+    RETURN true;
+  END IF;
+  BEGIN
+    a := public.logistics_order_is_archived(p_order_id);
+    RETURN coalesce((a->>'gearchiveerd')::boolean, false);
+  EXCEPTION WHEN OTHERS THEN
+    RETURN false; -- leesfout: order blijft meetellen (fail closed)
+  END;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_stock_trigger()
+ RETURNS trigger
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  oid uuid := COALESCE(NEW.order_id, OLD.order_id);
+BEGIN
+  IF public.logistics_order_is_backfill(oid) THEN RETURN NULL; END IF;
+  BEGIN
+    PERFORM public.logistics_scan_order_stock(oid);
+  EXCEPTION WHEN OTHERS THEN
+    NULL;
+  END;
+  RETURN NULL;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_open_orders_zonder_kar()
+ RETURNS TABLE(order_id uuid, order_number text, delivery_date text, laatste_reden text)
+ LANGUAGE sql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+  SELECT public.logistics_acc_guard('ingelogd', 'logistics_open_orders_zonder_kar');
+  WITH lq AS (
+    SELECT DISTINCT ON (q.order_id) q.order_id, q.status, q.reason_code, q.error
+      FROM public.logistics_plan_queue q ORDER BY q.order_id, q.updated_at DESC
+  )
+  SELECT o.id, o.order_number, o.delivery_date, lq.error
+    FROM public.orders o
+    LEFT JOIN lq ON lq.order_id = o.id
+   WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+     AND lower(coalesce(o.status,'')) NOT IN ('cancelled','geannuleerd','deleted','verwijderd','afgehandeld','completed','delivered','geleverd')
+     AND o.delivery_date ~ '^\d{4}-\d{2}-\d{2}'
+     AND (left(o.delivery_date,10)::date >= public.logistics_local_today()
+          OR (left(o.delivery_date,10)::date >= public.logistics_local_today() - 7 AND o.updated_at > now() - interval '24 hours'))
+     AND EXISTS (SELECT 1 FROM public.order_items oi WHERE oi.order_id = o.id)
+     AND NOT public.logistics_order_is_backfill(o.id)
+     AND NOT coalesce(public.logistics_order_buffer_excluded(o.id), false)
+     AND NOT (coalesce(lq.status,'') IN ('geblokkeerd','pending','running'))
+     AND NOT (coalesce(lq.status,'') = 'gearchiveerd'
+              AND coalesce(lq.reason_code,'') IN ('belading_onwaarschijnlijk','belading_onvolledig','belading_onbekend','artikel_kiezen','ladingdrager_onbekend'))
+     AND NOT EXISTS (SELECT 1 FROM logistics_active.order_carts c WHERE c.order_id = o.id)
+     AND NOT EXISTS (SELECT 1 FROM public.order_items oi
+                       JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+                       JOIN logistics_active.order_carts c ON c.id = ci.cart_id
+                      WHERE oi.order_id = o.id);
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_plan_overview(p_days integer DEFAULT 2)
+ RETURNS TABLE(order_ref text, delivery_date date, plan_ready boolean, cart_total integer, released boolean, reason text)
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_days integer := GREATEST(COALESCE(p_days, 2), 1);
+  r record;
+  v_status jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_cart_plan_overview');
+  FOR r IN
+    SELECT o.order_number, public.logistics_order_date(o.delivery_date::text) AS ddate
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND NOT public.logistics_order_is_backfill(o.id)
+       AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+       AND public.logistics_order_date(o.delivery_date::text) < (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date + v_days
+     ORDER BY 2, 1
+  LOOP
+    v_status := public.logistics_cart_plan_status(r.order_number);
+    order_ref := r.order_number;
+    delivery_date := r.ddate;
+    plan_ready := COALESCE((v_status->>'ready')::boolean, false);
+    cart_total := COALESCE((v_status->>'cartTotal')::integer, 0);
+    released := COALESCE((v_status->>'released')::boolean, false);
+    reason := v_status->>'reason';
+    RETURN NEXT;
+  END LOOP;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$ SELECT '2026-11-10'::text $function$;
+-- ==== migratie 20261110090236
+
+CREATE TABLE IF NOT EXISTS public.logistics_merge_meldingen (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  soort text NOT NULL,
+  order_id uuid,
+  group_key text,
+  aantal integer,
+  fout text,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS logistics_merge_meldingen_created_idx ON public.logistics_merge_meldingen (created_at DESC);
+GRANT ALL ON public.logistics_merge_meldingen TO service_role;
+ALTER TABLE public.logistics_merge_meldingen ENABLE ROW LEVEL SECURITY;
+
+CREATE TABLE IF NOT EXISTS public.logistics_merge_herstel_log (
+  merged_order_id uuid PRIMARY KEY,
+  kept_order_id uuid,
+  categorie text NOT NULL,
+  regels_terug integer NOT NULL DEFAULT 0,
+  hersteld_at timestamptz NOT NULL DEFAULT now(),
+  details jsonb
+);
+GRANT ALL ON public.logistics_merge_herstel_log TO service_role;
+ALTER TABLE public.logistics_merge_herstel_log ENABLE ROW LEVEL SECURITY;
+
+CREATE OR REPLACE FUNCTION public._logistics_merge_melding(p_soort text, p_order_id uuid, p_key text, p_aantal integer, p_fout text)
+RETURNS void LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  INSERT INTO public.logistics_merge_meldingen(soort, order_id, group_key, aantal, fout)
+  VALUES (p_soort, p_order_id, p_key, p_aantal, left(p_fout, 2000));
+  DELETE FROM public.logistics_merge_meldingen WHERE created_at < now() - interval '90 days';
+EXCEPTION WHEN OTHERS THEN
+  RAISE WARNING 'logistiek-engine: samenvoegmelding vastleggen mislukt (%): %', p_soort, SQLERRM;
+END $$;
+REVOKE ALL ON FUNCTION public._logistics_merge_melding(text, uuid, text, integer, text) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public._logistics_merge_melding(text, uuid, text, integer, text) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_merge_key_v2(p_order_id uuid)
+RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE o record; v_dag date; v_loc text; v_pick text; v_ts timestamptz;
+BEGIN
+  SELECT id, customer_id, delivery_date, custom_fields INTO o FROM public.orders WHERE id = p_order_id;
+  IF NOT FOUND OR o.customer_id IS NULL OR o.delivery_date IS NULL THEN RETURN NULL; END IF;
+  BEGIN
+    v_dag := public.logistics_order_date(o.delivery_date::text);
+  EXCEPTION WHEN OTHERS THEN
+    v_dag := NULL;
+  END;
+  IF v_dag IS NULL THEN RETURN NULL; END IF;
+  IF jsonb_typeof(o.custom_fields) IS DISTINCT FROM 'object' THEN RETURN NULL; END IF;
+  v_loc := nullif(btrim(coalesce(o.custom_fields->>'delivery_location_gln', o.custom_fields->>'delivery_location_id',
+                                 o.custom_fields->>'delivery_location', '')), '');
+  v_pick := nullif(btrim(coalesce(o.custom_fields->>'pickup_moment', o.custom_fields->>'pickup_datetime', '')), '');
+  IF v_loc IS NULL OR v_pick IS NULL THEN RETURN NULL; END IF;
+  BEGIN
+    v_ts := public.logistics_pickup_ts(v_pick, v_dag);
+  EXCEPTION WHEN OTHERS THEN
+    v_ts := NULL;
+  END;
+  RETURN concat_ws('|', 'v2', o.customer_id::text, v_dag::text, lower(v_loc), coalesce(v_ts::text, lower(v_pick)));
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_order_merge_key_v2(uuid) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_order_merge_key_v2(uuid) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_mergeable(p_order_id uuid)
+RETURNS boolean LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_ok boolean; v_dag date; v_dd text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_mergeable');
+  SELECT o.delivery_date INTO v_dd FROM public.orders o WHERE o.id = p_order_id;
+  IF NOT FOUND OR v_dd IS NULL THEN RETURN false; END IF;
+  BEGIN
+    v_dag := public.logistics_order_date(v_dd);
+  EXCEPTION WHEN OTHERS THEN
+    RETURN false;
+  END;
+  IF v_dag IS NULL OR v_dag < (now() AT TIME ZONE 'Europe/Amsterdam')::date THEN RETURN false; END IF;
+  SELECT (o.deleted_at IS NULL
+          AND o.cancelled_at IS NULL
+          AND o.plan_locked_at IS NULL
+          AND COALESCE(o.is_reservation, false) = false
+          AND o.order_source = 'floriday'
+          AND lower(btrim(COALESCE(o.status, ''))) NOT IN
+              ('verzonden', 'afgehandeld', 'gereed voor facturatie', 'gepickt', 'geannuleerd',
+               'cancelled', 'canceled', 'annulering', 'gereserveerd')
+          AND NOT public.logistics_order_is_backfill(o.id)
+          AND NOT EXISTS (SELECT 1 FROM logistics_active.order_carts oc WHERE oc.order_id = o.id)
+          AND NOT EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.order_number = o.order_number)
+          AND NOT public.logistics_order_print_actief(o.order_number))
+    INTO v_ok
+    FROM public.orders o
+   WHERE o.id = p_order_id;
+  RETURN COALESCE(v_ok, false);
+EXCEPTION WHEN OTHERS THEN
+  PERFORM public._logistics_merge_melding('fout', p_order_id, NULL, NULL, 'controle samenvoegen: ' || SQLERRM);
+  RETURN false;
+END $$;
+
+CREATE OR REPLACE FUNCTION public.logistics_merge_floriday_lines(p_order_id uuid)
+RETURNS uuid LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_key text; v_keep uuid; v_keepnr text; v_cust uuid; r record;
+  v_moved int; v_logged int; v_total int := 0; v_count int := 0; v_groep int;
+  v_lines text[] := ARRAY[]::text[];
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_merge_floriday_lines');
+  IF p_order_id IS NULL THEN RETURN p_order_id; END IF;
+  IF COALESCE(current_setting('logistics.merge_uit', true), '') = '1' THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_merge_lines_enabled() THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_order_mergeable(p_order_id) THEN RETURN p_order_id; END IF;
+  IF NOT EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = p_order_id) THEN RETURN p_order_id; END IF;
+
+  v_key := public.logistics_order_merge_key_v2(p_order_id);
+  IF v_key IS NULL THEN RETURN p_order_id; END IF;
+  IF NOT pg_try_advisory_xact_lock(hashtext('logistics_merge:' || v_key)) THEN RETURN p_order_id; END IF;
+  SELECT customer_id INTO v_cust FROM public.orders WHERE id = p_order_id;
+
+  CREATE TEMP TABLE IF NOT EXISTS _logistics_merge_groep (id uuid, order_number text, sales text, created_at timestamptz) ON COMMIT DROP;
+  TRUNCATE _logistics_merge_groep;
+  INSERT INTO _logistics_merge_groep
+  SELECT o.id, o.order_number, o.floriday_sales_order_id, o.created_at
+    FROM public.orders o
+   WHERE o.customer_id = v_cust AND o.deleted_at IS NULL AND o.order_source = 'floriday'
+     AND EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = o.id)
+     AND public.logistics_order_merge_key_v2(o.id) = v_key
+     AND public.logistics_order_mergeable(o.id);
+  SELECT count(*) INTO v_groep FROM _logistics_merge_groep;
+  IF v_groep < 2 THEN RETURN p_order_id; END IF;
+  IF v_groep > 20 THEN
+    IF NOT EXISTS (SELECT 1 FROM public.logistics_merge_meldingen m
+                    WHERE m.soort = 'groep_te_groot' AND m.group_key = v_key AND m.created_at > now() - interval '1 day') THEN
+      PERFORM public._logistics_merge_melding('groep_te_groot', p_order_id, v_key, v_groep,
+        v_groep || ' orders met dezelfde klant, leverdag, afleverlocatie en ophaalmoment; niet samengevoegd.');
+    END IF;
+    RETURN p_order_id;
+  END IF;
+
+  SELECT g.id, g.order_number INTO v_keep, v_keepnr FROM _logistics_merge_groep g
+   ORDER BY g.order_number ASC NULLS LAST, g.created_at ASC LIMIT 1;
+
+  FOR r IN SELECT * FROM _logistics_merge_groep g WHERE g.id <> v_keep ORDER BY g.order_number ASC NULLS LAST LOOP
+    BEGIN
+      INSERT INTO public.logistics_order_merge_lines(
+        group_key, from_order_id, from_order_number, to_order_id, to_order_number,
+        order_item_id, product_id, product_name, quantity, source_line_key,
+        sales_order_id, ordered_at, reason)
+      SELECT v_key, r.id, r.order_number, v_keep, v_keepnr,
+             i.id, i.product_id, i.product_name, i.quantity, i.source_line_key,
+             r.sales, r.created_at, 'Zelfde klant, leverdag, afleverlocatie en ophaalmoment'
+        FROM logistics_active.order_items i WHERE i.order_id = r.id;
+      GET DIAGNOSTICS v_logged = ROW_COUNT;
+      UPDATE public.order_items SET order_id = v_keep WHERE order_id = r.id AND quarantined_at IS NULL;
+      GET DIAGNOSTICS v_moved = ROW_COUNT;
+      IF v_moved <> v_logged THEN RAISE EXCEPTION 'aantal verplaatste regels (%) wijkt af van het logboek (%)', v_moved, v_logged; END IF;
+      IF v_moved = 0 THEN RAISE EXCEPTION 'geen regels verplaatst; order blijft staan'; END IF;
+      INSERT INTO public.logistics_order_merges(group_key, kept_order_id, kept_order_number,
+        merged_order_id, merged_order_number, sales_order_id, items_moved)
+      VALUES (v_key, v_keep, v_keepnr, r.id, r.order_number, r.sales, v_moved)
+      ON CONFLICT (merged_order_id) DO NOTHING;
+      UPDATE public.orders SET deleted_at = now(),
+             notes = COALESCE(NULLIF(notes, ''), '')
+                     || CASE WHEN COALESCE(notes, '') = '' THEN '' ELSE E'\n' END
+                     || 'Samengevoegd met ' || COALESCE(v_keepnr, '') || '.',
+             updated_at = now()
+       WHERE id = r.id;
+      v_total := v_total + v_moved; v_count := v_count + 1;
+      v_lines := v_lines || (COALESCE(r.order_number, '') || ': ' || v_moved::text || ' regel(s)');
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public._logistics_merge_melding('fout', r.id, v_key, NULL,
+        'samenvoegen ' || COALESCE(r.order_number, '?') || ' met ' || COALESCE(v_keepnr, '?') || ': ' || SQLERRM);
+    END;
+  END LOOP;
+
+  IF v_count > 0 THEN
+    UPDATE public.orders o SET total = to_char(COALESCE((
+             SELECT SUM(COALESCE(i.quantity, 0) * COALESCE(i.unit_price, 0))
+               FROM logistics_active.order_items i WHERE i.order_id = o.id), 0), 'FM9999999990.00'),
+           updated_at = now()
+     WHERE o.id = v_keep;
+    PERFORM public.logistics_trace_order_step(
+      v_keep, 'stap:bestelregels_samenvoegen', 'bestelregels samenvoegen', 'geslaagd',
+      'samengevoegd tot ' || COALESCE(v_keepnr, 'één bestelling'),
+      v_count::text || ' order(s), ' || v_total::text || ' regel(s) verplaatst: ' || array_to_string(v_lines, '; '),
+      'Orders combineren');
+  END IF;
+  IF EXISTS (SELECT 1 FROM public.orders WHERE id = p_order_id AND deleted_at IS NOT NULL) THEN RETURN v_keep; END IF;
+  RETURN p_order_id;
+EXCEPTION WHEN OTHERS THEN
+  PERFORM public._logistics_merge_melding('fout', p_order_id, v_key, NULL, 'samenvoegen: ' || SQLERRM);
+  RETURN p_order_id;
+END $$;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_enqueue(p_order_id uuid, p_reason text DEFAULT 'change'::text)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_ok boolean;
+  v_id uuid;
+  v_status text;
+  v_decision text;
+  v_target uuid := p_order_id;
+  v_wacht jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_plan_enqueue');
+  IF COALESCE(current_setting('logistics.plan_uit', true), '') = '1' THEN RETURN; END IF;
+  IF COALESCE(current_setting('logistics.merging', true), '') <> '1' THEN
+    BEGIN
+      PERFORM set_config('logistics.merging', '1', true);
+      v_target := COALESCE(public.logistics_merge_floriday_lines(p_order_id), p_order_id);
+      PERFORM set_config('logistics.merging', '0', true);
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public._logistics_merge_melding('fout', p_order_id, NULL, NULL, 'samenvoegen bij aanmelden: ' || SQLERRM);
+      v_target := p_order_id;
+    END;
+  END IF;
+
+  IF public.logistics_order_is_backfill(v_target) THEN
+    BEGIN
+      PERFORM public.logistics_trace_order_step(
+        v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+        'niet aangemeld', 'Ingehaalde order: krijgt geen kar, reservering of documenten', NULL);
+    EXCEPTION WHEN OTHERS THEN
+      RAISE WARNING 'logistiek-engine: trace ingehaalde order mislukt: %', SQLERRM;
+    END;
+    RETURN;
+  END IF;
+  v_wacht := public.logistics_plan_wachttijd(v_target, p_reason);
+  IF COALESCE((v_wacht->>'wacht')::boolean, false) THEN
+    PERFORM public.logistics_plan_wachttijd_melden(v_target, p_reason, v_wacht);
+    RETURN;
+  END IF;
+
+  SELECT (o.deleted_at IS NULL AND COALESCE(o.is_reservation, false) = false AND o.plan_locked_at IS NULL)
+    INTO v_ok FROM public.orders o WHERE o.id = v_target;
+  IF COALESCE(v_ok, false) AND public.logistics_order_geannuleerd(v_target) THEN
+    PERFORM public.logistics_trace_order_step(
+      v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+      'niet aangemeld', 'Order is geannuleerd', NULL);
+    RETURN;
+  END IF;
+  IF NOT COALESCE(v_ok, false) THEN
+    PERFORM public.logistics_trace_order_step(
+      v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+      'niet aangemeld', 'Order is verwijderd, samengevoegd, een reservering of de indeling staat vast', NULL);
+    RETURN;
+  END IF;
+
+  SELECT q.id, q.status INTO v_id, v_status
+    FROM public.logistics_plan_queue q
+   WHERE q.order_id = v_target
+     AND q.status IN ('pending', 'running', 'geblokkeerd')
+   ORDER BY q.updated_at DESC
+   LIMIT 1
+   FOR UPDATE;
+
+  IF v_id IS NULL THEN
+    BEGIN
+      INSERT INTO public.logistics_plan_queue(order_id, reason) VALUES (v_target, p_reason);
+      v_decision := 'nieuw aangemeld voor indeling';
+    EXCEPTION WHEN unique_violation THEN
+      v_decision := 'stond al in de wachtrij';
+    END;
+  ELSIF v_status = 'geblokkeerd' THEN
+    UPDATE public.logistics_plan_queue
+       SET status = 'pending', attempts = 0, reason = p_reason, reason_code = NULL,
+           error = NULL, claimed_at = NULL, next_attempt_at = now(), updated_at = now()
+     WHERE id = v_id;
+    v_decision := 'blokkade opgeheven, opnieuw aangemeld';
+  ELSE
+    UPDATE public.logistics_plan_queue
+       SET reason = p_reason, next_attempt_at = LEAST(next_attempt_at, now()), updated_at = now()
+     WHERE id = v_id;
+    v_decision := 'opnieuw aangemeld';
+  END IF;
+
+  PERFORM public.logistics_trace_order_step(
+    v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'geslaagd',
+    v_decision, p_reason, 'Karrenindeling');
+
+  PERFORM public.logistics_plan_kick();
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public._logistics_merge_herstel_kandidaten()
+RETURNS TABLE(merged_order_id uuid, merged_order_number text, kept_order_id uuid, kept_order_number text,
+              categorie text, regels integer, status text, leverdag date, reden text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record; v_dag date; v_onzeker text; v_vandaag date := (now() AT TIME ZONE 'Europe/Amsterdam')::date;
+BEGIN
+  FOR r IN
+    SELECT m.merged_order_id, m.merged_order_number, m.kept_order_id, m.kept_order_number, m.items_moved,
+           o.status, o.delivery_date
+      FROM public.logistics_order_merges m
+      JOIN public.orders o ON o.id = m.merged_order_id
+     WHERE o.deleted_at IS NOT NULL
+       AND NOT EXISTS (SELECT 1 FROM public.logistics_merge_herstel_log h WHERE h.merged_order_id = m.merged_order_id)
+  LOOP
+    v_onzeker := NULL;
+    BEGIN
+      v_dag := public.logistics_order_date(r.delivery_date::text);
+    EXCEPTION WHEN OTHERS THEN
+      v_dag := NULL;
+    END;
+    IF v_dag IS NULL THEN v_onzeker := 'leverdag onleesbaar'; END IF;
+    IF v_onzeker IS NULL AND (SELECT count(*) FROM public.logistics_order_merge_lines l WHERE l.from_order_id = r.merged_order_id)
+                             <> COALESCE(r.items_moved, 0) THEN
+      v_onzeker := 'logboek en aantal verplaatste regels verschillen';
+    END IF;
+    IF v_onzeker IS NULL AND EXISTS (
+         SELECT 1 FROM public.logistics_order_merge_lines l
+          LEFT JOIN public.order_items i ON i.id = l.order_item_id
+          WHERE l.from_order_id = r.merged_order_id
+            AND (i.id IS NULL OR i.order_id IS DISTINCT FROM r.kept_order_id)) THEN
+      v_onzeker := 'regel staat niet meer bij de verzamelorder';
+    END IF;
+    IF v_onzeker IS NULL AND EXISTS (
+         SELECT 1 FROM public.logistics_order_merge_lines l
+          WHERE l.from_order_id = r.merged_order_id
+            AND EXISTS (SELECT 1 FROM public.logistics_order_merge_lines l2
+                         WHERE l2.order_item_id = l.order_item_id AND l2.from_order_id <> l.from_order_id)) THEN
+      v_onzeker := 'regel komt bij meer dan één order vandaan';
+    END IF;
+    merged_order_id := r.merged_order_id; merged_order_number := r.merged_order_number;
+    kept_order_id := r.kept_order_id; kept_order_number := r.kept_order_number;
+    regels := COALESCE(r.items_moved, 0); status := r.status; leverdag := v_dag; reden := v_onzeker;
+    categorie := CASE
+      WHEN v_onzeker IS NOT NULL THEN 'onzeker'
+      WHEN v_dag < v_vandaag THEN 'verleden'
+      WHEN lower(btrim(COALESCE(r.status, ''))) = 'nog te picken' THEN 'urgent'
+      ELSE 'toekomst_overig' END;
+    RETURN NEXT;
+  END LOOP;
+END $$;
+REVOKE ALL ON FUNCTION public._logistics_merge_herstel_kandidaten() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public._logistics_merge_herstel_kandidaten() TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_merge_herstel_voorbeeld()
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_merge_herstel_voorbeeld');
+  SELECT jsonb_object_agg(c.categorie, jsonb_build_object('orders', c.n, 'regelsTerug', c.regels,
+           'voorbeelden', to_jsonb(c.vb[1:10]))) INTO v
+    FROM (SELECT k.categorie, count(*) n, COALESCE(sum(k.regels), 0) regels,
+                 array_agg(jsonb_build_object('order', k.merged_order_number, 'verzamelorder', k.kept_order_number,
+                    'status', k.status, 'leverdag', k.leverdag, 'regels', k.regels, 'reden', k.reden)
+                    ORDER BY k.leverdag DESC NULLS LAST, k.merged_order_number) vb
+            FROM public._logistics_merge_herstel_kandidaten() k GROUP BY k.categorie) c;
+  RETURN jsonb_build_object(
+    'categorieen', COALESCE(v, '{}'::jsonb),
+    'alHersteld', (SELECT COALESCE(jsonb_object_agg(categorie, n), '{}'::jsonb)
+                     FROM (SELECT categorie, count(*) n FROM public.logistics_merge_herstel_log GROUP BY 1) h),
+    'volgorde', jsonb_build_array('urgent', 'toekomst_overig', 'verleden'),
+    'toelichting', 'onzeker wordt nooit automatisch hersteld');
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_merge_herstel_voorbeeld() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_merge_herstel_voorbeeld() TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_merge_herstel_uitvoeren(p_categorie text, p_max integer DEFAULT 200)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  k record; v_terug int; v_ok int := 0; v_regels int := 0; v_fouten jsonb := '[]'::jsonb;
+  v_kept uuid[] := ARRAY[]::uuid[]; v_opgeruimd int := 0; v_rest int;
+  v_notes_re text := E'\\n?Samengevoegd met [^\\n]*\\.';
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_merge_herstel_uitvoeren');
+  IF p_categorie IS NULL OR p_categorie NOT IN ('urgent', 'toekomst_overig', 'verleden') THEN
+    RAISE EXCEPTION 'Onbekende categorie %; kies urgent, toekomst_overig of verleden.', p_categorie;
+  END IF;
+  PERFORM set_config('logistics.merge_uit', '1', true);
+  PERFORM set_config('logistics.merging', '1', true);
+
+  FOR k IN SELECT * FROM public._logistics_merge_herstel_kandidaten() c
+            WHERE c.categorie = p_categorie
+            ORDER BY c.leverdag, c.merged_order_number
+            LIMIT greatest(least(COALESCE(p_max, 200), 2000), 1)
+  LOOP
+    BEGIN
+      PERFORM set_config('logistics.plan_uit', CASE WHEN p_categorie = 'urgent' THEN '0' ELSE '1' END, true);
+      UPDATE public.orders o
+         SET deleted_at = NULL,
+             notes = NULLIF(btrim(regexp_replace(COALESCE(o.notes, ''), v_notes_re, '', 'g')), ''),
+             custom_fields = CASE WHEN p_categorie = 'verleden'
+                               THEN (CASE WHEN jsonb_typeof(o.custom_fields) = 'object' THEN o.custom_fields ELSE '{}'::jsonb END)
+                                    || jsonb_build_object('backfill', jsonb_build_object('categorie', 'herstel_samenvoegen', 'at', now()))
+                               ELSE o.custom_fields END,
+             updated_at = now()
+       WHERE o.id = k.merged_order_id AND o.deleted_at IS NOT NULL;
+      IF NOT FOUND THEN RAISE EXCEPTION 'order is al actief'; END IF;
+
+      UPDATE public.order_items i SET order_id = k.merged_order_id
+        FROM public.logistics_order_merge_lines l
+       WHERE l.from_order_id = k.merged_order_id AND l.order_item_id = i.id AND i.order_id = k.kept_order_id;
+      GET DIAGNOSTICS v_terug = ROW_COUNT;
+      IF v_terug <> k.regels THEN
+        RAISE EXCEPTION '% van % regels teruggezet; niets gewijzigd', v_terug, k.regels;
+      END IF;
+
+      UPDATE public.orders o SET total = to_char(COALESCE((
+               SELECT SUM(COALESCE(i.quantity, 0) * COALESCE(i.unit_price, 0))
+                 FROM logistics_active.order_items i WHERE i.order_id = o.id), 0), 'FM9999999990.00'),
+             updated_at = now()
+       WHERE o.id IN (k.merged_order_id, k.kept_order_id);
+
+      INSERT INTO public.logistics_merge_herstel_log(merged_order_id, kept_order_id, categorie, regels_terug, details)
+      VALUES (k.merged_order_id, k.kept_order_id, p_categorie, v_terug,
+              jsonb_build_object('order', k.merged_order_number, 'verzamelorder', k.kept_order_number, 'status', k.status));
+
+      IF p_categorie = 'urgent' THEN
+        PERFORM public.logistics_plan_enqueue(k.merged_order_id, 'herstel_samenvoegen');
+      END IF;
+      PERFORM set_config('logistics.plan_uit', '0', true);
+      v_ok := v_ok + 1; v_regels := v_regels + v_terug;
+      IF NOT (k.kept_order_id = ANY (v_kept)) THEN v_kept := v_kept || k.kept_order_id; END IF;
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM set_config('logistics.plan_uit', '0', true);
+      v_fouten := v_fouten || jsonb_build_object('order', k.merged_order_number, 'fout', SQLERRM);
+      PERFORM public._logistics_merge_melding('herstel_fout', k.merged_order_id, NULL, NULL,
+        'herstel ' || COALESCE(k.merged_order_number, '?') || ': ' || SQLERRM);
+    END;
+  END LOOP;
+
+  WITH weg AS (
+    DELETE FROM public.logistics_plan_queue q
+     USING public.orders o
+     WHERE q.order_id = o.id AND q.order_id = ANY (v_kept)
+       AND q.status IN ('pending', 'geblokkeerd')
+       AND (lower(btrim(COALESCE(o.status, ''))) <> 'nog te picken'
+            OR public.logistics_order_date(o.delivery_date::text) < (now() AT TIME ZONE 'Europe/Amsterdam')::date)
+    RETURNING q.id)
+  SELECT count(*) INTO v_opgeruimd FROM weg;
+
+  PERFORM set_config('logistics.merge_uit', '0', true);
+  PERFORM set_config('logistics.merging', '0', true);
+  SELECT count(*) INTO v_rest FROM public._logistics_merge_herstel_kandidaten() c WHERE c.categorie = p_categorie;
+  RETURN jsonb_build_object('categorie', p_categorie, 'hersteld', v_ok, 'regelsTerug', v_regels,
+                            'wachtrijOpgeruimd', v_opgeruimd, 'nogTeDoen', v_rest, 'fouten', v_fouten);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_merge_herstel_uitvoeren(text, integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_merge_herstel_uitvoeren(text, integer) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_merge_status()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_merge_status');
+  RETURN jsonb_build_object(
+    'samenvoegenAan', public.logistics_merge_lines_enabled(),
+    'groepTeGroot', (SELECT COALESCE(sum(x.aantal), 0) FROM (
+        SELECT DISTINCT ON (m.group_key) m.aantal FROM public.logistics_merge_meldingen m
+         WHERE m.soort = 'groep_te_groot' AND m.created_at > now() - interval '7 days'
+         ORDER BY m.group_key, m.created_at DESC) x),
+    'nieuwVerwijderd', (SELECT count(*) FROM public.orders o
+        WHERE o.deleted_at IS NOT NULL AND o.created_at > now() - interval '7 days'
+          AND o.deleted_at - o.created_at < interval '2 minutes'
+          AND NOT EXISTS (SELECT 1 FROM public.logistics_merge_herstel_log h WHERE h.merged_order_id = o.id)),
+    'fouten', (SELECT count(*) FROM public.logistics_merge_meldingen m
+        WHERE m.soort IN ('fout', 'herstel_fout') AND m.created_at > now() - interval '7 days'),
+    'laatsteFout', (SELECT jsonb_build_object('op', m.created_at, 'melding', m.fout) FROM public.logistics_merge_meldingen m
+        WHERE m.soort IN ('fout', 'herstel_fout') ORDER BY m.created_at DESC LIMIT 1),
+    'hersteld', (SELECT COALESCE(jsonb_object_agg(categorie, n), '{}'::jsonb)
+        FROM (SELECT categorie, count(*) n FROM public.logistics_merge_herstel_log GROUP BY 1) h));
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_merge_status() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_merge_status() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_coverage_check()
+ RETURNS jsonb LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $function$
+  SELECT public.logistics_acc_guard('server', 'logistics_cart_coverage_check');
+WITH o AS (
+  SELECT id, order_number, order_source, status, buffer_id,
+    (status IN ('Verzonden','Gereed voor facturatie')) afgehandeld
+  FROM orders WHERE deleted_at IS NULL AND cancelled_at IS NULL AND buffer_id IS NOT NULL
+    AND (status IN ('Verzonden','Gereed voor facturatie') OR NOT public.logistics_order_is_backfill(id))
+), r AS (
+  SELECT o.*, oi.id item, oi.quantity q, COALESCE(NULLIF(oi.plants_per_crate,0),1) ppc,
+    (SELECT count(*) FROM logistics_active.order_items d WHERE d.order_id=o.id AND d.product_id IS NOT DISTINCT FROM oi.product_id) > 1 dubbel,
+    (SELECT sum(ci.crates) FROM logistics_active.order_cart_items ci JOIN logistics_active.order_carts c ON c.id=ci.cart_id
+      WHERE ci.order_item_id=oi.id AND (c.order_id=o.id OR (c.order_id IS DISTINCT FROM o.id AND c.buffer_id=o.buffer_id))) c_goed,
+    (SELECT sum(ci.crates*COALESCE(ci.plants_per_crate,1)) FROM logistics_active.order_cart_items ci JOIN logistics_active.order_carts c ON c.id=ci.cart_id
+      WHERE ci.order_item_id=oi.id AND (c.order_id=o.id OR (c.order_id IS DISTINCT FROM o.id AND c.buffer_id=o.buffer_id))) p_goed,
+    EXISTS (SELECT 1 FROM logistics_active.order_cart_items ci JOIN logistics_active.order_carts c ON c.id=ci.cart_id
+      WHERE ci.order_item_id=oi.id AND c.order_id IS DISTINCT FROM o.id AND c.buffer_id IS DISTINCT FROM o.buffer_id) verkeerd,
+    (SELECT q.reason_code FROM logistics_plan_queue q WHERE q.order_id=o.id AND q.status='geblokkeerd' ORDER BY q.enqueued_at DESC LIMIT 1) blok
+  FROM o JOIN logistics_active.order_items oi ON oi.order_id=o.id
+), k AS (
+  SELECT r.*, CASE
+    WHEN verkeerd THEN 'verkeerde_karinhoud'
+    WHEN blok IS NOT NULL AND c_goed IS NULL THEN 'geblokkeerd'
+    WHEN c_goed IS NULL THEN 'geen_kar'
+    WHEN q IN (c_goed, p_goed) THEN 'gelijk'
+    WHEN abs(p_goed - q) < ppc THEN 'gelijk_afgerond'
+    ELSE 'echt_verschil' END klasse
+  FROM r
+), po AS (
+  SELECT id, order_number, order_source, status, buffer_id, afgehandeld,
+    (array_agg(klasse ORDER BY CASE klasse WHEN 'verkeerde_karinhoud' THEN 1 WHEN 'geblokkeerd' THEN 2 WHEN 'geen_kar' THEN 3
+                                         WHEN 'echt_verschil' THEN 4 WHEN 'gelijk_afgerond' THEN 5 ELSE 6 END))[1] klasse,
+    sum(q) q, sum(c_goed) c_goed, sum(p_goed) p_goed, max(blok) blok, bool_or(dubbel) dubbel, count(*) regels
+  FROM k GROUP BY id, order_number, order_source, status, buffer_id, afgehandeld
+)
+SELECT jsonb_build_object(
+  'gemetenOp', now(),
+  'perOrder', true,
+  'totaal', (SELECT jsonb_object_agg(klasse, n) FROM (SELECT klasse, count(*) n FROM po GROUP BY 1) s),
+  'lopend', (SELECT COALESCE(jsonb_object_agg(klasse, n),'{}') FROM (SELECT klasse, count(*) n FROM po WHERE NOT afgehandeld GROUP BY 1) s),
+  'afgehandeld', (SELECT COALESCE(jsonb_object_agg(klasse, n),'{}') FROM (SELECT klasse, count(*) n FROM po WHERE afgehandeld GROUP BY 1) s),
+  'dubbeleRegels', (SELECT count(*) FROM k WHERE dubbel),
+  'afwijkingen', (SELECT COALESCE(jsonb_agg(jsonb_build_object('order',order_number,'bron',order_source,'status',status,
+      'buffer',buffer_id,'klasse',klasse,'besteld',q,'fusten',c_goed,'planten',p_goed,'blokkade',blok,'dubbel',dubbel,
+      'afgehandeld',afgehandeld,'regels',regels)
+      ORDER BY afgehandeld, order_number),'[]')
+    FROM po WHERE klasse NOT IN ('gelijk','gelijk_afgerond'))
+);
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_tick_http_log(p_steps jsonb)
+RETURNS void LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_fouten jsonb := coalesce(p_steps->'stickerSyncFouten', '[]'::jsonb);
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_tick_http_log');
+  INSERT INTO public.logistics_tick_runs(started_at, finished_at, duration_ms, has_error, steps)
+  VALUES (coalesce((p_steps->>'gestart')::timestamptz, now()), now(),
+          nullif(p_steps->>'duurMs', '')::int,
+          false,
+          jsonb_build_object('bron', 'http') || p_steps);
+  INSERT INTO public.logistics_tick_state(key, value, updated_at)
+  VALUES ('sticker_sync', jsonb_build_object('at', now(), 'fouten', v_fouten), now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+END $$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_samenvoegen()
+RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE f text;
+BEGIN
+  FOREACH f IN ARRAY ARRAY['logistics_order_is_backfill(uuid)', 'logistics_order_merge_key_v2(uuid)',
+      'logistics_order_mergeable(uuid)', 'logistics_merge_floriday_lines(uuid)',
+      'logistics_merge_herstel_voorbeeld()', 'logistics_merge_herstel_uitvoeren(text,integer)',
+      'logistics_merge_status()', 'logistics_trace_event(uuid,text,text,text)', 'logistics_schema_versie()'] LOOP
+    onderdeel := 'functie ' || f;
+    ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+    RETURN NEXT;
+  END LOOP;
+  onderdeel := 'tabel logistics_merge_herstel_log';
+  ok := to_regclass('public.logistics_merge_herstel_log') IS NOT NULL;
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_install_check_samenvoegen() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_samenvoegen() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE c text; f text; t text; v_fav text; n bigint; s record;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check');
+  FOREACH f IN ARRAY ARRAY['logistics_pickup_at(text,date)',
+      'logistics_pickup_ts(text,date)', 'logistics_pickup_herbereken()'] LOOP
+    onderdeel := 'functie ' || f;
+    ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+    RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY[
+      'f:logistics_try_uuid','f:logistics_tz','f:logistics_is_beheer','f:logistics_buffer_payload','f:logistics_apply_order_buffer',
+      'f:logistics_apply_buffer_decision','f:logistics_rebuffer_pending','f:logistics_departure_calc','f:logistics_own_transport_departure',
+      'f:logistics_order_departure','f:logistics_brief_transport','f:logistics_order_frozen','f:logistics_order_is_frozen',
+      'f:logistics_order_finalize_run','f:run_logistics_tasks_dispatch','f:enqueue_cart_replan_if_unlocked','f:logistics_tick',
+      't:logistics_tick_runs',
+      'f:logistics_belading_bevestig','f:logistics_cart_seq_dubbel','f:logistics_plan_retry_later','f:logistics_own_traysticker_sync',
+      't:logistics_belading_bevestigingen',
+      'f:logistics_sticker_copies','f:logistics_sticker_etiket_status','f:logistics_sticker_order_counts','f:logistics_sticker_sync',
+      'c:logistics_sticker_prints.kopieen_bron',
+      'f:logistics_carrier_settings_ensure','t:logistics_carrier_settings','t:logistics_carrier_recalc_queue','t:logistics_carrier_events',
+      'f:logistics_carrier_status','f:logistics_carrier_set_backfill','f:logistics_carrier_preview_existing','c:control_get_todays_carts.carrier_name',
+      'f:logistics_plan_fail_log'] LOOP
+    onderdeel := CASE substr(f, 3) WHEN 'run_logistics_tasks_dispatch' THEN 'Voorraad: ' WHEN 'enqueue_cart_replan_if_unlocked' THEN 'Verkoop: ' ELSE 'Engine: ' END || substr(f, 3);
+    ok := CASE left(f, 1)
+      WHEN 'f' THEN EXISTS (SELECT 1 FROM pg_proc p WHERE p.pronamespace = 'public'::regnamespace AND p.proname = substr(f, 3))
+      WHEN 't' THEN to_regclass('public.' || substr(f, 3)) IS NOT NULL
+      ELSE CASE WHEN split_part(substr(f, 3), '.', 1) = 'control_get_todays_carts'
+             THEN coalesce(pg_get_function_result(to_regprocedure('public.control_get_todays_carts()')), '') LIKE '%carrier_name%'
+             ELSE EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public'
+                           AND table_name = split_part(substr(f, 3), '.', 1) AND column_name = split_part(substr(f, 3), '.', 2)) END
+    END;
+    toelichting := CASE WHEN ok THEN 'aanwezig' WHEN substr(f, 3) = 'run_logistics_tasks_dispatch' THEN 'ontbreekt: hoort bij Voorraad; werk Voorraad bij' WHEN substr(f, 3) = 'enqueue_cart_replan_if_unlocked' THEN 'ontbreekt: hoort bij Verkoop; werk Verkoop bij' ELSE 'ontbreekt: Engine-migratie (1.0.182 t/m 1.0.188) in dev uitvoeren en via schemasync verspreiden' END;
+    RETURN NEXT;
+  END LOOP;
+  FOREACH c IN ARRAY ARRAY['carrier_id','carrier_source','carrier_reason','carrier_resolved_at','carrier_set_by','carrier_set_at'] LOOP
+    onderdeel := 'orders.' || c;
+    ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='orders' AND column_name=c);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY['logistics_resolve_carrier(uuid)','logistics_resolve_carrier_many(uuid[])',
+      'logistics_resolve_carrier_for_location(uuid,uuid)','logistics_resolve_carrier_for_location_many(uuid[],uuid)',
+      'logistics_resolve_carrier_for_location_many(jsonb)',
+      'logistics_set_order_carrier(uuid,uuid)','logistics_carrier_recalc_run(integer)'] LOOP
+    onderdeel := 'functie ' || f; ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  FOREACH t IN ARRAY ARRAY['orders:trg_logistics_orders_carrier_fill','orders:trg_logistics_orders_carrier_changed',
+      'carriers:trg_logistics_carriers_enqueue','customer_delivery_locations:trg_logistics_locations_enqueue'] LOOP
+    onderdeel := 'trigger ' || split_part(t, ':', 2);
+    ok := EXISTS (SELECT 1 FROM pg_trigger g WHERE g.tgname = split_part(t, ':', 2)
+                   AND g.tgrelid = to_regclass('public.' || split_part(t, ':', 1)));
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  onderdeel := 'minuutronde rekent vervoerders';
+  ok := EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'logistics_tick' AND prosrc LIKE '%logistics_carrier_recalc_run%');
+  toelichting := CASE WHEN ok THEN 'ja' ELSE 'nee' END; RETURN NEXT;
+  FOREACH c IN ARRAY ARRAY['carrier_kind','is_favorite','archived_at','delivery_location_glns'] LOOP
+    onderdeel := 'Afhandeling: carriers.' || c;
+    ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='carriers' AND column_name=c);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Afhandeling' END; RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY['afh_favorite_carrier','afh_city_code','afh_normalize_country','afh_normalize_nl_province'] LOOP
+    onderdeel := 'Afhandeling: ' || f || '()';
+    ok := EXISTS (SELECT 1 FROM pg_proc p WHERE p.pronamespace = 'public'::regnamespace AND p.proname = f);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Afhandeling' END; RETURN NEXT;
+  END LOOP;
+  onderdeel := 'Favoriete vervoerder ingesteld en bruikbaar';
+  IF to_regprocedure('public.afh_favorite_carrier()') IS NULL THEN ok := false; toelichting := 'functie ontbreekt';
+  ELSE
+    BEGIN v_fav := public.logistics_carrier_favorite_id()::text; EXCEPTION WHEN OTHERS THEN v_fav := NULL; END;
+    ok := public.logistics_try_uuid(v_fav) IS NOT NULL AND public.logistics_carrier_skip_reason(public.logistics_try_uuid(v_fav)) IS NULL;
+    toelichting := CASE WHEN ok THEN 'ja' WHEN v_fav IS NULL THEN 'geen favoriet ingesteld (Afhandeling → Vervoerders)'
+                        ELSE public.logistics_carrier_skip_reason(public.logistics_try_uuid(v_fav)) END;
+  END IF;
+  RETURN NEXT;
+  onderdeel := 'Klanten: customers.default_carrier_id';
+  ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='customers' AND column_name='default_carrier_id');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Klanten' END; RETURN NEXT;
+  IF to_regclass('public.logistics_carrier_settings') IS NOT NULL AND to_regclass('public.orders') IS NOT NULL
+     AND EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='orders' AND column_name='carrier_source') THEN
+    SELECT * INTO s FROM public.logistics_carrier_settings_ensure();
+    EXECUTE $q$SELECT count(*) FROM public.orders o
+      WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+        AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date
+        AND (o.carrier_source = 'geen' OR (o.carrier_source IS NULL AND o.created_at >= $1))$q$ INTO n USING s.installed_at;
+    onderdeel := 'Open orders zonder vervoerder'; ok := n = 0; toelichting := n || ' order(s)'; RETURN NEXT;
+    onderdeel := 'Schakelaar bestaande orders'; ok := true;
+    toelichting := CASE WHEN coalesce(s.backfill_existing, false) THEN 'aan' ELSE 'uit (bestaande orders wachten op akkoord)' END; RETURN NEXT;
+  END IF;
+  SELECT count(*) INTO n FROM public.logistics_trace_events e
+   WHERE e.actor IN ('trg_logistics_plan_order_items', 'trg_logistics_plan_orders')
+     AND e.status = 'mislukt' AND e.created_at > now() - interval '24 hours';
+  onderdeel := 'Mislukte herplanning (laatste 24 uur)'; ok := n = 0;
+  toelichting := CASE WHEN n = 0 THEN 'geen' ELSE n || ' keer; laatste: ' || coalesce((SELECT coalesce(e.order_ref, '?') || ': ' || coalesce(e.error, '') FROM public.logistics_trace_events e
+     WHERE e.actor IN ('trg_logistics_plan_order_items', 'trg_logistics_plan_orders') AND e.status = 'mislukt'
+     ORDER BY e.created_at DESC LIMIT 1), '') END;
+  RETURN NEXT;
+  RETURN QUERY SELECT * FROM public.logistics_install_check_194();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_196();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_197();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_198();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();
+  RETURN QUERY SELECT * FROM public.logistics_overload_check();
+  RETURN QUERY SELECT * FROM public.logistics_check_190();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_productiebon();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_samenvoegen();
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $function$ SELECT '2026-11-10b'::text $function$;
+
+-- ==== migratie 20261110090544
+CREATE OR REPLACE FUNCTION public.logistics_merge_floriday_lines(p_order_id uuid)
+RETURNS uuid LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_key text; v_keep uuid; v_keepnr text; v_cust uuid; r record; v_ids uuid[];
+  v_moved int; v_logged int; v_total int := 0; v_count int := 0; v_groep int;
+  v_lines text[] := ARRAY[]::text[];
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_merge_floriday_lines');
+  IF p_order_id IS NULL THEN RETURN p_order_id; END IF;
+  IF COALESCE(current_setting('logistics.merge_uit', true), '') = '1' THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_merge_lines_enabled() THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_order_mergeable(p_order_id) THEN RETURN p_order_id; END IF;
+  IF NOT EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = p_order_id) THEN RETURN p_order_id; END IF;
+
+  v_key := public.logistics_order_merge_key_v2(p_order_id);
+  IF v_key IS NULL THEN RETURN p_order_id; END IF;
+  IF NOT pg_try_advisory_xact_lock(hashtext('logistics_merge:' || v_key)) THEN RETURN p_order_id; END IF;
+  SELECT customer_id INTO v_cust FROM public.orders WHERE id = p_order_id;
+
+  SELECT array_agg(o.id ORDER BY o.order_number ASC NULLS LAST, o.created_at ASC) INTO v_ids
+    FROM public.orders o
+   WHERE o.customer_id = v_cust AND o.deleted_at IS NULL AND o.order_source = 'floriday'
+     AND EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = o.id)
+     AND public.logistics_order_merge_key_v2(o.id) = v_key
+     AND public.logistics_order_mergeable(o.id);
+  v_groep := COALESCE(cardinality(v_ids), 0);
+  IF v_groep < 2 THEN RETURN p_order_id; END IF;
+  IF v_groep > 20 THEN
+    IF NOT EXISTS (SELECT 1 FROM public.logistics_merge_meldingen m
+                    WHERE m.soort = 'groep_te_groot' AND m.group_key = v_key AND m.created_at > now() - interval '1 day') THEN
+      PERFORM public._logistics_merge_melding('groep_te_groot', p_order_id, v_key, v_groep,
+        v_groep || ' orders met dezelfde klant, leverdag, afleverlocatie en ophaalmoment; niet samengevoegd.');
+    END IF;
+    RETURN p_order_id;
+  END IF;
+
+  v_keep := v_ids[1];
+  SELECT order_number INTO v_keepnr FROM public.orders WHERE id = v_keep;
+  -- Geen geneste samenvoegronde tijdens het verplaatsen van regels.
+  PERFORM set_config('logistics.merge_uit', '1', true);
+
+  FOR r IN SELECT o.id, o.order_number, o.floriday_sales_order_id AS sales, o.created_at
+             FROM public.orders o WHERE o.id = ANY (v_ids) AND o.id <> v_keep
+            ORDER BY o.order_number ASC NULLS LAST LOOP
+    BEGIN
+      INSERT INTO public.logistics_order_merge_lines(
+        group_key, from_order_id, from_order_number, to_order_id, to_order_number,
+        order_item_id, product_id, product_name, quantity, source_line_key,
+        sales_order_id, ordered_at, reason)
+      SELECT v_key, r.id, r.order_number, v_keep, v_keepnr,
+             i.id, i.product_id, i.product_name, i.quantity, i.source_line_key,
+             r.sales, r.created_at, 'Zelfde klant, leverdag, afleverlocatie en ophaalmoment'
+        FROM logistics_active.order_items i WHERE i.order_id = r.id;
+      GET DIAGNOSTICS v_logged = ROW_COUNT;
+      UPDATE public.order_items SET order_id = v_keep WHERE order_id = r.id AND quarantined_at IS NULL;
+      GET DIAGNOSTICS v_moved = ROW_COUNT;
+      IF v_moved <> v_logged THEN RAISE EXCEPTION 'aantal verplaatste regels (%) wijkt af van het logboek (%)', v_moved, v_logged; END IF;
+      IF v_moved = 0 THEN RAISE EXCEPTION 'geen regels verplaatst; order blijft staan'; END IF;
+      INSERT INTO public.logistics_order_merges(group_key, kept_order_id, kept_order_number,
+        merged_order_id, merged_order_number, sales_order_id, items_moved)
+      VALUES (v_key, v_keep, v_keepnr, r.id, r.order_number, r.sales, v_moved)
+      ON CONFLICT (merged_order_id) DO NOTHING;
+      UPDATE public.orders SET deleted_at = now(),
+             notes = COALESCE(NULLIF(notes, ''), '')
+                     || CASE WHEN COALESCE(notes, '') = '' THEN '' ELSE E'\n' END
+                     || 'Samengevoegd met ' || COALESCE(v_keepnr, '') || '.',
+             updated_at = now()
+       WHERE id = r.id;
+      v_total := v_total + v_moved; v_count := v_count + 1;
+      v_lines := v_lines || (COALESCE(r.order_number, '') || ': ' || v_moved::text || ' regel(s)');
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public._logistics_merge_melding('fout', r.id, v_key, NULL,
+        'samenvoegen ' || COALESCE(r.order_number, '?') || ' met ' || COALESCE(v_keepnr, '?') || ': ' || SQLERRM);
+    END;
+  END LOOP;
+  PERFORM set_config('logistics.merge_uit', '0', true);
+
+  IF v_count > 0 THEN
+    UPDATE public.orders o SET total = to_char(COALESCE((
+             SELECT SUM(COALESCE(i.quantity, 0) * COALESCE(i.unit_price, 0))
+               FROM logistics_active.order_items i WHERE i.order_id = o.id), 0), 'FM9999999990.00'),
+           updated_at = now()
+     WHERE o.id = v_keep;
+    PERFORM public.logistics_trace_order_step(
+      v_keep, 'stap:bestelregels_samenvoegen', 'bestelregels samenvoegen', 'geslaagd',
+      'samengevoegd tot ' || COALESCE(v_keepnr, 'één bestelling'),
+      v_count::text || ' order(s), ' || v_total::text || ' regel(s) verplaatst: ' || array_to_string(v_lines, '; '),
+      'Orders combineren');
+  END IF;
+  IF EXISTS (SELECT 1 FROM public.orders WHERE id = p_order_id AND deleted_at IS NOT NULL) THEN RETURN v_keep; END IF;
+  RETURN p_order_id;
+EXCEPTION WHEN OTHERS THEN
+  PERFORM set_config('logistics.merge_uit', '0', true);
+  PERFORM public._logistics_merge_melding('fout', p_order_id, v_key, NULL, 'samenvoegen: ' || SQLERRM);
+  RETURN p_order_id;
+END $$;
+
+CREATE OR REPLACE FUNCTION public._logistics_merge_herstel_kandidaten()
+RETURNS TABLE(merged_order_id uuid, merged_order_number text, kept_order_id uuid, kept_order_number text,
+              categorie text, regels integer, status text, leverdag date, reden text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record; v_dag date; v_onzeker text; v_vandaag date := (now() AT TIME ZONE 'Europe/Amsterdam')::date;
+BEGIN
+  FOR r IN
+    SELECT m.merged_order_id, m.merged_order_number, m.kept_order_id, m.kept_order_number, m.items_moved,
+           o.status, o.delivery_date
+      FROM public.logistics_order_merges m
+      JOIN public.orders o ON o.id = m.merged_order_id
+     WHERE o.deleted_at IS NOT NULL
+       AND COALESCE(m.group_key, '') NOT LIKE 'v2|%'
+       AND NOT EXISTS (SELECT 1 FROM public.logistics_merge_herstel_log h WHERE h.merged_order_id = m.merged_order_id)
+  LOOP
+    v_onzeker := NULL;
+    BEGIN
+      v_dag := public.logistics_order_date(r.delivery_date::text);
+    EXCEPTION WHEN OTHERS THEN
+      v_dag := NULL;
+    END;
+    IF v_dag IS NULL THEN v_onzeker := 'leverdag onleesbaar'; END IF;
+    IF v_onzeker IS NULL AND (SELECT count(*) FROM public.logistics_order_merge_lines l WHERE l.from_order_id = r.merged_order_id)
+                             <> COALESCE(r.items_moved, 0) THEN
+      v_onzeker := 'logboek en aantal verplaatste regels verschillen';
+    END IF;
+    IF v_onzeker IS NULL AND EXISTS (
+         SELECT 1 FROM public.logistics_order_merge_lines l
+          LEFT JOIN public.order_items i ON i.id = l.order_item_id
+          WHERE l.from_order_id = r.merged_order_id
+            AND (i.id IS NULL OR i.order_id IS DISTINCT FROM r.kept_order_id)) THEN
+      v_onzeker := 'regel staat niet meer bij de verzamelorder';
+    END IF;
+    IF v_onzeker IS NULL AND EXISTS (
+         SELECT 1 FROM public.logistics_order_merge_lines l
+          WHERE l.from_order_id = r.merged_order_id
+            AND EXISTS (SELECT 1 FROM public.logistics_order_merge_lines l2
+                         WHERE l2.order_item_id = l.order_item_id AND l2.from_order_id <> l.from_order_id)) THEN
+      v_onzeker := 'regel komt bij meer dan één order vandaan';
+    END IF;
+    merged_order_id := r.merged_order_id; merged_order_number := r.merged_order_number;
+    kept_order_id := r.kept_order_id; kept_order_number := r.kept_order_number;
+    regels := COALESCE(r.items_moved, 0); status := r.status; leverdag := v_dag; reden := v_onzeker;
+    categorie := CASE
+      WHEN v_onzeker IS NOT NULL THEN 'onzeker'
+      WHEN v_dag < v_vandaag THEN 'verleden'
+      WHEN lower(btrim(COALESCE(r.status, ''))) = 'nog te picken' THEN 'urgent'
+      ELSE 'toekomst_overig' END;
+    RETURN NEXT;
+  END LOOP;
+END $$;
+
+REVOKE EXECUTE ON FUNCTION public.logistics_order_merge_key_v2(uuid) FROM authenticated;
+
+-- ==== migratie 20261110090709
+CREATE OR REPLACE FUNCTION public.logistics_merge_floriday_lines(p_order_id uuid)
+RETURNS uuid LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_key text; v_keep uuid; v_keepnr text; v_cust uuid; r record; v_ids uuid[];
+  v_moved int; v_logged int; v_total int := 0; v_count int := 0; v_groep int;
+  v_lines text[] := ARRAY[]::text[];
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_merge_floriday_lines');
+  IF p_order_id IS NULL THEN RETURN p_order_id; END IF;
+  IF COALESCE(current_setting('logistics.merge_uit', true), '') = '1' THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_merge_lines_enabled() THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_order_mergeable(p_order_id) THEN RETURN p_order_id; END IF;
+  IF NOT EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = p_order_id) THEN RETURN p_order_id; END IF;
+
+  v_key := public.logistics_order_merge_key_v2(p_order_id);
+  IF v_key IS NULL THEN RETURN p_order_id; END IF;
+  IF NOT pg_try_advisory_xact_lock(hashtext('logistics_merge:' || v_key)) THEN RETURN p_order_id; END IF;
+  SELECT customer_id INTO v_cust FROM public.orders WHERE id = p_order_id;
+
+  SELECT array_agg(o.id ORDER BY o.order_number ASC NULLS LAST, o.created_at ASC) INTO v_ids
+    FROM public.orders o
+   WHERE o.customer_id = v_cust AND o.deleted_at IS NULL AND o.order_source = 'floriday'
+     AND EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = o.id)
+     AND public.logistics_order_merge_key_v2(o.id) = v_key
+     AND public.logistics_order_mergeable(o.id);
+  v_groep := COALESCE(cardinality(v_ids), 0);
+  IF v_groep < 2 THEN RETURN p_order_id; END IF;
+  v_keep := v_ids[1];
+  -- Grens: eerder samengevoegde orders bij dezelfde bewaarorder tellen mee.
+  v_groep := v_groep + (SELECT count(*) FROM public.logistics_order_merges m WHERE m.kept_order_id = v_keep AND m.group_key = v_key);
+  IF v_groep > 20 THEN
+    IF NOT EXISTS (SELECT 1 FROM public.logistics_merge_meldingen m
+                    WHERE m.soort = 'groep_te_groot' AND m.group_key = v_key AND m.created_at > now() - interval '1 day') THEN
+      PERFORM public._logistics_merge_melding('groep_te_groot', p_order_id, v_key, v_groep,
+        v_groep || ' orders met dezelfde klant, leverdag, afleverlocatie en ophaalmoment; niet samengevoegd.');
+    END IF;
+    RETURN p_order_id;
+  END IF;
+
+  SELECT order_number INTO v_keepnr FROM public.orders WHERE id = v_keep;
+  PERFORM set_config('logistics.merge_uit', '1', true);
+
+  FOR r IN SELECT o.id, o.order_number, o.floriday_sales_order_id AS sales, o.created_at
+             FROM public.orders o WHERE o.id = ANY (v_ids) AND o.id <> v_keep
+            ORDER BY o.order_number ASC NULLS LAST LOOP
+    BEGIN
+      INSERT INTO public.logistics_order_merge_lines(
+        group_key, from_order_id, from_order_number, to_order_id, to_order_number,
+        order_item_id, product_id, product_name, quantity, source_line_key,
+        sales_order_id, ordered_at, reason)
+      SELECT v_key, r.id, r.order_number, v_keep, v_keepnr,
+             i.id, i.product_id, i.product_name, i.quantity, i.source_line_key,
+             r.sales, r.created_at, 'Zelfde klant, leverdag, afleverlocatie en ophaalmoment'
+        FROM logistics_active.order_items i WHERE i.order_id = r.id;
+      GET DIAGNOSTICS v_logged = ROW_COUNT;
+      UPDATE public.order_items SET order_id = v_keep WHERE order_id = r.id AND quarantined_at IS NULL;
+      GET DIAGNOSTICS v_moved = ROW_COUNT;
+      IF v_moved <> v_logged THEN RAISE EXCEPTION 'aantal verplaatste regels (%) wijkt af van het logboek (%)', v_moved, v_logged; END IF;
+      IF v_moved = 0 THEN RAISE EXCEPTION 'geen regels verplaatst; order blijft staan'; END IF;
+      INSERT INTO public.logistics_order_merges(group_key, kept_order_id, kept_order_number,
+        merged_order_id, merged_order_number, sales_order_id, items_moved)
+      VALUES (v_key, v_keep, v_keepnr, r.id, r.order_number, r.sales, v_moved)
+      ON CONFLICT (merged_order_id) DO NOTHING;
+      UPDATE public.orders SET deleted_at = now(),
+             notes = COALESCE(NULLIF(notes, ''), '')
+                     || CASE WHEN COALESCE(notes, '') = '' THEN '' ELSE E'\n' END
+                     || 'Samengevoegd met ' || COALESCE(v_keepnr, '') || '.',
+             updated_at = now()
+       WHERE id = r.id;
+      v_total := v_total + v_moved; v_count := v_count + 1;
+      v_lines := v_lines || (COALESCE(r.order_number, '') || ': ' || v_moved::text || ' regel(s)');
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public._logistics_merge_melding('fout', r.id, v_key, NULL,
+        'samenvoegen ' || COALESCE(r.order_number, '?') || ' met ' || COALESCE(v_keepnr, '?') || ': ' || SQLERRM);
+    END;
+  END LOOP;
+  PERFORM set_config('logistics.merge_uit', '0', true);
+
+  IF v_count > 0 THEN
+    UPDATE public.orders o SET total = to_char(COALESCE((
+             SELECT SUM(COALESCE(i.quantity, 0) * COALESCE(i.unit_price, 0))
+               FROM logistics_active.order_items i WHERE i.order_id = o.id), 0), 'FM9999999990.00'),
+           updated_at = now()
+     WHERE o.id = v_keep;
+    PERFORM public.logistics_trace_order_step(
+      v_keep, 'stap:bestelregels_samenvoegen', 'bestelregels samenvoegen', 'geslaagd',
+      'samengevoegd tot ' || COALESCE(v_keepnr, 'één bestelling'),
+      v_count::text || ' order(s), ' || v_total::text || ' regel(s) verplaatst: ' || array_to_string(v_lines, '; '),
+      'Orders combineren');
+  END IF;
+  IF EXISTS (SELECT 1 FROM public.orders WHERE id = p_order_id AND deleted_at IS NOT NULL) THEN RETURN v_keep; END IF;
+  RETURN p_order_id;
+EXCEPTION WHEN OTHERS THEN
+  PERFORM set_config('logistics.merge_uit', '0', true);
+  PERFORM public._logistics_merge_melding('fout', p_order_id, v_key, NULL, 'samenvoegen: ' || SQLERRM);
+  RETURN p_order_id;
+END $$;
+
+-- ==== migratie 20261110090737
+CREATE OR REPLACE FUNCTION public.logistics_merge_status()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_merge_status');
+  RETURN jsonb_build_object(
+    'samenvoegenAan', public.logistics_merge_lines_enabled(),
+    'groepTeGroot', (SELECT COALESCE(sum(x.aantal), 0) FROM (
+        SELECT DISTINCT ON (m.group_key) m.aantal FROM public.logistics_merge_meldingen m
+         WHERE m.soort = 'groep_te_groot' AND m.created_at > now() - interval '7 days'
+         ORDER BY m.group_key, m.created_at DESC) x),
+    'nieuwVerwijderd', (SELECT count(*) FROM public.orders o
+        WHERE o.deleted_at IS NOT NULL AND o.created_at > now() - interval '7 days'
+          AND o.deleted_at - o.created_at < interval '2 minutes'
+          AND NOT EXISTS (SELECT 1 FROM public.logistics_order_merges m
+                           WHERE m.merged_order_id = o.id AND m.items_moved > 0 AND m.group_key LIKE 'v2|%')
+          AND NOT EXISTS (SELECT 1 FROM public.logistics_merge_herstel_log h WHERE h.merged_order_id = o.id)),
+    'fouten', (SELECT count(*) FROM public.logistics_merge_meldingen m
+        WHERE m.soort IN ('fout', 'herstel_fout') AND m.created_at > now() - interval '7 days'),
+    'laatsteFout', (SELECT jsonb_build_object('op', m.created_at, 'melding', m.fout) FROM public.logistics_merge_meldingen m
+        WHERE m.soort IN ('fout', 'herstel_fout') ORDER BY m.created_at DESC LIMIT 1),
+    'hersteld', (SELECT COALESCE(jsonb_object_agg(categorie, n), '{}'::jsonb)
+        FROM (SELECT categorie, count(*) n FROM public.logistics_merge_herstel_log GROUP BY 1) h));
+END $$;
+