hazo_collab_forms 3.1.6 → 5.0.0

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

@@ -10,7 +10,7 @@ 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) {
+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) => {
@@ -209,14 +209,35 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
     const set_active_step = useCallback((step) => {
         set_active_step_raw(step);
     }, []);
-    const [review_queue_decisions, set_review_queue_decisions] = useState(new Map());
+    // ── 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([]);
-    const [send_back_comments, set_send_back_comments] = useState(new Map());
     // Build review queue items from draft clarifications
     const effective_pending = pending_clarification_responses ?? EMPTY_PENDING_RESPONSES;
     const review_queue_items = useMemo(() => {
@@ -227,14 +248,33 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
         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, avoiding duplicates
+        // 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 sent_ids = new Set(responded_sent.map(c => c.id));
-        const all_items = [
-            ...draft_clarifications,
-            ...responded_sent.filter(c => !draft_ids.has(c.id)),
-            ...front_clrs.filter(c => !draft_ids.has(c.id) && !sent_ids.has(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';
@@ -356,9 +396,104 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
             // 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;
-            const enriched_clr = (needs_enrichment || needs_status_update)
+            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,
@@ -371,7 +506,7 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
                 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]);
+    }, [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)
@@ -381,18 +516,96 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
         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');
-        return live.length > 0 ? live : confirmed_send_back_items;
-    }, [effective_review_items, review_queue_decisions, confirmed_send_back_items]);
+        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 ?? {};
-        const review_enabled = has_review_items || review_was_completed;
+        // 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',
@@ -413,10 +626,10 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
                 label: labels.send_back ?? 'Send Back',
                 badge_count: send_back_items.length || confirmed_send_back_count,
                 enabled: send_back_enabled,
-                completed: false,
+                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]);
+    }, [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(() => {
@@ -431,14 +644,28 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
         }));
         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
+        // 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)
+                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)
@@ -483,62 +710,120 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
         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 persisted file_validation_results ──
-    // On mount (or instance switch), if all rule_results for a file are accepted,
-    // pre-populate review_queue_decisions so the Review step reflects prior decisions.
+    // ── 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(() => {
-        // Only restore once per instance key (avoid re-running after user makes new decisions)
         if (has_restored_decisions.current.has(instance_key))
             return;
-        // Don't overwrite existing decisions
+        // 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;
         }
-        // Find files where ALL rule_results are accepted
-        const accepted_file_ids = new Set();
-        for (const [file_id, vr] of Object.entries(file_validation_results)) {
-            const rules = vr?.rule_results;
-            if (rules?.length && rules.every(rr => rr.accepted)) {
-                accepted_file_ids.add(file_id);
+        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);
+                        }
+                    }
+                }
             }
         }
-        if (accepted_file_ids.size === 0)
-            return;
-        // Build the full item list from all sources — same logic as review_queue_items
-        const responded_sent = sent_clarifications.filter(c => c.status === 'responded');
-        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)
-            : [];
-        const draft_ids = new Set(draft_clarifications.map(c => c.id));
-        const sent_ids = new Set(responded_sent.map(c => c.id));
-        const all_items = [
-            ...draft_clarifications,
-            ...responded_sent.filter(c => !draft_ids.has(c.id)),
-            ...front_clrs.filter(c => !draft_ids.has(c.id) && !sent_ids.has(c.id)),
-        ];
-        if (all_items.length === 0)
-            return;
-        // Match items to accepted files
-        const restored = new Map();
-        for (const item of all_items) {
-            const file_id = item.doc_references?.[0]?.file_id;
-            if (file_id && accepted_file_ids.has(file_id)) {
-                restored.set(item.id, 'accept');
+        // 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,
-                accepted_files: Array.from(accepted_file_ids),
+                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;
             });
         }
-    }, [instance_key, draft_clarifications, file_validation_results, review_queue_decisions.size, sent_clarifications, props.front_form_data]);
+    }, [form_data_entries]);
     const stepper_snapshots = useRef({});
     const prev_stepper_instance_id = useRef(active_instance_id);
     useEffect(() => {
@@ -549,12 +834,10 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
         if (prev_id && prev_id !== active_instance_id) {
             stepper_snapshots.current[prev_id] = {
                 step: active_step,
-                decisions: review_queue_decisions,
                 was_completed: review_was_completed,
                 send_back_count: confirmed_send_back_count,
                 review_items: confirmed_review_items,
                 send_back_items: confirmed_send_back_items,
-                comments: send_back_comments,
             };
         }
         prev_stepper_instance_id.current = active_instance_id;
@@ -562,14 +845,12 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
         const saved = active_instance_id ? stepper_snapshots.current[active_instance_id] : undefined;
         if (saved) {
             set_active_step_raw(saved.step);
-            set_review_queue_decisions(saved.decisions);
             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);
-            set_send_back_comments(saved.comments);
         }
-        else {
+        else if (!has_restored_decisions.current.has(instance_key ?? '')) {
             // Fresh initialization
             if (review_queue_items.length === 0) {
                 set_active_step_raw('tax_data');
@@ -577,12 +858,10 @@ export function use_fb_form_state(props, active_instance_id, active_instance, pe
             else {
                 set_active_step_raw('review');
             }
-            set_review_queue_decisions(new Map());
             set_review_was_completed(false);
             set_confirmed_send_back_count(0);
             set_confirmed_review_items([]);
             set_confirmed_send_back_items([]);
-            set_send_back_comments(new Map());
         }
     }, [props.agent_stepper, active_instance_id]);
     return {