P0-R7-F1-D no-upload qualitative reliability

app.py

@@ -860,11 +860,25 @@ def _current_method_preflight(*, confirmed_method_family: str | None = None) ->
     preflight = resolve_generation_preflight(
         str(st.session_state.get("sp_topic") or DEFAULT_TOPIC),
         _canonical_user_keywords(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS),
-        materials=_uploaded_material_descriptors(),
+        # P0-R7-F1: new tasks are intentionally no-upload.  Never let stale
+        # Streamlit widget/session state influence design resolution.
+        materials=[],
         confirmed_method_family=confirmed,
     )
     return preflight, signature
 
+
+def _clear_new_task_material_state() -> None:
+    """Remove stale upload/session projections for the no-upload new-task UI.
+
+    Historical/resumable tasks retain their already-frozen request.json inputs;
+    this guard only prevents browser session residue from entering a new task.
+    """
+    st.session_state["up_research_materials"] = []
+    st.session_state["sp_material_parse_cache"] = {}
+    for family in METHOD_FAMILIES:
+        st.session_state.pop(f"up_research_materials_{family}", None)
+
 def _classify_and_save_research_materials(
     method_family: str, inputs_dir: Path
 ) -> tuple[list[str], list[str], list[str], str, list[dict]]:
@@ -934,9 +948,15 @@ def _persist_task_request(
     if not expected_lane or expected_lane != str(mode or "").strip().lower():
         raise RuntimeError("method_family_policy_lane_mismatch")
 
-    refs, data, interviews, material_use_decision, material_file_roles = _classify_and_save_research_materials(
-        method_family, inputs_dir
-    )
+    # P0-R7-F1 no-upload contract for every NEW request.  Do not consult
+    # Streamlit uploader/session state here: request freeze is the server-side
+    # authority that closes hidden/stale upload paths.  Legacy frozen tasks are
+    # unaffected because they already own their immutable request.json.
+    refs: list[str] = []
+    data: list[str] = []
+    interviews: list[str] = []
+    material_use_decision = "none"
+    material_file_roles: list[dict] = []
 
     request_data = {
         "task_id": task_id,
@@ -1155,14 +1175,6 @@ def _process_pending_launch(lang_code: str) -> None:
         st.warning(tr(lang_code, "method_resolution_invalid"))
         return
 
-    material_gate = _material_preflight_report(
-        pending_family, _uploaded_material_entries()
-    )
-    if not bool(material_gate.get("ok")):
-        st.session_state["sp_pending_launch"] = None
-        st.warning(tr(lang_code, "material_preflight_blocked"))
-        return
-
     projection = get_product_ui_projection()
     selected_product_tier = (
         str(st.session_state.get("sp_product_tier") or "").strip().upper()
@@ -1848,9 +1860,10 @@ def render_workspace_controls(user):
         key="sp_keywords",
     )
 
-    # P0-R7-E1 simplified workspace: Research Design -> Recommended Template ->
-    # Research Materials.  New tasks accept empirical materials only; reference
-    # literature upload is intentionally removed from the product surface.
+    # P0-R7-F1 simplified workspace: Paper Title -> Keywords -> Research Design
+    # -> Standard/Flagship -> Target Word Count -> Generate.  New tasks accept
+    # no uploaded literature or empirical material.  Historical task inputs
+    # remain frozen in their existing request.json and are not rewritten here.
     if active:
         active_family = _task_method_family(task)
         active_capability = method_capability(active_family)
@@ -1864,6 +1877,7 @@ def render_workspace_controls(user):
         }
         method_signature = ""
     else:
+        _clear_new_task_material_state()
         # One business authority owns the new-task research design. The widget is
         # only a UI projection; workflow/engine/template come from the registry.
         authority_family, method_signature, _reconciliation = (
@@ -1897,106 +1911,6 @@ def render_workspace_controls(user):
     elif not active:
         st.info(tr(lang_code, "method_supported", method=method_label))
 
-    with st.expander(tr(lang_code, "adaptive_template_expander")):
-        if method_family in METHOD_FAMILIES:
-            st.markdown(tr(lang_code, f"template_help_{method_family}"))
-            capability = dict(preflight.get("capability") or method_capability(method_family))
-            template_profile = str(capability.get("template_profile") or "").strip()
-            template_info = get_research_material_template(lang_code, template_profile)
-            template_data = str(template_info.get("content") or "")
-            if template_data:
-                st.code(template_data, language=str(template_info.get("code_language") or "text"))
-                st.download_button(
-                    label=tr(lang_code, "download_research_template"),
-                    data=template_data,
-                    file_name=str(template_info.get("filename") or "SmartPaper_Research_Materials_Template.txt"),
-                    mime=str(template_info.get("mime_type") or "text/plain"),
-                    use_container_width=True,
-                )
-            else:
-                st.warning(tr(lang_code, "method_resolution_invalid"))
-        else:
-            st.markdown(tr(lang_code, "template_help_undetermined"))
-
-    allowed_extensions = (
-        _research_material_extension_contract(method_family)
-        if method_family in METHOD_FAMILIES
-        else ()
-    )
-    uploader_help_key = (
-        f"research_materials_help_{method_family}"
-        if method_family in METHOD_FAMILIES
-        else "research_materials_help_undetermined"
-    )
-    uploaded_widget = st.file_uploader(
-        tr(lang_code, "research_materials_label"),
-        type=list(allowed_extensions),
-        accept_multiple_files=True,
-        key=f"up_research_materials_{method_family}",
-        disabled=active or not allowed_extensions,
-        help=tr(lang_code, uploader_help_key),
-    )
-    # Canonical non-widget session projection used by request freeze/preflight.
-    st.session_state["up_research_materials"] = list(uploaded_widget or [])
-
-    material_entries = _uploaded_material_entries()
-    limits_ok, material_counts, material_policy = _material_limits_ok(material_entries)
-    if material_counts["research"] > material_policy["research_material_file_limit"]:
-        st.error(
-            tr(
-                lang_code,
-                "material_research_limit_exceeded",
-                limit=material_policy["research_material_file_limit"],
-            )
-        )
-
-    material_gate = {"ok": True, "failures": []}
-    if not active and limits_ok:
-        material_gate = _material_preflight_report(method_family, material_entries)
-        expected_format = (material_gate.get("expected_extensions") or [""])[0].upper()
-        for failure in material_gate.get("failures") or []:
-            error_code = str(failure.get("error") or "")
-            if error_code.startswith("research_material_file_too_large"):
-                st.error(
-                    tr(
-                        lang_code,
-                        "material_file_size_exceeded",
-                        filename=str(failure.get("name") or ""),
-                        limit_mb=max(1, int(material_policy["research_material_file_max_bytes"]) // (1024 * 1024)),
-                    )
-                )
-            elif error_code == "template_example_not_replaced":
-                st.error(
-                    tr(
-                        lang_code,
-                        "material_template_example_not_replaced",
-                        filename=str(failure.get("name") or ""),
-                    )
-                )
-            else:
-                st.error(
-                    tr(
-                        lang_code,
-                        "material_template_parse_failed",
-                        filename=str(failure.get("name") or ""),
-                        format=expected_format,
-                    )
-                )
-        if material_gate.get("total_size_exceeded"):
-            st.error(
-                tr(
-                    lang_code,
-                    "material_total_size_exceeded",
-                    limit_mb=max(1, int(material_policy["research_material_total_max_bytes"]) // (1024 * 1024)),
-                )
-            )
-        if material_gate.get("bundle_capacity_exceeded"):
-            st.error(tr(lang_code, "material_bundle_capacity_exceeded"))
-        if material_gate.get("content_insufficient"):
-            st.error(tr(lang_code, "material_research_content_insufficient"))
-    elif not active:
-        material_gate = {"ok": False, "failures": []}
-
     product_ui = get_product_ui_projection()
     product_ui_ready = product_ui.get("mode") == "a5_product"
     selected_remaining: int | None = None
@@ -2072,7 +1986,6 @@ def render_workspace_controls(user):
                 st.rerun()
         can_start = bool(
             preflight.get("can_start_generation")
-            and bool(material_gate.get("ok"))
             and product_ui_ready
             and selected_remaining is not None
             and selected_remaining > 0
@@ -2090,17 +2003,12 @@ def render_workspace_controls(user):
             click_preflight, click_signature = _current_method_preflight(
                 confirmed_method_family=launch_family
             )
-            click_material_gate = _material_preflight_report(
-                launch_family, _uploaded_material_entries()
-            )
             if (
                 not launch_family
                 or not bool(click_preflight.get("can_start_generation"))
                 or str(click_preflight.get("method_family") or "").strip().casefold() != launch_family
             ):
                 st.warning(tr(lang_code, "method_resolution_invalid"))
-            elif not bool(click_material_gate.get("ok")):
-                st.warning(tr(lang_code, "material_preflight_blocked"))
             else:
                 resolved_mode = str(click_preflight.get("legacy_policy_lane") or "").strip().lower()
                 capability = dict(click_preflight.get("capability") or {})
@@ -2125,7 +2033,6 @@ def render_workspace_controls(user):
                 st.info(tr(lang_code, "pipeline_start"))
                 _inject_generation_action_scroll()
 
-    inject_file_uploader_i18n(lang_code)
 
 
 render_workspace_controls(authenticated_user)

core/qualitative_engine.py

@@ -660,6 +660,7 @@ Rules:
 7. Freeze concise, internally coherent trustworthiness, ethics, and reflexivity procedures in their typed arrays so later Methods prose has an explicit study-owned source. Do not name a real ethics board, institution, vendor, approval number, or identifiable organization.
 8. The study_facts object and evidence packet will become the frozen single source of truth for the entire manuscript.
 9. Avoid decorative language, generic AI phrasing, and repetitive quotation patterns.
+10. Keep the JSON compact: each representative quotation should be one concise complete sentence; keep labels short, analytic_logic to one sentence, and each procedure array to at most three concise items. Do not add explanatory prose outside the required fields.
 
 {schema}
 """
@@ -681,22 +682,10 @@ Rules:
         cjk_chars = re.findall(r"[\u3400-\u4dbf\u4e00-\u9fff]", quote)
         return len(cjk_chars) >= 8
 
-    def _qualitative_packet_validation_error(self, data, *, has_user_data, user_intent=None):
-        """Return a bounded local validation reason, or an empty string when safe.
-
-        This pre-freeze validator mirrors the existing fatal packet gates so a
-        malformed/incomplete model response can be regenerated once before any
-        study fact or quotation becomes authoritative. It never repairs JSON or
-        mutates model output.
-        """
-        if not isinstance(data, dict):
-            return "packet_not_json_object"
-
-        facts = data.get("study_facts") or {}
-        evidence = data.get("evidence") or data.get("quotes") or []
-        if not isinstance(facts, dict) or not isinstance(evidence, list):
-            return "invalid_packet_schema"
-
+    def _study_facts_validation_error(self, facts, *, has_user_data, user_intent=None):
+        """Validate frozen qualitative study facts without repairing model output."""
+        if not isinstance(facts, dict):
+            return "invalid_study_facts_schema"
         for key in ("participant_count", "interview_count"):
             value = facts.get(key)
             if value is not None and (not isinstance(value, int) or value <= 0):
@@ -746,6 +735,30 @@ Rules:
             missing_sources = sorted(requested_sources - observed_sources)
             if missing_sources:
                 return "user_intent_data_source_mismatch:" + ",".join(missing_sources)
+        return ""
+
+    def _qualitative_packet_validation_error(self, data, *, has_user_data, user_intent=None):
+        """Return a bounded local validation reason, or an empty string when safe.
+
+        The validator never repairs JSON, invents quotations, or mutates model
+        output.  A completed but unsafe response is discarded and, when
+        appropriate, regenerated through smaller structured stages.
+        """
+        if not isinstance(data, dict):
+            return "packet_not_json_object"
+
+        facts = data.get("study_facts") or {}
+        evidence = data.get("evidence") or data.get("quotes") or []
+        if not isinstance(facts, dict) or not isinstance(evidence, list):
+            return "invalid_packet_schema"
+
+        facts_reason = self._study_facts_validation_error(
+            facts,
+            has_user_data=has_user_data,
+            user_intent=user_intent,
+        )
+        if facts_reason:
+            return facts_reason
 
         seen_quotes = set()
         theme_keys = set()
@@ -774,79 +787,261 @@ Rules:
             return "generated_packet_missing_deviant_evidence"
         return ""
 
-    def _generate_qualitative_packet(self, topic, keywords, raw_interviews, *, has_user_data):
-        """Generate and validate one evidence packet with one bounded fresh retry."""
+    @staticmethod
+    def _theme_plan_validation_error(value):
+        if not isinstance(value, list):
+            return "invalid_theme_plan"
+        cleaned = [re.sub(r"\s+", " ", str(item or "")).strip() for item in value]
+        cleaned = [item for item in cleaned if item]
+        unique = {item.casefold() for item in cleaned}
+        if len(unique) < 3:
+            return "incomplete_theme_plan"
+        return ""
+
+    def _call_qualitative_json(self, system_prompt, prompt, *, max_tokens):
+        """Make one bounded structured call and parse it strictly; never repair JSON."""
+        response = self.agent.call_deepseek(
+            system_prompt,
+            prompt,
+            max_tokens=max_tokens,
+            temp=0.0,
+            model_role="reasoning",
+            thinking=False,
+            allow_fallback=False,
+            response_format={"type": "json_object"},
+            logical_node="structured_json",
+        )
+        response = re.sub(
+            r"<think>.*?</think>",
+            "",
+            str(response or ""),
+            flags=re.DOTALL,
+        ).strip()
+        return self.agent._extract_json_from_text(response)
+
+    def _build_study_facts_stage_request(self, topic, keywords, raw_interviews, user_intent):
+        intent_block = json.dumps(user_intent, ensure_ascii=False)
+        facts_schema = """Return ONLY one valid JSON object with this schema:
+{
+  "study_facts": {
+    "research_setting": "string or Not specified",
+    "data_sources": ["string"],
+    "data_source_roles": [{"actor_role":"string", "data_source":"string", "count":integer or null}],
+    "participant_count": integer or null,
+    "interview_count": integer or null,
+    "trustworthiness_procedures": ["concise procedure"],
+    "ethics_procedures": ["concise procedure"],
+    "reflexivity_procedures": ["concise procedure"],
+    "analytic_design": "one allowed design",
+    "analytic_logic": "one concise sentence",
+    "temporal_structure": "string or Not specified",
+    "case_structure": "string or Not specified"
+  },
+  "theme_plan": ["concise theme 1", "concise theme 2", "concise theme 3"]
+}
+Allowed analytic designs: Process analysis; Comparative case analysis; Grounded theory; Gioia-style inductive coding; Longitudinal qualitative analysis; Iterative thematic/process analysis.
+"""
+        if raw_interviews and len(raw_interviews) > 100:
+            material_block = f"""Use ONLY the supplied qualitative material as the source of study facts. Use null, empty arrays, or \"Not specified\" when the material does not support a fact. Preserve the user's requested design/data-source family only when evidence truth permits it. Do not invent actors, counts, procedures, cases, dates, or settings. The theme_plan must contain at least three concise evidence-grounded higher-order themes and must not contain quotations.
+
+<QUALITATIVE_MATERIAL>
+{raw_interviews[:30000]}
+</QUALITATIVE_MATERIAL>"""
+        else:
+            material_block = """No interview material was supplied. Construct one generic, internally coherent organizational qualitative study directly relevant to the topic. Do not name a real organization or identifiable person. Freeze one coherent setting, sample/data-source structure, analytic design, procedures, temporal/case structure, and at least three concise higher-order themes. Keep every field compact."""
+        return f"""Topic: {topic}
+Keywords: {keywords}
+<USER_RESEARCH_INTENT>{intent_block}</USER_RESEARCH_INTENT>
+
+This is FALLBACK STAGE A. Produce STUDY FACTS and a compact THEME PLAN only. Do not produce quotations or an evidence array.
+
+{material_block}
+
+{facts_schema}
+"""
+
+    def _build_evidence_stage_request(
+        self,
+        topic,
+        keywords,
+        raw_interviews,
+        user_intent,
+        *,
+        facts,
+        theme_plan,
+        prior_reason="",
+    ):
+        intent_block = json.dumps(user_intent, ensure_ascii=False)
+        facts_block = json.dumps(facts, ensure_ascii=False, separators=(",", ":"))
+        themes_block = json.dumps(theme_plan, ensure_ascii=False)
+        retry_note = (
+            f"\nThe previous completed Stage B response failed deterministic validation with reason={prior_reason}. "
+            "Generate a fresh evidence object from the same frozen facts and original inputs; do not repair or continue the previous response."
+            if prior_reason
+            else ""
+        )
+        if raw_interviews and len(raw_interviews) > 100:
+            evidence_rules = f"""Use ONLY the supplied qualitative material. Return 8-12 representative quotations VERBATIM; never repair, paraphrase, translate, combine, or invent a quotation. Use at least three themes from the frozen theme plan when supported. Preserve stage/case labels only when supported by the material.
+
+<QUALITATIVE_MATERIAL>
+{raw_interviews[:30000]}
+</QUALITATIVE_MATERIAL>"""
+        else:
+            evidence_rules = """Generate exactly 12 concise natural representative quotations distributed across at least three themes from the frozen theme plan. Quotations must sound like distinct participants, each should be one concise complete sentence, and at least one evidence item must be clearly labelled deviant. Do not change or contradict any frozen study fact."""
+        return f"""Topic: {topic}
+Keywords: {keywords}
+<USER_RESEARCH_INTENT>{intent_block}</USER_RESEARCH_INTENT>
+
+This is FALLBACK STAGE B. The study facts below are frozen authority and MUST NOT be changed.
+<FROZEN_STUDY_FACTS>{facts_block}</FROZEN_STUDY_FACTS>
+<FROZEN_THEME_PLAN>{themes_block}</FROZEN_THEME_PLAN>
+
+{evidence_rules}
+{retry_note}
+
+Return ONLY one valid JSON object with this schema:
+{{
+  "evidence": [
+    {{
+      "theme": "one frozen theme",
+      "concept": "concise empirical concept",
+      "quote": "representative quotation",
+      "stage": "temporal/process stage or Not specified",
+      "case_label": "generic case/actor label or Not specified",
+      "evidence_role": "typical or deviant"
+    }}
+  ]
+}}
+No Markdown and no explanatory prose.
+"""
+
+    def _generate_staged_qualitative_packet(
+        self,
+        topic,
+        keywords,
+        raw_interviews,
+        *,
+        has_user_data,
+        user_intent,
+        trigger_reason,
+    ):
+        """Bounded small-JSON fallback after a completed unsafe full packet."""
         system_prompt = (
             "You are a rigorous qualitative research analyst. "
             "Evidence fidelity has priority over narrative completeness."
         )
-        user_intent = build_user_research_intent(topic, keywords, mode="qualitative")
-        base_prompt = self._build_request(topic, keywords, raw_interviews)
-        last_reason = "packet_not_json_object"
-
-        for local_attempt in range(2):
-            # API/auth/balance/cancellation/transport failures remain owned by
-            # the model client and are deliberately not converted into local
-            # content retries here. Only a completed but locally invalid packet
-            # reaches the second attempt.
-            if local_attempt == 0:
-                response = self.agent.call_deepseek(
-                    system_prompt + "\n\nDIRECT OUTPUT MODE: Produce the complete evidence packet directly without extended hidden reasoning.",
-                    base_prompt,
-                    max_tokens=8000, temp=0.0, model_role="reasoning",
-                    thinking=False, allow_fallback=False, response_format={"type": "json_object"},
-                    logical_node='structured_json',
-                )
-            else:
-                retry_prompt = base_prompt + (
-                    "\n\nLOCAL VALIDATION RETRY: The previous completed response failed local "
-                    f"JSON/schema/content validation with reason={last_reason}. Generate a fresh complete "
-                    "qualitative evidence packet from the ORIGINAL inputs above. Do not repair, continue, "
-                    "quote, or rely on the previous response. Return exactly one complete JSON object matching "
-                    "the required schema, with no Markdown or explanatory prose. The evidence array must contain "
-                    "the required complete evidence objects, each with non-empty theme, concept, quote, stage, "
-                    "case_label, and evidence_role fields. Preserve every evidence-fidelity rule from the original "
-                    "request, including verbatim quotation requirements when user material was supplied."
-                )
-                response = self.agent.call_deepseek(
-                    system_prompt,
-                    retry_prompt,
-                    max_tokens=8000,
-                    temp=0.0,
-                    model_role="reasoning",
-                    thinking=False,
-                    allow_fallback=False,
-                    response_format={"type": "json_object"},
-                    logical_node='structured_json',
+        facts_data = None
+        facts = None
+        theme_plan = None
+        facts_reason = "packet_not_json_object"
+        facts_prompt = self._build_study_facts_stage_request(
+            topic, keywords, raw_interviews, user_intent
+        )
+        for attempt in range(2):
+            prompt = facts_prompt
+            if attempt:
+                prompt += (
+                    "\n\nLOCAL STAGE-A RETRY: The previous completed response failed deterministic "
+                    f"validation with reason={facts_reason}. Generate a fresh complete Stage A JSON object "
+                    "from the ORIGINAL inputs. Do not repair or continue the previous response."
                 )
-
-            response = re.sub(
-                r"<think>.*?</think>",
-                "",
-                str(response or ""),
-                flags=re.DOTALL,
-            ).strip()
-            data = self.agent._extract_json_from_text(response)
-            last_reason = self._qualitative_packet_validation_error(
-                data,
+            facts_data = self._call_qualitative_json(
+                system_prompt,
+                prompt,
+                max_tokens=2600,
+            )
+            if not isinstance(facts_data, dict):
+                facts_reason = "packet_not_json_object"
+                continue
+            facts = facts_data.get("study_facts")
+            theme_plan = facts_data.get("theme_plan")
+            facts_reason = self._study_facts_validation_error(
+                facts,
                 has_user_data=has_user_data,
                 user_intent=user_intent,
+            ) or self._theme_plan_validation_error(theme_plan)
+            if not facts_reason:
+                break
+            logging.warning(
+                "Qualitative staged fallback facts retry | attempt=%s/2 | trigger=%s | reason=%s",
+                attempt + 1,
+                trigger_reason,
+                facts_reason,
+            )
+        if facts_reason:
+            raise RuntimeError(
+                "Qualitative evidence facts fallback failed deterministic validation: "
+                f"{facts_reason}."
             )
-            if not last_reason:
-                return data
-            if local_attempt == 0:
-                logging.warning(
-                    "Qualitative evidence structured-output local retry | attempt=1/2 | reason=%s",
-                    last_reason,
-                )
 
-        if last_reason == "packet_not_json_object":
-            raise RuntimeError("Qualitative evidence packet could not be parsed safely.")
-        if last_reason == "invalid_packet_schema":
-            raise RuntimeError("Qualitative evidence packet has an invalid schema.")
+        evidence_reason = "packet_not_json_object"
+        for attempt in range(2):
+            evidence_prompt = self._build_evidence_stage_request(
+                topic,
+                keywords,
+                raw_interviews,
+                user_intent,
+                facts=facts,
+                theme_plan=theme_plan,
+                prior_reason=evidence_reason if attempt else "",
+            )
+            evidence_data = self._call_qualitative_json(
+                system_prompt,
+                evidence_prompt,
+                max_tokens=4600,
+            )
+            evidence = evidence_data.get("evidence") if isinstance(evidence_data, dict) else None
+            merged = {"study_facts": facts, "evidence": evidence}
+            evidence_reason = self._qualitative_packet_validation_error(
+                merged,
+                has_user_data=has_user_data,
+                user_intent=user_intent,
+            )
+            if not evidence_reason:
+                return merged
+            logging.warning(
+                "Qualitative staged fallback evidence retry | attempt=%s/2 | trigger=%s | reason=%s",
+                attempt + 1,
+                trigger_reason,
+                evidence_reason,
+            )
         raise RuntimeError(
-            "Qualitative evidence packet failed local validation after one bounded regeneration: "
-            f"{last_reason}."
+            "Qualitative evidence fallback failed deterministic validation after bounded regeneration: "
+            f"{evidence_reason}."
+        )
+
+    def _generate_qualitative_packet(self, topic, keywords, raw_interviews, *, has_user_data):
+        """Generate one compact packet, then fall back to bounded smaller JSON stages."""
+        system_prompt = (
+            "You are a rigorous qualitative research analyst. "
+            "Evidence fidelity has priority over narrative completeness."
+        )
+        user_intent = build_user_research_intent(topic, keywords, mode="qualitative")
+        base_prompt = self._build_request(topic, keywords, raw_interviews)
+        data = self._call_qualitative_json(
+            system_prompt + "\n\nDIRECT OUTPUT MODE: Produce the complete compact evidence packet directly without extended hidden reasoning.",
+            base_prompt,
+            max_tokens=8000,
+        )
+        reason = self._qualitative_packet_validation_error(
+            data,
+            has_user_data=has_user_data,
+            user_intent=user_intent,
+        )
+        if not reason:
+            return data
+
+        logging.warning(
+            "Qualitative evidence full packet unsafe; entering staged fallback | reason=%s",
+            reason,
+        )
+        return self._generate_staged_qualitative_packet(
+            topic,
+            keywords,
+            raw_interviews,
+            has_user_data=has_user_data,
+            user_intent=user_intent,
+            trigger_reason=reason,
         )
 
     def resolve_qualitative_data(self, topic, keywords, raw_interviews=""):