hazo_collab_forms 2.2.8 → 3.0.2

package/dist/components/hazo_fb_form/hooks/use_llm_run.js

@@ -0,0 +1,1435 @@
+/**
+ * LLM "Run" pipeline hook - handles per-file classification + file routing to back-office.
+ *
+ * After classification, files are routed to matching back-office groups by tag_id,
+ * then autofill is triggered automatically on each group.
+ */
+'use client';
+import { useCallback, useRef } from 'react';
+import { use_logger } from '../../../logger/index.js';
+import { rule_to_fb_execution } from '../../../utils/rule_to_execution.js';
+/** Extract file info from a FileTextboxValue */
+function get_files_from_value(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((b) => b.type === 'file' && b.attachment?.file_id)
+        .map((b) => ({ file_id: b.attachment.file_id, file_name: b.attachment.file_name, attachment: b.attachment }));
+}
+/** Extract text content from a FileTextboxValue */
+function get_text_from_value(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .filter((b) => b.type === 'text' && b.content)
+        .map((b) => b.content)
+        .join('\n');
+}
+/** Build a map of tag_id -> group configs from back_sections */
+function build_tag_group_map(back_sections) {
+    const map = new Map();
+    for (const section of back_sections) {
+        for (const group of section.groups ?? []) {
+            const tag_id = group.tag_id;
+            if (tag_id) {
+                const existing = map.get(tag_id) ?? [];
+                existing.push(group);
+                map.set(tag_id, existing);
+            }
+        }
+    }
+    return map;
+}
+/** Route classified files to back-office groups and trigger autofill */
+async function route_files_to_back_office(options) {
+    const { classifications, back_sections, front_form_data, on_back_change, back_form_data, autofill_api_endpoint, file_manager, update_progress, set_group_autofill_log, run_log, tracker, on_autofill_file } = options;
+    const tag_group_map = build_tag_group_map(back_sections);
+    const errors = [];
+    const unassigned = [];
+    // Collect all classified files across all fields
+    const all_files = [];
+    for (const cls of classifications) {
+        const field_files = get_files_from_value(front_form_data[cls.field_id]);
+        for (const fc of cls.file_classifications) {
+            const file_info = field_files.find((f) => f.file_id === fc.file_id);
+            all_files.push({ ...fc, source_field_id: cls.field_id, attachment: file_info?.attachment });
+        }
+    }
+    // Track accumulated files per group locally to avoid stale state reads.
+    // React state updates from on_back_change are async, so reading back_form_data
+    // for the same key multiple times would miss prior additions within this loop.
+    const accumulated_files = new Map();
+    // Track which files are NEWLY routed (not already in back_form_data) — only these need autofill
+    const newly_routed_files = new Map();
+    const groups_to_autofill = new Set();
+    for (const file of all_files) {
+        let matched = false;
+        // Route each file to only ONE group — the first matching tag wins.
+        // Tags are ordered by priority (LLM returns best-match first), so
+        // iterating in order and breaking after the first match prevents a
+        // multi-tagged file from being duplicated across every matching group.
+        for (const tag of file.tags) {
+            const groups = tag_group_map.get(tag);
+            if (groups) {
+                matched = true;
+                for (const group of groups) {
+                    if (on_back_change && file.attachment) {
+                        const file_key = `__files_${group.id}`;
+                        // Seed from back_form_data on first access, then use local accumulator
+                        if (!accumulated_files.has(file_key)) {
+                            accumulated_files.set(file_key, [...(back_form_data[file_key] ?? [])]);
+                        }
+                        const current = accumulated_files.get(file_key);
+                        const is_new = !current.some((f) => f.file_id === file.file_id);
+                        if (is_new) {
+                            current.push(file.attachment);
+                            // Track as newly routed for autofill
+                            if (!newly_routed_files.has(file_key)) {
+                                newly_routed_files.set(file_key, []);
+                            }
+                            newly_routed_files.get(file_key).push(file.attachment);
+                            groups_to_autofill.add(group.id);
+                        }
+                    }
+                }
+                break; // First matching tag wins — don't duplicate to other groups
+            }
+        }
+        // Persist tags to hazo_files
+        if (file.tags.length > 0 && file_manager?.callbacks?.update_tags) {
+            try {
+                await file_manager.callbacks.update_tags(file.file_id, file.tags);
+            }
+            catch (err) {
+                errors.push({ step: `update_tags:${file.file_id}`, error: err instanceof Error ? err.message : 'Failed to update tags' });
+            }
+        }
+        if (!matched) {
+            unassigned.push({
+                file_id: file.file_id,
+                file_name: file.file_name,
+                tags: file.tags,
+                document_date: file.document_date,
+                document_nature: file.document_nature,
+                source_field_id: file.source_field_id,
+            });
+        }
+    }
+    // Flush accumulated files to state in one call per group
+    if (on_back_change) {
+        for (const [file_key, files] of accumulated_files) {
+            on_back_change(file_key, files);
+        }
+    }
+    // Trigger autofill only for NEWLY routed files (not files already in the group)
+    if (autofill_api_endpoint && groups_to_autofill.size > 0) {
+        let autofill_done = 0;
+        // Count total NEW files across all groups for progress
+        let total_autofills = 0;
+        for (const gid of groups_to_autofill) {
+            const fk = `__files_${gid}`;
+            const new_files = newly_routed_files.get(fk) ?? [];
+            total_autofills += Math.max(new_files.length, 1);
+        }
+        // Add autofill actions to the pipeline tracker (now that we know the count)
+        if (tracker) {
+            tracker.total += total_autofills;
+        }
+        for (const group_id of groups_to_autofill) {
+            // Find the group config to get prompt_area/prompt_key
+            let group_config;
+            for (const section of back_sections) {
+                group_config = section.groups?.find((g) => g.id === group_id);
+                if (group_config)
+                    break;
+            }
+            if (group_config?.prompt_area && group_config?.prompt_key) {
+                const file_key = `__files_${group_id}`;
+                // Only autofill newly routed files, not files already processed in prior runs
+                const group_files = newly_routed_files.get(file_key) ?? [];
+                const fields_schema = group_config.fields?.map((f) => ({
+                    field_id: f.id,
+                    label: f.label,
+                    field_type: f.field_type,
+                    component_type: f.component_type,
+                    table_config: f.table_config,
+                })) ?? [];
+                let group_fields_populated = 0;
+                let group_last_file_name = '';
+                let group_error = '';
+                const details = [];
+                // Track accumulated values per field to merge array data (tables) across files
+                const accumulated_field_values = new Map();
+                // Autofill API expects one file per request (matches AutofillRequest shape)
+                for (let fi = 0; fi < group_files.length; fi++) {
+                    const f = group_files[fi];
+                    group_last_file_name = f.file_name;
+                    autofill_done++;
+                    if (tracker)
+                        tracker.completed++;
+                    const pct = tracker ? `${Math.round((tracker.completed / tracker.total) * 100)}% ` : '';
+                    update_progress({
+                        current_step: `${pct}Auto-filling ${group_id} — file ${fi + 1}/${group_files.length} (${autofill_done}/${total_autofills})`,
+                        overall_percent: tracker ? Math.round((tracker.completed / tracker.total) * 100) : undefined,
+                    });
+                    on_autofill_file?.(f.file_id, true);
+                    try {
+                        const download_url = file_manager?.callbacks?.get_download_url?.(f.file_id, 'public') ?? '';
+                        const autofill_body = {
+                            file_id: f.file_id,
+                            file_name: f.file_name,
+                            mime_type: f.mime_type ?? 'application/octet-stream',
+                            download_url,
+                            group_id,
+                            prompt_area: group_config.prompt_area,
+                            prompt_key: group_config.prompt_key,
+                            fields: fields_schema,
+                        };
+                        const autofill_start = Date.now();
+                        const response = await fetch(autofill_api_endpoint, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(autofill_body),
+                        });
+                        const result = await response.json();
+                        run_log.push({
+                            step: 'autofill',
+                            label: `Autofill: ${group_id} — ${f.file_name}`,
+                            prompt_area: group_config.prompt_area,
+                            prompt_key: group_config.prompt_key,
+                            request: autofill_body,
+                            response: result,
+                            timestamp: autofill_start,
+                            duration_ms: Date.now() - autofill_start,
+                        });
+                        if (result.success && result.data && on_back_change) {
+                            const field_count = Object.keys(result.data).length;
+                            group_fields_populated += field_count;
+                            for (const [field_id, value] of Object.entries(result.data)) {
+                                // Capture detail entry
+                                const field_cfg = group_config.fields?.find((fld) => fld.id === field_id);
+                                const value_summary = Array.isArray(value)
+                                    ? `${value.length} row(s)`
+                                    : String(value ?? '').slice(0, 50);
+                                details.push({
+                                    field_id,
+                                    field_label: field_cfg?.label ?? field_id,
+                                    file_name: f.file_name,
+                                    value_summary,
+                                });
+                                // For arrays (data tables), append rows across files with source file metadata
+                                if (Array.isArray(value)) {
+                                    const tagged_rows = value.map((row) => ({
+                                        ...row,
+                                        _source_file_id: f.file_id,
+                                        _source_file_name: f.file_name,
+                                    }));
+                                    // Seed from existing back_form_data on first access so prior instance data is preserved
+                                    const existing = accumulated_field_values.get(field_id)
+                                        ?? (Array.isArray(back_form_data[field_id]) ? back_form_data[field_id] : undefined);
+                                    const merged = Array.isArray(existing) ? [...existing, ...tagged_rows] : tagged_rows;
+                                    accumulated_field_values.set(field_id, merged);
+                                    on_back_change(field_id, merged);
+                                }
+                                else {
+                                    // Scalar: last file wins
+                                    accumulated_field_values.set(field_id, value);
+                                    on_back_change(field_id, value);
+                                }
+                            }
+                        }
+                        else if (!result.success) {
+                            group_error = result.error || 'Autofill failed';
+                            errors.push({ step: `autofill:${group_id}`, error: group_error });
+                        }
+                        else if (result.success && (!result.data || Object.keys(result.data).length === 0)) {
+                            // Success but no data extracted
+                            if (!group_error && group_fields_populated === 0) {
+                                group_error = result.message || 'No matching data found in document';
+                            }
+                        }
+                    }
+                    catch (err) {
+                        group_error = err instanceof Error ? err.message : 'Autofill request failed';
+                        errors.push({ step: `autofill:${group_id}:${f.file_id}`, error: group_error });
+                    }
+                    finally {
+                        on_autofill_file?.(f.file_id, false);
+                    }
+                }
+                // Set autofill log for this group
+                if (group_error && group_fields_populated === 0) {
+                    // If there was an error and no fields were populated, check if it's a real error or just empty
+                    const is_empty = !errors.some((e) => e.step.startsWith(`autofill:${group_id}`));
+                    set_group_autofill_log((prev) => ({
+                        ...prev,
+                        [group_id]: {
+                            status: is_empty ? 'empty' : 'error',
+                            message: group_error,
+                            timestamp: Date.now(),
+                        },
+                    }));
+                }
+                else if (group_fields_populated > 0) {
+                    const file_label = group_files.length === 1 ? group_last_file_name : `${group_files.length} file(s)`;
+                    set_group_autofill_log((prev) => ({
+                        ...prev,
+                        [group_id]: {
+                            status: 'success',
+                            message: `Populated ${group_fields_populated} field(s) from ${file_label}`,
+                            timestamp: Date.now(),
+                            details,
+                        },
+                    }));
+                }
+                else {
+                    set_group_autofill_log((prev) => ({
+                        ...prev,
+                        [group_id]: {
+                            status: 'empty',
+                            message: 'No matching data found in document',
+                            timestamp: Date.now(),
+                        },
+                    }));
+                }
+            }
+            else {
+                autofill_done++;
+            }
+        }
+    }
+    return { unassigned, errors };
+}
+/** Build a lookup of user-resolved rule+file combinations from responded clarifications */
+function build_resolved_rules_map(clarifications) {
+    const map = new Map();
+    for (const item of clarifications) {
+        if (!item.rule_id)
+            continue;
+        if (item.status !== 'responded' && item.status !== 'resolved')
+            continue;
+        for (const ref of item.doc_references ?? []) {
+            if (!ref.file_id)
+                continue;
+            const key = `${item.rule_id}::${ref.file_id}`;
+            map.set(key, {
+                response_choice: item.response_choice,
+                user_comment: item.user_comment,
+            });
+        }
+    }
+    return map;
+}
+/** Validate classified files against matching validation rules */
+async function validate_classified_files(options) {
+    const { classifications, validation_api_endpoint, validation_rules, file_manager, front_form_data, update_progress, set_file_validation_results, run_log, tracker } = options;
+    const errors = [];
+    const all_validation_results = [];
+    const failed_file_ids = new Set();
+    // Collect all files with their document types
+    const files_to_validate = [];
+    for (const cls of classifications) {
+        // Look up file attachments from form data to get actual mime_type
+        const field_files = get_files_from_value(front_form_data[cls.field_id]);
+        const file_lookup = new Map(field_files.map(f => [f.file_id, f]));
+        for (const fc of cls.file_classifications) {
+            const source_file = file_lookup.get(fc.file_id);
+            files_to_validate.push({
+                file_id: fc.file_id,
+                file_name: fc.file_name,
+                mime_type: source_file?.attachment?.mime_type ?? 'application/octet-stream',
+                document_types: fc.document_type ?? [],
+                source_field_id: cls.field_id,
+            });
+        }
+    }
+    // Validation logging moved to hazo_logs (consumer configures via LoggerProvider)
+    const manual_review = options.manual_review_file_ids;
+    // Validate each file
+    for (let i = 0; i < files_to_validate.length; i++) {
+        const file = files_to_validate[i];
+        if (tracker)
+            tracker.completed++;
+        const pct = tracker ? `${Math.round((tracker.completed / tracker.total) * 100)}% ` : '';
+        update_progress({
+            current_step: `${pct}Validating ${file.file_name} (${i + 1}/${files_to_validate.length})`,
+            overall_percent: tracker ? Math.round((tracker.completed / tracker.total) * 100) : undefined,
+        });
+        // Skip validation for files marked for manual review by client
+        if (manual_review?.has(file.file_id)) {
+            const result = {
+                file_id: file.file_id,
+                file_name: file.file_name,
+                status: 'manual_review',
+                errors: [],
+                document_types: file.document_types,
+            };
+            all_validation_results.push(result);
+            set_file_validation_results((prev) => ({ ...prev, [file.file_id]: result }));
+            continue;
+        }
+        // Find matching rules by document_type.
+        // A rule matches if:
+        //   1. Its document_type is in the file's document_types, OR
+        //   2. Its document_type is 'general' (catch-all — always matches), OR
+        //   3. The file has no document_types (match all enabled rules)
+        const check_type_filter = options.check_type_filter;
+        // check_type filter: rules without check_type default to 'immediate' context.
+        // When filtering for 'backoffice', only explicitly backoffice rules run.
+        const matching_rules = validation_rules.filter((r) => r.enabled && (file.document_types.includes(r.document_type) ||
+            r.document_type === 'general' ||
+            file.document_types.length === 0) && (!check_type_filter || r.check_type === check_type_filter || (!r.check_type && check_type_filter === 'immediate')));
+        if (matching_rules.length === 0) {
+            // No rules match — preserve existing result if available (e.g. immediate passed),
+            // otherwise mark as skipped
+            set_file_validation_results((prev) => {
+                if (prev[file.file_id])
+                    return prev; // keep existing result
+                const result = {
+                    file_id: file.file_id,
+                    file_name: file.file_name,
+                    status: 'skipped',
+                    errors: [],
+                    document_types: file.document_types,
+                };
+                return { ...prev, [file.file_id]: result };
+            });
+            continue;
+        }
+        // Separate rules into user-resolved (skip LLM) and rules to execute
+        const resolved_map = options.resolved_rules;
+        const resolved_rule_results = [];
+        const rules_needing_execution = [];
+        for (const rule of matching_rules) {
+            const key = `${rule.rule_id}::${file.file_id}`;
+            const resolution = resolved_map?.get(key);
+            if (resolution) {
+                // User already resolved this rule for this file — skip LLM call
+                resolved_rule_results.push({
+                    rule_id: rule.rule_id,
+                    rule_name: rule.name,
+                    has_issue: true,
+                    user_resolved: true,
+                    user_resolution: {
+                        response_choice: resolution.response_choice,
+                        user_comment: resolution.user_comment,
+                    },
+                });
+            }
+            else {
+                rules_needing_execution.push(rule);
+            }
+        }
+        // If all rules are user-resolved, no need for LLM call
+        if (rules_needing_execution.length === 0) {
+            const validation_result = {
+                file_id: file.file_id,
+                file_name: file.file_name,
+                status: 'passed',
+                errors: [],
+                document_types: file.document_types,
+                rule_results: resolved_rule_results,
+            };
+            all_validation_results.push(validation_result);
+            set_file_validation_results((prev) => ({ ...prev, [file.file_id]: validation_result }));
+            continue;
+        }
+        // Mark as validating
+        set_file_validation_results((prev) => ({
+            ...prev,
+            [file.file_id]: {
+                file_id: file.file_id,
+                file_name: file.file_name,
+                status: 'validating',
+                errors: [],
+                document_types: file.document_types,
+            },
+        }));
+        try {
+            const download_url = file_manager?.callbacks?.get_download_url?.(file.file_id, 'public') ?? '';
+            const rules_to_execute = rules_needing_execution.map(rule_to_fb_execution);
+            const validate_body = {
+                file_name: file.file_name,
+                mime_type: file.mime_type,
+                download_url,
+                rules: rules_to_execute,
+            };
+            const validate_start = Date.now();
+            const response = await fetch(validation_api_endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(validate_body),
+            });
+            const result = await response.json();
+            run_log.push({
+                step: 'validate',
+                label: `Validate: ${file.file_name}`,
+                request: validate_body,
+                response: result,
+                timestamp: validate_start,
+                duration_ms: Date.now() - validate_start,
+            });
+            // Enrich rule_results with human-readable rule names from rules_needing_execution
+            const rule_name_lookup = new Map(rules_needing_execution.map(r => [r.rule_id, r.name]));
+            const enriched_rule_results = result.rule_results?.map(rr => ({
+                ...rr,
+                rule_name: rr.rule_name ?? rule_name_lookup.get(rr.rule_id),
+            })) ?? [];
+            // Merge user-resolved results with API results
+            const all_rule_results = [...resolved_rule_results, ...enriched_rule_results];
+            // Enrich clarification doc_references with actual file_id
+            const enriched_clarifications = (result.clarifications ?? []).map(c => ({
+                ...c,
+                doc_references: c.doc_references.map(ref => ({
+                    ...ref,
+                    file_id: ref.file_id || file.file_id,
+                })),
+            }));
+            const has_issues = enriched_clarifications.length > 0;
+            const validation_result = {
+                file_id: file.file_id,
+                file_name: file.file_name,
+                status: has_issues ? 'failed' : 'passed',
+                errors: enriched_clarifications,
+                document_types: file.document_types,
+                rule_results: all_rule_results,
+            };
+            all_validation_results.push(validation_result);
+            set_file_validation_results((prev) => ({ ...prev, [file.file_id]: validation_result }));
+            if (has_issues) {
+                failed_file_ids.add(file.file_id);
+            }
+        }
+        catch (err) {
+            errors.push({ step: `validate:${file.file_id}`, error: err instanceof Error ? err.message : 'Validation request failed' });
+            const error_result = {
+                file_id: file.file_id,
+                file_name: file.file_name,
+                status: 'failed',
+                errors: [],
+                document_types: file.document_types,
+                rule_results: resolved_rule_results.length > 0 ? resolved_rule_results : undefined,
+            };
+            all_validation_results.push(error_result);
+            set_file_validation_results((prev) => ({ ...prev, [file.file_id]: error_result }));
+            failed_file_ids.add(file.file_id);
+        }
+    }
+    // Build passed_classifications by filtering out failed files
+    const passed_classifications = classifications.map((cls) => {
+        const passed_file_cls = cls.file_classifications.filter((fc) => !failed_file_ids.has(fc.file_id));
+        const passed_tags = [...new Set(passed_file_cls.flatMap((fc) => fc.tags))];
+        return {
+            field_id: cls.field_id,
+            tags: passed_tags,
+            file_classifications: passed_file_cls,
+        };
+    }).filter((cls) => cls.file_classifications.length > 0);
+    return { passed_classifications, all_validation_results, errors };
+}
+export function use_llm_run({ props, update_progress, classification_results, set_classification_results, set_active_tab, add_classifying_files, remove_classifying_files, add_queued_files, remove_queued_files, set_unassigned_files, set_group_autofill_log, set_file_validation_results, manual_review_file_ids, sent_clarifications, pending_clarification_responses, draft_clarifications, file_validation_results, set_autofilling_file_ids, set_validating_file_ids }) {
+    const logger = use_logger();
+    // Refs to always read the latest values inside trigger_run,
+    // avoiding stale closures when submit flushes responses then immediately triggers a run.
+    const sent_clarifications_ref = useRef(sent_clarifications);
+    sent_clarifications_ref.current = sent_clarifications;
+    const pending_responses_ref = useRef(pending_clarification_responses);
+    pending_responses_ref.current = pending_clarification_responses;
+    const draft_clarifications_ref = useRef(draft_clarifications);
+    draft_clarifications_ref.current = draft_clarifications;
+    /** Classify a single file within a field and update results */
+    const trigger_classify_file = useCallback(async (field_id, file_id, file_name) => {
+        const { field_textbox_configs, llm_api_endpoint, front_form_data } = props;
+        logger.info('[use_llm_run] trigger_classify_file', { field_id, file_id, file_name, has_endpoint: !!llm_api_endpoint });
+        if (!field_textbox_configs || !llm_api_endpoint) {
+            logger.warn('[use_llm_run] classify_file_skipped: missing config', { has_configs: !!field_textbox_configs, has_endpoint: !!llm_api_endpoint });
+            return;
+        }
+        const config = field_textbox_configs[field_id];
+        if (!config)
+            return;
+        const client_text = get_text_from_value(front_form_data[field_id]);
+        add_classifying_files([file_id]);
+        update_progress({ status: 'classifying', total_steps: 1, completed_steps: 0, current_step: `Classifying ${file_name}`, error: undefined });
+        try {
+            const response = await fetch(llm_api_endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    action: 'classify_files',
+                    field_id,
+                    files: [{ file_id, file_name }],
+                    client_text,
+                    prompt_area: config.classification.prompt_area,
+                    prompt_key: config.classification.prompt_key,
+                    available_tags: config.classification.available_tags ?? props.available_tags ?? [],
+                    ...(props.available_document_types?.length ? { available_document_types: props.available_document_types } : {}),
+                }),
+            });
+            const result = await response.json();
+            logger.debug('[use_llm_run] classify_file_response', { file_id, success: result.success, classification_count: result.file_classifications?.length ?? 0 });
+            if (result.success && result.file_classifications) {
+                const new_file_cls = result.file_classifications;
+                // Merge: replace this file's classification, keep others.
+                // Use functional update to avoid stale closure when multiple files classify concurrently.
+                set_classification_results((prev_results) => {
+                    const prev = prev_results.find((c) => c.field_id === field_id);
+                    const existing_file_cls = prev?.file_classifications?.filter((fc) => fc.file_id !== file_id) ?? [];
+                    const all_file_cls = [...existing_file_cls, ...new_file_cls];
+                    const all_tags = [...new Set(all_file_cls.flatMap((fc) => fc.tags))];
+                    const updated_result = { field_id, tags: all_tags, file_classifications: all_file_cls };
+                    return [
+                        ...prev_results.filter((c) => c.field_id !== field_id),
+                        updated_result,
+                    ];
+                });
+            }
+            // Validate the re-classified file (if configured)
+            if (result.success && result.file_classifications) {
+                const new_file_cls = result.file_classifications;
+                const single_classification = {
+                    field_id,
+                    tags: [...new Set(new_file_cls.flatMap((fc) => fc.tags))],
+                    file_classifications: new_file_cls,
+                };
+                if (props.validation_api_endpoint && props.validation_rules?.length) {
+                    // Classification done — switch from classifying to validating state
+                    remove_classifying_files([file_id]);
+                    set_validating_file_ids(prev => { const s = new Set(prev); s.add(file_id); return s; });
+                    update_progress({ status: 'validating', total_steps: 2, completed_steps: 1, current_step: `Validating ${file_name}...` });
+                    const run_log = [];
+                    await validate_classified_files({
+                        classifications: [single_classification],
+                        validation_api_endpoint: props.validation_api_endpoint,
+                        validation_rules: props.validation_rules,
+                        file_manager: props.file_manager,
+                        front_form_data: props.front_form_data,
+                        update_progress,
+                        set_file_validation_results,
+                        run_log,
+                        manual_review_file_ids,
+                        check_type_filter: 'immediate',
+                    });
+                }
+            }
+            // Phase 1 complete — routing deferred to trigger_complete
+            update_progress({ status: 'validated', total_steps: 2, completed_steps: 2, current_step: undefined, error: undefined });
+        }
+        catch (err) {
+            logger.error('[use_llm_run] classify_file_error', { file_id, file_name, error: err instanceof Error ? err.message : String(err) });
+            update_progress({
+                status: 'error',
+                total_steps: 1,
+                completed_steps: 0,
+                current_step: undefined,
+                error: err instanceof Error ? err.message : 'Classification failed',
+            });
+        }
+        finally {
+            remove_classifying_files([file_id]);
+            set_validating_file_ids(prev => { const s = new Set(prev); s.delete(file_id); return s; });
+        }
+    }, [props, classification_results, update_progress, set_classification_results, add_classifying_files, remove_classifying_files, set_unassigned_files, set_group_autofill_log, set_file_validation_results, manual_review_file_ids, set_validating_file_ids]);
+    /** Manually assign a file to a tag and route it to matching back-office group */
+    const trigger_assign_file = useCallback(async (file_id, tag_id) => {
+        const { back_sections, on_back_change, back_form_data, autofill_api_endpoint, file_manager, front_form_data } = props;
+        // Find the file attachment from front_form_data
+        let attachment;
+        let file_name = '';
+        for (const [_field_id, value] of Object.entries(front_form_data)) {
+            const files = get_files_from_value(value);
+            const found = files.find((f) => f.file_id === file_id);
+            if (found?.attachment) {
+                attachment = found.attachment;
+                file_name = found.file_name;
+                break;
+            }
+        }
+        if (!attachment)
+            return;
+        const tag_group_map = build_tag_group_map(back_sections);
+        const groups = tag_group_map.get(tag_id);
+        if (groups && on_back_change) {
+            for (const group of groups) {
+                const file_key = `__files_${group.id}`;
+                const existing_files = back_form_data[file_key] ?? [];
+                if (!existing_files.some((f) => f.file_id === file_id)) {
+                    on_back_change(file_key, [...existing_files, attachment]);
+                }
+                // Trigger autofill for this group (single file, matches AutofillRequest shape)
+                if (autofill_api_endpoint && group.prompt_area && group.prompt_key) {
+                    try {
+                        const download_url = file_manager?.callbacks?.get_download_url?.(attachment.file_id, 'public') ?? '';
+                        const response = await fetch(autofill_api_endpoint, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                file_id: attachment.file_id,
+                                file_name: attachment.file_name,
+                                mime_type: attachment.mime_type ?? 'application/octet-stream',
+                                download_url,
+                                group_id: group.id,
+                                prompt_area: group.prompt_area,
+                                prompt_key: group.prompt_key,
+                                fields: group.fields?.map((f) => ({
+                                    field_id: f.id,
+                                    label: f.label,
+                                    field_type: f.field_type,
+                                    component_type: f.component_type,
+                                    table_config: f.table_config,
+                                })) ?? [],
+                            }),
+                        });
+                        const result = await response.json();
+                        if (result.success && result.data) {
+                            const field_count = Object.keys(result.data).length;
+                            for (const [field_id, value] of Object.entries(result.data)) {
+                                on_back_change(field_id, value);
+                            }
+                            set_group_autofill_log((prev) => ({
+                                ...prev,
+                                [group.id]: {
+                                    status: field_count > 0 ? 'success' : 'empty',
+                                    message: field_count > 0
+                                        ? `Populated ${field_count} field(s) from ${file_name}`
+                                        : result.message || 'No matching data found in document',
+                                    timestamp: Date.now(),
+                                },
+                            }));
+                        }
+                        else if (!result.success) {
+                            set_group_autofill_log((prev) => ({
+                                ...prev,
+                                [group.id]: {
+                                    status: 'error',
+                                    message: result.error || 'Autofill failed',
+                                    timestamp: Date.now(),
+                                },
+                            }));
+                        }
+                    }
+                    catch (err) {
+                        // Autofill error logged via group_autofill_log
+                        set_group_autofill_log((prev) => ({
+                            ...prev,
+                            [group.id]: {
+                                status: 'error',
+                                message: err instanceof Error ? err.message : 'Autofill request failed',
+                                timestamp: Date.now(),
+                            },
+                        }));
+                    }
+                }
+            }
+        }
+        // Persist tags
+        if (file_manager?.callbacks?.update_tags) {
+            try {
+                await file_manager.callbacks.update_tags(file_id, [tag_id]);
+            }
+            catch (err) {
+                // Tag update error — non-critical, file_manager may not support update_tags
+            }
+        }
+        // Remove from unassigned files list (handled by caller via set_unassigned_files)
+    }, [props, set_group_autofill_log]);
+    const trigger_run = useCallback(async (mode = 'new_only') => {
+        const { field_textbox_configs, llm_api_endpoint, front_form_data, on_back_change, back_form_data, back_sections, autofill_api_endpoint, file_manager, on_run_complete } = props;
+        const run_start = Date.now();
+        logger.info('[use_llm_run] trigger_run_start', {
+            mode,
+            has_configs: !!field_textbox_configs,
+            has_llm_endpoint: !!llm_api_endpoint,
+            has_autofill_endpoint: !!autofill_api_endpoint,
+            has_validation_endpoint: !!props.validation_api_endpoint,
+            field_count: field_textbox_configs ? Object.keys(field_textbox_configs).length : 0,
+            validation_rule_count: props.validation_rules?.length ?? 0,
+        });
+        if (!field_textbox_configs || !llm_api_endpoint) {
+            logger.warn('[use_llm_run] trigger_run_aborted: missing config', { has_configs: !!field_textbox_configs, has_endpoint: !!llm_api_endpoint });
+            return;
+        }
+        set_group_autofill_log({});
+        // When running all, clear existing classification results (tags + metadata) upfront
+        if (mode === 'all') {
+            set_classification_results([]);
+        }
+        const all_field_ids = Object.keys(field_textbox_configs);
+        // Build list of fields that need classification and which files are new
+        const fields_to_process = [];
+        for (const field_id of all_field_ids) {
+            const current_files = get_files_from_value(front_form_data[field_id]);
+            if (current_files.length === 0)
+                continue;
+            const prev = classification_results.find((c) => c.field_id === field_id);
+            if (mode === 'all' || !prev) {
+                // Classify all files
+                fields_to_process.push({
+                    field_id,
+                    files_to_classify: current_files,
+                    existing_file_classifications: [],
+                });
+            }
+            else {
+                // Only classify new files (not previously classified)
+                const prev_file_cls = prev.file_classifications ?? [];
+                const classified_ids = new Set(prev_file_cls.map((fc) => fc.file_id));
+                const new_files = current_files.filter((f) => !classified_ids.has(f.file_id));
+                if (new_files.length > 0) {
+                    // Keep existing classifications for files still present
+                    const still_present_ids = new Set(current_files.map((f) => f.file_id));
+                    const kept = prev_file_cls.filter((fc) => still_present_ids.has(fc.file_id));
+                    fields_to_process.push({
+                        field_id,
+                        files_to_classify: new_files,
+                        existing_file_classifications: kept,
+                    });
+                }
+            }
+        }
+        logger.info('[use_llm_run] fields_to_process', {
+            count: fields_to_process.length,
+            total_files: fields_to_process.reduce((sum, f) => sum + f.files_to_classify.length, 0),
+            fields: fields_to_process.map(f => ({ field_id: f.field_id, file_count: f.files_to_classify.length, existing_count: f.existing_file_classifications.length })),
+        });
+        if (fields_to_process.length === 0) {
+            // No new files to classify — but still run backoffice validation if configured
+            // (immediate-only validation may have skipped backoffice-only rules)
+            const has_backoffice_validation = !!(props.validation_api_endpoint && props.validation_rules?.length);
+            const has_existing_classifications = classification_results.length > 0;
+            if (has_backoffice_validation && has_existing_classifications) {
+                update_progress({ status: 'validating', current_step: 'Running back-office validation...' });
+                const run_log = [];
+                const current_sent = sent_clarifications_ref.current;
+                const current_pending = pending_responses_ref.current;
+                const current_drafts = draft_clarifications_ref.current;
+                let effective_clarifications = current_sent;
+                if (current_pending.size > 0) {
+                    const pending_items = [];
+                    for (const [clar_id, response] of current_pending) {
+                        if (!response.response_choice)
+                            continue;
+                        if (current_sent.some(c => c.id === clar_id && (c.status === 'responded' || c.status === 'resolved')))
+                            continue;
+                        const original = current_drafts.find(c => c.id === clar_id) ?? current_sent.find(c => c.id === clar_id);
+                        if (original) {
+                            pending_items.push({ ...original, status: 'responded', response_choice: response.response_choice, user_comment: response.user_comment });
+                        }
+                    }
+                    if (pending_items.length > 0) {
+                        effective_clarifications = [...current_sent, ...pending_items];
+                    }
+                }
+                const resolved_rules = build_resolved_rules_map(effective_clarifications);
+                const vr = await validate_classified_files({
+                    classifications: classification_results,
+                    validation_api_endpoint: props.validation_api_endpoint,
+                    validation_rules: props.validation_rules,
+                    file_manager: props.file_manager,
+                    front_form_data,
+                    update_progress,
+                    set_file_validation_results,
+                    run_log,
+                    manual_review_file_ids,
+                    check_type_filter: 'backoffice',
+                    resolved_rules,
+                });
+                // Trigger completion with existing classifications + new validation results
+                const run_result = {
+                    classifications: classification_results,
+                    unassigned_files: [],
+                    validation_results: vr.all_validation_results,
+                    errors: vr.errors,
+                };
+                update_progress({ status: 'validated', total_steps: 0, completed_steps: 0, current_step: undefined, error: undefined });
+                return;
+            }
+            update_progress({ status: 'validated', total_steps: 0, completed_steps: 0, current_step: undefined, error: undefined });
+            return;
+        }
+        // Build overall pipeline tracker: classify + validate + autofill (autofill count added dynamically)
+        const total_files_for_validation = fields_to_process.flatMap((f) => f.files_to_classify).length;
+        const has_validation = !!(props.validation_api_endpoint && props.validation_rules?.length);
+        const tracker = {
+            completed: 0,
+            total: fields_to_process.length + (has_validation ? total_files_for_validation : 0),
+            // autofill actions are added to total in route_files_to_back_office once known
+        };
+        update_progress({ status: 'classifying', total_steps: fields_to_process.length, completed_steps: 0, overall_percent: 0, error: undefined });
+        const new_classifications = [];
+        const errors = [];
+        const run_log = [];
+        // Mark all files as queued initially
+        const all_file_ids = fields_to_process.flatMap((f) => f.files_to_classify.map((file) => file.file_id));
+        add_queued_files(all_file_ids);
+        // Step 1: Per-field classification with batch support
+        const batch_size = props.classification_batch_size ?? 5;
+        for (let i = 0; i < fields_to_process.length; i++) {
+            const { field_id, files_to_classify, existing_file_classifications } = fields_to_process[i];
+            const config = field_textbox_configs[field_id];
+            // Move this field's files from queued → classifying
+            const field_file_ids = files_to_classify.map((f) => f.file_id);
+            remove_queued_files(field_file_ids);
+            add_classifying_files(field_file_ids);
+            const client_text = get_text_from_value(front_form_data[field_id]);
+            tracker.completed++;
+            const pct = Math.round((tracker.completed / tracker.total) * 100);
+            update_progress({
+                current_step: `${pct}% Classifying ${files_to_classify.length} file(s) in ${field_id} (${i + 1}/${fields_to_process.length})`,
+                completed_steps: i,
+                overall_percent: pct,
+            });
+            // Split files into batches to reduce per-call overhead
+            const batches = [];
+            for (let b = 0; b < files_to_classify.length; b += batch_size) {
+                batches.push(files_to_classify.slice(b, b + batch_size));
+            }
+            const batch_file_cls = [];
+            let batch_failed = false;
+            for (let bi = 0; bi < batches.length; bi++) {
+                const batch = batches[bi];
+                try {
+                    const classify_body = {
+                        action: 'classify_files',
+                        field_id,
+                        files: batch,
+                        client_text,
+                        prompt_area: config.classification.prompt_area,
+                        prompt_key: config.classification.prompt_key,
+                        available_tags: config.classification.available_tags ?? props.available_tags ?? [],
+                        ...(props.available_document_types?.length ? { available_document_types: props.available_document_types } : {}),
+                    };
+                    const classify_start = Date.now();
+                    const response = await fetch(llm_api_endpoint, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(classify_body),
+                    });
+                    const result = await response.json();
+                    run_log.push({
+                        step: 'classify',
+                        label: `Classification: ${field_id}${batches.length > 1 ? ` (batch ${bi + 1}/${batches.length})` : ''}`,
+                        prompt_area: config.classification.prompt_area,
+                        prompt_key: config.classification.prompt_key,
+                        request: classify_body,
+                        response: result,
+                        timestamp: classify_start,
+                        duration_ms: Date.now() - classify_start,
+                    });
+                    if (result.success && result.file_classifications) {
+                        batch_file_cls.push(...result.file_classifications);
+                    }
+                    else {
+                        errors.push({ step: `classify:${field_id}`, error: result.error || 'Classification failed' });
+                        batch_failed = true;
+                    }
+                }
+                catch (err) {
+                    errors.push({ step: `classify:${field_id}`, error: err instanceof Error ? err.message : 'Unknown error' });
+                    batch_failed = true;
+                }
+            }
+            if (!batch_failed || batch_file_cls.length > 0) {
+                const all_file_cls = [...existing_file_classifications, ...batch_file_cls];
+                const all_tags = [...new Set(all_file_cls.flatMap((fc) => fc.tags))];
+                new_classifications.push({
+                    field_id,
+                    tags: all_tags,
+                    file_classifications: all_file_cls,
+                });
+            }
+            // Clear classifying state for this field's files
+            remove_classifying_files(field_file_ids);
+        }
+        logger.info('[use_llm_run] classification_phase_complete', {
+            new_classification_count: new_classifications.length,
+            total_file_classifications: new_classifications.reduce((sum, c) => sum + c.file_classifications.length, 0),
+            error_count: errors.length,
+            duration_ms: Date.now() - run_start,
+        });
+        // Merge with existing results for fields that weren't re-processed
+        const processed_field_ids = new Set(fields_to_process.map((f) => f.field_id));
+        const prior_results = mode === 'all' ? [] : classification_results;
+        const merged_classifications = [
+            ...prior_results.filter((c) => !processed_field_ids.has(c.field_id)),
+            ...new_classifications,
+        ];
+        set_classification_results(merged_classifications);
+        // Step 2: Validate (if configured)
+        let all_validation_results = [];
+        if (props.validation_api_endpoint && props.validation_rules?.length) {
+            update_progress({ status: 'validating', current_step: 'Validating documents...' });
+            // Build resolved rules map from sent clarifications + pending responses.
+            // Use refs to get latest values — avoids stale closure when submit flushes responses then runs pipeline.
+            // Merge pending responses with sent clarifications so we don't re-validate already-resolved issues
+            // even if the parent component hasn't re-rendered with updated props yet.
+            const current_sent = sent_clarifications_ref.current;
+            const current_pending = pending_responses_ref.current;
+            const current_drafts = draft_clarifications_ref.current;
+            let effective_clarifications = current_sent;
+            if (current_pending.size > 0) {
+                // Create synthetic responded items from pending responses
+                const pending_items = [];
+                for (const [clar_id, response] of current_pending) {
+                    if (!response.response_choice)
+                        continue;
+                    // Skip if already in sent_clarifications as responded
+                    if (current_sent.some(c => c.id === clar_id && (c.status === 'responded' || c.status === 'resolved')))
+                        continue;
+                    const original = current_drafts.find(c => c.id === clar_id) ?? current_sent.find(c => c.id === clar_id);
+                    if (original) {
+                        pending_items.push({
+                            ...original,
+                            status: 'responded',
+                            response_choice: response.response_choice,
+                            user_comment: response.user_comment,
+                        });
+                    }
+                }
+                if (pending_items.length > 0) {
+                    effective_clarifications = [...current_sent, ...pending_items];
+                }
+            }
+            const resolved_rules = build_resolved_rules_map(effective_clarifications);
+            const vr = await validate_classified_files({
+                classifications: new_classifications,
+                validation_api_endpoint: props.validation_api_endpoint,
+                validation_rules: props.validation_rules,
+                file_manager: props.file_manager,
+                front_form_data,
+                update_progress,
+                set_file_validation_results,
+                run_log,
+                tracker,
+                manual_review_file_ids,
+                check_type_filter: 'backoffice',
+                resolved_rules,
+            });
+            all_validation_results = vr.all_validation_results;
+            errors.push(...vr.errors);
+            logger.info('[use_llm_run] validation_phase_complete', {
+                total_results: vr.all_validation_results.length,
+                passed: vr.all_validation_results.filter(r => r.status === 'passed').length,
+                failed: vr.all_validation_results.filter(r => r.status === 'failed').length,
+                skipped: vr.all_validation_results.filter(r => r.status === 'skipped').length,
+                validation_errors: vr.errors.length,
+            });
+        }
+        // Phase 1 complete: classification + validation done.
+        // Routing + autofill deferred to trigger_complete (Phase 2).
+        const run_result = {
+            classifications: new_classifications,
+            unassigned_files: [],
+            validation_results: all_validation_results,
+            errors,
+        };
+        update_progress({
+            status: errors.length > 0 ? 'error' : 'validated',
+            completed_steps: fields_to_process.length,
+            total_steps: fields_to_process.length,
+            current_step: undefined,
+            overall_percent: 100,
+            error: errors.length > 0 ? `${errors.length} error(s) during processing` : undefined,
+            error_details: errors.length > 0 ? errors : undefined,
+            run_log,
+        });
+        logger.info('[use_llm_run] trigger_run_complete', {
+            mode,
+            total_duration_ms: Date.now() - run_start,
+            classification_count: new_classifications.length,
+            validation_count: all_validation_results.length,
+            error_count: errors.length,
+            run_log_entries: run_log.length,
+        });
+        on_run_complete?.(run_result);
+        // Switch to clarifications tab so user can review validation results
+        set_active_tab('clarifications');
+        // Note: sent_clarifications is read via ref (sent_clarifications_ref.current) to avoid stale closures
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props, classification_results, update_progress, set_classification_results, set_active_tab, add_classifying_files, remove_classifying_files, add_queued_files, remove_queued_files, set_unassigned_files, set_group_autofill_log, set_file_validation_results, manual_review_file_ids]);
+    /** Route specific files (by file_id) to back-office groups using their classification tags + trigger autofill.
+     *  Used by "skip validation and process" flow in clarifications view. */
+    const route_skipped_files = useCallback(async (file_ids) => {
+        if (file_ids.length === 0)
+            return;
+        const { back_sections, front_form_data, on_back_change, back_form_data, autofill_api_endpoint, file_manager } = props;
+        // Build synthetic passed_classifications containing only the specified files
+        const file_id_set = new Set(file_ids);
+        const synthetic_classifications = classification_results
+            .map((cls) => ({
+            field_id: cls.field_id,
+            tags: cls.tags,
+            file_classifications: cls.file_classifications.filter((fc) => file_id_set.has(fc.file_id)),
+        }))
+            .filter((cls) => cls.file_classifications.length > 0);
+        if (synthetic_classifications.length === 0)
+            return;
+        const run_log = [];
+        await route_files_to_back_office({
+            classifications: synthetic_classifications,
+            back_sections,
+            front_form_data,
+            on_back_change,
+            back_form_data,
+            autofill_api_endpoint,
+            file_manager,
+            update_progress,
+            set_group_autofill_log,
+            run_log,
+        });
+    }, [props, classification_results, update_progress, set_group_autofill_log]);
+    /** Phase 2: Route eligible files to back-office groups and trigger autofill.
+     *  Called when user clicks "Complete" after classification + validation (Phase 1).
+     *  Includes files that passed validation AND files whose validation issues were resolved
+     *  via clarifications. For resolved clarifications with response files, both the original
+     *  file and response files are routed using the original file's tags. */
+    const trigger_complete = useCallback(async () => {
+        const { on_back_change, back_form_data, back_sections, front_form_data, autofill_api_endpoint, file_manager, on_run_complete } = props;
+        const complete_start = Date.now();
+        logger.info('[use_llm_run] trigger_complete_start', {
+            classification_count: classification_results.length,
+            total_file_classifications: classification_results.reduce((sum, c) => sum + c.file_classifications.length, 0),
+            validation_result_count: Object.keys(file_validation_results).length,
+            has_on_back_change: !!on_back_change,
+            has_autofill_endpoint: !!autofill_api_endpoint,
+        });
+        if (!on_back_change)
+            return;
+        set_group_autofill_log({});
+        update_progress({ status: 'routing', total_steps: 1, completed_steps: 0, current_step: 'Routing files to back-office...', error: undefined });
+        const current_sent = sent_clarifications_ref.current;
+        const current_pending = pending_responses_ref.current;
+        const current_drafts = draft_clarifications_ref.current;
+        // Build a unified view of all clarification items with their latest status.
+        // Clarifications may be in drafts (auto-populated from validation), sent (approved by agent),
+        // or have pending responses (client responded but not yet flushed). Merge them all.
+        const all_clarification_items = new Map();
+        for (const item of current_drafts)
+            all_clarification_items.set(item.id, item);
+        for (const item of current_sent)
+            all_clarification_items.set(item.id, item);
+        // Apply pending responses on top
+        for (const [clar_id, response] of current_pending) {
+            const existing = all_clarification_items.get(clar_id);
+            if (existing && response.response_choice) {
+                all_clarification_items.set(clar_id, {
+                    ...existing,
+                    status: 'responded',
+                    response_choice: response.response_choice,
+                    user_comment: response.user_comment,
+                    response_files: response.response_files ?? existing.response_files ?? [],
+                });
+            }
+        }
+        // Build a lookup of all file attachments from front_form_data
+        const all_attachments = new Map();
+        for (const value of Object.values(front_form_data)) {
+            if (!Array.isArray(value))
+                continue;
+            for (const block of value) {
+                if (block?.type === 'file' && block?.attachment?.file_id) {
+                    all_attachments.set(block.attachment.file_id, block.attachment);
+                }
+            }
+        }
+        // Determine eligible files: passed/skipped validation, OR failed but all clarifications resolved
+        const eligible_classifications = [];
+        for (const cls of classification_results) {
+            const eligible_file_cls = [];
+            for (const fc of cls.file_classifications) {
+                const vr = file_validation_results[fc.file_id];
+                if (!vr || vr.status === 'passed' || vr.status === 'skipped') {
+                    eligible_file_cls.push(fc);
+                }
+                else if (vr.status === 'failed') {
+                    // Failed — check if ALL its clarification errors are resolved (in sent, drafts, or pending).
+                    // 'ignore' response means the user wants to skip this file entirely — treat as NOT resolved.
+                    const all_resolved = vr.errors.length === 0 || vr.errors.every(err => {
+                        const item = all_clarification_items.get(err.id);
+                        if (!item || (item.status !== 'responded' && item.status !== 'resolved'))
+                            return false;
+                        return item.response_choice !== 'ignore';
+                    });
+                    if (all_resolved) {
+                        eligible_file_cls.push(fc);
+                    }
+                }
+                // manual_review and other statuses: not eligible unless explicitly skipped
+            }
+            if (eligible_file_cls.length > 0) {
+                eligible_classifications.push({
+                    field_id: cls.field_id,
+                    tags: [...new Set(eligible_file_cls.flatMap(fc => fc.tags))],
+                    file_classifications: eligible_file_cls,
+                });
+            }
+        }
+        // Also include response files from resolved clarifications.
+        // These inherit the original file's tags and get routed to the same groups.
+        const routed_file_ids = new Set(eligible_classifications.flatMap(c => c.file_classifications.map(f => f.file_id)));
+        for (const item of all_clarification_items.values()) {
+            if ((item.status !== 'responded' && item.status !== 'resolved') || !item.response_files?.length)
+                continue;
+            const source_file_id = item.doc_references?.[0]?.file_id;
+            if (!source_file_id)
+                continue;
+            // Find the original file's tags
+            let source_tags = [];
+            let source_field_id = '';
+            for (const cls of classification_results) {
+                const fc = cls.file_classifications.find(f => f.file_id === source_file_id);
+                if (fc && fc.tags.length > 0) {
+                    source_tags = fc.tags;
+                    source_field_id = cls.field_id;
+                    break;
+                }
+            }
+            if (source_tags.length === 0)
+                continue;
+            const new_file_cls = [];
+            for (const att of item.response_files) {
+                if (!routed_file_ids.has(att.file_id)) {
+                    new_file_cls.push({ file_id: att.file_id, file_name: att.file_name, tags: source_tags });
+                    routed_file_ids.add(att.file_id);
+                }
+            }
+            if (new_file_cls.length > 0) {
+                eligible_classifications.push({
+                    field_id: source_field_id,
+                    tags: source_tags,
+                    file_classifications: new_file_cls,
+                });
+            }
+        }
+        // Route + autofill
+        const handle_autofill_file = (file_id, active) => {
+            set_autofilling_file_ids(prev => {
+                const next = new Set(prev);
+                if (active)
+                    next.add(file_id);
+                else
+                    next.delete(file_id);
+                return next;
+            });
+        };
+        const run_log = [];
+        const routing_result = await route_files_to_back_office({
+            classifications: eligible_classifications,
+            back_sections,
+            front_form_data,
+            on_back_change,
+            back_form_data,
+            autofill_api_endpoint,
+            file_manager,
+            update_progress,
+            set_group_autofill_log,
+            run_log,
+            on_autofill_file: handle_autofill_file,
+        });
+        set_unassigned_files(routing_result.unassigned);
+        logger.info('[use_llm_run] trigger_complete_done', {
+            duration_ms: Date.now() - complete_start,
+            eligible_file_count: eligible_classifications.reduce((sum, c) => sum + c.file_classifications.length, 0),
+            unassigned_count: routing_result.unassigned.length,
+            routing_errors: routing_result.errors.length,
+        });
+        update_progress({
+            status: routing_result.errors.length > 0 ? 'error' : 'done',
+            completed_steps: 1,
+            total_steps: 1,
+            current_step: undefined,
+            overall_percent: 100,
+            error: routing_result.errors.length > 0 ? `${routing_result.errors.length} error(s) during routing` : undefined,
+            run_log,
+        });
+        set_active_tab('back');
+    }, [props, classification_results, file_validation_results, update_progress, set_active_tab, set_unassigned_files, set_group_autofill_log]);
+    /** Run the back-office pipeline: backoffice validation → routing → autofill.
+     *  Classification is NOT re-run — it's already done per-file in the front office.
+     *  This is triggered manually by the "Run on Backoffice" button. */
+    const trigger_backoffice_run = useCallback(async () => {
+        const { on_back_change, back_form_data, back_sections, front_form_data, autofill_api_endpoint, file_manager, on_run_complete, validation_api_endpoint, validation_rules } = props;
+        const bo_start = Date.now();
+        logger.info('[use_llm_run] trigger_backoffice_run_start', {
+            classification_count: classification_results.length,
+            has_validation: !!(validation_api_endpoint && validation_rules?.length),
+            rule_count: validation_rules?.length ?? 0,
+        });
+        if (!on_back_change)
+            return;
+        if (classification_results.length === 0)
+            return;
+        set_group_autofill_log({});
+        const run_log = [];
+        const errors = [];
+        // ── Step 1: Backoffice validation ──
+        const has_backoffice_validation = !!(validation_api_endpoint && validation_rules?.length);
+        if (has_backoffice_validation) {
+            update_progress({ status: 'validating', total_steps: 1, completed_steps: 0, current_step: 'Running back-office validation...', error: undefined });
+            const current_sent = sent_clarifications_ref.current;
+            const current_pending = pending_responses_ref.current;
+            const current_drafts = draft_clarifications_ref.current;
+            let effective_clarifications = current_sent;
+            if (current_pending.size > 0) {
+                const pending_items = [];
+                for (const [clar_id, response] of current_pending) {
+                    if (!response.response_choice)
+                        continue;
+                    if (current_sent.some(c => c.id === clar_id && (c.status === 'responded' || c.status === 'resolved')))
+                        continue;
+                    const original = current_drafts.find(c => c.id === clar_id) ?? current_sent.find(c => c.id === clar_id);
+                    if (original) {
+                        pending_items.push({ ...original, status: 'responded', response_choice: response.response_choice, user_comment: response.user_comment });
+                    }
+                }
+                if (pending_items.length > 0) {
+                    effective_clarifications = [...current_sent, ...pending_items];
+                }
+            }
+            const resolved_rules = build_resolved_rules_map(effective_clarifications);
+            const vr = await validate_classified_files({
+                classifications: classification_results,
+                validation_api_endpoint: validation_api_endpoint,
+                validation_rules: validation_rules,
+                file_manager,
+                front_form_data,
+                update_progress,
+                set_file_validation_results,
+                run_log,
+                manual_review_file_ids,
+                check_type_filter: 'backoffice',
+                resolved_rules,
+            });
+            errors.push(...vr.errors);
+        }
+        // ── Step 2: Determine eligible files and route + autofill ──
+        update_progress({ status: 'routing', total_steps: 1, completed_steps: 0, current_step: 'Routing files to back-office...', error: undefined });
+        const current_sent = sent_clarifications_ref.current;
+        const current_pending = pending_responses_ref.current;
+        const current_drafts = draft_clarifications_ref.current;
+        // Build unified clarification items view
+        const all_clarification_items = new Map();
+        for (const item of current_drafts)
+            all_clarification_items.set(item.id, item);
+        for (const item of current_sent)
+            all_clarification_items.set(item.id, item);
+        for (const [clar_id, response] of current_pending) {
+            const existing = all_clarification_items.get(clar_id);
+            if (existing && response.response_choice) {
+                all_clarification_items.set(clar_id, {
+                    ...existing,
+                    status: 'responded',
+                    response_choice: response.response_choice,
+                    user_comment: response.user_comment,
+                    response_files: response.response_files ?? existing.response_files ?? [],
+                });
+            }
+        }
+        // Determine eligible files
+        const eligible_classifications = [];
+        for (const cls of classification_results) {
+            const eligible_file_cls = [];
+            for (const fc of cls.file_classifications) {
+                const vr = file_validation_results[fc.file_id];
+                if (!vr || vr.status === 'passed' || vr.status === 'skipped') {
+                    eligible_file_cls.push(fc);
+                }
+                else if (vr.status === 'failed') {
+                    const all_resolved = vr.errors.length === 0 || vr.errors.every(err => {
+                        const item = all_clarification_items.get(err.id);
+                        if (!item || (item.status !== 'responded' && item.status !== 'resolved'))
+                            return false;
+                        return item.response_choice !== 'ignore';
+                    });
+                    if (all_resolved)
+                        eligible_file_cls.push(fc);
+                }
+            }
+            if (eligible_file_cls.length > 0) {
+                eligible_classifications.push({
+                    field_id: cls.field_id,
+                    tags: [...new Set(eligible_file_cls.flatMap(fc => fc.tags))],
+                    file_classifications: eligible_file_cls,
+                });
+            }
+        }
+        // Include response files from resolved clarifications
+        const routed_file_ids = new Set(eligible_classifications.flatMap(c => c.file_classifications.map(f => f.file_id)));
+        for (const item of all_clarification_items.values()) {
+            if ((item.status !== 'responded' && item.status !== 'resolved') || !item.response_files?.length)
+                continue;
+            const source_file_id = item.doc_references?.[0]?.file_id;
+            if (!source_file_id)
+                continue;
+            let source_tags = [];
+            let source_field_id = '';
+            for (const cls of classification_results) {
+                const fc = cls.file_classifications.find(f => f.file_id === source_file_id);
+                if (fc && fc.tags.length > 0) {
+                    source_tags = fc.tags;
+                    source_field_id = cls.field_id;
+                    break;
+                }
+            }
+            if (source_tags.length === 0)
+                continue;
+            const new_file_cls = [];
+            for (const att of item.response_files) {
+                if (!routed_file_ids.has(att.file_id)) {
+                    new_file_cls.push({ file_id: att.file_id, file_name: att.file_name, tags: source_tags });
+                    routed_file_ids.add(att.file_id);
+                }
+            }
+            if (new_file_cls.length > 0) {
+                eligible_classifications.push({ field_id: source_field_id, tags: source_tags, file_classifications: new_file_cls });
+            }
+        }
+        // Route + autofill
+        const handle_autofill_file = (file_id, active) => {
+            set_autofilling_file_ids(prev => {
+                const next = new Set(prev);
+                if (active)
+                    next.add(file_id);
+                else
+                    next.delete(file_id);
+                return next;
+            });
+        };
+        const routing_result = await route_files_to_back_office({
+            classifications: eligible_classifications,
+            back_sections,
+            front_form_data,
+            on_back_change,
+            back_form_data,
+            autofill_api_endpoint,
+            file_manager,
+            update_progress,
+            set_group_autofill_log,
+            run_log,
+            on_autofill_file: handle_autofill_file,
+        });
+        set_unassigned_files(routing_result.unassigned);
+        errors.push(...routing_result.errors);
+        logger.info('[use_llm_run] trigger_backoffice_run_complete', {
+            duration_ms: Date.now() - bo_start,
+            eligible_file_count: eligible_classifications.reduce((sum, c) => sum + c.file_classifications.length, 0),
+            unassigned_count: routing_result.unassigned.length,
+            error_count: errors.length,
+        });
+        update_progress({
+            status: errors.length > 0 ? 'error' : 'done',
+            completed_steps: 1,
+            total_steps: 1,
+            current_step: undefined,
+            overall_percent: 100,
+            error: errors.length > 0 ? `${errors.length} error(s) during processing` : undefined,
+            error_details: errors.length > 0 ? errors : undefined,
+            run_log,
+        });
+        set_active_tab('back');
+    }, [props, classification_results, file_validation_results, update_progress, set_active_tab, set_unassigned_files, set_group_autofill_log, set_file_validation_results, manual_review_file_ids]);
+    return { trigger_run, trigger_complete, trigger_classify_file, trigger_assign_file, route_skipped_files, trigger_backoffice_run };
+}
+//# sourceMappingURL=use_llm_run.js.map