@@ -5,6 +5,11 @@
 from pathlib import Path
 import urllib.request
 
+
+def dataset_source_path(category: str) -> Path:
+    repo_root = Path(__file__).resolve().parents[3]
+    return repo_root / "benchmark" / "process" / "dataset_candidate" / category
+
 def setup_metachain():
     cmd = "pip list | grep metachain"
     response = run_command_in_container(cmd)
@@ -31,8 +36,8 @@ def setup_dataset(category: str, local_workplace: str):
         return
 
     # 检查源目录是否存在
-    source_path = f"../benchmark/process/dataset_candidate/{category}"
-    if not os.path.exists(source_path):
+    source_path = dataset_source_path(category)
+    if not source_path.exists():
         raise Exception(f"source path {source_path} not exists")
 
     try:
 
@@ -6,12 +6,86 @@
 from datetime import datetime
 import json
 from pathlib import Path
+import re
 import uuid
 from typing import Any, Dict, List, Optional
 
 from research_agent.inno.evals.evaluator import build_default_research_evaluator
 from research_agent.inno.evals.evaluator import GoalDrivenEvalReport
-from research_agent.inno.evals.trace import AgentStepTrace, ResearchRunTrace, ToolCallTrace
+from research_agent.inno.evals.trace import AgentStepTrace, ResearchRunTrace, RetrievalItem, ToolCallTrace
+
+
+def _split_claim_block(text: str) -> List[str]:
+    normalized = text.replace("\r", "").strip()
+    if not normalized:
+        return []
+
+    sections = re.split(r"\n\s*\n+", normalized)
+    claims: List[str] = []
+    for section in sections:
+        section = re.sub(r"^\s*(\d+\.\s*)", "", section.strip())
+        section = re.sub(r"^\s*[-*]\s*", "", section)
+        if len(section) < 8:
+            continue
+        claims.append(section)
+    return claims or [normalized]
+
+
+def _normalize_claims(claims: Optional[List[str]]) -> List[str]:
+    normalized_claims: List[str] = []
+    for claim in claims or []:
+        claim = claim.strip()
+        if not claim:
+            continue
+        normalized_claims.extend(_split_claim_block(claim))
+    return normalized_claims
+
+
+def _collect_evidence_items(
+    plan: Optional[Dict[str, Any]],
+    final_output: Optional[Dict[str, Any]],
+) -> List[RetrievalItem]:
+    items: List[RetrievalItem] = []
+    for section_name, section_value in (plan or {}).items():
+        if isinstance(section_value, str) and section_value.strip():
+            items.append(
+                RetrievalItem(
+                    source_type="other",
+                    identifier=f"plan:{section_name}",
+                    title=section_name,
+                    content=section_value,
+                )
+            )
+        elif isinstance(section_value, dict) and section_value:
+            items.append(
+                RetrievalItem(
+                    source_type="other",
+                    identifier=f"plan:{section_name}",
+                    title=section_name,
+                    content=json.dumps(section_value, ensure_ascii=False),
+                )
+            )
+
+    for output_name, output_value in (final_output or {}).items():
+        if isinstance(output_value, str) and output_value.strip():
+            items.append(
+                RetrievalItem(
+                    source_type="tool_output",
+                    identifier=f"final:{output_name}",
+                    title=output_name,
+                    content=output_value,
+                )
+            )
+        elif isinstance(output_value, dict) and output_value:
+            items.append(
+                RetrievalItem(
+                    source_type="tool_output",
+                    identifier=f"final:{output_name}",
+                    title=output_name,
+                    content=json.dumps(output_value, ensure_ascii=False),
+                )
+            )
+    return items
 
 
 def build_research_run_trace(
@@ -39,11 +113,13 @@ def build_research_run_trace(
         task_id=task_id,
         query=query,
         goal=goal,
-        claims=list(claims or []),
+        claims=_normalize_claims(claims),
         plan=dict(plan or {}),
         final_output=dict(final_output or {}),
         metadata=dict(metadata or {}),
     )
+    for item in _collect_evidence_items(plan, final_output):
+        trace.add_retrieval(item)
     for tool_call in tool_calls or []:
         trace.add_tool_call(tool_call)
     for agent_step in agent_steps or []:
 
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 from typing import Dict, Iterable, List, Sequence
 
 from research_agent.inno.evals.trace import ResearchRunTrace
@@ -16,6 +17,39 @@ def _contains_any(haystack: str, needles: Iterable[str]) -> bool:
     return any(_normalize(needle) in normalized_haystack for needle in needles if needle)
 
 
+def _tokenize(text: str) -> set[str]:
+    return {
+        token
+        for token in re.findall(r"[a-z0-9]+", _normalize(text))
+        if len(token) >= 4
+    }
+
+
+def _is_supported_by_evidence(claim: str, evidence_texts: Sequence[str]) -> bool:
+    if not claim.strip():
+        return True
+
+    normalized_claim = _normalize(claim)
+    claim_tokens = _tokenize(claim)
+    if not claim_tokens:
+        return False
+
+    for evidence in evidence_texts:
+        normalized_evidence = _normalize(evidence)
+        if normalized_claim in normalized_evidence:
+            return True
+
+        evidence_tokens = _tokenize(evidence)
+        if not evidence_tokens:
+            continue
+
+        overlap = len(claim_tokens & evidence_tokens) / len(claim_tokens)
+        if overlap >= 0.45:
+            return True
+
+    return False
+
+
 def evidence_coverage(trace: ResearchRunTrace) -> Dict[str, object]:
     """Score how many claims are backed by retrieved evidence or tool outputs."""
 
@@ -32,10 +66,15 @@ def evidence_coverage(trace: ResearchRunTrace) -> Dict[str, object]:
         for call in trace.tool_calls
         if call.success
     )
