Fix: proposal </div> render, persist dossier uploads across navigation, robust dark-mode bridge

app/ui/dossier_screen.py

@@ -216,13 +216,27 @@ def is_cloud_mode() -> bool:
     return bool(os.getenv("SPACE_ID") or os.getenv("UPWORK_CLOUD"))
 
 
-def _materialize_uploads(files) -> str:
-    """Write uploaded files into this session's temp dir; return its path.
+# Session keys for the persisted upload set. The records (name + bytes) are
+# kept in session — NOT just in the file_uploader widget — because the widget
+# returns an empty list after the user navigates to another step and back, so
+# relying on it alone makes the dossier appear "lost". Kept until the page is
+# reloaded (new session) or the user clears them.
+_UPLOAD_RECORDS_KEY = "dossier_uploaded_files"
+_UPLOAD_SEQ_KEY = "dossier_uploader_seq"
 
-    A re-upload fully replaces the previous set. The directory lives under the
-    OS temp location and holds the files only for the lifetime of the session;
-    it is never committed or shared. Returns the directory path so the standard
-    folder pipeline can read it.
+
+def _upload_signature(records: list[dict]) -> tuple:
+    """(name, size) per file — detects a genuinely changed upload set."""
+    return tuple((r["name"], len(r["bytes"])) for r in records)
+
+
+def _materialize_records(records: list[dict]) -> str:
+    """Write the persisted upload records into this session's temp dir.
+
+    Fully replaces the previous set. The directory lives under the OS temp
+    location and holds the files only for the lifetime of the session; it is
+    never committed or shared. Returns the directory path for the standard
+    folder pipeline.
     """
     base = st.session_state.get("_dossier_upload_dir")
     if not base or not Path(base).is_dir():
@@ -234,15 +248,66 @@ def _materialize_uploads(files) -> str:
             existing.unlink()
         except OSError:  # pragma: no cover - best effort cleanup
             pass
-    for f in files:
-        # Strip any directory components from the browser-supplied name.
-        safe_name = Path(f.name).name
+    for r in records:
+        safe_name = Path(r["name"]).name  # strip any directory components
         if not safe_name:
             continue
-        (base_path / safe_name).write_bytes(f.getvalue())
+        (base_path / safe_name).write_bytes(r["bytes"])
     return str(base_path)
 
 
+def _sync_dossier_uploads() -> list[dict]:
+    """Reconcile the live uploader with the persisted record set.
+
+    * A new/changed upload replaces the stored records, re-materializes the
+      temp folder, and invalidates downstream evidence.
+    * An empty uploader (e.g. after navigating away and back) keeps the stored
+      records, so the dossier is never silently lost.
+    * If the records exist but their temp folder is gone (rare), it is rebuilt.
+
+    Returns the current persisted records.
+    """
+    ss = st.session_state
+    accepted = sorted(ext.lstrip(".") for ext in SUPPORTED_EXTENSIONS)
+    uploader_key = f"dossier_uploads_{ss.get(_UPLOAD_SEQ_KEY, 0)}"
+    files = st.file_uploader(
+        "Upload your profile evidence",
+        type=accepted,
+        accept_multiple_files=True,
+        key=uploader_key,
+        help=(
+            "Portfolio, résumé, testimonials, past proposals. Your files are "
+            "processed in this session only and are never stored on the server."
+        ),
+    )
+
+    stored: list[dict] = ss.get(_UPLOAD_RECORDS_KEY) or []
+    if files:
+        records = [{"name": f.name, "bytes": f.getvalue()} for f in files]
+        if _upload_signature(records) != _upload_signature(stored):
+            ss[_UPLOAD_RECORDS_KEY] = records
+            ss["dossier_folder_path"] = _materialize_records(records)
+            _reset_downstream()
+            stored = records
+    elif stored:
+        # Uploader came back empty (navigation), but we still hold the files —
+        # make sure the temp folder still backs them for the read pipeline.
+        path = (ss.get("dossier_folder_path") or "").strip()
+        if not path or not Path(path).is_dir():
+            ss["dossier_folder_path"] = _materialize_records(stored)
+    return stored
+
+
+def _clear_dossier_uploads() -> None:
+    """Remove the persisted dossier upload set and reset the uploader widget."""
+    ss = st.session_state
+    ss[_UPLOAD_RECORDS_KEY] = []
+    ss["dossier_folder_path"] = ""
+    # Bump the uploader key so the widget itself re-mounts empty.
+    ss[_UPLOAD_SEQ_KEY] = ss.get(_UPLOAD_SEQ_KEY, 0) + 1
+    _reset_downstream()
+
+
 def _card_upload_dossier(debug: bool) -> None:
     """Cloud variant of the dossier step: upload files, then continue.
 
@@ -255,26 +320,21 @@ def _card_upload_dossier(debug: bool) -> None:
         theme.section_label(
             "Step 1 · Upload dossier files" if debug else "Upload dossier files"
         )
