dsh-vibe-math 2.5.0 → 2.7.0

package/vibe-math-v4/vibe-math-v4.js

@@ -12,6 +12,32 @@
 // only from the dynamic-package start path); v2/v3 use those globals and work. An earlier
 // version of this note claimed the globals do not exist — false for file rows, and it would
 // only become true if this preset were ever converted to a dynamic package.
+// The Lean job id and the archive de-duplication are CONTENT-hash based (`lean-incremental-async`
+// spec §4.3), so the plugin needs a real SHA-256. `node:crypto` is a plain Node builtin here: a
+// preset is a FILE row loaded by a host-realm import(), and the plugin already relies on Node
+// builtins (`process.platform`) — see the header note about the vm sandbox applying only to a
+// DYNAMIC package's host half.
+import { createHash } from 'node:crypto'
+// math_computation (docs/math-computation.md, `_oneoff/mc-P1-ready/INTERFACE-FREEZE.md` §5): the tool
+// CORE lives in the shared module — installed byte-identically into all four presets by the
+// integration owner and checked by `tests/audit-math-computation-parity.mjs`. This preset only WIRES
+// it: params, one registration, and the prompt text. Names/shapes come from the module, never
+// re-spelled here (the six parameter names are a frozen cross-preset contract).
+import {
+  registerMathComputation,
+  probeMathEngines,
+  MATH_TOOL_DESCRIPTION,
+  MATH_PERSONA_TOOL_LINE,
+  MATH_RULE_LINES,
+  MATH_RULE_LINES_EN,
+  MATH_ARCHIVE_WORKFLOW_LINE,
+  MATH_ARCHIVE_WORKFLOW_LINE_EN,
+  MATH_PARAM_DEFAULTS,
+  MATH_PARAM_NAMES,
+  normalizeMathParams,
+  mathAvailabilityLine,
+} from './math-computation.js'
+
 export const inject = ['subagents', 'agents', 'fs', 'tools', 'commands', 'timer']
 
 // ---- host live-child cap (DSH ≥ 0.2) ----------------------------------------
@@ -43,6 +69,15 @@ function hostChildLimitHint(limit){
 }
 
 export function apply(ctx) {
+  // math_computation (v5-style structure, per-session module instances):
+  //   1. a THROWAWAY capture-only host yields the frozen tool face (name/description/schema) once;
+  //   2. the tool is registered ONCE with a router that resolves the CALLING session;
+  //   3. each session lazily gets its OWN `registerMathComputation(...)` instance, cached by that
+  //      session's host object, so there is NO "current session" slot at all and two sessions can run
+  //      math calls CONCURRENTLY without ever seeing each other's params/root/fs/probe cache.
+  // (An earlier revision used a single holder plus a plugin-level serialisation chain; a shared slot
+  // was only safe while calls could not overlap, and serialising cost cross-session parallelism.)
+  let mathToolFace = null
   const subagents = ctx.subagents
   const agents = ctx.agents
   const fs = ctx.fs
@@ -90,8 +125,127 @@ export function apply(ctx) {
       leanCommand: 'lean',
       leanArgs: [],            // inserted BEFORE the file name (e.g. ['env','lean'] with lake)
       leanTimeoutMs: 120000,
+      // ---- incremental + async Lean compilation (lean-incremental-async spec §1.1) ----------
+      // true (default): `lean_run` / `lean_archive{run:true}` ENQUEUE a background job and return
+      // immediately (`async:{jobId,state:'queued'}`); the queue is drained from the existing
+      // heartbeat. false: the historical synchronous `await` path, unchanged. The compile budget
+      // is `leanTimeoutMs`; the executable/args are `leanCommand`/`leanArgs` (no new parameter).
+      leanAsync: true,
+      // AMENDMENT §1: PROACTIVITY is a separate knob from the verification requirement.
+      // `formalVerify` says how strong the check must be at VOTING time; `leanInitiative` says how
+      // eager the group should be while WORKING. 'off' = no proactive nagging (verify-time only),
+      // 'normal' = today's "顺手形式化" line, 'eager' = actively formalize valuable small
+      // lemmas/propositions/definitions as they appear.
+      leanInitiative: 'normal',
+      // AMENDMENT §2: extra search roots, injected in ORDER before the automatic VibeMath root,
+      // de-duplicated; an explicit --search-path/-R/--root in `leanArgs` still wins outright.
+      leanSearchPaths: [],
+      // AMENDMENT §5: how many background compiles may run at once (default 1 = serial).
+      leanJobsMaxParallel: 1,
+      // ---- final paper (docs/final-paper.md §1) ----------------------------------
+      // The run's conclusion is a PAPER the whole team co-authors once consensus has converged.
+      // finalPaper=true triggers it automatically at that moment (idempotent); the other four knobs
+      // decide what is produced, in which language, whether PDFs are attempted, and WHO finalises.
+      finalPaper: true,
+      paperFormat: 'both',     // 'both' | 'md' | 'tex'
+      paperLanguage: 'zh',     // 'zh' | 'en'
+      paperCompilePdf: true,   // compile a PDF when a LaTeX engine is actually detected
+      // v2 §A5: the editor is the SESSION ROOT / human side ("office") by default — v4 has no
+      // `facilitator` roster member with an LLM — or one named resident (`resident:<id>`).
+      paperEditor: 'office',
+      paperLatexCommand: '',   // preferred LaTeX executable ('' = the standard detection order)
+      // ---- math_computation (docs/math-computation.md) ---------------------------
+      // The six MATH_* parameter names are a FROZEN cross-preset contract; the VALUES come from the
+      // shared module so a drift in one preset cannot diverge from the others (the integration
+      // owner's parity guard compares the four presets). `mathEngines`/`mathPackages` are copied,
+      // never aliased: `MATH_PARAM_DEFAULTS` is frozen and shared.
+      mathComputation: MATH_PARAM_DEFAULTS.mathComputation,   // 'auto' | 'on' | 'off' (off = true no-op)
+      mathMode: MATH_PARAM_DEFAULTS.mathMode,                 // 'typed+shell' | 'typed'
+      mathEngines: MATH_PARAM_DEFAULTS.mathEngines.slice(),
+      mathTimeoutMs: MATH_PARAM_DEFAULTS.mathTimeoutMs,
+      mathPackages: MATH_PARAM_DEFAULTS.mathPackages.slice(),
+      mathInstallScope: MATH_PARAM_DEFAULTS.mathInstallScope,
     }
     let params = Object.assign({}, DEFAULT_PARAMS)
+    // ── math_computation availability line (P1) ────────────────────────────────────────────────
+    // The tool itself is registered ONCE at apply level (the host adapter there resolves the calling
+    // session dynamically). The PROMPT line is per-session state, so it is derived here from a
+    // session-local probe host: `probeMathEngines` caches per host object, so the expensive probe
+    // runs once per session and every later prompt re-uses it. `mathComputation:'off'` is a true
+    // no-op (no probe, no line).
+    const mathProbeHost = {
+      register: ()=>{},                       // probeMathEngines never registers; adaptHost requires it
+      params: ()=>params,
+      projectRoot: ()=>frameworkRoot(),
+      writeText: (rel,text)=>writeText(rel,text),
+      readText: (rel)=>readText(rel),
+      exists: async (rel)=>{ try { const t=await fsTarget(rel); return (await fs.stat(t))!==undefined } catch(e){ return false } },
+      // P2a/audit-R2: the module's per-project retention check (MATH_ARCHIVE_MAX_RUNS) only runs
+      // when the host exposes listDir. Root ('', '.') means the project root. The field is attached
+      // ONLY when the fs surface actually has the method, so "no listDir" stays expressible (a
+      // never-absent function would make the module's `typeof H.listDir === 'function'` vacuous).
+      ...(typeof fs.listDir === 'function' ? { listDir: async (rel)=>{ try { const t=await fsTarget(rel===''||rel==='.'?'':rel); return (await fs.listDir(t))||[] } catch(e){ return [] } } } : {}),
+      resolveExecutable: async (cmd)=>{
+        const sub=subprocessOf()
+        if(sub===undefined||typeof sub.resolveExecutable!=='function') throw new Error('NO_SUBPROCESS')
+        return await sub.resolveExecutable(String(cmd))
+      },
+      spawn: async (o)=>{ const r=await mathSpawnAdapter(o); return r },
+      // Same capability flag as the registered host: the prompt-side probe should not advertise
+      // engines on a host that cannot execute at all.
+      hasSubprocess: ()=>!!subprocessOf(),
+      log: (kind,msg)=>logActivity(String(kind||'math'),String(msg||'')),
+      refreshAvailability: ()=>refreshMathAvailability(),
+    }
+    /**
+     * The shared module's spawn contract is flat — `{argv,cwd,timeoutMs,stdoutCap,stderrCap}` →
+     * `{exit,timedOut,killed,ms,stdout,stderr}` — while the host service hands back a live handle.
+     * A TIMEOUT MUST ACTIVELY KILL: the same race-and-terminate discipline `leanRunFile` uses, so the
+     * module is never told "timed out" while the process is still running. Output is collected up to
+     * the caller's cap; `run` passes 4MB on purpose (the module archives the COMPLETE output itself
+     * and only truncates its REPLY to 64KB).
+     */
+    async function mathSpawnAdapter(o){
+      const sub=subprocessOf()
+      // `null` is the module's documented "this host cannot execute" signal (it maps it to
+      // MATH_NO_SUBPROCESS), so it must NOT be papered over with an empty success-looking result.
+      if(sub===undefined||typeof sub.spawn!=='function') return null
+      const spec=o||{}
+      const cap=Math.max(1000,Math.floor(Number(spec.timeoutMs))||MATH_PARAM_DEFAULTS.mathTimeoutMs)
+      const outCap=Math.max(1024,Math.floor(Number(spec.stdoutCap))||64*1024)
+      const errCap=Math.max(1024,Math.floor(Number(spec.stderrCap))||64*1024)
+      const started=now()
+      let handle
+      try { handle=sub.spawn({ argv:Array.isArray(spec.argv)?spec.argv:[], cwd:spec.cwd||frameworkRoot(), stdio:{stdin:'ignore',stdout:{maxBytes:outCap},stderr:{maxBytes:errCap}}, graceMs:cap }) }
+      catch(e){ return {exit:null,timedOut:false,killed:false,ms:now()-started,stdout:'',stderr:String((e&&e.message)||e)} }
+      let killedByUs=false, timerDispose=null, outcome
+      try {
+        outcome=await Promise.race([
+          handle.done,
+          new Promise(function(resolve){
+            if(typeof ctx.timeout!=='function') return   // no timer service: the host grace window is all we have
+            timerDispose=ctx.timeout(function(){
+              killedByUs=true
+              try { if(typeof handle.terminate==='function') handle.terminate() } catch(e){ /* best effort */ }
+              resolve({exitCode:null,signal:'SIGTERM'})
+            }, cap)
+          }),
+        ])
+      } catch(e){
+        if(timerDispose){ try { timerDispose() } catch(_e){} }
+        return {exit:null,timedOut:false,killed:killedByUs,ms:now()-started,stdout:'',stderr:String((e&&e.message)||e)}
+      }
+      if(timerDispose){ try { timerDispose() } catch(e){ /* already fired */ } }
+      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 */ }
+      const ms=now()-started
+      const exit=(outcome&&outcome.exitCode!==undefined)?outcome.exitCode:null
+      // Two ways a timeout is observed (identical to `leanRunFile`): OUR timer won and killed the
+      // handle, or the host's own grace window killed it first and its `done` beat our timer.
+      const timedOut=killedByUs||(exit!==0&&ms>=cap)
+      return {exit, timedOut, killed:killedByUs, ms, stdout:out, stderr:err}
+    }
     let running = false, autoDone = false, phase = 'idle'
     let residents = new Map(), mailboxes = new Map(), taskboard = [], decisions = []
     let meetings = [], reports = [], activityLog = []
@@ -102,6 +256,22 @@ export function apply(ctx) {
     // whether its verdict may take effect.
     let formal = {}, formalTodos = [], formalPersisted = false
     let meetingState = null, verifyState = null, pendingVerify = [], pendingMeeting = null   // pendingVerify: FIFO queue (several residents may independently propose different objects before any verify runs — a single slot silently DROPPED all but the last proposal)
+    // The final-paper flow (docs/final-paper.md, v1 + v2 amendments). In-memory only: the DURABLE
+    // idempotency record is `Paper/<run id>/paper.meta.json` on disk (finalizedAt + per-artifact
+    // existence, v2 §C), so a re-trigger after a restart is still recognised even though this object
+    // did not survive. While a paper is in flight this holds the whole team-authoring state machine.
+    let paperState = null
+    // ---- Lean compile queue (lean-incremental-async spec §2) --------------------------------
+    // Per-SESSION in-memory FIFO (created/destroyed with the session), mirrored to
+    // `<project>/Formal/Jobs/<jobId>.json` for crash recovery and `lean_lib.jobs`. Concurrency is a
+    // CONSTANT (1): compiling competes with the model for CPU and Lean parallelises internally, so
+    // the queue serialises instead of fanning out; the cap is not a parameter (D5: reuse, don't
+    // grow the parameter surface).
+    const LEAN_QUEUE_CONCURRENCY = 1   // the DEFAULT cap; `leanJobsMaxParallel` overrides it (AMENDMENT §5)
+    let leanQueue = []        // job ids waiting (queued, not started)
+    let leanInflight = []     // jobs currently compiling (length ≤ the concurrency cap)
+    let leanJobs = {}         // jobId -> job record (mirrors Formal/Jobs/*.json)
+    let leanNotices = []      // settled-job announcements, injected once into the next prompt
     let busy = new Set(), wakeKind = new Map(), currentResident = ''
     let finalizeLock = null   // 'meeting'|'verify' while a consensus finalize is running (reentry guard)
     const verifiedRecently = new Map()   // targetId -> timestamp when it was closed as Verified (dedup re-propose)
@@ -253,7 +423,7 @@ export function apply(ctx) {
     }
     async function ensureDirs(){
       const base=frameworkRoot()
-      const dirs=['Problems','Progress','Propos','Methods','Subproblems','Shared/meetings','Shared/debates','Verified/命题','Verified/问题','Verified/Lean','Formal','Reliable','Notes','State']
+      const dirs=['Problems','Progress','Propos','Methods','Subproblems','Shared/meetings','Shared/debates','Verified/命题','Verified/问题','Verified/Lean','Formal','Formal/Jobs','Computation','Reliable','Notes','State']
       // The GLOBAL reuse library (Formal/Lib + Formal/Proved) deliberately lives beside the
       // project tree, NOT inside it: cross-project reuse is the whole point (spec §3). It is
       // created here so the first `lean_archive kind='def'` never has to invent its parent.
@@ -394,7 +564,10 @@ export function apply(ctx) {
       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}
       }
-      const argv=[exe].concat((Array.isArray(params.leanArgs)?params.leanArgs:[]).map(String)).concat([abs])
+      // §3.1: the search path is computed HERE (never persisted into `leanArgs`): user args first,
+      // then `--search-path <VibeMath root>` unless the user already stated a search root, then the
+      // file. `lake env lean` therefore becomes `lake env lean --search-path <root> <file>` for free.
+      const argv=leanArgv(exe, abs)
       let handle
       try {
         handle=sub.spawn({ argv, cwd:frameworkRoot(), stdio:{stdin:'ignore',stdout:{maxBytes:64*1024},stderr:{maxBytes:64*1024}}, graceMs:cap })
@@ -465,6 +638,338 @@ export function apply(ctx) {
       }))
     }
 
