P0-R5-R3-D single authority registry projection

app.py

@@ -34,8 +34,9 @@ from i18n import (
     get_target_flag, get_target_language, tr,
 )
 from core.advanced_method_registry import (
-    METHOD_FAMILIES, METHOD_RESOLVER_VERSION, method_capability,
-    resolve_generation_preflight,
+    METHOD_CAPABILITY_REGISTRY_VERSION, METHOD_FAMILIES, METHOD_RESOLVER_VERSION, default_method_family,
+    method_capability, method_family_for_legacy_lane, normalize_method_family,
+    reconcile_method_authority, resolve_generation_preflight,
 )
 from smartpaper_restore_bridge import edge_bridge
 
@@ -304,10 +305,10 @@ 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_method_selector": "qualitative",
-    "sp_method_selector_signature": "",
+    "sp_research_design_authority": "",
+    "sp_method_selector_ui": "",
+    "sp_research_design_ui_snapshot": "",
+    "sp_research_intent_snapshot": "",
     "sp_material_document_use": "reference",
 }.items():
     if key not in st.session_state:
@@ -464,7 +465,7 @@ def _task_method_family(task: dict) -> str:
             except Exception:
                 pass
     mode = _task_mode(task)
-    return "qualitative" if mode == "asq" else "survey_path"
+    return method_family_for_legacy_lane(mode) or default_method_family()
 
 
 def _task_output_path(task: dict) -> Path | None:
@@ -504,48 +505,89 @@ def _uploaded_material_descriptors() -> list[dict[str, str]]:
     return out
 
 
-def _method_intent_signature() -> str:
-    """Identity of the current paper intent for launch-time stale-state checks.
+def _normalized_research_intent_text(value: object) -> str:
+    """Normalize intent text so whitespace-only edits do not reset design."""
+    return re.sub(r"\s+", " ", str(value or "")).strip()
 
-    Title/Keywords remain part of the launch signature so a pending generation
-    cannot start against a different paper intent. Research Design reset itself
-    is event-driven by the Title/Keywords widgets rather than by every Streamlit
-    rerun; unrelated product-tier, word-count, and button reruns therefore never
-    change the selected design. Uploaded materials do not reset the selection.
-    """
+
+def _method_intent_signature() -> str:
+    """Stable Title/Keywords identity used by design reconciliation and launch."""
     payload = {
-        "research_design_control": "manual-default-qualitative-v3-event-reset",
-        "topic": str(st.session_state.get("sp_topic") or DEFAULT_TOPIC).strip(),
-        "keywords": str(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS).strip(),
+        "research_design_control": "single-authority-registry-projection-v1",
+        "topic": _normalized_research_intent_text(
+            st.session_state.get("sp_topic") or DEFAULT_TOPIC
+        ),
+        "keywords": _normalized_research_intent_text(
+            st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS
+        ),
     }
     return hashlib.sha256(
         json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
     ).hexdigest()
 
 
-def _reset_research_design_after_intent_edit() -> None:
-    """Reset a not-yet-started paper to the qualitative default after intent edit.
+def _reconcile_research_design_authority() -> tuple[str, str, dict]:
+    """Maintain one mutable new-task Research Design authority.
 
