dsh-vibe-math 2.7.1 → 2.7.3

package/vibe-math-v3/vibe-math-v3.js

@@ -1,3 +1,118 @@
+// ================= 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: '每个求解方向的最大迭代轮数', suggestion: 3 },
+    { name: 'directionsPerSolver', type: 'integer', description: '每个 solver 提示词附带的其他活跃方向摘要数量：1 = 只看自己方向', suggestion: 1 },
+    { name: 'verifierCount', type: 'integer', description: '每个验证对象的独立验证器数量（实际下界为 2：少于 2 份独立评审一律不定论，见 minVotes）', suggestion: 3 },
+    { name: 'debateMaxRounds', type: 'integer', description: '验证辩论（交流群）最大轮数', suggestion: 5 },
+    { name: 'verdictMode', type: 'enum', options: ['flat', 'forced'], description: '裁决模式：flat = 均衡机制（分歧时 0.5）；forced = 强制裁决（对每票等权取均值；严格 1/0 是绝对投票，其影响通过数值本身拉向端点。**不按"历史准确率"加权**——该统计量统计的是与本批裁决的一致度，没有后续真值可纠正）；两者都先做近共识判定（同侧且均值≥0.85/≤0.15取均值，修复 v2 flat 误判）', suggestion: 'forced' },
+    { 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: 'plannerPersona', type: 'string', description: '注入规划代理提示词开头的人格/要求', suggestion: '' },
+    { name: 'methodKeeperPersona', type: 'string', description: '注入方法整理代理提示词开头的人格/要求', suggestion: '' },
+    { name: 'knowledgeContext', type: 'string', description: '共享知识/数据模型说明（空 = 内置完整版；非空 = 覆盖）', 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=允许；false=禁止', suggestion: '' },
+    { name: 'verifierAllowNetwork', type: 'boolean', description: '验证器网络工具开关', suggestion: '' },
+    { name: 'solverAllowScripts', type: 'boolean', description: '求解器脚本工具开关', suggestion: '' },
+    { name: 'verifierAllowScripts', type: 'boolean', description: '验证器脚本工具开关', suggestion: '' },
+    { name: 'solverMaxToolCalls', type: 'integer', description: '求解器每轮外部工具调用上限（0 = 不限）', suggestion: 0 },
+    { name: 'verifierMaxToolCalls', type: 'integer', description: '验证器每轮外部工具调用上限（0 = 不限）', suggestion: 0 },
+    { name: 'reportIntervalMs', type: 'integer', description: '进度汇报间隔（毫秒）：0 = 仅事件驱动', suggestion: 0 },
+    { name: 'reportMode', type: 'enum', options: ['file', 'push', 'both'], description: 'file = 写报告文件；push = 推送消息；both = 两者', suggestion: 'file' },
+    { name: 'promoteValueThreshold', type: 'number', description: '命题「价值/关键性」≥ 该值且未决(0,1) 时自动晋升为问题', suggestion: 0.7 },
+    { name: 'priorityAdjust', type: 'enum', options: ['none', 'deadend-deprioritize', 'survival-map'], description: '问题优先级动态调整策略', suggestion: 'none' },
+    { name: 'proposPriorityAdjust', type: 'enum', options: ['none', 'progress-graded'], description: '命题优先级动态调整策略', 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: 'planningHorizon', type: 'integer', description: '规划代理一次计划的最多动作数（"接下来 n 次"）', suggestion: 3 },
+    { name: 'plannerEnabled', type: 'boolean', description: 'false = 完全走内置启发式调度（规划代理禁用）', suggestion: true },
+    { name: 'plannerProvider', type: 'string', description: '规划代理模型 provider（空 = 继承根代理）', suggestion: '' },
+    { name: 'plannerModel', type: 'string', description: '规划代理模型 id（空 = 继承根代理）', suggestion: '' },
+    { name: 'planMinIntervalMs', type: 'integer', description: '每一次规划调用的最小间隔（毫秒）；对**每一次**规划调用都生效（含空计划、含「空闲但仍有工作」，不再有空闲绕过）', suggestion: 30000 },
+    { name: 'plannerMaxFails', type: 'integer', description: '规划代理连续失败达此值 → 自动降级启发式', suggestion: 3 },
+    { name: 'methodKeepIntervalMs', type: 'integer', description: 'Method Keeper 定时整理间隔（0 = 事件驱动）', suggestion: 0 },
+    { name: 'methodKeepEvery', type: 'integer', description: '每积累 N 个待沉淀发明/新命题触发一次整理', suggestion: 5 },
+    { name: 'methodAutoPromote', type: 'boolean', description: '项目级方法自动晋升全局库（false = 人工门）', suggestion: false },
+    { name: 'indexAutoRebuild', type: 'boolean', description: '每次写盘后自动重建索引（false = 手动 vibe_math_index）', suggestion: true },
+    { name: 'projectLockTimeoutMs', type: 'integer', description: '项目锁等待超时（毫秒）', suggestion: 60000 },
+    { name: 'fileLockTimeoutMs', type: 'integer', description: '文件写锁租约时长（毫秒，默认 60000，最小 1000）：持有代理存活期间自动续租，持有者消失后最多这么久失效，避免长文写入被别人抢锁（审计 D2）', suggestion: 60000 },
+    { name: 'formalVerify', type: 'enum', options: ['off', 'encourage', 'require'], description: 'Lean 形式化验证：off = 不额外要求（默认，提示词里不出现任何 Lean 内容）；encourage = 鼓励按实现难度形式化，Lean 通过后验证转为忠实性审查；require = 同上并加门禁：真/假定论必须先达到 Lean 已通过 或 已记录显式阻塞原因，否则记为未定论（formal-required）并进「形式化待办」', suggestion: 'off' },
+    { name: 'leanCommand', type: 'string', description: 'Lean 可执行文件（例：lean / lake；配合 leanArgs=[env,lean] 用 lake）', suggestion: 'lean' },
+    { name: 'leanArgs', type: 'string[]', description: '插在 .lean 文件名之前的附加参数', suggestion: [] },
+    { name: 'leanTimeoutMs', type: 'integer', description: '单次 Lean 运行的超时上限（毫秒，非正数回退默认）；异步档下它同时是**每个后台作业**的预算（到时主动 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_job 公告（**只有作业落地为 ok 才会置 passed 并写归档证明**）；false = 完全同步 await（与旧行为逐字一致）', suggestion: true },
+    { name: 'leanJobsMaxParallel', type: 'integer', description: '后台 Lean 编译的并发上限（默认 1 = 串行，保持可预测的资源占用；调大可并行编译多个作业）', suggestion: 1 },
+    { name: 'leanInitiative', type: 'enum', options: ['off', 'normal', 'eager'], description: '日常流程中的形式化主动性：off（不主动，只在验证提示词按 formalVerify 的要求做）| normal（默认：顺手把有价值且可能复用的东西形式化）| eager（更主动：日常就主动把有价值的小引理/命题/定义形式化）。注意它与 formalVerify（验证时的要求强度：off|encourage|require）是**两件事**', suggestion: 'normal' },
+    { name: 'leanSearchPaths', type: 'string[]', description: '额外 Lean 搜索路径（默认空数组 = 只用框架自动注入的 VibeMath 根）。非空时按顺序先注入这里给的路径、再注入自动根（去重）；若 leanArgs 里已显式给了 --search-path/-R/--root，则完全尊重用户配置、不注入任何东西', suggestion: [] },
+    { name: 'finalPaper', type: 'boolean', description: '收口（checkTermination 的完整收口分支：无未解决问题、无待验证对象、无任务/计划/门）时自动撰写最终论文：派遣一名专职「论文撰写」子代理，把已定论命题/解法/方法整理成 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 优先）。解析不到时按"未检测到"降级', 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: 'enum', options: ['user', 'system'], description: '安装作用域：user（默认，用户级目录）；system 只对当次显式调用生效、永不记忆（不会写进状态文件）', suggestion: 'user' },
+  ]
+
+// 钉住"机读键集合"（现状 v2=49 / v3=63 个，不随 PARAM_SCHEMA 增删而漂移）。
+const PARAM_PROPS_KEYS = ['mode', 'maxParallelThreshold', 'solverMaxRounds', 'verifierCount', 'debateMaxRounds', 'verdictMode', 'reportMode', 'promoteValueThreshold', 'priorityAdjust', 'proposPriorityAdjust', 'provider', 'model', 'solverPersona', 'verifierPersona', 'explorerPersona', 'plannerPersona', 'methodKeeperPersona', 'knowledgeContext', 'solverToolAllow', 'solverToolDeny', 'verifierToolAllow', 'verifierToolDeny', 'solverAllowNetwork', 'verifierAllowNetwork', 'solverAllowScripts', 'verifierAllowScripts', 'solverMaxToolCalls', 'verifierMaxToolCalls', 'reportIntervalMs', 'tickIntervalMs', 'activityLogCap', 'maxExplorerRetries', 'directionsPerSolver', 'planningHorizon', 'plannerEnabled', 'plannerProvider', 'plannerModel', 'planMinIntervalMs', 'plannerMaxFails', 'methodKeepIntervalMs', 'methodKeepEvery', 'methodAutoPromote', 'indexAutoRebuild', 'projectLockTimeoutMs', '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' } },
+leanSearchPaths: { type: 'array', items: { type: 'string' } },
+mode: { type: 'string', enum: ['manual', 'auto'] },
+}
+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 V3 — host plugin implementing the THIRD-generation architecture
 // ("vibe-math-v3/实现方案.md"): paper-style Markdown knowledge base + agent
 // self-organizing scheduling + universal theory/method invention library.
