dsh-vibe-math 2.0.2 → 2.0.4

package/README.md

@@ -40,6 +40,7 @@
 **一句话流水线**：起始产生 N 个**常驻子代理**（continuable，持久上下文）先各自头脑风暴、产出初始见解/方向 → 此后**所有任务安排由它们互相留言 + 集体开会自主决定**（框架只做消息总线/会议/任务板/产物沉淀，**绝不分配任务**）；每个常驻把有价值的产物按**价值程度 / 动机用途计划 / 自身概率估计**沉淀到**自己**的 `Progress/<id>/`、`Propos/<id>/`、`Methods/<id>/`、`Subproblems/<id>/` 库，并**可互相阅读**；验证由它们**自行商议**发起，**仅当全体常驻一致（真或假）**才写入 `Verified/`，否则留库附概率；常驻上下文量达阈值（默认 66%）自动 `/compact`；**仅当全体一致认为原问题已解决**才停止；可随时人工干预/增开/关闭常驻，支持断点续跑。
 
 > 说明：V4 去掉 v3 的中央规划器与确定性角色（explorer/solver/verifier/planner/method-keeper），把"研究者"本身作为主体。详见 `vibe-math-v4/实现方案.md`。
+> 保活机制（分级保活 A+B）：团伙空闲超 `activityTimeoutMs` 会收到**自驱动** CHECKPOINT（建议继续解决/发消息/提议任务，而非"是否要停止"），唤醒失败会自动重新武装心跳；若团队空闲且**无新产物**超过 `stallAutoMeetingMs`（默认 6 分钟），框架会自动召集一次同步会议让常驻们自行决定下一步——因此小组不会"跑完就永久停滞"（框架只促成、从不指派任务）。
 
 ---
 
@@ -97,7 +98,8 @@ dsh plugin --profile <你的 profile> add github:ChongCyrus/Vibe-Mathematics
 - **形态依赖**：三个 preset 依赖 DSH 的标准 **agent-preset 机制**（`~/.dsh/.agent-presets/<id>/` + preset picker）与 **bundle patch 机制**（`cordis.patch.yml` 注入安装器）。
 - **宿主插件行**：`agent.cordis.yml` 引用宿主提供的 `@deepseek-ai/dsh-*` 插件行（persona、agent-instructions、tool-bash/pwsh、tool-fs/fs-search、tool-jobs、skill-filesystem、tool-skill、tool-goal、plan-mode、compaction、subagent/workflow、ask-user、todo、web 等，约 21 个唯一包名）。宿主缺行会导致 preset 挂载失败（会话启动时报错）。
 - **宿主服务 API**：预设插件消费 `subagents`（startContinuable / followup / interrupt）、`agents`（roots）、`tools`（register）、`commands`（register）、`fs`（resolve/stat/readText/writeText/listDir）、可选 `subprocess` / `sandboxPolicy`。这些 API 形状随 DSH 版本演进；本项目**已充分测试并确认适配 `dsh-v0.1.2-rc.1`**（`package.json` 的 `dsh.testedVersion`；`minVersion` 为 `0.1.2-rc.1`）。**注意：DSH 0.1.2 起 `subagents.startContinuable` 的 `agentOptions` / `toolFilter` 需要宿主 provider 声明对应 capability**（spawn / fork 进程内 provider 均支持，v4 指定常驻模型/路由与工具权限依赖于此）。