-    Streamlit invokes this callback only when the Title or Keywords widget
-    actually changes. It is intentionally not attached to product tier, target
-    words, research materials, or the Generate button.
+    The selector is only a UI projection. Explicit selector changes win over a
+    simultaneous Title/Keywords edit; otherwise a genuine intent edit resets to
+    the registry-configured default. Product tier, word count, language, upload,
+    payment, and Generate reruns do not participate in this reconciliation.
     """
-    st.session_state["sp_method_selector"] = "qualitative"
-    st.session_state["sp_method_confirmation"] = ""
-    st.session_state["sp_method_confirmation_signature"] = ""
-    st.session_state["sp_method_selector_signature"] = ""
-    st.session_state["sp_pending_launch"] = None
-    st.session_state["run_mode"] = "asq"
+    default_family = default_method_family()
+
+    authority = normalize_method_family(st.session_state.get("sp_research_design_authority"))
+    if not authority:
+        # One-time migration for live sessions created by the previous UI key.
+        authority = (
+            normalize_method_family(st.session_state.get("sp_method_selector"))
+            or default_family
+        )
+
+    current_ui = (
+        normalize_method_family(st.session_state.get("sp_method_selector_ui"))
+        or authority
+    )
+    previous_ui = (
+        normalize_method_family(st.session_state.get("sp_research_design_ui_snapshot"))
+        or authority
+    )
+    current_signature = _method_intent_signature()
+    previous_signature = str(st.session_state.get("sp_research_intent_snapshot") or "").strip()
+    if not previous_signature:
+        previous_signature = current_signature
+
+    reconciliation = reconcile_method_authority(
+        current_authority=authority,
+        current_ui_family=current_ui,
+        previous_ui_family=previous_ui,
+        current_intent_signature=current_signature,
+        previous_intent_signature=previous_signature,
+    )
+    resolved_family = normalize_method_family(
+        reconciliation.get("method_family"), fallback_to_default=True
+    )
+
+    if reconciliation.get("ui_changed") or reconciliation.get("intent_changed"):
+        # Any explicit design/intent change invalidates a not-yet-launched snapshot.
+        st.session_state["sp_pending_launch"] = None
+
+    st.session_state["sp_research_design_authority"] = resolved_family
+    st.session_state["sp_method_selector_ui"] = resolved_family
+    st.session_state["sp_research_design_ui_snapshot"] = resolved_family
+    st.session_state["sp_research_intent_snapshot"] = current_signature
+    return resolved_family, current_signature, reconciliation
 
 
 def _current_method_preflight(*, confirmed_method_family: str | None = None) -> tuple[dict, str]:
+    """Validate the current/frozen authority without re-selecting a design."""
     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()
+    confirmed = normalize_method_family(confirmed_method_family)
+    if not confirmed:
+        confirmed = normalize_method_family(
+            st.session_state.get("sp_research_design_authority"),
+            fallback_to_default=True,
+        )
     preflight = resolve_generation_preflight(
         str(st.session_state.get("sp_topic") or DEFAULT_TOPIC),
         str(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS),
@@ -554,7 +596,6 @@ def _current_method_preflight(*, confirmed_method_family: str | None = None) ->
     )
     return preflight, signature
 
-
 def _classify_and_save_research_materials(
     method_family: str, inputs_dir: Path
 ) -> tuple[list[str], list[str], list[str], str]:
@@ -580,22 +621,26 @@ def _classify_and_save_research_materials(
     if decision not in {"reference", "research"}:
         decision = "reference"
 
-    reference_items = []
-    data_items = list(structured)
-    interview_items = []
+    buckets = {"reference": [], "data": [], "interview": []}
+    capability = method_capability(method_family)
+    material_routing = dict(capability.get("material_routing") or {})
+
+    def _route(items: list, route_key: str) -> None:
+        bucket = str(material_routing.get(route_key) or "").strip().casefold()
+        if bucket not in buckets:
+            raise RuntimeError("method_material_routing_unsupported")
+        buckets[bucket].extend(items)
+
+    _route(structured, "structured")
+    _route(text_materials, "text")
+    _route(
+        documents,
+        "document_research" if decision == "research" else "document_reference",
+    )
 
-    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)
+    reference_items = buckets["reference"]
+    data_items = buckets["data"]
+    interview_items = buckets["interview"]
 
     refs = _save_uploaded(reference_items, inputs_dir, "ref")
     data = _save_uploaded(data_items[:1], inputs_dir, "data")
@@ -621,7 +666,7 @@ def _persist_task_request(
 
     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():
+    if not expected_lane or expected_lane != str(mode or "").strip().lower():
         raise RuntimeError("method_family_policy_lane_mismatch")
 
     refs, data, interviews, material_use_decision = _classify_and_save_research_materials(
@@ -801,19 +846,34 @@ def _process_pending_launch(lang_code: str) -> None:
     idempotency_key = str(pending.get("idempotency_key") or "").strip()
     pending_signature = str(pending.get("method_intent_signature") or "").strip()
 
-    # Repeat the capability preflight immediately before any task/quota
-    # creation so a stale rerun or modified session state cannot bypass the
-    # manually selected/default research design.
+    # Validate the frozen launch snapshot. This gate may reject stale state, but
+    # it must never choose or rewrite Research Design after the user clicks Generate.
+    current_authority = normalize_method_family(
+        st.session_state.get("sp_research_design_authority")
+    )
     preflight, current_signature = _current_method_preflight(
-        confirmed_method_family=pending_family or None
+        confirmed_method_family=pending_family
     )
     resolved_family = str(preflight.get("method_family") or "").strip().casefold()
     resolved_mode = str(preflight.get("legacy_policy_lane") or "").strip().lower()
+    capability = dict(preflight.get("capability") or {})
+    projection_matches = all([
+        str(pending.get("capability_registry_version") or "").strip()
+            == str(capability.get("registry_version") or "").strip(),
+        str(pending.get("engine_family") or "").strip()
+            == str(capability.get("engine_family") or "").strip(),
+        str(pending.get("template_profile") or "").strip()
+            == str(capability.get("template_profile") or "").strip(),
+        str(pending.get("material_profile") or "").strip()
+            == str(capability.get("material_profile") or "").strip(),
+    ])
     if (
         not bool(preflight.get("can_start_generation"))
         or not pending_family
+        or pending_family != current_authority
         or pending_family != resolved_family
         or pending_mode != resolved_mode
+        or not projection_matches
         or not pending_signature
         or pending_signature != current_signature
     ):
@@ -1499,14 +1559,12 @@ def render_workspace_controls(user):
         value=DEFAULT_TOPIC,
         disabled=active,
         key="sp_topic",
-        on_change=_reset_research_design_after_intent_edit,
     )
     st.text_input(
         tr(lang_code, "keywords_label"),
         value=DEFAULT_KEYWORDS,
         disabled=active,
         key="sp_keywords",
-        on_change=_reset_research_design_after_intent_edit,
     )
 
     # U1-R2 unified research workspace: academic intent/materials first, then
@@ -1547,32 +1605,21 @@ def render_workspace_controls(user):
         }
         method_signature = ""
     else:
-        # SmartPaper intentionally supports only two reader-visible research
-        # designs. New tasks default to qualitative research. Title/Keywords
-        # changes reset the selector through their explicit on_change callback;
-        # unrelated Streamlit reruns must preserve the user's manual selection.
-        method_signature = _method_intent_signature()
-        selected_default = str(
-            st.session_state.get("sp_method_selector") or "qualitative"
-        ).strip().casefold()
-        if selected_default not in METHOD_FAMILIES:
-            selected_default = "qualitative"
-            st.session_state["sp_method_selector"] = selected_default
-
-        selected = st.selectbox(
+        # One business authority owns the new-task research design. The widget is
+        # only a UI projection; workflow/engine/template come from the registry.
+        authority_family, method_signature, _reconciliation = (
+            _reconcile_research_design_authority()
+        )
+        st.selectbox(
             tr(lang_code, "detected_method_label"),
             list(METHOD_FAMILIES),
-            index=list(METHOD_FAMILIES).index(selected_default),
             format_func=lambda family: tr(lang_code, f"method_{family}"),
-            key="sp_method_selector",
+            key="sp_method_selector_ui",
             disabled=active,
         )
-        selected = str(selected or "qualitative").strip().casefold()
-        if selected not in METHOD_FAMILIES:
-            selected = "qualitative"
-        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)
+        preflight, method_signature = _current_method_preflight(
+            confirmed_method_family=authority_family
+        )
 
     method_family = str(preflight.get("method_family") or "undetermined").strip().casefold()
     method_label = (
@@ -1593,7 +1640,9 @@ def render_workspace_controls(user):
     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)
+            capability = dict(preflight.get("capability") or method_capability(method_family))
+            template_profile = str(capability.get("template_profile") or "").strip()
+            template_info = get_research_material_template(lang_code, template_profile)
             template_data = str(template_info.get("content") or "")
             if template_data:
                 st.code(template_data, language=str(template_info.get("code_language") or "text"))
@@ -1604,6 +1653,8 @@ def render_workspace_controls(user):
                     mime=str(template_info.get("mime_type") or "text/plain"),
                     use_container_width=True,
                 )
+            else:
+                st.warning(tr(lang_code, "method_resolution_invalid"))
         else:
             st.markdown(tr(lang_code, "template_help_undetermined"))
 
@@ -1690,25 +1741,37 @@ def render_workspace_controls(user):
             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.
+            # Freeze the already-reconciled authority. This is validation only;
+            # Generate must never infer or reset Research Design.
+            launch_family = normalize_method_family(
+                st.session_state.get("sp_research_design_authority")
+            )
             click_preflight, click_signature = _current_method_preflight(
-                confirmed_method_family=method_family if method_family in METHOD_FAMILIES else None
+                confirmed_method_family=launch_family
             )
-            if not bool(click_preflight.get("can_start_generation")):
-                reason = str(click_preflight.get("block_reason") or "")
+            if (
+                not launch_family
+                or not bool(click_preflight.get("can_start_generation"))
+                or str(click_preflight.get("method_family") or "").strip().casefold() != launch_family
+            ):
                 st.warning(tr(lang_code, "method_resolution_invalid"))
             else:
-                resolved_family = str(click_preflight.get("method_family") or "").strip().casefold()
                 resolved_mode = str(click_preflight.get("legacy_policy_lane") or "").strip().lower()
+                capability = dict(click_preflight.get("capability") or {})
                 st.session_state["run_mode"] = resolved_mode
                 st.session_state["sp_pending_launch"] = {
                     "mode": resolved_mode,
-                    "method_family": resolved_family,
+                    "method_family": launch_family,
                     "method_resolver_version": str(
                         (click_preflight.get("resolution") or {}).get("resolver_version")
                         or METHOD_RESOLVER_VERSION
                     ),
+                    "capability_registry_version": str(
+                        capability.get("registry_version") or METHOD_CAPABILITY_REGISTRY_VERSION
+                    ),
+                    "engine_family": str(capability.get("engine_family") or ""),
+                    "template_profile": str(capability.get("template_profile") or ""),
+                    "material_profile": str(capability.get("material_profile") or ""),
                     "method_intent_signature": click_signature,
                     "idempotency_key": _new_generation_idempotency_key(),
                 }

core/advanced_method_registry.py

@@ -4,8 +4,8 @@
 Production research design is intentionally limited to two supported paths:
 qualitative research and survey-based quantitative research. New tasks default to
 qualitative research, and the user may explicitly adjust the design before task
-creation. Title, Keywords, and uploaded Research Materials never auto-select or
-change the research design.
+creation. Title/Keywords edits may reset an unlaunched design to the configured
+default through deterministic reconciliation; materials never select a design.
 
 This module never selects providers/models and never rewrites Title/Keywords.
 """
