dsh-vibe-math 2.7.1 → 2.7.3

package/vibe-math-v2/vibe-math-v2.js

@@ -1,3 +1,106 @@
+// ================= F-B: 参数机读 schema 的单一真源（模块作用域） =================
+// 工具面 `vibe_math_set_params` 的 `parameters` 由 PARAM_SCHEMA 派生，描述/类型只有一处真源
+//（真源与例外说明见 docs/parameter-schema.md）。本块整体位于**模块作用域**，因为本文件定义了两处
+// `objParams`（会话层 makeSession + apply 层）——只有模块作用域能被两层同时看见（rehearsal 曾因此
+// 让 apply 层拿到只有例外项的残缺 schema）。下列常量与 PARAM_SCHEMA 是从 makeSession 内**逐字上移**的纯
+// 常量（值不变、作用域上移），会话层原有引用照旧解析到它们。
+  const IS_WINDOWS = process.platform === 'win32'
+  const SCRIPT_TOOLS = IS_WINDOWS ? ['pwsh'] : ['bash']
+  const NETWORK_TOOLS = ['web_search', 'web_fetch']
+  const ACTIVITY_REPORT_MAX = 30
+const LEAN_INITIATIVE_MODES = ['off', 'normal', 'eager']
+  const PARAM_SCHEMA = [
+    { name: 'mode', type: 'enum', options: ['auto', 'manual'], description: 'auto = 无人值守自动通过关键节点；manual = 关键节点挂起人工决策', suggestion: 'auto' },
+    { name: 'maxParallelThreshold', type: 'integer', description: '全局最大并发子代理轮数（新派发前须满足 active < 阈值）', suggestion: 4 },
+    { name: 'solverMaxRounds', type: 'integer', description: '每个求解方向的最大迭代轮数（agent_self_iteration 上限）', suggestion: 3 },
+    { name: 'directionsPerSolver', type: 'integer', description: '每个 solver 提示词附带的其他活跃方向摘要数量：1 = 只看自己方向（互不干扰）；N>1 = 额外附带最多 N 个其他活跃方向摘要用于协调', suggestion: 1 },
+    { name: 'verifierCount', type: 'integer', description: '每个验证对象的独立验证器数量（下限 2：一票不裁决）。并发预算紧张时单个对象同时最多占用 maxParallelThreshold-2 个槽位（至少 2），以保证另一个对象也凑得齐 2 票', suggestion: 3 },
+    { name: 'debateMaxRounds', type: 'integer', description: '验证辩论（交流群）最大轮数', suggestion: 5 },
+    { name: 'verdictMode', type: 'enum', options: ['flat', 'forced'], description: 'flat = 均衡机制（不一致时取各评审自报概率的**均值**，绝不折叠成固定的 0.5）；forced = 强制裁决（按验证者历史准确率+布尔票置信度加权）。准确率按 provider/model 这种稳定身份记，且只在对象**后来**取得布尔定论时才计分', suggestion: 'flat' },
+    { name: 'provider', type: 'string', description: '子代理模型 provider（空 = 继承根代理）', suggestion: '' },
+    { name: 'model', type: 'string', description: '子代理模型 id（空 = 继承根代理）', suggestion: '' },
+    { name: 'solverPersona', type: 'string', description: '注入每个求解器提示词开头的人格/要求', suggestion: '' },
+    { name: 'verifierPersona', type: 'string', description: '注入每个验证器提示词开头的人格/要求', suggestion: '' },
+    { name: 'explorerPersona', type: 'string', description: '注入每个 explorer/重派生提示词开头的人格/要求', suggestion: '' },
+    { name: 'knowledgeContext', type: 'string', description: '共享知识/数据模型说明（空 = 内置完整版；非空 = 覆盖，注入 explorer/solver/verifier 提示词）', suggestion: '' },
+    { name: 'solverToolAllow', type: 'string[]', description: '求解器允许的工具名列表（空 = 继承全部工具）', suggestion: [] },
+    { name: 'solverToolDeny', type: 'string[]', description: '求解器禁止的工具名列表', suggestion: [] },
+    { name: 'verifierToolAllow', type: 'string[]', description: '验证器允许的工具名列表', suggestion: [] },
+    { name: 'verifierToolDeny', type: 'string[]', description: '验证器禁止的工具名列表', suggestion: [] },
+    { name: 'solverAllowNetwork', type: 'boolean', description: '求解器网络工具开关：空=继承全部；true=允许（在已有 allow 列表时补入本次组合真正注册的网络工具）；false=禁止网络工具', suggestion: '' },
+    { name: 'verifierAllowNetwork', type: 'boolean', description: '验证器网络工具开关（同 solverAllowNetwork）', suggestion: '' },
+    { name: 'solverAllowScripts', type: 'boolean', description: '求解器脚本工具开关：空=继承全部；true=允许（在已有 allow 列表时补入）；false=禁止 ' + SCRIPT_TOOLS.join('/'), suggestion: '' },
+    { name: 'verifierAllowScripts', type: 'boolean', description: '验证器脚本工具开关（同 solverAllowScripts）', suggestion: '' },
+    { name: 'solverMaxToolCalls', type: 'integer', description: '求解器每轮外部工具调用**建议**上限（0 = 不限）。框架只把它写进提示词，不计数、不强制', suggestion: 0 },
+    { name: 'verifierMaxToolCalls', type: 'integer', description: '验证器每轮外部工具调用**建议**上限（0 = 不限）。框架只把它写进提示词，不计数、不强制', suggestion: 0 },
+    { name: 'reportIntervalMs', type: 'integer', description: '进度汇报间隔（毫秒）：0 = 仅事件驱动（有代理状态更新等事件才写/推报告）；>0 = 同时按该间隔定时自动汇报', suggestion: 0 },
+    { name: 'reportMode', type: 'enum', options: ['file', 'push', 'both'], description: 'file = 写报告文件；push = 推送消息让主代理主动汇报；both = 两者都做', suggestion: 'file' },
+    { name: 'promoteValueThreshold', type: 'number', description: 'Propos 中「价值/关键性」≥ 该值且未决(0,1) 的命题自动加入 qs.json', suggestion: 0.7 },
+    { name: 'priorityAdjust', type: 'enum', options: ['none', 'deadend-deprioritize', 'survival-map'], description: '优先级动态调整策略：none=不自动调；deadend-deprioritize=方向全死路时降优先级；survival-map=按最高方向存活率重算（存活率高越优先）', suggestion: 'none' },
+    { name: 'proposPriorityAdjust', type: 'enum', options: ['none', 'progress-graded'], description: '命题优先级动态调整：none=不自动调；progress-graded=按「定论接近度（|布尔估计-0.5|）+ 证明/证伪材料量」重算，越接近定论越优先验证', suggestion: 'none' },
+    { name: 'tickIntervalMs', type: 'integer', description: '调度器心跳间隔（毫秒）：多久扫描一次子代理状态并推进（越小越灵敏、越大越省资源）', suggestion: 2000 },
+    { name: 'activityLogCap', type: 'integer', description: '活动日志保留条数（影响 status/report 里 recentActivity 的细节量，两者最多显示 ' + ACTIVITY_REPORT_MAX + ' 条）', suggestion: 100 },
+    { name: 'maxExplorerRetries', type: 'integer', description: 'explorer 拆方向失败的重派生上限（达到后该问题标记为方向耗尽）', suggestion: 3 },
+    { name: 'formalVerify', type: 'enum', options: ['off', 'encourage', 'require'], description: 'Lean 形式化验证档位：off=不额外要求（默认，提示词里不出现 Lean）；encourage=鼓励按实现难度自行形式化，一旦 Lean 通过则验证重点转为「忠实性审查」；require=同 encourage 且加门禁——对象的 formal.status 未达到 passed/blocked 前，真/假裁定记为未定论（原因 formal-required）并写入 Formal/TODO.md', suggestion: 'off' },
+    { name: 'leanCommand', type: 'string', description: '要执行的 Lean 可执行文件（默认 lean；用 lake 时配合 leanArgs=["env","lean"]）', suggestion: 'lean' },
+    { name: 'leanArgs', type: 'string[]', description: '插在 .lean 文件名之前的附加命令行参数（默认空）', suggestion: [] },
+    { name: 'leanTimeoutMs', type: 'integer', description: '单次 Lean 运行的超时上限（毫秒，默认 120000，最小 1000）；异步档下它同时是**每个后台编译作业**的预算（到时主动 terminate，作业记 timeout、对象留在 attempted）', suggestion: 120000 },
+    { name: 'leanAsync', type: 'boolean', description: 'Lean 编译模式：true（默认）= 后台队列，vibe_math_lean_run / vibe_math_lean_archive{run:true} 立即返回 async.jobId 入队，成员不阻塞，结果由下一轮提示的【形式化结果】行与 vibe_math_lean_lib / vibe_math_lean_job 公告（**只有作业落地为 ok 才会置 passed 并写归档证明**）；false = 完全同步 await（与旧行为逐字一致）', suggestion: true },
+    { name: 'leanJobsMaxParallel', type: 'integer', description: '后台 Lean 编译的并发上限（默认 1 = 串行，保持可预测的资源占用；调大可并行编译多个作业）', suggestion: 1 },
+    { name: 'leanInitiative', type: 'string', enum: LEAN_INITIATIVE_MODES.slice(), description: '日常流程中的形式化主动性：off（不主动，只在验证提示词按 formalVerify 的要求做）| normal（默认：顺手把有价值且可能复用的东西形式化）| eager（更主动：日常就主动把有价值的小引理/命题/定义形式化）。注意它与 formalVerify（验证时的要求强度：off|encourage|require）是**两件事**', suggestion: 'normal' },
+    { name: 'leanSearchPaths', type: 'array', items: { type: 'string' }, description: '额外 Lean 搜索路径（默认空数组 = 只用框架自动注入的 VibeMath 根）。非空时按顺序先注入这里给的路径、再注入自动根（去重）；若 leanArgs 里已显式给了 --search-path/-R/--root，则完全尊重用户配置、不注入任何东西', suggestion: [] },
+    { name: 'finalPaper', type: 'boolean', description: '收口（严格终止）时自动撰写最终论文：派遣一名专职「论文撰写」子代理，把已检验通过的命题/解法/成果整理成 Paper/<项目>/{paper.md,paper.tex,paper.meta.json,paper.log.md}。false = 只关自动触发，/vibe paper 手动命令仍可用', suggestion: true },
+    { name: 'paperFormat', type: 'enum', options: ['both', 'md', 'tex'], description: '论文产出格式：both = markdown + latex；md = 只写 paper.md；tex = 只写 paper.tex（tex 才会尝试编译 pdf）', suggestion: 'both' },
+    { name: 'paperLanguage', type: 'enum', options: ['zh', 'en'], description: '论文语言：zh = 中文（LaTeX 用 ctexart，引擎优先 xelatex）；en = 英文（article，引擎优先 pdflatex/latexmk）', suggestion: 'zh' },
+    { name: 'paperCompilePdf', type: 'boolean', description: '检测到 LaTeX 时是否编译 paper.pdf（-interaction=nonstopmode 跑两遍；失败先尝试修复：换引擎/去不支持宏包/最小模板）。false 或无 LaTeX 时只保留 tex+md 并记日志', suggestion: true },
+    { name: 'paperLatexCommand', type: 'string', description: '指定 LaTeX 引擎可执行文件（空 = 按语言探测：中文 xelatex > latexmk > pdflatex > lualatex > tectonic；英文 pdflatex 优先）。该命令解析不到时按"未检测到"降级（只留 tex+md）', suggestion: '' },
+    // ---- 数学计算 math_computation（六参数冻结；描述与 prompts.md §1/§6 口径一致）----
+    { name: 'mathComputation', type: 'enum', options: ['off', 'auto', 'on'], description: '数学计算总开关：off = 真无操作（提示词零提及）；auto = 探测到 mathEngines 里任一允许引擎才工作；on = 同上（探测失败时工具仍返回可执行的安装指引，而不是假装可用）', suggestion: 'auto' },
+    { name: 'mathMode', type: 'enum', options: ['typed', 'typed+shell'], description: '计算策略：typed+shell（默认）= 工具不可用时允许宿主 shell 兜底，但结论必须标注"未经工具归档（shell 路径）"；typed = 只用工具路径（提示词里不出现 shell 兜底段，engine:"cli" 返回 REFUSED{reason:policy}）', suggestion: 'typed+shell' },
+    { name: 'mathEngines', type: 'string[]', description: '允许的引擎列表（默认 python|r|octave|julia|matlab|maple|wolfram|cli）。cli 默认开启且走同一套超时/输出上限/回执；从列表里移除某引擎即禁用（商业引擎只探测+许可，永不安装）', suggestion: MATH_PARAM_DEFAULTS.mathEngines.slice() },
+    { name: 'mathTimeoutMs', type: 'integer', description: '单次数学计算的超时上限（毫秒，默认 60000，最小 1000）；到时主动 terminate 并把回执标为 MATH_TIMEOUT', suggestion: 60000 },
+    { name: 'mathPackages', type: 'string[]', description: '需要预检的包（默认空）。缺包只报告 + 给"用户自装指引"或"代理代装计划"，不会执行脚本，也永不自动安装', suggestion: [] },
+    { name: 'mathInstallScope', type: 'string', enum: ['user', 'system'], description: '安装作用域：user（默认，用户级目录）；system 只对当次显式调用生效、永不记忆（不会写进状态文件）', suggestion: 'user' },
+  ]
+
+// 钉住"机读键集合"（现状 v2=49 / v3=63 个，不随 PARAM_SCHEMA 增删而漂移）。
+const PARAM_PROPS_KEYS = ['maxParallelThreshold', 'solverMaxRounds', 'verifierCount', 'debateMaxRounds', 'verdictMode', 'reportMode', 'promoteValueThreshold', 'priorityAdjust', 'proposPriorityAdjust', 'provider', 'model', 'solverPersona', 'verifierPersona', 'explorerPersona', 'knowledgeContext', 'solverToolAllow', 'solverToolDeny', 'verifierToolAllow', 'verifierToolDeny', 'solverAllowNetwork', 'verifierAllowNetwork', 'solverAllowScripts', 'verifierAllowScripts', 'solverMaxToolCalls', 'verifierMaxToolCalls', 'reportIntervalMs', 'tickIntervalMs', 'activityLogCap', 'maxExplorerRetries', 'directionsPerSolver', 'formalVerify', 'leanCommand', 'leanArgs', 'leanTimeoutMs', 'leanAsync', 'leanJobsMaxParallel', 'leanInitiative', 'leanSearchPaths', 'mathComputation', 'mathMode', 'mathEngines', 'mathTimeoutMs', 'mathPackages', 'mathInstallScope', 'finalPaper', 'paperFormat', 'paperLanguage', 'paperCompilePdf', 'paperLatexCommand']
+// 源无法表达的条目：数组 items / oneOf / mode 的现状枚举顺序 —— 逐字沿用，并由
+// "例外集合 == docs/parameter-schema.md" 断言钉住。
+const PARAM_PROPS_EXTRA = {
+solverToolAllow: { type: 'array', items: { type: 'string' } },
+solverToolDeny: { type: 'array', items: { type: 'string' } },
+verifierToolAllow: { type: 'array', items: { type: 'string' } },
+verifierToolDeny: { type: 'array', items: { type: 'string' } },
+leanArgs: { type: 'array', items: { type: 'string' } },
+mathEngines: { type: 'array', items: { type: 'string' } },
+mathPackages: { type: 'array', items: { type: 'string' } },
+solverAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] },
+verifierAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] },
+solverAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] },
+verifierAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] },
+}
+function paramProps() {
+  const props = {}
+  for (const name of PARAM_PROPS_KEYS) {
+    const e = PARAM_SCHEMA.find(function (x) { return x && x.name === name })
+    if (!e) continue
+    const enumVals = (Array.isArray(e.enum) && e.enum.length) ? e.enum : ((Array.isArray(e.options) && e.options.length) ? e.options : null)
+    const isEnum = e.type === 'enum' || !!enumVals
+    const p = isEnum ? { type: 'string', enum: (enumVals || []).slice() } : { type: e.type }
+    if (e.description) p.description = e.description
+    props[name] = p
+  }
+  // 例外表覆盖"源无法表达"的字段，但**保留源里的描述**（覆盖度 v2 49/49、v3 63/63）
+  for (const k of Object.keys(PARAM_PROPS_EXTRA)) {
+    const base = props[k] || {}
+    props[k] = Object.assign({}, PARAM_PROPS_EXTRA[k])
+    if (base.description) props[k].description = base.description
+  }
+  return props
+}
+// ================= end F-B =================
+
 // Vibe Math V2 — host plugin implementing the classic-architecture spec
 // ("vibe-math-v2/实现方案.md"): probability-driven scheduling over a
 // problem list (qs/qs.json) and a proposition knowledge base (Propos/),
