Update app.py via AI Editor

app.py

@@ -10,10 +10,6 @@ from docx import Document
 import mimetypes
 from threading import Lock
 import time
-import tempfile
-import shutil
-import uuid
-from flask import Flask, session, request
 
 import google.generativeai as genai
 
@@ -24,7 +20,6 @@ logging.basicConfig(
 
 app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
 server = app.server
-app.server.secret_key = os.environ.get('SECRET_KEY', str(uuid.uuid4()))
 
 GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "")
 genai.configure(api_key=GOOGLE_API_KEY)
@@ -33,42 +28,15 @@ GEMINI_MODEL = "models/gemini-2.5-pro-preview-03-25"
 MAX_INPUT_TOKENS = 1048576
 MAX_OUTPUT_TOKENS = 65536
 
-SESSION_DATA = {}
-SESSION_LOCKS = {}
-
-SESSION_FILE_ROOT = tempfile.gettempdir()
-
-def get_session_id():
-    if 'session_id' not in session:
-        session['session_id'] = str(uuid.uuid4())
-    return session['session_id']
-
-def get_session_data():
-    sid = get_session_id()
-    if sid not in SESSION_DATA:
-        SESSION_DATA[sid] = {
-            'uploaded_documents': {},
-            'uploaded_documents_fileid': {},
-            'uploaded_documents_bytes': {},
-            'proposals': {},
-            'proposals_fileid': {},
-            'shredded_documents': {},
-            'generated_response': None,
-            'lock': Lock(),
-            'tmpdir': create_session_tmpdir(sid)
-        }
-        SESSION_LOCKS[sid] = SESSION_DATA[sid]['lock']
-    return SESSION_DATA[sid]
-
-def create_session_tmpdir(sid):
-    tmpdir = os.path.join(SESSION_FILE_ROOT, f"dashrfp_{sid}")
-    os.makedirs(tmpdir, exist_ok=True)
-    return tmpdir
+uploaded_documents = {}
+uploaded_documents_fileid = {}
+uploaded_documents_bytes = {}
+proposals = {}
+proposals_fileid = {}
+shredded_documents = {}
+generated_response = None
 
-def cleanup_session_tmpdir(sid):
-    tmpdir = os.path.join(SESSION_FILE_ROOT, f"dashrfp_{sid}")
-    if os.path.exists(tmpdir):
-        shutil.rmtree(tmpdir, ignore_errors=True)
+gemini_lock = Lock()
 
 def decode_document(decoded_bytes):
     try:
@@ -202,17 +170,21 @@ def save_loe_as_docx(loe_text, proposal_filename):
     memf.seek(0)
     return memf.read()
 
-def process_document(session_dict, action, selected_filename=None, chat_input=None, rfp_decoded_bytes=None, selected_proposal_filename=None):
+def process_document(action, selected_filename=None, chat_input=None, rfp_decoded_bytes=None, selected_proposal_filename=None):
+    global generated_response
+
+    logging.info(f"Process document called with action: {action}")
+
     doc_content = None
     doc_fileid = None
     if action in ["shred", "compliance", "virtual_board", "proposal", "recover"]:
-        if selected_filename and selected_filename in session_dict['uploaded_documents']:
-            doc_content = session_dict['uploaded_documents'][selected_filename]
-            doc_fileid = session_dict['uploaded_documents_fileid'].get(selected_filename)
-        elif session_dict['uploaded_documents']:
-            doc_content = next(iter(session_dict['uploaded_documents'].values()))
-            selected_filename = next(iter(session_dict['uploaded_documents'].keys()))
-            doc_fileid = session_dict['uploaded_documents_fileid'].get(selected_filename)
+        if selected_filename and selected_filename in uploaded_documents:
+            doc_content = uploaded_documents[selected_filename]
+            doc_fileid = uploaded_documents_fileid.get(selected_filename)
+        elif uploaded_documents:
+            doc_content = next(iter(uploaded_documents.values()))
+            selected_filename = next(iter(uploaded_documents.keys()))
+            doc_fileid = uploaded_documents_fileid.get(selected_filename)
         else:
             doc_content = None
             doc_fileid = None
