dsh-vibe-math 2.0.17 → 2.0.19

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-vibe-math",
   "description": "Multi-agent mathematical problem-solving & verification frameworks for DeepSeek Harness — THREE agent presets in one install: vibe-math-v2 (probability-driven: qs.json + Propos knowledge base + explorer→solver→review/debate verdict), vibe-math-v3 (THIRD-generation, recommended: paper-style Markdown knowledge base with Problems/Progress/Propos/Methods/Verified + planner-agent scheduling that decides the next N actions + universal theory/method invention library + agents write their own Markdown directly via a per-file write lock), and vibe-math-v4 (FOURTH-generation: persistent self-organizing resident subagents that message & meet to decide all tasks, verify only by unanimous consensus, /compact at a context threshold, and stop only when all agree the problem is solved). Installing this bundle auto-installs all three presets (v1 was removed at v2.0.0).",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"

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

@@ -46,7 +46,7 @@ export function apply(ctx) {
     let residents = new Map(), mailboxes = new Map(), taskboard = [], decisions = []
     let meetings = [], reports = [], activityLog = []
     let problemText = '', problemId = 'problem', runId = 'run-' + shortId()
-    let meetingState = null, verifyState = null, pendingVerify = null, pendingMeeting = null
+    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)
     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)
@@ -102,7 +102,22 @@ export function apply(ctx) {
     async function fsTarget(rel){ return await fs.resolve(rel,{cwd:frameworkRoot()}) }
     async function readText(rel){ try { const t=await fsTarget(rel); if(await fs.stat(t)===undefined) return undefined; return await fs.readText(t) } catch(e){ return undefined } }
     async function writeText(rel,content){ try { const t=await fsTarget(rel); await fs.writeText(t,content,undefined,undefined,getPolicy()); return true } catch(e){ return false } }
-    async function writeJson(rel,obj){ return await writeText(rel,JSON.stringify(obj,null,2)) }
+    // State files (taskboard/residents/session/mailboxes/decisions) are written by MANY concurrent
+    // flows (parallel resident turns + end handlers + tools). Two near-simultaneous writers of the
+    // SAME file each stringified their snapshot BEFORE their fs.writeText landed, so the writer with
+    // the OLDER snapshot could land LAST and silently erase the other's entry (e.g. two residents
+    // proposing tasks in the same tick → one task vanished from taskboard.json until the next save).
+    // Fix: serialize writes PER FILE, and defer JSON.stringify until the write actually runs (so the
+    // snapshot always reflects the newest in-memory state at execution time — late writers win with
+    // the FULL state, never with a stale subset).
+    const jsonQueues = new Map()   // rel -> tail promise (per-session file write chain)
+    function writeJson(rel,obj){
+      const key='j:'+rel
+      const prev=jsonQueues.get(key)||Promise.resolve(true)
+      const run=prev.catch(()=>{}).then(async ()=>{ try { const t=await fsTarget(rel); await fs.writeText(t,JSON.stringify(obj,null,2),undefined,undefined,getPolicy()); return true } catch(e){ return false } })
+      jsonQueues.set(key,run.catch(()=>{}))
+      return run
+    }
     async function readJson(rel){ const t=await readText(rel); if(t===undefined||t==='') return undefined; try { return JSON.parse(t) } catch(e){ return undefined } }
     async function ensureDirs(){ const base=frameworkRoot(); const dirs=['Problems','Progress','Propos','Methods','Subproblems','Shared/meetings','Shared/debates','Verified/命题','Verified/问题','Reliable','Notes','State']; return await runShell('New-Item -Force -ItemType Directory -Path '+[vibeRoot()+'/Projects'].concat(dirs.map(d=>base+'/'+d)).map(psQuote).join(',')+' | Out-Null') }
     async function readTextAbs(path){ try { const t=await fs.resolve(path); const s=await fs.stat(t); if(s===undefined) return undefined; return await fs.readText(t) } catch(e){ return undefined } }
@@ -218,7 +233,7 @@ export function apply(ctx) {
         +'\n团队成员：\n'+banner()+'\n'
         +'New items:\n'+ (await inboxText(r.rId)) +'\n'
         +'Reply with ONLY a JSON object:\n'
-        +'{"summary":"<what you did / decided this round, 1-3 sentences>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","claim_task":"<task id|null>","task_done":"<task id|null>","contextPct":40}'
+        +'{"summary":"<what you did / decided this round, 1-3 sentences>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","task_desc":"<optional: why this task matters / what it covers|null>","claim_task":"<task id|null>","task_done":"<task id|null>","contextPct":40}'
     }
     function meetingPrompt(r, st){
       const prior=Object.entries(st.inputs).filter(([k])=>k!==r.rId).map(([k,iv])=>'  ['+k+'] '+String(iv.input||iv.summary||'')).join('\n')
@@ -306,10 +321,10 @@ export function apply(ctx) {
     function byChild(childId){ for(const [,r] of residents){ if(r.childId===childId) return r } return undefined }
 
     // ---- artifact writers (resident-facing) ----
-    async function publishProgress(rId,content){ const rel='Progress/'+rId+'/progress.md'; const prev=(await readText(rel))||''; await writeText(rel, prev+'\n### '+fmtTime()+'｜'+rId+'\n'+String(content||'')+'\n'); return {ok:true} }
-    async function recordProposition(rId,o){ const id=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){ const id=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){ const id=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'} }
+    async function publishProgress(rId,content){ if(!rId||!residents.has(rId)) return {ok:false,message:'no such resident'} ; const rel='Progress/'+rId+'/progress.md'; const prev=(await readText(rel))||''; await writeText(rel, prev+'\n### '+fmtTime()+'｜'+rId+'\n'+String(content||'')+'\n'); return {ok:true} }
+    async function recordProposition(rId,o){ if(!rId||!residents.has(rId)) return {ok:false,message:'no such resident'} ; const id=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||('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||('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 new artifacts, convene a general coordination meeting
     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):''})) }
@@ -373,13 +388,17 @@ export function apply(ctx) {
     // ---- meeting ----
     async function startMeeting(agenda,type,targetId){
       if(meetingState) return {ok:false,message:'meeting already in progress'}
-      // A meeting must NOT preempt an active or pending verification (unanimous-consensus is the
-      // group's truth-making step; preempting it would let every round resurface the same conflict).
-      // Wait instead of stealing the floor: park the request and resume it after the verify settles.
-      if(verifyState || pendingVerify){
-        // Keep the FIRST deferred request (never overwrite an earlier one with a later agenda).
+      // Park-and-resume (never lose a coordination request, never create a zombie): while a
+      // verification holds the floor, while the group is still brainstorming (members are busy in
+      // their first rounds — a meeting started there could not be serviced and the old code let its
+      // stall watchdog silently ABANDON it minutes later), or while the run is paused, the meeting
+      // request is parked in pendingMeeting (FIRST request wins) and starts as soon as the floor is
+      // free. A never-started session (no residents to talk) and a concluded run (autoDone) refuse
+      // instead — convening there previously created a meeting nobody could ever be woken into.
+      if(!running || autoDone || phase==='brainstorm' || verifyState || pendingVerify.length>0){
+        if(autoDone || (!running && residents.size===0)) return {ok:false,message:'run is not active (use vibe_v4_start or vibe_v4_resume first)'}
         if(!pendingMeeting) pendingMeeting = { agenda, type:type||'general', targetId:targetId||null }
-        return {ok:true,deferred:true,during:'verify'}
+        return {ok:true,deferred:true,during: phase==='brainstorm'?'brainstorm':(!running?'paused':'verify')}
       }
       clearHeartbeat()
       const ids=Array.from(residents.keys())
@@ -447,18 +466,18 @@ export function apply(ctx) {
     async function beginVerify(pv){
       clearHeartbeat()
       // Re-check dedup at ACTUAL start, not just at propose time: a resident may propose object X while
-      // X is already being verified (it does not know). That proposal sits in pendingVerify; when the
-      // current X verify closes, beginVerify would run X end-to-end a SECOND time (test9: p-r3-04 was
-      // verified twice back-to-back). Drop it if X was closed within the dedup window.
+      // X is already being verified (it does not know). That proposal sits in the pendingVerify queue;
+      // when the current X verify closes, beginVerify would run X end-to-end a SECOND time (test9:
+      // p-r3-04 was verified twice back-to-back). Drop it if X was closed within the dedup window.
+      // (pv was already popped from the FIFO queue by scheduleNext — nothing else to clear here.)
       const tgt=pv&&pv.targetId?String(pv.targetId):''
       if(tgt){
         const last=verifiedRecently.get(tgt)
         if(last!==undefined && (now()-last) < recoverStallMs()){
           logActivity('verify',tgt+' queued verify dropped at start (just verified at '+fmtTime(last)+')')
-          pendingVerify=null; await saveAll(); await scheduleNext(); return
+          await saveAll(); await scheduleNext(); return
         }
       }
-      pendingVerify=null
       verifyState={targetId:pv.targetId,targetType:pv.targetType,targetOwner:pv.proposer||'',stage:'independent',round:0,asked:[],verdicts:{},history:{},transcript:[],at:now(),lastVerdictAt:now()}
       markProgress();
       logActivity('verify','debate begin: '+pv.targetId+' ('+pv.targetType+')'); await saveAll(); await scheduleNext()
@@ -526,10 +545,12 @@ export function apply(ctx) {
       // never swallowed by the still-held reentry lock)
     }
     // Queue a verify proposal UNLESS the same object was just verified (closed as 真/假). In parallel
-    // self-organization several residents may independently propose the same target while a verify is
-    // already settling; without the guard the object gets re-verified end-to-end a second time (test9:
-    // p-r3-04 was Verified twice back-to-back). A resident who genuinely extends the object later can
-    // still re-propose after the dedup window (recoverStallMs) has passed.
+    // self-organization several residents may independently propose targets while a verify is already
+    // settling — sometimes the SAME object (test9: p-r3-04 was Verified twice back-to-back), sometimes
+    // DIFFERENT objects (e.g. a sync meeting where each member proposes its own target). pendingVerify
+    // is therefore a FIFO queue with per-target dedup: every distinct proposal is honored in order, and
+    // duplicates collapse to one entry. A resident who genuinely extends the object later can still
+    // re-propose after the dedup window (recoverStallMs) has passed.
     function maybeQueueVerify(target, proposer){
       const t=String(target||'').trim()
       if(!t) return false
@@ -538,7 +559,8 @@ export function apply(ctx) {
         logActivity('verify',t+' re-propose ignored (just verified at '+fmtTime(last)+')')
         return false
       }
-      pendingVerify={targetId:t,targetType:guessTargetType(t),proposer:proposer||'',at:now()}
+      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()})
       return true
     }
     async function writeDebateDoc(vs,done,val){
@@ -631,7 +653,7 @@ export function apply(ctx) {
       return (params.residentPersona?params.residentPersona+'\n':'')
         +'Resident researcher '+r.rId+' — CHECKPOINT（团队空闲，请由你们继续自主推进）。当前项目尚未解决（除非你已确认）。团队在等待有人继续：请**继续解决这个问题**——读他人的库对齐、推进某个子问题/引理/方法、尝试一条路线；或向团队发消息（input）、提议任务（propose_task）让大家分工。若你确实认为问题已解决、或已彻底无路可走，才提议开会（propose_meeting）让团队表决/商量、或声明 solved=true。默认立场是：**请推进，而不是停在原地。**\n'
         +'Reply with ONLY a JSON object:\n'
-        +'{"summary":"<what you will do / what you advanced this round>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","claim_task":"<id|null>","contextPct":40}'
+        +'{"summary":"<what you will do / what you advanced this round>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","task_desc":"<optional: why this task matters / what it covers|null>","claim_task":"<id|null>","contextPct":40}'
     }
     function clearHeartbeat(){ if(heartbeatDisposer!==null){ try{ heartbeatDisposer() }catch(e){} heartbeatDisposer=null } }
     function armHeartbeat(){
@@ -666,9 +688,9 @@ export function apply(ctx) {
       if(phase==='brainstorm'){ await maybeFinishBrainstorm(); return }
       if(meetingState){ await continueMeetingRound(); return }
       if(verifyState){ await continueVerifyRound(); return }
-      if(pendingVerify){ const pv=pendingVerify; await beginVerify(pv); return }
+      if(pendingVerify.length){ const pv=pendingVerify.shift(); await beginVerify(pv); return }
       // A meeting requested while a verify held the floor is parked in pendingMeeting; once the
-      // verify has truly settled (no verifyState / pendingVerify), resume it before anything else.
+      // 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
       const delivered=await deliverNextMailbox(); if(delivered) return
@@ -680,7 +702,7 @@ export function apply(ctx) {
       //    (framework convenes & records; residents decide — never assigns work). Only when no
       //    meeting/verify/pending work is active AND no resident is currently working (so it never
       //    preempts an in-flight round).
-      if(phase==='active' && !meetingState && !verifyState && !pendingVerify && busy.size===0){
+      if(phase==='active' && !meetingState && !verifyState && pendingVerify.length===0 && busy.size===0){
         const stallMs=Number(params.stallAutoMeetingMs)||((Number(params.activityTimeoutMs)||120000)*3)
         if(now()-lastProgressAt>=stallMs){
           await startMeeting('团队较长时间没有新进展。请你们自行讨论：当前问题是否已解决、开放难点是什么、谁负责哪部分、下一步如何推进，并自主决定是否继续。框架只负责转达与记录，不替你们决定。','general',null)
@@ -752,7 +774,13 @@ export function apply(ctx) {
     // ---- resident end handler ----
     async function onResidentEnd(childId, info){
       const r=byChild(childId); if(!r) return
-      busy.delete(r.rId)
+      // A turn that is NOT marked busy is a duplicate/stale end (the same subagent/end delivered twice,
+      // or an end for a turn already settled). Without this guard every side effect below — task
+      // proposal, group relay, verify queueing, meetings.push — would run a SECOND time (the
+      // duplicate-task/duplicate-stop class from test9 reappears whenever a host re-delivers an end).
+      // Every legitimate end corresponds to a busy turn: busy is added at spawn/wake and cleared only
+      // here, on wake failure, on removeMember, or on respawn (whose stale childIds no longer match).
+      if(!busy.delete(r.rId)) return
       // Any resident turn that COMPLETED is real activity for the stall clock (B). Residents frequently
       // write their libraries via direct fs (not the record* tools), so relying only on
       // bumpArtifacts/markProgress would leave lastProgressAt stale and B would fire against an active
@@ -769,21 +797,29 @@ export function apply(ctx) {
         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()
         if(parsed.propose_verify) maybeQueueVerify(parsed.propose_verify, r.rId)
-        await saveAll(); await continueMeetingRound(); return
+        await saveAll()
+        // PAUSE/stop: record the in-flight input/verdict but do NOT start any NEW consensus wake —
+        // a paused run must stay paused (resume() refreshes the consensus clocks and re-drives).
+        if(!running || autoDone) return
+        await continueMeetingRound(); return
       }
       if((kind==='verif-ind'||kind==='verif-deb') && verifyState){
         const v=(parsed&&parsed.vote)||{}
         // verdict = 0-1 probability the object is TRUE (1=绝对真, 0=绝对假, 0.5=不确定);
-        // also accept legacy 'TRUE'/'FALSE' strings.
+        // also accept legacy 'TRUE'/'FALSE' strings AND quoted numeric strings ("0.9"), which LLMs
+        // occasionally emit — without this a confident "0.9" was silently misread as 0.5 (uncertainty).
         let p
         if(typeof v.verdict==='number'){ p=clamp01(v.verdict) }
         else if(/^TRUE$/i.test(String(v.verdict))){ p=1 }
         else if(/^FALSE$/i.test(String(v.verdict))){ p=0 }
+        else if(typeof v.verdict==='string' && v.verdict.trim()!=='' && Number.isFinite(Number(v.verdict))){ p=clamp01(Number(v.verdict)) }
         else { p=clamp01(Number(v.confidence)) }
         // verdict is a PURE 0-1 probability (a degree); no binary TRUE/FALSE classification.
         verifyState.verdicts[r.rId]={prob:p,confidence:p,reason:String(v.reason||parsed.summary||'')}
         verifyState.lastVerdictAt=now()
-        await saveAll(); await continueVerifyRound(); return
+        await saveAll()
+        if(!running || autoDone) return   // pause: freeze (resume refreshes the clocks and re-drives)
+        await continueVerifyRound(); return
       }
       // normal turn
       if(r.status==='brainstorm'){ r.insight=parsed.summary||output; r.status='active' }
@@ -817,7 +853,11 @@ export function apply(ctx) {
       if(residentCount) params.residentCount=Number(residentCount)||4
       running=true; autoDone=false; phase='brainstorm'
       await writeText('Problems/'+problemId+'.md','# 问题｜'+problemId+'\n- ID: '+problemId+'\n- 类型: 问题\n- 状态: 求解中\n- 优先级: 1\n- 依赖: []\n\n## 陈述\n'+problemText+'\n')
-      residents=new Map(); mailboxes=new Map(); taskboard=[]; decisions=[]; meetings=[]; reports=[]; verifyState=null; meetingState=null; pendingVerify=null; residentSeq=0; artifactCount=0; clearHeartbeat()
+      // A reused session may still have OLD residents in flight from a previous run (start is a FRESH
+      // run that reuses the same r-1.. library paths). Interrupt them BEFORE resetting, otherwise their
+      // still-running turns keep writing into the same per-resident files the new run is about to use.
+      for(const [,or] of residents){ if(or.childId){ try{ subagents.interrupt(or.childId,{kind:'ancestor',agent:rootAgent}) }catch(e){} } }
+      residents=new Map(); mailboxes=new Map(); taskboard=[]; decisions=[]; meetings=[]; reports=[]; verifyState=null; meetingState=null; pendingVerify=[]; residentSeq=0; artifactCount=0; clearHeartbeat()
       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
       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):[]
@@ -826,6 +866,10 @@ export function apply(ctx) {
     }
     async function resume(){
       currentProject=await readCurrentProject(); await ensureDirs(); await loadAll(); await loadSettings()
+      // A run the group CONCLUDED (unanimous voteSolved → autoDone) must not be silently revived into
+      // a zombie that keeps waking residents with no consensus that it should still run. The group
+      // decided it is done; continuing means a NEW run (vibe_v4_start / vibe_v4_configure).
+      if(autoDone) return {ok:false,message:'This run already concluded (all residents agreed solved). Start a fresh run with vibe_v4_start (vibe_v4_configure a new problem first if needed).'}
       // After loadAll the residentSeq counter is still whatever THIS process had (0 on a fresh process),
       // but persisted residents may already be r-1..r-N. Sync it to the max existing id so a later
       // addMember never collides with an existing resident (it would silently overwrite it).
@@ -844,22 +888,29 @@ export function apply(ctx) {
       const needRespawn = Array.from(residents.values()).some(r=>!r.childId)
       if(needRespawn){
         for(const [,r] of residents){ r.childId=''; r.status='brainstorm'; r.insight=''; r.roundsSinceCompact=0 }
-        busy=new Set(); wakeKind=new Map(); currentResident=''; pendingMeeting=null; pendingVerify=null; verifyState=null; meetingState=null; finalizeLock=null; verifiedRecently.clear()
+        busy=new Set(); wakeKind=new Map(); currentResident=''; pendingMeeting=null; pendingVerify=[]; verifyState=null; meetingState=null; finalizeLock=null; verifiedRecently.clear()
       }
       for(const [,r] of residents){ if(!r.childId){ await spawnResident(r) } }
       if(!running){ running=true; autoDone=false; if(phase==='idle') phase='active' }
       if(needRespawn && phase!=='brainstorm') phase='brainstorm'   // let re-spawned residents re-bootstrap together
+      // A pause froze an in-progress meeting/verify with its watchdog clock still running: refresh the
+      // clocks so a resumed consensus gets a full fresh stall window instead of being abandoned the
+      // instant it is serviced again (a short pause must never silently kill a real discussion).
+      if(meetingState && meetingState.lastInputAt) meetingState.lastInputAt=now()
+      if(verifyState && verifyState.lastVerdictAt) verifyState.lastVerdictAt=now()
       logActivity('resume','restarted'+(crossProcess?' (cross-process: re-spawned)':needRespawn?' (re-spawned)':'')); await saveAll(); await scheduleNext(); return {ok:true,message:'resumed',project:currentProject}
     }
     function status(){ return { ok:true, running, phase, autoDone, project:currentProject, residentCount:residents.size,
       residents:listResidents(), busy:[...busy], taskboard:taskboard.length,
-      meetingInProgress: !!(meetingState), verifyInProgress: !!(verifyState), pendingVerify: pendingVerify?pendingVerify.targetId:null,
+      meetingInProgress: !!(meetingState), verifyInProgress: !!(verifyState), pendingVerify: pendingVerify.length?pendingVerify[0].targetId:null, pendingVerifyCount: pendingVerify.length,
+      parkedMeeting: pendingMeeting?pendingMeeting.agenda:null,
       params:['residentCount','compactAfterRounds','compactThreshold','maxParallel','activityTimeoutMs','meetingKeepEvery','verdictMaxRounds','stallAutoMeetingMs','provider','model','residentPersona','toolAllow','toolDeny'].map(k=>k+'='+(Array.isArray(params[k])?params[k].join(','):params[k])).join(', ') } }
     function report(){ return { ok:true, running, phase, autoDone, project:currentProject, problem:problemText,
       residents:listResidents(), taskboard:taskboard.filter(t=>t.status!=='done'),
       meeting: meetingState?{id:meetingState.id, agenda:meetingState.agenda, spoke:Object.keys(meetingState.inputs).length+'/'+residents.size}:null,
       verify: verifyState?{target:verifyState.targetId,stage:verifyState.stage, voted:Object.keys(verifyState.verdicts).length+'/'+residents.size}:null,
-      pendingVerify: pendingVerify?pendingVerify.targetId:null,
+      pendingVerify: pendingVerify.length?pendingVerify[0].targetId:null,
+      parkedMeeting: pendingMeeting?pendingMeeting.agenda:null,
       meetings:meetings.length, recentActivity: activityLog.slice(-8) } }
     async function addMember(direction){ const r=newResident(direction||''); await spawnResident(r)
       // Mid-meeting additions must join the meeting's speaking order; otherwise allSpoke (over CURRENT
@@ -869,14 +920,24 @@ export function apply(ctx) {
       // Mid-verify additions are automatically asked to vote (continueVerifyRound recomputes ids from
       // the live residents map), so no extra handling is needed there.
       return {ok:true,id:r.rId,direction:r.direction} }
-    async function removeMember(id){ const r=residents.get(id); if(!r) return {ok:false}; if(r.childId){ try{ subagents.interrupt(r.childId,{kind:'ancestor',agent:rootAgent}) }catch(e){} } residents.delete(id); busy.delete(id); mailboxes.delete(id); wakeKind.delete(id)
+    async function removeMember(id){ const r=residents.get(id); if(!r) return {ok:false}; if(r.childId){ try{ subagents.interrupt(r.childId,{kind:'ancestor',agent:rootAgent}) }catch(e){} } residents.delete(id); busy.delete(id); mailboxes.delete(id); wakeKind.delete(id); if(currentResident===id) currentResident=''
       // Reconcile in-progress coordination so a removed member cannot hang consensus or crash a round:
-      // drop its meeting speech / verify verdict / deferred-meeting / pending-verify if it owned them, and
-      // prune it from the meeting's speaking order so the find() there never selects a ghost.
+      // drop its meeting speech / verify verdict and prune it from the meeting's speaking order so the
+      // find() there never selects a ghost. Its QUEUED verify proposals are deliberately KEPT: a
+      // proposal is a statement about an OBJECT the group can judge on its merits with its CURRENT
+      // members (allVoted recomputes over the live residents), and dropping the queue entry would also
+      // erase the intent of any OTHER member who independently proposed the same target (dedup keeps
+      // only the first entry, which may belong to the removed member).
       if(meetingState){ delete meetingState.inputs[id]; meetingState.order=(meetingState.order||[]).filter(x=>x!==id) }
       if(verifyState){ delete verifyState.verdicts[id] }
-      if(pendingVerify && pendingVerify.proposer===id) pendingVerify=null
-      await saveAll(); return {ok:true} }
+      await saveAll()
+      // Re-drive the scheduler right away. If the removed member was the ONLY turn in flight (e.g. the
+      // last unspoken meeting speaker / the last unvoted voter, interrupted mid-turn), NO subagent/end
+      // will ever arrive to trigger the next pass, and while a consensus is being serviced no heartbeat
+      // is armed either — without this kick the meeting/verify would freeze forever behind members that
+      // can already conclude. scheduleNext no-ops safely when the run is paused/stopped.
+      await scheduleNext()
+      return {ok:true} }
     // Normalize one parameter value to its intended type so a string from /v4 set or configure
     // becomes the right number/array. Keeps settings.json clean regardless of how it was set.
     function normalizeParam(k, v){
@@ -909,7 +970,7 @@ export function apply(ctx) {
       onResidentEnd, start, resume, status, report, addMember, removeMember, setParams,
       setPause, initAbort, postMessage, startMeeting, saveAll, broadcast, configure, loadSettings,
       currentResident:()=>currentResident,
-      residentIdOf:(agent)=>{ const m=residentOfAgent(agent); return m||currentResident },
+      residentIdOf:(agent)=>{ const m=residentOfAgent(agent); if(m) return m; const c=currentResident; return (c && residents.has(c)) ? c : '' },
       useResident:(id)=>{ currentResident=id },
       publishProgress, recordProposition, recordMethod, recordSubproblem, listResidents, reportContext,
       proposeTask, claimTask, taskDone, listTasks,

package/vibe-math-v4//345/256/236/347/216/260/346/226/271/346/241/210.md

@@ -570,7 +570,35 @@ VibeMath/Projects/<project>/
 >
 > 说明：无法对"某常驻真的拒绝/掉线"的情况达成全体一致时，看门狗会把该对象保留为"未定论/带概率"，这是哲学上期望的诚实结果。`session.json` 仍不持久化 `meetingState`（进行中的会议不跨进程恢复），B 的停滞看门狗在重启后仍会触发，因此重启也能自愈。
 >
-> 全套测试仍全绿：`selfdrive-v4` 21/21、`e2e-v4-fixes` 61/61（含 T20 源卡回写 / T21 终结重入 / T22 验证去重）、v3 100/100、v2 business 18/regression 14、multisession 25/25。
+> 全套测试仍全绿：`selfdrive-v4` 21/21、`e2e-v4-fixes` 94/94（T1–T32，后续审计回归见 §27/§28）、v3 100/100、v2 business 18/regression 14、multisession 25/25。
+
+## 27. 第三轮全面深度审计（npm v2.0.18，牵连对象/逻辑）
+
+对 v2.0.16/17 修复做连带对象与逻辑审计，又发现并修复 6 处真实缺陷（每处均有新回归 T24–T28 钉住）：
+
+- **验证提议单槽丢失（pendingVerify 改 FIFO 队列）**：旧实现 `pendingVerify` 是单槽，后到覆盖先到——一次同步会议里多位常驻**各自提议不同对象**（或并行普通轮同时提议）时，只有最后一个对象的验证会被执行，前面的提议**静默丢失**（正是"框架忠实转达"哲学最不能丢的一环）。修复：改为 FIFO 队列 + 队内同目标去重（`maybeQueueVerify` 去重窗口后入队；`scheduleNext` 出队头启动；`beginVerify` 的"启动时二次去重"保留；`removeMember` 过滤其名下在队提议；status/report 显示队头 + `pendingVerifyCount`）。**T25**：一次会议两个成员各提议一个对象 → 两个都完整验证到 Verified/。
+- **removeMember 后不再驱动调度 → 共识永久冻结**：会议/验证在服务中不武装心跳，靠"常驻 end 事件"推进。若被移除的常驻恰是**唯一在途**的那一个（如最后一个未投票者/未发言者，interrupt 后不会再发 end），其余常驻明明已齐票/齐发言却没人触发 finalize——没有看门狗能救（看门狗也在 end 驱动的轮次里），**永久冻结**。修复：`removeMember` 清理后立即 `await scheduleNext()`（顺带把 `currentResident` 复位）。**T26**：验证中移除在途未投票者（mock 永不发 end）→ 验证在剩余成员间照常达成全票、正常定论。
+- **会议在 brainstorm/暂停期"假启动"后被看门狗误杀**：会议在 brainstorm 阶段（成员都在首轮思考）或暂停期间无法被服务，但它的看门狗时钟在创建时就开始走；几分钟后真正轮到它时已被判定卡死而**放弃**（主持人/常驻的会议请求被静默吞掉）。修复：`startMeeting` 在这两种情形（以及验证占场、暂停）一律**暂存到 `pendingMeeting`**（首条优先、不覆盖），等 brainstorm 完成/验证清空/恢复后再真正开始（时钟从真正开始时算）；从未启动（无成员）与已全票定论（autoDone）的运行则**明确拒绝**——旧代码在那里开会只会造出一个谁也唤不醒的僵尸会议。
+- **autoDone 后 resume 把已结束的 run 悄悄复活**：已全票定论（`autoDone`）的 run 被 resume 后会把 autoDone 清掉、继续唤醒常驻工作——违反"只有全组一致认为已解决才停止"的哲学（僵尸复活）。修复：`resume()` 在 autoDone 时拒绝并提示改用 `vibe_v4_start`/`vibe_v4_configure`。**T24**。
+- **暂停(Pause)不冻结共识;恢复后看门狗误杀进行中的会议/验证**：旧 setPause 只停 A/B 自驱动，进行中的会议/验证在常驻 end 后仍继续**新唤醒**（暂停不暂停）；而暂停期间时钟照走，恢复后若暂停超过看门狗窗口，进行中的会议/验证会被**立即放弃**。修复：end 处理器在 `!running` 时记录在途发言/投票后**不再启动新唤醒**（真暂停）；`resume()` 对仍在进行的 meeting/verify **刷新看门狗时钟**后继续。**T28**：暂停期间在途会议发言被记录但无新唤醒；恢复后会议照常收尾（转录文件写出）。
+- **writeJson 并发丢写（同文件延迟序列化）**：taskboard/session/residents 等 State 文件被并行轮、end 处理器、工具并发写；两个近同时写同一文件的流程各自在 fs.writeText 落地**之前**序列化快照，**旧快照后落地会覆盖新快照**（同一瞬间两位常驻各自 proposeTask → 其中一条从 taskboard.json 消失，直到下次保存才自愈）。修复：`writeJson` 按文件串行化 + **延迟到真正执行时才 JSON.stringify**（执行时取最新内存态，后写者永远带全量状态，不会用旧子集覆盖）。
+- **连带小修**：verdict 为**引号数字串**（`"0.9"`，LLM 常见）时旧解析落到 confidence 缺省 → 静默记成 0.5 不确定；现按数字解析。**T27**。
+- **start() 前中断旧常驻**：同一会话复用启动新 run 时，旧 run 仍在途的常驻会继续往**同名** `r-1..` 库路径写文件，与新 run 的 r-1.. 互相污染；start 重置前先 interrupt 旧常驻。
+
+> 设计边界复查确认（未改）：① 会议/验证轮次唤醒**不额外受 maxParallel 限制**——共识需要全员发言/投票；每个调度 pass 只唤醒一个未发言/未投票者，由各 end 事件串行驱动（残留的普通轮可能造成短暂并发，但不会无限累积）；② 非一致（平均概率留库）的对象可被后续提议**再次端到端验证**（去重窗口只挡"刚定论为真/假"的对象）——重复提议者是在不知情时提议的，重验一轮不算错；③ 验证中途 `addMember` 的新成员会被要求投票（v2.0.17 注释行为，保持）；④ 已定论 run 的成果随时可在磁盘读取，resume 拒绝只针对"自动复活"。
+
+## 28. 第四轮全面深度审计（npm v2.0.19，对 v2.0.18 修复的牵连检查）
+
+对 v2.0.18 的修复（FIFO 验证队列、会议暂存、暂停门控、writeJson 串行化等）做连带对象复查，发现并修复 4 处（新增回归 T29–T32）：
+
+- **同回合重复 `subagent/end` 会把每个副作用跑两遍**：`onResidentEnd` 对"已结算回合的重复/迟到 end"无守卫——重复投递同一 end（宿主重放、桥接层抖动）会让 propose_task / 群聊转发 / 验证入队 / meetings.push **全部二次执行**（test9 的重复任务/重复 stop 一类问题在"重复 end"场景会原样复发）。修复：回合必须以 busy 标记在册为前提——`if(!busy.delete(r.rId)) return`（每次合法 end 都对应一次 spawn/wake 置位的 busy；busy 仅在本处、唤醒失败、removeMember、重生成时清除，而后者 stale childId 已无法 byChild 命中）。**T29**：同一 tick 内连发两次相同 end → 任务只提议一次、群聊只转发一次。
+- **空/失效 rId 的 resident 写入工具会制造库根散卡**：`currentResident` 被复位为 `''`（如移除最后一名常驻后）时，主机/未知代理调用 `vibe_v4_record_*`/`vibe_v4_publish_progress` 会把路径 `Propos//p-x.md` 塌缩成**库根目录的散乱卡片**（正是 test9 曾出现的 0 字节散卡一类问题）。修复：`residentIdOf` 回退仅当 `currentResident` 仍真实存在时生效，否则返回 `''`；四个库写入函数对空/未知 rId 直接拒绝 `{ok:false}`（主机以 `currentResident` 代写这一既有便利不受影响——自驱动测试仍走该回退）。**T30**。
+- **移除者的已排队验证提议被丢弃 → 提议静默蒸发（含"第二提议者意图被去重吞掉"边角）**：v2.0.12 遗留的"移除提议者则清掉其 pendingVerify"在 FIFO 队列下会把该成员的排队提议**整条删除**；且同目标被两人提议时去重只保留第一人的条目——若第一人被移除，第二人的意图同样蒸发。修复：`removeMember` **不再过滤验证队列**——提议是关于对象的陈述，由**当前成员**按对象价值共识判定（allVoted 本就按实时成员集计算，写回扫描也不依赖提出者存续）。**T31**：r-3 提议 p-x 后在 p-y 验证中被移除 → p-x 仍由剩余成员完整验证到 Verified/。
+- **暂存的会议对用户不可见 / 普通轮提议任务永远没有描述**：`status/report` 新增 `parkedMeeting`（暂存会议议程），便于确认"会议没丢、在排队"（**T32** 同时钉住"brainstorm 期开会 → 暂存 → bootstrap 后真正召开"，不再被看门狗误杀）；普通轮/心跳提示词模板补上 `task_desc` 字段（此前普通轮提议任务时描述恒为空，只有会议轮能带描述）。
+
+> 边界复查（未改，记录）：brainstorm 阶段若某常驻首轮 end 永不触发，run 停在 brainstorm（brainstorm 无看门狗、无心跳可唤醒"已空闲"者推进）——真实 DSH 的轮次必然以 completed/error/timeout 结束并触发 end，纯属框架外故障，不做可能"静默丢掉慢成员声音"的自动跳过；`Shared/taskboard.md`（人类视图）由调用时快照生成、非逐文件串行，最坏情况短暂滞后于 `State/taskboard.json`（权威源），下次任务动作即自愈。
+>
+> 全套测试仍全绿：`selfdrive-v4` 21/21、`e2e-v4-fixes` 94/94（T1–T32）、v3 100/100、v2 business 18/regression 14、multisession 25/25、selfdrive-v3 0 异常。