init

.gitignore

@@ -0,0 +1,3 @@
+workspaces/
+*.pyc
+__pycache__/

Dockerfile

@@ -0,0 +1,35 @@
+FROM node:18-slim
+
+# Install Python3, pip
+RUN apt-get update && apt-get install -y python3 python3-pip && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Global install Claude Code CLI
+RUN npm install -g @anthropic-ai/claude-code
+
+# Copy solver source files
+COPY run.py spawn.py outline.md config.json /app/solver/
+
+# Copy web app files
+COPY app.py solver.py /app/
+COPY static/ /app/static/
+
+# Create workspaces directory
+RUN mkdir -p /app/workspaces
+
+# Claude Code config
+RUN mkdir -p /root/.claude
+COPY settings.json /root/.claude/settings.json
+
+# Environment variables (set via Hugging Face Space secrets)
+ENV ANTHROPIC_BASE_URL=""
+ENV ANTHROPIC_API_KEY=""
+
+EXPOSE 7860
+
+CMD ["python3", "/app/app.py"]

app.py

@@ -0,0 +1,48 @@
+from flask import Flask, request, jsonify, send_from_directory
+import solver
+
+app = Flask(__name__, static_folder='static')
+
+
+@app.route('/')
+def index():
+    return send_from_directory('static', 'solver.html')
+
+
+@app.route('/api/submit', methods=['POST'])
+def api_submit():
+    data = request.json
+    problem = data.get('problem', '').strip()
+    if not problem:
+        return jsonify({'error': 'No problem provided'}), 400
+
+    task_id = solver.submit_task(problem)
+    if task_id is None:
+        return jsonify({'error': 'Server is busy, please try again later'}), 503
+
+    return jsonify({'task_id': task_id})
+
+
+@app.route('/api/status/<task_id>')
+def api_status(task_id):
+    task = solver.get_task(task_id)
+    if not task:
+        return jsonify({'error': 'Task not found'}), 404
+    return jsonify(task)
+
+
+@app.route('/api/result/<task_id>')
+def api_result(task_id):
+    content = solver.get_task_result(task_id)
+    if content is None:
+        return jsonify({'error': 'Result not available yet'}), 404
+    return jsonify({'content': content})
+
+
+@app.route('/api/tasks')
+def api_tasks():
+    return jsonify({'tasks': solver.list_tasks()})
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)

config.json

@@ -0,0 +1,4 @@
+{
+  "model": "qwen3.6-plus",
+  "timeout_seconds": 86400
+}

outline.md

