dsh-vibe-math 2.4.1 → 2.6.0

package/prompt-corpus-v3/formal-verify-v3.md

@@ -17,32 +17,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-off",
-      "kind": "proposition",
-      "target": "p-off",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-off（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-off"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -77,7 +58,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -125,7 +107,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -155,7 +138,59 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>"}
 ```
 
-## [3] spawn · planner:plan-<ID>
+## [3] spawn · paper-writer:lean-off
+
+```text
+You are the DEDICATED PAPER WRITER (single-author mode) of a math research run that has just CONVERGED.
+Write its final paper in 中文（Chinese）, using ONLY the evidence in the MATERIAL section below.
+
+HARD RULES:
+- NEVER invent content: no new proposition, no new computation, no citation that is not in the MATERIAL.
+- Unresolved or refuted items MUST be explicitly labelled (「未定论」/「已被否证」, or "unresolved"/"refuted" in English); never present them as established.
+- Fixed 9-section skeleton — provide bodies for these EXACT `## ` headings (the framework writes the headings, author/date and the evidence index itself):
+    1. 摘要 — 1 标题、作者、日期、摘要（原问题 + 主要结论）
+    2. 引言与问题背景 — 2 原问题的完整陈述
+    3. 原问题的完整解法 — 3 最终答案 + 完整推理链
+    4. 已检验通过的命题 — 4 逐条列出，含判定为真的估计值与证据来源
+    5. 已解决的子问题与中间成果 — 5
+    6. 创造或发现的有价值之物 — 6 方法、理论、思想、有价值经验、数学理解
+    7. 规律总结 — 7 从上述条目归纳出的可复用规律
+    8. 讨论、局限与展望 — 8
+    9. 附录：证据与文件索引 — 9 Verified/、Logs/、关键卡片路径
+- A section with no evidence must be exactly 「（本节暂无证据支持的内容——不编造。）」 (do not pad it).
+- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.
+
+OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:
+{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}
+
+MATERIAL (evidence only — do not add anything beyond it):
+PRESET: vibe-math-v3 (single-author)
+PROJECT: lean-off
+
+[ORIGINAL PROBLEMS] (Problems/*.md)
+- (none)
+
+[PROPOSITIONS] (Propos/<分类>/<id>.md)
+- id=p-off | 概率=1 | 状态=已验证·真 | 优先级=never | 价值/关键性=0.5 | 来源问题= | 陈述=关模式下的普通命题
+    · 已检验通过：证明#0 | mock 裁决 1
+
+[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)
+- (none)
+
+[STILL UNVERIFIED — v3 的完整性判据 leftoverVerify（buildVerifyCandidates）；必须标注为未决]
+- (none — 没有待验证对象)
+
+[UNRESOLVED / REFUTED — 论文里必须显式标注，不得当成已成立的结论]
+- (none — 所有对象均已定论)
+
+[EVIDENCE INDEX] (only files that exist)
+- Logs/Verification/r-p-off_<TIME>.json
+- Propos/数论/p-off.md
+- State/index.json
+- Verified/命题/p-off.md
+```
+
+## [4] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -166,32 +201,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-offr",
-      "kind": "proposition",
-      "target": "p-offr",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-off-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-offr"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -208,7 +224,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [4] spawn · verifier:r-p-offr:0
+## [5] spawn · verifier:r-p-offr:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -226,7 +242,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -256,7 +273,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>"}
 ```
 
-## [5] spawn · verifier:r-p-offr:1
+## [6] spawn · verifier:r-p-offr:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -274,7 +291,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -304,7 +322,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>"}
 ```
 
-## [6] spawn · explorer:qE
+## [7] spawn · explorer:qE
 
 ```text
 You are a research mathematician orchestrating strategy for one problem.
@@ -321,7 +339,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -349,7 +368,7 @@ feasibility ∈ [0,1] = your estimate of the probability this direction leads to
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [7] spawn · planner:plan-<ID>
+## [8] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -360,40 +379,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [
-    {
-      "id": "qE",
-      "状态": "求解中",
-      "优先级": 1,
-      "依赖": [],
-      "依赖就绪": true,
-      "方向数": 0,
-      "活跃方向": [],
-      "running_solver_dirs": [],
-      "最高存活率": null,
-      "解法数": 0
-    }
-  ],
-  "verify_candidates": [],
-  "active_agents": [
-    {
-      "childId": "<CHILD>",
-      "role": "explorer",
-      "target": "qE",
-      "direction": "",
-      "round": ""
-    }
-  ],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-work（v3：md 知识库 + 规划代理调度 + 方法库）"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -410,7 +402,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [8] spawn · explorer:qE
+## [9] spawn · explorer:qE
 
 ```text
 You are a research mathematician orchestrating strategy for one problem.
@@ -427,7 +419,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -455,7 +448,7 @@ feasibility ∈ [0,1] = your estimate of the probability this direction leads to
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [9] spawn · planner:plan-<ID>
+## [10] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -466,54 +459,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [
-    {
-      "id": "qE",
-      "状态": "求解中",
-      "优先级": 1,
-      "依赖": [],
-      "依赖就绪": true,
-      "方向数": 1,
-      "活跃方向": [
-        "d1"
-      ],
-      "running_solver_dirs": [],
-      "最高存活率": 0.7,
-      "解法数": 0
-    }
-  ],
-  "verify_candidates": [],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-work（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 1 problem(s), 0 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】c7 通过回执记录 qE 形式化阻塞：需要先形式化连分数收敛定理"
-    },
-    {
-      "at": "<TIME>",
-      "event": "explorer",
-      "detail": "problem qE → 1 directions (meta sync)"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -530,7 +482,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [10] spawn · solver:qE:d1
+## [11] spawn · solver:qE:d1
 
 ```text
 You are a dedicated solver agent working ONE solution direction of a math problem (agent_self_iteration).
@@ -549,7 +501,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -566,7 +519,7 @@ WRITE-INTO-MD WORKFLOW（优先推荐）：把研究内容直接写进你的归
 - 若你的环境无法真正写文件（文件工具不可用/被拒），回退：把要写的内容放进回复 JSON 的 `__writes` 数组（`[{"path":"<目标>","content":"<全文>"}]`）并同样配 `meta`，由调度器落盘。两种方式二选一，不要重复。
 你的归属文件：
 - 求解器：把该方向的完整叙述（本轮进展/子路线/可行性信号/教训/完整解法文本）写进 `Progress/<问题id>/<方向id>.md`；聚合索引 `Progress/<问题id>.md` 由调度器维护，不要动它。
-- 新引理：写一张完整命题卡到 `Propos/<分类>/<p-id>.md`，含锚点 `- 标题:`、`- ID/类型/状态/概率/优先级` 与 `## 陈述`；证明写进 `### 证明 1｜标题｜概率X｜状态Y` 段落（完整证明文本是验证必需，否则验证器只能验裸命题）。
+- 新引理：写一张完整命题卡到 `Propos/<分类>/<p-id>.md`，含锚点 `- 标题:`、`- ID/类型/状态/概率/优先级/价值关键性` 与 `## 陈述`；证明写进 `### 证明 1｜标题｜概率X｜状态Y` 段落（完整证明文本是验证必需，否则验证器只能验裸命题）。`- 价值/关键性: <0..1>` 表示这条引理对项目主线的关键程度（≥ 阈值会被自动晋升为独立问题），别省。
 
 
 YOUR PERMISSIONS / CAPABILITIES:
@@ -598,7 +551,7 @@ LEMMA RULES: every lemma you register MUST carry a complete proof in `lemmas[].p
 
 OUTPUT CONTRACT — pick ONE channel. Write content into Markdown; only lightweight scheduling metadata (and verification-required proofs) cross the machine reply.
 CHANNEL A (recommended, you can write files): write the full round narrative into `Progress/qE/d1.md` and each new lemma card into `Propos/<分类>/<id>.md`, then reply ONLY this metadata object:
-{"meta":{"kind":"solver","qid":"qE","dirId":"d1","round":1,"survival":0.5,"status":"continue|success|dead-end","dead_end_reason":"... or null","lemmas":[{"id":"p-...","title":"...","statement":"...","proof":"<完整证明文本，供验证器核验>","prob":0.6,"分类":"<引理卡目录名，必须与你要写入的 Propos/<分类>/ 目录严格一致>","优先级":1}],"methods_used":[{"id":"m-...","效果":"...","建议":"..."}],"new_inventions":[{"类型":"...","标题":"...","内容描述":"...","是否已入库":false}],"solution_prob":0.85,"solution_text":"<完整解法文本，或 null>","sub_questions":[{"q_sub_title":"...","q_sub_statement":"完整问题陈述(含所有对象/定义)","assumption_title":"p_{q-tmp} 标题","assumption_statement":"完整假设陈述(含所有定义)"}]}}
+{"meta":{"kind":"solver","qid":"qE","dirId":"d1","round":1,"survival":0.5,"status":"continue|success|dead-end","dead_end_reason":"... or null","lemmas":[{"id":"p-...","title":"...","statement":"...","proof":"<完整证明文本，供验证器核验>","prob":0.6,"价值/关键性":0.5,"分类":"<引理卡目录名，必须与你要写入的 Propos/<分类>/ 目录严格一致>","优先级":1}],"methods_used":[{"id":"m-...","效果":"...","建议":"..."}],"new_inventions":[{"类型":"...","标题":"...","内容描述":"...","是否已入库":false}],"solution_prob":0.85,"solution_text":"<完整解法文本，或 null>","sub_questions":[{"q_sub_title":"...","q_sub_statement":"完整问题陈述(含所有对象/定义)","assumption_title":"p_{q-tmp} 标题","assumption_statement":"完整假设陈述(含所有定义)"}]}}
 CHANNEL B (your file tools are unavailable): put the content you would have written into __writes and carry the same meta:
 {"__writes":[{"path":"Progress/qE/d1.md","content":"<完整本轮叙述>"}],"meta":{"kind":"solver","qid":"qE","dirId":"d1",...同上 meta 字段...}}
 区分规则：methods_used 只能填**已存在的方法卡 ID**（m-…，来自 AVAILABLE METHODS 列表）——引用你自己刚想出的新方法/新技巧不属于 methods_used，请如实填入 new_inventions（它会由 Method Keeper 蒸馏建卡）；不要把方法名/标题当 id 填进 methods_used。
@@ -606,7 +559,7 @@ CHANNEL B (your file tools are unavailable): put the content you would have writ
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [11] wake · solver:qE:d1
+## [12] wake · solver:qE:d1
 
 ```text
 You are a dedicated solver agent working ONE solution direction of a math problem (agent_self_iteration).
@@ -628,7 +581,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -645,7 +599,7 @@ WRITE-INTO-MD WORKFLOW（优先推荐）：把研究内容直接写进你的归
 - 若你的环境无法真正写文件（文件工具不可用/被拒），回退：把要写的内容放进回复 JSON 的 `__writes` 数组（`[{"path":"<目标>","content":"<全文>"}]`）并同样配 `meta`，由调度器落盘。两种方式二选一，不要重复。
 你的归属文件：
 - 求解器：把该方向的完整叙述（本轮进展/子路线/可行性信号/教训/完整解法文本）写进 `Progress/<问题id>/<方向id>.md`；聚合索引 `Progress/<问题id>.md` 由调度器维护，不要动它。
-- 新引理：写一张完整命题卡到 `Propos/<分类>/<p-id>.md`，含锚点 `- 标题:`、`- ID/类型/状态/概率/优先级` 与 `## 陈述`；证明写进 `### 证明 1｜标题｜概率X｜状态Y` 段落（完整证明文本是验证必需，否则验证器只能验裸命题）。
+- 新引理：写一张完整命题卡到 `Propos/<分类>/<p-id>.md`，含锚点 `- 标题:`、`- ID/类型/状态/概率/优先级/价值关键性` 与 `## 陈述`；证明写进 `### 证明 1｜标题｜概率X｜状态Y` 段落（完整证明文本是验证必需，否则验证器只能验裸命题）。`- 价值/关键性: <0..1>` 表示这条引理对项目主线的关键程度（≥ 阈值会被自动晋升为独立问题），别省。
 
 
 YOUR PERMISSIONS / CAPABILITIES:
@@ -677,7 +631,7 @@ LEMMA RULES: every lemma you register MUST carry a complete proof in `lemmas[].p
 
 OUTPUT CONTRACT — pick ONE channel. Write content into Markdown; only lightweight scheduling metadata (and verification-required proofs) cross the machine reply.
 CHANNEL A (recommended, you can write files): write the full round narrative into `Progress/qE/d1.md` and each new lemma card into `Propos/<分类>/<id>.md`, then reply ONLY this metadata object:
-{"meta":{"kind":"solver","qid":"qE","dirId":"d1","round":2,"survival":0.5,"status":"continue|success|dead-end","dead_end_reason":"... or null","lemmas":[{"id":"p-...","title":"...","statement":"...","proof":"<完整证明文本，供验证器核验>","prob":0.6,"分类":"<引理卡目录名，必须与你要写入的 Propos/<分类>/ 目录严格一致>","优先级":1}],"methods_used":[{"id":"m-...","效果":"...","建议":"..."}],"new_inventions":[{"类型":"...","标题":"...","内容描述":"...","是否已入库":false}],"solution_prob":0.85,"solution_text":"<完整解法文本，或 null>","sub_questions":[{"q_sub_title":"...","q_sub_statement":"完整问题陈述(含所有对象/定义)","assumption_title":"p_{q-tmp} 标题","assumption_statement":"完整假设陈述(含所有定义)"}]}}
+{"meta":{"kind":"solver","qid":"qE","dirId":"d1","round":2,"survival":0.5,"status":"continue|success|dead-end","dead_end_reason":"... or null","lemmas":[{"id":"p-...","title":"...","statement":"...","proof":"<完整证明文本，供验证器核验>","prob":0.6,"价值/关键性":0.5,"分类":"<引理卡目录名，必须与你要写入的 Propos/<分类>/ 目录严格一致>","优先级":1}],"methods_used":[{"id":"m-...","效果":"...","建议":"..."}],"new_inventions":[{"类型":"...","标题":"...","内容描述":"...","是否已入库":false}],"solution_prob":0.85,"solution_text":"<完整解法文本，或 null>","sub_questions":[{"q_sub_title":"...","q_sub_statement":"完整问题陈述(含所有对象/定义)","assumption_title":"p_{q-tmp} 标题","assumption_statement":"完整假设陈述(含所有定义)"}]}}
 CHANNEL B (your file tools are unavailable): put the content you would have written into __writes and carry the same meta:
 {"__writes":[{"path":"Progress/qE/d1.md","content":"<完整本轮叙述>"}],"meta":{"kind":"solver","qid":"qE","dirId":"d1",...同上 meta 字段...}}
 区分规则：methods_used 只能填**已存在的方法卡 ID**（m-…，来自 AVAILABLE METHODS 列表）——引用你自己刚想出的新方法/新技巧不属于 methods_used，请如实填入 new_inventions（它会由 Method Keeper 蒸馏建卡）；不要把方法名/标题当 id 填进 methods_used。
@@ -685,7 +639,7 @@ CHANNEL B (your file tools are unavailable): put the content you would have writ
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [12] spawn · method-keeper
+## [13] spawn · method-keeper
 
 ```text
 You are the METHOD KEEPER of a mathematical research system. Your job: distill reusable THEORIES, FRAMEWORKS, TOOLS, METHODS, IDEAS (including experiential ones) invented during solving into the theory library, so future work can apply and extend them — like inventing group theory while solving an equation, or functional analysis while studying variational problems.
@@ -701,7 +655,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -734,7 +689,7 @@ CHANNEL B (your file tools are unavailable): put the method-card content into __
 {"__writes":[{"path":"Methods/<m-id>.md","content":"<# 方法｜标题 + 锚点 + ## 核心内容... 完整卡面>"}],"meta":{"kind":"methods","used":[...],"created":["m-xxx"],"improvements":[...]}}
 ```
 
-## [13] spawn · planner:plan-<ID>
+## [14] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -745,32 +700,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-enc",
-      "kind": "proposition",
-      "target": "p-enc",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-verify（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-enc"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -787,7 +723,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [14] spawn · verifier:r-p-enc:0
+## [15] spawn · verifier:r-p-enc:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -805,7 +741,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -845,7 +782,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-enc","decision":"used|blocked|defect","file":"Formal/p-enc.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [15] spawn · verifier:r-p-enc:1
+## [16] spawn · verifier:r-p-enc:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -863,7 +800,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -903,7 +841,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-enc","decision":"used|blocked|defect","file":"Formal/p-enc.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [16] wake · verifier:r-p-enc:0
+## [17] wake · verifier:r-p-enc:0
 
 ```text
 You are one reviewer in a DEBATE ("交流群") about this object.
@@ -921,7 +859,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -962,7 +901,7 @@ Reply with ONLY a single JSON object in a ```json code fence, no prose outside i
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: updated logic chain / counterexample / proof / refutation>","changed":"brief reason if you changed your Result, else null","formal":{"target":"p-enc","decision":"used|blocked|defect","file":"Formal/p-enc.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [17] wake · verifier:r-p-enc:1
+## [18] wake · verifier:r-p-enc:1
 
 ```text
 You are one reviewer in a DEBATE ("交流群") about this object.
@@ -980,7 +919,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1021,7 +961,7 @@ Reply with ONLY a single JSON object in a ```json code fence, no prose outside i
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: updated logic chain / counterexample / proof / refutation>","changed":"brief reason if you changed your Result, else null","formal":{"target":"p-enc","decision":"used|blocked|defect","file":"Formal/p-enc.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [18] spawn · planner:plan-<ID>
+## [19] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -1032,34 +972,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-verify（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-enc"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 0 problem(s), 1 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -1076,7 +995,60 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [19] spawn · planner:plan-<ID>
+## [20] spawn · paper-writer:lean-verify
+
+```text
+You are the DEDICATED PAPER WRITER (single-author mode) of a math research run that has just CONVERGED.
+Write its final paper in 中文（Chinese）, using ONLY the evidence in the MATERIAL section below.
+
+HARD RULES:
+- NEVER invent content: no new proposition, no new computation, no citation that is not in the MATERIAL.
+- Unresolved or refuted items MUST be explicitly labelled (「未定论」/「已被否证」, or "unresolved"/"refuted" in English); never present them as established.
+- Fixed 9-section skeleton — provide bodies for these EXACT `## ` headings (the framework writes the headings, author/date and the evidence index itself):
+    1. 摘要 — 1 标题、作者、日期、摘要（原问题 + 主要结论）
+    2. 引言与问题背景 — 2 原问题的完整陈述
+    3. 原问题的完整解法 — 3 最终答案 + 完整推理链
+    4. 已检验通过的命题 — 4 逐条列出，含判定为真的估计值与证据来源
+    5. 已解决的子问题与中间成果 — 5
+    6. 创造或发现的有价值之物 — 6 方法、理论、思想、有价值经验、数学理解
+    7. 规律总结 — 7 从上述条目归纳出的可复用规律
+    8. 讨论、局限与展望 — 8
+    9. 附录：证据与文件索引 — 9 Verified/、Logs/、关键卡片路径
+- A section with no evidence must be exactly 「（本节暂无证据支持的内容——不编造。）」 (do not pad it).
+- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.
+
+OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:
+{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}
+
+MATERIAL (evidence only — do not add anything beyond it):
+PRESET: vibe-math-v3 (single-author)
+PROJECT: lean-verify
+
+[ORIGINAL PROBLEMS] (Problems/*.md)
+- (none)
+
+[PROPOSITIONS] (Propos/<分类>/<id>.md)
+- id=p-enc | 概率=1 | 状态=已验证·真 | 优先级=never | 价值/关键性=0.5 | 来源问题= | 形式化=none | 陈述=鼓励模式下的忠实性审查
+    · 已检验通过：证明#0 | mock 第二轮一致
+
+[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)
+- (none)
+
+[STILL UNVERIFIED — v3 的完整性判据 leftoverVerify（buildVerifyCandidates）；必须标注为未决]
+- (none — 没有待验证对象)
+
+[UNRESOLVED / REFUTED — 论文里必须显式标注，不得当成已成立的结论]
+- (none — 所有对象均已定论)
+
+[EVIDENCE INDEX] (only files that exist)
+- Logs/Verification/r-p-enc_<TIME>.json
+- Propos/数论/p-enc.md
+- State/formal.json
+- State/index.json
+- Verified/命题/p-enc.md
+```
+
+## [21] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -1087,32 +1059,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-gate",
-      "kind": "proposition",
-      "target": "p-gate",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-gate（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-gate"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -1129,7 +1082,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [20] spawn · verifier:r-p-gate:0
+## [22] spawn · verifier:r-p-gate:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1147,7 +1100,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1187,7 +1141,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-gate","decision":"used|blocked|defect","file":"Formal/p-gate.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [21] spawn · verifier:r-p-gate:1
+## [23] spawn · verifier:r-p-gate:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1205,7 +1159,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1245,7 +1200,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-gate","decision":"used|blocked|defect","file":"Formal/p-gate.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [22] spawn · planner:plan-<ID>
+## [24] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -1256,69 +1211,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-gate",
-      "kind": "proposition",
-      "target": "p-gate",
-      "prob": 0.6,
-      "priority": 1
-    },
-    {
-      "rId": "r-p-mode",
-      "kind": "proposition",
-      "target": "p-mode",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】p-gate 的表决结果为 真，但 **require 模式**要求先有 Lean 通过或显式阻塞记录，因此本轮**不定论**（已记入 Formal/TODO.md）。请完成形式化（vibe_math_lean_archive kind='proof'）或记录阻塞原因（kind='blocked'）后重新提议验证。"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-gate = 1 被 require 门禁搁置（formal-required；对象 p-gate 尚无 Lean 通过或阻塞记录）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-mode"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "cleared 0 agent(s) and 1 task(s) (restart)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-gate（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-mode"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -1335,7 +1234,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [23] spawn · verifier:r-p-mode:0
+## [25] spawn · verifier:r-p-mode:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1353,7 +1252,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1393,7 +1293,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [24] spawn · verifier:r-p-mode:1
+## [26] spawn · verifier:r-p-mode:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1411,7 +1311,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1451,7 +1352,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [25] spawn · planner:plan-<ID>
+## [27] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -1462,69 +1363,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-gate",
-      "kind": "proposition",
-      "target": "p-gate",
-      "prob": 0.6,
-      "priority": 1
-    },
-    {
-      "rId": "r-p-mode",
-      "kind": "proposition",
-      "target": "p-mode",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-gate（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-mode"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 0 problem(s), 2 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 2 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "cleared 0 agent(s) and 1 task(s) (restart)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-gate（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-gate"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -1541,7 +1386,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [26] spawn · verifier:r-p-gate:0
+## [28] spawn · verifier:r-p-gate:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1559,7 +1404,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1599,7 +1445,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-gate","decision":"used|blocked|defect","file":"Formal/p-gate.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [27] spawn · verifier:r-p-gate:1
+## [29] spawn · verifier:r-p-gate:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1617,7 +1463,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1657,7 +1504,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-gate","decision":"used|blocked|defect","file":"Formal/p-gate.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [28] spawn · verifier:r-p-mode:0
+## [30] spawn · verifier:r-p-mode:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1675,7 +1522,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1715,7 +1563,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [29] spawn · verifier:r-p-mode:1
+## [31] spawn · verifier:r-p-mode:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1733,7 +1581,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1773,7 +1622,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [30] spawn · planner:plan-<ID>
+## [32] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -1784,69 +1633,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-gate",
-      "kind": "proposition",
-      "target": "p-gate",
-      "prob": 0.6,
-      "priority": 1
-    },
-    {
-      "rId": "r-p-mode",
-      "kind": "proposition",
-      "target": "p-mode",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 0 problem(s), 2 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-mode"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-G 为 p-gate 归档形式化证明 Formal/p-gate.lean（运行 **通过**，已归档到 Verified/Lean/p-gate.lean，验证转为忠实性审查）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 4 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "cleared 0 agent(s) and 2 task(s) (restart)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-gate（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-gate"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -1863,7 +1656,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [31] spawn · verifier:r-p-gate:0
+## [33] spawn · verifier:r-p-gate:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1881,7 +1674,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1923,7 +1717,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-gate","decision":"used|blocked|defect","file":"Formal/p-gate.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [32] spawn · verifier:r-p-gate:1
+## [34] spawn · verifier:r-p-gate:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -1941,7 +1735,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -1983,7 +1778,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-gate","decision":"used|blocked|defect","file":"Formal/p-gate.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [33] spawn · verifier:r-p-mode:0
+## [35] spawn · verifier:r-p-mode:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2001,7 +1796,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2041,7 +1837,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [34] spawn · verifier:r-p-mode:1
+## [36] spawn · verifier:r-p-mode:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2059,7 +1855,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2099,7 +1896,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [35] spawn · planner:plan-<ID>
+## [37] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -2110,69 +1907,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-blocked-ok",
-      "kind": "proposition",
-      "target": "p-blocked-ok",
-      "prob": 0.6,
-      "priority": 1
-    },
-    {
-      "rId": "r-p-mode",
-      "kind": "proposition",
-      "target": "p-mode",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-mode"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-gate = 1 (fully verified)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-blocked-ok"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-G 记录 p-blocked-ok 形式化阻塞：命题涉及未形式化的分析学，本轮不做"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 2 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "cleared 0 agent(s) and 2 task(s) (restart)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-gate（v3：md 知识库 + 规划代理调度 + 方法库）"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -2189,7 +1930,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [36] spawn · verifier:r-p-blocked-ok:0
+## [38] spawn · verifier:r-p-blocked-ok:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2207,7 +1948,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2241,7 +1983,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-blocked-ok","decision":"used|blocked|defect","file":"Formal/p-blocked-ok.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [37] spawn · verifier:r-p-blocked-ok:1
+## [39] spawn · verifier:r-p-blocked-ok:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2259,7 +2001,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2293,7 +2036,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-blocked-ok","decision":"used|blocked|defect","file":"Formal/p-blocked-ok.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [38] spawn · verifier:r-p-mode:0
+## [40] spawn · verifier:r-p-mode:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2311,7 +2054,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2351,7 +2095,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [39] spawn · verifier:r-p-mode:1
+## [41] spawn · verifier:r-p-mode:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2369,7 +2113,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2409,7 +2154,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-mode","decision":"used|blocked|defect","file":"Formal/p-mode.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [40] spawn · planner:plan-<ID>
+## [42] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -2420,32 +2165,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-reply",
-      "kind": "proposition",
-      "target": "p-reply",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-reply"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -2462,7 +2188,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [41] spawn · verifier:r-p-reply:0
+## [43] spawn · verifier:r-p-reply:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2480,7 +2206,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2520,7 +2247,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-reply","decision":"used|blocked|defect","file":"Formal/p-reply.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [42] spawn · verifier:r-p-reply:1
+## [44] spawn · verifier:r-p-reply:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2538,7 +2265,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2578,7 +2306,60 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-reply","decision":"used|blocked|defect","file":"Formal/p-reply.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [43] spawn · planner:plan-<ID>
+## [45] spawn · paper-writer:lean-reply
+
+```text
+You are the DEDICATED PAPER WRITER (single-author mode) of a math research run that has just CONVERGED.
+Write its final paper in 中文（Chinese）, using ONLY the evidence in the MATERIAL section below.
+
+HARD RULES:
+- NEVER invent content: no new proposition, no new computation, no citation that is not in the MATERIAL.
+- Unresolved or refuted items MUST be explicitly labelled (「未定论」/「已被否证」, or "unresolved"/"refuted" in English); never present them as established.
+- Fixed 9-section skeleton — provide bodies for these EXACT `## ` headings (the framework writes the headings, author/date and the evidence index itself):
+    1. 摘要 — 1 标题、作者、日期、摘要（原问题 + 主要结论）
+    2. 引言与问题背景 — 2 原问题的完整陈述
+    3. 原问题的完整解法 — 3 最终答案 + 完整推理链
+    4. 已检验通过的命题 — 4 逐条列出，含判定为真的估计值与证据来源
+    5. 已解决的子问题与中间成果 — 5
+    6. 创造或发现的有价值之物 — 6 方法、理论、思想、有价值经验、数学理解
+    7. 规律总结 — 7 从上述条目归纳出的可复用规律
+    8. 讨论、局限与展望 — 8
+    9. 附录：证据与文件索引 — 9 Verified/、Logs/、关键卡片路径
+- A section with no evidence must be exactly 「（本节暂无证据支持的内容——不编造。）」 (do not pad it).
+- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.
+
+OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:
+{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}
+
+MATERIAL (evidence only — do not add anything beyond it):
+PRESET: vibe-math-v3 (single-author)
+PROJECT: lean-reply
+
+[ORIGINAL PROBLEMS] (Problems/*.md)
+- (none)
+
+[PROPOSITIONS] (Propos/<分类>/<id>.md)
+- id=p-reply | 概率=0.5 | 状态=未定论 | 优先级=1 | 价值/关键性=0.5 | 来源问题= | 形式化=blocked | 陈述=用回执记录阻塞
+
+[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)
+- (none)
+
+[STILL UNVERIFIED — v3 的完整性判据 leftoverVerify（buildVerifyCandidates）；必须标注为未决]
+- (none — 没有待验证对象)
+
+[UNRESOLVED / REFUTED — 论文里必须显式标注，不得当成已成立的结论]
+- 未定论：命题 p-reply（概率=0.5）
+
+[EVIDENCE INDEX] (only files that exist)
+- Formal/Index.md
+- Formal/TODO.md
+- Logs/Verification/r-p-reply_<TIME>.json
+- Propos/数论/p-reply.md
+- State/formal.json
+- State/index.json
+```
+
+## [46] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -2589,62 +2370,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-used",
-      "kind": "proposition",
-      "target": "p-used",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 0 problem(s), 1 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】c39 通过回执记录 p-reply 形式化阻塞：需要大量未形式化的实分析前置知识"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-reply = 0.5 (uncertain)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "stop",
-      "detail": "all active problems solved (never-priority excluded) and no active agents/tasks/plans — scheduler stopped (strict termination)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-used"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -2661,7 +2393,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [44] spawn · verifier:r-p-used:0
+## [47] spawn · verifier:r-p-used:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2679,7 +2411,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2719,7 +2452,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-used","decision":"used|blocked|defect","file":"Formal/p-used.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [45] spawn · verifier:r-p-used:1
+## [48] spawn · verifier:r-p-used:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2737,7 +2470,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2777,7 +2511,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-used","decision":"used|blocked|defect","file":"Formal/p-used.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [46] spawn · planner:plan-<ID>
+## [49] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -2788,69 +2522,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-used",
-      "kind": "proposition",
-      "target": "p-used",
-      "prob": 0.6,
-      "priority": 1
-    },
-    {
-      "rId": "r-p-nonote",
-      "kind": "proposition",
-      "target": "p-nonote",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-used"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 0 problem(s), 1 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】c42 通过回执记录 p-used 形式化草稿：Formal/p-used.lean"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】p-used 的表决结果为 真，但 **require 模式**要求先有 Lean 通过或显式阻塞记录，因此本轮**不定论**（已记入 Formal/TODO.md）。请完成形式化（vibe_math_lean_archive kind='proof'）或记录阻塞原因（kind='blocked'）后重新提议验证。"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-used = 1 被 require 门禁搁置（formal-required；对象 p-used 尚无 Lean 通过或阻塞记录）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -2867,7 +2545,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [47] spawn · verifier:r-p-nonote:0
+## [50] spawn · verifier:r-p-nonote:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2885,7 +2563,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2925,7 +2604,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-nonote","decision":"used|blocked|defect","file":"Formal/p-nonote.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [48] spawn · verifier:r-p-nonote:1
+## [51] spawn · verifier:r-p-nonote:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -2943,7 +2622,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -2983,7 +2663,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-nonote","decision":"used|blocked|defect","file":"Formal/p-nonote.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [49] spawn · planner:plan-<ID>
+## [52] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -2994,37 +2674,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-defect",
-      "kind": "proposition",
-      "target": "p-defect",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-I 为 p-defect 归档形式化证明 Formal/p-defect.lean（运行 **通过**，已归档到 Verified/Lean/p-defect.lean，验证转为忠实性审查）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-defect（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-defect"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -3041,7 +2697,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [50] spawn · verifier:r-p-defect:0
+## [53] spawn · verifier:r-p-defect:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3059,7 +2715,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3101,7 +2758,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-defect","decision":"used|blocked|defect","file":"Formal/p-defect.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [51] spawn · verifier:r-p-defect:1
+## [54] spawn · verifier:r-p-defect:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3119,7 +2776,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3161,7 +2819,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-defect","decision":"used|blocked|defect","file":"Formal/p-defect.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [52] spawn · planner:plan-<ID>
+## [55] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -3172,37 +2830,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-nonote-defect",
-      "kind": "proposition",
-      "target": "p-nonote-defect",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-J 为 p-nonote-defect 归档形式化证明 Formal/p-nonote-defect.lean（运行 **通过**，已归档到 Verified/Lean/p-nonote-defect.lean，验证转为忠实性审查）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-defect-nonote（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-nonote-defect"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -3219,7 +2853,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [53] spawn · verifier:r-p-nonote-defect:0
+## [56] spawn · verifier:r-p-nonote-defect:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3237,7 +2871,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3279,7 +2914,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-nonote-defect","decision":"used|blocked|defect","file":"Formal/p-nonote-defect.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [54] spawn · verifier:r-p-nonote-defect:1
+## [57] spawn · verifier:r-p-nonote-defect:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3297,7 +2932,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3339,7 +2975,64 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-nonote-defect","decision":"used|blocked|defect","file":"Formal/p-nonote-defect.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [55] spawn · planner:plan-<ID>
+## [58] spawn · paper-writer:lean-defect-nonote
+
+```text
+You are the DEDICATED PAPER WRITER (single-author mode) of a math research run that has just CONVERGED.
+Write its final paper in 中文（Chinese）, using ONLY the evidence in the MATERIAL section below.
+
+HARD RULES:
+- NEVER invent content: no new proposition, no new computation, no citation that is not in the MATERIAL.
+- Unresolved or refuted items MUST be explicitly labelled (「未定论」/「已被否证」, or "unresolved"/"refuted" in English); never present them as established.
+- Fixed 9-section skeleton — provide bodies for these EXACT `## ` headings (the framework writes the headings, author/date and the evidence index itself):
+    1. 摘要 — 1 标题、作者、日期、摘要（原问题 + 主要结论）
+    2. 引言与问题背景 — 2 原问题的完整陈述
+    3. 原问题的完整解法 — 3 最终答案 + 完整推理链
+    4. 已检验通过的命题 — 4 逐条列出，含判定为真的估计值与证据来源
+    5. 已解决的子问题与中间成果 — 5
+    6. 创造或发现的有价值之物 — 6 方法、理论、思想、有价值经验、数学理解
+    7. 规律总结 — 7 从上述条目归纳出的可复用规律
+    8. 讨论、局限与展望 — 8
+    9. 附录：证据与文件索引 — 9 Verified/、Logs/、关键卡片路径
+- A section with no evidence must be exactly 「（本节暂无证据支持的内容——不编造。）」 (do not pad it).
+- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.
+
+OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:
+{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}
+
+MATERIAL (evidence only — do not add anything beyond it):
+PRESET: vibe-math-v3 (single-author)
+PROJECT: lean-defect-nonote
+
+[ORIGINAL PROBLEMS] (Problems/*.md)
+- (none)
+
+[PROPOSITIONS] (Propos/<分类>/<id>.md)
+- id=p-nonote-defect | 概率=1 | 状态=已验证·真 | 优先级=never | 价值/关键性=0.5 | 来源问题= | 形式化=passed（Verified/Lean/p-nonote-defect.lean） | 陈述=没有偏差说明的缺陷回执
+    · 已检验通过：证明#0 | 觉得不忠实但没写清楚
+
+[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)
+- (none)
+
+[STILL UNVERIFIED — v3 的完整性判据 leftoverVerify（buildVerifyCandidates）；必须标注为未决]
+- (none — 没有待验证对象)
+
+[UNRESOLVED / REFUTED — 论文里必须显式标注，不得当成已成立的结论]
+- (none — 所有对象均已定论)
+
+[EVIDENCE INDEX] (only files that exist)
+- Formal/Index.md
+- Formal/TODO.md
+- Formal/p-nonote-defect.lean
+- Logs/Verification/r-p-nonote-defect_<TIME>.json
+- Propos/数论/p-nonote-defect.md
+- State/formal.json
+- State/index.json
+- Verified/Lean/p-nonote-defect.lean
+- Verified/命题/p-nonote-defect.md
+```
+
+## [59] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -3350,62 +3043,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-blocked-defect",
-      "kind": "proposition",
-      "target": "p-blocked-defect",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 0 problem(s), 1 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】c51 的 formal.decision=defect 未写明 note，已**拒绝**记录（忠实性缺陷必须写出具体偏差，否则无从复核）。该对象的形式化记录与归档证明**保持不变**。"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-nonote-defect = 1 (fully verified)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "stop",
-      "detail": "all active problems solved (never-priority excluded) and no active agents/tasks/plans — scheduler stopped (strict termination)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-J 记录 p-blocked-defect 形式化阻塞：先按难度记为阻塞"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-defect-nonote（v3：md 知识库 + 规划代理调度 + 方法库）"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -3422,7 +3066,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [56] spawn · verifier:r-p-blocked-defect:0
+## [60] spawn · verifier:r-p-blocked-defect:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3440,7 +3084,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3474,7 +3119,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-blocked-defect","decision":"used|blocked|defect","file":"Formal/p-blocked-defect.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [57] spawn · verifier:r-p-blocked-defect:1
+## [61] spawn · verifier:r-p-blocked-defect:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3492,7 +3137,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3526,7 +3172,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-blocked-defect","decision":"used|blocked|defect","file":"Formal/p-blocked-defect.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [58] spawn · planner:plan-<ID>
+## [62] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -3537,37 +3183,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-nodelete",
-      "kind": "proposition",
-      "target": "p-nodelete",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-K 为 p-nodelete 归档形式化证明 Formal/p-nodelete.lean（运行 **通过**，已归档到 Verified/Lean/p-nodelete.lean，验证转为忠实性审查）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-defect-nodelete（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-nodelete"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -3584,7 +3206,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [59] spawn · verifier:r-p-nodelete:0
+## [63] spawn · verifier:r-p-nodelete:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3602,7 +3224,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3644,7 +3267,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-nodelete","decision":"used|blocked|defect","file":"Formal/p-nodelete.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [60] spawn · verifier:r-p-nodelete:1
+## [64] spawn · verifier:r-p-nodelete:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3662,7 +3285,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3704,7 +3328,62 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-nodelete","decision":"used|blocked|defect","file":"Formal/p-nodelete.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [61] spawn · planner:plan-<ID>
+## [65] spawn · paper-writer:lean-defect-nodelete
+
+```text
+You are the DEDICATED PAPER WRITER (single-author mode) of a math research run that has just CONVERGED.
+Write its final paper in 中文（Chinese）, using ONLY the evidence in the MATERIAL section below.
+
+HARD RULES:
+- NEVER invent content: no new proposition, no new computation, no citation that is not in the MATERIAL.
+- Unresolved or refuted items MUST be explicitly labelled (「未定论」/「已被否证」, or "unresolved"/"refuted" in English); never present them as established.
+- Fixed 9-section skeleton — provide bodies for these EXACT `## ` headings (the framework writes the headings, author/date and the evidence index itself):
+    1. 摘要 — 1 标题、作者、日期、摘要（原问题 + 主要结论）
+    2. 引言与问题背景 — 2 原问题的完整陈述
+    3. 原问题的完整解法 — 3 最终答案 + 完整推理链
+    4. 已检验通过的命题 — 4 逐条列出，含判定为真的估计值与证据来源
+    5. 已解决的子问题与中间成果 — 5
+    6. 创造或发现的有价值之物 — 6 方法、理论、思想、有价值经验、数学理解
+    7. 规律总结 — 7 从上述条目归纳出的可复用规律
+    8. 讨论、局限与展望 — 8
+    9. 附录：证据与文件索引 — 9 Verified/、Logs/、关键卡片路径
+- A section with no evidence must be exactly 「（本节暂无证据支持的内容——不编造。）」 (do not pad it).
+- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.
+
+OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:
+{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}
+
+MATERIAL (evidence only — do not add anything beyond it):
+PRESET: vibe-math-v3 (single-author)
+PROJECT: lean-defect-nodelete
+
+[ORIGINAL PROBLEMS] (Problems/*.md)
+- (none)
+
+[PROPOSITIONS] (Propos/<分类>/<id>.md)
+- id=p-nodelete | 概率=0.5 | 状态=未定论 | 优先级=1 | 价值/关键性=0.5 | 来源问题= | 形式化=attempted | 陈述=宿主无法删除文件时的撤回
+
+[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)
+- (none)
+
+[STILL UNVERIFIED — v3 的完整性判据 leftoverVerify（buildVerifyCandidates）；必须标注为未决]
+- (none — 没有待验证对象)
+
+[UNRESOLVED / REFUTED — 论文里必须显式标注，不得当成已成立的结论]
+- 未定论：命题 p-nodelete（概率=0.5）
+
+[EVIDENCE INDEX] (only files that exist)
+- Formal/Index.md
+- Formal/TODO.md
+- Formal/p-nodelete.lean
+- Logs/Verification/r-p-nodelete_<TIME>.json
+- Propos/数论/p-nodelete.md
+- State/formal.json
+- State/index.json
+- Verified/Lean/p-nodelete.lean
+```
+
+## [66] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -3715,37 +3394,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-stale",
-      "kind": "proposition",
-      "target": "p-stale",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-L 为 p-stale 归档形式化证明 Formal/p-stale.lean（运行 **通过**，已归档到 Verified/Lean/p-stale.lean，验证转为忠实性审查）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-stale-card（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-stale"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -3762,7 +3417,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [62] spawn · verifier:r-p-stale:0
+## [67] spawn · verifier:r-p-stale:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3780,7 +3435,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3822,7 +3478,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-stale","decision":"used|blocked|defect","file":"Formal/p-stale.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [63] spawn · verifier:r-p-stale:1
+## [68] spawn · verifier:r-p-stale:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -3840,7 +3496,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -3882,7 +3539,64 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-stale","decision":"used|blocked|defect","file":"Formal/p-stale.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [64] spawn · planner:plan-<ID>
+## [69] spawn · paper-writer:lean-stale-card
+
+```text
+You are the DEDICATED PAPER WRITER (single-author mode) of a math research run that has just CONVERGED.
+Write its final paper in 中文（Chinese）, using ONLY the evidence in the MATERIAL section below.
+
+HARD RULES:
+- NEVER invent content: no new proposition, no new computation, no citation that is not in the MATERIAL.
+- Unresolved or refuted items MUST be explicitly labelled (「未定论」/「已被否证」, or "unresolved"/"refuted" in English); never present them as established.
+- Fixed 9-section skeleton — provide bodies for these EXACT `## ` headings (the framework writes the headings, author/date and the evidence index itself):
+    1. 摘要 — 1 标题、作者、日期、摘要（原问题 + 主要结论）
+    2. 引言与问题背景 — 2 原问题的完整陈述
+    3. 原问题的完整解法 — 3 最终答案 + 完整推理链
+    4. 已检验通过的命题 — 4 逐条列出，含判定为真的估计值与证据来源
+    5. 已解决的子问题与中间成果 — 5
+    6. 创造或发现的有价值之物 — 6 方法、理论、思想、有价值经验、数学理解
+    7. 规律总结 — 7 从上述条目归纳出的可复用规律
+    8. 讨论、局限与展望 — 8
+    9. 附录：证据与文件索引 — 9 Verified/、Logs/、关键卡片路径
+- A section with no evidence must be exactly 「（本节暂无证据支持的内容——不编造。）」 (do not pad it).
+- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.
+
+OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:
+{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}
+
+MATERIAL (evidence only — do not add anything beyond it):
+PRESET: vibe-math-v3 (single-author)
+PROJECT: lean-stale-card
+
+[ORIGINAL PROBLEMS] (Problems/*.md)
+- (none)
+
+[PROPOSITIONS] (Propos/<分类>/<id>.md)
+- id=p-stale | 概率=1 | 状态=已验证·真 | 优先级=never | 价值/关键性=0.5 | 来源问题= | 形式化=passed（Verified/Lean/p-stale.lean） | 陈述=定论后才被认定形式化不忠实
+    · 已检验通过：证明#0 | mock 裁决 1
+
+[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)
+- (none)
+
+[STILL UNVERIFIED — v3 的完整性判据 leftoverVerify（buildVerifyCandidates）；必须标注为未决]
+- (none — 没有待验证对象)
+
+[UNRESOLVED / REFUTED — 论文里必须显式标注，不得当成已成立的结论]
+- (none — 所有对象均已定论)
+
+[EVIDENCE INDEX] (only files that exist)
+- Formal/Index.md
+- Formal/TODO.md
+- Formal/p-stale.lean
+- Logs/Verification/r-p-stale_<TIME>.json
+- Propos/数论/p-stale.md
+- State/formal.json
+- State/index.json
+- Verified/Lean/p-stale.lean
+- Verified/命题/p-stale.md
+```
+
+## [70] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -3893,67 +3607,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [
-    {
-      "id": "q-w",
-      "状态": "求解中",
-      "优先级": 1,
-      "依赖": [],
-      "依赖就绪": true,
-      "方向数": 0,
-      "活跃方向": [],
-      "running_solver_dirs": [],
-      "最高存活率": null,
-      "解法数": 0
-    }
-  ],
-  "verify_candidates": [],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-stale-card（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-stale"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> called with 0 problem(s), 1 verify candidate(s)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-stale = 1 (fully verified)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "stop",
-      "detail": "all active problems solved (never-priority excluded) and no active agents/tasks/plans — scheduler stopped (strict termination)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-stale-card（v3：md 知识库 + 规划代理调度 + 方法库）"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -3970,7 +3630,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [65] spawn · explorer:q-w
+## [71] spawn · explorer:q-w
 
 ```text
 You are a research mathematician orchestrating strategy for one problem.
@@ -3987,7 +3647,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4015,7 +3676,7 @@ feasibility ∈ [0,1] = your estimate of the probability this direction leads to
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [66] spawn · explorer:q-w
+## [72] spawn · explorer:q-w
 
 ```text
 You are a research mathematician orchestrating strategy for one problem.
@@ -4032,7 +3693,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4060,7 +3722,7 @@ feasibility ∈ [0,1] = your estimate of the probability this direction leads to
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [67] spawn · explorer:q-defect
+## [73] spawn · explorer:q-defect
 
 ```text
 You are a research mathematician orchestrating strategy for one problem.
@@ -4077,7 +3739,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4105,7 +3768,7 @@ feasibility ∈ [0,1] = your estimate of the probability this direction leads to
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [68] spawn · planner:plan-<ID>
+## [74] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -4116,45 +3779,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [
-    {
-      "id": "q-defect",
-      "状态": "求解中",
-      "优先级": 1,
-      "依赖": [],
-      "依赖就绪": true,
-      "方向数": 0,
-      "活跃方向": [],
-      "running_solver_dirs": [],
-      "最高存活率": null,
-      "解法数": 0
-    }
-  ],
-  "verify_candidates": [],
-  "active_agents": [
-    {
-      "childId": "<CHILD>",
-      "role": "explorer",
-      "target": "q-defect",
-      "direction": "",
-      "round": ""
-    }
-  ],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-M 为 q-defect 归档形式化证明 Formal/q-defect.lean（运行 **通过**，已归档到 Verified/Lean/q-defect.lean，验证转为忠实性审查）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-workline（v3：md 知识库 + 规划代理调度 + 方法库）"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -4171,7 +3802,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [69] spawn · solver:q-defect:d1
+## [75] spawn · solver:q-defect:d1
 
 ```text
 You are a dedicated solver agent working ONE solution direction of a math problem (agent_self_iteration).
@@ -4190,7 +3821,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4207,7 +3839,7 @@ WRITE-INTO-MD WORKFLOW（优先推荐）：把研究内容直接写进你的归
 - 若你的环境无法真正写文件（文件工具不可用/被拒），回退：把要写的内容放进回复 JSON 的 `__writes` 数组（`[{"path":"<目标>","content":"<全文>"}]`）并同样配 `meta`，由调度器落盘。两种方式二选一，不要重复。
 你的归属文件：
 - 求解器：把该方向的完整叙述（本轮进展/子路线/可行性信号/教训/完整解法文本）写进 `Progress/<问题id>/<方向id>.md`；聚合索引 `Progress/<问题id>.md` 由调度器维护，不要动它。
-- 新引理：写一张完整命题卡到 `Propos/<分类>/<p-id>.md`，含锚点 `- 标题:`、`- ID/类型/状态/概率/优先级` 与 `## 陈述`；证明写进 `### 证明 1｜标题｜概率X｜状态Y` 段落（完整证明文本是验证必需，否则验证器只能验裸命题）。
+- 新引理：写一张完整命题卡到 `Propos/<分类>/<p-id>.md`，含锚点 `- 标题:`、`- ID/类型/状态/概率/优先级/价值关键性` 与 `## 陈述`；证明写进 `### 证明 1｜标题｜概率X｜状态Y` 段落（完整证明文本是验证必需，否则验证器只能验裸命题）。`- 价值/关键性: <0..1>` 表示这条引理对项目主线的关键程度（≥ 阈值会被自动晋升为独立问题），别省。
 
 
 YOUR PERMISSIONS / CAPABILITIES:
@@ -4239,7 +3871,7 @@ LEMMA RULES: every lemma you register MUST carry a complete proof in `lemmas[].p
 
 OUTPUT CONTRACT — pick ONE channel. Write content into Markdown; only lightweight scheduling metadata (and verification-required proofs) cross the machine reply.
 CHANNEL A (recommended, you can write files): write the full round narrative into `Progress/q-defect/d1.md` and each new lemma card into `Propos/<分类>/<id>.md`, then reply ONLY this metadata object:
-{"meta":{"kind":"solver","qid":"q-defect","dirId":"d1","round":1,"survival":0.5,"status":"continue|success|dead-end","dead_end_reason":"... or null","lemmas":[{"id":"p-...","title":"...","statement":"...","proof":"<完整证明文本，供验证器核验>","prob":0.6,"分类":"<引理卡目录名，必须与你要写入的 Propos/<分类>/ 目录严格一致>","优先级":1}],"methods_used":[{"id":"m-...","效果":"...","建议":"..."}],"new_inventions":[{"类型":"...","标题":"...","内容描述":"...","是否已入库":false}],"solution_prob":0.85,"solution_text":"<完整解法文本，或 null>","sub_questions":[{"q_sub_title":"...","q_sub_statement":"完整问题陈述(含所有对象/定义)","assumption_title":"p_{q-tmp} 标题","assumption_statement":"完整假设陈述(含所有定义)"}]}}
+{"meta":{"kind":"solver","qid":"q-defect","dirId":"d1","round":1,"survival":0.5,"status":"continue|success|dead-end","dead_end_reason":"... or null","lemmas":[{"id":"p-...","title":"...","statement":"...","proof":"<完整证明文本，供验证器核验>","prob":0.6,"价值/关键性":0.5,"分类":"<引理卡目录名，必须与你要写入的 Propos/<分类>/ 目录严格一致>","优先级":1}],"methods_used":[{"id":"m-...","效果":"...","建议":"..."}],"new_inventions":[{"类型":"...","标题":"...","内容描述":"...","是否已入库":false}],"solution_prob":0.85,"solution_text":"<完整解法文本，或 null>","sub_questions":[{"q_sub_title":"...","q_sub_statement":"完整问题陈述(含所有对象/定义)","assumption_title":"p_{q-tmp} 标题","assumption_statement":"完整假设陈述(含所有定义)"}]}}
 CHANNEL B (your file tools are unavailable): put the content you would have written into __writes and carry the same meta:
 {"__writes":[{"path":"Progress/q-defect/d1.md","content":"<完整本轮叙述>"}],"meta":{"kind":"solver","qid":"q-defect","dirId":"d1",...同上 meta 字段...}}
 区分规则：methods_used 只能填**已存在的方法卡 ID**（m-…，来自 AVAILABLE METHODS 列表）——引用你自己刚想出的新方法/新技巧不属于 methods_used，请如实填入 new_inventions（它会由 Method Keeper 蒸馏建卡）；不要把方法名/标题当 id 填进 methods_used。
@@ -4247,7 +3879,7 @@ CHANNEL B (your file tools are unavailable): put the content you would have writ
 形式化回执（本模式）：若你本轮对某个对象做了形式化难度判断，请在回执里加上 "formal":{"target":"<对象id>","decision":"used|blocked|defect","file":"Formal/<对象id>.lean","note":"难度判断/阻塞原因/具体偏差"}（decision='blocked' 与 decision='defect' 时必须写明 note，否则拒绝记录；decision='defect' 表示你认定这条已通过的 Lean 形式化**不忠实于命题原文**——那不是"命题为假"，框架会撤回其已通过状态并把对象放回形式化待办）。
 ```
 
-## [70] spawn · planner:plan-<ID>
+## [76] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -4258,37 +3890,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-fid",
-      "kind": "proposition",
-      "target": "p-fid",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-N 为 p-fid 归档形式化证明 Formal/p-fid.lean（运行 **通过**，已归档到 Verified/Lean/p-fid.lean，验证转为忠实性审查）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-fidelity（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-fid"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -4305,7 +3913,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [71] spawn · verifier:r-p-fid:0
+## [77] spawn · verifier:r-p-fid:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -4323,7 +3931,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4365,7 +3974,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-fid","decision":"used|blocked|defect","file":"Formal/p-fid.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [72] spawn · verifier:r-p-fid:1
+## [78] spawn · verifier:r-p-fid:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -4383,7 +3992,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4425,7 +4035,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-fid","decision":"used|blocked|defect","file":"Formal/p-fid.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [73] wake · verifier:r-p-fid:0
+## [79] wake · verifier:r-p-fid:0
 
 ```text
 You are one reviewer in a DEBATE ("交流群") about this object.
@@ -4443,7 +4053,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4486,7 +4097,7 @@ Reply with ONLY a single JSON object in a ```json code fence, no prose outside i
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: updated logic chain / counterexample / proof / refutation>","changed":"brief reason if you changed your Result, else null","formal":{"target":"p-fid","decision":"used|blocked|defect","file":"Formal/p-fid.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [74] wake · verifier:r-p-fid:1
+## [80] wake · verifier:r-p-fid:1
 
 ```text
 You are one reviewer in a DEBATE ("交流群") about this object.
@@ -4504,7 +4115,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4547,7 +4159,7 @@ Reply with ONLY a single JSON object in a ```json code fence, no prose outside i
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: updated logic chain / counterexample / proof / refutation>","changed":"brief reason if you changed your Result, else null","formal":{"target":"p-fid","decision":"used|blocked|defect","file":"Formal/p-fid.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [75] spawn · planner:plan-<ID>
+## [81] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -4558,69 +4170,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-used",
-      "kind": "proposition",
-      "target": "p-used",
-      "prob": 0.6,
-      "priority": 1
-    },
-    {
-      "rId": "r-p-usedkeep",
-      "kind": "proposition",
-      "target": "p-usedkeep",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】c45 的 formal.decision=blocked 未写明 note，已**拒绝**记录（难度判断必须显式、可审计）。"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-nonote = 0.5 (uncertain)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-usedkeep"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-H 为 p-usedkeep 归档形式化证明 Formal/p-usedkeep.lean（运行 **通过**，已归档到 Verified/Lean/p-usedkeep.lean，验证转为忠实性审查）"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -4637,7 +4193,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [76] spawn · verifier:r-p-usedkeep:0
+## [82] spawn · verifier:r-p-usedkeep:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -4655,7 +4211,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4697,7 +4254,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-usedkeep","decision":"used|blocked|defect","file":"Formal/p-usedkeep.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [77] spawn · verifier:r-p-usedkeep:1
+## [83] spawn · verifier:r-p-usedkeep:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -4715,7 +4272,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4757,7 +4315,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-usedkeep","decision":"used|blocked|defect","file":"Formal/p-usedkeep.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [78] spawn · planner:plan-<ID>
+## [84] spawn · planner:plan-<ID>
 
 ```text
 You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
@@ -4768,69 +4326,13 @@ CURRENT STATE BRIEF (JSON):
   "horizon": 3,
   "free_slots": <SLOTS>,
   "maxParallelThreshold": 64,
-  "problems": [],
-  "verify_candidates": [
-    {
-      "rId": "r-p-used",
-      "kind": "proposition",
-      "target": "p-used",
-      "prob": 0.6,
-      "priority": 1
-    },
-    {
-      "rId": "r-p-usedblocked",
-      "kind": "proposition",
-      "target": "p-usedblocked",
-      "prob": 0.6,
-      "priority": 1
-    }
-  ],
-  "active_agents": [],
-  "methods": [],
-  "pending_inventions": 0,
-  "last_plan": null,
-  "recent_events": [
-    {
-      "at": "<TIME>",
-      "event": "plan",
-      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】c72 通过回执记录 p-usedkeep 形式化草稿：Formal/p-usedkeep.lean（保留已有的 passed 状态：一次 used 回执不撤销已成立的证明/已记录的阻塞）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verdict",
-      "detail": "r-p-usedkeep = 0.5 (uncertain)"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-H 运行 Lean 通过：Formal/p-usedkeep.lean（0.0s）｜对象 p-usedkeep"
-    },
-    {
-      "at": "<TIME>",
-      "event": "abort",
-      "detail": "scheduler aborted, 0 child(ren) interrupted"
-    },
-    {
-      "at": "<TIME>",
-      "event": "start",
-      "detail": "scheduler started for project lean-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
-    },
-    {
-      "at": "<TIME>",
-      "event": "verify",
-      "detail": "verification task created for r-p-usedblocked"
-    },
-    {
-      "at": "<TIME>",
-      "event": "formal",
-      "detail": "【形式化】sess-H 记录 p-usedblocked 形式化阻塞：需要大量未形式化的实分析前置知识"
-    }
-  ]
+  "problems": "<PROBLEMS>",
+  "verify_candidates": "<VERIFY_CANDIDATES>",
+  "active_agents": "<ACTIVE_AGENTS>",
+  "methods": "<METHODS>",
+  "pending_inventions": "<PENDING_INVENTIONS>",
+  "last_plan": "<LAST_PLAN>",
+  "recent_events": "<RECENT_EVENTS>"
 }
 
 ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
@@ -4847,7 +4349,7 @@ Respond with ONLY a single JSON object wrapped in a ```json code fence — no pr
 {"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
 ```
 
-## [79] spawn · verifier:r-p-usedblocked:0
+## [85] spawn · verifier:r-p-usedblocked:0
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -4865,7 +4367,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
@@ -4899,7 +4402,7 @@ Independently output your initial review — ONLY a single JSON object in a ```j
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-usedblocked","decision":"used|blocked|defect","file":"Formal/p-usedblocked.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
 
-## [80] spawn · verifier:r-p-usedblocked:1
+## [86] spawn · verifier:r-p-usedblocked:1
 
 ```text
 You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
@@ -4917,7 +4420,8 @@ KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
 
 2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
 - 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
-- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], 价值/关键性, 来源问题, 来源方向, ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- `价值/关键性 ∈ [0,1]`（M1）：这条命题对**整个项目主线**有多关键——若它成立/被证伪，能改变多少后续方向。≥ promoteValueThreshold（默认 0.7）且仍未定论(概率∈(0,1))的命题会被自动晋升成「判断下述命题是否成立：…」问题，由求解器专门证明/证伪并把结果回写源命题。你不填就默认 0.5（永不晋升）。**只有你（写卡的代理）能设这个值**——请在你认为"这条引理/猜想值得单独立项"时显式写上。
 - 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
 - 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
 - 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。