R14-TQ2-PQ1-P0-R1 Study Integrity Terminal UI Mode Decoupling

app.py

@@ -264,7 +264,7 @@ for key, default in {
     "is_running": False,
     "zip_buffer": None,
     "zip_filename": "",
-    "run_mode": "amj",
+    "run_mode": "asq",
     "sp_generation_task": None,
     "sp_pending_launch": None,
     "sp_pending_resume_task_id": "",
@@ -412,8 +412,8 @@ def _cleanup_task_artifacts(task_id: str) -> None:
 
 
 def _task_mode(task: dict) -> str:
-    mode = str((task or {}).get("mode") or st.session_state.get("run_mode") or "amj").strip().lower()
-    return "asq" if mode == "asq" else "amj"
+    mode = str((task or {}).get("mode") or st.session_state.get("run_mode") or "asq").strip().lower()
+    return "amj" if mode == "amj" else "asq"
 
 
 def _task_output_path(task: dict) -> Path | None:
@@ -740,6 +740,19 @@ def _localized_monitor_node(lang_code: str, node: str) -> str:
         return tr(lang_code, "draft_stage_writing")
     return tr(lang_code, "draft_stage_processing")
 
+def _markdown_safe_html(markup: str) -> str:
+    """Prevent Streamlit Markdown from reclassifying indented HTML as code.
+
+    Only indentation before actual HTML tags is removed. Text rendered inside
+    preview containers keeps its own leading whitespace.
+    """
+    lines = []
+    for line in textwrap.dedent(str(markup or "")).strip().splitlines():
+        stripped = line.lstrip()
+        lines.append(stripped if stripped.startswith("<") else line)
+    return "\n".join(lines)
+
+
 def _render_monitor_box(task: dict, lang_code: str) -> None:
     """Render the approved monitor location with DOM targets for live updates."""
     status = str(task.get("status") or "")
@@ -764,7 +777,7 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
         </div>
         """).strip()
 
-    st.markdown(textwrap.dedent(f"""
+    st.markdown(_markdown_safe_html(f"""
     <div class='log-box' id='sp-live-monitor'>
         {progress_markup}
         <div><b>{tr(lang_code, 'monitor_pipeline')}:</b> <span id='sp-live-status'>{html.escape(status_label)}</span></div>
@@ -781,7 +794,7 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
             <span style='background: #d1fae5;padding:4px 8px;border-radius:4px;color:black;'>🌐 OpenAlex: <b id='sp-live-oa'>{oa_calls}</b></span>
         </div>
     </div>
-    """).strip(), unsafe_allow_html=True)
+    """), unsafe_allow_html=True)
 
 
 def _watch_task_status_live(task: dict) -> dict | None:
@@ -996,50 +1009,74 @@ def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
     with left:
         st.markdown(tr(lang_code, "english_draft"))
         st.markdown(
-            textwrap.dedent(f"""
+            _markdown_safe_html(f"""
             <div id='sp-live-manuscript-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:220px;max-height:68vh;overflow:auto;background:#ffffff;color:#111827;'>
               <div id='sp-live-manuscript-status' style='white-space:pre-wrap;font-size:0.88em;color:#374151;opacity:1;margin:0 0 8px 0;display:{english_status_display};'>{html.escape(english_status_initial)}</div>
               <div id='sp-live-manuscript-preview' data-sp-placeholder='{english_placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{html.escape(english_initial)}</div>
               <span id='sp-live-manuscript-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span>
             </div>
-            """).strip(),
+            """),
             unsafe_allow_html=True,
         )
     with right:
         st.markdown(tr(lang_code, "target_draft", flag=get_target_flag(lang_code)))
         st.markdown(
-            textwrap.dedent(f"""
+            _markdown_safe_html(f"""
             <div id='sp-live-translation-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:220px;max-height:68vh;overflow:auto;background:#ffffff;color:#111827;'>
               <div id='sp-live-translation-preview' data-sp-placeholder='{target_placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{html.escape(target_initial)}</div>
               <span id='sp-live-translation-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span>
             </div>
-            """).strip(),
+            """),
             unsafe_allow_html=True,
         )
     st.markdown("<style>@keyframes spBlink { 0%,49% {opacity:1} 50%,100% {opacity:0} }</style>", unsafe_allow_html=True)
 
 
 def _scroll_to_completed_download_once(task_id: str) -> None:
-    """Move the page to the existing download area once per completed task."""
+    """Scroll only after the task-scoped download anchor actually exists.
+
+    Success identity is browser-session scoped and is written only after
+    scrollIntoView executes. A missed early attempt therefore remains retryable
+    on later Streamlit reruns.
+    """
     task_id = str(task_id or "").strip()
-    if not task_id or st.session_state.get("sp_completed_download_scroll_task_id") == task_id:
+    if not task_id:
         return
-    st.session_state["sp_completed_download_scroll_task_id"] = task_id
     components.html(
         f"""
         <script>
         (() => {{
-          const parentDocument = window.parent.document;
+          const parentWindow = window.parent;
+          const parentDocument = parentWindow.document;
           const expectedTaskId = {json.dumps(task_id)};
+          const storageKey = `sp-completed-download-scrolled:${{expectedTaskId}}`;
+          const root = parentDocument.documentElement;
+          if (root && root.dataset.spCompletedDownloadScrolled === expectedTaskId) return;
+          try {{
+            if (parentWindow.sessionStorage.getItem(storageKey) === '1') return;
+          }} catch (_) {{}}
           let done = false;
+          let observer = null;
           const locate = () => {{
-            if (done) return;
+            if (done) return true;
             const target = parentDocument.getElementById('sp-completed-download-anchor');
-            if (!target || target.dataset.spTaskId !== expectedTaskId) return;
+            if (!target || target.dataset.spTaskId !== expectedTaskId) return false;
             done = true;
             target.scrollIntoView({{behavior:'smooth', block:'center'}});
+            if (root) root.dataset.spCompletedDownloadScrolled = expectedTaskId;
+            try {{ parentWindow.sessionStorage.setItem(storageKey, '1'); }} catch (_) {{}}
+            if (observer) observer.disconnect();
+            return true;
           }};
-          [0, 60, 140, 300, 650, 1000].forEach(delay => window.setTimeout(locate, delay));
+          if (locate()) return;
+          if (parentDocument.body && parentWindow.MutationObserver) {{
+            observer = new parentWindow.MutationObserver(locate);
+            observer.observe(parentDocument.body, {{childList:true, subtree:true}});
+          }}
+          [80, 180, 360, 700, 1200, 2000, 3200, 4800].forEach((delay) =>
+            parentWindow.setTimeout(locate, delay)
+          );
+          parentWindow.setTimeout(() => {{ if (observer) observer.disconnect(); }}, 5200);
         }})();
         </script>
         """,
@@ -1153,7 +1190,7 @@ def _scroll_to_generation_action_once() -> None:
     if not bool(st.session_state.get("sp_scroll_to_generation_action")):
         return
     st.session_state["sp_scroll_to_generation_action"] = False
-    mode = str(st.session_state.get("run_mode") or "amj")
+    mode = str(st.session_state.get("run_mode") or "asq")
     fallback_id = "sp-generation-action-asq" if mode.lower() == "asq" else "sp-generation-action-amj"
     components.html(
         f"""
@@ -1188,10 +1225,10 @@ def _select_active_task_tab(task: dict, lang_code: str) -> None:
     """Keep the existing visual tab aligned with the immutable task mode after rerun/refresh."""
     status = str((task or {}).get("status") or "")
     mode = str((task or {}).get("mode") or "").strip().lower()
-    if status not in ACTIVE_TASK_STATUSES and status != "resumable":
-        return
     if mode not in {"amj", "asq"}:
         return
+    if status not in (ACTIVE_TASK_STATUSES | {"resumable", "completed", "failed", "cancelled"}):
+        return
     label = tr(lang_code, "tab_asq" if mode == "asq" else "tab_amj")
     components.html(
         f"""
@@ -1272,29 +1309,7 @@ def render_workspace_controls(user):
         key="sp_words",
     )
 
-    tab_amj, tab_asq = st.tabs([tr(lang_code, "tab_amj"), tr(lang_code, "tab_asq")])
-    with tab_amj:
-        st.markdown(tr(lang_code, "amj_config"))
-        st.info(tr(lang_code, "amj_info"))
-        st.file_uploader(tr(lang_code, "upload_reference"), type=["pdf", "doc", "docx"], accept_multiple_files=True, key="up_amj_ref", disabled=active)
-        st.file_uploader(tr(lang_code, "upload_stats"), type=["csv", "xlsx", "xls"], key="up_amj_data", disabled=active)
-        with st.expander(tr(lang_code, "amj_expander")):
-            st.markdown(tr(lang_code, "amj_hint"))
-            template = get_amj_csv_template(lang_code)
-            st.code(template, language="csv")
-            st.download_button(label=tr(lang_code, "download_amj_template"), data=template, file_name="AMJ_Data_Template.csv", mime="text/csv", use_container_width=True)
-        st.markdown("<div id='sp-generation-action-amj'></div>", unsafe_allow_html=True)
-        if active and _task_mode(task) == "amj":
-            if st.button(tr(lang_code, "cancel_generation"), key="cancel_amj"):
-                st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "")
-                st.rerun()
-        elif st.button(tr(lang_code, "start_amj"), disabled=active, key="btn_amj"):
-            st.session_state["run_mode"] = "amj"
-            st.session_state["sp_pending_launch"] = {"mode": "amj", "idempotency_key": _new_generation_idempotency_key()}
-            st.session_state["sp_scroll_to_generation_action"] = True
-            st.info(tr(lang_code, "pipeline_start"))
-            _inject_generation_action_scroll("amj")
-
+    tab_asq, tab_amj = st.tabs([tr(lang_code, "tab_asq"), tr(lang_code, "tab_amj")])
     with tab_asq:
         st.markdown(tr(lang_code, "asq_config"))
         st.info(tr(lang_code, "asq_info"))
@@ -1317,6 +1332,27 @@ def render_workspace_controls(user):
             st.info(tr(lang_code, "pipeline_start"))
             _inject_generation_action_scroll("asq")
 
+    with tab_amj:
+        st.markdown(tr(lang_code, "amj_config"))
+        st.info(tr(lang_code, "amj_info"))
+        st.file_uploader(tr(lang_code, "upload_reference"), type=["pdf", "doc", "docx"], accept_multiple_files=True, key="up_amj_ref", disabled=active)
+        st.file_uploader(tr(lang_code, "upload_stats"), type=["csv", "xlsx", "xls"], key="up_amj_data", disabled=active)
+        with st.expander(tr(lang_code, "amj_expander")):
+            st.markdown(tr(lang_code, "amj_hint"))
+            template = get_amj_csv_template(lang_code)
+            st.code(template, language="csv")
+            st.download_button(label=tr(lang_code, "download_amj_template"), data=template, file_name="AMJ_Data_Template.csv", mime="text/csv", use_container_width=True)
+        st.markdown("<div id='sp-generation-action-amj'></div>", unsafe_allow_html=True)
+        if active and _task_mode(task) == "amj":
+            if st.button(tr(lang_code, "cancel_generation"), key="cancel_amj"):
+                st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "")
+                st.rerun()
+        elif st.button(tr(lang_code, "start_amj"), disabled=active, key="btn_amj"):
+            st.session_state["run_mode"] = "amj"
+            st.session_state["sp_pending_launch"] = {"mode": "amj", "idempotency_key": _new_generation_idempotency_key()}
+            st.session_state["sp_scroll_to_generation_action"] = True
+            st.info(tr(lang_code, "pipeline_start"))
+            _inject_generation_action_scroll("amj")
     _select_active_task_tab(task, lang_code)
     inject_file_uploader_i18n(lang_code)
 

config.py

@@ -378,7 +378,7 @@ def load_config():
             "asq": {
                 "introduction": "Open with the organizational puzzle, establish why existing explanations are insufficient, state the research question, and preview the emergent theoretical payoff without pre-solving the puzzle.",
                 "theoretical_framing": "Use prior theory as sensitizing concepts and a source of tension. Define what remains unexplained without forcing hypotheses or predicting the findings.",
-                "methods": "Describe the frozen setting, data, analytic design, trustworthiness, ethics, and reflexivity. The analytic method must match the selected qualitative design rather than default to Gioia.",
+                "methods": "Describe the frozen setting, data, and analytic design. Describe trustworthiness, ethics, or reflexivity procedures only when those procedures are explicitly present in the frozen Study Evidence Ledger; never infer or invent member checking, peer debriefing, audit trails, field journals, consent/approval procedures, positionality, or other study-owned procedures. The analytic method must match the selected qualitative design rather than default to Gioia.",
                 "findings": "Move from concrete episode, quotation, or observation to recurring pattern, temporal/process relationship, and emergent mechanism. Keep informant or field evidence central and include deviant evidence when available.",
                 "discussion": "Explain how the emergent mechanism changes, qualifies, or extends prior theory. Distinguish what is grounded in this setting from what may transfer beyond it.",
                 "conclusion": "Resolve the organizational puzzle and state the bounded theoretical contribution without introducing new data, quotations, or claims.",
@@ -480,7 +480,7 @@ Literature Metadata:
         "deep_refinement_directive": "Ensure logical flow and focus on the emergent theoretical model. Write in continuous, engaging paragraphs. Apply claim-specific citation: use at most one [CITE-XX] tag per sentence, never combine sources in one parenthesis, and cite only the single most direct source when several sources support the same claim.",
         "deep_synthesis_directive": "Structure this synthesis to highlight a critical empirical puzzle or theoretical paradox that qualitative investigation can unravel.",
         "hypothesis_development_directive": "Develop the theoretical framing. DO NOT use formal hypotheses. Detail the conceptual gaps and frame the overarching research questions or theoretical propositions.",
-        "methodological_defense_directive": "Describe only the frozen research setting and data sources. Explain the analytic design actually selected for this study (for example process analysis, comparative case logic, grounded-theory/Gioia-style coding when appropriate) and its trustworthiness procedures without forcing one method onto every qualitative study.",
+        "methodological_defense_directive": "Describe only the frozen research setting, actor/data-source relations, data, analytic design, and explicitly frozen study procedures. Explain the analytic design actually selected for this study (for example process analysis, comparative case logic, grounded-theory/Gioia-style coding when appropriate). Discuss trustworthiness, ethics, or reflexivity as procedures actually performed only when the frozen Study Evidence Ledger explicitly records them; otherwise do not manufacture such procedures or convert general methodological best practice into a study-owned fact.",
         "discussion_depth_directive": "Connect the emergent mechanism or process to prior theory. Show precisely what the evidence changes, qualifies, or newly explains, including negative or deviant evidence when present. Do not force a process-model contrast when the selected qualitative design does not support it.",
         "conclusion_anchor_directive": "Derive the conclusion only after validated Findings and Discussion. Resolve the organizational puzzle and state the bounded theoretical change without introducing new evidence or forcing sensemaking language.",
         "anchor_generation_directive": "Generate a PROVISIONAL RESEARCH LOGIC CONTRACT, not an expected finding or conclusion. Identify the organizational puzzle, sensitizing theoretical tension, evidence boundaries, and research question while leaving the empirical resolution open. Output only the contract.",

core/generation_runner.py

@@ -2667,10 +2667,55 @@ Output only final academic prose. Do not report the word count."""
                     data_metadata=data_metadata,
                     quote_invocation_plan=quote_invocation_plan,
                 )
+            if mode == "asq":
+                en_resolved, study_fact_rows = agent.repair_qualitative_study_fact_contract(
+                    en_resolved, data_metadata, section_name=display_name
+                )
+                if study_fact_rows:
+                    logging.warning(
+                        "Qualitative Study Evidence Ledger repair | unit=%s count=%s types=%s",
+                        display_name, len(study_fact_rows),
+                        sorted({str(row.get("type") or "") for row in study_fact_rows}),
+                    )
+                    quality_diagnostics.append({
+                        "scope":"qualitative_study_fact_integrity", "name":display_name,
+                        "status":"deterministic_repair", "count":len(study_fact_rows),
+                        "examples":study_fact_rows[:3],
+                    })
+                agent.validate_qualitative_study_fact_contract(
+                    en_resolved, data_metadata, section_name=display_name
+                )
+            en_resolved, enumeration_rows = agent.repair_and_validate_enumeration_contract(
+                en_resolved, section_name=display_name
+            )
+            if enumeration_rows:
+                logging.warning(
+                    "Structural enumeration repaired | unit=%s count=%s details=%s",
+                    display_name, len(enumeration_rows), enumeration_rows[:3],
+                )
+                quality_diagnostics.append({
+                    "scope":"structural_enumeration", "name":display_name,
+                    "status":"deterministic_repair", "count":len(enumeration_rows),
+                    "examples":enumeration_rows[:3],
+                })
             en_resolved, duplicate_rows = self._remove_severe_cross_unit_duplicates(en_resolved, full_draft_en)
             if duplicate_rows:
                 logging.warning("Severe cross-unit redundancy removed | unit=%s count=%s max_similarity=%s", display_name, len(duplicate_rows), max(row["similarity"] for row in duplicate_rows))
                 quality_diagnostics.append({"scope":"manuscript_redundancy","name":display_name,"status":"bounded_duplicate_removed","count":len(duplicate_rows),"examples":duplicate_rows[:3]})
+            en_resolved, sentence_echo_rows = agent.remove_severe_cross_unit_sentence_echoes(
+                en_resolved, full_draft_en
+            )
+            if sentence_echo_rows:
+                logging.warning(
+                    "Severe cross-unit sentence echo removed | unit=%s count=%s max_similarity=%s",
+                    display_name, len(sentence_echo_rows),
+                    max(row["similarity"] for row in sentence_echo_rows),
+                )
+                quality_diagnostics.append({
+                    "scope":"manuscript_sentence_echo", "name":display_name,
+                    "status":"bounded_duplicate_removed", "count":len(sentence_echo_rows),
+                    "examples":sentence_echo_rows[:3],
+                })
             full_draft_en += en_resolved + "\n\n"
             if assigned_tag_list:
                 logging.info(
@@ -2732,6 +2777,19 @@ Output only final academic prose. Do not report the word count."""
         if not state.get("english_finalized"):
             self._progress(91, "english_validation")
             full_draft_en = _clean_trailing_references(full_draft_en, ["Reference", "References", "Reference List"])
+            if mode == "asq":
+                fact_checked, fact_rows = agent.repair_qualitative_study_fact_contract(
+                    full_draft_en, data_metadata, section_name="Final English manuscript"
+                )
+                if fact_checked.strip() != full_draft_en.strip() or fact_rows:
+                    raise RuntimeError(
+                        "final_qualitative_study_fact_contract_requires_section_regeneration"
+                    )
+            enum_checked, enum_rows = agent.repair_and_validate_enumeration_contract(
+                full_draft_en, section_name="Final English manuscript"
+            )
+            if enum_checked.strip() != full_draft_en.strip() or enum_rows:
+                raise RuntimeError("final_enumeration_contract_requires_section_regeneration")
             # Validate the completed body while the Working Abstract is still in
             # place. Final front matter must not be generated until all body
             # sections, citation cleanup, and any Discussion rebalance are frozen.

core/pipeline_agent.py

@@ -3397,6 +3397,283 @@ INPUT:
         )
         return repaired
 
+    @staticmethod
+    def _qual_source_family(value):
+        text = re.sub(r"\s+", " ", str(value or "")).strip().casefold()
+        if re.search(r"\b(interview|interviews|interviewed|semi[- ]structured interview)\b", text):
+            return "interview"
+        if re.search(r"\bfocus\s+groups?\b", text):
+            return "focus_group"
+        if re.search(r"\b(observation|observations|observed|field observation)\b", text):
+            return "observation"
+        if re.search(r"\b(usage|interaction|system)\s+logs?\b|\blog\s+data\b", text):
+            return "log"
+        if re.search(r"\b(document|documents|records?|archive|archival)\b", text):
+            return "document"
+        return ""
+
+    @classmethod
+    def _qual_actor_variants(cls, role):
+        text = re.sub(r"\s+", " ", str(role or "")).strip().casefold()
+        if not text:
+            return []
+        variants = {text}
+        words = re.findall(r"[a-z][a-z-]{2,}", text)
+        generic = {"participants", "participant", "respondents", "respondent", "actors", "actor", "users", "user"}
+        informative = [w for w in words if w not in generic]
+        if informative:
+            variants.add(" ".join(informative))
+            variants.add(informative[-1])
+            if informative[-1].endswith("s") and len(informative[-1]) > 4:
+                variants.add(informative[-1][:-1])
+        return sorted((v for v in variants if len(v) >= 4), key=len, reverse=True)
+
+    @classmethod
+    def _nearest_qual_source_family(cls, sentence, actor_start):
+        text = str(sentence or "")
+        markers = []
+        patterns = {
+            "interview": r"\b(?:semi[- ]structured\s+)?interviews?\b|\binterviewed\b|\binterview\s+participants?\b",
+            "focus_group": r"\bfocus\s+groups?\b",
+            "observation": r"\b(?:field\s+)?observations?\b|\bobserved\b",
+            "log": r"\b(?:usage|interaction|system)\s+logs?\b|\blog\s+data\b",
+            "document": r"\bdocuments?\b|\barchival\s+(?:records?|materials?)\b|\brecords?\b",
+        }
+        for family, pattern in patterns.items():
+            for match in re.finditer(pattern, text, flags=re.I):
+                markers.append((abs(match.start() - int(actor_start)), family))
+        if not markers:
+            return ""
+        markers.sort(key=lambda row: row[0])
+        return markers[0][1]
+
+    @classmethod
+    def repair_qualitative_study_fact_contract(cls, text, metadata, section_name=""):
+        """Remove/repair only high-confidence study-owned fact violations.
+
+        The frozen Study Evidence Ledger owns actor/data-source relations and
+        whether trustworthiness/ethics/reflexivity procedures were actually
+        performed. External methodological best practice never authorizes a
+        study-owned procedure claim.
+        """
+        value = str(text or "")
+        facts = dict((metadata or {}).get("study_facts") or {})
+        relations = [row for row in (facts.get("data_source_roles") or []) if isinstance(row, dict)]
+        procedure_lists = {
+            "trustworthiness": [str(x or "").strip() for x in (facts.get("trustworthiness_procedures") or []) if str(x or "").strip()],
+            "ethics": [str(x or "").strip() for x in (facts.get("ethics_procedures") or []) if str(x or "").strip()],
+            "reflexivity": [str(x or "").strip() for x in (facts.get("reflexivity_procedures") or []) if str(x or "").strip()],
+        }
+        allowed_by_actor = {}
+        canonical_relations = []
+        for row in relations:
+            role = re.sub(r"\s+", " ", str(row.get("actor_role") or "")).strip()
+            source = re.sub(r"\s+", " ", str(row.get("data_source") or "")).strip()
+            family = cls._qual_source_family(source)
+            if not role or not source or not family:
+                continue
+            canonical_relations.append((role, source, row.get("count")))
+            for variant in cls._qual_actor_variants(role):
+                allowed_by_actor.setdefault(variant, set()).add(family)
+
+        study_owned = re.compile(
+            r"\b(?:we|our\s+study|this\s+study|the\s+study|research\s+team|participants?|respondents?)\b|"
+            r"\b(?:was|were)\s+(?:conducted|performed|used|maintained|obtained|recorded|anonymized|anonymised)\b",
+            flags=re.I,
+        )
+        procedure_patterns = {
+            "trustworthiness": r"\bmember\s+check(?:ing|s)?\b|\bpeer\s+debrief(?:ing|ed)?\b|\baudit\s+trail\b|\bexternal\s+audit\b",
+            "ethics": r"\binformed\s+consent\b|\bethics?\s+approval\b|\binstitutional\s+review\s+board\b|\bIRB\b|\bapproval\s+(?:number|code)\b",
+            "reflexivity": r"\bfield\s+journal\b|\breflexive\s+journal\b|\bpositionality\s+(?:statement|memo)\b|\breflexive\s+memo(?:s)?\b",
+        }
+        spans = cls._sentence_spans(value)
+        replacements = []
+        diagnostics = []
+        for start, end, sentence in spans:
+            core = str(sentence or "")
+            lower = core.casefold()
+            if not core.strip():
+                continue
+            removed = False
+            if study_owned.search(core):
+                for category, pattern in procedure_patterns.items():
+                    procedure_match = re.search(pattern, core, flags=re.I)
+                    if not procedure_match:
+                        continue
+                    observed = procedure_match.group(0).casefold()
+                    if "member check" in observed:
+                        key = "member check"
+                    elif "peer debrief" in observed:
+                        key = "peer debrief"
+                    elif "audit trail" in observed:
+                        key = "audit trail"
+                    elif "external audit" in observed:
+                        key = "external audit"
+                    elif "informed consent" in observed:
+                        key = "informed consent"
+                    elif "ethic" in observed and "approval" in observed:
+                        key = "ethics approval"
+                    elif "review board" in observed or observed == "irb":
+                        key = "review board"
+                    elif "approval" in observed:
+                        key = "approval"
+                    elif "field journal" in observed:
+                        key = "field journal"
+                    elif "reflexive journal" in observed:
+                        key = "reflexive journal"
+                    elif "positionality" in observed:
+                        key = "positionality"
+                    else:
+                        key = "reflexive memo"
+                    authorized = any(key in item.casefold() for item in procedure_lists[category])
+                    if not authorized:
+                        replacements.append((start, end, ""))
+                        diagnostics.append({"type":"unsupported_study_procedure", "category":category, "procedure":key, "preview":core.strip()[:180]})
+                        removed = True
+                        break
+            if removed or not canonical_relations:
+                continue
+            for actor_variant, allowed_families in allowed_by_actor.items():
+                for actor_match in re.finditer(rf"(?<![A-Za-z]){re.escape(actor_variant)}(?![A-Za-z])", lower, flags=re.I):
+                    nearest = cls._nearest_qual_source_family(core, actor_match.start())
+                    if nearest and nearest not in allowed_families:
+                        relation_text = " and ".join(
+                            f"{source} with {role}" + (f" (n={count})" if isinstance(count, int) else "")
+                            for role, source, count in canonical_relations
+                        )
+                        replacement = f"Data collection comprised {relation_text}."
+                        leading = core[: len(core) - len(core.lstrip())]
+                        trailing = core[len(core.rstrip()):]
+                        replacements.append((start, end, f"{leading}{replacement}{trailing}"))
+                        diagnostics.append({"type":"actor_data_source_relation_repaired", "actor":actor_variant, "observed":nearest, "allowed":sorted(allowed_families)})
+                        removed = True
+                        break
+                if removed:
+                    break
+        if replacements:
+            for start, end, replacement in sorted(replacements, reverse=True):
+                value = value[:start] + replacement + value[end:]
+            value = re.sub(r"[ \t]+\n", "\n", value)
+            value = re.sub(r"\n{3,}", "\n\n", value)
+            value = re.sub(r" {2,}", " ", value)
+        return value.strip(), diagnostics
+
+    @classmethod
+    def validate_qualitative_study_fact_contract(cls, text, metadata, section_name=""):
+        repaired, diagnostics = cls.repair_qualitative_study_fact_contract(text, metadata, section_name=section_name)
+        if repaired.strip() != str(text or "").strip():
+            raise RuntimeError(f"qualitative_study_fact_contract_unrepaired:{section_name}:{diagnostics[:3]}")
+        return True
+
+    @classmethod
+    def repair_and_validate_enumeration_contract(cls, text, section_name=""):
+        """Repair only high-confidence ordinal shifts tied to an explicit count."""
+        value = str(text or "")
+        number_map = {"two":2, "three":3, "four":4, "five":5, "six":6, "2":2, "3":3, "4":4, "5":5, "6":6}
+        ordinal_map = {"first":1, "second":2, "third":3, "fourth":4, "fifth":5, "sixth":6}
+        reverse = {1:"first",2:"second",3:"third",4:"fourth",5:"fifth",6:"sixth"}
+        decl = re.compile(
+            r"\b(two|three|four|five|six|[2-6])\s+(?:provisional\s+)?"
+            r"(domains?|mechanisms?|dimensions?|stages?|patterns?|components?|themes?|processes?|conditions?)\b",
+            flags=re.I,
+        )
+        offset = 0
+        diagnostics = []
+        for match in list(decl.finditer(value)):
+            count = number_map[match.group(1).lower()]
+            start = match.end() + offset
+            next_heading = re.search(r"\n#{1,3}\s+", value[start:])
+            scope_end = start + min(3500, next_heading.start() if next_heading else 3500)
+            scope = value[start:scope_end]
+            ordinals = list(re.finditer(r"\bThe\s+(first|second|third|fourth|fifth|sixth)\b", scope, flags=re.I))
+            if len(ordinals) < count:
+                continue
+            selected = ordinals[:count]
+            nums = [ordinal_map[m.group(1).lower()] for m in selected]
+            expected = list(range(1, count + 1))
+            if nums == expected:
+                continue
+            consecutive = nums == list(range(nums[0], nums[0] + count))
+            if not consecutive:
+                raise RuntimeError(f"enumeration_contract_mismatch:{section_name}:declared={count}:ordinals={nums}")
+            scope_chars = list(scope)
+            for index, omatch in reversed(list(enumerate(selected, start=1))):
+                old = omatch.group(1)
+                new = reverse[index]
+                if old[:1].isupper():
+                    new = new.capitalize()
+                a, b = omatch.start(1), omatch.end(1)
+                scope_chars[a:b] = list(new)
+            repaired_scope = "".join(scope_chars)
+            value = value[:start] + repaired_scope + value[scope_end:]
+            delta = len(repaired_scope) - len(scope)
+            offset += delta
+            diagnostics.append({"declared":count, "observed":nums, "repaired":expected})
+        # Validate the same high-confidence patterns after repair.
+        for match in decl.finditer(value):
+            count = number_map[match.group(1).lower()]
+            start = match.end()
+            next_heading = re.search(r"\n#{1,3}\s+", value[start:])
+            scope_end = start + min(3500, next_heading.start() if next_heading else 3500)
+            nums = [ordinal_map[m.group(1).lower()] for m in list(re.finditer(r"\bThe\s+(first|second|third|fourth|fifth|sixth)\b", value[start:scope_end], flags=re.I))[:count]]
+            if len(nums) >= count and nums != list(range(1, count + 1)):
+                raise RuntimeError(f"enumeration_contract_unresolved:{section_name}:declared={count}:ordinals={nums}")
+        return value, diagnostics
+
+    @classmethod
+    def remove_severe_cross_unit_sentence_echoes(cls, candidate, prior_text):
+        """Remove only near-verbatim long sentence echoes from earlier units.
+
+        Quotations, headings, and sentences with different citation/numeric
+        ownership are never removed. This is intentionally stricter than a
+        general semantic similarity rewriter.
+        """
+        previous = []
+        for _start, _end, sentence in cls._sentence_spans(prior_text):
+            core = re.sub(r"\s+", " ", str(sentence or "")).strip()
+            if len(core.split()) < 20 or core.startswith("#") or '"' in core or "QUOTE-" in core:
+                continue
+            tokens = set(re.findall(r"[A-Za-z][A-Za-z0-9_-]{2,}", re.sub(r"\[?CITE-\d+\]?", " ", core, flags=re.I).lower()))
+            if tokens:
+                reader_citations = set(re.findall(r"\([^()\n]{0,120}(?:19|20)\d{2}[a-z]?[^()\n]{0,40}\)", core))
+                raw_citations = set(re.findall(r"\[?CITE-\d+\]?", core, flags=re.I))
+                previous.append((core, tokens, raw_citations | reader_citations, set(re.findall(r"(?<![A-Za-z])[-+]?\d+(?:\.\d+)?%?(?![A-Za-z])", core))))
+        value = str(candidate or "")
+        replacements = []
+        diagnostics = []
+        for start, end, sentence in cls._sentence_spans(value):
+            core = re.sub(r"\s+", " ", str(sentence or "")).strip()
+            if len(core.split()) < 20 or core.startswith("#") or '"' in core or "QUOTE-" in core:
+                continue
+            tokens = set(re.findall(r"[A-Za-z][A-Za-z0-9_-]{2,}", re.sub(r"\[?CITE-\d+\]?", " ", core, flags=re.I).lower()))
+            if not tokens:
+                continue
+            citations = set(re.findall(r"\[?CITE-\d+\]?", core, flags=re.I))
+            citations |= set(re.findall(r"\([^()\n]{0,120}(?:19|20)\d{2}[a-z]?[^()\n]{0,40}\)", core))
+            numerics = set(re.findall(r"(?<![A-Za-z])[-+]?\d+(?:\.\d+)?%?(?![A-Za-z])", core))
+            duplicate = None
+            for old, old_tokens, old_citations, old_numerics in previous:
+                if citations != old_citations or numerics != old_numerics:
+                    continue
+                union = tokens | old_tokens
+                similarity = len(tokens & old_tokens) / max(1, len(union))
+                normalized_same = re.sub(r"\W+", " ", core).strip().casefold() == re.sub(r"\W+", " ", old).strip().casefold()
+                if normalized_same or similarity >= 0.96:
+                    duplicate = (1.0 if normalized_same else similarity, old[:180])
+                    break
+            if duplicate:
+                replacements.append((start, end, ""))
+                diagnostics.append({"similarity":round(duplicate[0],4), "removed_preview":core[:180]})
+            else:
+                previous.append((core, tokens, citations, numerics))
+        if replacements:
+            for start, end, replacement in sorted(replacements, reverse=True):
+                value = value[:start] + replacement + value[end:]
+            value = re.sub(r"[ \t]+\n", "\n", value)
+            value = re.sub(r"\n{3,}", "\n\n", value)
+            value = re.sub(r" {2,}", " ", value)
+        return value.strip(), diagnostics
+
     def semantic_audit_claim_specific_citations(
         self,
         text,

core/qualitative_engine.py

@@ -36,6 +36,37 @@ class QualitativeEngine:
         lookup = {item.lower(): item for item in cls.ALLOWED_ANALYTIC_DESIGNS}
         return lookup.get(cleaned.lower(), "Iterative thematic/process analysis")
 
+    @classmethod
+    def _normalize_string_list(cls, values):
+        if values is None:
+            return []
+        if not isinstance(values, list):
+            values = [values]
+        out = []
+        for value in values:
+            cleaned = cls._clean_cell(value, "")
+            if cleaned and cleaned.casefold() != "not specified" and cleaned not in out:
+                out.append(cleaned)
+        return out
+
+    @classmethod
+    def _normalize_data_source_roles(cls, values):
+        rows = []
+        for item in values or []:
+            if not isinstance(item, dict):
+                continue
+            actor_role = cls._clean_cell(item.get("actor_role"), "")
+            data_source = cls._clean_cell(item.get("data_source"), "")
+            count = item.get("count")
+            if not actor_role or not data_source:
+                continue
+            if count is not None and (not isinstance(count, int) or count <= 0):
+                continue
+            row = {"actor_role": actor_role, "data_source": data_source, "count": count}
+            if row not in rows:
+                rows.append(row)
+        return rows
+
     @classmethod
     def build_scoped_evidence_md(
         cls,
@@ -74,6 +105,10 @@ class QualitativeEngine:
         temporal_structure = cls._clean_cell(facts.get("temporal_structure"))
         case_structure = cls._clean_cell(facts.get("case_structure"))
         setting = cls._clean_cell(facts.get("research_setting"))
+        data_source_roles = cls._normalize_data_source_roles(facts.get("data_source_roles") or [])
+        trustworthiness = cls._normalize_string_list(facts.get("trustworthiness_procedures"))
+        ethics = cls._normalize_string_list(facts.get("ethics_procedures"))
+        reflexivity = cls._normalize_string_list(facts.get("reflexivity_procedures"))
 
         lines = [
             "### Frozen Qualitative Study Facts",
@@ -87,12 +122,29 @@ class QualitativeEngine:
             f"| Analytic logic | {analytic_logic} |",
             f"| Temporal structure | {temporal_structure} |",
             f"| Case structure | {case_structure} |",
+            f"| Trustworthiness procedures | {'; '.join(trustworthiness) if trustworthiness else 'Not specified'} |",
+            f"| Ethics procedures | {'; '.join(ethics) if ethics else 'Not specified'} |",
+            f"| Reflexivity procedures | {'; '.join(reflexivity) if reflexivity else 'Not specified'} |",
+        ]
+        if data_source_roles:
+            lines.extend([
+                "",
+                "### Frozen Actor / Data-Source Relations",
+                "| Actor role | Data source | Count |",
+                "| :--- | :--- | :--- |",
+            ])
+            lines.extend(
+                f"| {row['actor_role']} | {row['data_source']} | {row['count'] if row['count'] is not None else 'Not specified'} |"
+                for row in data_source_roles
+            )
+        lines.extend([
             "",
             "[QUALITATIVE EVIDENCE CHANNELS]",
             "1. STUDY FACTS and THEME SUMMARIES below are this study's internal empirical evidence. Never attach an external [CITE-XX] tag to a sentence merely because it reports or interprets these frozen facts.",
             "2. External literature may support only prior-theory, prior-evidence, or methodological-rationale claims. Keep those claims in distinct sentences from this study's setting, sample, data, events, quotations, and findings.",
             "3. ASSIGNED QUOTATIONS, when present, are analysis-only verbatim evidence owned by the current stable theme. Do not reproduce the verbatim wording or any internal quotation identifier in generated prose; the Executor renders frozen quotations deterministically after narrative QA.",
-        ]
+            "4. Study-owned trustworthiness, ethics, reflexivity, recruitment, consent, observation, or audit procedures may be stated as performed only when explicitly frozen above. Never convert general methodological best practice into a fact about this study.",
+        ])
 
         allowed_theme_titles = None
         if theme_titles:
@@ -216,8 +268,12 @@ class QualitativeEngine:
   "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": ["explicitly supported/frozen procedure"],
+    "ethics_procedures": ["explicitly supported/frozen procedure"],
+    "reflexivity_procedures": ["explicitly supported/frozen procedure"],
     "analytic_design": "one allowed design",
     "analytic_logic": "one concise sentence",
     "temporal_structure": "string or Not specified",
@@ -242,12 +298,12 @@ Keywords: {keywords}
 Analyze the supplied interview or field material for an ASQ-oriented qualitative manuscript.
 
 Rules:
-1. Treat the supplied material as the only source of study facts. Use null or "Not specified" for any setting, sample, count, date, case, or data source not supported by the material.
+1. Treat the supplied material as the only source of study facts. Use null, empty arrays, or "Not specified" for any setting, sample, count, date, case, actor/data-source relation, trustworthiness procedure, ethics procedure, reflexivity procedure, or data source not explicitly supported by the material.
 2. Extract 8-15 representative quotations VERBATIM. Never repair, paraphrase, translate, combine, or invent a quotation.
 3. Choose the analytic design that best fits the actual material. Do NOT default to Gioia. Use Gioia-style coding only if the evidence structure genuinely warrants it.
 4. Organize evidence around a central organizational puzzle and, when the material supports it, preserve temporal stages, actor/case contrasts, process transitions, and at least one deviant or boundary observation.
 5. Do not manufacture a longitudinal sequence when the material is cross-sectional, and do not manufacture multiple cases when only one is present.
-6. The study_facts object and quotations will become the frozen single source of truth for the entire manuscript.
+6. Freeze actor-to-data-source relations explicitly in data_source_roles whenever the material supports them (for example extension officers -> interviews; farmers -> focus groups). Never infer that an actor participated in a data source not supported by the material. The study_facts object and quotations will become the frozen single source of truth for the entire manuscript.
 
 {schema}
 <QUALITATIVE_MATERIAL>
@@ -261,13 +317,14 @@ Construct one internally coherent qualitative evidence packet for a complete ASQ
 
 Rules:
 1. Choose one generic organizational research setting directly relevant to the topic and keep it fixed. Do not name a real organization, institution, or identifiable person.
-2. Freeze one participant count, interview count, data-source set, analytic design, temporal/case structure, and analytic logic. Keep them internally consistent.
+2. Freeze one participant count, interview count, data-source set, actor-to-data-source relation map, analytic design, temporal/case structure, and analytic logic. Keep them internally consistent. Every actor/data-source relationship later stated in the paper must be represented in data_source_roles.
 3. Produce exactly 12 natural representative quotations distributed across at least three higher-order themes. Quotations must sound like distinct participants rather than repeated template variants.
 4. Choose the analytic design that best fits the constructed evidence; do NOT default to Gioia. Use process, comparative-case, grounded-theory, longitudinal, or Gioia-style logic only when the packet supports it.
 5. Include at least one clearly labelled deviant/boundary observation so the eventual theory is not built only from confirming examples.
 6. The evidence should support a process/mechanism explanation, not merely descriptive topic categories.
-7. The study_facts object and evidence packet will become the frozen single source of truth for the entire manuscript.
-8. Avoid decorative language, generic AI phrasing, and repetitive quotation patterns.
+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.
 
 {schema}
 """
@@ -292,6 +349,38 @@ Rules:
             value = facts.get(key)
             if value is not None and (not isinstance(value, int) or value <= 0):
                 return f"invalid_{key}"
+        raw_relations = facts.get("data_source_roles") or []
+        if raw_relations and not isinstance(raw_relations, list):
+            return "invalid_data_source_roles"
+        declared_sources = [
+            re.sub(r"\s+", " ", str(item or "")).strip().casefold()
+            for item in (facts.get("data_sources") or [])
+            if str(item or "").strip()
+        ]
+        for item in raw_relations:
+            if not isinstance(item, dict) or not str(item.get("actor_role") or "").strip() or not str(item.get("data_source") or "").strip():
+                return "invalid_data_source_role_item"
+            count = item.get("count")
+            if count is not None and (not isinstance(count, int) or count <= 0):
+                return "invalid_data_source_role_count"
+            relation_source = re.sub(r"\s+", " ", str(item.get("data_source") or "")).strip().casefold()
+            if declared_sources and not any(
+                relation_source == source or relation_source in source or source in relation_source
+                for source in declared_sources
+            ):
+                return "data_source_role_not_in_declared_sources"
+        for key in ("trustworthiness_procedures", "ethics_procedures", "reflexivity_procedures"):
+            value = facts.get(key) or []
+            if not isinstance(value, list):
+                return f"invalid_{key}"
+            if any(not str(item or "").strip() for item in value):
+                return f"invalid_{key}"
+        if not has_user_data:
+            if not raw_relations:
+                return "generated_packet_missing_data_source_roles"
+            for key in ("trustworthiness_procedures", "ethics_procedures", "reflexivity_procedures"):
+                if not (facts.get(key) or []):
+                    return f"generated_packet_missing_{key}"
 
         seen_quotes = set()
         theme_keys = set()
@@ -408,6 +497,10 @@ Rules:
         setting = self._clean_cell(facts.get("research_setting"))
         clean_sources = [self._clean_cell(item) for item in data_sources]
         sources = ", ".join(clean_sources)
+        data_source_roles = self._normalize_data_source_roles(facts.get("data_source_roles") or [])
+        trustworthiness = self._normalize_string_list(facts.get("trustworthiness_procedures"))
+        ethics = self._normalize_string_list(facts.get("ethics_procedures"))
+        reflexivity = self._normalize_string_list(facts.get("reflexivity_procedures"))
         participants = facts.get("participant_count")
         interviews = facts.get("interview_count")
         analytic_design = self._normalize_analytic_design(
@@ -435,16 +528,29 @@ Rules:
             f"| Analytic design | {analytic_design} |\n"
             f"| Analytic logic | {analytic_logic} |\n"
             f"| Temporal structure | {temporal_structure} |\n"
-            f"| Case structure | {case_structure} |\n\n"
+            f"| Case structure | {case_structure} |\n"
+            f"| Trustworthiness procedures | {'; '.join(trustworthiness) if trustworthiness else 'Not specified'} |\n"
+            f"| Ethics procedures | {'; '.join(ethics) if ethics else 'Not specified'} |\n"
+            f"| Reflexivity procedures | {'; '.join(reflexivity) if reflexivity else 'Not specified'} |\n\n"
             "[QUALITATIVE EVIDENCE CONTRACT]\n"
             "Use the frozen design summary and tagged evidence below as the only source of this study's empirical facts. "
-            "Do not change the setting, sample, interview count, data sources, analytic design, temporal structure, cases, or quotations. "
-            "Do not infer an event sequence, actor comparison, negative case, or quotation that is absent from this packet.\n\n"
+            "Do not change the setting, sample, interview count, data sources, actor/data-source relations, analytic design, temporal structure, cases, procedures, or quotations. "
+            "Do not infer an event sequence, actor comparison, trustworthiness/ethics/reflexivity procedure, negative case, or quotation that is absent from this packet.\n\n"
             "### Table: Qualitative Evidence Structure\n"
             "| Higher-order Theme | Empirical Concept | Process Stage | Case/Actor | Evidence Role | Representative Quote |\n"
             "| :--- | :--- | :--- | :--- | :--- | :--- |\n"
         )
 
+        if data_source_roles:
+            md += (
+                "### Frozen Actor / Data-Source Relations\n"
+                "| Actor role | Data source | Count |\n"
+                "| :--- | :--- | :--- |\n"
+            )
+            for row in data_source_roles:
+                md += f"| {row['actor_role']} | {row['data_source']} | {row['count'] if row['count'] is not None else 'Not specified'} |\n"
+            md += "\n"
+
         clean_evidence = []
         seen_quotes = set()
         for item in evidence[:15]:
@@ -537,8 +643,12 @@ Rules:
             "study_facts": {
                 "research_setting": setting,
                 "data_sources": clean_sources,
+                "data_source_roles": data_source_roles,
                 "participant_count": participants,
                 "interview_count": interviews,
+                "trustworthiness_procedures": trustworthiness,
+                "ethics_procedures": ethics,
+                "reflexivity_procedures": reflexivity,
                 "analytic_design": analytic_design,
                 "analysis_method": analytic_design,
                 "analytic_logic": analytic_logic,