@@ -0,0 +1,248 @@
+# Outline — 多Agent协作物理解题系统
+
+## System: Orchestrator
+
+你是 Orchestrator（编排者），负责协调多个 sub-Agent 解决物理题目。
+
+**工作方式：**
+1. 用 read_file 读取项目根目录的 outline.md，理解完整的工作流架构和各 Agent 定义
+2. 从 outline.md 的 `## Architecture` 部分了解执行顺序、数据流和反馈规则
+3. 从 outline.md 的 `## Agent: <name>` 部分提取对应 Agent 的 prompt
+4. **自动识别输入结构**：
+   - 如果指定目录下存在若干子文件夹，每个子文件夹内含 problem.md → 视为多题目录，依次串行处理每个子文件夹
+   - 否则 → 视为单题目录，读取该目录下 problem.md 作为唯一题目
+   - 多题场景下，每道题独立执行步骤 5-9，全部完成后在**父目录**生成 `batch_summary.md` 汇总所有子题目结果
+5. 对每一道题，按 Architecture 定义的顺序，用 Bash 调用 spawn.py 逐个创建 sub-Agent：
+   ```
+   python3 spawn.py <role> <workspace> <prompt_file> <task_file>
+   ```
+   - `<role>`: Agent 角色名（Planner / Builder / Evaluator）
+   - `<workspace>`: 工作目录路径
+   - `<prompt_file>`: 临时文件，先写入从 outline.md 提取的 Agent prompt
+   - `<task_file>`: 临时文件，先写入任务描述（要读什么文件、输出到什么文件）
+   - spawn.py 会创建一个 Claude Code 子进程，完成后将结果写入 `<workspace>/.<role>.result`
+6. 记录每个 sub-Agent 的调用轮次、用时和结果
+7. 全部阶段完成后，检查 Evaluator 的输出文件：
+   - 包含 "PASS" → 将解题结果按合理格式写入 {workspace}/final_summary.md，结束
+   - 包含 "REVISE" → 按 Architecture 反馈规则重新执行相关 Agent，最多迭代 2 次
+8. 迭代时，将审查意见作为额外上下文加入 Builder 的 task 描述
+9. 第二次迭代仍 REVISE → 将当前最佳方案和未解决问题列表写入 {workspace}/final_summary.md，结束
+
+**输出格式：**
+- **单题**：在 final_summary.md 中，请包含以下信息：
+  - 各阶段的执行统计：读每个 `.{role}.metrics` 文件（JSON），提取 duration_ms、usage 中的 tokens，汇总轮次、总用时、总 Token 消耗
+  - 最终答案的完整呈现
+  - 格式清晰、易读
+- **多题**：在父目录生成 `batch_summary.md`，包含每道题的子目录名、是否 PASS、最终答案摘要、轮次和用时。
+
+**原则：**
+- 你自己不做具体的物理解题——所有分析、求解、审查都委托给 sub-Agent
+- 你只负责编排：读配置、分配任务、传递上下文、判断是否迭代
+- 每个 sub-Agent 是独立的 Claude Code 进程，完成后返回结果文本
+
+
+## Agent: Planner
+
+你是 Planner（规划者），负责分析物理题目并制定解题计划。
+
+**输入：** 用 read_file 读取 task 中指定的文件（problem.md，可能还有前置输出）。
+**输出：** 用 write_file 将解题计划写入 task 中指定的输出文件。
+
+**解题计划应包含：**
+
+### 物理情景
+- 用文字描述物理过程和示意图（标注物体、力/场的方向、坐标系）
+- 明确物理过程的阶段划分（如：加速阶段、碰撞前后等）
+
+### 符号约定表
+| 符号 | 含义 | 数值 | 单位 |
+- 已知量和未知量分开列出
+
+### 适用物理定律
+- 列出每条定律名称和对应公式
+- 说明为什么适用（满足什么前提条件）
+
+### 逐步解题路线
+- 从待求量出发逆向推导：需要什么中间量 → 用什么定律得到 → 写出对应方程
+- 验证方程可解性：未知量个数 = 独立方程个数
+
+### 量纲预检
+- 关键等式两边的量纲是否一致
+
+### 特殊情况
+- 边界条件、极端情况、多解可能性
+
+
+## Agent: Builder
+
+你是 Builder（求解者），负责基于解题计划执行完整推导。
+
+**输入：** 用 read_file 读取 task 中指定的文件（problem.md + plan.md）。
+**输出：** 用 write_file 将求解过程写入 task 中指定的输出文件。
+**可选技能：** 你可以在推导过程中运用 outline.md 中定义的 Skills（如 calculation、dimension_check），不需要调用外部工具——凭自身能力按 Skill 描述执行即可。
+
+**求解过程应包含：**
+
+### 逐步推导
+每一步格式：
+> **Step N: [定律名]**
+> 公式：...
+> 代入：... = ...
+> 结果：... = ... (单位)
+
+- 代数推导完整，不跳步
+- 每个数值结果带单位和有效数字
+- 关键步骤后穿插量纲检查
+
+### 最终答案
+- 醒目标注，带完整单位
+- 对应题目要求的每个小问逐一回答
+
+### 合理性检验
+- 数量级是否合理（与常识对比）
+- 方向是否正确
+- 极端参数退化是否合理（如 μ→0, θ→0 等）
+
+如果 task 中包含审查反馈（REVISE 上下文），请先根据反馈定位问题，再修正推导。
+
+
+## Agent: Evaluator
+
+你是 Evaluator（审查者），负责严格审查物理求解过程。
+
+**输入：** 用 read_file 读取 task 中指定的文件（problem.md + solution.md，可能还有 plan.md）。
+**输出：** 用 write_file 将审查结果写入 task 中指定的输出文件。
+
+**审查清单：**
+1. **题意覆盖** — 是否遗漏已知条件？是否误解题意？是否回答了所有小问？
+2. **模型合理性** — 坐标系/参考系选择是否合理？近似条件是否成立？
+3. **推导正确性** — 每步定律适用是否正确？公式是否有误？代数运算是否正确？
+4. **量纲一致性** — 每步等式两边量纲？最终答案单位？
+5. **数值合理性** — 有效数字？数量级可信？
+6. **合理性检验** — 是否做了充分的自洽检查？
+
+**输出格式（严格遵守）：**
+- 解答正确完整 → 第一行写 `PASS`，后面附简要肯定说明
+- 存在问题 → 第一行写 `REVISE`，后面逐条列出：
+  - 在哪一步
+  - 错在何处
+  - 应如何修正
+  描述要足够具体，让 Builder 能直接定位并修正
+
+
+## Architecture
+
+### 执行顺序
+```
+Orchestrator
+  │
+  ├─→ spawn Planner
+  │     读 problem.md → 写 {workspace}/plan.md
+  │
+  ├─→ spawn Builder
+  │     读 problem.md + {workspace}/plan.md → 写 {workspace}/solution.md
+  │
+  ├─→ spawn Evaluator
+  │     读 problem.md + {workspace}/solution.md → 写 {workspace}/review.md
+  │
+  └─→ 检查 review.md
+        PASS → 写 {workspace}/final_summary.md，结束
+        REVISE → 迭代（见下方反馈规则）
+```
+
+### 反馈规则
+- 若 review.md 第一行为 `REVISE`：
+  1. Orchestrator 重新 spawn Builder，task 中附带审查意见原文
+  2. Builder 修正后写 {workspace}/solution.md
+  3. Orchestrator spawn Evaluator 重新审查
+  4. 最多迭代 **2** 次
+- 第二次迭代仍 REVISE → 将当前最佳方案和未解决问题列表写入 {workspace}/final_summary.md，结束
+
+
+## Format
+
+各 Agent 输出文件使用 Markdown 格式，遵循以下结构。
+
+### plan.md
+```markdown
+# 解题计划 — [题目简述]
+
+## 物理情景
+[文字描述 + 示意图]
+
+## 符号约定
+| 符号 | 含义 | 数值 | 单位 |
+|------|------|------|------|
+
+## 适用定律
+1. [定律名]: [公式] — 适用原因: ...
+
+## 解题路线
+Step 1: [定律] → [方程] → [求出量]
+Step 2: ...
+
+## 可解性检查
+未知量 N 个 = 独立方程 N 个 ✓/✗
+
+## 量纲预检
+[关键等式的量纲验证]
+
+## 特殊情况
+[边界/极端/多解]
+```
+
+### solution.md
+```markdown
+# 求解过程
+
+**Step 1: [定律名]**
+公式: ...
+代入: ...
+结果: ... = ... (单位)
+
+...
+
+## 最终答案
+1. [小问1]: ... = ... (单位)
+2. [小问2]: ...
+
+## 合理性检验
+[数量级/方向/极端情况验证]
+```
+
+### review.md
+```markdown
+PASS
+[简要肯定说明]
+
+或
+
+REVISE
+1. [步骤]: [问题描述] → [修正建议]
+2. ...
+```
+
+### 文件命名约定
+- 输入文件统一为 `{workspace}/problem.md`
+- 各阶段输出文件名固定: `plan.md`, `solution.md`, `review.md`
+- workspace 目录路径由 Orchestrator 在 task 中指定
+
+
+## Skills
+
+Skills 是 Agent 可调用的问题解决能力，由模型自身执行（无外部脚本）。
+Orchestrator 在 spawn Agent 时会将 Agent prompt 中引用的 Skill 内容一并传入。
+新增 Skill 只需在本节添加定义，并在对应 Agent prompt 中声明引用。
+
+### Skill: calculation
+数值计算与代数推导验证。
+- 对关键数值结果做手算复核：列出完整的数值代入过程，逐步计算
+- 对代数推导做交叉验证：用不同路线（如能量法 vs 力学法）验证同一结论
+- 结果标注有效数字，与粗略估计对比数量级
+
+### Skill: dimension_check
+量纲一致性检查。
+- 逐步验证每个物理等式：左右两边量纲是否相同
+- 验证最终答案的量纲是否与待求量的物理意义匹配
+- 常见SI量纲：m(L), kg(M), s(T), N(M·L·T⁻²), J(M·L²·T⁻²), m/s(L·T⁻¹), m/s²(L·T⁻²)
+- 检查时将所有量展开为基本量纲(L,M,T)后对比

