diff --git a/backend/pyproject.toml b/backend/pyproject.toml
index f3ce3440..7dd9f9ed 100644
--- a/backend/pyproject.toml
+++ b/backend/pyproject.toml
@@ -35,6 +35,7 @@ dependencies = [
"duckdb>=1.4.4",
"bibtexparser>=1.4.0",
"rapidfuzz>=3.5.0",
+ "rank-bm25>=0.2.2",
"beautifulsoup4>=4.12.3",
]
diff --git a/backend/src/gateway/contracts/__init__.py b/backend/src/gateway/contracts/__init__.py
index f3c9837c..23e91824 100644
--- a/backend/src/gateway/contracts/__init__.py
+++ b/backend/src/gateway/contracts/__init__.py
@@ -8,6 +8,7 @@
IdeaGenError,
IdeaGenRunEvent,
IdeaGenRunCreate,
+ IdeaGenPresetDefinition,
IdeaGenRunEventType,
IdeaGenRunResponse,
IdeaGenRunStatus,
@@ -63,6 +64,7 @@
"IdeaGenError",
"IdeaGenRunEvent",
"IdeaGenRunCreate",
+ "IdeaGenPresetDefinition",
"IdeaGenRunEventType",
"IdeaGenRunResponse",
"IdeaGenRunStatus",
diff --git a/backend/src/gateway/contracts/idea_gen.py b/backend/src/gateway/contracts/idea_gen.py
index 9606e0d0..20c81f87 100644
--- a/backend/src/gateway/contracts/idea_gen.py
+++ b/backend/src/gateway/contracts/idea_gen.py
@@ -7,6 +7,7 @@
from typing import Literal
from pydantic import BaseModel, Field, field_validator, model_validator
+from src.modules.idea_gen.config_presets import PresetMode
IDEA_GEN_DEFAULT_TARGET_VENUES = ("NIPS", "ICML", "ICLR")
DEFAULT_MAX_CRITIC_ITERATIONS = 2
@@ -63,6 +64,7 @@ class IdeaGenRunCreate(BaseModel):
"""Request model for creating a new Idea Gen run."""
target: str = Field(..., min_length=10, max_length=1000)
+ preset_mode: PresetMode = "custom"
academic_domain: str = Field(default="AI/ML", min_length=1, max_length=200)
target_venues: list[str] = Field(
default_factory=lambda: list(IDEA_GEN_DEFAULT_TARGET_VENUES)
@@ -124,6 +126,16 @@ def _strip_answer(cls, value: str) -> str:
return stripped
+class IdeaGenPresetDefinition(BaseModel):
+ """Preset metadata exposed to the frontend."""
+
+ mode: PresetMode
+ label: str = Field(..., min_length=1, max_length=100)
+ description: str = Field(..., min_length=1, max_length=300)
+ default_max_iterations: int = Field(..., ge=1)
+ max_critic_iterations: int = Field(..., ge=1)
+
+
class CriticFeedbackSimple(BaseModel):
"""Current critic feedback shape persisted by the workflow."""
diff --git a/backend/src/gateway/routers/idea_gen.py b/backend/src/gateway/routers/idea_gen.py
index fe5942a6..b8fca5c9 100644
--- a/backend/src/gateway/routers/idea_gen.py
+++ b/backend/src/gateway/routers/idea_gen.py
@@ -24,14 +24,26 @@
IdeaGenRunEvent,
IdeaGenRunEventType,
IdeaGenRunCreate,
+ IdeaGenPresetDefinition,
IdeaGenRunResponse,
create_initial_idea_gen_run,
idea_gen_run_dir,
idea_gen_run_events_path,
idea_gen_run_metadata_path,
)
-from src.modules.idea_gen.config import get_workflow_config
+from src.modules.idea_gen.config import get_workflow_config, runtime_config_scope
+from src.modules.idea_gen.config_presets import (
+ build_runtime_config_bundle,
+ list_preset_descriptors,
+)
from src.modules.idea_gen.utils import IdeaResearchExecutor, NodeExecutor
+from src.modules.idea_gen.utils.state_utils import (
+ get_clarification_question,
+ get_compressed_papers,
+ get_research_runs,
+ get_supervisor_action,
+ needs_clarification,
+)
from src.modules.idea_gen.workflow import (
IdeaGenInput,
IdeaGenState,
@@ -69,6 +81,51 @@ def _utc_now() -> datetime:
return datetime.now(timezone.utc)
+def _config_overrides_from_input(input_payload: IdeaGenRunCreate) -> dict[str, dict]:
+ """Convert flat API fields into preset override sections."""
+
+ workflow_config: dict[str, object] = {}
+ paper_config: dict[str, object] = {}
+
+ if input_payload.max_concurrent_research_units is not None:
+ workflow_config["max_concurrent_research_units"] = (
+ input_payload.max_concurrent_research_units
+ )
+ if input_payload.search_results_per_topic is not None:
+ workflow_config["search_results_per_topic"] = input_payload.search_results_per_topic
+ if input_payload.max_critic_iterations is not None:
+ workflow_config["max_critic_iterations"] = input_payload.max_critic_iterations
+ if input_payload.critic_quality_threshold is not None:
+ workflow_config["critic_quality_threshold"] = input_payload.critic_quality_threshold
+
+ if input_payload.enable_scoring is not None:
+ paper_config["enable_scoring"] = input_payload.enable_scoring
+ if input_payload.score_threshold is not None:
+ paper_config["score_threshold"] = input_payload.score_threshold
+ if input_payload.top_k_papers is not None:
+ paper_config["top_k_papers"] = input_payload.top_k_papers
+ if input_payload.enable_pdf_parsing is not None:
+ paper_config["enable_pdf_parsing"] = input_payload.enable_pdf_parsing
+ if input_payload.enable_summarization is not None:
+ paper_config["enable_summarization"] = input_payload.enable_summarization
+ if input_payload.enable_paper_cache is not None:
+ paper_config["enable_paper_cache"] = input_payload.enable_paper_cache
+
+ overrides: dict[str, dict] = {}
+ if workflow_config:
+ overrides["workflow_config"] = workflow_config
+ if paper_config:
+ overrides["paper_config"] = paper_config
+ return overrides
+
+
+def _build_runtime_bundle(input_payload: IdeaGenRunCreate):
+ return build_runtime_config_bundle(
+ input_payload.preset_mode,
+ _config_overrides_from_input(input_payload),
+ )
+
+
class IdeaGenRunManager:
"""Persisted run manager for Idea Gen v1 polling APIs."""
@@ -120,10 +177,11 @@ def create_run(
background_tasks: BackgroundTasks,
) -> IdeaGenRunResponse:
run_id = str(uuid.uuid4())
+ runtime_bundle = _build_runtime_bundle(input_payload)
run = create_initial_idea_gen_run(
run_id=run_id,
input_payload=input_payload,
- max_critic_iterations=self._max_critic_iterations(),
+ max_critic_iterations=runtime_bundle.workflow.max_critic_iterations,
)
self._save_run(run)
self._append_event(
@@ -259,156 +317,155 @@ def _execute_run(
) -> None:
current_node: str | None = None
try:
- state = IdeaGenState(
- input=IdeaGenInput(**execution_input.model_dump()),
- thread_id=run_id,
- messages=messages,
- )
- self._append_event(
- run_id,
- event_type="run_started",
- status_value="running",
- message="Background execution started",
- payload={"input_target": display_input.target},
- )
- clarify_executor = NodeExecutor("clarify")
- brief_executor = NodeExecutor("brief")
- query_generation_executor = NodeExecutor("query_generation")
- supervisor_executor = NodeExecutor("supervisor")
- research_executor = IdeaResearchExecutor(node_executor=NodeExecutor("research_dispatch"))
- compress_executor = NodeExecutor("compress")
- report_executor = NodeExecutor("report")
-
- def run_node(node_name: str, fn):
- nonlocal state, current_node
- self._abort_if_deleted(run_id)
- current_node = node_name
- self._save_run(
- self._build_run_from_state(
- run_id=run_id,
- input_payload=display_input,
- state=state,
- status_value="running",
- current_node=node_name,
- )
+ runtime_bundle = _build_runtime_bundle(execution_input)
+ with runtime_config_scope(runtime_bundle):
+ state = IdeaGenState(
+ input=IdeaGenInput(**execution_input.model_dump()),
+ thread_id=run_id,
+ messages=messages,
)
self._append_event(
run_id,
- event_type="node_started",
+ event_type="run_started",
status_value="running",
- node=node_name,
- message=f"Node {node_name} started",
- payload=self._event_payload_from_state(state),
+ message="Background execution started",
+ payload={"input_target": display_input.target},
)
- state = fn(state)
- self._abort_if_deleted(run_id)
- interim_status = (
- "clarification_required"
- if node_name == "clarify" and state.temp_data.get("need_clarification")
- else "running"
- )
- self._save_run(
- self._build_run_from_state(
- run_id=run_id,
- input_payload=display_input,
- state=state,
- status_value=interim_status,
- current_node=node_name if interim_status == "running" else None,
+ clarify_executor = NodeExecutor("clarify")
+ brief_executor = NodeExecutor("brief")
+ query_generation_executor = NodeExecutor("query_generation")
+ supervisor_executor = NodeExecutor("supervisor")
+ research_executor = IdeaResearchExecutor(node_executor=NodeExecutor("research_dispatch"))
+ compress_executor = NodeExecutor("compress")
+ report_executor = NodeExecutor("report")
+
+ def run_node(node_name: str, fn):
+ nonlocal state, current_node
+ self._abort_if_deleted(run_id)
+ current_node = node_name
+ self._save_run(
+ self._build_run_from_state(
+ run_id=run_id,
+ input_payload=display_input,
+ state=state,
+ status_value="running",
+ current_node=node_name,
+ )
)
- )
- self._append_event(
- run_id,
- event_type=(
+ self._append_event(
+ run_id,
+ event_type="node_started",
+ status_value="running",
+ node=node_name,
+ message=f"Node {node_name} started",
+ payload=self._event_payload_from_state(state),
+ )
+ state = fn(state)
+ self._abort_if_deleted(run_id)
+ interim_status = (
"clarification_required"
- if interim_status == "clarification_required"
- else "node_completed"
- ),
- status_value=interim_status,
- node=node_name,
- message=(
- "Run requires clarification before continuing"
- if interim_status == "clarification_required"
- else f"Node {node_name} completed"
- ),
- payload={
- **self._event_payload_from_state(state),
- **(
- {
- "clarification_question": state.temp_data.get(
- "clarification_question",
- "",
- )
- }
+ if node_name == "clarify" and needs_clarification(state)
+ else "running"
+ )
+ self._save_run(
+ self._build_run_from_state(
+ run_id=run_id,
+ input_payload=display_input,
+ state=state,
+ status_value=interim_status,
+ current_node=node_name if interim_status == "running" else None,
+ )
+ )
+ self._append_event(
+ run_id,
+ event_type=(
+ "clarification_required"
+ if interim_status == "clarification_required"
+ else "node_completed"
+ ),
+ status_value=interim_status,
+ node=node_name,
+ message=(
+ "Run requires clarification before continuing"
if interim_status == "clarification_required"
- else {}
+ else f"Node {node_name} completed"
),
- },
+ payload={
+ **self._event_payload_from_state(state),
+ **(
+ {
+ "clarification_question": get_clarification_question(state)
+ }
+ if interim_status == "clarification_required"
+ else {}
+ ),
+ },
+ )
+
+ run_node("start", start_node)
+ run_node("clarify", lambda current: clarify_node(current, clarify_executor))
+ if needs_clarification(state):
+ self._save_run(
+ self._build_run_from_state(
+ run_id=run_id,
+ input_payload=display_input,
+ state=state,
+ status_value="clarification_required",
+ current_node=None,
+ )
+ )
+ return
+
+ run_node("brief", lambda current: brief_node(current, brief_executor))
+ run_node(
+ "query_generation",
+ lambda current: query_generation_node(current, query_generation_executor),
)
- run_node("start", start_node)
- run_node("clarify", lambda current: clarify_node(current, clarify_executor))
- if state.temp_data.get("need_clarification"):
+ while True:
+ run_node("supervisor", lambda current: supervisor_node(current, supervisor_executor))
+ supervisor_action = get_supervisor_action(state, "RESEARCH_COMPLETE")
+
+ if supervisor_action == "THINK":
+ continue
+
+ if supervisor_action == "CONDUCT_RESEARCH":
+ run_node(
+ "query_generation",
+ lambda current: query_generation_node(current, query_generation_executor),
+ )
+ run_node(
+ "research_dispatch",
+ lambda current: research_dispatch_node(current, research_executor),
+ )
+ run_node("compress", lambda current: compress_node(current, compress_executor))
+ continue
+
+ run_node("critic", critic_node)
+ if state.temp_data.get("critic_action") == "ITERATE":
+ continue
+
+ break
+
+ run_node("report", lambda current: report_node(current, report_executor))
+ run_node("finalize", finalize_node)
self._save_run(
self._build_run_from_state(
run_id=run_id,
input_payload=display_input,
state=state,
- status_value="clarification_required",
- current_node=None,
+ status_value="completed",
+ current_node="finalize",
)
)
- return
-
- run_node("brief", lambda current: brief_node(current, brief_executor))
- run_node(
- "query_generation",
- lambda current: query_generation_node(current, query_generation_executor),
- )
-
- while True:
- run_node("supervisor", lambda current: supervisor_node(current, supervisor_executor))
- supervisor_action = state.temp_data.get("supervisor_action", "RESEARCH_COMPLETE")
-
- if supervisor_action == "THINK":
- continue
-
- if supervisor_action == "CONDUCT_RESEARCH":
- run_node(
- "query_generation",
- lambda current: query_generation_node(current, query_generation_executor),
- )
- run_node(
- "research_dispatch",
- lambda current: research_dispatch_node(current, research_executor),
- )
- run_node("compress", lambda current: compress_node(current, compress_executor))
- continue
-
- run_node("critic", critic_node)
- if state.temp_data.get("critic_action") == "ITERATE":
- continue
-
- break
-
- run_node("report", lambda current: report_node(current, report_executor))
- run_node("finalize", finalize_node)
- self._save_run(
- self._build_run_from_state(
- run_id=run_id,
- input_payload=display_input,
- state=state,
+ self._append_event(
+ run_id,
+ event_type="run_completed",
status_value="completed",
- current_node="finalize",
+ node="finalize",
+ message="Run completed successfully",
+ payload=self._event_payload_from_state(state),
)
- )
- self._append_event(
- run_id,
- event_type="run_completed",
- status_value="completed",
- node="finalize",
- message="Run completed successfully",
- payload=self._event_payload_from_state(state),
- )
except _RunDeletedError:
logger.info("Idea Gen run %s was deleted while executing; stopping background task", run_id)
except Exception as exc:
@@ -475,7 +532,7 @@ def _build_run_from_state(
"input": input_payload,
"artifacts": self._list_artifacts(run_id),
"clarification_question": (
- state.temp_data.get("clarification_question")
+ get_clarification_question(state)
if state and status_value == "clarification_required"
else None
),
@@ -484,14 +541,14 @@ def _build_run_from_state(
return previous.model_copy(update=update)
def _papers_count(self, run_id: str, state: IdeaGenState | None) -> int:
- from_state = len({paper.get("paper_id") for paper in (state.temp_data.get("compressed_papers", []) if state else []) if paper.get("paper_id")})
+ from_state = len({paper.get("paper_id") for paper in (get_compressed_papers(state) if state else []) if paper.get("paper_id")})
from_disk = len(list((self._run_dir(run_id) / "papers").glob("*.md")))
manifest_count = int(((state.temp_data.get("storage_manifest") if state else None) or {}).get("papers_count", 0))
return max(from_state, from_disk, manifest_count)
def _compressed_papers_count(self, run_id: str, state: IdeaGenState | None) -> int:
from_state = 0
- for paper in (state.temp_data.get("compressed_papers", []) if state else []):
+ for paper in (get_compressed_papers(state) if state else []):
if any(
paper.get(key)
for key in ("core_summary", "technical_depth", "empirical_support")
@@ -503,7 +560,7 @@ def _compressed_papers_count(self, run_id: str, state: IdeaGenState | None) -> i
def _search_results_count(self, run_id: str, state: IdeaGenState | None) -> int:
from_runs = sum(
len(run.get("results") or [])
- for run in ((state.temp_data.get("research_runs") or []) if state else [])
+ for run in (get_research_runs(state) if state else [])
if isinstance(run, dict)
)
from_disk = len(list((self._run_dir(run_id) / "raw" / "search").glob("*.json")))
@@ -682,6 +739,18 @@ async def list_runs() -> list[IdeaGenRunResponse]:
return run_manager.list_runs()
+@router.get(
+ "/presets",
+ response_model=list[IdeaGenPresetDefinition],
+ summary="List Idea Gen preset metadata",
+)
+async def list_presets() -> list[IdeaGenPresetDefinition]:
+ return [
+ IdeaGenPresetDefinition.model_validate(item)
+ for item in list_preset_descriptors()
+ ]
+
+
@router.get(
"/{run_id}",
response_model=IdeaGenRunResponse,
diff --git a/backend/src/modules/draft_gen/utils/latex_validator.py b/backend/src/modules/draft_gen/utils/latex_validator.py
index 37dda36a..76d37f31 100644
--- a/backend/src/modules/draft_gen/utils/latex_validator.py
+++ b/backend/src/modules/draft_gen/utils/latex_validator.py
@@ -1,7 +1,5 @@
"""LaTeX validator."""
-import re
-
class LatexValidator:
"""Validate LaTeX structure."""
diff --git a/backend/src/modules/draft_gen/workflow.py b/backend/src/modules/draft_gen/workflow.py
index 894701b7..e8b96766 100644
--- a/backend/src/modules/draft_gen/workflow.py
+++ b/backend/src/modules/draft_gen/workflow.py
@@ -3,7 +3,6 @@
import logging
from datetime import datetime
from pathlib import Path
-from typing import Any
from src.modules.draft_gen.schemas import (
DraftGenState, PaperOutline, SectionOutline, SectionProse, ReferenceEntry
diff --git a/backend/src/modules/exp_gen/skills_config.py b/backend/src/modules/exp_gen/skills_config.py
index 13486aae..d6e5141c 100644
--- a/backend/src/modules/exp_gen/skills_config.py
+++ b/backend/src/modules/exp_gen/skills_config.py
@@ -1,7 +1,6 @@
"""Skills configuration for exp_gen module."""
from dataclasses import dataclass
from pathlib import Path
-from types import MappingProxyType
@dataclass
diff --git a/backend/src/modules/exp_gen/utils/run_context.py b/backend/src/modules/exp_gen/utils/run_context.py
index c8a407fe..7ed806c0 100644
--- a/backend/src/modules/exp_gen/utils/run_context.py
+++ b/backend/src/modules/exp_gen/utils/run_context.py
@@ -2,7 +2,6 @@
from datetime import datetime, timezone
from pathlib import Path
-from typing import Any
from uuid import uuid4
from src.modules.exp_gen.schemas import ExpGenState
diff --git a/backend/src/modules/exp_gen/utils/runtime_planner.py b/backend/src/modules/exp_gen/utils/runtime_planner.py
index 1623a470..a9a9143c 100644
--- a/backend/src/modules/exp_gen/utils/runtime_planner.py
+++ b/backend/src/modules/exp_gen/utils/runtime_planner.py
@@ -1,7 +1,5 @@
"""Runtime project-plan and per-task contract helpers for exp_gen."""
-from typing import Any
-
from src.modules.exp_gen.schemas import (
ArtifactContract,
ExpGenState,
@@ -12,7 +10,6 @@
)
from .dataset_manager import _get_dataset_preparation
-from .plan_builder import _coerce_project_plan
from .storage_manager import _load_iteration_checkpoint_payload
def _build_runtime_project_plan(state: ExpGenState) -> ProjectPlan:
diff --git a/backend/src/modules/exp_gen/workflow.py b/backend/src/modules/exp_gen/workflow.py
index d43b6e14..4719cdd7 100644
--- a/backend/src/modules/exp_gen/workflow.py
+++ b/backend/src/modules/exp_gen/workflow.py
@@ -29,7 +29,6 @@
QuickEvalResult,
ReferenceSelectionOutput,
TaskMetadataOutput,
- TaskListOutput,
)
from src.modules.exp_gen.utils import generation_manifest
from src.modules.exp_gen.utils import plan_builder
diff --git a/backend/src/modules/idea_gen/config.py b/backend/src/modules/idea_gen/config.py
index 7d0befdb..eadff883 100644
--- a/backend/src/modules/idea_gen/config.py
+++ b/backend/src/modules/idea_gen/config.py
@@ -1,6 +1,8 @@
"""Configuration for deep_research workflow nodes and runtime limits."""
import os
-from dataclasses import dataclass, field
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass, field, replace
from pathlib import Path
from langchain_openai import ChatOpenAI
@@ -30,6 +32,59 @@ def _default_embedding_model() -> str:
return os.getenv("IDEA_GEN_EMBEDDING_MODEL") or os.getenv("DF_EMBEDDING_MODEL") or "text-embedding-3-small"
+def _default_evidence_lane_hybrid_weights() -> dict[str, dict[str, float]]:
+ return {
+ "inspiration": {"embedding": 0.75, "bm25": 0.25},
+ "novelty": {"embedding": 0.35, "bm25": 0.65},
+ "contradiction": {"embedding": 0.60, "bm25": 0.40},
+ "execution": {"embedding": 0.30, "bm25": 0.70},
+ }
+
+
+def _default_evidence_lane_targets() -> dict[str, int]:
+ return {
+ "inspiration": 1,
+ "novelty": 2,
+ "contradiction": 1,
+ "execution": 1,
+ }
+
+
+def _default_evidence_lane_completeness_weights() -> dict[str, float]:
+ return {
+ "inspiration": 0.15,
+ "novelty": 0.40,
+ "contradiction": 0.25,
+ "execution": 0.20,
+ }
+
+
+def _default_evidence_lane_quality_thresholds() -> dict[str, float]:
+ return {
+ "inspiration": 0.55,
+ "novelty": 0.65,
+ "contradiction": 0.65,
+ "execution": 0.65,
+ }
+
+
+def _default_report_idea_detail_lane_limits() -> dict[str, int]:
+ return {
+ "novelty": 3,
+ "contradiction": 3,
+ "inspiration": 3,
+ "execution": 2,
+ }
+
+
+def _default_report_section_min_citations() -> dict[str, int]:
+ return {
+ "limitations": 2,
+ "idea_detail": 2,
+ "comparison": 2,
+ }
+
+
@dataclass
class NodeLLMConfig:
"""LLM configuration for a single node."""
@@ -63,7 +118,13 @@ class WorkflowRuntimeConfig:
"""Non-LLM runtime configuration for deep_research workflow."""
default_max_iterations: int = 8
+ global_max_iterations: int = 10
max_concurrent_research_units: int = 8
+ search_max_concurrency: int = 4
+ web_fetch_max_concurrency: int = 3
+ llm_max_concurrency: int = 4
+ max_consecutive_thinks: int = 2
+ max_total_thinks_per_phase: int = 3
search_results_per_topic: int = 20
researcher_simple_search_calls_max: int = 3
researcher_complex_search_calls_max: int = 5
@@ -72,6 +133,50 @@ class WorkflowRuntimeConfig:
critic_quality_threshold: float = 7.5
+@dataclass
+class SeedConfig:
+ """Seed discovery configuration."""
+
+ target_seed_count: int = 2
+ min_distinct_seed_directions_for_completion: int = 2
+ json_repair_max_rounds: int = 3
+ max_papers_for_seed_discovery: int = 8 # Top-k papers to use for seed generation
+ max_summary_chars_per_paper: int = 3000 # Max chars per paper summary
+
+
+@dataclass
+class EvidenceConfig:
+ """Evidence retrieval and readiness configuration."""
+
+ top_k: int = 3
+ search_top_k: int = 8
+ max_parallel_seed_workers: int = 4
+ rrf_k: int = 60
+ ready_unique_papers_threshold: int = 5
+ ready_completeness_threshold: float = 0.75
+ lane_targets: dict[str, int] = field(default_factory=_default_evidence_lane_targets)
+ lane_hybrid_weights: dict[str, dict[str, float]] = field(default_factory=_default_evidence_lane_hybrid_weights)
+ lane_completeness_weights: dict[str, float] = field(default_factory=_default_evidence_lane_completeness_weights)
+ lane_quality_thresholds: dict[str, float] = field(default_factory=_default_evidence_lane_quality_thresholds)
+ required_lanes: list[str] = field(default_factory=lambda: ["novelty", "contradiction", "execution"])
+
+
+@dataclass
+class ReportConfig:
+ """Section-wise report generation configuration."""
+
+ idea_detail_reference_pool_size: int = 10
+ report_search_top_k: int = 12
+ idea_detail_prior_work_limit: int = 4
+ idea_detail_contrast_limit: int = 3
+ idea_detail_inspiration_limit: int = 2
+ idea_detail_execution_limit: int = 1
+ idea_detail_lane_limits: dict[str, int] = field(default_factory=_default_report_idea_detail_lane_limits)
+ ideas_overview_citations_per_idea: int = 1
+ section_min_citations: dict[str, int] = field(default_factory=_default_report_section_min_citations)
+ section_retry_max_rounds: int = 1
+
+
@dataclass
class PaperProcessingConfig:
"""Paper processing runtime configuration."""
@@ -111,6 +216,7 @@ class PaperProcessingConfig:
mineru_api_token: str | None = field(default_factory=lambda: os.getenv("MINERU_API_TOKEN"))
mineru_api_endpoint: str = "https://mineru.net/api/v4/extract/task"
enable_embedding_rerank: bool = True
+ pdf_parse_max_concurrency: int = 4
embedding_model: str = field(default_factory=_default_embedding_model)
candidate_pool_size: int = 20
top_k_for_pdf: int = 5
@@ -153,6 +259,18 @@ class CompressionConfig:
empirical_support_max_chars: int = 6000
+@dataclass(frozen=True)
+class IdeaGenRuntimeConfigBundle:
+ """Per-run runtime config bundle used to isolate preset overrides."""
+
+ workflow: WorkflowRuntimeConfig
+ seed: SeedConfig
+ evidence: EvidenceConfig
+ report: ReportConfig
+ paper: PaperProcessingConfig
+ critic: CriticConfig
+
+
NODE_CONFIGS = {
"clarify": NodeLLMConfig(
model="gpt-4o-mini",
@@ -174,6 +292,36 @@ class CompressionConfig:
temperature=0.1,
max_tokens=16000,
),
+ "supervisor_validator": NodeLLMConfig(
+ model="gpt-4o-mini",
+ temperature=0.1,
+ max_tokens=8000,
+ ),
+ "seed_discovery": NodeLLMConfig(
+ model="gpt-4o-mini",
+ temperature=0.1,
+ max_tokens=12000,
+ ),
+ "seed_discovery_validator": NodeLLMConfig(
+ model="gpt-4o-mini",
+ temperature=0.1,
+ max_tokens=8000,
+ ),
+ "evidence_orchestrator": NodeLLMConfig(
+ model="gpt-4o-mini",
+ temperature=0.1,
+ max_tokens=12000,
+ ),
+ "hypothesis": NodeLLMConfig(
+ model="gpt-4o-mini",
+ temperature=0.1,
+ max_tokens=12000,
+ ),
+ "hypothesis_validator": NodeLLMConfig(
+ model="gpt-4o-mini",
+ temperature=0.1,
+ max_tokens=8000,
+ ),
"compress": NodeLLMConfig(
model="gpt-4o-mini",
temperature=0.1,
@@ -217,10 +365,67 @@ class CompressionConfig:
}
WORKFLOW_CONFIG = WorkflowRuntimeConfig()
+SEED_CONFIG = SeedConfig()
+EVIDENCE_CONFIG = EvidenceConfig()
+REPORT_CONFIG = ReportConfig()
PAPER_PROCESSING_CONFIG = PaperProcessingConfig()
CRITIC_CONFIG = CriticConfig()
COMPRESSION_CONFIG = CompressionConfig()
+_RUNTIME_CONFIG_OVERRIDE: ContextVar[IdeaGenRuntimeConfigBundle | None] = ContextVar(
+ "idea_gen_runtime_config_override",
+ default=None,
+)
+
+
+def get_runtime_config_bundle() -> IdeaGenRuntimeConfigBundle:
+ """Return the active runtime config bundle for the current execution context."""
+
+ override = _RUNTIME_CONFIG_OVERRIDE.get()
+ if override is not None:
+ return override
+
+ return IdeaGenRuntimeConfigBundle(
+ workflow=WORKFLOW_CONFIG,
+ seed=SEED_CONFIG,
+ evidence=EVIDENCE_CONFIG,
+ report=REPORT_CONFIG,
+ paper=PAPER_PROCESSING_CONFIG,
+ critic=CRITIC_CONFIG,
+ )
+
+
+def create_runtime_config_bundle(
+ *,
+ workflow_config: dict | None = None,
+ seed_config: dict | None = None,
+ evidence_config: dict | None = None,
+ report_config: dict | None = None,
+ paper_config: dict | None = None,
+ critic_config: dict | None = None,
+) -> IdeaGenRuntimeConfigBundle:
+ """Create a per-run runtime config bundle by overriding the global defaults."""
+
+ return IdeaGenRuntimeConfigBundle(
+ workflow=replace(WORKFLOW_CONFIG, **(workflow_config or {})),
+ seed=replace(SEED_CONFIG, **(seed_config or {})),
+ evidence=replace(EVIDENCE_CONFIG, **(evidence_config or {})),
+ report=replace(REPORT_CONFIG, **(report_config or {})),
+ paper=replace(PAPER_PROCESSING_CONFIG, **(paper_config or {})),
+ critic=replace(CRITIC_CONFIG, **(critic_config or {})),
+ )
+
+
+@contextmanager
+def runtime_config_scope(bundle: IdeaGenRuntimeConfigBundle):
+ """Temporarily apply a per-run runtime config bundle."""
+
+ token = _RUNTIME_CONFIG_OVERRIDE.set(bundle)
+ try:
+ yield
+ finally:
+ _RUNTIME_CONFIG_OVERRIDE.reset(token)
+
def get_node_config(node_name: str) -> NodeLLMConfig:
"""Return the configured LLM settings for a node."""
@@ -237,19 +442,37 @@ def get_node_tool_config(node_name: str) -> NodeToolConfig:
def get_workflow_config() -> WorkflowRuntimeConfig:
"""Return the configured runtime limits for the workflow."""
- return WORKFLOW_CONFIG
+ return get_runtime_config_bundle().workflow
+
+
+def get_seed_config() -> SeedConfig:
+ """Return the configured seed-discovery settings."""
+
+ return get_runtime_config_bundle().seed
+
+
+def get_evidence_config() -> EvidenceConfig:
+ """Return the configured evidence retrieval and readiness settings."""
+
+ return get_runtime_config_bundle().evidence
+
+
+def get_report_config() -> ReportConfig:
+ """Return the configured section-wise report generation settings."""
+
+ return get_runtime_config_bundle().report
def get_paper_processing_config() -> PaperProcessingConfig:
"""Return the configured paper processing settings."""
- return PAPER_PROCESSING_CONFIG
+ return get_runtime_config_bundle().paper
def get_critic_config() -> CriticConfig:
"""Return the configured critic settings."""
- return CRITIC_CONFIG
+ return get_runtime_config_bundle().critic
def get_compression_config() -> CompressionConfig:
diff --git a/backend/src/modules/idea_gen/config_presets.py b/backend/src/modules/idea_gen/config_presets.py
new file mode 100644
index 00000000..0230694f
--- /dev/null
+++ b/backend/src/modules/idea_gen/config_presets.py
@@ -0,0 +1,513 @@
+"""Configuration presets for idea_gen workflow.
+
+提供预设配置模式，简化用户配置。用户只需选择预设模式，系统自动应用最佳参数组合。
+"""
+from dataclasses import dataclass
+from typing import Any
+from typing import Literal
+
+from src.modules.idea_gen.config import (
+ WorkflowRuntimeConfig,
+ SeedConfig,
+ EvidenceConfig,
+ ReportConfig,
+ PaperProcessingConfig,
+ CriticConfig,
+ IdeaGenRuntimeConfigBundle,
+ create_runtime_config_bundle,
+ get_workflow_config,
+)
+
+
+PresetMode = Literal["fast", "balanced", "quality", "custom"]
+
+
+@dataclass
+class WorkflowPreset:
+ """工作流预设配置。
+
+ 预设模式说明：
+ - fast: 快速模式，适合测试和快速迭代（5-10 分钟）
+ - balanced: 平衡模式，质量和速度兼顾（10-20 分钟）
+ - quality: 高质量模式，追求最佳结果（20-40 分钟）
+ - custom: 自定义模式，用户完全控制所有参数
+ """
+
+ mode: PresetMode = "balanced"
+
+ # 可选的自定义覆盖参数
+ workflow_config: WorkflowRuntimeConfig | None = None
+ seed_config: SeedConfig | None = None
+ evidence_config: EvidenceConfig | None = None
+ report_config: ReportConfig | None = None
+ paper_config: PaperProcessingConfig | None = None
+ critic_config: CriticConfig | None = None
+
+
+# ============ 预设配置定义 ============
+
+FAST_PRESET = {
+ "workflow_config": {
+ "default_max_iterations": 2,
+ "global_max_iterations": 4,
+ "max_concurrent_research_units": 2,
+ "max_consecutive_thinks": 2,
+ "max_total_thinks_per_phase": 2,
+ "search_results_per_topic": 5,
+ "max_critic_iterations": 1,
+ "critic_quality_threshold": 6.0,
+ },
+ "seed_config": {
+ "target_seed_count": 2,
+ "min_distinct_seed_directions_for_completion": 2,
+ },
+ "evidence_config": {
+ "top_k": 2,
+ "search_top_k": 10,
+ "max_parallel_seed_workers": 4,
+ "rrf_k": 60,
+ "ready_unique_papers_threshold": 5,
+ "ready_completeness_threshold": 0.70,
+ "lane_targets": {
+ "inspiration": 1,
+ "novelty": 2,
+ "contradiction": 1,
+ "execution": 1,
+ },
+ },
+ "report_config": {
+ "idea_detail_reference_pool_size": 10,
+ "report_search_top_k": 10,
+ "idea_detail_prior_work_limit": 2,
+ "idea_detail_contrast_limit": 2,
+ "idea_detail_inspiration_limit": 1,
+ "idea_detail_execution_limit": 1,
+ "idea_detail_lane_limits": {
+ "novelty": 3,
+ "contradiction": 2,
+ "inspiration": 2,
+ "execution": 1,
+ },
+ "section_retry_max_rounds": 1,
+ },
+ "paper_config": {
+ "enable_scoring": False,
+ "enable_two_tier_storage": True,
+ "enable_pdf_parsing": True,
+ "enable_embedding_rerank": True,
+ "enable_paper_pool": True,
+ "candidate_pool_size": 15,
+ "top_k_for_pdf": 8,
+ "rerank_pool_size": 8,
+ "pool_relevance_threshold": 7.0,
+ "pool_top_k_for_expansion": 5,
+ "pool_max_citations_per_paper": 3,
+ "pool_max_final_papers": 15,
+ "max_papers_to_compress": 15,
+ },
+ "critic_config": {
+ "model_names": ["gpt-4o-mini"],
+ "temperature": 0.3,
+ "max_tokens": 12000,
+ "timeout_seconds": 300,
+ },
+}
+
+
+BALANCED_PRESET = {
+ "workflow_config": {
+ "default_max_iterations": 4,
+ "global_max_iterations": 10,
+ "max_concurrent_research_units": 3,
+ "max_consecutive_thinks": 2,
+ "max_total_thinks_per_phase": 3,
+ "search_results_per_topic": 10,
+ "max_critic_iterations": 2,
+ "critic_quality_threshold": 6.5,
+ },
+ "seed_config": {
+ "target_seed_count": 2,
+ "min_distinct_seed_directions_for_completion": 2,
+ },
+ "evidence_config": {
+ "top_k": 3,
+ "search_top_k": 20,
+ "max_parallel_seed_workers": 4,
+ "rrf_k": 60,
+ "ready_unique_papers_threshold": 8,
+ "ready_completeness_threshold": 0.75,
+ "lane_targets": {
+ "inspiration": 2,
+ "novelty": 3,
+ "contradiction": 2,
+ "execution": 2,
+ },
+ },
+ "report_config": {
+ "idea_detail_reference_pool_size": 20,
+ "report_search_top_k": 20,
+ "idea_detail_prior_work_limit": 3,
+ "idea_detail_contrast_limit": 2,
+ "idea_detail_inspiration_limit": 2,
+ "idea_detail_execution_limit": 1,
+ "idea_detail_lane_limits": {
+ "novelty": 4,
+ "contradiction": 3,
+ "inspiration": 3,
+ "execution": 2,
+ },
+ "section_retry_max_rounds": 1,
+ },
+ "paper_config": {
+ "enable_scoring": False,
+ "enable_two_tier_storage": True,
+ "enable_pdf_parsing": True,
+ "enable_embedding_rerank": True,
+ "enable_paper_pool": True,
+ "candidate_pool_size": 30,
+ "top_k_for_pdf": 15,
+ "rerank_pool_size": 15,
+ "pool_relevance_threshold": 7.5,
+ "pool_top_k_for_expansion": 8,
+ "pool_max_citations_per_paper": 5,
+ "pool_max_final_papers": 20,
+ "max_papers_to_compress": 20,
+ },
+ "critic_config": {
+ "model_names": ["gpt-4o", "gemini-3-flash-preview"],
+ "temperature": 0.3,
+ "max_tokens": 15000,
+ "timeout_seconds": 360,
+ },
+}
+
+
+QUALITY_PRESET = {
+ "workflow_config": {
+ "default_max_iterations": 6,
+ "global_max_iterations": 15,
+ "max_concurrent_research_units": 5,
+ "max_consecutive_thinks": 2,
+ "max_total_thinks_per_phase": 4,
+ "search_results_per_topic": 15,
+ "max_critic_iterations": 3,
+ "critic_quality_threshold": 7.0,
+ },
+ "seed_config": {
+ "target_seed_count": 3,
+ "min_distinct_seed_directions_for_completion": 2,
+ },
+ "evidence_config": {
+ "top_k": 4,
+ "search_top_k": 30,
+ "max_parallel_seed_workers": 4,
+ "rrf_k": 60,
+ "ready_unique_papers_threshold": 12,
+ "ready_completeness_threshold": 0.75,
+ "lane_targets": {
+ "inspiration": 3,
+ "novelty": 4,
+ "contradiction": 3,
+ "execution": 2,
+ },
+ },
+ "report_config": {
+ "idea_detail_reference_pool_size": 30,
+ "report_search_top_k": 30,
+ "idea_detail_prior_work_limit": 4,
+ "idea_detail_contrast_limit": 3,
+ "idea_detail_inspiration_limit": 3,
+ "idea_detail_execution_limit": 2,
+ "idea_detail_lane_limits": {
+ "novelty": 5,
+ "contradiction": 4,
+ "inspiration": 4,
+ "execution": 3,
+ },
+ "section_retry_max_rounds": 2,
+ },
+ "paper_config": {
+ "enable_scoring": True,
+ "enable_two_tier_storage": True,
+ "enable_pdf_parsing": True,
+ "enable_embedding_rerank": True,
+ "enable_paper_pool": True,
+ "candidate_pool_size": 50,
+ "top_k_for_pdf": 25,
+ "rerank_pool_size": 25,
+ "pool_relevance_threshold": 7.5,
+ "pool_top_k_for_expansion": 15,
+ "pool_max_citations_per_paper": 8,
+ "pool_max_final_papers": 30,
+ "max_papers_to_compress": 30,
+ },
+ "critic_config": {
+ "model_names": ["gpt-5.4", "gemini-3-pro-preview"],
+ "temperature": 0.3,
+ "max_tokens": 16000,
+ "timeout_seconds": 480,
+ },
+}
+
+
+PRESET_REGISTRY = {
+ "fast": FAST_PRESET,
+ "balanced": BALANCED_PRESET,
+ "quality": QUALITY_PRESET,
+}
+
+PRESET_LABELS = {
+ "fast": "快速 Fast",
+ "balanced": "平衡 Balanced",
+ "quality": "高质量 Quality",
+ "custom": "自定义 Custom",
+}
+
+PRESET_DESCRIPTIONS = {
+ "fast": "低成本快速探索，适合测试、原型验证和短迭代。",
+ "balanced": "默认生产预设，在质量、成本和耗时之间保持平衡。",
+ "quality": "更高预算换取更深研究与更强 critic 配置。",
+ "custom": "基于系统默认配置手动覆盖参数，不套用固定预设。",
+}
+
+
+def get_preset_config(mode: PresetMode) -> dict:
+ """获取预设配置。
+
+ Args:
+ mode: 预设模式 (fast/balanced/quality/custom)
+
+ Returns:
+ 预设配置字典
+
+ Raises:
+ ValueError: 如果模式不存在
+ """
+ if mode == "custom":
+ return {}
+
+ if mode not in PRESET_REGISTRY:
+ raise ValueError(
+ f"Unknown preset mode: {mode}. "
+ f"Available modes: {list(PRESET_REGISTRY.keys())}"
+ )
+
+ return PRESET_REGISTRY[mode]
+
+
+def apply_preset(
+ mode: PresetMode,
+ overrides: dict | None = None,
+) -> dict:
+ """应用预设配置，支持部分覆盖。
+
+ Args:
+ mode: 预设模式
+ overrides: 可选的覆盖参数，格式：
+ {
+ "workflow_config": {"max_iterations": 5},
+ "paper_config": {"top_k_for_pdf": 20},
+ }
+
+ Returns:
+ 合并后的完整配置
+
+ Example:
+ >>> config = apply_preset("balanced", {
+ ... "workflow_config": {"max_iterations": 5},
+ ... "paper_config": {"enable_scoring": True},
+ ... })
+ """
+ if mode == "custom":
+ return overrides or {}
+
+ preset = get_preset_config(mode)
+
+ if not overrides:
+ return preset
+
+ # 深度合并覆盖参数
+ result = {}
+ for key, value in preset.items():
+ if key in overrides and isinstance(value, dict):
+ result[key] = {**value, **overrides[key]}
+ else:
+ result[key] = overrides.get(key, value)
+
+ # 添加 preset 中没有的覆盖参数
+ for key, value in overrides.items():
+ if key not in result:
+ result[key] = value
+
+ return result
+
+
+def build_runtime_config_bundle(
+ mode: PresetMode,
+ overrides: dict | None = None,
+) -> IdeaGenRuntimeConfigBundle:
+ """Build a per-run runtime config bundle from a preset and optional overrides."""
+
+ resolved = apply_preset(mode, overrides)
+ return create_runtime_config_bundle(
+ workflow_config=resolved.get("workflow_config"),
+ seed_config=resolved.get("seed_config"),
+ evidence_config=resolved.get("evidence_config"),
+ report_config=resolved.get("report_config"),
+ paper_config=resolved.get("paper_config"),
+ critic_config=resolved.get("critic_config"),
+ )
+
+
+def get_preset_descriptor(mode: PresetMode) -> dict[str, Any]:
+ """Return frontend-friendly metadata for a preset mode."""
+
+ if mode == "custom":
+ workflow_config = get_workflow_config()
+ return {
+ "mode": mode,
+ "label": PRESET_LABELS[mode],
+ "description": PRESET_DESCRIPTIONS[mode],
+ "default_max_iterations": workflow_config.default_max_iterations,
+ "max_critic_iterations": workflow_config.max_critic_iterations,
+ }
+
+ preset = get_preset_config(mode)
+ workflow_config = preset["workflow_config"]
+ return {
+ "mode": mode,
+ "label": PRESET_LABELS[mode],
+ "description": PRESET_DESCRIPTIONS[mode],
+ "default_max_iterations": workflow_config["default_max_iterations"],
+ "max_critic_iterations": workflow_config["max_critic_iterations"],
+ }
+
+
+def list_preset_descriptors() -> list[dict[str, Any]]:
+ """Return all preset descriptors in UI display order."""
+
+ return [
+ get_preset_descriptor("fast"),
+ get_preset_descriptor("balanced"),
+ get_preset_descriptor("quality"),
+ get_preset_descriptor("custom"),
+ ]
+
+
+def get_preset_summary(mode: PresetMode) -> str:
+ """获取预设配置的摘要说明。
+
+ Args:
+ mode: 预设模式
+
+ Returns:
+ 配置摘要字符串
+ """
+ summaries = {
+ "fast": """
+快速模式 (Fast Mode)
+==================
+适用场景：测试、快速迭代、原型验证
+预计耗时：5-10 分钟
+成本：低
+
+关键参数：
+- 迭代次数：2 次/阶段
+- PDF 下载：8 篇
+- Critic 模型：1 个（gpt-4o-mini）
+- 论文评分：关闭
+- 证据通道：每通道 1-2 篇
+
+优点：快速反馈，成本低
+缺点：结果质量一般，适合初步探索
+ """,
+
+ "balanced": """
+平衡模式 (Balanced Mode)
+=======================
+适用场景：日常研究、标准工作流、生产环境
+预计耗时：10-20 分钟
+成本：中等
+
+关键参数：
+- 迭代次数：4 次/阶段
+- PDF 下载：15 篇
+- Critic 模型：2 个（gpt-4o-mini + claude-3-5-sonnet）
+- 论文评分：关闭
+- 证据通道：每通道 2-3 篇
+
+优点：质量和速度平衡，性价比高
+缺点：在极端场景下可能不够深入
+ """,
+
+ "quality": """
+高质量模式 (Quality Mode)
+========================
+适用场景：重要研究、论文投稿、深度分析
+预计耗时：20-40 分钟
+成本：高
+
+关键参数：
+- 迭代次数：6 次/阶段
+- PDF 下载：25 篇
+- Critic 模型：3 个（gpt-5.4 + gemini-3-pro + claude-opus-4-6）
+- 论文评分：启用
+- 证据通道：每通道 2-4 篇
+
+优点：最高质量，全面深入
+缺点：耗时长，成本高
+ """,
+
+ "custom": """
+自定义模式 (Custom Mode)
+=======================
+适用场景：特殊需求、精细调优
+预计耗时：取决于配置
+成本：取决于配置
+
+说明：
+用户完全控制所有参数，需要手动配置每个模块。
+建议先从预设模式开始，再根据需求微调。
+ """,
+ }
+
+ return summaries.get(mode, "Unknown mode")
+
+
+def print_preset_comparison():
+ """打印所有预设模式的对比表格。"""
+ print("\n预设模式对比")
+ print("=" * 80)
+ print(f"{'参数':<30} {'Fast':<15} {'Balanced':<15} {'Quality':<15}")
+ print("-" * 80)
+
+ comparisons = [
+ ("预计耗时", "5-10 分钟", "10-20 分钟", "20-40 分钟"),
+ ("成本", "低", "中", "高"),
+ ("迭代次数/阶段", "2", "4", "6"),
+ ("全局预算", "4", "10", "15"),
+ ("PDF 下载数", "8", "15", "25"),
+ ("Critic 模型数", "1", "2", "3"),
+ ("论文评分", "关闭", "关闭", "启用"),
+ ("证据通道论文数", "5 篇", "9 篇", "12 篇"),
+ ("报告引用数", "8 篇", "12 篇", "16 篇"),
+ ]
+
+ for param, fast, balanced, quality in comparisons:
+ print(f"{param:<30} {fast:<15} {balanced:<15} {quality:<15}")
+
+ print("=" * 80)
+ print("\n推荐：")
+ print("- 测试/快速迭代 → fast")
+ print("- 日常研究/生产 → balanced")
+ print("- 重要研究/投稿 → quality")
+ print()
+
+
+if __name__ == "__main__":
+ # 打印对比表格
+ print_preset_comparison()
+
+ # 打印每个模式的详细说明
+ for mode in ["fast", "balanced", "quality"]:
+ print(get_preset_summary(mode))
diff --git a/backend/src/modules/idea_gen/nodes/__init__.py b/backend/src/modules/idea_gen/nodes/__init__.py
new file mode 100644
index 00000000..9fb59331
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/__init__.py
@@ -0,0 +1,43 @@
+"""Workflow nodes for idea_gen."""
+
+from .bootstrap import start_node, clarify_node, brief_node, query_generation_node
+from .compress import compress_node
+from .critic import critic_node
+from .evidence import evidence_orchestrator_node, hypothesis_node
+from .finalize import finalize_node
+from .paper_pool import paper_pool_process_node
+from .report import report_node
+from .research import research_dispatch_node
+from .routing import (
+ route_clarify,
+ route_compress,
+ route_critic,
+ route_query_generation,
+ route_supervisor,
+)
+from .seed import seed_discovery_node, seed_discovery_validate_node
+from .supervisor import supervisor_node, supervisor_validate_node
+
+__all__ = [
+ "start_node",
+ "clarify_node",
+ "brief_node",
+ "query_generation_node",
+ "supervisor_node",
+ "supervisor_validate_node",
+ "research_dispatch_node",
+ "seed_discovery_node",
+ "seed_discovery_validate_node",
+ "evidence_orchestrator_node",
+ "hypothesis_node",
+ "paper_pool_process_node",
+ "compress_node",
+ "critic_node",
+ "report_node",
+ "finalize_node",
+ "route_clarify",
+ "route_query_generation",
+ "route_compress",
+ "route_supervisor",
+ "route_critic",
+]
diff --git a/backend/src/modules/idea_gen/nodes/bootstrap.py b/backend/src/modules/idea_gen/nodes/bootstrap.py
new file mode 100644
index 00000000..db874c2b
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/bootstrap.py
@@ -0,0 +1,342 @@
+"""Bootstrap and query-generation nodes."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from src.modules.idea_gen.config import get_workflow_config
+from src.modules.idea_gen.prompts import (
+ build_brief_prompt,
+ build_clarify_prompt,
+ build_query_generation_prompt,
+)
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import NodeExecutor, query_utils
+from src.modules.idea_gen.utils import workflow_helpers
+from src.modules.idea_gen.utils.error_utils import handle_node_error
+from src.modules.idea_gen.utils.query_planning_utils import (
+ _needs_web_query,
+ _plan_to_queries,
+ _query_generation_mode,
+ _summarize_query_feedback_for_prompt,
+)
+from src.modules.idea_gen.utils.query_state_manager import QueryStateManager
+from src.modules.idea_gen.utils.state_utils import (
+ current_research_phase,
+ get_temp_value,
+ phase_completion_action,
+ reset_supervisor_think_counters,
+ set_temp_value,
+ sync_query_state,
+)
+from src.modules.idea_gen.utils.supervisor_utils import tasks_to_topics
+from src.utils.structured_output import parse_structured_output
+
+
+def start_node(state: IdeaGenState) -> IdeaGenState:
+ """Initialize workflow state."""
+ print("\n[NODE] start - Initializing workflow...")
+ workflow_config = get_workflow_config()
+ state.final_report = ""
+ state.research_runs = []
+ state.iteration_count = 0
+ state.broad_iteration_count = 0
+ state.evidence_iteration_count = 0
+ state.unit_count = 0
+ state.global_max_iterations = max(1, workflow_config.global_max_iterations)
+ set_temp_value(state, "workflow_date", datetime.now().strftime("%Y-%m-%d"))
+ set_temp_value(state, "need_clarification", False)
+ set_temp_value(state, "clarification_question", "")
+ set_temp_value(state, "research_phase", "broad")
+ set_temp_value(state, "supervisor_tasks", [])
+ set_temp_value(state, "supervisor_topics", [])
+ set_temp_value(state, "supervisor_action", "")
+ set_temp_value(state, "supervisor_validation_status", "")
+ set_temp_value(state, "supervisor_validation_rounds", 0)
+ set_temp_value(state, "seed_validation_status", "")
+ set_temp_value(state, "seed_validation_rounds", 0)
+ set_temp_value(state, "final_papers_for_compress", [])
+ set_temp_value(state, "compressed_papers", [])
+ set_temp_value(state, "evidence_status", {})
+ set_temp_value(state, "critic_action", "")
+ reset_supervisor_think_counters(state, "broad")
+ sync_query_state(state)
+ QueryStateManager.ensure_history(state)
+ return state
+
+
+def clarify_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Check whether clarification is required."""
+ print("\n[NODE] clarify - Checking if clarification needed...")
+
+ if not state.input.allow_clarification:
+ state.temp.need_clarification = False
+ state.temp.clarification_question = ""
+ print("[NODE] clarify - Skipped (not allowed)")
+ return state
+
+ messages_str = "\n".join(f"{m.get('role', 'user')}: {m.get('content', '')}" for m in state.messages) if state.messages else f"user: {state.input.target}"
+
+ system, user = build_clarify_prompt(
+ messages_str,
+ date=get_temp_value(state, "workflow_date"),
+ )
+ executor = executor or NodeExecutor("clarify")
+ response = executor.invoke_text(system, user)
+
+ try:
+ data = parse_structured_output(response)
+ need_clarification = data.get("need_clarification", False)
+ state.temp.need_clarification = bool(need_clarification)
+ state.temp.clarification_question = ""
+ if need_clarification:
+ state.temp.clarification_question = data.get("question", "")
+ print(f"[NODE] clarify - Need clarification: {data.get('question', '')[:100]}")
+ else:
+ print("[NODE] clarify - No clarification needed")
+ except Exception as exc:
+ state.temp.need_clarification = False
+ state.temp.clarification_question = ""
+ print(f"[NODE] clarify - Error: {exc}, proceeding without clarification")
+
+ return state
+
+
+def brief_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Generate research brief."""
+ print("\n[NODE] brief - Generating research brief...")
+
+ messages_str = "\n".join(f"{m.get('role', 'user')}: {m.get('content', '')}" for m in state.messages) if state.messages else f"user: {state.input.target}"
+ system, user = build_brief_prompt(
+ messages_str,
+ date=get_temp_value(state, "workflow_date"),
+ language=state.input.language,
+ academic_domain=state.input.academic_domain,
+ target_venues=state.input.target_venues,
+ )
+ executor = executor or NodeExecutor("brief")
+ response = executor.invoke_text(system, user)
+
+ try:
+ data = parse_structured_output(response)
+ state.research_brief = data.get("research_brief", state.input.target)
+ except Exception:
+ state.research_brief = state.input.target
+
+ state.paper_queries = []
+ state.web_queries = []
+
+ print(f"[NODE] brief - Done: {state.research_brief[:100]}...")
+ workflow_helpers._save_artifact(state, "research_brief.md", state.research_brief)
+ workflow_helpers._save_node_state(state, "brief")
+ return state
+
+
+def query_generation_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Generate or rewrite query plans."""
+ mode = _query_generation_mode(state)
+ query_state = sync_query_state(state)
+ QueryStateManager.ensure_history(state)
+ previous_active_paper_queries = list(query_state.get("active_paper_queries", []) or state.paper_queries)
+ previous_active_web_queries = list(query_state.get("active_web_queries", []) or state.web_queries)
+ print(f"\n[NODE] query_generation - Generating search queries ({mode})...")
+
+ if mode == "reuse_initial":
+ state.paper_queries = list(previous_active_paper_queries)
+ state.web_queries = list(previous_active_web_queries)
+ print(
+ f"[NODE] query_generation - Reusing initial active queries: "
+ f"{len(state.paper_queries)} paper, {len(state.web_queries)} web"
+ )
+ workflow_helpers._save_node_state(state, "query_generation")
+ return state
+
+ query_feedback = get_temp_value(state, "query_feedback", {}) or {}
+ latest_supervisor = state.supervisor_messages[-1] if state.supervisor_messages else {}
+ supervisor_tasks = list(get_temp_value(state, "supervisor_tasks", []) or [])
+ system, user = build_query_generation_prompt(
+ target=state.input.target,
+ research_brief=state.research_brief,
+ date=get_temp_value(state, "workflow_date"),
+ academic_domain=state.input.academic_domain,
+ target_venues=state.input.target_venues,
+ mode=mode,
+ current_active_queries={
+ "paper_queries": list(query_state.get("active_paper_queries", []) or state.paper_queries),
+ "web_queries": list(query_state.get("active_web_queries", []) or state.web_queries),
+ "paper_query_plan": list(query_state.get("active_paper_query_plan", []) or []),
+ "web_query_plan": list(query_state.get("active_web_query_plan", []) or []),
+ },
+ supervisor_reflection=latest_supervisor.get("reflection", ""),
+ supervisor_topics=list(get_temp_value(state, "supervisor_topics", []) or []),
+ supervisor_tasks=supervisor_tasks,
+ query_feedback=_summarize_query_feedback_for_prompt(query_feedback),
+ query_history=state.temp_data.get("query_history") or {},
+ )
+ executor = executor or NodeExecutor("query_generation")
+ try:
+ response = executor.invoke_text(system, user)
+ except Exception as exc:
+ fatal = mode == "initial"
+ handle_node_error(
+ state,
+ node="query_generation",
+ error=exc,
+ recoverable=not fatal,
+ message=f"query generation failed in {mode} mode",
+ fatal=fatal,
+ )
+ response = ""
+
+ rewrite_strategy = "initial" if mode == "initial" else "retain"
+ rewrite_reason = "initial query generation from target + brief"
+ next_paper_plan: list[dict] = []
+ next_web_plan: list[dict] = []
+ need_more_queries = True
+ missing_aspects = list(query_feedback.get("missing_aspects", []) or [])
+
+ try:
+ data = parse_structured_output(response)
+ need_more_queries = bool(data.get("need_more_queries", True))
+ response_missing = list(data.get("missing_aspects", []) or [])
+ if response_missing:
+ missing_aspects = [item for item in (query_utils.normalize_query_text(v) for v in response_missing) if item]
+ next_paper_plan = query_utils.coerce_plan(
+ data.get("paper_queries"),
+ channel="paper",
+ limit=6,
+ default_source="model",
+ fallback_role="candidate",
+ )
+ next_web_plan = query_utils.coerce_plan(
+ data.get("web_queries"),
+ channel="web",
+ limit=6,
+ default_source="model",
+ fallback_role="candidate",
+ )
+ rewrite_strategy = query_utils.normalize_query_text(data.get("rewrite_strategy", rewrite_strategy)).lower() or rewrite_strategy
+ rewrite_reason = query_utils.normalize_query_text(data.get("reason", rewrite_reason)) or rewrite_reason
+ except Exception:
+ next_paper_plan = []
+ next_web_plan = []
+ need_more_queries = mode == "initial"
+
+ if mode == "initial":
+ next_paper_plan = query_utils.dedupe_and_filter_plan(
+ next_paper_plan,
+ target=state.input.target,
+ research_brief=state.research_brief,
+ channel="paper",
+ limit=3,
+ )
+ if len(next_paper_plan) < 3:
+ for candidate in query_utils.default_initial_queries(state.input.target, state.research_brief):
+ if len(next_paper_plan) >= 3:
+ break
+ next_paper_plan = query_utils.dedupe_and_filter_plan(
+ [*next_paper_plan, candidate],
+ target=state.input.target,
+ research_brief=state.research_brief,
+ channel="paper",
+ limit=3,
+ )
+ next_web_plan = []
+ else:
+ if rewrite_strategy == "stop" or not need_more_queries:
+ next_paper_plan = []
+ next_web_plan = []
+ else:
+ next_paper_plan = query_utils.dedupe_and_filter_plan(
+ next_paper_plan,
+ target=state.input.target,
+ research_brief=state.research_brief,
+ channel="paper",
+ limit=2,
+ )
+ next_web_plan = query_utils.dedupe_and_filter_plan(
+ next_web_plan,
+ target=state.input.target,
+ research_brief=state.research_brief,
+ channel="web",
+ limit=1,
+ )
+ gap_inputs = missing_aspects or tasks_to_topics(supervisor_tasks) or list(get_temp_value(state, "supervisor_topics", []) or [])
+ if not next_paper_plan and gap_inputs:
+ next_paper_plan = query_utils.default_iterative_queries(
+ target=state.input.target,
+ research_brief=state.research_brief,
+ missing_aspects=gap_inputs,
+ channel="paper",
+ )
+ if not next_web_plan and gap_inputs and _needs_web_query(gap_inputs):
+ next_web_plan = query_utils.default_iterative_queries(
+ target=state.input.target,
+ research_brief=state.research_brief,
+ missing_aspects=gap_inputs,
+ channel="web",
+ )
+
+ next_paper_queries = _plan_to_queries(next_paper_plan, limit=3)
+ next_web_queries = _plan_to_queries(next_web_plan, limit=3)
+ dropped_queries = (
+ query_utils.compute_dropped(previous_active_paper_queries, next_paper_queries)
+ + query_utils.compute_dropped(previous_active_web_queries, next_web_queries)
+ ) if mode != "initial" else []
+
+ state.paper_queries = next_paper_queries
+ state.web_queries = next_web_queries
+
+ if mode == "initial":
+ query_state["seed_paper_queries"] = list(next_paper_queries)
+ query_state["seed_web_queries"] = list(next_web_queries)
+ query_state["seed_paper_query_plan"] = list(next_paper_plan)
+ query_state["seed_web_query_plan"] = list(next_web_plan)
+
+ query_state["active_paper_queries"] = list(next_paper_queries)
+ query_state["active_web_queries"] = list(next_web_queries)
+ query_state["active_paper_query_plan"] = list(next_paper_plan)
+ query_state["active_web_query_plan"] = list(next_web_plan)
+ query_state["last_rewrite_strategy"] = rewrite_strategy
+ query_state["coverage_summary"] = dict(query_feedback.get("coverage_summary", {}) or {})
+ query_state["missing_aspects"] = list(missing_aspects)
+
+ entry = {
+ "iteration": state.iteration_count,
+ "mode": mode,
+ "need_more_queries": need_more_queries,
+ "paper_queries": list(next_paper_queries),
+ "web_queries": list(next_web_queries),
+ "paper_query_plan": list(next_paper_plan),
+ "web_query_plan": list(next_web_plan),
+ "missing_aspects": list(missing_aspects),
+ "strategy": rewrite_strategy,
+ "reason": rewrite_reason,
+ "dropped_queries": dropped_queries,
+ }
+ QueryStateManager.record_entry(state, entry)
+ set_temp_value(state, "query_state", query_state)
+
+ if mode != "initial" and not state.paper_queries and not state.web_queries and (rewrite_strategy == "stop" or not need_more_queries):
+ completion_action = phase_completion_action(current_research_phase(state))
+ set_temp_value(state, "supervisor_action", completion_action)
+ set_temp_value(state, "supervisor_tasks", [])
+ set_temp_value(state, "supervisor_topics", [])
+
+ if mode == "initial" and not state.paper_queries:
+ error = ValueError("initial query generation produced no usable paper queries")
+ handle_node_error(
+ state,
+ node="query_generation",
+ error=error,
+ recoverable=False,
+ message=str(error),
+ fatal=True,
+ )
+
+ print(
+ f"[NODE] query_generation - Done ({rewrite_strategy}): "
+ f"{len(state.paper_queries)} paper queries, {len(state.web_queries)} web queries"
+ )
+ workflow_helpers._save_node_state(state, "query_generation")
+ return state
diff --git a/backend/src/modules/idea_gen/nodes/compress.py b/backend/src/modules/idea_gen/nodes/compress.py
new file mode 100644
index 00000000..81c74439
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/compress.py
@@ -0,0 +1,12 @@
+"""Compression node."""
+
+from __future__ import annotations
+
+from src.modules.idea_gen.services import CompressionService
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import NodeExecutor
+
+
+def compress_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Compress selected papers."""
+ return CompressionService().run(state, executor=executor)
diff --git a/backend/src/modules/idea_gen/nodes/critic.py b/backend/src/modules/idea_gen/nodes/critic.py
new file mode 100644
index 00000000..805948ee
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/critic.py
@@ -0,0 +1,139 @@
+"""Critic node."""
+
+from __future__ import annotations
+
+import asyncio
+
+from src.modules.idea_gen.config import get_critic_config, get_workflow_config
+from src.modules.idea_gen.prompts import build_critic_prompt
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils.critic_executor import MultiModelCriticExecutor, aggregate_critiques
+from src.modules.idea_gen.utils.workflow_helpers import _save_node_state
+from src.modules.idea_gen.utils.state_utils import set_temp_value
+
+
+def _finalize_critic_state(
+ state: IdeaGenState,
+ *,
+ action: str,
+ status: str,
+ ran: bool,
+ successful_models: int = 0,
+ avg_score: float | None = None,
+) -> IdeaGenState:
+ """Persist critic execution metadata on state."""
+ set_temp_value(state, "critic_action", action)
+ state.temp_data["critic_action"] = action
+ state.temp_data["critic_status"] = status
+ state.temp_data["critic_ran"] = ran
+ state.temp_data["critic_successful_models"] = successful_models
+ if avg_score is None:
+ state.temp_data.pop("critic_avg_score", None)
+ else:
+ state.temp_data["critic_avg_score"] = avg_score
+ _save_node_state(state, f"critic_iter{state.critic_iteration_count}")
+ return state
+
+
+def critic_node(state: IdeaGenState) -> IdeaGenState:
+ """Run multi-model critique and decide iterate vs accept."""
+ print(f"\n[NODE] critic - Iteration {state.critic_iteration_count}")
+
+ critic_config = get_critic_config()
+ workflow_config = get_workflow_config()
+
+ configured_models = [
+ model_name
+ for model_name in critic_config.model_names
+ if model_name and model_name.strip()
+ ]
+ state.temp_data["critic_requested_models"] = configured_models
+ if not configured_models:
+ print("[NODE] critic - Skipped (no models configured)")
+ return _finalize_critic_state(
+ state,
+ action="ACCEPT",
+ status="skipped_no_models",
+ ran=False,
+ )
+
+ effective_min_successful_models = min(
+ max(1, critic_config.min_successful_models),
+ len(configured_models),
+ )
+
+ if state.critic_iteration_count >= workflow_config.max_critic_iterations:
+ print("[NODE] critic - ACCEPT (max iterations)")
+ return _finalize_critic_state(
+ state,
+ action="ACCEPT",
+ status="accepted_max_iterations",
+ ran=False,
+ )
+
+ system, user = build_critic_prompt(
+ research_brief=state.research_brief,
+ notes=state.notes,
+ previous_feedback=state.critic_feedback,
+ )
+
+ executor = MultiModelCriticExecutor()
+ model_results = asyncio.run(executor.evaluate_parallel(system, user))
+
+ if not model_results:
+ print("[NODE] critic - ACCEPT (no results)")
+ return _finalize_critic_state(
+ state,
+ action="ACCEPT",
+ status="accepted_no_results",
+ ran=True,
+ successful_models=0,
+ )
+
+ if len(model_results) < effective_min_successful_models:
+ print(
+ "[NODE] critic - ACCEPT "
+ f"(insufficient successful models: {len(model_results)}/{effective_min_successful_models})"
+ )
+ return _finalize_critic_state(
+ state,
+ action="ACCEPT",
+ status="accepted_insufficient_models",
+ ran=True,
+ successful_models=len(model_results),
+ )
+
+ aggregated = aggregate_critiques(model_results)
+ avg_score = sum(aggregated.consensus_scores.values()) / len(aggregated.consensus_scores)
+
+ if avg_score >= workflow_config.critic_quality_threshold:
+ state.critic_feedback = None
+ print(f"[NODE] critic - ACCEPT (score: {avg_score:.1f})")
+ return _finalize_critic_state(
+ state,
+ action="ACCEPT",
+ status="accepted_threshold",
+ ran=True,
+ successful_models=len(model_results),
+ avg_score=avg_score,
+ )
+
+ blocking = [
+ f"{dimension}: {score:.1f}/10"
+ for dimension, score in aggregated.consensus_scores.items()
+ if score < workflow_config.critic_quality_threshold
+ ]
+ state.critic_feedback = {
+ "blocking_issues": ", ".join(blocking),
+ "suggestions": aggregated.summary,
+ }
+ state.critic_iteration_count += 1
+ print(f"[NODE] critic - ITERATE (score: {avg_score:.1f})")
+ return _finalize_critic_state(
+ state,
+ action="ITERATE",
+ status="iterate_threshold",
+ ran=True,
+ successful_models=len(model_results),
+ avg_score=avg_score,
+ )
diff --git a/backend/src/modules/idea_gen/nodes/evidence.py b/backend/src/modules/idea_gen/nodes/evidence.py
new file mode 100644
index 00000000..c1dfb661
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/evidence.py
@@ -0,0 +1,245 @@
+"""Evidence and hypothesis nodes."""
+
+from __future__ import annotations
+
+import json
+from concurrent.futures import as_completed
+from typing import Any
+
+from src.modules.idea_gen.config import create_node_model, get_evidence_config
+from src.modules.idea_gen.prompts import build_hypothesis_prompt, build_hypothesis_validation_prompt
+from src.modules.idea_gen.schemas import EvidenceBundle, Hypothesis
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import NodeExecutor
+from src.modules.idea_gen.utils import workflow_helpers
+from src.modules.idea_gen.utils.embedding_store import EmbeddingStore
+from src.modules.idea_gen.utils.evidence_retriever import (
+ RetrieverConfig,
+ build_evidence_bundle_with_diagnostics,
+)
+from src.modules.idea_gen.utils.evidence_utils import extract_allowed_paper_keys_from_bundle
+from src.modules.idea_gen.utils.error_utils import handle_node_error
+from src.modules.idea_gen.utils.state_utils import get_final_papers_for_compress, get_temp_value, set_temp_value
+from src.modules.idea_gen.utils.thread_pool_manager import ThreadPoolManager
+from src.utils.structured_output import parse_structured_output
+
+
+def evidence_orchestrator_node(state: IdeaGenState) -> IdeaGenState:
+ """Build EvidenceBundle for each seed via 4-lane parallel retrieval."""
+ import asyncio
+
+ def _run_coroutine(coro: Any) -> Any:
+ loop = asyncio.new_event_loop()
+ try:
+ asyncio.set_event_loop(loop)
+ return loop.run_until_complete(coro)
+ finally:
+ asyncio.set_event_loop(None)
+ loop.close()
+
+ def _clone_embedding_store(source: EmbeddingStore) -> EmbeddingStore:
+ cloned = EmbeddingStore()
+ cloned._paper_keys = list(source._paper_keys)
+ cloned._docs = list(source._docs)
+ cloned._bm25 = source._bm25
+ cloned._chunk_keys = list(source._chunk_keys)
+ cloned._chunk_texts = list(source._chunk_texts)
+ cloned._chunk_vectors = source._chunk_vectors
+ return cloned
+
+ print("\n[NODE] evidence_orchestrator - Building evidence bundles...")
+
+ if not state.seeds:
+ print("[NODE] evidence_orchestrator - No seeds, skipping")
+ return state
+
+ output_dir = workflow_helpers._get_output_dir(state)
+ papers_dir = output_dir / "papers"
+ selected_papers = get_final_papers_for_compress(state)
+ pool_papers = selected_papers or (state.paper_pool.get_all_papers() if state.paper_pool else [])
+
+ paper_docs: dict[str, str] = {}
+ for paper in pool_papers:
+ key = paper.get("paper_key", "")
+ if not key:
+ continue
+ md_file = papers_dir / f"{paper.get('paper_id', key)}.md"
+ if md_file.exists():
+ paper_docs[key] = md_file.read_text(encoding="utf-8")
+ else:
+ paper_docs[key] = f"{paper.get('title', '')} {paper.get('abstract', '')}"
+
+ store = EmbeddingStore()
+ store.build(
+ [
+ {
+ "paper_key": paper.get("paper_key", ""),
+ "title": paper.get("title", ""),
+ "abstract": paper.get("abstract", ""),
+ }
+ for paper in pool_papers
+ if paper.get("paper_key")
+ ]
+ )
+ try:
+ _run_coroutine(store.build_embeddings())
+ except Exception as exc:
+ handle_node_error(
+ state,
+ node="evidence_orchestrator",
+ error=exc,
+ recoverable=True,
+ message="embedding build failed for evidence retrieval; falling back to lexical support",
+ )
+ print(f"[NODE] evidence_orchestrator - Embedding build failed: {exc}")
+
+ evidence_config = get_evidence_config()
+ cfg = RetrieverConfig(
+ top_k=evidence_config.top_k,
+ search_top_k=evidence_config.search_top_k,
+ rrf_k=evidence_config.rrf_k,
+ ready_unique_papers_threshold=evidence_config.ready_unique_papers_threshold,
+ ready_completeness_threshold=evidence_config.ready_completeness_threshold,
+ lane_targets=dict(evidence_config.lane_targets),
+ lane_hybrid_weights={lane: dict(weights) for lane, weights in evidence_config.lane_hybrid_weights.items()},
+ lane_completeness_weights=dict(evidence_config.lane_completeness_weights),
+ lane_quality_thresholds=dict(evidence_config.lane_quality_thresholds),
+ required_lanes=tuple(evidence_config.required_lanes),
+ )
+
+ def _build_for_seed(seed: Any) -> tuple[Any, dict[str, Any]]:
+ seed_store = _clone_embedding_store(store)
+ llm = create_node_model("evidence_orchestrator")
+ return _run_coroutine(
+ build_evidence_bundle_with_diagnostics(
+ seed,
+ seed_store,
+ paper_docs,
+ llm,
+ cfg,
+ )
+ )
+
+ bundle_results: list[tuple[Any, dict[str, Any]] | None] = [None] * len(state.seeds)
+ pool = ThreadPoolManager.get_compute_pool()
+ future_to_index = {
+ pool.submit(_build_for_seed, seed): index
+ for index, seed in enumerate(state.seeds)
+ }
+ for future in as_completed(future_to_index):
+ index = future_to_index[future]
+ seed = state.seeds[index]
+ try:
+ bundle_results[index] = future.result()
+ except Exception as exc:
+ handle_node_error(
+ state,
+ node="evidence_orchestrator",
+ error=exc,
+ recoverable=True,
+ message=f"evidence bundle build failed for seed {seed.seed_id}",
+ )
+ bundle_results[index] = (
+ EvidenceBundle(seed_id=seed.seed_id),
+ {
+ "seed_id": seed.seed_id,
+ "lane_diagnostics": {},
+ "evidence_status": {
+ "seed_id": seed.seed_id,
+ "ready_for_hypothesis": False,
+ "blocking_lanes": ["novelty", "contradiction", "execution"],
+ "evidence_gaps": ["evidence bundle construction failed"],
+ },
+ },
+ )
+
+ bundles = [bundle for bundle, _diag in bundle_results if bundle is not None]
+ diagnostics = [diag for _bundle, diag in bundle_results if diag is not None]
+ seed_statuses = [diag.get("evidence_status", {}) for diag in diagnostics]
+ phase_ready = bool(seed_statuses) and all(item.get("ready_for_hypothesis", False) for item in seed_statuses)
+
+ state.evidence_bundles = list(bundles)
+ set_temp_value(
+ state,
+ "evidence_status",
+ {
+ "phase_ready": phase_ready,
+ "seed_statuses": seed_statuses,
+ },
+ )
+ state.temp_data["evidence_lane_diagnostics"] = diagnostics
+ workflow_helpers._save_artifact(
+ state,
+ "evidence_status.json",
+ json.dumps(get_temp_value(state, "evidence_status", {}), ensure_ascii=False, indent=2),
+ )
+ workflow_helpers._save_artifact(
+ state,
+ "evidence_lane_diagnostics.json",
+ json.dumps(diagnostics, ensure_ascii=False, indent=2),
+ )
+ print(f"[NODE] evidence_orchestrator - Built {len(state.evidence_bundles)} bundles")
+ return state
+
+
+def hypothesis_node(
+ state: IdeaGenState,
+ executor: NodeExecutor | None = None,
+ validator_executor: NodeExecutor | None = None,
+) -> IdeaGenState:
+ """Build Hypothesis for each seed from its EvidenceBundle."""
+ print("\n[NODE] hypothesis - Building hypotheses...")
+ executor = executor or NodeExecutor("hypothesis")
+ validator_executor = validator_executor or NodeExecutor("hypothesis_validator")
+ max_rounds = 3
+
+ bundle_map = {bundle.seed_id: bundle for bundle in state.evidence_bundles}
+ hypotheses: list[Hypothesis] = []
+ for seed in state.seeds:
+ bundle = bundle_map.get(seed.seed_id)
+ if not bundle:
+ continue
+ system, user = build_hypothesis_prompt(
+ seed_json=seed.model_dump_json(indent=2),
+ evidence_bundle_json=bundle.model_dump_json(indent=2),
+ )
+ allowed_paper_keys = extract_allowed_paper_keys_from_bundle(bundle)
+ try:
+ response = executor.invoke_messages([
+ {"role": "system", "content": system},
+ {"role": "user", "content": user},
+ ])
+ candidate = NodeExecutor.get_text(response)
+ workflow_helpers._save_artifact(state, f"hypothesis_raw_{seed.seed_id}.txt", candidate)
+
+ last_error: Exception | None = None
+ for attempt in range(max_rounds + 1):
+ try:
+ data = parse_structured_output(candidate, dict)
+ data["evidence_trace"] = bundle.model_dump()
+ hypotheses.append(Hypothesis(**data))
+ break
+ except Exception as exc:
+ last_error = exc
+ if attempt >= max_rounds:
+ raise
+ repair_system, repair_user = build_hypothesis_validation_prompt(
+ raw_hypothesis_output=candidate,
+ seed_json=seed.model_dump_json(indent=2),
+ evidence_bundle_json=bundle.model_dump_json(indent=2),
+ allowed_paper_keys=allowed_paper_keys,
+ )
+ candidate = validator_executor.invoke_text(repair_system, repair_user)
+ workflow_helpers._save_artifact(
+ state,
+ f"hypothesis_validation_{seed.seed_id}_attempt_{attempt + 1}.txt",
+ candidate,
+ )
+ if last_error is not None and hypotheses and hypotheses[-1].seed_id == seed.seed_id:
+ print(f"[NODE] hypothesis - Repaired hypothesis for seed {seed.seed_id}")
+ except Exception as exc:
+ print(f"[NODE] hypothesis - Error for seed {seed.seed_id}: {exc}")
+
+ state.hypotheses = hypotheses
+ print(f"[NODE] hypothesis - Built {len(state.hypotheses)} hypotheses")
+ return state
diff --git a/backend/src/modules/idea_gen/nodes/finalize.py b/backend/src/modules/idea_gen/nodes/finalize.py
new file mode 100644
index 00000000..311eb008
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/finalize.py
@@ -0,0 +1,12 @@
+"""Finalize node."""
+
+from __future__ import annotations
+
+from src.modules.idea_gen.state import IdeaGenState
+
+
+def finalize_node(state: IdeaGenState) -> IdeaGenState:
+ """Finish the workflow and print a compact summary."""
+ print("\n[NODE] finalize - Workflow complete")
+ print(f"[SUMMARY] Iterations: {state.iteration_count}, Units: {state.unit_count}")
+ return state
diff --git a/backend/src/modules/idea_gen/nodes/paper_pool.py b/backend/src/modules/idea_gen/nodes/paper_pool.py
new file mode 100644
index 00000000..cc114eea
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/paper_pool.py
@@ -0,0 +1,12 @@
+"""Paper pool node."""
+
+from __future__ import annotations
+
+from src.modules.idea_gen.services import PaperPoolService
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import NodeExecutor
+
+
+def paper_pool_process_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Process paper pool."""
+ return PaperPoolService().process(state, executor=executor)
diff --git a/backend/src/modules/idea_gen/nodes/report.py b/backend/src/modules/idea_gen/nodes/report.py
new file mode 100644
index 00000000..938f11b4
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/report.py
@@ -0,0 +1,214 @@
+"""Report node."""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any
+
+from src.modules.idea_gen.config import get_report_config
+from src.modules.idea_gen.prompts import build_report_prompt, build_report_section_prompt
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import NodeExecutor
+from src.modules.idea_gen.utils import workflow_helpers
+from src.modules.idea_gen.utils.report_builder import (
+ build_citation_retry_feedback,
+ build_fixed_report_outline,
+ build_report_retrieval_context,
+ build_section_payload,
+ build_source_catalog,
+ lint_section_citations,
+ renumber_citations,
+ render_outline_markdown,
+ render_sources_section,
+ sanitize_section_markdown,
+)
+from src.modules.idea_gen.utils.report_source_handler import ReportSourceHandler
+from src.modules.idea_gen.utils.state_utils import get_temp_value, set_final_report
+
+
+def _messages_text(state: IdeaGenState) -> str:
+ if state.messages:
+ return "\n".join(
+ f"{message.get('role', 'user')}: {message.get('content', '')}"
+ for message in state.messages
+ )
+ return f"user: {state.input.target}"
+
+
+def report_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Generate the final report."""
+ node_start = time.time()
+ print("\n[NODE] report - Generating final report...")
+
+ messages_str = _messages_text(state)
+ executor = executor or NodeExecutor("report")
+ report_config = get_report_config()
+ workflow_date = get_temp_value(state, "workflow_date")
+
+ hypotheses_json = ""
+ if state.hypotheses:
+ hypotheses_json = json.dumps(
+ [hypothesis.model_dump(exclude={"evidence_trace"}) for hypothesis in state.hypotheses],
+ ensure_ascii=False,
+ indent=2,
+ )
+
+ if not state.hypotheses:
+ system = build_report_prompt(
+ research_brief=state.research_brief,
+ messages=messages_str,
+ findings=state.notes,
+ date=workflow_date,
+ language=state.input.language,
+ target_venues=state.input.target_venues,
+ hypotheses_json=hypotheses_json,
+ )
+ user = f"Research brief:\n{state.research_brief}\n\nNotes:\n{state.notes}"
+ response = executor.invoke_text(system, user)
+ response = ReportSourceHandler.repair_sources(response, state)
+ set_final_report(state, response)
+ workflow_helpers._save_artifact(state, "final_report.md", response)
+ workflow_helpers._save_node_state(state, "report")
+ total_ms = round((time.time() - node_start) * 1000, 2)
+ state.temp_data["report_timing"] = {"total_ms": total_ms}
+ print(f"[NODE] report - report.total_ms={total_ms:.2f}")
+ print(f"[NODE] report - Done, {len(response)} chars")
+ return state
+
+ source_catalog = build_source_catalog(state)
+ report_retrieval_context = build_report_retrieval_context(state, source_catalog)
+ outline = build_fixed_report_outline(state)
+ outline_markdown = render_outline_markdown(outline)
+ sources_heading = next(
+ (
+ section.get("heading", "## Sources")
+ for section in outline
+ if section.get("section_id") == "sources"
+ ),
+ "## Sources",
+ )
+
+ state.temp_data["report_outline"] = outline
+ state.temp_data["report_source_catalog"] = list(source_catalog.values())
+ workflow_helpers._save_artifact(state, "report_outline.md", outline_markdown)
+ workflow_helpers._save_artifact(
+ state,
+ "report_source_catalog.json",
+ json.dumps(list(source_catalog.values()), ensure_ascii=False, indent=2),
+ )
+
+ report_sections = [
+ section for section in outline
+ if section.get("section_id") != "sources"
+ ]
+ generated_sections: list[str] = []
+ section_payloads: list[dict[str, Any]] = []
+ section_lint_results: list[dict[str, Any]] = []
+ for index, section in enumerate(report_sections, start=1):
+ section_payload = build_section_payload(
+ state,
+ section,
+ source_catalog,
+ retrieval_context=report_retrieval_context,
+ )
+ section_payloads.append(section_payload)
+ print(
+ f"[REPORT] Section {index}/{len(report_sections)} - "
+ f"{section.get('heading', section.get('section_id', 'unknown'))}"
+ )
+ system, user = build_report_section_prompt(
+ research_brief=state.research_brief,
+ section_id=section.get("section_id", ""),
+ section_heading=section.get("heading", ""),
+ section_goal=section.get("goal", ""),
+ section_instruction=section.get("instruction", ""),
+ outline_markdown=outline_markdown,
+ section_context_json=json.dumps(section_payload, ensure_ascii=False, indent=2),
+ allowed_sources_json=json.dumps(
+ section_payload.get("sources", []),
+ ensure_ascii=False,
+ indent=2,
+ ),
+ date=workflow_date,
+ language=state.input.language,
+ target_venues=state.input.target_venues,
+ )
+ raw_section = executor.invoke_text(system, user)
+ normalized_section = sanitize_section_markdown(
+ raw_section,
+ section.get("heading", "## Section"),
+ )
+ lint_result = lint_section_citations(section, section_payload, normalized_section)
+
+ retry_attempts = 0
+ max_retry_rounds = max(0, int(report_config.section_retry_max_rounds))
+ while not lint_result["valid"] and retry_attempts < max_retry_rounds:
+ retry_attempts += 1
+ print(
+ f"[REPORT] Citation lint retry for {section.get('section_id', 'unknown')}: "
+ + "; ".join(lint_result.get("errors", []))
+ )
+ retry_feedback = build_citation_retry_feedback(lint_result, section_payload)
+ retry_user = f"{user}\n\n\n{retry_feedback}\n"
+ retry_raw_section = executor.invoke_text(system, retry_user)
+ retry_normalized_section = sanitize_section_markdown(
+ retry_raw_section,
+ section.get("heading", "## Section"),
+ )
+ retry_lint_result = lint_section_citations(
+ section,
+ section_payload,
+ retry_normalized_section,
+ )
+ retry_lint_result["retried"] = True
+ retry_lint_result["retry_round"] = retry_attempts
+ retry_lint_result["first_pass_errors"] = lint_result.get(
+ "first_pass_errors",
+ lint_result.get("errors", []),
+ )
+ if retry_lint_result["valid"] or len(retry_lint_result.get("valid_keys", [])) >= len(
+ lint_result.get("valid_keys", [])
+ ):
+ normalized_section = retry_normalized_section
+ lint_result = retry_lint_result
+ else:
+ lint_result["retried"] = True
+ lint_result["retry_round"] = retry_attempts
+ lint_result["retry_errors"] = retry_lint_result.get("errors", [])
+
+ section_lint_results.append(lint_result)
+ generated_sections.append(normalized_section)
+ workflow_helpers._save_artifact(
+ state,
+ f"report_section_{index:02d}_{section.get('section_id', f'section_{index}')}.md",
+ normalized_section,
+ )
+
+ state.temp_data["report_section_inputs"] = section_payloads
+ state.temp_data["report_section_lint"] = section_lint_results
+ workflow_helpers._save_artifact(
+ state,
+ "report_section_lint.json",
+ json.dumps(section_lint_results, ensure_ascii=False, indent=2),
+ )
+ report_body = "\n\n".join(generated_sections).strip()
+ renumbered_body, used_source_ids = renumber_citations(report_body, source_catalog)
+ sources_section = render_sources_section(
+ used_source_ids,
+ source_catalog,
+ heading=sources_heading,
+ )
+ response = f"{renumbered_body}\n\n{sources_section}".strip()
+
+ state.temp_data["report_used_source_ids"] = used_source_ids
+ state.temp_data["report_unknown_source_ids"] = []
+ set_final_report(state, response)
+ workflow_helpers._save_artifact(state, "final_report.md", response)
+ workflow_helpers._save_node_state(state, "report")
+
+ total_ms = round((time.time() - node_start) * 1000, 2)
+ state.temp_data["report_timing"] = {"total_ms": total_ms}
+ print(f"[NODE] report - report.total_ms={total_ms:.2f}")
+ print(f"[NODE] report - Done, {len(response)} chars")
+ return state
diff --git a/backend/src/modules/idea_gen/nodes/research.py b/backend/src/modules/idea_gen/nodes/research.py
new file mode 100644
index 00000000..7cad0be3
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/research.py
@@ -0,0 +1,12 @@
+"""Research dispatch node."""
+
+from __future__ import annotations
+
+from src.modules.idea_gen.services import ResearchService
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import IdeaResearchExecutor
+
+
+def research_dispatch_node(state: IdeaGenState, executor: IdeaResearchExecutor | None = None) -> IdeaGenState:
+ """Execute research dispatch."""
+ return ResearchService().run(state, executor=executor)
diff --git a/backend/src/modules/idea_gen/nodes/routing.py b/backend/src/modules/idea_gen/nodes/routing.py
new file mode 100644
index 00000000..0d52f80c
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/routing.py
@@ -0,0 +1,84 @@
+"""Routing helpers for the idea_gen workflow graph."""
+
+from __future__ import annotations
+
+from src.modules.idea_gen.config import get_workflow_config
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils.state_utils import (
+ current_research_phase,
+ get_supervisor_action,
+ get_temp_value,
+ needs_clarification,
+ phase_completion_action,
+)
+
+
+def global_budget_exhausted(state: IdeaGenState) -> bool:
+ """Return whether the global workflow budget has been exhausted."""
+ configured_limit = state.global_max_iterations or get_workflow_config().global_max_iterations
+ return state.iteration_count >= max(1, configured_limit)
+
+
+def budget_exhausted_target(state: IdeaGenState) -> str:
+ """Choose the next safe terminal path when the global budget is exhausted."""
+ if not state.seeds:
+ return "seed_discovery"
+ if not state.hypotheses and state.evidence_bundles:
+ return "hypothesis"
+ return "compress"
+
+
+def route_clarify(state: IdeaGenState):
+ """Stop for clarification or continue to brief generation."""
+ from src.modules.idea_gen.workflow import END
+
+ return END if needs_clarification(state) else "brief"
+
+
+def route_query_generation(state: IdeaGenState) -> str:
+ """Move to research when queries exist, otherwise hand control to supervisor."""
+ if state.paper_queries or state.web_queries:
+ return "research_dispatch"
+ action = get_supervisor_action(state, "").strip().upper()
+ if action in {"GENERATE_SEEDS", "BUILD_HYPOTHESIS"}:
+ return route_supervisor(state)
+ return "supervisor"
+
+
+def route_compress(state: IdeaGenState) -> str:
+ """Branch from compression into seed discovery or critic review."""
+ phase = current_research_phase(state)
+ if phase == "broad" and not state.seeds:
+ return "seed_discovery"
+ return "critic"
+
+
+def route_supervisor(state: IdeaGenState) -> str:
+ """Resolve supervisor action into the next node name."""
+ phase = current_research_phase(state)
+ default_action = phase_completion_action(phase)
+ action = str(get_supervisor_action(state, default_action) or default_action).strip().upper()
+ routing = {
+ "THINK": "supervisor",
+ "CONDUCT_RESEARCH": "query_generation",
+ "GENERATE_SEEDS": "paper_pool_process",
+ "BUILD_HYPOTHESIS": "hypothesis",
+ }
+
+ if global_budget_exhausted(state) and action in {"THINK", "CONDUCT_RESEARCH"}:
+ return budget_exhausted_target(state)
+
+ if action in routing:
+ return routing[action]
+
+ print(f"[ROUTE] supervisor - Unknown action '{action}', falling back to completion path")
+ return routing.get(default_action, budget_exhausted_target(state))
+
+
+def route_critic(state: IdeaGenState) -> str:
+ """Loop back for another iteration or continue to report."""
+ if str(get_temp_value(state, "critic_action", "") or "").upper() == "ITERATE":
+ if global_budget_exhausted(state):
+ return "report"
+ return "supervisor"
+ return "report"
diff --git a/backend/src/modules/idea_gen/nodes/seed.py b/backend/src/modules/idea_gen/nodes/seed.py
new file mode 100644
index 00000000..6f91a97f
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/seed.py
@@ -0,0 +1,28 @@
+"""Seed nodes."""
+
+from __future__ import annotations
+
+from src.modules.idea_gen.services import SeedService
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import NodeExecutor
+
+
+def seed_discovery_node(
+ state: IdeaGenState,
+ executor: NodeExecutor | None = None,
+ *,
+ validate_immediately: bool = True,
+ validator_executor: NodeExecutor | None = None,
+) -> IdeaGenState:
+ """Generate candidate seeds."""
+ return SeedService().discover(
+ state,
+ executor=executor,
+ validate_immediately=validate_immediately,
+ validator_executor=validator_executor,
+ )
+
+
+def seed_discovery_validate_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Validate candidate seeds."""
+ return SeedService().validate(state, executor=executor)
diff --git a/backend/src/modules/idea_gen/nodes/supervisor.py b/backend/src/modules/idea_gen/nodes/supervisor.py
new file mode 100644
index 00000000..c46e62a9
--- /dev/null
+++ b/backend/src/modules/idea_gen/nodes/supervisor.py
@@ -0,0 +1,235 @@
+"""Supervisor nodes."""
+
+from __future__ import annotations
+
+import json
+
+from src.modules.idea_gen.config import get_workflow_config
+from src.modules.idea_gen.prompts import (
+ build_supervisor_prompt,
+ build_supervisor_validation_prompt,
+)
+from src.modules.idea_gen.schemas import SupervisorDecision
+from src.modules.idea_gen.state import IdeaGenState
+from src.modules.idea_gen.utils import NodeExecutor
+from src.modules.idea_gen.utils import workflow_helpers
+from src.modules.idea_gen.utils.state_utils import (
+ current_research_phase,
+ ensure_supervisor_think_phase,
+ get_phase_iteration_count,
+ get_temp_value,
+ phase_completion_action,
+ set_temp_value,
+)
+from src.modules.idea_gen.nodes.routing import global_budget_exhausted
+from src.modules.idea_gen.utils.supervisor_utils import (
+ apply_supervisor_decision,
+ compact_evidence_status_for_supervisor,
+ collect_phase_followup_tasks,
+ fallback_supervisor_decision,
+ tasks_to_topics,
+)
+from src.modules.idea_gen.utils.query_planning_utils import _summarize_query_feedback_for_prompt
+from src.utils.structured_output import parse_structured_output
+
+
+def supervisor_node(
+ state: IdeaGenState,
+ executor: NodeExecutor | None = None,
+ *,
+ validate_immediately: bool = True,
+ validator_executor: NodeExecutor | None = None,
+) -> IdeaGenState:
+ """Choose the next workflow action."""
+ print(f"\n[NODE] supervisor - Iteration {state.iteration_count}")
+ workflow_config = get_workflow_config()
+ max_topics = workflow_config.max_concurrent_research_units
+ state.temp_data.pop("supervisor_raw_response", None)
+
+ phase = current_research_phase(state)
+ ensure_supervisor_think_phase(state, phase)
+ phase_iteration_count = get_phase_iteration_count(state, phase)
+ if global_budget_exhausted(state):
+ fallback = phase_completion_action(phase)
+ set_temp_value(state, "supervisor_action", fallback)
+ set_temp_value(state, "supervisor_tasks", [])
+ set_temp_value(state, "supervisor_topics", [])
+ print(
+ f"[NODE] supervisor - {fallback} "
+ f"(global budget reached: {state.iteration_count}/{state.global_max_iterations}, phase={phase})"
+ )
+ workflow_helpers._save_node_state(state, f"supervisor_iter{state.iteration_count}")
+ return state
+
+ if phase_iteration_count >= state.input.max_iterations:
+ fallback = phase_completion_action(phase)
+ set_temp_value(state, "supervisor_action", fallback)
+ set_temp_value(state, "supervisor_tasks", [])
+ set_temp_value(state, "supervisor_topics", [])
+ print(
+ f"[NODE] supervisor - {fallback} "
+ f"(phase budget reached: {phase_iteration_count}/{state.input.max_iterations}, phase={phase})"
+ )
+ workflow_helpers._save_node_state(state, f"supervisor_iter{state.iteration_count}")
+ return state
+
+ max_consecutive_thinks = max(1, int(workflow_config.max_consecutive_thinks))
+ max_total_thinks = max(1, int(workflow_config.max_total_thinks_per_phase))
+ last_action = str(get_temp_value(state, "supervisor_action", "") or "")
+ if last_action == "THINK":
+ consecutive_thinks = int(get_temp_value(state, "consecutive_thinks", 0) or 0)
+ total_thinks = int(get_temp_value(state, "total_thinks", 0) or 0)
+ if consecutive_thinks >= max_consecutive_thinks or total_thinks >= max_total_thinks:
+ fallback_tasks = collect_phase_followup_tasks(state, max_topics, phase)
+ fallback_action = "CONDUCT_RESEARCH" if fallback_tasks else phase_completion_action(phase)
+ set_temp_value(state, "supervisor_action", fallback_action)
+ set_temp_value(
+ state,
+ "supervisor_tasks",
+ fallback_tasks if fallback_action == "CONDUCT_RESEARCH" else [],
+ )
+ set_temp_value(
+ state,
+ "supervisor_topics",
+ tasks_to_topics(fallback_tasks) if fallback_action == "CONDUCT_RESEARCH" else [],
+ )
+ print(
+ f"[NODE] supervisor - {fallback_action} "
+ f"(THINK guard hit: consecutive={consecutive_thinks}/{max_consecutive_thinks}, "
+ f"total={total_thinks}/{max_total_thinks})"
+ )
+ workflow_helpers._save_node_state(state, f"supervisor_iter{state.iteration_count}")
+ return state
+
+ last_action = str(get_temp_value(state, "supervisor_action", "") or "")
+ last_reflection = state.supervisor_messages[-1].get("reflection", "") if state.supervisor_messages else ""
+
+ system = build_supervisor_prompt(
+ date=get_temp_value(state, "workflow_date"),
+ max_researcher_iterations=state.input.max_iterations,
+ max_concurrent_research_units=max_topics,
+ last_action=last_action,
+ last_reflection=last_reflection,
+ research_phase=phase,
+ current_phase_iteration=phase_iteration_count,
+ )
+ user = (
+ f"Research brief:\n{state.research_brief}\n\n"
+ f"Notes:\n{state.notes}\n\n"
+ f"Iteration: {state.iteration_count}\n"
+ f"Phase Iteration: {phase_iteration_count}"
+ )
+ query_state = get_temp_value(state, "query_state", {}) or {}
+ if query_state.get("active_paper_queries") or query_state.get("active_web_queries"):
+ user += (
+ "\n\nCurrent Active Queries:\n"
+ f"- Paper: {json.dumps(query_state.get('active_paper_queries', []), ensure_ascii=False)}\n"
+ f"- Web: {json.dumps(query_state.get('active_web_queries', []), ensure_ascii=False)}"
+ )
+ query_feedback = get_temp_value(state, "query_feedback", {}) or {}
+ if query_feedback:
+ user += (
+ "\n\nRecent Query Feedback Summary:\n"
+ f"{json.dumps(_summarize_query_feedback_for_prompt(query_feedback), ensure_ascii=False, indent=2)}"
+ )
+ if state.critic_feedback:
+ user += (
+ f"\n\n[CRITIC FEEDBACK]\n{state.critic_feedback.get('blocking_issues', '')}\n"
+ f"{state.critic_feedback.get('suggestions', '')}"
+ )
+ if phase == "evidence":
+ compact_status = compact_evidence_status_for_supervisor(state)
+ if compact_status:
+ user += (
+ "\n\n\n"
+ f"{json.dumps(compact_status, ensure_ascii=False, indent=2)}\n"
+ ""
+ )
+ executor = executor or NodeExecutor("supervisor")
+ try:
+ response = executor.invoke_text(system, user)
+ state.temp_data["supervisor_raw_response"] = response
+ workflow_helpers._save_artifact(state, f"supervisor_raw_iter{state.iteration_count}.txt", response)
+ print("[NODE] supervisor - Candidate decision generated")
+ if validate_immediately:
+ return supervisor_validate_node(state, executor=validator_executor)
+ except Exception as exc:
+ fallback = fallback_supervisor_decision(
+ state,
+ phase=phase,
+ phase_iteration_count=phase_iteration_count,
+ max_topics=max_topics,
+ error=exc,
+ node="supervisor",
+ message_template="supervisor decision fallback to {fallback}",
+ )
+ print(f"[NODE] supervisor - Error: {exc}, fallback to {fallback}")
+ workflow_helpers._save_node_state(state, f"supervisor_iter{state.iteration_count}")
+ return state
+
+
+def supervisor_validate_node(state: IdeaGenState, executor: NodeExecutor | None = None) -> IdeaGenState:
+ """Validate or repair supervisor output into strict JSON action."""
+ print(f"\n[NODE] supervisor_validate - Iteration {state.iteration_count}")
+ workflow_config = get_workflow_config()
+ max_topics = workflow_config.max_concurrent_research_units
+ phase = current_research_phase(state)
+ phase_iteration_count = get_phase_iteration_count(state, phase)
+ candidate = str(state.temp_data.get("supervisor_raw_response", "") or "")
+
+ if not candidate:
+ print("[NODE] supervisor_validate - No candidate output, using precomputed action")
+ workflow_helpers._save_node_state(state, f"supervisor_iter{state.iteration_count}")
+ return state
+
+ executor = executor or NodeExecutor("supervisor_validator")
+ max_rounds = 3
+ last_error: Exception | None = None
+ for attempt in range(max_rounds + 1):
+ try:
+ data = parse_structured_output(candidate, dict)
+ decision = SupervisorDecision(**data)
+ action, cleaned_tasks = apply_supervisor_decision(
+ state,
+ decision=decision,
+ phase=phase,
+ phase_iteration_count=phase_iteration_count,
+ max_topics=max_topics,
+ )
+ state.temp.supervisor_validation_status = "validated" if attempt == 0 else "repaired"
+ state.temp.supervisor_validation_rounds = attempt
+ state.temp_data.pop("supervisor_raw_response", None)
+ print(f"[NODE] supervisor_validate - {action}, Tasks: {len(cleaned_tasks)}")
+ workflow_helpers._save_node_state(state, f"supervisor_iter{state.iteration_count}")
+ return state
+ except Exception as exc:
+ last_error = exc
+ if attempt >= max_rounds:
+ break
+ system, user = build_supervisor_validation_prompt(
+ raw_supervisor_output=candidate,
+ research_phase=phase,
+ max_concurrent_research_units=max_topics,
+ )
+ candidate = executor.invoke_text(system, user)
+ workflow_helpers._save_artifact(
+ state,
+ f"supervisor_validation_attempt_{state.iteration_count}_{attempt + 1}.txt",
+ candidate,
+ )
+
+ if last_error is not None:
+ fallback = fallback_supervisor_decision(
+ state,
+ phase=phase,
+ phase_iteration_count=phase_iteration_count,
+ max_topics=max_topics,
+ error=last_error,
+ node="supervisor_validate",
+ message_template="supervisor validation fallback to {fallback}",
+ )
+ state.temp.supervisor_validation_status = "failed"
+ state.temp_data.pop("supervisor_raw_response", None)
+ print(f"[NODE] supervisor_validate - Error: {last_error}, fallback to {fallback}")
+ workflow_helpers._save_node_state(state, f"supervisor_iter{state.iteration_count}")
+ return state
diff --git a/backend/src/modules/idea_gen/prompts.py b/backend/src/modules/idea_gen/prompts.py
index d1842871..3a8e10d7 100644
--- a/backend/src/modules/idea_gen/prompts.py
+++ b/backend/src/modules/idea_gen/prompts.py
@@ -2,7 +2,7 @@
from datetime import datetime
-from src.modules.idea_gen.config import get_workflow_config
+from src.modules.idea_gen.config import get_seed_config, get_workflow_config
def build_clarify_prompt(messages: str, date: str | None = None) -> tuple[str, str]:
@@ -154,6 +154,7 @@ def build_query_generation_prompt(
current_active_queries: dict[str, list[str]] | None = None,
supervisor_reflection: str = "",
supervisor_topics: list[str] | None = None,
+ supervisor_tasks: list[dict[str, str]] | None = None,
query_feedback: dict | None = None,
query_history: dict | None = None,
) -> tuple[str, str]:
@@ -164,6 +165,7 @@ def build_query_generation_prompt(
venues_str = ", ".join(target_venues) if target_venues else "NIPS, ICML, ICLR"
current_active_queries = current_active_queries or {}
supervisor_topics = supervisor_topics or []
+ supervisor_tasks = supervisor_tasks or []
query_feedback = query_feedback or {}
query_history = query_history or {}
@@ -216,10 +218,10 @@ def build_query_generation_prompt(
{{
"need_more_queries": true,
"paper_queries": [
- {{"query": "query1", "intent": "method_gap", "source": "model"}}
+ {{"query": "query1", "intent": "method_gap", "source": "model", "seed_id": "seed_1", "lane": "novelty", "rationale": "why this query is needed"}}
],
"web_queries": [
- {{"query": "query2", "intent": "benchmark_evaluation", "source": "model"}}
+ {{"query": "query2", "intent": "benchmark_evaluation", "source": "model", "seed_id": "seed_1", "lane": "execution", "rationale": "why this query is needed"}}
],
"missing_aspects": ["method evidence", "benchmark evidence"],
"rewrite_strategy": "retain|tighten|retarget|stop",
@@ -230,6 +232,7 @@ def build_query_generation_prompt(