dsh-vibe-math 2.5.0 → 2.7.0

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

@@ -18,6 +18,24 @@
 //   VibeMath_State/            — scheduler private state (checkpoint/resume)
 export const name = 'vibe-math-v2'
 export const inject = ['subagents', 'agents', 'fs', 'tools', 'commands']
+// Lean 增量/异步（规格：docs/formal-verification.md §1）：内容哈希用于归档去重与作业幂等。
+// `node:crypto` 与 v4/v5 同一写法（只读的内置模块，不执行任何动态代码）。
+import { createHash } from 'node:crypto'
+// 数学计算工具（共享模块，四套字节一致；由 integration owner 维护，本文件只做接线）。
+// 模块内部自己 import './math-engines.js'，接线方不直接引用引擎表。
+import {
+  registerMathComputation,
+  MATH_PARAM_NAMES,
+  MATH_PARAM_DEFAULTS,
+  MATH_TOOL_DESCRIPTION,
+  MATH_TOOL_SCHEMA,
+  MATH_ARCHIVE_WORKFLOW_LINE,
+  MATH_PERSONA_TOOL_LINE,
+  MATH_RULE_LINES,
+  normalizeMathParams,
+  mathAvailabilityLine,
+  probeMathEngines,
+} from './math-computation.js'
 
 // Standing mount: DSH mounts each agent preset ONCE per preset and joins every
 // session that names it to that SAME plugin instance (see @deepseek-ai/dsh-agent-presets).
@@ -164,6 +182,24 @@ export function apply(ctx) {
     leanCommand: 'lean',          // 要执行的 Lean 可执行文件（例：'lake'）
     leanArgs: [],                 // 插在文件名之前的附加参数（例：['env','lean'] 配合 leanCommand='lake'）
     leanTimeoutMs: 120000,        // 单次 Lean 运行的超时上限（毫秒）
+    leanAsync: true,              // true = Lean 编译走后台队列（入队即返回）| false = 同步 await（今天的语义）
+    leanJobsMaxParallel: 1,       // 后台编译并发上限（默认 1 = 串行；可调大以并行编译）
+    leanInitiative: 'normal',     // 日常流程中的形式化主动性：off | normal | eager（与 formalVerify 的"验证要求强度"是两件事）
+    leanSearchPaths: [],          // 额外搜索路径（默认空 = 只用自动注入的 VibeMath 根）；非空时先注入它们、再注入自动根
+    // ---- 最终论文（规格：docs/final-paper.md；v2/v3 为单作者变体）----
+    finalPaper: true,             // 收口时是否自动撰写最终论文（false 只关自动触发；/vibe paper 仍可用）
+    paperFormat: 'both',          // both = md + tex | md = 只写 markdown | tex = 只写 latex
+    paperLanguage: 'zh',          // zh = 中文（ctexart/xelatex 优先）| en = 英文（article/pdflatex 优先）
+    paperCompilePdf: true,        // 检测到 LaTeX 时是否编译 paper.pdf
+    paperLatexCommand: '',        // 指定 LaTeX 引擎（空 = 按语言探测 xelatex/latexmk/pdflatex/lualatex/tectonic）
+    // ---- 数学计算 math_computation（规格：docs/math-computation.md；六参数已冻结，拼写不得改）----
+    // 值取共享模块的 MATH_PARAM_DEFAULTS（四套逐字一致）；数组必须**拷贝**，否则四套会共享同一个默认数组。
+    mathComputation: MATH_PARAM_DEFAULTS.mathComputation,   // off | auto | on（auto = 探测到任一允许引擎才工作）
+    mathMode: MATH_PARAM_DEFAULTS.mathMode,                 // typed | typed+shell（后者才允许提示词里的 shell 兜底段）
+    mathEngines: MATH_PARAM_DEFAULTS.mathEngines.slice(),   // 允许的引擎（含 cli；cli 默认开启，受 mathMode/mathEngines 双闸）
+    mathTimeoutMs: MATH_PARAM_DEFAULTS.mathTimeoutMs,       // 单次计算超时上限（毫秒，下界 1000）
+    mathPackages: MATH_PARAM_DEFAULTS.mathPackages.slice(), // 需要预检的包（缺包只报告 + 给安装计划）
+    mathInstallScope: MATH_PARAM_DEFAULTS.mathInstallScope, // user | system（system 只对当次显式调用生效，永不记忆）
   }
   let params = Object.assign({}, DEFAULT_PARAMS)
   let scheduler = { running: false, startedAt: 0, lastCheckpoint: 0, gate: null } // activeCount 由 activeCount() 从 agentRegistry 推导，不再作为字段
@@ -283,7 +319,23 @@ export function apply(ctx) {
     { name: 'formalVerify', type: 'enum', options: ['off', 'encourage', 'require'], description: 'Lean 形式化验证档位：off=不额外要求（默认，提示词里不出现 Lean）；encourage=鼓励按实现难度自行形式化，一旦 Lean 通过则验证重点转为「忠实性审查」；require=同 encourage 且加门禁——对象的 formal.status 未达到 passed/blocked 前，真/假裁定记为未定论（原因 formal-required）并写入 Formal/TODO.md', suggestion: 'off' },
     { name: 'leanCommand', type: 'string', description: '要执行的 Lean 可执行文件（默认 lean；用 lake 时配合 leanArgs=["env","lean"]）', suggestion: 'lean' },
     { name: 'leanArgs', type: 'string[]', description: '插在 .lean 文件名之前的附加命令行参数（默认空）', suggestion: [] },
-    { name: 'leanTimeoutMs', type: 'integer', description: '单次 Lean 运行的超时上限（毫秒，默认 120000，最小 1000）', suggestion: 120000 },
+    { name: 'leanTimeoutMs', type: 'integer', description: '单次 Lean 运行的超时上限（毫秒，默认 120000，最小 1000）；异步档下它同时是**每个后台编译作业**的预算（到时主动 terminate，作业记 timeout、对象留在 attempted）', suggestion: 120000 },
+    { name: 'leanAsync', type: 'boolean', description: 'Lean 编译模式：true（默认）= 后台队列，vibe_math_lean_run / vibe_math_lean_archive{run:true} 立即返回 async.jobId 入队，成员不阻塞，结果由下一轮提示的【形式化结果】行与 vibe_math_lean_lib / vibe_math_lean_job 公告（**只有作业落地为 ok 才会置 passed 并写归档证明**）；false = 完全同步 await（与旧行为逐字一致）', suggestion: true },
+    { name: 'leanJobsMaxParallel', type: 'integer', description: '后台 Lean 编译的并发上限（默认 1 = 串行，保持可预测的资源占用；调大可并行编译多个作业）', suggestion: 1 },
+    { name: 'leanInitiative', type: 'string', enum: LEAN_INITIATIVE_MODES.slice(), description: '日常流程中的形式化主动性：off（不主动，只在验证提示词按 formalVerify 的要求做）| normal（默认：顺手把有价值且可能复用的东西形式化）| eager（更主动：日常就主动把有价值的小引理/命题/定义形式化）。注意它与 formalVerify（验证时的要求强度：off|encourage|require）是**两件事**', suggestion: 'normal' },
+    { name: 'leanSearchPaths', type: 'array', items: { type: 'string' }, description: '额外 Lean 搜索路径（默认空数组 = 只用框架自动注入的 VibeMath 根）。非空时按顺序先注入这里给的路径、再注入自动根（去重）；若 leanArgs 里已显式给了 --search-path/-R/--root，则完全尊重用户配置、不注入任何东西', suggestion: [] },
+    { name: 'finalPaper', type: 'boolean', description: '收口（严格终止）时自动撰写最终论文：派遣一名专职「论文撰写」子代理，把已检验通过的命题/解法/成果整理成 Paper/<项目>/{paper.md,paper.tex,paper.meta.json,paper.log.md}。false = 只关自动触发，/vibe paper 手动命令仍可用', suggestion: true },
+    { name: 'paperFormat', type: 'enum', options: ['both', 'md', 'tex'], description: '论文产出格式：both = markdown + latex；md = 只写 paper.md；tex = 只写 paper.tex（tex 才会尝试编译 pdf）', suggestion: 'both' },
+    { name: 'paperLanguage', type: 'enum', options: ['zh', 'en'], description: '论文语言：zh = 中文（LaTeX 用 ctexart，引擎优先 xelatex）；en = 英文（article，引擎优先 pdflatex/latexmk）', suggestion: 'zh' },
+    { name: 'paperCompilePdf', type: 'boolean', description: '检测到 LaTeX 时是否编译 paper.pdf（-interaction=nonstopmode 跑两遍；失败先尝试修复：换引擎/去不支持宏包/最小模板）。false 或无 LaTeX 时只保留 tex+md 并记日志', suggestion: true },
+    { name: 'paperLatexCommand', type: 'string', description: '指定 LaTeX 引擎可执行文件（空 = 按语言探测：中文 xelatex > latexmk > pdflatex > lualatex > tectonic；英文 pdflatex 优先）。该命令解析不到时按"未检测到"降级（只留 tex+md）', suggestion: '' },
+    // ---- 数学计算 math_computation（六参数冻结；描述与 prompts.md §1/§6 口径一致）----
+    { name: 'mathComputation', type: 'enum', options: ['off', 'auto', 'on'], description: '数学计算总开关：off = 真无操作（提示词零提及）；auto = 探测到 mathEngines 里任一允许引擎才工作；on = 同上（探测失败时工具仍返回可执行的安装指引，而不是假装可用）', suggestion: 'auto' },
+    { name: 'mathMode', type: 'enum', options: ['typed', 'typed+shell'], description: '计算策略：typed+shell（默认）= 工具不可用时允许宿主 shell 兜底，但结论必须标注"未经工具归档（shell 路径）"；typed = 只用工具路径（提示词里不出现 shell 兜底段，engine:"cli" 返回 REFUSED{reason:policy}）', suggestion: 'typed+shell' },
+    { name: 'mathEngines', type: 'string[]', description: '允许的引擎列表（默认 python|r|octave|julia|matlab|maple|wolfram|cli）。cli 默认开启且走同一套超时/输出上限/回执；从列表里移除某引擎即禁用（商业引擎只探测+许可，永不安装）', suggestion: MATH_PARAM_DEFAULTS.mathEngines.slice() },
+    { name: 'mathTimeoutMs', type: 'integer', description: '单次数学计算的超时上限（毫秒，默认 60000，最小 1000）；到时主动 terminate 并把回执标为 MATH_TIMEOUT', suggestion: 60000 },
+    { name: 'mathPackages', type: 'string[]', description: '需要预检的包（默认空）。缺包只报告 + 给"用户自装指引"或"代理代装计划"，不会执行脚本，也永不自动安装', suggestion: [] },
+    { name: 'mathInstallScope', type: 'string', enum: ['user', 'system'], description: '安装作用域：user（默认，用户级目录）；system 只对当次显式调用生效、永不记忆（不会写进状态文件）', suggestion: 'user' },
   ]
 
   // ================= fs =================
@@ -348,6 +400,19 @@ export function apply(ctx) {
     if (isWindows()) return 'Remove-Item -Force -LiteralPath ' + psQuote(path) + ' -ErrorAction SilentlyContinue'
     return 'rm -f ' + shQuote(path)
   }