@@ -218,7 +321,7 @@ export function apply(ctx) {
   let explorerRetries = {}
   // 状态/报告里最近活动最多显示多少条（**一个常量**）：此前 buildReport 用 min(30, cap)、getStatus
   // 硬编码 min(10, cap)，同一个字段两个端点给出不同答案，而参数说明承诺的是 30（审计 M15）。
-  const ACTIVITY_REPORT_MAX = 30
+  const ACTIVITY_PERSIST_MAX = 200 // P5：活动日志落盘上限（status/report 只显示 30 条，但恢复时保留更多线索）
   // 至少 2 名独立评审才能出裁决（审计 M11）：一票裁决会把单个验证者的判断写成"完全验证"的布尔结论。
   const MIN_REVIEWERS = 2
   // 中段裁决（0<正确概率<1）的**重验冷却**（审计 M12）：中段值是"为真的概率"，不是定论，对象不能
@@ -234,12 +337,30 @@ export function apply(ctx) {
   function projectRoot(slug) { return vibeRoot() + '/Projects/' + slug }
   function frameworkRoot() { return projectRoot(currentProject) }
   let warnedNoPolicy = false
+  // F-5：围栏漂移检测（只告警不拒写）。边界：若解析结果**不暴露**任何 root 字段，本比对无法运行。
+  function policyRootOf(p) {
+    if (!p || typeof p !== 'object') return ''
+    const cand = p.workspaceRoot || p.root || p.cwd || (p.config && p.config.workspaceRoot) || ''
+    return String(cand || '').replace(/\\/g, '/').replace(/\/+$/, '')
+  }
+  let warnedFenceDrift = false
+  function warnFenceDriftOnce(actual, expected) {
+    if (warnedFenceDrift) return
+    warnedFenceDrift = true
+    console.error('vibe-math-v2' + ': sandbox fence root differs from this session workspace (resolved="' + actual + '", session="' + expected + '") — writes may be fenced to the host-configured root; boundary: when the policy object exposes no root field this comparison cannot run')
+  }
+  function checkFenceRoot(p) {
+    const actual = policyRootOf(p)
+    const expected = String(workspaceRoot() || '').replace(/\\/g, '/').replace(/\/+$/, '')
+    if (actual && expected && actual !== expected) warnFenceDriftOnce(actual, expected)
+    return p
+  }
   function warnNoPolicyOnce() { if (!warnedNoPolicy) { warnedNoPolicy = true; console.error('vibe-math-v2: sandboxPolicy unavailable; writes go out with no explicit policy') } }
   // Sandbox fence for our own writes. The `resolve({})` fallback is a last resort and is
   // deliberately reported (once): with no session it resolves the policy's CONFIGURED root
   // (dsh-sandbox-policy: resolveWorkspaceRoot(config.workspaceRoot ?? process.cwd())),
   // which is not necessarily this session's workspace — a silently different fence.
-  function getPolicy() { const sp = sandboxPolicyOf(); if (!sp) { warnNoPolicyOnce(); return undefined } try { if (rootAgent && rootAgent.session) return sp.resolve({ session: rootAgent.session }) } catch (e) { warnNoPolicyOnce() } try { const p = sp.resolve({}); if (!warnedNoPolicy) { warnedNoPolicy = true; console.error('vibe-math-v2: falling back to sandboxPolicy.resolve({}) — the fence root is the host-configured workspace, not necessarily this session cwd') } return p } catch (e) { warnNoPolicyOnce() } return undefined }
+  function getPolicy() { const sp = sandboxPolicyOf(); if (!sp) { warnNoPolicyOnce(); return undefined } try { if (rootAgent && rootAgent.session) return checkFenceRoot(sp.resolve({ session: rootAgent.session })) } catch (e) { warnNoPolicyOnce() } try { const p = sp.resolve({}); if (!warnedNoPolicy) { warnedNoPolicy = true; console.error('vibe-math-v2: falling back to sandboxPolicy.resolve({}) — the fence root is the host-configured workspace, not necessarily this session cwd') } return checkFenceRoot(p) } catch (e) { warnNoPolicyOnce() } return undefined }
   function makeSignal(ms) { return AbortSignal.timeout(ms || 30000) }
 
   // ================= capability / tool-name lists =================
@@ -253,14 +374,11 @@ export function apply(ctx) {
   // host applies the filter when establishing a continuable child
   // (dsh-subagent: childCtx.tools.restrict(...)), so a stale name meant the child
   // was never created at all.
-  const IS_WINDOWS = process.platform === 'win32'
-  const SCRIPT_TOOLS = IS_WINDOWS ? ['pwsh'] : ['bash']
   // 这两个名字是否真的存在取决于**本次组合**：v2 自己的 agent.cordis.yml 把 tool-web 行设成
   // fetch:false，于是 web_search 在、web_fetch 不在，而 filter 里只要有一个宿主不注册的名字，
   // restrict() 就整条拒绝 → 子代理先失败一次再走 sanitizeToolFilter 重试，日志还会谎称"你的配置过期"
   // （审计 M8/M9）。所以能力清单**向宿主的可见工具面查询**（tools.schemas，宿主自己在
   // dsh-tools/lib/index.js 里就是这么用的），查不到/不可信时才退回静态候选表。
-  const NETWORK_TOOLS = ['web_search', 'web_fetch']
   /**
    * 本会话可见的工具名集合；null = 无法可信地确定（此时一律保留候选名，行为与改动前一致）。
    * 自校验：这张表必须包含本插件自己注册的工具，否则说明这个 scope 视图不是子代理真正看到的
@@ -285,64 +403,17 @@ export function apply(ctx) {
   }
 
   // ================= parameter schema =================
-  const PARAM_SCHEMA = [
-    { name: 'mode', type: 'enum', options: ['auto', 'manual'], description: 'auto = 无人值守自动通过关键节点；manual = 关键节点挂起人工决策', suggestion: 'auto' },
-    { name: 'maxParallelThreshold', type: 'integer', description: '全局最大并发子代理轮数（新派发前须满足 active < 阈值）', suggestion: 4 },
-    { name: 'solverMaxRounds', type: 'integer', description: '每个求解方向的最大迭代轮数（agent_self_iteration 上限）', suggestion: 3 },
-    { name: 'directionsPerSolver', type: 'integer', description: '每个 solver 提示词附带的其他活跃方向摘要数量：1 = 只看自己方向（互不干扰）；N>1 = 额外附带最多 N 个其他活跃方向摘要用于协调', suggestion: 1 },
-    { name: 'verifierCount', type: 'integer', description: '每个验证对象的独立验证器数量（下限 2：一票不裁决）。并发预算紧张时单个对象同时最多占用 maxParallelThreshold-2 个槽位（至少 2），以保证另一个对象也凑得齐 2 票', suggestion: 3 },
-    { name: 'debateMaxRounds', type: 'integer', description: '验证辩论（交流群）最大轮数', suggestion: 5 },
-    { name: 'verdictMode', type: 'enum', options: ['flat', 'forced'], description: 'flat = 均衡机制（不一致时取各评审自报概率的**均值**，绝不折叠成固定的 0.5）；forced = 强制裁决（按验证者历史准确率+布尔票置信度加权）。准确率按 provider/model 这种稳定身份记，且只在对象**后来**取得布尔定论时才计分', suggestion: 'flat' },
-    { name: 'provider', type: 'string', description: '子代理模型 provider（空 = 继承根代理）', suggestion: '' },
-    { name: 'model', type: 'string', description: '子代理模型 id（空 = 继承根代理）', suggestion: '' },
-    { name: 'solverPersona', type: 'string', description: '注入每个求解器提示词开头的人格/要求', suggestion: '' },
-    { name: 'verifierPersona', type: 'string', description: '注入每个验证器提示词开头的人格/要求', suggestion: '' },
-    { name: 'explorerPersona', type: 'string', description: '注入每个 explorer/重派生提示词开头的人格/要求', suggestion: '' },
-    { name: 'knowledgeContext', type: 'string', description: '共享知识/数据模型说明（空 = 内置完整版；非空 = 覆盖，注入 explorer/solver/verifier 提示词）', suggestion: '' },
-    { name: 'solverToolAllow', type: 'string[]', description: '求解器允许的工具名列表（空 = 继承全部工具）', suggestion: [] },
-    { name: 'solverToolDeny', type: 'string[]', description: '求解器禁止的工具名列表', suggestion: [] },
-    { name: 'verifierToolAllow', type: 'string[]', description: '验证器允许的工具名列表', suggestion: [] },
-    { name: 'verifierToolDeny', type: 'string[]', description: '验证器禁止的工具名列表', suggestion: [] },
-    { name: 'solverAllowNetwork', type: 'boolean', description: '求解器网络工具开关：空=继承全部；true=允许（在已有 allow 列表时补入本次组合真正注册的网络工具）；false=禁止网络工具', suggestion: '' },
-    { name: 'verifierAllowNetwork', type: 'boolean', description: '验证器网络工具开关（同 solverAllowNetwork）', suggestion: '' },
-    { name: 'solverAllowScripts', type: 'boolean', description: '求解器脚本工具开关：空=继承全部；true=允许（在已有 allow 列表时补入）；false=禁止 ' + SCRIPT_TOOLS.join('/'), suggestion: '' },
-    { name: 'verifierAllowScripts', type: 'boolean', description: '验证器脚本工具开关（同 solverAllowScripts）', suggestion: '' },
-    { name: 'solverMaxToolCalls', type: 'integer', description: '求解器每轮外部工具调用**建议**上限（0 = 不限）。框架只把它写进提示词，不计数、不强制', suggestion: 0 },
-    { name: 'verifierMaxToolCalls', type: 'integer', description: '验证器每轮外部工具调用**建议**上限（0 = 不限）。框架只把它写进提示词，不计数、不强制', suggestion: 0 },
-    { name: 'reportIntervalMs', type: 'integer', description: '进度汇报间隔（毫秒）：0 = 仅事件驱动（有代理状态更新等事件才写/推报告）；>0 = 同时按该间隔定时自动汇报', suggestion: 0 },
-    { name: 'reportMode', type: 'enum', options: ['file', 'push', 'both'], description: 'file = 写报告文件；push = 推送消息让主代理主动汇报；both = 两者都做', suggestion: 'file' },
-    { name: 'promoteValueThreshold', type: 'number', description: 'Propos 中「价值/关键性」≥ 该值且未决(0,1) 的命题自动加入 qs.json', suggestion: 0.7 },
-    { name: 'priorityAdjust', type: 'enum', options: ['none', 'deadend-deprioritize', 'survival-map'], description: '优先级动态调整策略：none=不自动调；deadend-deprioritize=方向全死路时降优先级；survival-map=按最高方向存活率重算（存活率高越优先）', suggestion: 'none' },
-    { name: 'proposPriorityAdjust', type: 'enum', options: ['none', 'progress-graded'], description: '命题优先级动态调整：none=不自动调；progress-graded=按「定论接近度（|布尔估计-0.5|）+ 证明/证伪材料量」重算，越接近定论越优先验证', suggestion: 'none' },
-    { name: 'tickIntervalMs', type: 'integer', description: '调度器心跳间隔（毫秒）：多久扫描一次子代理状态并推进（越小越灵敏、越大越省资源）', suggestion: 2000 },
-    { name: 'activityLogCap', type: 'integer', description: '活动日志保留条数（影响 status/report 里 recentActivity 的细节量，两者最多显示 ' + ACTIVITY_REPORT_MAX + ' 条）', suggestion: 100 },
-    { name: 'maxExplorerRetries', type: 'integer', description: 'explorer 拆方向失败的重派生上限（达到后该问题标记为方向耗尽）', suggestion: 3 },
-    { name: 'formalVerify', type: 'enum', options: ['off', 'encourage', 'require'], description: 'Lean 形式化验证档位：off=不额外要求（默认，提示词里不出现 Lean）；encourage=鼓励按实现难度自行形式化，一旦 Lean 通过则验证重点转为「忠实性审查」；require=同 encourage 且加门禁——对象的 formal.status 未达到 passed/blocked 前，真/假裁定记为未定论（原因 formal-required）并写入 Formal/TODO.md', suggestion: 'off' },
-    { name: 'leanCommand', type: 'string', description: '要执行的 Lean 可执行文件（默认 lean；用 lake 时配合 leanArgs=["env","lean"]）', suggestion: 'lean' },
-    { name: 'leanArgs', type: 'string[]', description: '插在 .lean 文件名之前的附加命令行参数（默认空）', suggestion: [] },
-    { name: 'leanTimeoutMs', type: 'integer', description: '单次 Lean 运行的超时上限（毫秒，默认 120000，最小 1000）；异步档下它同时是**每个后台编译作业**的预算（到时主动 terminate，作业记 timeout、对象留在 attempted）', suggestion: 120000 },
-    { name: 'leanAsync', type: 'boolean', description: 'Lean 编译模式：true（默认）= 后台队列，vibe_math_lean_run / vibe_math_lean_archive{run:true} 立即返回 async.jobId 入队，成员不阻塞，结果由下一轮提示的【形式化结果】行与 vibe_math_lean_lib / vibe_math_lean_job 公告（**只有作业落地为 ok 才会置 passed 并写归档证明**）；false = 完全同步 await（与旧行为逐字一致）', suggestion: true },
-    { name: 'leanJobsMaxParallel', type: 'integer', description: '后台 Lean 编译的并发上限（默认 1 = 串行，保持可预测的资源占用；调大可并行编译多个作业）', suggestion: 1 },
-    { name: 'leanInitiative', type: 'string', enum: LEAN_INITIATIVE_MODES.slice(), description: '日常流程中的形式化主动性：off（不主动，只在验证提示词按 formalVerify 的要求做）| normal（默认：顺手把有价值且可能复用的东西形式化）| eager（更主动：日常就主动把有价值的小引理/命题/定义形式化）。注意它与 formalVerify（验证时的要求强度：off|encourage|require）是**两件事**', suggestion: 'normal' },
-    { name: 'leanSearchPaths', type: 'array', items: { type: 'string' }, description: '额外 Lean 搜索路径（默认空数组 = 只用框架自动注入的 VibeMath 根）。非空时按顺序先注入这里给的路径、再注入自动根（去重）；若 leanArgs 里已显式给了 --search-path/-R/--root，则完全尊重用户配置、不注入任何东西', suggestion: [] },
-    { name: 'finalPaper', type: 'boolean', description: '收口（严格终止）时自动撰写最终论文：派遣一名专职「论文撰写」子代理，把已检验通过的命题/解法/成果整理成 Paper/<项目>/{paper.md,paper.tex,paper.meta.json,paper.log.md}。false = 只关自动触发，/vibe paper 手动命令仍可用', suggestion: true },
-    { name: 'paperFormat', type: 'enum', options: ['both', 'md', 'tex'], description: '论文产出格式：both = markdown + latex；md = 只写 paper.md；tex = 只写 paper.tex（tex 才会尝试编译 pdf）', suggestion: 'both' },
-    { name: 'paperLanguage', type: 'enum', options: ['zh', 'en'], description: '论文语言：zh = 中文（LaTeX 用 ctexart，引擎优先 xelatex）；en = 英文（article，引擎优先 pdflatex/latexmk）', suggestion: 'zh' },
-    { name: 'paperCompilePdf', type: 'boolean', description: '检测到 LaTeX 时是否编译 paper.pdf（-interaction=nonstopmode 跑两遍；失败先尝试修复：换引擎/去不支持宏包/最小模板）。false 或无 LaTeX 时只保留 tex+md 并记日志', suggestion: true },
-    { name: 'paperLatexCommand', type: 'string', description: '指定 LaTeX 引擎可执行文件（空 = 按语言探测：中文 xelatex > latexmk > pdflatex > lualatex > tectonic；英文 pdflatex 优先）。该命令解析不到时按"未检测到"降级（只留 tex+md）', suggestion: '' },
-    // ---- 数学计算 math_computation（六参数冻结；描述与 prompts.md §1/§6 口径一致）----
-    { name: 'mathComputation', type: 'enum', options: ['off', 'auto', 'on'], description: '数学计算总开关：off = 真无操作（提示词零提及）；auto = 探测到 mathEngines 里任一允许引擎才工作；on = 同上（探测失败时工具仍返回可执行的安装指引，而不是假装可用）', suggestion: 'auto' },
-    { name: 'mathMode', type: 'enum', options: ['typed', 'typed+shell'], description: '计算策略：typed+shell（默认）= 工具不可用时允许宿主 shell 兜底，但结论必须标注"未经工具归档（shell 路径）"；typed = 只用工具路径（提示词里不出现 shell 兜底段，engine:"cli" 返回 REFUSED{reason:policy}）', suggestion: 'typed+shell' },
-    { name: 'mathEngines', type: 'string[]', description: '允许的引擎列表（默认 python|r|octave|julia|matlab|maple|wolfram|cli）。cli 默认开启且走同一套超时/输出上限/回执；从列表里移除某引擎即禁用（商业引擎只探测+许可，永不安装）', suggestion: MATH_PARAM_DEFAULTS.mathEngines.slice() },
-    { name: 'mathTimeoutMs', type: 'integer', description: '单次数学计算的超时上限（毫秒，默认 60000，最小 1000）；到时主动 terminate 并把回执标为 MATH_TIMEOUT', suggestion: 60000 },
-    { name: 'mathPackages', type: 'string[]', description: '需要预检的包（默认空）。缺包只报告 + 给"用户自装指引"或"代理代装计划"，不会执行脚本，也永不自动安装', suggestion: [] },
-    { name: 'mathInstallScope', type: 'string', enum: ['user', 'system'], description: '安装作用域：user（默认，用户级目录）；system 只对当次显式调用生效、永不记忆（不会写进状态文件）', suggestion: 'user' },
-  ]
 
   // ================= fs =================
   async function fsTarget(rel) { return await fs.resolve(rel, { cwd: frameworkRoot() }) }
   async function readText(rel) { try { const t = await fsTarget(rel); const s = await fs.stat(t); if (s === undefined) return undefined; return await fs.readText(t) } catch (e) { return undefined } }
-  async function writeText(rel, content) { const t = await fsTarget(rel); await fs.writeText(t, content, undefined, undefined, getPolicy()); return true }
+  async function writeText(rel, content) {
+    const t = await fsTarget(rel)
+    const r = await fs.writeText(t, content, undefined, undefined, getPolicy())
+    // P4：宿主若用返回值（而非抛异常）报告写失败，也要留痕——旧实现无条件 return true 会把它吞掉。
+    if (r && r.ok === false) noteStateWriteFailure(rel, 'host reported write failure' + (r.error ? (': ' + r.error) : ''))
+    return true
+  }
   async function readJson(rel) { const t = await readText(rel); if (t === undefined || t === '') return undefined; try { return JSON.parse(t) } catch (e) { noteSuspect(rel); return undefined } }
   /**
    * Corruption guard. `readJson` cannot tell "no file yet" from "file present but
@@ -368,18 +439,26 @@ export function apply(ctx) {
     console.error('vibe-math-v2: write to ' + rel + ' blocked (file is unparseable; see the earlier warning)')
     return false
   }
-  async function writeJson(rel, obj) { if (!assertWritable(rel)) return false; return await writeText(rel, JSON.stringify(obj, null, 2)) }
+  async function writeJson(rel, obj) {
+    if (!assertWritable(rel)) {
+      // P4：损坏守卫拒绝写入过去是**完全静默**的（返回 false 没人看）⇒ 会话以为已提交、磁盘还是旧内容。
+      noteStateWriteFailure(rel, 'corruption guard refused write')
+      logActivity('state', '拒绝写入（该 JSON 已存在但无法解析，先修/删它）：' + rel)
+      return false
+    }
+    return await writeText(rel, JSON.stringify(obj, null, 2))
+  }
   async function listFiles(rel) { try { const t = await fsTarget(rel); const s = await fs.stat(t); if (s === undefined) return []; const entries = await fs.listDir(t); return entries.filter(function (e) { return e && e.type === 'file' }).map(function (e) { return e.name }) } catch (e) { return [] } }
   async function listDirsAt(base, rel) { try { const t = await fs.resolve(rel, { cwd: base }); const s = await fs.stat(t); if (s === undefined) return []; const entries = await fs.listDir(t); return entries.filter(function (e) { return e && e.type === 'directory' }).map(function (e) { return e.name }) } catch (e) { return [] } }
   async function readTextAbs(path) { try { const t = await fs.resolve(path); const s = await fs.stat(t); if (s === undefined) return undefined; return await fs.readText(t) } catch (e) { return undefined } }
   async function writeTextAbs(path, content) { try { const t = await fs.resolve(path); await fs.writeText(t, content, undefined, undefined, getPolicy()); return true } catch (e) { return false } }
   async function readCurrentProject() {
     // 按会话隔离的 current 文件（多会话并行时互不覆盖）；无则回退旧共享文件
-    try { const t = await fs.resolve('current.' + safeId(sessionId) + '.json', { cwd: vibeRoot() }); const s = await fs.stat(t); if (s !== undefined) { const txt = await fs.readText(t); const j = safeJson(txt, null); const p = (j && j.project) ? String(j.project) : 'default'; return slugify(p) } } catch (e) {}
-    try { const t = await fs.resolve('current.json', { cwd: vibeRoot() }); const s = await fs.stat(t); if (s === undefined) return 'default'; const txt = await fs.readText(t); const j = safeJson(txt, null); const p = (j && j.project) ? String(j.project) : 'default'; return slugify(p) } catch (e) { return 'default' }
+try { const t = await fs.resolve('current.' + safeId(sessionId) + '.json', { cwd: vibeRoot() }); const s = await fs.stat(t); if (s !== undefined) { const txt = await fs.readText(t); const j = safeJson(txt, null); const p = (j && j.project) ? String(j.project) : 'default'; return slugify(p) } } catch (e) { noteStateWriteFailure('current.' + safeId(sessionId) + '.json', 'read failed: ' + ((e && e.message) || e)) }
+try { const t = await fs.resolve('current.json', { cwd: vibeRoot() }); const s = await fs.stat(t); if (s === undefined) return 'default'; const txt = await fs.readText(t); const j = safeJson(txt, null); const p = (j && j.project) ? String(j.project) : 'default'; return slugify(p) } catch (e) { noteStateWriteFailure('current.json', 'read failed: ' + ((e && e.message) || e)); return 'default' }
   }
   async function writeCurrentProject() {
-    try { const t = await fs.resolve('current.' + safeId(sessionId) + '.json', { cwd: vibeRoot() }); await fs.writeText(t, JSON.stringify({ project: currentProject }), undefined, undefined, getPolicy()) } catch (e) {}
+try { const t = await fs.resolve('current.' + safeId(sessionId) + '.json', { cwd: vibeRoot() }); await fs.writeText(t, JSON.stringify({ project: currentProject }), undefined, undefined, getPolicy()) } catch (e) { noteStateWriteFailure('current.' + safeId(sessionId) + '.json', (e && e.message) || e) }   // F-6c: 内存已切/磁盘未落必须可观察，否则重启丢失项目切换
   }
 
   // ================= subprocess =================
@@ -732,6 +811,75 @@ export function apply(ctx) {
     }
     return out
   }
+  /** P2：状态提交的原子性 + 完整性标记。
+   *
+   *  可用能力只有 fs.resolve/stat/readText/writeText（**宿主没有 rename**）。所以提交协议是
+   *  「**暂存 → 回读校验 → 提交 → 标记**」：
+   *    1) 每个状态文件先写 `<rel>.tmp`，再回读确认**非空**（截断/失败写在这里就被抓住）；
+   *    2) 暂存成功才把它写进最终路径（`writeText(rel, …)`），失败则记入 `stateWriteFailures`；
+   *    3) 全部落地后**最后**写 `VibeMath_State/commit.json`：`{seq, at, checkpoint, files, missing, mode}`
+   *       —— 它是"这次提交完整"的唯一标记，恢复时用它判断上一次提交是否撕裂。
+   *
+   *  **不用 shell move**：宿主可能只提供受控/模拟的 subprocess（本轮实测：假 subprocess 返回 exit 0
+   *  但不会真的移动文件 ⇒ "搬"成功、文件却不存在，状态直接丢失）。有鉴于此，这里坚持只走宿主 fs API；
+   *  代价是没有 rename 级原子性，收益是任何宿主上都不会静默丢文件。
+   */
+  let stateCommitSeq = 0
+  let stateCommit = { seq: 0, at: 0, complete: false, mode: '', files: [], missing: [] }
+  const stateWriteFailures = []   // P4：被拒绝/失败的落盘（status/report 可见）
+  function noteStateWriteFailure(rel, error) {
+    stateWriteFailures.push({ rel: String(rel), error: String(error || 'unknown'), at: now() })
+    if (stateWriteFailures.length > 32) stateWriteFailures.shift()
+  }
+  async function relNonEmpty(rel) {
+    try { const t = await fsTarget(rel); const st = await fs.stat(t); return !!(st && (st.size === undefined || st.size > 0)) } catch (e) { return false }
+  }
+  async function writeJsonAtomic(rel, obj) {
+    // P4：原子路径也必须过损坏守卫（否则「存在但解析失败」的状态文件会被静默覆写）
+    if (!assertWritable(rel)) {
+      noteStateWriteFailure(rel, 'corruption guard refused write')
+      logActivity('state', '拒绝写入（该 JSON 已存在但无法解析，先修/删它）：' + rel)
+      return 'refused'
+    }
+    const text = JSON.stringify(obj, null, 2)
+    // 没有 shell 就没法清理暂存文件（宿主 fs 无 delete/rename）⇒ 直接写，避免留下 .tmp 垃圾与告警
+    if (!subprocessOf()) {
+      try { await writeText(rel, text) } catch (e) { noteStateWriteFailure(rel, (e && e.message) || e) }
+      if (!(await relNonEmpty(rel))) noteStateWriteFailure(rel, 'written but empty/missing')
+      return 'direct'
+    }
+    const tmp = rel + '.tmp'
+    let staged = false
+    try { await writeText(tmp, text); staged = await relNonEmpty(tmp) } catch (e) { staged = false }
+    let mode = 'direct'
+    if (staged) {
+      try { await writeText(rel, text); mode = 'stage-commit' } catch (e) { noteStateWriteFailure(rel, (e && e.message) || e) }
+      try { await removeFile(tmp) } catch (e) { /* 清理暂存文件失败不影响提交内容 */ }
+    } else {
+      try { await writeText(rel, text) } catch (e) { noteStateWriteFailure(rel, (e && e.message) || e) }
+    }
+    if (!(await relNonEmpty(rel))) noteStateWriteFailure(rel, 'written but empty/missing')
+    return mode
+  }
+  async function commitState(files) {
+    stateCommitSeq += 1
+    const modes = []
+    const missing = []
+    for (let i = 0; i < files.length; i++) {
+      const mode = await writeJsonAtomic(files[i].rel, files[i].obj)
+      modes.push(mode)
+      if (!(await relNonEmpty(files[i].rel))) missing.push(files[i].rel)
+    }
+    const commit = {
+      seq: stateCommitSeq, at: now(), epoch: processEpoch,
+      checkpoint: Number(scheduler.lastCheckpoint) || now(),
+      files: files.map(function (x) { return x.rel }), missing: missing,
+      mode: modes.indexOf('stage-commit') === -1 ? 'direct' : 'stage-commit',
+    }
+    await writeJsonAtomic('VibeMath_State/commit.json', commit)
+    stateCommit = Object.assign({ complete: missing.length === 0 }, commit)
+    return commit
+  }
   async function loadState() {
     const s = await readJson('VibeMath_State/scheduler_state.json')
     // 丢弃历史持久化的 activeCount：旧值可能已经漂移，绝不能覆盖推导值（见 activeCount()）。
@@ -741,23 +889,55 @@ export function apply(ctx) {
     const va = await readJson('VibeMath_State/verifier_accuracy.json'); if (va) verifierAccuracy = sanitizeAccuracy(va)
     const tk = await readJson('VibeMath_State/tasks.json'); if (tk) tasks = tk
     const er = await readJson('VibeMath_State/explorer_retries.json'); if (er) explorerRetries = er
+    // P3：恢复待计分样本（有上限、有溢出告警，见 recordReviewForScoring）
+    // P5：把磁盘上的活动日志并回内存（旧实现只落 report 快照且从不回读 ⇒ 恢复后 status 从零开始）
+    const al = await readJson('VibeMath_State/activity_log.json')
+    if (Array.isArray(al) && al.length) { const seen = {}; const merged = []; for (const e of al.concat(activityLog)) { const k = String(e && e.at) + '|' + String(e && e.detail); if (seen[k]) continue; seen[k] = true; merged.push(e) } activityLog = merged.slice(-ACTIVITY_PERSIST_MAX) }
+    // P6：论文排队/回收计数恢复；在途撰写者跨进程不可恢复 ⇒ 清掉留痕
+    const pj = await readJson('VibeMath_State/paper.json')
+    if (pj && typeof pj === 'object') { if (pj.pending) paperPending = pj.pending; paperReaps = Number(pj.reaps) || 0 }
+    if (paperInFlight) { logActivity('paper', '上一进程的在途撰写者 ' + paperInFlight + ' 不可恢复（child 随进程结束）⇒ 交由 paper 锁/回收逻辑重新触发'); paperInFlight = ''; paperInFlightAt = 0 }
+    const prs = await readJson('VibeMath_State/pending_review_scores.json')
+    if (prs && typeof prs === 'object' && !Array.isArray(prs)) pendingReviewScores = prs
     // 形式化记录（docs/formal-verification.md §4）：v2 没有会话投影，这条状态必须自己持久化，
     // 否则一次 resume 就让 require 门禁失忆（已 passed 的对象被再当"未尝试"）。
+    // P2：先校验上一次提交的完整性（不完整 ⇒ 留痕，再按逐文件容错读取）
+    await loadCommitMarker()
     const fm = await readJson('VibeMath_State/formal.json')
     formalState = {
       records: (fm && fm.records && typeof fm.records === 'object' && !Array.isArray(fm.records)) ? fm.records : {},
       todo: (fm && Array.isArray(fm.todo)) ? fm.todo : [],
     }
   }
+  /** P2：恢复时校验上一次提交的完整性（标记列出但缺失/为空的状态文件 = 撕裂提交）。 */
+  async function loadCommitMarker() {
+    const cm = await readJson('VibeMath_State/commit.json')
+    if (!cm || typeof cm !== 'object') { stateCommit = { seq: 0, at: 0, complete: false, mode: '', files: [], missing: [] }; return stateCommit }
+    const missing = []
+    const files = Array.isArray(cm.files) ? cm.files : []
+    for (let i = 0; i < files.length; i++) { if (!(await relNonEmpty(files[i]))) missing.push(files[i]) }
+    stateCommitSeq = Number(cm.seq) || 0
+    stateCommit = Object.assign({}, cm, { complete: missing.length === 0, missing: missing })
+    if (missing.length && files.length) logActivity('state', '上一次状态提交不完整（缺失/为空：' + missing.join(', ') + '）⇒ 按逐文件容错读取，最后一次提交的部分字段可能丢失')
+    return stateCommit
+  }
   async function saveAll() {
-    await writeJson('VibeMath_State/scheduler_state.json', scheduler)
-    await writeJson('VibeMath_State/agent_registry.json', agentRegistry)
-    await writeJson('VibeMath_State/decision_queue.json', decisionQueue)
-    await writeJson('VibeMath_State/verifier_accuracy.json', verifierAccuracy)
-    await writeJson('VibeMath_State/tasks.json', tasks)
-    await writeJson('VibeMath_State/explorer_retries.json', explorerRetries)
-    await writeJson('VibeMath_State/formal.json', { records: formalRecords(), todo: formalTodo() })
+    // P2：checkpoint 先落进内存再提交（旧顺序是提交完才改内存 ⇒ 磁盘上的 checkpoint 永远滞后一次）
     scheduler.lastCheckpoint = now()
+    await commitState([
+      { rel: 'VibeMath_State/scheduler_state.json', obj: scheduler },
+      { rel: 'VibeMath_State/agent_registry.json', obj: agentRegistry },
+      { rel: 'VibeMath_State/decision_queue.json', obj: decisionQueue },
+      { rel: 'VibeMath_State/verifier_accuracy.json', obj: verifierAccuracy },
+      { rel: 'VibeMath_State/tasks.json', obj: tasks },
+      { rel: 'VibeMath_State/explorer_retries.json', obj: explorerRetries },
+      { rel: 'VibeMath_State/formal.json', obj: { records: formalRecords(), todo: formalTodo() } },
+      // P3：待计分样本也必须落盘——旧实现只在内存，崩溃/恢复后这批评审永远不会被计分（准确率静默丢样本）
+      { rel: 'VibeMath_State/pending_review_scores.json', obj: pendingReviewScores },
+      // P5：活动日志（有界）落盘；P6：论文排队/回收计数落盘（在途 childId 不落，见 loadState）
+      { rel: 'VibeMath_State/activity_log.json', obj: activityLog.slice(-ACTIVITY_PERSIST_MAX) },
+      { rel: 'VibeMath_State/paper.json', obj: { pending: paperPending, reaps: paperReaps } },
+    ])
   }
   // 查询类工具（status/setup/report）汇报前重读设置文件：文件是唯一持久化源，可能在会话启动后被用户手改或由本进程外编辑更新。
   async function refreshParams() {
@@ -1969,7 +2149,9 @@ export function apply(ctx) {
     const rec = formalGateRecord(t)
     if (formalGateOk(rec)) return false
     const own = formalOf(t)
-    const reason = 'formal-required：尚未取得 Lean 形式化通过，也没有显式阻塞记录（当前状态 ' + (rec.status || 'none') + '）' + (why ? '｜' + why : '')
+    const statusZh = ({ none: '未尝试', attempted: '已尝试未通过', blocked: '已记录阻塞', passed: '已通过' })[String(rec.status || 'none')] || String(rec.status || 'none')
+    const reason = 'formal-required：尚未取得 Lean 形式化通过，也没有显式阻塞记录（当前状态 ' + statusZh + '；代码 formal-required）' + (why ? '｜' + why : '') +
+      '；下一步：把该对象形式化到 Lean 通过（vibe_math_lean_archive，kind=proof/lemma），或写入显式阻塞记录（kind=blocked）后重新提议该对象，即可再次表决'
     const list = formalTodo().filter(function (x) { return x.id !== t })
     list.push({ id: t, at: now(), why: reason })
     // 不改动对象的既有权重/概率字段：只补一条 formal 记录（status 保持 none/attempted）。
@@ -2016,6 +2198,21 @@ export function apply(ctx) {
     return out
   }
   async function findProposition(pId) { const all = await getPropos(); return all.find(function (p) { return p.id === pId }) }
+  /**
+   * P1：`add_proposition`/`/vibe add-proposition` 只用于**新建**。id 已存在时**拒绝**，绝不覆盖——
+   * 旧实现是"按 id upsert"，会把已有卡的 陈述/证明列表/证伪列表 换成全新的空列表（静默丢数据），
+   * 而 sync_meta 的引理路径（v3 侧）本来就有 `propos.has` + 文件存在双守卫。这里把两者语义拉齐。
+   */
+  function propositionIdConflict(id, all) {
+    const hit = (all || []).filter(function (x) { return String(x.id) === String(id) })[0]
+    if (!hit) return null
+    return {
+      code: 'PROPOSITION_ID_EXISTS',
+      message: '命题 id "' + id + '" 已存在：add_proposition 只用于**新建**，不会覆盖已有卡（其 陈述/证明列表/证伪列表 一律保留）。',
+      next: '换一个新 id 新建（例如 p-' + shortId() + '）；要修改已有卡请用文件工具直接编辑 Propos/<分类>/<id>.md。',
+      existing: { id: hit.id, 概述: hit.概述, 布尔估计: hit.布尔估计, category: hit._category },
+    }
+  }
   async function upsertProposition(p) {
     const cat = p._category || categoryOf(p)
     delete p._category
@@ -2025,13 +2222,6 @@ export function apply(ctx) {
     await writeJson(proposFile(cat), list)
     return cat
   }
-  async function deleteProposition(p) {
-    const cat = p._category || categoryOf(p)
-    const list = await readProposCategory(cat)
-    const next = list.filter(function (x) { return x.id !== p.id })
-    await writeJson(proposFile(cat), next)
-  }
-
   // ================= data layer: Verified / Reliable =================
   async function readVerifiedCategory(cat) { const a = await readJson('Verified/' + String(cat) + '_Verified.json'); return Array.isArray(a) ? a : [] }
   async function reliableFiles() { return await listFiles('Reliable') }
@@ -2042,13 +2232,18 @@ export function apply(ctx) {
     const qs = await getQs()
     const propos = await getPropos()
     return {
-      ok: true, at: now(), project: currentProject, frameworkRoot: frameworkRoot(),
+      ok: true, at: now(), project: currentProject, projectExists: await projectExistsOnDisk(), frameworkRoot: frameworkRoot(),
+      stateWriteFailures: { count: stateWriteFailures.length, last: stateWriteFailures[stateWriteFailures.length - 1] || null },
       running: scheduler.running, mode: params.mode,
       activeCount: activeCount(), maxParallelThreshold: params.maxParallelThreshold,
       problems: { total: qs.length, solved: qs.filter(function (q) { return q.已解决 }).length },
       propositions: { total: propos.length, resolved: propos.filter(function (p) { return p.布尔估计 === 1 || p.布尔估计 === 0 }).length },
-      pendingDecisions: decisionQueue.filter(function (d) { return d.status === 'pending' }).map(function (d) { return { id: d.id, node: d.node, context: d.context } }),
+// F-A（有意拆分）：pendingDecisions 是**合同**（两面同形的数字）；pendingDecisionItems 是**诊断**（明细），只出现在 report——status 面向代理自省、report 面向文件快照。改动此处需同步 docs/status-report-fields.md（该文档租约在共享层 owner）。
+      pendingDecisions: decisionQueue.filter(function (d) { return d.status === 'pending' }).length,
+      pendingDecisionItems: decisionQueue.filter(function (d) { return d.status === 'pending' }).map(function (d) { return { id: d.id, node: d.node, context: d.context } }),
       registeredAgents: Object.keys(agentRegistry).length,
+      // D4 审计面：每个在飞验证任务的参与集/票数都由 voteCount 投影出来（两个视图可对照）。
+      verifyTasks: verifyTasksView(tasks),
       recentActivity: activityLog.slice(-Math.min(ACTIVITY_REPORT_MAX, Number(params.activityLogCap) || 100)),
       // Lean 形式化：可调档位与开关同处可读参数表（契约 §1），并附当前形式化记录概况。
       formal: {
@@ -2056,9 +2251,12 @@ export function apply(ctx) {
         leanCommand: params.leanCommand, leanArgs: params.leanArgs, leanTimeoutMs: params.leanTimeoutMs,
         objects: Object.keys(formalRecords()).map(function (k) { const r = formalRecords()[k] || {}; return { target: k, status: r.status, file: r.file, proof: r.proof, note: r.note } }),
         todo: formalTodo(),
-        paths: { project: 'Formal/', lib: vibeRoot() + '/Formal/Lib/', proved: vibeRoot() + '/Formal/Proved/', proofs: 'Verified/Lean/' },
+        // F6：四项路径基准不同 ⇒ 必须点名 base（project/proofs 相对 base，lib/proved 已绝对）。
+        paths: { base: frameworkRoot() + '/', project: 'Formal/', proofs: 'Verified/Lean/', lib: vibeRoot() + '/Formal/Lib/', proved: vibeRoot() + '/Formal/Proved/', note: 'project/proofs 相对 base（项目根）；lib/proved 已含绝对前缀' },
       },
       params: params,
+      // F5：report/status 两面字段集对齐（旧实现只有 status 看得到论文/编译状态）。
+      paper: await paperStatusView(),
     }
   }
   async function maybeWriteReport(force) {
@@ -2084,8 +2282,8 @@ export function apply(ctx) {
       const report = await buildReport()
       const text = '[Vibe Math V2] 进度更新：当前项目 "' + currentProject + '" 运行中=' + report.running +
         '，问题 ' + report.problems.solved + '/' + report.problems.total + ' 已解决，命题 ' + report.propositions.resolved + '/' + report.propositions.total + ' 已定论，' +
-        '活跃代理轮数=' + report.activeCount + '，待人工决策=' + report.pendingDecisions.length + '。' +
-        '请调用 vibe_math_report 汇总当前进展及各代理状态，并用人话简要汇报（不打断用户，简短即可）。'
+        '活跃代理轮数=' + report.activeCount + '，待人工决策=' + report.pendingDecisions + '。' +
+        '请调用 vibe_math_report 汇总当前进展，并用 vibe_math_list_agents 取各代理（id/角色/目标）状态，再用人话简要汇报（不打断用户，简短即可）。'
       // 来源 kind 必须是**已声明**的：`MessageSourceMap` 是 merge-extensible 的联合，但没有共享的
       // catch-all `plugin` kind（dsh-llm message.d.ts），{kind:'plugin'} 是契约外形状。role 本来就是
       // 'user'，正文也自带 "[Vibe Math V2] 进度更新" 的真署名，所以用核心声明的 {kind:'user'}。
@@ -2097,7 +2295,14 @@ export function apply(ctx) {
   }
 
   // ================= child spawn / followup =================
-  function pickProvider() { try { const names = subagents.list ? subagents.list() : []; if (names.indexOf('spawn') !== -1) return 'spawn'; if (names.indexOf('fork') !== -1) return 'fork' } catch (e) {} return 'spawn' }
+  // F-6a：宿主 list() 失败（或既无 spawn 也无 fork）时回退到假定值必须**留痕**，不能静默猜。
+  let providerFallbackWarned = false
+  function warnProviderFallback(why) {
+    if (providerFallbackWarned) return
+    providerFallbackWarned = true
+    console.error('vibe-math-v2: pickProvider() falling back to \'spawn\': ' + why)
+  }
+  function pickProvider() { let names = []; let listed = false; try { names = subagents.list ? subagents.list() : []; listed = true } catch (e) { warnProviderFallback('subagents.list() failed: ' + ((e && e.message) || e)) } if (names.indexOf('spawn') !== -1) return 'spawn'; if (names.indexOf('fork') !== -1) return 'fork'; if (listed) warnProviderFallback('host exposes neither spawn nor fork (list=' + JSON.stringify(names) + ')'); return 'spawn' }
   function childAgentOptions() { const o = {}; try { if (rootAgent && rootAgent.options) { if (rootAgent.options.provider) o.provider = rootAgent.options.provider; if (rootAgent.options.model) o.model = rootAgent.options.model } } catch (e) {} if (params.provider) o.provider = params.provider; if (params.model) o.model = params.model; return o }
   /**
    * Drop filter names this host does not register. `known` comes from the host's
@@ -2165,7 +2370,28 @@ export function apply(ctx) {
     // 不再手工累加并发计数：唤醒的是 registry 里已登记的 child，计数已由 registry 长度体现。
     await saveAll()
   }
-  async function interruptChild(childId) { try { subagents.interrupt(childId, { kind: 'ancestor', agent: rootAgent }) } catch (e) {} }
+  /**
+   * 中断一个**在册**子代理。审计 D1：旧实现 `try{…}catch(e){}` 把"没有这个 child / 宿主拒绝中断"
+   * 都吞成静默成功（调用方拿到 undefined，还以为已经中断）。现在：空/未知 id ⇒ `code` +
+   * `next{tool,hint}`，宿主抛错 ⇒ 保留错误文本并给替代出口；只有真的发出中断才 `ok:true`。
+   */
+  /** F-6b：中断失败必须留痕（调用点此前丢掉 {ok:false}，界面看起来一切正常）。 */
+  async function interruptTraced(cid, why) {
+    const r = await interruptChild(cid)
+    if (r && r.ok === false) logActivity('interrupt', '中断失败（' + why + '）：' + String(cid) + ' — ' + String(r.message || r.code || ''))
+    return r
+  }
+  async function interruptChild(childId) {
+    const id = String(childId == null ? '' : childId).trim()
+    if (!id) return { ok: false, code: 'VIBE_MATH_INVALID_ARGUMENT', message: 'interruptChild 失败：childId 为空——无法确定要中断哪个子代理。', next: { kind: 'reason', tool: 'vibe_math_list_agents', hint: '用 vibe_math_list_agents 列出本会话在册子代理的 id，再带 childId 调用。' } }
+    if (!Object.prototype.hasOwnProperty.call(agentRegistry, id)) return { ok: false, code: 'VIBE_MATH_CHILD_NOT_FOUND', message: 'interruptChild 失败：' + id + ' 不在本会话的在册子代理里（在册 ' + Object.keys(agentRegistry).length + ' 个）——可能已经结束，或不是本会话的子代理。', next: { kind: 'reason', tool: 'vibe_math_list_agents', hint: '用 vibe_math_list_agents 取当前在册 id；要停整个会话用 vibe_math_abort。' } }
+    try {
+      await subagents.interrupt(id, { kind: 'ancestor', agent: rootAgent })
+      return { ok: true, childId: id }
+    } catch (e) {
+      return { ok: false, code: 'VIBE_MATH_INTERRUPT_FAILED', message: 'interruptChild 失败：宿主拒绝中断 ' + id + '（' + String((e && e.message) || e) + '）。', next: { kind: 'reason', tool: 'vibe_math_abort', hint: '宿主不接受单点中断时，用 vibe_math_abort 终止整个会话的子代理。' } }
+    }
+  }
 
   // ================= prompts =================
   function solverPersonaText() { return params.solverPersona ? (String(params.solverPersona) + '\n\n') : '' }
@@ -2212,6 +2438,14 @@ export function apply(ctx) {
     // 数学计算可用性行（prompts.md §2+§4）：与"顺手形式化"并列注入；off 档为空串。
     return '\n' + t + formalReplyNote() + notice + math + '\n'
   }
+  /**
+   * F7：机器回执的**键名大小写**是契约的一部分，必须显式写在提示词里。
+   * v2 各回执的对象类型不同（验证回执用 `Result`/`Reason` 首字母大写；计划/求解/方法卡回执用小写
+   * `directions`/`lemmas`/`status`/`solution`/`solution_probability`），历史上只在示例里体现大小写——
+   * 模型猜错键名会被解析器当成"缺字段"静默兜底（`Result` 缺失 ⇒ 0.5），所以这里统一说清：
+   * **解析器按大小写精确匹配、不接受别名**（`parsed.Result` / `parsed.directions` 都是原样取键）。
+   */
+  const REPLY_KEY_STYLE_LINE = '\nKEY CASE IS PART OF THE REPLY CONTRACT: the verifier reply uses `Result`/`Reason` (capitalised; the debate round adds `changed`), while every other reply uses lowercase keys exactly as shown (`directions`, `lemmas`, `status`, `solution`, `solution_probability`). The parser matches keys EXACTLY, case-sensitively, and accepts NO aliases (e.g. `result` is not read).\n'
   function capabilitiesText(role) {
     const maxCalls = role === 'solver' ? params.solverMaxToolCalls : params.verifierMaxToolCalls
     const netOn = role === 'solver' ? params.solverAllowNetwork : params.verifierAllowNetwork
@@ -2227,6 +2461,7 @@ export function apply(ctx) {
     t += '- You may READ any file under Verified/ as a known, trusted dependency (resolved facts).\n'
     t += '- You should BASE your reasoning on the existing knowledge under Propos/ (propositions with proofs/refutations and probabilities) and Reliable/ (trusted references).\n'
     t += '- You must NOT write files directly: return structured JSON only — the scheduler is the single writer.\n'
+    t += REPLY_KEY_STYLE_LINE
     t += '\nHOW TO READ EXISTING KNOWLEDGE (coarse scan → fine read):\n'
     t += '- These are JSON files. A conclusion object carries summary-index fields (概述 / 布尔估计 / 优先级) and the full detail (证明列表 / 证伪列表 / 完整过程 / progress).\n'
     t += '- COARSE SCAN first: use a read/grep tool to extract ONLY the summary index (概述, 布尔估计, 优先级, titles) to locate which files / objects look relevant — do NOT load full proofs yet.\n'
@@ -2402,7 +2637,10 @@ export function apply(ctx) {
     if (node === 'verdict') { const overridden = resolution.action === 'override' && (resolution.verdict === 1 || resolution.verdict === 0); const v = overridden ? Number(resolution.verdict) : data.verdict; const applied = await settleVerdict(data.task, v); delete tasks[data.task.id]; return { verdict: v, overridden: overridden, applied: applied } }
     return {}
   }
-  async function resolveDecision(id, resolution) { const d = decisionQueue.find(function (x) { return x.id === id }); if (!d) return { ok: false, message: 'decision not found' }; if (d.status !== 'pending') return { ok: false, message: 'decision already resolved' }; d.status = 'resolved'; d.resolution = resolution; if (scheduler.gate && scheduler.gate.decisionId === id) scheduler.gate = null; logActivity('decide', id + ' resolved: ' + resolution.action + (resolution.verdict !== undefined ? ' ' + resolution.verdict : '')); await saveAll(); scheduleTick(); return { ok: true, message: 'decision resolved' } }
+  async function resolveDecision(id, resolution) {
+    const d = decisionQueue.find(function (x) { return x.id === id })
+    if (!d) return { ok: false, code: 'VIBE_MATH_DECISION_NOT_FOUND', message: 'decision not found：' + String(id == null ? '' : id) + ' 不在人工决策队列里（队列现有 ' + decisionQueue.length + ' 个' + (decisionQueue.length ? ('：' + decisionQueue.map(function (x) { return x.id }).join(', ')) : '') + '）——可能已被 vibe_math_decide 结清，或被 start/resume/abort/换项目作废（作废是终态，不会回到 pending）。', next: { kind: 'reason', tool: 'vibe_math_list_decisions', hint: '先用 vibe_math_list_decisions 取当前 pending 的 id；若期望它还在，检查是否发生过 start/resume/abort/换项目。' } }
+    if (d.status !== 'pending') return { ok: false, code: 'VIBE_MATH_DECISION_ALREADY_RESOLVED', message: 'decision already resolved：' + String(id) + ' 当前状态是 ' + String(d.status) + '——每次决策只生效一次。', next: { kind: 'reason', tool: 'vibe_math_list_decisions', hint: '用 vibe_math_list_decisions 看还有哪些 pending；要重新决策请等框架发起新的决策项。' } }; d.status = 'resolved'; d.resolution = resolution; if (scheduler.gate && scheduler.gate.decisionId === id) scheduler.gate = null; logActivity('decide', id + ' resolved: ' + resolution.action + (resolution.verdict !== undefined ? ' ' + resolution.verdict : '')); await saveAll(); scheduleTick(); return { ok: true, message: 'decision resolved' } }
   /**
    * 清掉 gate 时**必须结清它指向的那个人工决策**（审计 M10）。start/resume/abort/切项目都会离开
    * 需要那次决策的运行，而决策若仍是 `pending`，它会永远留在 `vibe_math_list_decisions` 里反复出现——
@@ -2694,13 +2932,14 @@ export function apply(ctx) {
   }
   async function backfillVerifiers(t) {
     const cap = reviewerCap()
-    while (t.children.length < t.expectedCount && t.children.length < cap) {
+    const want = voteCount(t).expected // 快照目标（不再直接读 t.expectedCount，保持单一来源）
+    while (t.children.length < want && t.children.length < cap) {
       if (activeCount() >= params.maxParallelThreshold) break
       const index = t.children.length
       const childId = await spawnChild('verifier:' + t.rId + ':' + index, verifierReviewPrompt(t.r), { role: 'verifier', rId: t.rId, round: 1, index: index })
       t.children.push(childId)
     }
-    if (t.children.length >= t.expectedCount) t.status = 'debating'
+    if (t.children.length >= want) t.status = 'debating'
   }
   async function reconcileVerify() {
     const ids = Object.keys(tasks)
@@ -2716,7 +2955,7 @@ export function apply(ctx) {
         } else continue
       }
       if (t.status === 'paused') {
-        const allReported = t.children.length > 0 && t.children.every(function (cid) { const r = t.childResults[cid]; return r && r.round === t.round })
+        const allReported = voteCount(t, t.round).allParticipantsReported
         if (allReported) { t.status = 'debating'; await advanceVerification(t, t.round); continue }
       }
       if (t.status !== 'spawning') continue
@@ -2869,8 +3108,9 @@ export function apply(ctx) {
     if (!lemma || !lemma.title) return
     let be = clamp01(lemma.布尔估计 != null ? lemma.布尔估计 : 0.6)
     if (be >= 1) be = 0.99; else if (be <= 0) be = 0.01 // 写入时概率必须 <1 且 >0（待验证器验证）
+    const p8Ids = (await getPropos()).map(function (x) { return x.id })
     const p = {
-      id: 'p-' + shortId(), 概述: lemma.statement || lemma.title,
+      id: 'p-' + shortIdUnique(function (x) { return p8Ids.indexOf(x) !== -1 }), 概述: lemma.statement || lemma.title,
       布尔估计: be,
       细类型: (lemma.细类型 && typeof lemma.细类型 === 'object') ? lemma.细类型 : { 未分类: {} },
       证明列表: [{ 完整过程: lemma.proof || '', 正确概率: clamp01(0.7), '支持信息/依据': '' }],
@@ -2940,9 +3180,55 @@ export function apply(ctx) {
   }
 
   // ================= verification (验证器) =================
+  /**
+   * 验证任务的**票数/参与集单一来源**（跨预设审计 D4，与 v3 的 voteCount 同型）。
+   *
+   * 定义（本文件里"参与集"只有一个含义）：一个 verify 任务的参与集 = **本轮被派出的评审**，
+   * 也就是 `t.children`（当前 round 的 `childResults` 条目是它们的票）；"需要几票"= **任务创建时的
+   * 快照** `t.expectedCount`（processVerify 建任务时写入），**绝不**读实时 `params.verifierCount`
+   * 或 `params.maxParallelThreshold`。旧实现把这个答案分散在三处——`consensus()` 只看
+   * `Object.keys(t.childResults)`（已报票）且用常量 MIN_REVIEWERS 当下限、`finalizeVerification()`
+   * 又自己数一遍、两处内联 `allReported` 用 `t.children` + round——同一个计数在不同视图里可以不同
+   * （中途增/减评审、某个评审掉线后，辩论视图与裁决视图可能对"这一轮算不算完"给出不同答案）。
+   * 现在所有视图都读这一个函数。
+   */
+  // 契约（P2-v2 修复轮，必须保持）：一致/票数下限仍按 **MIN_REVIEWERS** 判定，一致性的对象是
+  // **所有已报结果**（reportedIds）。`voteCount` 只是把这些读法收拢到一个来源 + 提供审计投影；
+  // 它**不**改变"一票不算共识"的既有语义（v2-fix-probes 的 M11 探针钉着这条）。
+  function voteCount(t, round) {
+    const tt = t || {}
+    const expected = Math.max(MIN_REVIEWERS, Number(tt.expectedCount) || 0)
+    const r = Number((round === undefined || round === null) ? (tt.round || 1) : round) || 1
+    const participants = Array.isArray(tt.children) ? tt.children.slice() : []
+    const results = tt.childResults || {}
+    const reportedIds = Object.keys(results)
+    const thisRoundIds = participants.filter(function (cid) { const x = results[cid]; return x && Number(x.round) === r })
+    return {
+      round: r, expected: expected, participants: participants,
+      dispatched: participants.length, reported: reportedIds.length, reportedIds: reportedIds,
+      reportedThisRound: thisRoundIds.length,
+      // 旧语义的「本轮都报了吗」：只看**已派出的评审**，不额外要求达到快照票数（那一条属于裁决下限）。
+      allParticipantsReported: participants.length > 0 && thisRoundIds.length === participants.length,
+      quorum: participants.length > 0 && participants.length >= expected && thisRoundIds.length === participants.length,
+    }
+  }
+/**
+ * 待验证任务视图（v2 唯一的"在飞验证任务清单"入口）。**单一来源**：`status` 与 `report` 两条
+ * 路径都必须调它——审计 6.5 之前这段投影被内联复制了两份，任何一边改字段就会让两个视图分叉
+ * （与 D4 的教训同型）。字段语义：expected = 创建时快照票数，dispatched = 本轮派出的评审数，
+ * reported = 本轮已报票数，quorum = 本轮是否齐票。
+ */
+function verifyTasksView(tasks) {
+  return Object.keys(tasks || {}).filter(function (k) { return tasks[k] && tasks[k].type === 'verify' })
+    .map(function (k) {
+      const t = tasks[k]
+      const v = voteCount(t)
+      return { rId: t.rId, status: t.status, round: v.round, expected: v.expected, dispatched: v.dispatched, reported: v.reportedThisRound, quorum: v.quorum }
+    })
+}
   // 一票不算共识：≥MIN_REVIEWERS 份独立评审才可能达成/否决共识（审计 M11；与 v3 的最小票数同型）。
-  function consensus(t) { const cids = Object.keys(t.childResults); if (cids.length < MIN_REVIEWERS) return false; const vs = cids.map(function (cid) { return t.childResults[cid].Result }); return vs.every(function (v) { return v === 1 }) || vs.every(function (v) { return v === 0 }) }
-  function buildTranscript(t) { const parts = []; const cids = Object.keys(t.childResults); for (let i = 0; i < cids.length; i++) { const r = t.childResults[cids[i]]; parts.push('Reviewer ' + i + ': Result=' + r.Result + ' Reason=' + r.Reason) } return parts.join('\n') }
+  function consensus(t) { const v = voteCount(t); if (v.reportedIds.length < MIN_REVIEWERS) return false; const vs = v.reportedIds.map(function (cid) { return t.childResults[cid].Result }); return vs.every(function (x) { return x === 1 }) || vs.every(function (x) { return x === 0 }) }
+  function buildTranscript(t) { const parts = []; const cids = Object.keys(t.childResults); for (let i = 0; i < cids.length; i++) { const r = t.childResults[cids[i]]; const changedNote = (r.changed != null && String(r.changed).trim()) ? (' [changed: ' + String(r.changed).trim() + ']') : ''; parts.push('Reviewer ' + i + ': Result=' + r.Result + ' Reason=' + r.Reason + changedNote) } return parts.join('\n') }
   // 说明（审计 L17）：这里曾有一个 `verifierWeight(cid, rigor)`，但全仓只有它的定义、没有任何调用点，
   // 且其公式（clamped ±0.2 rigor 加成、按 childId 取准确率）与 finalVerdict 里真正在用的
   // 稳定身份键 + 0.1 自信加成**并不相同**——留着它只会让人以为 forced 模式走的是那条公式。已删除。
@@ -2952,7 +3238,11 @@ export function apply(ctx) {
    * 由 spawnChild 写进 agentRegistry 的 meta，再随每次投票进入 childResults。
    */
   function verifierIdentityKey() { const o = childAgentOptions(); return 'm:' + String(o.provider || '-') + '/' + String(o.model || '-') }
-  const PENDING_SCORE_MAX_OBJECTS = 32
+  const PENDING_SCORE_MAX_OBJECTS = 32   // 全局最多保留多少个对象的待计分样本（FIFO 丢弃，见 recordReviewForScoring）
+  const PENDING_SCORE_CAP_PER_OBJECT = 8 // 每个对象最多保留多少条待计分样本
+  const PENDING_SCORE_WARN_INTERVAL_MS = 5 * 60 * 1000 // 全局丢弃告警的最小间隔（避免每票刷屏）
+  const scoreCapWarned = new Set()
+  let scoreGlobalWarnedAt = 0
   /** 记下本轮各评审的投票，等**这个对象后来**取得布尔定论时再回溯计分（见 scorePendingReviews）。 */
   function recordReviewForScoring(objectId, key, result) {
     const id = String(objectId || '')
@@ -2960,9 +3250,26 @@ export function apply(ctx) {
     let list = pendingReviewScores[id]
     if (!list) { list = []; pendingReviewScores[id] = list }
     list.push({ key: String(key || 'm:unknown'), result: clamp01(result) })
-    if (list.length > 8) list.shift()
+    // 有界保留（**故意**的截断，已文档化）：每对象最多 PENDING_SCORE_CAP_PER_OBJECT 条待计分样本、
+    // 全局最多 PENDING_SCORE_MAX_OBJECTS 个对象；超限丢弃**最旧**的（FIFO）。丢弃会写活动日志，
+    // 避免"verifierAccuracy 随对象数悄悄漂移"而无人知晓（已累计的准确率不受影响）。
+    if (list.length > PENDING_SCORE_CAP_PER_OBJECT) {
+      list.shift()
+      if (!scoreCapWarned.has(id)) {
+        scoreCapWarned.add(id)
+        if (scoreCapWarned.size > 64) scoreCapWarned.clear()
+        logActivity('verify', '评审计分样本达上限（每对象 ' + PENDING_SCORE_CAP_PER_OBJECT + ' 条）：' + id + ' 丢弃最旧一条（故意保留上限；已累计 verifierAccuracy 不受影响）')
+      }
+    }
     const ids = Object.keys(pendingReviewScores)
-    while (ids.length > PENDING_SCORE_MAX_OBJECTS) delete pendingReviewScores[ids.shift()]
+    if (ids.length > PENDING_SCORE_MAX_OBJECTS) {
+      let dropped = 0
+      while (ids.length > PENDING_SCORE_MAX_OBJECTS) { delete pendingReviewScores[ids.shift()]; dropped++ }
+      if (now() - scoreGlobalWarnedAt > PENDING_SCORE_WARN_INTERVAL_MS) {
+        scoreGlobalWarnedAt = now()
+        logActivity('verify', '评审计分样本的对象数达上限（' + PENDING_SCORE_MAX_OBJECTS + '）：丢弃最旧的 ' + dropped + ' 个对象的待计分样本（故意保留上限；已累计 verifierAccuracy 不受影响）')
+      }
+    }
   }
   /** 对象取得布尔定论（1/0）时，用它给**此前**那些还没被检验过的评审打分。绝不拿聚合值给同一批打分。 */
   async function scorePendingReviews(objectId, truth) {
@@ -2998,9 +3305,9 @@ export function apply(ctx) {
       return
     }
     if (t.children.indexOf(childId) === -1) t.children.push(childId)
-    t.childResults[childId] = { Result: Result, Reason: Reason, round: meta.round, key: meta.verificationKey || verifierIdentityKey() }
+    t.childResults[childId] = { Result: Result, Reason: Reason, round: meta.round, key: meta.verificationKey || verifierIdentityKey(), changed: (parsed && parsed.changed != null && String(parsed.changed).trim()) ? String(parsed.changed).trim() : null }
     delete agentRegistry[childId]
-    const allReported = t.children.length > 0 && t.children.every(function (cid) { const r = t.childResults[cid]; return r && r.round === meta.round })
+    const allReported = voteCount(t, meta.round).allParticipantsReported
     if (!allReported) { await saveAll(); return }
     await advanceVerification(t, meta.round)
     await saveAll()
@@ -3040,7 +3347,7 @@ export function apply(ctx) {
    * `stalled`，冷却期后重试（任务保留 ⇒ processVerify 不会为同一个 rId 另造任务，也不会每 tick 重试）。
    */
   async function finalizeVerification(t) {
-    const reviews = Object.keys(t.childResults || {}).length
+    const reviews = voteCount(t).reportedIds.length
     if (reviews < MIN_REVIEWERS) {
       const tried = Number(t.reviewerRespawn || 0)
       if (scheduler.running && tried < 2 && reviewerCap() >= MIN_REVIEWERS) {
@@ -3071,7 +3378,8 @@ export function apply(ctx) {
     }
   }
   function finalVerdict(t) {
-    const rs = Object.keys(t.childResults).map(function (cid) { return t.childResults[cid] })
+    const v = voteCount(t)
+    const rs = v.reportedIds.map(function (cid) { return t.childResults[cid] })
     if (rs.length === 0) return 0.5
     if (rs.every(function (r) { return r.Result === 1 })) return 1
     if (rs.every(function (r) { return r.Result === 0 })) return 0
@@ -3146,7 +3454,7 @@ export function apply(ctx) {
     // 文件名来自 t.rId，而 rId 是**用户可写**的 q.id / p.id 拼出来的（buildVerifyCandidates 里
     // 'r-' + q.id + '-s' + j）。fs.resolve 只做规范化、并不拒绝 '..'，所以 q.id = 'x/../../../../pwn'
     // 会让这次写落到项目树之外（审计 C1，已用 pathdemo2.cjs 复现）。路径段一律过 safeId。
-    await writeJson('Verification_logs/' + safeId(String(t.rId)) + '_' + Date.now() + '.json', { r: r, verdict: v, results: t.childResults, transcript: buildTranscript(t), history: t.history || [], at: now() })
+    await writeJson('Verification_logs/' + safeId(String(t.rId)) + '_' + Date.now() + '_' + shortId() + '.json', { r: r, verdict: v, results: t.childResults, transcript: buildTranscript(t), history: t.history || [], at: now() })
 
     if (r.kind === 'proposition') {
       const p = await findProposition(r.pId)
@@ -3434,7 +3742,7 @@ export function apply(ctx) {
     const cid = paperInFlight
     paperInFlight = ''; paperInFlightAt = 0
     if (cid) {
-      try { await interruptChild(cid) } catch (e) { /* best effort */ }
+      try { await interruptTraced(cid, 'paper writer re-dispatch') } catch (e) { /* best effort */ }
       delete agentRegistry[cid]
       paperAbandoned[cid] = true
     }
@@ -3451,13 +3759,25 @@ export function apply(ctx) {
   /** 证据索引（spec §3.9）：只列**确实存在**的文件；绝不含 Paper/ 自己（否则输入哈希会自我污染）。
    *  off 档必须真的是无操作（formal-verify-v2 的语料守卫会断言"off 的提示词里零 Lean 文本"）：
    *  formal 未启用时，形式化相关的路径与字段一概不写进材料。 */
+  /**
+   * 成员可见路径说明（跨预设审计 P0）。成员/子代理的**文件工具按会话 cwd 解析**相对路径，而下面列出的
+   * 路径都是**项目根相对**的 ⇒ 必须显式说明"先拼绝对前缀"；计算产物用回执里的绝对字段。一处常量、
+   * 两处**成员可见**材料文本（`paperEvidenceIndex` 证据索引 + `buildPaperDigest` 摘要）各自 append（绝不替换既有行）。
+   * 另三处（`paperCompile` / `paperEmitArtifacts` / `paperMissingArtifacts`）是**框架侧文件操作**，其路径从不进入
+   * 成员可见文本，因此**不**追加本说明——这不是遗漏，而是按"是否需要成员照抄路径"分类的结果。
+   */
+  const PAPER_PATH_NOTE = '（路径说明：成员/子代理的文件工具按**会话 cwd** 解析相对路径，因此上面列出的相对路径都必须先拼上**项目根的绝对前缀**再使用；计算产物请用回执里的绝对字段 `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来。）'
   async function paperEvidenceIndex() {
     const formalNow = formalOn()
-    const out = ['qs/qs.json']
+    const out = []
+    if (await paperPathExists('qs/qs.json')) out.push('qs/qs.json')
     if (formalNow && await paperPathExists('VibeMath_State/formal.json')) out.push('VibeMath_State/formal.json')
     for (const f of await listFiles('Propos')) out.push('Propos/' + f)
     for (const f of await listFiles('Verified')) out.push('Verified/' + f)
     if (formalNow) for (const f of await listFiles('Verified/Lean')) out.push('Verified/Lean/' + f)
+    // 审计 F2：提示词要求「引用 Reliable/ 里的可信来源时要给出处」，材料证据索引也必须收它，
+    // 否则被要求引用的那一层永远进不了论文材料（reliableFiles() 因此从死代码变成活代码）。
+    for (const f of await reliableFiles()) out.push('Reliable/' + f)
     const dirs = ['Verification_logs', 'Progress_Logs'].concat(formalNow ? ['Formal'] : [])
     for (let i = 0; i < dirs.length; i++) { const files = await listFiles(dirs[i]); for (let j = 0; j < files.length; j++) out.push(dirs[i] + '/' + files[j]) }
     return out.filter(function (x) { return x.indexOf('Paper/') !== 0 }).sort()
@@ -3484,6 +3804,7 @@ export function apply(ctx) {
     const props = await getPropos()
     L.push('')
     L.push('[PROPOSITIONS] (Propos/*.json)')
+    L.push(PAPER_PATH_NOTE)
     if (props.length === 0) L.push('- (none)')
     for (let i = 0; i < props.length; i++) {
       const p = props[i]
@@ -3525,7 +3846,7 @@ export function apply(ctx) {
       PAPER_SKELETON.map(function (s, i) { return '    ' + (i + 1) + '. ' + s.key + ' — ' + s.spec }).join('\n') + '\n' +
       '- A section with no evidence must be exactly 「' + PAPER_NO_EVIDENCE + '」 (do not pad it).\n' +
       '- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.\n\n' +
-      'OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:\n' +
+      'OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:\n' + REPLY_KEY_STYLE_LINE +
       '{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}\n\n' +
       'MATERIAL (evidence only — do not add anything beyond it):\n' + digest
   }
@@ -3881,7 +4202,7 @@ export function apply(ctx) {
     const prevEpoch = await readJson('VibeMath_State/process_epoch.json')
     const stale = typeof prevEpoch === 'string' && prevEpoch !== processEpoch
     if (fresh || stale) {
-      if (fresh) { const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptChild(ids[i]) }
+      if (fresh) { const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptTraced(ids[i], 'batch clear (start/abort)') }
       if (Object.keys(agentRegistry).length > 0 || Object.keys(tasks).length > 0) {
         logActivity(fresh ? 'start' : 'resume', 'cleared ' + Object.keys(agentRegistry).length + ' agent(s) and ' + Object.keys(tasks).length + ' task(s) (' + (fresh ? 'restart' : 'stale from previous process') + ')')
         agentRegistry = {}; tasks = {}
@@ -3905,7 +4226,7 @@ export function apply(ctx) {
   async function startScheduler() { const r = await init(true); if (!r.ok) return r; abandonGatedDecision('scheduler restarted'); scheduler.running = true; scheduler.startedAt = now(); logActivity('start', 'scheduler started for project ' + currentProject); await saveAll(); await maybeWriteReport(true); scheduleTick(); return { ok: true, message: 'scheduler started', project: currentProject, frameworkRoot: frameworkRoot() } }
   async function resumeScheduler() { const r = await init(false); if (!r.ok) return r; abandonGatedDecision('scheduler resumed (离开那次运行，挂起的节点不再等待)'); scheduler.running = true; logActivity('resume', 'scheduler resumed'); await saveAll(); await maybeWriteReport(true); scheduleTick(); return { ok: true, message: 'scheduler resumed', project: currentProject, frameworkRoot: frameworkRoot() } }
   async function pauseScheduler() { scheduler.running = false; logActivity('pause', 'scheduler paused'); await saveAll(); return { ok: true, message: 'scheduler paused' } }
-  async function abortScheduler() { scheduler.running = false; abandonGatedDecision('scheduler aborted'); const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptChild(ids[i]); agentRegistry = {}; paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0; paperPending = null; logActivity('abort', 'scheduler aborted, ' + ids.length + ' child(ren) interrupted'); await saveAll(); return { ok: true, message: 'scheduler aborted', interrupted: ids.length } }
+  async function abortScheduler() { scheduler.running = false; abandonGatedDecision('scheduler aborted'); const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptTraced(ids[i], 'batch clear (start/abort)'); agentRegistry = {}; paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0; paperPending = null; logActivity('abort', 'scheduler aborted, ' + ids.length + ' child(ren) interrupted'); await saveAll(); return { ok: true, message: 'scheduler aborted', interrupted: ids.length } }
   // auto 模式语义 = 无人值守自动通过关键节点：切回 auto 时把仍挂起的人工决策按自动策略放行
   async function autoResolvePending() {
     const pending = decisionQueue.filter(function (d) { return d.status === 'pending' })
@@ -3926,26 +4247,42 @@ export function apply(ctx) {
     }
     if (pending.length > 0) { scheduler.gate = null; logActivity('mode', 'switched to auto — auto-resolved ' + pending.length + ' pending decision(s)'); await saveAll(); scheduleTick() }
   }
+  /** 审计 F7：`project` 是**当前会话**的项目名，`projects` 是磁盘上已存在的 slug 列表；
+   *  两者不闭合时（新会话 project='default' 而磁盘上没有该目录）语义必须显式，不能靠调用方猜。 */
+  async function projectExistsOnDisk() { return (await listDirsAt(vibeRoot(), 'Projects')).indexOf(currentProject) !== -1 }
   async function getStatus() {
     const qs = await getQs(); const propos = await getPropos()
     return {
+      at: now(),
       ok: true, initialized: rootAgent !== undefined, running: scheduler.running,
-      project: currentProject, projects: await listDirsAt(vibeRoot(), 'Projects'),
+      project: currentProject, projectExists: await projectExistsOnDisk(), projects: await listDirsAt(vibeRoot(), 'Projects'),
+      stateCommit: stateCommit,
+      stateWriteFailures: { count: stateWriteFailures.length, last: stateWriteFailures[stateWriteFailures.length - 1] || null },
       mode: params.mode, activeCount: activeCount(), maxParallelThreshold: params.maxParallelThreshold,
       frameworkRoot: frameworkRoot(),
       problems: { total: qs.length, solved: qs.filter(function (q) { return q.已解决 }).length },
       propositions: { total: propos.length, resolved: propos.filter(function (p) { return p.布尔估计 === 1 || p.布尔估计 === 0 }).length },
       pendingDecisions: decisionQueue.filter(function (d) { return d.status === 'pending' }).length,
       registeredAgents: Object.keys(agentRegistry).length,
+      // D4 审计面：每个在飞验证任务的参与集/票数都由 voteCount 投影出来（两个视图可对照）。
+      verifyTasks: verifyTasksView(tasks),
       recentActivity: activityLog.slice(-Math.min(ACTIVITY_REPORT_MAX, Number(params.activityLogCap) || 100)), params: params,
       formal: {
         mode: formalMode(), required: formalRequired(),
         leanCommand: params.leanCommand, leanArgs: params.leanArgs, leanTimeoutMs: params.leanTimeoutMs,
         objects: Object.keys(formalRecords()).map(function (k) { const r = formalRecords()[k] || {}; return { target: k, status: r.status, file: r.file, proof: r.proof, note: r.note } }),
         todo: formalTodo(),
-        paths: { project: 'Formal/', lib: vibeRoot() + '/Formal/Lib/', proved: vibeRoot() + '/Formal/Proved/', proofs: 'Verified/Lean/' },
+        // F6：四项路径基准不同 ⇒ 必须点名 base（project/proofs 相对 base，lib/proved 已绝对）。
+        paths: { base: frameworkRoot() + '/', project: 'Formal/', proofs: 'Verified/Lean/', lib: vibeRoot() + '/Formal/Lib/', proved: vibeRoot() + '/Formal/Proved/', note: 'project/proofs 相对 base（项目根）；lib/proved 已含绝对前缀' },
       },
       // 最终论文的可观测面（spec §2/§6）：自动开关、在途/排队、定稿时间、产物与编译结果。
+      // F3（对照 v5 的 leanNoticesScope/fieldScopes）：本面把**会话内存**与**耐久**字段并排放在同一层，
+      // 这里逐组标注来源，读者不必猜哪个重启会归零。
+      fieldScopes: {
+        durable: ['project', 'projects', 'problems', 'propositions', 'stateCommit', 'formal', 'paper.finalizedAt', 'paper.artifacts', 'paper.compile'],
+        session: ['stateWriteFailures', 'activeCount', 'pendingDecisions', 'registeredAgents', 'verifyTasks', 'recentActivity', 'paper.inFlight', 'paper.inFlightSince', 'paper.inFlightAgeMs', 'paper.reapedThisRun', 'paper.queued'],
+        note: 'session = 本进程内存，重启后归零（看着永远健康是假象）；durable = 落在项目树里（State/Formal/Progress/Verified 等），重启后仍在',
+      },
       paper: await paperStatusView(),
     }
   }
@@ -3997,12 +4334,14 @@ export function apply(ctx) {
   registerTool('vibe_math_status', 'Show scheduler status, params, active agents, projects, and recent activity.', objParams({}), async function () { await refreshParams(); return await getStatus() })
   registerTool('vibe_math_report', 'Return the full progress report and write it to Progress_Logs/report.json.', objParams({}), async function () { await refreshParams(); await maybeWriteReport(true); return await buildReport() })
   registerTool('vibe_math_set_mode', 'Switch between manual and auto (preset) mode. Switching to auto auto-resolves any pending manual decisions.', objParams({ mode: { type: 'string', enum: ['manual', 'auto'] } }, ['mode']), async function (args) { params.mode = args.mode; await saveAll(); await saveSettings(); if (params.mode === 'auto') await autoResolvePending(); return { ok: true, mode: params.mode } })
-  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式（框架会在用户 leanArgs 之后、文件名之前自动追加 `--search-path <VibeMath 根>`，用户已显式给出就不注入）；leanAsync = true（默认，后台队列：入队即返回，只有作业落地 ok 才置 passed 并写归档证明）| false（同步 await 的旧语义）。leanJobsMaxParallel = 后台编译并发上限（默认 1 = 串行）；leanInitiative = off|normal|eager 控制**日常的**形式化主动性（与 formalVerify 的验证要求强度是两件事：formalVerify=off 只关验证阶段，eager 仍注入日线）；leanSearchPaths = 额外 Lean 搜索路径（默认空 = 只用自动注入的 VibeMath 根；非空时先注入它们、再注入自动根）。最终论文：finalPaper（默认 true；收口时自动派遣一名「论文撰写」子代理）/ paperFormat = both|md|tex / paperLanguage = zh|en / paperCompilePdf（检测到 LaTeX 时编译 paper.pdf）/ paperLatexCommand（指定引擎，空 = 自动探测），产物在 Paper/<项目>/。数学计算（工具 math_computation，回执落在 Computation/<id>/）：mathComputation = off|auto|on（默认 auto；off 时提示词零提及）· mathMode = typed|typed+shell（默认 typed+shell；typed 时提示词不含 shell 兜底段且 cli 返回 REFUSED{reason:policy}）· mathEngines = 允许的引擎列表（默认含 cli，cli 默认开启）· mathTimeoutMs（默认 60000，最小 1000；到时主动 terminate）· mathPackages（需预检的包，缺包只报告+给安装计划）· mathInstallScope = user|system（默认 user；system 只对当次显式调用生效、永不记忆）。', objParams({ maxParallelThreshold: { type: 'integer' }, solverMaxRounds: { type: 'integer' }, verifierCount: { type: 'integer' }, debateMaxRounds: { type: 'integer' }, verdictMode: { type: 'string', enum: ['flat', 'forced'] }, reportMode: { type: 'string', enum: ['file', 'push', 'both'] }, promoteValueThreshold: { type: 'number' }, priorityAdjust: { type: 'string', enum: ['none', 'deadend-deprioritize', 'survival-map'] }, proposPriorityAdjust: { type: 'string', enum: ['none', 'progress-graded'] }, provider: { type: 'string' }, model: { type: 'string' }, solverPersona: { type: 'string' }, verifierPersona: { type: 'string' }, explorerPersona: { type: 'string' }, knowledgeContext: { type: 'string' }, solverToolAllow: { type: 'array', items: { type: 'string' } }, solverToolDeny: { type: 'array', items: { type: 'string' } }, verifierToolAllow: { type: 'array', items: { type: 'string' } }, verifierToolDeny: { type: 'array', items: { type: 'string' } }, solverAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, formalVerify: { type: 'string', enum: ['off', 'encourage', 'require'] }, leanCommand: { type: 'string' }, leanArgs: { type: 'array', items: { type: 'string' } }, leanTimeoutMs: { type: 'integer' }, leanAsync: { type: 'boolean' }, leanJobsMaxParallel: { type: 'integer' }, leanInitiative: { type: 'string', enum: ['off', 'normal', 'eager'] }, leanSearchPaths: { type: 'array', items: { type: 'string' } }, mathComputation: { type: 'string', enum: ['off', 'auto', 'on'] }, mathMode: { type: 'string', enum: ['typed', 'typed+shell'] }, mathEngines: { type: 'array', items: { type: 'string' } }, mathTimeoutMs: { type: 'integer' }, mathPackages: { type: 'array', items: { type: 'string' } }, mathInstallScope: { type: 'string', enum: ['user', 'system'] }, finalPaper: { type: 'boolean' }, paperFormat: { type: 'string', enum: ['both', 'md', 'tex'] }, paperLanguage: { type: 'string', enum: ['zh', 'en'] }, paperCompilePdf: { type: 'boolean' }, paperLatexCommand: { type: 'string' } }), async function (args) { params = Object.assign({}, params, sanitizeParams(args)); await saveAll(); await saveSettings(); if (args && MATH_PARAM_NAMES.some(function (k) { return k in args })) { try { await refreshMathProbe(true) } catch (e) { /* 探测失败不影响参数保存 */ } } return { ok: true, params: params } })
+  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式（框架会在用户 leanArgs 之后、文件名之前自动追加 `--search-path <VibeMath 根>`，用户已显式给出就不注入）；leanAsync = true（默认，后台队列：入队即返回，只有作业落地 ok 才置 passed 并写归档证明）| false（同步 await 的旧语义）。leanJobsMaxParallel = 后台编译并发上限（默认 1 = 串行）；leanInitiative = off|normal|eager 控制**日常的**形式化主动性（与 formalVerify 的验证要求强度是两件事：formalVerify=off 只关验证阶段，eager 仍注入日线）；leanSearchPaths = 额外 Lean 搜索路径（默认空 = 只用自动注入的 VibeMath 根；非空时先注入它们、再注入自动根）。最终论文：finalPaper（默认 true；收口时自动派遣一名「论文撰写」子代理）/ paperFormat = both|md|tex / paperLanguage = zh|en / paperCompilePdf（检测到 LaTeX 时编译 paper.pdf）/ paperLatexCommand（指定引擎，空 = 自动探测），产物在 Paper/<项目>/。数学计算（工具 math_computation，回执落在 Computation/<id>/）：mathComputation = off|auto|on（默认 auto；off 时提示词零提及）· mathMode = typed|typed+shell（默认 typed+shell；typed 时提示词不含 shell 兜底段且 cli 返回 REFUSED{reason:policy}）· mathEngines = 允许的引擎列表（默认含 cli，cli 默认开启）· mathTimeoutMs（默认 60000，最小 1000；到时主动 terminate）· mathPackages（需预检的包，缺包只报告+给安装计划）· mathInstallScope = user|system（默认 user；system 只对当次显式调用生效、永不记忆）。', objParams(paramProps()), async function (args) { params = Object.assign({}, params, sanitizeParams(args)); await saveAll(); await saveSettings(); if (args && MATH_PARAM_NAMES.some(function (k) { return k in args })) { try { await refreshMathProbe(true) } catch (e) { /* 探测失败不影响参数保存 */ } } return { ok: true, params: params } })
   registerTool('vibe_math_setup', 'Return the interactive parameter schema for guided configuration.', objParams({}), async function () { await refreshParams(); const list = PARAM_SCHEMA.map(function (p) { const out = Object.assign({}, p); out.current = params[p.name]; out.default = DEFAULT_PARAMS[p.name]; return out }); return { ok: true, parameters: list, saveTo: frameworkRoot() + '/vibe_math_setting.json' } })
   registerTool('vibe_math_save_settings', 'Write the current params to vibe_math_setting.json (JSON with comments) as new defaults.', objParams({}), async function () { return await saveSettings() })
   registerTool('vibe_math_template', 'Create a fresh vibe_math_setting.json template (with defaults + comments) in the workspace (global) or current project folder.', objParams({ where: { type: 'string', enum: ['global', 'project'] } }), async function (args) { return await createTemplate((args && args.where) || 'global') })
   registerTool('vibe_math_add_problem', 'Add a problem to the current project qs/qs.json.', objParams({ id: { type: 'string' }, description: { type: 'string' }, priority: { type: 'integer' } }, ['id', 'description']), async function (args) { const qs = await getQs(); if (qs.some(function (q) { return q.id === args.id })) return { ok: false, message: 'problem id already exists' }; qs.push({ id: args.id, 概述: args.description, 已解决: false, 解法列表: [], 优先级: args.priority || 0, progress: { directions: [] } }); await writeQs(qs); scheduleTick(); return { ok: true, message: 'problem added' } })
-  registerTool('vibe_math_add_proposition', 'Add a proposition to Propos/ (with 概述, 布尔估计, 细类型, 优先级, 价值/关键性).', objParams({ id: { type: 'string' }, 概述: { type: 'string' }, 布尔估计: { type: 'number' }, 优先级: { type: 'integer' }, '价值/关键性': { type: 'number' }, 细类型: { type: 'object' } }, ['id', '概述']), async function (args) {
+  registerTool('vibe_math_add_proposition', 'Add a NEW proposition to Propos/ (with 概述, 布尔估计, 细类型, 优先级, 价值/关键性). The id must be NEW: if it already exists the call is REFUSED with code PROPOSITION_ID_EXISTS (existing cards are never overwritten — their 证明列表/证伪列表 are preserved); pick a fresh id (e.g. p-<8 hex>) or edit the card file Propos/<分类>/<id>.md directly.', objParams({ id: { type: 'string' }, 概述: { type: 'string' }, 布尔估计: { type: 'number' }, 优先级: { type: 'integer' }, '价值/关键性': { type: 'number' }, 细类型: { type: 'object' } }, ['id', '概述']), async function (args) {
+    const p1Conflict = propositionIdConflict(args.id, await getPropos())
+    if (p1Conflict) { logActivity('proposition', '拒绝覆盖已有命题：' + args.id); return Object.assign({ ok: false }, p1Conflict) }
     const p = { id: args.id, 概述: args.概述, 布尔估计: clamp01(args.布尔估计 != null ? args.布尔估计 : 0.5), 细类型: (args.细类型 && typeof args.细类型 === 'object') ? args.细类型 : { 未分类: {} }, 证明列表: [], 证伪列表: [], 优先级: (args.优先级 != null) ? args.优先级 : 1, '价值/关键性': clamp01(args['价值/关键性'] != null ? args['价值/关键性'] : 0.5), progress: { 来源: 'user', 说明: '用户手动添加。' } }
     await upsertProposition(p); scheduleTick(); return { ok: true, proposition: p, file: proposFile(categoryOf(p)) }
   })
@@ -4011,10 +4350,10 @@ export function apply(ctx) {
   registerTool('vibe_math_set_project', 'Switch the current math project.', objParams({ name: { type: 'string' } }, ['name']), async function (args) { const slug = slugify(args.name); return await setProject(slug, false) })
   registerTool('vibe_math_list_projects', 'List math projects.', objParams({}), async function () { return { ok: true, current: currentProject, projects: await listDirsAt(vibeRoot(), 'Projects') } })
   registerTool('vibe_math_list_decisions', 'List pending manual decisions.', objParams({}), async function () { return { ok: true, decisions: decisionQueue.filter(function (d) { return d.status === 'pending' }).map(function (d) { return { id: d.id, node: d.node, context: d.context } }) } })
-  registerTool('vibe_math_decide', 'Resolve a pending manual decision (verdict override uses verdict: 1|0).', objParams({ id: { type: 'string' }, action: { type: 'string', enum: ['approve', 'reject', 'override'] }, verdict: { type: 'number' } }, ['id', 'action']), async function (args) { const d = decisionQueue.find(function (x) { return x.id === args.id }); if (!d) return { ok: false, message: 'decision not found' }; if (d.status !== 'pending') return { ok: false, message: 'decision already resolved' }; const resolution = { action: args.action, verdict: args.verdict }; const applied = await applyDecision(d.node, d.data, resolution); const r = await resolveDecision(args.id, resolution); return Object.assign({ ok: true, applied: applied }, r) })
+  registerTool('vibe_math_decide', 'Resolve a pending manual decision (verdict override uses verdict: 1|0).', objParams({ id: { type: 'string' }, action: { type: 'string', enum: ['approve', 'reject', 'override'] }, verdict: { type: 'number' } }, ['id', 'action']), async function (args) { const d = decisionQueue.find(function (x) { return x.id === args.id }); const resolution = { action: args.action, verdict: args.verdict }; if (!d || d.status !== 'pending') return await resolveDecision(args.id, resolution); const applied = await applyDecision(d.node, d.data, resolution); const r = await resolveDecision(args.id, resolution); return Object.assign({ ok: true, applied: applied }, r) })
   registerTool('vibe_math_list_agents', 'List tracked sub-agents (child sessions).', objParams({}), async function () { const out = []; const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) { const m = agentRegistry[ids[i]]; out.push({ childId: ids[i], role: m.role, qid: m.qid, direction: m.direction, round: m.round, rId: m.rId }) } return { ok: true, agents: out, count: out.length } })
   registerTool('vibe_math_message_agent', 'Send a message to a tracked child agent (next turn).', objParams({ childId: { type: 'string' }, message: { type: 'string' } }, ['childId', 'message']), async function (args) { if (!agentRegistry[args.childId]) return { ok: false, message: 'unknown childId' }; await followupChild(args.childId, args.message); return { ok: true, message: 'message delivered' } })
-  registerTool('vibe_math_interrupt_agent', 'Interrupt a tracked child agent.', objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { await interruptChild(args.childId); return { ok: true, message: 'interrupt requested' } })
+  registerTool('vibe_math_interrupt_agent', 'Interrupt a tracked child agent.', objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { const r = await interruptChild(args.childId); return Object.assign({}, r, { ok: !!(r && r.ok) }) })
   // ---- Lean 形式化验证（契约 §5）----
   registerTool('vibe_math_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the VibeMath root and report the result. Never throws: a missing toolchain returns LEAN_NOT_FOUND, a non-zero exit returns the compiler output. Pass target=<object id> to also record the run against that object.', objParams({ file: { type: 'string' }, target: { type: 'string' }, timeout_ms: { type: 'integer' } }, ['file']), async function (args, agent) { return await leanRunTool(memberIdOf(agent), args) })
   registerTool('vibe_math_lean_archive', '(member) Archive Lean code. kind="def": a REUSABLE definition/object/assumption → the global cross-project library (Formal/Lib). kind="lemma": a machine-checked lemma → Formal/Proved. kind="proof": the formal proof of a project object → Formal/<target>.lean, and (when the run passes) also Verified/Lean/<target>.lean, marking the object Lean-passed. kind="blocked": record an explicit, reasoned "cannot/not worth formalizing" decision (note required).', objParams({ kind: { type: 'string', enum: ['def', 'lemma', 'proof', 'blocked'] }, name: { type: 'string' }, target: { type: 'string' }, content: { type: 'string' }, from: { type: 'string' }, note: { type: 'string' }, run: { type: 'boolean' } }, ['kind']), async function (args, agent) { return await leanArchive(memberIdOf(agent), args) })
@@ -4050,7 +4389,7 @@ export function apply(ctx) {
     if (cmd === 'save') return await saveSettings()
     if (cmd === 'template') return await createTemplate(args[0] === 'project' ? 'project' : 'global')
     if (cmd === 'add') { const id = args[0]; const desc = args.slice(1).join(' '); if (!id || !desc) return { ok: false, message: 'usage: /vibe add <id> <description>' }; const qs = await getQs(); if (qs.some(function (q) { return q.id === id })) return { ok: false, message: 'problem id already exists' }; qs.push({ id: id, 概述: desc, 已解决: false, 解法列表: [], 优先级: 0, progress: { directions: [] } }); await writeQs(qs); scheduleTick(); return { ok: true, message: 'problem added' } }
-    if (cmd === 'add-proposition') { const id = args[0]; const desc = args.slice(1).join(' '); if (!id || !desc) return { ok: false, message: 'usage: /vibe add-proposition <id> <概述>' }; const p = { id: id, 概述: desc, 布尔估计: 0.5, 细类型: { 未分类: {} }, 证明列表: [], 证伪列表: [], 优先级: 1, '价值/关键性': 0.5, progress: { 来源: 'user-vibe', 说明: '用户通过 /vibe 添加。' } }; await upsertProposition(p); scheduleTick(); return { ok: true, proposition: p, file: proposFile(categoryOf(p)) } }
+    if (cmd === 'add-proposition') { const id = args[0]; const desc = args.slice(1).join(' '); if (!id || !desc) return { ok: false, message: 'usage: /vibe add-proposition <id> <概述>' }; const p1c = propositionIdConflict(id, await getPropos()); if (p1c) { logActivity('proposition', '拒绝覆盖已有命题：' + id); return Object.assign({ ok: false }, p1c) } const p = { id: id, 概述: desc, 布尔估计: 0.5, 细类型: { 未分类: {} }, 证明列表: [], 证伪列表: [], 优先级: 1, '价值/关键性': 0.5, progress: { 来源: 'user-vibe', 说明: '用户通过 /vibe 添加。' } }; await upsertProposition(p); scheduleTick(); return { ok: true, proposition: p, file: proposFile(categoryOf(p)) } }
     if (cmd === 'list-propositions') { const all = await getPropos(); return { ok: true, count: all.length, propositions: all.map(function (p) { return { id: p.id, 概述: p.概述, 布尔估计: p.布尔估计, 优先级: p.优先级, '价值/关键性': p['价值/关键性'], category: p._category } }) } }
     if (cmd === 'project') {
       if (args.length === 0 || args[0] === 'list') return { ok: true, current: currentProject, projects: await listDirsAt(vibeRoot(), 'Projects') }
@@ -4086,10 +4425,6 @@ export function apply(ctx) {
     mathProbeDue: mathProbeDue,
     refreshMathProbe: refreshMathProbe,
     mathProbe: function () { return mathProbe },
-    // P2a：persona 两个文本块必须含的「归档→编辑→重跑」规则（文本取自共享模块常量，persona 不手抄）。
-    mathArchiveWorkflowLine: MATH_ARCHIVE_WORKFLOW_LINE,
-    // A 项：替代声明规则（文本由共享模块给出；persona 两块与每轮可用性行都必须带它）。
-    mathSubstitutionRuleLine: MATH_SUBSTITUTION_RULE_LINE,
     leanQueueSize: function () { return leanQueue.length },
     leanJobsPublic: function () { const out = []; for (const j of leanJobs.values()) out.push(leanJobPublic(j)); return out },
     // childOwner 裁剪用：这个会话当前仍"可能再发 subagent/end"的 child（在册的 + 任务正在等的）。
@@ -4137,12 +4472,12 @@ export function apply(ctx) {
   registerTool('vibe_math_status', 'Show scheduler status, params, active agents, projects, and recent activity.', objParams({}), 'vibe_math_status')
   registerTool('vibe_math_report', 'Return the full progress report and write it to Progress_Logs/report.json.', objParams({}), 'vibe_math_report')
   registerTool('vibe_math_set_mode', 'Switch between manual and auto (preset) mode. Switching to auto auto-resolves any pending manual decisions.', objParams({ mode: { type: 'string', enum: ['manual', 'auto'] } }, ['mode']), 'vibe_math_set_mode')
-  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式（框架会在用户 leanArgs 之后、文件名之前自动追加 `--search-path <VibeMath 根>`，用户已显式给出就不注入）；leanAsync = true（默认，后台队列：入队即返回，只有作业落地 ok 才置 passed 并写归档证明）| false（同步 await 的旧语义）。leanJobsMaxParallel = 后台编译并发上限（默认 1 = 串行）；leanInitiative = off|normal|eager 控制**日常的**形式化主动性（与 formalVerify 的验证要求强度是两件事：formalVerify=off 只关验证阶段，eager 仍注入日线）；leanSearchPaths = 额外 Lean 搜索路径（默认空 = 只用自动注入的 VibeMath 根；非空时先注入它们、再注入自动根）。最终论文：finalPaper（默认 true；收口时自动派遣一名「论文撰写」子代理）/ paperFormat = both|md|tex / paperLanguage = zh|en / paperCompilePdf（检测到 LaTeX 时编译 paper.pdf）/ paperLatexCommand（指定引擎，空 = 自动探测），产物在 Paper/<项目>/。数学计算（工具 math_computation，回执落在 Computation/<id>/）：mathComputation = off|auto|on（默认 auto；off 时提示词零提及）· mathMode = typed|typed+shell（默认 typed+shell；typed 时提示词不含 shell 兜底段且 cli 返回 REFUSED{reason:policy}）· mathEngines = 允许的引擎列表（默认含 cli，cli 默认开启）· mathTimeoutMs（默认 60000，最小 1000；到时主动 terminate）· mathPackages（需预检的包，缺包只报告+给安装计划）· mathInstallScope = user|system（默认 user；system 只对当次显式调用生效、永不记忆）。', objParams({ maxParallelThreshold: { type: 'integer' }, solverMaxRounds: { type: 'integer' }, verifierCount: { type: 'integer' }, debateMaxRounds: { type: 'integer' }, verdictMode: { type: 'string', enum: ['flat', 'forced'] }, reportMode: { type: 'string', enum: ['file', 'push', 'both'] }, promoteValueThreshold: { type: 'number' }, priorityAdjust: { type: 'string', enum: ['none', 'deadend-deprioritize', 'survival-map'] }, proposPriorityAdjust: { type: 'string', enum: ['none', 'progress-graded'] }, provider: { type: 'string' }, model: { type: 'string' }, solverPersona: { type: 'string' }, verifierPersona: { type: 'string' }, explorerPersona: { type: 'string' }, knowledgeContext: { type: 'string' }, solverToolAllow: { type: 'array', items: { type: 'string' } }, solverToolDeny: { type: 'array', items: { type: 'string' } }, verifierToolAllow: { type: 'array', items: { type: 'string' } }, verifierToolDeny: { type: 'array', items: { type: 'string' } }, solverAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, formalVerify: { type: 'string', enum: ['off', 'encourage', 'require'] }, leanCommand: { type: 'string' }, leanArgs: { type: 'array', items: { type: 'string' } }, leanTimeoutMs: { type: 'integer' }, leanAsync: { type: 'boolean' }, leanJobsMaxParallel: { type: 'integer' }, leanInitiative: { type: 'string', enum: ['off', 'normal', 'eager'] }, leanSearchPaths: { type: 'array', items: { type: 'string' } }, mathComputation: { type: 'string', enum: ['off', 'auto', 'on'] }, mathMode: { type: 'string', enum: ['typed', 'typed+shell'] }, mathEngines: { type: 'array', items: { type: 'string' } }, mathTimeoutMs: { type: 'integer' }, mathPackages: { type: 'array', items: { type: 'string' } }, mathInstallScope: { type: 'string', enum: ['user', 'system'] }, finalPaper: { type: 'boolean' }, paperFormat: { type: 'string', enum: ['both', 'md', 'tex'] }, paperLanguage: { type: 'string', enum: ['zh', 'en'] }, paperCompilePdf: { type: 'boolean' }, paperLatexCommand: { type: 'string' } }), 'vibe_math_set_params')
+  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式（框架会在用户 leanArgs 之后、文件名之前自动追加 `--search-path <VibeMath 根>`，用户已显式给出就不注入）；leanAsync = true（默认，后台队列：入队即返回，只有作业落地 ok 才置 passed 并写归档证明）| false（同步 await 的旧语义）。leanJobsMaxParallel = 后台编译并发上限（默认 1 = 串行）；leanInitiative = off|normal|eager 控制**日常的**形式化主动性（与 formalVerify 的验证要求强度是两件事：formalVerify=off 只关验证阶段，eager 仍注入日线）；leanSearchPaths = 额外 Lean 搜索路径（默认空 = 只用自动注入的 VibeMath 根；非空时先注入它们、再注入自动根）。最终论文：finalPaper（默认 true；收口时自动派遣一名「论文撰写」子代理）/ paperFormat = both|md|tex / paperLanguage = zh|en / paperCompilePdf（检测到 LaTeX 时编译 paper.pdf）/ paperLatexCommand（指定引擎，空 = 自动探测），产物在 Paper/<项目>/。数学计算（工具 math_computation，回执落在 Computation/<id>/）：mathComputation = off|auto|on（默认 auto；off 时提示词零提及）· mathMode = typed|typed+shell（默认 typed+shell；typed 时提示词不含 shell 兜底段且 cli 返回 REFUSED{reason:policy}）· mathEngines = 允许的引擎列表（默认含 cli，cli 默认开启）· mathTimeoutMs（默认 60000，最小 1000；到时主动 terminate）· mathPackages（需预检的包，缺包只报告+给安装计划）· mathInstallScope = user|system（默认 user；system 只对当次显式调用生效、永不记忆）。', objParams(paramProps()), 'vibe_math_set_params')
   registerTool('vibe_math_setup', 'Return the interactive parameter schema for guided configuration.', objParams({}), 'vibe_math_setup')
   registerTool('vibe_math_save_settings', 'Write the current params to vibe_math_setting.json (JSON with comments) as new defaults.', objParams({}), 'vibe_math_save_settings')
   registerTool('vibe_math_template', 'Create a fresh vibe_math_setting.json template (with defaults + comments) in the workspace (global) or current project folder.', objParams({ where: { type: 'string', enum: ['global', 'project'] } }), 'vibe_math_template')
   registerTool('vibe_math_add_problem', 'Add a problem to the current project qs/qs.json.', objParams({ id: { type: 'string' }, description: { type: 'string' }, priority: { type: 'integer' } }, ['id', 'description']), 'vibe_math_add_problem')
-  registerTool('vibe_math_add_proposition', 'Add a proposition to Propos/ (with 概述, 布尔估计, 细类型, 优先级, 价值/关键性).', objParams({ id: { type: 'string' }, 概述: { type: 'string' }, 布尔估计: { type: 'number' }, 优先级: { type: 'integer' }, '价值/关键性': { type: 'number' }, 细类型: { type: 'object' } }, ['id', '概述']), 'vibe_math_add_proposition')
+  registerTool('vibe_math_add_proposition', 'Add a NEW proposition to Propos/ (with 概述, 布尔估计, 细类型, 优先级, 价值/关键性). The id must be NEW: if it already exists the call is REFUSED with code PROPOSITION_ID_EXISTS (existing cards are never overwritten — their 证明列表/证伪列表 are preserved); pick a fresh id (e.g. p-<8 hex>) or edit the card file Propos/<分类>/<id>.md directly.', objParams({ id: { type: 'string' }, 概述: { type: 'string' }, 布尔估计: { type: 'number' }, 优先级: { type: 'integer' }, '价值/关键性': { type: 'number' }, 细类型: { type: 'object' } }, ['id', '概述']), 'vibe_math_add_proposition')
   registerTool('vibe_math_list_propositions', 'List propositions from Propos/ (summary index: id, 概述, 布尔估计, 优先级, 价值/关键性, category, 依赖假设).', objParams({}), 'vibe_math_list_propositions')
   registerTool('vibe_math_new_project', 'Create a new math project folder and switch to it.', objParams({ name: { type: 'string' } }, ['name']), 'vibe_math_new_project')
   registerTool('vibe_math_set_project', 'Switch the current math project.', objParams({ name: { type: 'string' } }, ['name']), 'vibe_math_set_project')
@@ -4567,7 +4902,6 @@ function leanJobId(key, fingerprint) {
 /** "已落地且通过"的**唯一**判据：state=settled 且 exit 0 且未超时未中断（内容哈希由 settle 校验）。 */
 function leanJobSettledOk(rec) { return !!rec && rec.state === 'settled' && rec.exitCode === 0 && !rec.timedOut && !rec.interrupted }
 /** 主动性档位（修订 §1）：与"验证时的要求强度"（formalVerify）是两件事。 */
-const LEAN_INITIATIVE_MODES = ['off', 'normal', 'eager']
 
 export const __testHelpers = {
   uuid,
@@ -4621,6 +4955,11 @@ function now() { return Date.now() }
 
 function uuid() { const h = '0123456789abcdef'; let s = ''; for (let i = 0; i < 36; i++) { if (i === 8 || i === 13 || i === 18 || i === 23) s += '-'; else s += h[Math.floor(Math.random() * 16)] } return s }
 
+/// P8：框架分配 id 时先查重（shortId 是 Math.random 的 8 位 hex，碰撞概率极低但后果是静默覆盖）。
+function shortIdUnique(isTaken) {
+  for (let i = 0; i < 8; i++) { const id = shortId(); if (!isTaken(id)) return id }
+  return shortId()
+}
 function shortId() { const h = '0123456789abcdef'; let s = ''; for (let i = 0; i < 8; i++) s += h[Math.floor(Math.random() * 16)]; return s }
 
 function clamp01(v) { const n = Number(v); if (!Number.isFinite(n)) return 0.5; return Math.max(0, Math.min(1, n)) }