hazo_collab_forms 5.9.0 → 6.0.0

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

@@ -1,919 +0,0 @@
-/**
- * Central state management hook for HazoFbForm.
- */
-'use client';
-import { useState, useCallback, useEffect, useMemo, useRef } from 'react';
-import { use_logger } from '../../../logger/index.js';
-import { VIRTUAL_INSTANCE_ID } from '../hazo_fb_form.js';
-const EMPTY_VALIDATION = {};
-const EMPTY_CLARIFICATIONS = [];
-const EMPTY_REVIEW_DECISIONS = new Map();
-const EMPTY_STRING_SET = new Set();
-const EMPTY_PENDING_RESPONSES = new Map();
-export function use_fb_form_state(props, active_instance_id, active_instance, pending_clarification_responses, form_data_entries) {
-    const logger = use_logger();
-    const [active_tab, set_active_tab_raw] = useState(props.initial_tab ?? 'front');
-    const set_active_tab = useCallback((tab) => {
-        logger.debug('[use_fb_form_state] tab_changed', { tab, instance_id: active_instance_id });
-        set_active_tab_raw(tab);
-    }, [active_instance_id]);
-    const [run_progress, set_run_progress] = useState({
-        status: 'idle',
-        total_steps: 0,
-        completed_steps: 0,
-    });
-    const [classification_results, set_classification_results] = useState(props.classification_results ?? []);
-    const [classifying_file_ids, set_classifying_file_ids] = useState(new Set());
-    const [unassigned_files, set_unassigned_files] = useState([]);
-    const [group_autofill_log, set_group_autofill_log] = useState({});
-    const [suggested_document_types, set_suggested_document_types] = useState([]);
-    const [queued_file_ids, set_queued_file_ids] = useState(new Set());
-    const [manual_review_file_ids, set_manual_review_file_ids] = useState(new Set());
-    const [validating_file_ids, set_validating_file_ids] = useState(new Set());
-    // ── Per-instance state (keyed by instance_id to avoid stale data on switch) ──
-    const instance_key = active_instance_id ?? VIRTUAL_INSTANCE_ID;
-    // File validation results — per-instance so auto-populate doesn't leak across instances
-    const [validation_map, set_validation_map] = useState(() => {
-        // Seed from active instance's persisted validation results
-        if (active_instance?.file_validation_results && instance_key) {
-            return { [instance_key]: active_instance.file_validation_results };
-        }
-        return {};
-    });
-    const file_validation_results = validation_map[instance_key] ?? EMPTY_VALIDATION;
-    // Restore persisted file_validation_results when switching to an instance that has them
-    useEffect(() => {
-        if (active_instance?.file_validation_results && instance_key && !(instance_key in validation_map)) {
-            set_validation_map(prev => ({ ...prev, [instance_key]: active_instance.file_validation_results }));
-        }
-    }, [instance_key]);
-    const set_file_validation_results = useCallback((setter) => {
-        set_validation_map((prev) => {
-            const current = prev[instance_key] ?? {};
-            const next = typeof setter === 'function' ? setter(current) : setter;
-            return { ...prev, [instance_key]: next };
-        });
-    }, [instance_key]);
-    // Draft clarifications — per-instance so switching doesn't flash stale drafts
-    const [drafts_map, set_drafts_map] = useState({});
-    const draft_clarifications = drafts_map[instance_key] ?? EMPTY_CLARIFICATIONS;
-    const set_draft_clarifications = useCallback((setter) => {
-        set_drafts_map((prev) => {
-            const current = prev[instance_key] ?? [];
-            const next = typeof setter === 'function' ? setter(current) : setter;
-            return { ...prev, [instance_key]: next };
-        });
-    }, [instance_key]);
-    // Review decisions — per-instance so switching doesn't mix decisions
-    const [review_decisions_map, set_review_decisions_map] = useState({});
-    const review_decisions = review_decisions_map[instance_key] ?? EMPTY_REVIEW_DECISIONS;
-    const set_review_decisions = useCallback((setter) => {
-        set_review_decisions_map((prev) => {
-            const current = prev[instance_key] ?? new Map();
-            const next = typeof setter === 'function' ? setter(current) : setter;
-            return { ...prev, [instance_key]: next };
-        });
-    }, [instance_key]);
-    // Ignored file IDs — per-instance (files where agent chose "dismiss_ignore")
-    const [ignored_map, set_ignored_map] = useState({});
-    const ignored_file_ids = ignored_map[instance_key] ?? EMPTY_STRING_SET;
-    const set_ignored_file_ids = useCallback((setter) => {
-        set_ignored_map((prev) => {
-            const current = prev[instance_key] ?? new Set();
-            const next = typeof setter === 'function' ? setter(current) : setter;
-            return { ...prev, [instance_key]: next };
-        });
-    }, [instance_key]);
-    // Skipped file IDs — per-instance (files where agent chose "skip_process")
-    const [skipped_map, set_skipped_map] = useState({});
-    const skipped_file_ids = skipped_map[instance_key] ?? EMPTY_STRING_SET;
-    const set_skipped_file_ids = useCallback((setter) => {
-        set_skipped_map((prev) => {
-            const current = prev[instance_key] ?? new Set();
-            const next = typeof setter === 'function' ? setter(current) : setter;
-            return { ...prev, [instance_key]: next };
-        });
-    }, [instance_key]);
-    // Reset per-instance ephemeral state when switching instances
-    const prev_instance_id = useRef(active_instance_id);
-    useEffect(() => {
-        if (active_instance_id !== undefined && active_instance_id !== prev_instance_id.current) {
-            logger.info('[use_fb_form_state] instance_switch_reset', { from: prev_instance_id.current, to: active_instance_id });
-            prev_instance_id.current = active_instance_id;
-            set_active_tab_raw(props.initial_tab ?? 'front');
-            set_run_progress({ status: 'idle', total_steps: 0, completed_steps: 0 });
-            set_classification_results(props.classification_results ?? []);
-            set_classifying_file_ids(new Set());
-            set_queued_file_ids(new Set());
-            set_unassigned_files([]);
-            set_group_autofill_log({});
-            set_suggested_document_types([]);
-            set_validating_file_ids(new Set());
-            // draft_clarifications and file_validation_results are per-instance — no reset needed
-        }
-    }, [active_instance_id]);
-    // Read sent clarifications: per-instance in multi-instance mode, shared in single-instance
-    const sent_clarifications = useMemo(() => {
-        if (active_instance && active_instance_id && active_instance_id !== VIRTUAL_INSTANCE_ID) {
-            return active_instance.sent_clarifications ?? [];
-        }
-        // Single-instance fallback: read from shared back_form_data
-        const raw = props.back_form_data?.['__clarifications'];
-        return Array.isArray(raw) ? raw : [];
-    }, [active_instance, active_instance_id, props.back_form_data]);
-    // Auto-populate drafts from file_validation_results, deduplicating against sent items
-    useEffect(() => {
-        const all_errors = [];
-        for (const result of Object.values(file_validation_results)) {
-            if (result.errors && result.errors.length > 0) {
-                all_errors.push(...result.errors);
-            }
-        }
-        if (all_errors.length === 0) {
-            // Preserve manually-added drafts (e.g., validation_override) even when no validation errors
-            set_draft_clarifications((prev) => {
-                const manual_only = prev.filter((d) => d.type === 'validation_override');
-                if (manual_only.length === prev.length)
-                    return prev;
-                return manual_only;
-            });
-            return;
-        }
-        // Build dedup sets from already-sent clarifications
-        const sent_ids = new Set(sent_clarifications.map((c) => c.id));
-        const sent_keys = new Set(sent_clarifications
-            .filter((c) => c.rule_id && c.target_field_id)
-            .map((c) => `${c.rule_id}::${c.target_field_id}`));
-        // Filter out already-sent items (by id match OR by rule_id::target_field_id match)
-        const new_drafts = all_errors.filter((item) => {
-            // Direct ID match — this error was already sent
-            if (sent_ids.has(item.id))
-                return false;
-            // Composite key match — same rule + target was already sent (handles re-run with new IDs)
-            if (item.rule_id && item.target_field_id && sent_keys.has(`${item.rule_id}::${item.target_field_id}`))
-                return false;
-            return true;
-        });
-        // Preserve manually-added drafts (e.g., validation_override) that aren't from validation errors
-        set_draft_clarifications((prev) => {
-            const manual_drafts = prev.filter((d) => d.type === 'validation_override');
-            const merged = [...new_drafts, ...manual_drafts.filter((md) => !new_drafts.some((nd) => nd.id === md.id))];
-            const prev_ids = new Set(prev.map((d) => d.id));
-            const next_ids = new Set(merged.map((d) => d.id));
-            if (prev_ids.size === next_ids.size && [...prev_ids].every((id) => next_ids.has(id)))
-                return prev;
-            return merged;
-        });
-    }, [file_validation_results, sent_clarifications, set_draft_clarifications]);
-    const update_progress = useCallback((update) => {
-        set_run_progress((prev) => ({ ...prev, ...update }));
-    }, []);
-    const add_classifying_files = useCallback((file_ids) => {
-        set_classifying_file_ids((prev) => {
-            const next = new Set(prev);
-            for (const id of file_ids)
-                next.add(id);
-            return next;
-        });
-    }, []);
-    const remove_classifying_files = useCallback((file_ids) => {
-        set_classifying_file_ids((prev) => {
-            const next = new Set(prev);
-            for (const id of file_ids)
-                next.delete(id);
-            return next;
-        });
-    }, []);
-    const add_queued_files = useCallback((file_ids) => {
-        set_queued_file_ids((prev) => {
-            const next = new Set(prev);
-            for (const id of file_ids)
-                next.add(id);
-            return next;
-        });
-    }, []);
-    const remove_queued_files = useCallback((file_ids) => {
-        set_queued_file_ids((prev) => {
-            const next = new Set(prev);
-            for (const id of file_ids)
-                next.delete(id);
-            return next;
-        });
-    }, []);
-    // Files currently being autofilled (for spinner display on file chips)
-    const [autofilling_file_ids, set_autofilling_file_ids] = useState(new Set());
-    // Back-office group collapsed state (persists across tab switches)
-    const [back_group_collapsed, set_back_group_collapsed] = useState({});
-    // ── Agent stepper state ──
-    const [active_step, set_active_step_raw] = useState('review');
-    const set_active_step = useCallback((step) => {
-        set_active_step_raw(step);
-    }, []);
-    // ── Per-instance review queue state (keyed by instance_key) ──
-    // These MUST be per-instance to prevent Instance 1 decisions leaking into Instance 2.
-    // Same pattern as validation_map, drafts_map, review_decisions_map.
-    const EMPTY_RQ_DECISIONS = useMemo(() => new Map(), []);
-    const EMPTY_SB_COMMENTS = useMemo(() => new Map(), []);
-    const [rq_decisions_map, set_rq_decisions_map] = useState({});
-    const review_queue_decisions = rq_decisions_map[instance_key] ?? EMPTY_RQ_DECISIONS;
-    const set_review_queue_decisions = useCallback((setter) => {
-        set_rq_decisions_map((prev) => {
-            const current = prev[instance_key] ?? new Map();
-            const next = typeof setter === 'function' ? setter(current) : setter;
-            return { ...prev, [instance_key]: next };
-        });
-    }, [instance_key]);
-    const [sb_comments_map, set_sb_comments_map] = useState({});
-    const send_back_comments = sb_comments_map[instance_key] ?? EMPTY_SB_COMMENTS;
-    const set_send_back_comments = useCallback((setter) => {
-        set_sb_comments_map((prev) => {
-            const current = prev[instance_key] ?? new Map();
-            const next = typeof setter === 'function' ? setter(current) : setter;
-            return { ...prev, [instance_key]: next };
-        });
-    }, [instance_key]);
-    // Track whether review was completed (persists even when draft_clarifications empty out after processing)
-    const [review_was_completed, set_review_was_completed] = useState(false);
-    const [confirmed_send_back_count, set_confirmed_send_back_count] = useState(0);
-    // Snapshot of review items at time of confirmation (survives draft_clarifications clearing)
-    const [confirmed_review_items, set_confirmed_review_items] = useState([]);
-    const [confirmed_send_back_items, set_confirmed_send_back_items] = useState([]);
-    // Build review queue items from draft clarifications
-    const effective_pending = pending_clarification_responses ?? EMPTY_PENDING_RESPONSES;
-    const review_queue_items = useMemo(() => {
-        // Include responded clarifications from multiple sources:
-        // 1. sent_clarifications (standard flow)
-        const responded_sent = sent_clarifications.filter(c => c.status === 'responded');
-        // 2. front_form_data.__clarifications (sourced items from Instance 2+ that client responded to)
-        const front_clrs = Array.isArray(props.front_form_data?.['__clarifications'])
-            ? props.front_form_data['__clarifications'].filter(c => c.status === 'responded' && c.thread && c.thread.length > 0)
-            : [];
-        // Combine all sources. When the same clarification exists in both sent_clarifications
-        // and front_form_data, use the version with the most complete thread (longest thread).
-        // front_form_data.__clarifications may have Instance 2 thread entries that
-        // sent_clarifications doesn't have (added by handle_sourced_respond).
-        const draft_ids = new Set(draft_clarifications.map(c => c.id));
-        const front_clr_map = new Map(front_clrs.map(c => [c.id, c]));
-        const all_items = [...draft_clarifications];
-        const added_ids = new Set(draft_ids);
-        for (const sc of responded_sent) {
-            if (added_ids.has(sc.id))
-                continue;
-            // Prefer the version with the longer thread (more complete conversation)
-            const front_version = front_clr_map.get(sc.id);
-            if (front_version && (front_version.thread?.length ?? 0) > (sc.thread?.length ?? 0)) {
-                all_items.push(front_version);
-            }
-            else {
-                all_items.push(sc);
-            }
-            added_ids.add(sc.id);
-        }
-        for (const fc of front_clrs) {
-            if (added_ids.has(fc.id))
-                continue;
-            all_items.push(fc);
-            added_ids.add(fc.id);
-        }
-        return all_items.map((clr) => {
-            // Determine category from classification results
-            let category = 'uncategorized';
-            let category_label = 'Uncategorized';
-            const file_id = clr.doc_references?.[0]?.file_id;
-            if (file_id) {
-                for (const cr of classification_results) {
-                    const fc = cr.file_classifications?.find((f) => f.file_id === file_id);
-                    if (fc && fc.tags.length > 0) {
-                        const tag_id = fc.tags[0];
-                        const tag = props.available_tags?.find((t) => t.tag_id === tag_id);
-                        if (tag) {
-                            category = tag.tag_id;
-                            category_label = tag.tag_label;
-                        }
-                        break;
-                    }
-                }
-            }
-            // Build client response string from clarification response or validation rule resolution
-            let client_response;
-            let response_choice = clr.response_choice;
-            let user_comment = clr.user_comment;
-            // If not on the clarification, check validation rule results and sent_clarifications for user response
-            let enriched_status = clr.status;
-            if (!response_choice && !user_comment) {
-                // Try to find the matching rule result from file_validation_results
-                let found_resolution = false;
-                // Strategy 1: Look up by file_id + rule_id
-                if (file_id && clr.rule_id) {
-                    const file_result = file_validation_results[file_id];
-                    const rule_result = file_result?.rule_results?.find(r => r.rule_id === clr.rule_id);
-                    if (rule_result?.user_resolved && rule_result.user_resolution) {
-                        response_choice = rule_result.user_resolution.response_choice;
-                        user_comment = rule_result.user_resolution.user_comment;
-                        found_resolution = true;
-                    }
-                }
-                // Strategy 2: Look up by file_id + rule_name (rule_id might differ)
-                if (!found_resolution && file_id && clr.rule_name) {
-                    const file_result = file_validation_results[file_id];
-                    const rule_result = file_result?.rule_results?.find(r => r.rule_name === clr.rule_name);
-                    if (rule_result?.user_resolved && rule_result.user_resolution) {
-                        response_choice = rule_result.user_resolution.response_choice;
-                        user_comment = rule_result.user_resolution.user_comment;
-                        found_resolution = true;
-                    }
-                }
-                // Strategy 3: Search all file results for matching rule (file_id on clarification might not match)
-                if (!found_resolution && (clr.rule_id || clr.rule_name)) {
-                    for (const fvr of Object.values(file_validation_results)) {
-                        const rule_result = fvr.rule_results?.find(r => (clr.rule_id && r.rule_id === clr.rule_id) || (clr.rule_name && r.rule_name === clr.rule_name));
-                        if (rule_result?.user_resolved && rule_result.user_resolution) {
-                            response_choice = rule_result.user_resolution.response_choice;
-                            user_comment = rule_result.user_resolution.user_comment;
-                            found_resolution = true;
-                            break;
-                        }
-                    }
-                }
-                // Strategy 4: Check sent_clarifications for matching item with client response
-                // (client may have responded to a sent clarification — response lives on instance.sent_clarifications)
-                // Match by: ID, rule_id+target, rule_name+target, or same file reference
-                if (!found_resolution) {
-                    const clr_file_id = clr.doc_references?.[0]?.file_id;
-                    const match = sent_clarifications.find(sc => {
-                        if (!(sc.response_choice || sc.user_comment))
-                            return false;
-                        // Direct ID match
-                        if (sc.id === clr.id)
-                            return true;
-                        // Rule ID + target match
-                        if (sc.rule_id && sc.rule_id === clr.rule_id && sc.target_field_id === clr.target_field_id)
-                            return true;
-                        // Rule name + target match
-                        if (sc.rule_name && sc.rule_name === clr.rule_name && sc.target_field_id === clr.target_field_id)
-                            return true;
-                        // Same rule + same file reference (handles target_field_id differences)
-                        if (clr_file_id && sc.doc_references?.[0]?.file_id === clr_file_id) {
-                            if ((sc.rule_id && sc.rule_id === clr.rule_id) || (sc.rule_name && sc.rule_name === clr.rule_name))
-                                return true;
-                        }
-                        return false;
-                    });
-                    if (match) {
-                        response_choice = match.response_choice;
-                        user_comment = match.user_comment;
-                        // Also update status to reflect client's response
-                        if (match.status === 'responded' || match.status === 'resolved') {
-                            enriched_status = match.status;
-                        }
-                        found_resolution = true;
-                    }
-                }
-                // Strategy 5: Check pending_clarification_responses (in-memory responses from immediate validation)
-                // These are captured when the client selects a response option in the front-office view
-                if (!found_resolution) {
-                    const pending = effective_pending.get(clr.id);
-                    if (pending?.response_choice || pending?.user_comment) {
-                        response_choice = pending.response_choice;
-                        user_comment = pending.user_comment;
-                        enriched_status = 'responded';
-                        found_resolution = true;
-                    }
-                }
-            }
-            if (response_choice || user_comment) {
-                const parts = [];
-                if (response_choice)
-                    parts.push(response_choice);
-                if (user_comment)
-                    parts.push(user_comment);
-                client_response = parts.join(' — ');
-            }
-            // Determine source type: text if no doc_references, or if mime_type is text/plain
-            const is_text_source = !clr.doc_references?.length
-                || clr.doc_references.every((ref) => ref.mime_type === 'text/plain')
-                || clr.doc_references.some((ref) => ref.file_id?.startsWith('__text_'));
-            // Enrich clarification with resolved response data for views to access
-            const needs_enrichment = (response_choice || user_comment) && (!clr.response_choice && !clr.user_comment);
-            const needs_status_update = enriched_status !== clr.status;
-            let enriched_clr = (needs_enrichment || needs_status_update)
-                ? { ...clr, ...(needs_enrichment ? { response_choice, user_comment } : {}), ...(needs_status_update ? { status: enriched_status } : {}) }
-                : clr;
-            // Enrich with v2 data model thread — the v2 thread has the complete cross-instance
-            // conversation history that the v1 ClarificationItem may be missing.
-            if (form_data_entries?.length) {
-                for (const entry of form_data_entries) {
-                    const v2_clr = entry.clarifications?.find((c) => c.clarification_id === clr.id);
-                    if (v2_clr) {
-                        // Use v2 thread if it has more entries (includes cross-instance responses)
-                        if (v2_clr.thread?.length > (enriched_clr.thread?.length ?? 0)) {
-                            // Collect classification tags from the entry's processed_data for display on file bars
-                            const entry_tags = [];
-                            for (const cdi of entry.client_data ?? []) {
-                                const inp = cdi.client_input;
-                                for (const pd of inp?.processed_data ?? []) {
-                                    if (pd.tags)
-                                        for (const t of pd.tags)
-                                            if (!entry_tags.includes(t))
-                                                entry_tags.push(t);
-                                }
-                            }
-                            // Collect validations for the info icon
-                            const entry_validations = entry.validations?.map((v) => ({
-                                rule_key: v.rule_key ?? '',
-                                status: v.status ?? '',
-                                details: v.details ?? '',
-                            })) ?? [];
-                            // Convert v2 FbThreadEntry[] to v1 ClarificationThreadEntry[] for the UI
-                            const v1_thread = v2_clr.thread.map((t) => ({
-                                role: t.role === 'agent' ? 'author' : t.role,
-                                action: t.action === 'issue_found' ? 'created' : t.action === 'reviewed' ? (t.decision === 'send_back' ? 'rejected' : 'resolved') : t.action,
-                                message: t.message || t.comment || t.feedback,
-                                response_choice: t.choice,
-                                timestamp: t.time,
-                                actor_name: t.user_name,
-                                actor_id: t.user,
-                                // Attach classification tags and validations to entries with files
-                                ...(t.files?.length ? { classification_tags: entry_tags, validations: entry_validations.length > 0 ? entry_validations : undefined } : {}),
-                                files: t.files?.map((f) => ({
-                                    file_id: f.file_id,
-                                    ref_id: f.file_id,
-                                    file_name: f.file_name,
-                                    file_size: 0,
-                                    mime_type: 'application/octet-stream',
-                                    visibility: 'public',
-                                    attached_at: t.time,
-                                })),
-                            }));
-                            // Prepend original file/source as the first "Input" entry so the history
-                            // shows what was submitted before the issue was found.
-                            // Skip if first entry is already an input (no message, has files).
-                            const first = v1_thread[0];
-                            const already_has_input = first && first.role === 'system' && first.action === 'created' && first.files?.length && !first.message;
-                            if (!already_has_input) {
-                                const first_thread_time = v2_clr.thread[0]?.time;
-                                const doc_refs = enriched_clr.doc_references ?? clr.doc_references;
-                                if (doc_refs?.length > 0) {
-                                    // Deduplicate doc_refs by file_id
-                                    const seen = new Set();
-                                    const unique_refs = doc_refs.filter((ref) => {
-                                        if (seen.has(ref.file_id))
-                                            return false;
-                                        seen.add(ref.file_id);
-                                        return true;
-                                    });
-                                    const input_entry = {
-                                        role: 'system',
-                                        action: 'created',
-                                        files: unique_refs.map((ref) => ({
-                                            file_id: ref.file_id,
-                                            ref_id: ref.file_id,
-                                            file_name: ref.file_name,
-                                            file_size: ref.file_size ?? 0,
-                                            mime_type: ref.mime_type ?? 'application/octet-stream',
-                                            visibility: 'public',
-                                            attached_at: first_thread_time ?? '',
-                                        })),
-                                        timestamp: first_thread_time ?? '',
-                                        validations: entry_validations.length > 0 ? entry_validations : undefined,
-                                    };
-                                    v1_thread.unshift(input_entry);
-                                }
-                            }
-                            enriched_clr = { ...enriched_clr, thread: v1_thread };
-                        }
-                        // Use v2 status if more accurate
-                        if (v2_clr.status === 'responded' && enriched_clr.status !== 'responded') {
-                            enriched_clr = { ...enriched_clr, status: 'responded' };
-                        }
-                        // Clear agent_feedback if v2 review is null (stale feedback from previous round)
-                        if (v2_clr.review === null && enriched_clr.agent_feedback) {
-                            enriched_clr = { ...enriched_clr, agent_feedback: undefined };
-                        }
-                        break;
-                    }
-                }
-            }
-            return {
-                id: clr.id,
-                category,
-                category_label,
-                source: is_text_source ? 'text' : 'file',
-                source_label: clr.doc_references?.[0]?.file_name ?? clr.target_label,
-                issue: clr.issue_description,
-                client_response,
-                clarification: enriched_clr,
-                decision: review_queue_decisions.get(clr.id),
-            };
-        });
-    }, [draft_clarifications, classification_results, props.available_tags, review_queue_decisions, file_validation_results, sent_clarifications, effective_pending, props.front_form_data, form_data_entries]);
-    // Use live items if available, otherwise fall back to confirmed snapshot
-    const effective_review_items = review_queue_items.length > 0 ? review_queue_items : confirmed_review_items;
-    // Computed: all items have decisions (or no items exist)
-    const review_complete = useMemo(() => {
-        if (effective_review_items.length === 0)
-            return true;
-        return effective_review_items.every((item) => review_queue_decisions.has(item.id));
-    }, [effective_review_items, review_queue_decisions]);
-    // Computed: items marked as send_back (use snapshot if live items cleared)
-    const is_completed_instance = active_instance?.status === 'completed' || active_instance?.status === 'archived';
-    const send_back_items = useMemo(() => {
-        const live = effective_review_items.filter((item) => review_queue_decisions.get(item.id) === 'send_back');
-        if (live.length > 0)
-            return live;
-        if (confirmed_send_back_items.length > 0)
-            return confirmed_send_back_items;
-        // For completed instances, rebuild from v2 data model clarifications with sent_back status
-        if (is_completed_instance && form_data_entries?.length) {
-            const v2_items = [];
-            for (const entry of form_data_entries) {
-                for (const clr of entry.clarifications ?? []) {
-                    if (clr.status === 'sent_back' || clr.status === 'accepted') {
-                        // Find file info from entry's processed_data
-                        let file_name = '';
-                        if (entry.client_data) {
-                            for (const cd of entry.client_data) {
-                                const inputs = Array.isArray(cd.client_input) ? cd.client_input : [cd.client_input];
-                                for (const inp of inputs) {
-                                    const pd = inp.processed_data?.find((p) => p.processed_data_id === clr.processed_data_ref);
-                                    if (pd?.processed_data_files?.file_name)
-                                        file_name = pd.processed_data_files.file_name;
-                                }
-                            }
-                        }
-                        v2_items.push({
-                            id: clr.clarification_id,
-                            category: 'uncategorized',
-                            category_label: 'Uncategorized',
-                            source: 'file',
-                            source_label: file_name || clr.issue,
-                            issue: clr.issue,
-                            clarification: { id: clr.clarification_id, issue_description: clr.issue },
-                            decision: clr.review?.decision ?? 'send_back',
-                            send_back_comment: clr.review?.feedback,
-                        });
-                    }
-                }
-            }
-            if (v2_items.length > 0)
-                return v2_items;
-        }
-        // Fallback to sent_clarifications (v1 path)
-        if (is_completed_instance && sent_clarifications.length > 0) {
-            return sent_clarifications.map((clr) => {
-                let category = 'uncategorized';
-                let category_label = 'Uncategorized';
-                const file_id = clr.doc_references?.[0]?.file_id;
-                if (file_id) {
-                    for (const cr of classification_results) {
-                        const fc = cr.file_classifications?.find(f => f.file_id === file_id);
-                        if (fc && fc.tags.length > 0) {
-                            const tag = props.available_tags?.find(t => t.tag_id === fc.tags[0]);
-                            if (tag) {
-                                category = tag.tag_id;
-                                category_label = tag.tag_label;
-                            }
-                            break;
-                        }
-                    }
-                }
-                const is_text = !clr.doc_references?.length || clr.doc_references.every(ref => ref.mime_type === 'text/plain');
-                return {
-                    id: clr.id,
-                    category,
-                    category_label,
-                    source: is_text ? 'text' : 'file',
-                    source_label: clr.doc_references?.[0]?.file_name ?? clr.target_label ?? '',
-                    issue: clr.issue_description,
-                    clarification: clr,
-                    decision: 'send_back',
-                };
-            });
-        }
-        return [];
-    }, [effective_review_items, review_queue_decisions, confirmed_send_back_items, is_completed_instance, sent_clarifications, classification_results, props.available_tags, form_data_entries]);
-    // Computed: step configurations
-    // Steps stay visible once they've been active — even if the underlying data clears after processing
-    const step_configs = useMemo(() => {
-        const has_review_items = effective_review_items.length > 0;
-        const undecided_count = effective_review_items.filter((item) => !review_queue_decisions.has(item.id)).length;
-        const labels = props.stepper_labels ?? {};
-        // Enable review step if there are items to review, review was completed this session,
-        // or there are responded clarifications (client has responded, waiting for agent review)
-        const has_responded_clrs = sent_clarifications.some(c => c.status === 'responded')
-            || (form_data_entries ?? []).some((e) => e.clarifications?.some((c) => c.status === 'responded'));
-        const review_enabled = has_review_items || review_was_completed || has_responded_clrs;
-        const send_back_enabled = send_back_items.length > 0 || confirmed_send_back_count > 0;
-        // Check v2 data model for completed send-back state
-        const has_v2_sent_back = (form_data_entries ?? []).some((e) => e.clarifications?.some((c) => c.status === 'sent_back' || c.status === 'accepted'));
-        return [
-            {
-                id: 'review',
-                label: labels.review ?? 'Review',
-                badge_count: undecided_count,
-                enabled: review_enabled,
-                completed: review_was_completed || (review_complete && has_review_items),
-            },
-            {
-                id: 'tax_data',
-                label: labels.tax_data ?? 'Tax Data',
-                badge_count: 0,
-                enabled: true,
-                completed: false,
-            },
-            {
-                id: 'send_back',
-                label: labels.send_back ?? 'Send Back',
-                badge_count: send_back_items.length || confirmed_send_back_count,
-                enabled: send_back_enabled,
-                completed: is_completed_instance && (has_v2_sent_back || sent_clarifications.length > 0),
-            },
-        ];
-    }, [review_queue_items, review_queue_decisions, review_complete, send_back_items, props.stepper_labels, review_was_completed, confirmed_send_back_count, sent_clarifications, is_completed_instance, form_data_entries]);
-    // Confirm review decisions: map to existing review_decisions, collect accepted file IDs, and advance step.
-    // Returns accepted file IDs so callers can trigger routing/autofill.
-    const confirm_review_decisions = useCallback(() => {
-        const sb_count = Array.from(review_queue_decisions.values()).filter(d => d === 'send_back').length;
-        set_review_was_completed(true);
-        set_confirmed_send_back_count(sb_count);
-        // Snapshot items before draft_clarifications get cleared by downstream processing
-        // Attach send_back_comment to each item
-        const items_with_comments = effective_review_items.map(i => ({
-            ...i,
-            send_back_comment: send_back_comments.get(i.id),
-        }));
-        set_confirmed_review_items(items_with_comments);
-        set_confirmed_send_back_items(items_with_comments.filter(i => review_queue_decisions.get(i.id) === 'send_back'));
-        // Collect accepted file IDs for routing — includes original doc_references AND response files
-        const accepted_file_ids = [];
-        const seen_ids = new Set();
-        for (const [item_id, decision] of review_queue_decisions.entries()) {
-            if (decision === 'accept') {
-                const item = effective_review_items.find(i => i.id === item_id);
-                // Original file from doc_references
-                const file_id = item?.clarification?.doc_references?.[0]?.file_id;
-                if (file_id && !seen_ids.has(file_id)) {
-                    seen_ids.add(file_id);
-                    accepted_file_ids.push(file_id);
-                }
-                // Response files from client (e.g. "provide new and keep existing")
-                const response_files = item?.clarification?.response_files;
-                if (response_files) {
-                    for (const rf of response_files) {
-                        if (rf.file_id && !seen_ids.has(rf.file_id)) {
-                            seen_ids.add(rf.file_id);
-                            accepted_file_ids.push(rf.file_id);
-                        }
-                    }
-                }
-            }
-        }
-        // Add accepted files to skipped_file_ids (consistent with clarifications_view skip_process flow)
-        if (accepted_file_ids.length > 0) {
-            set_skipped_file_ids((prev) => {
-                const next = new Set(prev);
-                for (const id of accepted_file_ids)
-                    next.add(id);
-                return next;
-            });
-            // Mark all rule_results as accepted so trigger_backoffice_run builds resolved_rules
-            // and validate_classified_files skips re-flagging these files
-            set_file_validation_results((prev) => {
-                const next = { ...prev };
-                for (const file_id of accepted_file_ids) {
-                    const vr = next[file_id];
-                    if (vr?.rule_results) {
-                        next[file_id] = {
-                            ...vr,
-                            rule_results: vr.rule_results.map(rr => ({
-                                ...rr,
-                                accepted: true,
-                            })),
-                        };
-                    }
-                }
-                return next;
-            });
-        }
-        set_review_decisions((prev) => {
-            const next = new Map(prev);
-            for (const [item_id, decision] of review_queue_decisions.entries()) {
-                if (decision === 'accept') {
-                    next.set(item_id, 'skip_process');
-                }
-                else if (decision === 'send_back') {
-                    next.set(item_id, 'approve');
-                }
-            }
-            return next;
-        });
-        set_active_step_raw('tax_data');
-        return accepted_file_ids;
-    }, [review_queue_decisions, set_review_decisions, effective_review_items, send_back_comments, set_skipped_file_ids, set_file_validation_results]);
-    // ── Restore review decisions from v2 data model (single source of truth) ──
-    // Per-instance keying ensures clean state per instance — no cross-instance leakage.
-    // This effect restores persisted review decisions when an instance's Map is empty.
-    const has_restored_decisions = useRef(new Set());
-    useEffect(() => {
-        if (has_restored_decisions.current.has(instance_key))
-            return;
-        // With per-instance keying, each instance starts with an empty Map.
-        // Only restore if the instance's Map is actually empty.
-        if (review_queue_decisions.size > 0) {
-            has_restored_decisions.current.add(instance_key);
-            return;
-        }
-        const restored = new Map();
-        const restored_comments = new Map();
-        // Read from v2 data model
-        if (form_data_entries?.length) {
-            for (const entry of form_data_entries) {
-                for (const clr of entry.clarifications ?? []) {
-                    if (clr.status === 'responded' || clr.review === null)
-                        continue;
-                    if (clr.review?.decision) {
-                        // Don't restore if a client response came AFTER the review (stale decision)
-                        const review_thread_ref = clr.review.thread_ref;
-                        const thread = clr.thread ?? [];
-                        const review_idx = thread.findIndex((t) => t.thread_id === review_thread_ref);
-                        const has_newer_client_response = thread.some((t, i) => i > review_idx && t.role === 'client' && t.action === 'responded');
-                        if (has_newer_client_response)
-                            continue; // Client responded after review — needs fresh review
-                        restored.set(clr.clarification_id, clr.review.decision);
-                        if (clr.review.feedback) {
-                            restored_comments.set(clr.clarification_id, clr.review.feedback);
-                        }
-                    }
-                }
-            }
-        }
-        // Fallback: check v1 sent_clarifications — but ONLY if v2 data isn't available.
-        // If v2 data IS available and says review=null, the v1 fallback must respect that.
-        // Build a set of clarification IDs where v2 says "needs fresh review" (review=null).
-        const v2_needs_fresh_review = new Set();
-        if (form_data_entries?.length) {
-            for (const entry of form_data_entries) {
-                for (const clr of entry.clarifications ?? []) {
-                    if (clr.review === null || clr.status === 'responded') {
-                        v2_needs_fresh_review.add(clr.clarification_id);
-                    }
-                }
-            }
-        }
-        if (restored.size === 0) {
-            for (const sc of sent_clarifications) {
-                if (sc.status === 'responded')
-                    continue;
-                // If v2 data says this item needs fresh review, don't restore old decisions
-                if (v2_needs_fresh_review.has(sc.id))
-                    continue;
-                if (sc.review_decision === 'skip_process') {
-                    restored.set(sc.id, 'accept');
-                }
-                else if (sc.review_decision === 'approve') {
-                    restored.set(sc.id, 'send_back');
-                    if (sc.agent_feedback)
-                        restored_comments.set(sc.id, sc.agent_feedback);
-                }
-            }
-        }
-        if (restored.size > 0) {
-            has_restored_decisions.current.add(instance_key);
-            set_review_queue_decisions(restored);
-            set_review_was_completed(true);
-            if (restored_comments.size > 0)
-                set_send_back_comments(restored_comments);
-            logger.info('[use_fb_form_state] restored_review_decisions', {
-                instance_key,
-                restored_count: restored.size,
-                send_back_count: restored_comments.size,
-            });
-        }
-    }, [instance_key, sent_clarifications, form_data_entries, review_queue_decisions.size]);
-    // ── Reconcile stale decisions with v2 data model ──
-    // The restore effect may run before v2 data is available, restoring stale decisions
-    // from v1. This effect runs when v2 data changes and clears any decisions/comments
-    // that v2 says should be fresh (review=null, status=responded).
-    useEffect(() => {
-        if (!form_data_entries?.length)
-            return;
-        if (review_queue_decisions.size === 0 && send_back_comments.size === 0)
-            return;
-        const stale_ids = new Set();
-        for (const entry of form_data_entries) {
-            for (const clr of entry.clarifications ?? []) {
-                if (clr.review === null || clr.status === 'responded') {
-                    if (review_queue_decisions.has(clr.clarification_id) || send_back_comments.has(clr.clarification_id)) {
-                        stale_ids.add(clr.clarification_id);
-                    }
-                }
-            }
-        }
-        if (stale_ids.size > 0) {
-            set_review_queue_decisions(prev => {
-                const next = new Map(prev);
-                for (const id of stale_ids)
-                    next.delete(id);
-                return next.size === prev.size ? prev : next;
-            });
-            set_send_back_comments(prev => {
-                const next = new Map(prev);
-                for (const id of stale_ids)
-                    next.delete(id);
-                return next.size === prev.size ? prev : next;
-            });
-        }
-    }, [form_data_entries]);
-    const stepper_snapshots = useRef({});
-    const prev_stepper_instance_id = useRef(active_instance_id);
-    useEffect(() => {
-        if (!props.agent_stepper)
-            return;
-        const prev_id = prev_stepper_instance_id.current;
-        // Save current stepper state for the previous instance
-        if (prev_id && prev_id !== active_instance_id) {
-            stepper_snapshots.current[prev_id] = {
-                step: active_step,
-                was_completed: review_was_completed,
-                send_back_count: confirmed_send_back_count,
-                review_items: confirmed_review_items,
-                send_back_items: confirmed_send_back_items,
-            };
-        }
-        prev_stepper_instance_id.current = active_instance_id;
-        // Restore saved state for the new instance, or initialize fresh
-        const saved = active_instance_id ? stepper_snapshots.current[active_instance_id] : undefined;
-        if (saved) {
-            set_active_step_raw(saved.step);
-            set_review_was_completed(saved.was_completed);
-            set_confirmed_send_back_count(saved.send_back_count);
-            set_confirmed_review_items(saved.review_items);
-            set_confirmed_send_back_items(saved.send_back_items);
-        }
-        else if (!has_restored_decisions.current.has(instance_key ?? '')) {
-            // Fresh initialization
-            if (review_queue_items.length === 0) {
-                set_active_step_raw('tax_data');
-            }
-            else {
-                set_active_step_raw('review');
-            }
-            set_review_was_completed(false);
-            set_confirmed_send_back_count(0);
-            set_confirmed_review_items([]);
-            set_confirmed_send_back_items([]);
-        }
-    }, [props.agent_stepper, active_instance_id]);
-    return {
-        active_tab,
-        set_active_tab,
-        run_progress,
-        set_run_progress,
-        update_progress,
-        classification_results,
-        set_classification_results,
-        classifying_file_ids,
-        add_classifying_files,
-        remove_classifying_files,
-        queued_file_ids,
-        add_queued_files,
-        remove_queued_files,
-        unassigned_files,
-        set_unassigned_files,
-        group_autofill_log,
-        set_group_autofill_log,
-        file_validation_results,
-        set_file_validation_results,
-        suggested_document_types,
-        set_suggested_document_types,
-        draft_clarifications,
-        set_draft_clarifications,
-        sent_clarifications,
-        manual_review_file_ids,
-        set_manual_review_file_ids,
-        validating_file_ids,
-        set_validating_file_ids,
-        review_decisions,
-        set_review_decisions,
-        ignored_file_ids,
-        set_ignored_file_ids,
-        skipped_file_ids,
-        set_skipped_file_ids,
-        autofilling_file_ids,
-        set_autofilling_file_ids,
-        back_group_collapsed,
-        set_back_group_collapsed,
-        active_step,
-        set_active_step,
-        step_configs,
-        review_queue_items: effective_review_items,
-        review_queue_decisions,
-        set_review_queue_decisions,
-        review_complete,
-        send_back_items,
-        send_back_comments,
-        set_send_back_comments,
-        confirm_review_decisions,
-    };
-}
-//# sourceMappingURL=use_fb_form_state.js.map