+  /**
+   * `subprocess.spawn` 的契约返回**句柄**（带 `done`），但桩宿主/测试替身常常写成 `async spawn(...)`
+   * ——那样返回的是 Promise，`handle.done` 是 undefined，`await handle.done` 得到 undefined，随后
+   * `outcome.exitCode` 抛 "Cannot read properties of undefined (reading 'exitCode')"，被 catch 成一条
+   * 误导性的 "mkdir 失败"（实测：第二个会话建项目目录时刷出这条）。
+   * 这里统一兼容一次：Promise 就先 await，句柄缺 `done` 才如实报错。
+   */
+  async function spawnHandle(subprocess, spec) {
+    const raw = subprocess.spawn(spec)
+    const handle = (raw && typeof raw.then === 'function') ? await raw : raw
+    if (!handle || handle.done === undefined) throw new Error('subprocess.spawn returned no handle.done')
+    return handle
+  }
   async function runShell(script, cwd) {
     const subprocess = subprocessOf()
     if (subprocess === undefined) return { ok: false, error: 'no-subprocess' }
@@ -355,9 +420,9 @@ export function apply(ctx) {
       const argv = isWindows()
         ? ['powershell', '-NoProfile', '-NonInteractive', '-Command', script]
         : ['/bin/sh', '-c', script]
-      const handle = subprocess.spawn({ argv: argv, cwd: cwd || workspaceRoot(), stdio: { stdin: 'ignore', stdout: 'inherit', stderr: 'inherit' }, graceMs: 20000 })
+      const handle = await spawnHandle(subprocess, { argv: argv, cwd: cwd || workspaceRoot(), stdio: { stdin: 'ignore', stdout: 'inherit', stderr: 'inherit' }, graceMs: 20000 })
       const outcome = await handle.done
-      return { ok: outcome.exitCode === 0, exitCode: outcome.exitCode }
+      return { ok: !!outcome && outcome.exitCode === 0, exitCode: (outcome && outcome.exitCode !== undefined) ? outcome.exitCode : null }
     } catch (e) { return { ok: false, error: String((e && e.message) || e) } }
   }
   /**
@@ -374,12 +439,13 @@ export function apply(ctx) {
     shellWarned[key] = true
     console.error('vibe-math-v2: ' + where + ' failed (' + why + ')')
   }
-  // 目录布局（docs/formal-verification.md §3）：
-  //   项目内：Formal/（对象形式化工作文件 + Index.md + TODO.md）、Verified/Lean/（归档证明）
+  // 目录布局（docs/formal-verification.md §3 / docs/math-computation.md §路径）：
+  //   项目内：Formal/（对象形式化工作文件 + Index.md + TODO.md）、Verified/Lean/（归档证明）、
+  //           Computation/（math_computation 的可复核回执：Computation/<runId>/ 与 Computation/installs/）
   //   全局（**不在项目内**，跨项目复用）：<VibeMath 根>/Formal/Lib/（可复用定义）、Formal/Proved/（已证引理）
   async function ensureDirs() {
     const base = frameworkRoot()
-    const dirs = ['qs', 'Propos', 'Reliable', 'Verified', 'Verified/Lean', 'Verification_logs', 'Progress_Logs', 'VibeMath_State', 'Formal']
+    const dirs = ['qs', 'Propos', 'Reliable', 'Verified', 'Verified/Lean', 'Verification_logs', 'Progress_Logs', 'VibeMath_State', 'Formal', 'Formal/Jobs', 'Computation']
     const paths = [vibeRoot() + '/Projects', vibeRoot() + '/Formal/Lib', vibeRoot() + '/Formal/Proved'].concat(dirs.map(function (d) { return base + '/' + d }))
     const r = await runShell(mkdirCmd(paths))
     if (!r || !r.ok) warnShellOnce('ensureDirs (mkdir ' + base + ')', r)
@@ -392,6 +458,121 @@ export function apply(ctx) {
     return r
   }
 
+  // ================= 数学计算 math_computation：会话侧接线（共享模块，FREEZE §4/§5） =================
+  // 探测量（是否装了 python/r/…）是异步的，而提示词是同步构造的 ⇒ 这里维护一个会话级缓存，
+  // 在 init / 参数变化 / TTL 到期时刷新，提示词侧只读缓存现算（与 formalVerify 的动态纪律一致）。
+  const MATH_PROBE_TTL_MS = 15 * 60 * 1000
+  let mathProbe = null
+  let mathProbeAt = 0
+  /**
+   * `host.spawn` 适配：模块只给 `{argv, cwd, timeoutMs, stdoutCap, stderrCap}`，超时/终止由**接线方**负责
+   * （契约：超时必须 handle.terminate()）。返回**完整** stdout/stderr——模块自己落盘完整版，只在返回体裁 64KB，
+   * 所以 stdio 上限要宽（默认 4MB），否则"超大输出"永远测不出完整落盘。
+   */
+  async function mathSpawn(spec) {
+    const sub = subprocessOf()
+    if (sub === undefined || typeof sub.spawn !== 'function') return null // 模块映射为 MATH_NO_SUBPROCESS
+    const s = spec || {}
+    const cap = Math.max(1000, Number(s.timeoutMs) || Number(params.mathTimeoutMs) || 60000)
+    const outCap = Math.max(4096, Number(s.stdoutCap) || 4 * 1024 * 1024)
+    const errCap = Math.max(4096, Number(s.stderrCap) || 4 * 1024 * 1024)
+    const started = now()
+    let handle
+    try {
+      handle = await spawnHandle(sub, {
+        argv: s.argv,
+        cwd: s.cwd || frameworkRoot(),
+        stdio: { stdin: 'ignore', stdout: { maxBytes: outCap }, stderr: { maxBytes: errCap } },
+        graceMs: cap,
+      })
+    } catch (e) { return null }
+    let timedOut = false, killed = false, timer = null, outcome
+    try {
+      outcome = await Promise.race([
+        handle.done,
+        new Promise(function (resolve) {
+          timer = setTimeout(function () {
+            timedOut = true
+            killed = true
+            try { if (handle && typeof handle.terminate === 'function') handle.terminate() } catch (e) { /* best effort */ }
+            resolve({ exitCode: null })
+          }, cap)
+        }),
+      ])
+    } catch (e) { if (timer !== null) clearTimeout(timer); return null }
+    if (timer !== null) clearTimeout(timer)
+    let out = '', err = ''
+    try { if (handle.collected && handle.collected.stdout) out = handle.collected.stdout.readFrom(0).text } catch (e) { /* best effort */ }
+    try { if (handle.collected && handle.collected.stderr) err = handle.collected.stderr.readFrom(0).text } catch (e) { /* best effort */ }
+    return {
+      exit: (outcome && outcome.exitCode !== undefined) ? outcome.exitCode : null,
+      timedOut: timedOut, killed: killed, ms: now() - started,
+      stdout: String(out == null ? '' : out), stderr: String(err == null ? '' : err),
+    }
+  }
+  /** host.exists：项目根相对路径是否存在。 */
+  async function mathExists(rel) {
+    try { const t = await fsTarget(rel); const s = await fs.stat(t); return s !== undefined } catch (e) { return false }
+  }
+  /**
+   * host.listDir（**可选**，FREEZE §4）：模块用它数 `Computation/` 下的 run 目录数（>200 只告警、永不删除）。
+   * 返回 DSH `fs.listDir` 的原样条目（{name,type}）——模块按 `type === 'directory'` 计数，
+   * 所以**不要**在这里把条目降级成字符串数组。宿主 fs 没有该能力时整个回调都不声明（见下面的条件字段），
+   * 否则模块每次运行都会去问一个不存在的服务。
+   */
+  async function mathListDir(rel) {
+    try { const t = await fsTarget(rel); const ents = await fs.listDir(t); return Array.isArray(ents) ? ents : [] } catch (e) { return [] }
+  }
+  /** 会话级 host：参数是**活引用**（函数），回执里写 designator='vibe-math-v2'。 */
+  const mathHost = {
+    // 模块注册时只**交回** handler/description/parameters；真正的挂载是 mathTool 之后的**字面量**两行。
+    // （会话层写 handlers 表、apply 层挂宿主工具面；两条路径名字/描述/schema 完全一致。）
+    register: function (name, description, parameters, handler) { /* 挂载见 mathTool 之后的字面量两行 */ },
+    params: function () { return params },
+    projectRoot: function () { return frameworkRoot() },
+    designator: 'vibe-math-v2',
+    // 宿主明知没有 subprocess 服务时直接说 false ⇒ 模块立即返回 MATH_NO_SUBPROCESS（不再逐个探引擎）。
+    hasSubprocess: function () { const sub = subprocessOf(); return !!(sub && typeof sub.spawn === 'function') },
+    // **可选能力，按宿主实际情况声明**：宿主 fs 没有 listDir 就不给这个回调（模块据此跳过
+    // "每项目 run 目录数 >200" 的保留检查，而不是每次运行都白问一次）。
+    listDir: (typeof fs.listDir === 'function') ? mathListDir : undefined,
+    writeText: async function (rel, text) { return await writeText(rel, text) },
+    readText: async function (rel) { return await readText(rel) },
+    exists: mathExists,
+    resolveExecutable: async function (cmd) {
+      const sub = subprocessOf()
+      if (sub === undefined || typeof sub.resolveExecutable !== 'function') throw new Error('no subprocess service')
+      const p = await sub.resolveExecutable(String(cmd))
+      if (typeof p !== 'string' || !p) throw new Error('not found: ' + String(cmd))
+      return p
+    },
+    spawn: mathSpawn,
+    log: function (kind, msg) { logActivity('math', String(kind) + ': ' + String(msg)) },
+  }
+  // 模块只调用一次 host.register(...)（FREEZE §4）⇒ 上面那个回调就是会话层注册。
+  // 注意：真实注册必须等到 `const handlers = {}` 与 `function registerTool(...)` 就绪之后
+  // （`handlers` 是 const，提前调用会撞 TDZ）⇒ 这里只留槽位，注册放在会话工具表旁。
+  let mathTool = null
+  /** 刷新探测缓存。`mathComputation:'off'` ⇒ 不探测、不缓存、不注入（真 no-op）。 */
+  async function refreshMathProbe(force) {
+    if (params.mathComputation === 'off') { mathProbe = null; mathProbeAt = 0; return null }
+    if (!mathTool) return null
+    try { mathProbe = await mathTool.probe(force ? { refresh: true } : undefined); mathProbeAt = now() } catch (e) { mathProbe = null }
+    return mathProbe
+  }
+  /** 心跳里的 TTL 刷新（每拍一次布尔判断，成本可忽略）。 */
+  function mathProbeDue() { return params.mathComputation !== 'off' && (!mathProbe || (now() - mathProbeAt) >= MATH_PROBE_TTL_MS) }
+  /**
+   * 每轮可用性行（中文）。由模块的 `mathAvailabilityLine(probe,'zh',mathMode)` 按档位拼装：
+   * 只有 `typed+shell` 才含 shell 兜底句（`mathMode:'typed'` 天然不含，守卫据此断言）。
+   * `off` 档返回空串——提示词零提及（对齐 formalVerify:'off' 的真 no-op 纪律）。
+   */
+  function mathWorkLine() {
+    if (params.mathComputation === 'off') return ''
+    if (!mathProbe) return '' // 还没探测过 ⇒ 不注入（不撒谎；init 会先探一次）
+    return '\n' + mathAvailabilityLine(mathProbe, 'zh', params.mathMode) + '\n'
+  }
+
   // ================= settings =================
   function sanitizeParams(obj) {
     const out = {}
@@ -406,9 +587,14 @@ export function apply(ctx) {
       maxParallelThreshold: 1, solverMaxRounds: 1, verifierCount: 2, debateMaxRounds: 1,
       directionsPerSolver: 1, tickIntervalMs: 200, reportIntervalMs: 1000, maxExplorerRetries: 1,
     }
+    // 数学计算六参数的显式强制（FREEZE §5.3）：交给共享模块的 normalizeMathParams，它按
+    // enum/array/integer 逐键判型——`'false'`/字符串/错误枚举一律回退默认值，**绝不**落到
+    // 下面 `else { out[k] = v }` 的尾巴（那会把任意字符串当合法值放行）。
+    const mathNorm = normalizeMathParams(obj)
     for (const k of Object.keys(DEFAULT_PARAMS)) {
       if (!(k in obj)) continue
       const v = obj[k]
+      if (MATH_PARAM_NAMES.indexOf(k) !== -1) { out[k] = Object.prototype.hasOwnProperty.call(mathNorm, k) ? mathNorm[k] : DEFAULT_PARAMS[k]; continue }
       if (intFields.indexOf(k) !== -1) {
         const n = Number(v)
         if (!Number.isFinite(n)) { out[k] = DEFAULT_PARAMS[k]; continue }
@@ -425,12 +611,30 @@ export function apply(ctx) {
       else if (k === 'priorityAdjust') { out[k] = (v === 'none' || v === 'deadend-deprioritize' || v === 'survival-map') ? v : DEFAULT_PARAMS[k] }
       else if (k === 'proposPriorityAdjust') { out[k] = (v === 'none' || v === 'progress-graded') ? v : DEFAULT_PARAMS[k] }
       else if (k === 'solverAllowNetwork' || k === 'verifierAllowNetwork' || k === 'solverAllowScripts' || k === 'verifierAllowScripts') { out[k] = (v === true || v === false || v === '') ? v : DEFAULT_PARAMS[k] }
+      else if (k === 'finalPaper' || k === 'paperCompilePdf') { out[k] = (v === true || v === false) ? v : DEFAULT_PARAMS[k] }
+      // leanAsync 必须**显式**归一化：`else { out[k] = v }` 会把字符串 'false' 当真理放行（spec §1.1）。
+      else if (k === 'leanAsync') { out[k] = (v === true || v === false) ? v : DEFAULT_PARAMS[k] }
+      else if (k === 'leanInitiative') { out[k] = LEAN_INITIATIVE_MODES.indexOf(v) !== -1 ? v : DEFAULT_PARAMS[k] }
+      else if (k === 'leanJobsMaxParallel') {
+        const n = Number(v)
+        out[k] = Number.isFinite(n) ? Math.max(1, Math.min(8, Math.floor(n))) : DEFAULT_PARAMS[k]
+      }
+      // leanSearchPaths：显式数组分支（字符串/非数组一律回退默认空数组），并去掉空串与重复项。
+      else if (k === 'leanSearchPaths') {
+        if (!Array.isArray(v)) { out[k] = DEFAULT_PARAMS[k]; continue }
+        const seen = {}
+        out[k] = v.map(function (x) { return String(x == null ? '' : x).trim() }).filter(function (x) { if (!x || seen[x]) return false; seen[x] = true; return true })
+      }
+      else if (k === 'paperFormat') { out[k] = (v === 'both' || v === 'md' || v === 'tex') ? v : DEFAULT_PARAMS[k] }
+      else if (k === 'paperLanguage') { out[k] = (v === 'zh' || v === 'en') ? v : DEFAULT_PARAMS[k] }
       else { out[k] = v }
     }
     // 非正的 leanTimeoutMs 会让每次 Lean 运行立即"超时"，而超时被记成"未通过"——静默失效。
     // 删除该键（回退默认），而不是抬到最小值，与 v5/v4 的既有处理一致。
     if (out.leanTimeoutMs !== undefined && !(out.leanTimeoutMs > 0)) delete out.leanTimeoutMs
     if (out.leanTimeoutMs !== undefined) out.leanTimeoutMs = Math.max(1000, out.leanTimeoutMs)
+    // 空白的 paperLatexCommand 会让 resolveExecutable('') 直接失败；回退默认（自动探测）。
+    if (out.paperLatexCommand !== undefined && !String(out.paperLatexCommand).trim()) out.paperLatexCommand = DEFAULT_PARAMS.paperLatexCommand
     // 未知档位一律回退 'off'（无操作），绝不回退到更强的档位：一个拼写错误若静默启用强制形式化，
     // 会让所有结论被门禁拦下。
     if (out.formalVerify !== undefined && ['off', 'encourage', 'require'].indexOf(String(out.formalVerify)) === -1) out.formalVerify = DEFAULT_PARAMS.formalVerify
@@ -633,7 +837,6 @@ export function apply(ctx) {
    * （无服务 / 无可执行文件 / spawn 失败 / 超时 / 非零退出）都变成可读结果。
    */
   async function leanRunFile(relPath, timeoutMs) {
-    const started = now()
     const rel = String(relPath || '').trim()
     if (!rel) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'file is required' }
     // 路径守卫：只允许执行 VibeMath 树内的文件，构造出来的路径不能让我们跑工作区之外的东西。
@@ -641,21 +844,35 @@ export function apply(ctx) {
     if (abs === null) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'Lean 文件必须位于 ' + vibeRoot() + '/ 之内（收到 ' + rel + '）' }
     if (!/\.lean$/.test(abs)) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: '只有 .lean 文件可以执行' }
     if (await readTextAbs(abs) === undefined) return { ok: false, code: 'V2_NOT_FOUND', message: 'no such file: ' + rel }
+    return await leanExecFile(rel, abs, timeoutMs)
+  }
+  /**
+   * 已解析路径的**实际执行**（同步档与后台作业共用同一段：argv 注入、超时 terminate、输出截断）。
+   * 搜索路径注入（spec §3）：`[exe, ...用户 leanArgs, --search-path <VibeMath 根>, <file>]`；
+   * 用户已显式给过 `--search-path`/`-R`/`--root` 就不再注入（显式覆盖优先）。
+   */
+  async function leanExecFile(rel, abs, timeoutMs, plan, onHandle) {
+    const started = now()
     const sub = subprocessOf()
     if (sub === undefined || typeof sub.spawn !== 'function') {
       return { ok: false, code: 'NO_SUBPROCESS', message: 'the host exposes no subprocess service; Lean cannot be executed here', file: rel, ms: 0 }
     }
     const cap = Math.max(1000, Number(timeoutMs) || Number(params.leanTimeoutMs) || 120000)
+    // 构建计划：异步作业用**入队时冻结**的计划（修订 §4：结果只对那个上下文有效）；同步档现算。
+    const p = plan || leanBuildPlan()
     let exe
     try {
-      exe = await sub.resolveExecutable(String(params.leanCommand || 'lean'))
+      exe = await sub.resolveExecutable(String(p.engine || 'lean'))
     } catch (e) {
-      return { ok: false, code: 'LEAN_NOT_FOUND', message: 'cannot resolve "' + String(params.leanCommand || 'lean') + '": ' + String((e && e.message) || e) + ' —— 仍可把形式化代码写下来归档，但无法在此宿主上执行', file: rel, ms: now() - started }
+      return { ok: false, code: 'LEAN_NOT_FOUND', message: 'cannot resolve "' + String(p.engine || 'lean') + '": ' + String((e && e.message) || e) + ' —— 仍可把形式化代码写下来归档，但无法在此宿主上执行', file: rel, ms: now() - started }
     }
-    const argv = [exe].concat((Array.isArray(params.leanArgs) ? params.leanArgs : []).map(String)).concat([abs])
+    const inject = Array.isArray(p.inject) ? p.inject : leanSearchPathPlan(p.args, p.searchPaths, vibeRoot()).inject
+    const argv = [exe].concat((Array.isArray(p.args) ? p.args : []).map(String)).concat(inject).concat([abs])
+    const searchPath = (Array.isArray(p.searchPaths) && p.searchPaths.length) ? p.searchPaths.join(',') : vibeRoot()
+    logActivity('formal', 'Lean 运行 ' + rel + '（search-path=' + searchPath + '）')
     let handle
     try {
-      handle = sub.spawn({
+      handle = await spawnHandle(sub, {
         argv: argv,
         cwd: frameworkRoot(),
         stdio: { stdin: 'ignore', stdout: { maxBytes: 64 * 1024 }, stderr: { maxBytes: 64 * 1024 } },
@@ -664,6 +881,8 @@ export function apply(ctx) {
     } catch (e) {
       return { ok: false, code: 'LEAN_SPAWN_FAILED', message: String((e && e.message) || e), file: rel, ms: now() - started }
     }
+    leanSyncHandle = handle
+    if (typeof onHandle === 'function') { try { onHandle(handle) } catch (e) { /* best effort */ } }
     // 超时必须有**主动**兜底：`graceMs` 只是宿主侧的宽限，契约 §7 明确要求"对超时调用
     // handle.terminate()"。此前 v2 只依赖 graceMs，从不终止进程：一个卡住的 Lean 会继续占着
     // 资源，而框架已经报了超时——它与自己的契约不一致。这里与 `handle.done` 竞速：计时器到点
@@ -687,6 +906,8 @@ export function apply(ctx) {
       return { ok: false, code: 'LEAN_RUN_FAILED', message: String((e && e.message) || e), file: rel, ms: now() - started }
     }
     if (timer !== null) clearTimeout(timer)
+    leanSyncHandle = null
+    if (typeof onHandle === 'function') { try { onHandle(null) } catch (e) { /* best effort */ } }
     let out = '', err = ''
     try { if (handle.collected && handle.collected.stdout) out = handle.collected.stdout.readFrom(0).text } catch (e) { /* best effort */ }
     try { if (handle.collected && handle.collected.stderr) err = handle.collected.stderr.readFrom(0).text } catch (e) { /* best effort */ }
@@ -699,14 +920,15 @@ export function apply(ctx) {
     // 输出截断到 ~4KB 再入库（避免把巨大的编译器输出写进状态）。
     return {
       ok: ok, exitCode: exitCode, signal: (outcome && outcome.signal) || null, ms: ms,
-      command: argv.join(' '), file: rel,
+      command: argv.join(' '), file: rel, searchPath: searchPath,
       stdout: tailText(out, 4000), stderr: tailText(err, 4000),
       timedOut: isTimeout,
       code: ok ? undefined : (isTimeout ? 'LEAN_TIMEOUT' : 'LEAN_FAILED'),
     }
   }
   // 把一次运行结果写进对象的形式化记录（不提升 status，状态迁移见契约 §4）。
-  async function formalSetRun(target, run) {
+  // `asyncInfo`（可选）：异步档把作业 id/state/attempts/落地时刻贴在记录上，供人对照（§1.4）。
+  async function formalSetRun(target, run, asyncInfo) {
     const t = safeId(String(target || ''))
     if (!t) return
     const prev = formalOf(t)
@@ -714,6 +936,7 @@ export function apply(ctx) {
       status: prev.status === 'passed' ? 'passed' : (prev.status === 'blocked' ? 'blocked' : 'attempted'),
       file: run.file || prev.file || '',
       run: { at: now(), ok: !!run.ok, exitCode: run.exitCode === undefined ? null : run.exitCode, ms: run.ms || 0, stdoutTail: tailText(run.stdout, 800), stderrTail: tailText(run.stderr, 800) },
+      async: asyncInfo || prev.async || null,
       updatedAt: now(),
     }))
   }
@@ -882,7 +1105,7 @@ export function apply(ctx) {
       L.push('    请复核这个判断是否成立；若你认为其实可以形式化，请指出来并动手做。')
     } else {
       L.push('  · 请先判断该对象的**实现难度**：若能在可接受的工作量内形式化，优先写 Lean 代码并执行。')
-      L.push('  · 工具：vibe_math_lean_run（执行）· vibe_math_lean_archive（归档）· vibe_math_lean_lib（查已有可复用库）')
+      L.push('  · 工具：vibe_math_lean_run（执行）· vibe_math_lean_archive（归档）· vibe_math_lean_lib（查已有可复用库/jobs）· vibe_math_lean_read（取回归档原文）')
       L.push('  · 工作目录：Formal/（相对项目根）；可复用定义放 ' + vroot + '/Formal/Lib/，已证引理放 '
         + vroot + '/Formal/Proved/；写之前先 vibe_math_lean_lib 查重。')
       L.push('  · **一旦 Lean 通过，你唯一需要确认的就是忠实性**：定义/对象/条件/假设/结论是否与命题原文逐条一致。'
@@ -895,19 +1118,42 @@ export function apply(ctx) {
         L.push('  · 若你判断不值得或无法形式化，可以不做，但请在回执的 formal 字段写明难度判断（decision=\'blocked\' 时必须写明 note）。')
       }
       L.push('  · 归档可复用定义/引理前先跑通（vibe_math_lean_archive run=true 或先 vibe_math_lean_run）；跑不通不要入库。')
+      // —— §5 B（逐字）：三条筛选判据 + 先查再写 + 异步"落地前不得当已通过" ——
+      L.push('  · 三条筛选判据：① 有价值或可能复用；② 较为关键或必要；③ 你对该陈述有把握（置信度高）。')
+      L.push('  · 写新定义/证明前**先 vibe_math_lean_lib 查已有库**（vibe_math_lean_read 可取回归档原文逐字复用），查不到再写；'
+        + '复用已归档内容用 `import Formal.Lib.<name>` / `import Formal.Proved.<name>`。')
+      L.push('  · **没把握就记 blocked** 并写清难点，别用形式化掩盖不确定。')
+      L.push('  · 该对象若已有后台编译在队列中（leanAsync 默认开启），**不得**在作业落地为通过之前声称已通过或转忠实性审查；'
+        + '等 vibe_math_lean_lib 的 jobs 显示 settled 再审。')
       L.push('  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或宿主不提供 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明'
         + '"宿主无 Lean 工具链"——这算显式阻塞原因，定论门禁可以据此放行。')
     }
-    return L.join('\n')
+    // 后台作业的一次性公告（spec §2.4）：注入到本轮提示里，取走即清空。
+    // 数学计算可用性行（prompts.md §2）：验证轮同样告知"先 probe 再 run / 回执即引用"。
+    return L.join('\n') + leanNoticeSection() + mathWorkLine()
   }
   function formalWorkLine() {
-    if (!formalOn()) return ''
-    // `Formal/Proved/` 在项目根下**并不存在**（可复用库故意在项目树之外），只写相对路径会让代理
-    // 去项目里找一个永远找不到的目录；这里与验证段落一样给出 VibeMath 根的绝对路径（契约 §6.2）。
-    return '【顺手形式化（' + (formalMode() === 'require' ? '强制' : '鼓励') + '）】把你工作中常用或可能复用的对象、假设、'
+    // 修订 §1 + v5 统一口径：**日常主动性（leanInitiative）与验证时的要求强度（formalVerify）是两根
+    // 独立的轴**。所以这里不能用 `!formalOn()` 一票否决——那会让 `leanInitiative:'eager'` 在
+    // `formalVerify:'off'` 下静默失效（"定论不额外要求，但日常鼓励形式化"组合必须真的成立）。
+    // `formalVerify:'off'` 只关掉**验证阶段**的 Lean 文本：那里仍是 `formalPromptBlock` 的
+    // `!formalOn() ⇒ ''`。`leanInitiative:'off'` 则连日线也不注入（真无操作）。
+    const initiative = LEAN_INITIATIVE_MODES.indexOf(params.leanInitiative) !== -1 ? params.leanInitiative : 'normal'
+    if (initiative === 'off' || !(formalOn() || initiative === 'eager')) return ''
+    return '【顺手形式化（' + (formalOn() ? (formalMode() === 'require' ? '强制' : '鼓励') : '仅主动性') + '·主动性 ' + initiative + '）】把你工作中常用或可能复用的对象、假设、'
       + '新定义用 Lean 形式化定义并归档到全局可复用库（vibe_math_lean_archive kind=\'def\'），已成立的引理归到 '
       + vibeRoot().replace(/\\/g, '/') + '/Formal/Proved/（kind=\'lemma\'）；写之前先 vibe_math_lean_lib 查重，避免重复定义。'
       + '归档前先跑通（vibe_math_lean_run 或 run=true）；跑不通的定义不要进可复用库。'
+      + (initiative === 'eager'
+        ? '\n  · **主动档（leanInitiative=eager）**：日常就主动把有价值的小引理/命题/定义形式化——每轮工作结束时审视一次"这轮有什么值得进库"，值得就顺手归档。'
+        : '\n  · 主动性 normal：顺手把明显有价值且可能复用的东西形式化；不必刻意扩大范围。')
+      // —— §5 A（逐字）：三条筛选判据 + 先查再写 + 「没把握就记 blocked」 + 异步"落地前不得当已通过" ——
+      + '\n  · 三条筛选判据：① 有价值或可能复用；② 较为关键或必要；③ 你对该陈述有把握（置信度高）。'
+      + '\n  · **先 vibe_math_lean_lib 查再决定是否重写**：vibe_math_lean_lib 列出现成定义/引理，vibe_math_lean_read 可取回归档原文逐字复用；'
+      + '复用已归档内容用 `import Formal.Lib.<name>` / `import Formal.Proved.<name>`（模块根 = ' + vibeRoot().replace(/\\/g, '/') + '，框架已把它加进编译搜索路径）。'
+      + '\n  · **没把握就记 blocked**（vibe_math_lean_archive kind=\'blocked\' note=…，或回执 formal 的 blocked）：把难点写清楚，别用形式化掩盖不确定。'
+      + '\n  · 编译默认走后台队列（leanAsync=true）：入队后你可以继续工作；用 vibe_math_lean_job（可 waitMs 等结果）或下一轮提示里的'
+      + '【形式化结果】行看结果。**在作业落地为通过之前，不得把该对象当成已通过。**'
   }
   /**
    * 回执契约里的 `formal` 字段（契约 §6.3）。**必须真的出现在回执契约里**：契约写了字段而框架
@@ -1079,6 +1325,298 @@ export function apply(ctx) {
     return await absorbFormalReply(f, memberId)
   }
 
+  // ================= Lean 增量 + 异步：作业队列（spec §2） =================
+  // 并发上限 = `leanJobsMaxParallel`（默认 1 = 串行）。队列是**内存**态，作业记录镜像到
+  // <项目>/Formal/Jobs/<jobId>.json —— 崩溃恢复、lean_lib.jobs 与 lean_job 都读它。
+  const LEAN_QUEUE_CONCURRENCY_MAX = 8
+  const leanQueue = []            // FIFO：待跑作业
+  const leanJobs = new Map()      // jobId -> job（内存视图，含 state）
+  const leanRunningHandles = new Map() // jobId -> 子进程 handle（dispose 时 terminate）
+  let leanSyncHandle = null       // 同步档在跑的 handle（同样能被 terminate）
+  const leanPendingNotices = []   // 一次性公告行（注入下一次 round prompt，spec §2.4）
+  /** 当前会话的构建计划（修订 §2/§4）：冻结 engine/args/搜索路径，作业与指纹都用它。 */
+  function leanBuildPlan() {
+    const userArgs = (Array.isArray(params.leanArgs) ? params.leanArgs : []).map(String)
+    const plan = leanSearchPathPlan(userArgs, params.leanSearchPaths, vibeRoot())
+    return { engine: String(params.leanCommand || 'lean'), args: userArgs, searchPaths: plan.paths, inject: plan.inject, explicit: plan.explicit }
+  }
+  function leanPlanContext(plan) { return leanBuildContext(plan.engine, plan.args, plan.searchPaths) }
+  /** 归档作业当前应绑定的构建计划（def/lemma 与 proof 都是本项目计划）。 */
+  function leanContextNow() { return leanPlanContext(leanBuildPlan()) }
+  function leanJobsMaxParallel() { return Math.max(1, Math.min(LEAN_QUEUE_CONCURRENCY_MAX, Number(params.leanJobsMaxParallel) || 1)) }
+  function leanActiveCount() { let n = 0; for (const j of leanJobs.values()) if (j.state === 'running') n++ ; return n }
+  function leanSleep(ms) { return new Promise(function (r) { setTimeout(r, Math.max(0, Number(ms) || 0)) }) }
+  function leanJobAbs(job) {
+    const rel = String((job && job.rel) || '')
+    if (!rel) return null
+    return job.scope === 'root' ? normalizeAbsPath(vibeAbs(rel)) : normalizeAbsPath(frameworkRoot() + '/' + rel)
+  }
+  /** 作业的回执路径与归档路径（lean_job 返回它们，修订 §3）。 */
+  function leanJobPaths(job) {
+    const rec = { receipt: 'Formal/Jobs/' + job.jobId + '.json' }
+    if (job.kind === 'archive' && job.archive && job.archive.kind === 'proof' && job.target) {
+      rec.work = job.rel
+      rec.archive = job.state === 'settled' ? ('Verified/Lean/' + job.target + '.lean') : ''
+    } else if (job.kind === 'archive') rec.archive = job.rel
+    else rec.file = job.rel
+    return rec
+  }
+  function leanJobRecord(job) {
+    return {
+      jobId: job.jobId, kind: job.kind, state: job.state, attempts: Number(job.attempts || 1),
+      target: job.target || '', name: job.name || '', rel: job.rel || '', scope: job.scope || 'project',
+      sha256: job.sha || '', buildSha256: job.buildSha || '', buildContext: job.buildCtx || '',
+      engine: (job.plan && job.plan.engine) || '', argv: (job.plan && job.plan.args) || [], searchPaths: (job.plan && job.plan.searchPaths) || [],
+      archiveKind: (job.archive && job.archive.kind) || '',
+      enqueuedAt: job.enqueuedAt || 0, startedAt: job.startedAt || 0, settledAt: job.settledAt || 0,
+      exitCode: job.exitCode === undefined ? null : job.exitCode,
+      timedOut: !!job.timedOut, interrupted: !!job.interrupted, note: job.note || '',
+      project: currentProject,
+    }
+  }
+  async function writeLeanJobFile(job) { await writeJson('Formal/Jobs/' + job.jobId + '.json', leanJobRecord(job)) }
+  function hydrateLeanJob(rec) {
+    return {
+      jobId: String(rec.jobId), kind: rec.kind || 'run', target: rec.target || '', name: rec.name || '',
+      rel: rec.rel || '', scope: rec.scope || 'project', sha: rec.sha256 || '',
+      buildSha: rec.buildSha256 || '', buildCtx: rec.buildContext || '',
+      plan: rec.engine !== undefined ? { engine: rec.engine || '', args: rec.argv || [], searchPaths: rec.searchPaths || [] } : null,
+      archive: rec.archiveKind ? { kind: rec.archiveKind, target: rec.target || '', name: rec.name || '' } : null,
+      state: rec.state || 'queued', attempts: Number(rec.attempts || 1), enqueuedAt: Number(rec.enqueuedAt || 0),
+      startedAt: Number(rec.startedAt || 0), settledAt: Number(rec.settledAt || 0),
+      exitCode: rec.exitCode === undefined ? null : rec.exitCode, timedOut: !!rec.timedOut,
+      interrupted: !!rec.interrupted, run: rec.run || null, note: rec.note || '',
+    }
+  }
+  /** 入队：同 jobId 已在队列/在跑 ⇒ 复用（幂等）；返回作业对象。 */
+  async function enqueueLeanJob(spec) {
+    const existing = leanJobs.get(spec.jobId)
+    if (existing && (existing.state === 'queued' || existing.state === 'running')) return existing
+    const job = Object.assign({}, spec, {
+      state: 'queued', attempts: Number(spec.attempts || ((existing && existing.attempts) || 0) + 1),
+      enqueuedAt: spec.enqueuedAt || now(), startedAt: 0, settledAt: 0, exitCode: null,
+      timedOut: false, interrupted: false, run: null, note: spec.note || '',
+    })
+    leanJobs.set(job.jobId, job)
+    leanQueue.push(job)
+    await writeLeanJobFile(job)
+    logActivity('formal', 'Lean 作业入队 ' + job.jobId + '（' + job.kind + (job.target ? '｜对象 ' + job.target : (job.name ? '｜' + job.name : '')) + '，state=queued）')
+    return job
+  }
+  function pushLeanNotice(line) { if (leanPendingNotices.length >= 20) leanPendingNotices.shift(); leanPendingNotices.push(String(line)) }
+  /** 一次性公告（spec §2.4）：取走即清空，保证同一条结果只注入一次。 */
+  function leanNoticeSection() {
+    if (leanPendingNotices.length === 0) return ''
+    const lines = leanPendingNotices.splice(0, leanPendingNotices.length)
+    return '\n' + lines.join('\n') + '\n'
+  }
+  function leanJobPublic(job) { return { jobId: job.jobId, state: job.state, rel: job.rel || '', target: job.target || '', attempts: Number(job.attempts || 1), settledAt: Number(job.settledAt || 0) } }
+  /**
+   * 心跳里推进队列：**不 await 编译本身**（调用方不 await 本函数）。
+   * 并发上限 = `leanJobsMaxParallel`（默认 1，串行）；串行时本函数等待该作业跑完再返回。
+   */
+  async function runLeanQueue() {
+    const max = leanJobsMaxParallel()
+    let started = 0
+    while (leanQueue.length > 0 && leanActiveCount() + started < max) {
+      const job = leanQueue.shift()
+      if (!job || job.state !== 'queued') continue
+      started++
+      if (max <= 1) { await runLeanJob(job); return }
+      runLeanJob(job).catch(function (e) { console.error('vibe-math-v2: lean job failed: ' + String((e && e.message) || e)) })
+    }
+  }
+  async function runLeanJob(job) {
+    if (job.state !== 'queued') return
+    job.state = 'running'; job.startedAt = now(); job.interrupted = false
+    await writeLeanJobFile(job)
+    let run
+    try { run = await leanExecFile(job.rel, leanJobAbs(job), job.timeoutMs, job.plan, function (h) { if (h) leanRunningHandles.set(job.jobId, h); else leanRunningHandles.delete(job.jobId) }) }
+    catch (e) { run = { ok: false, exitCode: null, code: 'LEAN_RUN_FAILED', message: String((e && e.message) || e), ms: 0 } }
+    try { await settleLeanJob(job, run) } catch (e) { console.error('vibe-math-v2: lean job settle failed: ' + String((e && e.stack) || e)) }
+  }
+  /** 结果公告行（spec §2.4 的四种结局）。 */
+  function leanSettleNotice(job, settledOk, capMs) {
+    const ms = (job.run && job.run.ms) || 0
+    if (job.interrupted) return '【形式化结果】' + job.jobId + '：中断（会话卸载或崩溃，已标记 attempted，可重跑）'
+    if (job.timedOut) return '【形式化结果】' + job.jobId + '：超时（leanTimeoutMs=' + capMs + ' 已 terminate；对象留在 attempted）'
+    if (settledOk) return '【形式化结果】' + job.jobId + '：通过（exit 0，' + (ms / 1000).toFixed(1) + 's' + ((job.kind === 'archive' && job.archive && job.archive.kind === 'proof') ? ('，已归档 Verified/Lean/' + job.target + '.lean') : '') + '）'
+    if (job.hashMismatch) return '【形式化结果】' + job.jobId + '：失败（编译期间文件内容已变，本次结果已丢弃；请重跑）'
+    if (job.contextMismatch) return '【形式化结果】' + job.jobId + '：失败（编译期间构建上下文已变：引擎/参数/搜索路径，本次结果已丢弃；请在新上下文下重跑）'
+    return '【形式化结果】' + job.jobId + '：失败（exit ' + String(job.exitCode) + '，见 stderr 尾部）'
+  }
+  /**
+   * 落地一个作业（**唯一**的 passed 入口，spec §2.1）：只有 exit 0 **且** 内容哈希仍匹配才算 ok；
+   * 其余一律 attempted；中断/超时都不是 passed；内容变了只标记不贴结果。
+   */
+  async function settleLeanJob(job, run) {
+    const capMs = Math.max(1000, Number(job.timeoutMs) || Number(params.leanTimeoutMs) || 120000)
+    let currentSha = null
+    try { const t = await readTextAbs(leanJobAbs(job)); if (t !== undefined) currentSha = leanContentSha(t) } catch (e) { /* 读不到 ⇒ 视为不匹配 */ }
+    const hashOk = currentSha !== null && currentSha === job.sha
+    // 修订 §4：结果只对**产生它的那个构建上下文**有效。参数在编译途中被改（引擎/参数/搜索路径）
+    // ⇒ 这次 ok 不能贴到"现在的配置"上，宁可判为未通过并明确公告。
+    const ctxNow = leanContextNow()
+    const ctxOk = !job.buildCtx || job.buildCtx === ctxNow
+    job.hashMismatch = !hashOk
+    job.contextMismatch = !ctxOk
+    job.exitCode = run.exitCode === undefined ? null : run.exitCode
+    job.timedOut = !!run.timedOut
+    job.settledAt = now()
+    const settledOk = !job.interrupted && !job.timedOut && run.exitCode === 0 && hashOk && ctxOk
+    job.state = job.interrupted ? 'interrupted' : (job.timedOut ? 'timeout' : (settledOk ? 'settled' : 'failed'))
+    job.run = { at: now(), ok: settledOk, exitCode: job.exitCode, ms: run.ms || 0, timedOut: !!job.timedOut, interrupted: !!job.interrupted, stdoutTail: tailText(run.stdout, 800), stderrTail: tailText(run.stderr, 800), searchPath: run.searchPath || vibeRoot(), buildContext: job.buildCtx || '' }
+    if (job.hashMismatch && !job.interrupted && !job.timedOut) job.note = 'file changed while compiling — result discarded (hash mismatch)'
+    else if (job.contextMismatch && !job.interrupted && !job.timedOut) job.note = 'build context changed while compiling (engine/args/search paths) — result discarded; re-run under the new context'
+    const asyncInfo = { jobId: job.jobId, state: job.state, attempts: job.attempts, enqueuedAt: job.enqueuedAt, startedAt: job.startedAt, settledAt: job.settledAt, exitCode: job.exitCode, buildSha256: job.buildSha || '' }
+    if (job.kind === 'archive') await settleLeanArchiveJob(job, settledOk, asyncInfo)
+    else if (job.target) await formalSetRun(job.target, Object.assign({}, run, { ok: settledOk, file: job.rel }), asyncInfo)
+    if (!job.interrupted) await writeFormalIndex()
+    await writeLeanJobFile(job)
+    pushLeanNotice(leanSettleNotice(job, settledOk, capMs))
+    logActivity('formal', 'Lean 作业 ' + job.jobId + ' ' + job.state + '（' + job.kind + '）' + (job.target ? '｜对象 ' + job.target : ''))
+    reportDirty = true
+  }
+  /** 归档类作业的落地：**只有 ok 才落库/置 passed**（def/lemma 的文件在入队前已写好）。 */
+  async function settleLeanArchiveJob(job, ok, asyncInfo) {
+    const a = job.archive || {}
+    if (a.kind !== 'proof') {
+      await rebuildLeanLibIndexes()
+      logActivity('formal', '归档作业 ' + job.jobId + '（' + a.kind + ' ' + job.rel + '）' + (ok ? '运行通过' : '运行未通过（见 stderr 尾部；该文件不应被当作可复用定义）'))
+      return
+    }
+    const target = job.target
+    const prev = formalOf(target)
+    const passed = !!ok
+    const stalePrev = passed ? '' : String(prev.proof || ('Verified/Lean/' + target + '.lean'))
+    const rec = Object.assign({}, prev, {
+      status: passed ? 'passed' : 'attempted',
+      file: job.rel,
+      proof: passed ? 'Verified/Lean/' + target + '.lean' : '',
+      decision: 'used',
+      note: String(prev.note || ''),
+      run: job.run,
+      async: asyncInfo,
+      updatedAt: now(),
+    })
+    let withdrawn = null
+    if (passed) {
+      const body = await readTextAbs(leanJobAbs(job))
+      if (body !== undefined) await writeText('Verified/Lean/' + target + '.lean', body)
+    } else if (stalePrev) { try { withdrawn = await withdrawArchivedProof(stalePrev) } catch (e) { withdrawn = { rel: stalePrev, outcome: 'failed' } } }
+    await putFormal(target, rec)
+    await syncVerificationTarget(target, rec.status, rec)
+    await rebuildLeanLibIndexes()
+    logActivity('formal', '归档作业 ' + job.jobId + ' 为 ' + target + ' ' + (passed ? ('通过，已归档 ' + rec.proof + '，验证转为忠实性审查')
+      : ('未通过：' + tailText(job.run && job.run.stderrTail, 160) + '；已撤回上一份已通过状态与归档证明' + (withdrawn && withdrawn.outcome !== 'failed' ? '（' + withdrawn.outcome + '）' : '（⚠ 撤回失败，请不要把 ' + stalePrev + ' 当作该对象的证明）'))))
+  }
+  /** 去重（spec §4.3）：同内容且已成功过 ⇒ 跳过写盘与重编译。 */
+  async function leanDedupeLookup(jobId, abs, sha, proofTarget) {
+    if (proofTarget) {
+      const rec = formalOf(proofTarget)
+      if (rec && rec.status === 'passed') {
+        const cur = await readTextAbs(vibeAbs('Verified/Lean/' + proofTarget + '.lean'))
+        if (cur !== undefined && leanContentSha(cur) === sha) return { deduped: true, file: 'Verified/Lean/' + proofTarget + '.lean' }
+      }
+      return null
+    }
+    const prev = await readJson('Formal/Jobs/' + jobId + '.json')
+    if (leanJobSettledOk(prev)) {
+      const cur = await readTextAbs(abs)
+      if (cur !== undefined && leanContentSha(cur) === sha) return { deduped: true, file: String(prev.rel || '') }
+    }
+    return null
+  }
+  /** 后台作业的公共返回形状（§1.2）。 */
+  function leanAsyncReturn(job, extra) {
+    return Object.assign({
+      ok: true, async: { jobId: job.jobId, state: job.state }, jobId: job.jobId,
+      message: '已入队后台编译（并发上限 1）；你可以继续工作。结果会写入 Formal/ 与索引，并在下一轮提示里公告；也可用 vibe_math_lean_lib 的 jobs 字段随时查看。**在该作业落地为通过之前，不得把相关对象当成已通过。**',
+    }, extra || {})
+  }
+  /** 崩溃恢复（spec §2.6）：queued 重入队；running 哈希匹配 ⇒ 标记 interrupted + 重入队（attempts+1），不匹配 ⇒ 只标记；恢复**绝不**置 passed。 */
+  async function recoverLeanJobs() {
+    let files = []
+    try { files = (await listFiles('Formal/Jobs')) || [] } catch (e) { return { recovered: 0 } }
+    let recovered = 0
+    for (let i = 0; i < files.length; i++) {
+      const f = String(files[i])
+      if (!/\.json$/.test(f)) continue
+      const rec = await readJson('Formal/Jobs/' + f)
+      if (!rec || !rec.jobId) continue
+      // 本进程内存里已知的作业（queued/running 或已落地）不再恢复：同一进程内切换项目时，
+      // 内存队列还在正常跑，按文件状态"恢复"会把一个在跑的作业误判成崩溃（重复入队/误置 interrupted）。
+      if (leanJobs.has(String(rec.jobId))) continue
+      const job = hydrateLeanJob(rec)
+      leanJobs.set(job.jobId, job)
+      const abs = leanJobAbs(job)
+      const txt = abs ? await readTextAbs(abs) : undefined
+      const curSha = txt === undefined ? null : leanContentSha(txt)
+      const hashMatch = curSha !== null && curSha === job.sha
+      if (job.state === 'queued') {
+        await enqueueLeanJob(job)
+        pushLeanNotice('【形式化结果】' + job.jobId + '：上次会话未执行的排队作业已重新入队')
+        recovered++
+      } else if (job.state === 'running') {
+        if (hashMatch) {
+          if (job.target) await putFormal(job.target, Object.assign({}, formalOf(job.target), { status: 'attempted', async: { jobId: job.jobId, state: 'interrupted', attempts: job.attempts }, updatedAt: now() }))
+          job.interrupted = true
+          // 先落到 interrupted，再重入队：否则 enqueueLeanJob 的幂等守卫会把这条 "running" 记录
+          // 当成"仍在跑"而早退，attempts 也不会 +1（恢复就静默失效了）。
+          job.state = 'interrupted'
+          await enqueueLeanJob(Object.assign({}, job, { attempts: job.attempts + 1 }))
+          pushLeanNotice('【形式化结果】' + job.jobId + '：中断（会话崩溃，已标记 attempted，已用新 attempts 重新入队）')
+        } else {
+          if (job.target) await putFormal(job.target, Object.assign({}, formalOf(job.target), { status: 'attempted', async: { jobId: job.jobId, state: 'interrupted', attempts: job.attempts, note: 'file changed' }, updatedAt: now() }))
+          job.state = 'interrupted'; job.interrupted = true
+          job.note = 'file changed while the previous session was compiling — not auto-re-driven'
+          await writeLeanJobFile(job)
+          pushLeanNotice('【形式化结果】' + job.jobId + '：中断（文件已变，未自动重驱；请手动重跑）')
+        }
+        recovered++
+      } else if (job.state === 'settled') {
+        // 修订 §4：只有**同一构建上下文**下的 settled(ok) 才允许恢复成 passed。
+        const ctxNow = leanContextNow()
+        const ctxOk = !job.buildCtx || job.buildCtx === ctxNow
+        if (leanJobSettledOk(rec) && hashMatch && ctxOk) {
+          job.run = { at: now(), ok: true, exitCode: 0, ms: 0, timedOut: false, interrupted: false, stdoutTail: '', stderrTail: '', searchPath: vibeRoot(), buildContext: job.buildCtx || '' }
+          if (job.kind === 'archive') await settleLeanArchiveJob(job, true, { jobId: job.jobId, state: 'settled', attempts: job.attempts, settledAt: job.settledAt, exitCode: 0, buildSha256: job.buildSha || '' })
+          else if (job.target) await formalSetRun(job.target, job.run, { jobId: job.jobId, state: 'settled', buildSha256: job.buildSha || '' })
+          pushLeanNotice('【形式化结果】' + job.jobId + '：已按作业记录补写归档与 passed（恢复时校验内容哈希与构建上下文一致）')
+        } else if (job.target) {
+          await putFormal(job.target, Object.assign({}, formalOf(job.target), { status: 'attempted', async: { jobId: job.jobId, state: 'interrupted', attempts: job.attempts, note: ctxOk ? 'recovered-incomplete' : 'build context changed' }, updatedAt: now() }))
+          pushLeanNotice('【形式化结果】' + job.jobId + '：按作业记录标记为未通过/已变（恢复绝不置 passed）')
+        }
+        recovered++
+      }
+    }
+    if (recovered > 0) logActivity('formal', 'Lean 作业恢复：处理了 ' + recovered + ' 条遗留作业记录（queued 重入队 / running 标记中断 / settled 补写；绝不置 passed）')
+    return { recovered: recovered }
+  }
+  /** 会话卸载/销毁：终止在跑的编译并标记 interrupted（不留孤儿进程，spec §2.5）。 */
+  function disposeLeanJobs() {
+    let n = 0
+    for (const job of leanJobs.values()) {
+      if (job.state === 'running') { job.interrupted = true; n++ }
+    }
+    for (const job of leanQueue) { job.state = 'interrupted'; job.interrupted = true; n++ }
+    for (const h of leanRunningHandles.values()) {
+      try { if (h && typeof h.terminate === 'function') h.terminate() } catch (e) { /* best effort */ }
+    }
+    leanRunningHandles.clear()
+    if (leanSyncHandle && typeof leanSyncHandle.terminate === 'function') { try { leanSyncHandle.terminate() } catch (e) { /* best effort */ } }
+    leanSyncHandle = null
+    leanQueue.length = 0
+    if (n > 0) {
+      pushLeanNotice('【形式化结果】干预：会话卸载，' + n + ' 个 Lean 作业已标记 interrupted（未落地为 passed）')
+      // 落盘尽力而为（disposer 不能 await）：作业记录留着，供下次 init 恢复时标记。
+      try {
+        for (const job of leanJobs.values()) { if (job.state === 'running' || job.interrupted) writeLeanJobFile(job).catch(function () { }) }
+      } catch (e) { /* best effort */ }
+    }
+    return n
+  }
+
   // ---- 三份索引（框架维护；契约 §9）----
   async function writeFormalIndex() {
     const recs = formalRecords()
@@ -1113,6 +1651,7 @@ export function apply(ctx) {
   async function rebuildLeanLibIndexes() {
     // 扫描**不执行**工具链：每次问"有什么可复用"就跑一遍 lean 既慢又出人意料。
     // 每个对象的运行结果存在对象记录里，显示在 Formal/Index.md。
+    // 依赖列（spec §4.4）：把 `import` 行扫出来写进索引，"有什么 / 叫什么 / 怎么导入"三问一次答完。
     const scan = async (dirAbs, dirRel, kindLabel) => {
       const rows = []
       try {
@@ -1125,21 +1664,23 @@ export function apply(ctx) {
           const txt = (await readTextAbs(dirAbs + '/' + e.name)) || ''
           const name = String(e.name).replace(/\.lean$/, '')
           const first = (txt.split('\n').filter(function (l) { return l.trim() && !/^\s*(\/\/|--|import)/.test(l) })[0] || '').trim().slice(0, 110)
-          rows.push('| ' + name + ' | ' + rel + ' | ' + kindLabel + ' | ' + first.replace(/\|/g, '/') + ' |')
+          const deps = txt.split('\n').filter(function (l) { return /^\s*import\s+/.test(l) })
+            .map(function (l) { return l.trim().replace(/^import\s+/, '').trim() }).filter(Boolean).slice(0, 4)
+          rows.push('| ' + name + ' | ' + rel + ' | ' + kindLabel + ' | ' + (deps.length ? deps.join(', ') : '—').replace(/\|/g, '/') + ' | ' + first.replace(/\|/g, '/') + ' |')
         }
       } catch (e) { /* 列表尽力而为 */ }
       return rows
     }
     const libRows = await scan(vibeRoot() + '/Formal/Lib', 'Formal/Lib', 'def')
     await writeTextAbs(vibeRoot() + '/Formal/Lib/Index.md', ['# 可复用 Lean 定义库（跨项目）｜' + currentProject, '',
-      '> 写新定义之前先查这里：能复用就不要重新定义。', '',
-      '| 名称 | 文件 | 类别 | 摘要 |', '|---|---|---|---|']
-      .concat(libRows.length ? libRows : ['| （暂无） | | | |']).join('\n') + '\n')
+      '> 写新定义之前先查这里：能复用就不要重新定义。复用方式：`import Formal.Lib.<名称>`（模块根 = VibeMath 根）。', '',
+      '| 名称 | 文件 | 类别 | 依赖（import） | 摘要 |', '|---|---|---|---|---|']
+      .concat(libRows.length ? libRows : ['| （暂无） | | | | |']).join('\n') + '\n')
     const provedRows = await scan(vibeRoot() + '/Formal/Proved', 'Formal/Proved', 'lemma')
     await writeTextAbs(vibeRoot() + '/Formal/Proved/Index.md', ['# 已成立的 Lean 命题 / 引理（机器已核对，可跨项目复用）｜' + currentProject, '',
-      '> 这些文件是通过内核检查的引理，可直接 import 复用。', '',
-      '| 名称 | 文件 | 类别 | 陈述 |', '|---|---|---|---|']
-      .concat(provedRows.length ? provedRows : ['| （暂无） | | | |']).join('\n') + '\n')
+      '> 这些文件是通过内核检查的引理，可直接 import 复用：`import Formal.Proved.<名称>`。', '',
+      '| 名称 | 文件 | 类别 | 依赖（import） | 陈述 |', '|---|---|---|---|---|']
+      .concat(provedRows.length ? provedRows : ['| （暂无） | | | | |']).join('\n') + '\n')
     await writeFormalIndex()
     await writeFormalTodo()
     return { lib: libRows.length, proved: provedRows.length, objects: Object.keys(formalRecords()).length }
@@ -1147,20 +1688,110 @@ export function apply(ctx) {
 
   // 执行一个 Lean 文件，记录运行结果（可按 target 归属到对象），刷新索引，并**原样**回报结果。
   // 刻意在 `off` 档也照常工作：人要调试自己的工具链时仍然可用。
+  // leanAsync=true（默认）：入队后立即返回（成员不阻塞）；false：逐字保留今天的同步路径。
   async function leanRunTool(memberId, o) {
     const args = o || {}
-    const run = await leanRunFile(String(args.file || ''), args.timeout_ms)
+    const rel = String(args.file || '').trim()
+    const target = String(args.target || '').trim()
+    if (params.leanAsync !== false) {
+      const guard = await leanResolveRunTarget(rel)
+      if (!guard.ok) return guard
+      const plan = leanBuildPlan()
+      const ctx = leanPlanContext(plan)
+      const fp = leanJobFingerprint(guard.text, ctx)
+      const jobId = leanJobId(target || guard.rel, fp)
+      const job = await enqueueLeanJob({ jobId: jobId, kind: 'run', key: target || guard.rel, rel: guard.rel, scope: 'project', target: target, sha: guard.sha, buildSha: fp, buildCtx: ctx, plan: plan, memberId: memberId, timeoutMs: args.timeout_ms })
+      return leanAsyncReturn(job, { file: guard.rel, state: job.state, hint: '已入队。**在它落地为通过之前，不得把该对象当成已通过**；结果会在下一轮提示的【形式化结果】行里公告，或用 vibe_math_lean_job / vibe_math_lean_lib 的 jobs 字段查看（lean_job 可 waitMs=… 等待）。' })
+    }
+    const run = await leanRunFile(rel, args.timeout_ms)
     if (run.ok || run.file) {
-      if (String(args.target || '').trim()) await formalSetRun(String(args.target), run)
+      if (target) await formalSetRun(target, run)
       await writeFormalIndex()
     }
     if (run.ok) logActivity('formal', (memberId || 'office') + ' 运行 Lean 通过：' + run.file + '（' + (run.ms / 1000).toFixed(1) + 's）' + (args.target ? '｜对象 ' + args.target : ''))
     return Object.assign({ ok: !!run.ok }, run, {
+      async: null,
       hint: run.ok
         ? '通过。若是某个对象的证明，请用 vibe_math_lean_archive kind=\'proof\' 归档（会写入 Verified/Lean/ 并把审查对象变成忠实性）；若是可复用定义/引理，用 kind=\'def\'/\'lemma\' 归档到全局库（归档时会先跑一次，跑不通不要入库）。'
         : '未通过。请按上面的编译器输出修复后重跑；若判断无法完成，用 vibe_math_lean_archive kind=\'blocked\' 记录原因。',
     })
   }
+  /** 异步档的路径/存在性校验（与 leanRunFile 同一套守卫与错误码）。 */
+  async function leanResolveRunTarget(relPath) {
+    const rel = String(relPath || '').trim()
+    if (!rel) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'file is required' }
+    const abs = leanAbsPath(rel)
+    if (abs === null) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'Lean 文件必须位于 ' + vibeRoot() + '/ 之内（收到 ' + rel + '）' }
+    if (!/\.lean$/.test(abs)) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: '只有 .lean 文件可以执行' }
+    const txt = await readTextAbs(abs)
+    if (txt === undefined) return { ok: false, code: 'V2_NOT_FOUND', message: 'no such file: ' + rel }
+    return { ok: true, rel: rel, abs: abs, sha: leanContentSha(txt), text: txt }
+  }
+  /**
+   * `lean_job`（修订 §3，只读）：不带 jobId ⇒ 本会话作业清单；带 ⇒ 该作业的 state/exitCode/
+   * 回执路径/归档路径。`waitMs>0` 时最多等这么久（内部轮询，**不阻塞心跳**——心跳是独立 timer），
+   * 超时就返回当前 state。
+   */
+  async function leanJobTool(o) {
+    const args = o || {}
+    const wantId = String(args.jobId || '').trim()
+    const waitMs = Math.max(0, Math.min(600000, Number(args.waitMs) || 0))
+    if (!wantId) {
+      const jobs = []
+      for (const j of leanJobs.values()) jobs.push(Object.assign(leanJobPublic(j), { exitCode: j.exitCode === undefined ? null : j.exitCode, paths: leanJobPaths(j), buildSha256: j.buildSha || '' }))
+      jobs.sort(function (a, b) { return (b.settledAt || 0) - (a.settledAt || 0) || String(a.jobId).localeCompare(String(b.jobId)) })
+      return { ok: true, async: params.leanAsync !== false, maxParallel: leanJobsMaxParallel(), queued: leanQueue.length, running: leanActiveCount(), jobs: jobs, paths: { receipts: 'Formal/Jobs/', proofs: 'Verified/Lean/', lib: 'VibeMath/Formal/Lib/', proved: 'VibeMath/Formal/Proved/' }, hint: 'state=settled 且 exitCode=0（且内容哈希/构建上下文一致）才算通过；queued/running 一律还不算。' }
+    }
+    let job = leanJobs.get(wantId)
+    if (!job) {
+      const rec = await readJson('Formal/Jobs/' + wantId + '.json')
+      if (!rec || !rec.jobId) return { ok: false, code: 'V2_NOT_FOUND', message: 'no such Lean job: ' + wantId + '（用不带 jobId 的 vibe_math_lean_job 列清单）' }
+      job = hydrateLeanJob(rec)
+      if (!leanJobs.has(job.jobId)) leanJobs.set(job.jobId, job)
+    }
+    const startedAt = now()
+    while (waitMs > 0 && (job.state === 'queued' || job.state === 'running') && (now() - startedAt) < waitMs) {
+      await leanSleep(50)
+      const cur = leanJobs.get(wantId)
+      if (cur) job = cur
+    }
+    return {
+      ok: true, jobId: job.jobId, state: job.state, exitCode: job.exitCode === undefined ? null : job.exitCode,
+      attempt: Number(job.attempts || 1), timedOut: !!job.timedOut, interrupted: !!job.interrupted, note: job.note || '',
+      buildSha256: job.buildSha || '', buildContext: job.buildCtx || '',
+      waitedMs: now() - startedAt, stillRunning: (job.state === 'queued' || job.state === 'running'),
+      passed: leanJobSettledOk(leanJobRecord(job)),
+      paths: leanJobPaths(job),
+      run: job.run || null,
+    }
+  }
+  /** `lean_read`：只读地取回归档的 Lean 原文（verbatim 复用；§1.2）。 */
+  async function leanReadTool(o) {
+    const args = o || {}
+    const rawName = String(args.name || '').trim()
+    if (!rawName) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'name is required' }
+    if (rawName.indexOf('..') !== -1 || /[\\/]/.test(rawName) || /^[a-z]:/i.test(rawName)) {
+      return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'name must be a bare library name (no path separators, no "..", no absolute path)' }
+    }
+    const name = safeId(rawName)
+    const kind = (args.kind === 'lib' || args.kind === 'proved') ? args.kind : 'auto'
+    const order = kind === 'auto' ? ['lib', 'proved'] : [kind]
+    for (let i = 0; i < order.length; i++) {
+      const k = order[i]
+      const rel = 'Formal/' + (k === 'lib' ? 'Lib' : 'Proved') + '/' + name + '.lean'
+      const dir = normalizeAbsPath(vibeRoot() + '/Formal/' + (k === 'lib' ? 'Lib' : 'Proved'))
+      const abs = normalizeAbsPath(vibeAbs(rel))
+      // 双保险：规范化后必须真的落在那两个目录之内（name 已过 safeId，这里是路径守卫）
+      if (abs.indexOf(dir + '/') !== 0) continue
+      const txt = await readTextAbs(abs)
+      if (txt === undefined) continue
+      const LIMIT = 64 * 1024
+      const bytes = Buffer.byteLength(txt, 'utf8')
+      const truncated = bytes > LIMIT
+      return { ok: true, name: name, file: rel, kind: k, sha256: leanContentSha(txt), bytes: bytes, text: truncated ? Buffer.from(txt, 'utf8').slice(0, LIMIT).toString('utf8') : txt, truncated: truncated }
+    }
+    return { ok: false, code: 'V2_NOT_FOUND', message: 'no archived Lean file named ' + name + '（查过 Formal/Lib 与 Formal/Proved）；可先用 vibe_math_lean_lib 看清单' }
+  }
   async function leanArchive(memberId, o) {
     const args = o || {}
     const kind = String(args.kind || '')
@@ -1181,6 +1812,22 @@ export function apply(ctx) {
       if (body === undefined) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'provide content, or from=<existing .lean file>' }
       const rel = 'Formal/' + (kind === 'def' ? 'Lib' : 'Proved') + '/' + name + '.lean'
       const abs = vibeAbs(rel)
+      const sha = leanContentSha(body)
+      const plan = leanBuildPlan()
+      const ctx = leanPlanContext(plan)
+      const fp = leanJobFingerprint(body, ctx)               // 修订 §4：指纹含内容 + 构建上下文
+      const jobId = leanJobId(name, fp)
+      // 去重（§4.3）：同内容 + 同构建上下文且已成功归档过 ⇒ 跳过重写与重编译。
+      const dedupe = await leanDedupeLookup(jobId, abs, sha, null)
+      if (dedupe) {
+        logActivity('formal', (memberId || 'office') + ' 归档 ' + kind + ' `' + name + '` 命中去重（同内容与构建上下文，跳过重写与重编译）')
+        return { ok: true, kind: kind, name: name, file: rel, deduped: true, sha256: sha, buildSha256: fp, note: '内容与构建上下文都与已归档并编译通过的版本一致：跳过重写与重编译（去重）。' }
+      }
+      if (params.leanAsync !== false && args.run !== false) {
+        if (!await writeTextAbs(abs, body)) return { ok: false, code: 'V2_WRITE_FAILED', message: 'could not write ' + rel }
+        const job = await enqueueLeanJob({ jobId: jobId, kind: 'archive', key: name, rel: rel, scope: 'root', name: name, target: '', sha: sha, buildSha: fp, buildCtx: ctx, plan: plan, memberId: memberId, archive: { kind: kind } })
+        return leanAsyncReturn(job, { kind: kind, name: name, file: rel, sha256: sha, buildSha256: fp, deduped: false, note: '文件已写入 ' + rel + '；编译已入队（并发上限 leanJobsMaxParallel）。**落地为通过之前，请不要把它当作可复用定义**；结果会在下一轮提示的【形式化结果】行公告，也可用 vibe_math_lean_job 查/等。' })
+      }
       if (!await writeTextAbs(abs, body)) return { ok: false, code: 'V2_WRITE_FAILED', message: 'could not write ' + rel }
       // 全局库在项目树之外，必须用**绝对路径**执行（相对形式会被解析到项目根之内）。
       const run = args.run === false ? null : await leanRunFile(abs)
@@ -1207,6 +1854,35 @@ export function apply(ctx) {
       }
       if (body === undefined) return { ok: false, code: 'V2_INVALID_ARGUMENT', message: 'provide content, or from=<existing .lean file>' }
       const workRel = 'Formal/' + target + '.lean'
+      const sha = leanContentSha(body)
+      const plan = leanBuildPlan()
+      const ctx = leanPlanContext(plan)
+      const fp = leanJobFingerprint(body, ctx)
+      const jobId = leanJobId(target, fp)
+      // 去重（§4.3）：对象已 passed 且归档证明与新提交内容一致 ⇒ 跳过。
+      const dedupe = await leanDedupeLookup(jobId, null, sha, target)
+      if (dedupe) {
+        logActivity('formal', (memberId || 'office') + ' 归档证明 ' + target + ' 命中去重（已 passed 且内容一致）')
+        return { ok: true, kind: kind, target: target, file: workRel, proof: dedupe.file, passed: true, deduped: true, sha256: sha, buildSha256: fp, status: 'passed', note: '该对象已是 passed，且归档证明与新提交内容一致：跳过重写与重编译（去重）。' }
+      }
+      if (params.leanAsync !== false) {
+        if (!await writeText(workRel, body)) return { ok: false, code: 'V2_WRITE_FAILED', message: 'could not write ' + workRel }
+        const prevA = formalOf(target)
+        await putFormal(target, Object.assign({}, prevA, {
+          status: prevA.status === 'passed' ? 'passed' : 'attempted',
+          file: workRel,
+          decision: 'used',
+          note: String(args.note || prevA.note || ''),
+          async: { jobId: jobId, state: 'queued', attempts: 0, enqueuedAt: now(), startedAt: 0, settledAt: 0, exitCode: null, buildSha256: fp },
+          updatedAt: now(),
+        }))
+        await writeFormalIndex()
+        const job = await enqueueLeanJob({ jobId: jobId, kind: 'archive', key: target, rel: workRel, scope: 'project', target: target, sha: sha, buildSha: fp, buildCtx: ctx, plan: plan, memberId: memberId, archive: { kind: 'proof', target: target } })
+        return leanAsyncReturn(job, {
+          kind: kind, target: target, file: workRel, status: 'attempted', sha256: sha, buildSha256: fp,
+          note: '工作文件已写入 ' + workRel + '；编译已入队。**只有该作业在同一个构建上下文下落地为通过，才会写入 Verified/Lean/' + target + '.lean 并把状态变为 passed**——在它落地之前，这个对象不是"已通过形式化"。',
+        })
+      }
       if (!await writeText(workRel, body)) return { ok: false, code: 'V2_WRITE_FAILED', message: 'could not write ' + workRel }
       const run = await leanRunFile(workRel)
       const prev = formalOf(target)
@@ -1514,10 +2190,13 @@ export function apply(ctx) {
   // 提示词里不能出现任何 Lean 字样（contract §2 / §10.1）。
   function formalWorkSection() {
     const t = formalWorkLine()
-    if (!t) return ''
+    const notice = leanNoticeSection()
+    const math = mathWorkLine()
+    if (!t && !notice && !math) return ''
     // 回执契约（契约 §6.3）：工作轮也必须被告知 formal 字段，否则"顺手形式化"里做出的难度判断
     // 无处可写，代理只能沉默——那正是 v2 首版死通道的成因。
-    return '\n' + t + formalReplyNote() + '\n'
+    // 数学计算可用性行（prompts.md §2+§4）：与"顺手形式化"并列注入；off 档为空串。
+    return '\n' + t + formalReplyNote() + notice + math + '\n'
   }
   function capabilitiesText(role) {
     const maxCalls = role === 'solver' ? params.solverMaxToolCalls : params.verifierMaxToolCalls
@@ -1759,11 +2438,18 @@ export function apply(ctx) {
       await maybeWriteReport(false)
       const qs = await getQs()
       const unsolved = qs.filter(function (q) { return !q.已解决 && q.优先级 !== 'never' })
-      if (unsolved.length === 0 && Object.keys(agentRegistry).length === 0 && Object.keys(tasks).length === 0) {
-        scheduler.running = false
+      // 收口判据（spec v2 §A2/§A3）：**排除**论文撰写子代理——它自己不能阻止收口，也不该被算作"在途工作"。
+      const realAgents = Object.keys(agentRegistry).filter(function (cid) { const m = agentRegistry[cid]; return m && m.role !== 'paper' }).length
+      if (unsolved.length === 0 && realAgents === 0 && Object.keys(tasks).length === 0) {
         logActivity('stop', 'all active problems solved (never-priority problems excluded) and no active agents/tasks — scheduler stopped (strict termination)')
+        // ★ 最终论文（修订 §A2）：**必须在 running=false 之前**派遣——停止之后 scheduleTick() 是空操作，
+        //   而且 v2 没有任何激活上限处理，被拒的撰写者会静默消失；派不出去就排队，由 apply 级心跳重试。
+        if (params.finalPaper !== false) {
+          try { await maybeWritePaper('auto') } catch (e) { logActivity('paper', '自动撰写最终论文失败：' + String((e && e.message) || e)) }
+        }
+        scheduler.running = false
         await saveAll(); await maybeWriteReport(true); await maybePushReport(true)
-      } else if (Object.keys(agentRegistry).length === 0 && Object.keys(tasks).length === 0 && unsolved.length > 0) {
+      } else if (realAgents === 0 && Object.keys(tasks).length === 0 && unsolved.length > 0) {
         let allBlocked = true
         for (let i = 0; i < unsolved.length; i++) {
           const prog = parseProgress(unsolved[i])
@@ -2663,15 +3349,507 @@ export function apply(ctx) {
   // 卡片写入结果 → 布尔（向后兼容既有的 if (await writeVerifiedCardIfNeeded(p)) 语义）。
   function cardOk(r) { return !!(r && r.ok) }
 
+  // ==========================================================================================
+  // 最终论文（规格：docs/final-paper.md（含本轮修订））—— 会话侧。
+  //
+  // 时序（修订 §A2）：v2 的收口信号是严格终止（本文件 tick() 的 branch，见 `strict termination`）。
+  // `scheduler.running=false` 之后 `scheduleTick()` 变空操作，所以**撰写子代理必须在停止翻转之前**
+  // 派遣；派不出去（宿主激活上限 ACTIVATION_LIMIT_REACHED）时排队，由 apply 级心跳
+  // （paperRetryDue/runPaperRetry）重试并给出可见告警。子代理的回复由 onChildEnd 的 `paper` 分支
+  // 处理（未知 role 会静默丢失）。收口判据里 paper 子代理被排除（realAgents），避免它自己阻止收口。
+  // 落盘（修订 §C/§D）：md/tex 是文本（走宿主 fs），**paper.pdf 只能由编译器子进程生成**，插件只 stat；
+  // paper.meta.json 最后写（提交点）。幂等 = run id + finalizedAt + 逐产物存在性（不引入材料稳定哈希）。
+  // ==========================================================================================
+  let paperInFlight = ''            // 正在撰写的 childId（空 = 无）
+  let paperInFlightAt = 0           // 派遣时刻（判定卡死窗口；force 与心跳都据它降级）
+  let paperReaps = 0                // 本 run 内已回收卡死撰写者的次数（自动重派上限）
+  const paperAbandoned = {}         // childId -> true：已放弃的撰写者；它事后返回时输出被丢弃并留痕
+  let paperPending = null           // 激活上限排队重试：{ tries, retryAt, reason, limit, trigger, opts }
+  const PAPER_RETRY_MS = 5000       // 激活上限拒绝后的重试间隔
+  const PAPER_MAX_RETRIES = 12      // 连续被拒上限（超过则放弃并给可见告警）
+  const PAPER_STALE_MS = 10 * 60 * 1000 // 撰写者卡死窗口：超过它，force 与心跳都会回收并重派（10 分钟）
+  const PAPER_MAX_AUTO_REAPS = 2    // 心跳自动回收+重派的次数上限，之后交给 /vibe paper force
+  const PAPER_LOCK_STALE_MS = 120000 // paper 作用域锁的失效时间（跨会话/跨进程尽力而为）
+  /** 宿主激活上限（maxActiveSubagents）报错里的人数：v4/v5 用的同一判据。 */
+  function activationLimitFrom(message) { const m = /active child limit:\s*(\d+)/.exec(String(message == null ? '' : message)); return m ? Number(m[1]) : undefined }
+  function paperId(opts) { return paperDirId((opts && opts.id) || currentProject) }
+  function paperDir(id) { return 'Paper/' + paperDirId(id) }
+  function paperAbsDir(id) { return frameworkRoot() + '/' + paperDir(id) }
+  function paperAuthorLine() { return 'Vibe Math V2（单作者：论文撰写子代理）· 项目 ' + currentProject }
+  /**
+   * 本次撰写的参数（spec §1/§2）：命令行的 lang=/format= 覆盖参数，参数覆盖默认值。
+   * 非法值已在 paperCommand 里拒绝；这里再做一次保守回退（落到纸面上的参数永远合法）。
+   */
+  function paperOpts(opts) {
+    const o = opts || {}
+    const fmt = (o.format === 'md' || o.format === 'tex' || o.format === 'both') ? o.format : ((params.paperFormat === 'md' || params.paperFormat === 'tex') ? params.paperFormat : 'both')
+    const lang = (o.lang === 'en' || o.lang === 'zh') ? o.lang : (params.paperLanguage === 'en' ? 'en' : 'zh')
+    const compilePdf = (o.compilePdf === true || o.compilePdf === false) ? o.compilePdf : (params.paperCompilePdf !== false)
+    return { format: fmt, lang: lang, compilePdf: compilePdf, force: o.force === true, id: o.id }
+  }
+  async function paperReadMeta(id) { const m = await readJson(paperDir(id) + '/paper.meta.json'); return (m && typeof m === 'object' && !Array.isArray(m)) ? m : undefined }
+  async function paperPathExists(rel) { try { const t = await fsTarget(rel); return (await fs.stat(t)) !== undefined } catch (e) { return false } }
+  async function paperAppendLog(id, tag, text) {
+    const rel = paperDir(id) + '/paper.log.md'
+    const prev = await readText(rel)
+    const head = (prev === undefined || !String(prev).trim()) ? (paperLogHead(id).join('\n') + '\n') : String(prev)
+    await writeText(rel, head + paperLogLine(now(), tag, text) + '\n')
+  }
+  /**
+   * paper 作用域锁（修订 §A3；v3 在触发前已释放项目锁，两个会话可能同时写同一棵 Paper/ 树）。
+   * 尽力而为：同一会话总是可重入（用于续租 at）；别的会话持有的锁未过期则拒绝。
+   */
+  async function paperLockAcquire(id) {
+    const rel = paperDir(id) + '/paper.lock.json'
+    const cur = await readJson(rel)
+    if (cur && cur.sessionId && cur.sessionId !== sessionId && (now() - Number(cur.at || 0)) < PAPER_LOCK_STALE_MS) return { ok: false, holder: String(cur.sessionId), at: Number(cur.at || 0) }
+    await writeJson(rel, { sessionId: sessionId, at: now(), project: currentProject })
+    return { ok: true }
+  }
+  async function paperLockRelease(id) {
+    const rel = paperDir(id) + '/paper.lock.json'
+    const cur = await readJson(rel)
+    if (cur && cur.sessionId === sessionId) await writeJson(rel, { sessionId: '', at: now(), released: true })
+  }
+  /**
+   * 回收一个卡死的撰写者（修订 §1：死掉的撰写者绝不能把论文永久卡住）。
+   * 做法：清状态 + 尽力中断 + 从 agentRegistry 摘除（否则它一直算"活跃子代理"，也会挡住后续派发）
+   * + 记进 paperAbandoned（事后返回的输出被明确丢弃并留痕，不是静默消失）+ 可见告警。
+   */
+  async function paperReapWriter(id, why) {
+    const cid = paperInFlight
+    paperInFlight = ''; paperInFlightAt = 0
+    if (cid) {
+      try { await interruptChild(cid) } catch (e) { /* best effort */ }
+      delete agentRegistry[cid]
+      paperAbandoned[cid] = true
+    }
+    await paperAppendLog(id, 'reap', '回收卡死的撰写者 ' + (cid || '(未知)') + '：' + why + '（论文不会被永久卡住；force/心跳会继续）')
+    logActivity('paper', '回收卡死的论文撰写子代理 ' + (cid || '(未知)') + '：' + why)
+    console.error('vibe-math-v2: reaped a stalled paper writer (' + (cid || 'unknown') + '): ' + why)
+    reportDirty = true
+    return cid
+  }
+  function paperWriterVerdictNow(force) {
+    return paperWriterVerdict({ inFlight: !!paperInFlight, force: !!force, ageMs: now() - Number(paperInFlightAt || 0), staleMs: PAPER_STALE_MS, childInRegistry: paperInFlight ? (agentRegistry[paperInFlight] !== undefined) : true })
+  }
+  function paperOneLine(s, cap) { return String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, cap || 400) }
+  /** 证据索引（spec §3.9）：只列**确实存在**的文件；绝不含 Paper/ 自己（否则输入哈希会自我污染）。
+   *  off 档必须真的是无操作（formal-verify-v2 的语料守卫会断言"off 的提示词里零 Lean 文本"）：
+   *  formal 未启用时，形式化相关的路径与字段一概不写进材料。 */
+  async function paperEvidenceIndex() {
+    const formalNow = formalOn()
+    const out = ['qs/qs.json']
+    if (formalNow && await paperPathExists('VibeMath_State/formal.json')) out.push('VibeMath_State/formal.json')
+    for (const f of await listFiles('Propos')) out.push('Propos/' + f)
+    for (const f of await listFiles('Verified')) out.push('Verified/' + f)
+    if (formalNow) for (const f of await listFiles('Verified/Lean')) out.push('Verified/Lean/' + f)
+    const dirs = ['Verification_logs', 'Progress_Logs'].concat(formalNow ? ['Formal'] : [])
+    for (let i = 0; i < dirs.length; i++) { const files = await listFiles(dirs[i]); for (let j = 0; j < files.length; j++) out.push(dirs[i] + '/' + files[j]) }
+    return out.filter(function (x) { return x.indexOf('Paper/') !== 0 }).sort()
+  }
+  /** 汇总材料（spec §4）：只含既有证据 + 未决/被否证的显式标注。不含时间戳 ⇒ 哈希稳定。 */
+  async function buildPaperDigest() {
+    const L = []
+    L.push('PRESET: vibe-math-v2 (single-author)')
+    L.push('PROJECT: ' + currentProject)
+    const qs = await getQs()
+    L.push('')
+    L.push('[ORIGINAL PROBLEMS] (qs/qs.json)')
+    if (qs.length === 0) L.push('- (none)')
+    for (let i = 0; i < qs.length; i++) {
+      const q = qs[i]
+      L.push('- id=' + q.id + ' | 已解决=' + (q.已解决 === true) + ' | 优先级=' + q.优先级 + ' | 概述=' + paperOneLine(q.概述, 800))
+      const sols = q.解法列表 || []
+      if (sols.length === 0) L.push('    · 解法：无')
+      for (let j = 0; j < sols.length; j++) {
+        const s = sols[j]
+        L.push('    · 解法#' + j + ' 正确概率=' + s.正确概率 + ' 已验=' + (s.已验 === true) + ' 证据=Verification_logs/ | ' + paperOneLine(s.完整解法, 1200))
+      }
+    }
+    const props = await getPropos()
+    L.push('')
+    L.push('[PROPOSITIONS] (Propos/*.json)')
+    if (props.length === 0) L.push('- (none)')
+    for (let i = 0; i < props.length; i++) {
+      const p = props[i]
+      const rec = formalOn() ? formalOf(p.id) : null   // off 档不把形式化字段写进材料（off 是真无操作）
+      L.push('- id=' + p.id + ' | 布尔估计=' + p.布尔估计 + ' | 状态=' + (p.已验证 ? '已验证' : '未定论') + ' | 优先级=' + p.优先级 + ' | 价值/关键性=' + p['价值/关键性'] + (rec ? (' | 形式化=' + ((rec && rec.status) || 'none') + (rec && rec.proof ? ('（' + rec.proof + '）') : '')) : '') + ' | 概述=' + paperOneLine(p.概述, 800))
+      const sides = [['证明', p.证明列表 || []], ['证伪', p.证伪列表 || []]]
+      for (let k = 0; k < sides.length; k++) {
+        const arr = sides[k][1]
+        for (let j = 0; j < arr.length; j++) if (arr[j] && arr[j].正确概率 === 1) L.push('    · 已检验通过：' + sides[k][0] + '#' + j + '（正确概率=1） | ' + paperOneLine(arr[j].完整过程, 900))
+      }
+    }
+    L.push('')
+    L.push('[UNRESOLVED / REFUTED — 论文里必须显式标注，不得当成已成立的结论]')
+    let any = false
+    for (let i = 0; i < qs.length; i++) {
+      const sols = qs[i].解法列表 || []
+      for (let j = 0; j < sols.length; j++) if (!(sols[j].正确概率 === 1 || sols[j].正确概率 === 0)) { any = true; L.push('- 未定论：问题 ' + qs[i].id + ' 的解法#' + j + '（正确概率=' + sols[j].正确概率 + '）') }
+    }
+    for (let i = 0; i < props.length; i++) {
+      if (!(props[i].布尔估计 === 1 || props[i].布尔估计 === 0)) { any = true; L.push('- 未定论：命题 ' + props[i].id + '（布尔估计=' + props[i].布尔估计 + '）') }
+      else if (props[i].布尔估计 === 0) L.push('- 已被否证：命题 ' + props[i].id + '（布尔估计=0）')
+    }
+    if (!any) L.push('- (none — 所有对象均已定论)')
+    L.push('')
+    L.push('[EVIDENCE INDEX] (only files that exist)')
+    const ev = await paperEvidenceIndex()
+    for (let i = 0; i < ev.length; i++) L.push('- ' + ev[i])
+    return L.join('\n')
+  }
+  /** 「论文撰写」子代理提示词（单作者；v2/v3 同一形状）。 */
+  function paperWriterPrompt(digest, o) {
+    const langName = o.lang === 'en' ? 'English' : '中文（Chinese）'
+    return 'You are the DEDICATED PAPER WRITER (single-author mode) of a math research run that has just CONVERGED.\n' +
+      'Write its final paper in ' + langName + ', using ONLY the evidence in the MATERIAL section below.\n\n' +
+      'HARD RULES:\n' +
+      '- NEVER invent content: no new proposition, no new computation, no citation that is not in the MATERIAL.\n' +
+      '- Unresolved or refuted items MUST be explicitly labelled (「未定论」/「已被否证」, or "unresolved"/"refuted" in English); never present them as established.\n' +
+      '- Fixed 9-section skeleton — provide bodies for these EXACT `## ` headings (the framework writes the headings, author/date and the evidence index itself):\n' +
+      PAPER_SKELETON.map(function (s, i) { return '    ' + (i + 1) + '. ' + s.key + ' — ' + s.spec }).join('\n') + '\n' +
+      '- A section with no evidence must be exactly 「' + PAPER_NO_EVIDENCE + '」 (do not pad it).\n' +
+      '- Markdown subset only: `#`/`##`/`###`, `- ` lists, `**bold**`, `*em*`, `` `code` ``, and inline math as `$...$`. No tables, images, footnotes or raw HTML.\n\n' +
+      'OUTPUT CONTRACT — respond with ONLY one ```json code fence, no prose:\n' +
+      '{"title":"<paper title>","abstract":"<original problem + main results>","sections":[{"name":"<one of the 9 headings>","body":"<markdown>"}, ...]}\n\n' +
+      'MATERIAL (evidence only — do not add anything beyond it):\n' + digest
+  }
+  /**
+   * LaTeX 检测（spec §5 + 修订 §D）：`paperLatexCommand` 非空时只用它（不猜）；
+   * 否则中文优先 xelatex、英文优先 pdflatex/latexmk。缺 subprocess/resolveExecutable 一律
+   * 视为"未检测到"（照 LEAN_NOT_FOUND 的降级方式，永不抛错）。
+   */
+  async function paperDetectLatex(lang) {
+    const sub = subprocessOf()
+    if (sub === undefined || typeof sub.spawn !== 'function') return { available: [], reason: 'no-subprocess' }
+    if (typeof sub.resolveExecutable !== 'function') return { available: [], reason: 'no-resolveExecutable' }
+    const forced = String(params.paperLatexCommand || '').trim()
+    if (forced) {
+      try { const p = await sub.resolveExecutable(forced); return p ? { available: [{ name: forced, path: String(p) }], reason: 'ok', forced: true } : { available: [], reason: 'paperLatexCommand not found: ' + forced, forced: true } }
+      catch (e) { return { available: [], reason: 'paperLatexCommand not found: ' + forced, forced: true } }
+    }
+    const order = lang === 'en' ? PAPER_ENGINE_ORDER_EN : PAPER_ENGINE_ORDER_ZH
+    const available = []
+    for (let i = 0; i < order.length; i++) {
+      try { const p = await sub.resolveExecutable(order[i]); if (p) available.push({ name: order[i], path: String(p) }) } catch (e) { /* 未安装 */ }
+    }
+    return { available: available, reason: available.length ? 'ok' : 'none' }
+  }
+  function paperArgvFor(engine) {
+    if (engine.name === 'latexmk') return [engine.path, '-pdf', '-interaction=nonstopmode', '-halt-on-error', 'paper.tex']
+    if (engine.name === 'tectonic') return [engine.path, '--keep-logs', 'paper.tex']
+    return [engine.path, '-interaction=nonstopmode', '-halt-on-error', 'paper.tex']
+  }
+  /** 一次编译（nonstopmode），带主动超时 terminate（与 leanRunFile 同一模式）。 */
+  async function paperRunOnce(engine, dirAbs, capMs) {
+    const sub = subprocessOf()
+    if (sub === undefined || typeof sub.spawn !== 'function') return { ok: false, exitCode: null, code: 'NO_SUBPROCESS' }
+    let handle
+    try { handle = await spawnHandle(sub, { argv: paperArgvFor(engine), cwd: dirAbs, stdio: { stdin: 'ignore', stdout: { maxBytes: 64 * 1024 }, stderr: { maxBytes: 64 * 1024 } }, graceMs: capMs }) }
+    catch (e) { return { ok: false, exitCode: null, code: 'SPAWN_FAILED', message: String((e && e.message) || e) } }
+    let timedOut = false, timer = null, outcome
+    try {
+      outcome = await Promise.race([
+        handle.done,
+        new Promise(function (resolve) { timer = setTimeout(function () { timedOut = true; try { if (handle && typeof handle.terminate === 'function') handle.terminate() } catch (e) { /* best effort */ } resolve({ exitCode: null }) }, capMs) }),
+      ])
+    } catch (e) { if (timer !== null) clearTimeout(timer); return { ok: false, exitCode: null, code: 'RUN_FAILED', message: String((e && e.message) || e) } }
+    if (timer !== null) clearTimeout(timer)
+    let err = ''
+    try { if (handle.collected && handle.collected.stderr) err = String(handle.collected.stderr.readFrom(0).text || '') } catch (e) { /* best effort */ }
+    return { ok: !timedOut && !!outcome && outcome.exitCode === 0, exitCode: outcome ? outcome.exitCode : null, timedOut: timedOut, stderr: err.slice(-1200) }
+  }
+  /**
+   * 编译 paper.tex（spec §5 + 修订 §D/§E）：检测 → 主引擎（nonstopmode，两遍）→ 换引擎 → 去不支持
+   * 宏包 → 最小模板再试一次；然后报告并降级（保留 tex+md，不改写论文内容）。
+   * **永不删除/覆盖已有 pdf**（§D）：旧的 paper.pdf 原样保留，成功判据 = 本次运行 exit 0 **且** pdf 存在。
+   */
+  async function paperCompile(id, o, texPrimary, bodyTex) {
+    const relDir = paperDir(id), absDir = paperAbsDir(id)
+    const attempts = []
+    if (!o.compilePdf) return { compile: 'skipped', reason: 'paperCompilePdf=false', engine: null, attempts: attempts, pdfPreserved: await paperPathExists(relDir + '/paper.pdf') }
+    // §E：tex 未产出（paperFormat=md）时**跳过**编译，且不得报"缺 tex 无法编译"的警告。
+    if (o.format === 'md') return { compile: 'skipped', reason: 'paperFormat=md（不产出 tex，跳过编译）', engine: null, attempts: attempts, pdfPreserved: await paperPathExists(relDir + '/paper.pdf') }
+    const det = await paperDetectLatex(o.lang)
+    if (det.available.length === 0) {
+      await paperAppendLog(id, 'latex', '未检测到任何 LaTeX 引擎（' + det.reason + '）→ 只保留 paper.tex + paper.md，不编译 pdf（spec §5：不阻塞定稿）')
+      return { compile: 'not-detected', reason: det.reason, engine: null, attempts: attempts, pdfPreserved: await paperPathExists(relDir + '/paper.pdf') }
+    }
+    await paperAppendLog(id, 'latex', '检测到引擎 ' + det.available.map(function (x) { return x.name }).join(', ') + (det.forced ? '（paperLatexCommand 指定）' : ('（顺序 ' + (o.lang === 'en' ? PAPER_ENGINE_ORDER_EN : PAPER_ENGINE_ORDER_ZH).join(' > ') + '）')))
+    const plan = [{ engine: det.available[0], tex: texPrimary, mode: 'primary' }]
+    if (det.available[1]) plan.push({ engine: det.available[1], tex: texPrimary, mode: 'engine-fallback' })
+    plan.push({ engine: det.available[0], tex: paperSanitizeTex(texPrimary), mode: 'drop-unsupported-packages' })
+    plan.push({ engine: det.available[0], tex: paperMinimalTexDoc({ lang: o.lang, bodyTex: bodyTex }), mode: 'minimal-template' })
+    const cap = 120000
+    for (let i = 0; i < plan.length; i++) {
+      const step = plan[i]
+      await writeText(relDir + '/paper.tex', step.tex)
+      const runs = []
+      for (let pass = 0; pass < 2; pass++) runs.push(await paperRunOnce(step.engine, absDir, cap))   // spec §5：跑两遍
+      const last = runs[runs.length - 1]
+      const pdf = !!last.ok && await paperPathExists(relDir + '/paper.pdf')
+      attempts.push({ engine: step.engine.name, mode: step.mode, ok: pdf, exitCode: last.exitCode, timedOut: !!last.timedOut, stderr: last.stderr || '' })
+      await paperAppendLog(id, 'compile', step.mode + ' engine=' + step.engine.name + ' → ' + (pdf ? 'ok（paper.pdf 已生成）' : ('failed（exit=' + String(last.exitCode) + (last.timedOut ? ', timeout' : '') + '）')))
+      if (pdf) return { compile: (i === 0) ? 'ok' : 'repaired', engine: step.engine.name, mode: step.mode, attempts: attempts, pdfPreserved: false }
+    }
+    await writeText(relDir + '/paper.tex', texPrimary)   // 失败时保留**主** tex（信息量最大；spec §5 保留 tex+md）
+    const preserved = await paperPathExists(relDir + '/paper.pdf')   // §D：已有的 pdf 绝不删除
+    await paperAppendLog(id, 'compile', '所有尝试均失败：保留 paper.tex + paper.md' + (preserved ? '（paper.pdf 是**上一次成功编译**留下的，未被覆盖）' : '，未生成 paper.pdf') + '（不阻塞定稿）')
+    logActivity('paper', '论文 pdf 编译失败（已尝试换引擎/去不支持宏包/最小模板），已保留 tex+md：' + relDir)
+    reportDirty = true
+    return { compile: 'failed', engine: det.available[0].name, attempts: attempts, pdfPreserved: preserved }
+  }
+  /** 落盘 md/tex/pdf/meta（幂等：内容相同则不重写；spec §2/§5）。 */
+  async function paperEmitArtifacts(id, o, info) {
+    const relDir = paperDir(id)
+    const dateStr = fmtTime(now()).slice(0, 10)
+    const author = paperAuthorLine()
+    const evidence = info.evidence || (await paperEvidenceIndex())
+    const title = String(info.title || '').trim() || ('研究报告：' + currentProject)
+    const md = paperBuildMarkdown({ title: title, author: author, date: dateStr, abstract: info.abstract, sections: info.sections, evidence: evidence })
+    const artifacts = { md: false, tex: false, pdf: false }
+    let compile = 'skipped', engine = null, attempts = [], pdfPreserved = false
+    if (o.format === 'md' || o.format === 'both') { await writeText(relDir + '/paper.md', md); artifacts.md = true }
+    if (o.format === 'tex' || o.format === 'both') {
+      const bodyTex = paperMdToTexBody(md)
+      const tex = paperTexDoc({ title: title, author: author, date: dateStr, lang: o.lang, bodyTex: bodyTex })
+      await writeText(relDir + '/paper.tex', tex)
+      artifacts.tex = true
+      const c = await paperCompile(id, o, tex, bodyTex)
+      compile = c.compile; engine = c.engine || null; attempts = c.attempts || []
+      pdfPreserved = !!c.pdfPreserved
+      if (compile === 'ok' || compile === 'repaired') artifacts.pdf = await paperPathExists(relDir + '/paper.pdf')
+    }
+    const filled = PAPER_SKELETON.map(function (s) { return s.key }).filter(function (k) { return !!(info.sections && String(info.sections[k] || '').trim()) })
+    const meta = {
+      id: id, dir: relDir, preset: 'vibe-math-v2', singleAuthor: true, project: currentProject,
+      title: title, author: author, date: dateStr, abstract: String(info.abstract || ''),
+      sectionBodies: info.sections || {}, sections: PAPER_SKELETON.map(function (s) { return s.key }), filledSections: filled,
+      raw: String(info.raw == null ? '' : info.raw), notes: Array.isArray(info.notes) ? info.notes : [],
+      trigger: info.trigger || 'manual', runStartedAt: Number(scheduler.startedAt) || 0,
+      params: { finalPaper: params.finalPaper !== false, paperFormat: o.format, paperLanguage: o.lang, paperCompilePdf: !!o.compilePdf, paperLatexCommand: String(params.paperLatexCommand || '') },
+      finalizedAt: now(), finalizedAtText: fmtTime(now()),
+      artifacts: artifacts, compile: compile, compileEngine: engine, compileAttempts: attempts, pdfPreserved: pdfPreserved,
+      material: info.material || null, evidence: evidence,
+    }
+    // meta **最后**写：它是"这次定稿已提交"的唯一标记（修订 §C 的原子提交点）。
+    await writeJson(relDir + '/paper.meta.json', meta)
+    return meta
+  }
+  async function paperMissingArtifacts(id, o) {
+    const relDir = paperDir(id)
+    const need = []
+    if (o.format === 'md' || o.format === 'both') { if (!(await paperPathExists(relDir + '/paper.md'))) need.push('paper.md') }
+    if (o.format === 'tex' || o.format === 'both') { if (!(await paperPathExists(relDir + '/paper.tex'))) need.push('paper.tex') }
+    return need
+  }
+  /**
+   * 派遣一次（内部）：材料摘要只作记录（修订 §C 不再用稳定哈希）；激活上限拒绝 → 排队重试（§A2）。
+   */
+  async function paperDispatch(trigger, o, id, prevTries) {
+    const relDir = paperDir(id)
+    const digest = await buildPaperDigest()
+    let childId
+    try {
+      childId = await spawnChild('paper-writer:' + id, paperWriterPrompt(digest, o), { role: 'paper', paperId: id, trigger: trigger, lang: o.lang, format: o.format, compilePdf: o.compilePdf })
+    } catch (e) {
+      const message = String((e && e.message) || e)
+      const limit = activationLimitFrom(message)
+      if (limit !== undefined || /ACTIVATION_LIMIT_REACHED|active child limit/i.test(message)) {
+        const tries = Number(prevTries || 0) + 1
+        if (tries > PAPER_MAX_RETRIES) {
+          paperPending = null
+          await paperAppendLog(id, 'dispatch-failed', '宿主激活上限连续拒绝 ' + PAPER_MAX_RETRIES + ' 次，已放弃自动派遣：' + message)
+          logActivity('paper', '论文撰写子代理被宿主激活上限连续拒绝（' + PAPER_MAX_RETRIES + ' 次），已放弃自动派遣（稍后可 /vibe paper force 重试）：' + message)
+          console.error('vibe-math-v2: paper writer refused by the host activation limit ' + PAPER_MAX_RETRIES + ' times; giving up (retry later with /vibe paper force) — ' + message)
+          await paperLockRelease(id)
+          return { ok: false, message: 'paper writer refused by the activation limit ' + PAPER_MAX_RETRIES + ' times: ' + message, id: id, dir: relDir, limit: limit }
+        }
+        paperPending = { tries: tries, retryAt: now() + PAPER_RETRY_MS, reason: message, limit: limit, trigger: trigger, opts: { lang: o.lang, format: o.format, compilePdf: o.compilePdf } }
+        if (tries === 1 || tries % 3 === 0) {
+          await paperAppendLog(id, 'dispatch-queued', '宿主激活上限（' + (limit === undefined ? '?' : limit) + '）拒绝派遣（第 ' + tries + ' 次）：' + (PAPER_RETRY_MS / 1000) + 's 后重试')
+          logActivity('paper', '论文撰写子代理被宿主激活上限拒绝（第 ' + tries + ' 次），已排队重试：' + message)
+          console.error('vibe-math-v2: paper writer queued after an activation-limit refusal (try ' + tries + '): ' + message)
+        }
+        reportDirty = true
+        return { ok: true, queued: true, reason: 'activation-limit-reached', tries: tries, retryAt: paperPending.retryAt, limit: limit, id: id, dir: relDir }
+      }
+      await paperAppendLog(id, 'dispatch-failed', message)
+      logActivity('paper', '「论文撰写」子代理派遣失败：' + message)
+      await paperLockRelease(id)
+      return { ok: false, message: 'paper writer dispatch failed: ' + message, id: id, dir: relDir }
+    }
+    paperInFlight = childId
+    paperInFlightAt = now()
+    // 只有"非自动重试"的派遣才重置回收计数：auto-retry 必须保留计数，否则卡死重派会无限循环。
+    if (trigger !== 'auto-retry') paperReaps = 0
+    paperPending = null
+    const material = paperMaterialSummary(digest)
+    await paperAppendLog(id, 'dispatch', 'trigger=' + trigger + ' child=' + childId + ' format=' + o.format + ' lang=' + o.lang + ' compilePdf=' + o.compilePdf + (o.force ? ' force=true' : '') + ' run=' + (Number(scheduler.startedAt) || 0) + ' material=' + material.chars + ' chars/' + material.lines + ' lines')
+    logActivity('paper', '已派遣「论文撰写」子代理（' + trigger + '，' + o.format + '/' + o.lang + '）→ ' + relDir)
+    reportDirty = true
+    return { ok: true, dispatched: true, childId: childId, id: id, dir: relDir, trigger: trigger, format: o.format, lang: o.lang, compilePdf: o.compilePdf }
+  }
+  /**
+   * 触发入口（spec §2/§3 + 修订 §A2/§A3）：自动（收口）与手动命令共用。
+   * 幂等 = **同一 run（scheduler.startedAt）+ finalizedAt + 逐产物存在性**（修订 §C）；force 跳过全部检查。
+   * 已有定稿但缺产物 → 用已存内容补写（不重新派遣作者）。别的会话持有 paper 锁 → 跳过并留痕。
+   */
+  async function maybeWritePaper(trigger, opts) {
+    const o = paperOpts(opts)
+    const id = paperId(opts)
+    const relDir = paperDir(id)
+    const meta = await paperReadMeta(id)
+    const sameRun = !!meta && Number(meta.runStartedAt || 0) === (Number(scheduler.startedAt) || 0)
+    if (!o.force && meta && meta.finalizedAt && sameRun) {
+      const missing = await paperMissingArtifacts(id, o)
+      if (missing.length === 0) {
+        await paperAppendLog(id, 'skip', '幂等：同一 run（' + (Number(scheduler.startedAt) || 0) + '）已有定稿且产物齐全 → 不重复撰写（/vibe paper force 可重写）')
+        return { ok: true, skipped: true, reason: 'already-finalized-this-run', id: id, dir: relDir, finalizedAt: meta.finalizedAt, artifacts: meta.artifacts || {}, compile: meta.compile, note: '同一 run 只写一次；重复触发只补写缺失产物（spec §2）' }
+      }
+      await paperAppendLog(id, 'fill', '幂等：已有定稿但缺少 ' + missing.join(', ') + ' → 用已存的定稿内容补写（不重新派遣作者）')
+      const filled = await paperEmitArtifacts(id, o, { title: meta.title, abstract: meta.abstract, sections: meta.sectionBodies || {}, evidence: meta.evidence, raw: meta.raw, notes: (meta.notes || []).concat(['补写缺失产物：' + missing.join(', ')]), trigger: meta.trigger || trigger, material: meta.material })
+      return { ok: true, skipped: true, reason: 'filled-missing-artifacts', filled: missing, id: id, dir: relDir, finalizedAt: filled.finalizedAt, artifacts: filled.artifacts, compile: filled.compile }
+    }
+    if (paperInFlight) {
+      const verdict = paperWriterVerdictNow(o.force)
+      if (verdict === 'reap') {
+        const gone = agentRegistry[paperInFlight] === undefined
+        await paperReapWriter(id, gone ? '子代理已不在 agentRegistry（end 事件丢失 / 宿主丢弃）' : ('超过卡死窗口 ' + Math.round(PAPER_STALE_MS / 60000) + ' 分钟未返回'))
+        // 回收后继续走下面的 paper 锁 + 派遣路径（force 与收口重试都是这个语义）
+      } else if (verdict === 'refuse') {
+        const ageMs = now() - Number(paperInFlightAt || 0)
+        await paperAppendLog(id, 'force-refused', '仍有在途撰写者 ' + paperInFlight + '（' + Math.round(ageMs / 1000) + 's）：超过 ' + Math.round(PAPER_STALE_MS / 60000) + ' 分钟才会被 force 放弃')
+        return { ok: false, reason: 'writer-in-flight', childId: paperInFlight, ageMs: ageMs, staleMs: PAPER_STALE_MS, id: id, dir: relDir, message: '已有在途的论文撰写子代理 ' + paperInFlight + '（已 ' + Math.round(ageMs / 1000) + 's 未返回）。等它返回，或等超过 ' + Math.round(PAPER_STALE_MS / 60000) + ' 分钟后 force 会自动回收并重派（心跳也会自动回收）。' }
+      } else {
+        return { ok: true, skipped: true, reason: 'writer-in-flight', childId: paperInFlight, ageMs: now() - Number(paperInFlightAt || 0), staleMs: PAPER_STALE_MS, id: id, dir: relDir }
+      }
+    }
+    if (paperPending) return { ok: true, queued: true, reason: 'retry-queued', retryAt: paperPending.retryAt, tries: paperPending.tries, id: id, dir: relDir }
+    const lock = await paperLockAcquire(id)
+    if (!lock.ok) {
+      await paperAppendLog(id, 'skip', 'paper 锁由会话 ' + lock.holder + ' 持有（未过期）→ 本次不派遣（修订 §A3 的 paper 作用域锁）')
+      return { ok: true, skipped: true, reason: 'locked-by-another-session', holder: lock.holder, id: id, dir: relDir }
+    }
+    return await paperDispatch(trigger, o, id, 0)
+  }
+  /** apply 级心跳用：有排队的论文派遣且到点了吗（同步判断，便宜）。 */
+  function paperRetryDue() { return !!(paperPending && now() >= Number(paperPending.retryAt || 0)) }
+  /**
+   * 心跳（修订 §1）：在途 → 续租 paper 锁；**卡死则自动回收**（child 不在注册表，或超过卡死窗口），
+   * 并自动重派（上限 PAPER_MAX_AUTO_REAPS，之后给出可执行提示交给 /vibe paper force）；有排队则重试派遣。
+   */
+  async function runPaperRetry() {
+    const id = paperId()
+    if (paperInFlight) {
+      if (paperWriterVerdictNow(false) === 'reap') {
+        const gone = agentRegistry[paperInFlight] === undefined
+        await paperReapWriter(id, gone ? '子代理已不在 agentRegistry（end 事件丢失 / 宿主丢弃）' : ('超过卡死窗口 ' + Math.round(PAPER_STALE_MS / 60000) + ' 分钟未返回'))
+        const meta = await paperReadMeta(id)
+        if (params.finalPaper !== false && !(meta && meta.finalizedAt) && Number(paperReaps || 0) < PAPER_MAX_AUTO_REAPS) {
+          paperReaps = Number(paperReaps || 0) + 1
+          await paperAppendLog(id, 'retry-after-reap', '第 ' + paperReaps + ' 次自动重派（上限 ' + PAPER_MAX_AUTO_REAPS + '）')
+          await paperDispatch('auto-retry', paperOpts({}), id, 0)
+        } else {
+          await paperAppendLog(id, 'reap-giveup', '自动重派已达上限 ' + PAPER_MAX_AUTO_REAPS + '（或已有定稿）：不再自动派遣，请用 /vibe paper force 手动重写')
+          logActivity('paper', '论文撰写子代理连续卡死/已放弃：不再自动重派，可用 /vibe paper force 手动重写')
+        }
+        return
+      }
+      try { await paperLockAcquire(id) } catch (e) { /* 续租失败不致命 */ }
+      return
+    }
+    if (!paperRetryDue()) return
+    const p = paperPending
+    paperPending = null
+    const o = paperOpts(p.opts)
+    await paperDispatch(p.trigger || 'auto-retry', o, id, Number(p.tries || 0))
+  }
+  /** `/vibe paper [lang=zh|en] [format=both|md|tex] [force]`（spec §2/§6）。非法参数 → ok:false（命令层转 kind:'error'）。 */
+  async function paperCommand(args) {
+    const rest = Array.isArray(args) ? args : []
+    const opts = {}
+    for (let i = 0; i < rest.length; i++) {
+      const a = String(rest[i] || '')
+      if (a === 'force') { opts.force = true; continue }
+      const eq = a.indexOf('=')
+      const k = eq > 0 ? a.slice(0, eq).toLowerCase() : ''
+      const v = eq > 0 ? a.slice(eq + 1).toLowerCase() : ''
+      if (k === 'lang') { if (v !== 'zh' && v !== 'en') return { ok: false, message: '/vibe paper lang= 只接受 zh|en（收到 ' + JSON.stringify(a) + '）' }; opts.lang = v; continue }
+      if (k === 'format') { if (v !== 'both' && v !== 'md' && v !== 'tex') return { ok: false, message: '/vibe paper format= 只接受 both|md|tex（收到 ' + JSON.stringify(a) + '）' }; opts.format = v; continue }
+      return { ok: false, message: 'unknown /vibe paper option: ' + a + '（可用 lang=zh|en、format=both|md|tex、force）' }
+    }
+    const r = await maybeWritePaper('manual', opts)
+    if (r.ok === false) return r
+    const autoNote = params.finalPaper === false ? '（自动触发已关闭 finalPaper=false；手动命令仍可用）' : ''
+    const msg = r.dispatched ? ('已派遣「论文撰写」子代理，产物将写入 ' + r.dir + '/')
+      : r.queued ? ('宿主激活上限已满：论文撰写已排队，' + (PAPER_RETRY_MS / 1000) + 's 后自动重试（第 ' + r.tries + ' 次）')
+        : (r.reason === 'already-finalized-this-run' ? '同一 run 已有定稿且产物齐全：不重复撰写（需要重写请用 /vibe paper force）'
+          : (r.reason === 'filled-missing-artifacts' ? ('已用既有定稿补写缺失产物：' + (r.filled || []).join(', ')) : ('未重新派遣：' + (r.reason || ''))))
+    return Object.assign({}, r, { message: msg + autoNote, autoDisabled: params.finalPaper === false })
+  }
+  /** 论文撰写子代理结束（spec §4）：解析回复 → 组装 9 节 → 落盘 → 编译 → 记日志 → 释放 paper 锁。 */
+  async function handlePaperWriter(childId, meta, output) {
+    const id = meta.paperId || paperId()
+    paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0
+    delete paperAbandoned[childId]
+    const o = paperOpts({ lang: meta.lang, format: meta.format, compilePdf: meta.compilePdf })
+    const parsed = parseJson(output)
+    const info = paperSkeletonFromReply(parsed, output)
+    if (!info.title) info.title = paperTitleFromMd(String(output || '')) || ('研究报告：' + currentProject)
+    for (let i = 0; i < info.notes.length; i++) await paperAppendLog(id, 'note', info.notes[i])
+    if (!String(output || '').trim()) await paperAppendLog(id, 'reply', '作者回复为空：只写骨架 + 占位说明（绝不编造内容）')
+    let written
+    try {
+      written = await paperEmitArtifacts(id, o, { title: info.title, abstract: info.abstract, sections: info.sections, raw: String(output || ''), notes: info.notes, trigger: meta.trigger || 'auto', material: paperMaterialSummary(await buildPaperDigest()) })
+    } catch (e) {
+      await paperAppendLog(id, 'finalize-failed', String((e && e.message) || e))
+      logActivity('paper', '论文落盘失败：' + String((e && e.message) || e))
+      await paperLockRelease(id)
+      return
+    }
+    await paperAppendLog(id, 'finalize', '产物 ' + JSON.stringify(written.artifacts) + ' compile=' + written.compile + (written.compileEngine ? (' engine=' + written.compileEngine) : '') + ' run=' + (Number(scheduler.startedAt) || 0))
+    logActivity('paper', '论文（最终稿）已落盘：' + paperDir(id) + '/（' + Object.keys(written.artifacts).filter(function (k) { return written.artifacts[k] }).join('/') + '，编译=' + written.compile + '）')
+    await paperLockRelease(id)
+    reportDirty = true
+    await saveAll()
+  }
+  /** status 里的论文视图（可观测性；命令与守卫都读它）。 */
+  async function paperStatusView() {
+    const id = paperId()
+    const meta = await paperReadMeta(id)
+    return {
+      id: id, dir: paperDir(id), inFlight: paperInFlight || null,
+      inFlightSince: paperInFlight ? Number(paperInFlightAt || 0) : null,
+      inFlightAgeMs: paperInFlight ? (now() - Number(paperInFlightAt || 0)) : null,
+      staleMs: PAPER_STALE_MS, reapedThisRun: Number(paperReaps || 0),
+      queued: paperPending ? { tries: paperPending.tries, retryAt: paperPending.retryAt, reason: paperPending.reason, limit: paperPending.limit === undefined ? null : paperPending.limit } : null,
+      autoFinalPaper: params.finalPaper !== false, format: params.paperFormat, language: params.paperLanguage, compilePdf: params.paperCompilePdf !== false,
+      finalizedAt: meta ? meta.finalizedAt : null, artifacts: meta ? (meta.artifacts || {}) : {}, compile: meta ? meta.compile : null,
+    }
+  }
+
   // ================= child result dispatch =================
   async function onChildEnd(info) {
     const meta = agentRegistry[info.id]
-    if (meta === undefined) return
+    if (meta === undefined) {
+      // 已放弃（回收）的撰写者事后才返回：输出被丢弃，但必须**留痕**，不能静默消失（修订 §1）。
+      if (paperAbandoned[info.id]) {
+        delete paperAbandoned[info.id]
+        logActivity('paper', '已回收的论文撰写子代理 ' + info.id + ' 事后返回：其输出被丢弃（已重派新的撰写者）')
+        reportDirty = true
+      }
+      return
+    }
     const output = blocksToText(info.lastAssistantMessage)
     try {
       if (meta.role === 'explorer') await handleExplorer(info.id, meta, output)
       else if (meta.role === 'solver') await handleSolver(info.id, meta, output, info.stopReason)
       else if (meta.role === 'verifier') await handleVerifier(info.id, meta, output, info.stopReason)
+      // 修订 §A2：论文撰写子代理必须有**自己的分支**——此前未知 role 会静默丢失（撰写成果永远落不了盘）。
+      else if (meta.role === 'paper') await handlePaperWriter(info.id, meta, output)
+      else console.error('vibe-math-v2: subagent ' + info.id + ' ended with an unknown role "' + String(meta.role) + '" — its output is dropped')
     } catch (e) { console.error('vibe-math-v2 onChildEnd error: ' + String((e && e.stack) || e)) }
     await saveAll()
     scheduleTick()
@@ -2693,17 +3871,27 @@ export function apply(ctx) {
       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 = {}
+        // 论文的派遣态是本进程内存态：子代理已被中断/丢弃，排队与在途标记必须一起清掉，
+        // 否则 paperInFlight 会永久挡住后续 /vibe paper（修订 §A2 的"静默消失"同类问题）。
+        if (paperInFlight || paperPending) logActivity('paper', '重启/跨进程恢复：清空论文撰写态（inFlight=' + (paperInFlight || '-') + (paperPending ? ', queued' : '') + '）')
+        paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0; paperPending = null
       }
       // 并发计数由 agentRegistry 推导：清空 registry 后自然归零，无需显式赋值。
     }
     await writeJson('VibeMath_State/process_epoch.json', processEpoch)
+    // Lean 异步作业的崩溃恢复（spec §2.6）：**同一进程 continue 不重驱**（作业还在内存队列里正常跑），
+    // 只有"新进程/新会话接手这棵树"（fresh 或 stale epoch）才按 Formal/Jobs/*.json 恢复；
+    // 恢复绝不置 passed（settle 的唯一判据仍然要重新校验内容哈希与 exit code）。
+    if (fresh || stale) { try { await recoverLeanJobs() } catch (e) { console.error('vibe-math-v2: lean job recovery failed: ' + String((e && e.message) || e)) } }
+    // 数学计算的引擎探测（异步）在 init 时先跑一次：提示词侧只读缓存现算（mathWorkLine）。
+    try { await refreshMathProbe(true) } catch (e) { /* 探测失败不影响 init：mathWorkLine 会因此为空 */ }
     await saveAll()
     return { ok: true }
   }
   async function startScheduler() { const r = await init(true); if (!r.ok) return r; abandonGatedDecision('scheduler restarted'); scheduler.running = true; scheduler.startedAt = now(); logActivity('start', 'scheduler started for project ' + currentProject); await saveAll(); await maybeWriteReport(true); scheduleTick(); return { ok: true, message: 'scheduler started', project: currentProject, frameworkRoot: frameworkRoot() } }
   async function resumeScheduler() { const r = await init(false); if (!r.ok) return r; abandonGatedDecision('scheduler resumed (离开那次运行，挂起的节点不再等待)'); scheduler.running = true; logActivity('resume', 'scheduler resumed'); await saveAll(); await maybeWriteReport(true); scheduleTick(); return { ok: true, message: 'scheduler resumed', project: currentProject, frameworkRoot: frameworkRoot() } }
   async function pauseScheduler() { scheduler.running = false; logActivity('pause', 'scheduler paused'); await saveAll(); return { ok: true, message: 'scheduler paused' } }
-  async function abortScheduler() { scheduler.running = false; abandonGatedDecision('scheduler aborted'); const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptChild(ids[i]); agentRegistry = {}; logActivity('abort', 'scheduler aborted, ' + ids.length + ' child(ren) interrupted'); await saveAll(); return { ok: true, message: 'scheduler aborted', interrupted: ids.length } }
+  async function abortScheduler() { scheduler.running = false; abandonGatedDecision('scheduler aborted'); const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) await interruptChild(ids[i]); agentRegistry = {}; paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0; paperPending = null; logActivity('abort', 'scheduler aborted, ' + ids.length + ' child(ren) interrupted'); await saveAll(); return { ok: true, message: 'scheduler aborted', interrupted: ids.length } }
   // auto 模式语义 = 无人值守自动通过关键节点：切回 auto 时把仍挂起的人工决策按自动策略放行
   async function autoResolvePending() {
     const pending = decisionQueue.filter(function (d) { return d.status === 'pending' })
@@ -2743,6 +3931,8 @@ export function apply(ctx) {
         todo: formalTodo(),
         paths: { project: 'Formal/', lib: vibeRoot() + '/Formal/Lib/', proved: vibeRoot() + '/Formal/Proved/', proofs: 'Verified/Lean/' },
       },
+      // 最终论文的可观测面（spec §2/§6）：自动开关、在途/排队、定稿时间、产物与编译结果。
+      paper: await paperStatusView(),
     }
   }
 
@@ -2755,9 +3945,15 @@ export function apply(ctx) {
     else abandonGatedDecision('project switched')
     currentProject = slug; await writeCurrentProject(); await ensureDirs()
     if ((await readJson('qs/qs.json')) === undefined) await writeJson('qs/qs.json', [])
-    params = Object.assign({}, DEFAULT_PARAMS); scheduler = { running: false, startedAt: 0, lastCheckpoint: 0, gate: null }; agentRegistry = {}; decisionQueue = []; verifierAccuracy = {}; tasks = {}; explorerRetries = {}; activityLog = []; lastReportWrite = 0; lastPushReport = 0; reportDirty = false
+    params = Object.assign({}, DEFAULT_PARAMS); scheduler = { running: false, startedAt: 0, lastCheckpoint: 0, gate: null }; agentRegistry = {}; decisionQueue = []; verifierAccuracy = {}; tasks = {}; explorerRetries = {}; activityLog = []; lastReportWrite = 0; lastPushReport = 0; reportDirty = false; paperInFlight = ''; paperInFlightAt = 0; paperReaps = 0; paperPending = null
     formalState = { records: {}, todo: [] } // 形式化记录随项目切换（loadState 会读新项目的 formal.json）
-    await loadSettings(); await migrateLegacyParams(); await loadState(); await saveAll()
+    await loadSettings(); await migrateLegacyParams(); await loadState()
+    // 切到/新建一个项目 = "接手这棵树的遗留作业"：Formal/Jobs/*.json 里本进程不认识的记录按 §2.6 恢复
+    // （queued 重入队 / running 标记 interrupted / settled 只在哈希与构建上下文都一致时补写）。
+    try { await recoverLeanJobs() } catch (e) { console.error('vibe-math-v2: lean job recovery on project switch failed: ' + String((e && e.message) || e)) }
+    // 切项目后引擎探测缓存过期（mathEngines/路径可能不同）：重探一次再让提示词读它。
+    try { await refreshMathProbe(true) } catch (e) { /* 探测失败不影响切换 */ }
+    await saveAll()
     return { ok: true, project: slug, frameworkRoot: frameworkRoot() }
   }
 
@@ -2770,6 +3966,13 @@ export function apply(ctx) {
   function objParams(props, required) { return { type: 'object', properties: props, additionalProperties: false, required: required || [] } }
   const handlers = {}
   function registerTool(name, description, parameters, executeFn) { handlers[name] = executeFn }
+  // math_computation 的**会话层**注册（共享模块的 host 在上面构造，绑定本会话的 params/Paths/fs）。
+  // 模块调用一次 host.register(...) ⇒ handlers['math_computation'] = 该会话的 handler；
+  // apply 层（工具面）在 apply 作用域单独注册一次，按名路由回这里（FREEZE §4 要求两层都在）。
+  mathTool = registerMathComputation(mathHost)
+  // 会话层挂载（**字面量形态**）：handler 是模块为**本会话**构造的那一个（闭包住本会话的 params/Paths/fs）；
+  // apply 层的同名词由宿主按 handlerName 路由回这里。两条路径的名字/描述/schema 三处逐字一致。
+  registerTool('math_computation', MATH_TOOL_DESCRIPTION, MATH_TOOL_SCHEMA, async function (args, agent) { return await mathTool.handler(args || {}, agent) })
   // Lean 工具需要知道调用者是谁（记进活动日志与索引署名）。调用者身份**显式传递**，
   // 不从任何全局可变状态推断（审计清单 §1.1）。无法识别时退回 'office'。
   function memberIdOf(agent) { try { const id = agent && agent.id ? String(agent.id) : ''; return id || 'office' } catch (e) { return 'office' } }
@@ -2780,7 +3983,7 @@ export function apply(ctx) {
   registerTool('vibe_math_status', 'Show scheduler status, params, active agents, projects, and recent activity.', objParams({}), async function () { await refreshParams(); return await getStatus() })
   registerTool('vibe_math_report', 'Return the full progress report and write it to Progress_Logs/report.json.', objParams({}), async function () { await refreshParams(); await maybeWriteReport(true); return await buildReport() })
   registerTool('vibe_math_set_mode', 'Switch between manual and auto (preset) mode. Switching to auto auto-resolves any pending manual decisions.', objParams({ mode: { type: 'string', enum: ['manual', 'auto'] } }, ['mode']), async function (args) { params.mode = args.mode; await saveAll(); await saveSettings(); if (params.mode === 'auto') await autoResolvePending(); return { ok: true, mode: params.mode } })
-  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式。', objParams({ maxParallelThreshold: { type: 'integer' }, solverMaxRounds: { type: 'integer' }, verifierCount: { type: 'integer' }, debateMaxRounds: { type: 'integer' }, verdictMode: { type: 'string', enum: ['flat', 'forced'] }, reportMode: { type: 'string', enum: ['file', 'push', 'both'] }, promoteValueThreshold: { type: 'number' }, priorityAdjust: { type: 'string', enum: ['none', 'deadend-deprioritize', 'survival-map'] }, proposPriorityAdjust: { type: 'string', enum: ['none', 'progress-graded'] }, provider: { type: 'string' }, model: { type: 'string' }, solverPersona: { type: 'string' }, verifierPersona: { type: 'string' }, explorerPersona: { type: 'string' }, knowledgeContext: { type: 'string' }, solverToolAllow: { type: 'array', items: { type: 'string' } }, solverToolDeny: { type: 'array', items: { type: 'string' } }, verifierToolAllow: { type: 'array', items: { type: 'string' } }, verifierToolDeny: { type: 'array', items: { type: 'string' } }, solverAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, formalVerify: { type: 'string', enum: ['off', 'encourage', 'require'] }, leanCommand: { type: 'string' }, leanArgs: { type: 'array', items: { type: 'string' } }, leanTimeoutMs: { type: 'integer' } }), async function (args) { params = Object.assign({}, params, sanitizeParams(args)); await saveAll(); await saveSettings(); return { ok: true, params: params } })
+  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式（框架会在用户 leanArgs 之后、文件名之前自动追加 `--search-path <VibeMath 根>`，用户已显式给出就不注入）；leanAsync = true（默认，后台队列：入队即返回，只有作业落地 ok 才置 passed 并写归档证明）| false（同步 await 的旧语义）。leanJobsMaxParallel = 后台编译并发上限（默认 1 = 串行）；leanInitiative = off|normal|eager 控制**日常的**形式化主动性（与 formalVerify 的验证要求强度是两件事：formalVerify=off 只关验证阶段，eager 仍注入日线）；leanSearchPaths = 额外 Lean 搜索路径（默认空 = 只用自动注入的 VibeMath 根；非空时先注入它们、再注入自动根）。最终论文：finalPaper（默认 true；收口时自动派遣一名「论文撰写」子代理）/ paperFormat = both|md|tex / paperLanguage = zh|en / paperCompilePdf（检测到 LaTeX 时编译 paper.pdf）/ paperLatexCommand（指定引擎，空 = 自动探测），产物在 Paper/<项目>/。数学计算（工具 math_computation，回执落在 Computation/<id>/）：mathComputation = off|auto|on（默认 auto；off 时提示词零提及）· mathMode = typed|typed+shell（默认 typed+shell；typed 时提示词不含 shell 兜底段且 cli 返回 REFUSED{reason:policy}）· mathEngines = 允许的引擎列表（默认含 cli，cli 默认开启）· mathTimeoutMs（默认 60000，最小 1000；到时主动 terminate）· mathPackages（需预检的包，缺包只报告+给安装计划）· mathInstallScope = user|system（默认 user；system 只对当次显式调用生效、永不记忆）。', objParams({ maxParallelThreshold: { type: 'integer' }, solverMaxRounds: { type: 'integer' }, verifierCount: { type: 'integer' }, debateMaxRounds: { type: 'integer' }, verdictMode: { type: 'string', enum: ['flat', 'forced'] }, reportMode: { type: 'string', enum: ['file', 'push', 'both'] }, promoteValueThreshold: { type: 'number' }, priorityAdjust: { type: 'string', enum: ['none', 'deadend-deprioritize', 'survival-map'] }, proposPriorityAdjust: { type: 'string', enum: ['none', 'progress-graded'] }, provider: { type: 'string' }, model: { type: 'string' }, solverPersona: { type: 'string' }, verifierPersona: { type: 'string' }, explorerPersona: { type: 'string' }, knowledgeContext: { type: 'string' }, solverToolAllow: { type: 'array', items: { type: 'string' } }, solverToolDeny: { type: 'array', items: { type: 'string' } }, verifierToolAllow: { type: 'array', items: { type: 'string' } }, verifierToolDeny: { type: 'array', items: { type: 'string' } }, solverAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, formalVerify: { type: 'string', enum: ['off', 'encourage', 'require'] }, leanCommand: { type: 'string' }, leanArgs: { type: 'array', items: { type: 'string' } }, leanTimeoutMs: { type: 'integer' }, leanAsync: { type: 'boolean' }, leanJobsMaxParallel: { type: 'integer' }, leanInitiative: { type: 'string', enum: ['off', 'normal', 'eager'] }, leanSearchPaths: { type: 'array', items: { type: 'string' } }, mathComputation: { type: 'string', enum: ['off', 'auto', 'on'] }, mathMode: { type: 'string', enum: ['typed', 'typed+shell'] }, mathEngines: { type: 'array', items: { type: 'string' } }, mathTimeoutMs: { type: 'integer' }, mathPackages: { type: 'array', items: { type: 'string' } }, mathInstallScope: { type: 'string', enum: ['user', 'system'] }, finalPaper: { type: 'boolean' }, paperFormat: { type: 'string', enum: ['both', 'md', 'tex'] }, paperLanguage: { type: 'string', enum: ['zh', 'en'] }, paperCompilePdf: { type: 'boolean' }, paperLatexCommand: { type: 'string' } }), async function (args) { params = Object.assign({}, params, sanitizeParams(args)); await saveAll(); await saveSettings(); if (args && MATH_PARAM_NAMES.some(function (k) { return k in args })) { try { await refreshMathProbe(true) } catch (e) { /* 探测失败不影响参数保存 */ } } return { ok: true, params: params } })
   registerTool('vibe_math_setup', 'Return the interactive parameter schema for guided configuration.', objParams({}), async function () { await refreshParams(); const list = PARAM_SCHEMA.map(function (p) { const out = Object.assign({}, p); out.current = params[p.name]; out.default = DEFAULT_PARAMS[p.name]; return out }); return { ok: true, parameters: list, saveTo: frameworkRoot() + '/vibe_math_setting.json' } })
   registerTool('vibe_math_save_settings', 'Write the current params to vibe_math_setting.json (JSON with comments) as new defaults.', objParams({}), async function () { return await saveSettings() })
   registerTool('vibe_math_template', 'Create a fresh vibe_math_setting.json template (with defaults + comments) in the workspace (global) or current project folder.', objParams({ where: { type: 'string', enum: ['global', 'project'] } }), async function (args) { return await createTemplate((args && args.where) || 'global') })
@@ -2801,17 +4004,24 @@ export function apply(ctx) {
   // ---- Lean 形式化验证（契约 §5）----
   registerTool('vibe_math_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the VibeMath root and report the result. Never throws: a missing toolchain returns LEAN_NOT_FOUND, a non-zero exit returns the compiler output. Pass target=<object id> to also record the run against that object.', objParams({ file: { type: 'string' }, target: { type: 'string' }, timeout_ms: { type: 'integer' } }, ['file']), async function (args, agent) { return await leanRunTool(memberIdOf(agent), args) })
   registerTool('vibe_math_lean_archive', '(member) Archive Lean code. kind="def": a REUSABLE definition/object/assumption → the global cross-project library (Formal/Lib). kind="lemma": a machine-checked lemma → Formal/Proved. kind="proof": the formal proof of a project object → Formal/<target>.lean, and (when the run passes) also Verified/Lean/<target>.lean, marking the object Lean-passed. kind="blocked": record an explicit, reasoned "cannot/not worth formalizing" decision (note required).', objParams({ kind: { type: 'string', enum: ['def', 'lemma', 'proof', 'blocked'] }, name: { type: 'string' }, target: { type: 'string' }, content: { type: 'string' }, from: { type: 'string' }, note: { type: 'string' }, run: { type: 'boolean' } }, ['kind']), async function (args, agent) { return await leanArchive(memberIdOf(agent), args) })
-  registerTool('vibe_math_lean_lib', '(member) List (and by default rebuild) the Lean reuse library: this project\'s Formal/Index.md, plus the global cross-project Formal/Lib and Formal/Proved indexes. Look here BEFORE writing a new definition so you reuse instead of redefining.', objParams({ refresh: { type: 'boolean' } }), async function (args) {
+  registerTool('vibe_math_lean_lib', '(member) List (and by default rebuild) the Lean reuse library: this project\'s Formal/Index.md, plus the global cross-project Formal/Lib and Formal/Proved indexes. Look here BEFORE writing a new definition so you reuse instead of redefining. Also reports the background compile jobs (jobs[]) when leanAsync=true.', objParams({ refresh: { type: 'boolean' } }), async function (args) {
     const noRefresh = !!(args && args.refresh === false)
     const r = noRefresh ? { lib: null, proved: null, objects: Object.keys(formalRecords()).length } : await rebuildLeanLibIndexes()
+    const jobs = []
+    for (const j of leanJobs.values()) jobs.push(Object.assign(leanJobPublic(j), { exitCode: j.exitCode === undefined ? null : j.exitCode, paths: leanJobPaths(j), buildSha256: j.buildSha || '' }))
+    jobs.sort(function (a, b) { return (b.settledAt || 0) - (a.settledAt || 0) || String(a.jobId).localeCompare(String(b.jobId)) })
     return {
       ok: true, mode: formalMode(), rebuilt: !noRefresh,
       counts: r, todo: formalTodo(),
-      objects: Object.keys(formalRecords()).map(function (k) { const rec = formalRecords()[k] || {}; return { target: k, status: rec.status, file: rec.file, proof: rec.proof, note: rec.note } }),
-      paths: { project: 'Formal/（相对项目根）', lib: 'VibeMath/Formal/Lib/', proved: 'VibeMath/Formal/Proved/', proofs: 'Verified/Lean/' },
-      hint: '复用优先：先在 Lib/ 里找现成定义；新定义用 vibe_math_lean_archive kind=\'def\' 归档，已证引理用 kind=\'lemma\'（归档前先跑通，跑不通不要入库）。',
+      async: params.leanAsync !== false,
+      jobs: jobs,
+      objects: Object.keys(formalRecords()).map(function (k) { const rec = formalRecords()[k] || {}; return { target: k, status: rec.status, file: rec.file, proof: rec.proof, note: rec.note, async: rec.async || null } }),
+      paths: { project: 'Formal/（相对项目根）', lib: 'VibeMath/Formal/Lib/', proved: 'VibeMath/Formal/Proved/', proofs: 'Verified/Lean/', searchPath: vibeRoot(), jobs: 'Formal/Jobs/' },
+      hint: '复用优先：先在 Lib/ 里找现成定义（vibe_math_lean_read 可看原文）；新定义用 vibe_math_lean_archive kind=\'def\' 归档，已证引理用 kind=\'lemma\'（归档前先跑通，跑不通不要入库）。异步档用 jobs 字段查后台编译：**只有 state=settled 才是通过**。',
     }
   })
+  registerTool('vibe_math_lean_read', '(member) Read back the original text of one archived Lean file (verbatim reuse). Only files under Formal/Lib and Formal/Proved are readable; name is id-sanitised and path escapes are rejected. Returns {ok,name,file,kind,sha256,bytes,text,truncated} (text capped at 64KB).', objParams({ name: { type: 'string' }, kind: { type: 'string', enum: ['auto', 'lib', 'proved'] } }, ['name']), async function (args) { return await leanReadTool(args) })
+  registerTool('vibe_math_lean_job', '(member) Read-only view of the background Lean compile jobs. Without jobId: the session job list (state/rel/target/attempts/paths). With jobId: that job state/exitCode/receipt + archive paths. waitMs>0 waits up to that many ms for a queued/running job to settle (polling; it does not block the heartbeat) and returns the current state on timeout. Only state=settled with exitCode=0 (same content hash AND same build context) counts as passed.', objParams({ jobId: { type: 'string' }, waitMs: { type: 'integer' } }), async function (args) { return await leanJobTool(args) })
 
   // ================= slash command /vibe =================
   async function dispatchVibeCommand(cmd, args) {
@@ -2835,7 +4045,8 @@ export function apply(ctx) {
     }
     if (cmd === 'decisions') 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 } }) }
     if (cmd === 'agents') { 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 }) } return { ok: true, agents: out } }
-    return { ok: false, usage: 'start | resume | pause | abort | status | report | mode <auto|manual> | setup | save | template [global|project] | add <id> <desc> | add-proposition <id> <概述> | list-propositions | project [list|new <name>|<name>] | decisions | agents', message: 'unknown /vibe subcommand: ' + (cmd || '(empty)') }
+    if (cmd === 'paper') return await paperCommand(args)
+    return { ok: false, usage: 'start | resume | pause | abort | status | report | mode <auto|manual> | setup | save | template [global|project] | add <id> <desc> | add-proposition <id> <概述> | list-propositions | project [list|new <name>|<name>] | decisions | agents | paper [lang=zh|en] [format=both|md|tex] [force]', message: 'unknown /vibe subcommand: ' + (cmd || '(empty)') }
   }
 
   // ================= session surface =================
@@ -2850,6 +4061,21 @@ export function apply(ctx) {
     // 每次工具调用前同步当前项目（按会话读 current.json；多会话互不干扰）
     refreshProject: async function () { if (rootAgent) currentProject = await readCurrentProject() },
     getRunning: function () { return scheduler.running },
+    // apply 级心跳用（修订 §A2）：running=false 之后 scheduleTick() 是空操作，论文的排队重试
+    // （激活上限）与 paper 锁续租必须由**独立于调度器**的心跳驱动。
+    paperRetryDue: paperRetryDue,
+    runPaperRetry: runPaperRetry,
+    // Lean 异步队列（spec §2）：心跳推进队列；dispose 时由 apply 级 disposer 终止在跑的编译。
+    runLeanQueue: runLeanQueue,
+    disposeLeanJobs: disposeLeanJobs,
+    // 数学计算（FREEZE §4）：心跳用 TTL 刷新探测缓存；off 档不探测（真 no-op）。
+    mathProbeDue: mathProbeDue,
+    refreshMathProbe: refreshMathProbe,
+    mathProbe: function () { return mathProbe },
+    // P2a：persona 两个文本块必须含的「归档→编辑→重跑」规则（文本取自共享模块常量，persona 不手抄）。
+    mathArchiveWorkflowLine: MATH_ARCHIVE_WORKFLOW_LINE,
+    leanQueueSize: function () { return leanQueue.length },
+    leanJobsPublic: function () { const out = []; for (const j of leanJobs.values()) out.push(leanJobPublic(j)); return out },
     // childOwner 裁剪用：这个会话当前仍"可能再发 subagent/end"的 child（在册的 + 任务正在等的）。
     referencedChildIds: function () {
       const out = Object.keys(agentRegistry)
@@ -2895,7 +4121,7 @@ export function apply(ctx) {
   registerTool('vibe_math_status', 'Show scheduler status, params, active agents, projects, and recent activity.', objParams({}), 'vibe_math_status')
   registerTool('vibe_math_report', 'Return the full progress report and write it to Progress_Logs/report.json.', objParams({}), 'vibe_math_report')
   registerTool('vibe_math_set_mode', 'Switch between manual and auto (preset) mode. Switching to auto auto-resolves any pending manual decisions.', objParams({ mode: { type: 'string', enum: ['manual', 'auto'] } }, ['mode']), 'vibe_math_set_mode')
-  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式。', objParams({ maxParallelThreshold: { type: 'integer' }, solverMaxRounds: { type: 'integer' }, verifierCount: { type: 'integer' }, debateMaxRounds: { type: 'integer' }, verdictMode: { type: 'string', enum: ['flat', 'forced'] }, reportMode: { type: 'string', enum: ['file', 'push', 'both'] }, promoteValueThreshold: { type: 'number' }, priorityAdjust: { type: 'string', enum: ['none', 'deadend-deprioritize', 'survival-map'] }, proposPriorityAdjust: { type: 'string', enum: ['none', 'progress-graded'] }, provider: { type: 'string' }, model: { type: 'string' }, solverPersona: { type: 'string' }, verifierPersona: { type: 'string' }, explorerPersona: { type: 'string' }, knowledgeContext: { type: 'string' }, solverToolAllow: { type: 'array', items: { type: 'string' } }, solverToolDeny: { type: 'array', items: { type: 'string' } }, verifierToolAllow: { type: 'array', items: { type: 'string' } }, verifierToolDeny: { type: 'array', items: { type: 'string' } }, solverAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, formalVerify: { type: 'string', enum: ['off', 'encourage', 'require'] }, leanCommand: { type: 'string' }, leanArgs: { type: 'array', items: { type: 'string' } }, leanTimeoutMs: { type: 'integer' } }), 'vibe_math_set_params')
+  registerTool('vibe_math_set_params', 'Update scheduler parameters (partial). Lean 形式化验证：formalVerify = off（默认，不额外要求）| encourage（按实现难度自行决定是否形式化；一旦 Lean 通过，验证转为对 Lean 陈述的「忠实性审查」）| require（同上，且加门禁：对象的 formal.status 未达到 passed/blocked 之前，真/假裁定记为未定论、原因 formal-required，并进入 Formal/TODO.md）；leanCommand/leanArgs/leanTimeoutMs 控制 Lean 工具链的调用方式（框架会在用户 leanArgs 之后、文件名之前自动追加 `--search-path <VibeMath 根>`，用户已显式给出就不注入）；leanAsync = true（默认，后台队列：入队即返回，只有作业落地 ok 才置 passed 并写归档证明）| false（同步 await 的旧语义）。leanJobsMaxParallel = 后台编译并发上限（默认 1 = 串行）；leanInitiative = off|normal|eager 控制**日常的**形式化主动性（与 formalVerify 的验证要求强度是两件事：formalVerify=off 只关验证阶段，eager 仍注入日线）；leanSearchPaths = 额外 Lean 搜索路径（默认空 = 只用自动注入的 VibeMath 根；非空时先注入它们、再注入自动根）。最终论文：finalPaper（默认 true；收口时自动派遣一名「论文撰写」子代理）/ paperFormat = both|md|tex / paperLanguage = zh|en / paperCompilePdf（检测到 LaTeX 时编译 paper.pdf）/ paperLatexCommand（指定引擎，空 = 自动探测），产物在 Paper/<项目>/。数学计算（工具 math_computation，回执落在 Computation/<id>/）：mathComputation = off|auto|on（默认 auto；off 时提示词零提及）· mathMode = typed|typed+shell（默认 typed+shell；typed 时提示词不含 shell 兜底段且 cli 返回 REFUSED{reason:policy}）· mathEngines = 允许的引擎列表（默认含 cli，cli 默认开启）· mathTimeoutMs（默认 60000，最小 1000；到时主动 terminate）· mathPackages（需预检的包，缺包只报告+给安装计划）· mathInstallScope = user|system（默认 user；system 只对当次显式调用生效、永不记忆）。', objParams({ maxParallelThreshold: { type: 'integer' }, solverMaxRounds: { type: 'integer' }, verifierCount: { type: 'integer' }, debateMaxRounds: { type: 'integer' }, verdictMode: { type: 'string', enum: ['flat', 'forced'] }, reportMode: { type: 'string', enum: ['file', 'push', 'both'] }, promoteValueThreshold: { type: 'number' }, priorityAdjust: { type: 'string', enum: ['none', 'deadend-deprioritize', 'survival-map'] }, proposPriorityAdjust: { type: 'string', enum: ['none', 'progress-graded'] }, provider: { type: 'string' }, model: { type: 'string' }, solverPersona: { type: 'string' }, verifierPersona: { type: 'string' }, explorerPersona: { type: 'string' }, knowledgeContext: { type: 'string' }, solverToolAllow: { type: 'array', items: { type: 'string' } }, solverToolDeny: { type: 'array', items: { type: 'string' } }, verifierToolAllow: { type: 'array', items: { type: 'string' } }, verifierToolDeny: { type: 'array', items: { type: 'string' } }, solverAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowNetwork: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, verifierAllowScripts: { oneOf: [{ type: 'boolean' }, { type: 'string', enum: [''] }] }, solverMaxToolCalls: { type: 'integer' }, verifierMaxToolCalls: { type: 'integer' }, reportIntervalMs: { type: 'integer' }, tickIntervalMs: { type: 'integer' }, activityLogCap: { type: 'integer' }, maxExplorerRetries: { type: 'integer' }, directionsPerSolver: { type: 'integer' }, formalVerify: { type: 'string', enum: ['off', 'encourage', 'require'] }, leanCommand: { type: 'string' }, leanArgs: { type: 'array', items: { type: 'string' } }, leanTimeoutMs: { type: 'integer' }, leanAsync: { type: 'boolean' }, leanJobsMaxParallel: { type: 'integer' }, leanInitiative: { type: 'string', enum: ['off', 'normal', 'eager'] }, leanSearchPaths: { type: 'array', items: { type: 'string' } }, mathComputation: { type: 'string', enum: ['off', 'auto', 'on'] }, mathMode: { type: 'string', enum: ['typed', 'typed+shell'] }, mathEngines: { type: 'array', items: { type: 'string' } }, mathTimeoutMs: { type: 'integer' }, mathPackages: { type: 'array', items: { type: 'string' } }, mathInstallScope: { type: 'string', enum: ['user', 'system'] }, finalPaper: { type: 'boolean' }, paperFormat: { type: 'string', enum: ['both', 'md', 'tex'] }, paperLanguage: { type: 'string', enum: ['zh', 'en'] }, paperCompilePdf: { type: 'boolean' }, paperLatexCommand: { type: 'string' } }), 'vibe_math_set_params')
   registerTool('vibe_math_setup', 'Return the interactive parameter schema for guided configuration.', objParams({}), 'vibe_math_setup')
   registerTool('vibe_math_save_settings', 'Write the current params to vibe_math_setting.json (JSON with comments) as new defaults.', objParams({}), 'vibe_math_save_settings')
   registerTool('vibe_math_template', 'Create a fresh vibe_math_setting.json template (with defaults + comments) in the workspace (global) or current project folder.', objParams({ where: { type: 'string', enum: ['global', 'project'] } }), 'vibe_math_template')
@@ -2917,13 +4143,23 @@ export function apply(ctx) {
   // 人/代理主动调用时一样可用。
   registerTool('vibe_math_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the VibeMath root and report the result. Never throws: a missing toolchain returns LEAN_NOT_FOUND, a non-zero exit returns the compiler output. Pass target=<object id> to also record the run against that object.', objParams({ file: { type: 'string' }, target: { type: 'string' }, timeout_ms: { type: 'integer' } }, ['file']), 'vibe_math_lean_run')
   registerTool('vibe_math_lean_archive', '(member) Archive Lean code. kind="def": a REUSABLE definition/object/assumption → the global cross-project library (Formal/Lib). kind="lemma": a machine-checked lemma → Formal/Proved. kind="proof": the formal proof of a project object → Formal/<target>.lean, and (when the run passes) also Verified/Lean/<target>.lean, marking the object Lean-passed. kind="blocked": record an explicit, reasoned "cannot/not worth formalizing" decision (note required).', objParams({ kind: { type: 'string', enum: ['def', 'lemma', 'proof', 'blocked'] }, name: { type: 'string' }, target: { type: 'string' }, content: { type: 'string' }, from: { type: 'string' }, note: { type: 'string' }, run: { type: 'boolean' } }, ['kind']), 'vibe_math_lean_archive')
-  registerTool('vibe_math_lean_lib', '(member) List (and by default rebuild) the Lean reuse library: this project\'s Formal/Index.md, plus the global cross-project Formal/Lib and Formal/Proved indexes. Look here BEFORE writing a new definition so you reuse instead of redefining.', objParams({ refresh: { type: 'boolean' } }), 'vibe_math_lean_lib')
+  registerTool('vibe_math_lean_lib', '(member) List (and by default rebuild) the Lean reuse library: this project\'s Formal/Index.md, plus the global cross-project Formal/Lib and Formal/Proved indexes. Look here BEFORE writing a new definition so you reuse instead of redefining. Also reports the background compile jobs (jobs[]) when leanAsync=true.', objParams({ refresh: { type: 'boolean' } }), 'vibe_math_lean_lib')
+  registerTool('vibe_math_lean_read', '(member) Read back the original text of one archived Lean file (verbatim reuse). Only files under Formal/Lib and Formal/Proved are readable; name is id-sanitised and path escapes are rejected. Returns {ok,name,file,kind,sha256,bytes,text,truncated} (text capped at 64KB).', objParams({ name: { type: 'string' }, kind: { type: 'string', enum: ['auto', 'lib', 'proved'] } }, ['name']), 'vibe_math_lean_read')
+  registerTool('vibe_math_lean_job', '(member) Read-only view of the background Lean compile jobs. Without jobId: the session job list (state/rel/target/attempts/paths). With jobId: that job state/exitCode/receipt + archive paths. waitMs>0 waits up to that many ms for a queued/running job to settle (polling; it does not block the heartbeat) and returns the current state on timeout. Only state=settled with exitCode=0 (same content hash AND same build context) counts as passed.', objParams({ jobId: { type: 'string' }, waitMs: { type: 'integer' } }), 'vibe_math_lean_job')
+
+  // ── math_computation：apply 层（工具面）────────────────────────────────────────────────────
+  // 共享模块的 handler 在**会话层**构造（它闭包住该会话的 params/Paths/fs）；这一层只把
+  // 工具名/描述/schema 挂到宿主工具面，执行时由 apply 级包装按 handlerName 路由回
+  // s.handlers['math_computation']（即上面那个会话级实例）。两层都注册是 v2/v3 的硬要求。
+  // **字面量形态**（名字字面量 + 描述/schema 常量）：与 v3 的两层声明保持同一形状，
+  // 静态扫描器/注册面审计（audit-registration、audit-v3-registration-parity）都能看见。
+  registerTool('math_computation', MATH_TOOL_DESCRIPTION, MATH_TOOL_SCHEMA, 'math_computation')
 
   // /vibe slash command (registered once; routed per session)
   ctx.effect(() => commands.register({
     name: 'vibe',
     description: 'control the Vibe Math V2 solver (start/pause/projects/setup/save/decisions/agents/propositions)',
-    input: { hint: '[start|resume|pause|abort|status|report|mode <auto|manual>|setup|save|template [global|project]|add <id> <desc>|add-proposition <id> <概述>|list-propositions|project [list|new <name>|<name>]|decisions|agents]' },
+    input: { hint: '[start|resume|pause|abort|status|report|mode <auto|manual>|setup|save|template [global|project]|add <id> <desc>|add-proposition <id> <概述>|list-propositions|project [list|new <name>|<name>]|decisions|agents|paper [lang=zh|en] [format=both|md|tex] [force]]' },
     handler: async function (invocation) {
       const s = getSession(invocation && invocation.agent)
       if (!s) return { kind: 'error', text: JSON.stringify({ ok: false, error: 'no vibe-math session for this agent' }) }
@@ -2956,14 +4192,31 @@ export function apply(ctx) {
   ctx.effect(() => {
     let beat = 0
     const t = setInterval(function () {
-      for (const s of sessions.values()) { if (s.getRunning() && !s.tickInFlight && s.tickDue() && s.scheduler.gate === null) s.scheduleTick() }
+      for (const s of sessions.values()) {
+        if (s.getRunning() && !s.tickInFlight && s.tickDue() && s.scheduler.gate === null) s.scheduleTick()
+        // 论文心跳（修订 §A2）：**独立于 scheduler.running** —— 收口后 running=false，但被激活上限
+        // 拒绝的撰写派遣仍要重试，在途时还要续租 paper 锁（否则别的会话 2 分钟后可接管同一棵树）。
+        // runPaperRetry() 在两种情形都不成立时立即返回（一次布尔判断）。
+        if (typeof s.runPaperRetry === 'function') s.runPaperRetry().catch(function (e) { console.error('vibe-math-v2: paper retry failed: ' + String((e && e.message) || e)) })
+        // Lean 异步队列（spec §2.2）：同样独立于 scheduler.running —— 作业在收口后仍要落地。
+        // runLeanQueue() 内部**不 await 编译**，所以这条心跳不会被一个编译占住。
+        if (typeof s.runLeanQueue === 'function') s.runLeanQueue().catch(function (e) { console.error('vibe-math-v2: lean queue failed: ' + String((e && e.message) || e)) })
+        // 数学计算的探测缓存 TTL 刷新（15 分钟或从未探测过）：mathWorkLine 只读缓存，不能自己 await。
+        if (typeof s.mathProbeDue === 'function' && s.mathProbeDue()) s.refreshMathProbe(false).catch(function (e) { console.error('vibe-math-v2: math probe failed: ' + String((e && e.message) || e)) })
+      }
       // childOwner / sessions 裁剪：每 30 拍（约 30s）一次，成本是"会话数 × 映射数"的一次扫描。
       if ((++beat % 30) === 0) {
         try { pruneChildOwner() } catch (e) { console.error('vibe-math-v2: pruneChildOwner failed: ' + String((e && e.message) || e)) }
         try { pruneSessions() } catch (e) { console.error('vibe-math-v2: pruneSessions failed: ' + String((e && e.message) || e)) }
       }
     }, 1000)
-    return () => clearInterval(t)
+    return () => {
+      clearInterval(t)
+      // 卸载/销毁：终止在跑的编译并标记 interrupted（不留孤儿进程，spec §2.5）。
+      for (const s of sessions.values()) {
+        try { if (typeof s.disposeLeanJobs === 'function') s.disposeLeanJobs() } catch (e) { console.error('vibe-math-v2: lean dispose failed: ' + String((e && e.message) || e)) }
+      }
+    }
   })
 }
 
@@ -2980,6 +4233,326 @@ export function apply(ctx) {
 // to the clock) and `parseProgress` normalises the object it is handed in place (pre-existing).
 // Nothing here is used by the plugin at runtime except through `apply()`, and behaviour is
 // byte-identical to the previous in-`apply` declarations.
+// ============================================================================================
+// 最终论文（规格：docs/final-paper.md）—— **纯函数部分**（module scope，v2/v3 逐字同构；
+// 只有数据来源不同）。会话相关的落盘/派遣/编译在 makeSession 里（见 paperCommand/maybeWritePaper）。
+// ============================================================================================
+/** 固定 9 节骨架（spec §3）。key 同时是 md 的 `## ` 标题与 tex 的 `\section{}`。 */
+const PAPER_SKELETON = [
+  { key: '摘要', spec: '1 标题、作者、日期、摘要（原问题 + 主要结论）' },
+  { key: '引言与问题背景', spec: '2 原问题的完整陈述' },
+  { key: '原问题的完整解法', spec: '3 最终答案 + 完整推理链' },
+  { key: '已检验通过的命题', spec: '4 逐条列出，含判定为真的估计值与证据来源' },
+  { key: '已解决的子问题与中间成果', spec: '5' },
+  { key: '创造或发现的有价值之物', spec: '6 方法、理论、思想、有价值经验、数学理解' },
+  { key: '规律总结', spec: '7 从上述条目归纳出的可复用规律' },
+  { key: '讨论、局限与展望', spec: '8' },
+  { key: '附录：证据与文件索引', spec: '9 Verified/、Logs/、关键卡片路径' },
+]
+const PAPER_NO_EVIDENCE = '（本节暂无证据支持的内容——不编造。）'
+const PAPER_EVIDENCE_HEADING = '证据与文件索引'
+/** LaTeX 引擎检测顺序（spec §5）：中文优先 xelatex，英文优先 pdflatex/latexmk。 */
+const PAPER_ENGINE_ORDER_ZH = ['xelatex', 'latexmk', 'pdflatex', 'lualatex', 'tectonic']
+const PAPER_ENGINE_ORDER_EN = ['pdflatex', 'latexmk', 'xelatex', 'lualatex', 'tectonic']
+/** 只用常见宏包（spec §5）；修复阶段会丢弃不在这个名单里的 \usepackage。 */
+const PAPER_ALLOWED_PACKAGES = ['amsmath', 'amssymb', 'amsthm', 'geometry', 'hyperref', 'longtable', 'booktabs']
+/** tex 必须转义的 10 个字符（spec §5）：\ _ % & # $ { } ~ ^ ——一次替换，避免二次转义。 */
+const PAPER_TEX_MAP = { '\\': '\\textbackslash{}', '_': '\\_', '%': '\\%', '&': '\\&', '#': '\\#', '$': '\\$', '{': '\\{', '}': '\\}', '~': '\\textasciitilde{}', '^': '\\textasciicircum{}' }
+function texEscape(s) { return String(s == null ? '' : s).replace(/[\\_%&#${}~^]/g, function (c) { return PAPER_TEX_MAP[c] }) }
+/** 输入材料摘要（仅供 paper.log.md/meta 记录规模，**不**用于幂等判定：spec v2 §C 用 run id + finalizedAt + 逐产物存在性）。 */
+function paperMaterialSummary(digest) {
+  const t = String(digest == null ? '' : digest)
+  return { chars: t.length, lines: t.split('\n').length }
+}
+/**
+ * 撰写者卡死判定（纯函数，便于守卫覆盖两条分支）：
+ *   'none'   正常在途（还没到卡死窗口，且 force 未要求放弃）
+ *   'reap'   必须回收：child 已不在 agentRegistry（end 事件丢失 / 宿主丢弃，它永远不会再回来），
+ *            或已超过卡死窗口——force 与心跳都据此自动降级，论文不能被一个死掉的撰写者永久卡住
+ *   'refuse' force 但还没到窗口：调用方必须给出**可执行**的报错（告诉调用者还要等多久）
+ */
+function paperWriterVerdict(o) {
+  if (!(o && o.inFlight)) return 'none'
+  if (o.childInRegistry === false) return 'reap'
+  const age = Number((o && o.ageMs) || 0)
+  const stale = Math.max(1, Number((o && o.staleMs) || 0))
+  if (age >= stale) return 'reap'
+  return (o && o.force) ? 'refuse' : 'none'
+}
+/** 行内 md → tex：``code`` / **bold** / *em* 转成命令，其余文本按 spec §5 转义；`$...$` 原样保留（数学模式由作者书写）。 */
+function paperInlineToTex(s) {
+  const t = String(s == null ? '' : s)
+  let out = ''
+  let i = 0
+  while (i < t.length) {
+    const c = t[i]
+    if (c === '$') { const j = t.indexOf('$', i + 1); if (j > i) { out += t.slice(i, j + 1); i = j + 1; continue } }
+    if (c === '`') { const j = t.indexOf('`', i + 1); if (j > i) { out += '\\texttt{' + texEscape(t.slice(i + 1, j)) + '}'; i = j + 1; continue } }
+    if (c === '*' && t[i + 1] === '*') { const j = t.indexOf('**', i + 2); if (j > i) { out += '\\textbf{' + paperInlineToTex(t.slice(i + 2, j)) + '}'; i = j + 2; continue } }
+    if (c === '*') { const j = t.indexOf('*', i + 1); if (j > i) { out += '\\emph{' + paperInlineToTex(t.slice(i + 1, j)) + '}'; i = j + 1; continue } }
+    // 普通字符：按 10 个字符的映射逐字转义（一次一个字符，天然不会二次转义）
+    out += PAPER_TEX_MAP[c] !== undefined ? PAPER_TEX_MAP[c] : c
+    i++
+  }
+  return out
+}
+/** md 正文 → tex 正文（标题/列表/段落；只认 compose 侧约定的最小语法）。 */
+function paperMdToTexBody(md) {
+  const out = []
+  let inList = false
+  let buf = []
+  const flush = function () { if (buf.length) { out.push(paperInlineToTex(buf.join(' '))); buf = [] } }
+  const closeList = function () { if (inList) { out.push('\\end{itemize}'); inList = false } }
+  const lines = String(md == null ? '' : md).split(/\r?\n/)
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].replace(/\s+$/, '')
+    const h = /^(#{1,4})\s+(.*)$/.exec(line)
+    if (h) {
+      flush(); closeList()
+      const txt = paperInlineToTex(h[2])
+      const lv = h[1].length
+      out.push(lv <= 1 ? ('\\section*{' + txt + '}') : lv === 2 ? ('\\section{' + txt + '}') : lv === 3 ? ('\\subsection{' + txt + '}') : ('\\subsubsection{' + txt + '}'))
+      continue
+    }
+    const li = /^\s*[-*]\s+(.*)$/.exec(line)
+    if (li) { flush(); if (!inList) { out.push('\\begin{itemize}'); inList = true } out.push('  \\item ' + paperInlineToTex(li[1])); continue }
+    if (!line.trim()) { flush(); closeList(); out.push(''); continue }
+    buf.push(line.trim())
+  }
+  flush(); closeList()
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trim()
+}
+/** 主模板（spec §5）：中文 ctexart / 英文 article，只加常见宏包。 */
+function paperTexDoc(o) {
+  const lang = (o && o.lang === 'en') ? 'en' : 'zh'
+  return [
+    '\\documentclass[11pt]{' + (lang === 'en' ? 'article' : 'ctexart') + '}',
+    '\\usepackage[margin=2.5cm]{geometry}',
+    '\\usepackage{amsmath,amssymb,amsthm}',
+    '\\usepackage{hyperref}',
+    '\\usepackage{longtable,booktabs}',
+    '\\title{' + texEscape(o && o.title) + '}',
+    '\\author{' + texEscape(o && o.author) + '}',
+    '\\date{' + texEscape(o && o.date) + '}',
+    '\\begin{document}',
+    '\\maketitle',
+    String((o && o.bodyTex) || ''),
+    '\\end{document}',
+  ].join('\n') + '\n'
+}
+/** 修复阶段的**最小模板**（spec §5）：只留 documentclass + 正文（section/itemize/texttt 都在 LaTeX 核心）。 */
+function paperMinimalTexDoc(o) {
+  const lang = (o && o.lang === 'en') ? 'en' : 'zh'
+  return [
+    '\\documentclass[11pt]{' + (lang === 'en' ? 'article' : 'ctexart') + '}',
+    '\\begin{document}',
+    String((o && o.bodyTex) || ''),
+    '\\end{document}',
+  ].join('\n') + '\n'
+}
+/** 修复阶段：丢弃不在常见宏包名单里的 \usepackage（其余原样保留）。 */
+function paperSanitizeTex(tex) {
+  const keep = []
+  const lines = String(tex == null ? '' : tex).split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^\s*\\usepackage(\[[^\]]*\])?\{([^}]*)\}\s*$/.exec(lines[i])
+    if (m) {
+      const pkgs = String(m[2]).split(',').map(function (x) { return x.trim() }).filter(Boolean)
+      const ok = pkgs.filter(function (p) { return PAPER_ALLOWED_PACKAGES.indexOf(p) >= 0 })
+      if (ok.length === 0) continue
+      keep.push('\\usepackage' + (m[1] || '') + '{' + ok.join(',') + '}')
+      continue
+    }
+    keep.push(lines[i])
+  }
+  return keep.join('\n')
+}
+/** 骨架名匹配：允许带序号/前缀，或只写节名的一部分（例如「附录」）。 */
+function paperSkeletonKey(name) {
+  const n = String(name == null ? '' : name).replace(/^#+\s*/, '').trim()
+  if (!n) return undefined
+  for (const s of PAPER_SKELETON) if (n === s.key) return s.key
+  for (const s of PAPER_SKELETON) if (n.indexOf(s.key) !== -1 || s.key.indexOf(n) !== -1) return s.key
+  return undefined
+}
+/** 按 `## ` 把任意 markdown 切成 [{name,text}]（无标题时 name=''）。 */
+function paperSplitByHeadings(md) {
+  const out = []
+  let cur = { name: '', text: [] }
+  const lines = String(md == null ? '' : md).split(/\r?\n/)
+  for (let i = 0; i < lines.length; i++) {
+    const h = /^##\s+(.*?)\s*$/.exec(lines[i])
+    if (h) { if (cur.name || cur.text.length) out.push({ name: cur.name, text: cur.text.join('\n').trim() }); cur = { name: h[1], text: [] }; continue }
+    cur.text.push(lines[i])
+  }
+  if (cur.name || cur.text.length) out.push({ name: cur.name, text: cur.text.join('\n').trim() })
+  return out
+}
+/**
+ * 把「论文撰写」子代理的回复映射到 9 节骨架上（spec §3/§4）。
+ * 接受契约 JSON（title/abstract/sections[]）或一整段 md（按 `## ` 切）；**绝不编造**：
+ * 没写到的节由调用方填 PAPER_NO_EVIDENCE，不属于骨架的节并入第 8 节并记一条说明。
+ */
+function paperSkeletonFromReply(reply, fallbackText) {
+  const sections = {}
+  const notes = []
+  let title = ''
+  let abstract = ''
+  const put = function (key, body) {
+    const b = String(body == null ? '' : body).trim()
+    if (!b) return
+    sections[key] = sections[key] ? (sections[key] + '\n\n' + b) : b
+  }
+  const absorbUnknown = function (name, text) {
+    if (!name && !String(text || '').trim()) return
+    notes.push('作者写了一节「' + (name || '(无名)') + '」，不属于固定 9 节骨架，已并入「讨论、局限与展望」')
+    put('讨论、局限与展望', (name ? ('**' + name + '**\n\n') : '') + text)
+  }
+  const obj = (reply && typeof reply === 'object' && !Array.isArray(reply)) ? reply : null
+  if (obj) {
+    title = String(obj.title || obj.标题 || '').trim()
+    abstract = String(obj.abstract || obj.摘要 || '').trim()
+    const list = Array.isArray(obj.sections) ? obj.sections : (Array.isArray(obj.章节) ? obj.章节 : [])
+    for (let i = 0; i < list.length; i++) {
+      const s = list[i]
+      if (!s) continue
+      const name = String(s.name || s.key || s.heading || s.标题 || '')
+      const body = String(s.body != null ? s.body : (s.content != null ? s.content : (s.内容 != null ? s.内容 : '')))
+      const key = paperSkeletonKey(name)
+      if (key === undefined) absorbUnknown(name.trim(), body)
+      else put(key, body)
+    }
+    const bodyField = String(obj.body || obj.content || obj.md || obj.正文 || '')
+    if (bodyField.trim()) {
+      const parts = paperSplitByHeadings(bodyField)
+      for (let i = 0; i < parts.length; i++) {
+        const key = paperSkeletonKey(parts[i].name)
+        if (key === undefined) { if (!parts[i].name && !abstract && !sections['摘要']) abstract = parts[i].text; else if (parts[i].name) absorbUnknown(parts[i].name, parts[i].text) }
+        else put(key, parts[i].text)
+      }
+    }
+  } else {
+    // 非契约 JSON：把模型**原样**写出的 md 当正文（不编造任何内容；识别不了就整体并入第 8 节）
+    const parts = paperSplitByHeadings(String(fallbackText == null ? '' : fallbackText))
+    let matched = 0
+    for (let i = 0; i < parts.length; i++) {
+      const key = paperSkeletonKey(parts[i].name)
+      if (key === undefined) { if (parts[i].name) absorbUnknown(parts[i].name, parts[i].text) }
+      else { put(key, parts[i].text); matched++ }
+    }
+    if (matched === 0) {
+      const raw = String(fallbackText == null ? '' : fallbackText).trim()
+      if (raw) { notes.push('作者回复不是契约 JSON，也没有可识别的 `## ` 节标题；其原样正文已记入「讨论、局限与展望」'); put('讨论、局限与展望', raw) }
+      else notes.push('作者回复为空：没有任何内容可写（不得编造）')
+    }
+  }
+  return { title: title, abstract: abstract, sections: sections, notes: notes }
+}
+/** 组装 md（spec §3）：9 节固定骨架 + 确定性证据索引；缺证据的节写占位说明。 */
+function paperBuildMarkdown(o) {
+  const sec = (o && o.sections) || {}
+  const ev = ((o && o.evidence) || []).slice()
+  const L = []
+  const ttl = String((o && o.title) || '').trim() || '研究报告'
+  L.push('# ' + ttl)
+  L.push('')
+  L.push('- 作者：' + String((o && o.author) || ''))
+  L.push('- 日期：' + String((o && o.date) || ''))
+  L.push('')
+  for (let i = 0; i < PAPER_SKELETON.length; i++) {
+    const key = PAPER_SKELETON[i].key
+    L.push('## ' + key)
+    L.push('')
+    let body = String(sec[key] || '').trim()
+    if (key === '摘要') { const ab = String((o && o.abstract) || '').trim(); if (ab) body = body ? (ab + '\n\n' + body) : ab }
+    if (key === '附录：证据与文件索引' && ev.length) {
+      const idx = '### ' + PAPER_EVIDENCE_HEADING + '\n\n' + ev.map(function (x) { return '- `' + String(x) + '`' }).join('\n')
+      body = body ? (body + '\n\n' + idx) : idx
+    }
+    L.push(body || PAPER_NO_EVIDENCE)
+    L.push('')
+  }
+  return L.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n'
+}
+/** paper.log.md 的**唯一格式**（v2/v3 逐字一致，spec §4）。 */
+function paperLogHead(id) {
+  return ['# 论文写作日志｜' + String(id), '',
+    '> 单作者流程（v2/v3 同一格式）：收口触发 → 派遣「论文撰写」子代理 → 落盘 md/tex → 编译 pdf。', '']
+}
+function paperLogLine(at, tag, text) { return '- ' + fmtTime(at) + ' [' + String(tag) + '] ' + String(text == null ? '' : text) }
+/** 论文目录 id：只允许安全字符（同一把归一化 ⇒ 不可能写出 Paper/ 之外，spec §6 越权用例）。 */
+function paperDirId(raw) { return (safeId(String(raw == null ? '' : raw).trim()) || 'run') }
+/** 从回复里抽出可能存在的标题行（md 非契约路径的兜底）。 */
+function paperTitleFromMd(md) {
+  const m = /^#\s+(.*?)\s*$/m.exec(String(md == null ? '' : md))
+  return m ? m[1].trim() : ''
+}
+
+// ============================================================================================
+// Lean 增量 + 异步（规格：docs/formal-verification.md；设计：_oneoff/lean-incremental-async-spec.md）
+// **纯函数部分**（module scope，v2/v3 逐字同构）。
+// ============================================================================================
+/** 搜索路径 flag：收敛成一个常量（不同 Lean 版本拼写可能不同，改这里即可，接口不变）。 */
+const LEAN_SEARCH_PATH_FLAG = '--search-path'
+/** 用户已显式给出搜索路径就不再注入（显式覆盖优先）。 */
+function hasLeanSearchFlag(args) {
+  return (Array.isArray(args) ? args : []).some(function (a) {
+    const s = String(a)
+    return s === LEAN_SEARCH_PATH_FLAG || s.indexOf(LEAN_SEARCH_PATH_FLAG + '=') === 0 || s === '-R' || s === '--root'
+  })
+}
+/**
+ * 搜索路径注入计划（修订 §2）：用户 leanArgs 已显式给过 ⇒ 什么都不注入（显式覆盖优先）；
+ * 否则**先注入用户给的 leanSearchPaths，再注入自动根**，去重且保持顺序。
+ */
+function leanSearchPathPlan(userArgs, extraPaths, autoRoot) {
+  const args = Array.isArray(userArgs) ? userArgs.map(String) : []
+  if (hasLeanSearchFlag(args)) return { inject: [], paths: [], explicit: true }
+  const out = []
+  const seen = {}
+  const add = function (p) {
+    const s = String(p == null ? '' : p).trim()
+    if (!s || seen[s]) return
+    seen[s] = true
+    out.push(s)
+  }
+  for (const p of (Array.isArray(extraPaths) ? extraPaths : [])) add(p)
+  add(autoRoot)
+  const inject = []
+  for (const p of out) { inject.push(LEAN_SEARCH_PATH_FLAG, p) }
+  return { inject: inject, paths: out, explicit: false }
+}
+/** 规范化文本：换行统一 \n、去行尾空白、去尾部空行——内容哈希只反映语义内容。 */
+function normalizeLeanText(t) {
+  return String(t == null ? '' : t).replace(/\r\n?/g, '\n').replace(/[ \t]+$/gm, '').replace(/\n+$/, '') + '\n'
+}
+/** 内容 sha256（归档去重与作业幂等的键）。 */
+function leanContentSha(t) { return createHash('sha256').update(normalizeLeanText(t), 'utf8').digest('hex') }
+/**
+ * 构建上下文（修订 §4）：同一段代码在不同引擎/参数/搜索路径下结果可能不同，
+ * 所以"已通过"的判定必须绑定**构建上下文**，不能只看内容。
+ */
+function leanBuildContext(engine, args, searchPaths) {
+  return JSON.stringify({
+    engine: String(engine == null ? '' : engine),
+    args: (Array.isArray(args) ? args : []).map(String),
+    searchPaths: (Array.isArray(searchPaths) ? searchPaths : []).map(String),
+  })
+}
+/** 作业指纹 = sha256(内容 + 构建上下文)（修订 §4：jobId 取它的前 12 位）。 */
+function leanJobFingerprint(contentText, buildCtx) {
+  return createHash('sha256').update(normalizeLeanText(contentText) + '\n' + String(buildCtx || ''), 'utf8').digest('hex')
+}
+/** jobId = `<target|name>-<指纹[0:12]>`：同一内容 + 同一构建上下文天然只有一个作业。 */
+function leanJobId(key, fingerprint) {
+  const k = String(key == null ? '' : key).replace(/[^A-Za-z0-9_.-]/g, '_').replace(/^_+|_+$/g, '').slice(0, 60) || 'job'
+  return k + '-' + String(fingerprint == null ? '' : fingerprint).slice(0, 12)
+}
+/** "已落地且通过"的**唯一**判据：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,
   shortId,
@@ -2994,6 +4567,38 @@ export const __testHelpers = {
   parseProgress,
   sanitizeToolFilter,
   registeredToolsFromError,
+  // Lean 增量/异步（§7 的纯函数守卫面）
+  LEAN_SEARCH_PATH_FLAG,
+  hasLeanSearchFlag,
+  leanSearchPathPlan,
+  normalizeLeanText,
+  leanContentSha,
+  leanBuildContext,
+  leanJobFingerprint,
+  leanJobId,
+  leanJobSettledOk,
+  LEAN_INITIATIVE_MODES,
+  // final paper（spec §6 的纯函数守卫面）
+  PAPER_SKELETON,
+  PAPER_NO_EVIDENCE,
+  PAPER_ALLOWED_PACKAGES,
+  PAPER_ENGINE_ORDER_ZH,
+  PAPER_ENGINE_ORDER_EN,
+  texEscape,
+  paperMaterialSummary,
+  paperWriterVerdict,
+  paperInlineToTex,
+  paperMdToTexBody,
+  paperTexDoc,
+  paperMinimalTexDoc,
+  paperSanitizeTex,
+  paperSkeletonKey,
+  paperSkeletonFromReply,
+  paperBuildMarkdown,
+  paperLogHead,
+  paperLogLine,
+  paperDirId,
+  paperTitleFromMd,
 }
 
 function now() { return Date.now() }