-- **运行时自检**：安装器（bundle 插件）每次启动时对上述服务与关键 API 做**能力自检**（DSH 不暴露版本号，故按能力而非版本检测；含 `fs.resolve` 返回形状检测与 subagent `agentOptions`/`toolFilter` capability 检测）；不满足时打 warning 并提示升级 DSH。preset 挂载失败时先看 DSH 日志里的自检 warning。
+- **DSH STORE 兼容声明**：`package.json` 的 `dsh.compatibility.dshReleases` 对每个完整 DSH 版本逐项声明 `compatible` / `incompatible` / `unknown`（当前 `0.1.2-alpha.4`、`0.1.2-alpha.5`、`0.1.2-rc.1` 均标 `compatible`）；`engines.node` 为 `^22.19.0 || >=24.0.0`（与 DSH 0.1.2 相同）。
+- **运行时自检（能力 + 版本双检）**：安装器（bundle 插件）每次启动时：**① 尽力探测 DSH 版本**（读 `@deepseek-ai/dsh/package.json` 或 `DSH_VERSION` 环境变量；DSH 未通过公开 service/context 暴露版本，故为尽力而为，探测不到就跳过）。若探测到且该版本未被 `dshReleases` 声明为 `compatible`，会给出明确"DSH 版本不匹配，请使用 `dsh-v0.1.2-rc.1`（或 `0.1.2-alpha.4/alpha.5`）"提示；**② 再对上述服务与关键 API 做能力自检**（这是真正的挂载门槛，含 `fs.resolve` 返回形状检测与 subagent `agentOptions`/`toolFilter` capability 检测），不满足时打 warning。preset 挂载失败时先看 DSH 日志里的自检 warning。
 - **升级路径**：DSH 升级后无需重装本包；升级本包用 `dsh plugin update dsh-vibe-math`，重启 DSH 后安装器会自动把 preset 更新到新版本（见上文「安装」说明）。
 
 ---
@@ -415,7 +417,8 @@ dsh plugin --profile <你的 profile> add github:ChongCyrus/Vibe-Mathematics
 | `compactAfterRounds` | 8 | 常驻每累计 N 轮（未压缩）触发一次软压缩 |
 | `meetingKeepEvery` | 5 | 每积累 N 个新产物自动触发一次同步会议 |
 | `maxParallel` | 3 | 同时唤醒的常驻上限（框架侧并发闸，非指派） |
-| `activityTimeoutMs` | 120000 | 空闲心跳间隔（超时才触发 CHECKPOINT 唤醒，推动收敛） |
+| `activityTimeoutMs` | 120000 | 空闲心跳间隔（超时才触发**自驱动** CHECKPOINT 唤醒，推动常驻继续推进；唤醒失败会自动重新武装心跳，保证小组永不永久停死） |
+| `stallAutoMeetingMs` | 360000 | **停滞自动同步会议阈值**（分级保活 B）：团队空闲且无新产物超过该时长时，框架自动召集一次同步会议，让常驻们自行决定下一步路线/分工（框架只促成，不指派） |
 | `verdictMaxRounds` | 3 | 验证在独立初评后进入辩论的最大轮数 |
 | `provider` / `model` | 空 | **常驻 LLM 路由**（空 = 常驻继承主代理的 provider/model；此前声明未用，v1.4.1 真正接入） |
 | `residentPersona` | 空 | 注入每个常驻提示词开头的人格/要求 |

package/installer.js

@@ -25,6 +25,7 @@
 //   - same version: no-op (idempotent). Missing files are ALWAYS restored.
 //   - force a full refresh at any time: delete the preset dirs and restart DSH.
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, unlinkSync, rmdirSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import { createHash } from 'node:crypto'
 import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