-        accepted = sorted(ext.lstrip(".") for ext in SUPPORTED_EXTENSIONS)
-        files = st.file_uploader(
-            "Upload your profile evidence",
-            type=accepted,
-            accept_multiple_files=True,
-            key="dossier_uploads",
-            help=(
-                "Portfolio, résumé, testimonials, past proposals. Your files "
-                "are processed in this session only and are never stored on "
-                "the server."
-            ),
-        )
-        if files:
-            path = _materialize_uploads(files)
-            if path != (st.session_state.get("dossier_folder_path") or "").strip():
-                st.session_state["dossier_folder_path"] = path
-                _reset_downstream()
-            st.caption(f"{len(files)} file(s) ready.")
+        stored = _sync_dossier_uploads()
+        has_files = bool(stored)
+
+        if has_files:
+            col_ready, col_clear = st.columns([3, 1])
+            col_ready.caption(f"{len(stored)} file(s) ready.")
+            if col_clear.button(
+                "Remove all",
+                key="dossier_clear_uploads_btn",
+                use_container_width=True,
+                help="Clear these files so you can upload a different set.",
+            ):
+                _clear_dossier_uploads()
+                st.rerun()
 
-        has_files = bool(files)
         if debug:
             # Validate against the uploaded folder so the file count / strength
             # panel works the same as the desktop debug flow.

app/ui/theme.py

@@ -416,18 +416,41 @@ def inject_css() -> None:
 
 
 def apply_step_accent(step_key: str, *, dark: bool = False) -> None:
-    """Re-tint the whole screen to the current step's signature hue."""
+    """Re-tint the whole screen to the current step's signature hue + theme.
+
+    The design tokens live under ``[data-theme]`` on the parent ``<html>``, so
+    this bridges from the component iframe to set it. It is hardened against the
+    two things that made dark mode feel flaky: the parent DOM not being ready
+    when the iframe first runs (so it retries briefly), and a write throwing in
+    some embedding contexts (so it is wrapped in try/catch). It also sets
+    ``color-scheme`` so native widgets (uploader, inputs) adopt the dark look.
+    """
     h, c, h2 = STEP_COLORS.get(step_key, _DEFAULT_ACCENT)
     theme_val = "dark" if dark else "light"
     components.html(
         f"""<script>
         (function(){{
-          var r = window.parent.document.documentElement;
-          if (!r) return;
-          r.setAttribute('data-theme', '{theme_val}');
-          r.style.setProperty('--accent-h', '{h}');
-          r.style.setProperty('--accent-c', '{c}');
-          r.style.setProperty('--accent2-h', '{h2}');
+          var theme = '{theme_val}';
+          function apply(){{
+            try {{
+              var r = window.parent.document.documentElement;
+              if (!r) return false;
+              r.setAttribute('data-theme', theme);
+              r.style.setProperty('color-scheme', theme);
+              r.style.setProperty('--accent-h', '{h}');
+              r.style.setProperty('--accent-c', '{c}');
+              r.style.setProperty('--accent2-h', '{h2}');
+              try {{ window.parent.document.body.style.colorScheme = theme; }} catch (e) {{}}
+              return true;
+            }} catch (e) {{ return false; }}
+          }}
+          if (!apply()) {{
+            // Parent not ready yet — retry a few times, then give up quietly.
+            var n = 0;
+            var t = setInterval(function(){{
+              if (apply() || ++n > 20) clearInterval(t);
+            }}, 50);
+          }}
         }})();
         </script>""",
         height=0,
@@ -478,8 +501,14 @@ def verdict_banner(beginner_result: str, headline: str, body: str) -> None:
 # ── Proposal document ──────────────────────────────────────────────────────
 
 
-def proposal_doc(text: str, word_count: int, file_count: int = 0) -> None:
-    """Render the styled proposal document card from the prototype."""
+def _proposal_doc_html(text: str, word_count: int, file_count: int = 0) -> str:
+    """Build the proposal card HTML as a single line (see :func:`proposal_doc`).
+
+    Returned as one line with no leading indentation and no whitespace-only
+    gaps so Streamlit's markdown parser renders it as pure HTML — a blank line
+    (e.g. when ``grounded`` is empty) would otherwise terminate the HTML block
+    and turn the trailing ``</div>`` into a literal code block.
+    """
     import html as _html
     import re as _re
 
@@ -515,15 +544,24 @@ def proposal_doc(text: str, word_count: int, file_count: int = 0) -> None:
         else ""
     )
     wc_label = f"{word_count} words" if word_count else ""
+    # Build as ONE line with no leading indentation and no whitespace-only
+    # gaps. Streamlit runs this through a markdown parser: a blank/whitespace
+    # line (e.g. when ``grounded`` is empty) would terminate the HTML block and
+    # the next indented ``</div>`` would render as a literal code block. Keeping
+    # it single-line avoids that entirely.
+    return (
+        f'<div class="doc-toolbar">'
+        f'<span class="wordcount">{wc_label}</span>'
+        f'<div class="toolbar-spacer"></div>'
+        f"</div>"
+        f'<div class="proposal-doc">{paras_html}{grounded}</div>'
+    )
+
+
+def proposal_doc(text: str, word_count: int, file_count: int = 0) -> None:
+    """Render the styled proposal document card from the prototype."""
     st.markdown(
-        f"""<div class="doc-toolbar">
-          <span class="wordcount">{wc_label}</span>
-          <div class="toolbar-spacer"></div>
-        </div>
-        <div class="proposal-doc">
-          {paras_html}
-          {grounded}
-        </div>""",
+        _proposal_doc_html(text, word_count, file_count),
         unsafe_allow_html=True,
     )