@@ -234,20 +206,20 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
         if result and not result.startswith("Error"):
             docx_bytes = save_shredded_as_docx(result, selected_filename)
             generated_docx_name = f"{os.path.splitext(selected_filename)[0]}_shredded.docx"
-            session_dict['uploaded_documents'][generated_docx_name] = result
-            session_dict['shredded_documents'][generated_docx_name] = docx_bytes
+            uploaded_documents[generated_docx_name] = result
+            shredded_documents[generated_docx_name] = docx_bytes
             return result, generated_docx_name, docx_bytes, None, None
         else:
             return result, None, None, None, None
 
     elif action == 'compliance':
-        if not selected_proposal_filename or selected_proposal_filename not in session_dict['proposals']:
+        if not selected_proposal_filename or selected_proposal_filename not in proposals:
             return "No proposal document selected for compliance.", None, None, None, None
-        if not selected_filename or selected_filename not in session_dict['uploaded_documents']:
+        if not selected_filename or selected_filename not in uploaded_documents:
             return "No RFP/SOW/PWS/RFI document selected for compliance.", None, None, None, None
 
-        rfp_text = session_dict['uploaded_documents'][selected_filename]
-        proposal_text = session_dict['proposals'][selected_proposal_filename]
+        rfp_text = uploaded_documents[selected_filename]
+        proposal_text = proposals[selected_proposal_filename]
         logging.info(f"Compliance check: comparing proposal [{selected_proposal_filename}] to RFP [{selected_filename}]")
         prompt = (
             "You are a proposal compliance expert. Use the following RFP/SOW/PWS/RFI and the generated proposal response. "
@@ -265,20 +237,20 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
         if result and not result.startswith("Error"):
             docx_bytes = save_compliance_as_docx(result, selected_filename)
             compliance_docx_name = f"{os.path.splitext(selected_filename)[0]}_compliance_check.docx"
-            session_dict['uploaded_documents'][compliance_docx_name] = result
-            session_dict['shredded_documents'][compliance_docx_name] = docx_bytes
+            uploaded_documents[compliance_docx_name] = result
+            shredded_documents[compliance_docx_name] = docx_bytes
             return result, compliance_docx_name, docx_bytes, None, None
         else:
             return result, None, None, None, None
 
     elif action == 'virtual_board':
-        if not selected_proposal_filename or selected_proposal_filename not in session_dict['proposals']:
+        if not selected_proposal_filename or selected_proposal_filename not in proposals:
             return "No proposal document selected for evaluation board.", None, None, None, None
-        if not selected_filename or selected_filename not in session_dict['uploaded_documents']:
+        if not selected_filename or selected_filename not in uploaded_documents:
             return "No RFP/SOW/PWS/RFI document selected for evaluation board.", None, None, None, None
 
-        rfp_text = session_dict['uploaded_documents'][selected_filename]
-        proposal_text = session_dict['proposals'][selected_proposal_filename]
+        rfp_text = uploaded_documents[selected_filename]
+        proposal_text = proposals[selected_proposal_filename]
         logging.info(f"Evaluation Board: extracting criteria from RFP [{selected_filename}], evaluating proposal [{selected_proposal_filename}]")
         prompt = (
             "You are a federal acquisition evaluation board. Your job is to extract Section L and Section M (evaluation criteria) from the following RFP/SOW/PWS/RFI if they exist. "
@@ -295,8 +267,8 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
         if result and not result.startswith("Error"):
             docx_bytes = save_virtual_board_as_docx(result, selected_filename)
             board_docx_name = f"{os.path.splitext(selected_filename)[0]}_evaluation_board.docx"
-            session_dict['uploaded_documents'][board_docx_name] = result
-            session_dict['shredded_documents'][board_docx_name] = docx_bytes
+            uploaded_documents[board_docx_name] = result
+            shredded_documents[board_docx_name] = docx_bytes
             return result, board_docx_name, docx_bytes, None, None
         else:
             return result, None, None, None, None
@@ -306,12 +278,12 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
             logging.warning("No RFP/SOW/PWS/RFI document selected for proposal action.")
             return "No RFP/SOW/PWS/RFI document selected.", None, None, None, None
         rfp_filename = selected_filename
-        rfp_fileid = session_dict['uploaded_documents_fileid'].get(selected_filename)
-        if not rfp_fileid and rfp_filename in session_dict['uploaded_documents_bytes']:
+        rfp_fileid = uploaded_documents_fileid.get(selected_filename)
+        if not rfp_fileid and rfp_filename in uploaded_documents_bytes:
             try:
-                fileid = upload_to_gemini_file(session_dict['uploaded_documents_bytes'][rfp_filename], rfp_filename)
+                fileid = upload_to_gemini_file(uploaded_documents_bytes[rfp_filename], rfp_filename)
                 if fileid:
-                    session_dict['uploaded_documents_fileid'][rfp_filename] = fileid
+                    uploaded_documents_fileid[rfp_filename] = fileid
                     rfp_fileid = fileid
                     logging.info(f"RFP file {rfp_filename} uploaded to Gemini for proposal.")
             except Exception as e:
@@ -326,26 +298,26 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
             prompt += f"User additional instructions: {chat_input}\n"
         prompt += f"\n---\nRFP/SOW/PWS/RFI ({rfp_filename}):\n{doc_content}\n"
         result = gemini_generate_content(prompt, file_id=rfp_fileid, chat_input=chat_input)
-        session_dict['generated_response'] = result
+        generated_response = result
         if result and not result.startswith("Error"):
             docx_bytes = save_proposal_as_docx(result, rfp_filename)
             generated_docx_name = f"{os.path.splitext(rfp_filename)[0]}_proposal.docx"
-            session_dict['proposals'][generated_docx_name] = result
-            session_dict['proposals_fileid'][generated_docx_name] = None
+            proposals[generated_docx_name] = result
+            proposals_fileid[generated_docx_name] = None
             return result, None, None, generated_docx_name, docx_bytes
         else:
             return result, None, None, None, None
 
     elif action == 'recover':
-        if not selected_proposal_filename or selected_proposal_filename not in session_dict['proposals']:
+        if not selected_proposal_filename or selected_proposal_filename not in proposals:
             logging.error("No proposal document selected for recovery.")
             return "No proposal document selected for recovery.", None, None, None, None
-        if not selected_filename or selected_filename not in session_dict['uploaded_documents']:
+        if not selected_filename or selected_filename not in uploaded_documents:
             logging.error("No compliance check or shredded requirements document selected for recovery.")
             return "No compliance check or shredded requirements document selected for recovery.", None, None, None, None
 
-        findings_content = session_dict['uploaded_documents'][selected_filename]
-        proposal_text = session_dict['proposals'][selected_proposal_filename]
+        findings_content = uploaded_documents[selected_filename]
+        proposal_text = proposals[selected_proposal_filename]
         prompt = (
             "You are a proposal compliance recovery expert. Use the findings and recommendations table and the original proposal response provided below. "
             "Address ONLY those sections of the proposal that have a finding and a recommendation for improvement. "
@@ -365,8 +337,8 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
             base_name = os.path.splitext(selected_proposal_filename)[0]
             recovered_docx_name = f"{base_name}_recovered.docx"
             docx_bytes = save_proposal_as_docx(result, base_name)
-            session_dict['proposals'][recovered_docx_name] = result
-            session_dict['proposals_fileid'][recovered_docx_name] = None
+            proposals[recovered_docx_name] = result
+            proposals_fileid[recovered_docx_name] = None
             logging.info(f"Recovered proposal generated and saved as {recovered_docx_name}.")
             return result, None, None, recovered_docx_name, docx_bytes
         else:
@@ -374,10 +346,11 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
             return result, None, None, None, None
 
     elif action == 'loe':
-        if not selected_proposal_filename or selected_proposal_filename not in session_dict['proposals']:
+        # LOE estimation implementation
+        if not selected_proposal_filename or selected_proposal_filename not in proposals:
             logging.warning("No proposal document selected for LOE estimation.")
             return "No proposal document selected for LOE estimation.", None, None, None, None
-        proposal_text = session_dict['proposals'][selected_proposal_filename]
+        proposal_text = proposals[selected_proposal_filename]
         proposal_base_name = os.path.splitext(selected_proposal_filename)[0]
         prompt = (
             "You are a federal proposal cost and level of effort estimator. "
@@ -398,8 +371,8 @@ def process_document(session_dict, action, selected_filename=None, chat_input=No
         result = gemini_generate_content(prompt, file_id=None, chat_input=chat_input)
         if result and not result.startswith("Error"):
             loe_docx_name = f"{proposal_base_name}_loe.docx"
-            session_dict['proposals'][loe_docx_name] = result
-            session_dict['proposals_fileid'][loe_docx_name] = None
+            proposals[loe_docx_name] = result
+            proposals_fileid[loe_docx_name] = None
             docx_bytes = save_loe_as_docx(result, proposal_base_name)
             logging.info(f"LOE generated and saved as {loe_docx_name}")
             return result, None, None, loe_docx_name, docx_bytes
@@ -473,8 +446,7 @@ def get_proposals_list(proposaldict):
     return dbc.ListGroup(doc_list, flush=True)
 
 app.layout = dbc.Container([
-    dcc.Store(id='preview-window-state', data='expanded', storage_type='session'),
-    dcc.Store(id='session-cleanup', data=False, storage_type='session', clear_data=True),
+    dcc.Store(id='preview-window-state', data='expanded'),
     dbc.Row([
         dbc.Col([
             dbc.Card([
@@ -498,10 +470,12 @@ app.layout = dbc.Container([
                         },
                         multiple=False
                     ),
-                    html.Div(id='documents-list'),
+                    html.Div(id='documents-list', children=get_documents_list(uploaded_documents, shredded_documents)),
                     dcc.Dropdown(
                         id='select-document-dropdown',
+                        options=[{'label': fn, 'value': fn} for fn in uploaded_documents.keys()],
                         placeholder="Select a document to work with",
+                        value=next(iter(uploaded_documents), None),
                         style={"marginBottom": "10px"}
                     ),
                 ])
@@ -527,10 +501,12 @@ app.layout = dbc.Container([
                         },
                         multiple=False
                     ),
-                    html.Div(id='proposals-list'),
+                    html.Div(id='proposals-list', children=get_proposals_list(proposals)),
                     dcc.Dropdown(
                         id='select-proposal-dropdown',
+                        options=[{'label': fn, 'value': fn} for fn in proposals.keys()],
                         placeholder="Select a proposal document",
+                        value=next(iter(proposals), None),
                         style={"marginBottom": "10px"}
                     ),
                 ])
@@ -616,8 +592,7 @@ def update_preview_window_style(state):
         State('select-proposal-dropdown', 'value'),
         State('chat-input', 'value'),
         Input('cancel-action-btn', 'n_clicks'),
-        State('preview-window-state', 'data'),
-        Input('session-cleanup', 'clear_data')
+        State('preview-window-state', 'data')
     ],
     prevent_initial_call=True
 )
@@ -625,12 +600,10 @@ def master_callback(
     shred_clicks, proposal_clicks, compliance_clicks, recover_clicks, board_clicks, loe_clicks,
     rfp_content, rfp_filename, doc_delete_clicks, selected_doc,
     proposal_content, proposal_filename, proposal_delete_clicks, selected_proposal,
-    chat_input, cancel_clicks, preview_window_state, session_cleanup_clear
+    chat_input, cancel_clicks, preview_window_state
 ):
     ctx = callback_context
     triggered_id = ctx.triggered[0]['prop_id'].split('.')[0] if ctx.triggered else None
-    session_dict = get_session_data()
-    lock = session_dict['lock']
 
     def safe_get_n_clicks(ctx, idx):
         try:
@@ -642,35 +615,29 @@ def master_callback(
     proposal_delete_clicks = safe_get_n_clicks(ctx, 12)
     uploaded_rfp_decoded_bytes = None
 
-    # Session cleanup: only clear all data and temp dir if session-cleanup's clear_data is triggered (i.e., browser close)
-    if triggered_id == 'session-cleanup' and session_cleanup_clear:
-        sid = get_session_id()
-        cleanup_session_tmpdir(sid)
-        if sid in SESSION_DATA:
-            del SESSION_DATA[sid]
-        if sid in SESSION_LOCKS:
-            del SESSION_LOCKS[sid]
-        return html.Div("Session ended. All data cleared.", style={"wordWrap": "break-word"}), None, [], None, None, [], None, "expanded"
-
-    # Cancel should just clear the preview and expand window, not clear session/docs
+    global gemini_lock, uploaded_documents_bytes
+
+    if triggered_id in [
+        'shred-action-btn', 'proposal-action-btn', 'compliance-action-btn',
+        'recover-action-btn', 'board-action-btn', 'loe-action-btn'
+    ] and preview_window_state != "shrunk":
+        return dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update, "shrunk"
+
     if triggered_id == 'cancel-action-btn':
-        doc_options = [{'label': fn, 'value': fn} for fn in session_dict['uploaded_documents'].keys()]
-        doc_value = selected_doc if selected_doc in session_dict['uploaded_documents'] else (next(iter(session_dict['uploaded_documents']), None) if session_dict['uploaded_documents'] else None)
-        proposals_list = get_proposals_list(session_dict['proposals'])
-        proposal_options = [{'label': fn, 'value': fn} for fn in session_dict['proposals'].keys()]
-        proposal_value = selected_proposal if selected_proposal in session_dict['proposals'] else (next(iter(session_dict['proposals']), None) if session_dict['proposals'] else None)
-        documents_list = get_documents_list(session_dict['uploaded_documents'], session_dict['shredded_documents'])
+        output_data_upload = html.Div("[Cancelled by user]\n", style={"wordWrap": "break-word"})
+        doc_options = [{'label': fn, 'value': fn} for fn in uploaded_documents.keys()]
+        doc_value = selected_doc if selected_doc in uploaded_documents else (next(iter(uploaded_documents), None) if uploaded_documents else None)
+        proposals_list = get_proposals_list(proposals)
+        proposal_options = [{'label': fn, 'value': fn} for fn in proposals.keys()]
+        proposal_value = selected_proposal if selected_proposal in proposals else (next(iter(proposals), None) if proposals else None)
+        documents_list = get_documents_list(uploaded_documents, shredded_documents)
         return (
-            html.Div("", style={"wordWrap": "break-word"}),
+            output_data_upload,
             documents_list, doc_options, doc_value,
             proposals_list, proposal_options, proposal_value,
             "expanded"
         )
 
-    # File uploads
-    doc_value = selected_doc
-    proposal_value = selected_proposal
-
     if triggered_id == 'upload-document' and rfp_content is not None and rfp_filename:
         content_type, content_string = rfp_content.split(',')
         decoded = base64.b64decode(content_string)
@@ -680,12 +647,11 @@ def master_callback(
         if rfp_filename.lower().endswith(('.pdf', '.docx', '.xlsx', '.xls')):
             fileid = upload_to_gemini_file(decoded, rfp_filename)
         if text is not None:
-            session_dict['uploaded_documents'][rfp_filename] = text
-            session_dict['uploaded_documents_bytes'][rfp_filename] = decoded
+            uploaded_documents[rfp_filename] = text
+            uploaded_documents_bytes[rfp_filename] = decoded
             if fileid:
-                session_dict['uploaded_documents_fileid'][rfp_filename] = fileid
+                uploaded_documents_fileid[rfp_filename] = fileid
             logging.info(f"Document uploaded: {rfp_filename}")
-            doc_value = rfp_filename  # Set selection to the newly uploaded doc
         else:
             logging.error(f"Failed to decode uploaded document: {rfp_filename}")
 
@@ -697,76 +663,65 @@ def master_callback(
         if proposal_filename.lower().endswith(('.pdf', '.docx', '.xlsx', '.xls')):
             fileid = upload_to_gemini_file(decoded, proposal_filename)
         if text is not None:
-            session_dict['proposals'][proposal_filename] = text
+            proposals[proposal_filename] = text
             if fileid:
-                session_dict['proposals_fileid'][proposal_filename] = fileid
+                proposals_fileid[proposal_filename] = fileid
             logging.info(f"Proposal uploaded: {proposal_filename}")
-            proposal_value = proposal_filename  # Set selection to the newly uploaded proposal
         else:
             logging.error(f"Failed to decode uploaded proposal: {proposal_filename}")
 
-    # Deletion handling
-    deleted_doc = False
     if triggered_id and isinstance(doc_delete_clicks, list):
         for i, n_click in enumerate(doc_delete_clicks):
             if n_click:
                 btn_id = ctx.inputs_list[8][i]['id']
                 del_filename = btn_id['index']
-                if del_filename in session_dict['uploaded_documents']:
-                    del session_dict['uploaded_documents'][del_filename]
-                    if del_filename in session_dict['uploaded_documents_fileid']:
+                if del_filename in uploaded_documents:
+                    del uploaded_documents[del_filename]
+                    if del_filename in uploaded_documents_fileid:
                         try:
-                            genai.delete_file(session_dict['uploaded_documents_fileid'][del_filename])
+                            genai.delete_file(uploaded_documents_fileid[del_filename])
                         except Exception as e:
                             logging.warning(f"Failed to delete Gemini file {del_filename}: {e}")
-                        del session_dict['uploaded_documents_fileid'][del_filename]
-                    if del_filename in session_dict['uploaded_documents_bytes']:
-                        del session_dict['uploaded_documents_bytes'][del_filename]
+                        del uploaded_documents_fileid[del_filename]
+                    if del_filename in uploaded_documents_bytes:
+                        del uploaded_documents_bytes[del_filename]
                     logging.info(f"Document deleted: {del_filename}")
-                if del_filename in session_dict['shredded_documents']:
-                    del session_dict['shredded_documents'][del_filename]
+                if del_filename in shredded_documents:
+                    del shredded_documents[del_filename]
                     logging.info(f"Shredded doc deleted: {del_filename}")
-                if doc_value == del_filename:
-                    doc_value = None
-                    deleted_doc = True
+                if selected_doc == del_filename:
+                    selected_doc = None
                 break
 
-    deleted_proposal = False
     if triggered_id and isinstance(proposal_delete_clicks, list):
         for i, n_click in enumerate(proposal_delete_clicks):
             if n_click:
                 btn_id = ctx.inputs_list[12][i]['id']
                 del_filename = btn_id['index']
-                if del_filename in session_dict['proposals']:
-                    del session_dict['proposals'][del_filename]
-                    if del_filename in session_dict['proposals_fileid']:
+                if del_filename in proposals:
+                    del proposals[del_filename]
+                    if del_filename in proposals_fileid:
                         try:
-                            genai.delete_file(session_dict['proposals_fileid'][del_filename])
+                            genai.delete_file(proposals_fileid[del_filename])
                         except Exception as e:
                             logging.warning(f"Failed to delete Gemini proposal file {del_filename}: {e}")
-                        del session_dict['proposals_fileid'][del_filename]
+                        del proposals_fileid[del_filename]
                     logging.info(f"Proposal deleted: {del_filename}")
-                if proposal_value == del_filename:
-                    proposal_value = None
-                    deleted_proposal = True
+                if selected_proposal == del_filename:
+                    selected_proposal = None
                 break
 
-    doc_options = [{'label': fn, 'value': fn} for fn in session_dict['uploaded_documents'].keys()]
-    # Always keep the selected doc if it's still present, otherwise select the first available or None
-    if not doc_value or doc_value not in session_dict['uploaded_documents']:
-        doc_value = next(iter(session_dict['uploaded_documents']), None)
-    proposal_options = [{'label': fn, 'value': fn} for fn in session_dict['proposals'].keys()]
-    if not proposal_value or proposal_value not in session_dict['proposals']:
-        proposal_value = next(iter(session_dict['proposals']), None)
-    documents_list = get_documents_list(session_dict['uploaded_documents'], session_dict['shredded_documents'])
-    proposals_list = get_proposals_list(session_dict['proposals'])
+    doc_options = [{'label': fn, 'value': fn} for fn in uploaded_documents.keys()]
+    doc_value = selected_doc if selected_doc in uploaded_documents else (next(iter(uploaded_documents), None) if uploaded_documents else None)
+    documents_list = get_documents_list(uploaded_documents, shredded_documents)
+    proposals_list = get_proposals_list(proposals)
+    proposal_options = [{'label': fn, 'value': fn} for fn in proposals.keys()]
+    proposal_value = selected_proposal if selected_proposal in proposals else (next(iter(proposals), None) if proposals else None)
 
     output_data_upload = html.Div("No action taken yet.", style={"wordWrap": "break-word"})
 
-    # Action buttons: always process immediately
-    if triggered_id in ['shred-action-btn', 'compliance-action-btn', 'board-action-btn',
-                        'proposal-action-btn', 'recover-action-btn', 'loe-action-btn']:
-        got_lock = lock.acquire(blocking=False)
+    if triggered_id in ['shred-action-btn', 'compliance-action-btn', 'board-action-btn']:
+        got_lock = gemini_lock.acquire(blocking=False)
         if not got_lock:
             output_data_upload = html.Div("Another Gemini operation is in progress. Please wait or cancel.", style={"wordWrap": "break-word"})
             return (
@@ -778,50 +733,73 @@ def master_callback(
         try:
             if triggered_id == "shred-action-btn":
                 action_name = "shred"
-                result, generated_filename, generated_docx_bytes, _, _ = process_document(session_dict, action_name, doc_value, chat_input, uploaded_rfp_decoded_bytes, None)
+                result, generated_filename, generated_docx_bytes, _, _ = process_document(action_name, doc_value, chat_input, uploaded_rfp_decoded_bytes, None)
                 output_data_upload = dcc.Markdown(result, style={"whiteSpace": "pre-wrap", "wordWrap": "break-word"})
             elif triggered_id == "compliance-action-btn":
                 action_name = "compliance"
                 result, generated_filename, generated_docx_bytes, _, _ = process_document(
-                    session_dict, action_name, doc_value, chat_input, uploaded_rfp_decoded_bytes, proposal_value
+                    action_name, doc_value, chat_input, uploaded_rfp_decoded_bytes, proposal_value
                 )
                 output_data_upload = dcc.Markdown(result, style={"whiteSpace": "pre-wrap", "wordWrap": "break-word"})
             elif triggered_id == "board-action-btn":
                 action_name = "virtual_board"
                 result, generated_filename, generated_docx_bytes, _, _ = process_document(
-                    session_dict, action_name, doc_value, chat_input, uploaded_rfp_decoded_bytes, proposal_value
+                    action_name, doc_value, chat_input, uploaded_rfp_decoded_bytes, proposal_value
                 )
                 output_data_upload = dcc.Markdown(result, style={"whiteSpace": "pre-wrap", "wordWrap": "break-word"})
-            elif triggered_id == "proposal-action-btn":
+        finally:
+            gemini_lock.release()
+        doc_options = [{'label': fn, 'value': fn} for fn in uploaded_documents.keys()]
+        doc_value = doc_value if doc_value in uploaded_documents else (next(iter(uploaded_documents), None) if uploaded_documents else None)
+        proposal_options = [{'label': fn, 'value': fn} for fn in proposals.keys()]
+        proposal_value = proposal_value if proposal_value in proposals else (next(iter(proposals), None) if proposals else None)
+        documents_list = get_documents_list(uploaded_documents, shredded_documents)
+        proposals_list = get_proposals_list(proposals)
+        return (
+            output_data_upload,
+            documents_list, doc_options, doc_value,
+            proposals_list, proposal_options, proposal_value,
+            "expanded"
+        )
+
+    if triggered_id in ['proposal-action-btn', 'recover-action-btn', 'loe-action-btn']:
+        got_lock = gemini_lock.acquire(blocking=False)
+        if not got_lock:
+            output_data_upload = html.Div("Another Gemini operation is in progress. Please wait or cancel.", style={"wordWrap": "break-word"})
+            return (
+                output_data_upload,
+                documents_list, doc_options, doc_value,
+                proposals_list, proposal_options, proposal_value,
+                "expanded"
+            )
+        try:
+            if triggered_id == "proposal-action-btn":
                 action_name = "proposal"
-                selected_bytes = session_dict['uploaded_documents_bytes'].get(doc_value, None)
+                selected_bytes = uploaded_documents_bytes.get(doc_value, None)
                 result, _, _, generated_filename, generated_docx_bytes = process_document(
-                    session_dict, action_name, doc_value, chat_input, selected_bytes, None
+                    action_name, doc_value, chat_input, selected_bytes, None
                 )
                 output_data_upload = dcc.Markdown(result, style={"whiteSpace": "pre-wrap", "wordWrap": "break-word"})
             elif triggered_id == "recover-action-btn":
                 action_name = "recover"
                 result, _, _, generated_filename, generated_docx_bytes = process_document(
-                    session_dict, action_name, doc_value, chat_input, None, proposal_value
+                    action_name, doc_value, chat_input, None, proposal_value
                 )
                 output_data_upload = dcc.Markdown(result, style={"whiteSpace": "pre-wrap", "wordWrap": "break-word"})
             elif triggered_id == "loe-action-btn":
                 action_name = "loe"
                 result, _, _, generated_filename, generated_docx_bytes = process_document(
-                    session_dict, action_name, None, chat_input, None, proposal_value
+                    action_name, None, chat_input, None, proposal_value
                 )
                 output_data_upload = dcc.Markdown(result, style={"whiteSpace": "pre-wrap", "wordWrap": "break-word"})
         finally:
-            lock.release()
-        # After processing, update lists/options/values, but do NOT clear any document/proposal unless deleted
-        doc_options = [{'label': fn, 'value': fn} for fn in session_dict['uploaded_documents'].keys()]
-        if not doc_value or doc_value not in session_dict['uploaded_documents']:
-            doc_value = next(iter(session_dict['uploaded_documents']), None)
-        proposal_options = [{'label': fn, 'value': fn} for fn in session_dict['proposals'].keys()]
-        if not proposal_value or proposal_value not in session_dict['proposals']:
-            proposal_value = next(iter(session_dict['proposals']), None)
-        documents_list = get_documents_list(session_dict['uploaded_documents'], session_dict['shredded_documents'])
-        proposals_list = get_proposals_list(session_dict['proposals'])
+            gemini_lock.release()
+        doc_options = [{'label': fn, 'value': fn} for fn in uploaded_documents.keys()]
+        doc_value = doc_value if doc_value in uploaded_documents else (next(iter(uploaded_documents), None) if uploaded_documents else None)
+        proposal_options = [{'label': fn, 'value': fn} for fn in proposals.keys()]
+        proposal_value = proposal_value if proposal_value in proposals else (next(iter(proposals), None) if proposals else None)
+        documents_list = get_documents_list(uploaded_documents, shredded_documents)
+        proposals_list = get_proposals_list(proposals)
         return (
             output_data_upload,
             documents_list, doc_options, doc_value,
@@ -829,7 +807,8 @@ def master_callback(
             "expanded"
         )
 
-    # Always keep selections sticky, unless user has deleted the item
+    doc_value = doc_value if doc_value in uploaded_documents else (next(iter(uploaded_documents), None) if uploaded_documents else None)
+    proposal_value = proposal_value if proposal_value in proposals else (next(iter(proposals), None) if proposals else None)
     return (
         output_data_upload,
         documents_list, doc_options, doc_value,