@@ -15,8 +15,9 @@ import os
 import re
 from typing import Any, Iterable
 
-METHOD_RESOLVER_VERSION = "smartpaper-manual-method-selector-v1"
-METHOD_CAPABILITY_REGISTRY_VERSION = "smartpaper-method-capability-registry-v3"
+METHOD_RESOLVER_VERSION = "smartpaper-manual-method-selector-v2-single-authority"
+METHOD_CAPABILITY_REGISTRY_VERSION = "smartpaper-method-capability-registry-v4"
+DEFAULT_METHOD_FAMILY = "qualitative"
 
 # Reader-visible / task-owning method families.  Order is intentional:
 # qualitative is the product default and appears first in the selector.
@@ -31,12 +32,28 @@ _METHOD_CAPABILITIES: dict[str, dict[str, Any]] = {
         "capability_status": "production_supported",
         "evidence_timing": "pre_literature",
         "engine_family": "qualitative_engine",
+        "template_profile": "qualitative_materials",
+        "material_profile": "qualitative_materials",
+        "material_routing": {
+            "structured": "data",
+            "text": "interview",
+            "document_reference": "reference",
+            "document_research": "interview",
+        },
     },
     "survey_path": {
         "legacy_policy_lane": "amj",
         "capability_status": "production_supported",
         "evidence_timing": "pre_literature",
         "engine_family": "quantitative_engine",
+        "template_profile": "survey_quantitative_data",
+        "material_profile": "survey_quantitative_data",
+        "material_routing": {
+            "structured": "data",
+            "text": "reference",
+            "document_reference": "reference",
+            "document_research": "reference",
+        },
     },
 }
 
