@flowselections/mailbox-orders 1.0.29 → 1.0.32

package/dist-lib/lib/mailbox-ingest.server.js

@@ -10,6 +10,9 @@
 // server-only helpers niet direct binnenhalen).
 import { emailBodyText } from "./mailbox-body.js";
 import { detectLoadCarrierInText, isLoadCarrierAllowed, loadCarrierLabel, normalizeAllowedLoadCarriers, } from "./load-carriers.js";
+import { classifyMessage, extractLatestPart } from "./mailbox-filter.js";
+import { normalizeUnitKind, toPlants, unitPricePerPlant } from "./mailbox-units.js";
+import { matchLine, rankCandidates } from "./mailbox-match.js";
 /**
  * Ladingdragers komen live uit de Logistics Engine — nooit cachen, nooit een
  * eigen lijst bijhouden.
@@ -126,12 +129,6 @@ const DEFAULT_AI_FIELDS = [
         field_type: "date",
         ai_hint: "Alleen invullen als de mail een datum of week noemt. Formaat YYYY-MM-DD.",
     },
-    {
-        key: "reference",
-        label: "Referentie klant",
-        field_type: "text",
-        ai_hint: "Order-, referentie- of PO-nummer van de klant.",
-    },
     {
         key: "notes",
         label: "Opmerking",
@@ -145,53 +142,104 @@ const DEFAULT_AI_FIELDS = [
         ai_hint: "Kies uitsluitend een id uit de meegegeven afleverlocaties van deze klant.",
     },
 ];
+/** Referentie klant wordt altijd gevraagd, los van het template. */
+const REFERENCE_FIELD = {
+    key: "reference",
+    label: "Referentie klant",
+    field_type: "text",
+    ai_hint: "Order-, referentie- of PO-nummer van de klant, letterlijk zoals in de mail.",
+};
 /** Centrale AI-instellingen van deze module (aanpasbaar via Instellingen). */
 export async function loadMailboxAiSettings(admin) {
     const { data } = await admin
         .from("mailbox_ai_settings")
-        .select("system_prompt, required_fields")
+        .select("system_prompt, required_fields, enabled")
         .limit(1)
         .maybeSingle();
     const req = Array.isArray(data?.required_fields) ? data.required_fields : [];
     return {
         systemPrompt: data?.system_prompt ?? null,
         requiredFields: req.length > 0 ? req : ["customer", "delivery_date", "delivery_location", "lines"],
+        enabled: data?.enabled !== false,
     };
 }
