AutoMCM-Pro Math Modeling Agent

python scripts/worklog.py append --role user --text "<用户这次说的话，一句话概括，不要逐字长篇转录>"

python scripts/pipeline_manager.py status 2>/dev/null

# 提取题目文本
python -c "import pdfplumber; pdf=pdfplumber.open('PROBLEM_PATH'); [print(p.extract_text()) for p in pdf.pages]" 2>/dev/null \
  || python -c "import pypdf; r=pypdf.PdfReader('PROBLEM_PATH'); [print(p.extract_text()) for p in r.pages]"

python scripts/setup_workspace.py

# 触发 Skunk Works 时（见 2a）追加 --skunk-works
python scripts/pipeline_manager.py init \
  --mode {AP|MANUAL} \
  --contest {CUMCM|MCM|ICM} \
  --problems {N} \
  --git

# 将题目和数据复制到工作区
cp PROBLEM_PATH CUMCM_Workspace/data/
cp DATA_FILES   CUMCM_Workspace/data/   # 如有

which xelatex >/dev/null 2>&1 || echo "[提示] 未检测到 xelatex，建议安装 TeX Live 或使用 Docker"

python scripts/plot_style.py check
# 退出码 0 → 中文字体可用，正常进行
# 退出码 1 → 会打印按操作系统区分的安装建议；无法立即安装时，图表标题/标签先改用
#           英文，避免中文乱码（方框）进入论文，不要在未确认可显示的情况下硬上中文

python scripts/pipeline_manager.py request-review \
  --stage "problem_analysis" \
  --summary "## 题目理解\n...\n## 建模策略\n...\n## 文献依据\n..." \
  --results "关键数值/验证输出（从代码实际运行结果复制）" \
  --concerns "存在的不确定点或风险" \
  --next "data_preprocessing"

[APPROVED:<stage>:<round>]
AI 自评（<stage>）：
- 本阶段完成情况：<一句话总结>
- 关键数值检查：<列举 2-3 个代表性结果>
- 验证状态：<PASS/本阶段无强制验证>
- 进入下一阶段的理由：<简要说明>

python scripts/pipeline_manager.py advance <stage>

python scripts/pipeline_manager.py andon-pull --reason "一句话说清楚问题" --by "<你的角色>"
# 拉下后，任何 advance 调用都会被拒绝（退出码非0），直到 andon-clear

python scripts/pipeline_manager.py andon-clear --resolution "怎么解决的，一句话说清楚"

python scripts/pipeline_manager.py start-stage problem_analysis

python scripts/pipeline_manager.py start-stage data_preprocessing

python scripts/pipeline_manager.py suggest-parallel

# suggest-parallel 的输出即为阶段列表，例：model_1_build model_2_build model_3_build
STAGES=$(python scripts/pipeline_manager.py suggest-parallel)
python scripts/pipeline_manager.py parallel-start $STAGES

Agent(description="问题一 build+verify", prompt=<AP子Agent模板 N=1>)
Agent(description="问题二 build+verify", prompt=<AP子Agent模板 N=2>)
Agent(description="问题三 build+verify", prompt=<AP子Agent模板 N=3>)

你是 AutoMCM-Pro AP 模式的 model_{N} 子 Agent，负责问题 {N} 的完整 build + verify 流程。

前置检查：
- 读取 CUMCM_Workspace/state/pipeline.json，确认 mode=AP、data_preprocessing=approved

执行（严格按顺序，禁止跳步）：
1. python scripts/pipeline_manager.py start-stage model_{N}_build
2. 编写 CUMCM_Workspace/src/models/problem{N}_{type}.py 并运行至无报错
3. python scripts/pipeline_manager.py start-stage model_{N}_verify
4. 编写并运行 CUMCM_Workspace/src/verifications/verify_problem{N}_{type}.py
5. 若有 ✗ FAIL → 修复 model 代码，重跑验证，循环直至全部 ✓ PASS
6. AP 自评（写入 human_intervention.md）并执行：
   python scripts/pipeline_manager.py advance model_{N}_verify