@@ -139,6 +156,74 @@ def _material_descriptors(materials: Iterable[Any] | None) -> list[dict[str, str
     return out
 
 
+def default_method_family() -> str:
+    """Return the single configured default research-design family."""
+    if DEFAULT_METHOD_FAMILY not in METHOD_FAMILIES:
+        raise RuntimeError("default_method_family_not_registered")
+    return DEFAULT_METHOD_FAMILY
+
+
+def normalize_method_family(value: Any, *, fallback_to_default: bool = False) -> str:
+    """Normalize a reader-visible method family without inventing new values."""
+    family = str(value or "").strip().casefold()
+    if family in METHOD_FAMILIES:
+        return family
+    return default_method_family() if fallback_to_default else ""
+
+
+def method_family_for_legacy_lane(selected_lane: Any) -> str:
+    """Project a legacy AMJ/ASQ lane back to its registered method family."""
+    lane = str(selected_lane or "").strip().casefold()
+    matches = [
+        family for family in METHOD_FAMILIES
+        if str((_METHOD_CAPABILITIES.get(family) or {}).get("legacy_policy_lane") or "").strip().casefold() == lane
+    ]
+    return matches[0] if len(matches) == 1 else ""
+
+
+def reconcile_method_authority(
+    *,
+    current_authority: Any,
+    current_ui_family: Any,
+    previous_ui_family: Any,
+    current_intent_signature: Any,
+    previous_intent_signature: Any,
+) -> dict[str, Any]:
+    """Deterministically reconcile the one mutable new-task design authority.
+
+    Explicit Research Design changes win over a simultaneous Title/Keywords
+    change. Otherwise, a genuine intent change resets to the configured default.
+    Unrelated reruns preserve the existing authority.
+    """
+    default_family = default_method_family()
+    authority = normalize_method_family(current_authority) or default_family
+    current_ui = normalize_method_family(current_ui_family) or authority
+    previous_ui = normalize_method_family(previous_ui_family) or current_ui
+    current_sig = str(current_intent_signature or "").strip()
+    previous_sig = str(previous_intent_signature or "").strip()
+
+    ui_changed = current_ui != previous_ui
+    intent_changed = bool(previous_sig) and current_sig != previous_sig
+
+    if ui_changed:
+        chosen = current_ui
+        reason = "user_selected_method_family"
+    elif intent_changed:
+        chosen = default_family
+        reason = "intent_changed_reset_to_default"
+    else:
+        chosen = authority
+        reason = "preserve_existing_authority"
+
+    return {
+        "method_family": chosen,
+        "reason": reason,
+        "ui_changed": ui_changed,
+        "intent_changed": intent_changed,
+        "default_method_family": default_family,
+    }
+
+
 def method_capability(method_family: str) -> dict[str, Any]:
     """Return a copy of versioned capability metadata for one supported family."""
     family = str(method_family or "").strip().casefold()
@@ -151,6 +236,9 @@ def method_capability(method_family: str) -> dict[str, Any]:
             "capability_status": "ambiguous",
             "evidence_timing": "undetermined",
             "engine_family": "undetermined",
+            "template_profile": None,
+            "material_profile": None,
+            "material_routing": {},
         }
     row.update({
         "registry_version": METHOD_CAPABILITY_REGISTRY_VERSION,
@@ -183,13 +271,14 @@ def resolve_method_family(
     """
     _ = title, keywords
     descriptors = _material_descriptors(materials)
-    capability = method_capability("qualitative")
+    family = default_method_family()
+    capability = method_capability(family)
     return {
         "resolver_version": METHOD_RESOLVER_VERSION,
         "shadow_only": False,
-        "method_family": "qualitative",
-        "confidence": "DEFAULT_QUALITATIVE",
-        "reason_codes": ["manual_design_control", "default_qualitative"],
+        "method_family": family,
+        "confidence": "DEFAULT_CONFIGURED",
+        "reason_codes": ["manual_design_control", "default_method_family"],
         "title_keyword_hits": [],
         "specialized_method_detected": False,
         "specialized_method_families": [],
@@ -221,14 +310,14 @@ def resolve_generation_preflight(
 ) -> dict[str, Any]:
     """Resolve the two supported designs before any task/quota creation.
 
-    The default is qualitative research. If the user explicitly selects one of
-    the two supported production designs, that selection is authoritative.
-    Title, Keywords, and Research Materials never alter the chosen design.
+    The configured default is used unless a supported method family is supplied
+    by the single UI authority. This function validates/projections capability;
+    it does not infer a design from Title, Keywords, or Research Materials.
     """
     resolution = resolve_method_family(title, keywords, materials=materials)
-    family = "qualitative"
+    family = default_method_family()
 
-    confirmed = str(confirmed_method_family or "").strip().casefold()
+    confirmed = normalize_method_family(confirmed_method_family)
     if confirmed in METHOD_FAMILIES:
         family = confirmed
         capability = method_capability(family)
@@ -244,12 +333,27 @@ def resolve_generation_preflight(
     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 or status != "production_supported":
+    engine_family = str(capability.get("engine_family") or "").strip()
+    template_profile = str(capability.get("template_profile") or "").strip()
+    material_profile = str(capability.get("material_profile") or "").strip()
+    material_routing = dict(capability.get("material_routing") or {})
+    routing_keys = {"structured", "text", "document_reference", "document_research"}
+    routing_values = {str(value or "").strip() for value in material_routing.values()}
+    if (
+        family not in METHOD_FAMILIES
+        or not lane
+        or status != "production_supported"
+        or not engine_family
+        or not template_profile
+        or not material_profile
+        or set(material_routing) != routing_keys
+        or not routing_values.issubset({"reference", "data", "interview"})
+    ):
         return {
             "can_start_generation": False,
             "block_reason": "method_resolution_invalid",
             "resolution": resolution,
-            "method_family": family or "qualitative",
+            "method_family": family or default_method_family(),
             "legacy_policy_lane": None,
             "capability": capability,
         }

i18n.py

@@ -1228,20 +1228,31 @@ 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 a template for one of the two supported production designs."""
-    family = str(method_family or "").strip().casefold()
-    if family == "survey_path":
+def get_research_material_template(language: str, template_profile: str) -> dict[str, str]:
+    """Return a strict template projection for a registered capability profile.
+
+    Unknown profiles return an empty projection rather than silently falling back
+    to qualitative research. The method registry owns method→profile mapping.
+    """
+    profile = str(template_profile or "").strip().casefold()
+    if profile == "survey_quantitative_data":
         return {
             "content": get_amj_csv_template(language),
             "code_language": "csv",
             "filename": "Survey_Path_Data_Template.csv",
             "mime_type": "text/csv",
         }
+    if profile == "qualitative_materials":
+        return {
+            "content": get_asq_txt_template(language),
+            "code_language": "text",
+            "filename": "Qualitative_Research_Materials_Template.txt",
+            "mime_type": "text/plain",
+        }
     return {
-        "content": get_asq_txt_template(language),
+        "content": "",
         "code_language": "text",
-        "filename": "Qualitative_Research_Materials_Template.txt",
+        "filename": "",
         "mime_type": "text/plain",
     }