U1-R2A Unified Auto-Method UI + Four-Language Copy

app.py

@@ -30,8 +30,12 @@ from managed_auth import (
     start_generation_task,
 )
 from i18n import (
-    LANGUAGE_OPTIONS, get_amj_csv_template, get_asq_txt_template,
-    get_output_suffix, get_target_flag, get_target_language, tr,
+    LANGUAGE_OPTIONS, get_output_suffix, get_research_material_template,
+    get_target_flag, get_target_language, tr,
+)
+from core.advanced_method_registry import (
+    METHOD_FAMILIES, METHOD_RESOLVER_VERSION, method_capability,
+    resolve_generation_preflight,
 )
 from smartpaper_restore_bridge import edge_bridge
 
@@ -73,6 +77,12 @@ def inject_file_uploader_i18n(language: str) -> None:
     payload = {
         "browse": tr(language, "browse_files"),
         "uploaders": {
+            tr(language, "research_materials_label"): {
+                "title": tr(language, "drop_research_materials"),
+                "limit": tr(language, "limit_research_materials"),
+            },
+            # Legacy labels remain recognized for recovered historical UI state,
+            # but the unified workspace renders only research_materials_label.
             tr(language, "upload_reference"): {
                 "title": tr(language, "drop_docs"),
                 "limit": tr(language, "limit_docs"),
@@ -294,6 +304,9 @@ for key, default in {
     "sp_last_ui_task_status": "",
     "sp_scroll_to_generation_action": False,
     "sp_completed_download_scroll_task_id": "",
+    "sp_method_confirmation": "",
+    "sp_method_confirmation_signature": "",
+    "sp_material_document_use": "reference",
 }.items():
     if key not in st.session_state:
         st.session_state[key] = default
@@ -435,6 +448,23 @@ def _task_mode(task: dict) -> str:
     return "amj" if mode == "amj" else "asq"
 
 
+def _task_method_family(task: dict) -> str:
+    """Return frozen new-task method_family, with legacy resume fallback."""
+    task_id = str((task or {}).get("task_id") or "").strip()
+    if task_id:
+        request_path = _task_dir(task_id) / "request.json"
+        if request_path.is_file():
+            try:
+                payload = json.loads(request_path.read_text(encoding="utf-8"))
+                family = str(payload.get("method_family") or "").strip().casefold()
+                if family in METHOD_FAMILIES:
+                    return family
+            except Exception:
+                pass
+    mode = _task_mode(task)
+    return "qualitative" if mode == "asq" else "survey_path"
+
+
 def _task_output_path(task: dict) -> Path | None:
     task_id = str(task.get("task_id") or "").strip()
     filename = os.path.basename(str(task.get("output_filename") or "").strip())
@@ -462,7 +492,100 @@ def _save_uploaded(items, inputs_dir: Path, prefix: str) -> list[str]:
     return saved
 
 
-def _persist_task_request(task: dict, mode: str, lang_code: str) -> dict:
+def _uploaded_material_descriptors() -> list[dict[str, str]]:
+    out: list[dict[str, str]] = []
+    for item in st.session_state.get("up_research_materials") or []:
+        name = os.path.basename(str(getattr(item, "name", "") or ""))
+        mime_type = str(getattr(item, "type", "") or "")
+        if name or mime_type:
+            out.append({"name": name, "mime_type": mime_type})
+    return out
+
+
+def _method_intent_signature() -> str:
+    payload = {
+        "topic": str(st.session_state.get("sp_topic") or DEFAULT_TOPIC),
+        "keywords": str(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS),
+        "materials": _uploaded_material_descriptors(),
+    }
+    return hashlib.sha256(
+        json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    ).hexdigest()
+
+
+def _current_method_preflight(*, confirmed_method_family: str | None = None) -> tuple[dict, str]:
+    signature = _method_intent_signature()
+    stored_confirmation = str(st.session_state.get("sp_method_confirmation") or "").strip()
+    stored_signature = str(st.session_state.get("sp_method_confirmation_signature") or "").strip()
+    if confirmed_method_family is None:
+        confirmed = stored_confirmation if stored_signature == signature else ""
+    else:
+        confirmed = str(confirmed_method_family or "").strip()
+    preflight = resolve_generation_preflight(
+        str(st.session_state.get("sp_topic") or DEFAULT_TOPIC),
+        str(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS),
+        materials=_uploaded_material_descriptors(),
+        confirmed_method_family=confirmed,
+    )
+    return preflight, signature
+
+
+def _classify_and_save_research_materials(
+    method_family: str, inputs_dir: Path
+) -> tuple[list[str], list[str], list[str], str]:
+    """Map one visible uploader into legacy request buckets without changing engines."""
+    uploads = list(st.session_state.get("up_research_materials") or [])
+    if not uploads:
+        return [], [], [], "none"
+
+    structured = []
+    text_materials = []
+    documents = []
+    for item in uploads:
+        name = os.path.basename(str(getattr(item, "name", "") or ""))
+        ext = Path(name).suffix.lower()
+        if ext in {".csv", ".xls", ".xlsx"}:
+            structured.append(item)
+        elif ext == ".txt":
+            text_materials.append(item)
+        else:
+            documents.append(item)
+
+    decision = str(st.session_state.get("sp_material_document_use") or "reference").strip().lower()
+    if decision not in {"reference", "research"}:
+        decision = "reference"
+
+    reference_items = []
+    data_items = list(structured)
+    interview_items = []
+
+    if method_family == "qualitative":
+        interview_items.extend(text_materials)
+        if decision == "research":
+            interview_items.extend(documents)
+        else:
+            reference_items.extend(documents)
+    else:
+        # Structured spreadsheets are the only legacy-safe empirical-data path
+        # for current survey production. Text/doc materials remain reference
+        # context unless a dedicated future method adapter owns them.
+        reference_items.extend(text_materials)
+        reference_items.extend(documents)
+
+    refs = _save_uploaded(reference_items, inputs_dir, "ref")
+    data = _save_uploaded(data_items[:1], inputs_dir, "data")
+    interviews = _save_uploaded(interview_items[:1], inputs_dir, "interview")
+    return refs, data, interviews, decision
+
+
+def _persist_task_request(
+    task: dict,
+    mode: str,
+    lang_code: str,
+    *,
+    method_family: str,
+    method_resolver_version: str,
+) -> dict:
     task_id = str(task.get("task_id") or "").strip()
     numeric_id = (st.session_state.get("sp_user") or {}).get("numeric_id")
     if not task_id or not isinstance(numeric_id, int) or numeric_id <= 0:
@@ -471,19 +594,23 @@ def _persist_task_request(task: dict, mode: str, lang_code: str) -> dict:
     inputs_dir = task_dir / "inputs"
     inputs_dir.mkdir(parents=True, exist_ok=True)
 
-    if mode == "amj":
-        refs = _save_uploaded(st.session_state.get("up_amj_ref") or [], inputs_dir, "ref")
-        data = _save_uploaded([st.session_state.get("up_amj_data")], inputs_dir, "data")
-        interviews = []
-    else:
-        refs = _save_uploaded(st.session_state.get("up_asq_ref") or [], inputs_dir, "ref")
-        data = []
-        interviews = _save_uploaded([st.session_state.get("up_asq_data")], inputs_dir, "interview")
+    capability = method_capability(method_family)
+    expected_lane = str(capability.get("legacy_policy_lane") or "").strip().lower()
+    if expected_lane not in {"amj", "asq"} or expected_lane != str(mode or "").strip().lower():
+        raise RuntimeError("method_family_policy_lane_mismatch")
+
+    refs, data, interviews, material_use_decision = _classify_and_save_research_materials(
+        method_family, inputs_dir
+    )
 
     request_data = {
         "task_id": task_id,
         "user_id": numeric_id,
         "mode": mode,
+        "method_family": method_family,
+        "method_resolver_version": str(method_resolver_version or METHOD_RESOLVER_VERSION),
+        "derived_policy_lane": expected_lane,
+        "material_use_decision": material_use_decision,
         "interface_language": lang_code,
         "target_lang": get_target_language(lang_code),
         "output_suffix": get_output_suffix(lang_code),
@@ -502,7 +629,6 @@ def _persist_task_request(task: dict, mode: str, lang_code: str) -> dict:
     _atomic_json(task_dir / "request.json", request_data)
     return request_data
 
-
 def _pid_alive(pid: int) -> bool:
     if not isinstance(pid, int) or pid <= 0:
         return False
@@ -644,8 +770,36 @@ def _process_pending_launch(lang_code: str) -> None:
     pending = st.session_state.get("sp_pending_launch")
     if not isinstance(pending, dict):
         return
-    mode = str(pending.get("mode") or "").strip().lower()
+
+    pending_family = str(pending.get("method_family") or "").strip().casefold()
+    pending_mode = str(pending.get("mode") or "").strip().lower()
     idempotency_key = str(pending.get("idempotency_key") or "").strip()
+    pending_signature = str(pending.get("method_intent_signature") or "").strip()
+
+    # U1-R2 repeats the capability preflight immediately before any task/quota
+    # creation so a stale rerun or modified session state cannot bypass it.
+    preflight, current_signature = _current_method_preflight(
+        confirmed_method_family=pending_family or None
+    )
+    resolved_family = str(preflight.get("method_family") or "").strip().casefold()
+    resolved_mode = str(preflight.get("legacy_policy_lane") or "").strip().lower()
+    if (
+        not bool(preflight.get("can_start_generation"))
+        or not pending_family
+        or pending_family != resolved_family
+        or pending_mode != resolved_mode
+        or not pending_signature
+        or pending_signature != current_signature
+    ):
+        st.session_state["sp_pending_launch"] = None
+        reason = str(preflight.get("block_reason") or "method_preflight_changed")
+        if reason == "method_capability_blocked":
+            method_label = tr(lang_code, f"method_{resolved_family}")
+            st.warning(tr(lang_code, "method_not_supported", method=method_label))
+        else:
+            st.warning(tr(lang_code, "method_confirmation_required"))
+        return
+
     projection = get_product_ui_projection()
     selected_product_tier = (
         str(st.session_state.get("sp_product_tier") or "").strip().upper()
@@ -655,7 +809,7 @@ def _process_pending_launch(lang_code: str) -> None:
     try:
         response = start_generation_task(
             idempotency_key=idempotency_key,
-            mode=mode,
+            mode=resolved_mode,
             interface_language=lang_code,
             target_words=int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]),
             product_tier=selected_product_tier,
@@ -684,10 +838,20 @@ def _process_pending_launch(lang_code: str) -> None:
         return
     st.session_state["sp_generation_task"] = task
     st.session_state["sp_last_ui_task_status"] = str(task.get("status") or "")
+    st.session_state["run_mode"] = resolved_mode
     try:
         request_path = _task_dir(task_id) / "request.json"
         if not request_path.is_file():
-            _persist_task_request(task, mode, lang_code)
+            _persist_task_request(
+                task,
+                resolved_mode,
+                lang_code,
+                method_family=resolved_family,
+                method_resolver_version=str(
+                    (preflight.get("resolution") or {}).get("resolver_version")
+                    or METHOD_RESOLVER_VERSION
+                ),
+            )
         _launch_executor(task_id)
     except Exception as exc:
         st.session_state["sp_pending_launch"] = None
@@ -1191,9 +1355,9 @@ def _localized_terminal_task_error(task: dict, lang_code: str) -> tuple[str, str
     return detail or code or tr(lang_code, "node_error"), ""
 
 
-def _inject_generation_action_scroll(mode: str) -> None:
-    """Scroll immediately to the active generation action without a server wait."""
-    target_id = "sp-generation-action-asq" if str(mode or "").lower() == "asq" else "sp-generation-action-amj"
+def _inject_generation_action_scroll(mode: str | None = None) -> None:
+    """Scroll immediately to the unified generation action without a server wait."""
+    target_id = "sp-generation-action"
     components.html(
         f"""
         <script>
@@ -1222,8 +1386,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 "asq")
-    fallback_id = "sp-generation-action-asq" if mode.lower() == "asq" else "sp-generation-action-amj"
+    fallback_id = "sp-generation-action"
     components.html(
         f"""
         <script>
@@ -1253,35 +1416,6 @@ def _scroll_to_generation_action_once() -> None:
     )
 
 
-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 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"""
-        <script>
-        (() => {{
-          const parentDocument = window.parent.document;
-          const expected = {json.dumps(label)};
-          const select = () => {{
-            const tabs = Array.from(parentDocument.querySelectorAll('[role="tab"]'));
-            const target = tabs.find((node) => (node.textContent || '').trim() === expected.trim());
-            if (target && target.getAttribute('aria-selected') !== 'true') target.click();
-          }};
-          [0, 80, 220, 500, 900].forEach((delay) => window.parent.setTimeout(select, delay));
-        }})();
-        </script>
-        """,
-        height=0,
-        width=0,
-    )
-
-
 def render_workspace_controls(user):
     top_toolbar = st.container()
     with top_toolbar:
@@ -1332,6 +1466,103 @@ def render_workspace_controls(user):
     st.text_input(tr(lang_code, "topic_label"), value=DEFAULT_TOPIC, disabled=active, key="sp_topic")
     st.text_input(tr(lang_code, "keywords_label"), value=DEFAULT_KEYWORDS, disabled=active, key="sp_keywords")
 
+    # U1-R2 unified research workspace: academic intent/materials first, then
+    # product/length controls. Legacy AMJ/ASQ remains internal policy routing.
+    st.file_uploader(
+        tr(lang_code, "research_materials_label"),
+        type=["pdf", "txt", "doc", "docx", "csv", "xls", "xlsx"],
+        accept_multiple_files=True,
+        key="up_research_materials",
+        disabled=active,
+        help=tr(lang_code, "research_materials_help"),
+    )
+
+    uploaded_materials = list(st.session_state.get("up_research_materials") or [])
+    has_document_material = any(
+        Path(str(getattr(item, "name", "") or "")).suffix.lower() in {".pdf", ".doc", ".docx"}
+        for item in uploaded_materials
+    )
+    if has_document_material and not active:
+        st.radio(
+            tr(lang_code, "material_document_use_label"),
+            ["reference", "research"],
+            format_func=lambda value: tr(lang_code, f"material_use_{value}"),
+            horizontal=True,
+            key="sp_material_document_use",
+        )
+
+    if active:
+        active_family = _task_method_family(task)
+        active_capability = method_capability(active_family)
+        preflight = {
+            "can_start_generation": True,
+            "block_reason": "",
+            "method_family": active_family,
+            "legacy_policy_lane": str(active_capability.get("legacy_policy_lane") or _task_mode(task)),
+            "capability": active_capability,
+            "resolution": {"confidence": "TASK_FROZEN", "resolver_version": METHOD_RESOLVER_VERSION},
+        }
+        method_signature = ""
+    else:
+        preflight, method_signature = _current_method_preflight()
+        if str(preflight.get("block_reason") or "") == "method_confirmation_required":
+            stored = str(st.session_state.get("sp_method_confirmation") or "").strip().casefold()
+            stored_sig = str(st.session_state.get("sp_method_confirmation_signature") or "").strip()
+            selected_default = stored if stored_sig == method_signature and stored in METHOD_FAMILIES else ""
+            options = [""] + list(METHOD_FAMILIES)
+            selected = st.selectbox(
+                tr(lang_code, "method_confirm_label"),
+                options,
+                index=options.index(selected_default) if selected_default in options else 0,
+                format_func=lambda family: (
+                    tr(lang_code, "method_confirm_placeholder")
+                    if not family else tr(lang_code, f"method_{family}")
+                ),
+            )
+            if selected:
+                st.session_state["sp_method_confirmation"] = selected
+                st.session_state["sp_method_confirmation_signature"] = method_signature
+                preflight, method_signature = _current_method_preflight(confirmed_method_family=selected)
+        else:
+            # Explicit Title/Keyword cues are authoritative; stale confirmations
+            # from a previous ambiguous intent cannot override them.
+            st.session_state["sp_method_confirmation"] = ""
+            st.session_state["sp_method_confirmation_signature"] = ""
+
+    method_family = str(preflight.get("method_family") or "undetermined").strip().casefold()
+    method_label = (
+        tr(lang_code, f"method_{method_family}")
+        if method_family in METHOD_FAMILIES
+        else tr(lang_code, "method_undetermined")
+    )
+    st.markdown(f"**{tr(lang_code, 'detected_method_label')}:** {method_label}")
+    st.caption(tr(lang_code, "method_detection_explanation"))
+
+    block_reason = str(preflight.get("block_reason") or "")
+    if block_reason == "method_capability_blocked":
+        st.warning(tr(lang_code, "method_not_supported", method=method_label))
+    elif block_reason == "method_confirmation_required":
+        st.warning(tr(lang_code, "method_confirmation_required"))
+    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}"))
+            template_info = get_research_material_template(lang_code, method_family)
+            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.markdown(tr(lang_code, "template_help_undetermined"))
+
     product_ui = get_product_ui_projection()
     if product_ui.get("mode") == "a5_product":
         products = product_ui.get("products") or {}
@@ -1386,51 +1617,47 @@ def render_workspace_controls(user):
         key="sp_words",
     )
 
-    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"))
-        st.file_uploader(tr(lang_code, "upload_reference"), type=["pdf", "doc", "docx"], accept_multiple_files=True, key="up_asq_ref", disabled=active)
-        st.file_uploader(tr(lang_code, "upload_interviews"), type=["txt", "pdf", "doc", "docx"], key="up_asq_data", disabled=active)
-        with st.expander(tr(lang_code, "asq_expander")):
-            st.markdown(tr(lang_code, "asq_hint"))
-            template = get_asq_txt_template(lang_code)
-            st.code(template, language="text")
-            st.download_button(label=tr(lang_code, "download_asq_template"), data=template, file_name="ASQ_Interview_Template.txt", mime="text/plain", use_container_width=True)
-        st.markdown("<div id='sp-generation-action-asq'></div>", unsafe_allow_html=True)
-        if active and _task_mode(task) == "asq":
-            if st.button(tr(lang_code, "cancel_generation"), key="cancel_asq"):
-                st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "")
-                st.rerun()
-        elif st.button(tr(lang_code, "start_asq"), disabled=active, key="btn_asq"):
-            st.session_state["run_mode"] = "asq"
-            st.session_state["sp_pending_launch"] = {"mode": "asq", "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("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)
+    st.markdown("<div id='sp-generation-action'></div>", unsafe_allow_html=True)
+    if active:
+        if st.button(tr(lang_code, "cancel_generation"), key="cancel_generation_unified"):
+            st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "")
+            st.rerun()
+    else:
+        can_start = bool(preflight.get("can_start_generation"))
+        if st.button(
+            tr(lang_code, "start_generation_unified"),
+            disabled=not can_start,
+            key="btn_generation_unified",
+        ):
+            # Re-resolve at click time; _process_pending_launch repeats this gate
+            # again immediately before authoritative task/quota creation.
+            click_preflight, click_signature = _current_method_preflight(
+                confirmed_method_family=method_family if method_family in METHOD_FAMILIES else None
+            )
+            if not bool(click_preflight.get("can_start_generation")):
+                reason = str(click_preflight.get("block_reason") or "")
+                if reason == "method_capability_blocked":
+                    st.warning(tr(lang_code, "method_not_supported", method=method_label))
+                else:
+                    st.warning(tr(lang_code, "method_confirmation_required"))
+            else:
+                resolved_family = str(click_preflight.get("method_family") or "").strip().casefold()
+                resolved_mode = str(click_preflight.get("legacy_policy_lane") or "").strip().lower()
+                st.session_state["run_mode"] = resolved_mode
+                st.session_state["sp_pending_launch"] = {
+                    "mode": resolved_mode,
+                    "method_family": resolved_family,
+                    "method_resolver_version": str(
+                        (click_preflight.get("resolution") or {}).get("resolver_version")
+                        or METHOD_RESOLVER_VERSION
+                    ),
+                    "method_intent_signature": click_signature,
+                    "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()
+
     inject_file_uploader_i18n(lang_code)
 
 

core/advanced_method_registry.py

@@ -0,0 +1,340 @@
+# -*- coding: utf-8 -*-
+"""Deterministic method-family resolver and capability preflight for SmartPaper.
+
+U1-R2 derives an academic ``method_family`` from frozen user intent
+(Title/Keywords plus light material metadata), maps that family to the legacy
+AMJ/ASQ policy lane, and blocks unsupported method families before task/quota
+creation.  It never selects providers/models and never rewrites Title/Keywords.
+"""
+from __future__ import annotations
+
+import os
+import re
+from typing import Any, Iterable
+
+METHOD_RESOLVER_VERSION = "smartpaper-auto-method-resolver-v2"
+METHOD_CAPABILITY_REGISTRY_VERSION = "smartpaper-method-capability-registry-v2"
+
+METHOD_FAMILIES = (
+    "survey_path",
+    "qualitative",
+    "fsqca",
+    "meta_analysis",
+    "panel_econometrics",
+    "bibliometric_integrative_review",
+)
+
+# Capability status is executable U1-R2 preflight authority. Advanced methods
+# remain BLOCKED until their dedicated engines are implemented.
+_METHOD_CAPABILITIES: dict[str, dict[str, Any]] = {
+    "survey_path": {
+        "legacy_policy_lane": "amj",
+        "capability_status": "production_supported",
+        "evidence_timing": "pre_literature",
+        "engine_family": "quantitative_engine",
+    },
+    "qualitative": {
+        "legacy_policy_lane": "asq",
+        "capability_status": "production_supported",
+        "evidence_timing": "pre_literature",
+        "engine_family": "qualitative_engine",
+    },
+    "fsqca": {
+        "legacy_policy_lane": "amj",
+        "capability_status": "blocked_pending_engine",
+        "evidence_timing": "pre_literature",
+        "engine_family": "fsqca_engine_pending",
+    },
+    "meta_analysis": {
+        "legacy_policy_lane": "amj",
+        "capability_status": "blocked_pending_engine",
+        "evidence_timing": "post_literature",
+        "engine_family": "meta_analysis_engine_pending",
+    },
+    "panel_econometrics": {
+        "legacy_policy_lane": "amj",
+        "capability_status": "blocked_pending_engine",
+        "evidence_timing": "pre_literature",
+        "engine_family": "panel_econometrics_engine_pending",
+    },
+    "bibliometric_integrative_review": {
+        "legacy_policy_lane": "amj",
+        "capability_status": "blocked_pending_engine",
+        "evidence_timing": "post_literature",
+        "engine_family": "review_engine_pending",
+    },
+}
+
+# Priority matters.  Method-defining paradigms outrank generic survey cues.
+_METHOD_PATTERNS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    (
+        "fsqca",
+        (
+            r"\bfsqca\b", r"\bfuzzy[- ]set\s+qca\b", r"\bfuzzy[- ]set\s+qualitative\s+comparative\s+analysis\b",
+            r"\bconfigurational\s+(?:analysis|paths?|approach)\b", r"\btruth\s+table\b",
+            r"模糊集定性比较分析", r"定性比较分析", r"组态(?:分析|路径)",
+            r"нечетк\w*.{0,18}сравнительн\w*.{0,18}анализ", r"конфигурационн\w*.{0,12}анализ",
+            r"бұлыңғыр.{0,16}сапалық.{0,16}салыстырмалы.{0,16}талдау", r"конфигурациялық.{0,12}талдау",
+        ),
+    ),
+    (
+        "meta_analysis",
+        (
+            r"\bmeta[- ]analysis\b", r"\bmeta[- ]analytic\b", r"\bmeta analysis\b",
+            r"元分析", r"荟萃分析",
+            r"мета[- ]?анализ", r"метааналитическ",
+            r"мета[- ]?талдау", r"метааналитикалық",
+        ),
+    ),
+    (
+        "bibliometric_integrative_review",
+        (
+            r"\bbibliometric\b", r"\bscience\s+mapping\b", r"\bco[- ]citation\b", r"\bco[- ]word\b",
+            r"\bintegrative\s+(?:theory\s+)?review\b", r"\btheory\s+review\b", r"\bsystematic\s+literature\s+review\b",
+            r"文献计量", r"科学知识图谱", r"共被引", r"共词", r"整合性(?:理论)?综述", r"系统性文献综述",
+            r"библиометр", r"научн\w*.{0,8}картирован", r"коцитирован", r"интегративн\w*.{0,8}обзор",
+            r"библиометр", r"ғылыми.{0,8}карталау", r"бірлескен.{0,8}дәйексөз", r"интегративті.{0,8}шолу",
+        ),
+    ),
+    (
+        "panel_econometrics",
+        (
+            r"\bpanel\s+data\b", r"\bfirm[- ]year\b", r"\bentity\s+fixed\s+effects?\b", r"\bfixed\s+effects?\b",
+            r"\brandom\s+effects?\b", r"\bpanel\s+econometrics?\b", r"\btwo[- ]way\s+fixed\s+effects?\b",
+            r"面板数据", r"固定效应", r"双向固定效应", r"公司[-—– ]?年度",
+            r"панельн\w*.{0,8}данн", r"фиксированн\w*.{0,8}эффект",
+            r"панельдік.{0,8}дерек", r"тұрақты.{0,8}әсер",
+        ),
+    ),
+    (
+        "qualitative",
+        (
+            r"\bqualitative\s+(?:study|research|analysis)\b", r"\bgioia\b", r"\bgrounded\s+theory\b",
+            r"\bcase\s+study\b", r"\bcomparative\s+case\b", r"\bprocess\s+study\b", r"\bethnograph",
+            r"\bsemi[- ]structured\s+interviews?\b", r"\binterviews?\b",
+            r"定性研究", r"质性研究", r"扎根理论", r"案例研究", r"个案研究", r"访谈", r"民族志",
+            r"качественн\w*.{0,8}(?:исследован|анализ)", r"обоснованн\w*.{0,8}теори", r"интервью", r"кейс[- ]?исследован",
+            r"сапалық.{0,8}(?:зерттеу|талдау)", r"негізделген.{0,8}теори", r"сұхбат", r"кейс.{0,8}зерттеу",
+        ),
+    ),
+    (
+        "survey_path",
+        (
+            r"\bsurvey\b", r"\bquestionnaire\b", r"\bstructural\s+equation\s+model", r"\bsem\b", r"\bpls[- ]sem\b",
+            r"\bregression\b", r"\bmediating\s+role\b", r"\bmoderating\s+role\b", r"\bmediation\b", r"\bmoderation\b",
+            r"问卷", r"结构方程", r"回归", r"中介(?:作用|效应|变量)?", r"调节(?:作用|效应|变量)?",
+            r"опрос", r"анкет", r"структурн\w*.{0,10}уравнен", r"регресс", r"медиирующ", r"модерирующ",
+            r"сауалнама", r"құрылымдық.{0,10}теңдеу", r"регресс", r"медиаторлық", r"модераторлық",
+        ),
+    ),
+)
+
+_MATERIAL_NAME_PATTERNS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("fsqca", (r"fsqca", r"truth[-_ ]?table", r"calibrat", r"condition[-_ ]?outcome")),
+    ("meta_analysis", (r"meta[-_ ]?analysis", r"effect[-_ ]?size", r"forest[-_ ]?plot", r"study[-_ ]?character")),
+    ("bibliometric_integrative_review", (r"bibliometric", r"corpus", r"co[-_ ]?citation", r"co[-_ ]?word", r"openalex")),
+    ("panel_econometrics", (r"panel", r"firm[-_ ]?year", r"entity[-_ ]?year", r"fixed[-_ ]?effect")),
+    ("qualitative", (r"interview", r"transcript", r"field[-_ ]?note", r"focus[-_ ]?group", r"访谈", r"сұхбат", r"интервью")),
+)
+
+
+def _normalized_text(value: Any) -> str:
+    return re.sub(r"\s+", " ", str(value or "")).strip()
+
+
+def _keyword_items(value: Any) -> list[str]:
+    if isinstance(value, (list, tuple)):
+        raw = list(value)
+    else:
+        raw = re.split(r"[;\n|]+", str(value or ""))
+        if len(raw) == 1:
+            raw = re.split(r"[,]", str(value or ""))
+    return [_normalized_text(item) for item in raw if _normalized_text(item)]
+
+
+def _material_descriptors(materials: Iterable[Any] | None) -> list[dict[str, str]]:
+    out: list[dict[str, str]] = []
+    for item in materials or []:
+        if isinstance(item, dict):
+            name = _normalized_text(item.get("name") or item.get("filename"))
+            mime = _normalized_text(item.get("mime_type") or item.get("type"))
+        else:
+            name = _normalized_text(getattr(item, "name", ""))
+            mime = _normalized_text(getattr(item, "type", ""))
+        if not name and not mime:
+            continue
+        out.append({
+            "name": name,
+            "mime_type": mime,
+            "extension": os.path.splitext(name)[1].lower().lstrip("."),
+        })
+    return out
+
+
+def method_capability(method_family: str) -> dict[str, Any]:
+    """Return a copy of versioned capability metadata for one method family."""
+    family = str(method_family or "").strip().casefold()
+    row = dict(_METHOD_CAPABILITIES.get(family) or {})
+    if not row:
+        return {
+            "registry_version": METHOD_CAPABILITY_REGISTRY_VERSION,
+            "method_family": "undetermined",
+            "legacy_policy_lane": None,
+            "capability_status": "ambiguous",
+            "evidence_timing": "undetermined",
+            "engine_family": "undetermined",
+        }
+    row.update({
+        "registry_version": METHOD_CAPABILITY_REGISTRY_VERSION,
+        "method_family": family,
+    })
+    return row
+
+
+def resolve_method_family(
+    title: Any,
+    keywords: Any,
+    *,
+    materials: Iterable[Any] | None = None,
+) -> dict[str, Any]:
+    """Resolve an academic method family from frozen user intent.
+
+    Explicit Title/Keyword cues are authoritative. Material *metadata* can add
+    support, but never overrides an explicit method cue. File contents are
+    deliberately not read here.
+    """
+    source_title = _normalized_text(title)
+    source_keywords = _keyword_items(keywords)
+    text = " ; ".join([source_title] + source_keywords)
+
+    hits: list[dict[str, Any]] = []
+    chosen = ""
+    for family, patterns in _METHOD_PATTERNS:
+        matched = [pattern for pattern in patterns if re.search(pattern, text, flags=re.I | re.UNICODE)]
+        if matched:
+            hits.append({"method_family": family, "source": "title_keywords", "match_count": len(matched)})
+            if not chosen:
+                chosen = family
+
+    descriptors = _material_descriptors(materials)
+    material_hits: list[str] = []
+    for descriptor in descriptors:
+        name = descriptor.get("name") or ""
+        for family, patterns in _MATERIAL_NAME_PATTERNS:
+            if any(re.search(pattern, name, flags=re.I | re.UNICODE) for pattern in patterns):
+                if family not in material_hits:
+                    material_hits.append(family)
+
+    # Explicit academic wording outranks material filename hints.  When there is
+    # no explicit cue, one unique material hint is useful but remains ambiguous
+    # until future U1 benchmarks justify auto-acceptance.
+    confidence = "HIGH_CONFIDENCE" if chosen else "AMBIGUOUS"
+    reason_codes: list[str] = []
+    if chosen:
+        reason_codes.append("explicit_title_keyword_method_cue")
+        conflicting = [row["method_family"] for row in hits if row["method_family"] != chosen]
+        if conflicting:
+            reason_codes.append("lower_priority_method_cues_present")
+    elif len(material_hits) == 1:
+        chosen = material_hits[0]
+        reason_codes.append("material_filename_method_hint_only")
+    elif len(material_hits) > 1:
+        reason_codes.append("conflicting_material_method_hints")
+    else:
+        reason_codes.append("no_explicit_method_cue")
+
+    capability = method_capability(chosen)
+    return {
+        "resolver_version": METHOD_RESOLVER_VERSION,
+        "shadow_only": False,
+        "method_family": chosen or "undetermined",
+        "confidence": confidence,
+        "reason_codes": reason_codes,
+        "title_keyword_hits": hits,
+        "material_hint_families": material_hits,
+        "material_count": len(descriptors),
+        "derived_policy_lane": capability.get("legacy_policy_lane"),
+        "capability": capability,
+    }
+
+
+def compare_shadow_to_legacy_lane(resolution: dict[str, Any], selected_lane: Any) -> dict[str, Any]:
+    """Compare shadow inference with the legacy user-selected AMJ/ASQ lane."""
+    selected = str(selected_lane or "").strip().casefold()
+    derived = str((resolution or {}).get("derived_policy_lane") or "").strip().casefold()
+    return {
+        "selected_legacy_lane": selected or None,
+        "derived_policy_lane": derived or None,
+        "lane_match": bool(selected and derived and selected == derived),
+        "comparable": bool(selected and derived),
+    }
+
+
+def resolve_generation_preflight(
+    title: Any,
+    keywords: Any,
+    *,
+    materials: Iterable[Any] | None = None,
+    confirmed_method_family: Any = None,
+) -> dict[str, Any]:
+    """Resolve method + capability before any task/quota creation.
+
+    A user confirmation is accepted only when deterministic resolution is
+    genuinely ambiguous. Explicit Title/Keyword cues always remain authoritative.
+    """
+    resolution = resolve_method_family(title, keywords, materials=materials)
+    family = str(resolution.get("method_family") or "").strip().casefold()
+    confidence = str(resolution.get("confidence") or "").strip().upper()
+
+    confirmed = str(confirmed_method_family or "").strip().casefold()
+    if confidence == "AMBIGUOUS":
+        if confirmed in METHOD_FAMILIES:
+            family = confirmed
+            capability = method_capability(family)
+            resolution = dict(resolution)
+            resolution.update({
+                "method_family": family,
+                "confidence": "USER_CONFIRMED",
+                "derived_policy_lane": capability.get("legacy_policy_lane"),
+                "capability": capability,
+                "reason_codes": list(resolution.get("reason_codes") or []) + ["user_confirmed_method_family"],
+            })
+        else:
+            return {
+                "can_start_generation": False,
+                "block_reason": "method_confirmation_required",
+                "resolution": resolution,
+                "method_family": family or "undetermined",
+                "legacy_policy_lane": None,
+                "capability": method_capability(family),
+            }
+
+    capability = method_capability(family)
+    lane = str(capability.get("legacy_policy_lane") or "").strip().casefold() or None
+    status = str(capability.get("capability_status") or "").strip().casefold()
+    if family not in METHOD_FAMILIES or not lane:
+        return {
+            "can_start_generation": False,
+            "block_reason": "method_confirmation_required",
+            "resolution": resolution,
+            "method_family": family or "undetermined",
+            "legacy_policy_lane": None,
+            "capability": capability,
+        }
+    if status != "production_supported":
+        return {
+            "can_start_generation": False,
+            "block_reason": "method_capability_blocked",
+            "resolution": resolution,
+            "method_family": family,
+            "legacy_policy_lane": lane,
+            "capability": capability,
+        }
+    return {
+        "can_start_generation": True,
+        "block_reason": "",
+        "resolution": resolution,
+        "method_family": family,
+        "legacy_policy_lane": lane,
+        "capability": capability,
+    }

