Update app.py

app.py

@@ -200,6 +200,7 @@ Each operation object in the JSON list must have these keys and string values:
 -   Any literal double quote (`"`) character *within* the string content MUST be escaped as `\\"`.
 -   Any literal backslash (`\\`) character *within* the string content MUST be escaped as `\\\\`.
 -   Any newline characters *within* the string content MUST be escaped as `\\n`. Avoid literal newlines in JSON string values; use `\\n` instead.
+    THIS IS ESPECIALLY IMPORTANT FOR THE 'insight' FIELD, as the insight text itself can be multi-line. Each internal newline in the original text MUST be represented as `\\n` in the JSON string value.
     *Example of correctly escaped insight string in JSON:*
     `"insight": "[RESPONSE_PRINCIPLE|0.8] User prefers concise answers, stating: \\"Just the facts!\\". Avoid verbose explanations unless asked.\\nFollow up with a question if appropriate."`
 **Your Reflection Process (Consider each step and generate operations accordingly):**
@@ -238,6 +239,7 @@ Task: Based on your three-step reflection process (Core Identity, New Learnings,
 2.  **Add New Learnings:** Identify and "add" any distinct new facts, skills, or important user preferences learned from the "Interaction Summary".
 3.  **Update Existing Principles:** "Update" any non-core principles from "Potentially Relevant Existing Rules" if the "Interaction Summary" provided a clear refinement.
 Combine all findings into a single JSON list of operations. If there are multiple distinct changes based on the interaction and existing rules, ensure your list reflects all of them. Output JSON only, adhering to all specified formatting rules.
+**ULTRA-IMPORTANT FINAL REMINDER: YOUR ENTIRE RESPONSE MUST BE A SINGLE, VALID JSON LIST. DOUBLE-CHECK ALL STRING VALUES FOR CORRECTLY ESCAPED NEWLINES (\\n) AND QUOTES (\\\") BEFORE OUTPUTTING. INVALID JSON WILL BE REJECTED.**
 """
         insight_msgs = [{"role":"system", "content":insight_sys_prompt}, {"role":"user", "content":insight_user_prompt}]
         insight_prov, insight_model_disp = provider, model_disp_name
@@ -250,44 +252,80 @@ Combine all findings into a single JSON list of operations. If there are multipl
         raw_ops_json = "".join(list(call_model_stream(provider=insight_prov, model_display_name=insight_model_disp, messages=insight_msgs, api_key_override=api_key_override, temperature=0.05, max_tokens=2000))).strip()
         ops, processed_count = [], 0
         json_match_ops = re.search(r"```json\s*(\[.*?\])\s*```", raw_ops_json, re.DOTALL|re.I) or re.search(r"(\[.*?\])", raw_ops_json, re.DOTALL)
+        
         if json_match_ops:
-            try: ops = json.loads(json_match_ops.group(1))
-            except Exception as e: logger.error(f"DEFERRED [{task_id}]: JSON ops parse error: {e}. Raw: {json_match_ops.group(1)[:500]}")
+            try: 
+                ops_json_str = json_match_ops.group(1)
+                ops = json.loads(ops_json_str)
+            except Exception as e: 
+                logger.error(f"DEFERRED [{task_id}]: JSON ops parse error: {e}. Raw content parsed: {ops_json_str[:500]}")
+        else:
+             logger.info(f"DEFERRED [{task_id}]: No JSON list structure found in LLM output. Raw output (first 500 chars): {raw_ops_json[:500]}")
+
         if isinstance(ops, list) and ops:
             logger.info(f"DEFERRED [{task_id}]: LLM provided {len(ops)} insight ops.")
-            for op in ops:
-                if not isinstance(op, dict): continue
-                action, insight_text = op.get("action","").lower(), op.get("insight","").strip()
-                if not insight_text or not re.match(r"\[(CORE_RULE|RESPONSE_PRINCIPLE|BEHAVIORAL_ADJUSTMENT|GENERAL_LEARNING)\|([\d\.]+?)\]", insight_text, re.I): continue
+            for op_idx, op in enumerate(ops):
+                if not isinstance(op, dict): 
+                    logger.warning(f"DEFERRED [{task_id}]: Op {op_idx}: Skipped non-dict item in ops list: {op}")
+                    continue
+                
+                action = op.get("action","").lower()
+                insight_text = op.get("insight","") # Keep as is initially for logging
+                old_insight = op.get("old_insight_to_replace","") # Keep as is initially
+
+                if not isinstance(insight_text, str):
+                    logger.warning(f"DEFERRED [{task_id}]: Op {op_idx}: Skipped op due to non-string insight_text: {op}")
+                    continue
+                insight_text = insight_text.strip() # Now strip
+
+                if not isinstance(old_insight, str) and old_insight is not None : # Allow None for old_insight
+                    logger.warning(f"DEFERRED [{task_id}]: Op {op_idx}: Skipped op due to non-string old_insight_to_replace: {op}")
+                    continue
+                if old_insight is not None:
+                    old_insight = old_insight.strip() # Strip if not None
+
+                if not insight_text or not re.match(r"\[(CORE_RULE|RESPONSE_PRINCIPLE|BEHAVIORAL_ADJUSTMENT|GENERAL_LEARNING)\|([\d\.]+?)\]", insight_text, re.I|re.DOTALL): 
+                    logger.warning(f"DEFERRED [{task_id}]: Op {op_idx}: Skipped op due to invalid/empty insight_text format: '{insight_text[:100]}...' from op: {op}")
+                    continue
+
                 if action == "add":
-                    success, _ = add_rule_entry(insight_text)
+                    success, status_msg = add_rule_entry(insight_text)
                     if success: processed_count +=1
+                    else: logger.warning(f"DEFERRED [{task_id}]: Op {op_idx} (add): Failed to add rule '{insight_text[:50]}...'. Status: {status_msg}")
                 elif action == "update":
-                    old_insight = op.get("old_insight_to_replace","").strip()
-                    if old_insight and old_insight != insight_text: remove_rule_entry(old_insight)
-                    success, _ = add_rule_entry(insight_text)
+                    if old_insight and old_insight != insight_text: 
+                        remove_success = remove_rule_entry(old_insight)
+                        if not remove_success:
+                             logger.warning(f"DEFERRED [{task_id}]: Op {op_idx} (update): Failed to remove old rule '{old_insight[:50]}...' before adding new.")
+                    success, status_msg = add_rule_entry(insight_text)
                     if success: processed_count +=1
-            logger.info(f"DEFERRED [{task_id}]: Processed {processed_count} insight ops.")
-        else: logger.info(f"DEFERRED [{task_id}]: No valid insight ops from LLM. Raw output (first 500 chars): {raw_ops_json[:500]}")
-    except Exception as e: logger.error(f"DEFERRED [{task_id}]: CRITICAL ERROR: {e}", exc_info=True)
+                    else: logger.warning(f"DEFERRED [{task_id}]: Op {op_idx} (update): Failed to add updated rule '{insight_text[:50]}...'. Status: {status_msg}")
+                else:
+                    logger.warning(f"DEFERRED [{task_id}]: Op {op_idx}: Skipped op due to unknown action '{action}': {op}")
+
+            logger.info(f"DEFERRED [{task_id}]: Processed {processed_count} insight ops out of {len(ops)} received.")
+        elif not json_match_ops : # Already logged if no JSON structure found
+            pass
+        else: # json_match_ops was true, but ops list is empty or not a list (e.g. parsing error led to ops not being a list)
+            logger.info(f"DEFERRED [{task_id}]: No valid list of insight ops from LLM after parsing. Raw match (first 500 chars): {json_match_ops.group(1)[:500] if json_match_ops else 'N/A'}")
+            
+    except Exception as e: logger.error(f"DEFERRED [{task_id}]: CRITICAL ERROR in deferred task: {e}", exc_info=True)
     logger.info(f"DEFERRED [{task_id}]: END. Total: {time.time() - start_time:.2f}s")
 
 def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_name: str, sel_model_disp_name: str, ui_api_key: str|None, cust_sys_prompt: str):
     global current_chat_session_history
     cleared_input, updated_gr_hist, status_txt = "", list(gr_hist_list), "Initializing..."
-    def_detect_out_md = gr.Markdown(visible=False) # Initialize with visible=False
-    def_fmt_out_txt = gr.Textbox(value="*Waiting...*", interactive=True) # Ensure interactive
+    def_detect_out_md = gr.Markdown(visible=False) 
+    def_fmt_out_txt = gr.Textbox(value="*Waiting...*", interactive=True) 
     def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False) 
     
     if not user_msg_txt.strip():
         status_txt = "Error: Empty message."
         updated_gr_hist.append((user_msg_txt or "(Empty)", status_txt))
-        # Make sure to yield for all outputs in chat_outs
         yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn)
         return
 
     updated_gr_hist.append((user_msg_txt, "<i>Thinking...</i>"))
-    # Initial yield for chat update
     yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn)
     
     internal_hist = list(current_chat_session_history); internal_hist.append({"role": "user", "content": user_msg_txt})
@@ -317,7 +355,7 @@ def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_na
                 if updated_gr_hist and updated_gr_hist[-1][0] == user_msg_txt: 
                     updated_gr_hist[-1] = (user_msg_txt, curr_bot_disp_msg or "(No text)")
                 
-                def_fmt_out_txt = gr.Textbox(value=curr_bot_disp_msg, interactive=True, show_copy_button=True) # Update
+                def_fmt_out_txt = gr.Textbox(value=curr_bot_disp_msg, interactive=True, show_copy_button=True)
                 
                 if curr_bot_disp_msg and not curr_bot_disp_msg.startswith("Error:"):
                     with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".md", encoding='utf-8') as tmpfile:
@@ -328,7 +366,7 @@ def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_na
                     def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
                 
                 insights_md_content = "### Insights Considered:\n" + ("\n".join([f"- **[{i.get('type','N/A')}|{i.get('score','N/A')}]** {i.get('text','N/A')[:100]}..." for i in insights_used_parsed[:3]]) if insights_used_parsed else "*None specific.*")
-                def_detect_out_md = gr.Markdown(value=insights_md_content, visible=True) # Update with value and visible
+                def_detect_out_md = gr.Markdown(value=insights_md_content, visible=True if insights_used_parsed else False)
 
             yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn)
             if upd_type == "final_response_and_insights": break
@@ -339,9 +377,9 @@ def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_na
             updated_gr_hist[-1] = (user_msg_txt, error_message_for_chat)
         else: 
             updated_gr_hist.append((user_msg_txt, error_message_for_chat))
-        def_fmt_out_txt = gr.Textbox(value=error_message_for_chat, interactive=True) # Update
-        def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False) # Reset
-        def_detect_out_md = gr.Markdown(value="*Error processing request.*", visible=True) # Update
+        def_fmt_out_txt = gr.Textbox(value=error_message_for_chat, interactive=True)
+        def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
+        def_detect_out_md = gr.Markdown(value="*Error processing request.*", visible=True)
         yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn)
         return
 
@@ -356,14 +394,13 @@ def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_na
         status_txt = "Response complete. Background learning initiated."
     else: 
         status_txt = "Processing finished; no valid response or error occurred."
-        if final_bot_resp_acc.startswith("Error:"): # If there was an error string in final_bot_resp_acc
+        if final_bot_resp_acc.startswith("Error:"): 
             status_txt = final_bot_resp_acc 
             if updated_gr_hist and updated_gr_hist[-1][0] == user_msg_txt:
-                 updated_gr_hist[-1] = (user_msg_txt, final_bot_resp_acc) # Update chatbot with error
+                 updated_gr_hist[-1] = (user_msg_txt, final_bot_resp_acc)
             def_fmt_out_txt = gr.Textbox(value=final_bot_resp_acc, interactive=True)
             def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
 
-    # Final yield for this handler
     yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn)
     
     if temp_dl_file_path and os.path.exists(temp_dl_file_path):
@@ -371,19 +408,16 @@ def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_na
         except Exception as e_unlink: logger.error(f"Error deleting temp download file {temp_dl_file_path}: {e_unlink}")
 
 # --- UI Functions for Rules and Memories ---
-def ui_view_rules_action_fn(): return "\n\n---\n\n".join(get_all_rules_cached()) or "No rules found."
+def ui_refresh_rules_display_fn(): return "\n\n---\n\n".join(get_all_rules_cached()) or "No rules found."
 
 def ui_download_rules_action_fn():
     rules_content = "\n\n---\n\n".join(get_all_rules_cached())
     if not rules_content.strip():
         gr.Warning("No rules to download.")
-        # Return an update to clear any previous file and disable button
         return gr.DownloadButton(value=None, interactive=False, label="No Rules") 
-    
     try:
         with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt", encoding='utf-8') as tmpfile:
             tmpfile.write(rules_content)
-            # Gradio's DownloadButton click handler should return the filepath string
             return tmpfile.name 
     except Exception as e:
         logger.error(f"Error creating rules download file: {e}")
@@ -413,30 +447,26 @@ def ui_upload_rules_action_fn(uploaded_file_obj, progress=gr.Progress()):
     msg = f"Rules Upload: Processed {total_to_process}. Added: {added_count}, Skipped (duplicates): {skipped_count}, Errors/Invalid: {error_count}."
     logger.info(msg); return msg
 
-def ui_view_memories_action_fn(): return get_all_memories_cached() or [] # Returns list of dicts
+def ui_refresh_memories_display_fn(): return get_all_memories_cached() or [] 
 
 def ui_download_memories_action_fn():
-    memories = get_all_memories_cached() # list of dicts
+    memories = get_all_memories_cached() 
     if not memories:
         gr.Warning("No memories to download.")
         return gr.DownloadButton(value=None, interactive=False, label="No Memories")
 
     jsonl_content = ""
     for mem_dict in memories:
-        try:
-            jsonl_content += json.dumps(mem_dict) + "\n"
-        except Exception as e:
-            logger.error(f"Error serializing memory for download: {mem_dict}, Error: {e}")
-            # Skip problematic memory for download
+        try: jsonl_content += json.dumps(mem_dict) + "\n"
+        except Exception as e: logger.error(f"Error serializing memory for download: {mem_dict}, Error: {e}")
     
     if not jsonl_content.strip():
         gr.Warning("No valid memories to serialize for download.")
         return gr.DownloadButton(value=None, interactive=False, label="No Data")
-
     try:
         with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".jsonl", encoding='utf-8') as tmpfile:
             tmpfile.write(jsonl_content)
-            return tmpfile.name # Return filepath string
+            return tmpfile.name 
     except Exception as e:
         logger.error(f"Error creating memories download file: {e}")
         gr.Error(f"Failed to prepare memories for download: {e}")
@@ -451,25 +481,37 @@ def ui_upload_memories_action_fn(uploaded_file_obj, progress=gr.Progress()):
     added_count, format_error_count, save_error_count = 0,0,0
     memory_objects_to_process = []
     try:
+        # Try parsing as a single JSON list first
         parsed_json = json.loads(content)
-        memory_objects_to_process = parsed_json if isinstance(parsed_json, list) else [parsed_json]
-    except json.JSONDecodeError:
+        if isinstance(parsed_json, list):
+            memory_objects_to_process = parsed_json
+        else: # If it's a single object, wrap it in a list
+            memory_objects_to_process = [parsed_json]
+    except json.JSONDecodeError: # If not a single JSON list, try JSONL
         for line in content.splitlines():
             if line.strip():
                 try: memory_objects_to_process.append(json.loads(line))
-                except: format_error_count += 1
-    if not memory_objects_to_process and format_error_count == 0: return "No valid memory objects found."
+                except json.JSONDecodeError: format_error_count += 1
+                                
+    if not memory_objects_to_process and format_error_count > 0 and not content.strip().startswith("["):
+         # If many format errors and not starting like a list, it was probably meant to be JSONL but all lines failed
+         return f"Memories Upload: File does not seem to be a valid JSON array or JSONL. Format errors on all lines attempted for JSONL."
+    elif not memory_objects_to_process:
+         return "No valid memory objects found in the uploaded file."
+
     total_to_process = len(memory_objects_to_process)
     if total_to_process == 0: return "No memory objects to process (after parsing)."
+    
     progress(0, desc="Starting memories upload...")
     for idx, mem_data in enumerate(memory_objects_to_process):
         if isinstance(mem_data, dict) and all(k in mem_data for k in ["user_input", "bot_response", "metrics"]):
             success, _ = add_memory_entry(mem_data["user_input"], mem_data["metrics"], mem_data["bot_response"])
             if success: added_count += 1
             else: save_error_count += 1
-        else: format_error_count += 1
+        else: format_error_count += 1 # Count errors if structure is wrong even after successful line parse
         progress((idx + 1) / total_to_process, desc=f"Processed {idx+1}/{total_to_process} memories...")
-    msg = f"Memories Upload: Processed {total_to_process}. Added: {added_count}, Format Errors: {format_error_count}, Save Errors: {save_error_count}."
+    
+    msg = f"Memories Upload: Processed {total_to_process} objects. Added: {added_count}, Format Errors (incl. structure issues): {format_error_count}, Save Errors: {save_error_count}."
     logger.info(msg); return msg
 
 
@@ -556,30 +598,31 @@ with gr.Blocks(
                                 scale=7, lines=1, max_lines=3
                             )
                             send_btn = gr.Button("Send", variant="primary", scale=1, min_width=100)
-                        with gr.Accordion("📝 Detailed Response", open=False):
+                        with gr.Accordion("📝 Detailed Response & Insights", open=False):
                             fmt_report_tb = gr.Textbox(
                                 label="Full AI Response", lines=8, interactive=True, show_copy_button=True
                             )
                             dl_report_btn = gr.DownloadButton(
-                                "Download Report", value=None, interactive=False, visible=False # Ensure value is None initially
+                                "Download Report", value=None, interactive=False, visible=False
                             )
-                        detect_out_md = gr.Markdown(visible=False) # Ensure visible is False initially
+                            detect_out_md = gr.Markdown(visible=False) 
 
                 with gr.TabItem("🧠 Knowledge Base"):
                     with gr.Row(equal_height=True):
                         with gr.Column():
                             gr.Markdown("### 📜 Rules Management")
                             rules_disp_ta = gr.TextArea(
-                                label=None, lines=10, placeholder="View or edit rules...", interactive=True
+                                label="Current Rules (Read-only, Edit via Upload/Save)", lines=10, 
+                                placeholder="Rules will appear here. Use 'Save Edited Text' or 'Upload File' to modify.", 
+                                interactive=True # Keep interactive for copy-pasting, but primary edit via save button
                             )
+                            gr.Markdown("To edit rules, modify the text above and click 'Save Edited Text', or upload a new file.")
+                            save_edited_rules_btn = gr.Button("💾 Save Edited Text", variant="primary")
                             with gr.Row(variant="compact"):
-                                view_rules_btn = gr.Button("🔄 Load Rules")
-                                save_edited_rules_btn = gr.Button("💾 Save Rules", variant="primary")
-                            with gr.Row(variant="compact"):
-                                dl_rules_btn = gr.DownloadButton("⬇️ Download Rules", value=None) # Add download button
-                                clear_rules_btn = gr.Button("🗑️ Clear Rules", variant="stop")
+                                dl_rules_btn = gr.DownloadButton("⬇️ Download Rules", value=None) 
+                                clear_rules_btn = gr.Button("🗑️ Clear All Rules", variant="stop")
                             upload_rules_fobj = gr.File(
-                                label="Upload Rules File (.txt, .jsonl)",
+                                label="Upload Rules File (.txt with '---' separators, or .jsonl of rule strings)",
                                 file_types=[".txt", ".jsonl"]
                             )
                             rules_stat_tb = gr.Textbox(
@@ -589,16 +632,15 @@ with gr.Blocks(
                         with gr.Column():
                             gr.Markdown("### 📚 Memories Management")
                             mems_disp_json = gr.JSON(
-                                label=None, value=[] # Initialize with empty list
+                                label="Current Memories (Read-only)", value=[] 
                             )
+                            gr.Markdown("To add memories, upload a .jsonl or .json file.")
                             with gr.Row(variant="compact"):
-                                view_mems_btn = gr.Button("🔄 Load Memories")
-                                dl_mems_btn = gr.DownloadButton("⬇️ Download Memories", value=None) # Add download button
-                            with gr.Row(variant="compact"):
-                                clear_mems_btn = gr.Button("🗑️ Clear Memories", variant="stop")
+                                dl_mems_btn = gr.DownloadButton("⬇️ Download Memories", value=None) 
+                                clear_mems_btn = gr.Button("🗑️ Clear All Memories", variant="stop")
                             upload_mems_fobj = gr.File(
-                                label="Upload Memories File (.jsonl)",
-                                file_types=[".jsonl", ".json"] # Allow .json for single list
+                                label="Upload Memories File (.jsonl of memory objects, or .json array of objects)",
+                                file_types=[".jsonl", ".json"] 
                             )
                             mems_stat_tb = gr.Textbox(
                                 label="Memories Status", interactive=False, lines=1, elem_classes=["status-text"]
@@ -614,84 +656,106 @@ with gr.Blocks(
     chat_ins = [user_msg_tb, main_chat_disp, prov_sel_dd, model_sel_dd, api_key_tb, sys_prompt_tb]
     chat_outs = [user_msg_tb, main_chat_disp, agent_stat_tb, detect_out_md, fmt_report_tb, dl_report_btn]
     
-    # Chat submission events
     chat_event_args = {"fn": handle_gradio_chat_submit, "inputs": chat_ins, "outputs": chat_outs}
     
     send_btn_click_event = send_btn.click(**chat_event_args)
     user_msg_submit_event = user_msg_tb.submit(**chat_event_args)
 
-    # Chain UI refreshes for rules and memories after chat interaction
     for event in [send_btn_click_event, user_msg_submit_event]:
-        event.then(fn=ui_view_rules_action_fn, inputs=None, outputs=rules_disp_ta)
-        event.then(fn=ui_view_memories_action_fn, inputs=None, outputs=mems_disp_json)
-
+        event.then(fn=ui_refresh_rules_display_fn, inputs=None, outputs=rules_disp_ta)
+        event.then(fn=ui_refresh_memories_display_fn, inputs=None, outputs=mems_disp_json)
 
     # Rules Management events
-    view_rules_btn.click(fn=ui_view_rules_action_fn, outputs=rules_disp_ta)
     dl_rules_btn.click(fn=ui_download_rules_action_fn, inputs=None, outputs=dl_rules_btn)
 
-
     def save_edited_rules_action_fn(edited_rules_text: str, progress=gr.Progress()):
         if not edited_rules_text.strip():
             return "No rules text to save."
+        
+        # Clear existing rules before adding from textarea to avoid duplicates if user edits and saves repeatedly
+        # Alternatively, implement a more sophisticated diff/update, but clearing and re-adding is simpler for now.
+        # For now, let's assume add_rule_entry handles duplicates by skipping.
+        # clear_all_rules_data_backend() # Option: clear all first
+        # logger.info("Cleared all rules before saving edited text.")
+
         potential_rules = edited_rules_text.split("\n\n---\n\n")
-        if len(potential_rules) == 1 and "\n" in edited_rules_text:
+        if len(potential_rules) == 1 and "\n" in edited_rules_text: # Fallback for simple newline separation
             potential_rules = [r.strip() for r in edited_rules_text.splitlines() if r.strip()]
+        
         if not potential_rules:
             return "No rules found to process from editor."
+
         added, skipped, errors = 0, 0, 0
         total = len(potential_rules)
         progress(0, desc=f"Saving {total} rules from editor...")
-        for idx, rule_text in enumerate(potential_rules):
-            if not rule_text.strip():
-                continue
-            success, status_msg = add_rule_entry(rule_text.strip())
-            if success:
-                added += 1
-            elif status_msg == "duplicate":
-                skipped += 1
-            else:
-                errors += 1
-            progress((idx + 1) / total, desc=f"Processed {idx+1}/{total} rules...")
-        return f"Editor Save: Added: {added}, Skipped (duplicates): {skipped}, Errors/Invalid: {errors}."
+        
+        # To prevent duplicates from the text area itself if it contained them,
+        # process unique rules from the input text.
+        unique_rules_to_process = sorted(list(set(filter(None, [r.strip() for r in potential_rules]))))
+        
+        # We need to identify rules to remove if they are no longer in the text area
+        # and rules to add if they are new. This is complex.
+        # Simpler: clear all existing rules, then add all from text area.
+        # This is destructive if the user only wanted to add/modify a few.
+        # For now, let's stick to `add_rule_entry` which skips duplicates.
+        # The user should be aware that "Save Edited Text" adds new rules from the text area
+        # and does not remove rules that are no longer present in the text area.
+        # To remove, they should use "Clear All Rules" or upload a new definitive list.
+
+        # For a "Save Edited Text" to truly reflect the text area as the source of truth:
+        # 1. Get current rules from text area.
+        # 2. Get rules currently in the system.
+        # 3. Rules to add = (rules in text area) - (rules in system)
+        # 4. Rules to remove = (rules in system) - (rules in text area)
+        # This is too complex for this iteration. The current add_rule_entry handles duplicates.
+        # Let's make `save_edited_rules_action_fn` clear and re-add for simplicity if that's desired.
+        # OR, it just adds new ones and updates existing ones if `add_rule_entry` can be made to update.
+        # Current `add_rule_entry` adds if not exact duplicate.
+        # Sticking to simpler "add if not present":
+        
+        for idx, rule_text in enumerate(unique_rules_to_process):
+            success, status_msg = add_rule_entry(rule_text) # add_rule_entry handles duplicates
+            if success: added += 1
+            elif status_msg == "duplicate": skipped += 1
+            else: errors += 1
+            progress((idx + 1) / len(unique_rules_to_process), desc=f"Processed {idx+1}/{len(unique_rules_to_process)} rules...")
+        
+        return f"Editor Save: Added: {added}, Skipped (duplicates): {skipped}, Errors/Invalid: {errors} from {len(unique_rules_to_process)} unique rules in text."
 
     save_edited_rules_btn.click(
         fn=save_edited_rules_action_fn,
         inputs=[rules_disp_ta],
         outputs=[rules_stat_tb],
         show_progress="full"
-    ).then(fn=ui_view_rules_action_fn, outputs=rules_disp_ta)
+    ).then(fn=ui_refresh_rules_display_fn, outputs=rules_disp_ta)
 
     upload_rules_fobj.upload(
         fn=ui_upload_rules_action_fn,
         inputs=[upload_rules_fobj],
         outputs=[rules_stat_tb],
         show_progress="full"
-    ).then(fn=ui_view_rules_action_fn, outputs=rules_disp_ta)
+    ).then(fn=ui_refresh_rules_display_fn, outputs=rules_disp_ta)
 
     clear_rules_btn.click(
         fn=lambda: ("All rules cleared." if clear_all_rules_data_backend() else "Error clearing rules."),
         outputs=rules_stat_tb
-    ).then(fn=ui_view_rules_action_fn, outputs=rules_disp_ta)
+    ).then(fn=ui_refresh_rules_display_fn, outputs=rules_disp_ta)
 
     # Memories Management events
-    view_mems_btn.click(fn=ui_view_memories_action_fn, outputs=mems_disp_json)
     dl_mems_btn.click(fn=ui_download_memories_action_fn, inputs=None, outputs=dl_mems_btn)
 
-
     upload_mems_fobj.upload(
         fn=ui_upload_memories_action_fn,
         inputs=[upload_mems_fobj],
         outputs=[mems_stat_tb],
         show_progress="full"
-    ).then(fn=ui_view_memories_action_fn, outputs=mems_disp_json)
+    ).then(fn=ui_refresh_memories_display_fn, outputs=mems_disp_json)
 
     clear_mems_btn.click(
         fn=lambda: ("All memories cleared." if clear_all_memory_data_backend() else "Error clearing memories."),
         outputs=mems_stat_tb
-    ).then(fn=ui_view_memories_action_fn, outputs=mems_disp_json)
+    ).then(fn=ui_refresh_memories_display_fn, outputs=mems_disp_json)
 
-    # Save FAISS for RAM backend
     if MEMORY_STORAGE_BACKEND == "RAM" and 'save_faiss_sidebar_btn' in locals():
         def save_faiss_action_with_feedback_sidebar_fn():
             save_faiss_indices_to_disk()
@@ -702,14 +766,33 @@ with gr.Blocks(
         initialize_memory_system()
         logger.info("App loaded. Memory system initialized.")
         backend_status = "AI Systems Initialized. Ready."
-        rules_on_load = ui_view_rules_action_fn()
-        mems_on_load = ui_view_memories_action_fn()
-        return backend_status, rules_on_load, mems_on_load
+        rules_on_load = ui_refresh_rules_display_fn()
+        mems_on_load = ui_refresh_memories_display_fn()
+        # Initial population of display areas
+        return backend_status, rules_on_load, mems_on_load, gr.Markdown(visible=False), gr.Textbox(value="*Waiting...*", interactive=True), gr.DownloadButton(interactive=False, value=None, visible=False)
+
+
+    # Ensure all outputs for app_load_fn match the number of output components
+    # chat_outs are: [user_msg_tb, main_chat_disp, agent_stat_tb, detect_out_md, fmt_report_tb, dl_report_btn]
+    # demo.load outputs are: [agent_stat_tb, rules_disp_ta, mems_disp_json]
+    # Let's adjust app_load_fn to return values for the components it's supposed to update.
+    
+    initial_load_outputs = [
+        agent_stat_tb, 
+        rules_disp_ta, 
+        mems_disp_json,
+        # Outputs for chat area that might need reset/initial state, matching chat_outs if possible
+        # user_msg_tb (cleared), main_chat_disp (cleared), agent_stat_tb (updated by app_load)
+        # detect_out_md, fmt_report_tb, dl_report_btn
+        detect_out_md, # from chat_outs
+        fmt_report_tb, # from chat_outs
+        dl_report_btn  # from chat_outs
+    ]
+    demo.load(fn=app_load_fn, inputs=None, outputs=initial_load_outputs)
 
-    demo.load(fn=app_load_fn, inputs=None, outputs=[agent_stat_tb, rules_disp_ta, mems_disp_json])
 
 if __name__ == "__main__":
-    logger.info(f"Starting Gradio AI Research Mega Agent (v5.9 - UI Refresh & Download/Upload Enhancements, Memory: {MEMORY_STORAGE_BACKEND})...")
+    logger.info(f"Starting Gradio AI Research Mega Agent (v6.0 - JSON Fix & UI Upload Simplification, Memory: {MEMORY_STORAGE_BACKEND})...")
     app_port = int(os.getenv("GRADIO_PORT", 7860))
     app_server = os.getenv("GRADIO_SERVER_NAME", "127.0.0.1")
     app_debug = os.getenv("GRADIO_DEBUG", "False").lower() == "true"