Fix: Preserve uploaded images across UI interactions

Images were being cleared when clicking radio buttons or other UI elements
because Streamlit re-runs the entire script on every interaction and the
file uploader widget was being recreated without preserving uploaded files.

This fix stores uploaded images in session_state with persistent keys, so they
remain available across reruns. Now users can:
- Upload an image
- Change radio buttons, dropdowns, or other UI elements
- The uploaded image stays visible and available

Applied to both single and multi-image uploaders.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

character_forge_image/ui/components/image_uploader.py

@@ -34,6 +34,10 @@ def render_image_uploader(
     Returns:
         PIL Image object or None
     """
+    # Create persistent key for storing the image in session state
+    persistent_key = f"{key}_persistent_image"
+    persistent_name_key = f"{key}_persistent_name"
+
     uploaded_file = st.file_uploader(
         label=label,
         type=["png", "jpg", "jpeg", "webp"],
@@ -51,6 +55,10 @@ def render_image_uploader(
                 image = Image.open(uploaded_file)
                 logger.debug(f"Image uploaded: {uploaded_file.name}, size: {image.size}")
 
+                # Store image in session state so it persists across reruns
+                st.session_state[persistent_key] = image
+                st.session_state[persistent_name_key] = uploaded_file.name
+
                 # Show preview immediately after upload (high quality, max 512px)
                 if show_preview:
                     # Calculate display size (clamp to 512px while maintaining aspect ratio)
@@ -71,6 +79,26 @@ def render_image_uploader(
             logger.error(f"Image upload error: {e}", exc_info=True)
             return None
 
+    # If no file uploaded but we have a persistent image, return it
+    elif persistent_key in st.session_state and st.session_state[persistent_key] is not None:
+        image = st.session_state[persistent_key]
+        filename = st.session_state.get(persistent_name_key, "uploaded image")
+
+        # Show preview of persistent image
+        if show_preview:
+            max_size = 512
+            scale = min(max_size / image.width, max_size / image.height, 1.0)
+            display_width = int(image.width * scale)
+
+            st.image(
+                image,
+                width=display_width,
+                caption=f"✅ {filename} ({image.width}x{image.height})",
+                use_container_width=False
+            )
+
+        return image
+
     return None
 
 
@@ -94,6 +122,10 @@ def render_multi_image_uploader(
     Returns:
         List of PIL Image objects (None for empty slots)
     """
+    # Create persistent key for storing images in session state
+    persistent_key = f"{key}_persistent_images"
+    persistent_names_key = f"{key}_persistent_names"
+
     uploaded_files = st.file_uploader(
         label=label,
         type=["png", "jpg", "jpeg", "webp"],
@@ -103,6 +135,7 @@ def render_multi_image_uploader(
     )
 
     images = []
+    filenames = []
 
     if uploaded_files:
         # Limit to max_images
@@ -112,11 +145,17 @@ def render_multi_image_uploader(
             try:
                 image = Image.open(uploaded_file)
                 images.append(image)
+                filenames.append(uploaded_file.name)
                 logger.debug(f"Image uploaded: {uploaded_file.name}, size: {image.size}")
             except Exception as e:
                 st.error(f"Failed to load {uploaded_file.name}: {str(e)}")
                 logger.error(f"Image upload error: {e}", exc_info=True)
                 images.append(None)
+                filenames.append(None)
+
+        # Store images in session state so they persist across reruns
+        st.session_state[persistent_key] = images
+        st.session_state[persistent_names_key] = filenames
 
         # Show previews if requested (high quality)
         if show_previews and any(img is not None for img in images):
@@ -140,6 +179,31 @@ def render_multi_image_uploader(
         if len(uploaded_files) > max_images:
             st.warning(f"Only the first {max_images} images will be used")
 
+    # If no files uploaded but we have persistent images, use them
+    elif persistent_key in st.session_state and st.session_state[persistent_key]:
+        images = st.session_state[persistent_key]
+        filenames = st.session_state.get(persistent_names_key, [])
+
+        # Show previews of persistent images
+        if show_previews and any(img is not None for img in images):
+            cols = st.columns(len([img for img in images if img is not None]))
+            col_idx = 0
+            for i, img in enumerate(images):
+                if img is not None:
+                    with cols[col_idx]:
+                        max_size = 300
+                        scale = min(max_size / img.width, max_size / img.height, 1.0)
+                        display_width = int(img.width * scale)
+
+                        fname = filenames[i] if i < len(filenames) else f"Image {i+1}"
+                        st.image(
+                            img,
+                            width=display_width,
+                            caption=f"✅ {fname}",
+                            use_container_width=False
+                        )
+                    col_idx += 1
+
     # Pad to max_images with None
     while len(images) < max_images:
         images.append(None)