+    // ================= Lean compile queue + incremental reuse (§2-§4) =================
+    //  · `leanAsync=true` (default): the tools ENQUEUE and return; the queue drains from the existing
+    //    heartbeat (`armHeartbeat`), concurrency 1, budget = `leanTimeoutMs`.
+    //  · `leanAsync=false`: the synchronous `await` path, verbatim.
+    //  · ONLY a settled, green job whose file STILL MATCHES the enqueued content hash may set
+    //    `passed` / write `Verified/Lean/<id>.lean`; every other outcome stays `attempted`.
+    const LEAN_ASYNC_ON = () => params.leanAsync !== false
+    // §3.6: the flag spelling is one constant on purpose — if a toolchain wants `-R <root>`, only
+    // this line changes and the interface stays put.
+    const LEAN_SEARCH_PATH_FLAG = '--search-path'
+    const LEAN_READ_MAX_BYTES = 64 * 1024
+    /** §3.1: never inject when the user already stated a search root (explicit config wins). */
+    function leanHasSearchFlag(args){ return (Array.isArray(args)?args:[]).some(a=>{ const s=String(a); return s===LEAN_SEARCH_PATH_FLAG||s.indexOf(LEAN_SEARCH_PATH_FLAG+'=')===0||s==='-R'||s==='--root' }) }
+    /** AMENDMENT §2: the roots to inject — USER paths first, then the automatic VibeMath root,
+     *  de-duplicated, order preserved. */
+    function leanSearchPathList(){
+      const out=[]
+      for(const p of (Array.isArray(params.leanSearchPaths)?params.leanSearchPaths:[])){ const s=String(p==null?'':p).trim(); if(s&&out.indexOf(s)<0) out.push(s) }
+      const root=vibeRoot().replace(/\\/g,'/')
+      if(out.indexOf(root)<0) out.push(root)
+      return out
+    }
+    /** The injected flag pairs, or [] when the user's own `leanArgs` already state a search root. */
+    function leanSearchPathArgs(){
+      const user=(Array.isArray(params.leanArgs)?params.leanArgs:[]).map(String)
+      if(leanHasSearchFlag(user)) return []
+      const out=[]
+      for(const p of leanSearchPathList()) out.push(LEAN_SEARCH_PATH_FLAG,p)
+      return out
+    }
+    /** `[exe, ...userArgs, ...(search roots unless the user stated one), ...tail]` (§3.1 + AMENDMENT §2). */
+    function leanArgv(exe,tail){
+      const user=(Array.isArray(params.leanArgs)?params.leanArgs:[]).map(String)
+      return [exe].concat(user).concat(leanSearchPathArgs()).concat(tail?[tail]:[])
+    }
+    /**
+     * AMENDMENT §4: the job id pins the WHOLE BUILD CONTEXT — content + engine + normalized argv +
+     * search paths — so a result compiled under a different toolchain/flag set can never be mistaken
+     * for a verification of this one, and only THAT context's `settled(ok)` may set `passed`.
+     */
+    async function leanBuildContext(){
+      const searchPaths=leanSearchPathList()
+      let exe=String(params.leanCommand||'lean')
+      const sub=subprocessOf()
+      try { if(sub&&typeof sub.resolveExecutable==='function') exe=String(await sub.resolveExecutable(exe)) } catch(e){ /* keep the configured name: the run itself will report LEAN_NOT_FOUND */ }
+      const argv=leanArgv(exe,null)
+      return {engine:exe,argv,argvLine:argv.join(' '),searchPaths,searchArgs:leanSearchPathArgs()}
+    }
+    /** §4.3: CRLF/CR → LF, strip trailing whitespace per line and trailing blank lines. */
+    function normalizeLeanContent(s){ return String(s==null?'':s).replace(/\r\n?/g,'\n').replace(/[ \t]+$/gm,'').replace(/\n+$/,'')+'\n' }
+    function sha256Text(s){ return createHash('sha256').update(normalizeLeanContent(s),'utf8').digest('hex') }
+    function leanJobsRel(){ return 'Formal/Jobs' }
+    function leanJobRel(jobId){ return leanJobsRel()+'/'+jobId+'.json' }
+    function leanJobId(key,buildHash){ return idSafe(String(key||'job')).replace(/\.lean$/,'')+'-'+String(buildHash).slice(0,12) }
+    /** AMENDMENT §4: the id hash covers content + engine + normalized argv + search paths. */
+    function leanBuildHashOf(content,ctx){ return sha256Text(JSON.stringify([sha256Text(content),String(ctx.engine||''),ctx.argv||[],ctx.searchPaths||[]])) }
+    async function leanJobIdFor(key,content){ const ctx=await leanBuildContext(); return {jobId:leanJobId(key,leanBuildHashOf(content,ctx)),ctx} }
+    /** Sleep through the host timer service (fiber-owned); the global fallback is what the header
+     *  note documents for file rows. */
+    function leanSleep(ms){ return new Promise(res=>{ if(typeof ctx.timeout==='function'){ ctx.timeout(()=>res(),ms); return } setTimeout(res,ms) }) }
+    function leanJobView(j){ return j?{jobId:j.jobId,state:j.state,rel:j.rel,target:j.target||j.name||'',attempts:j.attempts||1,settledAt:j.settledAt||0,exitCode:(j.exitCode===undefined?null:j.exitCode)}:null }
+    function listLeanJobs(){ return Object.keys(leanJobs).sort().map(k=>leanJobView(leanJobs[k])) }
+    async function writeLeanJob(job){
+      leanJobs[job.jobId]=job
+      try { await writeJson(leanJobRel(job.jobId),job) } catch(e){ logActivity('formal','job 记录写入失败 '+job.jobId+': '+String((e&&e.message)||e)) }
+      return job
+    }
+    async function readLeanJob(jobId){ try { return await readJson(leanJobRel(jobId))||undefined } catch(e){ return undefined } }
+    /** §2.4: ONE line per settled job, injected into the next prompt that is constructed. */
+    function pushLeanNotice(job,run){
+      const sec=run&&run.ms?((run.ms/1000).toFixed(1)+'s'):'—'
+      let line
+      if(job.state==='settled'&&run&&run.ok) line='通过（exit 0，'+sec+(job.kind==='proof'?('，已归档 '+job.verifiedRel):'，已重建索引')+'）'
+      else if(job.state==='timeout') line='超时（leanTimeoutMs='+posMs(params.leanTimeoutMs,120000)+' 已 terminate，对象保持 attempted，可重跑）'
+      else if(job.state==='interrupted') line='中断（会话卸载或崩溃，已标记 attempted，可重跑）'
+      else if(job.state==='failed'&&run&&!run.ok&&!run.hashMatch) line='失败（文件在编译期间被改写，结果不可用——请对新内容重跑）'
+      else line='失败（exit '+String(run&&run.exitCode)+'，见 stderr 尾部：'+tail((run&&run.stderr)||'',160)+'）'
+      leanNotices.push('【形式化结果】'+job.jobId+'：'+line)
+      logActivity('formal','形式化结果 '+job.jobId+' → '+job.state+(job.target?('（对象 '+job.target+'）'):''))
+    }
+    /** Consume-and-clear the pending announcements (injected into the next constructed prompt). */
+    function pendingLeanNoticeText(){ if(!leanNotices.length) return ''; const t=leanNotices.join('\n'); leanNotices=[]; return t }
+    /**
+     * Enqueue one compile. `job` = {kind:'run'|'def'|'lemma'|'proof', key, target, rel, content}.
+     * Deduplicated by CONTENT hash (§4.3): the job id embeds `sha[0:12]`, so re-archiving identical
+     * content cannot produce a second job.
+     */
+    async function enqueueLeanJob(job){
+      const content=String(job.content==null?'':job.content)
+      const sha=job.sha256||sha256Text(content)
+      const ctx=job.ctx||await leanBuildContext()
+      const buildHash=leanBuildHashOf(content,ctx)
+      const jobId=leanJobId(job.key,buildHash)
+      const existing=leanJobs[jobId]
+      if(existing&&(existing.state==='queued'||existing.state==='running')) return {ok:true,duplicate:true,job:existing}
+      const rec={ jobId, kind:job.kind, key:job.key, target:job.target||'', name:job.name||'', rel:job.rel, abs:job.abs||'',
+        sha256:sha, buildHash, build:{engine:ctx.engine,argv:ctx.argv,searchPaths:ctx.searchPaths}, contextChanged:false,
+        content, via:job.via||'', state:'queued', attempts:((existing&&existing.attempts)||0)+1,
+        enqueuedAt:now(), startedAt:0, settledAt:0, exitCode:null, timedOut:false, interrupted:false, run:null, verifiedRel:'' }
+      await writeLeanJob(rec)
+      leanQueue.push(jobId)
+      logActivity('formal','入队后台编译 '+jobId+'（'+(job.kind||'run')+' '+job.rel+'，engine='+ctx.engine+'，search-path='+(ctx.searchPaths.join(',')||'（用户自带）')+'）')
+      armHeartbeat()   // §2.2: the queue is drained from the EXISTING heartbeat
+      return {ok:true,job:rec}
+    }
+    /** §2.1/§2.4: the ONE place an object may become `passed` (and the proof be archived). */
+    async function settleLeanJob(job,run){
+      const nowText=await readTextAbs(job.abs)
+      const hashMatch=nowText!==undefined&&sha256Text(nowText)===job.sha256
+      // AMENDMENT §4: the id already pins the build context; if the user changed the toolchain while
+      // the job was in flight, RECORD that the current context differs (the compile itself was done
+      // with the recorded context, which is what the job id attests to).
+      let contextChanged=false
+      try { const nowCtx=await leanBuildContext()
+        contextChanged=JSON.stringify([nowCtx.engine,nowCtx.argv,nowCtx.searchPaths])!==JSON.stringify([(job.build||{}).engine,(job.build||{}).argv,(job.build||{}).searchPaths])
+        if(contextChanged) logActivity('formal','作业 '+job.jobId+' 的结果属于记录中的构建上下文（engine/argv/search-paths 已被改动，未影响该次编译的结论）')
+      } catch(e){ /* best effort */ }
+      const ok=!!(run&&run.ok)&&hashMatch
+      const timedOut=!!(run&&run.timedOut)
+      const state=ok?'settled':(timedOut?'timeout':'failed')
+      const settled=Object.assign({},job,{
+        state, settledAt:now(), exitCode:(run&&run.exitCode===undefined?null:run.exitCode),
+        timedOut, interrupted:false, hashMatch, contextChanged,
+        run:{at:now(),ok,exitCode:(run&&run.exitCode===undefined?null:run.exitCode),ms:(run&&run.ms)||0,timedOut,interrupted:false,
+             hashMatch,stdoutTail:tail((run&&run.stdout)||'',800),stderrTail:tail((run&&run.stderr)||'',800)},
+      })
+      if(ok&&job.kind==='proof'){
+        // ★ ONLY here: a green run on UNCHANGED content mints the proof and flips the record.
+        settled.verifiedRel='Verified/Lean/'+job.key+'.lean'
+        await writeText(settled.verifiedRel,job.content)
+        const prev=formalOf(job.key)
+        await putFormal(job.key,Object.assign({},prev,{ status:'passed', file:job.rel, proof:settled.verifiedRel, decision:'used',
+          note:prev.note||'', async:{jobId:job.jobId,state,attempts:settled.attempts,enqueuedAt:job.enqueuedAt,startedAt:job.startedAt,settledAt:settled.settledAt,exitCode:settled.exitCode},
+          run:settled.run, updatedAt:now() }))
+      } else {
+        const prev=formalOf(job.key)
+        if(job.kind==='proof'){
+          await putFormal(job.key,Object.assign({},prev,{ status:prev.status==='passed'?'attempted':(prev.status==='blocked'?'blocked':'attempted'),
+            file:job.rel, proof:prev.proof||'', decision:prev.decision||'used', note:prev.note||'',
+            async:{jobId:job.jobId,state,attempts:settled.attempts,enqueuedAt:job.enqueuedAt,startedAt:job.startedAt,settledAt:settled.settledAt,exitCode:settled.exitCode},
+            run:settled.run, updatedAt:now() }))
+        } else if(job.kind==='run'&&job.target){
+          // A plain run only touches the formal records when it was aimed at an OBJECT (exactly what
+          // the synchronous path does: no target, no record). `passed`/`blocked` are preserved.
+          await formalSetRun(job.target,Object.assign({},run,{ok,file:job.rel,timedOut,interrupted:false}))
+          const cur=formalOf(job.target)
+          await putFormal(job.target,Object.assign({},cur,{status:cur.status==='passed'?'passed':(cur.status==='blocked'?'blocked':'attempted'),
+            async:{jobId:job.jobId,state,attempts:settled.attempts,enqueuedAt:job.enqueuedAt,startedAt:job.startedAt,settledAt:settled.settledAt,exitCode:settled.exitCode}}))
+        }
+      }
+      await writeLeanJob(settled)
+      try { await rebuildLeanLibIndexes() } catch(e){ /* best-effort */ }
+      pushLeanNotice(settled,Object.assign({},run,{ok,hashMatch}))
+      return settled
+    }
+    /** §2.2 + AMENDMENT §5: the drain. One pass starts up to `leanJobsMaxParallel` workers and
+     *  returns IMMEDIATELY (a long compile must not block the heartbeat); each worker chains the
+     *  next pass when it settles. A no-op pass costs one comparison + one array check. */
+    async function runLeanQueue(){
+      const cap=Math.max(1,Math.floor(Number(params.leanJobsMaxParallel))||LEAN_QUEUE_CONCURRENCY)
+      let started=false
+      while(leanInflight.length<cap&&leanQueue.length){
+        const jobId=leanQueue.shift()
+        const job=leanJobs[jobId]
+        if(!job) continue
+        const running=Object.assign({},job,{state:'running',startedAt:now()})
+        leanInflight.push(running); await writeLeanJob(running)
+        started=true
+        ;(async()=>{
+          let run
+          // Compile the ABSOLUTE path recorded at enqueue time: a `def`/`lemma` lives under the
+          // global `VibeMath/Formal/{Lib,Proved}` (beside the project tree), so the project-relative
+          // form would resolve to a non-existent file and report V4_NOT_FOUND.
+          try { run=await leanRunFile(String(running.abs||running.rel)) }
+          catch(e){ run={ok:false,code:'LEAN_RUN_FAILED',message:String((e&&e.message)||e),file:running.rel} }
+          leanInflight=leanInflight.filter(j=>j.jobId!==jobId)
+          if(leanJobs[jobId]&&leanJobs[jobId].state==='interrupted') return   // dispose() already settled it
+          await settleLeanJob(leanJobs[jobId]||running,run)
+          runLeanQueue().catch(()=>{})   // keep the pipeline moving at the cap
+        })()
+      }
+      return started
+    }
+    /** §2.5: dispose/abort terminates every in-flight compile and marks it interrupted — never `passed`. */
+    async function disposeLean(){
+      leanQueue=[]
+      const jobs=leanInflight.slice()
+      leanInflight=[]
+      if(!jobs.length) return false
+      for(const job of jobs){
+        try { if(job.handle&&typeof job.handle.terminate==='function') job.handle.terminate() } catch(e){ /* best effort */ }
+        const cur=leanJobs[job.jobId]||job
+        const rec=Object.assign({},cur,{state:'interrupted',interrupted:true,settledAt:now(),
+          run:Object.assign({},cur.run||{},{ok:false,interrupted:true,hashMatch:false})})
+        await writeLeanJob(rec)
+        if(rec.kind==='proof'&&rec.key){ const prev=formalOf(rec.key)
+          await putFormal(rec.key,Object.assign({},prev,{status:prev.status==='passed'?'attempted':(prev.status||'attempted'),
+            async:{jobId:rec.jobId,state:'interrupted',attempts:rec.attempts,enqueuedAt:rec.enqueuedAt,startedAt:rec.startedAt,settledAt:rec.settledAt,exitCode:null}})) }
+        pushLeanNotice(rec,{ok:false,exitCode:null,ms:0})
+      }
+      return true
+    }
+    /**
+     * §2.6 crash/restart recovery: scan `<project>/Formal/Jobs/*.json` AFTER the project dirs exist.
+     * It NEVER mints a `passed` anything unless the job record itself says exitCode===0 AND the file
+     * on disk still hashes to the enqueued content.
+     */
+    async function recoverLeanJobs(opts){
+      const o=opts||{}
+      const applySettled=o.applySettled!==false
+      let files=[]
+      try {
+        const t=await fs.resolve(leanJobsRel(),{cwd:frameworkRoot()})
+        if(await fs.stat(t)===undefined) return {scanned:0}
+        files=await fs.listDir(t)
+      } catch(e){ return {scanned:0} }
+      let queued=0,redriven=0,stale=0,completed=0
+      for(const f of files||[]){
+        if(!f||f.type!=='file'||!/\.json$/.test(String(f.name))) continue
+        const job=await readJson(leanJobsRel()+'/'+f.name)
+        if(!job||!job.jobId||!job.rel) continue
+        leanJobs[job.jobId]=job
+        const sha=String(job.sha256||'')
+        const text=await readTextAbs(job.abs||vibeRelAbs(job.rel))
+        const hashMatch=text!==undefined&&sha256Text(text)===sha
+        if(job.state==='queued'){ if(leanQueue.indexOf(job.jobId)<0) leanQueue.push(job.jobId); queued++; continue }
+        if(job.state==='running'){
+          if(hashMatch){
+            await writeLeanJob(Object.assign({},job,{state:'queued',interrupted:true,attempts:(job.attempts||1)+1,run:Object.assign({},job.run||{},{ok:false,interrupted:true,hashMatch:true})}))
+            if(leanQueue.indexOf(job.jobId)<0) leanQueue.push(job.jobId)
+            if(job.kind==='proof'&&job.key){ const prev=formalOf(job.key)
+              await putFormal(job.key,Object.assign({},prev,{status:prev.status==='passed'?'attempted':(prev.status||'attempted'),
+                async:{jobId:job.jobId,state:'queued',attempts:(job.attempts||1)+1,enqueuedAt:job.enqueuedAt,startedAt:job.startedAt,settledAt:0,exitCode:null}})) }
+            leanNotices.push('【形式化结果】'+job.jobId+'：崩溃/重启中断，已按新尝试次数重新入队（旧进程结果不可知，对象保持 attempted）')
+            redriven++
+          } else {
+            await writeLeanJob(Object.assign({},job,{state:'interrupted',interrupted:true,settledAt:now(),run:Object.assign({},job.run||{},{ok:false,interrupted:true,hashMatch:false})}))
+            if(job.kind==='proof'&&job.key){ const prev=formalOf(job.key)
+              await putFormal(job.key,Object.assign({},prev,{status:'attempted',
+                async:{jobId:job.jobId,state:'interrupted',attempts:job.attempts||1,enqueuedAt:job.enqueuedAt,startedAt:job.startedAt,settledAt:now(),exitCode:null}})) }
+            leanNotices.push('【形式化结果】'+job.jobId+'：文件已变，请手动重跑（不自动重驱，避免把旧代码的结果贴到新代码上）')
+            stale++
+          }
+          continue
+        }
+        if(job.state==='settled'&&job.kind==='proof'&&job.key&&applySettled){
+          const rec=formalOf(job.key)
+          const applied=rec.async&&rec.async.jobId===job.jobId&&rec.async.state==='settled'
+          if(!applied&&job.exitCode===0&&hashMatch&&job.verifiedRel){
+            await writeText(job.verifiedRel,job.content)
+            await putFormal(job.key,Object.assign({},rec,{status:'passed',file:job.rel,proof:job.verifiedRel,decision:rec.decision||'used',
+              async:{jobId:job.jobId,state:'settled',attempts:job.attempts||1,enqueuedAt:job.enqueuedAt,startedAt:job.startedAt,settledAt:job.settledAt,exitCode:0},
+              run:job.run||rec.run,updatedAt:now()}))
+            leanNotices.push('【形式化结果】'+job.jobId+'：按作业记录补齐（通过，已归档 '+job.verifiedRel+'）')
+            completed++
+          }
+        }
+      }
+      if(queued+redriven+stale+completed){ await writeLeanLibIndexesSafe() ; if(leanQueue.length) armHeartbeat() }
+      return {scanned:(files||[]).length,queued,redriven,stale,completed}
+    }
+    async function writeLeanLibIndexesSafe(){ try { await rebuildLeanLibIndexes() } catch(e){ /* best-effort */ } }
+    /**
+     * §1.2 `lean_read`: read ONE archived library file VERBATIM (for import-or-copy reuse).
+     * Read-only; the path is confined to `<VibeMath>/Formal/{Lib,Proved}` — the sanitised `name`
+     * cannot contain a separator, and the resolved path is re-checked against the root so a crafted
+     * name can never escape (a `.lean` suffix is added, never accepted as a path).
+     */
+    async function leanRead(o){
+      const args=o||{}
+      const raw=String(args.name==null?'':args.name).trim()
+      const kind=String(args.kind||'auto')
+      if(!raw) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'name is required'}
+      if(raw.indexOf('/')>=0||raw.indexOf('\\')>=0||raw.indexOf('..')>=0) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'name must be a bare library name (no path separators)'}
+      if(['auto','lib','proved'].indexOf(kind)<0) return {ok:false,code:'V4_INVALID_ARGUMENT',message:"kind must be 'auto' | 'lib' | 'proved'"}
+      const name=idSafe(raw).replace(/\.lean$/,'')
+      if(!name||name==='id') return {ok:false,code:'V4_INVALID_ARGUMENT',message:'invalid name'}
+      const cands=[]
+      if(kind==='auto'||kind==='lib') cands.push({kind:'lib',rel:'Formal/Lib/'+name+'.lean',abs:formalLibRoot()+'/'+name+'.lean'})
+      if(kind==='auto'||kind==='proved') cands.push({kind:'proved',rel:'Formal/Proved/'+name+'.lean',abs:formalProvedRoot()+'/'+name+'.lean'})
+      const checked=[]
+      for(const c of cands){
+        const norm=normalizeAbsPath(c.abs)
+        const root=normalizeAbsPath(vibeRoot())
+        if(norm.indexOf(root+'/Formal/')!==0) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'refused: resolves outside the VibeMath/Formal library'}
+        checked.push(c)
+      }
+      const found=await (async()=>{
+        for(const c of checked){ const t=(await readTextAbs(c.abs)); if(t!==undefined) return {c,t} }
+        return null
+      })()
+      if(!found) return {ok:false,code:'V4_NOT_FOUND',message:'no archived library file named '+name+(kind==='auto'?' (checked Formal/Lib and Formal/Proved)':' in Formal/'+(kind==='lib'?'Lib':'Proved')),name,kind}
+      const full=String(found.t)
+      const bytes=(typeof TextEncoder==='function')?new TextEncoder().encode(full).length:full.length
+      const truncated=bytes>LEAN_READ_MAX_BYTES
+      const text=truncated?full.slice(0,LEAN_READ_MAX_BYTES):full
+      return {ok:true,name,file:found.c.rel,kind:found.c.kind,sha256:sha256Text(full),bytes,text,truncated,
+        hint:'复用：新文件里写 '+(found.c.kind==='lib'?'import Formal.Lib.':'import Formal.Proved.')+name+'（模块根=VibeMath 根，框架已把它加入编译搜索路径），或按上面的原文逐字复制。'}
+    }
+
+    /**
+     * AMENDMENT §3: the read-only result/wait surface. Without `jobId` it lists THIS session's jobs;
+     * with it, returns the job's state / exitCode / receipt path (`Formal/Jobs/<id>.json`) / archive
+     * path. `waitMs>0` waits up to that many ms and then reports the CURRENT state (never blocks
+     * forever, never throws).
+     */
+    const LEAN_JOB_TERMINAL=['settled','failed','timeout','interrupted']
+    async function leanJobTool(o){
+      const args=o||{}
+      const jobId=String(args.jobId||'').trim()
+      const waitMs=Math.max(0,Math.min(600000,Math.floor(Number(args.waitMs))||0))
+      if(!jobId){
+        const ids=Object.keys(leanJobs).sort()
+        return {ok:true,count:ids.length,
+          jobs:ids.map(k=>Object.assign(leanJobView(leanJobs[k]),{receipt:leanJobRel(k),archive:leanJobs[k].verifiedRel||'',timedOut:!!leanJobs[k].timedOut,interrupted:!!leanJobs[k].interrupted})),
+          queued:leanQueue.slice(),running:leanInflight.map(j=>j.jobId),
+          hint:'有 jobId 时用 vibe_v4_lean_job {jobId, waitMs} 取结果/等待（waitMs 超时只返回当前 state）。'}
+      }
+      let job=leanJobs[jobId]||await readLeanJob(jobId)
+      if(job&&waitMs>0){
+        const t0=now()
+        while(LEAN_JOB_TERMINAL.indexOf(job.state)<0&&now()-t0<waitMs){ await leanSleep(25); job=leanJobs[jobId]||job }
+      }
+      if(!job) return {ok:false,code:'V4_NOT_FOUND',message:'no such job: '+jobId}
+      return {ok:true,jobId,job:leanJobView(job),state:job.state,exitCode:(job.exitCode===undefined?null:job.exitCode),
+        rel:job.rel,receipt:leanJobRel(jobId),archive:job.verifiedRel||'',target:job.target||'',key:job.key||'',
+        timedOut:!!job.timedOut,interrupted:!!job.interrupted,attempts:job.attempts||1,settledAt:job.settledAt||0,
+        build:job.build||null,buildHash:job.buildHash||'',sha256:job.sha256||'',
+        run:job.run||null,
+        hint:LEAN_JOB_TERMINAL.indexOf(job.state)>=0?'（已终态）':'（仍在队列/编译中；可用 waitMs 再等，或等下一轮【形式化结果】公告）'}
+    }
+
     function formalModeWord(){ return formalMode()==='require'?'强制':'鼓励' }
     /**
      * The verification-prompt block. Every branch is computed from the CURRENT mode and the
@@ -500,8 +1005,11 @@ export function apply(ctx) {
         L.push('  ▸ 因此请把 verdict 用在"这个阻塞判断是否成立 / 是否仍有别的形式化路线"上，并给出理由。')
       } else {
         L.push('  · 请先判断该对象的**实现难度**：若能在可接受的工作量内形式化，优先写 Lean 代码并执行。')
-        L.push('  · 工具：vibe_v4_lean_run（执行）· vibe_v4_lean_archive（归档）· vibe_v4_lean_lib（查已有可复用库）')
-        L.push('  · 工作目录：Formal/（相对项目根）；可复用定义放 '+formalLibRoot().replace(/\\/g,'/')+'/，已证引理放 '+formalProvedRoot().replace(/\\/g,'/')+'/；写之前先 vibe_v4_lean_lib 查重。')
+        // lean-incremental-async spec §5 B (verbatim, after the implementation-difficulty line).
+        L.push('  · 形式化只写你有把握的版本；没把握就记 blocked 并写清难点——不要用形式化掩盖不确定。')
+        L.push('  · 该对象若已有后台编译在队列中，**不得**在它落地前声称已通过或走忠实性审查；等 vibe_v4_lean_lib 显示 passed 再审。')
+        L.push('  · 工具：vibe_v4_lean_run（执行/入队）· vibe_v4_lean_archive（归档）· vibe_v4_lean_lib（查已有可复用库与 jobs）· vibe_v4_lean_read（读归档原文逐字复用）')
+        L.push('  · 工作目录：Formal/（相对项目根）；可复用定义放 '+formalLibRoot().replace(/\\/g,'/')+'/，已证引理放 '+formalProvedRoot().replace(/\\/g,'/')+'/；写之前先 vibe_v4_lean_lib 查重。复用已归档内容：`import Formal.Lib.<name>` / `import Formal.Proved.<name>`（模块根 = VibeMath 根，框架已加入编译搜索路径）。项目工作文件 Formal/<对象 id>.lean 只是归档用，**不是**模块路径，不要 import 它。')
         L.push('  · **一旦 Lean 通过，你唯一需要确认的就是忠实性**：定义/对象/条件/假设/结论是否与命题原文逐条一致。请把注意力放在这种核对上，而不是重新做一遍推导。')
         if(formalMode()==='require'){
           L.push("  · **本模式要求**：必须产出 Lean 形式化，或**必须**给出显式的阻塞原因（vibe_v4_lean_archive kind='blocked' note=… 或回执 formal.note）。若两者都没有，本次裁定不会生效，会被记为未定论（原因 formal-required）并进入「形式化待办」。")
@@ -520,17 +1028,85 @@ export function apply(ctx) {
       }
       return L.join('\n')
     }
-    /** The ordinary-work-round line (spec §6.2): formalize reusable objects as you go. */
+    /** `leanInitiative` (v5-aligned): how EAGER the group is about formalizing while working. It is a
+     *  SEPARATE axis from `formalVerify` — see `leanDailyOn` below. */
+    const leanInitiative=()=>(['off','normal','eager'].indexOf(String(params.leanInitiative))!==-1?String(params.leanInitiative):'normal')
+    /** The DAILY line is injected when the group should formalize while working: any non-'off'
+     *  initiative with `formalVerify` on, OR explicitly `eager` — which asks for it even when
+     *  `formalVerify:'off'`, because the two knobs are independent (v5 uses the exact same rule).
+     *  'off' never injects the daily line; the VERIFICATION prompt still follows `formalVerify`. */
+    const leanDailyOn=()=>leanInitiative()!=='off'&&(formalOn()||leanInitiative()==='eager')
+    /** The ordinary-work-round line (spec §6.2): formalize reusable objects as you go. Carries the
+     *  three selection criteria, the blocked-instead-of-guessing rule, the look-up-first reuse path
+     *  and the background-compile rule (lean-incremental-async spec §5 A, verbatim). */
     function formalWorkLine(){
-      if(!formalOn()) return ''
-      return '【顺手形式化（'+formalModeWord()+'）】把你工作中常用或可能复用的对象、假设、新定义，'
+      if(!leanDailyOn()) return ''
+      // v5-aligned header: with `formalVerify:'off'` the mode word would be misleading, so the eager
+      // 档 names itself instead.
+      return '【顺手形式化（'+(formalOn()?formalModeWord():'主动（leanInitiative=eager）')+'）】把你工作中常用或可能复用的对象、假设、新定义，'
         +"用 Lean 形式化定义并归档到全局可复用库（vibe_v4_lean_archive kind='def'），已成立的引理归到 Formal/Proved/"
         +"（kind='lemma'）；写之前先 vibe_v4_lean_lib 查重，避免重复定义。"
+        +'\n  · 判断标准：① 有价值或可能复用；② 较为关键或必要；③ 你对该陈述有把握（置信度高）。**没把握的先别入库**——'
+        +'\n    进了 Formal/Proved 的东西会被当成已核对引理；没把握就记 blocked 并写清难点，别用形式化掩盖不确定。'
+        +'\n  · 复用优先：写新定义/证明前**先 vibe_v4_lean_lib 查已有库**；复用已归档内容用'
+        +'\n    `import Formal.Lib.<name>` / `import Formal.Proved.<name>`（模块根 = VibeMath 根，框架已把它加进编译搜索路径），'
+        +'\n    或 `vibe_v4_lean_read {name}` 取原文逐字复制。**查不到再新写**；同内容重复归档会自动去重。'
+        +'\n  · 编译默认走后台队列（leanAsync=true）：入队后你可以继续工作；用 vibe_v4_lean_lib 的 jobs 字段或下一轮提示里的'
+        +'\n    【形式化结果】行看结果。**在作业落地为"通过"之前，不得把该对象当成已通过。**'
         +(formalMode()==='require'
           ? '本模式下，任何要定论为真/假的对象都必须先有 Lean 通过或显式阻塞记录。'
           : '这会让后续的验证与证明省掉大量重复工作。')
+        // AMENDMENT §1: only `leanInitiative='eager'` asks for MORE proactivity than the normal line.
+        // `formalVerify` is deliberately NOT consulted here: it expresses the verification-time
+        // requirement, not how eagerly the group should formalize while working.
+        +(leanInitiative()==='eager'
+          ? '\n  · 本档（leanInitiative=eager）：工作中出现**有价值且你有把握**的小引理 / 小命题 / 小定义时，**主动**顺手形式化并归档，不必等到验证轮；把握不足就照上面的判据记 blocked。'
+          : '')
         +'归档前先跑通（vibe_v4_lean_run 或 run=true）；跑不通的定义不要进可复用库。'
     }