完成后输出一行：[model_{N}] ✓ 全部验证通过，已 advance。

python scripts/pipeline_manager.py parallel-all-done \
  model_1_verify model_2_verify model_3_verify
# 退出码 0 → 进入 sensitivity_analysis
# 退出码 1 → 查看 parallel-status，针对未完成项重试

python scripts/pipeline_manager.py start-stage sensitivity_analysis

python scripts/pipeline_manager.py start-stage model_1_build

python scripts/pipeline_manager.py start-stage model_1_verify

python scripts/los_alamos/hypothesis_tree.py status --problem-n {N}

Agent(description="问题N Alsos 文献普查", prompt=<Alsos 普查 Prompt 模板>)

你是问题 {N} 的 Alsos 情报组，任务是做一次结构化文献普查，不建模、不下结论。

1. 用抽象化关键词（不要直接粘贴题目原文，遵守 SOP S3）检索该题型的已有解法，
   目标 ≥8 篇跨越不同范式的文献。
2. **对照 `LOS_ALAMOS_METHOD_CATALOG.md` 自查**：题目所属的大类（优化/预测/
   评价/仿真/分类/网络）里，清单上列出但纯文献检索没搜到的候选范式，针对性补
   一轮检索——这一步是为了防止文献普查只找到"最常见"的范式、漏掉同样适用但
   不那么显眼的技术路线，不是要凑齐清单上所有条目。
3. 对识别出的每个建模范式，写一条结构化记录（paradigm_id 格式 PM-P{N}-序号）：
   name / typical_assumptions / strengths / weaknesses / applicable_when /
   citations / maps_to_division（T=解析理论 / E=数值仿真 / O=元启发式 / CM=数据驱动，
   若都不像就留空，不必强行归类）。
4. 把结构化列表写入 CUMCM_Workspace/memory/paradigm_pool_{N}.json（JSON 数组），
   人类可读版写入 memory/literature_survey_{N}.md；**每篇引用同时用
   `scripts/cite_check.py register --problem-n {N} ...`（见 SOP §15）登记进共享
   引用池，不要只写进 JSON 就算了——`quality_gate.py lit` 认的是登记+核验过的
   citations.bib，不是 paradigm_pool_{N}.json 里的自由文本**。
5. 完成后输出一行：[Alsos-P{N}] ✓ 普查完成，发现 {paradigm_count} 种范式，
   分歧点：<一句话>。

mkdir -p CUMCM_Workspace/state
cat > CUMCM_Workspace/state/scope_anchor_{N}.md << 'EOF'
# 问题 {N} 范围锚点（冻结于 Los Alamos 探索开始时，非 Checkpoint LA 不得修改）
## 这个子问题到底在问什么
<一段话复述题目对问题 N 的要求>
## 已确认的假设（探索开始前）
<列出 problem_analysis 阶段已写入 thought_process.md 的假设>
EOF

python scripts/los_alamos/hypothesis_tree.py expand --problem-n {N} \
  --node-id N-P{N}-001 --assumption-id A-P{N}-T-01 --seed-paradigm T --depth 1
# ……对每个第一层分支各跑一次 expand

python scripts/los_alamos/hypothesis_tree.py expand --problem-n {N} \
  --node-id N-P{N}-001-a --parent-ids N-P{N}-001 \
  --assumption-id A-P{N}-T-01a --seed-paradigm T --depth 2
# 例：N-P{N}-001-a = "HiGHS 精确求解"，N-P{N}-001-b = "分支定界+启发式热启动"

python scripts/los_alamos/adjudicate.py screen --problem-n {N} --node-id N-P{N}-001 \
  --coherence 0.0-1.0 --plausibility 0.0-1.0 --novelty 0.0-1.0 \
  --problem-alignment 0.0-1.0 --verdict expand|prune|merge_candidate|needs_more_intel \
  --rationale "一句话理由"

python scripts/los_alamos/hypothesis_tree.py status --problem-n {N}
# 前沿列出的 screened_pass 节点，才是本步真正要 spawn 的对象——以此为准，
# 不要凭 Step 3/4 时的记忆去猜"应该有哪几个"