@@ -75,8 +76,42 @@ function writeState(path, state) {
 
 // DSH 适配性自检（能力检测，而非版本号——DSH 不向插件暴露版本）。
 // 检查 preset 运行时需要的宿主服务与关键 API 形状是否可用，缺失时打 warning。
+// Best-effort DSH host-version detection. DSH does NOT expose its version through a documented
+// service/context property or a guaranteed env var, so we probe in order: an explicit env var
+// (future-proofing), then the installed @deepseek-ai/dsh package.json. This is layout-dependent
+// (works for a typical global install where @deepseek-ai/dsh is a sibling of this plugin); when it
+// cannot resolve, the capability self-check below is still the authoritative gate.
+const __require = createRequire(import.meta.url)
+function detectDshVersion() {
+  try { const v = process.env.DSH_VERSION; if (v && String(v).trim()) return String(v).trim() } catch (e) {}
+  try {
+    const p = __require.resolve('@deepseek-ai/dsh/package.json')
+    const v = (JSON.parse(readFileSync(p, 'utf8')).version || '').trim()
+    if (v) return v
+  } catch (e) { /* host package not resolvable from here — rely on capability check */ }
+  return undefined
+}
+
 async function checkHostCapabilities(ctx, logger) {
   const problems = []
+  // 1) DSH version compatibility (best-effort, only when the version is detectable).
+  //    Declared under package.json dsh.compatibility.dshReleases (per the DSH STORE contract):
+  //    each full DSH release maps to 'compatible' | 'incompatible' | 'unknown'. A version that is
+  //    absent or 'unknown' is a soft warning; 'incompatible' is a hard "please use X" message.
+  let dshRel = {}
+  try { const m = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'package.json'), 'utf8')); dshRel = (m.dsh && m.dsh.compatibility && m.dsh.compatibility.dshReleases) || {} } catch (e) {}
+  const supported = Object.keys(dshRel).sort()
+  const dshVersion = detectDshVersion()
+  if (dshVersion) {
+    const status = dshRel[dshVersion]
+    if (status === 'incompatible') {
+      problems.push('当前 DSH 版本 v' + dshVersion + ' 被本包声明为 incompatible；请使用 ' + supported.join(' / ') + '。')
+    } else if (status === undefined || status === 'unknown') {
+      problems.push('当前 DSH 版本 v' + dshVersion + ' 尚未被本包声明为兼容（dshReleases 仅声明 ' + supported.join(' / ') + '）；建议使用 ' + supported.join(' / ') + '，或将该版本在 dshReleases 中标注后再自行验证。')
+    }
+  }
+  // 2) capability self-check (the authoritative mounting gate; also covers hosts whose version
+  //    could not be read). subagents / agents / tools / commands / fs shapes + v4 capabilities.
   const checks = [
     ['subagents', ['startContinuable', 'followup', 'interrupt']],
     ['agents', ['roots']],
@@ -120,9 +155,9 @@ async function checkHostCapabilities(ctx, logger) {
     }
   } catch (e) { /* 探测失败不致命 */ }
   if (problems.length > 0) {
-    logger?.warn?.('[dsh-vibe-math] 宿主能力自检：' + problems.length + ' 项不满足（' + problems.join('；') + '）。v2/v3/v4 预设依赖这些宿主服务/API，旧版 DSH 可能无法挂载，建议升级 DSH（本项目已充分测试并确认适配 dsh-v0.1.2-rc.1，见 package.json 的 dsh.minVersion/testedVersion）。')
+    logger?.warn?.('[dsh-vibe-math] 宿主自检：' + problems.length + ' 项不满足（' + problems.join('；') + '）。v2/v3/v4 预设依赖这些宿主服务/API，旧版或未经声明兼容的 DSH 可能无法挂载' + (dshVersion ? '（当前检测到 DSH v' + dshVersion + '，本包适配 ' + (supported.length ? supported.join(' / ') : '(未声明)') + '）' : '') + '。')
   } else {
-    logger?.info?.('[dsh-vibe-math] 宿主能力自检通过：subagents / agents / tools / commands / fs 服务及关键 API 均可用（已确认适配 DSH 0.1.2-rc.1）。')
+    logger?.info?.('[dsh-vibe-math] 宿主自检通过：subagents / agents / tools / commands / fs 服务及关键 API 均可用' + (dshVersion ? '（当前 DSH v' + dshVersion + '，本包已声明兼容 ' + supported.join(' / ') + '）' : '') + '。')
   }
 }
 

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "dsh-vibe-math",
   "description": "Multi-agent mathematical problem-solving & verification frameworks for DeepSeek Harness — THREE agent presets in one install: vibe-math-v2 (probability-driven: qs.json + Propos knowledge base + explorer→solver→review/debate verdict), vibe-math-v3 (THIRD-generation, recommended: paper-style Markdown knowledge base with Problems/Progress/Propos/Methods/Verified + planner-agent scheduling that decides the next N actions + universal theory/method invention library + agents write their own Markdown directly via a per-file write lock), and vibe-math-v4 (FOURTH-generation: persistent self-organizing resident subagents that message & meet to decide all tasks, verify only by unanimous consensus, /compact at a context threshold, and stop only when all agree the problem is solved). Installing this bundle auto-installs all three presets (v1 was removed at v2.0.0).",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "type": "module",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
   "main": "installer.js",
   "exports": {
     ".": "./installer.js",
@@ -54,6 +57,13 @@
     },
     "minVersion": "0.1.2-rc.1",
     "testedVersion": "0.1.2-rc.1",
