dsh-vibe-math 2.4.1 → 2.6.0

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

@@ -90,6 +90,18 @@ export function apply(ctx) {
       leanCommand: 'lean',
       leanArgs: [],            // inserted BEFORE the file name (e.g. ['env','lean'] with lake)
       leanTimeoutMs: 120000,
+      // ---- 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)
     }
     let params = Object.assign({}, DEFAULT_PARAMS)
     let running = false, autoDone = false, phase = 'idle'
@@ -102,10 +114,20 @@ 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
     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)
     let lastActivityAt = now(), lastProgressAt = now(), artifactCount = 0, lastSyncMeetingAt = 0, persistedEpoch = '', heartbeatDisposer = null
+    // `artifactBaseline` = the artifact count observed when the auto-sync-meeting counter was last
+    // re-based (see `countArtifacts`/`syncArtifactCount`): the documented behaviour is "every N NEW
+    // artifacts", so the modulo test must run against the number of artifacts written SINCE the run
+    // started, not against the raw file count of a possibly pre-existing project tree.
+    let artifactBaseline = null
     const activityLogCap = 200
 
     // ---- utils ----
@@ -858,10 +880,21 @@ export function apply(ctx) {
       // `off` mode must not CREATE Lean state: a run that never used the feature leaves no
       // State/formal.json behind. Seeded/live records (or a mode that is on) still persist.
       if(formalOn()||formalPersisted||Object.keys(formal).length||formalTodos.length) await writeJson('State/formal.json', {records:formal,todo:formalTodos})
-      await writeJson('State/session.json', {running,autoDone,phase,problemId,problemText,runId,meetings,reports,lastActivityAt,lastProgressAt,activityLog,processEpoch,artifactCount})
+      await writeJson('State/session.json', {running,autoDone,phase,problemId,problemText,runId,meetings,reports,lastActivityAt,lastProgressAt,activityLog,processEpoch,artifactCount,artifactBaseline,
+        // In-flight consensus must survive a restart too: a verification that had collected 3 of 4
+        // verdicts and a meeting that had collected half the speeches used to evaporate entirely
+        // (Shared/debates|meetings/<id>.md are only written by finalize*, so the partial debate was
+        // not even on disk) — and the queued proposals in pendingVerify were lost with it.
+        meetingState,verifyState,pendingVerify,pendingMeeting})
     }
     async function loadAll(){
-      const s=await readJson('State/session.json'); if(s){ running=!!s.running; autoDone=!!s.autoDone; phase=s.phase||'idle'; problemId=s.problemId||problemId; problemText=s.problemText||problemText; runId=s.runId||runId; meetings=s.meetings||[]; reports=s.reports||[]; lastActivityAt=s.lastActivityAt||now(); lastProgressAt=s.lastProgressAt||now(); activityLog=s.activityLog||activityLog; persistedEpoch=s.processEpoch||''; artifactCount=s.artifactCount||0 }
+      const s=await readJson('State/session.json'); if(s){ running=!!s.running; autoDone=!!s.autoDone; phase=s.phase||'idle'; problemId=s.problemId||problemId; problemText=s.problemText||problemText; runId=s.runId||runId; meetings=s.meetings||[]; reports=s.reports||[]; lastActivityAt=s.lastActivityAt||now(); lastProgressAt=s.lastProgressAt||now(); activityLog=s.activityLog||activityLog; persistedEpoch=s.processEpoch||''; artifactCount=s.artifactCount||0; artifactBaseline=(s.artifactBaseline===undefined?null:Number(s.artifactBaseline))
+        // Restore the in-flight consensus (see saveAll). `resume()` refreshes the watchdog clocks right
+        // after this, so a run resumed after a crash gets a fresh stall window instead of being
+        // abandoned by the meeting/verify watchdog on its first serviced pass.
+        meetingState=s.meetingState||null; verifyState=s.verifyState||null
+        pendingVerify=Array.isArray(s.pendingVerify)?s.pendingVerify:[]
+        pendingMeeting=s.pendingMeeting||null }
       const rm=await readJson('State/residents.json'); if(rm&&typeof rm==='object') residents=new Map(Object.entries(rm))
       const mb=await readJson('State/mailboxes.json'); if(mb&&typeof mb==='object') mailboxes=new Map(Object.entries(mb))
       const tb=await readJson('State/taskboard.json'); if(Array.isArray(tb)) taskboard=tb
@@ -878,7 +911,12 @@ export function apply(ctx) {
 
     // ---- resident prompts ----
     function banner(){ const o=[]; for(const [id,r] of residents) o.push('- '+id+'「'+(r.direction||'（未定）')+'」'+r.status+'·轮'+r.rounds); return o.join('\n') }
-    async function inboxText(rId){ const mb=mailboxes.get(rId)||[]; if(mb.length===0) return '  (no new messages)\n'; return mb.map(m=>'  ['+m.from+'] '+m.content).join('\n')+'\n' }
+    // Who sent this? `facilitator` is the framework/human messenger (NOT a resident, not on the
+    // roster): a resident that reads a bare `[facilitator]` line tries to reply to it and gets
+    // `no such resident`. The definition travels WITH the frame, so it is present on the very wake
+    // that shows the message — not only in the once-only onboarding brief.
+    function senderLabel(from){ return String(from)==='facilitator'?'facilitator（框架/人类信使，不是常驻成员，不要向它回信；要回话请用本轮回执的 "input" 或 vibe_v4_send_message {to:"all"}）':String(from) }
+    async function inboxText(rId){ const mb=mailboxes.get(rId)||[]; if(mb.length===0) return '  (no new messages)\n'; return mb.map(m=>'  ['+senderLabel(m.from)+'] '+m.content).join('\n')+'\n' }
     function residentLibraries(){
       const base=frameworkRoot()
       return '你的资料库根目录：'+base+'/\n'
@@ -934,6 +972,7 @@ export function apply(ctx) {
       s.push('### 规则')
       s.push('- 只有 Verified/（或卡片标"已验证·真/假"）算已确立；其余都是你的实验性工作，请区分"猜想/已知"。')
       s.push('- 验证必须**全组一致**（全真或全假）；你只信全票结果。未全票的对象留在库里带概率。')
+      s.push('- `facilitator` 是**框架/人类介入的信使名**（不是常驻成员，不在编制里）：它转达人类或框架的话，但**不要向它回信**（会返回 no such resident）；要回话请用本轮回执的 "input" 字段（会转给全组）或 `vibe_v4_send_message {to:"all"}`。')
       s.push('- 你自己决定做什么，但**优先级/分工由团队讨论决定**，不是固定模式。若你认为问题已解决或接近解决，请**发起会议**让团队表决。')
       s.push('- 退出时**只**输出一个 JSON 对象（放在 ```json 代码围栏内；围栏外不要有文字）。')
       return s.join('\n')
@@ -947,6 +986,7 @@ export function apply(ctx) {
       // dynamic: after a /compact the resident must re-anchor on the rules it is actually
       // 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()):'')
     }
     function brainstormPrompt(r){
@@ -975,11 +1015,10 @@ export function apply(ctx) {
       const prior=Object.entries(st.inputs).filter(([k])=>k!==r.rId).map(([k,iv])=>'  ['+k+'] '+String(iv.input||iv.summary||'')).join('\n')
       return (params.residentPersona?params.residentPersona+'\n':'')
         +'Resident '+r.rId+' — 团队会议进行中。 A meeting is in progress (agenda: '+st.agenda+').'
-        +(st.type==='verify'?('\n团队正在验证对象：'+st.targetId+'（'+st.targetType+'，提出者 '+st.targetOwner+'）。请先看他人意见，再给独立判断。'):'')
         +'\n这是一场真实讨论：下面已有人发言（转给你），请先看，然后**加入讨论/补充/反驳/表决**。'
         +(prior?('\n\n### 已有发言（他人 input，已转发给你）\n'+prior):'\n（目前还没人发言，你先说。）')
         +'\n\n你可以：提议任务（propose_task）、认领开放任务（claim_task）、提议验证对象（propose_verify）、或对"原问题是否已解决"表决（voteSolved）。请把**你的实际发言**写进 "input"。'
-        +'\nReply with ONLY a JSON object:\n'
+        +'\n**停止表决必须是绝对票**：`voteSolved:true` 只表示你认为原问题**已解决**；只要有一名在册常驻没投 `true`（投 false、弃权、或漏写这个字段），run 就**不会**停止。不确定就投 false。'        +'\nReply with ONLY a JSON object:\n'
         +'{"input":"<your real contribution to this discussion>","propose_task":"<task title or null>","task_desc":"...","claim_task":"<task id or null>","propose_verify":"<id or null>","voteSolved":true}'
     }
     function verifyPrompt(r, vs){
@@ -990,9 +1029,19 @@ export function apply(ctx) {
       const others=Object.entries(src).map(([k,v])=>'- '+k+': 正确概率 '+String(v.prob!=null?Number(v.prob).toFixed(2):0.5)+' → '+v.reason).join('\n')
       const L=[]
       L.push((params.residentPersona?params.residentPersona+'\n':'')
-        +'Resident '+r.rId+' — 团队验证。 The group is verifying object '+vs.targetId+'（'+vs.targetType+'，提出者 '+vs.targetOwner+'）。\n'
+        +'Resident '+r.rId+' — 团队验证。 The group is verifying object '+vs.targetId+'（'+targetTypeWord(vs.targetType)+'，提出者 '+vs.targetOwner+'）。\n'
         +'请给出你对「该对象为真」的**正确概率 `verdict`**，仅一个 0–1 数值：**1 = 绝对为真，0 = 绝对为假，0.5 = 完全不确定，其余为介于其间的程度**（不要给 TRUE/FALSE，就给一个数值）。\n'
-        +'判定规则：仅当**全体常驻一致给 1（都认为是真）或一致给 0（都认为是假）**，才按「真/假」写入 Verified/；否则**只作为概率数值（一种程度）保留在库中**，附全组平均正确概率，不写成真/假。\n'
+        // ── THE VOTE CONTRACT (why the example below is 1 and not 0.9) ──────────────────────────
+        // Only an EXACT 1 or 0 is a vote; anything strictly between is the model's honest
+        // probability of truth, i.e. an ABSTENTION. The old text demonstrated `verdict:0.9` while
+        // the code required `Number(prob)===1`, so a cautious-but-convinced group could never
+        // converge: every round burned and the object stayed unverified forever. The rule is now
+        // stated HERE, the example shows `1`, and 0.9 is explained instead of merely tolerated.
+        +'**投票契约**：只有**恰好 1**（你认为是**绝对**为真）和**恰好 0**（你认为是**绝对**为假）算表决；**严格介于 0 与 1 之间**（例如 0.9、0.95、0.5）是**弃权**——它是你对"该对象为真"的**概率估计**，不是你的一票。\n'
+        +'  · 有把握认为它为真就投 **1**；不要为了"留一点余地"投 0.9——那会让全组永远无法定论。\n'
+        +'  · 弃权会被如实统计：本轮没有人全票 → 对象**不会**停止验证，而是把全组的**平均概率**写回它在库中的卡片（`- 概率:`），带概率继续留在库里。\n'
+        +'  · 弃权的两种合法用途：① 你确实不确定（用 0.5 附近的值表达）；② 已归档的机器检查证明与命题原文不一致、你**不能**用 0 表达"命题为假"（此时请用 `formal` 回执的 `decision:"defect"` 报告偏差，见下方形式化段）。\n'
+        +'判定规则：**仅当全体在册常驻都恰好给 1（都认为是真）、或都恰好给 0（都认为是假）**，才按「真/假」写入 Verified/ 并回写来源卡的「已验证·真/假」；否则**只按概率数值（一种程度）保留在库中**，附全组平均正确概率，不写成真/假。\n'
         +'请给出你**诚实独立的判断**'
         +(vs.stage==='debate'?'，并参考他人意见：\n':'。\n')
         +(vs.stage==='debate'&&others?('### 他人上一轮意见（已转发给你）\n'+others+'\n'):''))
@@ -1004,7 +1053,7 @@ export function apply(ctx) {
       }
       L.push('')
       L.push('Reply with ONLY a JSON object:')
-      L.push('{"vote":{"verdict":0.9,"reason":"<your logic>"}}')
+      L.push('{"vote":{"verdict":1,"reason":"<your logic>"}}')
       if(formalOn()){
         // The formal field belongs in the VOTING contract too: voters are exactly the agents who
         // must either formalize the object or record why they judged it infeasible.
@@ -1068,6 +1117,33 @@ export function apply(ctx) {
 
     // ---- resident lifecycle ----
     let residentSeq = 0
+    // Spawns that are currently IN FLIGHT, plus the `subagent/start` payloads seen while they were.
+    //
+    // ORDERING FACT (verified against the installed host, dsh-subagent 0.2.0-rc.2): `subagent/start`
+    // is emitted SYNCHRONOUSLY from inside `startContinuable`'s await — `emit('subagent/start', …)` at
+    // `dsh-subagent/lib/index.js:279` (and again from the lifecycle observer at `:306` once
+    // `observer.start(handle.agent)` runs at `:1116`) — and `startContinuable` resolves only
+    // afterwards. `spawnResident` therefore cannot know `started.childId` when the event fires, and
+    // the payload carries no label (see `SubagentRunInfo`: runId/provider/id/local only), so the ONLY
+    // information available at that moment is "a child of mine just started".
+    //
+    // So: the start handler STASHES the live Agent by child id (no ownership guess at all), and
+    // `spawnResident` CLAIMS the record for its child id as soon as the call resolves — at which point
+    // ownership is known exactly. `labelHints` bridges the (mock-ish) hosts that embed the label in
+    // the id for the handler's own `ownsChild` check.
+    const pendingSpawnLabels = new Set()
+    const pendingStartAgents = new Map()   // childId -> Agent, seen but not yet owned
+    function stashStartAgent(childId, agent){
+      if(!childId || !agent) return
+      if(pendingStartAgents.size>=64) pendingStartAgents.delete(pendingStartAgents.keys().next().value)
+      pendingStartAgents.set(String(childId), agent)
+    }
+    function claimStartAgent(childId){
+      const id=String(childId==null?'':childId)
+      const agent=pendingStartAgents.get(id)
+      if(agent) pendingStartAgents.delete(id)
+      return agent
+    }
     function newResident(dir){ const rId='r-'+(++residentSeq); return {rId,childId:'',direction:dir||'',status:'brainstorm',rounds:0,roundsSinceCompact:0,lastActiveAt:now(),insight:'',contextPct:0,contextSeed:'',needCompact:false} }
     async function spawnResident(r){
       // Skip BEFORE touching the host when we already KNOW the ceiling and our own live children
@@ -1076,6 +1152,8 @@ export function apply(ctx) {
       if(hostChildLimit!==undefined && liveChildCount()>=hostChildLimit){ noteSpawnRefused(r, hostChildLimit); return false }
       const ao=residentAgentOptions(); const tf=residentToolFilter()
       let started
+      // Register the label for the whole in-flight window: `subagent/start` fires inside this await.
+      pendingSpawnLabels.add(r.rId)
       try {
         started=await startWithToolFilter(tf, function(f){ return {provider:pickProvider(),label:r.rId,request:{prompt:[textBlock(brainstormPrompt(r))],parent:rootAgent,agentOptions:ao,...(f?{toolFilter:f}:{})},signal:makeSignal(params.activityTimeoutMs||60000)} })
       } catch(e){
@@ -1085,17 +1163,46 @@ export function apply(ctx) {
         // failure keeps its previous behaviour and still propagates.
         if(!isActivationLimitReached(e)) throw e
         noteSpawnRefused(r, noteChildLimit(e)); return false
-      }
+      } finally { pendingSpawnLabels.delete(r.rId) }
+      // The child just started, so its `subagent/start` payload has already been seen (the host emits
+      // it inside the await above). Claim the stashed Agent for it NOW — ownership is exact here — and
+      // that is what makes the REAL `/compact` path reachable (see the `subagent/start` listener).
+      const claimed=claimStartAgent(started.childId)
+      if(claimed) rememberAgent(started.childId, claimed)
       r.childId=started.childId; r.status='brainstorm'; r.lastActiveAt=now()
       childOwner.set(started.childId,sessionId); busy.add(r.rId); wakeKind.set(r.rId,'normal'); currentResident=r.rId
       residents.set(r.rId,r); await saveAll(); logActivity('spawn',r.rId+' ('+(r.direction||'brainstorm')+')')
       return true
     }
+    /**
+     * Is `childId` one of THIS session's residents — including a spawn that is still IN FLIGHT?
+     *
+     * `spawnResident` sets `r.childId` (and `childOwner`) only after `startContinuable` resolves, but
+     * the host emits `subagent/start` from inside that await. So "is this mine?" must also consult the
+     * pending-spawn labels registered around the call; without that, the start handler rejects every
+     * child of a fresh spawn and `liveAgents` never gets populated.
+     */
+    function ownsChild(childId){
+      const id=String(childId)
+      for(const [,r] of residents){ if(r.childId===id) return true }
+      for(const r of pendingSpawns){ if(r.childId===id) return true }
+      // During the spawn await the child's id is not recorded anywhere yet, but the framework chose
+      // the spawn's LABEL and `spawnResident` registers it for exactly this window. A host id that
+      // embeds the label (`child-r-1`, the common test/mock shape) is matched by containment; an
+      // opaque host id cannot be matched here, which is why the label is only a
+      // best-effort bridge in addition to the roster checks above.
+      for(const label of pendingSpawnLabels){ if(id===label || id.indexOf(label)>=0) return true }
+      return false
+    }
     async function wakeResident(r, promptText, kind){
       if(!r || !r.childId) return false   // a removed resident must never be woken (else r.childId would crash)
       clearHeartbeat()
       busy.add(r.rId); wakeKind.set(r.rId,kind||'normal'); currentResident=r.rId
-      r.lastActiveAt=now(); r.rounds+=1; r.roundsSinceCompact+=1
+      // `rounds`/`roundsSinceCompact` are advanced only AFTER the send actually succeeded (below), so
+      // a wake that never reached the child cannot consume a "round" of the compaction heuristic nor
+      // inflate the round number the resident is told. `lastActiveAt` still moves here on purpose: a
+      // failed wake must back the A-fill off for one activityTimeoutMs instead of hammering the child.
+      r.lastActiveAt=now()
       // Context compaction has TWO distinct needs. Confusing them is the bug that made
       // '[核心规则重申]+[CONTEXT COMPACT]' repeat at the start of nearly every prompt:
       //   (a) r.needCompact (set by a REAL /compact) => the resident's rules may be blurred, so
@@ -1135,6 +1242,8 @@ export function apply(ctx) {
         } else {
           throw new Error('no subagent continuation API (need sendMessage or followup)')
         }
+        // The turn is really in flight now: count it (F10 — a failed send must not consume a round).
+        r.rounds+=1; r.roundsSinceCompact+=1
         return true
       }
       catch(e){ console.error('vibe-v4 wake '+r.rId+' failed: '+String((e&&e.message)||e)); busy.delete(r.rId); return false }
@@ -1146,18 +1255,74 @@ export function apply(ctx) {
     async function recordProposition(rId,o){ if(!rId||!residents.has(rId)) return {ok:false,message:'no such resident'} ; const id=o.id?idSafe(o.id):('p-'+shortId()); const lines=['# 命题｜'+(o.title||id),'- 标题: '+(o.title||id),'- ID: '+id,'- 类型: 命题','- 状态: 未定论','- 概率: '+cl(o.prob!=null?o.prob:0.5),'- 价值程度: '+cl(o.value!=null?o.value:0.5),'- 动机用途计划: '+(o.motivation||''),'- 依赖: []','','## 陈述',String(o.statement||''),'','## 证明尝试','','## 证伪尝试','']; await writeText('Propos/'+rId+'/'+id+'.md',lines.join('\n')); logActivity('record',rId+' 命题 '+id); bumpArtifacts(); return {ok:true,id,file:'Propos/'+rId+'/'+id+'.md'} }
     async function recordMethod(rId,o){ if(!rId||!residents.has(rId)) return {ok:false,message:'no such resident'} ; const id=o.id?idSafe(o.id):('m-'+shortId()); const lines=['# 方法｜'+(o.title||id),'- 标题: '+(o.title||id),'- ID: '+id,'- 类型: '+(o.type||'方法'),'- 状态: 经验','- 可信断言: []','- 价值程度: '+cl(o.value!=null?o.value:0.5),'- 动机用途计划: '+(o.motivation||''),'','## 核心内容',String(o.content||''),'','## 定义与记号',String(o.notation||''),'','## 应用记录','## 改进历史','']; await writeText('Methods/'+rId+'/'+id+'.md',lines.join('\n')); logActivity('record',rId+' 方法 '+id); bumpArtifacts(); return {ok:true,id,file:'Methods/'+rId+'/'+id+'.md'} }
     async function recordSubproblem(rId,o){ if(!rId||!residents.has(rId)) return {ok:false,message:'no such resident'} ; const id=o.id?idSafe(o.id):('s-'+shortId()); const lines=['# 子问题｜'+(o.title||id),'- 标题: '+(o.title||id),'- ID: '+id,'- 状态: 求解中','- 价值程度: '+cl(o.value!=null?o.value:0.5),'- 动机用途计划: '+(o.motivation||''),'- 依赖: []','','## 陈述',String(o.statement||''),'','## 进度','']; await writeText('Subproblems/'+rId+'/'+id+'.md',lines.join('\n')); logActivity('record',rId+' 子问题 '+id); bumpArtifacts(); return {ok:true,id,file:'Subproblems/'+rId+'/'+id+'.md'} }
-    // auto-sync meeting: every meetingKeepEvery artifact records, convene a general coordination meeting.
+    // ── auto-sync meeting: every `meetingKeepEvery` NEW artifacts, convene a coordination meeting ──
+    //
+    // The counting basis is the RESIDENTS' card libraries themselves (Propos/Methods/Subproblems),
+    // NOT the three `record_*` convenience tools. The prompt tells residents verbatim that those tools
+    // are optional and that they are recommended to write their own files directly with `fs`, so a
+    // team that follows the recommendation never called `bumpArtifacts` and
+    // `artifactCount % meetingKeepEvery === 0` could never fire — the documented "every N new
+    // artifacts auto-sync" was UNREACHABLE in the very workflow the prompt recommends, leaving the
+    // stall watchdog as the only path that ever convenes an auto-meeting.
     //
-    // ⚠ 已知设计缺口（有意保留，未修）：计数口径**只有** record_* 三个便捷工具的调用。而提示词明确
-    // 告诉常驻："vibe_v4_publish_progress/record_* 只是便捷记录器（可选；推荐直接用 fs 写自己的文件）"，
-    // 所以一个完全按推荐方式（fs 直写）工作的团队不会让 artifactCount 增长，
-    // `artifactCount % meetingKeepEvery === 0` 永不成立 —— 文档承诺的"每积累 N 个新产物自动同步
-    // 一次"在推荐工作流下不可达（此时只有"停滞看门狗"那条时间触发路径会开会）。
-    // 试过把"完成的常驻轮次"也计入，但那会改变开会节奏，令 e2e-v4-fixes T4 与 selfdrive-v4 的
-    // 时序断言失败（两套测试都按当前节奏写死了预期）。这属于**设计参数取舍**，需要维护者决定：
-    // 要么改计数口径并同步调整测试预期，要么把"便捷记录器可选"的措辞改为"建议使用以便触发周期同步"。
-    function bumpArtifacts(){ artifactCount+=1; markProgress(); if(!meetingState && !verifyState && !pendingMeeting && Number(params.meetingKeepEvery)>0 && artifactCount % Number(params.meetingKeepEvery)===0){ startMeeting('定期同步：分工/进展/是否需要验证','general',null).catch(()=>{}) } }
-    function listResidents(){ return Array.from(residents.values()).map(r=>({id:r.rId,direction:r.direction,status:r.status,rounds:r.rounds,contextPct:r.contextPct,insight:r.insight?r.insight.slice(0,80):''})) }
+    // Setting `artifactBaseline` also means a tile count of the correct sign, since residents write
+    // the paths `Propos/<r>/<id>.md` explicitly.
+    async function countArtifacts(){
+      let n=0
+      for(const base of ['Propos','Methods','Subproblems']){
+        try {
+          const t=await fs.resolve(base,{cwd:frameworkRoot()})
+          if(await fs.stat(t)===undefined) continue
+          const ents=await fs.listDir(t)
+          for(const e of ents||[]){
+            if(!e||e.type!=='directory') continue
+            try {
+              const dt=await fs.resolve(base+'/'+e.name,{cwd:frameworkRoot()})
+              if(await fs.stat(dt)===undefined) continue
+              const files=await fs.listDir(dt)
+              for(const f of files||[]) if(f&&f.type==='file'&&/\.md$/.test(String(f.name))) n++
+            } catch(e2){ /* a single unreadable library must not stop the scan */ }
+          }
+        } catch(e){ /* best-effort: an absent library counts as zero */ }
+      }
+      return n
+    }
+    /**
+     * Re-base the artifact counter on what is on disk. Called from `start()` (a fresh run: the count
+     * of NEW artifacts starts at 0 even if the project tree already held cards) and from
+     * `scheduleNext` (the single choke point of every scheduling pass, right before the auto-meeting
+     * test), so a group that writes its cards with `fs` still drives the documented cadence.
+     * Costs no writes and never throws into the scheduler.
+     */
+    async function syncArtifactCount(){
+      const n=await countArtifacts()
+      if(artifactBaseline===null) artifactBaseline=n
+      artifactCount=Math.max(artifactCount, n-(artifactBaseline||0))
+      return artifactCount
+    }
+    /**
+     * The `meetingKeepEvery` cadence: every N newly accumulated artifacts, convene ONE coordination
+     * meeting. Called from BOTH paths that can observe the count:
+     *   · `bumpArtifacts` (a `record_*` convenience-tool call — the counter moves immediately), and
+     *   · `scheduleNext` right after `syncArtifactCount()` re-bases the counter on the files on disk,
+     *     which is the ONLY way an `fs`-written card can be seen.
+     * Without the second call site the documented cadence is unreachable in the very workflow the
+     * prompt recommends (`record_*` 可选；推荐直接用 fs 写自己的文件). `lastSyncMeetingAt` is reused as
+     * the count at which the last sync meeting was convened, so the same crossing cannot fire twice.
+     */
+    function maybeArtifactSyncMeeting(){
+      const every=Number(params.meetingKeepEvery)
+      if(!(every>0)) return false
+      if(meetingState || verifyState || pendingMeeting) return false
+      if(!(artifactCount>0) || artifactCount % every !== 0) return false
+      if(artifactCount<=lastSyncMeetingAt) return false   // this crossing already convened a meeting
+      lastSyncMeetingAt=artifactCount
+      logActivity('meeting','定期同步触发：新增产物达到 '+every+' 的倍数（累计 '+artifactCount+'）')
+      startMeeting('定期同步：分工/进展/是否需要验证','general',null).catch(()=>{})
+      return true
+    }
+    function bumpArtifacts(){ artifactCount+=1; markProgress(); maybeArtifactSyncMeeting() }
+    function listResidents(){ return Array.from(residents.values()).map(r=>({id:r.rId,direction:r.direction,status:r.status,rounds:r.rounds,contextPct:r.contextPct,insight:r.insight?r.insight.slice(0,80):'',roundsSinceCompact:r.roundsSinceCompact||0,needCompact:!!r.needCompact,wakeKind:wakeKind.get(r.rId)||''})) }
     // identify WHICH resident is calling a resident-facing tool: match the caller's
     // subagent id to a resident's childId. Fall back to the last-woken resident when
     // the caller is the host/assistant (or an unknown agent). This makes per-resident
@@ -1171,17 +1336,28 @@ export function apply(ctx) {
       // wake the claimer to work on it (framework moves the task, resident decides how).
       // NOT while paused/stopped: a paused run must not start new work — the claim is recorded on the
       // board and the resident (who claimed it) picks it up again after resume.
-      const r=residents.get(claimer); if(r && !busy.has(claimer) && running && !autoDone){ currentResident=claimer; await wakeResident(r, (await normalPrompt(r))+'\n\n[YOU CLAIMED TASK '+id+'] '+t.title+' — '+t.description,'normal'); await saveAll() }
+      const r=residents.get(claimer); if(r && !busy.has(claimer) && running && !autoDone){ currentResident=claimer; const ok=await wakeResident(r, (await normalPrompt(r))+'\n\n[YOU CLAIMED TASK '+id+'] '+t.title+' — '+t.description,'normal'); await saveAll(); if(!ok) armHeartbeat() }
       return {ok:true} }
     async function taskDone(id,claimer){ const t=taskboard.find(x=>x.id===id); if(!t) return {ok:false}; t.status='done'; t.doneBy=claimer; await saveTaskboard(); await writeTaskboard(); markProgress(); logActivity('task','done '+id); return {ok:true} }
     async function saveTaskboard(){ await writeJson('State/taskboard.json',taskboard); await writeTaskboard() }
     function listTasks(){ return taskboard.filter(t=>t.status!=='done') }
     async function reportContext(rId,pct){ const r=residents.get(rId); if(r){ r.contextPct=clPct(pct); if(Number(pct)<30) r.needCompact=false; } return {ok:true} }
-    // Apply context/compact bookkeeping from a resident's reply, so the flag can clear even when
-    // the reply came through a meeting/verify branch (defensive) as well as the normal branch.
-    function postmark(r, parsed){
+    /**
+     * Apply context/compact bookkeeping from a resident's reply.
+     *
+     * `kind` is the wake kind. It matters because the OLD version treated ANY non-empty `summary`
+     * on ANY turn as the acknowledgement of a requested compaction: a meeting/verify reply that
+     * happened to echo a summary (their contracts do not forbid it) cleared `needCompact`, zeroed
+     * `roundsSinceCompact` and clamped `contextPct` to <=25 WITHOUT any compaction happening — so the
+     * soft-compact trigger stayed below threshold and the compaction the flag was asking for was
+     * never issued. Only a real normal research turn can acknowledge the soft directive it received
+     * (`wakeResident` injects `[CONTEXT COMPACT …]` on normal rounds only); `parsed.compacted===true`
+     * stays honoured on every kind, because that is the resident explicitly saying it condensed.
+     */
+    function postmark(r, parsed, kind){
       const cp=Number(parsed.contextPct); if(Number.isFinite(cp)) r.contextPct=clPct(cp)   // tolerate numeric strings ("40")
-      if(parsed.compacted===true || (r.needCompact && parsed.summary)){
+      const isNormalTurn=(kind||'normal')==='normal'
+      if(parsed.compacted===true || (isNormalTurn && r.needCompact && parsed.summary)){
         r.contextSeed=String(parsed.summary||r.contextSeed||'')
         r.contextPct=Math.min(r.contextPct||15,25)
         r.roundsSinceCompact=0
@@ -1195,8 +1371,22 @@ export function apply(ctx) {
       const r=residents.get(to); if(!r) return {ok:false,message:'no such resident'}
       if(!busy.has(to)){
         currentResident=r.rId
-        await wakeResident(r, (await normalPrompt(r))+'\n\n[NEW MESSAGE from '+from+']\n'+content,'normal')
-        await saveAll(); markProgress(); logActivity('message',from+'→'+to); return {ok:true}
+        const ok=await wakeResident(r, (await normalPrompt(r))+'\n\n[NEW MESSAGE from '+from+']\n'+content,'normal')
+        await saveAll(); markProgress()
+        if(ok){ logActivity('message',from+'→'+to); return {ok:true} }
+        // The immediate wake FAILED (and `wakeResident` already cleared the `busy` mark, so no turn
+        // actually started). Round C: the message must fall back to the MAILBOX instead of being
+        // discarded — the old code logged "(wake failed; heartbeat re-armed)" and then dropped the
+        // text, so the re-armed heartbeat had nothing left to do and the message was lost forever
+        // while the recipient stayed cold (this is what the audit's F1 probe measured: it reported
+        // "queued mail already consumed: false" but the mailbox was in fact already empty, so no
+        // later pass could ever deliver anything). The mailbox is the one place a pass is guaranteed
+        // to look again — including during `brainstorm`, see the delivery call at the top of
+        // scheduleNext — and a successful retry marks the recipient busy and clears the queue.
+        const mb=mailboxes.get(to)||[]; mb.push({from,at:now(),content}); mailboxes.set(to,mb)
+        await saveAll(); armHeartbeat()
+        logActivity('message',from+'→'+to+' (immediate wake failed; queued for retry)')
+        return {ok:true}
       }
       const mb=mailboxes.get(to)||[]; mb.push({from,at:now(),content}); mailboxes.set(to,mb); await saveAll(); logActivity('message',from+'→'+to+' (queued)'); return {ok:true}
     }
@@ -1287,14 +1477,36 @@ export function apply(ctx) {
           if(iv.claim_task) await claimTask(iv.claim_task, id)
           if(iv.propose_verify) maybeQueueVerify(iv.propose_verify, id)
         }
-        const votes=Object.values(st.inputs).map(x=>x.voteSolved).filter(v=>typeof v==='boolean')
-        const allSolved = allSpoke && votes.length>0 && votes.every(v=>v===true)
+        // ── the STOP vote must be UNANIMOUS, abstentions included ────────────────────────────────
+        // `onResidentEnd` stores `voteSolved` only when it is a real boolean, otherwise `null`. The
+        // old code filtered those nulls OUT and then asked `votes.every(v=>v===true)`, so a resident
+        // that omitted the field (the meeting contract makes every key except `input` optional) or
+        // wrote the string "true" simply dropped out of the electorate — and 3-of-4 voting true read
+        // as "the whole team agrees the problem is solved" and STOPPED the run. `finalizeVerify` was
+        // already written correctly (every resident must have a verdict); this mirrors it: every
+        // speaker must have produced an explicit `true`.
+        const speakers=Object.values(st.inputs)
+        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()
@@ -1369,14 +1581,18 @@ export function apply(ctx) {
           else await closeVerify(vs,allTrue)
           doSchedule=true
         }
-        else if(vs.round+1<params.verdictMaxRounds){
+        else if(vs.round<params.verdictMaxRounds){
+          // `verdictMaxRounds` is documented (README / 实现方案 / persona) as the maximum number of
+          // verification rounds: 1 independent first vote + (verdictMaxRounds-1) debate re-votes. The
+          // old `vs.round+1<verdictMaxRounds` gave one round FEWER than the name and the docs promise
+          // (default 3 → only 2), so the parameter read as an off-by-one from every documented surface.
           // Move to a REAL debate round: snapshot the current votes into history (so the next round's
           // prompt can show others' previous stances), then CLEAR verdicts so every resident is asked to
           // give a fresh independent judgement after seeing the debate. Without the clear, allVoted stays
           // true and the debate rounds burn through with NOBODY being re-asked (a silent no-op).
           vs.history=Object.assign({}, vs.verdicts); vs.verdicts={}
           vs.lastVerdictAt=now()   // fresh deadlock window for the re-vote round
-          vs.stage='debate'; vs.round+=1; vs.asked=[]; logActivity('verify',vs.targetId+' round '+vs.round+' → debate (re-vote after seeing others)'); await saveAll(); doSchedule=true
+          vs.stage='debate'; vs.round+=1; vs.asked=[]; logActivity('verify',vs.targetId+' round '+vs.round+'/'+params.verdictMaxRounds+' → debate (re-vote after seeing others)'); await saveAll(); doSchedule=true
         }
         else {
           const avg=vals.length? vals.reduce((a,x)=>a+(x.prob!=null?x.prob:0.5),0)/vals.length : 0.5
@@ -1440,13 +1656,25 @@ export function apply(ctx) {
     function maybeQueueVerify(target, proposer){
       const t=idSafe(target)   // sanitize BEFORE it becomes file names / dedup keys / status output
       if(!t || t==='id') return false
+      // The object KIND is derived from the id prefix, and it decides BOTH the directory the Verified
+      // card lands in (Verified/命题/ vs Verified/问题/) and the `- 类型:` line of the source card's
+      // write-back. The old fallback mapped EVERY unrecognised id to 'proposition', so proposing a
+      // method/sub-problem whose id does not start with m-/s- (e.g. `2.1`, `lemma-A`) silently wrote a
+      // card into Verified/命题/ carrying `类型: 命题` — a card whose location and declaration disagree.
+      // The prefix IS the coordination contract (the prompt hands residents `p-`/`m-`/`s-`), so an id
+      // that does not carry one is refused HERE, at the single queueing funnel, instead of guessing.
+      const tt=guessTargetType(t)
+      if(!tt){
+        logActivity('verify',t+' 的提议被拒绝：对象 id 必须以 p-（命题）/ m-（方法）/ s-（子问题）开头，否则框架无法确定它属于哪个库（V4_INVALID_ARGUMENT）')
+        return false
+      }
       const last=verifiedRecently.get(t)
       if(last!==undefined && (now()-last) < recoverStallMs()){
         logActivity('verify',t+' re-propose ignored (just verified at '+fmtTime(last)+')')
         return false
       }
       if(pendingVerify.some(p=>String(p.targetId)===t)) return true   // already queued → keep ONE entry
-      pendingVerify.push({targetId:t,targetType:guessTargetType(t),proposer:proposer||'',at:now()})
+      pendingVerify.push({targetId:t,targetType:tt,proposer:proposer||'',at:now()})
       return true
     }
     async function writeDebateDoc(vs,done,val){
@@ -1532,7 +1760,11 @@ export function apply(ctx) {
       next=rewriteCardField(next,'概率',isTrue?'1':'0')
       await writeText(rel,next||text)
     }
-    function guessTargetType(id){ if(/^p-/.test(id)) return 'proposition'; if(/^m-/.test(id)) return 'method'; if(/^s-/.test(id)) return 'subproblem'; return 'proposition' }
+    function guessTargetType(id){ if(/^p-/.test(id)) return 'proposition'; if(/^m-/.test(id)) return 'method'; if(/^s-/.test(id)) return 'subproblem'; return '' }
+    // Human-readable word for the target kind, used in the prompts. Never print the RAW internal
+    // token: the voter is a model, and `proposition`/`method`/`subproblem` in an otherwise Chinese
+    // contract is exactly the kind of untranslated placeholder these audits look for.
+    function targetTypeWord(t){ return t==='method'?'方法':(t==='subproblem'?'子问题':'命题') }
 
     // ---- heartbeat / liveness helpers (boundary-A: event-driven + gated heartbeat) ----
     // A checkpoint wake is NOT "keep working forever": it nudges the least-recently-active
@@ -1648,11 +1880,35 @@ 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.
       if(pendingSpawns.length) await retryPendingSpawns()
+      // Queued mail MUST also be delivered while the group is still brainstorming (Round C, F1).
+      // A human/team message is not "work": the brainstorm phase used to return at the next line
+      // before ever reaching the delivery point below, so a wake that FAILED left the message
+      // re-queued and every subsequent heartbeat firing a no-op (`maybeFinishBrainstorm` only flips
+      // the phase once every resident has an insight). The scheduler then stayed cold with mail
+      // still queued — the exact permanent stall F1 exists to remove, narrowed to this phase
+      // (_oneoff/probe-v4-mailbox-stall.mjs used to print REPRODUCED here).
+      // Deliberately conditioned on "no consensus in progress": continueMeetingRound /
+      // continueVerifyRound refuse to flush mailboxes on purpose (a backlog must not starve a
+      // consensus past its watchdog, see their comments), so a parked meeting/verify keeps that
+      // guarantee and the mail goes out on the first pass after the consensus closes.
+      if(!meetingState && !verifyState){ const delivered=await deliverNextMailbox(); if(delivered) return }
       if(phase==='brainstorm'){ await maybeFinishBrainstorm(); return }
       if(meetingState){ await continueMeetingRound(); return }
       if(verifyState){ await continueVerifyRound(); return }
@@ -1660,11 +1916,24 @@ export function apply(ctx) {
       // A meeting requested while a verify held the floor is parked in pendingMeeting; once the
       // verify queue has truly drained (no verifyState / pendingVerify), resume it before anything else.
       if(pendingMeeting){ const pm=pendingMeeting; pendingMeeting=null; await startMeeting(pm.agenda, pm.type, pm.targetId); return }
-      // mailbox delivery
+      // mailbox delivery. `wakeResident` CLEARS the heartbeat as its first act, so a pass that delivers
+      // NOTHING must not return without re-arming one: a rejected `sendMessage`
+      // (subagent/delivery-unavailable, a cold-resumed child whose Activation closed, a transient
+      // persistence failure) re-queues the message, refreshes the recipient's lastActiveAt (so the fill
+      // loop below skips it for a whole activityTimeoutMs) and used to end the pass with no wake, no
+      // heartbeat and no in-flight turn — nothing else could ever re-drive the scheduler, so the whole
+      // group stopped permanently with mail still queued. Falling through instead lets the branches
+      // below re-arm (and B/A still get their chance); on a SUCCESSFUL delivery the recipient's own
+      // subagent/end re-drives the pump, so the pass can end here as before.
       const delivered=await deliverNextMailbox(); if(delivered) return
       // maxParallel: don't start a new wake when the in-flight cap is reached
       const mp=Number(params.maxParallel)||0
       if(mp>0 && busy.size>=mp){ armHeartbeat(); return }
+      // Refresh the artifact counter from the residents' own card libraries (fs-written cards count
+      // too) before the auto-sync test below, so `meetingKeepEvery` measures NEW artifacts — and
+      // convene the sync meeting here, because this is the only place an `fs`-written card is seen.
+      await syncArtifactCount()
+      if(maybeArtifactSyncMeeting()) return
       // B) stall auto-sync meeting (分级保活 B): the group has been idle with NO progress for
       //    stallAutoMeetingMs → convene a sync meeting so the residents coordinate their next move
       //    (framework convenes & records; residents decide — never assigns work). Only when no
@@ -1763,8 +2032,12 @@ export function apply(ctx) {
       realCompact(r).catch(()=>{})   // best-effort real DSH /compact of this resident while idle
       const output=blocksToText(info&&info.lastAssistantMessage)
       const parsed=parseReply(output)
-      postmark(r, parsed)   // context/compact bookkeeping, regardless of wake kind (clears any leak)
       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()
@@ -1822,6 +2095,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()
@@ -1843,6 +2824,10 @@ export function apply(ctx) {
       // carrying a previous run's records over would let a stale `passed` open the new gate.
       formal={}; formalTodos=[]
       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()
       lastActivityAt=now(); lastProgressAt=now()   // fresh stall/activity clock for the new run (else B could fire immediately on a reused session)
       const dirs=Array.isArray(seedDirections)?seedDirections.slice(0,params.residentCount):[]
       pendingSpawns=[]                 // a fresh run replaces the roster: nothing is queued from before
@@ -1883,7 +2868,15 @@ export function apply(ctx) {
       // If the persisted State came from a DIFFERENT process (crash/restart), the saved
       // childIds are stale; clear them so residents re-spawn (their libraries persist on
       // disk and re-seed the resumed run). Same-process pause→resume keeps continuable ids.
+      //
+      // `persistedEpoch` is only ever READ here, so before this fix a same-process pause→resume
+      // compared this process's random epoch against the epoch saved by ITSELF and always concluded
+      // "cross-process": every resident was re-spawned, `busy`/`wakeKind` were thrown away while the
+      // OLD children were still running (`resume()` never interrupts them, so the late
+      // `subagent/end` that the code's own comment warns about was guaranteed, not hypothetical).
+      // Re-sync it on a same-process load, which is the contract `paused` already assumes.
       const crossProcess = persistedEpoch !== processEpoch
+      if(!crossProcess) persistedEpoch = processEpoch
       if(crossProcess){ for(const [,r] of residents){ r.childId=''; r.status='brainstorm'; r.roundsSinceCompact=0 } }
       // ANY re-spawn (cross-process OR a same-process abort that already cleared childIds) must get a FRESH
       // coordination/concurrency state and a brainstorm phase. Otherwise: re-spawned brainstorm residents run
@@ -1913,10 +2906,20 @@ export function apply(ctx) {
       pendingSpawns: pendingSpawns.length, hostChildLimit: (hostChildLimit===undefined?null:hostChildLimit),
       meetingInProgress: !!(meetingState), verifyInProgress: !!(verifyState), pendingVerify: pendingVerify.length?pendingVerify[0].targetId:null, pendingVerifyCount: pendingVerify.length,
       parkedMeeting: pendingMeeting?pendingMeeting.agenda:null,
+      // The coordination counters (`spoke k/N`, `voted k/N`, the verification round) used to live only
+      // in `report()`: from `status()` alone an operator could not tell "the group is progressing"
+      // from "the group is stuck at 2/4 votes", which is exactly how F1/F2/F7 stay invisible.
+      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(),
-      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(', ') } }
+      // 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','finalPaper','paperFormat','paperLanguage','paperCompilePdf','paperEditor','paperLatexCommand'].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()
@@ -1933,6 +2936,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()} }
@@ -1980,6 +2984,21 @@ export function apply(ctx) {
       // 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 }
       // 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.
@@ -2003,9 +3022,30 @@ export function apply(ctx) {
       if(min===undefined) return n
       return n < min ? min : n
     }
-    function setParams(upd){ for(const k of Object.keys(upd||{})){ if(k in params){ const nv=normalizeParam(k, upd[k]); params[k]= (typeof nv==='number') ? clampInt(k, nv) : nv } } saveSettings().catch(()=>{}); return {ok:true} }
+    /**
+     * Apply a parameter update. Keys the parameter layer does not know are NOT silently dropped: the
+     * caller gets them back (`ok:false` + `ignored`), because `{ok:true}` for a call that changed
+     * nothing is the "declared but not received" silent failure AUDIT-CHECKLIST §1.9 names.
+     */
+    function setParams(upd){
+      const keys=Object.keys(upd||{})
+      // `k in params` 会沿原型链判真：`toString` / `constructor` / `__proto__` 这类键会被当成"已知参数"
+      // 写进 params（`params['__proto__']=…` 还会真的改掉 params 的原型），而 schema 的
+      // additionalProperties:false 在 v4 上**不产生运行期拒绝**（裸 tools.register，宿主不校验实参）。
+      // 已知参数一律以**自有属性**为准（AUDIT-CHECKLIST §1.9 的"声明=接收"只能在自有键上成立）。
+      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 } }
+      saveSettings().catch(()=>{})
+      if(ignored.length){
+        logActivity('set','忽略未知参数：'+ignored.join(', '))
+        return {ok:false,message:'unknown parameter(s): '+ignored.join(', ')+' — nothing was changed'+(ignored.length<keys.length?('（已应用：'+keys.filter(k=>!(ignored.indexOf(k)>=0)).join(', ')+'）'):''),ignored,applied:keys.filter(k=>!(ignored.indexOf(k)>=0))}
+      }
+      return {ok:true,applied:keys}
+    }
     // ---- create / configure (no auto-start) + settings-file persistence ----
-    async function loadSettings(){ const s=await readJson('State/settings.json'); if(s&&typeof s==='object'){ for(const k of Object.keys(s)){ if(k in params){ const nv=normalizeParam(k, s[k]); params[k]= (typeof nv==='number') ? clampInt(k, nv) : nv } } } }
+    // 同一把守护：State/settings.json 是用户可编辑的，原型链上的键名（toString/__proto__）不是参数。
+    async function loadSettings(){ const s=await readJson('State/settings.json'); if(s&&typeof s==='object'){ for(const k of Object.keys(s)){ if(Object.prototype.hasOwnProperty.call(params,k)){ const nv=normalizeParam(k, s[k]); params[k]= (typeof nv==='number') ? clampInt(k, nv) : nv } } } }
     async function saveSettings(){ await writeJson('State/settings.json', params) }
     // Create/configure a project and set params/problem WITHOUT starting any resident.
     // The intended flow: vibe_v4_configure {project?, problem?, params?}  →  vibe_v4_start {}.
@@ -2030,6 +3070,7 @@ 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 saveAll(); return {ok:true,message:'aborted'} }
     function setPause(){ clearHeartbeat(); running=false; return {ok:true,message:'paused'} }
 
@@ -2041,10 +3082,30 @@ 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. */
+      stashStartAgent,
       // safety kick: drive one scheduler pass (used when an end handler errored, so an exceptional
       // turn can never leave the group with no end-event and no heartbeat to continue it)
       nudge:()=>scheduleNext().catch(()=>{}),
-      residentIdOf:(agent)=>{ const m=residentOfAgent(agent); if(m) return m; const c=currentResident; return (c && residents.has(c)) ? c : '' },
+      /**
+       * Which resident is calling a resident-facing tool?
+       *   1. the caller's subagent id matched against a resident's childId — the exact answer;
+       *   2. the last-woken resident, but ONLY when no caller identity exists at all (the mock/harness
+       *      path, where `exec.agent` is undefined).
+       * An agent that IS present but matches no resident is NOT guessed at: attributing a host call to
+       * whichever resident happened to be woken last writes into that resident's private library with
+       * no indication that the attribution was invented (AUDIT-CHECKLIST §0.2: identity is never
+       * inferred from global mutable state). Such a call now fails explicitly with 'no such resident'.
+       */
+      residentIdOf:(agent)=>{ const m=residentOfAgent(agent); if(m) return m
+        let hasId=false; try { hasId=!!(agent&&agent.id) } catch(e){ hasId=false }
+        if(hasId) return ''
+        const c=currentResident; return (c && residents.has(c)) ? c : '' },
       useResident:(id)=>{ currentResident=id },
       publishProgress, recordProposition, recordMethod, recordSubproblem, listResidents, reportContext,
       proposeTask, claimTask, taskDone, listTasks,
@@ -2071,6 +3132,12 @@ export function apply(ctx) {
         // `vs` mirrors the live verification state ({targetId,targetType,targetOwner,stage,history,verdicts});
         // pass one explicitly to ask "what WOULD the voters read for this object right now?".
         verify:(rId,vs)=>{ const r=residents.get(String(rId)); return r?verifyPrompt(r, vs||verifyState||{targetId:'',targetType:'proposition',targetOwner:'',stage:'independent',verdicts:{}}):'' },
+        // The meeting prompt is the ONLY group-chat / task-allocation / stop-vote surface this preset
+        // has, so a host (or the audit corpus) must be able to READ it. Pass `st` to ask "what would
+        // the next speaker read right now?"; the live meeting state is the default.
+        meeting:(rId,st)=>{ const r=residents.get(String(rId)); if(!r) return ''
+          const s=st||meetingState||{agenda:'（无进行中的会议）',type:'general',inputs:{},order:[]}
+          return meetingPrompt(r,s) },
         formalBlock:(target)=>formalPromptBlock(target),
         formalWorkLine:()=>formalWorkLine(),
       },
@@ -2081,9 +3148,15 @@ export function apply(ctx) {
         if(which==='brainstorm') return brainstormPrompt(r)
         if(which==='heartbeat') return heartbeatPrompt(r)
         if(which==='coreRules') return coreRulesBrief()
+        if(which==='meeting') return (arg&&arg.meeting)?meetingPrompt(r,arg.meeting):(meetingState?meetingPrompt(r,meetingState):meetingPrompt(r,{agenda:'（无进行中的会议）',type:'general',inputs:{},order:[]}))
         if(which==='verify'){
           const target=idSafe(String((arg&&arg.target)||''))
-          return verifyPrompt(r,{targetId:target,targetType:guessTargetType(target),targetOwner:'',stage:String((arg&&arg.stage)||'independent'),history:{},verdicts:{}})
+          // F14 的同一条尺子：前缀（p-/m-/s-）就是对象归属的契约。此前的兜底把**任何**认不出的 id
+          // 都当成 proposition，于是这个"读真实提示词"的工具会展示一条带着错误对象类型的投票提示词
+          // （而真正入队的入口 maybeQueueVerify 已经拒绝这种 id）。认不出就如实拒绝，不猜。
+          const tt=guessTargetType(target)
+          if(!tt) return 'V4_INVALID_ARGUMENT: target must start with p- (proposition) / m- (method) / s- (subproblem) — cannot render a verification prompt for an unknown object kind'
+          return verifyPrompt(r,{targetId:target,targetType:tt,targetOwner:'',stage:String((arg&&arg.stage)||'independent'),history:{},verdicts:{}})
         }
         return normalPrompt(r)
       },
@@ -2117,7 +3190,7 @@ export function apply(ctx) {
   // The exact text a resident would receive. "成员读到的文字就是产品" (AUDIT-CHECKLIST §0.1): a host
   // (or an audit) must be able to READ the prompt, not just the tool return values, or a prompt
   // defect stays invisible. Pure builder calls — no side effects on the run.
-  registerTool('vibe_v4_prompts','Read the exact prompt text a resident would receive (which: brainstorm|normal|heartbeat|verify|coreRules). member = resident id; target/stage describe the object for `verify`. Prompt text is the product — this makes it auditable.',objParams({which:{type:'string',enum:['brainstorm','normal','heartbeat','verify','coreRules']},member:{type:'string'},target:{type:'string'},stage:{type:'string'}},['which']),async (s,a)=>{
+  registerTool('vibe_v4_prompts','Read the exact prompt text a resident would receive (which: brainstorm|normal|heartbeat|meeting|verify|coreRules). member = resident id; target/stage describe the object for `verify`. Prompt text is the product — this makes it auditable.',objParams({which:{type:'string',enum:['brainstorm','normal','heartbeat','meeting','verify','coreRules']},member:{type:'string'},target:{type:'string'},stage:{type:'string'}},['which']),async (s,a)=>{
     const which=String(a.which||'normal')
     if(which==='coreRules') return {ok:true,which,text:await s.promptApi.coreRules()}
     const text=await s.promptFor(which,String(a.member||'r-1'),a)
@@ -2135,7 +3208,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. 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.',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)=>{ s.setParams(a); return s.status() })
+  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; 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'}}),(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) })
@@ -2152,8 +3225,16 @@ export function apply(ctx) {
   registerTool('vibe_v4_list_tasks','(resident) List open tasks.',objParams({}),(s)=>({ok:true,tasks:s.listTasks()}))
   // context / compact (resident reports its context usage so the framework can /compact-equivalent)
   registerTool('vibe_v4_report_context','(resident) Report your context usage %; the framework compacts (self-summary) when it reaches compactThreshold.',objParams({pct:{type:'number'}},['pct']),(s,a,x)=>s.reportContext(s.residentIdOf(x),a.pct))
-  registerTool('vibe_v4_claim_write','Reserved: shared-file write lock (framework-managed).',objParams({target:{type:'string'}},['target']),(s,a)=>({ok:true,key:a.target}))
-  registerTool('vibe_v4_release_write','Reserved: shared-file write lock release.',objParams({target:{type:'string'}},['target']),(s,a)=>({ok:true,key:a.target}))
+  // NOT IMPLEMENTED — and the description says so. These two tools were registered with
+  // "Reserved: shared-file write lock", which reads as "the lock exists and works": a model following
+  // the v3 convention called `claim_write`, got `{ok:true}` and concluded it held a lock that no code
+  // anywhere implements (this preset has no shared file a resident writes — see the write-scope rule
+  // in `contextBrief`, which restricts every resident to its OWN Progress/Propos/Methods/Subproblems
+  // library, while the framework alone writes Shared/ and State/). They stay registered (removing them
+  // would change the model-visible tool surface) and keep echoing the key, but they now tell the
+  // truth: nothing is reserved, nothing is serialized, write only your own files.
+  registerTool('vibe_v4_claim_write','NOT IMPLEMENTED: no lock exists. This returns {ok:true} without reserving anything. Each resident writes only its own library (Progress/<you>/, Propos/<you>/, Methods/<you>/, Subproblems/<you>/), so overlapping writers are not expected; the framework alone writes Shared/ and State/ (serially, per file). Do not rely on this to exclude another resident.',objParams({target:{type:'string'}},['target']),(s,a)=>({ok:true,key:a.target,locked:false,note:'no lock is implemented; write only your own library files'}))
+  registerTool('vibe_v4_release_write','NOT IMPLEMENTED: there is no lock to release. Returns {ok:true} as a no-op so an agent that calls it out of habit is not misled into thinking it held a reservation.',objParams({target:{type:'string'}},['target']),(s,a)=>({ok:true,key:a.target,locked:false,note:'no lock is implemented; nothing was reserved'}))
 
   // ── Lean formal verification (docs/formal-verification.md §5) ─────────────
   // These three tools are registered UNCONDITIONALLY. Registration is STATIC (a mode-dependent
@@ -2174,13 +3255,16 @@ export function apply(ctx) {
   // 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)
       let r
       if(cmd==='configure') r=await s.configure({project:rest[0]||'', problem:parts.slice(2).join(' ')})
-      else if(cmd==='start') r=await s.start({})
+      // `/v4 start <problem>` is the natural way to try this out and the tool it mirrors accepts a
+      // problem, so the arguments are honoured instead of silently dropped (a bare `/v4 start` keeps
+      // using the configured problem).
+      else if(cmd==='start') r=await s.start(rest.length?{problem:rest.join(' ')}:{})
       else if(cmd==='resume') r=await s.resume()
       else if(cmd==='pause') r=s.setPause()
       else if(cmd==='abort') r=await s.initAbort()
@@ -2191,9 +3275,40 @@ export function apply(ctx) {
       else if(cmd==='members') r={ok:true,residents:s.listResidents()}
       else if(cmd==='add') r=await s.addMember(rest.join(' '))
       else if(cmd==='remove') r=await s.removeMember(rest[0]||'')
-      else if(cmd==='set'){ const upd={}; for(const tok of rest){ const eq=tok.indexOf('='); if(eq>0){ const k=tok.slice(0,eq); const rv=tok.slice(eq+1); const n=Number(rv); upd[k]=Number.isFinite(n)?n:rv } } r=s.setParams(upd) }
-      else r={ok:false,usage:'configure|start|resume|pause|abort|status|report|message <to|all> <content>|meeting|members|add|remove|set'}
-      return {kind:'success',text:JSON.stringify(r,null,2)}
+      else if(cmd==='set'){
+        // Keys are validated HERE and the value is handed to the same `normalizeParam` the tool path
+        // uses, so `/v4 set` cannot (a) coerce `provider=123` into a number for a string-typed key,
+        // or (b) report success for a typo that `setParams` would silently ignore.
+        const upd={}
+        const known=s.status().paramsKeys||[]
+        for(const tok of rest){
+          const eq=tok.indexOf('='); if(eq<=0) continue
+          const k=tok.slice(0,eq)
+          if(known.indexOf(k)<0){ r={ok:false,message:'unknown parameter: '+k+'（用 /v4 status 查看可调参数）'}; break }
+          upd[k]=tok.slice(eq+1)
+        }
+        if(r===undefined){
+          // Apply, then answer with the SAME shape the `vibe_v4_set` TOOL answers with (the current
+          // status + the applied/ignored bookkeeping): reporting only the raw setParams result would
+          // make the slash command a different, less useful surface than the tool it mirrors.
+          const res=s.setParams(upd)
+          const st=s.status()
+          r=(res&&res.ok===false)?Object.assign({},st,{ok:false,warning:res.message,ignored:res.ignored}):Object.assign({},st,{applied:res.applied})
+        }
+      }
+      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)
+      return {kind: failed?'error':'success', text:JSON.stringify(r,null,2)}
     },
   }))
 
@@ -2202,13 +3317,36 @@ export function apply(ctx) {
   // registry (dsh-subagent:1231 dispose -> dsh-agent:508 store.delete ->
   // dsh-subagent:1241 settle/emit), so an end-time `agents.get(childId)` can never
   // resolve. See `liveAgents` in the session body.
+  //
+  // DO NOT key this handler on `childOwner`: the host emits `subagent/start` INSIDE
+  // `startContinuable`'s await (dsh-subagent/lib/index.js:1116 → `observer.start` → emit at `:306`,
+  // and the direct `emit('subagent/start', …)` at `:279`), i.e. BEFORE that call resolves — and
+  // `spawnResident` can only learn `started.childId` after the resolve. Keying on it made this
+  // handler return for EVERY child, so `liveAgents` stayed empty for the whole run and the real
+  // `/compact` path (`liveAgentOf` → `if(!agent || !agent.session) return`) was dead code.
+  //
+  // Ownership is therefore resolved the other way round: the handler finds the (usually single)
+  // session whose spawn window is open and STASHES the Agent under the child id from the payload;
+  // `spawnResident` claims that stash the moment its call resolves. For a host that embeds the spawn
+  // label in the id, `ownsChild` can be decided from the payload alone — that path is used when no
+  // spawn window is open, so a `subagent/start` for a child we did not spawn is never recorded.
   ctx.on('subagent/start', function(info){
     if(!info || !info.id) return
-    const sid=childOwner.get(info.id); const s=sid!==undefined?sessions.get(sid):undefined
-    if(!s) return
     let agent
     try { agent = agents.get(info.id) } catch(e){ agent = undefined }
-    if(agent) s.rememberAgent(info.id, agent)
+    if(!agent) return
+    let s
+    try {
+      for(const [,ss] of sessions){
+        const open=ss.ownsChild && ss.ownsChild(info.id)
+        if(open){ s=ss; break }
+      }
+      if(!s){ const sid=childOwner.get(info.id); if(sid!==undefined) s=sessions.get(sid) }
+    } catch(e){ s=undefined }
+    if(s){ s.rememberAgent(info.id, agent); return }
+    // No owner yet — the spawn this child belongs to is still inside `startContinuable`. Stash it for
+    // the first session whose spawn window is open, so the claim after the resolve can find it.
+    for(const [,ss] of sessions){ if(ss.stashStartAgent){ ss.stashStartAgent(info.id, agent); return } }
   })
 
   ctx.on('subagent/end', function(info){