Agent(description="问题N-分支node_id build+verify", prompt=<Division 子 Agent 模板（Los Alamos 版）>)

你是问题 {N} 假设分支 {node_id} 的 Division，负责该分支的完整 build + verify 流程。

前置检查：
- 读取 CUMCM_Workspace/state/scope_anchor_{N}.md，确认本分支假设未越界

执行（严格按顺序，禁止跳步）：
1. python scripts/los_alamos/hypothesis_tree.py mark --problem-n {N} \
     --node-id {node_id} --state building --sender Division-{node_id}
2. 编写 CUMCM_Workspace/src/models/problem{N}_variant_{node_id}.py 并运行至无报错
3. 在 CUMCM_Workspace/memory/ledgers/problem{N}_{node_id}.json 中，为本分支用到的
   每条关键假设写一条 ledger 记录（id/statement/math_form/source/source_ref/
   citation_id/depends_on/downstream_impact/falsifiable_if/proposed_by，
   schema 见 AutoMCM_SOP.md §9.2），depends_on 正确指向父节点传下来的假设 id
4. 若建模中需要补充文献依据，先发情报请求再自行检索：
   python scripts/los_alamos/bus.py send --problem-n {N} \
     --performative INTEL_REQUEST --sender Division-{node_id} --receiver Alsos \
     --ref-assumption-id <本分支假设id或父假设id> \
     --content '{"query": "...", "justification": "..."}'
   （必须提供 --ref-assumption-id 或 --new-assumption-proposal 二选一，否则会被
   quality_gate.py message 判定违规——不得未登记直接引用未经检索的"常识性"文献）
5. 编写并运行 CUMCM_Workspace/src/verifications/verify_problem{N}_variant_{node_id}.py
   （验证清单同 AutoMCM_SOP.md §4.3，末尾打印结构化 VERIFICATION REPORT）
6. python scripts/los_alamos/hypothesis_tree.py mark --problem-n {N} \
     --node-id {node_id} --state verify_pass --sender Division-{node_id}
   （若 FAIL → 修复模型代码，重跑验证，循环直至 PASS 再执行本步）

完成后输出一行：[{node_id}] ✓ build+verify 通过，等待红队复核。

Agent(description="问题N-分支node_id 红队复核", prompt=<Bletchley 红队 Prompt 模板>)

你是红队，任务是攻击、不是评价。你拿到的是问题 {N} 分支 {node_id}：已通过自证
（verify PASS）的模型代码、verify report、假设 ledger
（CUMCM_Workspace/memory/ledgers/problem{N}_{node_id}.json，含每条假设的
falsifiable_if 字段）。

你的目标不是判断"写得好不好"，而是主动尝试证明它是错的：
1. 对 ledger 里每条关键假设，实际检查其 falsifiable_if 条件是否真的被数据/结果
   触发（不要相信 ledger 里"未触发"的自我陈述，自己重新算一遍）；
2. 构造至少 2 个 verify_*.py 未覆盖的边界/极端场景，检查模型是否给出荒谬结果；
3. 尝试构造一个满足题目约束但会让结论方向逆转的反例。

把结果记账（无论攻破与否都要如实报告，不要为了"有产出"夸大问题）：
python scripts/los_alamos/adjudicate.py redteam --problem-n {N} --node-id {node_id} \
  --verdict survived|weakened|broken --severity none|minor|major|fatal \
  --rationale "一句话理由" \
  --attacks-json '[{"type":"...","result":"..."}, ...]'

完成后输出一行：[{node_id}] 红队裁定 = <verdict>。

python scripts/quality_gate.py red-team --problem-n {N} --node-id N-P{N}-001
# 退出码 0 → 该分支进入决赛圈；退出码 1 → broken，打回 Step 5 修复后重新 Step 6

python scripts/los_alamos/groves_monitor.py check --problem-n {N}

python scripts/los_alamos/hypothesis_tree.py status --problem-n {N}
# "决赛圈（in_tournament）"列出的才是真正存活到这一步的分支——凭这个判断
# 有几个要裁决，不要凭 Step 5/6 时候的记忆