-    "compatNote": "依赖宿主提供的 subagents/agents/tools/commands/fs 服务与 @deepseek-ai/dsh-* 插件行。本项目已充分测试并确认适配 dsh-v0.1.2-rc.1（v2/v3/v4；v1 已于 v2.0.0 移除）。注意：DSH 0.1.2 起 subagents.startContinuable 的 agentOptions/toolFilter 需要宿主 provider 声明对应 capability（spawn/fork 进程内 provider 均支持），安装器启动时会做能力自检并在旧版宿主上告警。"
+    "compatNote": "依赖宿主提供的 subagents/agents/tools/commands/fs 服务与 @deepseek-ai/dsh-* 插件行。本项目已充分测试并确认适配 dsh-v0.1.2-rc.1（v2/v3/v4；v1 已于 v2.0.0 移除）。注意：DSH 0.1.2 起 subagents.startContinuable 的 agentOptions/toolFilter 需要宿主 provider 声明对应 capability（spawn/fork 进程内 provider 均支持），安装器启动时会做能力自检并在旧版宿主上告警。",
+    "compatibility": {
+      "dshReleases": {
+        "0.1.2-alpha.4": "compatible",
+        "0.1.2-alpha.5": "compatible",
+        "0.1.2-rc.1": "compatible"
+      }
+    }
   }
 }

package/vibe-math-v4/agent.cordis.yml

@@ -61,7 +61,7 @@
       Main controls (recommended flow: configure FIRST, then start):
         - vibe_v4_configure {project?, problem?, params?} — create/configure the project (name, problem, params) WITHOUT starting a run; set everything here first.
         - vibe_v4_start {problem?, residentCount?, seedDirections?} — begin the run (spawn residents, brainstorm). If problem was configured, omit it.
-        - vibe_v4_set {residentCount, compactThreshold, compactAfterRounds, meetingKeepEvery, maxParallel, activityTimeoutMs, verdictMaxRounds, provider, model, residentPersona, toolAllow, toolDeny} — tune params (persisted to the settings file). provider/model override the residents' LLM route (empty = they inherit YOUR model/provider); toolAllow/toolDeny are per-resident tool permissions (empty = they inherit all tools).
+        - vibe_v4_set {residentCount, compactThreshold, compactAfterRounds, meetingKeepEvery, maxParallel, activityTimeoutMs, stallAutoMeetingMs, verdictMaxRounds, provider, model, residentPersona, toolAllow, toolDeny} — tune params (persisted to the settings file). provider/model override the residents' LLM route (empty = they inherit YOUR model/provider); toolAllow/toolDeny are per-resident tool permissions (empty = they inherit all tools). stallAutoMeetingMs is the stalled-group auto-sync-meeting threshold (分级保活 B).
         - vibe_v4_resume / vibe_v4_pause / vibe_v4_abort / vibe_v4_status / vibe_v4_report.
         - vibe_v4_message {to|all, content} — inject a message to a resident (human/assistant intervention).
         - vibe_v4_meeting {agenda} — force a meeting.

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