i18n.py

@@ -206,10 +206,10 @@ REFERENCE_HEADINGS = {
 TEXTS: dict[str, dict[str, str]] = {
     "zh": {
         "title": "📊 工商管理论文智能体",
-        "topic_label": "📝 论文名称",
-        "keywords_label": "🔍 关键字",
-        "words_label": "📏 目标总单词数（{min_words}–{max_words}单词）",
-        "words_label_product": "📏 目标正文单词数（{min_words}–{max_words}单词）",
+        "topic_label": "📝 论文题目（必填）",
+        "keywords_label": "🔍 关键词（必填）",
+        "words_label": "📏 目标正文字数（必填，{min_words}–{max_words} 单词）",
+        "words_label_product": "📏 目标正文字数（必填，{min_words}–{max_words} 单词）",
         "product_tier_label": "版本",
         "product_tier_standard": "标准版",
         "product_tier_flagship": "旗舰版",
@@ -275,6 +275,37 @@ TEXTS: dict[str, dict[str, str]] = {
         "asq_hint": "**⚠️ 核心提示**：为了让AI准确提取语录和编码树，请务必标注**受访者角色（Role）**，并采用清晰的**对话格式**。",
         "download_asq_template": "📥 一键下载 TXT 访谈模板",
         "start_asq": "🚀 启动 ASQ 模式生成",
+        "research_materials_label": "研究资料（可选）",
+        "research_materials_help": "支持 PDF、TXT、DOC、DOCX、CSV、XLS、XLSX。SmartPaper 会结合论文题目、关键词与文件特征判断研究设计和资料用途。",
+        "drop_research_materials": "将研究资料拖到这里",
+        "limit_research_materials": "每个文件最大 1 GB · PDF, TXT, DOC, DOCX, CSV, XLS, XLSX",
+        "material_document_use_label": "如何使用上传的 PDF/DOC/DOCX 文件？",
+        "material_use_reference": "作为参考文献资料",
+        "material_use_research": "作为研究资料",
+        "detected_method_label": "研究设计（自动识别）",
+        "method_detection_explanation": "SmartPaper 根据论文题目、关键词和可选研究资料自动识别研究方法；不会修改你的题目或关键词。",
+        "method_confirm_label": "请确认研究设计",
+        "method_confirm_placeholder": "请选择研究方法",
+        "method_confirmation_required": "当前信息不足以可靠识别研究设计，请先确认研究方法。",
+        "method_not_supported": "已识别为“{method}”。该研究方法的专用生成引擎尚未开放；本次不会创建任务，也不会占用额度。",
+        "method_supported": "已识别为“{method}”。系统将按对应研究流程生成论文。",
+        "method_undetermined": "尚未确定",
+        "method_survey_path": "问卷与路径关系研究",
+        "method_qualitative": "定性研究",
+        "method_fsqca": "fsQCA 组态研究",
+        "method_meta_analysis": "元分析",
+        "method_panel_econometrics": "面板计量研究",
+        "method_bibliometric_integrative_review": "文献计量与整合性综述",
+        "adaptive_template_expander": "💡 推荐模板（可选）",
+        "download_research_template": "📥 下载研究资料模板",
+        "template_help_survey_path": "推荐使用变量或统计结果表。若未上传数据，系统会按项目规则生成用于初稿的辅助证据。",
+        "template_help_qualitative": "推荐使用访谈、田野记录或案例材料。若未上传资料，系统会构建匿名的初稿证据包。",
+        "template_help_fsqca": "推荐使用条件变量、结果变量及校准信息表。专用 fsQCA 引擎开放后将按此结构处理。",
+        "template_help_meta_analysis": "推荐使用研究层面的效应量提取表。真实论文身份与系统辅助效应量必须严格分离。",
+        "template_help_panel_econometrics": "推荐使用实体—时间面板数据表，例如企业—年度结构。",
+        "template_help_bibliometric_integrative_review": "推荐使用真实文献语料的题名、作者、年份、DOI、期刊和关键词等元数据。",
+        "template_help_undetermined": "确认研究设计后，系统将显示对应的研究资料模板。",
+        "start_generation_unified": "🚀 开始生成",
         "api_key_missing": "❌ 缺少 DEEPSEEK_API_KEY，请配置API密钥。",
         "resume_toast": "🔄 检测到页面刷新或网络抖动，系统正在自动恢复进度……",
         "pipeline_start": "⏳ 流水线启动……",
@@ -416,10 +447,10 @@ TEXTS: dict[str, dict[str, str]] = {
     },
     "en": {
         "title": "📊 Business Administration Article Agent",
-        "topic_label": "📝 Article Title",
-        "keywords_label": "🔍 Keywords",
-        "words_label": "📏 Target Word Count ({min_words}–{max_words} words)",
-        "words_label_product": "📏 Target Body Word Count ({min_words}–{max_words} words)",
+        "topic_label": "📝 Title (Required)",
+        "keywords_label": "🔍 Keywords (Required)",
+        "words_label": "📏 Target Word Count (Required, {min_words}–{max_words} words)",
+        "words_label_product": "📏 Target Word Count (Required, {min_words}–{max_words} words)",
         "product_tier_label": "Version",
         "product_tier_standard": "Standard",
         "product_tier_flagship": "Flagship",
@@ -433,7 +464,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "resume_unavailable_runtime_replaced": "⚠️ A paused unfinished paper task was detected, but this runtime no longer has the local request or checkpoint files required to continue it. Resume has been disabled to prevent an unsafe recovery. To release this task and start again, explicitly choose ‘Delete and Start Again’.",
         "resume": "🔄 Continue Previous Task",
         "clear": "🗑️ Delete and Start Again",
-        "cancel_generation": "⛔ Cancel Generation",
+        "cancel_generation": "⛔ Cancel",
         "draft_preparing": "Preparing the English draft…",
         "draft_stage_inputs": "Organizing research inputs and evidence…",
         "draft_stage_search": "Searching the academic literature…",
@@ -485,6 +516,37 @@ TEXTS: dict[str, dict[str, str]] = {
         "asq_hint": "**⚠️ Important**: Clearly label each **informant role** and use a consistent **dialogue format** so the system can accurately extract quotations and build the coding structure.",
         "download_asq_template": "📥 Download TXT Interview Template",
         "start_asq": "🚀 Start ASQ Generation",
+        "research_materials_label": "Research Materials (Optional)",
+        "research_materials_help": "Supports PDF, TXT, DOC, DOCX, CSV, XLS, and XLSX. SmartPaper uses the Title, Keywords, and file characteristics to infer the research design and material role.",
+        "drop_research_materials": "Drag research materials here",
+        "limit_research_materials": "Up to 1 GB per file · PDF, TXT, DOC, DOCX, CSV, XLS, XLSX",
+        "material_document_use_label": "How should SmartPaper use the uploaded PDF/DOC/DOCX files?",
+        "material_use_reference": "Use as reference literature",
+        "material_use_research": "Use as research materials",
+        "detected_method_label": "Research Design (Auto-detected)",
+        "method_detection_explanation": "SmartPaper infers the research method from the Title, Keywords, and optional materials without rewriting your Title or Keywords.",
+        "method_confirm_label": "Confirm Research Design",
+        "method_confirm_placeholder": "Select a research method",
+        "method_confirmation_required": "The current information is insufficient for reliable method detection. Please confirm the research design first.",
+        "method_not_supported": "Detected method: {method}. Its dedicated generation engine is not yet enabled, so no task will be created and no quota will be used.",
+        "method_supported": "Detected method: {method}. SmartPaper will use the corresponding research workflow.",
+        "method_undetermined": "Not yet determined",
+        "method_survey_path": "Survey and Path-Relationship Study",
+        "method_qualitative": "Qualitative Study",
+        "method_fsqca": "fsQCA Configurational Study",
+        "method_meta_analysis": "Meta-Analysis",
+        "method_panel_econometrics": "Panel Econometric Study",
+        "method_bibliometric_integrative_review": "Bibliometric and Integrative Review",
+        "adaptive_template_expander": "💡 Recommended Template (Optional)",
+        "download_research_template": "📥 Download Research Materials Template",
+        "template_help_survey_path": "A variable-level or statistical-results table is recommended. If no data are uploaded, SmartPaper may construct draft evidence under the project provenance rules.",
+        "template_help_qualitative": "Interview, field-note, or case materials are recommended. If none are uploaded, SmartPaper may construct an anonymous draft evidence packet.",
+        "template_help_fsqca": "A table of conditions, outcomes, and calibration information is recommended. The dedicated fsQCA engine will use this structure once enabled.",
+        "template_help_meta_analysis": "A study-level effect-size extraction table is recommended. Real paper identities must remain separate from any system-assisted effect-size evidence.",
+        "template_help_panel_econometrics": "An entity-time panel table, such as a firm-year structure, is recommended.",
+        "template_help_bibliometric_integrative_review": "Use real-corpus metadata such as title, authors, year, DOI, venue, and keywords.",
+        "template_help_undetermined": "Confirm the research design to view the corresponding research-material template.",
+        "start_generation_unified": "🚀 Start Generation",
         "api_key_missing": "❌ DEEPSEEK_API_KEY is missing. Configure the API key.",
         "resume_toast": "🔄 A page refresh or network interruption was detected. Progress is being restored automatically…",
         "pipeline_start": "⏳ Starting the pipeline…",
@@ -626,10 +688,10 @@ TEXTS: dict[str, dict[str, str]] = {
     },
     "ru": {
         "title": "📊 Интеллектуальный агент для научных статей по управлению бизнесом",
-        "topic_label": "📝 Название статьи",
-        "keywords_label": "🔍 Ключевые слова",
-        "words_label": "📏 Целевой объём ({min_words}–{max_words} слов)",
-        "words_label_product": "📏 Целевой объём основного текста ({min_words}–{max_words} слов)",
+        "topic_label": "📝 Название статьи (обязательно)",
+        "keywords_label": "🔍 Ключевые слова (обязательно)",
+        "words_label": "📏 Целевой объём текста (обязательно, {min_words}–{max_words} слов)",
+        "words_label_product": "📏 Целевой объём текста (обязательно, {min_words}–{max_words} слов)",
         "product_tier_label": "Версия",
         "product_tier_standard": "Стандарт",
         "product_tier_flagship": "Флагман",
@@ -643,7 +705,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "resume_unavailable_runtime_replaced": "⚠️ Обнаружена приостановленная незавершённая задача, но в текущей среде выполнения отсутствуют локальный файл запроса или контрольная точка, необходимые для продолжения. Чтобы избежать некорректного восстановления, кнопка продолжения отключена. Для освобождения задачи и нового запуска явно выберите «Удалить и начать заново».",
         "resume": "🔄 Продолжить предыдущую задачу",
         "clear": "🗑️ Удалить и начать заново",
-        "cancel_generation": "⛔ Отменить генерацию",
+        "cancel_generation": "⛔ Отменить",
         "draft_preparing": "Подготовка черновика на английском языке…",
         "draft_stage_inputs": "Систематизация исследовательских данных и доказательств…",
         "draft_stage_search": "Поиск научной литературы…",
@@ -695,6 +757,37 @@ TEXTS: dict[str, dict[str, str]] = {
         "asq_hint": "**⚠️ Важно**: укажите **роль информанта** и соблюдайте единый **формат диалога**, чтобы система точно извлекала цитаты и строила структуру кодирования.",
         "download_asq_template": "📥 Скачать TXT-шаблон интервью",
         "start_asq": "🚀 Запустить формирование в режиме ASQ",
+        "research_materials_label": "Материалы исследования (необязательно)",
+        "research_materials_help": "Поддерживаются PDF, TXT, DOC, DOCX, CSV, XLS и XLSX. SmartPaper определяет дизайн исследования и назначение материалов по названию статьи, ключевым словам и характеристикам файлов.",
+        "drop_research_materials": "Перетащите исследовательские материалы сюда",
+        "limit_research_materials": "До 1 ГБ на файл · PDF, TXT, DOC, DOCX, CSV, XLS, XLSX",
+        "material_document_use_label": "Как использовать загруженные файлы PDF/DOC/DOCX?",
+        "material_use_reference": "Как научные источники",
+        "material_use_research": "Как исследовательские материалы",
+        "detected_method_label": "Дизайн исследования (определяется автоматически)",
+        "method_detection_explanation": "SmartPaper определяет метод по названию статьи, ключевым словам и необязательным материалам, не изменяя название и ключевые слова.",
+        "method_confirm_label": "Подтвердите дизайн исследования",
+        "method_confirm_placeholder": "Выберите метод исследования",
+        "method_confirmation_required": "Имеющейся информации недостаточно для надёжного определения метода. Сначала подтвердите дизайн исследования.",
+        "method_not_supported": "Определён метод «{method}». Специализированный движок этого метода пока не включён, поэтому задача не будет создана и квота не будет списана.",
+        "method_supported": "Определён метод «{method}». SmartPaper применит соответствующий исследовательский процесс.",
+        "method_undetermined": "Пока не определён",
+        "method_survey_path": "Опросное исследование и анализ связей",
+        "method_qualitative": "Качественное исследование",
+        "method_fsqca": "Конфигурационное исследование fsQCA",
+        "method_meta_analysis": "Мета-анализ",
+        "method_panel_econometrics": "Панельное эконометрическое исследование",
+        "method_bibliometric_integrative_review": "Библиометрический и интегративный обзор",
+        "adaptive_template_expander": "💡 Рекомендуемый шаблон (необязательно)",
+        "download_research_template": "📥 Скачать шаблон исследовательских материалов",
+        "template_help_survey_path": "Рекомендуется таблица переменных или статистических результатов. При отсутствии данных SmartPaper может сформировать черновые доказательные материалы в рамках правил происхождения данных.",
+        "template_help_qualitative": "Рекомендуются интервью, полевые заметки или материалы кейсов. При их отсутствии SmartPaper может сформировать анонимный черновой пакет доказательств.",
+        "template_help_fsqca": "Рекомендуется таблица условий, результата и параметров калибровки. После включения специализированный движок fsQCA будет использовать эту структуру.",
+        "template_help_meta_analysis": "Рекомендуется таблица извлечения размеров эффектов на уровне исследований. Реальные публикации нельзя связывать с системно сформированными размерами эффектов.",
+        "template_help_panel_econometrics": "Рекомендуется панельная таблица «объект–время», например структура «компания–год».",
+        "template_help_bibliometric_integrative_review": "Используйте реальные метаданные корпуса: название, авторов, год, DOI, журнал и ключевые слова.",
+        "template_help_undetermined": "После подтверждения дизайна исследования будет показан соответствующий шаблон материалов.",
+        "start_generation_unified": "🚀 Начать",
         "api_key_missing": "❌ Не задан DEEPSEEK_API_KEY. Настройте ключ API.",
         "resume_toast": "🔄 Обнаружено обновление страницы или нарушение соединения. Выполняется автоматическое восстановление…",
         "pipeline_start": "⏳ Запуск конвейера…",
@@ -836,10 +929,10 @@ TEXTS: dict[str, dict[str, str]] = {
     },
     "kk": {
         "title": "📊 Бизнес-басқару жөніндегі ғылыми мақала интеллектуалды агенті",
-        "topic_label": "📝 Мақала атауы",
-        "keywords_label": "🔍 Түйін сөздер",
-        "words_label": "📏 Мақсатты көлем ({min_words}–{max_words} сөз)",
-        "words_label_product": "📏 Негізгі мәтіннің мақсатты көлемі ({min_words}–{max_words} сөз)",
+        "topic_label": "📝 Мақала тақырыбы (міндетті)",
+        "keywords_label": "🔍 Кілт сөздер (міндетті)",
+        "words_label": "📏 Мақсатты сөз саны (міндетті, {min_words}–{max_words} сөз)",
+        "words_label_product": "📏 Мақсатты сөз саны (міндетті, {min_words}–{max_words} сөз)",
         "product_tier_label": "Нұсқа",
         "product_tier_standard": "Стандарт",
         "product_tier_flagship": "Флагман",
@@ -853,7 +946,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "resume_unavailable_runtime_replaced": "⚠️ Уақытша тоқтатылған аяқталмаған тапсырма анықталды, бірақ ағымдағы іске қосу ортасында оны жалғастыруға қажет жергілікті сұрау немесе бақылау нүктесі файлдары жоқ. Қате қалпына келтіруге жол бермеу үшін жалғастыру түймесі өшірілді. Тапс��рманы босатып, қайта бастау үшін «Өшіріп, қайта бастау» әрекетін нақты таңдаңыз.",
         "resume": "🔄 Алдыңғы тапсырманы жалғастыру",
         "clear": "🗑️ Өшіріп, қайта бастау",
-        "cancel_generation": "⛔ Генерацияны тоқтату",
+        "cancel_generation": "⛔ Болдырмау",
         "draft_preparing": "Ағылшын тіліндегі бастапқы нұсқа дайындалуда…",
         "draft_stage_inputs": "Зерттеу кірістері мен дәлелдер реттелуде…",
         "draft_stage_search": "Ғылыми әдебиеттер ізделуде…",
@@ -905,6 +998,37 @@ TEXTS: dict[str, dict[str, str]] = {
         "asq_hint": "**⚠️ Маңызды**: жүйе дәйексөздерді дәл шығарып, кодтау құрылымын құруы үшін **ақпарат берушінің рөлін** көрсетіп, бірізді **диалог пішімін** қолданыңыз.",
         "download_asq_template": "📥 TXT сұхбат үлгісін жүктеу",
         "start_asq": "🚀 ASQ режимінде дайындауды бастау",
+        "research_materials_label": "Зерттеу материалдары (міндетті емес)",
+        "research_materials_help": "PDF, TXT, DOC, DOCX, CSV, XLS және XLSX форматтары қолдау табады. SmartPaper мақала атауы, түйін сөздер және файл сипаттары негізінде зерттеу дизайны мен материалдардың қызметін анықтайды.",
+        "drop_research_materials": "Зерттеу материалдарын осы жерге сүйреп әкеліңіз",
+        "limit_research_materials": "Әр файлға 1 ГБ дейін · PDF, TXT, DOC, DOCX, CSV, XLS, XLSX",
+        "material_document_use_label": "Жүктелген PDF/DOC/DOCX файлдарын қалай пайдалану керек?",
+        "material_use_reference": "Ғылыми дереккөз ретінде",
+        "material_use_research": "Зерттеу материалы ретінде",
+        "detected_method_label": "Зерттеу дизайны (автоматты түрде анықталады)",
+        "method_detection_explanation": "SmartPaper зерттеу әдісін мақала атауы, түйін сөздер және қосымша материалдар негізінде анықтайды; мақала атауы мен түйін сөздерді өзгертпейді.",
+        "method_confirm_label": "Зерттеу дизайнын растаңыз",
+        "method_confirm_placeholder": "Зерттеу әдісін таңдаңыз",
+        "method_confirmation_required": "Қазіргі ақпарат зерттеу әдісін сенімді анықтауға жеткіліксіз. Алдымен зерттеу дизайнын растаңыз.",
+        "method_not_supported": "«{method}» әдісі анықталды. Бұл әдістің арнайы генерация қозғалтқышы әлі қосылмаған, сондықтан тапсырма құрылмайды және квота пайдаланылмайды.",
+        "method_supported": "«{method}» әдісі анықталды. SmartPaper тиісті зерттеу үдерісін қолданады.",
+        "method_undetermined": "Әзірге анықталмаған",
+        "method_survey_path": "Сауалнама және байланыстарды талдау зерттеуі",
+        "method_qualitative": "Сапалық зерттеу",
+        "method_fsqca": "fsQCA конфигурациялық зерттеуі",
+        "method_meta_analysis": "Мета-талдау",
+        "method_panel_econometrics": "Панельдік эконометрикалық зерттеу",
+        "method_bibliometric_integrative_review": "Библиометриялық және интегративті шолу",
+        "adaptive_template_expander": "💡 Ұсынылатын үлгі (міндетті емес)",
+        "download_research_template": "📥 Зерттеу материалдары үлгісін жүктеу",
+        "template_help_survey_path": "Айнымалылар немесе статистикалық нәтижелер кестесі ұсынылады. Дерек жүктелмесе, SmartPaper жоба ережелеріне сәйкес бастапқы нұсқаға арналған көмекші дәлелдерді құра алады.",
+        "template_help_qualitative": "Сұхбат, далалық жазба немесе кейс материалдары ұсынылады. Олар болмаса, SmartPaper анонимді бастапқы дәлелдер пакетін құра алады.",
+        "template_help_fsqca": "Шарттар, нәтиже және калибрлеу ақпараты бар кесте ұсынылады. Арнайы fsQCA қозғалтқышы қосылғаннан кейін осы құрылым қолданылады.",
+        "template_help_meta_analysis": "Зерттеу деңгейіндегі әсер мөлшерлерін шығару кестесі ұсынылады. Нақты мақалалардың сәйкестендіргіштері жүйе құрастырған әсер мөлшерлерімен байланыстырылмауы тиіс.",
+        "template_help_panel_econometrics": "Нысан–уақыт панельдік кестесі, мысалы компания–жыл құрылымы ұсынылады.",
+        "template_help_bibliometric_integrative_review": "Нақты әдеби корпус метадеректерін пайдаланыңыз: атауы, авторлары, жылы, DOI, басылымы және түйін сөздері.",
+        "template_help_undetermined": "Зерттеу дизайнын растағаннан кейін тиісті материал үлгісі көрсетіледі.",
+        "start_generation_unified": "🚀 Бастау",
         "api_key_missing": "❌ DEEPSEEK_API_KEY көрсетілмеген. API кілтін баптаңыз.",
         "resume_toast": "🔄 Бет жаңартылғаны немесе желі үзілісі анықталды. Үдеріс автоматты түрде қалпына келтірілуде…",
         "pipeline_start": "⏳ Жұмыс үдерісі басталуда…",
@@ -1080,5 +1204,53 @@ def get_asq_txt_template(language: str) -> str:
     return ASQ_TXT_TEMPLATES[normalize_language(language)]
 
 
+def get_research_material_template(language: str, method_family: str) -> dict[str, str]:
+    """Return the method-adaptive user template without changing engine policy."""
+    family = str(method_family or "").strip().casefold()
+    if family == "survey_path":
+        return {
+            "content": get_amj_csv_template(language),
+            "code_language": "csv",
+            "filename": "Survey_Path_Data_Template.csv",
+            "mime_type": "text/csv",
+        }
+    if family == "qualitative":
+        return {
+            "content": get_asq_txt_template(language),
+            "code_language": "text",
+            "filename": "Qualitative_Research_Materials_Template.txt",
+            "mime_type": "text/plain",
+        }
+    advanced = {
+        "fsqca": (
+            "case_id,condition_1,condition_2,condition_3,outcome\n"
+            "CASE001,0.85,0.20,0.70,0.90\n",
+            "fsQCA_Conditions_Outcome_Template.csv",
+        ),
+        "meta_analysis": (
+            "study_id,effect_size,standard_error,sample_size,moderator\n"
+            "STUDY001,0.25,0.08,240,context_A\n",
+            "Meta_Analysis_Effect_Size_Template.csv",
+        ),
+        "panel_econometrics": (
+            "entity_id,year,outcome,x1,x2,control_1\n"
+            "E001,2025,0.62,0.40,0.71,0.15\n",
+            "Panel_Entity_Time_Template.csv",
+        ),
+        "bibliometric_integrative_review": (
+            "title,authors,year,doi,venue,keywords\n"
+            "Real publication title,Author A; Author B,2025,10.xxxx/xxxxx,Journal Name,keyword1; keyword2\n",
+            "Bibliometric_Corpus_Metadata_Template.csv",
+        ),
+    }
+    content, filename = advanced.get(family, ("", "SmartPaper_Research_Materials_Template.txt"))
+    return {
+        "content": content,
+        "code_language": "csv" if content else "text",
+        "filename": filename,
+        "mime_type": "text/csv" if content else "text/plain",
+    }
+
+
 def get_reference_heading(language: str) -> str:
     return REFERENCE_HEADINGS[normalize_language(language)]

task_executor.py

@@ -29,6 +29,7 @@ import requests
 
 from config import APP_CONFIG
 from core.checkpoint_store import TaskCheckpointStore, checkpoint_authority_lock
+from core.advanced_method_registry import METHOD_FAMILIES, method_capability
 
 _log_handlers = [logging.StreamHandler(sys.stdout)]
 _executor_log_path = str(os.environ.get("SMARTPAPER_EXECUTOR_LOG_PATH") or "").strip()
@@ -415,6 +416,23 @@ def _snapshot_nullable_version(value):
     return text or None
 
 
+def _validate_request_method_family(request_data: dict, task: dict) -> None:
+    """Validate new U1-R2 method identity while preserving legacy requests."""
+    raw_family = str((request_data or {}).get("method_family") or "").strip().casefold()
+    if not raw_family:
+        return
+    if raw_family not in METHOD_FAMILIES:
+        raise RuntimeError("request_method_family_invalid")
+    capability = method_capability(raw_family)
+    expected_lane = str(capability.get("legacy_policy_lane") or "").strip().casefold()
+    request_lane = str((request_data or {}).get("derived_policy_lane") or "").strip().casefold()
+    task_lane = str((task or {}).get("mode") or "").strip().casefold()
+    if expected_lane not in {"amj", "asq"} or request_lane != expected_lane or task_lane != expected_lane:
+        raise RuntimeError("request_method_family_lane_mismatch")
+    if str(capability.get("capability_status") or "").strip().casefold() != "production_supported":
+        raise RuntimeError("request_method_family_capability_blocked")
+
+
 def _trusted_task_policy_snapshot_envelope(snapshot: dict, resolved: dict) -> dict:
     return {
         "task_id": str(snapshot.get("task_id") or ""),
@@ -455,11 +473,18 @@ def _validate_trusted_task_policy_snapshot(claim: dict, task: dict, request_data
     entitlement_class = str(snapshot.get("entitlement_class") or "").strip().upper()
     if tier not in {"STANDARD", "FLAGSHIP"}:
         raise RuntimeError("task_policy_snapshot_product_tier_invalid")
-    if entitlement_class not in {"STANDARD_TRIAL", "STANDARD_PAID", "FLAGSHIP_PAID"}:
+    trial = resolved.get("trial") if isinstance(resolved.get("trial"), dict) else None
+    billing = resolved.get("billing") if isinstance(resolved.get("billing"), dict) else None
+    allowed_entitlements = []
+    if trial and str(trial.get("entitlement_class") or "").strip():
+        allowed_entitlements.append(str(trial.get("entitlement_class") or "").strip().upper())
+    if billing and str(billing.get("entitlement_class") or "").strip():
+        paid_class = str(billing.get("entitlement_class") or "").strip().upper()
+        if paid_class not in allowed_entitlements:
+            allowed_entitlements.append(paid_class)
+    if not entitlement_class or entitlement_class not in allowed_entitlements:
         raise RuntimeError("task_policy_snapshot_entitlement_invalid")
-    if tier == "STANDARD" and entitlement_class == "FLAGSHIP_PAID":
-        raise RuntimeError("task_policy_snapshot_entitlement_mismatch")
-    if tier == "FLAGSHIP" and entitlement_class != "FLAGSHIP_PAID":
+    if any(not value.startswith(f"{tier}_") for value in allowed_entitlements):
         raise RuntimeError("task_policy_snapshot_entitlement_mismatch")
 
     if str(resolved.get("snapshot_schema_version") or "") != str(snapshot.get("snapshot_schema_version") or ""):
@@ -479,6 +504,7 @@ def _validate_trusted_task_policy_snapshot(claim: dict, task: dict, request_data
         if _snapshot_nullable_version(resolved.get(field)) != _snapshot_nullable_version(snapshot.get(field)):
             raise RuntimeError("task_policy_snapshot_policy_version_mismatch")
 
+    _validate_request_method_family(request_data, task)
     if str(resolved.get("manuscript_mode") or "").strip().lower() != str(task.get("mode") or "").strip().lower():
         raise RuntimeError("task_policy_snapshot_mode_mismatch")
     target_words = int(task.get("target_words") or 0)