# Track 1：整理各分支 verify report 里的量化指标为 decision_matrix.json，见
# scripts/los_alamos/README.md 的示例格式，然后：
python scripts/los_alamos/adjudicate.py entropy-weight --problem-n {N} \
  --matrix-file decision_matrix_{N}.json

# Track 2：spawn 3~5 个独立评审子 Agent（同一条消息并发），每个都用下方模板

Agent(description="问题N 评审员1", prompt=<Track2 评审 Prompt 模板>)
Agent(description="问题N 评审员2", prompt=<Track2 评审 Prompt 模板>)
Agent(description="问题N 评审员3", prompt=<Track2 评审 Prompt 模板>)

你是问题 {N} 的独立评审 judge-{k}，评审对象是以下候选分支（材料已匿名化，不含
分部代号/proposed_by 字段——请勿询问或猜测哪个分支来自哪个建模范式）：
<粘贴各存活分支的 ledger + verify report 摘要，去掉 proposed_by 字段>

你不知道其他评审的判断，也不能假设自己的判断需要与别人一致。
对每一对候选 (A, B)，针对以下维度分别给出 A>B / B>A / TIE 的偏好和一句话理由，
禁止给出绝对数值分数：
- physical_plausibility（物理/数学合理性）
- problem_fit（与题意的贴合度）
- parsimony（假设精简度）

每一对每一维度都要记账：
python scripts/los_alamos/adjudicate.py panel-vote --problem-n {N} \
  --judge-id judge-{k} --candidate-a <node_id_A> --candidate-b <node_id_B> \
  --dimension physical_plausibility|problem_fit|parsimony --preference A|B|TIE \
  --rationale "一句话理由"

完成后输出一行：[judge-{k}] ✓ 全部两两比较已提交。

python scripts/los_alamos/adjudicate.py panel-entropy --problem-n {N} --round 1
python scripts/los_alamos/adjudicate.py combine --problem-n {N}
# 退出码 0 → 有明确冠军，进入 Step 10a
# 退出码 1 → 存疑：分歧熵超阈值时，不要直接跳 Step 10b——先试 RAND Delphi 匿名
#           收敛（AutoMCM_SOP.md §9.6，最多 2 轮）：
#   python scripts/los_alamos/adjudicate.py delphi-summary --problem-n {N} --round 1
#   （把摘要给评审小组读，重新收一轮 panel-vote --round 2，再跑
#    panel-entropy --round 2 —— 仍不收敛（含首轮共 3 轮后）才进入 Step 10b）

cp CUMCM_Workspace/src/models/problem{N}_variant_<champion_node_id>.py \
   CUMCM_Workspace/src/models/problem{N}_{type}.py
cp CUMCM_Workspace/src/verifications/verify_problem{N}_variant_<champion_node_id>.py \
   CUMCM_Workspace/src/verifications/verify_problem{N}_{type}.py
# 重新跑一遍确认在 canonical 路径下依然无报错，然后按原有 AP 自评流程
# advance model_{N}_build → model_{N}_verify（quality_gate.py verify/red-team 均需通过）

# 落选分支归档，作为论文"模型比较"素材：
echo "问题 {N} 落选分支：见 memory/ledgers/problem{N}_*.json 与 state/leaderboard_{N}.md" \
  >> CUMCM_Workspace/memory/alternative_approaches_{N}.md

python scripts/pipeline_manager.py request-review \
  --stage "model_{N}_adjudicate" \
  --summary "$(cat CUMCM_Workspace/state/leaderboard_{N}.md)" \
  --results "Track1/Track2 排名与分歧熵见上" \
  --concerns "两轨冲突或分歧熵过高，需要人类判断哪个分支更合适" \
  --next "model_{N}_build"

python scripts/pipeline_manager.py start-stage sensitivity_analysis

python scripts/pipeline_manager.py kaizen-assess --problem-n {N} \
  --significance {1-5} --robustness {1-5} --assumptions {1-5} --completeness {1-5} \
  --weakest "<最弱维度一句话>"