+    evidence_texts.extend(
+        f"{step.agent_name} {step.output_summary}".strip()
+        for step in trace.agent_steps
+        if step.output_summary
+    )
 
     supported, unsupported = [], []
     for claim in claims:
-        if _contains_any(" ".join(evidence_texts), [claim]):
+        if _is_supported_by_evidence(claim, evidence_texts):
             supported.append(claim)
         else:
             unsupported.append(claim)
 
@@ -9,6 +9,7 @@
 import logging
 import os
 import re
+from datetime import datetime, timezone
 from typing import Any, Dict, List
 
 from pydantic import BaseModel, Field
@@ -20,6 +21,14 @@
 logger = logging.getLogger(__name__)
 
 
+def append_stage_event(cache_path: str, event: Dict[str, Any]) -> str:
+    events_path = os.path.join(cache_path, "stage_events.jsonl")
+    os.makedirs(cache_path, exist_ok=True)
+    with open(events_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(event, ensure_ascii=False) + "\n")
+    return events_path
+
+
 def _read_json_file(path: str) -> Dict:
     if not path or not os.path.exists(path):
         return {}
@@ -47,6 +56,16 @@ def update_stage_state(
     }
     with open(stage_state_path, "w", encoding="utf-8") as f:
         json.dump(stage_state, f, ensure_ascii=False, indent=4)
+    append_stage_event(
+        cache_path,
+        {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "stage": stage_name,
+            "status": status,
+            "artifacts": artifacts or {},
+            "metadata": metadata or {},
+        },
+    )
     return stage_state_path
 
 
@@ -493,6 +512,28 @@ def find_json_boundaries(text: str):
     return {}
 
 
+def resolve_experiment_analysis(
+    context_variables: Dict[str, Any],
+    fallback_output: str,
+) -> tuple[str, dict]:
+    """Resolve experiment analysis content from structured context or fallback text."""
+
+    experiment_report = context_variables.get("experiment_report")
+    if isinstance(experiment_report, list) and experiment_report:
+        latest_report = experiment_report[-1] or {}
+        analysis_report = latest_report.get("analysis_report")
+        if analysis_report:
+            return analysis_report, latest_report.get("further_plan", {}) or {}
+
+    parsed_output = extract_json_from_output(fallback_output)
+    if parsed_output:
+        analysis_report = parsed_output.get("analysis_report") or fallback_output
+        further_plan = parsed_output.get("further_plan", {}) or {}
+        return analysis_report, further_plan
+
+    return fallback_output, {}
+
+
 def get_args():
     parser = argparse.ArgumentParser()
     parser.add_argument("--instance_path", type=str, default="benchmark/gnn.json")
 
@@ -45,6 +45,7 @@
     load_cached_survey_result,
     load_cached_prepare_result,
     persist_stage_result,
+    resolve_experiment_analysis,
     resolve_prepare_result,
     persist_survey_result,
     get_args,