@@ -32,6 +32,7 @@ export function apply(ctx) {
       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: '',
@@ -47,7 +48,7 @@ export function apply(ctx) {
     let problemText = '', problemId = 'problem', runId = 'run-' + shortId()
     let meetingState = null, verifyState = null, pendingVerify = null
     let busy = new Set(), wakeKind = new Map(), currentResident = ''
-    let lastActivityAt = now(), artifactCount = 0, lastSyncMeetingAt = 0, persistedEpoch = '', heartbeatDisposer = null
+    let lastActivityAt = now(), lastProgressAt = now(), artifactCount = 0, lastSyncMeetingAt = 0, persistedEpoch = '', heartbeatDisposer = null
     const activityLogCap = 200
 
     // ---- utils ----
@@ -64,6 +65,11 @@ export function apply(ctx) {
     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(); }
     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
@@ -110,10 +116,10 @@ export function apply(ctx) {
       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,activityLog,processEpoch,artifactCount})
+      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(); activityLog=s.activityLog||activityLog; persistedEpoch=s.processEpoch||''; artifactCount=s.artifactCount||0 }
+      const s=await readJson('State/session.json'); if(s){ running=!!s.running; autoDone=!!s.autoDone; phase=s.phase||'idle'; problemId=s.problemId||problemId; problemText=s.problemText||problemText; runId=s.runId||runId; meetings=s.meetings||[]; reports=s.reports||[]; lastActivityAt=s.lastActivityAt||now(); lastProgressAt=s.lastProgressAt||now(); activityLog=s.activityLog||activityLog; persistedEpoch=s.processEpoch||''; artifactCount=s.artifactCount||0 }
       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
@@ -280,7 +286,7 @@ export function apply(ctx) {
     async function recordMethod(rId,o){ const id=o.id||('m-'+shortId()); const lines=['# 方法｜'+(o.title||id),'- 标题: '+(o.title||id),'- ID: '+id,'- 类型: '+(o.type||'方法'),'- 状态: 经验','- 可信断言: []','- 价值程度: '+cl(o.value!=null?o.value:0.5),'- 动机用途计划: '+(o.motivation||''),'','## 核心内容',String(o.content||''),'','## 定义与记号',String(o.notation||''),'','## 应用记录','## 改进历史','']; await writeText('Methods/'+rId+'/'+id+'.md',lines.join('\n')); logActivity('record',rId+' 方法 '+id); bumpArtifacts(); return {ok:true,id,file:'Methods/'+rId+'/'+id+'.md'} }
     async function recordSubproblem(rId,o){ const id=o.id||('s-'+shortId()); const lines=['# 子问题｜'+(o.title||id),'- 标题: '+(o.title||id),'- ID: '+id,'- 状态: 求解中','- 价值程度: '+cl(o.value!=null?o.value:0.5),'- 动机用途计划: '+(o.motivation||''),'- 依赖: []','','## 陈述',String(o.statement||''),'','## 进度','']; await writeText('Subproblems/'+rId+'/'+id+'.md',lines.join('\n')); logActivity('record',rId+' 子问题 '+id); bumpArtifacts(); return {ok:true,id,file:'Subproblems/'+rId+'/'+id+'.md'} }
     // auto-sync meeting: every meetingKeepEvery new artifacts, convene a general coordination meeting
-    function bumpArtifacts(){ artifactCount+=1; if(!meetingState && !verifyState && Number(params.meetingKeepEvery)>0 && artifactCount % Number(params.meetingKeepEvery)===0){ startMeeting('定期同步：分工/进展/是否需要验证','general',null).catch(()=>{}) } }
+    function bumpArtifacts(){ artifactCount+=1; markProgress(); if(!meetingState && !verifyState && 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
@@ -290,12 +296,12 @@ export function apply(ctx) {
 
     // ---- 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(); 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(); logActivity('task',claimer+' claimed '+id); 
+    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)
       const r=residents.get(claimer); if(r && !busy.has(claimer)){ 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(); logActivity('task','done '+id); 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} }
@@ -318,7 +324,7 @@ export function apply(ctx) {
       if(!busy.has(to)){
         currentResident=r.rId
         await wakeResident(r, (await normalPrompt(r))+'\n\n[NEW MESSAGE from '+from+']\n'+content,'normal')
-        await saveAll(); logActivity('message',from+'→'+to); return {ok:true}
+        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}
     }
@@ -336,7 +342,7 @@ export function apply(ctx) {
         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)); await saveAll()
+      logActivity('relay',from+' → 团队: '+text.slice(0,60)); markProgress(); await saveAll()
     }
 
     // ---- meeting ----