requirements.txt

@@ -0,0 +1 @@
+Flask==2.3.3

run.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Minimal bootstrap — launches Orchestrator Agent via Claude Code CLI."""
+
+import sys, os, json, re, subprocess
+
+ROOT = os.path.dirname(os.path.abspath(__file__))
+os.chdir(ROOT)
+
+CONFIG = json.loads(open(os.path.join(ROOT, "config.json"), encoding="utf-8").read())
+MODEL = CONFIG.get("model", "sonnet")
+TIMEOUT = CONFIG.get("timeout_seconds", 600)
+
+SUMMARY_FILE = "problems/001/final_summary.md"
+
+
+def extract_section(md, heading):
+    """Extract content after '## <heading>' until the next ## or EOF."""
+    pattern = rf"^##\s+{re.escape(heading)}\s*\n(.*?)(?=^##\s|\Z)"
+    m = re.search(pattern, md, re.MULTILINE | re.DOTALL)
+    return m.group(1).strip() if m else ""
+
+
+def main():
+    workspace = sys.argv[1] if len(sys.argv) > 1 else "problems/001"
+
+    outline = open(os.path.join(ROOT, "outline.md"), encoding="utf-8").read()
+    orchestrator_prompt = extract_section(outline, "System: Orchestrator")
+
+    if not orchestrator_prompt:
+        print("Error: cannot find '## System: Orchestrator' in outline.md")
+        sys.exit(1)
+
+    agents_json = json.dumps({
+        "Orchestrator": {
+            "description": "Orchestrator — 编排多个Agent解决物理题目",
+            "prompt": orchestrator_prompt,
+        }
+    })
+
+    cmd = [
+        "claude",
+        "--print",
+        "--output-format", "json",
+        "--permission-mode", "bypassPermissions",
+        "--bare",
+        "--agents", agents_json,
+        "--agent", "Orchestrator",
+        "--allowed-tools", "Bash,Read,Write",
+        "--add-dir", workspace,
+        "--model", MODEL,
+        f"请解决 {workspace}/problem.md 中的物理题目。\n"
+        f"先读取 outline.md 了解工作流架构和各 Agent 定义，然后按照架构执行。\n"
+        f"创建子 Agent 的方法：Bash 调用 spawn.py <role> <workspace> <prompt_file> <task_file>\n"
+        f"全部阶段完成后，将最终解题结果（包含轮次统计、用时、Token消耗等关键指标和解题内容）写入 {workspace}/final_summary.md 文件。\n"
+        f"工作目录: {workspace}",
+    ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=TIMEOUT)
+
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        print(f"Error: JSON parse failed\n{result.stdout[-500:]}")
+        sys.exit(1)
+
+    if data.get("is_error"):
+        print(f"Error: {data.get('result', 'Unknown')[:300]}")
+        sys.exit(1)
+
+    # Print whatever Orchestrator wrote
+    summary_path = os.path.join(workspace, "final_summary.md")
+    if os.path.exists(summary_path):
+        print(open(summary_path, encoding="utf-8").read())
+    else:
+        print("No summary file found.")
+
+
+if __name__ == "__main__":
+    main()

