feat: SPEC_10 - Domain-Agnostic Refactor + License Fix (#87)

* feat: implement SPEC_10 domain-agnostic refactor

* fix: complete SPEC_10 audit - license + HierarchicalOrchestrator domain

License Fixes:
- LICENSE: Fix copyright "Antibody Training Pipeline ESM" → "DeepBoner Contributors"
- pyproject.toml: Add missing license = "Apache-2.0" field
- README.md: Fix frontmatter license: mit → apache-2.0

Domain Threading Fixes:
- hierarchical.py: Add domain param to __init__ and pass to ResearchTeam
- factory.py: Pass domain to HierarchicalOrchestrator

All 237 tests pass. Domain now properly threaded through all orchestrators.

* test: enhance domain handling in orchestrators and judges

- Updated unit tests for `configure_orchestrator` to include mock mode and free tier scenarios, ensuring the domain is correctly passed to handlers.
- Refactored tests for `JudgeHandler` to mock model retrieval, allowing for domain acceptance without API key requirements.
- Improved `AdvancedOrchestrator` tests to mock API key validation and ensure domain handling is consistent across orchestrators.

All tests pass successfully, reinforcing domain threading in the application.

* fix: CodeRabbit review - trailing comma bug + missing assertion

CRITICAL:
- src/app.py:148: Remove trailing comma that made has_anthropic a tuple
instead of boolean, breaking free tier detection

Minor:
- test_magentic_agents_domain.py: Add assertion to verify domain-specific
judge system prompt is passed through

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 DeepBoner Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -8,7 +8,7 @@ sdk_version: "6.0.1"
 python_version: "3.11"
 app_file: src/app.py
 pinned: true
-license: mit
+license: apache-2.0
 short_description: "Deep Research Agent for the Strongest Boners 💪🔬"
 tags:
   - mcp-in-action-track-enterprise

pyproject.toml

@@ -3,6 +3,7 @@ name = "deepboner"
 version = "0.1.0"
 description = "AI-Native Sexual Health Research Agent"
 readme = "README.md"
+license = "Apache-2.0"
 requires-python = ">=3.11"
 dependencies = [
     # Core

src/agent_factory/judges.py

@@ -15,10 +15,11 @@ from pydantic_ai.providers.huggingface import HuggingFaceProvider
 from pydantic_ai.providers.openai import OpenAIProvider
 from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential
 
+from src.config.domain import ResearchDomain
 from src.prompts.judge import (
-    SYSTEM_PROMPT,
     format_empty_evidence_prompt,
     format_user_prompt,
+    get_system_prompt,
     select_evidence_for_judge,
 )
 from src.utils.config import settings
@@ -84,18 +85,24 @@ class JudgeHandler:
     Uses PydanticAI to ensure responses match the JudgeAssessment schema.
     """
 
-    def __init__(self, model: Any = None) -> None:
+    def __init__(
+        self,
+        model: Any = None,
+        domain: ResearchDomain | str | None = None,
+    ) -> None:
         """
         Initialize the JudgeHandler.
 
         Args:
             model: Optional PydanticAI model. If None, uses config default.
+            domain: Research domain for prompt customization.
         """
         self.model = model or get_model()
+        self.domain = domain
         self.agent = Agent(
             model=self.model,
             output_type=JudgeAssessment,
-            system_prompt=SYSTEM_PROMPT,
+            system_prompt=get_system_prompt(domain),
             retries=3,
         )
 
@@ -126,6 +133,7 @@ class JudgeHandler:
             question=question[:100],
             evidence_count=len(evidence),
             iteration=iteration,
+            domain=self.domain,
         )
 
         # Format the prompt based on whether we have evidence
@@ -138,6 +146,7 @@ class JudgeHandler:
                 iteration,
                 max_iterations,
                 total_evidence_count=len(evidence),
+                domain=self.domain,
             )
         else:
             user_prompt = format_empty_evidence_prompt(question)
@@ -213,14 +222,20 @@ class HFInferenceJudgeHandler:
     # Rationale: 3 models x 3 retries each = 9 total API attempts before circuit break
     MAX_CONSECUTIVE_FAILURES: ClassVar[int] = 3
 
-    def __init__(self, model_id: str | None = None) -> None:
+    def __init__(
+        self,
+        model_id: str | None = None,
+        domain: ResearchDomain | str | None = None,
+    ) -> None:
         """
         Initialize with HF Inference client.
 
         Args:
             model_id: Optional specific model ID. If None, uses FALLBACK_MODELS chain.
+            domain: Research domain for prompt customization.
         """
         self.model_id = model_id
+        self.domain = domain
         # Will automatically use HF_TOKEN from env if available
         self.client = InferenceClient()
         self.call_count = 0
@@ -269,6 +284,7 @@ class HFInferenceJudgeHandler:
                 iteration,
                 max_iterations,
                 total_evidence_count=len(evidence),
+                domain=self.domain,
             )
         else:
             user_prompt = format_empty_evidence_prompt(question)
@@ -314,12 +330,13 @@ class HFInferenceJudgeHandler:
     async def _call_with_retry(self, model: str, prompt: str, question: str) -> JudgeAssessment:
         """Make API call with retry logic using chat_completion."""
         loop = asyncio.get_running_loop()
+        system_prompt = get_system_prompt(self.domain)
 
         # Build messages for chat_completion (model-agnostic)
         messages = [
             {
                 "role": "system",
-                "content": f"""{SYSTEM_PROMPT}
+                "content": f"""{system_prompt}
 
 IMPORTANT: Respond with ONLY valid JSON matching this schema:
 {{
@@ -420,7 +437,9 @@ IMPORTANT: Respond with ONLY valid JSON matching this schema:
         return None
 
     def _create_quota_exhausted_assessment(
-        self, question: str, evidence: list[Evidence]
+        self,
+        question: str,
+        evidence: list[Evidence],
     ) -> JudgeAssessment:
         """Create an assessment that stops the loop when quota is exhausted."""
         findings = _extract_titles_from_evidence(
@@ -455,7 +474,9 @@ IMPORTANT: Respond with ONLY valid JSON matching this schema:
         )
 
     def _create_forced_synthesis_assessment(
-        self, question: str, evidence: list[Evidence]
+        self,
+        question: str,
+        evidence: list[Evidence],
     ) -> JudgeAssessment:
         """Force synthesis after repeated failures to prevent infinite loops."""
         findings = _extract_titles_from_evidence(
@@ -524,14 +545,20 @@ class MockJudgeHandler:
     to provide a useful demo experience without requiring API keys.
     """
 
-    def __init__(self, mock_response: JudgeAssessment | None = None) -> None:
+    def __init__(
+        self,
+        mock_response: JudgeAssessment | None = None,
+        domain: ResearchDomain | str | None = None,
+    ) -> None:
         """
         Initialize with optional mock response.
 
         Args:
             mock_response: The assessment to return. If None, extracts from evidence.
+            domain: Research domain (ignored in mock but kept for interface compatibility).
         """
         self.mock_response = mock_response
+        self.domain = domain
         self.call_count = 0
         self.last_question: str | None = None
         self.last_evidence: list[Evidence] | None = None

src/agents/magentic_agents.py

@@ -9,14 +9,19 @@ from src.agents.tools import (
     search_preprints,
     search_pubmed,
 )
+from src.config.domain import ResearchDomain, get_domain_config
 from src.utils.config import settings
 
 
-def create_search_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+def create_search_agent(
+    chat_client: OpenAIChatClient | None = None,
+    domain: ResearchDomain | str | None = None,
+) -> ChatAgent:
     """Create a search agent with internal LLM and search tools.
 
     Args:
         chat_client: Optional custom chat client. If None, uses default.
+        domain: Research domain for customization.
 
     Returns:
         ChatAgent configured for biomedical search
@@ -25,14 +30,12 @@ def create_search_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgen
         model_id=settings.openai_model,  # Use configured model
         api_key=settings.openai_api_key,
     )
+    config = get_domain_config(domain)
 
     return ChatAgent(
         name="SearchAgent",
-        description=(
-            "Searches biomedical databases (PubMed, ClinicalTrials.gov, Europe PMC) "
-            "for drug repurposing evidence"
-        ),
-        instructions="""You are a biomedical search specialist. When asked to find evidence:
+        description=config.search_agent_description,
+        instructions=f"""You are a biomedical search specialist. When asked to find evidence:
 
 1. Analyze the request to determine what to search for
 2. Extract key search terms (drug names, disease names, mechanisms)
@@ -43,18 +46,23 @@ def create_search_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgen
 4. Summarize what you found and highlight key evidence
 
 Be thorough - search multiple databases when appropriate.
-Focus on finding: mechanisms of action, clinical evidence, and specific drug candidates.""",
+Focus on finding: mechanisms of action, clinical evidence, and specific findings
+related to {config.name}.""",
         chat_client=client,
         tools=[search_pubmed, search_clinical_trials, search_preprints],
         temperature=1.0,  # Explicitly set for reasoning model compatibility (o1/o3)
     )
 
 
-def create_judge_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+def create_judge_agent(
+    chat_client: OpenAIChatClient | None = None,
+    domain: ResearchDomain | str | None = None,
+) -> ChatAgent:
     """Create a judge agent that evaluates evidence quality.
 
     Args:
         chat_client: Optional custom chat client. If None, uses default.
+        domain: Research domain for customization.
 
     Returns:
         ChatAgent configured for evidence assessment
@@ -63,11 +71,14 @@ def create_judge_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent
         model_id=settings.openai_model,
         api_key=settings.openai_api_key,
     )
+    config = get_domain_config(domain)
 
     return ChatAgent(
         name="JudgeAgent",
         description="Evaluates evidence quality and determines if sufficient for synthesis",
-        instructions="""You are an evidence quality assessor. When asked to evaluate:
+        instructions=f"""{config.judge_system_prompt}
+
+When asked to evaluate:
 
 1. Review all evidence presented in the conversation
 2. Score on two dimensions (0-10 each):
@@ -89,11 +100,15 @@ Be rigorous but fair. Look for:
     )
 
 
-def create_hypothesis_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+def create_hypothesis_agent(
+    chat_client: OpenAIChatClient | None = None,
+    domain: ResearchDomain | str | None = None,
+) -> ChatAgent:
     """Create a hypothesis generation agent.
 
     Args:
         chat_client: Optional custom chat client. If None, uses default.
+        domain: Research domain for customization.
 
     Returns:
         ChatAgent configured for hypothesis generation
@@ -102,11 +117,14 @@ def create_hypothesis_agent(chat_client: OpenAIChatClient | None = None) -> Chat
         model_id=settings.openai_model,
         api_key=settings.openai_api_key,
     )
+    config = get_domain_config(domain)
 
     return ChatAgent(
         name="HypothesisAgent",
-        description="Generates mechanistic hypotheses for drug repurposing",
-        instructions="""You are a biomedical hypothesis generator. Based on evidence:
+        description=config.hypothesis_agent_description,
+        instructions=f"""{config.hypothesis_system_prompt}
+
+Based on evidence:
 
 1. Identify the key molecular targets involved
 2. Map the biological pathways affected
@@ -126,11 +144,15 @@ Focus on mechanistic plausibility and existing evidence.""",
     )
 
 