@@ -349,6 +355,7 @@ export function apply(ctx) {
       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}
+      markProgress();
       logActivity('meeting','start: '+agenda); await saveAll(); await scheduleNext(); return {ok:true,id:meetingState.id}
     }
     async function continueMeetingRound(){
@@ -359,7 +366,8 @@ export function apply(ctx) {
       const order=meetingState.order||ids
       const id=order.find(x=>meetingState.inputs[x]===undefined && !busy.has(x)); if(!id) return
       const r=residents.get(id)
-      await wakeResident(r, meetingPrompt(r,meetingState), 'meeting'); await saveAll()
+      const ok = await wakeResident(r, meetingPrompt(r,meetingState), 'meeting'); await saveAll()
+      if(!ok) armHeartbeat()   // a failed meeting wake must NOT silently hang the meeting
     }
     async function finalizeMeeting(){
       const st=meetingState
@@ -387,6 +395,7 @@ export function apply(ctx) {
       clearHeartbeat()
       pendingVerify=null
       verifyState={targetId:pv.targetId,targetType:pv.targetType,targetOwner:pv.proposer||'',stage:'independent',round:0,asked:[],verdicts:{},transcript:[]}
+      markProgress();
       logActivity('verify','debate begin: '+pv.targetId+' ('+pv.targetType+')'); await saveAll(); await scheduleNext()
     }
     async function continueVerifyRound(){
@@ -395,7 +404,8 @@ export function apply(ctx) {
       if(allVoted){ await finalizeVerify(); return }
       const id=ids.find(x=>verifyState.verdicts[x]===undefined && !busy.has(x)); if(!id) return
       const r=residents.get(id)
-      await wakeResident(r, verifyPrompt(r,verifyState), verifyState.stage==='independent'?'verif-ind':'verif-deb'); await saveAll()
+      const ok = await wakeResident(r, verifyPrompt(r,verifyState), verifyState.stage==='independent'?'verif-ind':'verif-deb'); await saveAll()
+      if(!ok) armHeartbeat()   // a failed verify wake must NOT silently hang the verification
     }
     async function finalizeVerify(){
       const vs=verifyState; const expected=Array.from(residents.keys()).length
@@ -460,15 +470,15 @@ export function apply(ctx) {
 
     // ---- 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 either make concrete progress or push the group
-    // toward a decision (meeting / verify / solved). This adds convergence pressure instead
-    // of infinite token-burning, matching the "framework never assigns work" philosophy.
+    // 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（空闲）：团队在等待方向。'
-        +'请用一句话说明你下一步做什么；若你已无产出、或认为问题已解决/接近解决，请**提议开会（propose_meeting）**、**提议验证（propose_verify）**、或**声明 solved=true**，让团队能做出决定——不要产出填充性工作。\n'
+        +'Resident researcher '+r.rId+' — CHECKPOINT（团队空闲，请由你们继续自主推进）。当前项目尚未解决（除非你已确认）。团队在等待有人继续：请**继续解决这个问题**——读他人的库对齐、推进某个子问题/引理/方法、尝试一条路线；或向团队发消息（input）、提议任务（propose_task）让大家分工。若你确实认为问题已解决、或已彻底无路可走，才提议开会（propose_meeting）让团队表决/商量、或声明 solved=true。默认立场是：**请推进，而不是停在原地。**\n'
         +'Reply with ONLY a JSON object:\n'
-        +'{"summary":"<what you do next or a declaration>","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","claim_task":"<id|null>"}'
+        +'{"summary":"<what you will do / what you advanced this round>","input":"<optional: a message to the whole team, or \\"\\">","solved":false,"propose_verify":"<id|null>","propose_meeting":"<agenda|null>","propose_task":"<task title|null>","claim_task":"<id|null>","contextPct":40}'
     }
     function clearHeartbeat(){ if(heartbeatDisposer!==null){ try{ heartbeatDisposer() }catch(e){} heartbeatDisposer=null } }
     function armHeartbeat(){
@@ -509,14 +519,30 @@ export function apply(ctx) {
       // 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 }
-      // heartbeat / coordination wake of the least-recently-active resident, ONLY after idle timeout
+      // 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 already active.
+      if(phase==='active' && !meetingState && !verifyState && !pendingVerify){
+        const stallMs=Number(params.stallAutoMeetingMs)||((Number(params.activityTimeoutMs)||120000)*3)
+        if(now()-lastProgressAt>=stallMs){
+          await startMeeting('团队较长时间没有新进展。请你们自行讨论：当前问题是否已解决、开放难点是什么、谁负责哪部分、下一步如何推进，并自主决定是否继续。框架只负责转达与记录，不替你们决定。','general',null)
+          return
+        }
+      }
+      // A) heartbeat / coordination: wake the least-recently-active resident after an idle timeout
+      //    to SELF-DRIVE (continue solving / message / propose task / meeting / verify). On a failed
+      //    wake we re-arm the heartbeat so a single follow-up error NEVER permanently stops the group.
       clearHeartbeat()
       let target=null, oldest=-1
       for(const [,r] of residents){ if(busy.has(r.rId)) continue; const idle=now()-r.lastActiveAt; if(idle>oldest){ oldest=idle; target=r } }
       const atOs=Number(params.activityTimeoutMs)||120000
       if(target && oldest>=atOs){
-        // an idle timeout has elapsed: checkpoint wake (event-driven work is unchanged)
-        await wakeResident(target, await heartbeatPrompt(target), 'normal'); await saveAll(); return
+        let ok=false
+        try { ok = await wakeResident(target, await heartbeatPrompt(target), 'normal') } catch(e){ ok=false }
+        await saveAll()
+        if(!ok) armHeartbeat()   // wake failed → re-arm so the group never permanently stops
+        return
       }
       // everyone is busy or not idle-enough: arm a heartbeat to re-check later (no infinite spin)
       armHeartbeat()
@@ -613,7 +639,7 @@ export function apply(ctx) {
     }
     function status(){ return { ok:true, running, phase, autoDone, project:currentProject, residentCount:residents.size,
       residents:listResidents(), busy:[...busy], taskboard:taskboard.length,
-      params:['residentCount','compactAfterRounds','compactThreshold','maxParallel','activityTimeoutMs','meetingKeepEvery','verdictMaxRounds','provider','model','residentPersona','toolAllow','toolDeny'].map(k=>k+'='+(Array.isArray(params[k])?params[k].join(','):params[k])).join(', ') } }
+      params:['residentCount','compactAfterRounds','compactThreshold','maxParallel','activityTimeoutMs','meetingKeepEvery','verdictMaxRounds','stallAutoMeetingMs','provider','model','residentPersona','toolAllow','toolDeny'].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'),
       verify: verifyState?{target:verifyState.targetId,stage:verifyState.stage}:null, meetings:meetings.length,
@@ -623,7 +649,7 @@ export function apply(ctx) {
     // Normalize one parameter value to its intended type so a string from /v4 set or configure
     // becomes the right number/array. Keeps settings.json clean regardless of how it was set.
     function normalizeParam(k, v){
-      const INT_KEYS=['residentCount','compactThreshold','compactAfterRounds','maxParallel','activityTimeoutMs','verdictMaxRounds','meetingKeepEvery']
+      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
@@ -689,7 +715,7 @@ export function apply(ctx) {
   // 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'},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} })
+  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.',objParams({to:{type:'string'},content:{type:'string'}},['to','content']),(s,a,x)=>s.postMessage(s.residentIdOf(x),a.to,a.content))

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

@@ -515,6 +515,28 @@ VibeMath/Projects/<project>/
 
 > 测试：`selfdrive-v4.mjs` 21/21；`e2e-v4-fixes.test.mjs` 36/36（新增 T10 模型/工具权限接线、T11 默认继承、T12 自主发明理论提示、T13 压缩指令不泄漏进 meetings）；v3 E2E 100/100、v2 regression 14/14、v2 business 24/24、multisession 25/25 全绿。
 
+---
+
+## 25. 分级保活：自驱动心跳 + 停滞自动同步会议（v1.4.2）
+
+针对一次真实 run（"跑完就停"）的诊断：三名常驻第一轮就把问题归约到**同一个硬核引理**并一致给出 `solved=false`——这是**自然的难点停滞**，而非 bug。但框架的活性机制太弱且会"死"：
+- 空闲后唯一驱动是心跳（`activityTimeoutMs` 唤醒一个常驻、CHECKPOINT 提示词偏向"是否要停止"），**缺乏推进力**；
+- **唤醒失败会永久停死**（`scheduleNext` 在心跳分支 `await wakeResident(...)` 后无条件 `return`，而 `wakeResident` 捕获异常后返回 false 但**不重新武装心跳**）→ 一旦某次 `subagents.followup` 抛异常，心跳不再武装，小组**永不再被唤醒**；
+- `session.json` 不持久化 `meetingState`（进行中会议只在进程内存），进程重启或会议唤醒失败都可能让会议悬停。
+
+### A · 自驱动心跳（修复推进力 + 永不永久停死）
+- `heartbeatPrompt` 改为**自驱动**：不是"是否要停止"，而是"**请继续解决这个问题**——读他人库、推进子问题/引理/方法、尝试路线；或向团队发消息（input）、提议任务（propose_task）；确实已解决/无路可走才提议开会/声明 solved。默认立场是推进而非停在原地。" 心跳回复 schema 增加 `input`、`propose_task`、`contextPct`，使一轮心跳能产生群聊消息/任务从而带动后续工作。
+- **唤醒失败重新武装心跳**：`scheduleNext` 心跳分支、`continueMeetingRound`、`continueVerifyRound` 在 `wakeResident` 失败（返回 false）时调用 `armHeartbeat()`，保证**任何一次唤醒失败都不会让小组永久停住**（会稍后重试其它常驻）。
+
+### B · 停滞自动同步会议（分级保活 B）
+- 新增 `lastProgressAt`（会话状态，随产物/会议/验证/任务/群聊/消息更新，`markProgress()`），并持久化到 `State/session.json`。
+- `scheduleNext` 在无 meeting/verify/pending、`phase==='active'` 且 `now()-lastProgressAt >= stallAutoMeetingMs`（默认 360000=6 分钟，可调）时，自动 `startMeeting('团队较长时间没有新进展。请你们自行讨论…')`——框架**只促成会议、不指派任务**，让常驻们自行决定下一步路线/分工，从而"复活"一个停滞的团队。
+- 这同时覆盖"进程重启后进行中会议丢失"的场景：重启后 `running:true, phase:active`、无会议 → 若持续无新产物，B 会自动再召集一次协调会议。
+
+> 行为：有产出的团队会不断更新 `lastProgressAt`，B 不会触发；真正停滞的团队先被 A（自驱动心跳）持续轻推，若仍无新产物则被 B（自动同步会议）召集起来自主重启。全程框架只"促成"，从不指派任务。
+>
+> 新增参数：`stallAutoMeetingMs`（`vibe_v4_set`/`status` 可见）。新增测试：T14（停滞自动会议）、T15（自驱动心跳提示词非旧的"说下一步"）；`selfdrive-v4` 21/21、`e2e-v4-fixes` 39/39。
+