@@ -61,6 +62,14 @@ def _persist_stage_output(cache_path: str, stage_name: str, payload: Dict[str, A
         json.dump(payload, f, ensure_ascii=False, indent=4)
     return stage_path
 
+
+def _update_runtime_progress(runtime: MasterRuntime, run_id: str, task_level: str) -> None:
+    runtime.write_runtime_status(
+        run_id=run_id,
+        status="running",
+        metadata={"entrypoint": "run_infer_idea", "task_level": task_level},
+    )
+
 class InnoFlow(FlowModule):
     def __init__(self, cache_path: str, log_path: Union[str, None, MetaChainLogger] = None, model: str = "gpt-4o-2024-08-06", code_env: DockerEnv = None, web_env: BrowserEnv = None, file_env: RequestsMarkdownBrowser = None):
         super().__init__(cache_path, log_path, model)
@@ -151,6 +160,7 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
                 artifacts={"prepare_result": os.path.join(self.cache_path, "prepare_stage", "prepare_result.json")},
             )
         context_variables["stage_state"] = runtime.load_state()
+        _update_runtime_progress(runtime, run_id, task_level)
         paper_list = prepare_dict["reference_papers"]
         download_res = self.download_papaer({"paper_list": paper_list, "local_root": local_root, "workplace_name": workplace_name})
 
@@ -229,6 +239,7 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
                 artifacts={"survey_result": survey_result_path},
             )
         context_variables["stage_state"] = runtime.load_state()
+        _update_runtime_progress(runtime, run_id, task_level)
 
         plan_query = f"""\
 I have an innovative ideas related to machine learning:
@@ -283,6 +294,7 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
                 artifacts=context_variables.get("plan_artifacts", {}),
             )
         context_variables["stage_state"] = runtime.load_state()
+        _update_runtime_progress(runtime, run_id, task_level)
 
         if not runtime.can_run_stage("implement"):
             raise RuntimeError("Implement stage cannot start before required prior stages are completed.")
@@ -427,6 +439,7 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
                 artifacts={"project_manifest": implement_path},
             )
         context_variables["stage_state"] = runtime.load_state()
+        _update_runtime_progress(runtime, run_id, task_level)
 
         if not runtime.can_run_stage("judge"):
             raise RuntimeError("Judge stage cannot start before implement stage is completed.")
@@ -478,6 +491,7 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
                 artifacts={"judge_report": judge_path},
             )
         context_variables["stage_state"] = runtime.load_state()
+        _update_runtime_progress(runtime, run_id, task_level)
 
         MAX_ITER_TIMES = max_iter_times
         for i in range(MAX_ITER_TIMES):
@@ -573,6 +587,7 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
                 artifacts={"submit_result": submit_path},
             )
         context_variables["stage_state"] = runtime.load_state()
+        _update_runtime_progress(runtime, run_id, task_level)
 
         EXP_ITER_TIMES = 2
         analysis_report = ""
@@ -598,9 +613,10 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
             judge_messages.append({"role": "user", "content": exp_planner_query})
             judge_messages, context_variables = await self.exp_analyser(judge_messages, context_variables, iter_times=f"refine_{i+1}")
             analysis_report = judge_messages[-1]["content"]
-
-            analysis_report = context_variables["experiment_report"][-1]["analysis_report"]
-            further_plan = context_variables["experiment_report"][-1]["further_plan"]
+            analysis_report, further_plan = resolve_experiment_analysis(
+                context_variables,
+                analysis_report,
+            )
             # print(analysis_report)
             refine_query = f"""\
 You are given an innovative idea:
@@ -636,6 +652,7 @@ async def forward(self, instance_path: str, task_level: str, local_root: str, wo
             "analyze",
             artifacts={"analysis_report": analysis_path},
         )
+        _update_runtime_progress(runtime, run_id, task_level)
 
         print(refine_res)
         runtime.sync_stage_state()
@@ -710,13 +727,14 @@ def main(args, references):
     with open(args.instance_path, "r", encoding="utf-8") as f:
         eval_instance = json.load(f)
     instance_id = eval_instance["instance_id"] + "_idea"
-    cache_path = args.cache_path + "_" + instance_id + "_" + COMPLETION_MODEL.replace("/", "__")
+    model_suffix = args.model.replace("/", "__")
+    cache_path = args.cache_path + "_" + instance_id + "_" + model_suffix
     local_root = os.path.join(
         os.getcwd(),
         "workplace_paper",
-        f"task_{instance_id}" + "_" + COMPLETION_MODEL.replace("/", "__"),
+        f"task_{instance_id}" + "_" + model_suffix,
     )
-    container_name = args.container_name + "_" + instance_id + "_" + COMPLETION_MODEL.replace("/", "__")
+    container_name = args.container_name + "_" + instance_id + "_" + model_suffix
     os.makedirs(local_root, exist_ok=True)
     env_config = DockerConfig(container_name = container_name, 
                               workplace_name = args.workplace_name,