dsh-vibe-math 2.5.0 → 2.7.0

package/tests/e2e-v5-round2.test.mjs

@@ -16,7 +16,8 @@
 //   · the host session log is NEVER written, and the state reloads through the JSON file
 // Run: node tests/e2e-v5-round2.test.mjs
 // ============================================================
-import { mkdtempSync, existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs'
+import { mkdtempSync, existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { tmpdir } from 'node:os'
 import { join, dirname, isAbsolute } from 'node:path'
 
@@ -59,6 +60,9 @@ function makeHost(opts) {
   const o = opts || {}
   const WS = o.ws || mkdtempSync(join(tmpdir(), 'vibe-v5r2-'))
   const listeners = {}, toolRegs = [], commandRegs = [], spawns = [], wakes = [], interrupts = [], drains = []
+  // Every effect disposer, so a test can simulate a plugin UNLOAD (the Lean queue's disposer is
+  // registered first: it terminates in-flight compiles and marks them interrupted).
+  const effectDisposers = []
   const liveAgents = new Map()
   // The two services the fix removed. This host does not provide them, and records every
   // request so the suite can assert the plugin never even LOOKS for them any more.
@@ -70,6 +74,9 @@ function makeHost(opts) {
       if (name === 'sandboxPolicy') return undefined
       if (name === 'compaction') return o.compaction
       if (name === 'subprocess') {
+        // o.subprocess injects a FAKE LaTeX toolchain for the final-paper tests (the plugin
+        // detects/compiles through this exact service, the same seam the Lean tests use).
+        if (o.subprocess) return o.subprocess
         return {
           async spawn({ argv }) {
             const script = argv[argv.length - 1] || ''
@@ -84,7 +91,7 @@ function makeHost(opts) {
       return undefined
     },
     on(e, fn) { (listeners[e] = listeners[e] || []).push(fn) },
-    effect(fn) { const d = fn(); return () => { if (typeof d === 'function') d() } },
+    effect(fn) { const d = fn(); const disp = () => { if (typeof d === 'function') d() }; effectDisposers.push(disp); return disp },
     logger: { info() {}, warn() {}, error() {} },
     timeout(cb, ms) { const h = setTimeout(cb, ms); return () => clearTimeout(h) },
     tools: { register(spec) { toolRegs.push(spec); return () => {} } },
@@ -191,12 +198,165 @@ function makeHost(opts) {
     }
     return null
   }
-  return { WS, ctx, ROOT, ROOT_SESSION, removedServiceQueries, spawns, wakes, interrupts, drains, toolRegs, commandRegs, listeners, callTool, childAgent, fireEnd, spawnOf, childOf, labelOf, kindOf, settleSpawns, drain, peekWakeOf, set plannedVotes(v) { plannedVotes = v }, get plannedVotes() { return plannedVotes }, set solvePlan(v) { solvePlan = v } }
+  // Any member's next prompt matching a predicate — used to capture the CHECKPOINT heartbeat,
+  // whose recipient is whichever member the scheduler picked.
+  async function peekWakeWhere(pred, maxWaitMs) {
+    const t0 = Date.now()
+    while (Date.now() - t0 < (maxWaitMs || 3000)) {
+      const i = wakes.findIndex(w => pred((w.blocks && w.blocks[0] && w.blocks[0].text) || ''))
+      if (i !== -1) {
+        const w = wakes.splice(i, 1)[0]
+        return { childId: w.childId, text: (w.blocks && w.blocks[0] && w.blocks[0].text) || '' }
+      }
+      if (wakes.length) {
+        const w = wakes.shift()
+        fireEnd(w.childId, { progress: '其他成员推进中', solved: false, contextPct: 10 })
+      }
+      await sleep(20)
+    }
+    return null
+  }
+  return { WS, ctx, ROOT, ROOT_SESSION, removedServiceQueries, spawns, wakes, interrupts, drains, toolRegs, commandRegs, listeners, effectDisposers, callTool, childAgent, fireEnd, spawnOf, childOf, labelOf, kindOf, settleSpawns, drain, peekWakeOf, peekWakeWhere, set plannedVotes(v) { plannedVotes = v }, get plannedVotes() { return plannedVotes }, set solvePlan(v) { solvePlan = v } }
 }
 
 const pluginModule = await import(PLUGIN.href + '?t=' + Date.now())
 const PROBLEM = '证明素数有无穷多个'
 
+// ── final-paper test helpers ────────────────────────────────────────────────
+// A FAKE LaTeX toolchain (docs/final-paper.md §10: "临时目录里放一个假的 xelatex/latexmk 脚本，或注入 runner").
+// It is injected through the SAME `subprocess` service the plugin detects and compiles with, so
+// the plugin's real detection/compile/repair code runs unchanged; only the toolchain is fake.
+// `installed`      — which engine names resolve (others throw, like a missing binary)
+// `failEngines`    — engines whose process exits 1
+// `failOn`         — a RegExp: if the tex on disk matches, the run exits 1 (drives the repair)
+// `alwaysFail`     — every run exits 1 (drives the degrade path)
+function fakeLatex(opts) {
+  const o = opts || {}
+  const calls = []
+  const installed = o.installed || ['xelatex', 'pdflatex']
+  return {
+    calls,
+    async resolveExecutable(name) {
+      if (installed.indexOf(name) === -1) throw new Error('ENOENT: ' + name)
+      return 'C:/fake/' + name
+    },
+    spawn(spec) {
+      const argv = spec.argv || []
+      const name = String(argv[0] || '').split(/[\\/]/).pop()
+      const dir = String(spec.cwd || '')
+      let tex = ''
+      try { tex = readFileSync(join(dir, 'paper.tex'), 'utf8') } catch (e) { /* first attempt may race */ }
+      calls.push({ name, args: argv.slice(1), dir, tex })
+      let ok = true
+      if (o.failEngines && o.failEngines.indexOf(name) !== -1) ok = false
+      if (o.failOn && o.failOn.test(tex)) ok = false
+      if (o.alwaysFail) ok = false
+      if (ok) {
+        try { mkdirSync(dir, { recursive: true }); writeFileSync(join(dir, 'paper.pdf'), '%PDF-1.4 fake\n', 'utf8') } catch (e) { ok = false }
+      }
+      return { done: Promise.resolve({ exitCode: ok ? 0 : 1 }), terminate() {} }
+    },
+  }
+}
+const paperKindOf = (p) => /【最终论文·撰写/.test(p) ? 'write'
+  : /【最终论文·互审/.test(p) ? 'review'
+    : /【最终论文·定稿/.test(p) ? 'final' : ''
+
+// ── fake Lean toolchain (docs/formal-verification.md §7) ────────────────────
+// Injected through the SAME `subprocess` service the plugin compiles with, so detection,
+// argv assembly, the queue and the settle logic all run unchanged; only the toolchain is fake.
+//   exitFor(argv, file) -> exitCode | undefined    terminated -> count of terminate() calls
+//   defer: true  every spawn stays alive until releaseAll() (for timeout/dispose/build-context)
+function fakeLean(opts) {
+  const o = opts || {}
+  const calls = []
+  return {
+    calls,
+    terminated: 0,
+    async resolveExecutable(cmd) {
+      const name = String(cmd || 'lean')
+      if (o.missing) throw new Error('ENOENT: ' + name)
+      return 'C:/fake/' + name
+    },
+    spawn(spec) {
+      const argv = (spec.argv || []).map(String)
+      // Only the LEAN engine is a compile: the plugin also uses the subprocess service for
+      // platform shell helpers (directory setup) AND for the math_computation engine probe
+      // (which resolves its own candidates through the same seam) — neither may pollute the
+      // Lean call log, nor be deferred by the gate.
+      const head = String(argv[0] || '')
+      if (!/(^|[\\/])lean$/i.test(head)) {
+        return { done: Promise.resolve({ exitCode: 0, stdout: '', stderr: '' }), terminate() { /* not a Lean compile */ } }
+      }
+      const file = argv[argv.length - 1]
+      calls.push({ argv, file, cwd: spec.cwd })
+      let exitCode = 0
+      if (o.alwaysFail) exitCode = 1
+      else if (typeof o.exitFor === 'function') { const r = o.exitFor(argv, file); if (r !== undefined && r !== null) exitCode = r }
+      const self = this
+      if (!o.defer) return { done: Promise.resolve({ exitCode }), terminate() { self.terminated += 1 } }
+      let settled = false
+      let resolveDone = null
+      const done = new Promise((resolve) => { resolveDone = resolve })
+      const finish = (v) => { if (!settled) { settled = true; resolveDone(v) } }
+      o._release = o._release || []
+      o._release.push(() => finish({ exitCode }))
+      return { done, terminate() { self.terminated += 1; finish({ exitCode: null, signal: 'SIGTERM' }) } }
+    },
+    releaseAll() { for (const f of (o._release || []).splice(0)) { try { f() } catch (e) { /* ignore */ } } },
+  }
+}
+const paperDirOf = (h, id) => join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Paper', id || 'institute')
+// Seed a .lean work file inside the institute tree (a run job needs an existing file).
+function seedLeanFile(h, rel, text) {
+  const abs = join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', ...String(rel).split('/'))
+  mkdirSync(dirname(abs), { recursive: true })
+  writeFileSync(abs, text, 'utf8')
+  return abs
+}
+function listFilesUnder(root, rel) {
+  const out = []
+  const base = rel === undefined ? '' : rel
+  for (const e of readdirSync(root, { withFileTypes: true })) {
+    const r = base ? base + '/' + e.name : e.name
+    if (e.isDirectory()) out.push(...listFilesUnder(join(root, e.name), r))
+    else out.push(r)
+  }
+  return out
+}
+// Answer the paper phase's own prompts until the flow stops asking: each member writes its
+// part, cross-reviews another member's part, and the editor finalises. `opts.write/review/final`
+// override the default (deliverable) replies, which is how the objection/cap paths are driven.
+async function drivePaper(h, opts) {
+  const o = opts || {}
+  let steps = 0, idle = 0
+  while (steps < (o.max || 40) && idle < 8) {
+    const i = h.wakes.findIndex(w => paperKindOf((w.blocks && w.blocks[0] && w.blocks[0].text) || ''))
+    if (i === -1) { idle++; await sleep(25); continue }
+    idle = 0
+    const w = h.wakes.splice(i, 1)[0]
+    const prompt = (w.blocks && w.blocks[0] && w.blocks[0].text) || ''
+    const kind = paperKindOf(prompt)
+    const who = h.labelOf(w.childId)
+    let reply
+    if (kind === 'write') {
+      reply = o.write ? o.write(who, prompt) : ({ paper_part: { title: who + ' 的贡献', solution: who + '：原问题的完整解法（只写有证据的部分）。', methods: who + ' 的方法与经验。', rules: who + ' 归纳的规律。', limits: who + ' 的局限（未定论项已标注）。', evidence: ['Members/' + who + '/Propos/p-' + who + '.md'] } })
+    } else if (kind === 'review') {
+      const om = /待审部分（([^）]*)）/.exec(prompt)
+      reply = o.review ? o.review(who, om ? om[1] : '', prompt) : ({ paper_review: { of: om ? om[1] : '', deliverable: true, comments: who + '：证据与表决记录一致，可交付。' } })
+    } else {
+      reply = o.final ? o.final(who, prompt) : ({ paper_final: { decision: 'deliverable', note: '已核对合并稿与互审意见，统一术语与符号。', conclusion: '题设范围内结论成立。' } })
+    }
+    // `capture` lets a case assert on the TEXT the member really received (the evidence-only
+    // clause lives in the prompt, not only in the plugin source).
+    if (o.capture) o.capture.push({ kind, who, prompt })
+    h.fireEnd(w.childId, reply)
+    steps++
+    await sleep(20)
+  }
+  return steps
+}
+
 // The durable authority is the hardened JSON file. A commit is applied to the in-memory
 // snapshot immediately but written through a deferred per-file chain, so a test that wants to
 // observe "this was committed" must poll the FILE — reading the session log is no longer possible
@@ -938,6 +1098,766 @@ console.log('\n[22] configure/start/resume/pause/stop/set belong to the PROVABLE
   assert(finalStop.ok === true, 'the office can still stop it (' + JSON.stringify(finalStop).slice(0, 90) + ')')
 }
 
+// ---------- 23. final-paper params: closed schema, defaults, explicit coercion ----------
+console.log('\n[23] final-paper params: closed schema, defaults and explicit coercion')
+{
+  const h = makeHost({ pluginModule })
+  const setSpec = h.toolRegs.find(t => t.name === 'vibe_v5_set')
+  const keys = ['finalPaper', 'paperFormat', 'paperLanguage', 'paperCompilePdf', 'paperEditor', 'paperLatexCommand']
+  assert(!!setSpec && keys.every(k => Object.prototype.hasOwnProperty.call(setSpec.parameters.properties, k)),
+    '★ vibe_v5_set advertises all six final-paper keys (the schema is closed, so an unlisted key is unreachable)')
+  const props = setSpec.parameters.properties
+  assert(JSON.stringify(props.paperFormat.enum) === JSON.stringify(['both', 'md', 'tex']) &&
+    JSON.stringify(props.paperLanguage.enum) === JSON.stringify(['zh', 'en']) &&
+    JSON.stringify(props.paperEditor.enum) === JSON.stringify(['office', 'academician']),
+    'the three enums are narrowed in the schema (a typo must not become a fourth mode)')
+  const s0 = (await h.callTool('vibe_v5_status', {})).params
+  assert(s0.finalPaper === true && s0.paperFormat === 'both' && s0.paperLanguage === 'zh' && s0.paperCompilePdf === true &&
+    s0.paperEditor === 'academician' && s0.paperLatexCommand === '',
+    'the documented defaults are live (' + JSON.stringify({ f: s0.finalPaper, fmt: s0.paperFormat, lang: s0.paperLanguage, pdf: s0.paperCompilePdf, ed: s0.paperEditor }) + ')')
+  const r = await h.callTool('vibe_v5_set', { finalPaper: 'false', paperFormat: 'bogus', paperLanguage: 'EN', paperEditor: 'root', paperCompilePdf: 1, paperLatexCommand: 'lualatex' })
+  assert(r.ok === true && r.params.finalPaper === false, "★ finalPaper:'false' is coerced to false (v2 §B: an unknown spelling must not stay truthy)")
+  assert(r.params.paperFormat === 'both', 'an unknown paperFormat falls back to both')
+  assert(r.params.paperLanguage === 'en' && r.params.paperEditor === 'office', 'enums are case-insensitive and legacy aliases resolve (EN → en, root → office)')
+  assert(r.params.paperCompilePdf === true && r.params.paperLatexCommand === 'lualatex', 'paperCompilePdf accepts 1 as true; paperLatexCommand is stored')
+}
+
+// ---------- 24. the team flow with the OFFICE as editor (+ the consultation gate) ----------
+console.log('\n[24] manual paper, office editor: parts → cross-review → consultation → finalise')
+{
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  // ONE verified object, so section 4 has real evidence to index.
+  await h.callTool('vibe_v5_record_proposition', { id: 'p-paper', statement: '最终论文只整理已有证据，不得编造', value: 0.9, motive: '论文证据', p: 1 }, h.childAgent(h.childOf('r-1')))
+  await h.callTool('vibe_v5_propose_verify', { target: 'p-paper', kind: 'proposition', reason: '论文证据' }, h.childAgent(h.childOf('r-1')))
+  h.plannedVotes = new Map([['acad', 1], ['r-1', 1]])
+  await h.drain(10)
+  const sv = await h.callTool('vibe_v5_status', {})
+  assert(sv.verified.indexOf('p-paper') !== -1, 'precondition: one object is verified (the paper needs evidence)')
+  assert(sv.paper === null, 'NEGATIVE: a run that has NOT concluded does not auto-start a paper')
+  // A second object is left UNDECIDED (both voters abstain), so section 8 has an unresolved item
+  // that MUST be marked as such.
+  await h.callTool('vibe_v5_set', { verdictMaxRounds: 1 })
+  await h.callTool('vibe_v5_record_proposition', { id: 'p-open', statement: '仍未定论的对象必须显式标注', value: 0.5, motive: '未决项', p: 0.5 }, h.childAgent(h.childOf('r-1')))
+  await h.callTool('vibe_v5_propose_verify', { target: 'p-open', kind: 'proposition', reason: '未决项' }, h.childAgent(h.childOf('r-1')))
+  h.plannedVotes = new Map([['acad', 0.5], ['r-1', 0.5]])
+  await h.drain(10)
+  const su = await h.callTool('vibe_v5_status', {})
+  assert(su.undecided.indexOf('p-open') !== -1, 'precondition: one object is recorded as 未定论 (got ' + JSON.stringify(su.undecided) + ')')
+  h.plannedVotes = new Map()
+  const started = await h.callTool('vibe_v5_paper', { lang: 'en', format: 'both', editor: 'office' })
+  assert(started.ok === true && started.started === true && started.editor === 'office',
+    'the manual paper starts with the office as its editor (' + JSON.stringify(started).slice(0, 130) + ')')
+  await drivePaper(h)
+  let st = await h.callTool('vibe_v5_status', {})
+  assert(st.paper && st.paper.status === 'awaiting-editor' && st.paper.parts.length === 2 && st.paper.reviews.length === 2,
+    '★ both permanent members wrote a part and cross-reviewed another part (' + JSON.stringify({ s: st.paper && st.paper.status, parts: st.paper && st.paper.parts.length, reviews: st.paper && st.paper.reviews.length }) + ')')
+  const refused = await h.callTool('vibe_v5_finalize_paper', { decision: 'deliverable', note: 'x' })
+  assert(refused.ok === false && refused.code === 'V5_PAPER_CONSULT_REQUIRED',
+    '★ NEGATIVE: the office cannot finalise before consulting the institute (' + JSON.stringify(refused).slice(0, 140) + ')')
+  const msg = await h.callTool('vibe_v5_message', { to: 'all', content: '请各自核对证据与结论，我们随后定稿。' })
+  assert(msg.ok === true, 'the office message is delivered')
+  await h.callTool('vibe_v5_meeting', { agenda: '定稿前审查：证据与结论是否一致', kind: 'sync' })
+  await h.drain(12)
+  st = await h.callTool('vibe_v5_status', {})
+  assert(st.paper.consult.messages >= 1 && st.paper.consult.meetings >= 1,
+    '★ the office consultation is RECORDED (messages=' + st.paper.consult.messages + ', meetings=' + st.paper.consult.meetings + ')')
+  const fin = await h.callTool('vibe_v5_finalize_paper', { decision: 'deliverable', note: '已与全所逐条核对证据，术语与符号统一，结论与表决记录一致。', conclusion: '题设范围内结论成立。' })
+  assert(fin.ok === true && fin.finalized === true, 'the office finalises after consulting (' + JSON.stringify(fin).slice(0, 150) + ')')
+  assert(fin.compile === 'not-detected', '★ this machine has no LaTeX: the compile degrades to not-detected instead of failing (' + fin.compile + ')')
+  const dir = paperDirOf(h, 'institute')
+  const md = existsSync(join(dir, 'paper.md')) ? readFileSync(join(dir, 'paper.md'), 'utf8') : ''
+  const tex = existsSync(join(dir, 'paper.tex')) ? readFileSync(join(dir, 'paper.tex'), 'utf8') : ''
+  const meta = existsSync(join(dir, 'paper.meta.json')) ? JSON.parse(readFileSync(join(dir, 'paper.meta.json'), 'utf8')) : null
+  const heads = (md.match(/^## \d+\. /gm) || []).length
+  assert(heads === 9, '★ the md carries exactly the 9-section skeleton (got ' + heads + ')')
+  assert(md.indexOf('p-paper') !== -1, '★ the verified proposition is listed with its evidence path')
+  assert(md.indexOf('未定论：p-open') !== -1, '★ an undecided object is EXPLICITLY marked in the paper (never silently dropped or promoted)')
+  assert(tex.indexOf('\\documentclass') !== -1 && /\\section\{1\. /.test(tex), '★ the tex version is generated from the same sections')
+  assert(md.indexOf('已与全所逐条核对证据') !== -1, 'the office finalisation note is written into the paper')
+  assert(!!meta && meta.editor === 'office' && meta.consultation.messages >= 1 && meta.consultation.meetings >= 1 && meta.compile.status === 'not-detected',
+    'the meta records the editor, the consultation evidence and the compile result')
+  assert(existsSync(join(dir, 'paper.log.md')), 'the paper log records who wrote/reviewed what')
+  const instRoot = join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute')
+  const stray = listFilesUnder(instRoot).filter(p => /(^|\/)paper\.(md|tex|pdf|meta\.json|log\.md)$/i.test(p) && p.indexOf('Paper/institute/') !== 0)
+  assert(stray.length === 0, '★ every paper artifact lives under Paper/<id>/ only (no Verified//State/ pollution): ' + JSON.stringify(stray))
+  assert((await h.callTool('vibe_v5_status', {})).autoDone === false, 'a MANUAL paper does not conclude the run')
+}
+
+// ---------- 25. idempotency: a repeated trigger only fills missing artifacts ----------
+console.log('\n[25] paper idempotency: repeated triggers only fill missing artifacts')
+{
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  const first = await h.callTool('vibe_v5_paper', {})
+  assert(first.ok === true && first.started === true, 'the single-member institute starts its paper')
+  await drivePaper(h)
+  const dir = paperDirOf(h, 'institute')
+  const metaPath = join(dir, 'paper.meta.json')
+  assert(existsSync(join(dir, 'paper.md')) && existsSync(metaPath), 'the first run delivered md + meta')
+  const meta1 = readFileSync(metaPath, 'utf8')
+  const again = await h.callTool('vibe_v5_paper', {})
+  assert(again.ok === true && again.alreadyFinalized === true, 'a repeated trigger reports alreadyFinalized instead of re-running the team (' + JSON.stringify(again).slice(0, 120) + ')')
+  assert(readFileSync(metaPath, 'utf8') === meta1, '★ paper.meta.json is NOT rewritten (finalizedAt/inputs untouched)')
+  unlinkSync(join(dir, 'paper.md'))
+  const refill = await h.callTool('vibe_v5_paper', {})
+  assert(refill.ok === true && existsSync(join(dir, 'paper.md')), '★ the missing artifact is refilled (' + JSON.stringify(refill.refill) + ')')
+  assert(readFileSync(metaPath, 'utf8') === meta1, 'the refill did not touch the settled meta either')
+  const forced = await h.callTool('vibe_v5_paper', { force: true, reason: 'manual force' })
+  assert(forced.ok === true && forced.started === true && !forced.alreadyFinalized,
+    '★ force re-runs the whole team flow instead of refilling (' + JSON.stringify(forced).slice(0, 120) + ')')
+  const stF = await h.callTool('vibe_v5_status', {})
+  assert(stF.paper.status === 'writing' && stF.paper.round === 1, 'the forced run restarted at round 1')
+}
+
+// ---------- 26. fake LaTeX: the success path produces paper.pdf ----------
+console.log('\n[26] fake LaTeX compiler: success path produces paper.pdf')
+{
+  const fake = fakeLatex({ installed: ['xelatex', 'pdflatex'] })
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  await h.callTool('vibe_v5_paper', { format: 'both' })
+  await drivePaper(h)
+  const st = await h.callTool('vibe_v5_status', {})
+  assert(st.paper && st.paper.status === 'finalized' && st.paper.compile === 'compiled', 'the paper finalised with the fake compiler (' + JSON.stringify(st.paper && { s: st.paper.status, c: st.paper.compile }) + ')')
+  const dir = paperDirOf(h, 'institute')
+  assert(existsSync(join(dir, 'paper.pdf')), '★ paper.pdf was produced by the compiler subprocess inside Paper/<id>/')
+  const meta = JSON.parse(readFileSync(join(dir, 'paper.meta.json'), 'utf8'))
+  assert(meta.compile.status === 'compiled' && meta.compile.engine === 'xelatex' && meta.compile.attempts.length === 1,
+    'the meta records compiled/xelatex on the FIRST attempt (' + JSON.stringify(meta.compile) + ')')
+  assert(fake.calls.length >= 2 && fake.calls.every(c => c.args.indexOf('-interaction=nonstopmode') !== -1),
+    '★ the engine ran twice with -interaction=nonstopmode (docs/final-paper.md §8)')
+}
+
+// ---------- 27. fake LaTeX: a failing package is repaired, then it degrades ----------
+console.log('\n[27] fake LaTeX compiler: repair path and persistent-failure degradation')
+{
+  // The fake refuses `\\usepackage[hidelinks]{hyperref}`; the repair pass strips optional
+  // packages, so attempt 3 succeeds (attempts 1-2 fail on the full tex).
+  const fake = fakeLatex({ installed: ['xelatex'], failOn: /\\usepackage\[hidelinks\]\{hyperref\}/ })
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  await h.callTool('vibe_v5_paper', { format: 'both' })
+  await drivePaper(h)
+  const dir = paperDirOf(h, 'institute')
+  const meta = JSON.parse(readFileSync(join(dir, 'paper.meta.json'), 'utf8'))
+  const at = meta.compile.attempts || []
+  assert(meta.compile.status === 'compiled' && existsSync(join(dir, 'paper.pdf')), '★ the repair retry turned a failing compile into a PDF')
+  assert(at.length === 3 && at[0].ok === false && at[1].ok === false && at[2].ok === true && at[2].label.indexOf('stripped') !== -1,
+    '★ attempts: full FAIL → nonstopmode rerun FAIL → stripped-package SUCCESS (' + JSON.stringify(at.map(a => a.label + ':' + a.ok)) + ')')
+  // A compiler that always fails must degrade, not throw, and must not block finalisation.
+  const fake2 = fakeLatex({ installed: ['xelatex'], alwaysFail: true })
+  const h2 = makeHost({ pluginModule, subprocess: fake2 })
+  await h2.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h2.settleSpawns()
+  const fin = await h2.callTool('vibe_v5_paper', { format: 'both' })
+  await drivePaper(h2)
+  const st2 = await h2.callTool('vibe_v5_status', {})
+  const dir2 = paperDirOf(h2, 'institute')
+  const meta2 = JSON.parse(readFileSync(join(dir2, 'paper.meta.json'), 'utf8'))
+  assert(fin.ok === true && st2.paper.status === 'finalized' && st2.paper.compile === 'failed',
+    '★ a persistent compile failure DEGRADES (finalisation still succeeds, compile=failed) (' + st2.paper.compile + ')')
+  assert(existsSync(join(dir2, 'paper.tex')) && existsSync(join(dir2, 'paper.md')) && !existsSync(join(dir2, 'paper.pdf')),
+    'tex+md are kept and no bogus pdf is written')
+  assert(/\\title\{/.test(readFileSync(join(dir2, 'paper.tex'), 'utf8')),
+    '★ the DELIVERED tex is the canonical generated one, not the minimal repair variant used by the last attempt')
+  assert((meta2.compile.attempts || []).length === 4, '★ the retry plan is CAPPED at 4 attempts (full → nonstopmode → stripped/engine-swap → minimal template)')
+  assert((meta2.warnings || []).join(' ').indexOf('编译失败') !== -1, 'the failure is reported as a warning in the meta')
+  // Engine swap: the first installed engine fails, so attempt 3 (the NEXT engine) succeeds.
+  const fake3 = fakeLatex({ installed: ['xelatex', 'pdflatex'], failEngines: ['xelatex'] })
+  const h3 = makeHost({ pluginModule, subprocess: fake3 })
+  await h3.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h3.settleSpawns()
+  await h3.callTool('vibe_v5_paper', { format: 'both' })
+  await drivePaper(h3)
+  const dir3 = paperDirOf(h3, 'institute')
+  const meta3 = JSON.parse(readFileSync(join(dir3, 'paper.meta.json'), 'utf8'))
+  assert(meta3.compile.status === 'compiled' && meta3.compile.engine === 'pdflatex' && (meta3.compile.attempts || []).length === 3,
+    '★ engine swap: xelatex fails twice, pdflatex succeeds on the third attempt (' + JSON.stringify({ e: meta3.compile.engine, n: (meta3.compile.attempts || []).length }) + ')')
+  // paperFormat=md with paperCompilePdf=true must skip compilation SILENTLY (no "missing tex"
+  // warning) — docs/final-paper.md §8.
+  const hm = makeHost({ pluginModule, subprocess: fakeLatex({ installed: ['xelatex'] }) })
+  await hm.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await hm.settleSpawns()
+  await hm.callTool('vibe_v5_paper', { format: 'md' })
+  await drivePaper(hm)
+  const dm = paperDirOf(hm, 'institute')
+  const metam = JSON.parse(readFileSync(join(dm, 'paper.meta.json'), 'utf8'))
+  assert(existsSync(join(dm, 'paper.md')) && !existsSync(join(dm, 'paper.tex')) && !existsSync(join(dm, 'paper.pdf')),
+    'paperFormat=md delivers md only (no tex, no pdf)')
+  assert(metam.compile.status === 'skipped' && !/编译|tex/.test((metam.warnings || []).join(' ')),
+    '★ paperFormat=md skips compilation silently (no missing-tex warning): ' + JSON.stringify(metam.warnings))
+}
+
+// ---------- 28. office-only surface + id normalisation ----------
+console.log('\n[28] the final-paper surface is office-only and its directory id cannot escape Paper/')
+{
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  const member = h.childAgent(h.childOf('r-1'))
+  const asMember = await h.callTool('vibe_v5_paper', {}, member)
+  assert(asMember.ok === false && asMember.code === 'V5_NOT_OFFICE', 'a member cannot start the paper (' + JSON.stringify(asMember).slice(0, 100) + ')')
+  const finAsMember = await h.callTool('vibe_v5_finalize_paper', { decision: 'deliverable', note: 'x' }, member)
+  assert(finAsMember.ok === false && finAsMember.code === 'V5_NOT_OFFICE', 'a member cannot finalise the paper')
+  // A traversal-shaped institute name must never become a path in the paper id.
+  const h2 = makeHost({ pluginModule })
+  await h2.callTool('vibe_v5_configure', { institute: 'evil/../x' })
+  await h2.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h2.settleSpawns()
+  await h2.callTool('vibe_v5_paper', {})
+  await drivePaper(h2)
+  const p2 = (await h2.callTool('vibe_v5_status', {})).paper
+  const id = String(p2.dir || '').replace(/^Paper\//, '').replace(/\/$/, '')
+  assert(id.length > 0 && id.indexOf('/') === -1 && id.indexOf('\\') === -1 && id !== '.' && id !== '..',
+    '★ the paper directory id is ONE normalised name (never a path): ' + JSON.stringify(id))
+  assert(existsSync(join(h2.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'x', 'Paper', id, 'paper.log.md')),
+    'the paper landed under Paper/<id>/ inside the resolved institute tree')
+}
+
+// ---------- 29. /v5 paper: overrides, force, kind:error; finalPaper=false gates AUTO ----------
+console.log('\n[29] /v5 paper: one-shot overrides, kind:error, and finalPaper=false')
+{
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  const cmd = h.commandRegs.find(c => c.name === 'v5')
+  assert(!!cmd, 'the /v5 command is registered')
+  const bad = await cmd.handler({ agent: h.ROOT, rawInput: 'paper bogus=1' })
+  assert(bad.kind === 'error', '★ an unknown paper option is a FAILED command (kind:error): ' + String(bad.text).slice(0, 100))
+  const memberCall = await cmd.handler({ agent: h.childAgent(h.childOf('acad')), rawInput: 'paper' })
+  assert(memberCall.kind === 'error', 'a member child cannot drive the /v5 control line')
+  const okCmd = await cmd.handler({ agent: h.ROOT, rawInput: 'paper lang=en format=tex editor=office' })
+  assert(okCmd.kind === 'success', 'the paper subcommand succeeds: ' + String(okCmd.text).slice(0, 120))
+  const st = await h.callTool('vibe_v5_status', {})
+  assert(st.paper && st.paper.lang === 'en' && st.paper.format === 'tex' && st.paper.editor === 'office',
+    '★ the command overrides language/format/editor FOR THIS PAPER (' + JSON.stringify({ l: st.paper.lang, f: st.paper.format, e: st.paper.editor }) + ')')
+  assert(st.params.paperLanguage === 'zh' && st.params.paperEditor === 'academician',
+    'the one-shot overrides do NOT rewrite the persisted params')
+  // finalPaper=false: the AUTO trigger is off, the run concludes immediately, the manual path says so.
+  const h2 = makeHost({ pluginModule })
+  await h2.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h2.settleSpawns()
+  await h2.callTool('vibe_v5_set', { finalPaper: false })
+  h2.solvePlan = true
+  await h2.callTool('vibe_v5_meeting', { agenda: '是否已解决原问题？', kind: 'solve-vote' })
+  await h2.drain(24)
+  const s2 = await h2.callTool('vibe_v5_status', {})
+  assert(s2.autoDone === true && !s2.paper, '★ finalPaper=false: the run concludes WITHOUT starting a paper (' + JSON.stringify({ autoDone: s2.autoDone, paper: s2.paper }) + ')')
+  const manual = await h2.callTool('vibe_v5_paper', {})
+  assert(manual.ok === true && manual.autoDisabled === true && /自动已关闭/.test(String(manual.note)),
+    'the manual command still works when finalPaper=false and says the automatic path is off (' + JSON.stringify(manual).slice(0, 220) + ')')
+}
+
+// ---------- 30. unanimity is required; the round cap records the disagreement ----------
+console.log('\n[30] unanimity: an objection does NOT finalise, the cap records the disagreement in the appendix')
+{
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  const objecting = () => ({ paper_review: { deliverable: false, comments: '证据不足，需补充' } })
+  await h.callTool('vibe_v5_paper', {})
+  // Round 1 stopped after its write+review: the objection must NOT finalise anything.
+  await drivePaper(h, { max: 2, review: () => objecting() })
+  let st = await h.callTool('vibe_v5_status', {})
+  assert(st.paper && st.paper.status === 'writing' && st.paper.round === 2,
+    '★ an objection does NOT finalise: the flow iterates to the next round (status=' + st.paper.status + ', round=' + st.paper.round + ')')
+  assert(st.paper.disagreement.length >= 1, 'the objection is recorded as a disagreement')
+  // Keep objecting; at the cap the editor (academician) is asked and asks to revise again — the
+  // spec says a cap is reached, a warning is recorded and the disagreement goes into the appendix.
+  await drivePaper(h, {
+    review: () => objecting(),
+    final: () => ({ paper_final: { decision: 'revise', note: '仍有未达成一致的意见' } }),
+  })
+  const st2 = await h.callTool('vibe_v5_status', {})
+  assert(st2.paper && st2.paper.status === 'finalized' && st2.paper.forcedAfterCap === true,
+    '★ the round cap was enforced, the disagreement recorded, and the editor finalised (' + JSON.stringify({ s: st2.paper && st2.paper.status, cap: st2.paper && st2.paper.forcedAfterCap }) + ')')
+  assert((st2.paper.warnings || []).join(' ').indexOf('上限') !== -1, 'the cap produced a WARNING (' + JSON.stringify(st2.paper.warnings) + ')')
+  const md = readFileSync(join(paperDirOf(h, 'institute'), 'paper.md'), 'utf8')
+  assert(md.indexOf('分歧记录') !== -1 && md.indexOf('证据不足，需补充') !== -1,
+    '★ the unresolved disagreement is written into the APPENDIX of the paper')
+}
+
+// ---------- 31. the DEFAULT auto trigger: the paper phase runs BEFORE completion ----------
+console.log('\n[31] a unanimous solve vote with finalPaper=true enters the paper phase BEFORE completion')
+{
+  // The mutant guard: deleting the auto-trigger branch in `checkSolved`
+  // (`if (params.finalPaper !== false)` -> `if (false)`) used to leave this whole suite green,
+  // because every other paper case drives the flow through the MANUAL vibe_v5_paper tool and
+  // the only auto assertion was "finalPaper=false => no paper" (which the mutant satisfies).
+  // This case pins the real contract: the default path must NOT complete the run until the
+  // paper is finalised, and the run must be observably alive with a paper in progress.
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  await h.callTool('vibe_v5_set', { activityTimeoutMs: 50 })
+  h.solvePlan = true
+  await h.callTool('vibe_v5_meeting', { agenda: '是否已解决原问题？', kind: 'solve-vote' })
+  await h.drain(24)
+  const mid = await h.callTool('vibe_v5_status', {})
+  assert(mid.autoDone === false,
+    '★ a unanimous solve vote with finalPaper=true does NOT complete the run immediately (got autoDone=' + mid.autoDone + ')')
+  const p0 = mid.paper || {}
+  assert(!!mid.paper && p0.status !== 'finalized',
+    '★ ... it ENTERS the paper phase instead (' + JSON.stringify({ s: p0.status, e: p0.editor }) + ')')
+  assert(p0.editor === 'academician' && p0.completesRun === true,
+    'the automatic run is edited by the wakeable academician and is marked as completing the run (' + JSON.stringify({ e: p0.editor, c: p0.completesRun }) + ')')
+  assert(mid.running === true, 'the run stays ALIVE while the paper phase runs (the machinery would refuse a concluded institute)')
+  const capture = []
+  await drivePaper(h, { capture })
+  let done = null
+  for (let i = 0; i < 40; i++) {
+    done = await h.callTool('vibe_v5_status', {})
+    if (done.autoDone) break
+    await drivePaper(h, { max: 4, capture })
+    await sleep(20)
+  }
+  assert(done.autoDone === true && done.running === false,
+    '★ the run is marked complete only AFTER the paper finalised (' + JSON.stringify({ a: done.autoDone, r: done.running }) + ')')
+  assert(done.paper && done.paper.status === 'finalized', 'the paper reached the finalized stage (' + JSON.stringify(done.paper && done.paper.status) + ')')
+  assert(existsSync(join(paperDirOf(h, 'institute'), 'paper.md')), 'the automatic path delivered Paper/<id>/paper.md')
+  // The members' own prompts carry the evidence-only clause (never invent content).
+  const write = capture.find(c => c.kind === 'write')
+  assert(!!write && /不得编造/.test(write.prompt) && /只写你自己库里已有证据支撑/.test(write.prompt),
+    '★ the paper write prompt says only-evidence/no-fabrication: ' + JSON.stringify(write && write.prompt.slice(0, 120)))
+  assert(!!write && /未决 \/ 被否证的条目必须显式标注/.test(write.prompt), 'the prompt requires undecided/refuted items to be marked explicitly')
+}
+
+// ---------- 32. a run that has NOT closed writes no Paper/ directory ----------
+console.log('\n[32] a run that has NOT closed writes NO Paper/ directory')
+{
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  // Real, non-closing work: one verification concludes, and the solve vote is NOT unanimous.
+  await h.callTool('vibe_v5_record_proposition', { id: 'p-not-closed', statement: '未收口就不得产出论文目录', value: 0.8, motive: '负用例', p: 1 }, h.childAgent(h.childOf('r-1')))
+  await h.callTool('vibe_v5_propose_verify', { target: 'p-not-closed', kind: 'proposition', reason: '负用例' }, h.childAgent(h.childOf('r-1')))
+  h.plannedVotes = new Map([['acad', 1], ['r-1', 1]])
+  await h.drain(12)
+  h.solvePlan = false
+  await h.callTool('vibe_v5_meeting', { agenda: '是否已解决？（未达成一致）', kind: 'solve-vote' })
+  await h.drain(16)
+  const st = await h.callTool('vibe_v5_status', {})
+  assert(st.autoDone === false && !st.paper, 'the run is still open and no paper phase started (' + JSON.stringify({ a: st.autoDone, p: st.paper }) + ')')
+  const paperRoot = join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Paper')
+  assert(!existsSync(paperRoot), '★ a run that has NOT closed writes no Paper/ directory at all')
+  const rel = await h.callTool('vibe_v5_report', {})
+  assert(String(rel.report || '').indexOf('最终论文') !== -1 && String(rel.report || '').indexOf('尚未开始') !== -1,
+    'the report tells the operator the paper has not started yet')
+}
+
+// ---------- 33. an existing paper.pdf is never clobbered ----------
+console.log('\n[33] an existing Paper/<id>/paper.pdf is never overwritten or deleted')
+{
+  const PRE = '%PDF-1.4 PRE-EXISTING DELIVERY\n'
+  // (a) a compiler that WOULD succeed: the existing pdf must make the flow skip compilation.
+  const fake = fakeLatex({ installed: ['xelatex'] })
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  const dir = paperDirOf(h, 'institute')
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, 'paper.pdf'), PRE, 'utf8')
+  await h.callTool('vibe_v5_paper', { format: 'both' })
+  await drivePaper(h)
+  assert(readFileSync(join(dir, 'paper.pdf'), 'utf8') === PRE, '★ the pre-existing pdf is byte-identical after the run (never overwritten)')
+  assert(fake.calls.length === 0, '★ compilation was SKIPPED entirely because a pdf already existed (never clobber)')
+  const meta = JSON.parse(readFileSync(join(dir, 'paper.meta.json'), 'utf8'))
+  assert(meta.compile.status === 'kept-existing', 'the meta records compile=kept-existing (' + meta.compile.status + ')')
+  // (b) a compiler that ALWAYS FAILS: still skipped, so a failing toolchain cannot destroy it.
+  const fake2 = fakeLatex({ installed: ['xelatex'], alwaysFail: true })
+  const h2 = makeHost({ pluginModule, subprocess: fake2 })
+  await h2.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h2.settleSpawns()
+  const dir2 = paperDirOf(h2, 'institute')
+  mkdirSync(dir2, { recursive: true })
+  writeFileSync(join(dir2, 'paper.pdf'), PRE, 'utf8')
+  await h2.callTool('vibe_v5_paper', { format: 'both' })
+  await drivePaper(h2)
+  assert(readFileSync(join(dir2, 'paper.pdf'), 'utf8') === PRE, '★ even an always-failing toolchain leaves the existing pdf untouched')
+  assert(fake2.calls.length === 0, 'no compiler process was launched for the already-delivered pdf')
+}
+
+// ---------- 34. Lean async/initiative/search params: closed schema + coercion ----------
+console.log('\n[34] Lean async params: closed schema, coercion, visibleParams, embedded sha256')
+{
+  const h = makeHost({ pluginModule })
+  const setSpec = h.toolRegs.find(t => t.name === 'vibe_v5_set')
+  const keys = ['leanAsync', 'leanInitiative', 'leanSearchPaths', 'leanJobsMaxParallel']
+  assert(keys.every(k => Object.prototype.hasOwnProperty.call(setSpec.parameters.properties, k)),
+    '★ vibe_v5_set advertises all four new Lean keys (the schema is closed, so an unlisted key is unreachable)')
+  assert(JSON.stringify(setSpec.parameters.properties.leanInitiative.enum) === JSON.stringify(['off', 'normal', 'eager']),
+    'leanInitiative is a closed enum in the schema')
+  const p0 = (await h.callTool('vibe_v5_status', {})).params
+  assert(p0.leanAsync === true && p0.leanInitiative === 'normal' && Array.isArray(p0.leanSearchPaths) && p0.leanSearchPaths.length === 0 && p0.leanJobsMaxParallel === 1,
+    '★ the documented defaults are live and visibleParams exposes all four (' + JSON.stringify({ a: p0.leanAsync, i: p0.leanInitiative, sp: p0.leanSearchPaths, mp: p0.leanJobsMaxParallel }) + ')')
+  const r = await h.callTool('vibe_v5_set', { leanAsync: 'false', leanInitiative: 'bogus', leanJobsMaxParallel: 0, leanSearchPaths: '/libA, /libB' })
+  assert(r.params.leanAsync === false, "★ leanAsync:'false' normalises to FALSE (a string must never stay truthy)")
+  assert(r.params.leanInitiative === 'normal', 'a bogus leanInitiative falls back to the documented default')
+  assert(r.params.leanJobsMaxParallel === 1, 'leanJobsMaxParallel:0 floors at 1')
+  assert(JSON.stringify(r.params.leanSearchPaths) === JSON.stringify(['/libA', '/libB']),
+    'leanSearchPaths accepts a comma string and keeps the given order (' + JSON.stringify(r.params.leanSearchPaths) + ')')
+  const help = String(setSpec.description || '')
+  assert(/leanAsync/.test(help) && /leanInitiative/.test(help) && /leanSearchPaths/.test(help) && /leanJobsMaxParallel/.test(help),
+    'the set-tool help text names all four (the switch is discoverable)')
+  const H = pluginModule.__testHelpers
+  assert(H.sha256Hex('abc') === 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad' &&
+    H.sha256Hex('') === 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+    '★ the embedded sha256 matches the published vectors (job ids/dedupe rest on it)')
+  assert(H.sha256Hex('中文abc') === createHash('sha256').update('中文abc', 'utf8').digest('hex'), 'it also matches node:crypto on non-ASCII input')
+  assert(H.leanHasSearchFlag(['-R', 'x']) && H.leanHasSearchFlag(['--search-path=o']) && H.leanHasSearchFlag(['--root', 'r']) && !H.leanHasSearchFlag(['-j4']),
+    'the search-flag guard recognises -R / --search-path(=) / --root and nothing else')
+}
+
+// ---------- 35. async Lean: enqueue → settle(ok) → passed ----------
+console.log('\n[35] async Lean: enqueue returns at once, settle(ok) is the only path to passed')
+{
+  const fake = fakeLean({})
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  await h.callTool('vibe_v5_set', { formalVerify: 'encourage' })
+  const arch = await h.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-async', content: 'theorem p_async : 1 + 1 = 2 := by decide\n' })
+  assert(arch.ok === true && arch.async && arch.async.state === 'queued' && arch.status === 'attempted',
+    '★ the archive ENQUEUES and returns async:{jobId,state} with the object at attempted (' + JSON.stringify(arch).slice(0, 150) + ')')
+  assert(fake.calls.length === 0, '★ the compiler has NOT been started when the tool returns')
+  const st0 = await h.callTool('vibe_v5_status', {})
+  assert(st0.formal.passed.indexOf('p-async') === -1, 'the queued object is not passed')
+  const listed = await h.callTool('vibe_v5_lean_job', {})
+  assert(listed.ok === true && listed.jobs.some(j => j.jobId === arch.jobId), 'lean_job lists the job (' + JSON.stringify(listed.jobs).slice(0, 140) + ')')
+  const waited = await h.callTool('vibe_v5_lean_job', { jobId: arch.jobId, waitMs: 3000 })
+  assert(waited.ok === true && waited.job.state === 'settled' && waited.job.exitCode === 0 && waited.job.proof === 'Verified/Lean/p-async.lean',
+    '★ lean_job {jobId,waitMs} waits for the settle and reports the archived proof (' + JSON.stringify(waited.job).slice(0, 170) + ')')
+  const st1 = await h.callTool('vibe_v5_status', {})
+  assert(st1.formal.passed.indexOf('p-async') !== -1 && st1.formal.objects.find(o => o.target === 'p-async').async.jobId === arch.jobId,
+    '★ ONLY the settled(ok) job set the object passed, and its receipt is on the record')
+  assert(existsSync(join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Verified', 'Lean', 'p-async.lean')),
+    'the proof is archived under Verified/Lean/<id>.lean')
+  const argv = fake.calls[0].argv
+  const root = join(h.WS, 'VibeMath').replace(/\\/g, '/')
+  const si = argv.indexOf('--search-path')
+  assert(si > 0 && argv[si + 1] === root && si + 2 === argv.length - 1 && /\.lean$/.test(argv[argv.length - 1]),
+    '★ argv carries `--search-path <ABSOLUTE VibeMath root>` right before the file (' + JSON.stringify(argv) + ')')
+  assert(fake.calls.length === 1, 'exactly one compile ran for the settle (got ' + fake.calls.length + ')')
+}
+
+// ---------- 36. failure / timeout / dispose never verify ----------
+console.log('\n[36] async Lean: failure, timeout and session dispose never verify')
+{
+  const fakeFail = fakeLean({ alwaysFail: true })
+  const h = makeHost({ pluginModule, subprocess: fakeFail })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  const a = await h.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-fail', content: 'theorem p_fail : 1 = 2 := by decide\n' })
+  const w = await h.callTool('vibe_v5_lean_job', { jobId: a.jobId, waitMs: 3000 })
+  assert(w.job.state === 'failed', '★ a failed compile settles as failed (' + w.job.state + ')')
+  assert(!existsSync(join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Verified', 'Lean', 'p-fail.lean')),
+    '★ no Verified/Lean file is written for a failure')
+  assert((await h.callTool('vibe_v5_status', {})).formal.passed.indexOf('p-fail') === -1, 'the failed object stays attempted')
+  // (b) the budget terminates the process
+  const fakeHang = fakeLean({ defer: true })
+  const h2 = makeHost({ pluginModule, subprocess: fakeHang })
+  await h2.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h2.settleSpawns()
+  seedLeanFile(h2, 'Formal/good.lean', 'theorem good : 1 + 1 = 2 := by decide\n')
+  const r = await h2.callTool('vibe_v5_lean_run', { file: 'Formal/good.lean', timeout_ms: 1000 })
+  assert(r.ok === true && r.async.state === 'queued', 'the run is queued')
+  const w2 = await h2.callTool('vibe_v5_lean_job', { jobId: r.jobId, waitMs: 5000 })
+  assert(w2.job.state === 'timeout' && fakeHang.terminated >= 1,
+    '★ the per-job budget TERMINATED the process and the job is timeout (' + JSON.stringify({ s: w2.job.state, t: fakeHang.terminated }) + ')')
+  // (c) session dispose (the plugin-unload disposer)
+  const fakeGate = fakeLean({ defer: true })
+  const h3 = makeHost({ pluginModule, subprocess: fakeGate })
+  await h3.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h3.settleSpawns()
+  const a3 = await h3.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-dispose', content: 'theorem p_dispose : 1 + 1 = 2 := by decide\n' })
+  await sleep(40)
+  assert(fakeGate.calls.length >= 1, 'precondition: the compile is in flight')
+  h3.effectDisposers[0]()
+  assert(fakeGate.terminated >= 1, '★ dispose TERMINATED the in-flight compiler (no orphan process)')
+  const w3 = await h3.callTool('vibe_v5_lean_job', { jobId: a3.jobId })
+  assert(w3.job.state === 'interrupted', '★ the job is marked interrupted, not settled (' + w3.job.state + ')')
+  assert((await h3.callTool('vibe_v5_status', {})).formal.passed.indexOf('p-dispose') === -1, '★ dispose NEVER verifies an object')
+}
+
+// ---------- 37. content-hash dedupe ----------
+console.log('\n[37] identical re-archive is de-duplicated (no rewrite, no recompile)')
+{
+  const fake = fakeLean({})
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  const PROOF = 'theorem p_dup : 2 + 2 = 4 := by decide\n'
+  const one = await h.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-dup', content: PROOF })
+  await h.callTool('vibe_v5_lean_job', { jobId: one.jobId, waitMs: 3000 })
+  const before = fake.calls.length
+  const again = await h.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-dup', content: PROOF })
+  assert(again.deduped === true && fake.calls.length === before,
+    '★ identical content is deduped: no new compile (' + JSON.stringify({ d: again.deduped, before, after: fake.calls.length }) + ')')
+  const diff = await h.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-dup', content: PROOF + '-- changed\n' })
+  assert(diff.deduped !== true && diff.async && diff.async.state === 'queued', 'different content is NOT deduped (a new job is queued)')
+  const DEF = 'def ZDup := Fin 2\n'
+  const d1 = await h.callTool('vibe_v5_lean_archive', { kind: 'def', name: 'ZDup', content: DEF })
+  await h.callTool('vibe_v5_lean_job', { jobId: d1.jobId, waitMs: 3000 })
+  const callsAfter = fake.calls.length
+  const d2 = await h.callTool('vibe_v5_lean_archive', { kind: 'def', name: 'ZDup', content: DEF })
+  assert(d2.deduped === true && fake.calls.length === callsAfter, '★ the global library dedupes on the same content hash too')
+}
+
+// ---------- 38. lean_read: verbatim text + path guard ----------
+console.log('\n[38] lean_read returns archived text verbatim and refuses a path-shaped name')
+{
+  const fake = fakeLean({})
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  const body = 'def ZRead : Nat := 7\n'
+  const a = await h.callTool('vibe_v5_lean_archive', { kind: 'def', name: 'ZRead', content: body })
+  await h.callTool('vibe_v5_lean_job', { jobId: a.jobId, waitMs: 3000 })
+  const rd = await h.callTool('vibe_v5_lean_read', { name: 'ZRead' })
+  assert(rd.ok === true && rd.kind === 'lib' && rd.text === body && rd.bytes === body.length && /^[0-9a-f]{64}$/.test(rd.sha256) && rd.truncated === false,
+    '★ lean_read returns the archived text verbatim with sha/bytes (' + JSON.stringify({ k: rd.kind, b: rd.bytes }) + ')')
+  const esc = await h.callTool('vibe_v5_lean_read', { name: '../ZRead' })
+  assert(esc.ok === false && esc.code === 'V5_INVALID_ARGUMENT', 'a path-shaped name is REFUSED, never sanitised into another file (' + JSON.stringify(esc).slice(0, 90) + ')')
+  assert((await h.callTool('vibe_v5_lean_read', { name: 'C:/x/ZRead' })).ok === false, 'an absolute name is refused')
+  const miss = await h.callTool('vibe_v5_lean_read', { name: 'NoSuchThing' })
+  assert(miss.ok === false && miss.code === 'V5_NOT_FOUND', 'an unknown name is V5_NOT_FOUND')
+  assert((await h.callTool('vibe_v5_lean_read', { name: 'ZRead', kind: 'bogus' })).ok === false, 'a bogus kind is refused')
+}
+
+// ---------- 39. a job only settles the BUILD CONTEXT it was queued under ----------
+console.log('\n[39] a job only settles the build context it was queued under')
+{
+  const fake = fakeLean({ defer: true })
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  seedLeanFile(h, 'Formal/good.lean', 'theorem good : 1 + 1 = 2 := by decide\n')
+  await h.callTool('vibe_v5_lean_run', { file: 'Formal/good.lean' })
+  await sleep(40)
+  const proof = await h.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-ctx', content: 'theorem p_ctx : 3 + 3 = 6 := by decide\n' })
+  await h.callTool('vibe_v5_set', { leanArgs: ['-Dctx=1'] })     // retune AFTER queueing
+  for (let i = 0; i < 10; i++) { fake.releaseAll(); await sleep(25) }
+  const w = await h.callTool('vibe_v5_lean_job', { jobId: proof.jobId, waitMs: 1000 })
+  assert(w.job.state === 'failed' && w.job.buildMatched === false,
+    '★ a job compiled under retuned args does NOT settle (' + JSON.stringify({ s: w.job.state, b: w.job.buildMatched }) + ')')
+  const st = await h.callTool('vibe_v5_status', {})
+  assert(st.formal.passed.indexOf('p-ctx') === -1, '★ the object stays attempted on a build-context mismatch')
+  assert(!existsSync(join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Verified', 'Lean', 'p-ctx.lean')),
+    'no Verified/Lean file for a mismatched build')
+  // (b) the CONTENT changed after the job was queued: the compile succeeds, but it compiled
+  // something else — the object must stay attempted.
+  const blocker2 = await h.callTool('vibe_v5_lean_run', { file: 'Formal/good.lean' })
+  await sleep(40)
+  const p2 = await h.callTool('vibe_v5_lean_archive', { kind: 'proof', target: 'p-hash', content: 'theorem p_hash : 4 + 4 = 8 := by decide\n' })
+  seedLeanFile(h, 'Formal/p-hash.lean', 'theorem p_hash : 4 + 4 = 8 := by decide\n-- edited while queued\n')
+  for (let i = 0; i < 10; i++) { fake.releaseAll(); await sleep(25) }
+  const w2 = await h.callTool('vibe_v5_lean_job', { jobId: p2.jobId, waitMs: 1000 })
+  assert(w2.job.exitCode === 0 && w2.job.state === 'failed' && w2.job.buildMatched === true,
+    '★ exit 0 with CHANGED content does not settle either (' + JSON.stringify({ s: w2.job.state, e: w2.job.exitCode, b: w2.job.buildMatched, blocker: blocker2.jobId }) + ')')
+  assert(!existsSync(join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Verified', 'Lean', 'p-hash.lean')),
+    'a changed-content compile writes no proof either')
+}
+
+// ---------- 40. leanJobsMaxParallel (default 1 = serial) ----------
+console.log('\n[40] leanJobsMaxParallel caps simultaneous compiles')
+{
+  const fake = fakeLean({ defer: true })
+  const h = makeHost({ pluginModule, subprocess: fake })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 0 })
+  await h.settleSpawns()
+  seedLeanFile(h, 'Formal/a.lean', 'theorem a : 1 = 1 := rfl\n')
+  seedLeanFile(h, 'Formal/b.lean', 'theorem b : 2 = 2 := rfl\n')
+  await h.callTool('vibe_v5_lean_run', { file: 'Formal/a.lean' })
+  await h.callTool('vibe_v5_lean_run', { file: 'Formal/b.lean' })
+  await sleep(50)
+  assert(fake.calls.length === 1, '★ with the default maxParallel=1 only ONE compile is in flight (got ' + fake.calls.length + ')')
+  const listed = await h.callTool('vibe_v5_lean_job', {})
+  assert(listed.maxParallel === 1 && listed.jobs.filter(j => j.state === 'queued').length === 1,
+    'lean_job reports maxParallel=1 with the second job queued (' + JSON.stringify(listed).slice(0, 150) + ')')
+  const q = listed.jobs.find(j => j.state === 'queued')
+  await h.callTool('vibe_v5_set', { leanJobsMaxParallel: 2 })
+  await h.callTool('vibe_v5_lean_job', { jobId: q.jobId, waitMs: 150 })
+  await sleep(30)
+  assert(fake.calls.length === 2, '★ raising maxParallel to 2 starts the queued job as well (got ' + fake.calls.length + ')')
+  for (let i = 0; i < 8; i++) { fake.releaseAll(); await sleep(20) }
+}
+
+// ---------- 41. the daily/verify Lean text is gated by leanInitiative ----------
+console.log('\n[41] leanInitiative gates the daily Lean reminders; the async rule is in both blocks')
+{
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  const promptFor = async (member, plan) => {
+    if (plan) await h.callTool('vibe_v5_set', plan)
+    await h.callTool('vibe_v5_say', { to: member, text: '请继续推进。' }, h.childAgent(h.childOf('acad')))
+    const w = await h.peekWakeOf(member, 3000)
+    if (!w) return ''
+    h.fireEnd(w.childId, { progress: '收到。', solved: false, contextPct: 10 })
+    await sleep(25)
+    return w.text
+  }
+  const normal = await promptFor('r-1', { formalVerify: 'off', leanInitiative: 'normal' })
+  assert(normal.indexOf('【顺手形式化') === -1, "leanInitiative=normal + formalVerify=off keeps today's behaviour (no daily Lean line)")
+  const eager = await promptFor('r-1', { leanInitiative: 'eager' })
+  assert(eager.indexOf('【顺手形式化') !== -1 && eager.indexOf('**主动**') !== -1,
+    '★ leanInitiative=eager injects the daily line even when formalVerify is off')
+  assert(eager.indexOf('判断标准：①') !== -1 && eager.indexOf('先 vibe_v5_lean_lib 查已有库') !== -1 && eager.indexOf('**查不到再新写**') !== -1,
+    '★ the three criteria + reuse-first ride in the daily line')
+  assert(eager.indexOf('import Formal.Lib.<name>') !== -1 && eager.indexOf('vibe_v5_lean_read') !== -1, 'the import/read reuse routes are named')
+  assert(eager.indexOf('没把握就记 blocked') !== -1, 'the no-confidence→blocked rule rides in the daily line')
+  assert(eager.indexOf('leanAsync=true') !== -1 && eager.indexOf('不得把该对象当成已通过') !== -1, '★ the async honesty rule rides in the daily line')
+  const offInit = await promptFor('r-1', { formalVerify: 'encourage', leanInitiative: 'off' })
+  assert(offInit.indexOf('【顺手形式化') === -1, '★ leanInitiative=off suppresses the daily line even when formalVerify is on')
+  // The VERIFY block carries the async rule too.
+  await h.callTool('vibe_v5_set', { formalVerify: 'encourage', leanInitiative: 'normal' })
+  await h.callTool('vibe_v5_record_proposition', { id: 'p-leanv', statement: '异步落地前不得当已通过', value: 0.6, motive: 'm', p: 0.9 }, h.childAgent(h.childOf('r-1')))
+  await h.callTool('vibe_v5_propose_verify', { target: 'p-leanv', kind: 'proposition', reason: '测试' }, h.childAgent(h.childOf('r-1')))
+  const vw = await h.peekWakeOf('r-1', 3000)
+  const vtxt = vw ? vw.text : ''
+  assert(/形式化只写你有把握的版本/.test(vtxt) && /不得\*\*在它落地前声称已通过/.test(vtxt),
+    '★ the verify block carries the confidence + async-honesty lines (' + JSON.stringify(vtxt.slice(-260)) + ')')
+}
+
+// ---------- 42. per-injection-site gate: every Lean prompt site, both directions ----------
+// Lens-1 (HIGH coverage gap): the gate `leanInitiative !== 'off' && (formalOn() || eager)` is
+// correct, but a static scan found ZERO assertions naming `eager` per SITE. v5 has exactly two
+// DAILY-line sites (normalPrompt, checkpointPrompt) plus two mode-gated Lean sites (briefBlock's
+// `[形式化]` state line and verifyPrompt's formalPromptBlock). Each site below is asserted in BOTH
+// directions: (1) formalVerify=off + leanInitiative=eager ⇒ that site HAS the daily line (with the
+// `**主动**` mark) while the VERIFY block stays absent; (2) leanInitiative=off ⇒ that site has NO
+// daily line while the mode/verify text still follows formalVerify.
+console.log('\n[42] every Lean prompt site obeys the leanInitiative gate in both directions')
+{
+  const DAILY = '【顺手形式化'
+  const EAGER = '**主动**'
+  // The verify-phase BLOCK header (its mode suffix distinguishes it from the normal prompt's
+  // reply contract, which also *mentions* 【Lean 形式化验证】).
+  const VERIFY_BLOCK = '【Lean 形式化验证（'
+  const STATE = '[形式化]'
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  const setAndAssert = async (plan) => {
+    const r = await h.callTool('vibe_v5_set', plan)
+    assert(r.ok === true, 'precondition: vibe_v5_set applied ' + JSON.stringify(plan) + ' (' + JSON.stringify(r).slice(0, 120) + ')')
+    return r.params
+  }
+  // Pending turns must be ANSWERED, never dropped: a discarded wake leaves its member busy
+  // forever, so the scheduler would have no idle member left to send a heartbeat to.
+  const flushWakes = async (rounds) => {
+    for (let i = 0; i < (rounds || 8); i++) {
+      const w = h.wakes.shift()
+      if (!w) return
+      h.fireEnd(w.childId, { progress: '收到。', solved: false, contextPct: 10 })
+      await sleep(10)
+    }
+  }
+  const normalFor = async (member) => {
+    await h.callTool('vibe_v5_say', { to: member, text: '请继续推进。' }, h.childAgent(h.childOf('acad')))
+    const w = await h.peekWakeOf(member, 3000)
+    if (!w) return ''
+    h.fireEnd(w.childId, { progress: '收到。', solved: false, contextPct: 10 })
+    await sleep(25)
+    return w.text
+  }
+  // ── SITE 1: normalPrompt ────────────────────────────────────────────────────
+  const pA = await setAndAssert({ formalVerify: 'off', leanInitiative: 'eager' })
+  assert(pA.formalVerify === 'off' && pA.leanInitiative === 'eager', 'precondition: formalVerify=off + leanInitiative=eager is live')
+  await flushWakes()
+  const s1eager = await normalFor('r-1')
+  assert(s1eager.indexOf(DAILY) !== -1 && s1eager.indexOf(EAGER) !== -1,
+    'S1 normalPrompt: formalVerify=off + leanInitiative=eager ⇒ the daily line IS injected (with **主动**)')
+  assert(s1eager.indexOf(VERIFY_BLOCK) === -1 && s1eager.indexOf(STATE) === -1,
+    'S1 normalPrompt: …while the VERIFY block and the [形式化] state line stay ABSENT (formalVerify=off)')
+  const pB = await setAndAssert({ formalVerify: 'encourage', leanInitiative: 'off' })
+  assert(pB.formalVerify === 'encourage' && pB.leanInitiative === 'off', 'precondition: formalVerify=encourage + leanInitiative=off is live')
+  await sleep(30)              // let prompts built with the previous params drain
+  await flushWakes()
+  const s1off = await normalFor('r-1')
+  assert(s1off.indexOf(DAILY) === -1, 'S1 normalPrompt: leanInitiative=off ⇒ NO daily line')
+  assert(s1off.indexOf(VERIFY_BLOCK) === -1 && s1off.indexOf(STATE) !== -1,
+    'S1 normalPrompt: …but the mode-gated [形式化] state line still follows formalVerify=encourage (stateIdx=' + s1off.indexOf(STATE) + ')')
+  // ── SITE 2: checkpointPrompt (the heartbeat) ────────────────────────────────
+  // Delivered to the longest-idle member that owns no in-progress task, so the queue is answered
+  // FIFO (a live institute keeps working) until a 【心跳检查】 turn shows up.
+  const checkpointFor = async (plan) => {
+    await setAndAssert(plan)
+    await flushWakes()
+    const seen = []
+    for (let i = 0; i < 30; i++) {
+      // A tuning call drives one scheduling pass, exactly like a real institute where events keep
+      // arriving; the heartbeat branch then picks the longest-idle member.
+      await h.callTool('vibe_v5_set', { maxParallel: i % 2 === 0 ? 3 : 4 })
+      const w = await h.peekWakeWhere(() => true, 300)
+      if (!w) continue
+      seen.push(w.text.slice(0, 20))
+      const isCheckpoint = w.text.indexOf('【心跳检查') !== -1
+      h.fireEnd(w.childId, { progress: '继续推进。', solved: false, contextPct: 10 })
+      await sleep(15)
+      if (isCheckpoint) return { text: w.text, seen }
+    }
+    return { text: '', seen }
+  }
+  await h.callTool('vibe_v5_set', { activityTimeoutMs: 40, chatDigestMs: 600000, stallAutoMeetingMs: 600000 })
+  const s2a = await checkpointFor({ formalVerify: 'off', leanInitiative: 'eager' })
+  const s2st = await h.callTool('vibe_v5_status', {})
+  assert(s2a.text !== '' && s2a.text.indexOf(DAILY) !== -1 && s2a.text.indexOf(EAGER) !== -1,
+    'S2 checkpointPrompt (heartbeat): formalVerify=off + leanInitiative=eager ⇒ the daily line IS injected (seen=' + JSON.stringify(s2a.seen) + ' status=' + JSON.stringify({ verify: s2st.verify && s2st.verify.target, meeting: s2st.meeting, paper: s2st.paper && s2st.paper.stage, busy: (s2st.members || []).filter((m) => m.busy).map((m) => m.id), undecided: s2st.undecided }) + ')')
+  assert(s2a.text.indexOf(VERIFY_BLOCK) === -1, 'S2 checkpointPrompt: the VERIFY block stays absent with formalVerify=off')
+  const s2b = await checkpointFor({ formalVerify: 'encourage', leanInitiative: 'off' })
+  assert(s2b.text !== '' && s2b.text.indexOf(DAILY) === -1,
+    'S2 checkpointPrompt: leanInitiative=off ⇒ NO daily line (seen=' + JSON.stringify(s2b.seen) + ')')
+  assert(s2b.text.indexOf(STATE) !== -1, 'S2 checkpointPrompt: …while the [形式化] state line still follows formalVerify=encourage')
+  // ── SITE 3: verifyPrompt's formalPromptBlock ────────────────────────────────
+  // Finish any verification that is already in flight (answering every voter turn) so that the
+  // NEXT verify wake is necessarily built with the params we set afterwards.
+  const drainVerify = async () => {
+    for (let i = 0; i < 25; i++) {
+      const st = await h.callTool('vibe_v5_status', {})
+      if (!st.verify) return true
+      await h.callTool('vibe_v5_set', { maxParallel: i % 2 === 0 ? 3 : 4 })
+      const w = await h.peekWakeWhere((p) => p.indexOf('【求真表决') !== -1, 250)
+      if (w) {
+        const tm = /"target"\s*:\s*"([^"]+)"/.exec(w.text)
+        h.fireEnd(w.childId, { verdict: { target: tm ? tm[1] : st.verify.target, verdict: 0.5, reason: '存疑' }, contextPct: 20 })
+      }
+      await sleep(20)
+    }
+    return false
+  }
+  const verifyFor = async (plan) => {
+    await drainVerify()
+    await setAndAssert(plan)
+    const id = 'p-site-' + Math.random().toString(36).slice(2, 8)
+    await h.callTool('vibe_v5_record_proposition', { id, statement: '站点门控', value: 0.6, motive: 'm', p: 0.9 }, h.childAgent(h.childOf('r-1')))
+    await h.callTool('vibe_v5_propose_verify', { target: id, kind: 'proposition', reason: 'x' }, h.childAgent(h.childOf('r-1')))
+    for (let i = 0; i < 25; i++) {
+      await h.callTool('vibe_v5_set', { maxParallel: i % 2 === 0 ? 3 : 4 })
+      const w = await h.peekWakeWhere((p) => p.indexOf('【求真表决') !== -1, 300)
+      if (!w) continue
+      const tm = /"target"\s*:\s*"([^"]+)"/.exec(w.text)
+      h.fireEnd(w.childId, { verdict: { target: tm ? tm[1] : id, verdict: 0.5, reason: '存疑' }, contextPct: 20 })
+      await sleep(25)
+      return w.text
+    }
+    return ''
+  }
+  const s3off = await verifyFor({ formalVerify: 'off', leanInitiative: 'eager' })
+  assert(s3off.indexOf('【求真表决') !== -1 && s3off.indexOf(VERIFY_BLOCK) === -1,
+    'S3 verifyPrompt: formalVerify=off ⇒ NO verify-phase Lean block even when leanInitiative=eager')
+  assert(s3off.indexOf(DAILY) === -1, 'S3 verifyPrompt: the daily line is never injected into the verify prompt')
+  const s3on = await verifyFor({ formalVerify: 'encourage', leanInitiative: 'off' })
+  assert(s3on.indexOf('【求真表决') !== -1 && s3on.indexOf(VERIFY_BLOCK) !== -1,
+    'S3 verifyPrompt: formalVerify=encourage ⇒ the verify-phase block appears even with leanInitiative=off')
+  assert(s3on.indexOf(DAILY) === -1, 'S3 verifyPrompt: …and the daily line is still absent there')
+}
+
 console.log('')
 console.log('passed=' + passed + ' failed=' + failed)
 if (failed) { console.error('FAILURES:'); for (const f of failures) console.error('  - ' + f); process.exit(1) }