settings.json

@@ -0,0 +1,3 @@
+{
+  "apiKeyHelper": "echo $ANTHROPIC_API_KEY"
+}

solver.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Background task manager for the physics solver."""
+
+import os
+import sys
+import json
+import time
+import shutil
+import subprocess
+import threading
+from datetime import datetime, timezone
+
+# Solver source location: Docker uses /app/solver, local falls back to project root
+SOLVER_SRC = "/app/solver" if os.path.isdir("/app/solver") else os.path.dirname(os.path.abspath(__file__))
+WORKSPACE_BASE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "workspaces")
+DEFAULT_TIMEOUT = int(os.environ.get("SOLVER_TIMEOUT", "600"))
+DEFAULT_MODEL = os.environ.get("SOLVER_MODEL", "qwen3.6-plus")
+MAX_TASKS = int(os.environ.get("SOLVER_MAX_TASKS", "1"))
+
+tasks = {}
+tasks_lock = threading.Lock()
+
+
+def _now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def active_count():
+    with tasks_lock:
+        return sum(1 for t in tasks.values() if t["status"] in ("pending", "running"))
+
+
+def submit_task(problem_text):
+    """Create a new task, return task_id or None if at capacity."""
+    with tasks_lock:
+        if active_count() >= MAX_TASKS:
+            return None
+
+    task_id = f"task-{int(time.time()*1000)}"
+    workspace = os.path.join(WORKSPACE_BASE, task_id)
+    os.makedirs(workspace, exist_ok=True)
+
+    # Write problem
+    with open(os.path.join(workspace, "problem.md"), "w", encoding="utf-8") as f:
+        f.write(problem_text)
+
+    # Copy solver source into workspace
+    for name in ("run.py", "spawn.py", "outline.md", "config.json"):
+        src = os.path.join(SOLVER_SRC, name)
+        if os.path.exists(src):
+            shutil.copy2(src, os.path.join(workspace, name))
+
+    # Override config.json with env-driven values
+    config_path = os.path.join(workspace, "config.json")
+    config = {"model": DEFAULT_MODEL, "timeout_seconds": DEFAULT_TIMEOUT}
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f)
+
+    task = {
+        "task_id": task_id,
+        "status": "pending",
+        "phase": "waiting",
+        "workspace": workspace,
+        "problem": problem_text[:200],
+        "created_at": _now(),
+        "started_at": None,
+        "finished_at": None,
+        "error": None,
+    }
+    with tasks_lock:
+        tasks[task_id] = task
+
+    # Spawn background thread
+    t = threading.Thread(target=_run_solver, args=(task_id, workspace), daemon=True)
+    t.start()
+    return task_id
+
+
+def _run_solver(task_id, workspace):
+    with tasks_lock:
+        tasks[task_id].update({"status": "running", "started_at": _now()})
+
+    env = os.environ.copy()
+    start = time.time()
+
+    try:
+        proc = subprocess.Popen(
+            [sys.executable, os.path.join(workspace, "run.py"), workspace],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=workspace,
+            env=env,
+        )
+
+        # Monitor workspace for progress
+        while proc.poll() is None:
+            elapsed = time.time() - start
+            if elapsed > DEFAULT_TIMEOUT:
+                proc.kill()
+                with tasks_lock:
+                    tasks[task_id].update({
+                        "status": "error",
+                        "error": f"Timeout after {elapsed:.0f}s",
+                        "finished_at": _now(),
+                    })
+                return
+
+            # Infer phase from workspace files
+            phase = _infer_phase(workspace)
+            with tasks_lock:
+                tasks[task_id]["phase"] = phase
+
+            time.sleep(2)
+
+        stdout, stderr = proc.communicate()
+
+        if proc.returncode != 0:
+            with tasks_lock:
+                tasks[task_id].update({
+                    "status": "error",
+                    "error": stderr.decode("utf-8", errors="replace")[-500:],
+                    "finished_at": _now(),
+                })
+            return
+
+        # Check for final summary
+        summary = os.path.join(workspace, "final_summary.md")
+        if os.path.exists(summary):
+            with tasks_lock:
+                tasks[task_id].update({
+                    "status": "complete",
+                    "phase": "complete",
+                    "finished_at": _now(),
+                })
+        else:
+            with tasks_lock:
+                tasks[task_id].update({
+                    "status": "error",
+                    "error": "Solver finished but no summary file was produced.",
+                    "finished_at": _now(),
+                })
+
+    except Exception as e:
+        with tasks_lock:
+            tasks[task_id].update({
+                "status": "error",
+                "error": str(e),
+                "finished_at": _now(),
+            })
+
+
+def _infer_phase(workspace):
+    """Check workspace files to determine current solver phase."""
+    if os.path.exists(os.path.join(workspace, "final_summary.md")):
+        return "complete"
+    if os.path.exists(os.path.join(workspace, "review.md")):
+        return "evaluating"
+    if os.path.exists(os.path.join(workspace, "solution.md")):
+        return "building"
+    if os.path.exists(os.path.join(workspace, "plan.md")):
+        return "planning"
+    return "starting"
+
+
+def get_task(task_id):
+    with tasks_lock:
+        return dict(tasks.get(task_id, {}))
+
+
+def get_task_result(task_id):
+    """Read final_summary.md if available."""
+    task = get_task(task_id)
+    if not task:
+        return None
+    summary = os.path.join(task.get("workspace", ""), "final_summary.md")
+    if os.path.exists(summary):
+        with open(summary, encoding="utf-8") as f:
+            return f.read()
+    return None
+
+
+def list_tasks():
+    with tasks_lock:
+        return [
+            {
+                "task_id": t["task_id"],
+                "status": t["status"],
+                "phase": t["phase"],
+                "problem": t["problem"],
+                "created_at": t["created_at"],
+                "finished_at": t.get("finished_at"),
+            }
+            for t in sorted(tasks.values(), key=lambda x: x["created_at"], reverse=True)
+        ]

spawn.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Helper script — spawn a sub-Agent via Claude Code CLI.
+Called by the Orchestrator through Bash tool use.
+
+Usage: spawn.py <role> <workspace> <prompt_file> <task_file> [--tools Read,Write]
+"""
+
+import sys, os, json, subprocess
+
+ROOT = os.path.dirname(os.path.abspath(__file__))
+CONFIG = json.loads(open(os.path.join(ROOT, "config.json"), encoding="utf-8").read())
+MODEL = CONFIG.get("model", "sonnet")
+TIMEOUT = CONFIG.get("timeout_seconds", 600)
+
+
+def main():
+    if len(sys.argv) < 5:
+        print("Usage: spawn.py <role> <workspace> <prompt_file> <task_file> [--tools Read,Write]")
+        sys.exit(1)
+
+    role = sys.argv[1]
+    workspace = sys.argv[2]
+    prompt_file = sys.argv[3]
+    task_file = sys.argv[4]
+
+    # Parse optional --tools
+    allowed_tools = "Read,Write"
+    for i, arg in enumerate(sys.argv):
+        if arg == "--tools" and i + 1 < len(sys.argv):
+            allowed_tools = sys.argv[i + 1]
+
+    system_prompt = open(prompt_file, encoding="utf-8").read()
+    task = open(task_file, encoding="utf-8").read()
+    if workspace:
+        task += f"\n工作目录: {workspace}"
+
+    agents_json = json.dumps({role: {"description": f"{role} Agent", "prompt": system_prompt}})
+
+    cmd = [
+        "claude",
+        "--print",
+        "--output-format", "json",
+        "--permission-mode", "bypassPermissions",
+        "--bare",
+        "--agents", agents_json,
+        "--agent", role,
+        "--allowed-tools", allowed_tools,
+        "--add-dir", workspace,
+        "--model", MODEL,
+        task,
+    ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=TIMEOUT)
+
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        print(f"[spawn:{role}] error: JSON parse failed — {result.stdout[-300:]}")
+        sys.exit(1)
+
+    if data.get("is_error"):
+        print(f"[spawn:{role}] error: {data.get('result', 'Unknown')[:300]}")
+        sys.exit(1)
+
+    # Write result text for Orchestrator
+    result_path = os.path.join(workspace, f".{role}.result")
+    with open(result_path, "w", encoding="utf-8") as f:
+        f.write(data.get("result", ""))
+
+    # Write metrics for Orchestrator to collect
+    metrics = {
+        "role": role,
+        "duration_ms": data.get("duration_ms", 0),
+        "duration_api_ms": data.get("duration_api_ms", 0),
+        "usage": data.get("usage", {}),
+    }
+    metrics_path = os.path.join(workspace, f".{role}.metrics")
+    with open(metrics_path, "w", encoding="utf-8") as f:
+        json.dump(metrics, f, ensure_ascii=False)
+
+    print(f"[spawn:{role}] done → {result_path}")
+
+
+if __name__ == "__main__":
+    main()