-async function buildAiContext(admin, customerId) {
-    const [{ data: products }, { data: locations }, { data: tplFields }, { data: plantRows }, settings] = await Promise.all([
-        admin.from("products").select("id, product").order("product").range(0, 999),
+/** Filter- en limietinstellingen. Fail closed: zonder instellingen geen analyse. */
+export async function loadFilterSettings(admin) {
+    const { data, error } = await admin
+        .from("mailbox_filter_settings")
+        .select("*")
+        .eq("singleton", true)
+        .maybeSingle();
+    if (error)
+        throw new Error(`Instellingen van de mailbox niet leesbaar: ${error.message}`);
+    if (!data)
+        throw new Error("Instellingen van de mailbox ontbreken (mailbox_filter_settings).");
+    return data;
+}
+const codeVal = (v) => typeof v === "string" || typeof v === "number" ? String(v).trim() || null : null;
+async function loadProductIndex(admin) {
+    const { data } = await admin
+        .from("products")
+        .select("id, product, article_number, barcode, floriday_trade_item_id, custom_fields, plants_per_crate, crates_per_layer, layers_per_cart")
+        .range(0, 9999);
+    const list = (Array.isArray(data) ? data : []).map((p) => {
+        const cf = p?.custom_fields ?? {};
+        const pl = cf?.floriday_payload ?? {};
+        const codes = [p.article_number, p.barcode, p.floriday_trade_item_id, cf.articleCode, pl.articleCode, pl.gtin, pl.vbnCode, pl.producerCode]
+            .map(codeVal)
+            .filter((x) => !!x);
+        const packs = Array.isArray(pl?.packingConfigurations) ? pl.packingConfigurations : [];
+        const n = (v) => Math.max(1, Math.round(Number(v ?? 1)) || 1);
+        return {
+            id: String(p.id),
+            name: String(p.product ?? ""),
+            codes,
+            belading: p.plants_per_crate
+                ? { plants_per_crate: n(p.plants_per_crate), crates_per_layer: n(p.crates_per_layer), layers_per_cart: n(p.layers_per_cart) }
+                : null,
+            packings: packs.map((pc) => ({
+                plants_per_crate: n(pc?.unitsPerPackage ?? pc?.piecesPerPackage),
+                crates_per_layer: n(pc?.packagesPerLayer),
+                layers_per_cart: n(pc?.layersPerLoadCarrier),
+            })),
+        };
+    });
+    return { list, byId: new Map(list.map((p) => [p.id, p])) };
+}
+const beladingText = (b) => b ? `${b.plants_per_crate} per fust, ${b.crates_per_layer} fust per laag, ${b.layers_per_cart} lagen per kar` : null;
+async function buildAiContext(admin, customerId, mailText, maxCandidates, idx) {
+    const [{ data: locations }, { data: tplFields }, { data: plantRows }, settings] = await Promise.all([
         customerId
-            ? admin
-                .from("customer_delivery_locations")
-                .select("id, name, city")
-                .eq("customer_id", customerId)
-                .limit(100)
+            ? admin.from("customer_delivery_locations").select("id, name, city, gln").eq("customer_id", customerId).limit(100)
             : Promise.resolve({ data: [] }),
         admin.from("mailbox_order_template_fields").select("*").order("sort_order", { ascending: true }),
         admin.from("products").select("product_type").not("product_type", "is", null).range(0, 999),
         loadMailboxAiSettings(admin),
     ]);
-    const catalog = (Array.isArray(products) ? products : []).map((p) => ({
+    // Alleen de beste kandidaten voor deze mail (codes eerst, dan naam).
+    const ranked = rankCandidates(mailText, idx.list, maxCandidates);
+    const candidates = (ranked.length ? ranked : idx.list.slice(0, Math.max(1, maxCandidates))).map((p) => ({
         id: p.id,
-        name: p.product ?? "",
+        name: p.name,
+        codes: p.codes.slice(0, 6),
+        belading: beladingText(p.belading),
     }));
     const plantTypes = Array.from(new Set((Array.isArray(plantRows) ? plantRows : [])
         .map((r) => (typeof r?.product_type === "string" ? r.product_type.trim() : ""))
         .filter(Boolean))).sort();
     const deliveryLocations = (Array.isArray(locations) ? locations : []).map((l) => ({
         id: l.id,
-        name: [l.name, l.city].filter(Boolean).join(" — ") || "Locatie",
+        name: [l.name, l.city, l.gln ? `GLN ${l.gln}` : null].filter(Boolean).join(" — ") || "Locatie",
     }));
     const rows = (Array.isArray(tplFields) ? tplFields : []).filter((f) => f.ai_enabled !== false);
-    const templateFields = rows.length > 0
+    const base = rows.length > 0
         ? rows.map((f) => ({
             key: f.key,
             label: f.label ?? f.key,
             field_type: f.field_type ?? "text",
             ai_hint: f.ai_hint ?? null,
             allowed: f.field_type === "product"
-                ? catalog
+                ? candidates.map((c) => ({ id: c.id, name: c.name }))
                 : f.field_type === "delivery_location"
                     ? deliveryLocations
                     : f.field_type === "plant_type"
@@ -202,38 +250,42 @@ async function buildAiContext(admin, customerId) {
             ...f,
             allowed: f.field_type === "delivery_location" ? deliveryLocations : undefined,
         }));
-    return { catalog, deliveryLocations, templateFields, plantTypes, settings };
+    const templateFields = base.some((f) => f.key === "reference") ? base : [...base, { ...REFERENCE_FIELD, allowed: undefined }];
+    return { candidates, deliveryLocations, templateFields, plantTypes, settings };
 }
 /** Voert de AI-parse uit voor één bericht. Gooit nooit — fouten komen terug in `error`. */
-async function aiParseMessage(admin, messageId, customerId) {
+async function aiParseMessage(admin, args) {
     try {
-        const { data: msg } = await admin
-            .from("mailbox_messages")
-            .select("subject, body_text, body_html")
-            .eq("id", messageId)
-            .maybeSingle();
-        const bodyText = emailBodyText(msg?.body_text, msg?.body_html);
-        if (!bodyText.trim())
+        if (!args.text.trim())
             throw new Error("Bericht bevat geen tekst om te lezen.");
-        const ctx = await buildAiContext(admin, customerId);
+        const ctx = await buildAiContext(admin, args.customerId, `${args.subject}\n${args.text}`, args.settings.max_candidates, args.idx);
         const { parseOrderEmail } = await import("./mailbox-ai.server.js");
         const res = await parseOrderEmail(admin, {
-            bodyText,
-            subject: msg?.subject ?? "",
+            bodyText: args.text,
+            subject: args.subject,
             templateFields: ctx.templateFields,
-            productCatalog: ctx.catalog,
+            productCatalog: ctx.candidates,
             deliveryLocations: ctx.deliveryLocations,
             plantTypes: ctx.plantTypes,
             requiredFields: ctx.settings.requiredFields,
             systemPrompt: ctx.settings.systemPrompt,
+            now: args.receivedAt,
+            maxAttemptsPerModel: args.settings.max_retry_attempts,
         });
-        return { parsed: res.parsed, meta: res.meta, error: null, transient: false, requiredFields: ctx.settings.requiredFields };
+        return {
+            parsed: res.parsed,
+            meta: res.meta,
+            error: null,
+            transient: false,
+            requiredFields: ctx.settings.requiredFields,
+            candidateIds: new Set(ctx.candidates.map((c) => c.id)),
+        };
     }
     catch (e) {
         const msg = String(e?.message ?? e);
         const { isTransientAiError } = await import("./mailbox-ai.server.js");
         const transient = e?.name === "AiUnavailableError" ? Boolean(e.transient) : isTransientAiError(msg);
-        return { parsed: null, meta: null, error: msg.slice(0, 500), transient, requiredFields: [] };
+        return { parsed: null, meta: null, error: msg.slice(0, 500), transient, requiredFields: [], candidateIds: new Set() };
     }
 }
 const FIELD_LABELS = {
@@ -246,6 +298,55 @@ const FIELD_LABELS = {
     reference: "Referentie klant",
     notes: "Opmerking",
 };
+/** Koppelt product (code eerst), bepaalt eenheid en rekent om naar planten. */
+function enrichLines(parsed, idx, candidateIds) {
+    return parsed.lines.map((l) => {
+        const m = matchLine({ code: l.code, raw_text: l.raw_product_text, name_in_mail: l.name_in_mail, product_id: l.product_id, ai_confidence: l.confidence.product }, idx.list, candidateIds);
+        const p = m.productId ? idx.byId.get(m.productId) ?? null : null;
+        let kind = normalizeUnitKind(l.unit);
+        if (kind === "onbekend" && l.unit_text)
+            kind = normalizeUnitKind(l.unit_text);
+        const warnings = [];
+        let bel = p?.belading ?? null;
+        const ppu = l.pieces_per_unit && l.pieces_per_unit > 0 ? Math.round(l.pieces_per_unit) : null;
+        if (p && ppu && kind === "fust" && bel && ppu !== bel.plants_per_crate) {
+            const alt = p.packings.find((x) => x.plants_per_crate === ppu);
+            if (alt) {
+                bel = alt;
+                warnings.push(`Belading met ${ppu} per fust gekozen, zoals genoemd in de mail.`);
+            }
+            else {
+                warnings.push(`De mail noemt ${ppu} per fust, de standaardbelading is ${bel.plants_per_crate} per fust.`);
+            }
+        }
+        if (!p)
+            warnings.push(`Onbekend artikel: ${l.name_in_mail || l.raw_product_text || "?"}`);
+        if (kind === "onbekend")
+            warnings.push("Eenheid onbekend: kies fust, laag, kar of stuks.");
+        const plants = toPlants(l.quantity, kind, bel);
+        const pricePer = l.price_per ?? (l.price !== null ? "stuk" : null);
+        return {
+            product_id: p?.id ?? null,
+            raw_product_text: l.raw_product_text,
+            plant_type: l.plant_type,
+            raw_code: l.code,
+            name_in_mail: l.name_in_mail,
+            qty_in_mail: l.quantity,
+            unit_text: l.unit_text,
+            unit_kind: kind,
+            pieces_per_unit: ppu,
+            plants,
+            unit_price: unitPricePerPlant(l.price, pricePer, kind, bel),
+            currency: l.currency,
+            price_per: pricePer,
+            mail_price: l.price,
+            belading: bel,
+            match_source: m.source,
+            confidence: { ...l.confidence, product: p ? Math.max(m.confidence, m.source === "code" ? 1 : 0) : 0 },
+            warnings,
+        };
+    });
+}
 /**
  * Combineert de zelfcontrole van de AI met een harde servercheck op de
  * verplichte velden. Ontbrekende of onzekere gegevens worden expliciet
@@ -253,6 +354,7 @@ const FIELD_LABELS = {
  */
 export function computeValidation(parsed, requiredFields, extra) {
     const label = (k) => FIELD_LABELS[k] ?? k;
+    const green = extra.confGreen ?? 0.8;
     const missing = new Set(parsed.validation?.missing ?? []);
     const uncertain = new Set(parsed.validation?.uncertain ?? []);
     for (const key of requiredFields) {
@@ -262,7 +364,7 @@ export function computeValidation(parsed, requiredFields, extra) {
             continue;
         }
         if (key === "customer") {
-            if (!extra.customerId && !parsed.fields?.customer?.value)
+            if (!extra.customerId)
                 missing.add(label("customer"));
             continue;
         }
@@ -270,29 +372,30 @@ export function computeValidation(parsed, requiredFields, extra) {
         const empty = f?.value === null || f?.value === undefined || f?.value === "";
         if (empty)
             missing.add(label(key));
-        else if (f && (f.needs_review || f.confidence < 0.8))
+        else if (f && (f.needs_review || f.confidence < green))
             uncertain.add(label(key));
     }
-    for (const l of parsed.lines) {
+    for (const l of extra.lines ?? []) {
+        const name = l.name_in_mail || l.raw_product_text || "onbekend";
         if (!l.product_id)
-            uncertain.add(`Artikel niet gekoppeld: ${l.raw_product_text || "onbekend"}`);
-        if (l.quantity === null || l.quantity <= 0)
-            missing.add(`Aantal ontbreekt: ${l.raw_product_text || "onbekend"}`);
-        if (!l.plant_type)
-            uncertain.add(`Plantsoort onbekend: ${l.raw_product_text || "onbekend"}`);
+            uncertain.add(`Onbekend artikel: ${name}`);
+        if (l.qty_in_mail === null || l.qty_in_mail <= 0)
+            missing.add(`Aantal ontbreekt: ${name}`);
+        if (l.unit_kind === "onbekend")
+            missing.add(`Eenheid onbekend: ${name}`);
+        if (l.unit_price === null)
+            uncertain.add(`Geen prijs bekend: ${name}`);
+        for (const w of l.warnings)
+            if (w.startsWith("De mail noemt"))
+                uncertain.add(w);
     }
     const m = Array.from(missing).slice(0, 50);
     const u = Array.from(uncertain).slice(0, 50);
-    return {
-        missing: m,
-        uncertain: u,
-        notes: parsed.validation?.notes ?? null,
-        ok: m.length === 0 && u.length === 0,
-    };
+    return { missing: m, uncertain: u, notes: parsed.validation?.notes ?? null, ok: m.length === 0 && u.length === 0 };
 }
 /** Maximaal aantal achtergrondpogingen voordat we het voorstel handmatig laten. */
-export const AI_MAX_BACKGROUND_RETRIES = 6;
-function aiPayloadBlock(attempt, fingerprint, prevAi) {
+export const AI_MAX_BACKGROUND_RETRIES = 3;
+function aiPayloadBlock(attempt, fingerprint, prevAi, maxRetries = AI_MAX_BACKGROUND_RETRIES) {
     if (attempt.parsed) {
         return {
             ok: true,
@@ -313,36 +416,38 @@ function aiPayloadBlock(attempt, fingerprint, prevAi) {
         error: attempt.error,
         transient,
         retry_count: retryCount,
-        retry_pending: transient && retryCount < AI_MAX_BACKGROUND_RETRIES,
+        retry_pending: transient && retryCount < maxRetries,
         last_attempt_at: new Date().toISOString(),
         fingerprint,
         parsed_at: new Date().toISOString(),
     };
 }
 /**
- * Vult het afleveradres aan met de hoofdafleverlocatie (is_primary) van de klant
- * wanneer de mail/AI géén geldige locatie heeft herkend. Herkent de AI wél een
- * locatie van deze klant, dan blijft die staan.
+ * Afleveradres: een GLN of locatie uit de mail wint. Anders de vaste locatie
+ * (is_primary, maximaal één per klant). Geen vaste locatie → niets kiezen.
  */
-export async function resolveDeliveryLocation(admin, customerId, aiValue) {
+export async function resolveDeliveryLocation(admin, customerId, aiValue, mailText = "") {
     if (!customerId)
         return null;
     const { data: rows } = await admin
         .from("customer_delivery_locations")
-        .select("id, is_primary")
+        .select("id, is_primary, gln")
         .eq("customer_id", customerId)
-        .order("is_primary", { ascending: false })
-        .limit(100);
+        .limit(200);
     const locations = Array.isArray(rows) ? rows : [];
     if (locations.length === 0)
         return null;
+    const glns = new Set((mailText.match(/\b\d{13}\b/g) ?? []).map((g) => g));
+    const byGln = locations.filter((l) => l.gln && glns.has(String(l.gln)));
+    if (byGln.length === 1)
+        return { id: String(byGln[0].id), source: "gln" };
     if (typeof aiValue === "string" && aiValue) {
         const hit = locations.find((l) => String(l.id) === aiValue);
         if (hit)
-            return { id: String(hit.id), primary: false };
+            return { id: String(hit.id), source: "mail" };
     }
-    const primary = locations.find((l) => l.is_primary === true) ?? locations[0];
-    return primary ? { id: String(primary.id), primary: true } : null;
+    const primary = locations.filter((l) => l.is_primary === true);
+    return primary.length === 1 ? { id: String(primary[0].id), source: "vast" } : null;
 }
 /**
  * Afhaallocatie (eigen tuin/warehouse): AI-herkenning wint, anders de hoofdlocatie
@@ -367,8 +472,8 @@ export async function resolvePickupLocation(admin, aiValue) {
     const main = own.find((r) => r?.data?.isDefault === true) ?? own[0];
     return main ? { id: String(main.floriday_id), primary: true } : null;
 }
-/** Schrijft velden + regels van een AI-parse weg (na het opschonen van oude rijen). */
-async function writeParsedDetails(admin, proposalId, parsed) {
+/** Schrijft velden + regels van een AI-parse weg. */
+async function writeParsedDetails(admin, proposalId, parsed, lines) {
     const fieldRows = Object.entries(parsed.fields).map(([key, v]) => ({
         proposal_id: proposalId,
         field_key: key,
@@ -380,162 +485,338 @@ async function writeParsedDetails(admin, proposalId, parsed) {
     if (fieldRows.length > 0) {
         await admin.from("mailbox_proposal_field_values").insert(fieldRows);
     }
-    if (parsed.lines.length > 0) {
-        await admin.from("mailbox_proposal_lines").insert(parsed.lines.map((l, idx) => ({
+    if (lines.length > 0) {
+        await admin.from("mailbox_proposal_lines").insert(lines.map((l, i) => ({
             proposal_id: proposalId,
             product_id: l.product_id,
             plant_type: l.plant_type,
             raw_product_text: l.raw_product_text,
-            quantity: l.quantity,
-            unit: l.unit,
-            match_confidence: l.match_confidence,
-            sort_order: idx,
+            quantity: l.plants,
+            unit: "planten",
+            match_confidence: l.confidence.product,
+            sort_order: i,
+            raw_code: l.raw_code,
+            name_in_mail: l.name_in_mail,
+            qty_in_mail: l.qty_in_mail,
+            unit_text: l.unit_text,
+            unit_kind: l.unit_kind,
+            pieces_per_unit: l.pieces_per_unit,
+            plants: l.plants,
+            unit_price: l.unit_price,
+            currency: l.currency,
+            price_per: l.price_per,
+            belading: l.belading,
+            confidence: { ...l.confidence, mail_price: l.mail_price },
+            match_source: l.match_source,
+            warnings: l.warnings,
         })));
     }
 }
-/**
- * Maakt exact één voorstel per bericht. Probeert eerst de AI-parse via de
- * centrale AI-Authenticatie module; lukt dat niet, dan valt hij terug op een
- * leeg voorstel met de reden erbij. Ingest mag nooit stukvallen op AI.
- */
-export async function createStubProposal(admin, messageId, fromEmail) {
-    const { data: existing } = await admin
-        .from("mailbox_order_proposals")
-        .select("id")
-        .eq("message_id", messageId)
+async function loadMessage(admin, messageId) {
+    const { data } = await admin
+        .from("mailbox_messages")
+        .select("id, from_email, subject, body_text, body_html, received_at, has_attachments, attachments, filter_outcome")
+        .eq("id", messageId)
         .maybeSingle();
-    if (existing?.id)
-        return;
-    // Val terug op het afzenderadres van het bericht zelf wanneer de event-payload
-    // geen adres meegaf — anders wordt de klant nooit automatisch herkend.
-    let senderEmail = normalizeEmail(fromEmail);
-    if (!senderEmail) {
-        const { data: msg } = await admin
-            .from("mailbox_messages")
-            .select("from_email")
-            .eq("id", messageId)
-            .maybeSingle();
-        senderEmail = normalizeEmail(msg?.from_email ?? null);
-    }
-    const matchResult = await matchCustomerByEmail(admin, senderEmail);
-    const basePayload = {
-        auto_matched_customer: matchResult.customerId !== null,
-        auto_match_source: matchResult.source,
-        auto_match_email: senderEmail || null,
-        auto_match_warning: matchResult.warning,
-        auto_match_candidates: matchResult.candidates,
-    };
-    // --- AI-parse (best effort) ---------------------------------------------
-    const { currentAiFingerprint } = await import("./mailbox-ai.server.js");
-    const fingerprint = await currentAiFingerprint(admin).catch(() => null);
-    const attempt = await aiParseMessage(admin, messageId, matchResult.customerId);
+    return data ?? null;
+}
+/** Bijlagen die geen ingesloten afbeelding zijn worden niet automatisch gelezen. */
+function hasUnreadAttachment(msg) {
+    const list = Array.isArray(msg.attachments) ? msg.attachments : [];
+    const real = list.filter((a) => !(a?.isInline === true || a?.inline === true || a?.contentId));
+    return real.length > 0 || (msg.has_attachments === true && list.length === 0);
+}
+async function senderMatch(admin, email, s) {
+    const match = await matchCustomerByEmail(admin, email);
+    if (match.customerId || !s.domain_match || !email.includes("@"))
+        return match;
+    const domain = email.split("@")[1];
+    const { data } = await admin.from("customers").select("id, company_name").ilike("email", `%@${domain}`).limit(3);
+    const rows = Array.isArray(data) ? data : [];
+    if (rows.length === 1) {
+        return {
+            customerId: rows[0].id,
+            source: "customers",
+            warning: `Klant herkend op domein (${domain}) — controleer de klant.`,
+            candidates: rows.map((c) => ({ id: c.id, name: c.company_name })),
+        };
+    }
+    return match;
+}
+/** Mogelijk dubbel: zelfde klant + zelfde referentie, of vrijwel dezelfde regels. */
+async function findDuplicate(admin, args) {
+    if (!args.customerId)
+        return null;
+    const since = new Date(Date.now() - Math.max(1, args.days) * 86400000).toISOString();
+    const { data } = await admin
+        .from("mailbox_order_proposals")
+        .select("id, message_id, order_number, customer_reference, created_at, mailbox_proposal_lines(product_id, plants)")
+        .eq("matched_customer_id", args.customerId)
+        .gte("created_at", since)
+        .neq("message_id", args.messageId)
+        .limit(100);
+    const rows = (Array.isArray(data) ? data : []).filter((r) => r.id !== args.excludeProposalId);
+    const ref = (args.reference ?? "").trim().toLowerCase();
+    if (ref) {
+        const hit = rows.find((r) => (r.customer_reference ?? "").trim().toLowerCase() === ref);
+        if (hit)
+            return { kind: "referentie", label: hit.order_number ?? "een eerder voorstel" };
+        const { data: orders } = await admin
+            .from("orders")
+            .select("order_number")
+            .eq("customer_id", args.customerId)
+            .gte("created_at", since)
+            .eq("custom_fields->>customer_reference", args.reference)
+            .limit(1);
+        if (Array.isArray(orders) && orders[0])
+            return { kind: "referentie", label: orders[0].order_number };
+    }
+    const sig = (ls) => ls.filter((l) => l.product_id).map((l) => `${l.product_id}:${l.plants ?? 0}`).sort().join("|");
+    const mine = sig(args.lines);
+    if (mine) {
+        const hit = rows.find((r) => sig(Array.isArray(r.mailbox_proposal_lines) ? r.mailbox_proposal_lines : []) === mine);
+        if (hit)
+            return { kind: "regels", label: hit.order_number ?? "een eerder voorstel" };
+    }
+    return null;
+}
+/** Klaar om te bevestigen, of controleren. Nooit automatisch bevestigen. */
+function readiness(validation, lines, deliveryLoc, customer) {
+    if (!validation || !customer || !deliveryLoc || lines.length === 0)
+        return "controleren";
+    if (validation.missing.length || validation.uncertain.length)
+        return "controleren";
+    if (lines.some((l) => !l.product_id || !l.plants || l.unit_price === null || l.warnings.length))
+        return "controleren";
+    return "klaar";
+}
+async function finishRun(admin, runId, messageId, attempt) {
+    if (runId) {
+        await admin
+            .from("mailbox_ai_runs")
+            .update({
+            finished_at: new Date().toISOString(),
+            ok: !!attempt.parsed,
+            input_tokens: attempt.meta?.inputTokens ?? null,
+            output_tokens: attempt.meta?.outputTokens ?? null,
+            error: attempt.error,
+        })
+            .eq("id", runId);
+    }
+    await admin.from("mailbox_messages").update({ analysis_state: "klaar" }).eq("id", messageId);
+}
+/** Legt het bericht vast als "in analyse" (één tegelijk) en bewaakt de limieten. */
+async function claimAnalysis(admin, messageId, force, trigger) {
+    const { data, error } = await admin.rpc("mailbox_claim_analysis", {
+        p_message_id: messageId,
+        p_force: force,
+        p_trigger: trigger,
+    });
+    if (error)
+        throw new Error(`Analyse vastleggen mislukt: ${error.message}`);
+    return (data ?? {});
+}
+/** Analyseert de mail en vult alle afgeleide velden (locatie, belading, prijs). */
+async function analyzeAndBuild(admin, msg, customerId, text, s) {
+    const idx = await loadProductIndex(admin);
+    const attempt = await aiParseMessage(admin, {
+        customerId,
+        subject: msg.subject ?? "",
+        text,
+        receivedAt: msg.received_at ? new Date(msg.received_at) : new Date(),
+        settings: s,
+        idx,
+    });
     const parsed = attempt.parsed;
-    const fieldValue = (key) => {
+    const fieldMeta = {};
+    const fv = (key) => {
         const v = parsed?.fields?.[key]?.value;
         return v === undefined ? null : v;
     };
-    const deliveryDate = typeof fieldValue("delivery_date") === "string" ? fieldValue("delivery_date") : null;
-    const notesValue = typeof fieldValue("notes") === "string" ? fieldValue("notes") : null;
-    // Afleveradres: AI-herkenning wint, anders de hoofdafleverlocatie van de klant.
-    const loc = await resolveDeliveryLocation(admin, matchResult.customerId, fieldValue("delivery_location"));
+    if (parsed) {
+        for (const [k, v] of Object.entries(parsed.fields)) {
+            if (v.value !== null && v.value !== undefined && v.value !== "")
+                fieldMeta[k] = { confidence: v.confidence, source: "uit mail" };
+        }
+    }
+    const loc = await resolveDeliveryLocation(admin, customerId, fv("delivery_location"), `${msg.subject ?? ""}\n${text}`);
     if (loc && parsed) {
+        const fromMail = loc.source !== "vast";
         parsed.fields = {
             ...parsed.fields,
-            delivery_location: loc.primary
-                ? { value: loc.id, confidence: 0.5, needs_review: true }
-                : (parsed.fields?.delivery_location ?? { value: loc.id, confidence: 0.9, needs_review: false }),
+            delivery_location: fromMail
+                ? { value: loc.id, confidence: Math.max(0.9, parsed.fields?.delivery_location?.confidence ?? 0), needs_review: false }
+                : { value: loc.id, confidence: 0.7, needs_review: false },
         };
+        fieldMeta.delivery_location = { confidence: fromMail ? 0.9 : 0.7, source: fromMail ? "uit mail" : "afgeleid" };
     }
-    // Afhaallocatie: AI-herkenning wint, anders de hoofd-afhaallocatie.
-    const pick = await resolvePickupLocation(admin, fieldValue("pickup_location"));
+    else if (parsed?.fields?.delivery_location) {
+        delete parsed.fields.delivery_location;
+    }
+    const pick = await resolvePickupLocation(admin, fv("pickup_location"));
     if (pick && parsed) {
         parsed.fields = {
             ...parsed.fields,
             pickup_location: pick.primary
-                ? { value: pick.id, confidence: 0.5, needs_review: true }
+                ? { value: pick.id, confidence: 0.7, needs_review: false }
                 : (parsed.fields?.pickup_location ?? { value: pick.id, confidence: 0.9, needs_review: false }),
         };
+        fieldMeta.pickup_location = { confidence: pick.primary ? 0.7 : 0.9, source: pick.primary ? "standaard" : "uit mail" };
     }
-    // Ladingdrager: alleen wat de Engine toestaat.
-    const lc = await resolveLoadCarrier(admin, messageId, fieldValue("load_carrier"));
+    const lc = await resolveLoadCarrier(admin, msg.id, fv("load_carrier"));
     if (lc.code && parsed) {
-        parsed.fields = {
-            ...parsed.fields,
-            load_carrier: { value: lc.code, confidence: 0.6, needs_review: false },
-        };
+        parsed.fields = { ...parsed.fields, load_carrier: { value: lc.code, confidence: 0.6, needs_review: false } };
+        fieldMeta.load_carrier = { confidence: 0.6, source: "standaard" };
     }
     const blockedNote = lc.blocked
         ? `Handmatig controleren - ladingdrager uitgeschakeld: "${lc.detectedLabel}" staat uit in de Rule Engine.`
         : null;
+    const lines = parsed ? enrichLines(parsed, idx, attempt.candidateIds) : [];
     const validation = parsed
-        ? computeValidation(parsed, attempt.requiredFields, { customerId: matchResult.customerId })
+        ? computeValidation(parsed, attempt.requiredFields, { customerId, lines, confGreen: Number(s.conf_green) })
         : null;
+    const reference = typeof fv("reference") === "string" && fv("reference").trim() ? String(fv("reference")).trim().slice(0, 120) : null;
+    const notesValue = typeof fv("notes") === "string" ? fv("notes") : null;
+    const deliveryDate = typeof fv("delivery_date") === "string" && /^\d{4}-\d{2}-\d{2}$/.test(fv("delivery_date")) ? fv("delivery_date") : null;
+    const duplicate = await findDuplicate(admin, {
+        customerId,
+        reference,
+        lines,
+        days: Number(s.duplicate_days ?? 7),
+        messageId: msg.id,
+    });
+    return {
+        attempt,
+        lines,
+        validation,
+        deliveryDate,
+        reference,
+        customerId,
+        notes: blockedNote ? [blockedNote, notesValue].filter(Boolean).join("\n") : notesValue,
+        confidence: parsed ? parsed.overall_confidence : customerId ? 1 : 0,
+        payloadExtra: {
+            load_carrier: lc.code,
+            load_carrier_blocked: lc.blocked,
+            load_carrier_detected: lc.detectedLabel,
+            field_meta: fieldMeta,
+            duplicate_of: duplicate,
+            attachment_unread: hasUnreadAttachment(msg),
+            readiness: readiness(validation, lines, !!loc, !!customerId),
+            thresholds: { green: Number(s.conf_green), orange: Number(s.conf_orange) },
+            blockedMessageStatus: lc.blocked,
+        },
+    };
+}
+/**
+ * Maakt exact één voorstel per bericht. Eerst het voorfilter (zonder AI), dan
+ * het vastleggen van de analyse (één tegelijk + limieten), en pas dan de AI.
+ */
+export async function createStubProposal(admin, messageId, fromEmail, opts = {}) {
+    const { data: existing } = await admin
+        .from("mailbox_order_proposals")
+        .select("id")
+        .eq("message_id", messageId)
+        .maybeSingle();
+    if (existing?.id)
+        return { status: "exists" };
+    const msg = await loadMessage(admin, messageId);
+    if (!msg)
+        return { status: "skipped", reason: "Bericht niet gevonden" };
+    // Al eerder beoordeeld als "geen bestelling" of "wacht": niet opnieuw (kost niets, maar ook geen AI).
+    if (!opts.force && msg.filter_outcome)
+        return { status: "skipped", reason: "Al beoordeeld" };
+    const s = await loadFilterSettings(admin);
+    const ai = await loadMailboxAiSettings(admin);
+    const body = emailBodyText(msg.body_text, msg.body_html);
+    const latest = extractLatestPart(body);
+    const senderEmail = normalizeEmail(latest.forwardedFrom ?? fromEmail ?? msg.from_email);
+    const matchResult = await senderMatch(admin, senderEmail, s);
+    const setMsg = (patch) => admin.from("mailbox_messages").update(patch).eq("id", messageId);
+    if (!opts.force) {
+        const cls = classifyMessage({ fromEmail: senderEmail, subject: msg.subject ?? "", body: latest.text, knownSender: !!matchResult.customerId }, s);
+        await setMsg({ filter_outcome: cls.outcome, filter_reason: cls.reason });
+        if (cls.outcome === "geen_bestelling") {
+            await setMsg({ status: "skipped" });
+            return { status: "skipped", reason: cls.reason };
+        }
+        if (cls.outcome === "onbekend_met_signalen" && !s.analyze_unknown_with_signals) {
+            await setMsg({ analysis_state: "wacht", analysis_note: "Onbekende afzender: automatisch analyseren staat uit" });
+            return { status: "waiting" };
+        }
+        if (!ai.enabled) {
+            await setMsg({ analysis_state: "wacht", analysis_note: "Automatisch analyseren staat uit" });
+            return { status: "waiting" };
+        }
+    }
+    else {
+        await setMsg({ filter_outcome: msg.filter_outcome ?? "analyseren", filter_reason: "Handmatig gestart" });
+    }
+    const claim = await claimAnalysis(admin, messageId, opts.force === true, opts.trigger ?? "auto");
+    if (!claim.ok) {
+        return claim.reason === "busy" ? { status: "busy" } : { status: "waiting", reason: claim.reason };
+    }
+    let built;
+    try {
+        built = await analyzeAndBuild(admin, msg, matchResult.customerId, latest.text, s);
+    }
+    catch (e) {
+        await finishRun(admin, claim.run_id ?? null, messageId, {
+            parsed: null, meta: null, error: String(e?.message ?? e).slice(0, 500), requiredFields: [], candidateIds: new Set(),
+        });
+        throw e;
+    }
+    const { currentAiFingerprint } = await import("./mailbox-ai.server.js");
+    const fingerprint = await currentAiFingerprint(admin).catch(() => null);
+    const parsed = built.attempt.parsed;
     const { data: proposal, error } = await admin
         .from("mailbox_order_proposals")
         .insert({
         message_id: messageId,
         matched_customer_id: matchResult.customerId,
-        confidence: parsed ? parsed.overall_confidence : matchResult.customerId ? 1 : 0,
-        delivery_date: deliveryDate,
-        notes: blockedNote ? [blockedNote, notesValue].filter(Boolean).join("\n") : notesValue,
+        confidence: built.confidence,
+        delivery_date: built.deliveryDate,
+        notes: built.notes,
         status: "pending",
-        ai_validation: validation,
+        customer_reference: built.reference,
+        ai_validation: built.validation,
         parsed_payload: {
-            ...basePayload,
+            auto_matched_customer: matchResult.customerId !== null,
+            auto_match_source: matchResult.source,
+            auto_match_email: senderEmail || null,
+            auto_match_forwarded: !!latest.forwardedFrom,
+            auto_match_warning: matchResult.warning,
+            auto_match_candidates: matchResult.candidates,
             stub: parsed === null,
             reason: parsed === null ? "ai_unavailable" : null,
-            load_carrier: lc.code,
-            load_carrier_blocked: lc.blocked,
-            load_carrier_detected: lc.detectedLabel,
-            ai: aiPayloadBlock(attempt, fingerprint),
+            ai: aiPayloadBlock(built.attempt, fingerprint, undefined, s.max_retry_attempts),
             fields: parsed?.fields ?? null,
-            validation,
+            validation: built.validation,
+            ...built.payloadExtra,
         },
     })
         .select("id")
         .single();
-    // 23505 = unique-violation op message_id: een concurrent trigger heeft 'm
-    // net ingevoegd. Idempotent — negeren. Alle andere fouten laten we bubbelen.
+    // Pas na het opslaan van het voorstel de analyse afsluiten, zodat een
+    // gelijktijdige trigger het bericht niet opnieuw kan claimen.
+    await finishRun(admin, claim.run_id ?? null, messageId, built.attempt);
     if (error) {
         if (error.code === "23505")
-            return;
+            return { status: "exists" };
         throw new Error(error.message);
     }
     const proposalId = proposal.id;
     if (parsed)
-        await writeParsedDetails(admin, proposalId, parsed);
-    else if (loc) {
-        await admin.from("mailbox_proposal_field_values").insert({
-            proposal_id: proposalId,
-            field_key: "delivery_location",
-            value: loc.id,
-            ai_confidence: 0.5,
-            ai_filled: false,
-            needs_review: true,
-        });
-    }
-    if (!parsed && lc.code) {
-        await admin.from("mailbox_proposal_field_values").upsert({
-            proposal_id: proposalId,
-            field_key: "load_carrier",
-            value: lc.code,
-            ai_confidence: 0.6,
-            ai_filled: false,
-            needs_review: false,
-        }, { onConflict: "proposal_id,field_key" });
-    }
-    if (lc.blocked) {
-        await admin
-            .from("mailbox_messages")
-            .update({ status: "manual_review_load_carrier_disabled" })
-            .eq("id", messageId);
+        await writeParsedDetails(admin, proposalId, parsed, built.lines);
+    if (built.payloadExtra.blockedMessageStatus) {
+        await setMsg({ status: "manual_review_load_carrier_disabled" });
     }
+    return { status: "created" };
 }
 /**
  * Analyseert een bestaand (nog niet goedgekeurd) voorstel opnieuw met de
  * huidige AI-agent. De vorige AI-analyse wordt vervangen.
  */
-export async function reparseProposal(admin, proposalId) {
+export async function reparseProposal(admin, proposalId, opts = {}) {
     const { data: prop } = await admin
         .from("mailbox_order_proposals")
         .select("id, message_id, status, matched_customer_id, parsed_payload")
@@ -546,20 +827,37 @@ export async function reparseProposal(admin, proposalId) {
     if (prop.status !== "pending") {
         return { ok: false, error: "Voorstel is al verwerkt — niet opnieuw geanalyseerd." };
     }
-    // Klantherkenning opnieuw proberen op basis van het afzenderadres.
+    const msg = await loadMessage(admin, prop.message_id);
+    if (!msg)
+        return { ok: false, error: "Bericht niet gevonden." };
+    const s = await loadFilterSettings(admin);
+    const body = emailBodyText(msg.body_text, msg.body_html);
+    const latest = extractLatestPart(body);
+    const senderEmail = normalizeEmail(latest.forwardedFrom ?? msg.from_email);
     let matchedCustomerId = prop.matched_customer_id ?? null;
-    const { data: msgRow } = await admin
-        .from("mailbox_messages")
-        .select("from_email")
-        .eq("id", prop.message_id)
-        .maybeSingle();
-    const senderEmail = normalizeEmail(msgRow?.from_email ?? null);
-    const rematch = matchedCustomerId ? null : await matchCustomerByEmail(admin, senderEmail);
+    const rematch = matchedCustomerId ? null : await senderMatch(admin, senderEmail, s);
     if (rematch?.customerId)
         matchedCustomerId = rematch.customerId;
+    const claim = await claimAnalysis(admin, msg.id, opts.force !== false, opts.trigger ?? "handmatig");
+    if (!claim.ok) {
+        return {
+            ok: false,
+            error: claim.reason === "busy" ? "Deze mail wordt al geanalyseerd." : "De limiet voor AI-analyses is bereikt.",
+        };
+    }
+    let built;
+    try {
+        built = await analyzeAndBuild(admin, msg, matchedCustomerId, latest.text, s);
+    }
+    catch (e) {
+        await finishRun(admin, claim.run_id ?? null, msg.id, {
+            parsed: null, meta: null, error: String(e?.message ?? e).slice(0, 500), requiredFields: [], candidateIds: new Set(),
+        });
+        return { ok: false, error: String(e?.message ?? e) };
+    }
+    await finishRun(admin, claim.run_id ?? null, msg.id, built.attempt);
     const { currentAiFingerprint } = await import("./mailbox-ai.server.js");
     const fingerprint = await currentAiFingerprint(admin).catch(() => null);
-    const attempt = await aiParseMessage(admin, prop.message_id, matchedCustomerId);
     const prevBase = (prop.parsed_payload && typeof prop.parsed_payload === "object" ? prop.parsed_payload : {});
     const base = rematch
         ? {
@@ -571,102 +869,53 @@ export async function reparseProposal(admin, proposalId) {
             auto_match_candidates: rematch.candidates,
         }
         : prevBase;
-    if (!attempt.parsed) {
-        // Mislukte hernieuwde analyse: bestaande gegevens laten staan, alleen de
-        // AI-status bijwerken zodat we niet in een lus blijven proberen.
+    if (!built.attempt.parsed) {
         await admin
             .from("mailbox_order_proposals")
-            .update({ parsed_payload: { ...base, ai: aiPayloadBlock(attempt, fingerprint, prevBase?.ai) } })
+            .update({ parsed_payload: { ...base, ai: aiPayloadBlock(built.attempt, fingerprint, base?.ai, s.max_retry_attempts) } })
             .eq("id", proposalId);
-        return { ok: false, error: attempt.error };
+        return { ok: false, error: built.attempt.error };
     }
-    const parsed = attempt.parsed;
-    const fv = (key) => {
-        const v = parsed.fields?.[key]?.value;
-        return v === undefined ? null : v;
-    };
-    // Afleveradres: AI-herkenning wint, anders de hoofdafleverlocatie van de klant.
-    const rloc = await resolveDeliveryLocation(admin, matchedCustomerId, fv("delivery_location"));
-    if (rloc) {
-        parsed.fields = {
-            ...parsed.fields,
-            delivery_location: rloc.primary
-                ? { value: rloc.id, confidence: 0.5, needs_review: true }
-                : (parsed.fields?.delivery_location ?? { value: rloc.id, confidence: 0.9, needs_review: false }),
-        };
-    }
-    // Afhaallocatie: AI-herkenning wint, anders de hoofd-afhaallocatie.
-    const rpick = await resolvePickupLocation(admin, fv("pickup_location"));
-    if (rpick) {
-        parsed.fields = {
-            ...parsed.fields,
-            pickup_location: rpick.primary
-                ? { value: rpick.id, confidence: 0.5, needs_review: true }
-                : (parsed.fields?.pickup_location ?? { value: rpick.id, confidence: 0.9, needs_review: false }),
-        };
-    }
-    // Ladingdrager: alleen wat de Engine toestaat.
-    const rlc = await resolveLoadCarrier(admin, prop.message_id, fv("load_carrier"));
-    if (rlc.code) {
-        parsed.fields = {
-            ...parsed.fields,
-            load_carrier: { value: rlc.code, confidence: 0.6, needs_review: false },
-        };
-    }
-    else if (parsed.fields) {
-        delete parsed.fields.load_carrier;
-    }
-    const rBlockedNote = rlc.blocked
-        ? `Handmatig controleren - ladingdrager uitgeschakeld: "${rlc.detectedLabel}" staat uit in de Rule Engine.`
-        : null;
     await admin.from("mailbox_proposal_lines").delete().eq("proposal_id", proposalId);
     await admin.from("mailbox_proposal_field_values").delete().eq("proposal_id", proposalId);
-    const rvalidation = computeValidation(parsed, attempt.requiredFields, {
-        customerId: matchedCustomerId,
-    });
-    const notesFromAi = typeof fv("notes") === "string" ? fv("notes") : null;
     const { error: updErr } = await admin
         .from("mailbox_order_proposals")
         .update({
         matched_customer_id: matchedCustomerId,
-        confidence: parsed.overall_confidence,
-        delivery_date: typeof fv("delivery_date") === "string" ? fv("delivery_date") : null,
-        notes: rBlockedNote ? [rBlockedNote, notesFromAi].filter(Boolean).join("\n") : notesFromAi,
-        ai_validation: rvalidation,
+        confidence: built.confidence,
+        delivery_date: built.deliveryDate,
+        notes: built.notes,
+        customer_reference: built.reference,
+        ai_validation: built.validation,
         parsed_payload: {
             ...base,
             stub: false,
             reason: null,
             reparsed: true,
-            load_carrier: rlc.code,
-            load_carrier_blocked: rlc.blocked,
-            load_carrier_detected: rlc.detectedLabel,
-            ai: aiPayloadBlock(attempt, fingerprint),
-            fields: parsed.fields,
-            validation: rvalidation,
+            ai: aiPayloadBlock(built.attempt, fingerprint),
+            fields: built.attempt.parsed.fields,
+            validation: built.validation,
+            ...built.payloadExtra,
         },
     })
         .eq("id", proposalId);
     if (updErr)
         return { ok: false, error: updErr.message };
-    if (rlc.blocked) {
-        await admin
-            .from("mailbox_messages")
-            .update({ status: "manual_review_load_carrier_disabled" })
-            .eq("id", prop.message_id);
+    if (built.payloadExtra.blockedMessageStatus) {
+        await admin.from("mailbox_messages").update({ status: "manual_review_load_carrier_disabled" }).eq("id", msg.id);
     }
-    await writeParsedDetails(admin, proposalId, parsed);
+    await writeParsedDetails(admin, proposalId, built.attempt.parsed, built.lines);
     return { ok: true, error: null };
 }
 /**
- * Detecteert een gewijzigde AI-agent: alle openstaande voorstellen waarvan de
- * opgeslagen vingerafdruk afwijkt van de huidige worden opnieuw geanalyseerd.
+ * Gewijzigde AI-agent: openstaande voorstellen opnieuw analyseren. Alleen via
+ * de knop, of automatisch tot het ingestelde maximum (standaard 0 = uit).
  */
 export async function reparseChangedAgentProposals(admin, limit = 25) {
     const { currentAiFingerprint } = await import("./mailbox-ai.server.js");
     const fingerprint = await currentAiFingerprint(admin).catch(() => null);
-    if (!fingerprint)
-        return { checked: 0, reparsed: 0, failed: 0, fingerprint: null };
+    if (!fingerprint || limit <= 0)
+        return { checked: 0, reparsed: 0, failed: 0, fingerprint };
     const { data: rows } = await admin
         .from("mailbox_order_proposals")
         .select("id, parsed_payload")
@@ -684,7 +933,7 @@ export async function reparseChangedAgentProposals(admin, limit = 25) {
         checked++;
         if (reparsed + failed >= limit)
             break;
-        const res = await reparseProposal(admin, r.id);
+        const res = await reparseProposal(admin, r.id, { force: false, trigger: "agent" });
         if (res.ok)
             reparsed++;
         else
@@ -692,13 +941,28 @@ export async function reparseChangedAgentProposals(admin, limit = 25) {
     }
     return { checked, reparsed, failed, fingerprint };
 }
+/** Telt openstaande voorstellen met een verouderde AI-analyse (voor de knop). */
+export async function countOutdatedAgentProposals(admin) {
+    const { currentAiFingerprint } = await import("./mailbox-ai.server.js");
+    const fingerprint = await currentAiFingerprint(admin).catch(() => null);
+    if (!fingerprint)
+        return 0;
+    const { data: rows } = await admin
+        .from("mailbox_order_proposals")
+        .select("parsed_payload")
+        .eq("status", "pending")
+        .limit(1000);
+    return (Array.isArray(rows) ? rows : []).filter((r) => {
+        const ai = r?.parsed_payload?.ai;
+        return ai?.ok === true && ai?.fingerprint && ai.fingerprint !== fingerprint;
+    }).length;
+}
 /**
  * Achtergrondherstel: voorstellen waarvan de AI-analyse door een tijdelijke
- * storing (bijv. model overbelast) mislukte, worden bij een volgende run
- * automatisch opnieuw geanalyseerd — tot AI_MAX_BACKGROUND_RETRIES pogingen.
- * Blijft strikt idempotent: alleen 'pending' voorstellen worden aangeraakt.
+ * storing mislukte, worden bij een volgende run opnieuw geanalyseerd — begrensd
+ * per run en per voorstel (instellingen), en binnen de dag-/maandlimiet.
  */
-export async function retryFailedAiProposals(admin, limit = 10) {
+export async function retryFailedAiProposals(admin, limit = 3, maxRetries = AI_MAX_BACKGROUND_RETRIES) {
     const { data: rows } = await admin
         .from("mailbox_order_proposals")
         .select("id, parsed_payload")
@@ -715,13 +979,13 @@ export async function retryFailedAiProposals(admin, limit = 10) {
             continue;
         if (ai.retry_pending !== true)
             continue;
-        if (Number(ai.retry_count ?? 0) >= AI_MAX_BACKGROUND_RETRIES)
+        if (Number(ai.retry_count ?? 0) >= maxRetries)
             continue;
         if (retried >= limit)
             break;
         retried++;
         try {
-            const res = await reparseProposal(admin, r.id);
+            const res = await reparseProposal(admin, r.id, { force: false, trigger: "herstel" });
             if (res.ok)
                 recovered++;
             else
@@ -876,11 +1140,12 @@ export async function runIngest(trigger) {
                     errorSample = `mark consumed: ${markErr.message}`.slice(0, 500);
             }
         }
-        // 5. Backfill: bestaande messages zonder proposal krijgen alsnog een stub.
+        // 5. Backfill: alleen berichten die nog nooit door het voorfilter zijn gegaan.
         const { data: orphans } = await supabaseAdmin
             .from("mailbox_messages")
             .select("id, from_email, mailbox_order_proposals(id)")
             .eq("connection_id", connectionId)
+            .is("filter_outcome", null)
             .order("received_at", { ascending: false })
             .limit(200);
         for (const m of (orphans ?? [])) {
@@ -888,7 +1153,7 @@ export async function runIngest(trigger) {
             if (props.length > 0)
                 continue;
             try {
-                await createStubProposal(supabaseAdmin, m.id, m.from_email ?? null);
+                await createStubProposal(supabaseAdmin, m.id, m.from_email ?? null, { trigger });
             }
             catch (e) {
                 errors++;
@@ -896,23 +1161,26 @@ export async function runIngest(trigger) {
                     errorSample = `orphan-stub: ${String(e?.message ?? e)}`.slice(0, 500);
             }
         }
-        // 6. Gewijzigde AI-agent? Openstaande voorstellen opnieuw analyseren.
-        try {
-            await reparseChangedAgentProposals(supabaseAdmin);
-        }
-        catch (e) {
-            errors++;
-            if (!errorSample)
-                errorSample = `reparse: ${String(e?.message ?? e)}`.slice(0, 500);
-        }
-        // 7. Herstelronde: mislukte AI-analyses door tijdelijke storingen opnieuw proberen.
-        try {
-            await retryFailedAiProposals(supabaseAdmin);
-        }
-        catch (e) {
-            errors++;
-            if (!errorSample)
-                errorSample = `reparse: ${String(e?.message ?? e)}`.slice(0, 500);
+        // 6 + 7. Gewijzigde AI-agent en herstelrondes: alleen vanuit cron en begrensd.
+        if (trigger === "cron") {
+            const s = await loadFilterSettings(supabaseAdmin);
+            try {
+                if (Number(s.max_agent_reparse) > 0)
+                    await reparseChangedAgentProposals(supabaseAdmin, Number(s.max_agent_reparse));
+            }
+            catch (e) {
+                errors++;
+                if (!errorSample)
+                    errorSample = `reparse: ${String(e?.message ?? e)}`.slice(0, 500);
+            }
+            try {
+                await retryFailedAiProposals(supabaseAdmin, Number(s.max_retries_per_run), Number(s.max_retry_attempts));
+            }
+            catch (e) {
+                errors++;
+                if (!errorSample)
+                    errorSample = `retry: ${String(e?.message ?? e)}`.slice(0, 500);
+            }
         }
     }
     finally {
@@ -931,3 +1199,63 @@ export async function runIngest(trigger) {
     }
     return { ok: true, runId, processed, inserted, errors, errorSample, connectionId };
 }
+// ─── Testset: filter + extractie zonder voorstel of order ───────────────────
+export async function dryRunAnalysis(admin, input) {
+    const s = await loadFilterSettings(admin);
+    const latest = extractLatestPart(input.body);
+    const sender = normalizeEmail(latest.forwardedFrom ?? input.fromEmail);
+    const match = await senderMatch(admin, sender, s);
+    const known = !!match.customerId || input.simulateKnownSender === true;
+    const cls = classifyMessage({ fromEmail: sender, subject: input.subject, body: latest.text, knownSender: known }, s);
+    const analyze = cls.outcome === "analyseren" || (cls.outcome === "onbekend_met_signalen" && s.analyze_unknown_with_signals);
+    if (!analyze) {
+        return { filter: cls, sender, forwarded: !!latest.forwardedFrom, analyzed: false, tokens: { input: 0, output: 0 }, result: null };
+    }
+    const { data: run } = await admin.from("mailbox_ai_runs").insert({ trigger: "testset", is_test: true }).select("id").single();
+    const idx = await loadProductIndex(admin);
+    const attempt = await aiParseMessage(admin, {
+        customerId: match.customerId,
+        subject: input.subject,
+        text: latest.text,
+        receivedAt: new Date(),
+        settings: s,
+        idx,
+    });
+    if (run?.id) {
+        await admin.from("mailbox_ai_runs").update({
+            finished_at: new Date().toISOString(),
+            ok: !!attempt.parsed,
+            input_tokens: attempt.meta?.inputTokens ?? null,
+            output_tokens: attempt.meta?.outputTokens ?? null,
+            error: attempt.error,
+        }).eq("id", run.id);
+    }
+    const lines = attempt.parsed ? enrichLines(attempt.parsed, idx, attempt.candidateIds) : [];
+    const f = (k) => attempt.parsed?.fields?.[k]?.value ?? null;
+    return {
+        filter: cls,
+        sender,
+        forwarded: !!latest.forwardedFrom,
+        analyzed: true,
+        tokens: { input: attempt.meta?.inputTokens ?? 0, output: attempt.meta?.outputTokens ?? 0 },
+        result: {
+            error: attempt.error,
+            customer_known: !!match.customerId,
+            delivery_date: typeof f("delivery_date") === "string" ? f("delivery_date") : null,
+            reference: typeof f("reference") === "string" ? f("reference") : null,
+            attachment_unread: input.hasAttachment,
+            lines: lines.map((l) => ({
+                text: l.name_in_mail || l.raw_product_text,
+                code: l.raw_code,
+                product_id: l.product_id,
+                product_known: !!l.product_id,
+                match_source: l.match_source,
+                quantity: l.qty_in_mail,
+                unit: l.unit_kind,
+                plants: l.plants,
+                unit_price: l.unit_price,
+                warnings: l.warnings,
+            })),
+        },
+    };
+}