+    // ================= math_computation availability line (P1) =================
+    // The line is DYNAMIC (it comes from the module's probe cache) while the resident prompts are
+    // built by BOTH sync and async builders, so the two language variants are cached here and
+    // refreshed from the async paths (start / resume / set / heartbeat) — a sync builder re-uses the
+    // last known line and kicks off a refresh when the cache is still cold. `mathComputation:'off'`
+    // is a true no-op: no probe, no line, nothing injected.
+    let mathAvailZh='', mathAvailEn='', mathAvailBusy=false
+    async function refreshMathAvailability(){
+      if(params.mathComputation==='off'){ mathAvailZh=''; mathAvailEn=''; return }
+      if(mathAvailBusy) return
+      mathAvailBusy=true
+      try {
+        // Use THIS session's cached module instance (keyed by `mathProbeHost`): the probe cache lives
+        // in the instance, so repeated refreshes cost nothing, and two sessions never share it.
+        const inst=mathInstanceFor(mathProbeHost)
+        const probe=inst?await inst.probe():await probeMathEngines(mathProbeHost)
+        // The third argument is the MODE: the module drops the shell-fallback sentence in 'typed'
+        // (prompts.md §4 consistency check 5) — the preset must not re-add it.
+        mathAvailZh=mathAvailabilityLine(probe,'zh',params.mathMode)
+        mathAvailEn=mathAvailabilityLine(probe,'en',params.mathMode)
+        // The availability line is REQUIRED to carry the rule lines (prompts.md §2/§4). Referencing
+        // both rule constants here is the drift check: if the module ever stops appending them, this
+        // preset notices instead of shipping an availability line without the rules.
+        if(mathAvailZh.indexOf(MATH_RULE_LINES[0])===-1||mathAvailEn.indexOf(MATH_RULE_LINES_EN[0])===-1){
+          logActivity('math','警告：mathAvailabilityLine 未附带规则段（MATH_RULE_LINES/_EN），提示词可能缺少用法规则')
+        }
+        // P2a: the archive→edit→re-run workflow rule is part of the same contract (an old receipt is
+        // NOT evidence for edited code). It is appended to the availability line by the module and to
+        // both persona blocks by this preset — this is the drift check for the former.
+        if(mathAvailZh.indexOf(MATH_ARCHIVE_WORKFLOW_LINE.trim())===-1||mathAvailEn.indexOf(MATH_ARCHIVE_WORKFLOW_LINE_EN.trim())===-1){
+          logActivity('math','警告：mathAvailabilityLine 未附带归档工作流规则（MATH_ARCHIVE_WORKFLOW_LINE/_EN）')
+        }
+      } catch(e){ /* a probe failure must never break a prompt; keep the last known line */ }
+      finally { mathAvailBusy=false }
+    }
+    /** The availability + rules block: the frozen persona tool line (tools/params shape) followed by
+     *  the dynamic zh + en availability lines. v4's prompts are bilingual (English frame, Chinese
+     *  rules), so both variants are injected; `mathComputation:'off'` yields '' (a true no-op). */
+    function mathAvailabilityBlock(){
+      if(params.mathComputation==='off') return ''
+      if(!mathAvailZh&&!mathAvailEn){ refreshMathAvailability().catch(()=>{}); return '' }
+      return [MATH_PERSONA_TOOL_LINE, mathAvailZh, mathAvailEn].filter(Boolean).join('\n')
+    }
     /** The `formal` object every non-off prompt documents in its JSON reply contract. */
     function formalReplyField(target){
       return '{"formal":{"target":"'+String(target||'p-x')+'","decision":"used|blocked|defect","file":"Formal/'+String(target||'p-x')+'.lean","note":"难度判断/阻塞原因/具体偏差"}}'
@@ -585,21 +1161,24 @@ export function apply(ctx) {
             const txt=(await readTextAbs(dirAbs+'/'+e.name))||''
             const name=String(e.name).replace(/\.lean$/,'')
             const first=(txt.split('\n').filter(l=>l.trim()&&!/^\s*(\/\/|--|import)/.test(l))[0]||'').trim().slice(0,110)
-            rows.push('| '+name+' | '+rel+' | '+kindLabel+' | '+first.replace(/\|/g,'/')+' |')
+            // §4.4: the dependency column v3 already has — one entry per `import` line, so a reader
+            // can see what a reusable file pulls in (and therefore what must travel with it).
+            const deps=(txt.match(/^\s*import\s+[^\s]+/gm)||[]).map(l=>l.replace(/^\s*import\s+/,'').trim()).filter(Boolean)
+            rows.push('| '+name+' | '+rel+' | '+kindLabel+' | '+(deps.length?deps.join(', ').replace(/\|/g,'/'):'—')+' | '+first.replace(/\|/g,'/')+' |')
           }
         } catch(e){ /* listing is best-effort */ }
         return rows
       }
       const libRows=await scan(formalLibRoot(),'Formal/Lib','def')
       await writeTextAbs(formalLibRoot()+'/Index.md',['# 可复用 Lean 定义库（跨项目）｜'+currentProject,'',
-        '> 写新定义之前先查这里：能复用就不要重新定义。','',
-        '| 名称 | 文件 | 类别 | 摘要 |','|---|---|---|---|']
-        .concat(libRows.length?libRows:['| （暂无） | | | |']).join('\n')+'\n')
+        '> 写新定义之前先查这里：能复用就不要重新定义。复用方式：`import Formal.Lib.<名称>`（模块根 = VibeMath 根，框架已加入编译搜索路径），或用 vibe_v4_lean_read 取原文逐字复制。','',
+        '| 名称 | 文件 | 类别 | 依赖 | 摘要 |','|---|---|---|---|---|']
+        .concat(libRows.length?libRows:['| （暂无） | | | | |']).join('\n')+'\n')
       const provedRows=await scan(formalProvedRoot(),'Formal/Proved','lemma')
       await writeTextAbs(formalProvedRoot()+'/Index.md',['# 已成立的 Lean 命题 / 引理（机器已核对，可跨项目复用）｜'+currentProject,'',
-        '> 这些文件是通过内核检查的引理，可直接 import 复用。','',
-        '| 名称 | 文件 | 类别 | 陈述 |','|---|---|---|---|']
-        .concat(provedRows.length?provedRows:['| （暂无） | | | |']).join('\n')+'\n')
+        '> 这些文件是通过内核检查的引理，可直接 `import Formal.Proved.<名称>` 复用（模块根 = VibeMath 根）。','',
+        '| 名称 | 文件 | 类别 | 依赖 | 陈述 |','|---|---|---|---|---|']
+        .concat(provedRows.length?provedRows:['| （暂无） | | | | |']).join('\n')+'\n')
       await writeFormalIndex()
       await writeFormalTodo()
       return {lib:libRows.length,proved:provedRows.length,objects:Object.keys(formalRecords()).length}