-def create_report_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgent:
+def create_report_agent(
+    chat_client: OpenAIChatClient | None = None,
+    domain: ResearchDomain | str | None = None,
+) -> ChatAgent:
     """Create a report synthesis agent.
 
     Args:
         chat_client: Optional custom chat client. If None, uses default.
+        domain: Research domain for customization.
 
     Returns:
         ChatAgent configured for report generation
@@ -139,11 +161,14 @@ def create_report_agent(chat_client: OpenAIChatClient | None = None) -> ChatAgen
         model_id=settings.openai_model,
         api_key=settings.openai_api_key,
     )
+    config = get_domain_config(domain)
 
     return ChatAgent(
         name="ReportAgent",
         description="Synthesizes research findings into structured reports",
-        instructions="""You are a scientific report writer. When asked to synthesize:
+        instructions=f"""{config.report_system_prompt}
+
+When asked to synthesize:
 
 Generate a structured report with these sections:
 
@@ -164,8 +189,8 @@ Databases searched, queries used, evidence reviewed
 - Clinical trials
 - Safety profile
 
-## Drug Candidates
-List specific drugs with repurposing potential
+## Candidates
+List specific candidates with potential
 
 ## Limitations
 Gaps in evidence, conflicting data, caveats

src/agents/search_agent.py

@@ -10,6 +10,7 @@ from agent_framework import (
     Role,
 )
 
+from src.config.domain import ResearchDomain, get_domain_config
 from src.orchestrators import SearchHandlerProtocol
 from src.utils.models import Citation, Evidence, SearchResult
 
@@ -25,10 +26,12 @@ class SearchAgent(BaseAgent):  # type: ignore[misc]
         search_handler: SearchHandlerProtocol,
         evidence_store: dict[str, list[Evidence]],
         embedding_service: "EmbeddingService | None" = None,
+        domain: ResearchDomain | str | None = None,
     ) -> None:
+        config = get_domain_config(domain)
         super().__init__(
             name="SearchAgent",
-            description="Searches PubMed for drug repurposing evidence",
+            description=config.search_agent_description,
         )
         self._handler = search_handler
         self._evidence_store = evidence_store

src/agents/tools.py

@@ -17,7 +17,7 @@ _clinicaltrials = ClinicalTrialsTool()
 _europepmc = EuropePMCTool()
 
 
-@ai_function  # type: ignore[arg-type, misc]
+@ai_function  # type: ignore[arg-type, misc, untyped-decorator]
 async def search_pubmed(query: str, max_results: int = 10) -> str:
     """Search PubMed for biomedical research papers.
 
@@ -77,12 +77,12 @@ async def search_pubmed(query: str, max_results: int = 10) -> str:
     return "\n".join(output)
 
 
-@ai_function  # type: ignore[arg-type, misc]
+@ai_function  # type: ignore[arg-type, misc, untyped-decorator]
 async def search_clinical_trials(query: str, max_results: int = 10) -> str:
     """Search ClinicalTrials.gov for clinical studies.
 
     Use this tool to find ongoing and completed clinical trials
-    for drug repurposing candidates.
+    for potential interventions.
 
     Args:
         query: Search terms (e.g., "metformin cancer phase 3")
@@ -117,7 +117,7 @@ async def search_clinical_trials(query: str, max_results: int = 10) -> str:
     return "\n".join(output)
 
 
-@ai_function  # type: ignore[arg-type, misc]
+@ai_function  # type: ignore[arg-type, misc, untyped-decorator]
 async def search_preprints(query: str, max_results: int = 10) -> str:
     """Search Europe PMC for preprints and papers.
 
@@ -157,7 +157,7 @@ async def search_preprints(query: str, max_results: int = 10) -> str:
     return "\n".join(output)
 
 
-@ai_function  # type: ignore[arg-type, misc]
+@ai_function  # type: ignore[arg-type, misc, untyped-decorator]
 async def get_bibliography() -> str:
     """Get the full list of collected evidence for the bibliography.
 

src/app.py

@@ -1,4 +1,4 @@
-"""Gradio UI for DeepBoner agent with MCP server support."""
+"Gradio UI for DeepBoner agent with MCP server support."
 
 import os
 from collections.abc import AsyncGenerator
@@ -11,6 +11,7 @@ from pydantic_ai.providers.anthropic import AnthropicProvider
 from pydantic_ai.providers.openai import OpenAIProvider
 
 from src.agent_factory.judges import HFInferenceJudgeHandler, JudgeHandler, MockJudgeHandler
+from src.config.domain import ResearchDomain
 from src.orchestrators import create_orchestrator
 from src.tools.clinicaltrials import ClinicalTrialsTool
 from src.tools.europepmc import EuropePMCTool
@@ -26,6 +27,7 @@ def configure_orchestrator(
     use_mock: bool = False,
     mode: str = "simple",
     user_api_key: str | None = None,
+    domain: str | ResearchDomain | None = None,
 ) -> tuple[Any, str]:
     """
     Create an orchestrator instance.
