dsh-vibe-math 2.0.21 → 2.0.22

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

@@ -1,1111 +1,1275 @@
-// Vibe Math V4 — persistent self-organizing collaborative research framework.
-// FACILITATOR (message bus / meetings / per-resident artifact libraries /
-// unanimous-consensus verification / context compaction proxy / resume / human
-// intervention). It NEVER assigns tasks: residents message & meet and decide all
-// task allocation among themselves. Consumes HOST subagents/agents/fs/tools/commands.
-// NOTE: must declare `inject` for every service read as a ctx property (the Guard
-// rejects undeclared dependencies), and must use the `timer` Service (ctx.timeout),
-// not global setTimeout/clearTimeout, which do not exist in the plugin runtime.
-export const inject = ['subagents', 'agents', 'fs', 'tools', 'commands', 'timer']
-export function apply(ctx) {
-  const subagents = ctx.subagents
-  const agents = ctx.agents
-  const fs = ctx.fs
-  const tools = ctx.tools
-  const commands = ctx.commands
-  const subprocess = ctx.get('subprocess')
-  const sandboxPolicy = ctx.get('sandboxPolicy')
-  const compaction = ctx.get('compaction')   // @deepseek-ai/dsh-compaction (CompactionEngine); optional
-
-  const sessions = new Map()      // rootAgentId -> Session
-  const childOwner = new Map()    // childId -> rootAgentId
-  const fileOwner = {}            // process-level write lock
-  const processEpoch = String(Date.now()) + '-' + Math.random().toString(36).slice(2, 8)
-
-  function sessionIdOf(agent){ try { return (agent&&agent.id)?String(agent.id):undefined } catch(e){ return undefined } }
-  function rootOf(agent){ try { let cur=agent; const seen=new Set(); while(cur){ const id=cur.id; if(seen.has(id)) return cur; seen.add(id); const p=(cur.session&&cur.session.header)?cur.session.header.parentSession:undefined; if(p===undefined) return cur; const par=agents.get(p); if(!par) return cur; cur=par } } catch(e){} return agent }
-  function getSession(agent){ const root=rootOf(agent); const sid=sessionIdOf(root); if(sid===undefined) return undefined; let s=sessions.get(sid); if(!s){ s=makeSession(root,sid); sessions.set(sid,s) } return s }
-
-  function makeSession(rootAgent, sessionId) {
-    let currentProject = 'default'
-    const DEFAULT_PARAMS = {
-      residentCount: 4, compactThreshold: 66, compactAfterRounds: 8,
-      maxParallel: 3, activityTimeoutMs: 120000, verdictMaxRounds: 3,
-      meetingKeepEvery: 5,   // 每积累 N 个新产物自动触发一次同步会议
-      stallAutoMeetingMs: 360000,   // 团队空闲且无新产物的"停滞阈值"：超过则自动召集同步会议（分级保活 B）
-      // model/provider inheritance: '' = the resident inherits the parent (main assistant)
-      // route (provider + model). Set them to override the resident's LLM backend/model.
-      provider: '', model: '', residentPersona: '',
-      // tool permissions: an allow/deny list of tool names applied via startContinuable's
-      // toolFilter (scoped tools.restrict() in the child). Empty = inherit all tools.
-      // CAUTION: only set one of these; an empty allow:[] would deny EVERY tool.
-      toolAllow: [], toolDeny: [],
-    }
-    let params = Object.assign({}, DEFAULT_PARAMS)
-    let running = false, autoDone = false, phase = 'idle'
-    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 = [], 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)
-    let lastActivityAt = now(), lastProgressAt = now(), artifactCount = 0, lastSyncMeetingAt = 0, persistedEpoch = '', heartbeatDisposer = null
-    const activityLogCap = 200
-
-    // ---- utils ----
-    function now(){ return Date.now() }
-    function uuid(){ const h='0123456789abcdef'; let s=''; for(let i=0;i<36;i++){ if(i===8||i===13||i===18||i===23) s+='-'; else s+=h[Math.floor(Math.random()*16)] } return s }
-    function shortId(){ const h='0123456789abcdef'; let s=''; for(let i=0;i<8;i++) s+=h[Math.floor(Math.random()*16)]; return s }
-    function clamp01(v){ const n=Number(v); if(!Number.isFinite(n)) return 0.5; return Math.max(0,Math.min(1,n)) }
-    function fmtTime(ts){ try { return new Date(ts||now()).toISOString().replace('T',' ').slice(0,19) } catch(e){ return String(ts||'') } }
-    function cl(x){ return clamp01(Number(x)) }
-    // contextPct is a PERCENT (0-100); never clamp to 0-1 or the compactThreshold
-    // comparison (e.g. 66) becomes `1.0 >= 66` and never fires.
-    function clPct(x){ const n=Number(x); if(!Number.isFinite(n)) return 0; return Math.max(0,Math.min(100,n)) }
-    function textBlock(t){ return { type:'text', text:String(t) } }
-    function blocksToText(b){ if(!b) return ''; let out=''; for(const x of b){ if(x&&x.type==='text'&&typeof x.text==='string') out+=x.text+'\n' } return out.trim() }
-    function logActivity(event,detail){ activityLog.push({at:now(),event,detail:String(detail||'')}); if(activityLog.length>activityLogCap) activityLog.shift() }
-    function logDecision(kind,detail){ decisions.push({at:now(),kind,detail:String(detail||'')}) }
-    // Record that the project made real progress (new artifact, meeting, verify, task, or a
-    // resident speaking to the group). The stall auto-sync meeting (B) fires only when this has
-    // NOT advanced for stallAutoMeetingMs, so a group that is genuinely producing keeps working
-    // and only a truly stalled group gets a coordination meeting to reboot itself.
-    function markProgress(){ lastProgressAt = now(); }
-    // How long a meeting/verify may run without collecting a new input/verdict before we treat it as
-    // deadlocked and abandon it. A meeting round's own signal window is activityTimeoutMs, so a
-    // resident should speak within that; 2× that without ANY new input/verdict means the meeting/verify
-    // is stuck and must not keep the whole group blocked.
-    // Positive duration with a safe fallback: a NEGATIVE/NaN activityTimeoutMs or stallAutoMeetingMs
-    // (misconfigured via vibe_v4_set) would otherwise make recoverStallMs negative → every meeting/
-    // verify watchdog fires INSTANTLY (abandoning all consensus) and A-fill's idle window would never
-    // elapse (waking everyone every pass). Guard every duration read with this.
-    function posMs(v,def){ const n=Number(v); return (Number.isFinite(n)&&n>0)?n:(def||120000) }
-    function recoverStallMs(){ return posMs(params.activityTimeoutMs,120000) * 2 }
-    function pickProvider(){ try { const n=subagents.list?subagents.list():[]; if(n.indexOf('spawn')!==-1) return 'spawn'; if(n.indexOf('fork')!==-1) return 'fork' } catch(e){} return 'spawn' }
-    // Per-resident model/provider inheritance: when params.provider / params.model are set,
-    // the resident uses that exact route; when left '' the resident inherits the parent's
-    // (main assistant) route — the documented DSH default (resolveChildAgentOptions merges
-    // requested over parent). No override is applied for empty values.
-    function residentAgentOptions(){ const ao={}; if(params.provider) ao.provider=params.provider; if(params.model) ao.model=params.model; return ao }
-    // Tool permission (scoped toolFilter). Only emit a filter when allow or deny has entries;
-    // an empty object is rejected by DSH ("must declare allow and/or deny").
-    function residentToolFilter(){
-      const allow=Array.isArray(params.toolAllow)?params.toolAllow.filter(x=>String(x).trim()):[]
-      const deny=Array.isArray(params.toolDeny)?params.toolDeny.filter(x=>String(x).trim()):[]
-      if(allow.length===0 && deny.length===0) return undefined
-      const f={}; if(allow.length) f.allow=allow; if(deny.length) f.deny=deny; return f
-    }
-    function makeSignal(ms){ return AbortSignal.timeout(posMs(ms,30000)) }
-    function workspaceRoot(){ try { if(rootAgent&&rootAgent.session&&rootAgent.session.header&&rootAgent.session.header.cwd) return rootAgent.session.header.cwd } catch(e){} if(sandboxPolicy&&sandboxPolicy.workspaceRoot) return sandboxPolicy.workspaceRoot; return '.' }
-    function vibeRoot(){ return (workspaceRoot()+'/VibeMath').replace(/\\/g,'/') }
-    function frameworkRoot(){ return vibeRoot()+'/Projects/'+currentProject }
-    function slugify(s){ const t=String(s==null?'':s).trim().toLowerCase().replace(/[^a-z0-9_\-\u4e00-\u9fa5]+/g,'-').replace(/^-+|-+$/g,''); return t||'project' }
-    // Object ids (verify targets, recorded cards) become FILE NAMES and DIRECTORY PATHS
-    // (Verified/命题/<id>.md, Shared/debates/<id>.md, Propos/<r>/<id>.md, source-card scans).
-    // A hostile/sloppy id containing path separators ('../../x') or Windows-forbidden chars would
-    // escape the project tree. Keep every harmless character (incl. Chinese) and replace only
-    // separators/control chars; strip leading/trailing dots/dashes so the name is never '.'/'..'.
-    function idSafe(s){
-      const t=String(s==null?'':s).trim().replace(/[\\/:*?"<>|\u0000-\u001f]+/g,'-').replace(/-{2,}/g,'-').replace(/^[.\-]+|[.\-]+$/g,'')
-      return t||'id'
-    }
-    function getPolicy(){ try { if(sandboxPolicy&&rootAgent&&rootAgent.session) return sandboxPolicy.resolve({session:rootAgent.session}) } catch(e){} try { if(sandboxPolicy) return sandboxPolicy.resolve({}) } catch(e){} return undefined }
-    function psQuote(p){ return "'"+String(p).replace(/'/g,"''")+"'" }
-    async function runShell(script,cwd){ if(subprocess===undefined) return {ok:false,error:'no-subprocess'}; try { const h=subprocess.spawn({argv:['powershell','-NoProfile','-NonInteractive','-Command',script],cwd:cwd||workspaceRoot(),stdio:{stdin:'ignore',stdout:'inherit',stderr:'inherit'},graceMs:20000}); const o=await h.done; return {ok:o.exitCode===0,exitCode:o.exitCode} } catch(e){ return {ok:false,error:String((e&&e.message)||e)} } }
-    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 } }
-    // 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 } }
-    async function writeTextAbs(path,content){ try { const t=await fs.resolve(path); await fs.writeText(t,content,undefined,undefined,getPolicy()); return true } catch(e){ return false } }
-    async function readCurrentProject(){ try { const t=await readTextAbs(vibeRoot()+'/.current'); if(t) return String(t).trim() } catch(e){} return currentProject }
-    async function writeCurrentProject(){ try { await writeTextAbs(vibeRoot()+'/.current', currentProject) } catch(e){} }
-    function tryJson(s){ try { return JSON.parse(s) } catch(e){ return undefined } }
-    function parseReply(text){
-      let obj; const fence=/```(?:json)?[ \t]*([\s\S]*?)```/gi; let m
-      while((m=fence.exec(text))!==null){ const o=tryJson(m[1].trim()); if(o&&typeof o==='object'&&!Array.isArray(o)) obj=o }
-      if(!obj){ const w=tryJson(text.trim()); if(w&&typeof w==='object'&&!Array.isArray(w)) obj=w }
-      return obj||{}
-    }
-
-    // ---- persistence ----
-    async function saveAll(){
-      await writeJson('State/residents.json', Object.fromEntries(residents))
-      await writeJson('State/mailboxes.json', Object.fromEntries(mailboxes))
-      await writeJson('State/taskboard.json', taskboard)
-      await writeJson('State/decisions.json', decisions)
-      await writeJson('State/session.json', {running,autoDone,phase,problemId,problemText,runId,meetings,reports,lastActivityAt,lastProgressAt,activityLog,processEpoch,artifactCount})
-    }
-    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 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
-      const dc=await readJson('State/decisions.json'); if(Array.isArray(dc)) decisions=dc
-    }
-
-    // ---- 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' }
-    function residentLibraries(){
-      const base=frameworkRoot()
-      return '你的资料库根目录：'+base+'/\n'
-        +'  Progress/<你>/progress.md —— 你的研究日志（叙述，可追加。主要内容是尝试过的各方法、路线、历程、进度，当前研究进展/进度、将来的计划与打算，及各路线、过程中遇到的障碍及其原因，对各路线、方法的看法、可行性评估，自己研究过程中的一些有价值看法、感想、猜想、理解。以及其它各种你认为有价值的值得记录的事物、经验、方法/想法、创新等都可进行记录）。\n'
-        +'  Propos/<你>/<id>.md —— 你的命题/引理。格式：\n'
-        +'    - ID: p-<id>; - 状态: 未定论; - 概率: <0-1>; - 价值程度: <0-1>; - 动机用途计划: <为何重要/打算怎么用>\n'
-        +'    然后 ## 陈述 <陈述>；## 证明尝试；## 证伪尝试。\n'
-        +'  Methods/<你>/<id>.md —— 你的理论/方法/工具。格式：- ID: m-<id>; - 状态: 经验; - 可信断言: []; - 价值程度: <0-1>; - 动机用途计划: ...；然后 ## 核心内容；## 定义与记号；## 应用记录；## 改进历史。\n'
-        +'  Subproblems/<你>/<id>.md —— 你的子问题。格式：- ID: s-<id>; - 状态: 求解中; - 价值程度: <0-1>; - 动机用途计划: ...；然后 ## 陈述；## 进度。\n'
-    }
-    function toolList(){
-      return 'vibe_v4_send_message {to, content} —— 给某常驻发消息（to=all 广播）。\n'
-        +'vibe_v4_meeting {agenda} —— 发起/参与会议（框架会把各常驻的实际 input 转给其他人，让大家看到并讨论/辩论）。\n'
-        +'vibe_v4_propose_task/claim_task/task_done/list_tasks —— 共享任务板（提议/认领/完成/查看；任务板是你们协调分工的载体）。\n'
-        +'vibe_v4_publish_progress/record_proposition/record_method/record_subproblem —— 便捷记录器（可选；推荐直接用 fs 写自己的文件）。\n'
-        +'vibe_v4_read_progress {id} —— 只读某常驻的进展。\n'
-        +'vibe_v4_list_residents / vibe_v4_list_tasks —— 查看团队组成 / 开放任务。\n'
-        +'vibe_v4_report_context {pct} —— 上报上下文占比（框架据此压缩你的上下文）。\n'
-        +'fs (read/write/list) —— 读取任意文件；写入你自己的文件（推荐直接用 fs 直接写自己的 md）。\n'
-    }
-    // A shared, complete context block so a resident always knows the situation: mission,
-    // work model, what it can do, which files it owns (+ formats), what others' files are,
-    // and that it may READ anyone and WRITE its own directly. level 'full' = initial brief.
-    function contextBrief(r, level){
-      const s=[]
-      s.push('## 背景 —— 你是常驻研究团队的一员')
-      s.push('You are resident researcher '+r.rId+'（常驻研究者 '+r.rId+'；共 '+params.residentCount+' 位常驻），正在协作解决：')
-      s.push(problemText)
-      s.push('')
-      s.push('这像一个**真实的学术小组**：没有中央调度器、没有外部派活——你们自己通过 **互相发消息 + 开会讨论** 来决定一切：谁做什么、怎么分工、验证什么、何时停止。你的 Round 决定你这一轮做什么；团队的优先级与分工由大家的讨论涌现。')
-      s.push('')
-      s.push('### 工作模式（会发生什么）')
-      s.push('1. 每人有一份持久、全组可见的专属资料库（见下）。')
-      s.push('2. 你们自由发消息、开会；**会议会把每个人实际说的话（input）转给其他人**，让你看得到、能回复、能讨论、能辩论。')
-      s.push('3. 你独立研究，并**直接用 fs 写入你自己的文件**（按格式），供全组阅读。')
-      s.push('4. 任何"已确立"的东西须**全组一致**验证（全真或全假）才作数；否则只是带概率的工作估计。')
-      s.push('5. 只有**全组在会议上一致认为原问题已解决**，run 才停止。')
-      s.push('')
-      s.push('### 你负责的文件（你只写自己的；但可读任何人的）')
-      s.push(residentLibraries())
-      s.push('其他人把结论/进展写进他们的目录，你就能读到。**你应主动读别人的库**，对齐事实、彼此衔接、避免重复劳动。')
-      if(level!=='full'){ s.push('（格式见你最初的说明；直接用 fs 写自己的文件即可。）') }
-      s.push('')
-      s.push('### 可用工具')
-      s.push(toolList())
-      s.push('')
-      if(level==='full'){
-        s.push('### 可自主发明理论/工具（鼓励，但不强迫）')
-        s.push('请注意：你可以（但**不强迫**，完全视实际需要而定）尝试自主构建新的理论框架或工具——例如对某种系统做抽象化、一般化，抽离/推广出更一般的结构或理论框架；然后不断完善这个理论框架，在该框架下推得各种定理、性质、结论，以利于该框架下问题的解决。这就像为解决方程问题发明了群论、为分析需要建立了泛函分析框架——它比单纯解决当前问题更有学术价值，因为你直接得到了一类更普遍的方法/理论体系。')
-        s.push('若你发明了这样的理论/工具，请**阐明它对原问题的用处、价值**；后续可根据需要不断**完善、一般化、推广**它。把这类成果记入你的 Methods/<你>/ 库。')
-        s.push('')
-      }
-      s.push('### 规则')
-      s.push('- 只有 Verified/（或卡片标"已验证·真/假"）算已确立；其余都是你的实验性工作，请区分"猜想/已知"。')
-      s.push('- 验证必须**全组一致**（全真或全假）；你只信全票结果。未全票的对象留在库里带概率。')
-      s.push('- 你自己决定做什么，但**优先级/分工由团队讨论决定**，不是固定模式。若你认为问题已解决或接近解决，请**发起会议**让团队表决。')
-      s.push('- 退出时**只**输出一个 JSON 对象（放在 ```json 代码围栏内；围栏外不要有文字）。')
-      return s.join('\n')
-    }
-    // A SHORT core-rules recap, re-injected ONLY right after a compaction so the resident
-    // never loses the ground rules (they are told fully once at brainstorm, but a /compact
-    // could blank them).
-    function coreRulesBrief(){
-      const base=frameworkRoot()
-      return '[核心规则重申] 只有 Verified/（及标记"已验证·真/假"）算已确立；验证须全组一致（全真或全假）才作数，否则留库附平均概率；你只写自己的库（'+base+'/ 的 Progress/<你>/、Propos/<你>/、Methods/<你>/、Subproblems/<你>/），可只读任何人的库；任务分工由团队讨论决定；退出只输出一个 JSON 对象。'
-    }
-    function brainstormPrompt(r){
-      return (params.residentPersona?params.residentPersona+'\n':'')
-        +contextBrief(r,'full')+'\n'
-        +(r.direction?('\n\n你被建议的初始方向（可自行调整/细化）：\n'+r.direction+'\n'):'')
-        +'## 这是你的第一轮：独立头脑风暴\n'
-        +'独立地想清楚：你对这个问题的洞察 / 解决方向 / 关键子问题 / 可能的引理 / 粗略计划。你还未见到其他人，先独立产出。\n'
-        +'把有价值的产物**直接用 fs 写进你自己的文件**（按上面格式），并在 summary 里概述你的切入方向与初步结论（标注哪些是猜想、哪些凭你已确证）。\n'
-        +'Reply with ONLY a JSON object:\n'
-        +'{"summary":"<your insight / direction / rough plan, one tight paragraph>","solved":false}'
-    }
-    async function normalPrompt(r){
-      return (params.residentPersona?params.residentPersona+'\n':'')
-        +'Resident researcher '+r.rId+' — 第 '+r.rounds+' 轮。一切由你和团队讨论决定。动手前先**读别人的库**对齐事实、避免重复；把新进展/结论**直接用 fs 写进你自己的文件**；想对团队说的话放 "input"（会转给其他常驻）。\n'
-        +'\n团队成员：\n'+banner()+'\n'
-        +'New items:\n'+ (await inboxText(r.rId)) +'\n'
-        +'Reply with ONLY a JSON object:\n'
-        +'{"summary":"<what you did / decided this round, 1-3 sentences>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","task_desc":"<optional: why this task matters / what it covers|null>","claim_task":"<task id|null>","task_done":"<task id|null>","contextPct":40}'
-    }
-    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')
-      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'
-        +'{"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){
-      // In a DEBATE round, show the PREVIOUS round's opinions (kept in vs.history) so the resident can
-      // see others' stances and give a fresh independent judgement; in the first (independent) round no
-      // others' opinions exist yet. vs.verdicts only ever holds the CURRENT round's votes.
-      const src = (vs.stage==='debate' && vs.history && Object.keys(vs.history).length>0) ? vs.history : (vs.stage==='debate' ? vs.verdicts : {})
-      const others=Object.entries(src).map(([k,v])=>'- '+k+': 正确概率 '+String(v.prob!=null?Number(v.prob).toFixed(2):0.5)+' → '+v.reason).join('\n')
-      return (params.residentPersona?params.residentPersona+'\n':'')
-        +'Resident '+r.rId+' — 团队验证。 The group is verifying object '+vs.targetId+'（'+vs.targetType+'，提出者 '+vs.targetOwner+'）。\n'
-        +'请给出你对「该对象为真」的**正确概率 `verdict`**，仅一个 0–1 数值：**1 = 绝对为真，0 = 绝对为假，0.5 = 完全不确定，其余为介于其间的程度**（不要给 TRUE/FALSE，就给一个数值）。\n'
-        +'判定规则：仅当**全体常驻一致给 1（都认为是真）或一致给 0（都认为是假）**，才按「真/假」写入 Verified/；否则**只作为概率数值（一种程度）保留在库中**，附全组平均正确概率，不写成真/假。\n'
-        +'请给出你**诚实独立的判断**'
-        +(vs.stage==='debate'?'，并参考他人意见：\n':'。\n')
-        +(vs.stage==='debate'&&others?('### 他人上一轮意见（已转发给你）\n'+others+'\n'):'')
-        +'\nReply with ONLY a JSON object:\n'
-        +'{"vote":{"verdict":0.9,"reason":"<your logic>"}}'
-    }
-
-    // ---- resident lifecycle ----
-    let residentSeq = 0
-    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){
-      const ao=residentAgentOptions(); const tf=residentToolFilter()
-      const started=await subagents.startContinuable({provider:pickProvider(),label:r.rId,request:{prompt:[textBlock(brainstormPrompt(r))],parent:rootAgent,agentOptions:ao,...(tf?{toolFilter:tf}:{})},signal:makeSignal(params.activityTimeoutMs||60000)})
-      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')+')')
-    }
-    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
-      // 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
-      //       re-anchor the short core rules on the next wake of ANY kind, then CLEAR the flag.
-      //       (Short recap only; no self-summary directive — the real compact already condensed.)
-      //   (b) soft-compact trigger (contextPct>=threshold OR roundsSinceCompact>=afterRounds) =>
-      //       the resident's context genuinely grew; ask it to self-summary. ONLY on a normal
-      //       research round (kind==='normal'): a meeting/verify reply has no contextPct/compacted
-      //       fields, so a directive injected there is never acknowledged and would repeat forever.
-      let prompt = promptText
-      const isNormal = (kind||'normal')==='normal'
-      const wantSoft = isNormal && (Number(r.contextPct)>=Number(params.compactThreshold) || Number(r.roundsSinceCompact)>=Number(params.compactAfterRounds))
-      const wantReanchor = r.needCompact
-      if(wantSoft){
-        prompt = coreRulesBrief() + '\n' +
-          '[CONTEXT COMPACT — your conversation is at/near the limit. Do NOT re-derive history.\n' +
-          'Condense your current working state into ONE tight self-summary (findings so far, active direction, key artifacts you recorded, next concrete steps, open questions), then answer this round in the normal JSON format as usual.\n' +
-          'Set "contextPct": 15 (your post-compact usage) and "compacted": true in the reply so the framework records the condensed seed.]\n\n' + promptText
-        r.needCompact = true
-      } else if(wantReanchor){
-        prompt = coreRulesBrief() + '\n' + prompt
-        r.needCompact = false
-      }
-      // The DSH continuable-wake API is subagents.sendMessage(sender, targetId, content, {signal}),
-      // NOT subagents.followup (which is only Agent.followup, and does NOT exist on the subagents
-      // service). Using a non-existent method threw TypeError and made EVERY wake fail silently →
-      // the group went idle forever. Prefer sendMessage; fall back to a legacy followup if a host
-      // still exposes it (older deployments), so this works across versions.
-      try {
-        if(typeof subagents.sendMessage==='function'){
-          await subagents.sendMessage(rootAgent, r.childId, [textBlock(prompt)], {signal: makeSignal(params.activityTimeoutMs||60000)})
-        } else if(typeof subagents.followup==='function'){
-          await subagents.followup(rootAgent, r.childId, [textBlock(prompt)], {source:{kind:'user'},signal:makeSignal(params.activityTimeoutMs||60000)})
-        } else {
-          throw new Error('no subagent continuation API (need sendMessage or followup)')
-        }
-        return true
-      }
-      catch(e){ console.error('vibe-v4 wake '+r.rId+' failed: '+String((e&&e.message)||e)); busy.delete(r.rId); return false }
-    }
-    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){ 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?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 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):''})) }
-    // 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
-    // libraries correct under concurrency (e.g. all brainstorm residents in flight).
-    function residentOfAgent(agent){ try { const id=agent&&agent.id?String(agent.id):''; if(!id) return ''; for(const [,r] of residents){ if(r.childId===id) return r.rId } } catch(e){} return '' }
-
-    // ---- task board (residents propose / claim / complete; framework wakes the claimer) ----
-    async function writeTaskboard(){ const lines=['# 任务板','']; for(const t of taskboard){ lines.push('- ['+t.status+'] '+t.title+(t.claimer?('（认领:'+t.claimer+'）'):'')+(t.proposer?('（提议:'+t.proposer+'）'):'')+(t.description?('：'+t.description):'')) } await writeText('Shared/taskboard.md',lines.join('\n')) }
-    async function proposeTask(title,description,proposer){ const id='t-'+shortId(); taskboard.push({id,title:String(title),description:String(description||''),status:'open',proposer:proposer||'',claimer:'',source:''}); await saveTaskboard(); markProgress(); logActivity('task','proposed '+id+'「'+title+'」'); return {ok:true,id} }
-    async function claimTask(id,claimer){ const t=taskboard.find(x=>x.id===id); if(!t) return {ok:false,message:'no such task'}; if(t.status!=='open') return {ok:false,message:'task already '+t.status}; t.status='claimed'; t.claimer=claimer; await saveTaskboard(); markProgress(); logActivity('task',claimer+' claimed '+id); 
-      // 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() }
-      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){
-      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)){
-        r.contextSeed=String(parsed.summary||r.contextSeed||'')
-        r.contextPct=Math.min(r.contextPct||15,25)
-        r.roundsSinceCompact=0
-        r.needCompact=false
-        logActivity('compact', r.rId+' consolidated context')
-      }
-    }
-
-    // ---- messaging ----
-    async function postMessage(from,to,content){
-      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 mb=mailboxes.get(to)||[]; mb.push({from,at:now(),content}); mailboxes.set(to,mb); await saveAll(); logActivity('message',from+'→'+to+' (queued)'); return {ok:true}
-    }
-    async function broadcast(content, from){
-      let n=0
-      for(const [,r] of residents){ if(from && r.rId===from) continue; const res=await postMessage(from||'facilitator',r.rId,content); if(res&&res.ok) n++ }
-      logActivity('broadcast','to '+n+' resident(s)'); await saveAll(); return {ok:true,message:'broadcast to '+n+' resident(s)'}
-    }
-    // group conversation relay: when a resident "speaks" (input in its round), forward its
-    // words to every other resident's inbox so the whole group can see & react — a real group chat.
-    async function relayToGroup(from, content){
-      const text=String(content||'').trim()
-      if(!text) return
-      for(const [,r] of residents){
-        if(r.rId===from) continue
-        const mb=mailboxes.get(r.rId)||[]; mb.push({from,at:now(),content:'[群聊] '+text}); mailboxes.set(r.rId,mb)
-      }
-      logActivity('relay',from+' → 团队: '+text.slice(0,60)); markProgress(); await saveAll()
-    }
-
-    // ---- meeting ----
-    async function startMeeting(agenda,type,targetId){
-      if(meetingState) return {ok:false,message:'meeting already in progress'}
-      // 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: phase==='brainstorm'?'brainstorm':(!running?'paused':'verify')}
-      }
-      clearHeartbeat()
-      const ids=Array.from(residents.keys())
-      // Rotate the per-meeting speaking order so the SAME resident isn't always the "first speaker
-      // who sees no one else's contribution"; a real discussion lets each member lead sometimes.
-      const rot=Math.floor(Math.random()*Math.max(1,ids.length))
-      const order=ids.slice(rot).concat(ids.slice(0,rot))
-      meetingState={id:'mt-'+shortId(),agenda,type:type||'general',targetId:targetId||null,round:0,asked:[],inputs:{},transcript:[],order,at:now(),lastInputAt:now()}
-      markProgress();
-      logActivity('meeting','start: '+agenda); await saveAll(); await scheduleNext(); return {ok:true,id:meetingState.id}
-    }
-    async function continueMeetingRound(){
-      if(!meetingState) return
-      const st=meetingState
-      // STUCK watchdog: a meeting that has been active but collected NO new input for a long while
-      // is deadlocked (e.g. an in-flight/hung resident, a run of failed wakes). Abandoning it returns
-      // the group to normal self-organization (A heartbeat / B auto-sync can then re-drive) instead of
-      // permanently blocking the whole group behind a broken meeting.
-      if(now()-(st.lastInputAt||st.at||now())>=recoverStallMs()){
-        meetingState=null; wakeKind.clear(); logActivity('meeting','abandoned (stuck: no resident spoke)')
-        await saveAll(); await scheduleNext(); return
-      }
-      const ids=Array.from(residents.keys()); const allSpoke=ids.every(id=>st.inputs[id]!==undefined)
-      if(allSpoke){ await finalizeMeeting(); return }
-      // only wake IDLE un-spoken residents (rotated order); in-flight ones re-trigger this on end.
-      // NOTE: we deliberately do NOT flush mailboxes here — drafting an un-spoken resident into a normal
-      // mail round would delay the meeting and can starve the consensus past its watchdog if the mail
-      // backlog is large. Mail is delivered on scheduleNext passes when no consensus is in progress.
-      const order=st.order||ids
-      const id=order.find(x=>st.inputs[x]===undefined && !busy.has(x))
-      if(!id){ armHeartbeat(); return }   // no idle un-spoken resident (a busy/hung one): re-check later
-      const r=residents.get(id)
-      const ok = await wakeResident(r, meetingPrompt(r,st), 'meeting'); await saveAll()
-      if(!ok) armHeartbeat()   // a failed meeting wake must NOT silently hang the meeting
-    }
-    async function finalizeMeeting(){
-      if(finalizeLock) return   // reentry guard: two onResidentEnd may both see allSpoke → only finalize once
-      finalizeLock='meeting'
-      let doSchedule=false
-      try {
-        const st=meetingState
-        const ids=Array.from(residents.keys()); const allSpoke=ids.length>0 && ids.every(id=>st.inputs[id]!==undefined)
-        const lines=['# 会议 '+st.id+'｜'+fmtTime(),'','**议程**：'+st.agenda,'']
-        for(const [id,iv] of Object.entries(st.inputs)){ lines.push('### '+id); lines.push(iv.input||''); lines.push('') }
-        await writeText('Shared/meetings/'+st.id+'.md', lines.join('\n'))
-        // the full transcript lives on disk (Shared/meetings/<id>.md); the State array keeps a small
-        // index (id/agenda/at) so session.json does not carry a second copy of every transcript and
-        // rewrite it on EVERY saveAll during long runs (reports below are capped for the same reason).
-        meetings.push({id:st.id,agenda:st.agenda,at:now()}); if(meetings.length>200) meetings.shift()
-        logDecision('meeting',st.agenda)
-        // handle what the meeting produced: task proposals/claims, verify targets, stop vote
-        for(const [id,iv] of Object.entries(st.inputs)){
-          if(iv.propose_task) await proposeTask(iv.propose_task, iv.task_desc||'', id)
-          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)
-        logActivity('meeting', 'concluded'+(allSolved?' → ALL agree solved':' (no unanimous solved vote)'))
-        if(allSolved){
-          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()
-        doSchedule=true
-      } finally { finalizeLock=null }   // release BEFORE scheduling so a chained verify/meeting is not swallowed
-      if(doSchedule) await scheduleNext()
-    }
-
-    // ---- verification (unanimous) ----
-    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 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)+')')
-          await saveAll(); await scheduleNext(); return
-        }
-      }
-      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()
-    }
-    async function continueVerifyRound(){
-      if(!verifyState) return
-      const vs=verifyState
-      // STUCK watchdog: a verification that has been active but collected no new verdict for a long
-      // while is deadlocked (e.g. an in-flight/hung resident). Abandoning it keeps the object as an
-      // unverified probability (no unanimous consensus was reachable) and returns the group to normal
-      // scheduling instead of blocking the whole team behind a broken verification.
-      if(now()-(vs.lastVerdictAt||vs.at||now())>=recoverStallMs()){
-        verifyState=null; wakeKind.clear(); logActivity('verify',vs.targetId+' abandoned (stuck: no unanimous verdict reachable)')
-        await saveAll(); await scheduleNext(); return
-      }
-      const ids=Array.from(residents.keys()); const allVoted=ids.every(id=>vs.verdicts[id]!==undefined)
-      if(allVoted){ await finalizeVerify(); return }
-      // NOTE: we deliberately do NOT flush mailboxes here — drafting an un-voted resident into a normal
-      // mail round would delay its verdict and can starve the verify past its watchdog when the backlog
-      // is large. Mail is delivered on scheduleNext passes when no consensus is in progress.
-      const id=ids.find(x=>vs.verdicts[x]===undefined && !busy.has(x))
-      if(!id){ armHeartbeat(); return }   // no idle un-voted resident (a busy/hung one): re-check later
-      const r=residents.get(id)
-      const ok = await wakeResident(r, verifyPrompt(r,vs), vs.stage==='independent'?'verif-ind':'verif-deb'); await saveAll()
-      if(!ok) armHeartbeat()   // a failed verify wake must NOT silently hang the verification
-    }
-    async function finalizeVerify(){
-      if(finalizeLock) return   // reentry guard (two onResidentEnd may both see allVoted)
-      finalizeLock='verify'
-      let doSchedule=false
-      try {
-        const vs=verifyState; const expected=Array.from(residents.keys()).length
-        const allVoted = expected>0 && Object.keys(vs.verdicts).length>=expected
-        const vals=Object.values(vs.verdicts)
-        // verdict is a PURE 0-1 probability; only ALL=1 (true) or ALL=0 (false) is a binary verdict.
-        const allTrue = allVoted && vals.every(x=>Number(x.prob)===1)
-        const allFalse = allVoted && vals.every(x=>Number(x.prob)===0)
-        if(allTrue||allFalse){ await closeVerify(vs,allTrue); doSchedule=true }
-        else if(vs.round+1<params.verdictMaxRounds){
-          // 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
-        }
-        else {
-          const avg=vals.length? vals.reduce((a,x)=>a+(x.prob!=null?x.prob:0.5),0)/vals.length : 0.5
-          await writeDebateDoc(vs,false,avg); await rewriteSourceProb(vs.targetId, avg, vs.targetOwner); logActivity('verify',vs.targetId+' NOT unanimous → kept unverified (avg '+avg.toFixed(2)+')')
-          verifyState=null; wakeKind.clear(); await saveAll(); doSchedule=true
-        }
-      } finally { finalizeLock=null }   // release BEFORE scheduling (chained verifies must not be swallowed)
-      if(doSchedule) await scheduleNext()
-    }
-    async function closeVerify(vs,isTrue){
-      await writeDebateDoc(vs,true,isTrue?1:0)
-      const target=vs.targetId
-      await writeVerifiedCard(vs,isTrue)
-      await rewriteSource(target,isTrue,vs.targetOwner)
-      verifiedRecently.set(target, now())   // dedup: block an immediate re-proposal of the same object
-      logActivity('verify',target+' → Verified ('+(isTrue?'真':'假')+') by unanimous consensus')
-      verifyState=null; wakeKind.clear(); await saveAll()
-      // scheduling is done by finalizeVerify AFTER it releases finalizeLock (so a chained verify is
-      // 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 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=idSafe(target)   // sanitize BEFORE it becomes file names / dedup keys / status output
-      if(!t || t==='id') 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()})
-      return true
-    }
-    async function writeDebateDoc(vs,done,val){
-      const lines=['# 验证辩论｜'+vs.targetId+'('+vs.targetType+')｜'+fmtTime(),'',(done?('**结论**：'+(val===1?'全体一致为真':'全体一致为假')):('**未达成全体一致**，平均概率 '+val.toFixed(2))),'','## 各常驻意见']
-      for(const [k,v] of Object.entries(vs.verdicts)){ lines.push('### '+k+'｜正确概率 '+(v.prob!=null?Number(v.prob).toFixed(2):'0.50')); lines.push(v.reason||''); lines.push('') }
-      await writeText('Shared/debates/'+vs.targetId+'.md', lines.join('\n'))
-    }
-    async function writeVerifiedCard(vs,isTrue){
-      const isSub=vs.targetType==='subproblem'
-      const dir= isSub?'问题':'命题'
-      const type= isSub?'问题': vs.targetType==='method'?'方法':'命题'
-      const text='# 已验证｜'+vs.targetId+'\n- ID: '+vs.targetId+'\n- 类型: '+type+'\n- 结论: '+(isTrue?'真':'假')+'\n- 概率: '+(isTrue?1:0)+'\n- 来源: 全体常驻一致\n## 陈述\n参见来源卡。\n'
-      await writeText('Verified/'+dir+'/'+vs.targetId+'.md', text)
-    }
-    // Does `content` declare the target as its card ID? Accept both the exact `- ID: <id>` and the
-    // compact single-line form (`- ID: <id>; - 状态: ...`). Residents write cards by hand via fs with
-    // varying formats and (crucially) sometimes put a DIFFERENT file name than the declared ID (e.g.
-    // Propos/r-3/p-01.md declares "- ID: p-r3-01"). Matching only on the file name then silently loses
-    // the verified-status write-back, so we scan candidates' declared ID too.
-    function cardDeclaresId(content, target){
-      if(!content || !target) return false
-      const m=/-\s*ID:\s*([^;\n]+)/.exec(content)
-      return !!(m && String(m[1]).trim()===String(target).trim())
-    }
-    async function findSourceRel(target, owner){
-      // 1) exact file name in the owner's library (fast path), then every resident's library
-      const order = owner ? [owner, ...Array.from(residents.keys()).filter(k=>k!==owner)] : Array.from(residents.keys())
-      for(const rid of order){
-        for(const base of ['Propos','Methods','Subproblems']){
-          const cand=base+'/'+rid+'/'+target+'.md'
-          const t0=await readText(cand); if(t0!==undefined) return cand
-        }
-      }
-      // 2) declared-ID scan: residents sometimes name the file differently from the declared card ID
-      //    (e.g. p-01.md declares ID p-r3-01). Look inside every card of every library for the target ID.
-      try {
-        for(const rid of order){
-          for(const base of ['Propos','Methods','Subproblems']){
-            const dirT=await fs.resolve(base+'/'+rid, {cwd: frameworkRoot()})
-            if(await fs.stat(dirT)===undefined) continue
-            const entries=await fs.listDir(dirT)
-            for(const e of entries||[]){
-              if(!e || e.type!=='file' || !/\.md$/.test(String(e.name))) continue
-              const c=await readText(base+'/'+rid+'/'+e.name)
-              if(c!==undefined && cardDeclaresId(c,target)) return base+'/'+rid+'/'+e.name
-            }
-          }
-        }
-      } catch(e){ /* scanning is best-effort */ }
-      return null   // NOT 'Propos/'+target+'.md': writing there would create a stray empty card
-    }
-    // Update the `- 状态:` / `- 概率:` fields of a source card. Residents hand-write cards in two
-    // shapes: one field per line, or one line with `; `-separated fields. Accept both by allowing the
-    // anchor anywhere on a line and consuming up to the next `;` when fields share the line.
-    function rewriteCardField(text, field, newValue){
-      if(!text) return text
-      const esc=field.replace(/[.*+?^${}()|[\]\\]/g,'\\$&')
-      // one-per-line: `- 状态: ...\n`  OR  inline: `; - 状态: ...;` / `- 状态: ...; - 概率:`
-      const re=new RegExp('(^|\\n|;\\s*)-\\s*'+esc+':[^;\\n]*','gm')
-      const replaced=text.replace(re,'$1- '+field+': '+newValue)
-      return replaced===text ? text : replaced
-    }
-    // non-unanimous verification: keep the object in its library but write back the
-    // average probability (design §8: "留库附概率"), so the card reflects the consensus estimate.
-    async function rewriteSourceProb(target,prob,owner){
-      const rel=await findSourceRel(target,owner)
-      if(!rel){ logActivity('verify',target+' source card NOT found; avg prob '+Number(prob).toFixed(2)+' not written back'); return }
-      let text=(await readText(rel))||''
-      const next=rewriteCardField(text,'概率',Number(prob).toFixed(2))
-      await writeText(rel,next||text)
-    }
-    async function rewriteSource(target,isTrue,owner){
-      // find & update the source card status/prob; best effort across per-resident libs
-      const rel=await findSourceRel(target,owner)
-      if(!rel){ logActivity('verify',target+' source card NOT found; verified status not written back'); return }
-      let text=(await readText(rel))||''
-      let next=rewriteCardField(text,'状态',isTrue?'已验证·真':'已验证·假')
-      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' }
-
-    // ---- heartbeat / liveness helpers (boundary-A: event-driven + gated heartbeat) ----
-    // A checkpoint wake is NOT "keep working forever": it nudges the least-recently-active
-    // resident, after an idle timeout, to CONTINUE the work itself (self-drive), and only to
-    // propose a meeting/verify/solved when it truly has nothing left. This keeps the group moving
-    // on its own (framework never assigns work) but adds convergence pressure instead of letting
-    // a stalled group sit idle forever.
-    function heartbeatPrompt(r){
-      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>","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(){
-      clearHeartbeat()
-      const ms=posMs(params.activityTimeoutMs,120000)
-      if(typeof ctx.timeout!=='function') return
-      heartbeatDisposer=ctx.timeout(()=>{ heartbeatDisposer=null; scheduleNext().catch(()=>{}) }, ms)
-    }
-    // Real DSH /compact of a resident's OWN session via ctx.compaction (if the host provides it);
-    // falling back silently to the resident self-summary directive when the service is absent.
-    async function realCompact(r){
-      if(!r || !r.childId) return
-      if(compaction===undefined || !compaction.compactIfNeeded) return
-      let agent
-      try { agent = agents.get(r.childId) } catch(e){ agent = undefined }
-      if(!agent || !agent.session) return
-      try {
-        const signal = makeSignal(params.activityTimeoutMs||60000)
-        const result = await compaction.compactIfNeeded(agent, 'pressure', signal)
-        if(result && (result.shadowedSeqs||[]).length>0){
-          // the resident's real session was compacted → its context is now a summary.
-          // Flag needCompact so the NEXT wake re-anchors the core rules (they may have been blurred).
-          r.roundsSinceCompact=0; r.needCompact=true; r.contextPct=Math.min(r.contextPct||15,25)
-          logActivity('compact', r.rId+' real /compact (shadowed '+result.shadowedSeqs.length+' items, ~'+String(result.shadowedTokenCount||0)+' tokens)')
-        }
-      } catch(e){ /* real compaction unavailable/failed; the soft directive already covers it */ }
-    }
-
-    // ---- liveness / scheduling ----
-    async function scheduleNext(){
-      if(!running||autoDone){ clearHeartbeat(); return }
-      if(phase==='brainstorm'){ await maybeFinishBrainstorm(); return }
-      if(meetingState){ await continueMeetingRound(); return }
-      if(verifyState){ await continueVerifyRound(); 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 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
-      // 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 }
-      // 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
-      //    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.length===0 && busy.size===0){
-        const stallMs=posMs(params.stallAutoMeetingMs, posMs(params.activityTimeoutMs,120000)*3)
-        if(now()-lastProgressAt>=stallMs){
-          await startMeeting('团队较长时间没有新进展。请你们自行讨论：当前问题是否已解决、开放难点是什么、谁负责哪部分、下一步如何推进，并自主决定是否继续。框架只负责转达与记录，不替你们决定。','general',null)
-          return
-        }
-      }
-      // A) heartbeat / coordination: wake IDLE residents after an idle timeout to SELF-DRIVE (continue
-      //    solving / message / propose task / meeting / verify). This is a CONCURRENCY FILL, not a
-      //    single nudge: scheduleNext should wake up to `maxParallel` idle residents in one pass so the
-      //    group can progress in parallel (design §A: "同一时刻可唤醒多个空闲常驻，受 maxParallel 上限").
-      //    On a FAILED wake we re-arm the heartbeat so a single follow-up error NEVER permanently stops
-      //    the group (a successful wake re-drives scheduleNext through its own onResidentEnd, which re-arms).
-      clearHeartbeat()
-      const atOs=posMs(params.activityTimeoutMs,120000)
-      // `mp` (maxParallel) is already declared above in this function scope.
-      // Collect idle (not busy) residents sorted by idle time, oldest-first (round-robin fairness).
-      const idleCandidates = Array.from(residents.values())
-        .filter(r=>!busy.has(r.rId))
-        .sort((a,b)=>(now()-b.lastActiveAt)-(now()-a.lastActiveAt))
-      // Fill the concurrency budget: keep waking the most-idle resident until either everyone idle is
-      // started OR the in-flight cap (maxParallel) is reached. This turns the previous "one at a time"
-      // serialization into genuine parallel progress.
-      let started=0
-      for(const r of idleCandidates){
-        const free = mp>0 ? (mp - busy.size) : Number.MAX_SAFE_INTEGER
-        if(free<=0) break            // concurrency cap reached → stop filling
-        if((now()-r.lastActiveAt)<atOs) break   // the remaining are all busy-or-not-idle-enough
-        let ok=false
-        try { ok = await wakeResident(r, await heartbeatPrompt(r), 'normal') } catch(e){ ok=false }
-        if(ok) started++
-        await saveAll()
-        if(!ok) continue             // a failed wake must NOT stop the fill; try the next idle resident
-      }
-      if(started>0) { armHeartbeat(); return }   // started some; re-drive comes via onResidentEnd, BUT also arm a
-      // safety-net heartbeat so a woken resident whose subagent/end NEVER arrives (a hung normal round) does not
-      // freeze the group. Below mp, the next scheduleNext will re-fill; if all woken residents are stuck busy the
-      // heartbeat just re-arms harmlessly. (Meeting/verify already have recoverStallMs watchdogs; normal A-fill did not.)
-      // everyone is busy or not idle-enough: arm a heartbeat to re-check later (no infinite spin)
-      armHeartbeat()
-    }
-    async function maybeFinishBrainstorm(){
-      const pending=[]; for(const [,r] of residents){ if(r.status==='brainstorm' && !r.insight) pending.push(r.rId) }
-      if(pending.length===0){ phase='active'; logActivity('phase','active — residents now self-organize'); await saveBrainstormSummary(); await saveAll(); await scheduleNext() }
-    }
-    async function saveBrainstormSummary(){
-      const lines=['# 头脑风暴','']; for(const [,r] of residents){ if(r.insight){ lines.push('## '+r.rId+'「'+(r.direction||'')+'」'); lines.push(r.insight); lines.push('') } }
-      await writeText('Shared/meetings/brainstorm.md', lines.join('\n'))
-    }
-    async function deliverNextMailbox(){
-      // Deliver queued messages to ALL currently-idle recipients in one pass (parallel), bounded by the
-      // same maxParallel concurrency cap, so a group chat (relayToGroup → many non-busy recipients) is
-      // not serialized one-message-at-a-time. Returns true if anything was delivered. A busy recipient
-      // keeps its message queued (avoid starving others).
-      let delivered=false
-      for(const [to,msgs] of mailboxes){
-        if(msgs.length===0) continue
-        const r=residents.get(to); if(!r){ mailboxes.delete(to); continue }   // stale recipient → drop the entry
-        if(busy.has(to)) continue   // recipient busy → leave the message queued for a later pass
-        const mp=Number(params.maxParallel)||0
-        if(mp>0 && busy.size>=mp) break   // concurrency cap reached → stop delivering more now
-        const m=msgs.shift()
-        currentResident=to
-        const ok = await wakeResident(r, (await normalPrompt(r))+'\n\n[MESSAGE from '+m.from+']\n'+m.content,'normal')
-        await saveAll(); if(!ok) msgs.unshift(m); delivered=delivered||ok
-      }
-      return delivered
-    }
-
-    // ---- resident end handler ----
-    async function onResidentEnd(childId, info){
-      const r=byChild(childId); if(!r) return
-      // 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
-      // team. We count only a clean 'completed' turn: an error/max-tokens/refusal did NOT meaningfully
-      // advance the work, so it must NOT mask a truly stalled group (B can then convene a recovery
-      // meeting). A completed turn also refreshes the meeting/verify deadlock clock through lastInputAt.
-      if(info && info.stopReason==='completed') markProgress()
-      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'
-      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()
-        if(parsed.propose_verify) maybeQueueVerify(parsed.propose_verify, r.rId)
-        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 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()
-        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' }
-      if(typeof parsed.solved==='boolean'){ reports.push({rId:r.rId,solved:parsed.solved,summary:parsed.summary||'',at:now()}); if(reports.length>100) reports.shift() }   // solved-signal ring (not surfaced in status/report)
-      if(parsed.propose_verify) maybeQueueVerify(parsed.propose_verify, r.rId)
-      // group-conversation relay: the resident may choose to speak to the whole team (input) —
-      // forward it to the others so this is a real discussion group, not private monologues.
-      if(typeof parsed.input==='string' && parsed.input.trim()) await relayToGroup(r.rId, parsed.input.trim())
-      // task actions via reply (a resident may propose or claim a task in its round)
-      if(parsed.propose_task) await proposeTask(parsed.propose_task, parsed.task_desc||'', r.rId)
-      if(parsed.claim_task) await claimTask(parsed.claim_task, r.rId)
-      if(parsed.task_done) await taskDone(parsed.task_done, r.rId)
-      // a resident may self-trigger a meeting (resident-driven coordination, closest to the philosophy).
-      // If a verify is holding the floor the meeting is deferred (pendingMeeting) and we fall through
-      // so the pending verify (or mailbox/heartbeat) still advances rather than being stuck behind it.
-      if(parsed.propose_meeting && !meetingState){
-        const mr=await startMeeting(String(parsed.propose_meeting),'general',null); await saveAll()
-        if(mr && !mr.deferred) return
-      }
-      await saveAll(); await scheduleNext()
-    }
-
-    // ---- controls ----
-    async function start({problem,residentCount,seedDirections}){
-      await loadSettings()
-      currentProject=await readCurrentProject(); if(!currentProject||currentProject==='default'){ currentProject='default'; }
-      await ensureDirs()
-      if(problem) problemText=String(problem)
-      if(!problemText) return {ok:false,message:'problem text required (pass problem, or use vibe_v4_configure first)'}
-      problemId=slugify(problemText.slice(0,40))||'problem'
-      if(residentCount) params.residentCount=Number(residentCount)||4
-      if(!(Number(params.residentCount)>=1)) params.residentCount=DEFAULT_PARAMS.residentCount   // a 0/negative count (settings misconfig) would spawn nobody & idle forever
-      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')
-      // 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):[]
-      for(let i=0;i<params.residentCount;i++){ const r=newResident(dirs[i]||''); await spawnResident(r) }
-      await saveAll(); return {ok:true,message:'v4 started: '+params.residentCount+' resident(s) brainstorming',project:currentProject}
-    }
-    async function resume(){
-      currentProject=await readCurrentProject(); await ensureDirs()
-      // Resume is only meaningful for a stopped/paused/crashed run. If THIS process is already driving
-      // a live run whose disk state belongs to it, loadAll below would overwrite the in-memory state
-      // with a slightly stale snapshot (busy marks, wake round counters, mailbox contents from the last
-      // saveAll) — a silent clobber for a useless "kick". No-op instead. A cross-process restart is
-      // always allowed: its disk epoch differs, so the in-memory state is empty/stale anyway.
-      const pre=await readJson('State/session.json')
-      if(running && !autoDone && pre && pre.processEpoch===processEpoch) return {ok:true,message:'already running (no-op)'}
-      await loadAll(); await loadSettings()
-      // 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).
-      for(const key of residents.keys()){ const mm=/^r-(\d+)$/.exec(String(key)); if(mm) residentSeq=Math.max(residentSeq, Number(mm[1])) }
-      lastActivityAt=now(); lastProgressAt=now()   // pause must not count as stall time; a resumed run gets a fresh clock
-      if(phase==='idle' && !running && residents.size===0) return {ok:false,message:'nothing to resume'}
-      // 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.
-      const 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
-      // under phase='active' (brainstorm summary never written), and a LATE subagent/end from an interrupted
-      // OLD resident (same rId) deletes the NEW resident's busy mark → A-fill can wake it mid-brainstorm.
-      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=[]; 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.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.length?pendingVerify[0].targetId:null,
-      parkedMeeting: pendingMeeting?pendingMeeting.agenda:null,
-      meetings:meetings.length, recentActivity: activityLog.slice(-8) } }
-    async function addMember(direction){
-      // Adding a member starts a REAL resident turn (spawnResident → brainstorm) — refuse unless the
-      // run is live: on a concluded (autoDone) or never-started/paused run the new member would work
-      // with nobody to coordinate (zombie work on a project the group already declared done).
-      if(!running || autoDone) return {ok:false,message:'no active run to join (start or resume first)'}
-      const r=newResident(direction||''); await spawnResident(r)
-      // Mid-meeting additions must join the meeting's speaking order; otherwise allSpoke (over CURRENT
-      // residents) can never be true for the new member (not in the snapshot order) and the meeting is
-      // only ever released by the stuck watchdog instead of finalizing with everyone's input.
-      if(meetingState){ if(!Array.isArray(meetingState.order)) meetingState.order=Array.from(residents.keys()); if(!meetingState.order.includes(r.rId)) meetingState.order.push(r.rId) }
-      // 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); 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 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] }
-      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){
-      const INT_KEYS=['residentCount','compactThreshold','compactAfterRounds','maxParallel','activityTimeoutMs','verdictMaxRounds','meetingKeepEvery','stallAutoMeetingMs']
-      if(INT_KEYS.includes(k)){ const n=Number(v); return Number.isFinite(n)?n:v }
-      if(k==='toolAllow'||k==='toolDeny'){ if(Array.isArray(v)) return v.map(x=>String(x).trim()).filter(Boolean); if(typeof v==='string') return v.split(',').map(x=>x.trim()).filter(Boolean); return [] }
-      return v
-    }
-    function setParams(upd){ for(const k of Object.keys(upd||{})){ if(k in params) params[k]=normalizeParam(k, upd[k]) } saveSettings().catch(()=>{}); return {ok:true} }
-    // ---- 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) params[k]=s[k] } } }
-    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 {}.
-    async function configure(cfg){
-      // configure is the PRE-START setup tool (project/problem/params). Switching the project while a
-      // run is LIVE would split the run's state across two trees: residents' briefs & libraries point
-      // at the OLD frameworkRoot while every subsequent saveAll/transcript/Verified card would go to the
-      // NEW project. Params tuning mid-run belongs to vibe_v4_set.
-      if(running && !autoDone) return {ok:false,message:'cannot configure while a run is running (pause or abort first; use vibe_v4_set to tune params)'}
-      if(cfg && cfg.project && String(cfg.project).trim()) currentProject=String(cfg.project).trim()
-      if(cfg && cfg.problem) problemText=String(cfg.problem)
-      if(cfg && cfg.params && typeof cfg.params==='object') setParams(cfg.params)
-      await writeCurrentProject(); await ensureDirs(); await saveSettings()
-      // create the problem card so the project is complete BEFORE the run starts
-      if(problemText){ const pid=slugify(problemText.slice(0,40))||'problem'; await writeText('Problems/'+pid+'.md','# 问题｜'+pid+'\n- ID: '+pid+'\n- 类型: 问题\n- 状态: 求解中\n- 优先级: 1\n- 依赖: []\n\n## 陈述\n'+problemText+'\n') }
-      await saveAll()
-      return {ok:true,project:currentProject,problem:problemText?problemText.slice(0,60):'',params:Object.keys(params).map(k=>k+'='+params[k]).join(', ')}
-    }
-    async function initAbort(){ clearHeartbeat(); running=false; phase='idle'; autoDone=false; for(const [,r] of residents){ if(r.childId){ try{ subagents.interrupt(r.childId,{kind:'ancestor',agent:rootAgent}) }catch(e){} } r.childId=''; r.lastActiveAt=0; r.roundsSinceCompact=0 }
-      // Wipe the coordination state too: an aborted run must not report an in-flight meeting/verify,
-      // a parked meeting, a verify queue, or busy residents (their childIds are gone, so no end event
-      // 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
-      await saveAll(); return {ok:true,message:'aborted'} }
-    function setPause(){ clearHeartbeat(); running=false; return {ok:true,message:'paused'} }
-
-    return {
-      sessionId, running:()=>running, autoDone:()=>autoDone, phase:()=>phase,
-      onResidentEnd, start, resume, status, report, addMember, removeMember, setParams,
-      setPause, initAbort, postMessage, startMeeting, saveAll, broadcast, configure, loadSettings,
-      currentResident:()=>currentResident,
-      // 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 : '' },
-      useResident:(id)=>{ currentResident=id },
-      publishProgress, recordProposition, recordMethod, recordSubproblem, listResidents, reportContext,
-      proposeTask, claimTask, taskDone, listTasks,
-      readProgress: async (rid)=>({text:(await readText('Progress/'+rid+'/progress.md'))||''}),
-      frameworkRoot:frameworkRoot, currentProject:()=>currentProject, problemText:()=>problemText,
-      residentCount:()=>residents.size,
-      busyCount:()=>busy.size,
-    }
-  } // end makeSession
-
-  // ================= apply-level registration (ONCE) =================
-  function objParams(props, required){ return { type:'object', properties:props, additionalProperties:false, required:required||[] } }
-  function registerTool(name, description, parameters, fn){
-    tools.register({ name, description, parameters,
-      output:{ schema:{ type:'string' }, render:(_a,v)=>[{type:'text',text:String(v)}] },
-      execute: async (args, exec)=>{
-        try { const s=getSession(exec&&exec.agent); if(!s) return JSON.stringify({ok:false,error:'no session'}); return JSON.stringify(await fn(s,args||{},exec&&exec.agent)) }
-        catch(e){ return JSON.stringify({ok:false,error:String((e&&e.message)||e)}) }
-      } })
-  }
-  // host/assistant-facing
-  registerTool('vibe_v4_configure','Create/configure a project: set project name, problem, and params WITHOUT starting a run. Use this FIRST, then vibe_v4_start to actually spawn residents.',objParams({project:{type:'string'},problem:{type:'string'},params:{type:'object'}}),(s,a)=>s.configure(a))
-  registerTool('vibe_v4_start','Start V4: spawn N resident subagents (brainstorm then self-organize).',objParams({problem:{type:'string'},residentCount:{type:'integer'},seedDirections:{type:'array',items:{type:'string'}}}),(s,a)=>s.start(a))
-  registerTool('vibe_v4_resume','Resume a persisted V4 run.',objParams({}),(s)=>s.resume())
-  registerTool('vibe_v4_pause','Pause V4.',objParams({}),(s)=>s.setPause())
-  registerTool('vibe_v4_abort','Abort V4 and interrupt residents.',objParams({}),(s)=>s.initAbort())
-  registerTool('vibe_v4_status','Show V4 status.',objParams({}),(s)=>s.status())
-  registerTool('vibe_v4_report','Return the V4 progress report.',objParams({}),(s)=>s.report())
-  registerTool('vibe_v4_message','Inject a message to a resident (or all).',objParams({to:{type:'string'},content:{type:'string'}},['to','content']),(s,a)=>{ const to=a.to||'all'; if(to==='all') return s.broadcast(a.content); return s.postMessage('facilitator',to,a.content) })
-  registerTool('vibe_v4_meeting','Start a meeting (coordinate / allocate / propose verification).',objParams({agenda:{type:'string'}},['agenda']),(s,a)=>s.startMeeting(a.agenda))
-  registerTool('vibe_v4_list_members','List residents.',objParams({}),(s)=>({ok:true,residents:s.listResidents()}))
-  registerTool('vibe_v4_add_member','Add a resident.',objParams({direction:{type:'string'}}),(s,a)=>s.addMember(a.direction))
-  registerTool('vibe_v4_remove_member','Close a resident.',objParams({id:{type:'string'}},['id']),(s,a)=>s.removeMember(a.id))
-  // model/provider inheritance: set model/provider to override the residents' LLM route (''=inherit
-  // the main assistant's route). toolAllow/toolDeny are per-resident tool permissions (scoped
-  // restrict). residentPersona prepends a persona line to every resident prompt.
-  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.',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'}}}),(s,a)=>{ s.setParams(a); return {ok:true} })
-  // 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) })
-  registerTool('vibe_v4_publish_progress','(resident) Append to your own progress markdown.',objParams({content:{type:'string'}},['content']),(s,a,x)=>s.publishProgress(s.residentIdOf(x),a.content))
-  registerTool('vibe_v4_record_proposition','(resident) Record a proposition to your library.',objParams({id:{type:'string'},title:{type:'string'},statement:{type:'string'},prob:{type:'number'},value:{type:'number'},motivation:{type:'string'}}),(s,a,x)=>s.recordProposition(s.residentIdOf(x),a))
-  registerTool('vibe_v4_record_method','(resident) Record a method/theory to your library.',objParams({id:{type:'string'},title:{type:'string'},type:{type:'string'},content:{type:'string'},notation:{type:'string'},value:{type:'number'},motivation:{type:'string'}}),(s,a,x)=>s.recordMethod(s.residentIdOf(x),a))
-  registerTool('vibe_v4_record_subproblem','(resident) Record a sub-problem to your library.',objParams({id:{type:'string'},title:{type:'string'},statement:{type:'string'},value:{type:'number'},motivation:{type:'string'}}),(s,a,x)=>s.recordSubproblem(s.residentIdOf(x),a))
-  registerTool('vibe_v4_read_progress','(resident) Read another resident\'s progress (read-only).',objParams({id:{type:'string'}},['id']),async (s,a)=>{ const rp=await s.readProgress(a.id); return {ok:true,text:(rp&&rp.text)||''} })
-  registerTool('vibe_v4_list_residents','(resident) List fellow residents.',objParams({}),(s)=>({ok:true,residents:s.listResidents()}))
-  // task board (residents; board is the residents' own allocation mechanism)
-  registerTool('vibe_v4_propose_task','(resident) Propose a task to the shared task board.',objParams({title:{type:'string'},description:{type:'string'}},['title']),(s,a,x)=>s.proposeTask(a.title,a.description,s.residentIdOf(x)))
-  registerTool('vibe_v4_claim_task','(resident) Claim an open task from the board (framework then wakes you to work it).',objParams({id:{type:'string'}},['id']),(s,a,x)=>s.claimTask(a.id,s.residentIdOf(x)))
-  registerTool('vibe_v4_task_done','(resident) Mark a claimed task done.',objParams({id:{type:'string'},claimer:{type:'string'}},['id']),(s,a,x)=>s.taskDone(a.id,a.claimer||s.residentIdOf(x)))
-  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}))
-
-  commands.register({
-    name:'v4', description:'control the Vibe Math V4 framework',
-    input:{hint:'[configure|start|resume|pause|abort|status|report|meeting|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({})
-      else if(cmd==='resume') r=await s.resume()
-      else if(cmd==='pause') r=s.setPause()
-      else if(cmd==='abort') r=await s.initAbort()
-      else if(cmd==='status') r=s.status()
-      else if(cmd==='report') r=s.report()
-      else if(cmd==='meeting') r=await s.startMeeting(rest.join(' '))
-      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|meeting|members|add|remove|set'}
-      return {kind:'success',text:JSON.stringify(r,null,2)}
-    },
-  })
-
-  ctx.on('subagent/end', function(info){
-    const sid=childOwner.get(info.id); const s=sid!==undefined?sessions.get(sid):undefined
-    if(s) s.onResidentEnd(info.id, info).catch(e=>{ console.error('vibe-v4 end: '+String((e&&e.stack)||e)); if(s.nudge) s.nudge() })
-  })
-}
+// Vibe Math V4 — persistent self-organizing collaborative research framework.
+// FACILITATOR (message bus / meetings / per-resident artifact libraries /
+// unanimous-consensus verification / context compaction proxy / resume / human
+// intervention). It NEVER assigns tasks: residents message & meet and decide all
+// task allocation among themselves. Consumes HOST subagents/agents/fs/tools/commands.
+// NOTE: must declare `inject` for every service read as a ctx property (the Guard
+// rejects undeclared dependencies), and must use the `timer` Service (ctx.timeout),
+// not global setTimeout/clearTimeout, which do not exist in the plugin runtime.
+export const inject = ['subagents', 'agents', 'fs', 'tools', 'commands', 'timer']
+export function apply(ctx) {
+  const subagents = ctx.subagents
+  const agents = ctx.agents
+  const fs = ctx.fs
+  const tools = ctx.tools
+  const commands = ctx.commands
+  // Optional services are resolved LAZILY at call time, never snapshotted in apply().
+  // A `ctx.get()` snapshot taken here is order-sensitive: if the service has not been
+  // provided yet when this preset subtree mounts, the snapshot stays undefined for the
+  // whole session, so `runShell` would report 'no-subprocess' forever and `ensureDirs()`
+  // would silently stop creating the project tree (only masked by fs.writeText's
+  // automatic parent creation). Reading on demand removes that dependency on mount order.
+  const subprocessOf = () => { try { return ctx.get('subprocess') } catch(e){ return undefined } }
+  const sandboxPolicyOf = () => { try { return ctx.get('sandboxPolicy') } catch(e){ return undefined } }
+  const compactionOf = () => { try { return ctx.get('compaction') } catch(e){ return undefined } }
+
+  const sessions = new Map()      // rootAgentId -> Session
+  const childOwner = new Map()    // childId -> rootAgentId
+  const fileOwner = {}            // process-level write lock
+  const processEpoch = String(Date.now()) + '-' + Math.random().toString(36).slice(2, 8)
+
+  function sessionIdOf(agent){ try { return (agent&&agent.id)?String(agent.id):undefined } catch(e){ return undefined } }
+  function rootOf(agent){ try { let cur=agent; const seen=new Set(); while(cur){ const id=cur.id; if(seen.has(id)) return cur; seen.add(id); const p=(cur.session&&cur.session.header)?cur.session.header.parentSession:undefined; if(p===undefined) return cur; const par=agents.get(p); if(!par) return cur; cur=par } } catch(e){} return agent }
+  function getSession(agent){ const root=rootOf(agent); const sid=sessionIdOf(root); if(sid===undefined) return undefined; let s=sessions.get(sid); if(!s){ s=makeSession(root,sid); sessions.set(sid,s) } return s }
+
+  function makeSession(rootAgent, sessionId) {
+    let currentProject = 'default'
+    const DEFAULT_PARAMS = {
+      residentCount: 4, compactThreshold: 66, compactAfterRounds: 8,
+      maxParallel: 3, activityTimeoutMs: 120000, verdictMaxRounds: 3,
+      meetingKeepEvery: 5,   // 每积累 N 个新产物自动触发一次同步会议
+      stallAutoMeetingMs: 360000,   // 团队空闲且无新产物的"停滞阈值"：超过则自动召集同步会议（分级保活 B）
+      // model/provider inheritance: '' = the resident inherits the parent (main assistant)
+      // route (provider + model). Set them to override the resident's LLM backend/model.
+      provider: '', model: '', residentPersona: '',
+      // tool permissions: an allow/deny list of tool names applied via startContinuable's
+      // toolFilter (scoped tools.restrict() in the child). Empty = inherit all tools.
+      // CAUTION: only set one of these; an empty allow:[] would deny EVERY tool.
+      toolAllow: [], toolDeny: [],
+    }
+    let params = Object.assign({}, DEFAULT_PARAMS)
+    let running = false, autoDone = false, phase = 'idle'
+    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 = [], 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)
+    let lastActivityAt = now(), lastProgressAt = now(), artifactCount = 0, lastSyncMeetingAt = 0, persistedEpoch = '', heartbeatDisposer = null
+    const activityLogCap = 200
+
+    // ---- utils ----
+    function now(){ return Date.now() }
+    function uuid(){ const h='0123456789abcdef'; let s=''; for(let i=0;i<36;i++){ if(i===8||i===13||i===18||i===23) s+='-'; else s+=h[Math.floor(Math.random()*16)] } return s }
+    function shortId(){ const h='0123456789abcdef'; let s=''; for(let i=0;i<8;i++) s+=h[Math.floor(Math.random()*16)]; return s }
+    function clamp01(v){ const n=Number(v); if(!Number.isFinite(n)) return 0.5; return Math.max(0,Math.min(1,n)) }
+    function fmtTime(ts){ try { return new Date(ts||now()).toISOString().replace('T',' ').slice(0,19) } catch(e){ return String(ts||'') } }
+    function cl(x){ return clamp01(Number(x)) }
+    // contextPct is a PERCENT (0-100); never clamp to 0-1 or the compactThreshold
+    // comparison (e.g. 66) becomes `1.0 >= 66` and never fires.
+    function clPct(x){ const n=Number(x); if(!Number.isFinite(n)) return 0; return Math.max(0,Math.min(100,n)) }
+    function textBlock(t){ return { type:'text', text:String(t) } }
+    function blocksToText(b){ if(!b) return ''; let out=''; for(const x of b){ if(x&&x.type==='text'&&typeof x.text==='string') out+=x.text+'\n' } return out.trim() }
+    function logActivity(event,detail){ activityLog.push({at:now(),event,detail:String(detail||'')}); if(activityLog.length>activityLogCap) activityLog.shift() }
+    function logDecision(kind,detail){ decisions.push({at:now(),kind,detail:String(detail||'')}) }
+    // Record that the project made real progress (new artifact, meeting, verify, task, or a
+    // resident speaking to the group). The stall auto-sync meeting (B) fires only when this has
+    // NOT advanced for stallAutoMeetingMs, so a group that is genuinely producing keeps working
+    // and only a truly stalled group gets a coordination meeting to reboot itself.
+    function markProgress(){ lastProgressAt = now(); }
+    // How long a meeting/verify may run without collecting a new input/verdict before we treat it as
+    // deadlocked and abandon it. A meeting round's own signal window is activityTimeoutMs, so a
+    // resident should speak within that; 2× that without ANY new input/verdict means the meeting/verify
+    // is stuck and must not keep the whole group blocked.
+    // Positive duration with a safe fallback: a NEGATIVE/NaN activityTimeoutMs or stallAutoMeetingMs
+    // (misconfigured via vibe_v4_set) would otherwise make recoverStallMs negative → every meeting/
+    // verify watchdog fires INSTANTLY (abandoning all consensus) and A-fill's idle window would never
+    // elapse (waking everyone every pass). Guard every duration read with this.
+    function posMs(v,def){ const n=Number(v); return (Number.isFinite(n)&&n>0)?n:(def||120000) }
+    function recoverStallMs(){ return posMs(params.activityTimeoutMs,120000) * 2 }
+    function pickProvider(){ try { const n=subagents.list?subagents.list():[]; if(n.indexOf('spawn')!==-1) return 'spawn'; if(n.indexOf('fork')!==-1) return 'fork' } catch(e){} return 'spawn' }
+    // Per-resident model/provider inheritance: when params.provider / params.model are set,
+    // the resident uses that exact route; when left '' the resident inherits the parent's
+    // (main assistant) route — the documented DSH default (resolveChildAgentOptions merges
+    // requested over parent). No override is applied for empty values.
+    function residentAgentOptions(){ const ao={}; if(params.provider) ao.provider=params.provider; if(params.model) ao.model=params.model; return ao }
+    // Tool permission (scoped toolFilter). Only emit a filter when allow or deny has entries;
+    // an empty object is rejected by DSH ("must declare allow and/or deny").
+    function residentToolFilter(){
+      const allow=Array.isArray(params.toolAllow)?params.toolAllow.filter(x=>String(x).trim()):[]
+      const deny=Array.isArray(params.toolDeny)?params.toolDeny.filter(x=>String(x).trim()):[]
+      if(allow.length===0 && deny.length===0) return undefined
+      const f={}; if(allow.length) f.allow=allow; if(deny.length) f.deny=deny; return f
+    }
+    function makeSignal(ms){ return AbortSignal.timeout(posMs(ms,30000)) }
+    function workspaceRoot(){ try { if(rootAgent&&rootAgent.session&&rootAgent.session.header&&rootAgent.session.header.cwd) return rootAgent.session.header.cwd } catch(e){} const sp=sandboxPolicyOf(); if(sp&&sp.workspaceRoot) return sp.workspaceRoot; return '.' }
+    function vibeRoot(){ return (workspaceRoot()+'/VibeMath').replace(/\\/g,'/') }
+    function frameworkRoot(){ return vibeRoot()+'/Projects/'+currentProject }
+    function slugify(s){ const t=String(s==null?'':s).trim().toLowerCase().replace(/[^a-z0-9_\-\u4e00-\u9fa5]+/g,'-').replace(/^-+|-+$/g,''); return t||'project' }
+    // Object ids (verify targets, recorded cards) become FILE NAMES and DIRECTORY PATHS
+    // (Verified/命题/<id>.md, Shared/debates/<id>.md, Propos/<r>/<id>.md, source-card scans).
+    // A hostile/sloppy id containing path separators ('../../x') or Windows-forbidden chars would
+    // escape the project tree. Keep every harmless character (incl. Chinese) and replace only
+    // separators/control chars; strip leading/trailing dots/dashes so the name is never '.'/'..'.
+    function idSafe(s){
+      const t=String(s==null?'':s).trim().replace(/[\\/:*?"<>|\u0000-\u001f]+/g,'-').replace(/-{2,}/g,'-').replace(/^[.\-]+|[.\-]+$/g,'')
+      return t||'id'
+    }
+    let warnedNoPolicy = false
+    function warnNoPolicyOnce(){ if(!warnedNoPolicy){ warnedNoPolicy=true; console.error('vibe-math-v4: sandboxPolicy unavailable; writes go out with no explicit policy') } }
+    function getPolicy(){ const sp=sandboxPolicyOf(); if(!sp){ warnNoPolicyOnce(); return undefined } try { if(rootAgent&&rootAgent.session) return sp.resolve({session:rootAgent.session}) } catch(e){ warnNoPolicyOnce() } try { const p=sp.resolve({}); if(!warnedNoPolicy){ warnedNoPolicy=true; console.error('vibe-math-v4: falling back to sandboxPolicy.resolve({}) — the fence root is the host-configured workspace, not necessarily this session cwd') } return p } catch(e){ warnNoPolicyOnce() } return undefined }
+    function psQuote(p){ return "'"+String(p).replace(/'/g,"''")+"'" }
+    /** POSIX 单引号引用：把 ' 换成 '\'' 以安全嵌入任意路径。 */
+    function shQuote(p){ return "'"+String(p).replace(/'/g,"'\\''")+"'" }
+    /**
+     * 执行一段 shell 脚本。**按平台选择解释器**：此前硬编码 powershell，而预设用
+     * `disabled: !!js process.platform !== 'win32'` 在非 Windows 上关掉了 tool-pwsh 行——
+     * 插件会调用一个自己声明不提供的二进制，且返回值无人检查，表现为静默失效。
+     */
+    function isWindows(){ return process.platform === 'win32' }
+    function mkdirCmd(paths){
+      if(isWindows()) return 'New-Item -Force -ItemType Directory -Path '+paths.map(psQuote).join(',')+' | Out-Null'
+      return 'mkdir -p '+paths.map(shQuote).join(' ')
+    }
+    async function runShell(script,cwd){
+      const subprocess=subprocessOf(); if(subprocess===undefined) return {ok:false,error:'no-subprocess'}
+      try {
+        const argv = isWindows()
+          ? ['powershell','-NoProfile','-NonInteractive','-Command',script]
+          : ['/bin/sh','-c',script]
+        const h=subprocess.spawn({argv:argv,cwd:cwd||workspaceRoot(),stdio:{stdin:'ignore',stdout:'inherit',stderr:'inherit'},graceMs:20000})
+        const o=await h.done
+        return {ok:o.exitCode===0,exitCode:o.exitCode}
+      } catch(e){ return {ok:false,error:String((e&&e.message)||e)} }
+    }
+    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 } }
+    // 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 { if(!(await assertWritable(rel))) return false; 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){ noteSuspect(rel); return undefined } }
+    /**
+     * Corruption guard. `readJson` cannot tell "no file yet" from "file present but
+     * unparseable", yet loadAll() treats both as "no data" and the next saveAll()
+     * writes that emptiness back — so one externally damaged State/*.json silently
+     * reset the whole run (residents, taskboard, mailboxes). Any read that hits a
+     * present-but-unparseable JSON file records it; writeJson then REFUSES to write
+     * that path until the file is fixed or deleted. A missing file is still created
+     * normally, so first-run behaviour is unchanged.
+     */
+    const suspectFiles = new Set()
+    const warnedSuspect = {}
+    function noteSuspect(rel){
+      suspectFiles.add(rel)
+      if(warnedSuspect[rel]) return
+      warnedSuspect[rel]=true
+      console.error('vibe-math-v4: '+rel+' exists but is not parseable JSON — REFUSING to overwrite it so a corrupted file cannot silently erase your run. Fix or delete the file, then retry.')
+    }
+    function assertWritableSync(rel){
+      if(suspectFiles.has(rel)){ console.error('vibe-math-v4: write to '+rel+' blocked (file is unparseable; see the earlier warning)'); return false }
+      return true
+    }
+    /**
+     * Nothing read this path yet, so inspect the file actually on disk before
+     * replacing it. This closes the case where a fresh process never ran loadAll()
+     * (configure/start) and would otherwise write an empty state over a corrupt one
+     * the user might still want to inspect or repair.
+     */
+    async function assertWritable(rel){
+      if(!assertWritableSync(rel)) return false
+      try {
+        const raw=await readText(rel)
+        if(raw!==undefined && raw!==''){
+          try { JSON.parse(raw) } catch(e){ noteSuspect(rel); return false }
+        }
+      } catch(e){}
+      return true
+    }
+    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(mkdirCmd([vibeRoot()+'/Projects'].concat(dirs.map(d=>base+'/'+d)))) }
+    async function readTextAbs(path){ try { const t=await fs.resolve(path); const s=await fs.stat(t); if(s===undefined) return undefined; return await fs.readText(t) } catch(e){ return undefined } }
+    async function writeTextAbs(path,content){ try { const t=await fs.resolve(path); await fs.writeText(t,content,undefined,undefined,getPolicy()); return true } catch(e){ return false } }
+    async function readCurrentProject(){ try { const t=await readTextAbs(vibeRoot()+'/.current'); if(t) return String(t).trim() } catch(e){} return currentProject }
+    async function writeCurrentProject(){ try { await writeTextAbs(vibeRoot()+'/.current', currentProject) } catch(e){} }
+    function tryJson(s){ try { return JSON.parse(s) } catch(e){ return undefined } }
+    function parseReply(text){
+      let obj; const fence=/```(?:json)?[ \t]*([\s\S]*?)```/gi; let m
+      while((m=fence.exec(text))!==null){ const o=tryJson(m[1].trim()); if(o&&typeof o==='object'&&!Array.isArray(o)) obj=o }
+      if(!obj){ const w=tryJson(text.trim()); if(w&&typeof w==='object'&&!Array.isArray(w)) obj=w }
+      return obj||{}
+    }
+
+    // ---- persistence ----
+    async function saveAll(){
+      await writeJson('State/residents.json', Object.fromEntries(residents))
+      await writeJson('State/mailboxes.json', Object.fromEntries(mailboxes))
+      await writeJson('State/taskboard.json', taskboard)
+      await writeJson('State/decisions.json', decisions)
+      await writeJson('State/session.json', {running,autoDone,phase,problemId,problemText,runId,meetings,reports,lastActivityAt,lastProgressAt,activityLog,processEpoch,artifactCount})
+    }
+    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 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
+      const dc=await readJson('State/decisions.json'); if(Array.isArray(dc)) decisions=dc
+    }
+
+    // ---- 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' }
+    function residentLibraries(){
+      const base=frameworkRoot()
+      return '你的资料库根目录：'+base+'/\n'
+        +'  Progress/<你>/progress.md —— 你的研究日志（叙述，可追加。主要内容是尝试过的各方法、路线、历程、进度，当前研究进展/进度、将来的计划与打算，及各路线、过程中遇到的障碍及其原因，对各路线、方法的看法、可行性评估，自己研究过程中的一些有价值看法、感想、猜想、理解。以及其它各种你认为有价值的值得记录的事物、经验、方法/想法、创新等都可进行记录）。\n'
+        +'  Propos/<你>/<id>.md —— 你的命题/引理。格式：\n'
+        +'    - ID: p-<id>; - 状态: 未定论; - 概率: <0-1>; - 价值程度: <0-1>; - 动机用途计划: <为何重要/打算怎么用>\n'
+        +'    然后 ## 陈述 <陈述>；## 证明尝试；## 证伪尝试。\n'
+        +'  Methods/<你>/<id>.md —— 你的理论/方法/工具。格式：- ID: m-<id>; - 状态: 经验; - 可信断言: []; - 价值程度: <0-1>; - 动机用途计划: ...；然后 ## 核心内容；## 定义与记号；## 应用记录；## 改进历史。\n'
+        +'  Subproblems/<你>/<id>.md —— 你的子问题。格式：- ID: s-<id>; - 状态: 求解中; - 价值程度: <0-1>; - 动机用途计划: ...；然后 ## 陈述；## 进度。\n'
+    }
+    function toolList(){
+      return 'vibe_v4_send_message {to, content} —— 给某常驻发消息（to=all 广播）。\n'
+        +'vibe_v4_meeting {agenda} —— 发起/参与会议（框架会把各常驻的实际 input 转给其他人，让大家看到并讨论/辩论）。\n'
+        +'vibe_v4_propose_task/claim_task/task_done/list_tasks —— 共享任务板（提议/认领/完成/查看；任务板是你们协调分工的载体）。\n'
+        +'vibe_v4_publish_progress/record_proposition/record_method/record_subproblem —— 便捷记录器（可选；推荐直接用 fs 写自己的文件）。\n'
+        +'vibe_v4_read_progress {id} —— 只读某常驻的进展。\n'
+        +'vibe_v4_list_residents / vibe_v4_list_tasks —— 查看团队组成 / 开放任务。\n'
+        +'vibe_v4_report_context {pct} —— 上报上下文占比（框架据此压缩你的上下文）。\n'
+        +'fs (read/write/list) —— 读取任意文件；写入你自己的文件（推荐直接用 fs 直接写自己的 md）。\n'
+    }
+    // A shared, complete context block so a resident always knows the situation: mission,
+    // work model, what it can do, which files it owns (+ formats), what others' files are,
+    // and that it may READ anyone and WRITE its own directly. level 'full' = initial brief.
+    function contextBrief(r, level){
+      const s=[]
+      s.push('## 背景 —— 你是常驻研究团队的一员')
+      s.push('You are resident researcher '+r.rId+'（常驻研究者 '+r.rId+'；共 '+params.residentCount+' 位常驻），正在协作解决：')
+      s.push(problemText)
+      s.push('')
+      s.push('这像一个**真实的学术小组**：没有中央调度器、没有外部派活——你们自己通过 **互相发消息 + 开会讨论** 来决定一切：谁做什么、怎么分工、验证什么、何时停止。你的 Round 决定你这一轮做什么；团队的优先级与分工由大家的讨论涌现。')
+      s.push('')
+      s.push('### 工作模式（会发生什么）')
+      s.push('1. 每人有一份持久、全组可见的专属资料库（见下）。')
+      s.push('2. 你们自由发消息、开会；**会议会把每个人实际说的话（input）转给其他人**，让你看得到、能回复、能讨论、能辩论。')
+      s.push('3. 你独立研究，并**直接用 fs 写入你自己的文件**（按格式），供全组阅读。')
+      s.push('4. 任何"已确立"的东西须**全组一致**验证（全真或全假）才作数；否则只是带概率的工作估计。')
+      s.push('5. 只有**全组在会议上一致认为原问题已解决**，run 才停止。')
+      s.push('')
+      s.push('### 你负责的文件（你只写自己的；但可读任何人的）')
+      s.push(residentLibraries())
+      s.push('其他人把结论/进展写进他们的目录，你就能读到。**你应主动读别人的库**，对齐事实、彼此衔接、避免重复劳动。')
+      if(level!=='full'){ s.push('（格式见你最初的说明；直接用 fs 写自己的文件即可。）') }
+      s.push('')
+      s.push('### 可用工具')
+      s.push(toolList())
+      s.push('')
+      if(level==='full'){
+        s.push('### 可自主发明理论/工具（鼓励，但不强迫）')
+        s.push('请注意：你可以（但**不强迫**，完全视实际需要而定）尝试自主构建新的理论框架或工具——例如对某种系统做抽象化、一般化，抽离/推广出更一般的结构或理论框架；然后不断完善这个理论框架，在该框架下推得各种定理、性质、结论，以利于该框架下问题的解决。这就像为解决方程问题发明了群论、为分析需要建立了泛函分析框架——它比单纯解决当前问题更有学术价值，因为你直接得到了一类更普遍的方法/理论体系。')
+        s.push('若你发明了这样的理论/工具，请**阐明它对原问题的用处、价值**；后续可根据需要不断**完善、一般化、推广**它。把这类成果记入你的 Methods/<你>/ 库。')
+        s.push('')
+      }
+      s.push('### 规则')
+      s.push('- 只有 Verified/（或卡片标"已验证·真/假"）算已确立；其余都是你的实验性工作，请区分"猜想/已知"。')
+      s.push('- 验证必须**全组一致**（全真或全假）；你只信全票结果。未全票的对象留在库里带概率。')
+      s.push('- 你自己决定做什么，但**优先级/分工由团队讨论决定**，不是固定模式。若你认为问题已解决或接近解决，请**发起会议**让团队表决。')
+      s.push('- 退出时**只**输出一个 JSON 对象（放在 ```json 代码围栏内；围栏外不要有文字）。')
+      return s.join('\n')
+    }
+    // A SHORT core-rules recap, re-injected ONLY right after a compaction so the resident
+    // never loses the ground rules (they are told fully once at brainstorm, but a /compact
+    // could blank them).
+    function coreRulesBrief(){
+      const base=frameworkRoot()
+      return '[核心规则重申] 只有 Verified/（及标记"已验证·真/假"）算已确立；验证须全组一致（全真或全假）才作数，否则留库附平均概率；你只写自己的库（'+base+'/ 的 Progress/<你>/、Propos/<你>/、Methods/<你>/、Subproblems/<你>/），可只读任何人的库；任务分工由团队讨论决定；退出只输出一个 JSON 对象。'
+    }
+    function brainstormPrompt(r){
+      return (params.residentPersona?params.residentPersona+'\n':'')
+        +contextBrief(r,'full')+'\n'
+        +(r.direction?('\n\n你被建议的初始方向（可自行调整/细化）：\n'+r.direction+'\n'):'')
+        +'## 这是你的第一轮：独立头脑风暴\n'
+        +'独立地想清楚：你对这个问题的洞察 / 解决方向 / 关键子问题 / 可能的引理 / 粗略计划。你还未见到其他人，先独立产出。\n'
+        +'把有价值的产物**直接用 fs 写进你自己的文件**（按上面格式），并在 summary 里概述你的切入方向与初步结论（标注哪些是猜想、哪些凭你已确证）。\n'
+        +'Reply with ONLY a JSON object:\n'
+        +'{"summary":"<your insight / direction / rough plan, one tight paragraph>","solved":false}'
+    }
+    async function normalPrompt(r){
+      return (params.residentPersona?params.residentPersona+'\n':'')
+        +'Resident researcher '+r.rId+' — 第 '+r.rounds+' 轮。一切由你和团队讨论决定。动手前先**读别人的库**对齐事实、避免重复；把新进展/结论**直接用 fs 写进你自己的文件**；想对团队说的话放 "input"（会转给其他常驻）。\n'
+        +'\n团队成员：\n'+banner()+'\n'
+        +'New items:\n'+ (await inboxText(r.rId)) +'\n'
+        +'Reply with ONLY a JSON object:\n'
+        +'{"summary":"<what you did / decided this round, 1-3 sentences>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","task_desc":"<optional: why this task matters / what it covers|null>","claim_task":"<task id|null>","task_done":"<task id|null>","contextPct":40}'
+    }
+    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')
+      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'
+        +'{"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){
+      // In a DEBATE round, show the PREVIOUS round's opinions (kept in vs.history) so the resident can
+      // see others' stances and give a fresh independent judgement; in the first (independent) round no
+      // others' opinions exist yet. vs.verdicts only ever holds the CURRENT round's votes.
+      const src = (vs.stage==='debate' && vs.history && Object.keys(vs.history).length>0) ? vs.history : (vs.stage==='debate' ? vs.verdicts : {})
+      const others=Object.entries(src).map(([k,v])=>'- '+k+': 正确概率 '+String(v.prob!=null?Number(v.prob).toFixed(2):0.5)+' → '+v.reason).join('\n')
+      return (params.residentPersona?params.residentPersona+'\n':'')
+        +'Resident '+r.rId+' — 团队验证。 The group is verifying object '+vs.targetId+'（'+vs.targetType+'，提出者 '+vs.targetOwner+'）。\n'
+        +'请给出你对「该对象为真」的**正确概率 `verdict`**，仅一个 0–1 数值：**1 = 绝对为真，0 = 绝对为假，0.5 = 完全不确定，其余为介于其间的程度**（不要给 TRUE/FALSE，就给一个数值）。\n'
+        +'判定规则：仅当**全体常驻一致给 1（都认为是真）或一致给 0（都认为是假）**，才按「真/假」写入 Verified/；否则**只作为概率数值（一种程度）保留在库中**，附全组平均正确概率，不写成真/假。\n'
+        +'请给出你**诚实独立的判断**'
+        +(vs.stage==='debate'?'，并参考他人意见：\n':'。\n')
+        +(vs.stage==='debate'&&others?('### 他人上一轮意见（已转发给你）\n'+others+'\n'):'')
+        +'\nReply with ONLY a JSON object:\n'
+        +'{"vote":{"verdict":0.9,"reason":"<your logic>"}}'
+    }
+
+    // ---- resident lifecycle ----
+    let residentSeq = 0
+    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){
+      const ao=residentAgentOptions(); const tf=residentToolFilter()
+      const started=await subagents.startContinuable({provider:pickProvider(),label:r.rId,request:{prompt:[textBlock(brainstormPrompt(r))],parent:rootAgent,agentOptions:ao,...(tf?{toolFilter:tf}:{})},signal:makeSignal(params.activityTimeoutMs||60000)})
+      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')+')')
+    }
+    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
+      // 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
+      //       re-anchor the short core rules on the next wake of ANY kind, then CLEAR the flag.
+      //       (Short recap only; no self-summary directive — the real compact already condensed.)
+      //   (b) soft-compact trigger (contextPct>=threshold OR roundsSinceCompact>=afterRounds) =>
+      //       the resident's context genuinely grew; ask it to self-summary. ONLY on a normal
+      //       research round (kind==='normal'): a meeting/verify reply has no contextPct/compacted
+      //       fields, so a directive injected there is never acknowledged and would repeat forever.
+      let prompt = promptText
+      const isNormal = (kind||'normal')==='normal'
+      const wantSoft = isNormal && (Number(r.contextPct)>=Number(params.compactThreshold) || Number(r.roundsSinceCompact)>=Number(params.compactAfterRounds))
+      const wantReanchor = r.needCompact
+      if(wantSoft){
+        prompt = coreRulesBrief() + '\n' +
+          '[CONTEXT COMPACT — your conversation is at/near the limit. Do NOT re-derive history.\n' +
+          'Condense your current working state into ONE tight self-summary (findings so far, active direction, key artifacts you recorded, next concrete steps, open questions), then answer this round in the normal JSON format as usual.\n' +
+          'Set "contextPct": 15 (your post-compact usage) and "compacted": true in the reply so the framework records the condensed seed.]\n\n' + promptText
+        r.needCompact = true
+      } else if(wantReanchor){
+        prompt = coreRulesBrief() + '\n' + prompt
+        r.needCompact = false
+      }
+      // The DSH continuable-wake API is subagents.sendMessage(sender, targetId, content, {signal}),
+      // NOT subagents.followup (which is only Agent.followup, and does NOT exist on the subagents
+      // service). Using a non-existent method threw TypeError and made EVERY wake fail silently →
+      // the group went idle forever. Prefer sendMessage; fall back to a legacy followup if a host
+      // still exposes it (older deployments), so this works across versions.
+      try {
+        if(typeof subagents.sendMessage==='function'){
+          await subagents.sendMessage(rootAgent, r.childId, [textBlock(prompt)], {signal: makeSignal(params.activityTimeoutMs||60000)})
+        } else if(typeof subagents.followup==='function'){
+          await subagents.followup(rootAgent, r.childId, [textBlock(prompt)], {source:{kind:'user'},signal:makeSignal(params.activityTimeoutMs||60000)})
+        } else {
+          throw new Error('no subagent continuation API (need sendMessage or followup)')
+        }
+        return true
+      }
+      catch(e){ console.error('vibe-v4 wake '+r.rId+' failed: '+String((e&&e.message)||e)); busy.delete(r.rId); return false }
+    }
+    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){ 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?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.
+    //
+    // ⚠ 已知设计缺口（有意保留，未修）：计数口径**只有** 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):''})) }
+    // 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
+    // libraries correct under concurrency (e.g. all brainstorm residents in flight).
+    function residentOfAgent(agent){ try { const id=agent&&agent.id?String(agent.id):''; if(!id) return ''; for(const [,r] of residents){ if(r.childId===id) return r.rId } } catch(e){} return '' }
+
+    // ---- task board (residents propose / claim / complete; framework wakes the claimer) ----
+    async function writeTaskboard(){ const lines=['# 任务板','']; for(const t of taskboard){ lines.push('- ['+t.status+'] '+t.title+(t.claimer?('（认领:'+t.claimer+'）'):'')+(t.proposer?('（提议:'+t.proposer+'）'):'')+(t.description?('：'+t.description):'')) } await writeText('Shared/taskboard.md',lines.join('\n')) }
+    async function proposeTask(title,description,proposer){ const id='t-'+shortId(); taskboard.push({id,title:String(title),description:String(description||''),status:'open',proposer:proposer||'',claimer:'',source:''}); await saveTaskboard(); markProgress(); logActivity('task','proposed '+id+'「'+title+'」'); return {ok:true,id} }
+    async function claimTask(id,claimer){ const t=taskboard.find(x=>x.id===id); if(!t) return {ok:false,message:'no such task'}; if(t.status!=='open') return {ok:false,message:'task already '+t.status}; t.status='claimed'; t.claimer=claimer; await saveTaskboard(); markProgress(); logActivity('task',claimer+' claimed '+id); 
+      // 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() }
+      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){
+      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)){
+        r.contextSeed=String(parsed.summary||r.contextSeed||'')
+        r.contextPct=Math.min(r.contextPct||15,25)
+        r.roundsSinceCompact=0
+        r.needCompact=false
+        logActivity('compact', r.rId+' consolidated context')
+      }
+    }
+
+    // ---- messaging ----
+    async function postMessage(from,to,content){
+      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 mb=mailboxes.get(to)||[]; mb.push({from,at:now(),content}); mailboxes.set(to,mb); await saveAll(); logActivity('message',from+'→'+to+' (queued)'); return {ok:true}
+    }
+    async function broadcast(content, from){
+      let n=0
+      for(const [,r] of residents){ if(from && r.rId===from) continue; const res=await postMessage(from||'facilitator',r.rId,content); if(res&&res.ok) n++ }
+      logActivity('broadcast','to '+n+' resident(s)'); await saveAll(); return {ok:true,message:'broadcast to '+n+' resident(s)'}
+    }
+    // group conversation relay: when a resident "speaks" (input in its round), forward its
+    // words to every other resident's inbox so the whole group can see & react — a real group chat.
+    async function relayToGroup(from, content){
+      const text=String(content||'').trim()
+      if(!text) return
+      for(const [,r] of residents){
+        if(r.rId===from) continue
+        const mb=mailboxes.get(r.rId)||[]; mb.push({from,at:now(),content:'[群聊] '+text}); mailboxes.set(r.rId,mb)
+      }
+      logActivity('relay',from+' → 团队: '+text.slice(0,60)); markProgress(); await saveAll()
+    }
+
+    // ---- meeting ----
+    async function startMeeting(agenda,type,targetId){
+      if(meetingState) return {ok:false,message:'meeting already in progress'}
+      // 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: phase==='brainstorm'?'brainstorm':(!running?'paused':'verify')}
+      }
+      clearHeartbeat()
+      const ids=Array.from(residents.keys())
+      // Rotate the per-meeting speaking order so the SAME resident isn't always the "first speaker
+      // who sees no one else's contribution"; a real discussion lets each member lead sometimes.
+      const rot=Math.floor(Math.random()*Math.max(1,ids.length))
+      const order=ids.slice(rot).concat(ids.slice(0,rot))
+      meetingState={id:'mt-'+shortId(),agenda,type:type||'general',targetId:targetId||null,round:0,asked:[],inputs:{},transcript:[],order,at:now(),lastInputAt:now()}
+      markProgress();
+      logActivity('meeting','start: '+agenda); await saveAll(); await scheduleNext(); return {ok:true,id:meetingState.id}
+    }
+    async function continueMeetingRound(){
+      if(!meetingState) return
+      const st=meetingState
+      // STUCK watchdog: a meeting that has been active but collected NO new input for a long while
+      // is deadlocked (e.g. an in-flight/hung resident, a run of failed wakes). Abandoning it returns
+      // the group to normal self-organization (A heartbeat / B auto-sync can then re-drive) instead of
+      // permanently blocking the whole group behind a broken meeting.
+      if(now()-(st.lastInputAt||st.at||now())>=recoverStallMs()){
+        meetingState=null; wakeKind.clear(); logActivity('meeting','abandoned (stuck: no resident spoke)')
+        await saveAll(); await scheduleNext(); return
+      }
+      const ids=Array.from(residents.keys()); const allSpoke=ids.every(id=>st.inputs[id]!==undefined)
+      if(allSpoke){ await finalizeMeeting(); return }
+      // only wake IDLE un-spoken residents (rotated order); in-flight ones re-trigger this on end.
+      // NOTE: we deliberately do NOT flush mailboxes here — drafting an un-spoken resident into a normal
+      // mail round would delay the meeting and can starve the consensus past its watchdog if the mail
+      // backlog is large. Mail is delivered on scheduleNext passes when no consensus is in progress.
+      const order=st.order||ids
+      const id=order.find(x=>st.inputs[x]===undefined && !busy.has(x))
+      if(!id){ armHeartbeat(); return }   // no idle un-spoken resident (a busy/hung one): re-check later
+      const r=residents.get(id)
+      const ok = await wakeResident(r, meetingPrompt(r,st), 'meeting'); await saveAll()
+      if(!ok) armHeartbeat()   // a failed meeting wake must NOT silently hang the meeting
+    }
+    async function finalizeMeeting(){
+      if(finalizeLock) return   // reentry guard: two onResidentEnd may both see allSpoke → only finalize once
+      finalizeLock='meeting'
+      let doSchedule=false
+      try {
+        const st=meetingState
+        const ids=Array.from(residents.keys()); const allSpoke=ids.length>0 && ids.every(id=>st.inputs[id]!==undefined)
+        const lines=['# 会议 '+st.id+'｜'+fmtTime(),'','**议程**：'+st.agenda,'']
+        for(const [id,iv] of Object.entries(st.inputs)){ lines.push('### '+id); lines.push(iv.input||''); lines.push('') }
+        await writeText('Shared/meetings/'+st.id+'.md', lines.join('\n'))
+        // the full transcript lives on disk (Shared/meetings/<id>.md); the State array keeps a small
+        // index (id/agenda/at) so session.json does not carry a second copy of every transcript and
+        // rewrite it on EVERY saveAll during long runs (reports below are capped for the same reason).
+        meetings.push({id:st.id,agenda:st.agenda,at:now()}); if(meetings.length>200) meetings.shift()
+        logDecision('meeting',st.agenda)
+        // handle what the meeting produced: task proposals/claims, verify targets, stop vote
+        for(const [id,iv] of Object.entries(st.inputs)){
+          if(iv.propose_task) await proposeTask(iv.propose_task, iv.task_desc||'', id)
+          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)
+        logActivity('meeting', 'concluded'+(allSolved?' → ALL agree solved':' (no unanimous solved vote)'))
+        if(allSolved){
+          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()
+        doSchedule=true
+      } finally { finalizeLock=null }   // release BEFORE scheduling so a chained verify/meeting is not swallowed
+      if(doSchedule) await scheduleNext()
+    }
+
+    // ---- verification (unanimous) ----
+    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 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)+')')
+          await saveAll(); await scheduleNext(); return
+        }
+      }
+      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()
+    }
+    async function continueVerifyRound(){
+      if(!verifyState) return
+      const vs=verifyState
+      // STUCK watchdog: a verification that has been active but collected no new verdict for a long
+      // while is deadlocked (e.g. an in-flight/hung resident). Abandoning it keeps the object as an
+      // unverified probability (no unanimous consensus was reachable) and returns the group to normal
+      // scheduling instead of blocking the whole team behind a broken verification.
+      if(now()-(vs.lastVerdictAt||vs.at||now())>=recoverStallMs()){
+        verifyState=null; wakeKind.clear(); logActivity('verify',vs.targetId+' abandoned (stuck: no unanimous verdict reachable)')
+        await saveAll(); await scheduleNext(); return
+      }
+      const ids=Array.from(residents.keys()); const allVoted=ids.every(id=>vs.verdicts[id]!==undefined)
+      if(allVoted){ await finalizeVerify(); return }
+      // NOTE: we deliberately do NOT flush mailboxes here — drafting an un-voted resident into a normal
+      // mail round would delay its verdict and can starve the verify past its watchdog when the backlog
+      // is large. Mail is delivered on scheduleNext passes when no consensus is in progress.
+      const id=ids.find(x=>vs.verdicts[x]===undefined && !busy.has(x))
+      if(!id){ armHeartbeat(); return }   // no idle un-voted resident (a busy/hung one): re-check later
+      const r=residents.get(id)
+      const ok = await wakeResident(r, verifyPrompt(r,vs), vs.stage==='independent'?'verif-ind':'verif-deb'); await saveAll()
+      if(!ok) armHeartbeat()   // a failed verify wake must NOT silently hang the verification
+    }
+    async function finalizeVerify(){
+      if(finalizeLock) return   // reentry guard (two onResidentEnd may both see allVoted)
+      finalizeLock='verify'
+      let doSchedule=false
+      try {
+        const vs=verifyState; const expected=Array.from(residents.keys()).length
+        const allVoted = expected>0 && Object.keys(vs.verdicts).length>=expected
+        const vals=Object.values(vs.verdicts)
+        // verdict is a PURE 0-1 probability; only ALL=1 (true) or ALL=0 (false) is a binary verdict.
+        const allTrue = allVoted && vals.every(x=>Number(x.prob)===1)
+        const allFalse = allVoted && vals.every(x=>Number(x.prob)===0)
+        if(allTrue||allFalse){ await closeVerify(vs,allTrue); doSchedule=true }
+        else if(vs.round+1<params.verdictMaxRounds){
+          // 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
+        }
+        else {
+          const avg=vals.length? vals.reduce((a,x)=>a+(x.prob!=null?x.prob:0.5),0)/vals.length : 0.5
+          await writeDebateDoc(vs,false,avg); await rewriteSourceProb(vs.targetId, avg, vs.targetOwner); logActivity('verify',vs.targetId+' NOT unanimous → kept unverified (avg '+avg.toFixed(2)+')')
+          verifyState=null; wakeKind.clear(); await saveAll(); doSchedule=true
+        }
+      } finally { finalizeLock=null }   // release BEFORE scheduling (chained verifies must not be swallowed)
+      if(doSchedule) await scheduleNext()
+    }
+    async function closeVerify(vs,isTrue){
+      await writeDebateDoc(vs,true,isTrue?1:0)
+      const target=vs.targetId
+      await writeVerifiedCard(vs,isTrue)
+      await rewriteSource(target,isTrue,vs.targetOwner)
+      verifiedRecently.set(target, now())   // dedup: block an immediate re-proposal of the same object
+      logActivity('verify',target+' → Verified ('+(isTrue?'真':'假')+') by unanimous consensus')
+      verifyState=null; wakeKind.clear(); await saveAll()
+      // scheduling is done by finalizeVerify AFTER it releases finalizeLock (so a chained verify is
+      // 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 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=idSafe(target)   // sanitize BEFORE it becomes file names / dedup keys / status output
+      if(!t || t==='id') 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()})
+      return true
+    }
+    async function writeDebateDoc(vs,done,val){
+      const lines=['# 验证辩论｜'+vs.targetId+'('+vs.targetType+')｜'+fmtTime(),'',(done?('**结论**：'+(val===1?'全体一致为真':'全体一致为假')):('**未达成全体一致**，平均概率 '+val.toFixed(2))),'','## 各常驻意见']
+      for(const [k,v] of Object.entries(vs.verdicts)){ lines.push('### '+k+'｜正确概率 '+(v.prob!=null?Number(v.prob).toFixed(2):'0.50')); lines.push(v.reason||''); lines.push('') }
+      await writeText('Shared/debates/'+vs.targetId+'.md', lines.join('\n'))
+    }
+    async function writeVerifiedCard(vs,isTrue){
+      const isSub=vs.targetType==='subproblem'
+      const dir= isSub?'问题':'命题'
+      const type= isSub?'问题': vs.targetType==='method'?'方法':'命题'
+      const text='# 已验证｜'+vs.targetId+'\n- ID: '+vs.targetId+'\n- 类型: '+type+'\n- 结论: '+(isTrue?'真':'假')+'\n- 概率: '+(isTrue?1:0)+'\n- 来源: 全体常驻一致\n## 陈述\n参见来源卡。\n'
+      await writeText('Verified/'+dir+'/'+vs.targetId+'.md', text)
+    }
+    // Does `content` declare the target as its card ID? Accept both the exact `- ID: <id>` and the
+    // compact single-line form (`- ID: <id>; - 状态: ...`). Residents write cards by hand via fs with
+    // varying formats and (crucially) sometimes put a DIFFERENT file name than the declared ID (e.g.
+    // Propos/r-3/p-01.md declares "- ID: p-r3-01"). Matching only on the file name then silently loses
+    // the verified-status write-back, so we scan candidates' declared ID too.
+    function cardDeclaresId(content, target){
+      if(!content || !target) return false
+      const m=/-\s*ID:\s*([^;\n]+)/.exec(content)
+      return !!(m && String(m[1]).trim()===String(target).trim())
+    }
+    async function findSourceRel(target, owner){
+      // 1) exact file name in the owner's library (fast path), then every resident's library
+      const order = owner ? [owner, ...Array.from(residents.keys()).filter(k=>k!==owner)] : Array.from(residents.keys())
+      for(const rid of order){
+        for(const base of ['Propos','Methods','Subproblems']){
+          const cand=base+'/'+rid+'/'+target+'.md'
+          const t0=await readText(cand); if(t0!==undefined) return cand
+        }
+      }
+      // 2) declared-ID scan: residents sometimes name the file differently from the declared card ID
+      //    (e.g. p-01.md declares ID p-r3-01). Look inside every card of every library for the target ID.
+      try {
+        for(const rid of order){
+          for(const base of ['Propos','Methods','Subproblems']){
+            const dirT=await fs.resolve(base+'/'+rid, {cwd: frameworkRoot()})
+            if(await fs.stat(dirT)===undefined) continue
+            const entries=await fs.listDir(dirT)
+            for(const e of entries||[]){
+              if(!e || e.type!=='file' || !/\.md$/.test(String(e.name))) continue
+              const c=await readText(base+'/'+rid+'/'+e.name)
+              if(c!==undefined && cardDeclaresId(c,target)) return base+'/'+rid+'/'+e.name
+            }
+          }
+        }
+      } catch(e){ /* scanning is best-effort */ }
+      return null   // NOT 'Propos/'+target+'.md': writing there would create a stray empty card
+    }
+    // Update the `- 状态:` / `- 概率:` fields of a source card. Residents hand-write cards in two
+    // shapes: one field per line, or one line with `; `-separated fields. Accept both by allowing the
+    // anchor anywhere on a line and consuming up to the next `;` when fields share the line.
+    function rewriteCardField(text, field, newValue){
+      if(!text) return text
+      const esc=field.replace(/[.*+?^${}()|[\]\\]/g,'\\$&')
+      // one-per-line: `- 状态: ...\n`  OR  inline: `; - 状态: ...;` / `- 状态: ...; - 概率:`
+      const re=new RegExp('(^|\\n|;\\s*)-\\s*'+esc+':[^;\\n]*','gm')
+      const replaced=text.replace(re,'$1- '+field+': '+newValue)
+      return replaced===text ? text : replaced
+    }
+    // non-unanimous verification: keep the object in its library but write back the
+    // average probability (design §8: "留库附概率"), so the card reflects the consensus estimate.
+    async function rewriteSourceProb(target,prob,owner){
+      const rel=await findSourceRel(target,owner)
+      if(!rel){ logActivity('verify',target+' source card NOT found; avg prob '+Number(prob).toFixed(2)+' not written back'); return }
+      let text=(await readText(rel))||''
+      const next=rewriteCardField(text,'概率',Number(prob).toFixed(2))
+      await writeText(rel,next||text)
+    }
+    async function rewriteSource(target,isTrue,owner){
+      // find & update the source card status/prob; best effort across per-resident libs
+      const rel=await findSourceRel(target,owner)
+      if(!rel){ logActivity('verify',target+' source card NOT found; verified status not written back'); return }
+      let text=(await readText(rel))||''
+      let next=rewriteCardField(text,'状态',isTrue?'已验证·真':'已验证·假')
+      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' }
+
+    // ---- heartbeat / liveness helpers (boundary-A: event-driven + gated heartbeat) ----
+    // A checkpoint wake is NOT "keep working forever": it nudges the least-recently-active
+    // resident, after an idle timeout, to CONTINUE the work itself (self-drive), and only to
+    // propose a meeting/verify/solved when it truly has nothing left. This keeps the group moving
+    // on its own (framework never assigns work) but adds convergence pressure instead of letting
+    // a stalled group sit idle forever.
+    function heartbeatPrompt(r){
+      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>","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(){
+      clearHeartbeat()
+      const ms=posMs(params.activityTimeoutMs,120000)
+      if(typeof ctx.timeout!=='function') return
+      heartbeatDisposer=ctx.timeout(()=>{ heartbeatDisposer=null; scheduleNext().catch(()=>{}) }, ms)
+    }
+    // Real DSH /compact of a resident's OWN session via ctx.compaction (if the host provides it);
+    // falling back silently to the resident self-summary directive when the service is absent.
+    //
+    // WHY THE LIVE-AGENT CACHE EXISTS: `subagent/end` fires AFTER the child's Activation has
+    // been torn down. The host's teardown order is
+    //   dsh-subagent/lib/index.js:1231  await activation.handle.dispose()
+    //   dsh-agent/lib/index.js:508      this.store.delete(entry.id)      <- child leaves the registry
+    //   dsh-subagent/lib/index.js:1241  activation.observer.settle(...)  <- ONLY NOW is subagent/end emitted
+    // so `agents.get(childId)` inside an end handler ALWAYS returns undefined. Looking the child
+    // up there made this entire path dead code. Instead we capture the live Agent when
+    // `subagent/start` fires (the child is still registered then) and hold it in a WeakRef so a
+    // resident that is never released cannot pin its Agent forever.
+    const liveAgents = new Map()   // childId -> WeakRef<Agent>
+    function rememberAgent(childId, agent){ if(childId && agent){ try { liveAgents.set(childId, new WeakRef(agent)) } catch(e){ liveAgents.set(childId, { deref:()=>agent }) } } }
+    function forgetAgent(childId){ liveAgents.delete(childId) }
+    function liveAgentOf(childId){
+      const ref=liveAgents.get(childId)
+      if(ref){ const a=typeof ref.deref==='function'?ref.deref():undefined; if(a) return a }
+      // fallback: a host that keeps the child registered through the end notification
+      try { return agents.get(childId) } catch(e){ return undefined }
+    }
+    /**
+     * Resolve the compaction service a CHILD AGENT should use — i.e. through that
+     * agent's own context, not this plugin's.
+     *
+     * Each preset group declares `isolate: { compaction: true, toolResultPruner: true }`
+     * (copied verbatim from DSH's own `standard` preset, whose comment states the realm's
+     * purpose: "What a preset chooses is whether its agent compacts at all, which is
+     * `compaction-basic` below"). A row sitting OUTSIDE that realm resolves the HOST ROOT
+     * instance instead, so this plugin's calls would ignore the preset's own compaction
+     * config, and the sub-agent's step-boundary compaction (which runs from inside the
+     * realm) would use a different instance than the framework's calls here.
+     *
+     * `Agent.ctx` is documented as "Agent-scoped context; its contributions are
+     * agent-local" (dsh-agent/lib/types/runtime-types.d.ts:148), so the child's own
+     * context resolves the preset plane the child actually lives on. This keeps the
+     * plugin row where it is (nothing else moves in or out of the realm) while making
+     * both compaction paths agree on one instance.
+     */
+    function compactionForAgent(agent){
+      try { const c = agent && agent.ctx ? agent.ctx.get('compaction') : undefined; if(c && c.compactIfNeeded) return c } catch(e){}
+      // fallback: this plugin's own plane (host root for a row outside the realm)
+      return compactionOf()
+    }
+    async function realCompact(r){
+      if(!r || !r.childId) return
+      const agent = liveAgentOf(r.childId)
+      if(!agent || !agent.session) return
+      const compaction = compactionForAgent(agent)
+      if(compaction===undefined || !compaction.compactIfNeeded) return
+      try {
+        const signal = makeSignal(params.activityTimeoutMs||60000)
+        const result = await compaction.compactIfNeeded(agent, 'pressure', signal)
+        if(result && (result.shadowedSeqs||[]).length>0){
+          // the resident's real session was compacted → its context is now a summary.
+          // Flag needCompact so the NEXT wake re-anchors the core rules (they may have been blurred).
+          r.roundsSinceCompact=0; r.needCompact=true; r.contextPct=Math.min(r.contextPct||15,25)
+          logActivity('compact', r.rId+' real /compact (shadowed '+result.shadowedSeqs.length+' items, ~'+String(result.shadowedTokenCount||0)+' tokens)')
+        }
+      } catch(e){ /* real compaction unavailable/failed; the soft directive already covers it */ }
+    }
+
+    // ---- liveness / scheduling ----
+    async function scheduleNext(){
+      if(!running||autoDone){ clearHeartbeat(); return }
+      if(phase==='brainstorm'){ await maybeFinishBrainstorm(); return }
+      if(meetingState){ await continueMeetingRound(); return }
+      if(verifyState){ await continueVerifyRound(); 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 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
+      // 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 }
+      // 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
+      //    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.length===0 && busy.size===0){
+        const stallMs=posMs(params.stallAutoMeetingMs, posMs(params.activityTimeoutMs,120000)*3)
+        if(now()-lastProgressAt>=stallMs){
+          await startMeeting('团队较长时间没有新进展。请你们自行讨论：当前问题是否已解决、开放难点是什么、谁负责哪部分、下一步如何推进，并自主决定是否继续。框架只负责转达与记录，不替你们决定。','general',null)
+          return
+        }
+      }
+      // A) heartbeat / coordination: wake IDLE residents after an idle timeout to SELF-DRIVE (continue
+      //    solving / message / propose task / meeting / verify). This is a CONCURRENCY FILL, not a
+      //    single nudge: scheduleNext should wake up to `maxParallel` idle residents in one pass so the
+      //    group can progress in parallel (design §A: "同一时刻可唤醒多个空闲常驻，受 maxParallel 上限").
+      //    On a FAILED wake we re-arm the heartbeat so a single follow-up error NEVER permanently stops
+      //    the group (a successful wake re-drives scheduleNext through its own onResidentEnd, which re-arms).
+      clearHeartbeat()
+      const atOs=posMs(params.activityTimeoutMs,120000)
+      // `mp` (maxParallel) is already declared above in this function scope.
+      // Collect idle (not busy) residents sorted by idle time, oldest-first (round-robin fairness).
+      const idleCandidates = Array.from(residents.values())
+        .filter(r=>!busy.has(r.rId))
+        .sort((a,b)=>(now()-b.lastActiveAt)-(now()-a.lastActiveAt))
+      // Fill the concurrency budget: keep waking the most-idle resident until either everyone idle is
+      // started OR the in-flight cap (maxParallel) is reached. This turns the previous "one at a time"
+      // serialization into genuine parallel progress.
+      let started=0
+      for(const r of idleCandidates){
+        const free = mp>0 ? (mp - busy.size) : Number.MAX_SAFE_INTEGER
+        if(free<=0) break            // concurrency cap reached → stop filling
+        if((now()-r.lastActiveAt)<atOs) break   // the remaining are all busy-or-not-idle-enough
+        let ok=false
+        try { ok = await wakeResident(r, await heartbeatPrompt(r), 'normal') } catch(e){ ok=false }
+        if(ok) started++
+        await saveAll()
+        if(!ok) continue             // a failed wake must NOT stop the fill; try the next idle resident
+      }
+      if(started>0) { armHeartbeat(); return }   // started some; re-drive comes via onResidentEnd, BUT also arm a
+      // safety-net heartbeat so a woken resident whose subagent/end NEVER arrives (a hung normal round) does not
+      // freeze the group. Below mp, the next scheduleNext will re-fill; if all woken residents are stuck busy the
+      // heartbeat just re-arms harmlessly. (Meeting/verify already have recoverStallMs watchdogs; normal A-fill did not.)
+      // everyone is busy or not idle-enough: arm a heartbeat to re-check later (no infinite spin)
+      armHeartbeat()
+    }
+    async function maybeFinishBrainstorm(){
+      const pending=[]; for(const [,r] of residents){ if(r.status==='brainstorm' && !r.insight) pending.push(r.rId) }
+      if(pending.length===0){ phase='active'; logActivity('phase','active — residents now self-organize'); await saveBrainstormSummary(); await saveAll(); await scheduleNext() }
+    }
+    async function saveBrainstormSummary(){
+      const lines=['# 头脑风暴','']; for(const [,r] of residents){ if(r.insight){ lines.push('## '+r.rId+'「'+(r.direction||'')+'」'); lines.push(r.insight); lines.push('') } }
+      await writeText('Shared/meetings/brainstorm.md', lines.join('\n'))
+    }
+    async function deliverNextMailbox(){
+      // Deliver queued messages to ALL currently-idle recipients in one pass (parallel), bounded by the
+      // same maxParallel concurrency cap, so a group chat (relayToGroup → many non-busy recipients) is
+      // not serialized one-message-at-a-time. Returns true if anything was delivered. A busy recipient
+      // keeps its message queued (avoid starving others).
+      let delivered=false
+      for(const [to,msgs] of mailboxes){
+        if(msgs.length===0) continue
+        const r=residents.get(to); if(!r){ mailboxes.delete(to); continue }   // stale recipient → drop the entry
+        if(busy.has(to)) continue   // recipient busy → leave the message queued for a later pass
+        const mp=Number(params.maxParallel)||0
+        if(mp>0 && busy.size>=mp) break   // concurrency cap reached → stop delivering more now
+        const m=msgs.shift()
+        currentResident=to
+        const ok = await wakeResident(r, (await normalPrompt(r))+'\n\n[MESSAGE from '+m.from+']\n'+m.content,'normal')
+        await saveAll(); if(!ok) msgs.unshift(m); delivered=delivered||ok
+      }
+      return delivered
+    }
+
+    // ---- resident end handler ----
+    async function onResidentEnd(childId, info){
+      const r=byChild(childId); if(!r) return
+      // 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
+      // team. We count only a clean 'completed' turn: an error/max-tokens/refusal did NOT meaningfully
+      // advance the work, so it must NOT mask a truly stalled group (B can then convene a recovery
+      // meeting). A completed turn also refreshes the meeting/verify deadlock clock through lastInputAt.
+      if(info && info.stopReason==='completed') markProgress()
+      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'
+      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()
+        if(parsed.propose_verify) maybeQueueVerify(parsed.propose_verify, r.rId)
+        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 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()
+        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' }
+      if(typeof parsed.solved==='boolean'){ reports.push({rId:r.rId,solved:parsed.solved,summary:parsed.summary||'',at:now()}); if(reports.length>100) reports.shift() }   // solved-signal ring (not surfaced in status/report)
+      if(parsed.propose_verify) maybeQueueVerify(parsed.propose_verify, r.rId)
+      // group-conversation relay: the resident may choose to speak to the whole team (input) —
+      // forward it to the others so this is a real discussion group, not private monologues.
+      if(typeof parsed.input==='string' && parsed.input.trim()) await relayToGroup(r.rId, parsed.input.trim())
+      // task actions via reply (a resident may propose or claim a task in its round)
+      if(parsed.propose_task) await proposeTask(parsed.propose_task, parsed.task_desc||'', r.rId)
+      if(parsed.claim_task) await claimTask(parsed.claim_task, r.rId)
+      if(parsed.task_done) await taskDone(parsed.task_done, r.rId)
+      // a resident may self-trigger a meeting (resident-driven coordination, closest to the philosophy).
+      // If a verify is holding the floor the meeting is deferred (pendingMeeting) and we fall through
+      // so the pending verify (or mailbox/heartbeat) still advances rather than being stuck behind it.
+      if(parsed.propose_meeting && !meetingState){
+        const mr=await startMeeting(String(parsed.propose_meeting),'general',null); await saveAll()
+        if(mr && !mr.deferred) return
+      }
+      await saveAll(); await scheduleNext()
+    }
+
+    // ---- controls ----
+    async function start({problem,residentCount,seedDirections}){
+      await loadSettings()
+      currentProject=await readCurrentProject(); if(!currentProject||currentProject==='default'){ currentProject='default'; }
+      await ensureDirs()
+      if(problem) problemText=String(problem)
+      if(!problemText) return {ok:false,message:'problem text required (pass problem, or use vibe_v4_configure first)'}
+      problemId=slugify(problemText.slice(0,40))||'problem'
+      if(residentCount) params.residentCount=Number(residentCount)||4
+      if(!(Number(params.residentCount)>=1)) params.residentCount=DEFAULT_PARAMS.residentCount   // a 0/negative count (settings misconfig) would spawn nobody & idle forever
+      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')
+      // 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):[]
+      for(let i=0;i<params.residentCount;i++){ const r=newResident(dirs[i]||''); await spawnResident(r) }
+      await saveAll(); return {ok:true,message:'v4 started: '+params.residentCount+' resident(s) brainstorming',project:currentProject}
+    }
+    async function resume(){
+      currentProject=await readCurrentProject(); await ensureDirs()
+      // Resume is only meaningful for a stopped/paused/crashed run. If THIS process is already driving
+      // a live run whose disk state belongs to it, loadAll below would overwrite the in-memory state
+      // with a slightly stale snapshot (busy marks, wake round counters, mailbox contents from the last
+      // saveAll) — a silent clobber for a useless "kick". No-op instead. A cross-process restart is
+      // always allowed: its disk epoch differs, so the in-memory state is empty/stale anyway.
+      const pre=await readJson('State/session.json')
+      if(running && !autoDone && pre && pre.processEpoch===processEpoch) return {ok:true,message:'already running (no-op)'}
+      await loadAll(); await loadSettings()
+      // 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).
+      for(const key of residents.keys()){ const mm=/^r-(\d+)$/.exec(String(key)); if(mm) residentSeq=Math.max(residentSeq, Number(mm[1])) }
+      lastActivityAt=now(); lastProgressAt=now()   // pause must not count as stall time; a resumed run gets a fresh clock
+      if(phase==='idle' && !running && residents.size===0) return {ok:false,message:'nothing to resume'}
+      // 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.
+      const 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
+      // under phase='active' (brainstorm summary never written), and a LATE subagent/end from an interrupted
+      // OLD resident (same rId) deletes the NEW resident's busy mark → A-fill can wake it mid-brainstorm.
+      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=[]; 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.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.length?pendingVerify[0].targetId:null,
+      parkedMeeting: pendingMeeting?pendingMeeting.agenda:null,
+      meetings:meetings.length, recentActivity: activityLog.slice(-8) } }
+    async function addMember(direction){
+      // Adding a member starts a REAL resident turn (spawnResident → brainstorm) — refuse unless the
+      // run is live: on a concluded (autoDone) or never-started/paused run the new member would work
+      // with nobody to coordinate (zombie work on a project the group already declared done).
+      if(!running || autoDone) return {ok:false,message:'no active run to join (start or resume first)'}
+      const r=newResident(direction||''); await spawnResident(r)
+      // Mid-meeting additions must join the meeting's speaking order; otherwise allSpoke (over CURRENT
+      // residents) can never be true for the new member (not in the snapshot order) and the meeting is
+      // only ever released by the stuck watchdog instead of finalizing with everyone's input.
+      if(meetingState){ if(!Array.isArray(meetingState.order)) meetingState.order=Array.from(residents.keys()); if(!meetingState.order.includes(r.rId)) meetingState.order.push(r.rId) }
+      // 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); 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 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] }
+      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){
+      const INT_KEYS=['residentCount','compactThreshold','compactAfterRounds','maxParallel','activityTimeoutMs','verdictMaxRounds','meetingKeepEvery','stallAutoMeetingMs']
+      if(INT_KEYS.includes(k)){ const n=Number(v); if(!Number.isFinite(n)) return v; return Math.floor(n) }
+      if(k==='toolAllow'||k==='toolDeny'){ if(Array.isArray(v)) return v.map(x=>String(x).trim()).filter(Boolean); if(typeof v==='string') return v.split(',').map(x=>x.trim()).filter(Boolean); return [] }
+      return v
+    }
+    /**
+     * 并发闸门相关参数的下界。
+     *
+     * `maxParallel` 在调度里被当成"0 或负数 = 不限流"（见 scheduleNext 的 `mp>0` 守卫与
+     * `free = mp>0 ? mp-busy.size : MAX_SAFE_INTEGER`），所以用户设成 0 会让闸门**完全失效**、
+     * 一次唤醒全部常驻，与"同时唤醒的常驻上限"语义正好相反 —— 这里抬到最小合法值 1。
+     * `residentCount` 同理（0 会一个常驻都不建）。
+     *
+     * 注意**不要**给 activityTimeoutMs / compactThreshold 之类加下界：文档明确建议测试时把
+     * activityTimeoutMs 设成 40ms 这种小值，钳制它会破坏受支持的配置。
+     */
+    const INT_MIN = { maxParallel: 1, residentCount: 1 }
+    function clampInt(k, n){
+      const min = INT_MIN[k]
+      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} }
+    // ---- 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 } } } }
+    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 {}.
+    async function configure(cfg){
+      // configure is the PRE-START setup tool (project/problem/params). Switching the project while a
+      // run is LIVE would split the run's state across two trees: residents' briefs & libraries point
+      // at the OLD frameworkRoot while every subsequent saveAll/transcript/Verified card would go to the
+      // NEW project. Params tuning mid-run belongs to vibe_v4_set.
+      if(running && !autoDone) return {ok:false,message:'cannot configure while a run is running (pause or abort first; use vibe_v4_set to tune params)'}
+      if(cfg && cfg.project && String(cfg.project).trim()) currentProject=String(cfg.project).trim()
+      if(cfg && cfg.problem) problemText=String(cfg.problem)
+      if(cfg && cfg.params && typeof cfg.params==='object') setParams(cfg.params)
+      await writeCurrentProject(); await ensureDirs(); await saveSettings()
+      // create the problem card so the project is complete BEFORE the run starts
+      if(problemText){ const pid=slugify(problemText.slice(0,40))||'problem'; await writeText('Problems/'+pid+'.md','# 问题｜'+pid+'\n- ID: '+pid+'\n- 类型: 问题\n- 状态: 求解中\n- 优先级: 1\n- 依赖: []\n\n## 陈述\n'+problemText+'\n') }
+      await saveAll()
+      return {ok:true,project:currentProject,problem:problemText?problemText.slice(0,60):'',params:Object.keys(params).map(k=>k+'='+params[k]).join(', ')}
+    }
+    async function initAbort(){ clearHeartbeat(); running=false; phase='idle'; autoDone=false; for(const [,r] of residents){ if(r.childId){ try{ subagents.interrupt(r.childId,{kind:'ancestor',agent:rootAgent}) }catch(e){} } r.childId=''; r.lastActiveAt=0; r.roundsSinceCompact=0 }
+      // Wipe the coordination state too: an aborted run must not report an in-flight meeting/verify,
+      // a parked meeting, a verify queue, or busy residents (their childIds are gone, so no end event
+      // 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
+      await saveAll(); return {ok:true,message:'aborted'} }
+    function setPause(){ clearHeartbeat(); running=false; return {ok:true,message:'paused'} }
+
+    return {
+      sessionId, running:()=>running, autoDone:()=>autoDone, phase:()=>phase,
+      onResidentEnd, start, resume, status, report, addMember, removeMember, setParams,
+      // live-Agent cache for the real /compact path (see `liveAgents`): the child is
+      // captured at subagent/start and released once its end handler has run.
+      rememberAgent, forgetAgent,
+      setPause, initAbort, postMessage, startMeeting, saveAll, broadcast, configure, loadSettings,
+      currentResident:()=>currentResident,
+      // 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 : '' },
+      useResident:(id)=>{ currentResident=id },
+      publishProgress, recordProposition, recordMethod, recordSubproblem, listResidents, reportContext,
+      proposeTask, claimTask, taskDone, listTasks,
+      readProgress: async (rid)=>({text:(await readText('Progress/'+rid+'/progress.md'))||''}),
+      frameworkRoot:frameworkRoot, currentProject:()=>currentProject, problemText:()=>problemText,
+      residentCount:()=>residents.size,
+      busyCount:()=>busy.size,
+    }
+  } // end makeSession
+
+  // ================= apply-level registration (ONCE) =================
+  function objParams(props, required){ return { type:'object', properties:props, additionalProperties:false, required:required||[] } }
+  function registerTool(name, description, parameters, fn){
+    // tools.register() returns a Cordis effect disposer. Both v2 and v3 keep the
+    // registration inside ctx.effect() so it is wound back when the preset subtree
+    // unloads; v4 used to drop the disposer, so a second mount of this preset in the
+    // same process collided on the already-registered tool names and the entries
+    // survived an unload. Route it through ctx.effect() like the other two.
+    ctx.effect(() => tools.register({ name, description, parameters,
+      output:{ schema:{ type:'string' }, render:(_a,v)=>[{type:'text',text:String(v)}] },
+      execute: async (args, exec)=>{
+        try { const s=getSession(exec&&exec.agent); if(!s) return JSON.stringify({ok:false,error:'no session'}); return JSON.stringify(await fn(s,args||{},exec&&exec.agent)) }
+        catch(e){ return JSON.stringify({ok:false,error:String((e&&e.message)||e)}) }
+      } }))
+  }
+  // host/assistant-facing
+  registerTool('vibe_v4_configure','Create/configure a project: set project name, problem, and params WITHOUT starting a run. Use this FIRST, then vibe_v4_start to actually spawn residents.',objParams({project:{type:'string'},problem:{type:'string'},params:{type:'object'}}),(s,a)=>s.configure(a))
+  registerTool('vibe_v4_start','Start V4: spawn N resident subagents (brainstorm then self-organize).',objParams({problem:{type:'string'},residentCount:{type:'integer'},seedDirections:{type:'array',items:{type:'string'}}}),(s,a)=>s.start(a))
+  registerTool('vibe_v4_resume','Resume a persisted V4 run.',objParams({}),(s)=>s.resume())
+  registerTool('vibe_v4_pause','Pause V4.',objParams({}),(s)=>s.setPause())
+  registerTool('vibe_v4_abort','Abort V4 and interrupt residents.',objParams({}),(s)=>s.initAbort())
+  registerTool('vibe_v4_status','Show V4 status.',objParams({}),(s)=>s.status())
+  registerTool('vibe_v4_report','Return the V4 progress report.',objParams({}),(s)=>s.report())
+  registerTool('vibe_v4_message','Inject a message to a resident (or all).',objParams({to:{type:'string'},content:{type:'string'}},['to','content']),(s,a)=>{ const to=a.to||'all'; if(to==='all') return s.broadcast(a.content); return s.postMessage('facilitator',to,a.content) })
+  registerTool('vibe_v4_meeting','Start a meeting (coordinate / allocate / propose verification).',objParams({agenda:{type:'string'}},['agenda']),(s,a)=>s.startMeeting(a.agenda))
+  registerTool('vibe_v4_list_members','List residents.',objParams({}),(s)=>({ok:true,residents:s.listResidents()}))
+  registerTool('vibe_v4_add_member','Add a resident.',objParams({direction:{type:'string'}}),(s,a)=>s.addMember(a.direction))
+  registerTool('vibe_v4_remove_member','Close a resident.',objParams({id:{type:'string'}},['id']),(s,a)=>s.removeMember(a.id))
+  // model/provider inheritance: set model/provider to override the residents' LLM route (''=inherit
+  // the main assistant's route). toolAllow/toolDeny are per-resident tool permissions (scoped
+  // restrict). residentPersona prepends a persona line to every resident prompt.
+  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.',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'}}}),(s,a)=>{ s.setParams(a); return {ok:true} })
+  // 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) })
+  registerTool('vibe_v4_publish_progress','(resident) Append to your own progress markdown.',objParams({content:{type:'string'}},['content']),(s,a,x)=>s.publishProgress(s.residentIdOf(x),a.content))
+  registerTool('vibe_v4_record_proposition','(resident) Record a proposition to your library.',objParams({id:{type:'string'},title:{type:'string'},statement:{type:'string'},prob:{type:'number'},value:{type:'number'},motivation:{type:'string'}}),(s,a,x)=>s.recordProposition(s.residentIdOf(x),a))
+  registerTool('vibe_v4_record_method','(resident) Record a method/theory to your library.',objParams({id:{type:'string'},title:{type:'string'},type:{type:'string'},content:{type:'string'},notation:{type:'string'},value:{type:'number'},motivation:{type:'string'}}),(s,a,x)=>s.recordMethod(s.residentIdOf(x),a))
+  registerTool('vibe_v4_record_subproblem','(resident) Record a sub-problem to your library.',objParams({id:{type:'string'},title:{type:'string'},statement:{type:'string'},value:{type:'number'},motivation:{type:'string'}}),(s,a,x)=>s.recordSubproblem(s.residentIdOf(x),a))
+  registerTool('vibe_v4_read_progress','(resident) Read another resident\'s progress (read-only).',objParams({id:{type:'string'}},['id']),async (s,a)=>{ const rp=await s.readProgress(a.id); return {ok:true,text:(rp&&rp.text)||''} })
+  registerTool('vibe_v4_list_residents','(resident) List fellow residents.',objParams({}),(s)=>({ok:true,residents:s.listResidents()}))
+  // task board (residents; board is the residents' own allocation mechanism)
+  registerTool('vibe_v4_propose_task','(resident) Propose a task to the shared task board.',objParams({title:{type:'string'},description:{type:'string'}},['title']),(s,a,x)=>s.proposeTask(a.title,a.description,s.residentIdOf(x)))
+  registerTool('vibe_v4_claim_task','(resident) Claim an open task from the board (framework then wakes you to work it).',objParams({id:{type:'string'}},['id']),(s,a,x)=>s.claimTask(a.id,s.residentIdOf(x)))
+  registerTool('vibe_v4_task_done','(resident) Mark a claimed task done.',objParams({id:{type:'string'},claimer:{type:'string'}},['id']),(s,a,x)=>s.taskDone(a.id,a.claimer||s.residentIdOf(x)))
+  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}))
+
+  // Same lifecycle rule as registerTool: commands.register() returns a disposer, so the
+  // registration belongs to this fiber and must be unwound with it.
+  ctx.effect(() => commands.register({
+    name:'v4', description:'control the Vibe Math V4 framework',
+    input:{hint:'[configure|start|resume|pause|abort|status|report|meeting|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({})
+      else if(cmd==='resume') r=await s.resume()
+      else if(cmd==='pause') r=s.setPause()
+      else if(cmd==='abort') r=await s.initAbort()
+      else if(cmd==='status') r=s.status()
+      else if(cmd==='report') r=s.report()
+      else if(cmd==='meeting') r=await s.startMeeting(rest.join(' '))
+      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|meeting|members|add|remove|set'}
+      return {kind:'success',text:JSON.stringify(r,null,2)}
+    },
+  }))
+
+  // Capture the live child Agent while it is still registered. `subagent/end` is
+  // emitted only AFTER the child's Activation teardown has removed it from the agent
+  // 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.
+  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)
+  })
+
+  ctx.on('subagent/end', function(info){
+    const sid=childOwner.get(info.id); const s=sid!==undefined?sessions.get(sid):undefined
+    if(s) s.onResidentEnd(info.id, info)
+      .catch(e=>{ console.error('vibe-v4 end: '+String((e&&e.stack)||e)); if(s.nudge) s.nudge() })
+      // Release the captured live Agent only AFTER this end has been processed, so the
+      // real /compact inside onResidentEnd still sees it. The WeakRef means a missed
+      // release only delays collection rather than leaking the Agent.
+      .finally(()=>{ if(s.forgetAgent) s.forgetAgent(info.id) })
+  })
+}