@@ -613,7 +1192,24 @@ export function apply(ctx) {
      */
     async function leanRunTool(memberId,o){
       const args=o||{}
-      const run=await leanRunFile(String(args.file||''),args.timeout_ms)
+      const rel=String(args.file||'')
+      // §2.3 (leanAsync=true, the default): ENQUEUE and return immediately — the member keeps
+      // working; the result lands in Formal/ + the indexes and is announced in the next prompt.
+      if(LEAN_ASYNC_ON()){
+        const abs=leanAbsPath(rel)
+        if(abs===null||!/\.lean$/.test(abs)) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'Lean file must live under '+vibeRoot().replace(/\\/g,'/')+'/ and end in .lean (got '+rel+')',file:rel}
+        const content=await readTextAbs(abs)
+        if(content===undefined) return {ok:false,code:'V4_NOT_FOUND',message:'no such file: '+rel,file:rel}
+        const target=String(args.target||'').trim()
+        const key=formalKey(target||rel.replace(/\.lean$/,''))
+        const q=await enqueueLeanJob({kind:'run',key,target,rel,abs,content,via:memberId||'host'})
+        if(q.duplicate) return {ok:true,async:leanJobView(q.job),jobId:q.job.jobId,file:rel,mode:formalMode(),
+          message:'同一内容已在队列/已归档（'+q.job.state+'），未重复入队；用 vibe_v4_lean_lib 的 jobs 查看，或用 lean_read 取原文。'}
+        logActivity('formal',(memberId||'host')+' vibe_v4_lean_run '+rel+' → 已入队 '+q.job.jobId)
+        return {ok:true,async:{jobId:q.job.jobId,state:'queued'},jobId:q.job.jobId,file:rel,mode:formalMode(),
+          message:'已入队后台编译；你可以继续工作。结果会写入 Formal/ 与索引，并在下一轮提示里公告；也可用 vibe_v4_lean_lib 的 jobs 字段随时查看。'}
+      }
+      const run=await leanRunFile(rel,args.timeout_ms)
       try {
         if(run.ok||run.file){
           if(String(args.target||'').trim()) formalSetRun(String(args.target),run)
@@ -625,6 +1221,9 @@ export function apply(ctx) {
       // bare `lean_run` abbreviation (docs §6 hard requirement 1).
       logActivity('formal',(memberId||'host')+' vibe_v4_lean_run '+(run.file||String(args.file||''))+' → '+(run.ok?'通过':(run.code||'未通过')))
       return Object.assign({ok:!!run.ok},run,{
+        // `leanAsync=false`: the historical shape, plus an explicit `async:null` so a caller can
+        // tell "synchronous result" from "queued job" without guessing.
+        async:null, jobId:null,
         mode:formalMode(),
         hint: run.ok
           ? "通过。若是某个对象的证明，请用 vibe_v4_lean_archive kind='proof' 归档（会写入 Verified/Lean/ 并把审查对象变成忠实性）；若是可复用定义/引理，用 kind='def'/'lemma' 归档到全局库——归档前先跑通（run=true 或先 vibe_v4_lean_run）：跑不通的定义不要进可复用库。"
@@ -659,20 +1258,57 @@ export function apply(ctx) {
         if(!name||name==='id') return {ok:false,code:'V4_INVALID_ARGUMENT',message:'name is required for a reusable definition/lemma'}
         const got=await bodyFrom(); if(got.error) return got.error
         const rel='Formal/'+(kind==='def'?'Lib':'Proved')+'/'+name+'.lean'
-        if(!await writeTextAbs(vibeRelAbs(rel),got.body)) return {ok:false,code:'V4_WRITE_FAILED',message:'could not write '+rel}
+        const abs=vibeRelAbs(rel)
+        const sha=sha256Text(got.body)
+        // AMENDMENT §4: de-duplication keys on the WHOLE build context (content + engine + argv +
+        // search paths), so identical content compiled by a different toolchain is a NEW job.
+        const jidFor=await leanJobIdFor(name,got.body)
+        const jobId=jidFor.jobId
+        // §4.3: the SAME content that already compiled green is a no-op — no rewrite, no recompile.
+        const prior=leanJobs[jobId]
+        if(prior&&prior.state==='settled'&&prior.run&&prior.run.ok&&sha256Text((await readTextAbs(abs))||'')===sha){
+          logActivity('formal',String(memberId||'host')+' 归档'+kind+' '+name+' → 去重（内容与已归档版本一致）')
+          return {ok:true,kind,name,file:rel,deduped:true,sha256:sha,jobId,async:leanJobView(prior),run:prior.run,
+            note:'内容与已归档版本一致，跳过重写与重编译'}
+        }
+        if(!await writeTextAbs(abs,got.body)) return {ok:false,code:'V4_WRITE_FAILED',message:'could not write '+rel}
+        if(LEAN_ASYNC_ON()){
+          const q=await enqueueLeanJob({kind,key:name,name,rel,abs,content:got.body,sha256:sha,ctx:jidFor.ctx,via:memberId||'host'})
+          logActivity('formal',String(memberId||'host')+' 归档'+(kind==='def'?'可复用定义':'已证引理')+' '+name+' → '+rel+'（已入队 '+(q.job&&q.job.jobId||jobId)+'）')
+          return {ok:true,kind,name,file:rel,sha256:sha,jobId:(q.job&&q.job.jobId)||jobId,
+            async:{jobId:(q.job&&q.job.jobId)||jobId,state:q.duplicate?'queued':'queued'},run:undefined,
+            note:'已并入全局可复用库并**入队后台编译**：通过前不要在别处把它当作已核对引理；结果见 vibe_v4_lean_lib.jobs 与下一轮【形式化结果】行'}
+        }
         // The global library sits BESIDE the project tree, so it must be executed through its
         // ABSOLUTE path — the project-relative form would resolve inside frameworkRoot.
-        const run=args.run===false?null:await leanRunFile(vibeRelAbs(rel))
+        const run=args.run===false?null:await leanRunFile(abs)
         try { await rebuildLeanLibIndexes() } catch(e){ /* index rebuild is best-effort */ }
         logActivity('formal',String(memberId||'host')+' 归档'+(kind==='def'?'可复用定义':'已证引理')+' '+name+' → '+rel+(run?('（运行 '+(run.ok?'通过':'未通过')+'）'):''))
-        return {ok:true,kind,name,file:rel,run:run||undefined,note:'已并入全局可复用库，后续项目可直接 import 复用'}
+        return {ok:true,kind,name,file:rel,deduped:false,sha256:sha,async:null,run:run||undefined,note:'已并入全局可复用库，后续项目可直接 import 复用'}
       }
       if(kind==='proof'){
         const key=formalKey(String(args.target||''))
         if(!key) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'target is required for kind=proof'}
         const got=await bodyFrom(); if(got.error) return got.error
         const workRel='Formal/'+key+'.lean'
+        const sha=sha256Text(got.body)
+        const jidFor=await leanJobIdFor(key,got.body)
+        // §4.3 (proof variant): identical content + the object is ALREADY `passed` and the archived
+        // proof still hashes the same ⇒ nothing to do.
+        const prevRec=formalOf(key)
+        if(prevRec.status==='passed'&&sha256Text((await readText('Verified/Lean/'+key+'.lean'))||'')===sha){
+          logActivity('formal',String(memberId||'host')+' 归档证明 '+key+' → 去重（对象已 passed 且归档内容一致）')
+          return {ok:true,kind,target:key,file:workRel,proof:prevRec.proof,passed:true,deduped:true,sha256:sha,async:leanJobView(leanJobs[jidFor.jobId])||null,status:prevRec.status}
+        }
         if(!await writeText(workRel,got.body)) return {ok:false,code:'V4_WRITE_FAILED',message:'could not write '+workRel}
+        if(LEAN_ASYNC_ON()){
+          const q=await enqueueLeanJob({kind:'proof',key,target:key,rel:workRel,abs:leanAbsPath(workRel),content:got.body,sha256:sha,ctx:jidFor.ctx,via:memberId||'host'})
+          const jid=(q.job&&q.job.jobId)||jidFor.jobId
+          logActivity('formal',String(memberId||'host')+' 为 '+key+' 归档形式化证明 '+workRel+'（已入队 '+jid+'；通过前不改 passed）')
+          return {ok:true,kind,target:key,file:workRel,sha256:sha,jobId:jid,
+            async:{jobId:jid,state:'queued'},run:undefined,
+            note:'证明已入队后台编译：**只有作业落地为通过**才会写入 Verified/Lean/'+key+'.lean 并把对象置 passed；其余情况保持 attempted，见 vibe_v4_lean_lib.jobs'}
+        }
         const run=await leanRunFile(workRel)
         const prev=formalOf(key)
         const passed=!!run.ok
@@ -692,7 +1328,7 @@ export function apply(ctx) {
         await putFormal(key,rec)
         try { await rebuildLeanLibIndexes() } catch(e){ /* best-effort */ }
         logActivity('formal',String(memberId||'host')+' 为 '+key+' 归档形式化证明 '+workRel+(passed?'（**通过**，已归档到 '+rec.proof+'，验证转为忠实性审查）':'（**未通过**：'+tail(run.stderr||run.message,160)+'）'))
-        return {ok:true,kind,target:key,file:workRel,proof:rec.proof,passed,run,status:rec.status}
+        return {ok:true,kind,target:key,file:workRel,proof:rec.proof,passed,run,status:rec.status,deduped:false,sha256:sha,async:null}
       }
       if(kind==='blocked'){
         const key=formalKey(String(args.target||''))
@@ -970,7 +1606,9 @@ export function apply(ctx) {
       // living under right now.
       return '[核心规则重申] 只有 Verified/（及标记"已验证·真/假"）算已确立；验证须全组一致（全真或全假）才作数，否则留库附平均概率；你只写自己的库（'+base+'/ 的 Progress/<你>/、Propos/<你>/、Methods/<你>/、Subproblems/<你>/），可只读任何人的库；任务分工由团队讨论决定；退出只输出一个 JSON 对象。'
         +'\n`facilitator` 是**框架/人类介入的信使名**，不是常驻成员，也不在编制里——**不要向它回信**（`vibe_v4_send_message` 会返回 no such resident）；要回话请用本轮回执的 "input" 字段（会转给全组）或 `vibe_v4_send_message {to:"all"}`。'
-        +(formalOn()?('\n'+formalWorkLine()):'')
+        +(leanDailyOn()?('\n'+formalWorkLine()):'')
+        // math_computation is INDEPENDENT of formalVerify (its own `mathComputation` switch).
+        +(mathAvailabilityBlock()?('\n'+mathAvailabilityBlock()):'')
     }
     function brainstormPrompt(r){
       return (params.residentPersona?params.residentPersona+'\n':'')
@@ -983,12 +1621,23 @@ export function apply(ctx) {
         +'{"summary":"<your insight / direction / rough plan, one tight paragraph>","solved":false}'
     }
     async function normalPrompt(r){
+      // Consume-and-clear ONCE: calling the accessor twice would return '' the second time (bug).
+      const leanNotice=pendingLeanNoticeText()
+      // The math availability line is built from the probe cache; awaiting the refresh HERE means a
+      // cold cache still yields a complete line on the first wake (later wakes hit the cache).
+      await refreshMathAvailability()
+      const mathAvail=mathAvailabilityBlock()
       return (params.residentPersona?params.residentPersona+'\n':'')
         +'Resident researcher '+r.rId+' — 第 '+r.rounds+' 轮。一切由你和团队讨论决定。动手前先**读别人的库**对齐事实、避免重复；把新进展/结论**直接用 fs 写进你自己的文件**；想对团队说的话放 "input"（会转给其他常驻）。\n'
         +'\n团队成员：\n'+banner()+'\n'
         +'New items:\n'+ (await inboxText(r.rId)) +'\n'
+        // Settled background compiles are announced ONCE, in the next prompt constructed (spec §2.4):
+        // the same dynamic discipline as the mode — an announcement is never frozen into a brief.
+        +(leanNotice?('\n'+leanNotice+'\n'):'')
         // 顺手形式化: computed from the CURRENT mode on every wake (docs §1: the mode is dynamic).
-        +(formalOn()?('\n'+formalWorkLine()+'\n'):'')
+        +(leanDailyOn()?('\n'+formalWorkLine()+'\n'):'')
+        // math_computation availability (dynamic probe cache; independent of formalVerify).
+        +(mathAvail?('\n'+mathAvail+'\n'):'')
         +'Reply with ONLY a JSON object:\n'
         +'{"summary":"<what you did / decided this round, 1-3 sentences>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","task_desc":"<optional: why this task matters / what it covers|null>","claim_task":"<task id|null>","task_done":"<task id|null>","contextPct":40'
         +(formalOn()?(',"formal":{"target":"<对象 id>","decision":"used|blocked|defect","file":"Formal/<对象 id>.lean","note":"难度判断/阻塞原因/具体偏差"}'):'')
@@ -1034,6 +1683,9 @@ export function apply(ctx) {
         L.push('')
         L.push(formalPromptBlock(vs.targetId))
       }
+      // A settled background compile is announced once, here too: a voter must not conclude on a
+      // "passed" that only landed in the queue a moment ago (spec §2.4/§5 B).
+      { const notice=pendingLeanNoticeText(); if(notice){ L.push(''); L.push(notice) } }
       L.push('')
       L.push('Reply with ONLY a JSON object:')
       L.push('{"vote":{"verdict":1,"reason":"<your logic>"}}')
@@ -1472,10 +2124,24 @@ export function apply(ctx) {
         const allSolved = allSpoke && speakers.length>0 && speakers.every(iv=>iv.voteSolved===true)
         logActivity('meeting', 'concluded'+(allSolved?' → ALL agree solved':' (no unanimous solved vote)'))
         if(allSolved){
+          // ── FINAL PAPER ENTRY (docs/final-paper.md §A1) ─────────────────────────────────────────────────
+          // The paper phase MUST start HERE, BEFORE `running=false; autoDone=true` and before the
+          // coordination state is released: afterwards `startMeeting` refuses (autoDone), this
+          // handler's meeting/verify branches return early on `!running||autoDone`, and
+          // `scheduleNext` does nothing — co-writing/merge/cross-review could never run. The run
+          // therefore stays `running` while the team writes; `paperFinalize()` performs the
+          // completion flip once the paper exists (or has degraded safely).
+          meetingState=null; pendingMeeting=null; verifyState=null; pendingVerify=[]; wakeKind.clear()
+          await saveAll()
+          if(params.finalPaper){
+            const paper=await paperStart('auto',{deferCompletion:true})
+            if(paper&&paper.ok){
+              logActivity('paper','收口：一致性停止票通过（'+PAPER_CLOSURE_SIGNAL+'）→ 进入最终论文阶段，论文完成后才标记完成')
+              return
+            }
+            logActivity('paper','最终论文未能启动（'+((paper&&paper.message)||'unknown')+'）→ 按原路径收口')
+          } else logActivity('paper','finalPaper=false：跳过最终论文，直接收口')
           running=false; autoDone=true; phase='done'; clearHeartbeat()
-          // symmetric with initAbort: the STOP path must also release the coordination state, else
-          // status keeps reporting a phantom in-progress meeting (and stale wake kinds) forever.
-          meetingState=null; wakeKind.clear(); pendingMeeting=null; verifyState=null; pendingVerify=[]
           logActivity('stop','all residents agree: problem solved'); await saveAll(); return
         }
         meetingState=null; wakeKind.clear(); await saveAll()
@@ -1744,7 +2410,10 @@ export function apply(ctx) {
     function heartbeatPrompt(r){
       return (params.residentPersona?params.residentPersona+'\n':'')
         +'Resident researcher '+r.rId+' — CHECKPOINT（团队空闲，请由你们继续自主推进）。当前项目尚未解决（除非你已确认）。团队在等待有人继续：请**继续解决这个问题**——读他人的库对齐、推进某个子问题/引理/方法、尝试一条路线；或向团队发消息（input）、提议任务（propose_task）让大家分工。若你确实认为问题已解决、或已彻底无路可走，才提议开会（propose_meeting）让团队表决/商量、或声明 solved=true。默认立场是：**请推进，而不是停在原地。**\n'
-        +(formalOn()?(formalWorkLine()+'\n'):'')
+        +(leanDailyOn()?(formalWorkLine()+'\n'):'')
+        // math_computation availability (cached; `normalPrompt` awaits the refresh, so a heartbeat
+        // that follows a wake is never cold).
+        +(mathAvailabilityBlock()?(mathAvailabilityBlock()+'\n'):'')
         +'Reply with ONLY a JSON object:\n'
         +'{"summary":"<what you will do / what you advanced this round>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","task_desc":"<optional: why this task matters / what it covers|null>","claim_task":"<id|null>","contextPct":40'
         +(formalOn()?(',"formal":{"target":"<对象 id>","decision":"used|blocked|defect","file":"Formal/<对象 id>.lean","note":"难度判断/阻塞原因/具体偏差"}'):'')
@@ -1755,7 +2424,12 @@ export function apply(ctx) {
       clearHeartbeat()
       const ms=posMs(params.activityTimeoutMs,120000)
       if(typeof ctx.timeout!=='function') return
-      heartbeatDisposer=ctx.timeout(()=>{ heartbeatDisposer=null; scheduleNext().catch(()=>{}) }, ms)
+      // §2.2: the EXISTING heartbeat is the queue driver (same place, same discipline as the paper
+      // retry: independent of `scheduler.running`). `runLeanQueue()` is one boolean when idle.
+      heartbeatDisposer=ctx.timeout(()=>{ heartbeatDisposer=null; runLeanQueue().catch(()=>{}).then(()=>scheduleNext().catch(()=>{})) }, ms)
+      // Keep the math availability line current (engines can be installed while a run is live). The
+      // module's probe cache makes this a no-op after the first probe.
+      refreshMathAvailability().catch(()=>{})
     }
     // Real DSH /compact of a resident's OWN session via ctx.compaction (if the host provides it);
     // falling back silently to the resident self-summary directive when the service is absent.
@@ -1849,7 +2523,19 @@ export function apply(ctx) {
 
     // ---- liveness / scheduling ----
     async function scheduleNext(){
-      if(!running||autoDone){ clearHeartbeat(); return }
+      if(!running||autoDone){
+        // A MANUALLY triggered final paper may run on an already-concluded run; it is the one thing
+        // that still needs the timer, so it keeps its own pacing here (paperAdvance re-arms the
+        // heartbeat while it waits and clears it once the paper is done).
+        if(paperState&&paperState.status!=='done'&&paperState.status!=='failed'){ try{ await paperAdvance('scheduler-concluded') }catch(e){} return }
+        clearHeartbeat(); return
+      }
+      // The run is CONCLUDING (its closing meeting voted unanimously to stop): the ONLY remaining
+      // work is the final paper. No new research round may be dispatched behind it (docs/final-paper.md §A1).
+      if(paperState&&paperState.status!=='done'&&paperState.status!=='failed'){
+        try{ await paperAdvance('scheduler-paper') }catch(e){ console.error('vibe-math-v4: paper pass failed: '+String((e&&e.message)||e)) }
+        return
+      }
       // Residents the host's live-child cap refused are retried here — the single choke point every
       // scheduling pass goes through — so a refused spawn is deferred by a whole round (and paced by
       // the heartbeat) instead of being retried inside the loop that discovered the refusal.
@@ -1991,6 +2677,10 @@ export function apply(ctx) {
       const parsed=parseReply(output)
       const kind=wakeKind.get(r.rId)||'normal'
       postmark(r, parsed, kind)   // context/compact bookkeeping — a mid-consensus turn may NOT ack a compaction it never received
+      // The final-paper flow (docs/final-paper.md §A1) has its own wake kinds and its own state machine. It is
+      // handled BEFORE the meeting/verify branches and before their `!running||autoDone` guards,
+      // because a manually triggered paper legitimately runs on an already-concluded run.
+      if(kind.indexOf('paper:')===0){ await onPaperWakeEnd(r,parsed); return }
       if(kind==='meeting' && meetingState){
         meetingState.inputs[r.rId]={input:parsed.input||parsed.summary||'',voteSolved:typeof parsed.voteSolved==='boolean'?parsed.voteSolved:null,propose_verify:parsed.propose_verify||null,propose_task:parsed.propose_task||null,task_desc:parsed.task_desc||'',claim_task:parsed.claim_task||null}
         meetingState.lastInputAt=now()
@@ -2048,6 +2738,714 @@ export function apply(ctx) {
       await saveAll(); await scheduleNext()
     }
 
+    // ================= final paper (docs/final-paper.md §3-§5) =================
+    // When v4's consensus has converged (§2: the unanimous "solved" meeting closed, no ballot in
+    // flight, nothing queued) the run must produce a PAPER, not stop at a chat log. The team
+    // co-authors it: every resident writes the part it owns, the facilitator (the framework)
+    // MERGES the parts, every participant CROSS-REVIEWS at least one other part, the `paperEditor`
+    // finalises the merged draft, and the paper is finalised only when every participant has
+    // explicitly stated it is deliverable. Dissent iterates a bounded number of rounds and, at the
+    // cap, the disagreement is recorded in the appendix and the run is warned about.
+    //
+    // Everything the paper states comes from EVIDENCE ALREADY ON DISK (Verified/ cards, Propos/
+    // cards, Methods/ cards, Shared/meetings|debates/, the Lean records) or from the team's own
+    // written parts. Nothing is invented; unresolved/refuted items are flagged as such.
+    const PAPER_FORMATS=['both','md','tex'], PAPER_LANGS=['zh','en']
+    // v2 §A5: v4's `facilitator` is NOT a roster member and has no LLM (it is the framework / the
+    // human-side messenger), so "let the facilitator unify the notation" has no author. The editor is
+    // therefore the SESSION ROOT (the office = the human side) by default, or one named resident.
+    const PAPER_EDITOR_DEFAULT='office'
+    function paperEditorOk(v){ const s=String(v==null?'':v).trim(); return s==='office'||/^resident:[^\s]+$/.test(s) }
+    // v2 §A4: v4's REAL closure signal is the closing meeting's UNANIMOUS stop vote — the branch
+    // below in `finalizeMeeting` (allSolved). The v1 wording ("every verify target decided / mailbox
+    // empty") is stricter than the code and would never fire, so the paper phase is entered from
+    // inside that exact branch and any still-未决 item is flagged in the paper instead.
+    const PAPER_CLOSURE_SIGNAL='finalizeMeeting/allSolved（一致性会议的一致停止票）'
+    const PAPER_MAX_ROUNDS=2          // bounded iterations after dissent (docs/final-paper.md §4: "有上限")
+    const PAPER_NUDGE_TRIES=2         // paced re-asks before the step deadline declares a timeout
+    const PAPER_WAIT_FLOOR_MS=2000    // a step's deadline is at least this (tests run with tiny timeouts)
+    const PAPER_KINDS={part:'paper:part',review:'paper:review',final:'paper:final',vote:'paper:vote',revise:'paper:revise'}
+    const PAPER_MARK={part:'[PAPER PART]',review:'[PAPER REVIEW]',final:'[PAPER FINAL]',vote:'[PAPER DELIVERABLE]',revise:'[PAPER REVISE]'}
+    const PAPER_HEAD_ZH=['标题、作者、日期与摘要','引言与问题背景','原问题的完整解法','已检验通过的命题','已解决的子问题与中间成果','创造或发现的有价值之物','规律总结','讨论、局限与展望','附录：证据与文件索引']
+    const PAPER_HEAD_EN=['Title, Authors, Date and Abstract','Introduction and Problem Background','Complete Solution of the Original Problem','Verified Propositions','Solved Sub-problems and Intermediate Results','Valuable Creations and Discoveries','Patterns and Reusable Principles','Discussion, Limitations and Outlook','Appendix: Evidence and File Index']
+
+    function paperTitles(lang){ return lang==='en'?PAPER_HEAD_EN:PAPER_HEAD_ZH }
+    /** The run id doubles as the v4 "institute id": Paper/<run id>/ (docs/final-paper.md §5). Sanitised through
+     *  `idSafe`+`slugify`, so a hostile problem text/title can never produce `../`. */
+    function paperIdFor(){ return idSafe(slugify('v4-'+problemId))+'-'+idSafe(runId) }
+    function paperDirFor(){ return 'Paper/'+paperIdFor() }
+    /** Containment (docs/final-paper.md §6): every paper write must stay inside `Paper/<id>/`. */
+    async function paperWriteRel(rel,content){
+      const dir=paperState?paperState.dir:paperDirFor()
+      const norm=String(rel).replace(/\\/g,'/')
+      if(norm.indexOf(dir+'/')!==0 || norm.indexOf('..')!==-1) return false
+      return await writeText(norm,content)
+    }
+    function paperLog(line){ const ps=paperState; if(ps) ps.log.push(fmtTime()+'｜'+String(line)) }
+    function paperStepLimit(){ return Math.max(PAPER_WAIT_FLOOR_MS, recoverStallMs()*4) }
+    function paperCfg(ov){
+      const o=ov||{}
+      const ed=String(o.editor==null?'':o.editor).trim()
+      return {
+        language:PAPER_LANGS.indexOf(String(o.lang))!==-1?String(o.lang):params.paperLanguage,
+        format:PAPER_FORMATS.indexOf(String(o.format))!==-1?String(o.format):params.paperFormat,
+        editor:paperEditorOk(ed)?ed:(paperEditorOk(params.paperEditor)?String(params.paperEditor):PAPER_EDITOR_DEFAULT),
+        compilePdf:params.paperCompilePdf!==false,
+      }
+    }
+    /** `resident:<id>` -> the id, `office`/absent -> ''. */
+    function paperEditorResidentId(editor){ const m=/^resident:([^\s]+)$/.exec(String(editor||'')); return m?m[1]:'' }
+    // ---- evidence (every claim in §4-§9 of the skeleton must be traceable to one of these) ----
+    async function paperListDirFiles(base){
+      const out=[]
+      try {
+        const t=await fs.resolve(base,{cwd:frameworkRoot()}); if(await fs.stat(t)===undefined) return out
+        for(const e of (await fs.listDir(t))||[]){ if(!e||e.type!=='file'||!/\.md$/.test(String(e.name))) continue
+          const rel=base+'/'+e.name; out.push({rel,text:(await readText(rel))||''}) }
+      } catch(e){ /* best effort: an absent directory is an empty evidence set */ }
+      out.sort((a,b)=>a.rel<b.rel?-1:a.rel>b.rel?1:0); return out
+    }
+    async function paperListCards(base){
+      const out=[]
+      try {
+        const root=await fs.resolve(base,{cwd:frameworkRoot()}); if(await fs.stat(root)===undefined) return out
+        for(const d of (await fs.listDir(root))||[]){ if(!d||d.type!=='directory') continue
+          const dir=base+'/'+d.name
+          try {
+            const t=await fs.resolve(dir,{cwd:frameworkRoot()}); if(await fs.stat(t)===undefined) continue
+            for(const e of (await fs.listDir(t))||[]){ if(!e||e.type!=='file'||!/\.md$/.test(String(e.name))) continue
+              const rel=dir+'/'+e.name; out.push({rel,text:(await readText(rel))||''}) }
+          } catch(e2){ /* one unreadable library must not stop the scan */ }
+        }
+      } catch(e){ /* best effort */ }
+      out.sort((a,b)=>a.rel<b.rel?-1:a.rel>b.rel?1:0); return out
+    }
+    function paperField(text,name){
+      const esc=String(name).replace(/[.*+?^${}()|[\]\\]/g,'\\$&')
+      const re=new RegExp('(?:^|\\n|;\\s*)-\\s*'+esc+':\\s*([^;\\n]*)')
+      const m=re.exec(String(text||'')); return m?m[1].trim():''
+    }
+    async function paperEvidence(){
+      const [verifiedFiles,problemFiles,propos,methods,subproblems,meetings,debates]=await Promise.all([
+        paperListDirFiles('Verified/命题'), paperListDirFiles('Verified/问题'), paperListCards('Propos'),
+        paperListCards('Methods'), paperListCards('Subproblems'), paperListDirFiles('Shared/meetings'), paperListDirFiles('Shared/debates'),
+      ])
+      const parse=f=>({rel:f.rel,id:paperField(f.text,'ID'),结论:paperField(f.text,'结论'),概率:paperField(f.text,'概率'),
+        类型:paperField(f.text,'类型'),状态:paperField(f.text,'状态')||paperField(f.text,'状态'),标题:paperField(f.text,'标题'),
+        可信断言:paperField(f.text,'可信断言'),text:f.text})
+      return {
+        problem:problemText, problemId:problemId, runId:runId, project:currentProject, converged:!!autoDone,
+        verified:verifiedFiles.map(parse), verifiedProblems:problemFiles.map(parse),
+        propos:propos.map(parse), methods:methods.map(parse), subproblems:subproblems.map(parse),
+        meetings:meetings.map(f=>f.rel), debates:debates.map(f=>f.rel),
+        formal:formalView().objects.map(o=>({target:o.target,status:o.status,file:o.file,proof:o.proof})),
+        index:[...verifiedFiles,...problemFiles,...propos,...methods,...subproblems,...meetings,...debates].map(f=>f.rel).sort(),
+      }
+    }
+    function paperHash(s){ let h=5381; const t=String(s==null?'':s); for(let i=0;i<t.length;i++) h=((h*33)^t.charCodeAt(i))>>>0; return h.toString(16).padStart(8,'0') }
+    /** Idempotency is per (run id, finalizedAt) plus per-artifact existence — docs/final-paper.md §C explicitly
+     *  drops v1's multi-file inputsHash. This only fingerprints one string for the log, never a
+     *  decision. */
+    function paperFingerprint(ev){ return paperHash([ev.problemId,ev.runId,ev.problem,ev.index.join('|')].join('\n')) }
+    // ---- prompts (stable markers so the flow is observable/driveable) ----
+    function paperPrompt(kind,rid,again){
+      const ps=paperState, T=paperTitles(ps.cfg.language), zh=ps.cfg.language!=='en'
+      const head=zh
+        ? '【最终论文·团队合写】你（'+rid+'）是本次运行的参与常驻。'
+        : '[FINAL PAPER — TEAM CO-AUTHORING] You ('+rid+') are a participating resident of this run.'
+      const common=(zh?'\n论文目录：`'+ps.dir+'/`（一切写入必须在这里面）。只整理**已有证据**：你自己的库、Verified/、Shared/meetings|debates/ 与既有卡片；**不得编造**；未决/被否证的条目必须显式标注。'
+        :'\nPaper directory: `'+ps.dir+'/` (everything you write stays inside it). Only organise EXISTING evidence (your own library, Verified/, Shared/meetings|debates/, the recorded cards); never invent; flag unresolved/refuted items explicitly.')
+      if(kind==='part') return PAPER_MARK.part+'\n'+head+'\n'+(again?(zh?'（上一次没有收到你的部分，请重发。）\n':'(no part was received from you last time — please resend.)\n'):'')
+        +(zh?'请撰写**你负责的那一部分**（你库里的命题/方法/子问题/进展，以及你亲自参与的会议与争论中确立的内容），成文即可，不必追求篇幅。\n'
+            :'Write the part YOU own (the propositions/methods/sub-problems/progress in your library and what you personally established in meetings/debates).\n')
+        +common+'\n'+(zh?'回复一个 JSON：`{"paperPart":{"title":"<部分标题>","markdown":"<正文 markdown>"}}`（也可以直接用 fs 写到 `'+ps.dir+'/parts/'+rid+'.md`）。'
+            :'Reply with one JSON object: `{"paperPart":{"title":"<title>","markdown":"<body markdown>"}}` (you may also write `'+ps.dir+'/parts/'+rid+'.md` with fs).')
+        +'\n'+(zh?'九节骨架：':"The paper's nine sections: ")+T.join(' / ')
+      if(kind==='review') return PAPER_MARK.review+'\n'+head+'\n'+(again?(zh?'（上一次的互审没有指名**其他**参与者，请重发。）\n':'(your last review did not name ANOTHER participant — please resend.)\n'):'')
+        +(zh?'合并稿见 `'+ps.dir+'/draft.md`。请**审阅至少一位其他参与者的部分**（不能审自己），指出具体问题并给出可落实的改进。\n'
+            :'The merged draft is at `'+ps.dir+'/draft.md`. Review AT LEAST ONE OTHER participant\'s part (never your own), name concrete problems and give actionable improvements.\n')
+        +common+'\n'+(zh?'回复一个 JSON：`{"paperReview":{"reviewed":"<被审的参与者 id>","points":["<问题>","..."],"improvements":"<你建议的改进>"}}`'
+            :'Reply with one JSON object: `{"paperReview":{"reviewed":"<other participant id>","points":["..."],"improvements":"..."}}`')
+      if(kind==='final') return PAPER_MARK.final+'\n'+head+'\n'
+        +(zh?'你是本次的**定稿代表**（paperEditor）。请把合并稿 `'+ps.dir+'/draft.md` 与互审意见梳理成**最终稿**：去重、统一术语与记号，保留全部证据与未决标注。\n'
+            :'You are the run\'s EDITOR (paperEditor). Turn the merged draft `'+ps.dir+'/draft.md` plus the review points into the FINAL draft: deduplicate, unify terms and notation, keep every evidence pointer and unresolved flag.\n')
+        +common+'\n'+(zh?'回复一个 JSON：`{"paperFinal":{"markdown":"<最终稿正文 markdown>"}}`（或直接写 `'+ps.dir+'/final.md`）。'
+            :'Reply with one JSON object: `{"paperFinal":{"markdown":"<final body markdown>"}}` (or write `'+ps.dir+'/final.md`).')
+      // vote / revise
+      return PAPER_MARK[kind]+'\n'+head+'\n'
+        +(zh?'请阅读最终稿 `'+ps.dir+'/final.md`，然后**明确表态它是否可交付**。有反对必须说明理由（框架会迭代，超限会把分歧写进附录）。\n'
+            :'Read the final draft at `'+ps.dir+'/final.md` and state EXPLICITLY whether it is deliverable. Any objection must state its reason (the framework iterates; at the cap the disagreement goes into the appendix).\n')
+        +common+'\n'+(zh?'回复一个 JSON：`{"paperDeliverable":true|false,"reason":"<理由>"}`'
+            :'Reply with one JSON object: `{"paperDeliverable":true|false,"reason":"<why>"}`')
+    }
+    // ---- state machine ----
+    function paperHas(step,rid){
+      const ps=paperState; if(!ps) return false
+      if(step==='parts') return !!ps.parts[rid]
+      if(step==='review') return !!ps.reviews[rid]
+      if(step==='final') return !!ps.finalDraft
+      if(step==='vote') return typeof ps.deliverable[rid]==='boolean'
+      return false
+    }
+    function paperMarkMissing(step,rid){
+      const ps=paperState
+      if(step==='parts') ps.parts[rid]={text:'',missing:true,source:'missing'}
+      else if(step==='review') ps.reviews[rid]={missing:true}
+      else if(step==='final'){ if(!ps.finalDraft) ps.finalDraft=paperFacilitatorFinal() }
+      else if(step==='vote') ps.deliverable[rid]=false
+      paperLog('超时：'+rid+' 在 '+step+' 阶段未回应，已按"缺少该部分/未表态"记录')
+    }
+    async function paperWakeSome(ids,kind){
+      const ps=paperState
+      for(const rid of ids){
+        const r=residents.get(rid)
+        if(!r||!r.childId){ paperLog('警告：'+rid+' 已不在场，跳过 '+kind); paperMarkMissing(kind==='part'?'parts':kind==='review'?'review':kind==='final'?'final':'vote',rid); continue }
+        if(busy.has(rid)) continue
+        const ok=await wakeResident(r,paperPrompt(kind,rid),PAPER_KINDS[kind])
+        if(!ok) paperLog('警告：无法唤醒 '+rid+' 执行 '+kind)
+      }
+      await paperWriteLog()
+    }
+    async function paperWait(step){
+      const ps=paperState; if(!ps) return
+      const miss=ps.participants.filter(x=>!paperHas(step,x))
+      if(!miss.length) return await paperAdvance('wait-recheck')
+      const nowTs=now()
+      if(nowTs-ps.stepAt>=paperStepLimit()){
+        for(const rid of miss) paperMarkMissing(step,rid)
+        ps.warning=(ps.warning?ps.warning+'；':'')+'有参与者在 '+step+' 阶段超时未回应（'+miss.join('、')+'），已按"缺少该部分"记录并继续'
+        paperLog('警告：'+ps.warning); ps.stepAt=nowTs
+        await paperWriteLog(); return await paperAdvance('timeout')
+      }
+      // Paced re-ask: at most one nudge per stall window, and only PAPER_NUDGE_TRIES in total, so an
+      // unresponsive host cannot produce a wake storm while the deadline is still open.
+      if(nowTs-(ps.lastNudgeAt||0)>=posMs(params.activityTimeoutMs,120000)){
+        ps.lastNudgeAt=nowTs
+        for(const rid of miss){
+          const key=rid+':'+step
+          ps.attempts[key]=(ps.attempts[key]||0)+1
+          if(ps.attempts[key]>PAPER_NUDGE_TRIES) continue
+          const r=residents.get(rid)
+          if(!r||!r.childId||busy.has(rid)) continue
+          const ok=await wakeResident(r,paperPrompt(step,rid,true),PAPER_KINDS[step])
+          if(!ok) paperLog('警告：无法唤醒 '+rid+'（'+step+' 重试）')
+        }
+        await paperWriteLog()
+      }
+      armHeartbeat()   // keep the clock running so the step deadline is actually reachable
+    }
+    async function paperAdvance(why){
+      const ps=paperState
+      if(!ps||ps.status==='done'||ps.status==='failed') return
+      try {
+        if(ps.status==='parts'){
+          if(ps.participants.every(x=>paperHas('parts',x))) return await paperMerge()
+          return await paperWait('parts')
+        }
+        if(ps.status==='review'){
+          if(ps.participants.every(x=>paperHas('review',x))) return await paperFinalStep()
+          return await paperWait('review')
+        }
+        if(ps.status==='final'){
+          if(ps.finalDraft) return await paperVoteStep()
+          return await paperWait('final')
+        }
+        if(ps.status==='vote'){
+          if(!ps.participants.every(x=>paperHas('vote',x))) return await paperWait('vote')
+          if(ps.participants.every(x=>ps.deliverable[x]===true)) return await paperFinalize()
+          return await paperIterate()
+        }
+      } catch(e){ console.error('vibe-math-v4: paper step ('+(why||'')+') failed: '+String((e&&e.stack)||e)) }
+    }
+    async function paperMerge(){
+      const ps=paperState
+      const parts=ps.participants.map(rid=>({rid,text:String((ps.parts[rid]&&ps.parts[rid].text)||'')})).filter(p=>p.text.trim())
+      const seen=new Map(), dups=[], terms=new Map(), conflicts=[], body=[]
+      for(const p of parts){
+        const paras=p.text.replace(/\r\n/g,'\n').split(/\n{2,}/)
+        for(const raw of paras){
+          const para=raw.trim(); if(!para) continue
+          const norm=para.replace(/\s+/g,' ').toLowerCase()
+          if(norm.length>=40 && seen.has(norm)){ dups.push({owner:seen.get(norm),dup:p.rid,head:para.slice(0,60)}); continue }
+          if(norm.length>=40) seen.set(norm,p.rid)
+          body.push(para)
+          // Notation/term unification: the FIRST definition of a `- 术语: 定义` / `**术语**：…` line
+          // wins; a different definition of the same term in another part is recorded as a conflict.
+          const m=/^(?:[-*]\s*)?(?:\*\*)?([\u4e00-\u9fa5A-Za-z][^:：*]{0,24})(?:\*\*)?\s*[:：]\s*(\S.*)$/.exec(para)
+          if(m){ const term=m[1].trim()
+            if(!terms.has(term)) terms.set(term,{owner:p.rid,def:para})
+            else if(terms.get(term).owner!==p.rid && terms.get(term).def!==para) conflicts.push({term,kept:terms.get(term).owner,conflict:p.rid}) }
+        }
+      }
+      ps.draft=body.join('\n\n')
+      const L=['# 合并稿（facilitator 合并）','','- 论文 id：'+ps.id,'- 参与成员：'+(ps.participants.join('、')||'（无常驻）'),
+        '- 合并规则：跨部分**完全重复**的段落只保留首次出现；同一术语的**首个定义**为准，冲突记入下方。','']
+      for(const p of parts) L.push('## 部分｜'+p.rid,'',p.text.trim(),'')
+      L.push('## 合并说明','')
+      L.push('- 去重：'+(dups.length?dups.map(d=>'「'+d.head+'…」（'+d.dup+' 重复了 '+d.owner+'）').join('；'):'无跨部分重复段落'))
+      L.push('- 术语/记号统一：'+(terms.size?[...terms.entries()].map(([k,v])=>k+'（取 '+v.owner+' 的定义）').join('；'):'未识别到形如「术语：定义」的行'))
+      L.push('- 术语冲突：'+(conflicts.length?conflicts.map(c=>c.term+'（保留 '+c.kept+'，'+c.conflict+' 的定义不同）').join('；'):'无'))
+      ps.mergeNotes={dups:dups.length,terms:terms.size,conflicts:conflicts.length}
+      paperLog('facilitator 合并完成：'+parts.length+' 个部分，去重 '+dups.length+' 段，统一术语 '+terms.size+' 个，冲突 '+conflicts.length+' 处')
+      await paperWriteRel(ps.dir+'/draft.md',L.join('\n')+'\n')
+      ps.status='review'; ps.stepAt=now(); ps.lastNudgeAt=0
+      await paperWriteMeta(); await paperWriteLog()
+      if(!ps.participants.length){ return await paperFinalStep() }
+      await paperWakeSome(ps.participants.slice(),'review')
+      await paperAdvance('review-started')
+    }
+    /** The framework's own finalisation (paperEditor='facilitator'): the merged body plus the review
+     *  round APPLIED as an attributed revision block. No new claims are introduced. */
+    function paperFacilitatorFinal(){
+      const ps=paperState
+      const L=[String(ps.draft||'').trim()]
+      const rows=ps.participants.map(rid=>ps.reviews[rid]).filter(Boolean)
+      if(rows.length){
+        L.push('','## 互审改进（已采纳）')
+        for(const rid of ps.participants){
+          const rv=ps.reviews[rid]; if(!rv) continue
+          if(rv.missing){ L.push('- '+rid+'：互审超时未提交（已记入附录）'); continue }
+          const pts=(rv.points||[]).map(x=>'「'+x+'」').join('、')
+          L.push('- '+rid+' → 审阅 '+rv.reviewed+'：'+(pts||'（未列出具体问题）')+(rv.improvements?('；改进：'+rv.improvements):''))
+        }
+      }
+      return L.join('\n').trim()
+    }
+    async function paperFinalStep(){
+      const ps=paperState
+      ps.status='final'; ps.stepAt=now(); ps.lastNudgeAt=0
+      const wantId=paperEditorResidentId(ps.cfg.editor)
+      const r=wantId?residents.get(wantId):undefined
+      if(wantId && r && r.childId){
+        ps.editorId=wantId
+        paperLog('定稿代表：resident:'+wantId+'（paperEditor 指定）')
+        const ok=await wakeResident(r,paperPrompt('final',wantId),PAPER_KINDS.final)
+        if(ok){ await paperWriteMeta(); await paperWriteLog(); armHeartbeat(); return }
+        ps.warning='无法唤醒定稿代表 resident:'+wantId+'，降级到 office'
+        ps.editorDowngraded=true; paperLog('警告：'+ps.warning)
+      } else if(wantId){
+        // v2 §A5: the named editor left the roster (e.g. removeMember) -> downgrade to office and
+        // RECORD the downgrade in meta + paper.log.md (never silently substitute an author).
+        ps.warning='定稿代表 resident:'+wantId+' 已不在编制（可能已被解雇），降级到 office'
+        ps.editorDowngraded=true; paperLog('警告：'+ps.warning)
+      }
+      ps.editorId='office'
+      paperLog('定稿代表：office（会话根/人类侧）—— 框架依 office 之责把合并稿与互审记录整理成最终稿')
+      if(!ps.finalDraft) ps.finalDraft=paperFacilitatorFinal()
+      await paperWriteRel(ps.dir+'/final.md',ps.finalDraft)
+      await paperWriteMeta(); await paperWriteLog()
+      return await paperVoteStep()
+    }
+    async function paperVoteStep(){
+      const ps=paperState
+      if(!ps.finalDraft) ps.finalDraft=paperFacilitatorFinal()
+      await paperWriteRel(ps.dir+'/final.md',ps.finalDraft)
+      ps.status='vote'; ps.stepAt=now(); ps.lastNudgeAt=0
+      paperLog('交付表决：请全体参与成员明确表态"可交付"')
+      await paperWriteMeta(); await paperWriteLog()
+      if(!ps.participants.length) return await paperFinalize()
+      await paperWakeSome(ps.participants.slice(),'vote')
+      await paperAdvance('vote-started')
+    }
+    async function paperIterate(){
+      const ps=paperState
+      const against=ps.participants.filter(x=>ps.deliverable[x]!==true)
+      ps.dissent=against.slice()
+      ps.round+=1
+      paperLog('第 '+ps.round+' 轮：'+against.join('、')+' 未表示可交付（'+(against.map(x=>ps.deliverable[x]===false?'明确反对':'未表态').join('；'))+'）')
+      if(ps.round>ps.maxRounds){
+        ps.warning=(ps.warning?ps.warning+'；':'')+'互审/交付迭代达到上限（'+ps.maxRounds+'）：'+against.join('、')+' 的分歧已写入附录'
+        paperLog('警告：'+ps.warning)
+        return await paperFinalize()
+      }
+      for(const rid of against) ps.deliverable[rid]=undefined
+      ps.status='vote'; ps.stepAt=now(); ps.lastNudgeAt=0
+      await paperWriteMeta(); await paperWriteLog()
+      await paperWakeSome(against,'revise')
+      await paperAdvance('revise-started')
+    }
+    // ---- content: the nine-section skeleton, built ONLY from evidence + the team's own text ----
+    function paperExtractSection(draft,words){
+      const lines=String(draft||'').split(/\r?\n/)
+      let start=-1,level=0
+      for(let i=0;i<lines.length;i++){
+        const m=/^(#{1,6})\s*(.+)$/.exec(lines[i])
+        if(m&&new RegExp(words,'i').test(m[2])){ start=i+1; level=m[1].length; break }
+      }
+      if(start<0) return ''
+      const out=[]
+      for(let i=start;i<lines.length;i++){
+        const m=/^(#{1,6})\s*/.exec(lines[i])
+        if(m&&m[1].length<=level) break
+        out.push(lines[i])
+      }
+      return out.join('\n').trim()
+    }
+    function paperBullets(items,empty){ return items.length?items.map(x=>'- '+x).join('\n'):('- '+empty) }
+    function paperCompose(ps,ev,cfg){
+      const zh=cfg.language!=='en', T=paperTitles(cfg.language)
+      const r=(a,b)=>zh?a:b
+      const body=String(ps.finalDraft||ps.draft||'').trim()
+      const truth=ev.verified.filter(v=>v.结论!=='假'), refuted=ev.verified.filter(v=>v.结论==='假')
+      const pending=ev.propos.filter(p=>!['已验证·真','已验证·假'].includes(p.状态))
+      const firstLine=String(ev.problem||'').split(/\r?\n/)[0].trim()
+      const conclusion=r(
+        (truth.length?('全体一致检验通过的命题 '+truth.length+' 条'+(refuted.length?('，被否证 '+refuted.length+' 条'):'')):'本轮没有取得全体一致的检验结论')+'；未决条目 '+pending.length+' 条。',
+        (truth.length?('Verified propositions: '+truth.length+(refuted.length?('; refuted: '+refuted.length):'')):'No unanimously verified proposition this run')+'; unresolved items: '+pending.length+'.')
+      const sec=[];
+      sec.push({title:T[0],body:[r('**摘要**：原问题——',' **Abstract** — problem: ')+firstLine,
+        r('主要结论：','Main conclusion: ')+conclusion].join('\n')});
+      sec.push({title:T[1],body:[r('原问题（完整陈述）：','Original problem (full statement):'),'',String(ev.problem||''),
+        '','- '+r('项目','Project')+'：'+ev.project,'- '+r('运行','Run')+'：'+ev.runId,'- '+r('状态','Status')+'：'+(ev.converged?r('已收敛','converged'):r('未收敛','not converged'))].join('\n')});
+      sec.push({title:T[2],body:[body||r('（团队本轮没有产出正文；以下仅为已有证据的索引。）','(The team authored no body this run; only the evidence index below.)'),
+        '','### '+r('最终答案与结论','Final answer and conclusions'),paperBullets(
+          truth.map(v=>v.id+(v.概率?('（'+r('判定为真，估计值','true, estimate')+' '+v.概率+'）'):'')+' ← `'+v.rel+'`'),
+          r('本轮没有被全体一致判定为真的命题','No unanimously true proposition this run'))].join('\n')});
+      sec.push({title:T[3],body:[paperBullets(
+        ev.verified.map(v=>{ const verdict=v.结论==='假'?r('已否证','refuted'):r('真','true')
+          return '['+verdict+'] '+v.id+(v.概率?('｜'+r('概率','probability')+' '+v.概率):'')+'｜'+r('证据','evidence')+' `'+v.rel+'`'+(v.类型?('｜'+v.类型):'') }),
+        r('本轮没有被检验通过的命题','No verified proposition this run')),
+        '','### '+r('未决 / 未通过','Unresolved / not passed'),
+        paperBullets(pending.map(p=>'[未决] '+p.id+'（'+r('状态','status')+'：'+(p.状态||'未定论')+'）｜`'+p.rel+'`')
+          .concat(ev.formal.filter(f=>f.status!=='passed').map(f=>'[未决·形式化] '+f.target+'（'+f.status+'）'+(f.file?('｜`'+f.file+'`'):''))),
+          r('无','none'))].join('\n')});
+      sec.push({title:T[4],body:[paperBullets(
+        ev.verifiedProblems.map(v=>'[已解决] '+v.id+'｜`'+v.rel+'`').concat(ev.subproblems.map(s=>'['+(['已验证·真','已验证·假'].includes(s.状态)?r('已解决','solved'):r('未决','unresolved'))+'] '+s.id+(s.标题?('「'+s.标题+'」'):'')+'｜`'+s.rel+'`')),
+        r('本轮没有记录子问题','No sub-problem was recorded this run'))].join('\n')});
+      sec.push({title:T[5],body:[paperBullets(
+        ev.methods.map(m=>m.id+(m.标题?('「'+m.标题+'」'):'')+'（'+(m.类型||r('方法','method'))+'，'+(m.状态||r('经验','experiential'))+'）'+(m.可信断言?('｜'+r('可信断言','trusted claims')+'：'+m.可信断言):'')+'｜`'+m.rel+'`'),
+        r('本轮没有记录方法/理论/工具','No method/theory/tool was recorded this run')),
+        '',r('已归档的形式化产物：','Archived formal artifacts: ')+paperBullets(ev.formal.filter(f=>f.status==='passed').map(f=>f.target+(f.proof?('｜`'+f.proof+'`'):'')+(f.file?('｜`'+f.file+'`'):'')),r('无','none'))].join('\n')});
+      const pattern=paperExtractSection(body,zh?'规律|总结|原理':'pattern|principle')
+      sec.push({title:T[6],body:[pattern||[r('团队本轮没有单独撰写"规律总结"；以下为**有证据支撑**的可复用条目（取自方法卡与已验证命题），未作外推：',
+        'The team did not author a separate "patterns" section; below are the EVIDENCE-BACKED reusable items (method cards and verified propositions), with no extrapolation:'),
+        paperBullets(ev.methods.filter(m=>m.可信断言).map(m=>m.可信断言+'（`'+m.rel+'`）')
+          .concat(truth.map(v=>v.id+'（`'+v.rel+'`）')),r('无','none'))].join('\n')].join('\n')});
+      const disc=paperExtractSection(body,zh?'讨论|局限|展望':'discussion|limitation|outlook')
+      sec.push({title:T[7],body:[disc||r('（团队未单独撰写讨论；以下为框架按证据整理的局限。）','(No separate discussion was authored; the framework lists the evidenced limitations.)'),
+        '','### '+r('局限与未决','Limitations and open items'),
+        paperBullets([
+          r('未决/未通过条目 '+pending.length+' 条（见第 4 节，均已标注）','Unresolved items: '+pending.length+' (flagged in §4)'),
+          r('被否证的命题 '+refuted.length+' 条（见第 4 节）','Refuted propositions: '+refuted.length+' (see §4)'),
+          (ps.compile&&ps.compile.result==='failed')?r('PDF 编译失败：已保留 paper.tex 与 paper.md 并上报','PDF compilation failed: paper.tex and paper.md were kept and reported'):'',
+          (ps.compile&&ps.compile.result==='not-detected')?r('本机未检测到 LaTeX 引擎：只产出 tex+md','No LaTeX engine detected: tex+md only'):'',
+          ps.dissent.length?r('交付分歧（'+ps.dissent.join('、')+'）已写入附录','Deliverability dissent ('+ps.dissent.join(', ')+') is recorded in the appendix'):'',
+          ps.warning?r('过程警告：'+ps.warning,'Process warning: '+ps.warning):'',
+        ].filter(Boolean),r('无','none'))].join('\n')});
+      sec.push({title:T[8],body:[r('证据与文件索引（全部相对于项目根）：','Evidence and file index (all relative to the project root):'),
+        '',paperBullets(ev.index.map(p=>'`'+p+'`'),r('无','none')),
+        '','- '+r('过程记录','Process log')+'：`'+ps.dir+'/paper.log.md`',
+        '- '+r('元数据','Metadata')+'：`'+ps.dir+'/paper.meta.json`',
+        '- '+r('各成员撰写部分','Per-member parts')+'：`'+ps.dir+'/parts/`',
+        '- '+r('互审记录','Cross-review records')+'：`'+ps.dir+'/reviews/`',
+        '- '+r('合并稿/最终稿','Merged / final draft')+'：`'+ps.dir+'/draft.md`、`'+ps.dir+'/final.md`',
+        (ps.dissent.length||ps.round>ps.maxRounds)?['','### '+r('附录：交付分歧','Appendix: deliverability dissent'),paperBullets(ps.participants.filter(x=>ps.deliverable[x]!==true).map(x=>x+'：'+(ps.deliverable[x]===false?r('反对交付','objected'):r('未表态','no statement'))+'｜'+r('迭代轮次','rounds')+' '+ps.round+'/'+ps.maxRounds),r('无','none'))].join('\n'):'']
+        .filter(Boolean).join('\n')});
+      const title=r('Vibe-Mathematics v4 研究报告','Vibe-Mathematics v4 Research Report')+'｜'+firstLine.slice(0,60)
+      const md=L=>L
+      const mdText=['# '+title,'','- '+r('作者','Authors')+'：Vibe-Mathematics v4（'+r('运行','run')+' '+ps.runId+'）',
+        '- '+r('日期','Date')+'：'+fmtTime(ps.finalizedAt||now()).slice(0,10),
+        '- '+r('参与成员','Participants')+'：'+(ps.participants.join('、')||r('（无常驻）','(no residents)')),
+        '- '+r('定稿代表','Editor')+'：'+(ps.editorId||cfg.editor),'',
+        ...sec.map((s,i)=>['## '+(i+1)+'. '+s.title,'',s.body,''].join('\n'))].join('\n')
+      const texBody=sec.map((s,i)=>'\\section{'+texEsc(s.title)+'}\n'+texEsc(s.body)).join('\n\n')
+      const tex=paperTex(cfg,title,texBody)
+      return {title, sections:sec, md:mdText, tex, texBody}
+    }
+    function paperTex(cfg,title,texBody){
+      const zh=cfg.language!=='en'
+      const cls=zh?'ctexart':'article'
+      const pkgs=['amsmath','amssymb','amsthm','geometry','hyperref','longtable','booktabs']
+      return ['% generated by vibe-math-v4 (final paper)','\\documentclass[11pt]{'+cls+'}',
+        ...pkgs.map(p=>'\\usepackage{'+p+'}'),
+        '\\title{'+texEsc(title)+'}','\\author{Vibe-Mathematics v4}','\\date{'+texEsc(fmtTime(now()).slice(0,10))+'}',
+        '\\begin{document}','\\maketitle','',texBody,'','\\end{document}',''].join('\n')
+    }
+    /** tex escaping (docs/final-paper.md §5): every `_ % & # $ { } ~ ^ \\` becomes a safe command/escape. */
+    function texEsc(s){
+      const M={'\\':'\\textbackslash{}','{':'\\{','}':'\\}','$':'\\$','&':'\\&','#':'\\#','^':'\\textasciicircum{}','_':'\\_','%':'\\%','~':'\\textasciitilde{}'}
+      let out=''; for(const ch of String(s==null?'':s)) out+=(M[ch]||ch); return out
+    }
+    // ---- compilation (detect → compile twice → capped repair → degrade; docs/final-paper.md §D/§E) ----
+    // The host fs is TEXT-ONLY (dsh-fs has no writeBytes), so `paper.pdf` can only ever be produced
+    // by the compiler subprocess inside `Paper/<id>/` — the plugin just `stat`s it. The Lean seam
+    // (`sub.resolveExecutable` + `sub.spawn`) is reused verbatim so a fake compiler is injectable.
+    async function paperDetectEngine(lang){
+      const sub=subprocessOf(); if(sub===undefined) return {ok:false,tried:[],reason:'NO_SUBPROCESS'}
+      const prefer=String(params.paperLatexCommand||'').trim()
+      const base=lang==='en'?['pdflatex','latexmk','xelatex','lualatex','tectonic']:['xelatex','latexmk','pdflatex','lualatex','tectonic']
+      const order=(prefer?[prefer]:[]).concat(base.filter(x=>x!==prefer))
+      const tried=[]
+      for(let i=0;i<order.length;i++){
+        const exe=order[i]
+        try { const r=await sub.resolveExecutable(exe); if(r) return {ok:true,exe:String(r),tried,alts:order.slice(i+1)} }
+        catch(e){ tried.push(exe) }
+      }
+      return {ok:false,tried,reason:'LATEX_NOT_FOUND'}
+    }
+    function paperEngineArgv(exe,lang){
+      if(/latexmk$/.test(exe)) return [exe,'-interaction=nonstopmode',lang==='en'?'-pdf':'-xelatex','paper.tex']
+      return [exe,'-interaction=nonstopmode','paper.tex']
+    }
+    async function paperRunEngine(exe,argv,dir,cap){
+      const sub=subprocessOf(); if(sub===undefined) return {ok:false,code:'NO_SUBPROCESS'}
+      let handle
+      try { handle=sub.spawn({argv,cwd:dir,stdio:{stdin:'ignore',stdout:{maxBytes:64*1024},stderr:{maxBytes:64*1024}},graceMs:cap}) }
+      catch(e){ return {ok:false,code:'LATEX_SPAWN_FAILED',message:String((e&&e.message)||e)} }
+      let killed=false,timerDispose=null,outcome
+      try {
+        outcome=await Promise.race([handle.done,new Promise(function(resolve){
+          if(typeof ctx.timeout!=='function') return
+          timerDispose=ctx.timeout(function(){ killed=true; try{ if(typeof handle.terminate==='function') handle.terminate() }catch(e){} resolve({exitCode:null,signal:'SIGTERM'}) },cap)
+        })])
+      } catch(e){ if(timerDispose){ try{ timerDispose() }catch(_e){} } return {ok:false,code:'LATEX_RUN_FAILED',message:String((e&&e.message)||e)} }
+      if(timerDispose){ try{ timerDispose() }catch(e){} }
+      let out='',err=''
+      try { if(handle.collected&&handle.collected.stdout) out=handle.collected.stdout.readFrom(0).text } catch(e){}
+      try { if(handle.collected&&handle.collected.stderr) err=handle.collected.stderr.readFrom(0).text } catch(e){}
+      const exitCode=outcome?outcome.exitCode:null
+      return {ok:exitCode===0,exitCode,timedOut:killed,stdout:tail(out,2000),stderr:tail(err,2000)}
+    }
+    async function paperPdfExists(dir){
+      try { const t=await fs.resolve(dir+'/paper.pdf',{cwd:frameworkRoot()}); return !!(await fs.stat(t)) } catch(e){ return false }
+    }
+    /** v2 §E: at most ONE engine swap, then ONE minimal-template retry, then report + degrade. */
+    async function paperCompile(ps,composed,ev){
+      const dir=ps.dir
+      // v2 §E: `paperFormat=md` produces no tex, so "cannot compile without tex" must NOT be warned.
+      if(ps.cfg.format==='md') return {result:'skipped',reason:'paperFormat=md（未产出 tex，跳过编译）',attempts:[]}
+      if(!ps.cfg.compilePdf) return {result:'skipped',reason:'paperCompilePdf=false',attempts:[]}
+      // Never clobber an existing pdf (v2 §D): a previously compiled artifact is kept as-is.
+      if(await paperPdfExists(dir)) return {result:'ok',engine:'existing',note:'已存在 paper.pdf，未覆盖',attempts:[]}
+      const det=await paperDetectEngine(ps.cfg.language)
+      if(!det.ok) return {result:'not-detected',reason:'未检测到 LaTeX 引擎（'+(det.tried.join('/')||'subprocess 不可用')+'）：只产出 tex+md，不编译',tried:det.tried,attempts:[]}
+      const cap=posMs(params.activityTimeoutMs,120000)
+      const attempts=[]
+      const runTwice=async(exe,label,passes)=>{
+        const argv=paperEngineArgv(exe,ps.cfg.language)
+        let ok=true,first=null
+        for(let i=0;i<(passes||2);i++){ const a=await paperRunEngine(exe,argv,dir,cap); if(i===0) first=a; if(!a.ok){ ok=false; break } }
+        const pdf=await paperPdfExists(dir)
+        attempts.push({stage:label,engine:exe,ok:!!(ok&&pdf),exitCode:first?first.exitCode:null,pdf,stderr:String((first&&first.stderr)||'').slice(0,300)})
+        return {ok:!!(ok&&pdf),last:first}
+      }
+      let r=await runTwice(det.exe,'initial',2)
+      if(r.ok) return {result:'ok',engine:det.exe,attempts}
+      // repair 1: swap to another RESOLVABLE engine (same tex, nonstopmode, twice) — capped at one swap
+      const sub=subprocessOf()
+      for(const alt of det.alts||[]){
+        let altExe=null
+        try { if(sub) altExe=String(await sub.resolveExecutable(alt)) } catch(e){ continue }
+        if(!altExe||altExe===det.exe) continue
+        const rr=await runTwice(altExe,'engine-switch',2)
+        if(rr.ok) return {result:'ok',engine:altExe,repaired:'engine-switch',attempts}
+        break
+      }
+      // repair 2: ONE minimal-template retry (drops every optional package / custom preamble)
+      await paperWriteRel(dir+'/paper.tex',paperMinimalTemplate(ps.cfg,composed.title,composed.texBody))
+      const rr=await runTwice(det.exe,'minimal-template',1)
+      if(rr.ok) return {result:'ok',engine:det.exe,repaired:'minimal-template',attempts}
+      const last=attempts[attempts.length-1]||{}
+      return {result:'failed',engine:det.exe,attempts,error:'编译失败（已按上限尝试换引擎/最小模板）：保留 paper.tex 与 paper.md，不阻塞定稿',tail:String(last.stderr||'')}
+    }
+    function paperMinimalTemplate(cfg,title,texBody){
+      const cls=cfg.language==='en'?'article':'ctexart'
+      return ['% generated by vibe-math-v4 (minimal fallback template)','\\documentclass[11pt]{'+cls+'}',
+        '\\begin{document}','\\section*{'+texEsc(title)+'}','',String(texBody||''),'','\\end{document}',''].join('\n')
+    }
+    async function paperEnsureArtifacts(meta,cfg){
+      const filled=[]
+      const dir=String(meta.dir||('Paper/'+meta.id))
+      const saved=paperState
+      try {
+        if(!paperState||paperState.id!==meta.id){
+          paperState={ id:meta.id, dir, trigger:'recheck', deferCompletion:false, startedAt:meta.startedAt||now(), finalizedAt:meta.finalizedAt||0,
+            status:'done', round:meta.rounds||0, maxRounds:PAPER_MAX_ROUNDS, cfg, fingerprint:meta.fingerprint||'',
+            participants:Array.isArray(meta.participants)?meta.participants:[], parts:{}, reviews:{}, deliverable:{}, dissent:meta.dissent||[],
+            log:[], warning:meta.warning||'', compile:meta.compile||null, draft:'', finalDraft:'', files:meta.files||[], stepAt:now(), lastNudgeAt:0, attempts:{}, editorId:meta.editorId||'' }
+        }
+        const ev=await paperEvidence()
+        const body=await readText(dir+'/final.md')
+        if(body!==undefined&&body!=='') paperState.finalDraft=body
+        const composed=paperCompose(paperState,ev,cfg)
+        const wantMd=cfg.format!=='tex', wantTex=cfg.format!=='md'
+        const mdRaw=await readText(dir+'/paper.md'), texRaw=await readText(dir+'/paper.tex')
+        if(wantMd&&mdRaw===undefined){ if(await paperWriteRel(dir+'/paper.md',composed.md)) filled.push('paper.md') }
+        if(wantTex&&texRaw===undefined){ if(await paperWriteRel(dir+'/paper.tex',composed.tex)) filled.push('paper.tex') }
+        if(cfg.compilePdf&&wantTex&&!(await paperPdfExists(dir))){
+          const c=await paperCompile(paperState,composed,ev)
+          paperState.compile=c
+          if(c.result==='ok') filled.push('paper.pdf')
+        }
+        if(filled.length) await paperWriteMeta()
+        return filled
+      } finally { paperState=saved||null }
+    }
+    async function paperWriteMeta(){
+      const ps=paperState; if(!ps) return false
+      const meta={ id:ps.id, dir:ps.dir, generatedBy:'vibe-math-v4', preset:'v4', trigger:ps.trigger,
+        runId, closureSignal:PAPER_CLOSURE_SIGNAL, startedAt:ps.startedAt, finalizedAt:ps.finalizedAt||0,
+        params:{finalPaper:params.finalPaper,paperFormat:ps.cfg.format,paperLanguage:ps.cfg.language,paperCompilePdf:ps.cfg.compilePdf,paperEditor:ps.cfg.editor,paperLatexCommand:params.paperLatexCommand},
+        editor:ps.cfg.editor, editorId:ps.editorId||'', editorDowngraded:!!ps.editorDowngraded, participants:ps.participants, rounds:ps.round, maxRounds:ps.maxRounds,
+        fingerprint:ps.fingerprint||'', warning:ps.warning||'', files:ps.files||[], compile:ps.compile||null, mergeNotes:ps.mergeNotes||null,
+        parts:Object.keys(ps.parts).sort().map(k=>({id:k,chars:String((ps.parts[k]||{}).text||'').length,missing:!!(ps.parts[k]||{}).missing,source:(ps.parts[k]||{}).source||''})),
+        reviews:Object.keys(ps.reviews).sort().map(k=>({id:k,reviewed:(ps.reviews[k]||{}).reviewed||'',points:((ps.reviews[k]||{}).points||[]).length,improvements:(ps.reviews[k]||{}).improvements||'',missing:!!(ps.reviews[k]||{}).missing})),
+        deliverable:Object.keys(ps.deliverable).sort().map(k=>({id:k,deliverable:ps.deliverable[k]})),
+        dissent:ps.dissent||[] }
+      return await paperWriteRel(ps.dir+'/paper.meta.json',JSON.stringify(meta,null,2))
+    }
+    async function paperWriteLog(){
+      const ps=paperState; if(!ps) return false
+      const L=['# 最终论文过程记录（paper.log.md）','','- 论文 id：'+ps.id,'- 触发：'+ps.trigger,
+        '- 语言 / 格式 / 定稿代表：'+ps.cfg.language+' / '+ps.cfg.format+' / '+ps.cfg.editor,'- 参与成员：'+(ps.participants.join('、')||'（无常驻）'),
+        '- 状态：'+ps.status,'']
+      L.push('## 过程（谁写了什么）'); for(const l of ps.log) L.push('- '+l); L.push('')
+      L.push('## 归属与处理（谁提了什么意见、如何采纳）')
+      for(const rid of ps.participants){ const p=ps.parts[rid]
+        L.push('- 撰写：'+rid+(p?(p.missing?'（超时未提交）':'（'+String(p.text||'').length+' 字，来源 '+(p.source||'reply')+'）'):'（未提交）')) }
+      for(const rid of ps.participants){ const rv=ps.reviews[rid]
+        if(!rv||rv.missing){ L.push('- 互审：'+rid+'（'+(rv?'超时未提交，已记入附录':'未完成')+'）'); continue }
+        L.push('- 互审：'+rid+' → '+rv.reviewed+'，意见 '+((rv.points||[]).length)+' 条，处理：已采纳并记入合并稿审阅记录'+(rv.improvements?('（改进：'+String(rv.improvements).slice(0,200)+'）'):'')) }
+      L.push('- 定稿：'+(ps.editorId||ps.cfg.editor))
+      for(const rid of ps.participants) if(typeof ps.deliverable[rid]==='boolean') L.push('- 交付表态：'+rid+' = '+(ps.deliverable[rid]?'可交付':'不可交付'))
+      if(ps.compile) L.push('- 编译：'+JSON.stringify({result:ps.compile.result,engine:ps.compile.engine||'',repaired:ps.compile.repaired||'',attempts:(ps.compile.attempts||[]).length,error:ps.compile.error||''}))
+      if(ps.warning) L.push('- 警告：'+ps.warning)
+      return await paperWriteRel(ps.dir+'/paper.log.md',L.join('\n')+'\n')
+    }
+    async function paperFinalize(){
+      const ps=paperState
+      const ev=await paperEvidence()
+      ps.fingerprint=paperFingerprint(ev)
+      // final.md / draft.md must exist before composing so a re-run is reproducible
+      if(!ps.finalDraft) ps.finalDraft=paperFacilitatorFinal()
+      await paperWriteRel(ps.dir+'/final.md',ps.finalDraft)
+      const composed=paperCompose(ps,ev,ps.cfg)
+      ps.files=[]
+      if(ps.cfg.format!=='tex'){ if(await paperWriteRel(ps.dir+'/paper.md',composed.md)) ps.files.push('paper.md') }
+      if(ps.cfg.format!=='md'){ if(await paperWriteRel(ps.dir+'/paper.tex',composed.tex)) ps.files.push('paper.tex') }
+      ps.compile=await paperCompile(ps,composed,ev)
+      if(ps.compile&&ps.compile.result==='ok') ps.files.push('paper.pdf')
+      ps.finalizedAt=now(); ps.status='done'
+      await paperWriteMeta(); await paperWriteLog()
+      // v2 §A1: the paper phase was entered from INSIDE the closing branch, BEFORE the completion
+      // flags — so the run only becomes "done" here, once the paper exists (or has degraded safely).
+      if(ps.deferCompletion && autoDone!==true){
+        running=false; autoDone=true; phase='done'; clearHeartbeat()
+        wakeKind.clear(); meetingState=null; verifyState=null; pendingMeeting=null; pendingVerify=[]
+        logActivity('stop','all residents agree: problem solved（一致性停止票；最终论文已产出）')
+        await saveAll()
+      }
+      const warn=[ps.warning,ps.compile&&ps.compile.result==='failed'?ps.compile.error:''].filter(Boolean).join('；')
+      if(warn) logActivity('paper','最终论文完成（有警告）：'+ps.dir+'｜'+warn)
+      else logActivity('paper','最终论文完成：'+ps.dir+'（'+ps.files.join('、')+(ps.compile?('｜编译 '+(ps.compile.result||'')):'')+'）')
+      return {ok:true,id:ps.id,dir:ps.dir,files:ps.files,compile:ps.compile,rounds:ps.round,dissent:ps.dissent,warning:ps.warning}
+    }
+    function paperStatusView(){
+      const ps=paperState
+      return {
+        params:{finalPaper:params.finalPaper,paperFormat:params.paperFormat,paperLanguage:params.paperLanguage,paperCompilePdf:params.paperCompilePdf,paperEditor:params.paperEditor,paperLatexCommand:params.paperLatexCommand},
+        id:ps?ps.id:paperIdFor(), dir:ps?ps.dir:paperDirFor(), status:ps?ps.status:'idle',
+        running:!!(ps&&ps.status!=='done'&&ps.status!=='failed'), trigger:ps?ps.trigger:'',
+        rounds:ps?ps.round:0, maxRounds:ps?ps.maxRounds:PAPER_MAX_ROUNDS, participants:ps?ps.participants:[],
+        editor:ps?(ps.editorId||ps.cfg.editor):params.paperEditor, editorDowngraded:!!(ps&&ps.editorDowngraded),
+        parts:ps?Object.keys(ps.parts).length:0, reviews:ps?Object.keys(ps.reviews).length:0,
+        finalizedAt:ps?ps.finalizedAt:0, warning:ps?ps.warning:'', files:ps?(ps.files||[]):[], compile:ps?ps.compile:null,
+        closureSignal:PAPER_CLOSURE_SIGNAL,
+      }
+    }
+    function paperStatusSummary(){
+      const v=paperStatusView()
+      return {ok:true, id:v.id, dir:v.dir, status:v.status, running:v.running, trigger:v.trigger, lang:v.params.paperLanguage,
+        format:v.params.paperFormat, editor:v.editor, editorDowngraded:v.editorDowngraded, participants:v.participants,
+        parts:v.parts, reviews:v.reviews, rounds:v.rounds+'/'+v.maxRounds, finalizedAt:v.finalizedAt, files:v.files,
+        params:v.params,
+        compile:v.compile?{result:v.compile.result,engine:v.compile.engine||'',repaired:v.compile.repaired||''}:null,
+        warning:v.warning, closureSignal:v.closureSignal}
+    }
+    async function paperStart(trigger,opts){
+      const o=opts||{}
+      const force=!!o.force
+      const cfg=paperCfg(o)
+      const id=paperIdFor(), dir='Paper/'+id
+      if(paperState && paperState.id===id && paperState.status!=='done' && paperState.status!=='failed' && !force)
+        return {ok:true,id,dir,status:paperState.status,alreadyRunning:true,message:'最终论文正在进行（'+paperState.status+'）'}
+      if(paperState && paperState.id!==id && paperState.status!=='done' && paperState.status!=='failed' && !force)
+        return {ok:false,code:'V4_PAPER_BUSY',message:'另一篇论文正在进行（'+paperState.id+'），完成或 force 后再试'}
+      // Idempotency (docs/final-paper.md §C): the run id IS the directory, so a finalizedAt in THAT directory
+      // means this run already has its paper; only per-artifact existence is re-checked.
+      const meta=await readJson(dir+'/paper.meta.json')
+      if(!force && meta && meta.finalizedAt){
+        const filled=await paperEnsureArtifacts(meta,cfg)
+        return {ok:true,id,dir,idempotent:true,finalizedAt:meta.finalizedAt,filled,
+          message:'论文已定稿（幂等：只补写缺失产物'+(filled.length?('：'+filled.join('、')):'：无缺失')+'）'+(params.finalPaper===false?'（finalPaper=false：自动触发已关闭，本次为手动命令）':'')}
+      }
+      const prevDeliver={}
+      paperState={ id, dir, trigger, deferCompletion:!!o.deferCompletion, startedAt:now(), finalizedAt:0, status:'parts', round:0, maxRounds:PAPER_MAX_ROUNDS,
+        cfg, fingerprint:'', participants:Array.from(residents.keys()).sort(), parts:{}, reviews:{}, deliverable:prevDeliver,
+        dissent:[], log:[], warning:'', compile:null, draft:'', finalDraft:'', files:[], stepAt:now(), lastNudgeAt:0, attempts:{}, editorId:'', editorDowngraded:false }
+      paperLog('触发（'+trigger+'）：'+id+'｜收敛信号='+PAPER_CLOSURE_SIGNAL+'｜语言='+cfg.language+'｜格式='+cfg.format+'｜定稿='+cfg.editor+'｜参与='+(paperState.participants.join('、')||'（无常驻）'))
+      if(params.finalPaper===false) paperLog('注意：finalPaper=false —— 自动触发已关闭；本次为手动命令')
+      await paperWriteMeta(); await paperWriteLog()
+      if(!paperState.participants.length){
+        paperState.warning='本轮没有在场常驻：正文由框架（office 侧）从既有证据整理'
+        paperLog('警告：'+paperState.warning)
+        await paperMerge()   // -> paperFinalStep -> vote(no participants) -> finalize
+        return {ok:true,id,dir,status:paperState.status,message:'最终论文已启动（无常驻成员，由框架从既有证据整理）'+(params.finalPaper===false?'（finalPaper=false：自动触发已关闭）':'')}
+      }
+      await paperWakeSome(paperState.participants.slice(),'part')
+      await paperAdvance('parts-started')
+      return {ok:true,id,dir,status:paperState.status,participants:paperState.participants,files:paperState.files,
+        message:'最终论文已启动（'+trigger+'）'+(params.finalPaper===false?'（finalPaper=false：自动触发已关闭）':'')}
+    }
+    async function runPaperCommand(ov,force){
+      const known=['lang','format','editor']
+      for(const k of Object.keys(ov||{})) if(known.indexOf(k)===-1) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'未知选项 '+k+'（支持 lang=zh|en / format=md|tex|both / editor=office|resident:<id> / force）'}
+      if(ov&&ov.lang&&PAPER_LANGS.indexOf(String(ov.lang))===-1) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'paperLanguage 只能是 zh|en'}
+      if(ov&&ov.format&&PAPER_FORMATS.indexOf(String(ov.format))===-1) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'paperFormat 只能是 both|md|tex'}
+      if(ov&&ov.editor&&!paperEditorOk(ov.editor)) return {ok:false,code:'V4_INVALID_ARGUMENT',message:'paperEditor 只能是 office 或 resident:<id>'}
+      return await paperStart('manual',{force:!!force,lang:ov&&ov.lang,format:ov&&ov.format,editor:ov&&ov.editor})
+    }
+    /** A paper wake's reply. `kind` is read from wakeKind (set by wakeResident, not cleared here). */
+    async function onPaperWakeEnd(r,parsed){
+      const ps=paperState; if(!ps) return
+      const kind=String(wakeKind.get(r.rId)||'')
+      // A paper contribution may arrive as a plain string or as `{markdown:"…"}` — anything else is
+      // NOT accepted (a stray object must never become "[object Object]" in the final draft).
+      const pick=v=>{ if(typeof v==='string') return v; if(v&&typeof v==='object'&&typeof v.markdown==='string') return v.markdown; return '' }
+      if(kind===PAPER_KINDS.part){
+        let text=pick(parsed&&parsed.paperPart).trim()
+        if(!text) text=String((await readText(ps.dir+'/parts/'+r.rId+'.md'))||'').trim()
+        if(text){ ps.parts[r.rId]={text,at:now(),source:'reply'}; await paperWriteRel(ps.dir+'/parts/'+r.rId+'.md',text)
+          paperLog(r.rId+' 提交了自己负责的部分（'+text.length+' 字）') }
+        else paperLog('警告：'+r.rId+' 的部分为空（将按超时/重试处理）')
+      } else if(kind===PAPER_KINDS.review){
+        const rv=(parsed&&parsed.paperReview&&typeof parsed.paperReview==='object')?parsed.paperReview:{}
+        const reviewed=String(rv.reviewed||'')
+        const others=ps.participants.filter(x=>x!==r.rId)
+        if(others.indexOf(reviewed)===-1){
+          paperLog('拒绝 '+r.rId+' 的互审：未指名其他参与者（reviewed='+JSON.stringify(rv.reviewed===undefined?null:rv.reviewed)+'）——必须审阅至少一位他人')
+        } else {
+          const points=Array.isArray(rv.points)?rv.points.map(String).filter(Boolean):[]
+          ps.reviews[r.rId]={reviewed,points,improvements:String(rv.improvements||''),at:now(),accepted:true}
+          paperLog(r.rId+' 审阅了 '+reviewed+' 的部分：'+points.length+' 条意见'+(rv.improvements?'，并给出改进建议':'') )
+          await paperWriteRel(ps.dir+'/reviews/'+r.rId+'.md',['# 互审记录｜'+r.rId,'','- 审阅对象：'+reviewed,'- 意见：','',
+            ...points.map(p=>'- '+p),'','## 改进建议','',String(rv.improvements||'（无）')].join('\n')+'\n')
+        }
+      } else if(kind===PAPER_KINDS.final){
+        let text=pick(parsed&&parsed.paperFinal).trim()
+        if(!text) text=String((await readText(ps.dir+'/final.md'))||'').trim()
+        if(text&&!/^#\s*互审记录/.test(text)){ ps.finalDraft=text; await paperWriteRel(ps.dir+'/final.md',text); paperLog('定稿代表 '+(ps.editorId||ps.cfg.editor)+' 提交了最终稿（'+text.length+' 字）') }
+        else paperLog('警告：定稿代表返回空稿，改由框架（office）定稿')
+      } else if(kind===PAPER_KINDS.vote||kind===PAPER_KINDS.revise){
+        const d=parsed?parsed.paperDeliverable:undefined
+        if(typeof d!=='boolean'){ paperLog('警告：'+r.rId+' 未明确表态"可交付/不可交付"（将按未表态处理）'); }
+        else { ps.deliverable[r.rId]=d
+          paperLog(r.rId+(d?' 表示：可交付':' 表示：不可交付')+(parsed&&parsed.reason?('｜理由：'+String(parsed.reason).slice(0,160)):'')) }
+      }
+      await paperWriteLog()
+      await paperAdvance('resident-end:'+kind)
+    }
+
     // ---- controls ----
     async function start({problem,residentCount,seedDirections}){
       await loadSettings()
@@ -2068,7 +3466,16 @@ export function apply(ctx) {
       // A fresh run starts with a clean formal slate: the ids r-1.. and p-* are reused, so
       // carrying a previous run's records over would let a stale `passed` open the new gate.
       formal={}; formalTodos=[]
+      // §2.6 recovery (fresh-run variant): a dead process may have left `Formal/Jobs/*.json` behind.
+      // A FRESH run must not adopt the previous run's SETTLED outcomes (that is what the clean slate
+      // above exists to prevent), so only the safe half of the table runs: `queued` jobs are
+      // re-driven and `running` jobs are marked/re-queued — never a `passed` from a stale record.
+      await recoverLeanJobs({mode:'start',applySettled:false})
+      // Warm the math_computation availability cache so the FIRST resident prompt already carries
+      // the line (the probe is cached per registered instance, so later refreshes cost nothing).
+      await refreshMathAvailability()
       busy=new Set(); wakeKind=new Map(); currentResident=''; pendingMeeting=null; lastSyncMeetingAt=0; finalizeLock=null; verifiedRecently.clear()   // fresh run must NOT inherit stale concurrency/coordination state (busy/wakeKind/currentResident/pendingMeeting) from a previous run on the same reused session
+      paperState=null   // a fresh run gets a fresh paper flow (its durable record lives in Paper/<run id>/)
       // Re-base the artifact counter on the cards already on disk, so the auto-sync meeting counts
       // artifacts written by THIS run (the project tree may already hold cards from an earlier run).
       artifactBaseline=null; artifactCount=0; await syncArtifactCount()
@@ -2099,6 +3506,10 @@ export function apply(ctx) {
       const pre=await readJson('State/session.json')
       if(running && !autoDone && pre && pre.processEpoch===processEpoch) return {ok:true,message:'already running (no-op)'}
       await loadAll(); await loadSettings()
+      // §2.6 recovery runs AFTER loadAll (the formal records it may complete/annotate are restored
+      // there — recovering earlier would write onto an unloaded `formal` and clobber them).
+      await recoverLeanJobs({mode:'resume',applySettled:true})
+      await refreshMathAvailability()   // same reason as start(): the next wake must carry the line
       // A run the group CONCLUDED (unanimous voteSolved → autoDone) must not be silently revived into
       // a zombie that keeps waking residents with no consensus that it should still run. The group
       // decided it is done; continuing means a NEW run (vibe_v4_start / vibe_v4_configure).
@@ -2156,13 +3567,14 @@ export function apply(ctx) {
       consensus: meetingState?{kind:'meeting',id:meetingState.id,agenda:meetingState.agenda,round:meetingState.round,spoke:Object.keys(meetingState.inputs).length,expected:residents.size,solvedVotes:Object.values(meetingState.inputs).filter(iv=>iv.voteSolved===true).length}
         :(verifyState?{kind:'verify',target:verifyState.targetId,targetType:verifyState.targetType,stage:verifyState.stage,round:verifyState.round,voted:Object.keys(verifyState.verdicts).length,expected:residents.size}:null),
       artifactCount: artifactCount, artifactBaseline: artifactBaseline,
+      paper: paperStatusSummary(),
       // The Lean knobs and the per-object formal records are part of the readable status: without
       // them a `require`-mode run that keeps returning 未定论 would be undiagnosable from outside.
       formal: formalView(),
       // The parameter NAMES (not just the rendered string) so a caller — the `/v4 set` handler in
       // particular — can reject an unknown key instead of silently dropping it.
       paramsKeys: Object.keys(params),
-      params:['residentCount','compactAfterRounds','compactThreshold','maxParallel','activityTimeoutMs','meetingKeepEvery','verdictMaxRounds','stallAutoMeetingMs','provider','model','residentPersona','toolAllow','toolDeny','formalVerify','leanCommand','leanArgs','leanTimeoutMs'].map(k=>k+'='+(Array.isArray(params[k])?params[k].join(','):params[k])).join(', ') } }
+      params:['residentCount','compactAfterRounds','compactThreshold','maxParallel','activityTimeoutMs','meetingKeepEvery','verdictMaxRounds','stallAutoMeetingMs','provider','model','residentPersona','toolAllow','toolDeny','formalVerify','leanCommand','leanArgs','leanTimeoutMs','finalPaper','paperFormat','paperLanguage','paperCompilePdf','paperEditor','paperLatexCommand','leanAsync','leanInitiative','leanSearchPaths','leanJobsMaxParallel'].concat(MATH_PARAM_NAMES).map(k=>k+'='+(Array.isArray(params[k])?params[k].join(','):params[k])).join(', ') } }
     function formalReportText(){
       if(!formalOn()) return '- 未启用（`formalVerify` = off；可用 vibe_v4_set 切到 encourage / require）'
       const v=formalView()
@@ -2179,6 +3591,7 @@ export function apply(ctx) {
       pendingVerify: pendingVerify.length?pendingVerify[0].targetId:null,
       parkedMeeting: pendingMeeting?pendingMeeting.agenda:null,
       formal: formalView(),
+      paper: paperStatusSummary(),
       meetings:meetings.length, recentActivity: activityLog.slice(-8) } }
     /** Human-readable mirror of the formal state (kept OUT of the JSON report shape). */
     function formalReport(){ return {ok:true, formalMode:formalMode(), formalReport:'## Lean 形式化\n'+formalReportText(), formal:formalView()} }
@@ -2218,14 +3631,54 @@ export function apply(ctx) {
     // Normalize one parameter value to its intended type so a string from /v4 set or configure
     // becomes the right number/array. Keeps settings.json clean regardless of how it was set.
     function normalizeParam(k, v){
-      const INT_KEYS=['residentCount','compactThreshold','compactAfterRounds','maxParallel','activityTimeoutMs','verdictMaxRounds','meetingKeepEvery','stallAutoMeetingMs']
+      const INT_KEYS=['residentCount','compactThreshold','compactAfterRounds','maxParallel','activityTimeoutMs','verdictMaxRounds','meetingKeepEvery','stallAutoMeetingMs','leanJobsMaxParallel']
       if(INT_KEYS.includes(k)){ const n=Number(v); if(!Number.isFinite(n)) return v; return Math.floor(n) }
-      if(k==='toolAllow'||k==='toolDeny'||k==='leanArgs'){ if(Array.isArray(v)) return v.map(x=>String(x).trim()).filter(Boolean); if(typeof v==='string') return v.split(',').map(x=>x.trim()).filter(Boolean); return [] }
+      if(k==='toolAllow'||k==='toolDeny'||k==='leanArgs'||k==='leanSearchPaths'){ if(Array.isArray(v)) return v.map(x=>String(x).trim()).filter(Boolean); if(typeof v==='string') return v.split(',').map(x=>x.trim()).filter(Boolean); return [] }
       // ---- Lean formal verification (docs §1) ------------------------------------------
       // `formalVerify` is a three-way enum and MUST degrade to the no-op 'off' on anything else.
       // Degrading to a STRONGER mode would let a typo silently gate every conclusion — the exact
       // failure mode `require` is supposed to avoid.
       if(k==='formalVerify') return FORMAL_MODES.indexOf(String(v))!==-1?String(v):'off'
+      // ---- final paper (docs/final-paper.md §B): booleans and enums are coerced HERE, because `/v4 set` hands
+      // the parameter layer RAW STRINGS ('false' must become false, not stay truthy) and an unknown
+      // value must fall back to the default instead of silently keeping a bogus strong setting. ----
+      if(k==='finalPaper'||k==='paperCompilePdf'){
+        if(typeof v==='boolean') return v
+        const s=String(v==null?'':v).trim().toLowerCase()
+        if(s==='true'||s==='1'||s==='yes'||s==='on') return true
+        if(s==='false'||s==='0'||s==='no'||s==='off') return false
+        return DEFAULT_PARAMS[k]
+      }
+      if(k==='paperFormat') return PAPER_FORMATS.indexOf(String(v))!==-1?String(v):DEFAULT_PARAMS.paperFormat
+      if(k==='paperLanguage') return PAPER_LANGS.indexOf(String(v))!==-1?String(v):DEFAULT_PARAMS.paperLanguage
+      // v2 §A5: `office` (the session root / human side) by default, or `resident:<id>`.
+      if(k==='paperEditor'){ const s=String(v==null?'':v).trim(); return paperEditorOk(s)?s:DEFAULT_PARAMS.paperEditor }
+      if(k==='paperLatexCommand'){ const s=String(v==null?'':v).trim(); return s }
+      // math_computation P1: the six keys go through the SHARED normalizer (explicit
+      // enum/array/integer coercion there), so `'false'`-style strings and unknown enum values can
+      // never leak into `params` — v4's function returns unknown keys AS-IS, which is why an
+      // explicit branch is mandatory. The two array keys additionally accept the comma-string form
+      // that `/v4 set` produces (v4's own style for `leanArgs`), then the module is authoritative.
+      if(MATH_PARAM_NAMES.indexOf(k)!==-1){
+        let val=v
+        if((k==='mathEngines'||k==='mathPackages')&&typeof val==='string') val=val.split(',').map(x=>x.trim()).filter(Boolean)
+        const one=normalizeMathParams({[k]:val})
+        if(Object.prototype.hasOwnProperty.call(one,k)) return one[k]
+        const def=DEFAULT_PARAMS[k]
+        return Array.isArray(def)?def.slice():def
+      }
+      // lean-incremental-async §1.1: an EXPLICIT branch — the string 'false' (what `/v4 set` hands us)
+      // must normalise to boolean false, never survive as a truthy string.
+      if(k==='leanAsync'){
+        if(typeof v==='boolean') return v
+        const s=String(v==null?'':v).trim().toLowerCase()
+        if(s==='true'||s==='1'||s==='yes'||s==='on') return true
+        if(s==='false'||s==='0'||s==='no'||s==='off') return false
+        return DEFAULT_PARAMS.leanAsync
+      }
+      // AMENDMENT §1: three-way PROACTIVITY enum — anything unknown degrades to the default
+      // ('normal'), never to a stronger setting.
+      if(k==='leanInitiative') return ['off','normal','eager'].indexOf(String(v))!==-1?String(v):DEFAULT_PARAMS.leanInitiative
       // A blank command would make resolveExecutable('') fail confusingly; fall back to the default.
       if(k==='leanCommand'){ const s=String(v==null?'':v).trim(); return s||'lean' }
       // A non-positive timeout is meaningless (the run would be killed instantly) → default.
@@ -2243,7 +3696,7 @@ export function apply(ctx) {
      * 注意**不要**给 activityTimeoutMs / compactThreshold 之类加下界：文档明确建议测试时把
      * activityTimeoutMs 设成 40ms 这种小值，钳制它会破坏受支持的配置。
      */
-    const INT_MIN = { maxParallel: 1, residentCount: 1 }
+    const INT_MIN = { maxParallel: 1, residentCount: 1, leanJobsMaxParallel: 1 }
     function clampInt(k, n){
       const min = INT_MIN[k]
       if(min===undefined) return n
@@ -2263,6 +3716,9 @@ export function apply(ctx) {
       const has = (o,k)=>Object.prototype.hasOwnProperty.call(o,k)
       const ignored=keys.filter(k=>!has(params,k))
       for(const k of keys){ if(has(params,k)){ const nv=normalizeParam(k, upd[k]); params[k]= (typeof nv==='number') ? clampInt(k, nv) : nv } }
+      // A math parameter changes what the NEXT prompt must say (the availability line encodes the
+      // enabled engines and the mode), so refresh it here — the probe is cached, so this is cheap.
+      if(keys.some(k=>MATH_PARAM_NAMES.indexOf(k)!==-1)) refreshMathAvailability().catch(()=>{})
       saveSettings().catch(()=>{})
       if(ignored.length){
         logActivity('set','忽略未知参数：'+ignored.join(', '))
@@ -2297,6 +3753,8 @@ export function apply(ctx) {
       // can ever clear those marks). resume()/start() re-initialize anyway; this keeps status truthful
       // between abort and the next action.
       meetingState=null; verifyState=null; pendingMeeting=null; pendingVerify=[]; busy=new Set(); wakeKind=new Map(); currentResident=''; finalizeLock=null
+      paperState=null   // an aborted run is over: its paper flow (if any) must not keep driving wakes
+      await disposeLean()   // §2.5: abort terminates the in-flight compile and marks it interrupted
       await saveAll(); return {ok:true,message:'aborted'} }
     function setPause(){ clearHeartbeat(); running=false; return {ok:true,message:'paused'} }
 
@@ -2308,6 +3766,9 @@ export function apply(ctx) {
       rememberAgent, forgetAgent,
       setPause, initAbort, postMessage, startMeeting, saveAll, broadcast, configure, loadSettings,
       currentResident:()=>currentResident,
+      // Final paper (docs/final-paper.md): the session API used by the `/v4 paper` command and by
+      // the suites. `paperStatus` is the same view `status()`/`report()` expose.
+      runPaperCommand, paperStatus:()=>paperStatusSummary(),
       /** Does this session own the given child id? (used by the `subagent/start` capture) */
       ownsChild,
       /** Stash a live Agent seen at `subagent/start` time; claimed by `spawnResident` on resolve. */
@@ -2341,6 +3802,17 @@ export function apply(ctx) {
       formalMode, formalOn, formalRecords, formalTodo, formalOf, formalView, formalReport,
       rebuildLeanLibIndexes, leanArchive, leanRunTool, writeFormalIndex, writeFormalTodo,
       leanRunToolApi: async (relPath,timeoutMs)=>await leanRunFile(relPath,timeoutMs),
+      // lean-incremental-async §6.3: the queue is reachable from the suite/dispatcher exactly like
+      // `leanRunToolApi`, so the async paths can be driven deterministically (no timer races).
+      leanQueueApi:{ enqueue:enqueueLeanJob, runQueue:runLeanQueue, state:()=>({running:leanInflight.map(leanJobView),queued:leanQueue.slice(),jobs:listLeanJobs(),notices:leanNotices.slice(),cap:Math.max(1,Math.floor(Number(params.leanJobsMaxParallel))||1)}), dispose:disposeLean, recover:recoverLeanJobs, job:leanJobTool },
+      leanRead, listLeanJobs, leanJobs:()=>Object.assign({},leanJobs), leanJobTool,
+      /** math_computation host surface — the SAME object the per-session module instance is keyed
+       *  by (`mathInstanceFor`), so the tool path and the prompt-side probe share one instance per
+       *  session (and one probe cache), and no state is shared across sessions. These accessors read
+       *  LIVE state (never a snapshot — `/v4 set mathMode=typed` must change the very next call). */
+      mathHost: mathProbeHost,
+      /** Absolute paths the Lean layer uses (read-only display; `searchPaths` are injected per spawn). */
+      leanPaths:()=>({searchPath:vibeRoot().replace(/\\/g,'/'),searchPaths:leanSearchPathList(),lib:formalLibRoot().replace(/\\/g,'/'),proved:formalProvedRoot().replace(/\\/g,'/'),jobs:leanJobsRel()}),
       /**
        * The prompt builders, addressed BY RESIDENT ID. "成员读到的文字就是产品"
        * (AUDIT-CHECKLIST §0.1): a suite that can only observe tool return values is blind to a
@@ -2431,7 +3903,7 @@ export function apply(ctx) {
   // MODE is dynamic — switching it changes the very next prompt), leanCommand/leanArgs select the
   // executable, leanTimeoutMs bounds one run. Invalid values fall back to the defaults and an
   // unknown mode degrades to 'off' (never to a STRONGER mode).
-  registerTool('vibe_v4_set','Set V4 parameters: residentCount (how many residents a start spawns), compactThreshold (resident context % that triggers a compaction) and compactAfterRounds (rounds between soft compactions), meetingKeepEvery (every N newly accumulated artifacts an automatic sync meeting is convened), maxParallel (how many residents may be woken concurrently), activityTimeoutMs (idle window before a resident is nudged; also the heartbeat/watchdog period), stallAutoMeetingMs (how long the group may make NO progress before an auto sync meeting is convened), verdictMaxRounds (how many verification rounds one object gets: 1 independent round + re-vote debate rounds), model/provider override resident LLM route (empty=inherit main); toolAllow/toolDeny restrict resident tools (arrays of tool names); residentPersona adds a persona line; formalVerify: "off" (default, a true no-op) | "encourage" (residents decide by implementation difficulty whether to formalize in Lean; a passing Lean run turns the vote into a FIDELITY review of the Lean statements) | "require" (same, plus a gate: a unanimous true/false verdict is withheld as undecided until the object is Lean-passed or has an explicit reasoned blocker record); leanCommand/leanArgs/leanTimeoutMs configure the toolchain. A key outside this list is refused (ok:false, ignored:[...]) instead of being silently dropped.',objParams({residentCount:{type:'integer'},compactAfterRounds:{type:'integer'},compactThreshold:{type:'integer'},meetingKeepEvery:{type:'integer'},maxParallel:{type:'integer'},activityTimeoutMs:{type:'integer'},verdictMaxRounds:{type:'integer'},stallAutoMeetingMs:{type:'integer'},provider:{type:'string'},model:{type:'string'},residentPersona:{type:'string'},toolAllow:{type:'array',items:{type:'string'}},toolDeny:{type:'array',items:{type:'string'}},formalVerify:{type:'string',enum:['off','encourage','require']},leanCommand:{type:'string'},leanArgs:{type:'array',items:{type:'string'}},leanTimeoutMs:{type:'integer'}}),(s,a)=>{ const r=s.setParams(a); const st=s.status(); if(r&&r.ok===false) return Object.assign({},st,{ok:false,warning:r.message,ignored:r.ignored}); return st })
+  registerTool('vibe_v4_set','Set V4 parameters: residentCount (how many residents a start spawns), compactThreshold (resident context % that triggers a compaction) and compactAfterRounds (rounds between soft compactions), meetingKeepEvery (every N newly accumulated artifacts an automatic sync meeting is convened), maxParallel (how many residents may be woken concurrently), activityTimeoutMs (idle window before a resident is nudged; also the heartbeat/watchdog period), stallAutoMeetingMs (how long the group may make NO progress before an auto sync meeting is convened), verdictMaxRounds (how many verification rounds one object gets: 1 independent round + re-vote debate rounds), model/provider override resident LLM route (empty=inherit main); toolAllow/toolDeny restrict resident tools (arrays of tool names); residentPersona adds a persona line; formalVerify: "off" (default, a true no-op) | "encourage" (residents decide by implementation difficulty whether to formalize in Lean; a passing Lean run turns the vote into a FIDELITY review of the Lean statements) | "require" (same, plus a gate: a unanimous true/false verdict is withheld as undecided until the object is Lean-passed or has an explicit reasoned blocker record); leanCommand/leanArgs/leanTimeoutMs configure the toolchain; leanAsync (default true) ENQUEUES each compile to a per-session background queue (concurrency 1, budget = leanTimeoutMs) and returns immediately with async:{jobId,state:\'queued\'} — results are announced in the next prompt and visible in vibe_v4_lean_lib.jobs; set leanAsync=false for the historical synchronous await; leanInitiative: "off" | "normal" (default) | "eager" is how PROACTIVE the group should be while working (it never changes what formalVerify requires at voting time); leanSearchPaths (array, default empty) adds extra compiler search roots — they are injected BEFORE the automatic VibeMath root, de-duplicated, and an explicit --search-path/-R/--root in leanArgs still wins; leanJobsMaxParallel (default 1) caps how many background compiles run at once; mathComputation: "auto" (default) | "on" | "off" enables the math_computation tool (off = a true no-op: no probe and no prompt line), mathMode: "typed+shell" (default) | "typed" drops the host-shell fallback and refuses the cli engine, mathEngines limits which engines may run (default python|r|octave|julia|matlab|maple|wolfram|cli), mathTimeoutMs bounds one computation, mathPackages is the pre-checked package list, mathInstallScope: "user" (default) | "system" is the scope an approved install plan may use (system applies to that request only and is never remembered); finalPaper (default true) writes the run\'s final PAPER automatically once the closing meeting votes unanimously to stop, paperFormat: "both" (default) | "md" | "tex" decides which text versions are produced, paperLanguage: "zh" (default) | "en", paperCompilePdf (default true) compiles a PDF when a LaTeX engine is actually detected (xelatex|latexmk|pdflatex|lualatex|tectonic, overridable via paperLatexCommand), paperEditor: "office" (default — the session root/human side) | "resident:<id>" names who finalises the merged draft after the cross-review round. A key outside this list is refused (ok:false, ignored:[...]) instead of being silently dropped.',objParams({residentCount:{type:'integer'},compactAfterRounds:{type:'integer'},compactThreshold:{type:'integer'},meetingKeepEvery:{type:'integer'},maxParallel:{type:'integer'},activityTimeoutMs:{type:'integer'},verdictMaxRounds:{type:'integer'},stallAutoMeetingMs:{type:'integer'},provider:{type:'string'},model:{type:'string'},residentPersona:{type:'string'},toolAllow:{type:'array',items:{type:'string'}},toolDeny:{type:'array',items:{type:'string'}},formalVerify:{type:'string',enum:['off','encourage','require']},leanCommand:{type:'string'},leanArgs:{type:'array',items:{type:'string'}},leanTimeoutMs:{type:'integer'},finalPaper:{type:'boolean'},paperFormat:{type:'string',enum:['both','md','tex']},paperLanguage:{type:'string',enum:['zh','en']},paperCompilePdf:{type:'boolean'},paperEditor:{type:'string'},paperLatexCommand:{type:'string'},leanAsync:{type:'boolean'},leanInitiative:{type:'string',enum:['off','normal','eager']},leanSearchPaths:{type:'array',items:{type:'string'}},leanJobsMaxParallel:{type:'integer'},mathComputation:{type:'string',enum:['auto','on','off']},mathMode:{type:'string',enum:['typed+shell','typed']},mathEngines:{type:'array',items:{type:'string'}},mathTimeoutMs:{type:'integer'},mathPackages:{type:'array',items:{type:'string'}},mathInstallScope:{type:'string',enum:['user','system']}}),(s,a)=>{ const r=s.setParams(a); const st=s.status(); if(r&&r.ok===false) return Object.assign({},st,{ok:false,warning:r.message,ignored:r.ignored}); return st })
   // resident-facing tools: route to the CALLING resident (exec.agent.id === childId);
   // fall back to the last-woken resident when called by the host/assistant.
   registerTool('vibe_v4_send_message','(resident) Send a message to another resident (to=all broadcasts to the whole team).',objParams({to:{type:'string'},content:{type:'string'}},['to','content']),(s,a,x)=>{ const from=s.residentIdOf(x); if(!from) return {ok:false,message:'no such resident'}; if(String(a.to)==='all') return s.broadcast(a.content, from); return s.postMessage(from,a.to,a.content) })
@@ -2466,19 +3938,94 @@ export function apply(ctx) {
   // if a human or an agent calls them deliberately, but no prompt mentions them.
   registerTool('vibe_v4_lean_run','(resident) Execute the Lean toolchain on one .lean file inside the workspace and report the result. Never throws: a missing toolchain returns LEAN_NOT_FOUND, a non-zero exit returns the compiler output verbatim, a timeout returns LEAN_TIMEOUT. Pass target=<object id> to also record the run against that object.',objParams({file:{type:'string'},target:{type:'string'},timeout_ms:{type:'integer'}},['file']),(s,a,x)=>s.leanRunTool(s.residentIdOf(x),a))
   registerTool('vibe_v4_lean_archive',"(resident) 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']),(s,a,x)=>s.leanArchive(s.residentIdOf(x),a))
-  registerTool('vibe_v4_lean_lib','(resident) 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 (s,a)=>{
+  registerTool('vibe_v4_lean_lib','(resident) 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. The `paths.searchPath` field is the module root the framework injects into the compiler, and `jobs` shows the state of every background compile (leanAsync).',objParams({refresh:{type:'boolean'}}),async (s,a)=>{
     const r=(a&&a.refresh===false)?{lib:null,proved:null,objects:Object.keys(s.formalRecords()).length}:await s.rebuildLeanLibIndexes()
     return { ok:true, mode:s.formalMode(), rebuilt:!(a&&a.refresh===false), counts:r, todo:s.formalTodo(),
       objects:s.formalView().objects,
-      paths:{project:'Formal/（相对项目根）',lib:'VibeMath/Formal/Lib/',proved:'VibeMath/Formal/Proved/',proofs:'Verified/Lean/'},
-      hint:"复用优先：先在 Lib/ 里找现成定义；新定义用 vibe_v4_lean_archive kind='def' 归档，已证引理用 kind='lemma'。" }
+      paths:{project:'Formal/（相对项目根）',lib:'VibeMath/Formal/Lib/',proved:'VibeMath/Formal/Proved/',proofs:'Verified/Lean/',searchPath:s.leanPaths().searchPath,searchPaths:s.leanPaths().searchPaths},
+      searchPath:s.leanPaths().searchPath,
+      importNamespace:{lib:'import Formal.Lib.<name>',proved:'import Formal.Proved.<name>'},
+      jobs:s.listLeanJobs(),
+      hint:"复用优先：先在 Lib/ 里找现成定义（vibe_v4_lean_read 可取原文逐字复制）；新定义用 vibe_v4_lean_archive kind='def' 归档，已证引理用 kind='lemma'；后台编译进度看 jobs。" }
   })
+  // lean-incremental-async §1.2: the ONLY new (read-only) tool. Reading an archived definition or
+  // lemma VERBATIM is how a member reuses it without re-deriving it — or copies it when the local
+  // toolchain cannot follow the import.
+  registerTool('vibe_v4_lean_read','(resident, read-only) Read ONE archived Lean library file verbatim (for import-or-copy reuse). name is a bare library name (no path); kind is auto|lib|proved. Refuses anything outside <VibeMath>/Formal/{Lib,Proved}, and truncates at 64KB (truncated:true).',objParams({name:{type:'string'},kind:{type:'string',enum:['auto','lib','proved']}},['name']),(s,a)=>s.leanRead(a))
+  // AMENDMENT §3: the read-only job/result surface (no polling tool beyond this one).
+  registerTool('vibe_v4_lean_job','(resident, read-only) Background-compile jobs. Without jobId: this session\'s job list (state/receipt/archive). With jobId: that job\'s state, exitCode, receipt path (Formal/Jobs/<jobId>.json) and archive path; waitMs>0 waits up to that many milliseconds and then reports the current state (it never blocks forever).',objParams({jobId:{type:'string'},waitMs:{type:'integer'}}),(s,a)=>s.leanJobTool(a))
+
+  // §2.5: the fiber's disposer must not leave an orphan compiler behind. Every session's in-flight
+  // Lean job is terminated (and marked `interrupted`, never `passed`) when this preset subtree
+  // unloads — the same lifecycle the tool/command registrations above already follow.
+  ctx.effect(() => () => { for(const s of sessions.values()){ try { s.disposeLean() } catch(e){ /* best effort */ } } })
+
+  //  (3) Per-session module instances: LAZY, cached by the session's host object. Each instance has
+  //      its own adapted host (and therefore its own probe cache), so no state is shared between
+  //      sessions — there is no "current session" slot to clobber, and concurrent calls from two
+  //      sessions are fully independent (v5 uses the same structure).
+  const mathInstances = new WeakMap()   // session host object -> module instance
+  function mathInstanceFor(hostObj){
+    if(!hostObj) return null
+    const cached=mathInstances.get(hostObj)
+    if(cached) return cached
+    const inst=registerMathComputation({
+      // Capture-only: the tool face was registered ONCE for the plugin instance (step 1/2 above).
+      register: ()=>{},
+      params: ()=>hostObj.params(),
+      projectRoot: ()=>hostObj.projectRoot(),
+      designator: 'vibe-math-v4',
+      writeText: (rel, text)=>hostObj.writeText(rel, text),
+      readText: (rel)=>hostObj.readText(rel),
+      exists: (rel)=>hostObj.exists(rel),
+      // audit-R2 lens-2: attached ONLY when the session surface really has it, so a surface without
+      // listDir reaches the module as an ABSENT field (the module's optional-callback contract).
+      ...(typeof hostObj.listDir === 'function' ? { listDir: (rel)=>hostObj.listDir(rel) } : {}),
+      resolveExecutable: (cmd)=>hostObj.resolveExecutable(cmd),
+      spawn: (o)=>hostObj.spawn(o),
+      // Optional capability flag: a host that KNOWS it has no subprocess service reports
+      // MATH_NO_SUBPROCESS up front instead of a misleading ENGINE_NOT_FOUND + install guide.
+      hasSubprocess: ()=>!!subprocessOf(),
+      log: (kind, msg)=>hostObj.log(kind, msg),
+    })
+    mathInstances.set(hostObj, inst)
+    return inst
+  }
+  function mathHandlerFor(session){
+    const inst=mathInstanceFor(session&&session.mathHost)
+    return inst?inst.handler:async()=>({ok:false,code:'MATH_INVALID_ARGUMENT',message:'math_computation: no session'})
+  }
+
+  // ================= math_computation registration (P1) =================
+  // The tool CORE is the shared module (installed byte-identically in all four presets).
+  //  (1) A throwaway CAPTURE-ONLY host yields the frozen tool face once: the module owns the name,
+  //      description and closed schema, and this preset must advertise exactly those.
+  registerMathComputation({
+    register: (name, description, parameters, handler)=>{
+      // The description/schema must be the module's frozen text (a local re-spelling would silently
+      // diverge from the other three presets); referencing MATH_TOOL_DESCRIPTION is that check.
+      if(description!==MATH_TOOL_DESCRIPTION) ctx.logger.warn('math_computation: 工具描述与共享模块的 MATH_TOOL_DESCRIPTION 不一致')
+      mathToolFace={name, description, parameters, handler}
+    },
+    params: ()=>DEFAULT_PARAMS,
+    projectRoot: ()=>'',
+    writeText: async()=>false,
+    readText: async()=>undefined,
+    exists: async()=>false,
+    resolveExecutable: async()=>{ throw new Error('NO_SUBPROCESS: capture-only host') },
+    spawn: async()=>null,
+    designator: 'vibe-math-v4',
+    log: ()=>{},
+  })
+  //  (2) ONE tool registration for the whole plugin instance; the handler resolves the CALLING
+  //      session's own module instance.
+  registerTool(mathToolFace.name, mathToolFace.description, mathToolFace.parameters, (s,a)=>mathHandlerFor(s)(a||{}))
 
   // Same lifecycle rule as registerTool: commands.register() returns a disposer, so the
   // registration belongs to this fiber and must be unwound with it.
   ctx.effect(() => commands.register({
     name:'v4', description:'control the Vibe Math V4 framework',
-    input:{hint:'[configure|start|resume|pause|abort|status|report|message <to|all> <content>|meeting|members|add|remove|set]'},
+    input:{hint:'[configure|start|resume|pause|abort|status|report|message <to|all> <content>|meeting|paper [lang=zh|en] [format=md|tex|both] [editor=office|resident:<id>] [force]|members|add|remove|set]'},
     handler: async function(inv){
       const s=getSession(inv&&inv.agent); if(!s) return {kind:'success',text:JSON.stringify({ok:false,error:'no session'})}
       const line=String(inv&&inv.rawInput?inv.rawInput:'').trim(); const parts=line.split(/\s+/); const cmd=parts[0]||''; const rest=parts.slice(1)
@@ -2519,7 +4066,15 @@ export function apply(ctx) {
           r=(res&&res.ok===false)?Object.assign({},st,{ok:false,warning:res.message,ignored:res.ignored}):Object.assign({},st,{applied:res.applied})
         }
       }
-      else r={ok:false,usage:'configure|start [problem]|resume|pause|abort|status|report|message <to|all> <content>|meeting|members|add|remove|set <k=v>...'}
+      else if(cmd==='paper'){
+        // Manual trigger (docs/final-paper.md §2). `lang=` / `format=` / `editor=` override THIS invocation only;
+        // a bare `force` rewrites an already-finalized paper. An unknown token becomes an unknown
+        // OPTION and is rejected by runPaperCommand → kind:'error' (never a silent success).
+        const o={}; let force=false
+        for(const tok of rest){ const eq=tok.indexOf('='); if(eq>0) o[tok.slice(0,eq)]=tok.slice(eq+1); else if(tok==='force') force=true; else if(tok) o[tok]=true }
+        r=await s.runPaperCommand(o,force)
+      }
+      else r={ok:false,usage:'configure|start [problem]|resume|pause|abort|status|report|message <to|all> <content>|meeting|paper [lang=zh|en] [format=md|tex|both] [editor=office|resident:<id>] [force]|members|add|remove|set <k=v>...'}
       // `kind:'error'` on a rejected business action, exactly as v2/v3 do: every branch above used to
       // report `success`, so the human's only non-tool control surface read as success on failure.
       const failed = !r || r.ok === false || (r.ok === undefined && !!r.error)