@@ -112,6 +227,7 @@ export function apply(ctx) {
   // 判据时最坏年龄仍有 2467ms，几乎顶到 2500ms 的租约上限。250ms 轮询下最坏租约年龄 ≈
   // max(250ms, projectLockTimeoutMs/4)，即上限的 1/4 再加一次轮询的抖动。
   const LOCK_POLL_MS = 250
+const ACTIVITY_PERSIST_MAX = 200 // P5：活动日志落盘上限（恢复时保留更多线索）
 
   function sessionIdOf(agent) { try { return (agent && agent.id) ? String(agent.id) : undefined } catch (e) { return undefined } }
   // Walk up the durable session lineage to the top-level (root) agent of this session,
@@ -191,6 +307,7 @@ export function apply(ctx) {
     methodAutoPromote: false,     // 项目级方法自动晋升全局库（false = 人工门）
     indexAutoRebuild: true,       // 每次写盘后自动重建索引（false = 手动 vibe_math_index）
     projectLockTimeoutMs: 60000,  // 项目锁等待超时
+    fileLockTimeoutMs: 60000,     // 文件写锁租约时长（审计 D2；持有者活着则每 LOCK_POLL_MS 续租）
     // ---- Lean 形式化验证（契约：docs/formal-verification.md，四架构同名同语义）----
     formalVerify: 'off',          // off | encourage | require（三档开关，见 实现方案.md §10.1）
     leanCommand: 'lean',          // 要执行的 Lean 可执行文件（例：'lake'）
@@ -224,6 +341,8 @@ export function apply(ctx) {
   // 长跑进程里无界增长并整表落盘。它已经不再参与任何加权（见 finalVerdict 的 M8 说明），
   // 只是审计轨迹，所以按插入顺序保留最近 N 条即可。
   const VERIFIER_ACC_KEEP = 200
+// F2（对照 v2:221）：status 与 report 的 recentActivity **共用**这一上限；参数 activityLogCap
+// 只能把它调小、不能调大（旧实现 status 硬编码 10、report 硬编码 30，读者无从知道）。
   function pruneVerifierAccuracy() {
     const keys = Object.keys(verifierAccuracy)
     for (let i = 0; i < keys.length - VERIFIER_ACC_KEEP; i++) delete verifierAccuracy[keys[i]]
@@ -276,87 +395,53 @@ export function apply(ctx) {
    * 保证结果永不为 `.` / `..`、也不含分隔符。
    */
   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-v3' + ': 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-v3: 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-v3: 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-v3: 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) }
 
   // ================= 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: '每个求解方向的最大迭代轮数', suggestion: 3 },
-    { name: 'directionsPerSolver', type: 'integer', description: '每个 solver 提示词附带的其他活跃方向摘要数量：1 = 只看自己方向', suggestion: 1 },
-    { name: 'verifierCount', type: 'integer', description: '每个验证对象的独立验证器数量（实际下界为 2：少于 2 份独立评审一律不定论，见 minVotes）', suggestion: 3 },
-    { name: 'debateMaxRounds', type: 'integer', description: '验证辩论（交流群）最大轮数', suggestion: 5 },
-    { name: 'verdictMode', type: 'enum', options: ['flat', 'forced'], description: '裁决模式：flat = 均衡机制（分歧时 0.5）；forced = 强制裁决（对每票等权取均值；严格 1/0 是绝对投票，其影响通过数值本身拉向端点。**不按"历史准确率"加权**——该统计量统计的是与本批裁决的一致度，没有后续真值可纠正）；两者都先做近共识判定（同侧且均值≥0.85/≤0.15取均值，修复 v2 flat 误判）', suggestion: 'forced' },
-    { 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: 'plannerPersona', type: 'string', description: '注入规划代理提示词开头的人格/要求', suggestion: '' },
-    { name: 'methodKeeperPersona', type: 'string', description: '注入方法整理代理提示词开头的人格/要求', suggestion: '' },
-    { name: 'knowledgeContext', type: 'string', description: '共享知识/数据模型说明（空 = 内置完整版；非空 = 覆盖）', 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=允许；false=禁止', suggestion: '' },
-    { name: 'verifierAllowNetwork', type: 'boolean', description: '验证器网络工具开关', suggestion: '' },
-    { name: 'solverAllowScripts', type: 'boolean', description: '求解器脚本工具开关', suggestion: '' },
-    { name: 'verifierAllowScripts', type: 'boolean', description: '验证器脚本工具开关', suggestion: '' },
-    { name: 'solverMaxToolCalls', type: 'integer', description: '求解器每轮外部工具调用上限（0 = 不限）', suggestion: 0 },
-    { name: 'verifierMaxToolCalls', type: 'integer', description: '验证器每轮外部工具调用上限（0 = 不限）', suggestion: 0 },
-    { name: 'reportIntervalMs', type: 'integer', description: '进度汇报间隔（毫秒）：0 = 仅事件驱动', suggestion: 0 },
-    { name: 'reportMode', type: 'enum', options: ['file', 'push', 'both'], description: 'file = 写报告文件；push = 推送消息；both = 两者', suggestion: 'file' },
-    { name: 'promoteValueThreshold', type: 'number', description: '命题「价值/关键性」≥ 该值且未决(0,1) 时自动晋升为问题', suggestion: 0.7 },
-    { name: 'priorityAdjust', type: 'enum', options: ['none', 'deadend-deprioritize', 'survival-map'], description: '问题优先级动态调整策略', suggestion: 'none' },
-    { name: 'proposPriorityAdjust', type: 'enum', options: ['none', 'progress-graded'], description: '命题优先级动态调整策略', suggestion: 'none' },
-    { name: 'tickIntervalMs', type: 'integer', description: '调度器心跳间隔（毫秒）', suggestion: 2000 },
-    { name: 'activityLogCap', type: 'integer', description: '活动日志保留条数', suggestion: 100 },
-    { name: 'maxExplorerRetries', type: 'integer', description: 'explorer 拆方向失败的重派生上限', suggestion: 3 },
-    { name: 'planningHorizon', type: 'integer', description: '规划代理一次计划的最多动作数（"接下来 n 次"）', suggestion: 3 },
-    { name: 'plannerEnabled', type: 'boolean', description: 'false = 完全走内置启发式调度（规划代理禁用）', suggestion: true },
-    { name: 'plannerProvider', type: 'string', description: '规划代理模型 provider（空 = 继承根代理）', suggestion: '' },
-    { name: 'plannerModel', type: 'string', description: '规划代理模型 id（空 = 继承根代理）', suggestion: '' },
-    { name: 'planMinIntervalMs', type: 'integer', description: '每一次规划调用的最小间隔（毫秒）；对**每一次**规划调用都生效（含空计划、含「空闲但仍有工作」，不再有空闲绕过）', suggestion: 30000 },
-    { name: 'plannerMaxFails', type: 'integer', description: '规划代理连续失败达此值 → 自动降级启发式', suggestion: 3 },
-    { name: 'methodKeepIntervalMs', type: 'integer', description: 'Method Keeper 定时整理间隔（0 = 事件驱动）', suggestion: 0 },
-    { name: 'methodKeepEvery', type: 'integer', description: '每积累 N 个待沉淀发明/新命题触发一次整理', suggestion: 5 },
-    { name: 'methodAutoPromote', type: 'boolean', description: '项目级方法自动晋升全局库（false = 人工门）', suggestion: false },
-    { name: 'indexAutoRebuild', type: 'boolean', description: '每次写盘后自动重建索引（false = 手动 vibe_math_index）', suggestion: true },
-    { name: 'projectLockTimeoutMs', type: 'integer', description: '项目锁等待超时（毫秒）', suggestion: 60000 },
-    { name: 'formalVerify', type: 'enum', options: ['off', 'encourage', 'require'], description: 'Lean 形式化验证：off = 不额外要求（默认，提示词里不出现任何 Lean 内容）；encourage = 鼓励按实现难度形式化，Lean 通过后验证转为忠实性审查；require = 同上并加门禁：真/假定论必须先达到 Lean 已通过 或 已记录显式阻塞原因，否则记为未定论（formal-required）并进「形式化待办」', suggestion: 'off' },
-    { name: 'leanCommand', type: 'string', description: 'Lean 可执行文件（例：lean / lake；配合 leanArgs=[env,lean] 用 lake）', suggestion: 'lean' },
-    { name: 'leanArgs', type: 'string[]', description: '插在 .lean 文件名之前的附加参数', suggestion: [] },
-    { name: 'leanTimeoutMs', type: 'integer', description: '单次 Lean 运行的超时上限（毫秒，非正数回退默认）；异步档下它同时是**每个后台作业**的预算（到时主动 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_job 公告（**只有作业落地为 ok 才会置 passed 并写归档证明**）；false = 完全同步 await（与旧行为逐字一致）', suggestion: true },
-    { name: 'leanJobsMaxParallel', type: 'integer', description: '后台 Lean 编译的并发上限（默认 1 = 串行，保持可预测的资源占用；调大可并行编译多个作业）', suggestion: 1 },
-    { name: 'leanInitiative', type: 'enum', options: ['off', 'normal', 'eager'], description: '日常流程中的形式化主动性：off（不主动，只在验证提示词按 formalVerify 的要求做）| normal（默认：顺手把有价值且可能复用的东西形式化）| eager（更主动：日常就主动把有价值的小引理/命题/定义形式化）。注意它与 formalVerify（验证时的要求强度：off|encourage|require）是**两件事**', suggestion: 'normal' },
-    { name: 'leanSearchPaths', type: 'string[]', description: '额外 Lean 搜索路径（默认空数组 = 只用框架自动注入的 VibeMath 根）。非空时按顺序先注入这里给的路径、再注入自动根（去重）；若 leanArgs 里已显式给了 --search-path/-R/--root，则完全尊重用户配置、不注入任何东西', suggestion: [] },
-    { name: 'finalPaper', type: 'boolean', description: '收口（checkTermination 的完整收口分支：无未解决问题、无待验证对象、无任务/计划/门）时自动撰写最终论文：派遣一名专职「论文撰写」子代理，把已定论命题/解法/方法整理成 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 优先）。解析不到时按"未检测到"降级', 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: 'enum', options: ['user', 'system'], description: '安装作用域：user（默认，用户级目录）；system 只对当次显式调用生效、永不记忆（不会写进状态文件）', suggestion: 'user' },
-  ]
 
   // ================= fs (adapted to DSH 0.1.1: resolve returns {targetKey, displayPath}) =================
   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 writeJson(rel, obj) { if (!assertWritable(rel)) return false; return await writeText(rel, JSON.stringify(obj, null, 2)) }
+  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 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 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
@@ -385,11 +470,11 @@ export function apply(ctx) {
   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() {
-    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 =================
@@ -443,8 +528,27 @@ export function apply(ctx) {
   // Progress_Logs/ 必须和别的骨架目录**一起**建出来（审计 L8）：vibe_math_report 会写
   // `Progress_Logs/report.json`，README 也把它列为布局的一部分，但此前它只靠 writeText 的隐式
   // mkdir 兜底——在宿主不支持删除/创建的路径上（runShell 失败）报告目录就时有时无。
-  async function ensureDirs() { const base = frameworkRoot(); const dirs = ['Problems', 'Progress', 'Progress_Logs', 'Propos', 'Methods', 'Verified/命题', 'Verified/问题', 'Verified/Lean', 'Formal', 'Formal/Jobs', 'Reliable', 'Notes', 'Logs/Verification', 'Logs/Plans', 'State', 'Computation']; const paths = [vibeRoot() + '/Projects', vibeRoot() + '/Methods', vibeRoot() + '/Formal/Lib', vibeRoot() + '/Formal/Proved'].concat(dirs.map(function (d) { return base + '/' + d })); return await runShell(mkdirCmd(paths)) }
-  async function removeFile(rel) { const base = frameworkRoot(); return await runShell(rmCmd(base + '/' + rel)) }
+  // F-4c：shell 兜底失败不能沉默（v2 有 warnShellOnce，v3 此前丢了 ⇒ mkdir/rm 失败无人知晓）。
+  const shellWarned = {}
+  function warnShellOnce(where, r) {
+    const why = (r && (r.error || (r.exitCode === undefined ? undefined : ('exit code ' + r.exitCode)))) || 'unknown failure'
+    const key = String(where) + '|' + why
+    if (shellWarned[key]) return
+    shellWarned[key] = true
+    console.error('vibe-math-v3: ' + where + ' failed (' + why + ')')
+  }
+  async function ensureDirs() {
+    const base = frameworkRoot(); const dirs = ['Problems', 'Progress', 'Progress_Logs', 'Propos', 'Methods', 'Verified/命题', 'Verified/问题', 'Verified/Lean', 'Formal', 'Formal/Jobs', 'Reliable', 'Notes', 'Logs/Verification', 'Logs/Plans', 'State', 'Computation']; const paths = [vibeRoot() + '/Projects', vibeRoot() + '/Methods', vibeRoot() + '/Formal/Lib', vibeRoot() + '/Formal/Proved'].concat(dirs.map(function (d) { return base + '/' + d })); return await runShell(mkdirCmd(paths))
+    const r = await runShell(mkdirCmd(paths))
+    if (!r || !r.ok) warnShellOnce('ensureDirs (mkdir ' + base + ')', r)
+    return r
+  }
+  async function removeFile(rel) {
+    const base = frameworkRoot()
+    const r = await runShell(rmCmd(base + '/' + rel))
+    if (!r || !r.ok) warnShellOnce('removeFile(' + rel + ')', r)
+    return r
+  }
 
   // ================= 数学计算 math_computation：会话侧接线（共享模块，FREEZE §4/§5） =================
   // 探测量（是否装了 python/r/…）是异步的，而提示词是同步构造的 ⇒ 会话级缓存 + TTL 刷新，
@@ -577,7 +681,7 @@ export function apply(ctx) {
   // ================= settings =================
   function sanitizeParams(obj) {
     const out = {}
-    const intFields = ['maxParallelThreshold', 'solverMaxRounds', 'directionsPerSolver', 'verifierCount', 'debateMaxRounds', 'solverMaxToolCalls', 'verifierMaxToolCalls', 'reportIntervalMs', 'tickIntervalMs', 'activityLogCap', 'maxExplorerRetries', 'planningHorizon', 'planMinIntervalMs', 'plannerMaxFails', 'methodKeepIntervalMs', 'methodKeepEvery', 'projectLockTimeoutMs']
+    const intFields = ['maxParallelThreshold', 'solverMaxRounds', 'directionsPerSolver', 'verifierCount', 'debateMaxRounds', 'solverMaxToolCalls', 'verifierMaxToolCalls', 'reportIntervalMs', 'tickIntervalMs', 'activityLogCap', 'maxExplorerRetries', 'planningHorizon', 'planMinIntervalMs', 'plannerMaxFails', 'methodKeepIntervalMs', 'methodKeepEvery', 'projectLockTimeoutMs', 'fileLockTimeoutMs']
     const numFields = ['promoteValueThreshold']
     const arrayFields = ['solverToolAllow', 'solverToolDeny', 'verifierToolAllow', 'verifierToolDeny', 'leanArgs']
     const boolFields = ['plannerEnabled', 'methodAutoPromote', 'indexAutoRebuild', 'finalPaper', 'paperCompilePdf', 'leanAsync']
@@ -918,6 +1022,7 @@ export function apply(ctx) {
       // 引理只在摘要给"索引"（id+标题），完整叙述在各方向文件 Progress/<qid>/<dirId>.md（由代理或调度器写入）
       if (d.lemmas && d.lemmas.length) { lines.push('**引理索引**：' + d.lemmas.map(function (l) { return '「' + l.title + '」(' + l.id + ')' }).join('；')) }
       lines.push('**完整叙述**：见 `Progress/' + qid + '/' + d.id + '.md`')
+    lines.push(PAPER_PATH_NOTE)
       for (const j of (d.journal || [])) {
         lines.push('')
         lines.push('### 第 ' + j.round + ' 轮｜' + (j.agent || '') + '｜' + (j.at || ''))
@@ -926,6 +1031,31 @@ export function apply(ctx) {
       lines.push('')
     }
     await writeText('Progress/' + qid + '.md', lines.join('\n').trimEnd() + '\n')
+    // 兜底（审计 F1）：聚合索引在上面用 `**完整叙述**：见 Progress/<qid>/<d.id>.md` 指向**逐方向**
+    // 研究日志。设计上这些文件由**代理**写（见 applyAgentWrites 的 Progress/<qid>/ 分支），但代理没写
+    // 时索引就会指向不存在的文件。这里补一份**调度器维护**的版本：`ensureProgressDir` 建目录、
+    // `directionMdText` 生成内容；带 scheduler-managed 标记的文件每轮刷新，**代理写的文件绝不动**。
+    // D6：只在**确实要写**时建目录（旧实现在每轮 writeJournal 开头无条件跑一次 shell mkdir，
+    // 即使所有方向文件都已存在且归代理所有）；宿主没有 subprocess 时直接跳过（writeText 仍会落盘），
+    // 这样无 shell 宿主的每一轮日志也不会留下一条 mkdir 失败记录。
+    let journalDirReady = false
+    for (const d of dirs) {
+      const rel = 'Progress/' + qid + '/' + d.id + '.md'
+      // 归属判定：带 `<!-- scheduler-managed -->` 首行的文件由**调度器**维护（每轮刷新）；
+      // 其它文件视为**代理**所有、绝不触碰（契约：聚合索引不覆盖各方向文件）。
+      let exists = false, owned = false
+      try {
+        const txt = await readText(rel)
+        exists = txt !== undefined
+        owned = exists && String(txt).indexOf('<!-- scheduler-managed -->') === 0
+      } catch (e) { exists = false; owned = false }
+      if (exists && !owned) continue
+      if (!journalDirReady) {
+        journalDirReady = true
+        try { if (subprocessOf()) await ensureProgressDir(qid) } catch (e) { /* 无 shell：不打扰这一轮 */ }
+      }
+      await writeText(rel, '<!-- scheduler-managed -->\n' + directionMdText(qid, d, true))
+    }
   }
   // 代理直接写内容：模拟/落盘代理声称写的文件（__writes），真实环境代理用 write 工具自己写，此处为调度器兜底落盘
   async function applyAgentWrites(writes) {
@@ -1055,10 +1185,87 @@ export function apply(ctx) {
    * 仍为 true、status 照常响应。计数还会写进 scheduler_state.json 一路带下去。
    */
   function activeCount() { return Object.keys(agentRegistry).length }
+  /** P2：状态提交的原子性 + 完整性标记。
+   *
+   *  可用能力只有 fs.resolve/stat/readText/writeText（**宿主没有 rename**）。所以提交协议是
+   *  「**暂存 → 回读校验 → 提交 → 标记**」：
+   *    1) 每个状态文件先写 `<rel>.tmp`，再回读确认**非空**（截断/失败写在这里就被抓住）；
+   *    2) 暂存成功才把它写进最终路径（`writeText(rel, …)`），失败则记入 `stateWriteFailures`；
+   *    3) 全部落地后**最后**写 `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('State/commit.json', commit)
+    stateCommit = Object.assign({ complete: missing.length === 0 }, commit)
+    return commit
+  }
   async function loadState() {
     const s = await readJson('State/scheduler_state.json')
     // 丢弃历史持久化的 activeCount：旧值可能已漂移，绝不能覆盖推导值。
     if (s) { const restored = Object.assign({}, s); delete restored.activeCount; scheduler = Object.assign({}, scheduler, restored) }
+    await loadCommitMarker()
+    // P5：活动日志回读（旧实现只落 report 快照且从不回读）
+    const al = await readJson('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('State/paper.json')
+    if (pj && typeof pj === 'object') { if (pj.pending) paperPending = pj.pending; paperReaps = Number(pj.reaps) || 0 }
+    if (paperInFlight) { logActivity('paper', '上一进程的在途撰写者 ' + paperInFlight + ' 不可恢复 ⇒ 交由 paper 锁/回收逻辑重新触发'); paperInFlight = ''; paperInFlightAt = 0 }
     const r = await readJson('State/agents.json'); if (r) agentRegistry = r
     const dq = await readJson('State/decision_queue.json'); if (dq) decisionQueue = dq
     const va = await readJson('State/verifier_accuracy.json'); if (va) verifierAccuracy = va
@@ -1085,22 +1292,43 @@ export function apply(ctx) {
       formalState = { records: clean, todo: Array.isArray(fm.todo) ? fm.todo.filter(function (t) { return t && t.id }) : [], libRuns: (fm.libRuns && typeof fm.libRuns === 'object') ? fm.libRuns : {} }
     }
   }
+  /** P2：恢复时校验上一次提交的完整性（标记列出但缺失/为空的状态文件 = 撕裂提交）。 */
+  async function loadCommitMarker() {
+    const cm = await readJson('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('State/scheduler_state.json', scheduler)
-    await writeJson('State/agents.json', agentRegistry)
-    await writeJson('State/decision_queue.json', decisionQueue)
-    await writeJson('State/verifier_accuracy.json', verifierAccuracy)
-    await writeJson('State/tasks.json', tasks)
-    await writeJson('State/explorer_retries.json', explorerRetries)
-    await writeJson('State/plans.json', { queued: planQueue, epoch: processEpoch })
-    await writeJson('State/method_log.json', methodLog)
-    await writeJson('State/project_lock.json', projectLock)
-    await writeJson('State/archived_journals.json', archivedJ)
-    // 未启用且从未产生任何形式化记录时不落这份状态文件（off 保持真正的无操作）。
-    if (formalOn() || Object.keys(formalState.records).length || formalState.todo.length || Object.keys(formalState.libRuns).length) await writeJson('State/formal.json', formalState)
-    if (lastPlanSummary) await writeJson('State/last_plan.json', lastPlanSummary)
+    // P2：checkpoint 先落内存再提交（旧顺序 ⇒ 磁盘 checkpoint 永远滞后一次）
     scheduler.lastCheckpoint = now()
-  }
+    const files = [
+      // P5：活动日志（有界）落盘；P6：论文排队/回收计数落盘
+      // 注：这里**没有** v2 的 pending_review_scores.json——v3 的"历史准确率"按稳定身份键直接累计、
+      // 没有"等对象后来取得布尔定论再回溯计分"的待计分表，因此它的缺席是**设计如此**，不是漏掉的产物。
+      { rel: 'State/activity_log.json', obj: activityLog.slice(-ACTIVITY_PERSIST_MAX) },
+      { rel: 'State/paper.json', obj: { pending: paperPending, reaps: paperReaps } },
+      { rel: 'State/scheduler_state.json', obj: scheduler },
+      { rel: 'State/agents.json', obj: agentRegistry },
+      { rel: 'State/decision_queue.json', obj: decisionQueue },
+      { rel: 'State/verifier_accuracy.json', obj: verifierAccuracy },
+      { rel: 'State/tasks.json', obj: tasks },
+      { rel: 'State/explorer_retries.json', obj: explorerRetries },
+      { rel: 'State/plans.json', obj: { queued: planQueue, epoch: processEpoch } },
+      { rel: 'State/method_log.json', obj: methodLog },
+      { rel: 'State/project_lock.json', obj: projectLock },
+      { rel: 'State/archived_journals.json', obj: archivedJ },
+    ]
+    if (formalOn() || Object.keys(formalState.records).length || formalState.todo.length || Object.keys(formalState.libRuns).length) files.push({ rel: 'State/formal.json', obj: formalState })
+    if (lastPlanSummary) files.push({ rel: 'State/last_plan.json', obj: lastPlanSummary })
+    await commitState(files)
+  }
+  // 未启用且从未产生任何形式化记录时不落这份状态文件（off 保持真正的无操作）。
   async function refreshParams() {
     params = Object.assign({}, DEFAULT_PARAMS)
     await loadSettings()
@@ -1122,20 +1350,24 @@ export function apply(ctx) {
   function logActivity(event, detail) { activityLog.push({ at: now(), event: event, detail: String(detail || '') }); const cap = Number(params.activityLogCap) || 100; if (activityLog.length > cap) activityLog.shift(); reportDirty = true }
   async function buildReport() {
     return {
-      ok: true, at: now(), project: currentProject, frameworkRoot: frameworkRoot(),
+      ok: true, at: now(), project: currentProject, projectExists: await projectExistsOnDisk(), frameworkRoot: frameworkRoot(),
       running: scheduler.running, mode: params.mode,
       activeCount: activeCount(), maxParallelThreshold: params.maxParallelThreshold,
       problems: { total: problems.size, solved: allProblems().filter(function (q) { return q.状态 === '已解决' }).length },
       propositions: { total: propos.size, resolved: allPropos().filter(function (p) { return p.概率 === 1 || p.概率 === 0 }).length },
       verifyPending: (await buildVerifyCandidates()).length,
       methods: { project: methods.size, global: globalMethods.size, pendingInventions: methodLog.pendingInventions.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,
       queuedPlanActions: planQueue.length,
-      recentActivity: activityLog.slice(-Math.min(30, Number(params.activityLogCap) || 100)),
+      recentActivity: activityLog.slice(-Math.min(ACTIVITY_REPORT_MAX, Number(params.activityLogCap) || 100)),
       // Lean 形式化：模式 + 每个对象的状态 + 形式化待办（可读参数表在 params 里）。
       formal: formalSummary(),
       params: params,
+      // F5：与 status 对齐，周期快照也能看到论文/编译状态。
+      paper: await paperStatusView(),
     }
   }
   async function maybeWriteReport(force) {
@@ -1152,7 +1384,7 @@ export function apply(ctx) {
     lines.push('# 项目进展报告｜' + currentProject + '｜' + fmtTime())
     lines.push('')
     lines.push('## 总览')
-    lines.push('- 运行中：' + scheduler.running + '；活跃子代理：' + activeCount() + '/' + params.maxParallelThreshold)
+    lines.push('- 运行中：' + (scheduler.running ? '是' : '否') + '；活跃子代理：' + activeCount() + '/' + params.maxParallelThreshold)
     lines.push('- 问题：' + allProblems().filter(function (q) { return q.状态 === '已解决' }).length + '/' + problems.size + ' 已解决；命题：' + allPropos().filter(function (p) { return p.概率 === 1 || p.概率 === 0 }).length + '/' + propos.size + ' 已定论')
     lines.push('- 方法库：项目 ' + methods.size + ' 条，全局 ' + globalMethods.size + ' 条，待沉淀发明 ' + methodLog.pendingInventions.length + ' 条')
     lines.push('- 待执行计划动作：' + planQueue.length + ' 条；待人工决策：' + decisionQueue.filter(function (d) { return d.status === 'pending' }).length + ' 条')
@@ -1160,7 +1392,9 @@ export function apply(ctx) {
     lines.push('## 问题状态')
     for (const q of allProblems()) {
       const dirs = getDirState(q.id)
-      const dirInfo = dirs.length ? '（方向：' + dirs.map(function (d) { return d.id + ':' + d.status }).join(', ') + '）' : ''
+      // F7：人读报告不把裸代码状态拼进中文；中文化后把代码放括号里备查。
+    const DIR_STATUS_ZH = { active: '进行中', 'dead-end': '死路', success: '已成功', queued: '排队中' }
+    const dirInfo = dirs.length ? '（方向：' + dirs.map(function (d) { return d.id + ':' + (DIR_STATUS_ZH[d.status] || d.status) + '(' + d.status + ')' }).join(', ') + '）' : ''
       lines.push('- **' + q.id + '**：' + q.状态 + '，优先级 ' + q.优先级 + '，解法 ' + (q.solutions || []).length + ' 条' + dirInfo)
     }
     lines.push('')
@@ -1190,10 +1424,10 @@ export function apply(ctx) {
     if (!rootAgent || typeof rootAgent.followup !== 'function') return
     try {
       const report = await buildReport()
-      const text = '[Vibe Math V3] 进度更新：项目 "' + currentProject + '" 运行中=' + report.running +
+      const text = '[Vibe Math V3] 进度更新：项目 "' + currentProject + '" 运行中=' + (report.running ? '是' : '否') +
         '，问题 ' + report.problems.solved + '/' + report.problems.total + ' 已解决，命题 ' + report.propositions.resolved + '/' + report.propositions.total + ' 已定论，' +
-        '活跃代理轮数=' + report.activeCount + '，待人工决策=' + report.pendingDecisions.length + '，待执行计划=' + report.queuedPlanActions + '。' +
-        '请调用 vibe_math_report 汇总当前进展及各代理状态，并用人话简要汇报（不打断用户，简短即可）。'
+        '活跃代理轮数=' + report.activeCount + '，待人工决策=' + report.pendingDecisions + '，待执行计划=' + report.queuedPlanActions + '。' +
+        '请调用 vibe_math_report 汇总当前进展，并用 vibe_math_list_agents 取各代理（id/角色/目标）状态，再用人话简要汇报（不打断用户，简短即可）。'
       // 来源 kind 必须是**已声明**的：`MessageSourceMap` 是 merge-extensible 联合，但没有共享的
       // catch-all `plugin` kind（审计 L5/dsh-llm message.d.ts），{kind:'plugin'} 是契约外形状。
       // role 本来就是 'user'，正文自带 "[Vibe Math V3] 进度更新" 的真署名，故用核心声明的 {kind:'user'}。
@@ -1205,7 +1439,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-v3: 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(role) {
     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) {}
@@ -1225,11 +1466,8 @@ 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']
   // 'web_fetch' is only registered when the composition enables fetch (the v4
   // preset sets `fetch: false`), so it is a candidate that sanitizeToolFilter drops.
-  const NETWORK_TOOLS = ['web_search', 'web_fetch']
   /**
    * Drop filter names this host does not register. `known` comes from the host's
    * own rejection message, which lists every registered global tool, so this
@@ -1309,7 +1547,28 @@ export function apply(ctx) {
     // 并发计数由 agentRegistry 推导，无需手工 +1。
     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 personaText(key) { return params[key] ? (String(params[key]) + '\n\n') : '' }
@@ -1524,14 +1783,16 @@ export function apply(ctx) {
   function plannerPrompt(brief) {
     return personaText('plannerPersona') + 'You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT ' + params.planningHorizon + ' agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).\n\n' +
       'CURRENT STATE BRIEF (JSON):\n' + JSON.stringify(brief, null, 2) + '\n\n' +
-      'ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):\n' +
+      'ACTION VOCABULARY — the code ACCEPTS exactly these 6 actions: spawn / interrupt / promote are HARD-VALIDATED (invalid ones are dropped), while wait / continue / stop are ADVISORY ONLY (they are logged and have NO scheduling effect):\n' +
       '- {"action":"spawn","role":"explorer","target":"<qid>","reason":"..."} — problem has no directions yet or all dead (re-derive).\n' +
       '- {"action":"spawn","role":"solver","target":"<qid>","direction":"<dirId>","reason":"..."} — active direction, needs a solving round.\n' +
       '- {"action":"spawn","role":"verifier","target":"<rId>","reason":"..."} — verify candidate (from verify_candidates); keep solving AND verifying balanced.\n' +
       '- {"action":"spawn","role":"method-keeper","reason":"..."} — distill pending inventions / maintain the theory library.\n' +
       '- {"action":"interrupt","childId":"<childId>","reason":"..."} — stop a running child (direction dead, superseded...).\n' +
       '- {"action":"promote","target":"<pId>","reason":"..."} — high-value unresolved proposition → judge problem.\n' +
-      '- {"action":"wait","target":"<id>","reason":"..."} — advisory: wait for a dependency.\n' +
+      '- {"action":"wait","target":"<id>","reason":"..."} — advisory only (logged; no scheduling effect): you are waiting for a dependency.\n' +
+      '- {"action":"continue","childId":"<childId>","reason":"..."} — advisory only (logged): continuation of an in-flight child is code-driven; this never re-dispatches anything.\n' +
+      '- {"action":"stop","childId":"<childId>","reason":"..."} — advisory only (logged; it does NOT stop anyone). To actually stop a child use `interrupt` with a live childId.\n' +
       '\nHARD RULES: never re-schedule verified objects; problems with 依赖未就绪 (依赖就绪=false) should wait unless you explicitly accept a temporary assumption; respect capacity (brief.free_slots); PREFER problems whose dependencies are ready and whose directions have the highest survival; DO NOT forget verification — unresolved solutions/proofs/refutations (verify_candidates) will never be checked unless you schedule a verifier; DO NOT assume a direction is already being worked just because it is shown "active" in a problem — check brief.problems[].running_solver_dirs and brief.active_agents: schedule a solver for a direction ONLY if that direction is NOT in running_solver_dirs (an "active" direction absent from running_solver_dirs is WAITING to be dispatched, not being worked); schedule at most ' + params.planningHorizon + ' actions.\n' +
       'Respond with ONLY a single JSON object wrapped in a ```json code fence — no prose:\n' +
       '{"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}'
@@ -1546,7 +1807,7 @@ export function apply(ctx) {
       mathWorkLine() +
       (formalWorkLine() + (formalOn() ? '\n【方法沉淀 × Lean 形式化】除了方法卡，你沉淀的每个可复用对象 / 定义 / 假设都应当归档到全局 Lean 库（vibe_math_lean_archive kind=\'def\'），已成立的引理归档到 Proved/（kind=\'lemma\'）；归档时**连同定义与陈述一起写清**，方便后续直接 import。\n' : '')) +
       'OUTPUT CONTRACT — pick ONE channel. Write method cards into Markdown; only the created IDs, which cards were used, and improvements cross the machine reply.\n' +
-      'CHANNEL A (recommended, you can write files): write each method card into `Methods/<m-id>.md` (`# 方法｜标题` + `- 标题/ID/类型/状态/可信断言/适用场景` + `## 核心内容`/`## 应用记录`/`## 改进历史`), then reply ONLY this metadata:\n' +
+      'CHANNEL A (recommended, you can write files): write each method card into `Methods/<m-id>.md` — the `<m-id>` in the FILE NAME must be EXACTLY the id you list in `created`（调度器按 `created` 里的 id 去 `Methods/<id>.md` 找卡；不一致会被当成"已沉淀"而实际没有卡）(`# 方法｜标题` + `- 标题/ID/类型/状态/可信断言/适用场景` + `## 核心内容`/`## 应用记录`/`## 改进历史`), then reply ONLY this metadata:\n' +
       '{"meta":{"kind":"methods","used":[{"id":"m-...","效果":"...","建议":"..."}],"created":["m-xxx"],"improvements":[{"id":"m-...","改进内容":"...","原因":"..."}]}}\n' +
       'CHANNEL B (your file tools are unavailable): put the method-card content into __writes and carry the same meta:\n' +
       '{"__writes":[{"path":"Methods/<m-id>.md","content":"<# 方法｜标题 + 锚点 + ## 核心内容... 完整卡面>"}],"meta":{"kind":"methods","used":[...],"created":["m-xxx"],"improvements":[...]}}'
@@ -1625,7 +1886,10 @@ export function apply(ctx) {
     }
     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' } }
 
   // ================= scheduler core =================
   function scheduleTick() { tick().catch(function (e) { console.error('vibe-math-v3 tick error: ' + String((e && e.stack) || e)) }) }
@@ -1877,7 +2141,7 @@ export function apply(ctx) {
     return true
   }
   async function backfillVerifiers(t) {
-    while (t.children.length < t.expectedCount) {
+    while (t.children.length < voteCount(t).expected) {
       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 })
@@ -1891,7 +2155,7 @@ export function apply(ctx) {
       const t = tasks[ids[i]]
       if (t.type !== 'verify') 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).quorum
         if (allReported) { t.status = 'debating'; await advanceVerification(t, t.round); continue }
       }
       if (t.status !== 'spawning') continue
@@ -2334,6 +2598,21 @@ export function apply(ctx) {
     await saveDirState(); await writeJournal(qid)
   }
   function statusFromStop(stopReason) { return (stopReason === 'completed' || stopReason === 'max-tokens') ? 'continue' : 'dead-end' }
+  /**
+   * P1：`add_proposition`/`/vibe add-proposition` 只用于**新建**。id 已存在时**拒绝**，绝不覆盖——
+   * 旧实现 `propos.set(id, p)` + `saveProposition(p)` 会把已有卡的 陈述/证明列表/证伪列表 整条换掉
+   * （静默丢数据）。自动路径（sync_meta 的引理）本来就有 `propos.has` + 文件存在双守卫，这里拉齐语义。
+   */
+  function propositionIdConflict(id) {
+    const hit = propos.get(id)
+    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.概率, 状态: hit.状态 },
+    }
+  }
   async function addLemmaAsProposition(qid, lemma) {
     if (!lemma || !lemma.title) return
     // M11：`prob`（提示词名）与 `布尔估计`（遗留扁平名）都接受；`分类` 与 `细类型` 同理。
@@ -2341,7 +2620,7 @@ export function apply(ctx) {
     let be = clamp01(rawProb != null ? rawProb : 0.6)
     if (be >= 1) be = 0.99; else if (be <= 0) be = 0.01
     const p = {
-      id: 'p-' + shortId(), 标题: lemma.title, 状态: '未定论', 概率: be,
+      id: 'p-' + shortIdUnique(function (x) { return propos.has(x) }), 标题: lemma.title, 状态: '未定论', 概率: be,
       优先级: (lemma.优先级 != null) ? lemma.优先级 : 1, 依赖: [], 价值关键性: clamp01(lemma['价值/关键性'] != null ? lemma['价值/关键性'] : 0.5),
       分类: categoryOf({ 分类: lemmaCategory(lemma) || '未分类' }),
       陈述: lemma.statement || lemma.title,
@@ -3756,16 +4035,36 @@ export function apply(ctx) {
    * 下限取 max(2, expectedCount)：verifierCount=1 不是"允许单票"，只是"至少 2 个独立验证器"
    * （与 createVerifyTask 的 `Math.max(2, ...)` 一致）。
    */
-  function minVotes(t) { return Math.max(2, Number(t && t.expectedCount) || 0, Number(params.verifierCount) || 0) }
-  function haveEnoughVotes(t) { return Object.keys(t.childResults).length >= minVotes(t) }
+  /**
+   * 票数/参与集的**单一来源**（审计 D4）。一个 verify 任务的参与集与"需要几票"只由**创建时的快照**
+   * `t.expectedCount`（createVerifyTask 写入）与当前 round 决定——**绝不**读实时 `params.verifierCount`
+   * 或实时名册：否则同一个计数会在 quorum 判据 / 裁决聚合 / 任务簿记之间给出不同答案，中途调参会让
+   * 已经在进行中的表决永远凑不够票数而卡死（守卫见 formal-verify-v3 §5c）。
+   */
+  function voteCount(t, round) {
+    const tt = t || {}
+    const expected = Math.max(2, 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,
+      quorum: participants.length > 0 && participants.length >= expected && thisRoundIds.length === participants.length,
+    }
+  }
+  function minVotes(t) { return voteCount(t).expected } // 快照值；**故意**不读实时 params.verifierCount
+  function haveEnoughVotes(t) { const v = voteCount(t); return v.reported >= minVotes(t) } // 单一来源：minVotes 也只读快照
   /** 所有已派出的验证器都报了本轮的票，**且**票数达到下限——否则不得推进/裁决。 */
   function allReportedWithQuorum(t, round) {
-    if (!t || !Array.isArray(t.children) || t.children.length === 0) return false
-    if (t.children.length < Math.max(2, Number(t.expectedCount) || 0)) return false
-    return t.children.every(function (cid) { const r = t.childResults[cid]; return r && r.round === round })
+    const v = voteCount(t, round)
+    return v.dispatched > 0 && v.dispatched >= v.expected && v.quorum
   }
-  function consensus(t) { const vs = Object.keys(t.childResults).map(function (cid) { return t.childResults[cid].Result }); if (vs.length === 0) return false; 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 vs = voteCount(t).reportedIds.map(function (cid) { return t.childResults[cid].Result }); if (vs.length === 0) return false; 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]]; 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') }
   async function handleVerifier(childId, meta, output, stopReason) {
     const rId = meta.rId
     const parsed = parseJson(output)
@@ -3784,7 +4083,7 @@ 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 }
+    t.childResults[childId] = { Result: Result, Reason: Reason, round: meta.round, changed: (parsed && parsed.changed != null && String(parsed.changed).trim()) ? String(parsed.changed).trim() : null }
     delete agentRegistry[childId]
     // H5：推进/裁决的前置条件是"已凑齐下限票数且本轮都已回报"，不是"目前存在的那几个孩子都报了"。
     // 未凑齐时保持 spawning，由 reconcileVerify 在后续 tick 里补派验证器（不裁决、不定论）。
@@ -3838,7 +4137,7 @@ export function apply(ctx) {
   }
   // 近共识 + forced/flat 裁决（修复 v2 flat 高置信分歧误判：全部同侧且均值≥0.85/≤0.15 取均值）
   function finalVerdict(t) {
-    const rs = Object.keys(t.childResults).map(function (cid) { return t.childResults[cid] })
+    const rs = voteCount(t).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
@@ -3877,7 +4176,7 @@ export function apply(ctx) {
       verifierAccuracy[cids[i]] = acc
     }
     pruneVerifierAccuracy()
-    await writeJson('Logs/Verification/' + t.rId + '_' + Date.now() + '.json', { r: r, verdict: v, results: t.childResults, transcript: buildTranscript(t), history: t.history || [], at: now() })
+    await writeJson('Logs/Verification/' + t.rId + '_' + Date.now() + '_' + shortId() + '.json', { r: r, verdict: v, results: t.childResults, transcript: buildTranscript(t), history: t.history || [], at: now() })
     // ── require 门禁（契约 §8）────────────────────────────────────────────────
     // 判定为真（严格证明）或假（严格反驳）之前必须先有 `passed` 或 `blocked`。门禁放在**改
     // 对象之前**：不这样就改写不出"不改变对象的既有权重/概率字段"（一旦先把 概率 写成 1，
@@ -4036,7 +4335,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
     }
@@ -4053,6 +4352,12 @@ export function apply(ctx) {
   /** 证据索引（spec §3.9）：只列**确实存在**的文件；排除 Paper/ 自己（避免自我污染）。
    *  formalVerify=off 必须真的是无操作（formal-verify-v3 的语料守卫断言"off 的提示词里零 Lean 文本"），
    *  所以 off 档不把形式化路径写进材料。 */
+  /**
+   * 成员可见路径说明（跨预设审计 P0）。成员/子代理的**文件工具按会话 cwd 解析**相对路径，而下面列出的
+   * 路径都是**项目根相对**的 ⇒ 必须显式说明"先拼绝对前缀"；计算产物用回执里的绝对字段。一处常量、
+   * 五处材料文本各自 append（绝不替换既有行）。
+   */
+  const PAPER_PATH_NOTE = '（路径说明：成员/子代理的文件工具按**会话 cwd** 解析相对路径，因此上面列出的相对路径都必须先拼上**项目根的绝对前缀**再使用；计算产物请用回执里的绝对字段 `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来。）'
   async function paperEvidenceIndex() {
     const formalNow = formalOn()
     const out = []
@@ -4061,6 +4366,9 @@ export function apply(ctx) {
     for (const p of allProblems()) out.push(problemRel(p))
     for (const p of allPropos()) out.push(propositionRel(p))
     for (const m of methods.values()) out.push(methodRel(m, false))
+    // 审计 F2（v3 同型）：Reliable/ 是用户提供的可信参考层，材料证据索引必须收它，
+    // 否则被引用/被要求给出处的来源进不了论文材料。
+    for (const f of await listFiles('Reliable')) out.push('Reliable/' + f)
     const dirs = ['Verified/命题', 'Verified/问题', 'Logs/Verification', 'Logs/Plans', 'Progress'].concat(formalNow ? ['Verified/Lean', '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]) }
     const seen = {}, uniq = []
@@ -4088,6 +4396,7 @@ export function apply(ctx) {
     const ps = allPropos()
     L.push('')
     L.push('[PROPOSITIONS] (Propos/<分类>/<id>.md)')
+    L.push(PAPER_PATH_NOTE)
     if (ps.length === 0) L.push('- (none)')
     for (let i = 0; i < ps.length; i++) {
       const p = ps[i]
@@ -4098,6 +4407,7 @@ export function apply(ctx) {
     }
     L.push('')
     L.push('[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)')
+    L.push(PAPER_PATH_NOTE)
     const ms = Array.from(methods.values()).concat(Array.from(globalMethods.values()))
     if (ms.length === 0) L.push('- (none)')
     for (let i = 0; i < ms.length; i++) {
@@ -4484,7 +4794,7 @@ export function apply(ctx) {
     const prevEpoch = await readJson('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 = {}
@@ -4551,7 +4861,7 @@ export function apply(ctx) {
   async function startScheduler(override) { const r = await init(true); if (!r.ok) return r; const lock = await acquireProjectLock(override === true); if (!lock.ok) return lock; scheduler.running = true; scheduler.startedAt = now(); scheduler.gate = null; logActivity('start', 'scheduler started for project ' + currentProject + '（v3：md 知识库 + 规划代理调度 + 方法库）'); await saveAll(); await maybeWriteReport(true); scheduleTick(); return { ok: true, message: 'scheduler started', project: currentProject, frameworkRoot: frameworkRoot() } }
   async function resumeScheduler(override) { const r = await init(false); if (!r.ok) return r; const lock = await acquireProjectLock(override === true); if (!lock.ok) return lock; scheduler.running = true; scheduler.gate = null; 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; await releaseProjectLock(); logActivity('pause', 'scheduler paused'); await saveAll(); return { ok: true, message: 'scheduler paused' } }
-  async function abortScheduler() { scheduler.running = false; const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptChild(ids[i]); agentRegistry = {}; planQueue = []; paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0; paperPending = null; await releaseProjectLock(); 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; const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptTraced(ids[i], 'batch clear (start/abort)'); agentRegistry = {}; planQueue = []; paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0; paperPending = null; await releaseProjectLock(); logActivity('abort', 'scheduler aborted, ' + ids.length + ' child(ren) interrupted'); await saveAll(); return { ok: true, message: 'scheduler aborted', interrupted: ids.length } }
   async function autoResolvePending() {
     const pending = decisionQueue.filter(function (d) { return d.status === 'pending' })
     for (let i = 0; i < pending.length; i++) {
@@ -4572,10 +4882,16 @@ 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（v3 同型）：`project` 是**当前会话**的项目名，`projects` 是磁盘上已存在的 slug 列表；
+   *  两者不闭合时（新会话 project='default' 而磁盘上没有该目录）语义必须显式，不能靠调用方猜。 */
+  async function projectExistsOnDisk() { return (await listDirsAt(vibeRoot(), 'Projects')).indexOf(currentProject) !== -1 }
   async function getStatus() {
     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: problems.size, solved: allProblems().filter(function (q) { return q.状态 === '已解决' }).length },
@@ -4587,8 +4903,14 @@ export function apply(ctx) {
       queuedPlanActions: planQueue.length,
       plannerEnabled: params.plannerEnabled, plannerFails: plannerFails,
       formal: formalSummary(),
-      recentActivity: activityLog.slice(-Math.min(10, Number(params.activityLogCap) || 100)), params: params,
+      recentActivity: activityLog.slice(-Math.min(ACTIVITY_REPORT_MAX, Number(params.activityLogCap) || 100)), params: params,
       // 最终论文的可观测面（spec §2/§6）。
+      // F3（对照 v5 的 leanNoticesScope/fieldScopes）：逐组标注会话内存 vs 耐久来源。
+      fieldScopes: {
+        durable: ['project', 'projects', 'problems', 'propositions', 'stateCommit', 'formal', 'methods.project', 'methods.global', 'paper.finalizedAt', 'paper.artifacts', 'paper.compile'],
+        session: ['stateWriteFailures', 'activeCount', 'pendingDecisions', 'registeredAgents', 'verifyPending', 'queuedPlanActions', 'plannerFails', 'methods.pendingInventions', 'recentActivity', 'paper.inFlight', 'paper.inFlightSince', 'paper.inFlightAgeMs', 'paper.reapedThisRun', 'paper.queued'],
+        note: 'session = 本进程内存，重启后归零（看着永远健康是假象）；durable = 落在项目树里（State/Formal/Progress/Verified 等），重启后仍在',
+      },
       paper: await paperStatusView(),
     }
   }
@@ -4678,7 +5000,7 @@ export function apply(ctx) {
   registerTool('vibe_math_status', TOOL_DESC.vibe_math_status, objParams({}), async function () { await refreshParams(); return await getStatus() })
   registerTool('vibe_math_report', TOOL_DESC.vibe_math_report, objParams({}), async function () { await refreshParams(); await maybeWriteReport(true); return await buildReport() })
   registerTool('vibe_math_set_mode', TOOL_DESC.vibe_math_set_mode, 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', TOOL_DESC.vibe_math_set_params, objParams({ mode: { type: 'string', enum: ['manual', 'auto'] }, 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' }, plannerPersona: { type: 'string' }, methodKeeperPersona: { 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: { type: 'boolean' }, verifierAllowNetwork: { type: 'boolean' }, solverAllowScripts: { type: 'boolean' }, verifierAllowScripts: { type: 'boolean' }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, planningHorizon: { type: 'integer' }, plannerEnabled: { type: 'boolean' }, plannerProvider: { type: 'string' }, plannerModel: { type: 'string' }, planMinIntervalMs: { type: 'integer' }, plannerMaxFails: { type: 'integer' }, methodKeepIntervalMs: { type: 'integer' }, methodKeepEvery: { type: 'integer' }, methodAutoPromote: { type: 'boolean' }, indexAutoRebuild: { type: 'boolean' }, projectLockTimeoutMs: { 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', TOOL_DESC.vibe_math_set_params, 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', TOOL_DESC.vibe_math_setup, 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', TOOL_DESC.vibe_math_save_settings, objParams({}), async function () { return await saveSettings() })
   registerTool('vibe_math_template', TOOL_DESC.vibe_math_template, objParams({ where: { type: 'string', enum: ['global', 'project'] } }), async function (args) { return await createTemplate((args && args.where) || 'global') })
@@ -4687,7 +5009,7 @@ export function apply(ctx) {
     // M9：内存键、对象 id、文件名必须是**同一个**归一化 id。此前内存键用原始 id、文件名用
     // idSafe(id)、重载键又来自文件名 ⇒ 同一个对象分裂成两个身份（`p-1/2` 与 `p-1-2`）。
     const id = idSafe(args.id)
-    if (propos.has(id)) return { ok: false, message: 'proposition id already exists' }
+    if (propos.has(id)) { const cf = propositionIdConflict(id); logActivity('proposition', '拒绝覆盖已有命题：' + id); return Object.assign({ ok: false }, cf) }
     const p = { id: id, 标题: id, 状态: '未定论', 概率: clamp01(args.概率 != null ? args.概率 : 0.5), 优先级: (args.优先级 != null) ? args.优先级 : 1, 依赖: [], 价值关键性: clamp01(args['价值/关键性'] != null ? args['价值/关键性'] : 0.5), 分类: args.分类 || '未分类', 陈述: String(args.概述 == null ? '' : args.概述), proofs: [], refutes: [], 来源问题: String(args.来源问题 || ''), 来源方向: String(args.来源方向 || ''), 在问题清单: false }
     propos.set(p.id, p); await saveProposition(p); await rebuildIndex(); scheduleTick(); return { ok: true, proposition: p, file: propositionRel(p) }
   })
@@ -4696,10 +5018,10 @@ export function apply(ctx) {
   registerTool('vibe_math_set_project', TOOL_DESC.vibe_math_set_project, objParams({ name: { type: 'string' } }, ['name']), async function (args) { const slug = slugify(args.name); return await setProject(slug, false) })
   registerTool('vibe_math_list_projects', TOOL_DESC.vibe_math_list_projects, objParams({}), async function () { return { ok: true, current: currentProject, projects: await listDirsAt(vibeRoot(), 'Projects') } })
   registerTool('vibe_math_list_decisions', TOOL_DESC.vibe_math_list_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', TOOL_DESC.vibe_math_decide, 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', TOOL_DESC.vibe_math_decide, 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', TOOL_DESC.vibe_math_list_agents, 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', TOOL_DESC.vibe_math_message_agent, 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', TOOL_DESC.vibe_math_interrupt_agent, objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { await interruptChild(args.childId); return { ok: true, message: 'interrupt requested' } })
+  registerTool('vibe_math_interrupt_agent', TOOL_DESC.vibe_math_interrupt_agent, objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { const r = await interruptChild(args.childId); return Object.assign({}, r, { ok: !!(r && r.ok) }) })
   registerTool('vibe_math_plan', TOOL_DESC.vibe_math_plan, objParams({ force: { type: 'boolean' } }), async function (args) { if (args && args.force && scheduler.running && !scheduler.gate) { await callPlanner(); return { ok: true, message: 'planning triggered', queued: planQueue.length } } return { ok: true, queued: planQueue, lastPlan: lastPlanSummary } })
   registerTool('vibe_math_index', TOOL_DESC.vibe_math_index, objParams({}), async function () { await loadKnowledgeBase(); const r = await rebuildIndex(); return { ok: true, index: r, project: currentProject } })
   registerTool('vibe_math_method_add', TOOL_DESC.vibe_math_method_add, objParams({ id: { type: 'string' }, 标题: { type: 'string' }, 类型: { type: 'string' }, 核心内容: { type: 'string' }, 适用场景: { type: 'string' } }, ['id', '标题']), async function (args) { const id = idSafe(args.id); if (methods.has(id)) return { ok: false, message: 'method id already exists' }; const m = { id: id, 标题: args.标题, 类型: args.类型 || '方法', 状态: '经验', 可信断言: [], 上级体系: [], 子方法: [], 相关: [], 适用场景: args.适用场景 || '', 核心内容: args.核心内容 || '', 定义与记号: '', applications: [], improvements: [], 来源: 'user' }; methods.set(m.id, m); await saveMethod(m, false); await rebuildIndex(); return { ok: true, method: m, file: methodRel(m, false) } })
@@ -4751,13 +5073,34 @@ export function apply(ctx) {
   function fileLockKey(target) {
     return String(target || '').replace(/\\/g, '/')
   }
+  /** 文件写锁的租约时长（审计 D2）：与项目锁同型——**持有者活着就续租**，持有者消失后最多这么久失效。
+   *  旧实现只在 claim 时写一次 `at`、判定窗口固定 60s 且全仓没有续租点：成员写一份大文件超过 60s 后，
+   *  另一个成员可以合法抢锁（锁恰好在它最该起作用的场景失效）。 */
+  function fileLockTtl() { return Math.max(1000, Number(params.fileLockTimeoutMs) || 60000) }
+  function fileLockDue() { return Math.max(250, fileLockTtl() / 4) }
+  function fileLockHolderAlive(id) {
+    const cid = String(id || '')
+    if (!cid || cid === 'scheduler') return true
+    if (agentRegistry[cid]) return true
+    try { return String((rootAgent && rootAgent.id) || '') === cid } catch (e) { return false }
+  }
+  /** 每次锁轮询（LOCK_POLL_MS）里与 renewProjectLock 一同执行：只续租**活着**的持有者。 */
+  async function renewFileLocks() {
+    const ids = Object.keys(fileOwner)
+    for (let i = 0; i < ids.length; i++) {
+      const o = fileOwner[ids[i]]
+      if (!o) continue
+      if (!fileLockHolderAlive(o.childId)) continue // 持有者已消失 ⇒ 让租约自然过期（有界接管）
+      if ((now() - (Number(o.at) || 0)) >= fileLockDue()) o.at = now()
+    }
+  }
   async function claimWrite(target, agent) {
     const childId = (agent && agent.id) ? String(agent.id) : 'scheduler'
     const key = String(target || '').replace(/\\/g, '/')
     if (!key) return { ok: false, message: 'target required' }
     const lockKey = fileLockKey(key)
     const owner = fileOwner[lockKey]
-    if (owner && owner.childId !== childId && (now() - (owner.at || 0)) < 60000) {
+    if (owner && owner.childId !== childId && (now() - (owner.at || 0)) < fileLockTtl()) {
       return { ok: false, busy: owner.childId, message: '文件 "' + key + '" 正被其他代理写入，请稍后（写锁）' }
     }
     // 确保目标父目录存在（如 Progress/<qid>/ 供方向文件写入）
@@ -4931,7 +5274,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 raw = args[0]; const desc = args.slice(1).join(' '); if (!raw || !desc) return { ok: false, message: 'usage: /vibe add <id> <description>' }; const id = idSafe(raw); if (problems.has(id)) return { ok: false, message: 'problem id already exists' }; problems.set(id, { id: id, 标题: id, 状态: '求解中', 优先级: 0, 依赖: [], 被依赖: [], 来源: '原始', 计划: '待调度', 陈述: desc, 来源与动机: '', solutions: [], 判断命题: '', 来源命题: '' }); await saveProblem(problems.get(id)); await rebuildIndex(); scheduleTick(); return { ok: true, message: 'problem added', file: problemRel(problems.get(id)) } }
-    if (cmd === 'add-proposition') { const raw = args[0]; const desc = args.slice(1).join(' '); if (!raw || !desc) return { ok: false, message: 'usage: /vibe add-proposition <id> <概述>' }; const id = idSafe(raw); const p = { id: id, 标题: id, 状态: '未定论', 概率: 0.5, 优先级: 1, 依赖: [], 价值关键性: 0.5, 分类: '未分类', 陈述: desc, proofs: [], refutes: [], 来源问题: '', 在问题清单: false }; propos.set(p.id, p); await saveProposition(p); await rebuildIndex(); scheduleTick(); return { ok: true, proposition: p, file: propositionRel(p) } }
+    if (cmd === 'add-proposition') { const raw = args[0]; const desc = args.slice(1).join(' '); if (!raw || !desc) return { ok: false, message: 'usage: /vibe add-proposition <id> <概述>' }; const id = idSafe(raw); const p1c = propositionIdConflict(id); if (p1c) { logActivity('proposition', '拒绝覆盖已有命题：' + id); return Object.assign({ ok: false }, p1c) } const p = { id: id, 标题: id, 状态: '未定论', 概率: 0.5, 优先级: 1, 依赖: [], 价值关键性: 0.5, 分类: '未分类', 陈述: desc, proofs: [], refutes: [], 来源问题: '', 在问题清单: false }; propos.set(p.id, p); await saveProposition(p); await rebuildIndex(); scheduleTick(); return { ok: true, proposition: p, file: propositionRel(p) } }
     if (cmd === 'list-propositions') { const all = allPropos(); return { ok: true, count: all.length, propositions: all.map(function (p) { return { id: p.id, 标题: p.标题, 概率: p.概率, 状态: p.状态, 优先级: p.优先级, 分类: categoryOf(p) } }) } }
     if (cmd === 'methods') { const all = Array.from(methods.values()); return { ok: true, count: all.length, methods: all.map(function (m) { return { id: m.id, 标题: m.标题, 类型: m.类型, 状态: m.状态 } }) } }
     if (cmd === 'index') { await loadKnowledgeBase(); return await rebuildIndex() }
@@ -4960,7 +5303,7 @@ export function apply(ctx) {
     scheduleTick: scheduleTick,
     // Lease renewal for the apply-scope interval (see the ctx.effect below). Kept on the session so
     // the timer needs no per-session context, and so a mock host WITHOUT ctx.timeout still renews.
-    renewLockIfDue: renewProjectLock,
+    renewLockIfDue: async function () { await renewProjectLock(); await renewFileLocks() },
     onChildEnd: onChildEnd,
     dispatchVibeCommand: dispatchVibeCommand,
     handlers: handlers,
@@ -4979,10 +5322,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,
     // childOwner 裁剪用（审计 L1）：这个会话当前仍"可能再发 subagent/end"的 child
     // = 在册子代理 + 任何任务正在等的那几个。
     referencedChildIds: function () {
@@ -5021,7 +5360,7 @@ export function apply(ctx) {
   registerTool('vibe_math_status', TOOL_DESC.vibe_math_status, objParams({}), 'vibe_math_status')
   registerTool('vibe_math_report', TOOL_DESC.vibe_math_report, objParams({}), 'vibe_math_report')
   registerTool('vibe_math_set_mode', TOOL_DESC.vibe_math_set_mode, objParams({ mode: { type: 'string', enum: ['manual', 'auto'] } }, ['mode']), 'vibe_math_set_mode')
-  registerTool('vibe_math_set_params', TOOL_DESC.vibe_math_set_params, objParams({ mode: { type: 'string', enum: ['manual', 'auto'] }, 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' }, plannerPersona: { type: 'string' }, methodKeeperPersona: { 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: { type: 'boolean' }, verifierAllowNetwork: { type: 'boolean' }, solverAllowScripts: { type: 'boolean' }, verifierAllowScripts: { type: 'boolean' }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, planningHorizon: { type: 'integer' }, plannerEnabled: { type: 'boolean' }, plannerProvider: { type: 'string' }, plannerModel: { type: 'string' }, planMinIntervalMs: { type: 'integer' }, plannerMaxFails: { type: 'integer' }, methodKeepIntervalMs: { type: 'integer' }, methodKeepEvery: { type: 'integer' }, methodAutoPromote: { type: 'boolean' }, indexAutoRebuild: { type: 'boolean' }, projectLockTimeoutMs: { 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', TOOL_DESC.vibe_math_set_params, objParams(paramProps()), 'vibe_math_set_params')
   registerTool('vibe_math_setup', TOOL_DESC.vibe_math_setup, objParams({}), 'vibe_math_setup')
   registerTool('vibe_math_save_settings', TOOL_DESC.vibe_math_save_settings, objParams({}), 'vibe_math_save_settings')
   registerTool('vibe_math_template', TOOL_DESC.vibe_math_template, objParams({ where: { type: 'string', enum: ['global', 'project'] } }), 'vibe_math_template')
@@ -5470,7 +5809,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,
@@ -5555,7 +5893,7 @@ const TOOL_DESC = {
   vibe_math_save_settings: 'Write the current params to vibe_math_setting.json (JSON with comments) as new defaults.',
   vibe_math_template: 'Create a fresh vibe_math_setting.json template (with defaults + comments) in the workspace (global) or current project folder.',
   vibe_math_add_problem: 'Add a problem to the current project (creates Problems/<id>.md).',
-  vibe_math_add_proposition: 'Add a proposition to Propos/ (creates Propos/<分类>/<id>.md).',
+  vibe_math_add_proposition: 'Add a NEW proposition to Propos/ (creates Propos/<分类>/<id>.md). The id must be NEW: an existing id is REFUSED with code PROPOSITION_ID_EXISTS (cards are never overwritten — 陈述/证明尝试/证伪尝试 are preserved); pick a fresh id (e.g. p-<8 hex>) or write into that card file directly.',
   vibe_math_list_propositions: 'List propositions from Propos/ (summary index: id, 标题, 概率, 状态, 优先级, 分类).',
   vibe_math_new_project: 'Create a new math project folder and switch to it.',
   vibe_math_set_project: 'Switch the current math project.',
@@ -5570,7 +5908,7 @@ const TOOL_DESC = {
   vibe_math_method_add: 'Manually add a method card to Methods/ (creates Methods/<id>.md).',
   vibe_math_method_list: 'List methods from Methods/ (+ global VibeMath/Methods/): id, 标题, 类型, 状态, 可信断言, applications count.',
   vibe_math_lock_status: 'Show the project lock occupancy.',
-  vibe_math_claim_write: '(member) Acquire the write lock for one target file (relative to the project root). Call before writing a Markdown file directly; a file may only be written by ONE agent at a time. Returns the display path you may write (VibeMath/Projects/<project>/<target>) and a hint.',
+  vibe_math_claim_write: '(member) Acquire the write lock for one target file (relative to the project root). Call before writing a Markdown file directly; a file may only be written by ONE agent at a time. The lock is a LEASE: it is renewed automatically while you are still alive, so a long write keeps it; if your process disappears the lease expires after fileLockTimeoutMs (default 60000) and another agent may take it. Returns the display path you may write (VibeMath/Projects/<project>/<target>) and a hint.',
   vibe_math_release_write: '(member) Release the write lock for one target file (relative to the project root). Call after you finished writing it.',
   vibe_math_sync_meta: '(member) After you write content into Markdown files, report ONLY lightweight scheduling metadata to keep the scheduler state in sync (content stays in the md files). meta.kind must be one of:\n- "directions": {qid, directions:[{id,title,method,core_assumption,feasibility}], methods_used:[{id,效果,建议}], new_inventions:[{类型,标题,内容描述,是否已入库}]}\n- "solver": {qid, dirId, round, survival, status:"continue|success|dead-end", dead_end_reason, lemmas:[{id,title,statement,proof,prob,价值/关键性,分类,优先级}], methods_used, new_inventions, solution_prob, solution_text, sub_questions:[{q_sub_title,q_sub_statement,assumption_title,assumption_statement}]}\n- "methods": {used:[{id,效果,建议}], created:[ids], improvements:[{id,改进内容,原因}]}',
   vibe_math_lean_run: "(member) Execute the Lean toolchain on one .lean file inside the workspace 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.",
@@ -5584,6 +5922,11 @@ const TOOL_DESC = {
 
 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)) }