hazo_collab_forms 5.7.0 → 6.0.0

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

@@ -1,1863 +0,0 @@
-/**
- * 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 { add_data_entry } from '../../../utils/fb_data_mutations.js';
-import { add_autofill_run } from '../../../utils/fb_data_mutations_v2.js';
-import { get_autofilled_file_groups } from '../../../utils/fb_data_queries.js';
-import { next_ie_id, next_pd_id, next_act_id } from '../../../types/fb_form_data_v1.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 }));
-}
-/** Infer MIME type from file extension */
-function mime_from_name(name) {
-    const ext = name.split('.').pop()?.toLowerCase();
-    switch (ext) {
-        case 'pdf': return 'application/pdf';
-        case 'png': return 'image/png';
-        case 'jpg':
-        case 'jpeg': return 'image/jpeg';
-        case 'gif': return 'image/gif';
-        case 'webp': return 'image/webp';
-        case 'svg': return 'image/svg+xml';
-        case 'csv': return 'text/csv';
-        case 'txt': return 'text/plain';
-        case 'xlsx': return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
-        case 'xls': return 'application/vnd.ms-excel';
-        case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
-        case 'doc': return 'application/msword';
-        default: return 'application/octet-stream';
-    }
-}
-/** 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, on_queue_files, force_autofill, on_autofill_activity, autofilled_file_groups, on_autofill_run } = 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) {
-        // Check both field value and __files_ prefix (Instance 2+ may only have __files_ populated)
-        const field_files = get_files_from_value(front_form_data[cls.field_id]);
-        const prefixed_files = get_files_from_value(front_form_data[`__files_${cls.field_id}`]);
-        const combined_files = field_files.length > 0 ? field_files : prefixed_files;
-        for (const fc of cls.file_classifications) {
-            const file_info = combined_files.find((f) => f.file_id === fc.file_id);
-            // Build attachment from classification data if not found in front_form_data
-            const attachment = file_info?.attachment ?? {
-                file_id: fc.file_id,
-                ref_id: `ref_${fc.file_id}`,
-                file_name: fc.file_name,
-                file_size: 0,
-                mime_type: mime_from_name(fc.file_name),
-                visibility: 'public',
-                attached_at: new Date().toISOString(),
-            };
-            all_files.push({ ...fc, source_field_id: cls.field_id, 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 for autofill: new files always, existing files only when force_autofill
-                        if (is_new || force_autofill) {
-                            if (!newly_routed_files.has(file_key)) {
-                                newly_routed_files.set(file_key, []);
-                            }
-                            // Avoid duplicates in the autofill list
-                            const autofill_list = newly_routed_files.get(file_key);
-                            if (!autofill_list.some((f) => f.file_id === file.file_id)) {
-                                autofill_list.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;
-        const all_autofill_file_ids = [];
-        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);
-            for (const f of new_files)
-                all_autofill_file_ids.push(f.file_id);
-        }
-        // Mark all files as queued before autofill starts
-        if (all_autofill_file_ids.length > 0) {
-            on_queue_files?.(all_autofill_file_ids, true);
-        }
-        // 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];
-                    // Skip files already successfully autofilled for this group (prevents duplicate data on refresh)
-                    if (autofilled_file_groups?.has(`${f.file_id}:${group_id}`)) {
-                        autofill_done++;
-                        if (tracker)
-                            tracker.completed++;
-                        on_queue_files?.([f.file_id], false);
-                        continue;
-                    }
-                    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_queue_files?.([f.file_id], false);
-                    on_autofill_file?.(f.file_id, true);
-                    const autofill_start = Date.now();
-                    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 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,
-                        });
-                        // Per-file details for the autofill activity
-                        const file_details = [];
-                        let file_field_count = 0;
-                        let file_status = 'empty';
-                        let file_error;
-                        if (result.success && result.data && on_back_change) {
-                            const field_count = Object.keys(result.data).length;
-                            file_field_count = field_count;
-                            group_fields_populated += field_count;
-                            file_status = field_count > 0 ? 'success' : 'empty';
-                            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);
-                                const detail = {
-                                    field_id,
-                                    field_label: field_cfg?.label ?? field_id,
-                                    file_name: f.file_name,
-                                    value_summary,
-                                };
-                                details.push(detail);
-                                file_details.push({ field_id, field_label: detail.field_label, 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) {
-                            file_status = 'error';
-                            file_error = result.error || 'Autofill failed';
-                            group_error = file_error ?? 'Autofill failed';
-                            errors.push({ step: `autofill:${group_id}`, error: group_error });
-                        }
-                        else if (result.success && (!result.data || Object.keys(result.data).length === 0)) {
-                            file_status = 'empty';
-                            // Success but no data extracted
-                            if (!group_error && group_fields_populated === 0) {
-                                group_error = result.message || 'No matching data found in document';
-                            }
-                        }
-                        // Persist autofill activity to hierarchical data model
-                        if (on_autofill_activity) {
-                            const autofill_activity = {
-                                activity_info: {
-                                    activity_no: `act_autofill_${group_id}_${f.file_id}`,
-                                    activity_type: 'autofill',
-                                    activity_location: 'back_office',
-                                    activity_time: new Date().toISOString(),
-                                },
-                                autofill_result: {
-                                    file_id: f.file_id,
-                                    file_name: f.file_name,
-                                    group_id,
-                                    prompt_area: group_config.prompt_area || '',
-                                    prompt_key: group_config.prompt_key || '',
-                                    fields_populated: file_field_count,
-                                    details: file_details,
-                                    duration_ms: Date.now() - autofill_start,
-                                    status: file_status,
-                                    error: file_error,
-                                },
-                            };
-                            on_autofill_activity(autofill_activity);
-                        }
-                        // Record autofill run in v2 data model (prevents re-run on refresh)
-                        on_autofill_run?.({
-                            file_id: f.file_id,
-                            file_name: f.file_name,
-                            group_id,
-                            status: file_status,
-                            fields_populated: file_field_count,
-                            time: new Date().toISOString(),
-                            form_instance: 1, // Will be overridden by caller if needed
-                            error: file_error,
-                        });
-                    }
-                    catch (err) {
-                        const caught_error = err instanceof Error ? err.message : 'Autofill request failed';
-                        group_error = caught_error;
-                        errors.push({ step: `autofill:${group_id}:${f.file_id}`, error: group_error });
-                        // Persist error activity to hierarchical data model
-                        if (on_autofill_activity) {
-                            const error_activity = {
-                                activity_info: {
-                                    activity_no: `act_autofill_${group_id}_${f.file_id}`,
-                                    activity_type: 'autofill',
-                                    activity_location: 'back_office',
-                                    activity_time: new Date().toISOString(),
-                                },
-                                autofill_result: {
-                                    file_id: f.file_id,
-                                    file_name: f.file_name,
-                                    group_id,
-                                    prompt_area: group_config.prompt_area || '',
-                                    prompt_key: group_config.prompt_key || '',
-                                    fields_populated: 0,
-                                    details: [],
-                                    duration_ms: Date.now() - autofill_start,
-                                    status: 'error',
-                                    error: caught_error,
-                                },
-                            };
-                            on_autofill_activity(error_activity);
-                        }
-                        // Record error run in v2 data model
-                        on_autofill_run?.({
-                            file_id: f.file_id,
-                            file_name: f.file_name,
-                            group_id,
-                            status: 'error',
-                            fields_populated: 0,
-                            time: new Date().toISOString(),
-                            form_instance: 1,
-                            error: caught_error,
-                        });
-                    }
-                    finally {
-                        on_autofill_file?.(f.file_id, false);
-                    }
-                }
-                // Collect run_log entries for this group
-                const group_run_log = run_log.filter((entry) => entry.step === 'autofill' && entry.label.startsWith(`Autofill: ${group_id}`));
-                // 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(),
-                            run_log: group_run_log.length > 0 ? group_run_log : undefined,
-                        },
-                    }));
-                }
-                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,
-                            run_log: group_run_log.length > 0 ? group_run_log : undefined,
-                        },
-                    }));
-                }
-                else {
-                    set_group_autofill_log((prev) => ({
-                        ...prev,
-                        [group_id]: {
-                            status: 'empty',
-                            message: 'No matching data found in document',
-                            timestamp: Date.now(),
-                            run_log: group_run_log.length > 0 ? group_run_log : undefined,
-                        },
-                    }));
-                }
-            }
-            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
-        // Check both field value and __files_ prefix (Instance 2+ may only have __files_ populated)
-        const field_files = get_files_from_value(front_form_data[cls.field_id]);
-        const prefixed_files = get_files_from_value(front_form_data[`__files_${cls.field_id}`]);
-        const combined = field_files.length > 0 ? field_files : prefixed_files;
-        const file_lookup = new Map(combined.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 ?? mime_from_name(fc.file_name),
-                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.
-        // check_type filter: rules without check_type run in ALL contexts (immediate + backoffice).
-        // Only rules with an explicit check_type are restricted to that context.
-        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 || r.check_type === check_type_filter));
-        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,
-                    issues: [{
-                            issue_id: '0',
-                            issue_description: 'User-resolved issue',
-                        }],
-                    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, skipped_file_ids, update_form_data, form_data_entries }) {
-    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;
-    const skipped_file_ids_ref = useRef(skipped_file_ids);
-    skipped_file_ids_ref.current = skipped_file_ids;
-    const update_form_data_ref = useRef(update_form_data);
-    update_form_data_ref.current = update_form_data;
-    const form_data_entries_ref = useRef(form_data_entries);
-    form_data_entries_ref.current = form_data_entries;
-    /** Record an autofill run in the v2 data model (prevents re-run on refresh) */
-    const record_autofill_run = useCallback((run) => {
-        const updater = update_form_data_ref.current;
-        if (!updater)
-            return;
-        updater((prev) => add_autofill_run(prev, run));
-    }, []);
-    /** Callback to persist an autofill activity to the hierarchical data model.
-     *  Creates a standalone data entry with the activity (not attached to an existing pd node)
-     *  since autofill activities are back-office operations that don't correspond to client inputs. */
-    const emit_autofill_activity = useCallback((activity) => {
-        const updater = update_form_data_ref.current;
-        if (!updater)
-            return;
-        updater((prev) => {
-            // Create a standalone entry for the autofill activity:
-            // data_entry → client_data (ie) → client_input → processed_data (pd) → activity
-            const ie_id = next_ie_id(prev);
-            const ie_num = parseInt(ie_id.replace('ie_', ''), 10);
-            const pd_id = next_pd_id(ie_num, []);
-            const file_ref = activity.autofill_result;
-            const act_id = next_act_id(pd_id, []);
-            const activity_with_id = {
-                ...activity,
-                activity_info: { ...activity.activity_info, activity_no: act_id },
-            };
-            const new_entry = {
-                question: {
-                    source_id: null,
-                    question_field_id: `autofill_${file_ref?.group_id}_${file_ref?.file_id}`,
-                    question_type: 'data_request',
-                    form_instance: 1,
-                    component_type: 'autofill',
-                    description: `Autofill: ${file_ref?.file_name ?? 'unknown'} → ${file_ref?.group_id ?? 'unknown'}`,
-                },
-                client_data: [{
-                        input_elt_id: ie_id,
-                        client_input: {
-                            data_type: 'file',
-                            data_files: file_ref ? { file_id: file_ref.file_id, file_name: file_ref.file_name } : null,
-                            input_status: 'complete',
-                            processed_data: [{
-                                    processed_data_id: pd_id,
-                                    processed_data_type: 'file',
-                                    processed_data_files: file_ref ? { file_id: file_ref.file_id, file_name: file_ref.file_name } : undefined,
-                                    activities: [activity_with_id],
-                                }],
-                        },
-                    }],
-            };
-            return add_data_entry(prev, new_entry);
-        });
-    }, []);
-    /** 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]).length > 0
-                ? get_files_from_value(front_form_data[field_id])
-                : get_files_from_value(front_form_data[`__files_${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 and review queue accept flow. */
-    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;
-        // Show queued state immediately so Tax Data view reflects pending files
-        add_queued_files(file_ids);
-        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 = [];
-        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,
-            force_autofill: true,
-            on_autofill_file: handle_autofill_file,
-            on_queue_files: (fids, queued) => {
-                if (queued)
-                    add_queued_files(fids);
-                else
-                    remove_queued_files(fids);
-            },
-            on_autofill_activity: emit_autofill_activity,
-            autofilled_file_groups: get_autofilled_file_groups(form_data_entries_ref.current ?? []),
-            on_autofill_run: record_autofill_run,
-        });
-    }, [props, classification_results, update_progress, set_group_autofill_log, add_queued_files, remove_queued_files, set_autofilling_file_ids, emit_autofill_activity, record_autofill_run]);
-    /** 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/pending/validating, 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' || vr.status === 'pending' || vr.status === 'validating' || vr.status === 'manual_review') {
-                    // No validation, passed, skipped, manual_review, or validation not yet complete — eligible
-                    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);
-                    }
-                    else {
-                        logger.warn('[use_llm_run] file ineligible: failed validation with unresolved errors', { file_id: fc.file_id, file_name: fc.file_name, error_count: vr.errors.length });
-                    }
-                }
-                else if (vr.status === 'manual_review') {
-                    // Client requested manual review — still eligible for routing/autofill
-                    eligible_file_cls.push(fc);
-                }
-                else {
-                    logger.warn('[use_llm_run] file ineligible: unexpected validation status', { file_id: fc.file_id, status: vr.status });
-                }
-            }
-            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,
-            on_queue_files: (file_ids, queued) => {
-                if (queued)
-                    add_queued_files(file_ids);
-                else
-                    remove_queued_files(file_ids);
-            },
-            on_autofill_activity: emit_autofill_activity,
-            autofilled_file_groups: get_autofilled_file_groups(form_data_entries_ref.current ?? []),
-            on_autofill_run: record_autofill_run,
-        });
-        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,
-            has_on_back_change: !!on_back_change,
-            has_autofill_endpoint: !!autofill_api_endpoint,
-            back_sections_count: back_sections.length,
-            back_section_groups: back_sections.map(s => (s.groups ?? []).map((g) => ({ id: g.id, tag_id: g.tag_id, prompt_area: g.prompt_area, prompt_key: g.prompt_key }))),
-        });
-        if (!on_back_change) {
-            logger.warn('[use_llm_run] trigger_backoffice_run: no on_back_change — aborting');
-            return;
-        }
-        if (classification_results.length === 0) {
-            logger.warn('[use_llm_run] trigger_backoffice_run: no classification_results — aborting');
-            return;
-        }
-        set_group_autofill_log({});
-        const run_log = [];
-        const errors = [];
-        // ── Queue all classified files as "queued" so UI shows pending state ──
-        const all_classified_file_ids = classification_results.flatMap(c => c.file_classifications.map(fc => fc.file_id));
-        if (all_classified_file_ids.length > 0) {
-            add_queued_files(all_classified_file_ids);
-        }
-        // ── Snapshot refs BEFORE backoffice validation ──
-        // Backoffice validation triggers set_file_validation_results → useEffect clears/replaces
-        // draft_clarifications via React state flush during await. Capture stable copies now.
-        const snapshot_sent = [...sent_clarifications_ref.current];
-        const snapshot_pending = new Map(pending_responses_ref.current);
-        const snapshot_drafts = [...draft_clarifications_ref.current];
-        // Build unified clarification items view from the snapshot
-        const all_clarification_items = new Map();
-        for (const item of snapshot_drafts)
-            all_clarification_items.set(item.id, item);
-        for (const item of snapshot_sent)
-            all_clarification_items.set(item.id, item);
-        for (const [clar_id, response] of snapshot_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 resolved rules map from snapshot (for backoffice validation to skip already-resolved rules)
-        let effective_clarifications_for_rules = snapshot_sent;
-        if (snapshot_pending.size > 0) {
-            const sent_responded_ids = new Set(snapshot_sent.filter(c => c.status === 'responded' || c.status === 'resolved').map(c => c.id));
-            const pending_items = [];
-            for (const [clar_id, response] of snapshot_pending) {
-                if (!response.response_choice)
-                    continue;
-                if (sent_responded_ids.has(clar_id))
-                    continue;
-                const original = all_clarification_items.get(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_for_rules = [...snapshot_sent, ...pending_items];
-            }
-        }
-        // ── Step 1: Backoffice validation ──
-        let effective_file_validation = { ...file_validation_results };
-        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 resolved_rules = build_resolved_rules_map(effective_clarifications_for_rules);
-            // Also mark accepted rules as resolved so they skip re-validation
-            for (const [, result] of Object.entries(effective_file_validation)) {
-                if (result.rule_results) {
-                    for (const rr of result.rule_results) {
-                        if (rr.accepted && rr.rule_id) {
-                            resolved_rules.set(rr.rule_id, { response_choice: rr.user_resolution?.response_choice ?? 'accepted', user_comment: rr.user_resolution?.user_comment });
-                        }
-                    }
-                }
-            }
-            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);
-            // Merge backoffice validation results into local copy for eligibility check
-            for (const result of vr.all_validation_results) {
-                effective_file_validation[result.file_id] = result;
-            }
-        }
-        // ── Step 1b: Text classification ──
-        // Extract text from front-office fields (non-file content) and classify it
-        const { field_textbox_configs, llm_api_endpoint } = props;
-        if (field_textbox_configs && llm_api_endpoint) {
-            const text_entries = [];
-            for (const field_id of Object.keys(field_textbox_configs)) {
-                const text = get_text_from_value(front_form_data[field_id]);
-                if (text.trim().length > 0) {
-                    text_entries.push({ field_id, text });
-                }
-            }
-            if (text_entries.length > 0) {
-                update_progress({ current_step: `Classifying ${text_entries.length} text entry(ies)...` });
-                for (const entry of text_entries) {
-                    try {
-                        const classify_text_start = Date.now();
-                        const response = await fetch(llm_api_endpoint, {
-                            method: 'POST',
-                            headers: { 'Content-Type': 'application/json' },
-                            body: JSON.stringify({
-                                action: 'classify_text',
-                                field_id: entry.field_id,
-                                text: entry.text,
-                                available_tags: field_textbox_configs[entry.field_id]?.classification?.available_tags ?? props.available_tags ?? [],
-                                ...(props.available_document_types?.length ? { available_document_types: props.available_document_types } : {}),
-                            }),
-                        });
-                        const result = await response.json();
-                        run_log.push({
-                            step: 'classify_text',
-                            label: `Text Classification: ${entry.field_id}`,
-                            request: { action: 'classify_text', field_id: entry.field_id, text_length: entry.text.length },
-                            response: result,
-                            timestamp: classify_text_start,
-                            duration_ms: Date.now() - classify_text_start,
-                        });
-                        if (result.success && result.tags?.length > 0) {
-                            // Add text classification to classification_results so review queue can use categories
-                            set_classification_results((prev) => {
-                                const text_cls_id = `__text_${entry.field_id}`;
-                                const text_file_cls = {
-                                    file_id: text_cls_id,
-                                    file_name: `Text from ${entry.field_id}`,
-                                    tags: result.tags,
-                                    document_nature: result.document_nature,
-                                };
-                                const existing = prev.find((c) => c.field_id === entry.field_id);
-                                if (existing) {
-                                    // Merge with existing file classifications
-                                    const filtered = existing.file_classifications.filter((fc) => fc.file_id !== text_cls_id);
-                                    return [
-                                        ...prev.filter((c) => c.field_id !== entry.field_id),
-                                        {
-                                            ...existing,
-                                            tags: [...new Set([...existing.tags, ...result.tags])],
-                                            file_classifications: [...filtered, text_file_cls],
-                                        },
-                                    ];
-                                }
-                                return [...prev, { field_id: entry.field_id, tags: result.tags, file_classifications: [text_file_cls] }];
-                            });
-                        }
-                        // Create draft clarifications from text issues
-                        if (result.success && result.issues?.length > 0) {
-                            const text_clarifications = result.issues.map((issue, idx) => ({
-                                id: `text_issue_${entry.field_id}_${idx}_${Date.now()}`,
-                                type: 'validation_issue',
-                                status: 'pending',
-                                target_field_id: entry.field_id,
-                                target_label: `Text from ${entry.field_id}`,
-                                issue_description: issue.description,
-                                severity: issue.severity === 'error' ? 'error' : 'warning',
-                                doc_references: [{
-                                        file_id: `__text_${entry.field_id}`,
-                                        file_name: `Text from ${entry.field_id}`,
-                                        mime_type: 'text/plain',
-                                    }],
-                                response_options: [
-                                    { value: 'acknowledge', label: 'Acknowledge' },
-                                    { value: 'will_fix', label: 'Will fix' },
-                                    { value: 'ignore', label: 'Ignore' },
-                                ],
-                                created_at: new Date().toISOString(),
-                            }));
-                            set_file_validation_results((prev) => ({
-                                ...prev,
-                                [`__text_${entry.field_id}`]: {
-                                    file_id: `__text_${entry.field_id}`,
-                                    file_name: `Text from ${entry.field_id}`,
-                                    status: 'failed',
-                                    errors: text_clarifications,
-                                    document_types: [],
-                                },
-                            }));
-                        }
-                    }
-                    catch (err) {
-                        errors.push({ step: `classify_text:${entry.field_id}`, error: err instanceof Error ? err.message : 'Text classification failed' });
-                        logger.error('[use_llm_run] classify_text_error', { field_id: entry.field_id, error: err instanceof Error ? err.message : String(err) });
-                    }
-                }
-                logger.info('[use_llm_run] text_classification_phase_complete', { text_entry_count: text_entries.length });
-            }
-        }
-        // Clear queued state — autofill will re-queue eligible files via on_queue_files
-        if (all_classified_file_ids.length > 0) {
-            remove_queued_files(all_classified_file_ids);
-        }
-        // ── 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 });
-        // Determine eligible files — use effective_file_validation which merges backoffice results
-        const eligible_classifications = [];
-        for (const cls of classification_results) {
-            const eligible_file_cls = [];
-            for (const fc of cls.file_classifications) {
-                // Skip files already routed via review accept / skip_process (prevent double-processing)
-                if (skipped_file_ids_ref.current.has(fc.file_id)) {
-                    logger.info('[use_llm_run] backoffice: file already routed via review accept — skipping', { file_id: fc.file_id });
-                    continue;
-                }
-                const vr = effective_file_validation[fc.file_id];
-                // Exclude files with any rule sent back to client (pending client fix)
-                const has_sent_back = vr?.rule_results?.some(rr => rr.sent_back);
-                if (has_sent_back) {
-                    logger.warn('[use_llm_run] backoffice: file ineligible — has sent-back rule pending client response', { file_id: fc.file_id });
-                    continue;
-                }
-                // Exclude files with unreviewed resolved rules (pending agent acceptance)
-                const resolved_rules_for_file = vr?.rule_results?.filter(rr => rr.issues.length > 0 && rr.user_resolved) ?? [];
-                if (resolved_rules_for_file.length > 0 && !resolved_rules_for_file.every(rr => rr.accepted)) {
-                    logger.warn('[use_llm_run] backoffice: file ineligible — has unaccepted resolved rules', { file_id: fc.file_id });
-                    continue;
-                }
-                if (!vr || vr.status === 'passed' || vr.status === 'skipped' || vr.status === 'pending' || vr.status === 'validating' || vr.status === 'manual_review') {
-                    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);
-                    else
-                        logger.warn('[use_llm_run] backoffice: file ineligible — failed with unresolved errors', { file_id: fc.file_id, error_count: vr.errors.length, errors: vr.errors.map(e => ({ id: e.id, status: e.status, rule_id: e.rule_id })) });
-                }
-                else {
-                    logger.warn('[use_llm_run] backoffice: file ineligible — unexpected status', { file_id: fc.file_id, status: vr.status });
-                }
-            }
-            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 (force_autofill: true so "Run Again" always re-runs 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,
-            on_queue_files: (file_ids, queued) => {
-                if (queued)
-                    add_queued_files(file_ids);
-                else
-                    remove_queued_files(file_ids);
-            },
-            force_autofill: true,
-            on_autofill_activity: emit_autofill_activity,
-            autofilled_file_groups: get_autofilled_file_groups(form_data_entries_ref.current ?? []),
-            on_autofill_run: record_autofill_run,
-        });
-        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