Render research processes as interactive flows

app.py

@@ -483,6 +483,33 @@ def prepare_evidence_inputs(
     return evidence_inputs
 
 
+def infer_section_source_ids(section: dict[str, Any], papers: list[dict[str, Any]]) -> list[str]:
+    """Recover omitted citations only when the section clearly names a retrieved paper or its authors."""
+    source_ids = list(section.get("source_ids", []))
+    haystack = json.dumps(
+        {key: section.get(key) for key in ("title", "takeaway", "content")}, ensure_ascii=False
+    ).lower()
+    compact_haystack = re.sub(r"\W+", "", haystack)
+    for paper in papers:
+        paper_id = paper.get("id")
+        if not paper_id or paper_id in source_ids:
+            continue
+        title = re.sub(r"\W+", "", str(paper.get("title", "")).lower())
+        year = str(paper.get("published", ""))[:4]
+        surnames = {
+            re.sub(r"[^a-z0-9]", "", str(author).lower().split()[-1])
+            for author in paper.get("authors", []) if str(author).strip()
+        }
+        mentioned_authors = [name for name in surnames if len(name) >= 4 and name in haystack]
+        title_match = len(title) >= 12 and title in compact_haystack
+        author_match = len(mentioned_authors) >= 2 or (
+            len(mentioned_authors) == 1 and len(mentioned_authors[0]) >= 6 and year and year in haystack
+        )
+        if title_match or author_match:
+            source_ids.append(paper_id)
+    return source_ids
+
+
 def build_report(
     request: ResearchRequest,
     papers: list[dict[str, Any]],
@@ -574,7 +601,8 @@ def build_report(
         "Write all presentation sections from the model-designed outline. Return only JSON matching the schema. "
         "Use the selected layout for each section and put layout-specific data in content. Text/evidence sections may use "
         "{points, details}; timeline uses {nodes:[{year,title,problem,innovation,limitation}]}; comparison uses "
-        "{columns:[...], rows:[{name, values:[...]}]}; process uses {steps:[...]}; equation uses "
+        "{columns:[...], rows:[{name, values:[...]}]}; process uses {steps:[{name,description}]} for a linear flow, "
+        "or {common_steps:[...],branches:[{name,steps:[...]}]} when methods diverge; equation uses "
         "{equation, symbols, interpretation}; paper-analysis uses {method,evidence,limitations}; evidence-gap uses "
         "{interpretation,related_topics,hypotheses,required_inputs}. Every takeaway must follow from the content. "
         "Distinguish sourced facts from analysis or hypotheses. Never invent sources, papers, metrics, or recency claims.",
@@ -610,8 +638,12 @@ def build_report(
     }
     allowed_ids = {paper["id"] for paper in papers}
     for section in assembled["sections"]:
-        section["source_ids"] = [paper_id for paper_id in section["source_ids"] if paper_id in allowed_ids]
-    assembled["references"] = [paper_id for paper_id in assembled["references"] if paper_id in allowed_ids]
+        section["source_ids"] = [
+            paper_id for paper_id in infer_section_source_ids(section, papers) if paper_id in allowed_ids
+        ]
+    assembled["references"] = sorted({
+        paper_id for section in assembled["sections"] for paper_id in section["source_ids"]
+    })
     return validate_report_with_repairs(assembled, shared_context)
 
 
@@ -775,6 +807,40 @@ def normalize_comparison(content: dict[str, Any]) -> tuple[str, list[str], list[
     return row_label, columns, normalized_rows
 
 
+def normalize_process(content: dict[str, Any]) -> tuple[list[Any], list[dict[str, Any]]]:
+    if isinstance(content.get("branches"), list):
+        common = content.get("common_steps") or ([content["start"]] if content.get("start") else [])
+        return common, [branch for branch in content["branches"] if isinstance(branch, dict)]
+
+    steps = content.get("steps", [])
+    common: list[Any] = []
+    grouped: dict[str, list[Any]] = {}
+    for step in steps:
+        name = str(step.get("name", "")) if isinstance(step, dict) else str(step)
+        match = re.match(r"^([^:：]{2,24})[:：]\s*(.+)$", name)
+        if not match:
+            common.append(step)
+            continue
+        lane, short_name = match.groups()
+        normalized_step = dict(step) if isinstance(step, dict) else {"name": short_name}
+        normalized_step["name"] = short_name
+        grouped.setdefault(lane, []).append(normalized_step)
+    if len(grouped) < 2:
+        return [], [{"name": content.get("name", "流程"), "steps": steps}]
+    return common, [{"name": name, "steps": lane_steps} for name, lane_steps in grouped.items()]
+
+
+def render_process_node(step: Any, index: str) -> str:
+    if not isinstance(step, dict):
+        return f'<article class="flow-node"><span>{esc(index)}</span><p>{esc(step)}</p></article>'
+    name = step.get("name") or step.get("title") or f"步骤 {index}"
+    details = {key: value for key, value in step.items() if key not in {"name", "title"}}
+    return (
+        f'<details class="flow-node"><summary><span>{esc(index)}</span><strong>{esc(name)}</strong></summary>'
+        f'<div class="flow-detail">{render_value(details)}</div></details>'
+    )
+
+
 def render_section_content(section: dict[str, Any]) -> str:
     content, layout = section.get("content", {}), section.get("layout", "text")
     if layout == "timeline":
@@ -793,10 +859,15 @@ def render_section_content(section: dict[str, Any]) -> str:
         )
         return f'<div class="table-wrap"><table class="comparison-table"><thead><tr><th>{esc(row_label)}</th>{head}</tr></thead><tbody>{body}</tbody></table></div>'
     if layout == "process":
-        return '<div class="process">' + "".join(
-            f'<article class="process-step"><span>{i}</span>{render_value(step)}</article>'
-            for i, step in enumerate(content.get("steps", []), 1)
-        ) + "</div>"
+        common, branches = normalize_process(content)
+        common_html = "".join(render_process_node(step, str(i)) for i, step in enumerate(common, 1))
+        branches_html = "".join(
+            f'<section class="flow-lane"><h3>{esc(branch.get("name") or branch.get("title") or "分支")}</h3>'
+            f'{"".join(render_process_node(step, f"{lane_index}.{step_index}") for step_index, step in enumerate(branch.get("steps", []), 1))}</section>'
+            for lane_index, branch in enumerate(branches, 1)
+        )
+        fork = '<div class="flow-fork" aria-hidden="true">分支</div>' if common and len(branches) > 1 else ""
+        return f'<div class="process-flow"><div class="flow-common">{common_html}</div>{fork}<div class="flow-branches">{branches_html}</div></div>'
     if layout == "equation":
         return (f'<pre class="equation">{esc(content.get("equation"))}</pre><p>{esc(content.get("interpretation"))}</p>'
                 f'{render_value(content.get("symbols"))}')

static/dynamic-content.css

@@ -73,3 +73,92 @@
 .comparison-table td > p {
   margin: 0;
 }
+.process-flow {
+  display: grid;
+  gap: 14px;
+}
+.flow-common {
+  display: grid;
+  gap: 12px;
+  max-width: 720px;
+  margin: 0 auto;
+}
+.flow-fork {
+  justify-self: center;
+  padding: 5px 14px;
+  border-radius: 999px;
+  background: #263b68;
+  color: #bcd0ff;
+  font-size: 13px;
+}
+.flow-branches {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: 18px;
+}
+.flow-lane {
+  display: grid;
+  align-content: start;
+  gap: 12px;
+  padding: 15px;
+  border: 1px solid #344158;
+  border-radius: 12px;
+  background: #0d1421;
+}
+.flow-lane h3 {
+  margin: 0;
+  color: #bcd0ff;
+}
+.flow-node {
+  position: relative;
+  margin: 0;
+  border: 1px solid #3d4c65;
+  border-radius: 10px;
+  background: #131d2d;
+  transition: transform .18s ease, border-color .18s ease, background .18s ease;
+}
+.flow-node + .flow-node::before {
+  content: "↓";
+  position: absolute;
+  top: -20px;
+  left: 50%;
+  color: var(--accent);
+}
+.flow-node:hover,
+.flow-node[open] {
+  transform: translateY(-2px);
+  border-color: var(--accent);
+  background: #182643;
+}
+.flow-node summary,
+.flow-node > p {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 12px 14px;
+  cursor: pointer;
+  list-style: none;
+}
+.flow-node summary::-webkit-details-marker {
+  display: none;
+}
+.flow-node summary span,
+.flow-node > span {
+  display: inline-grid;
+  flex: 0 0 30px;
+  place-items: center;
+  width: 30px;
+  height: 30px;
+  border-radius: 50%;
+  background: #2b4274;
+  color: #fff;
+  font-size: 12px;
+}
+.flow-detail {
+  padding: 0 14px 14px 54px;
+  animation: reveal .2s ease-out;
+}
+@keyframes reveal {
+  from { opacity: 0; transform: translateY(-5px); }
+  to { opacity: 1; transform: translateY(0); }
+}

tests/test_app.py

@@ -3,7 +3,7 @@ from unittest.mock import patch
 
 from pydantic import ValidationError
 
-from app import ResearchReport, chat_json, deduplicate, normalize_comparison, parse_json_object, prepare_evidence_inputs, render_presentation, render_section_content, render_value, safe_slug
+from app import ResearchReport, chat_json, deduplicate, infer_section_source_ids, normalize_comparison, normalize_process, parse_json_object, prepare_evidence_inputs, render_presentation, render_section_content, render_value, safe_slug
 
 
 def base_report(section):
@@ -105,6 +105,27 @@ class AppTests(unittest.TestCase):
         self.assertEqual(output.count("<th>方法维度</th>"), 1)
         self.assertIn("恢复场景物理辐射度图", output)
 
+    def test_process_is_split_into_interactive_branches(self):
+        content = {"steps": [
+            {"name": "输入多曝光LDR图像序列", "description": "公共输入"},
+            {"name": "HDR重建：辐射度标定", "description": "恢复CRF"},
+            {"name": "HDR重建：权重融合", "description": "辐射域融合"},
+            {"name": "多曝光融合：多尺度分解", "description": "拉普拉斯金字塔"},
+            {"name": "多曝光融合：权重图生成与融合", "description": "质量权重"},
+        ]}
+        common, branches = normalize_process(content)
+        self.assertEqual(len(common), 1)
+        self.assertEqual([branch["name"] for branch in branches], ["HDR重建", "多曝光融合"])
+        output = render_section_content({"layout": "process", "content": content})
+        self.assertIn("flow-branches", output)
+        self.assertIn("<details", output)
+        self.assertIn("恢复CRF", output)
+
+    def test_named_retrieved_paper_recovers_missing_source_id(self):
+        section = {"title": "经典路线", "takeaway": "Debevec and Malik established the calibrated HDR pipeline.", "content": {"details": "The 1997 method estimates the camera response function."}, "source_ids": []}
+        papers = [{"id": "paper-1", "title": "Recovering High Dynamic Range Radiance Maps from Photographs", "authors": ["Paul Debevec", "Jitendra Malik"], "published": "1997-01-01"}]
+        self.assertEqual(infer_section_source_ids(section, papers), ["paper-1"])
+
 
 if __name__ == "__main__":
     unittest.main()