static/solver.html

@@ -0,0 +1,289 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Physics Problem Solver</title>
+  <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #f0f2f5; color: #333; min-height: 100vh; }
+
+    .container { max-width: 960px; margin: 0 auto; padding: 20px; }
+    h1 { text-align: center; padding: 20px 0 10px; color: #1a1a2e; font-size: 1.8em; }
+    .subtitle { text-align: center; color: #666; margin-bottom: 24px; font-size: 0.95em; }
+
+    .card { background: #fff; border-radius: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.08); padding: 24px; margin-bottom: 20px; }
+
+    textarea { width: 100%; min-height: 180px; border: 1px solid #ddd; border-radius: 8px; padding: 12px; font-size: 14px; font-family: inherit; resize: vertical; line-height: 1.6; }
+    textarea:focus { outline: none; border-color: #4361ee; box-shadow: 0 0 0 3px rgba(67,97,238,0.15); }
+
+    .btn-row { display: flex; gap: 12px; margin-top: 12px; }
+    .btn { padding: 10px 28px; border: none; border-radius: 8px; font-size: 15px; cursor: pointer; font-weight: 600; transition: all 0.15s; }
+    .btn-primary { background: #4361ee; color: #fff; }
+    .btn-primary:hover:not(:disabled) { background: #3a56d4; }
+    .btn-primary:disabled { background: #a0b0f0; cursor: not-allowed; }
+    .btn-secondary { background: #e8e8e8; color: #333; }
+    .btn-secondary:hover { background: #d8d8d8; }
+
+    /* Progress Steps */
+    .progress-bar { display: none; margin: 16px 0 8px; }
+    .progress-bar.visible { display: block; }
+    .steps { display: flex; justify-content: space-between; position: relative; margin-bottom: 8px; }
+    .steps::before { content: ''; position: absolute; top: 14px; left: 40px; right: 40px; height: 3px; background: #e0e0e0; z-index: 0; }
+    .step { position: relative; z-index: 1; text-align: center; flex: 1; }
+    .step-circle { width: 28px; height: 28px; border-radius: 50%; background: #e0e0e0; margin: 0 auto 6px; display: flex; align-items: center; justify-content: center; font-size: 13px; color: #999; transition: all 0.3s; }
+    .step.active .step-circle { background: #4361ee; color: #fff; }
+    .step.done .step-circle { background: #2ecc71; color: #fff; }
+    .step-label { font-size: 12px; color: #888; }
+    .step.active .step-label { color: #4361ee; font-weight: 600; }
+    .step.done .step-label { color: #2ecc71; }
+
+    .elapsed { text-align: center; color: #888; font-size: 13px; margin-top: 4px; }
+
+    /* Result */
+    .result { display: none; margin-top: 16px; }
+    .result.visible { display: block; }
+    .result h2 { margin: 12px 0 8px; font-size: 1.2em; color: #1a1a2e; }
+    .result-content { line-height: 1.7; }
+    .result-content table { border-collapse: collapse; width: 100%; margin: 12px 0; }
+    .result-content th, .result-content td { border: 1px solid #ddd; padding: 8px 12px; text-align: left; }
+    .result-content th { background: #f5f5f5; }
+    .result-content pre { background: #f8f8f8; padding: 12px; border-radius: 6px; overflow-x: auto; font-size: 13px; }
+    .result-content code { background: #f0f0f0; padding: 1px 4px; border-radius: 3px; font-size: 13px; }
+    .result-content pre code { background: none; padding: 0; }
+    .result-content blockquote { border-left: 3px solid #4361ee; padding-left: 12px; color: #555; margin: 8px 0; }
+
+    /* Task list */
+    .task-list { max-height: 200px; overflow-y: auto; }
+    .task-item { display: flex; justify-content: space-between; align-items: center; padding: 8px 0; border-bottom: 1px solid #f0f0f0; cursor: pointer; }
+    .task-item:last-child { border-bottom: none; }
+    .task-item:hover { background: #fafafa; margin: 0 -24px; padding: 8px 24px; border-radius: 4px; }
+    .task-id { font-family: monospace; font-size: 13px; color: #666; }
+    .badge { font-size: 11px; padding: 2px 8px; border-radius: 10px; font-weight: 600; }
+    .badge-pending { background: #fff3cd; color: #856404; }
+    .badge-running { background: #cce5ff; color: #004085; }
+    .badge-complete { background: #d4edda; color: #155724; }
+    .badge-error { background: #f8d7da; color: #721c24; }
+
+    .error-msg { background: #f8d7da; color: #721c24; padding: 12px; border-radius: 8px; margin-top: 12px; display: none; }
+    .error-msg.visible { display: block; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Physics Problem Solver</h1>
+    <p class="subtitle">Multi-agent AI system: Plan &rarr; Build &rarr; Evaluate</p>
+
+    <div class="card">
+      <label style="font-weight:600;margin-bottom:8px;display:block;">Input Physics Problem</label>
+      <textarea id="problem-input" placeholder="e.g. A 2.0 kg object slides down a 30-degree rough incline..."></textarea>
+      <div class="btn-row">
+        <button class="btn btn-primary" id="submit-btn" onclick="submitProblem()">Solve</button>
+      </div>
+
+      <!-- Progress -->
+      <div class="progress-bar" id="progress-bar">
+        <div class="steps">
+          <div class="step" id="step-starting"><div class="step-circle">1</div><div class="step-label">Starting</div></div>
+          <div class="step" id="step-planning"><div class="step-circle">2</div><div class="step-label">Planning</div></div>
+          <div class="step" id="step-building"><div class="step-circle">3</div><div class="step-label">Building</div></div>
+          <div class="step" id="step-evaluating"><div class="step-circle">4</div><div class="step-label">Evaluating</div></div>
+          <div class="step" id="step-complete"><div class="step-circle">5</div><div class="step-label">Complete</div></div>
+        </div>
+        <div class="elapsed" id="elapsed"></div>
+      </div>
+
+      <div class="error-msg" id="error-msg"></div>
+
+      <!-- Result -->
+      <div class="result" id="result">
+        <div class="result-content" id="result-content"></div>
+        <div class="btn-row">
+          <button class="btn btn-secondary" onclick="resetForm()">New Problem</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Task History -->
+    <div class="card">
+      <h2 style="font-size:1em;margin-bottom:12px;">Recent Tasks</h2>
+      <div class="task-list" id="task-list">
+        <p style="color:#999;font-size:13px;">No tasks yet.</p>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    let currentTaskId = null;
+    let pollTimer = null;
+    let startTime = null;
+    let elapsedTimer = null;
+
+    const phaseOrder = ['starting', 'planning', 'building', 'evaluating', 'complete'];
+
+    function setStatus(status) {
+      document.getElementById('submit-btn').disabled = (status === 'running');
+    }
+
+    function updateProgress(phase) {
+      phaseOrder.forEach(p => {
+        const el = document.getElementById('step-' + p);
+        el.classList.remove('active', 'done');
+        if (p === phase) el.classList.add('active');
+        else if (phaseOrder.indexOf(p) < phaseOrder.indexOf(phase)) el.classList.add('done');
+      });
+    }
+
+    function showError(msg) {
+      const el = document.getElementById('error-msg');
+      el.textContent = msg;
+      el.classList.add('visible');
+    }
+
+    function hideError() {
+      document.getElementById('error-msg').classList.remove('visible');
+    }
+
+    async function submitProblem() {
+      const text = document.getElementById('problem-input').value.trim();
+      if (!text) return;
+
+      hideError();
+      document.getElementById('result').classList.remove('visible');
+      document.getElementById('progress-bar').classList.add('visible');
+      setStatus('running');
+
+      try {
+        const resp = await fetch('/api/submit', {
+          method: 'POST',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({problem: text})
+        });
+        const data = await resp.json();
+        if (data.error) { showError(data.error); setStatus('idle'); return; }
+
+        currentTaskId = data.task_id;
+        startTime = Date.now();
+        startElapsed();
+        pollStatus();
+      } catch (e) {
+        showError('Network error: ' + e.message);
+        setStatus('idle');
+      }
+    }
+
+    function pollStatus() {
+      if (pollTimer) clearInterval(pollTimer);
+      pollTimer = setInterval(async () => {
+        if (!currentTaskId) return;
+        try {
+          const resp = await fetch('/api/status/' + currentTaskId);
+          const data = await resp.json();
+          if (data.error) { showError(data.error); stopPolling(); return; }
+
+          updateProgress(data.phase || 'starting');
+
+          if (data.status === 'complete') {
+            stopPolling();
+            await loadResult();
+          } else if (data.status === 'error') {
+            stopPolling();
+            showError(data.error || 'Task failed');
+            setStatus('idle');
+          }
+        } catch (e) { /* retry next poll */ }
+      }, 3000);
+    }
+
+    function stopPolling() {
+      if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
+      if (elapsedTimer) { clearInterval(elapsedTimer); elapsedTimer = null; }
+    }
+
+    function startElapsed() {
+      if (elapsedTimer) clearInterval(elapsedTimer);
+      elapsedTimer = setInterval(() => {
+        if (!startTime) return;
+        const s = Math.floor((Date.now() - startTime) / 1000);
+        const m = Math.floor(s / 60);
+        document.getElementById('elapsed').textContent = `Elapsed: ${m}m ${s % 60}s`;
+      }, 1000);
+    }
+
+    async function loadResult() {
+      try {
+        const resp = await fetch('/api/result/' + currentTaskId);
+        const data = await resp.json();
+        if (data.content) {
+          document.getElementById('result-content').innerHTML = marked.parse(data.content);
+          document.getElementById('result').classList.add('visible');
+        }
+        setStatus('idle');
+      } catch (e) {
+        showError('Failed to load result');
+        setStatus('idle');
+      }
+    }
+
+    function resetForm() {
+      currentTaskId = null;
+      startTime = null;
+      stopPolling();
+      document.getElementById('problem-input').value = '';
+      document.getElementById('progress-bar').classList.remove('visible');
+      document.getElementById('result').classList.remove('visible');
+      hideError();
+      setStatus('idle');
+      phaseOrder.forEach(p => {
+        document.getElementById('step-' + p).classList.remove('active', 'done');
+      });
+    }
+
+    async function loadTaskList() {
+      try {
+        const resp = await fetch('/api/tasks');
+        const data = await resp.json();
+        const el = document.getElementById('task-list');
+        if (!data.tasks || data.tasks.length === 0) {
+          el.innerHTML = '<p style="color:#999;font-size:13px;">No tasks yet.</p>';
+          return;
+        }
+        el.innerHTML = data.tasks.slice(0, 20).map(t => {
+          const badgeClass = 'badge-' + t.status;
+          const time = t.created_at ? new Date(t.created_at).toLocaleTimeString() : '';
+          return `<div class="task-item" onclick="viewTask('${t.task_id}')">
+            <span class="task-id">${t.task_id}</span>
+            <span>${time}</span>
+            <span class="badge ${badgeClass}">${t.status}</span>
+          </div>`;
+        }).join('');
+      } catch (e) {}
+    }
+
+    async function viewTask(taskId) {
+      const resp = await fetch('/api/status/' + taskId);
+      const data = await resp.json();
+      if (data.status === 'complete') {
+        currentTaskId = taskId;
+        startTime = Date.now();
+        document.getElementById('progress-bar').classList.add('visible');
+        updateProgress(data.phase || 'complete');
+        await loadResult();
+      } else if (data.status === 'error') {
+        showError(data.error || 'Task failed');
+      } else {
+        currentTaskId = taskId;
+        startTime = Date.now();
+        document.getElementById('progress-bar').classList.add('visible');
+        updateProgress(data.phase || 'starting');
+        startElapsed();
+        pollStatus();
+      }
+    }
+
+    loadTaskList();
+    setInterval(loadTaskList, 5000);
+  </script>
+</body>
+</html>