@@ -34,6 +36,7 @@ def configure_orchestrator(
         use_mock: If True, use MockJudgeHandler (no API key needed)
         mode: Orchestrator mode ("simple" or "advanced")
         user_api_key: Optional user-provided API key (BYOK) - auto-detects provider
+        domain: Research domain (e.g., "general", "sexual_health")
 
     Returns:
         Tuple of (Orchestrator instance, backend_name)
@@ -56,7 +59,7 @@ def configure_orchestrator(
 
     # 1. Forced Mock (Unit Testing)
     if use_mock:
-        judge_handler = MockJudgeHandler()
+        judge_handler = MockJudgeHandler(domain=domain)
         backend_info = "Mock (Testing)"
 
     # 2. Paid API Key (User provided or Env)
@@ -77,20 +80,20 @@ def configure_orchestrator(
             raise ConfigurationError(
                 "Invalid API key format. Expected sk-... (OpenAI) or sk-ant-... (Anthropic)"
             )
-        judge_handler = JudgeHandler(model=model)
+        judge_handler = JudgeHandler(model=model, domain=domain)
 
     # 3. Environment API Keys (fallback)
     elif os.getenv("OPENAI_API_KEY"):
-        judge_handler = JudgeHandler(model=None)  # Uses env key
+        judge_handler = JudgeHandler(model=None, domain=domain)  # Uses env key
         backend_info = "Paid API (OpenAI from env)"
 
     elif os.getenv("ANTHROPIC_API_KEY"):
-        judge_handler = JudgeHandler(model=None)  # Uses env key
+        judge_handler = JudgeHandler(model=None, domain=domain)  # Uses env key
         backend_info = "Paid API (Anthropic from env)"
 
     # 4. Free Tier (HuggingFace Inference)
     else:
-        judge_handler = HFInferenceJudgeHandler()
+        judge_handler = HFInferenceJudgeHandler(domain=domain)
         backend_info = "Free Tier (Llama 3.1 / Mistral)"
 
     orchestrator = create_orchestrator(
@@ -99,6 +102,7 @@ def configure_orchestrator(
         config=config,
         mode=mode,  # type: ignore
         api_key=user_api_key,
+        domain=domain,
     )
 
     return orchestrator, backend_info
@@ -108,6 +112,7 @@ async def research_agent(
     message: str,
     history: list[dict[str, Any]],
     mode: str = "simple",
+    domain: str = "general",
     api_key: str = "",
     api_key_state: str = "",
 ) -> AsyncGenerator[str, None]:
@@ -118,6 +123,7 @@ async def research_agent(
         message: User's research question
         history: Chat history (Gradio format)
         mode: Orchestrator mode ("simple" or "advanced")
+        domain: Research domain
         api_key: Optional user-provided API key (BYOK - auto-detects provider)
         api_key_state: Persistent API key state (survives example clicks)
 
@@ -132,6 +138,7 @@ async def research_agent(
     # Gradio passes None for missing example columns, overriding defaults
     api_key_str = api_key or ""
     api_key_state_str = api_key_state or ""
+    domain_str = domain or "general"
 
     # BUG FIX: Prefer freshly-entered key, then persisted state
     user_api_key = (api_key_str.strip() or api_key_state_str.strip()) or None
@@ -172,11 +179,12 @@ async def research_agent(
             use_mock=False,  # Never use mock in production - HF Inference is the free fallback
             mode=mode,
             user_api_key=user_api_key,
+            domain=domain_str,
         )
 
         # Immediate backend info + loading feedback so user knows something is happening
         yield (
-            f"🧠 **Backend**: {backend_name}\n\n"
+            f"🧠 **Backend**: {backend_name} | **Domain**: {domain_str.title()}\n\n"
             "⏳ **Processing...** Searching PubMed, ClinicalTrials.gov, Europe PMC, OpenAlex...\n"
         )
 
@@ -231,34 +239,39 @@ def create_demo() -> tuple[gr.ChatInterface, gr.Accordion]:
     api_key_state = gr.State("")
 
     # 1. Unwrapped ChatInterface (Fixes Accordion Bug)
+    description = (
+        "*AI-Powered Research Agent — searches PubMed, "
+        "ClinicalTrials.gov, Europe PMC & OpenAlex*\n\n"
+        "Deep research for sexual wellness, ED treatments, hormone therapy, "
+        "libido, and reproductive health - for all genders.\n\n"
+        "---\n"
+        "*Research tool only — not for medical advice.*  \n"
+        "**MCP Server Active**: Connect Claude Desktop to `/gradio_api/mcp/`"
+    )
+
     demo = gr.ChatInterface(
         fn=research_agent,
         title="🍆 DeepBoner",
-        description=(
-            "*AI-Powered Sexual Health Research Agent — searches PubMed, "
-            "ClinicalTrials.gov, Europe PMC & OpenAlex*\n\n"
-            "Deep research for sexual wellness, ED treatments, hormone therapy, "
-            "libido, and reproductive health - for all genders.\n\n"
-            "---\n"
-            "*Research tool only — not for medical advice.*  \n"
-            "**MCP Server Active**: Connect Claude Desktop to `/gradio_api/mcp/`"
-        ),
+        description=description,
         examples=[
             [
                 "What drugs improve female libido post-menopause?",
                 "simple",
+                "sexual_health",
                 None,
                 None,
             ],
             [
-                "Clinical trials for erectile dysfunction alternatives to PDE5 inhibitors?",
-                "advanced",
+                "Metformin mechanism for Alzheimer's?",
+                "simple",
+                "general",
                 None,
                 None,
             ],
             [
-                "Testosterone therapy for Hypoactive Sexual Desire Disorder?",
-                "simple",
+                "Clinical trials for PDE5 inhibitors alternatives?",
+                "advanced",
+                "sexual_health",
                 None,
                 None,
             ],
@@ -271,6 +284,12 @@ def create_demo() -> tuple[gr.ChatInterface, gr.Accordion]:
                 label="Orchestrator Mode",
                 info="⚡ Simple: Free/Any | 🔬 Advanced: OpenAI (Deep Research)",
             ),
+            gr.Dropdown(
+                choices=[d.value for d in ResearchDomain],
+                value="general",
+                label="Research Domain",
+                info="Select research focus area (adjusts prompts)",
+            ),
             gr.Textbox(
                 label="🔑 API Key (Optional)",
                 placeholder="sk-... (OpenAI) or sk-ant-... (Anthropic)",
@@ -281,9 +300,6 @@ def create_demo() -> tuple[gr.ChatInterface, gr.Accordion]:
         ],
     )
 
-    # API key persists because examples include [message, mode, None, None].
-    # The explicit None values tell Gradio to NOT overwrite those inputs.
-
     return demo, additional_inputs_accordion
 
 

src/config/domain.py

@@ -0,0 +1,176 @@
+"""Centralized domain configuration for research agents.
+
+This module defines research domains and their associated prompts,
+allowing the agent to operate in domain-agnostic or domain-specific modes.
+
+Usage:
+    from src.config.domain import get_domain_config, ResearchDomain
+
+    # Get default (general) config
+    config = get_domain_config()
+
+    # Get specific domain
+    config = get_domain_config(ResearchDomain.SEXUAL_HEALTH)
+
+    # Use in prompts
+    system_prompt = config.judge_system_prompt
+"""
+
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+class ResearchDomain(str, Enum):
+    """Available research domains."""
+
+    GENERAL = "general"
+    DRUG_REPURPOSING = "drug_repurposing"
+    SEXUAL_HEALTH = "sexual_health"
+
+
+class DomainConfig(BaseModel):
+    """Configuration for a research domain.
+
+    Contains all domain-specific text used across the codebase,
+    ensuring consistency and single-source-of-truth.
+    """
+
+    # Identity
+    name: str
+    description: str
+
+    # Report generation
+    report_title: str
+    report_focus: str
+
+    # Judge prompts
+    judge_system_prompt: str
+    judge_scoring_prompt: str
+
+    # Hypothesis prompts
+    hypothesis_system_prompt: str
+
+    # Report writer prompts
+    report_system_prompt: str
+
+    # Search context
+    search_description: str
+    search_example_query: str
+
+    # Agent descriptions (for Magentic mode)
+    search_agent_description: str
+    hypothesis_agent_description: str
+
+
+# ─────────────────────────────────────────────────────────────────
+# Domain Definitions
+# ─────────────────────────────────────────────────────────────────
+
+GENERAL_CONFIG = DomainConfig(
+    name="General Research",
+    description="General-purpose biomedical research agent",
+    report_title="## Research Analysis",
+    report_focus="comprehensive research synthesis",
+    judge_system_prompt="""You are an expert research judge.
+Your role is to evaluate evidence quality, assess relevance to the research query,
+and determine if sufficient evidence exists to synthesize findings.""",
+    judge_scoring_prompt="""Score this evidence for research relevance.
+Provide ONLY scores and extracted data.""",
+    hypothesis_system_prompt="""You are a biomedical research scientist.
+Your role is to generate evidence-based hypotheses from the literature,
+identifying key mechanisms, targets, and potential therapeutic implications.""",
+    report_system_prompt="""You are a scientific writer specializing in research reports.
+Your role is to synthesize evidence into clear, well-structured reports with
+proper citations and evidence-based conclusions.""",
+    search_description="Searches biomedical literature for relevant evidence",
+    search_example_query="metformin aging mechanisms",
+    search_agent_description="Searches PubMed, ClinicalTrials.gov, and Europe PMC for evidence",
+    hypothesis_agent_description="Generates mechanistic hypotheses from evidence",
+)
+
+DRUG_REPURPOSING_CONFIG = DomainConfig(
+    name="Drug Repurposing",
+    description="Drug repurposing research specialist",
+    report_title="## Drug Repurposing Analysis",
+    report_focus="drug repurposing opportunities",
+    judge_system_prompt="""You are an expert drug repurposing research judge.
+Your role is to evaluate evidence for drug repurposing potential, assess
+mechanism plausibility, and determine if compounds warrant further investigation.""",
+    judge_scoring_prompt="""Score this evidence for drug repurposing potential.
+Provide ONLY scores and extracted data.""",
+    hypothesis_system_prompt=(
+        """You are a biomedical research scientist specializing in drug repurposing.
+Your role is to generate mechanistic hypotheses for how existing drugs might
+treat new indications, based on shared pathways and targets."""
+    ),
+    report_system_prompt=(
+        """You are a scientific writer specializing in drug repurposing research reports.
+Your role is to synthesize evidence into actionable drug repurposing recommendations
+with clear mechanistic rationale and clinical translation potential."""
+    ),
+    search_description="Searches biomedical literature for drug repurposing evidence",
+    search_example_query="metformin alzheimer repurposing",
+    search_agent_description="Searches PubMed for drug repurposing evidence",
+    hypothesis_agent_description="Generates mechanistic hypotheses for drug repurposing",
+)
+
+SEXUAL_HEALTH_CONFIG = DomainConfig(
+    name="Sexual Health Research",
+    description="Sexual health and wellness research specialist",
+    report_title="## Sexual Health Analysis",
+    report_focus="sexual health and wellness interventions",
+    judge_system_prompt="""You are an expert sexual health research judge.
+Your role is to evaluate evidence for sexual health interventions, assess
+efficacy and safety data, and determine clinical applicability.""",
+    judge_scoring_prompt="""Score this evidence for sexual health relevance.
+Provide ONLY scores and extracted data.""",
+    hypothesis_system_prompt=(
+        """You are a biomedical research scientist specializing in sexual health.
+Your role is to generate evidence-based hypotheses for sexual health interventions,
+identifying mechanisms of action and potential therapeutic applications."""
+    ),
+    report_system_prompt=(
+        """You are a scientific writer specializing in sexual health research reports.
+Your role is to synthesize evidence into clear recommendations for sexual health
+interventions with proper safety considerations."""
+    ),
+    search_description="Searches biomedical literature for sexual health evidence",
+    search_example_query="testosterone therapy female libido",
+    search_agent_description="Searches PubMed for sexual health evidence",
+    hypothesis_agent_description="Generates hypotheses for sexual health interventions",
+)
+
+# ─────────────────────────────────────────────────────────────────
+# Domain Registry
+# ─────────────────────────────────────────────────────────────────
+
+DOMAIN_CONFIGS: dict[ResearchDomain, DomainConfig] = {
+    ResearchDomain.GENERAL: GENERAL_CONFIG,
+    ResearchDomain.DRUG_REPURPOSING: DRUG_REPURPOSING_CONFIG,
+    ResearchDomain.SEXUAL_HEALTH: SEXUAL_HEALTH_CONFIG,
+}
+
+# Default domain
+DEFAULT_DOMAIN = ResearchDomain.GENERAL
+
+
+def get_domain_config(domain: ResearchDomain | str | None = None) -> DomainConfig:
+    """Get configuration for a research domain.
+
+    Args:
+        domain: The research domain. Defaults to GENERAL if None.
+
+    Returns:
+        DomainConfig for the specified domain.
+    """
+    if domain is None:
+        domain = DEFAULT_DOMAIN
+
+    if isinstance(domain, str):
+        try:
+            domain = ResearchDomain(domain)
+        except ValueError:
+            domain = DEFAULT_DOMAIN
+
+    return DOMAIN_CONFIGS[domain]

src/mcp_tools.py

@@ -7,6 +7,7 @@ Each function follows the MCP tool contract:
 - Formatted string returns
 """
 
+from src.config.domain import get_domain_config
 from src.tools.clinicaltrials import ClinicalTrialsTool
 from src.tools.europepmc import EuropePMCTool
 from src.tools.pubmed import PubMedTool
@@ -17,27 +18,29 @@ _trials = ClinicalTrialsTool()
 _europepmc = EuropePMCTool()
 
 
-async def search_pubmed(query: str, max_results: int = 10) -> str:
+async def search_pubmed(query: str, max_results: int = 10, domain: str = "general") -> str:
     """Search PubMed for peer-reviewed biomedical literature.
 
     Searches NCBI PubMed database for scientific papers matching your query.
     Returns titles, authors, abstracts, and citation information.
 
     Args:
-        query: Search query (e.g., "metformin alzheimer", "drug repurposing cancer")
+        query: Search query (e.g., "metformin alzheimer")
         max_results: Maximum results to return (1-50, default 10)
+        domain: Research domain (general, drug_repurposing, sexual_health)
 
     Returns:
         Formatted search results with paper titles, authors, dates, and abstracts
     """
     max_results = max(1, min(50, max_results))  # Clamp to valid range
+    config = get_domain_config(domain)
 
     results = await _pubmed.search(query, max_results)
 
     if not results:
         return f"No PubMed results found for: {query}"
 
-    formatted = [f"## PubMed Results for: {query}\n"]
+    formatted = [f"## PubMed Results for: {query} ({config.name})\n"]
     for i, evidence in enumerate(results, 1):
         formatted.append(f"### {i}. {evidence.citation.title}")
         formatted.append(f"**Authors**: {', '.join(evidence.citation.authors[:3])}")
@@ -109,15 +112,16 @@ async def search_europepmc(query: str, max_results: int = 10) -> str:
     return "\n".join(formatted)
 
 
-async def search_all_sources(query: str, max_per_source: int = 5) -> str:
+async def search_all_sources(query: str, max_per_source: int = 5, domain: str = "general") -> str:
     """Search all biomedical sources simultaneously.
 
     Performs parallel search across PubMed, ClinicalTrials.gov, and Europe PMC.
-    This is the most comprehensive search option for drug repurposing research.
+    This is the most comprehensive search option for biomedical research.
 
     Args:
         query: Search query (e.g., "metformin alzheimer", "aspirin cancer prevention")
         max_per_source: Maximum results per source (1-20, default 5)
+        domain: Research domain (general, drug_repurposing, sexual_health)
 
     Returns:
         Combined results from all sources with source labels
@@ -125,9 +129,10 @@ async def search_all_sources(query: str, max_per_source: int = 5) -> str:
     import asyncio
 
     max_per_source = max(1, min(20, max_per_source))
+    config = get_domain_config(domain)
 
     # Run all searches in parallel
-    pubmed_task = search_pubmed(query, max_per_source)
+    pubmed_task = search_pubmed(query, max_per_source, domain)
     trials_task = search_clinical_trials(query, max_per_source)
     europepmc_task = search_europepmc(query, max_per_source)
 
@@ -135,7 +140,7 @@ async def search_all_sources(query: str, max_per_source: int = 5) -> str:
         pubmed_task, trials_task, europepmc_task, return_exceptions=True
     )
 
-    formatted = [f"# Comprehensive Search: {query}\n"]
+    formatted = [f"# Comprehensive Search: {query} ({config.name})\n"]
 
     # Add each result section (handle exceptions gracefully)
     if isinstance(pubmed_results, str):
@@ -161,10 +166,10 @@ async def analyze_hypothesis(
     condition: str,
     evidence_summary: str,
 ) -> str:
-    """Perform statistical analysis of drug repurposing hypothesis using Modal.
+    """Perform statistical analysis of research hypothesis using Modal.
 
     Executes AI-generated Python code in a secure Modal sandbox to analyze
-    the statistical evidence for a drug repurposing hypothesis.
+    the statistical evidence for a research hypothesis.
 
     Args:
         drug: The drug being evaluated (e.g., "metformin")

src/orchestrators/advanced.py

@@ -36,6 +36,7 @@ from src.agents.magentic_agents import (
     create_search_agent,
 )
 from src.agents.state import init_magentic_state
+from src.config.domain import ResearchDomain, get_domain_config
 from src.orchestrators.base import OrchestratorProtocol
 from src.utils.config import settings
 from src.utils.llm_factory import check_magentic_requirements
@@ -68,6 +69,7 @@ class AdvancedOrchestrator(OrchestratorProtocol):
         chat_client: OpenAIChatClient | None = None,
         api_key: str | None = None,
         timeout_seconds: float = 600.0,
+        domain: ResearchDomain | str | None = None,
     ) -> None:
         """Initialize orchestrator.
 
@@ -76,6 +78,7 @@ class AdvancedOrchestrator(OrchestratorProtocol):
             chat_client: Optional shared chat client for agents
             api_key: Optional OpenAI API key (for BYOK)
             timeout_seconds: Maximum workflow duration (default: 10 minutes)
+            domain: Research domain for customization
         """
         # Validate requirements only if no key provided
         if not chat_client and not api_key:
@@ -83,6 +86,8 @@ class AdvancedOrchestrator(OrchestratorProtocol):
 
         self._max_rounds = max_rounds
         self._timeout_seconds = timeout_seconds
+        self.domain = domain
+        self.domain_config = get_domain_config(domain)
         self._chat_client: OpenAIChatClient | None
 
         if chat_client:
@@ -104,10 +109,10 @@ class AdvancedOrchestrator(OrchestratorProtocol):
     def _build_workflow(self) -> Any:
         """Build the workflow with ChatAgent participants."""
         # Create agents with internal LLMs
-        search_agent = create_search_agent(self._chat_client)
-        judge_agent = create_judge_agent(self._chat_client)
-        hypothesis_agent = create_hypothesis_agent(self._chat_client)
-        report_agent = create_report_agent(self._chat_client)
+        search_agent = create_search_agent(self._chat_client, domain=self.domain)
+        judge_agent = create_judge_agent(self._chat_client, domain=self.domain)
+        hypothesis_agent = create_hypothesis_agent(self._chat_client, domain=self.domain)
+        report_agent = create_report_agent(self._chat_client, domain=self.domain)
 
         # Manager chat client (orchestrates the agents)
         manager_client = self._chat_client or OpenAIChatClient(
@@ -156,7 +161,7 @@ class AdvancedOrchestrator(OrchestratorProtocol):
 
         workflow = self._build_workflow()
 
-        task = f"""Research drug repurposing opportunities for: {query}
+        task = f"""Research {self.domain_config.report_focus} for: {query}
 
 Workflow:
 1. SearchAgent: Find evidence from PubMed, ClinicalTrials.gov, and Europe PMC

src/orchestrators/factory.py

@@ -13,6 +13,7 @@ from typing import TYPE_CHECKING, Literal
 
 import structlog
 
+from src.config.domain import ResearchDomain
 from src.orchestrators.base import (
     JudgeHandlerProtocol,
     OrchestratorProtocol,
@@ -58,6 +59,7 @@ def create_orchestrator(
     config: OrchestratorConfig | None = None,
     mode: Literal["simple", "magentic", "advanced", "hierarchical"] | None = None,
     api_key: str | None = None,
+    domain: ResearchDomain | str | None = None,
 ) -> OrchestratorProtocol:
     """
     Create an orchestrator instance.
@@ -73,6 +75,7 @@ def create_orchestrator(
         mode: "simple", "magentic", "advanced", or "hierarchical"
               Note: "magentic" is an alias for "advanced" (kept for backwards compatibility)
         api_key: Optional API key for advanced mode (OpenAI)
+        domain: Research domain for customization (default: General)
 
     Returns:
         Orchestrator instance implementing OrchestratorProtocol
@@ -83,19 +86,20 @@ def create_orchestrator(
     """
     effective_config = config or OrchestratorConfig()
     effective_mode = _determine_mode(mode, api_key)
-    logger.info("Creating orchestrator", mode=effective_mode)
+    logger.info("Creating orchestrator", mode=effective_mode, domain=domain)
 
     if effective_mode == "advanced":
         orchestrator_cls = _get_advanced_orchestrator_class()
         return orchestrator_cls(
             max_rounds=effective_config.max_iterations,
             api_key=api_key,
+            domain=domain,
         )
 
     if effective_mode == "hierarchical":
         from src.orchestrators.hierarchical import HierarchicalOrchestrator
 
-        return HierarchicalOrchestrator(config=effective_config)
+        return HierarchicalOrchestrator(config=effective_config, domain=domain)
 
     # Simple mode requires handlers
     if search_handler is None or judge_handler is None:
@@ -105,6 +109,7 @@ def create_orchestrator(
         search_handler=search_handler,
         judge_handler=judge_handler,
         config=effective_config,
+        domain=domain,
     )
 
 

src/orchestrators/hierarchical.py

@@ -18,6 +18,7 @@ import structlog
 
 from src.agents.judge_agent_llm import LLMSubIterationJudge
 from src.agents.magentic_agents import create_search_agent
+from src.config.domain import ResearchDomain
 from src.middleware.sub_iteration import SubIterationMiddleware, SubIterationTeam
 from src.orchestrators.base import OrchestratorProtocol
 from src.state import init_magentic_state
@@ -37,8 +38,8 @@ class ResearchTeam(SubIterationTeam):
     sub-iteration middleware framework.
     """
 
-    def __init__(self) -> None:
-        self.agent = create_search_agent()
+    def __init__(self, domain: ResearchDomain | str | None = None) -> None:
+        self.agent = create_search_agent(domain=domain)
 
     async def execute(self, task: str) -> str:
         """Execute a research task.
@@ -71,16 +72,19 @@ class HierarchicalOrchestrator(OrchestratorProtocol):
         self,
         config: OrchestratorConfig | None = None,
         timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+        domain: ResearchDomain | str | None = None,
     ) -> None:
         """Initialize the hierarchical orchestrator.
 
         Args:
             config: Optional configuration (uses defaults if not provided)
             timeout_seconds: Maximum workflow duration (default: 5 minutes)
+            domain: Research domain for customization
         """
         self.config = config or OrchestratorConfig()
         self._timeout_seconds = timeout_seconds
-        self.team = ResearchTeam()
+        self.domain = domain
+        self.team = ResearchTeam(domain=domain)
         self.judge = LLMSubIterationJudge()
         self.middleware = SubIterationMiddleware(
             self.team, self.judge, max_iterations=self.config.max_iterations

src/orchestrators/simple.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING, Any, ClassVar
 
 import structlog
 
+from src.config.domain import ResearchDomain, get_domain_config
 from src.orchestrators.base import JudgeHandlerProtocol, SearchHandlerProtocol
 from src.utils.config import settings
 from src.utils.models import (
@@ -61,6 +62,7 @@ class Orchestrator:
         config: OrchestratorConfig | None = None,
         enable_analysis: bool = False,
         enable_embeddings: bool = True,
+        domain: ResearchDomain | str | None = None,
     ):
         """
         Initialize the orchestrator.
@@ -71,6 +73,7 @@ class Orchestrator:
             config: Optional configuration (uses defaults if not provided)
             enable_analysis: Whether to perform statistical analysis (if Modal available)
             enable_embeddings: Whether to use semantic search for ranking/dedup
+            domain: Research domain for customization
         """
         self.search = search_handler
         self.judge = judge_handler
@@ -78,6 +81,8 @@ class Orchestrator:
         self.history: list[dict[str, Any]] = []
         self._enable_analysis = enable_analysis and settings.modal_available
         self._enable_embeddings = enable_embeddings
+        self.domain = domain
+        self.domain_config = get_domain_config(domain)
 
         # Lazy-load services (typed for IDE support)
         self._analyzer: StatisticalAnalyzer | None = None
@@ -473,7 +478,7 @@ class Orchestrator:
             ]
         )
 
-        return f"""## Drug Repurposing Analysis
+        return f"""{self.domain_config.report_title}
 
 ### Question
 {query}
@@ -561,7 +566,7 @@ class Orchestrator:
         )
         comb_strength = "Sufficient" if combined_score >= 12 else "Partial"
 
-        return f"""## Drug Repurposing Analysis
+        return f"""{self.domain_config.report_title}
 
 ### Research Question
 {query}

src/prompts/hypothesis.py

@@ -2,13 +2,18 @@
 
 from typing import TYPE_CHECKING
 
+from src.config.domain import ResearchDomain, get_domain_config
 from src.utils.text_utils import select_diverse_evidence, truncate_at_sentence
 
 if TYPE_CHECKING:
     from src.services.embedding_protocol import EmbeddingServiceProtocol
     from src.utils.models import Evidence
 
-SYSTEM_PROMPT = """You are a biomedical research scientist specializing in drug repurposing.
+
+def get_system_prompt(domain: ResearchDomain | str | None = None) -> str:
+    """Get the system prompt for the hypothesis agent."""
+    config = get_domain_config(domain)
+    return f"""{config.hypothesis_system_prompt}
 
 Your role is to generate mechanistic hypotheses based on evidence.
 
@@ -29,6 +34,10 @@ Example hypothesis format:
 Be specific. Use actual gene/protein names when possible."""
 
 
+# Keep SYSTEM_PROMPT for backwards compatibility
+SYSTEM_PROMPT = get_system_prompt()
+
+
 async def format_hypothesis_prompt(
     query: str, evidence: list["Evidence"], embeddings: "EmbeddingServiceProtocol | None" = None
 ) -> str:

src/prompts/judge.py

@@ -1,8 +1,13 @@
 """Judge prompts for evidence assessment."""
 
+from src.config.domain import ResearchDomain, get_domain_config
 from src.utils.models import Evidence
 
-SYSTEM_PROMPT = """You are an expert drug repurposing research judge.
+
+def get_system_prompt(domain: ResearchDomain | str | None = None) -> str:
+    """Get the system prompt for the judge agent."""
+    config = get_domain_config(domain)
+    return f"""{config.judge_system_prompt}
 
 Your task is to SCORE evidence from biomedical literature. You do NOT decide whether to
 continue searching or synthesize - that decision is made by the orchestration system
@@ -62,6 +67,16 @@ When suggesting next_search_queries:
 - Refine existing terms, don't explore random medical associations
 """
 
+
+def get_scoring_prompt(domain: ResearchDomain | str | None = None) -> str:
+    """Get the scoring instructions for the judge."""
+    config = get_domain_config(domain)
+    return config.judge_scoring_prompt
+
+
+# Keep SYSTEM_PROMPT for backwards compatibility
+SYSTEM_PROMPT = get_system_prompt()
+
 MAX_EVIDENCE_FOR_JUDGE = 30  # Keep under token limits
 
 
@@ -99,6 +114,7 @@ def format_user_prompt(
     iteration: int = 0,
     max_iterations: int = 10,
     total_evidence_count: int | None = None,
+    domain: ResearchDomain | str | None = None,
 ) -> str:
     """
     Format user prompt with selected evidence and iteration context.
@@ -108,6 +124,7 @@ def format_user_prompt(
     """
     total_count = total_evidence_count or len(evidence)
     max_content_len = 1500
+    scoring_prompt = get_scoring_prompt(domain)
 
     def format_single_evidence(i: int, e: Evidence) -> str:
         content = e.content
@@ -137,7 +154,7 @@ def format_user_prompt(
 
 ## Your Task
 
-Score this evidence for drug repurposing potential. Provide ONLY scores and extracted data.
+{scoring_prompt}
 DO NOT decide "synthesize" vs "continue" - that decision is made by the system.
 
 ## REMINDER: Original Question (stay focused)

src/prompts/report.py

@@ -2,13 +2,18 @@
 
 from typing import TYPE_CHECKING, Any
 
+from src.config.domain import ResearchDomain, get_domain_config
 from src.utils.text_utils import select_diverse_evidence, truncate_at_sentence
 
 if TYPE_CHECKING:
     from src.services.embedding_protocol import EmbeddingServiceProtocol
     from src.utils.models import Evidence, MechanismHypothesis
 
-SYSTEM_PROMPT = """You are a scientific writer specializing in drug repurposing research reports.
+
+def get_system_prompt(domain: ResearchDomain | str | None = None) -> str:
+    """Get the system prompt for the report agent."""
+    config = get_domain_config(domain)
+    return f"""{config.report_system_prompt}
 
 Your role is to synthesize evidence and hypotheses into a clear, structured report.
 
@@ -36,8 +41,10 @@ The `hypotheses_tested` field MUST be a LIST of objects, each with these fields:
 
 Example:
   hypotheses_tested: [
-    {"hypothesis": "Metformin -> AMPK -> reduced inflammation", "supported": 3, "contradicted": 1},
-    {"hypothesis": "Aspirin inhibits COX-2 pathway", "supported": 5, "contradicted": 0}
+    {{"hypothesis": "Metformin -> AMPK -> reduced inflammation",
+      "supported": 3, "contradicted": 1}},
+    {{"hypothesis": "Aspirin inhibits COX-2 pathway",
+      "supported": 5, "contradicted": 0}}
   ]
 
 The `references` field MUST be a LIST of objects, each with these fields:
@@ -48,7 +55,7 @@ The `references` field MUST be a LIST of objects, each with these fields:
 
 Example:
   references: [
-    {"title": "Metformin and Cancer", "authors": "Smith et al.", "source": "pubmed", "url": "https://pubmed.ncbi.nlm.nih.gov/12345678/"}
+    {{"title": "Metformin and Cancer", "authors": "Smith et al.", "source": "pubmed", "url": "https://pubmed.ncbi.nlm.nih.gov/12345678/"}}
   ]
 
 ─────────────────────────────────────────────────────────────────────────────
@@ -68,6 +75,10 @@ VIOLATION OF THESE RULES PRODUCES DANGEROUS MISINFORMATION.
 ─────────────────────────────────────────────────────────────────────────────"""
 
 
+# Keep SYSTEM_PROMPT for backwards compatibility
+SYSTEM_PROMPT = get_system_prompt()
+
+
 async def format_report_prompt(
     query: str,
     evidence: list["Evidence"],

src/utils/config.py

@@ -7,6 +7,7 @@ import structlog
 from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+from src.config.domain import ResearchDomain
 from src.utils.exceptions import ConfigurationError
 
 
@@ -20,6 +21,9 @@ class Settings(BaseSettings):
         extra="ignore",
     )
 
+    # Domain configuration
+    research_domain: ResearchDomain = ResearchDomain.GENERAL
+
     # LLM Configuration
     openai_api_key: str | None = Field(default=None, description="OpenAI API key")
     anthropic_api_key: str | None = Field(default=None, description="Anthropic API key")

tests/e2e/test_simple_mode.py

@@ -56,7 +56,7 @@ async def test_simple_mode_structure_validation(mock_search_handler, mock_judge_
     report = complete_event.message
 
     # Check markdown structure
-    assert "## Drug Repurposing Analysis" in report
+    assert "## Research Analysis" in report
     assert "### Citations" in report
     assert "### Key Findings" in report
 

tests/unit/agent_factory/test_judge_domain.py

@@ -0,0 +1,72 @@
+"""Tests for JudgeHandler domain support."""
+
+from unittest.mock import MagicMock, patch
+
+from src.agent_factory.judges import JudgeHandler
+from src.config.domain import ResearchDomain
+from src.utils.models import AssessmentDetails, JudgeAssessment
+
+
+class TestJudgeHandlerDomain:
+    @patch("src.agent_factory.judges.get_model")
+    @patch("src.agent_factory.judges.Agent")
+    def test_judge_handler_accepts_domain(self, mock_agent_cls, mock_get_model):
+        # Mock get_model to avoid API key requirement
+        mock_get_model.return_value = MagicMock()
+        # Test init with domain
+        handler = JudgeHandler(domain=ResearchDomain.SEXUAL_HEALTH)
+        assert handler.domain == ResearchDomain.SEXUAL_HEALTH
+
+    @patch("src.agent_factory.judges.get_model")
+    @patch("src.agent_factory.judges.Agent")
+    @patch("src.agent_factory.judges.format_user_prompt")
+    @patch("src.agent_factory.judges.select_evidence_for_judge")
+    async def test_judge_handler_passes_domain_to_prompt(
+        self, mock_select, mock_format, mock_agent_cls, mock_get_model
+    ):
+        # Setup mocks
+        mock_get_model.return_value = MagicMock()
+        mock_agent_instance = MagicMock()
+        mock_agent_cls.return_value = mock_agent_instance
+
+        mock_assessment = JudgeAssessment(
+            details=AssessmentDetails(
+                mechanism_score=0,
+                mechanism_reasoning="Insufficient evidence to determine mechanism.",
+                clinical_evidence_score=0,
+                clinical_reasoning="Insufficient evidence to determine clinical viability.",
+                drug_candidates=[],
+                key_findings=[],
+            ),
+            sufficient=False,
+            confidence=0.0,
+            recommendation="continue",
+            next_search_queries=[],
+            reasoning=("Insufficient evidence collected so far to form a conclusion."),
+        )
+
+        # Use async return value for run()
+        async def mock_run(*args, **kwargs):
+            return MagicMock(output=mock_assessment)
+
+        mock_agent_instance.run.side_effect = mock_run
+
+        mock_select.return_value = []  # mock select returns empty list
+        # Wait, if evidence is empty, format_empty_evidence_prompt is called.
+        # We want format_user_prompt to be called.
+
+        evidence = [MagicMock()]  # Provide some evidence
+        mock_select.return_value = evidence
+
+        # Test
+        handler = JudgeHandler(domain=ResearchDomain.DRUG_REPURPOSING)
+        await handler.assess("query", evidence)
+
+        # Verify format_user_prompt called with domain
+        mock_format.assert_called_once()
+        call_kwargs = mock_format.call_args.kwargs
+        # Or check args if positional
+        # format_user_prompt signature: (question, evidence, iteration, max_iterations, ...)
+
+        # Check if domain was passed in kwargs
+        assert call_kwargs.get("domain") == ResearchDomain.DRUG_REPURPOSING

tests/unit/agents/test_magentic_agents_domain.py

@@ -0,0 +1,47 @@
+"""Tests for Magentic Agents domain support."""
+
+from unittest.mock import patch
+
+from src.agents.magentic_agents import (
+    create_hypothesis_agent,
+    create_judge_agent,
+    create_report_agent,
+    create_search_agent,
+)
+from src.config.domain import SEXUAL_HEALTH_CONFIG, ResearchDomain
+
+
+class TestMagenticAgentsDomain:
+    @patch("src.agents.magentic_agents.ChatAgent")
+    @patch("src.agents.magentic_agents.OpenAIChatClient")
+    def test_create_search_agent_uses_domain(self, mock_client, mock_agent_cls):
+        create_search_agent(domain=ResearchDomain.SEXUAL_HEALTH)
+
+        # Check instructions or description passed to ChatAgent
+        call_kwargs = mock_agent_cls.call_args.kwargs
+        assert SEXUAL_HEALTH_CONFIG.search_agent_description in call_kwargs["description"]
+        # Ideally check instructions too if we update them
+
+    @patch("src.agents.magentic_agents.ChatAgent")
+    @patch("src.agents.magentic_agents.OpenAIChatClient")
+    def test_create_judge_agent_uses_domain(self, mock_client, mock_agent_cls):
+        create_judge_agent(domain=ResearchDomain.SEXUAL_HEALTH)
+
+        # Verify domain-specific judge system prompt is passed through
+        call_kwargs = mock_agent_cls.call_args.kwargs
+        assert SEXUAL_HEALTH_CONFIG.judge_system_prompt in call_kwargs["instructions"]
+
+    @patch("src.agents.magentic_agents.ChatAgent")
+    @patch("src.agents.magentic_agents.OpenAIChatClient")
+    def test_create_hypothesis_agent_uses_domain(self, mock_client, mock_agent_cls):
+        create_hypothesis_agent(domain=ResearchDomain.SEXUAL_HEALTH)
+        call_kwargs = mock_agent_cls.call_args.kwargs
+        assert SEXUAL_HEALTH_CONFIG.hypothesis_agent_description in call_kwargs["description"]
+
+    @patch("src.agents.magentic_agents.ChatAgent")
+    @patch("src.agents.magentic_agents.OpenAIChatClient")
+    def test_create_report_agent_uses_domain(self, mock_client, mock_agent_cls):
+        create_report_agent(domain=ResearchDomain.SEXUAL_HEALTH)
+        # Check instructions contains domain prompt
+        call_kwargs = mock_agent_cls.call_args.kwargs
+        assert SEXUAL_HEALTH_CONFIG.report_system_prompt in call_kwargs["instructions"]

tests/unit/agents/test_search_agent_domain.py

@@ -0,0 +1,19 @@
+"""Tests for Search Agent domain support."""
+
+from unittest.mock import MagicMock
+
+from src.agents.search_agent import SearchAgent
+from src.config.domain import SEXUAL_HEALTH_CONFIG, ResearchDomain
+
+
+class TestSearchAgentDomain:
+    def test_search_agent_accepts_domain(self):
+        mock_handler = MagicMock()
+        store = {"current": []}
+
+        agent = SearchAgent(
+            search_handler=mock_handler, evidence_store=store, domain=ResearchDomain.SEXUAL_HEALTH
+        )
+
+        # Verify description updated
+        assert agent.description == SEXUAL_HEALTH_CONFIG.search_agent_description

tests/unit/config/test_domain.py

@@ -0,0 +1,53 @@
+"""Tests for domain configuration."""
+
+from src.config.domain import (
+    ResearchDomain,
+    get_domain_config,
+)
+
+
+class TestResearchDomain:
+    def test_enum_values(self):
+        assert ResearchDomain.GENERAL.value == "general"
+        assert ResearchDomain.DRUG_REPURPOSING.value == "drug_repurposing"
+        assert ResearchDomain.SEXUAL_HEALTH.value == "sexual_health"
+
+
+class TestGetDomainConfig:
+    def test_default_returns_general(self):
+        config = get_domain_config()
+        assert config.name == "General Research"
+
+    def test_explicit_general(self):
+        config = get_domain_config(ResearchDomain.GENERAL)
+        assert "Research Analysis" in config.report_title
+
+    def test_drug_repurposing(self):
+        config = get_domain_config(ResearchDomain.DRUG_REPURPOSING)
+        assert "Drug Repurposing" in config.report_title
+        assert "drug repurposing" in config.judge_system_prompt.lower()
+
+    def test_sexual_health(self):
+        config = get_domain_config(ResearchDomain.SEXUAL_HEALTH)
+        assert "Sexual Health" in config.report_title
+
+    def test_accepts_string(self):
+        config = get_domain_config("drug_repurposing")
+        assert "Drug Repurposing" in config.name
+
+    def test_invalid_string_returns_default(self):
+        config = get_domain_config("invalid_domain")
+        assert config.name == "General Research"
+
+    def test_all_domains_have_required_fields(self):
+        required_fields = [
+            "name",
+            "report_title",
+            "judge_system_prompt",
+            "hypothesis_system_prompt",
+            "report_system_prompt",
+        ]
+        for domain in ResearchDomain:
+            config = get_domain_config(domain)
+            for field in required_fields:
+                assert getattr(config, field), f"{domain} missing {field}"

tests/unit/mcp/test_mcp_tools_domain.py

@@ -0,0 +1,29 @@
+"""Tests for MCP Tools domain support."""
+
+from unittest.mock import MagicMock, patch
+
+from src.mcp_tools import search_pubmed
+
+
+class TestMCPToolsDomain:
+    @patch("src.mcp_tools._pubmed.search")
+    async def test_search_pubmed_accepts_domain(self, mock_search):
+        mock_search.return_value = []
+
+        result = await search_pubmed("query", domain="sexual_health")
+
+        # The function returns "No PubMed results found..." if empty
+        assert "No PubMed results" in result
+
+        # Let's mock results
+        mock_evidence = MagicMock()
+        mock_evidence.citation.title = "Test Title"
+        mock_evidence.citation.authors = ["Author"]
+        mock_evidence.citation.date = "2024"
+        mock_evidence.citation.url = "http://url"
+        mock_evidence.content = "content"
+
+        mock_search.return_value = [mock_evidence]
+
+        result = await search_pubmed("query", domain="sexual_health")
+        assert "## PubMed Results for: query (Sexual Health Research)" in result

tests/unit/orchestrators/test_advanced_orchestrator_domain.py

@@ -0,0 +1,51 @@
+"""Tests for Advanced Orchestrator domain support."""
+
+from unittest.mock import MagicMock, patch
+
+from src.config.domain import ResearchDomain
+from src.orchestrators.advanced import AdvancedOrchestrator
+
+
+class TestAdvancedOrchestratorDomain:
+    @patch("src.orchestrators.advanced.check_magentic_requirements")
+    @patch("src.orchestrators.advanced.OpenAIChatClient")
+    def test_advanced_orchestrator_accepts_domain(self, mock_client, mock_check):
+        # Mock to avoid API key validation
+        mock_client.return_value = MagicMock()
+        orch = AdvancedOrchestrator(domain=ResearchDomain.SEXUAL_HEALTH, api_key="sk-test")
+        assert orch.domain == ResearchDomain.SEXUAL_HEALTH
+
+    @patch("src.orchestrators.advanced.check_magentic_requirements")
+    @patch("src.orchestrators.advanced.create_search_agent")
+    @patch("src.orchestrators.advanced.create_judge_agent")
+    @patch("src.orchestrators.advanced.create_hypothesis_agent")
+    @patch("src.orchestrators.advanced.create_report_agent")
+    @patch("src.orchestrators.advanced.MagenticBuilder")
+    @patch("src.orchestrators.advanced.OpenAIChatClient")
+    def test_build_workflow_uses_domain(
+        self,
+        mock_client,
+        mock_builder,
+        mock_create_report,
+        mock_create_hypothesis,
+        mock_create_judge,
+        mock_create_search,
+        mock_check,
+    ):
+        mock_client.return_value = MagicMock()
+        orch = AdvancedOrchestrator(domain=ResearchDomain.SEXUAL_HEALTH, api_key="sk-test")
+
+        # Call private method to verify agent creation calls
+        orch._build_workflow()
+
+        # Verify agents created with domain
+        mock_create_search.assert_called_with(
+            orch._chat_client, domain=ResearchDomain.SEXUAL_HEALTH
+        )
+        mock_create_judge.assert_called_with(orch._chat_client, domain=ResearchDomain.SEXUAL_HEALTH)
+        mock_create_hypothesis.assert_called_with(
+            orch._chat_client, domain=ResearchDomain.SEXUAL_HEALTH
+        )
+        mock_create_report.assert_called_with(
+            orch._chat_client, domain=ResearchDomain.SEXUAL_HEALTH
+        )

tests/unit/orchestrators/test_factory_domain.py

@@ -0,0 +1,37 @@
+"""Tests for Orchestrator Factory domain support."""
+
+from unittest.mock import ANY, MagicMock, patch
+
+from src.config.domain import ResearchDomain
+from src.orchestrators.factory import create_orchestrator
+
+
+class TestFactoryDomain:
+    @patch("src.orchestrators.factory.Orchestrator")
+    def test_create_simple_uses_domain(self, mock_simple_cls):
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        create_orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+            mode="simple",
+            domain=ResearchDomain.SEXUAL_HEALTH,
+        )
+
+        mock_simple_cls.assert_called_with(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+            config=ANY,
+            domain=ResearchDomain.SEXUAL_HEALTH,
+        )
+
+    @patch("src.orchestrators.factory._get_advanced_orchestrator_class")
+    def test_create_advanced_uses_domain(self, mock_get_cls):
+        mock_adv_cls = MagicMock()
+        mock_get_cls.return_value = mock_adv_cls
+
+        create_orchestrator(mode="advanced", domain=ResearchDomain.SEXUAL_HEALTH)
+
+        call_kwargs = mock_adv_cls.call_args.kwargs
+        assert call_kwargs["domain"] == ResearchDomain.SEXUAL_HEALTH

tests/unit/orchestrators/test_simple_orchestrator_domain.py

@@ -0,0 +1,47 @@
+"""Tests for Orchestrator (Simple) domain support."""
+
+from unittest.mock import MagicMock
+
+from src.config.domain import SEXUAL_HEALTH_CONFIG, ResearchDomain
+from src.orchestrators.simple import Orchestrator
+
+
+class TestSimpleOrchestratorDomain:
+    def test_orchestrator_accepts_domain(self):
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orch = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+            domain=ResearchDomain.SEXUAL_HEALTH,
+        )
+
+        assert orch.domain == ResearchDomain.SEXUAL_HEALTH
+        assert orch.domain_config.name == SEXUAL_HEALTH_CONFIG.name
+
+    def test_orchestrator_uses_domain_title_in_synthesis(self):
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orch = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+            domain=ResearchDomain.SEXUAL_HEALTH,
+        )
+
+        # Test _generate_synthesis
+        mock_assessment = MagicMock()
+        mock_assessment.details.drug_candidates = []
+        mock_assessment.details.key_findings = []
+        mock_assessment.confidence = 0.5
+        mock_assessment.reasoning = "test"
+        mock_assessment.details.mechanism_score = 5
+        mock_assessment.details.clinical_evidence_score = 5
+
+        report = orch._generate_synthesis("query", [], mock_assessment)
+        assert "## Sexual Health Analysis" in report
+
+        # Test _generate_partial_synthesis
+        report_partial = orch._generate_partial_synthesis("query", [])
+        assert "## Sexual Health Analysis" in report_partial

tests/unit/prompts/test_hypothesis_prompt_domain.py

@@ -0,0 +1,16 @@
+"""Tests for hypothesis prompt domain support."""
+
+from src.config.domain import DRUG_REPURPOSING_CONFIG, GENERAL_CONFIG, ResearchDomain
+from src.prompts.hypothesis import get_system_prompt
+
+
+class TestHypothesisPromptDomain:
+    def test_get_system_prompt_default(self):
+        prompt = get_system_prompt()
+        assert GENERAL_CONFIG.hypothesis_system_prompt in prompt
+        assert "Your role is to generate mechanistic hypotheses" in prompt
+
+    def test_get_system_prompt_domain(self):
+        prompt = get_system_prompt(ResearchDomain.DRUG_REPURPOSING)
+        assert DRUG_REPURPOSING_CONFIG.hypothesis_system_prompt in prompt
+        assert "Your role is to generate mechanistic hypotheses" in prompt

tests/unit/prompts/test_judge_prompt_domain.py

@@ -0,0 +1,31 @@
+"""Tests for judge prompt domain support."""
+
+from src.config.domain import DRUG_REPURPOSING_CONFIG, GENERAL_CONFIG, ResearchDomain
+from src.prompts.judge import format_user_prompt, get_scoring_prompt, get_system_prompt
+
+
+class TestJudgePromptDomain:
+    def test_get_system_prompt_default(self):
+        prompt = get_system_prompt()
+        assert GENERAL_CONFIG.judge_system_prompt in prompt
+        assert "Your task is to SCORE evidence" in prompt
+
+    def test_get_system_prompt_domain(self):
+        prompt = get_system_prompt(ResearchDomain.DRUG_REPURPOSING)
+        assert DRUG_REPURPOSING_CONFIG.judge_system_prompt in prompt
+        assert "Your task is to SCORE evidence" in prompt
+
+    def test_get_scoring_prompt_default(self):
+        prompt = get_scoring_prompt()
+        assert GENERAL_CONFIG.judge_scoring_prompt == prompt
+
+    def test_format_user_prompt_default(self):
+        prompt = format_user_prompt("query", [])
+        assert GENERAL_CONFIG.judge_scoring_prompt in prompt
+        assert "drug repurposing" not in prompt.lower()
+
+    def test_format_user_prompt_with_domain(self):
+        prompt = format_user_prompt("query", [], domain=ResearchDomain.DRUG_REPURPOSING)
+        assert DRUG_REPURPOSING_CONFIG.judge_scoring_prompt in prompt
+        # The drug repurposing prompt contains "drug repurposing"
+        assert "drug repurposing" in prompt.lower()

tests/unit/prompts/test_report_prompt_domain.py

@@ -0,0 +1,16 @@
+"""Tests for report prompt domain support."""
+
+from src.config.domain import DRUG_REPURPOSING_CONFIG, GENERAL_CONFIG, ResearchDomain
+from src.prompts.report import get_system_prompt
+
+
+class TestReportPromptDomain:
+    def test_get_system_prompt_default(self):
+        prompt = get_system_prompt()
+        assert GENERAL_CONFIG.report_system_prompt in prompt
+        assert "Your role is to synthesize evidence" in prompt
+
+    def test_get_system_prompt_domain(self):
+        prompt = get_system_prompt(ResearchDomain.DRUG_REPURPOSING)
+        assert DRUG_REPURPOSING_CONFIG.report_system_prompt in prompt
+        assert "Your role is to synthesize evidence" in prompt

tests/unit/test_app_domain.py

@@ -0,0 +1,70 @@
+"""Tests for App domain support."""
+
+from unittest.mock import ANY, MagicMock, patch
+
+from src.app import configure_orchestrator, research_agent
+from src.config.domain import ResearchDomain
+
+
+class TestAppDomain:
+    @patch("src.app.create_orchestrator")
+    @patch("src.app.MockJudgeHandler")
+    def test_configure_orchestrator_passes_domain_mock_mode(self, mock_judge, mock_create):
+        """Test domain is passed when using mock mode (unit test path)."""
+        configure_orchestrator(use_mock=True, mode="simple", domain=ResearchDomain.SEXUAL_HEALTH)
+
+        # MockJudgeHandler should receive domain
+        mock_judge.assert_called_with(domain=ResearchDomain.SEXUAL_HEALTH)
+        mock_create.assert_called_with(
+            search_handler=ANY,
+            judge_handler=ANY,
+            config=ANY,
+            mode="simple",
+            api_key=None,
+            domain=ResearchDomain.SEXUAL_HEALTH,
+        )
+
+    @patch.dict("os.environ", {}, clear=True)
+    @patch("src.app.create_orchestrator")
+    @patch("src.app.HFInferenceJudgeHandler")
+    def test_configure_orchestrator_passes_domain_free_tier(self, mock_hf_judge, mock_create):
+        """Test domain is passed when using free tier (no API keys)."""
+        configure_orchestrator(use_mock=False, mode="simple", domain=ResearchDomain.SEXUAL_HEALTH)
+
+        # HFInferenceJudgeHandler should receive domain (no API keys = free tier)
+        mock_hf_judge.assert_called_with(domain=ResearchDomain.SEXUAL_HEALTH)
+        mock_create.assert_called_with(
+            search_handler=ANY,
+            judge_handler=ANY,
+            config=ANY,
+            mode="simple",
+            api_key=None,
+            domain=ResearchDomain.SEXUAL_HEALTH,
+        )
+
+    @patch("src.app.configure_orchestrator")
+    async def test_research_agent_passes_domain(self, mock_config):
+        # Mock orchestrator
+        mock_orch = MagicMock()
+        mock_orch.run.return_value = []  # Async iterator?
+
+        # To mock async generator
+        async def async_gen(*args):
+            if False:
+                yield  # Make it a generator
+
+        mock_orch.run = async_gen
+
+        mock_config.return_value = (mock_orch, "Test Backend")
+
+        # Consume the generator from research_agent
+        gen = research_agent(
+            message="query", history=[], mode="simple", domain=ResearchDomain.SEXUAL_HEALTH
+        )
+
+        async for _ in gen:
+            pass
+
+        mock_config.assert_called_with(
+            use_mock=False, mode="simple", user_api_key=None, domain=ResearchDomain.SEXUAL_HEALTH
+        )

tests/unit/utils/test_config_domain.py

@@ -0,0 +1,15 @@
+"""Tests for research domain configuration settings."""
+
+from src.config.domain import ResearchDomain
+from src.utils.config import Settings
+
+
+def test_research_domain_default():
+    settings = Settings()
+    assert settings.research_domain == ResearchDomain.GENERAL
+
+
+def test_research_domain_from_env(monkeypatch):
+    monkeypatch.setenv("RESEARCH_DOMAIN", "drug_repurposing")
+    settings = Settings()
+    assert settings.research_domain == ResearchDomain.DRUG_REPURPOSING