dsh-vibe-math 2.4.1 → 2.6.0

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

@@ -16,7 +16,7 @@
 //   · 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 { tmpdir } from 'node:os'
 import { join, dirname, isAbsolute } from 'node:path'
 
@@ -70,6 +70,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] || ''
@@ -197,6 +200,89 @@ function makeHost(opts) {
 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' : ''
+const paperDirOf = (h, id) => join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Paper', id || 'institute')
+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
@@ -347,6 +433,47 @@ console.log('\n[6] quorum recomputed when a voter is dismissed')
   assert(h.drains.length === 2, 'both dismissed researchers had their resident child released')
 }
 
+// ---------- 6b. a dismissed voter's old ballot votes in NEITHER direction ----------
+console.log('\n[6b] a dismissed voter\'s old ballot is dropped from the ledger AND the tally')
+{
+  // Round A H2 fixed "a dismissed member's old ballot still counts". The suite used to prove only
+  // that m/voterCount were recomputed and that the resident was released — never that the BALLOT
+  // stopped counting. This case votes, dismisses, then re-votes, which is the sequence the audit
+  // asked for: r-1 asserts TRUE, is dismissed, and the remaining voter's FALSE must now CONCLUDE
+  // (with r-1's ballot ignored). If a former member's vote still counted, 1 vs 0 would conflict
+  // and the object could never reach Verified/ — so the verdict itself is the discriminator.
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  const stateFile = join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'State', 'institute.v5state.json')
+  const ballots = () => {
+    try {
+      const s = JSON.parse(readFileSync(stateFile, 'utf8'))
+      const v = s.institutes[Object.keys(s.institutes)[0]].verdicts['p-dismiss']
+      return v ? Object.keys(v.votes || {}) : null
+    } catch (e) { return null }
+  }
+  const s0 = await h.callTool('vibe_v5_status', {})
+  assert(s0.quorum.voterCount === 2 && s0.quorum.m === 2, 'baseline: acad + r-1 = 2 voters, m=2 (got P=' + s0.quorum.voterCount + ', m=' + s0.quorum.m + ')')
+  await h.callTool('vibe_v5_record_proposition', { id: 'p-dismiss', statement: '被解雇者的旧票不得计入', value: 0.5, motive: 'm', p: 0.5 })
+  await h.callTool('vibe_v5_propose_verify', { target: 'p-dismiss', kind: 'proposition', reason: 'r' }, h.childAgent(h.childOf('r-1')))
+  const s1 = await h.callTool('vibe_v5_status', {})
+  assert(!!s1.verify && s1.verify.target === 'p-dismiss', 'the ballot on p-dismiss is live')
+  const voted = await h.callTool('vibe_v5_verdict', { target: 'p-dismiss', verdict: 1, reason: 'r-1 断言为真' }, h.childAgent(h.childOf('r-1')))
+  assert(voted.ok === true && voted.allVoted === false, 'r-1 cast the ONLY boolean vote so far (the other voter has not answered)')
+  assert((ballots() || []).indexOf('r-1') !== -1, 'the durable open-verdict record carries r-1\'s ballot before the dismissal (' + JSON.stringify(ballots()) + ')')
+  const removed = await h.callTool('vibe_v5_remove_researcher', { id: 'r-1' })
+  assert(removed.ok === true, 'r-1 was dismissed with the ballot still open (' + JSON.stringify(removed).slice(0, 80) + ')')
+  const s2 = await h.callTool('vibe_v5_status', {})
+  assert(s2.quorum.voterCount === 1 && s2.quorum.m === 1, 'the live roster recomputes immediately: P=1, m=1 (got P=' + s2.quorum.voterCount + ', m=' + s2.quorum.m + ')')
+  assert((ballots() || []).indexOf('r-1') === -1, '★ the dismissed member\'s ballot is DELETED from the durable open verdict (votes=' + JSON.stringify(ballots()) + ')')
+  const finalVote = await h.callTool('vibe_v5_verdict', { target: 'p-dismiss', verdict: 0, reason: 'acad 断言为假' }, h.childAgent(h.childOf('acad')))
+  assert(finalVote.ok === true && finalVote.allVoted === true, 'the remaining voter completed the ballot (allVoted=true)')
+  const s3 = await h.callTool('vibe_v5_status', {})
+  assert(s3.verified.indexOf('p-dismiss') !== -1,
+    '★ the ballot CONCLUDED false — a former member\'s TRUE vote cannot block it (got verified=' + JSON.stringify(s3.verified) + ', undecided=' + JSON.stringify(s3.undecided) + ')')
+}
+
 // ---------- 7. vibe_v5_wait ----------
 console.log('\n[7] vibe_v5_wait')
 {
@@ -584,6 +711,703 @@ console.log('\n[15] the host live-child cap (ACTIVATION_LIMIT_REACHED) is named,
   assert(st2.members.filter(m => m.phase === 'active' && m.childId).length === CAP, 'the institute is back at the host ceiling (active=' + st2.members.filter(m => m.phase === 'active').map(m => m.id).join(',') + ')')
 }
 
+// ---------- 16. a state file that was never loaded must never be overwritten (audit H1) --------
+console.log('\n[16] a pre-seeded snapshot is ADOPTED, never overwritten with an empty institute')
+{
+  // Round A H1. Ported from the reproduction that lived outside the repository
+  // (`_oneoff/audit241-v5-overwrite.mjs`): a host with no `sandboxPolicy` service (the supported
+  // case the e2e harness itself models) used to latch the DEFAULT path on its first read, after
+  // which `configure {institute:'alpha'}` wrote an EMPTY institute over alpha's real file.
+  const ws = mkdtempSync(join(tmpdir(), 'vibe-v5-seed-'))
+  const seedFile = join(ws, 'VibeMath', 'Projects', 'default', 'Institutes', 'alpha', 'State', 'alpha.v5state.json')
+  mkdirSync(dirname(seedFile), { recursive: true })
+  const seeded = {
+    v: 1,
+    institutes: {
+      'default::alpha': {
+        key: 'default::alpha', project: 'default', institute: 'alpha', createdAt: 1, phase: 'active',
+        problem: { id: 'p', statement: 'a real problem' }, params: {}, runId: 'run-x',
+        members: ['acad', 'r-1', 'r-2', 'r-3', 't-1'].map((id) => ({
+          id, kind: id === 'acad' ? 'academician' : id[0] === 'r' ? 'researcher' : 'temp',
+          childId: '', phase: 'active', direction: 'd', hiredBy: '', term: '', provider: 'spawn',
+          persona: 'CHARTER', error: '', createdAt: 1, dismissedAt: 0, dismissReason: '',
+        })),
+        tasks: [], messages: [], delivered: [], meetings: [], debates: [], verdicts: {}, formal: {},
+        todo: [], queue: [], counters: { academician: 1, researcher: 3, temp: 1, task: 0, meeting: 0, message: 0, verify: 0 },
+        lastProgressAt: 1, artifactCount: 7, diagnostics: [],
+      },
+    },
+    order: ['default::alpha'],
+  }
+  writeFileSync(seedFile, JSON.stringify(seeded, null, 2), 'utf8')
+  const h = makeHost({ pluginModule, ws })
+  const c = await h.callTool('vibe_v5_configure', { institute: 'alpha', problem: 'a real problem' })
+  assert(c.ok === true && c.institute === 'alpha', 'configure accepted the existing named institute (' + JSON.stringify(c).slice(0, 90) + ')')
+  const after = JSON.parse(readFileSync(seedFile, 'utf8')).institutes['default::alpha']
+  assert(after && after.members.length === 5, '★ the 5-member snapshot on disk survived configure (got ' + (after && after.members.length) + ')')
+  assert(after.artifactCount === 7 && after.runId === 'run-x', 'the rest of the snapshot survived too (artifactCount=' + after.artifactCount + ', runId=' + after.runId + ')')
+  const st = await h.callTool('vibe_v5_status', {})
+  assert(st.key === 'default::alpha' && st.members.length === 5, 'status reads the ADOPTED institute, not an empty one (key=' + st.key + ', members=' + st.members.length + ')')
+}
+
+// ---------- 17. the NAMED institute's own file is really read (audit H1, second half) ----------
+console.log('\n[17] a second host reads the NAMED institute from its own file')
+{
+  // Ported from `_oneoff/audit241-v5-key.mjs`. `configure` must read `Institutes/<name>/State/
+  // <name>.v5state.json` — the audit's bug was that it silently created a NEW empty institute
+  // under the requested name while the real file stayed untouched.
+  const h1 = makeHost({ pluginModule })
+  const c1 = await h1.callTool('vibe_v5_configure', { institute: 'alpha', problem: 'named institute' })
+  assert(c1.ok === true && c1.institute === 'alpha', 'host A configured the named institute')
+  const s1 = await h1.callTool('vibe_v5_status', {})
+  assert(s1.key === 'default::alpha', 'host A reports key=default::alpha (got ' + s1.key + ')')
+  await h1.callTool('vibe_v5_start', { researcherCount: 1 })
+  await h1.settleSpawns()
+  const namedFile = join(h1.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'alpha', 'State', 'alpha.v5state.json')
+  const onDisk = () => { try { return JSON.parse(readFileSync(namedFile, 'utf8')).institutes['default::alpha'] } catch (e) { return null } }
+  let snapshot = null
+  for (let i = 0; i < 80 && !(snapshot && snapshot.members.length >= 2); i++) { snapshot = onDisk(); if (!(snapshot && snapshot.members.length >= 2)) await sleep(25) }
+  assert(!!snapshot && snapshot.members.length >= 2, 'host A persisted the institute into the file NAMED AFTER IT (' + JSON.stringify(snapshot && snapshot.members.map(m => m.id)) + ')')
+  const ids = (snapshot || { members: [] }).members.map(m => m.id)
+  // A fresh host (fresh module instance) over the SAME workspace: this is what a user restarting
+  // DSH sees. It must adopt the institute, not found a second empty one.
+  const h2 = makeHost({ pluginModule, ws: h1.WS })
+  const c2 = await h2.callTool('vibe_v5_configure', { institute: 'alpha', problem: 'named institute' })
+  assert(c2.ok === true, 'host B configured the same named institute (' + JSON.stringify(c2).slice(0, 90) + ')')
+  const s2 = await h2.callTool('vibe_v5_status', {})
+  assert(s2.key === 'default::alpha' && s2.backend === 'file', 'host B reports the named institute over the file backend (key=' + s2.key + ', backend=' + s2.backend + ')')
+  assert(ids.length > 0 && ids.every(id => s2.members.some(m => m.id === id)),
+    '★ host B READ the existing members instead of starting empty (got ' + JSON.stringify(s2.members.map(m => m.id)) + ', expected to include ' + JSON.stringify(ids) + ')')
+  const resumed = await h2.callTool('vibe_v5_resume', {})
+  assert(resumed.ok === true, 'resume on the adopted institute succeeded (' + JSON.stringify(resumed).slice(0, 120) + ')')
+}
+
+// ---------- 18. a FAILED turn: stopReason=error, lastAssistantMessage OMITTED -------------------
+console.log('\n[18] a turn ending with stopReason=error is recorded, with or without output')
+{
+  // The real host emits `stopReason:'error'` for a failed turn and OMITS `lastAssistantMessage`
+  // when there is nothing to report (dsh-subagent index.js:268-278/317-324). Every other mock in
+  // the suite fires 'completed' WITH a message, so this branch — and the omission it must survive —
+  // was never executed in CI (audit A-7).
+  const h = makeHost({ pluginModule })
+  const chatText = () => {
+    const dir = join(h.WS, 'VibeMath', 'Projects', 'default', 'Institutes', 'institute', 'Shared', 'Chat')
+    return existsSync(dir) ? readdirSync(dir).filter(f => f.endsWith('.md')).map(f => readFileSync(join(dir, f), 'utf8')).join('\n') : ''
+  }
+  // The exact host event, with the field ABSENT (not an empty array).
+  const fireBare = (childId, stopReason) => { for (const fn of h.listeners['subagent/end'] || []) fn({ id: childId, runId: 'r', provider: 'spawn', local: true, stopReason }) }
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  // Wake r-1 first: an end for a member with no in-flight token is ignored BY DESIGN (the
+  // idempotence guard), so without this the error branch would be unreachable.
+  await h.callTool('vibe_v5_say', { to: 'r-1', text: '请回报进展。' }, h.childAgent(h.childOf('acad')))
+  await sleep(40)
+  const st0 = await h.callTool('vibe_v5_status', {})
+  assert((st0.members.find(m => m.id === 'r-1') || {}).busy === true, 'precondition: r-1 has a turn in flight')
+  const before = chatText().length
+  fireBare(h.childOf('r-1'), 'error')
+  await sleep(80)
+  const written = chatText().slice(before)
+  const seg = written.indexOf('【异常】') === -1 ? '' : written.slice(written.indexOf('【异常】'), written.indexOf('【异常】') + 400)
+  const line = (seg.match(/【异常】[^\n]*/) || [''])[0]
+  assert(/【异常】r-1/.test(line) && /error/.test(line), '★ a failed turn is recorded in the group chat as 【异常】 for its OWNER: ' + JSON.stringify(line.slice(0, 120)))
+  assert(seg.indexOf('最后输出') === -1, 'an OMITTED lastAssistantMessage adds no phantom output text')
+  const st1 = await h.callTool('vibe_v5_status', {})
+  assert((st1.members.find(m => m.id === 'r-1') || {}).busy !== true, 'the failed member is not left marked busy')
+  assert(st1.running === true, 'the institute keeps running after a failed turn')
+  // And the SAME branch WITH output must carry it — otherwise the two assertions above could hold
+  // for a handler that only ever writes the member id.
+  await h.callTool('vibe_v5_say', { to: 'r-1', text: '再来一次。' }, h.childAgent(h.childOf('acad')))
+  await sleep(40)
+  const mark = chatText().length
+  h.fireEnd(h.childOf('r-1'), { progress: 'partial text before the failure' }, 'max-tokens')
+  await sleep(80)
+  const after = chatText().slice(mark)
+  const idx2 = after.indexOf('【异常】')
+  const seg2 = idx2 === -1 ? '' : after.slice(idx2, idx2 + 400)
+  const line2 = (seg2.match(/【异常】[^\n]*/) || [''])[0]
+  assert(/max-tokens/.test(line2) && /最后输出/.test(line2) && /partial text before the failure/.test(seg2),
+    '★ a non-completed turn WITH output carries that output and its stop reason: ' + JSON.stringify(seg2.slice(0, 140)))
+}
+
+// ---------- 19. two proposals in the SAME tick are never lost -------------------
+console.log('\n[19] concurrent propose_verify: the durable queue must not lose one')
+{
+  // The verify queue was mutated with a whole-array read-modify-write (`inst().queue.slice()`,
+  // push, `await putQueue(q)`). Two members proposing in the same tick both read the same array
+  // and each committed its own copy, so the last writer won and the first proposal vanished from
+  // the durable queue with BOTH calls reporting ok:true. The mutation now happens inside the
+  // event fold (`appendToQueue`), so no same-tick append can overwrite another.
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  const who = h.childAgent(h.childOf('r-1'))
+  const [pa, pb] = await Promise.all([
+    h.callTool('vibe_v5_propose_verify', { target: 'p-race-a', kind: 'proposition', reason: 'race A' }, who),
+    h.callTool('vibe_v5_propose_verify', { target: 'p-race-b', kind: 'proposition', reason: 'race B' }, who),
+  ])
+  assert(pa.ok === true && pb.ok === true, 'both concurrent proposals report ok (the buggy code reported ok for the lost one too)')
+  const s = await h.callTool('vibe_v5_status', {})
+  const seen = (s.verify ? [s.verify.target] : []).concat(s.verifyQueue)
+  assert(seen.indexOf('p-race-a') !== -1 && seen.indexOf('p-race-b') !== -1,
+    '★ neither same-tick proposal is lost: each is in-flight or queued (verify=' + JSON.stringify(s.verify && s.verify.target) + ', queue=' + JSON.stringify(s.verifyQueue) + ')')
+  await sleep(30)
+  const st = JSON.parse(readFileSync(statePathOf(h.WS), 'utf8'))
+  const inst = st.institutes[Object.keys(st.institutes)[0]]
+  const durable = (inst.queue || []).map(q => q.target)
+  const open = Object.keys(inst.verdicts || {}).filter(k => !inst.verdicts[k].closed)
+  const bothDurable = (durable.indexOf('p-race-a') !== -1 || open.indexOf('p-race-a') !== -1) &&
+    (durable.indexOf('p-race-b') !== -1 || open.indexOf('p-race-b') !== -1)
+  assert(bothDurable, '★ the durable state file keeps both as well (queue=' + JSON.stringify(durable) + ', open verdicts=' + JSON.stringify(open) + ')')
+}
+
+// ---------- 20. invalid numeric params are clamped, not silently destructive ----------
+console.log('\n[20] invalid numeric params are clamped instead of silently destructive')
+{
+  // `compactThreshold <= 0` made EVERY round look over the threshold (a permanent compaction
+  // directive), `verdictMaxRounds < 1` collapsed every debate to one round, and `chatDigestMax < 1`
+  // emptied the digest bucket. `normalizeParams` now applies the same discipline the durations use.
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  const r = await h.callTool('vibe_v5_set', { verdictMaxRounds: 0, chatDigestMax: -3, compactThreshold: 0 })
+  assert(r.ok === true && r.params.verdictMaxRounds === 1, 'verdictMaxRounds=0 floors at 1 (got ' + r.params.verdictMaxRounds + ')')
+  assert(r.params.chatDigestMax === 1, 'chatDigestMax=-3 floors at 1 (got ' + r.params.chatDigestMax + ')')
+  assert(r.params.compactThreshold === 66, 'compactThreshold=0 falls back to the default 66 (got ' + r.params.compactThreshold + ')')
+}
+
+// ---------- 21. an office-only tool never impersonates the office for an unknown caller ----
+console.log('\n[21] office-only tools refuse a caller that is neither a member nor the session root')
+{
+  // `memberIdOfAgent` answers 'office' for the root AND '' for an unrelated descendant, and
+  // `isOffice('')` used to be true — so the old handlers fell back to the office and let any
+  // unresolvable caller convene meetings / hire / fire / ASSIGN / NUDGE / create tasks as the
+  // office (audit L6 and its follow-up). `officeCaller` now refuses, every writing tool resolves
+  // through it, and `isOffice` itself only accepts the literal 'office'.
+  const h = makeHost({ pluginModule })
+  await h.callTool('vibe_v5_start', { problem: PROBLEM, researcherCount: 1 })
+  await h.settleSpawns()
+  const ghost = h.childAgent('c-nobody')
+  const mtg = await h.callTool('vibe_v5_meeting', { agenda: '冒充所办', kind: 'sync' }, ghost)
+  assert(mtg.ok === false && mtg.code === 'V5_MEMBER_NOT_FOUND',
+    'meeting is refused for a caller that is not a member or the session root (' + JSON.stringify(mtg).slice(0, 90) + ')')
+  const res = await h.callTool('vibe_v5_add_researcher', { direction: 'x' }, ghost)
+  assert(res.ok === false && res.code === 'V5_MEMBER_NOT_FOUND',
+    'add_researcher is refused for the same caller (' + JSON.stringify(res).slice(0, 90) + ')')
+  // The whole family of writing tools must refuse that caller, not just the office-only ones:
+  // each of these used to receive '' from memberIdOfAgent and treat it as the office. A REAL task
+  // is opened first so the ghost's task_update / prioritize have live state to damage.
+  const t1 = await h.callTool('vibe_v5_task_create', { subject: '真实任务' })
+  assert(t1.ok === true, 'a real caller can still open a task (' + JSON.stringify(t1).slice(0, 90) + ')')
+  const boardBefore = (await h.callTool('vibe_v5_task_list', {})).tasks.length
+  const ghostWrites = [
+    ['vibe_v5_assign', { subject: '冒充分派', to: 'r-1', why: 'w', acceptance: 'a' }],
+    ['vibe_v5_nudge', { to: 'r-1', why: 'w' }],
+    ['vibe_v5_task_create', { subject: '冒充所办建的任务' }],
+    ['vibe_v5_task_update', { task_id: t1.task.id, expected_revision: 1, action: 'delete' }],
+    ['vibe_v5_prioritize', { order: [{ task_id: t1.task.id, priority: 9 }], why: 'w' }],
+    ['vibe_v5_propose_verify', { target: 'p-ghost', kind: 'proposition', reason: 'r' }],
+    ['vibe_v5_lean_run', { file: 'Formal/ghost.lean' }],
+  ]
+  for (const [name, args] of ghostWrites) {
+    const r = await h.callTool(name, args, ghost)
+    assert(r.ok === false && r.code === 'V5_MEMBER_NOT_FOUND',
+      name + ' is refused for the unidentifiable caller (' + JSON.stringify(r).slice(0, 90) + ')')
+  }
+  const boardAfter = await h.callTool('vibe_v5_task_list', {})
+  const t1After = boardAfter.tasks.find((t) => t.id === t1.task.id)
+  assert(boardAfter.tasks.length === boardBefore,
+    'no refused write reached the board (before=' + boardBefore + ', after=' + boardAfter.tasks.length + ')')
+  assert(t1After && t1After.status !== 'deleted', 'the refused task_update did not delete a real task')
+  assert(t1After && t1After.priority === 0, 'the refused prioritize did not reorder a real task (priority=' + (t1After && t1After.priority) + ')')
+  // ...and the real identities still work: the office signs as the office, a member acts as itself.
+  const asgOffice = await h.callTool('vibe_v5_assign', { subject: '所办分派', to: 'r-1', why: 'w', acceptance: 'a' })
+  assert(asgOffice.ok === true && asgOffice.task && asgOffice.task.assignedBy === 'office',
+    'the office still assigns and is signed as office (' + JSON.stringify(asgOffice).slice(0, 110) + ')')
+  const tcOffice = await h.callTool('vibe_v5_task_create', { subject: '所办任务' })
+  assert(tcOffice.ok === true && tcOffice.task.createdBy === 'office', 'the office task_create still records createdBy=office')
+  const nudgeAcad = await h.callTool('vibe_v5_nudge', { to: 'r-1', why: '院士督办' }, h.childAgent(h.childOf('acad')))
+  assert(nudgeAcad.ok === true, 'the academician still nudges (' + JSON.stringify(nudgeAcad).slice(0, 90) + ')')
+  const office = await h.callTool('vibe_v5_meeting', { agenda: '所办直接开会', kind: 'sync' })
+  assert(office.ok === true, 'the real office (session root) still convenes a meeting (' + JSON.stringify(office).slice(0, 90) + ')')
+  // Two office-impersonation holes the independent verifier found AFTER Round D — same L6 class,
+  // and neither was covered by the assertions above: `vibe_v5_message` signed EVERY caller's text
+  // as the office (no caller resolution at all), and `vibe_v5_remove_researcher` ("Office only")
+  // accepted any caller. Both now resolve through `officeCaller` and refuse.
+  const ghostMsg = await h.callTool('vibe_v5_message', { to: 'all', content: '冒充所办通知' }, ghost)
+  assert(ghostMsg.ok === false && ghostMsg.code === 'V5_MEMBER_NOT_FOUND',
+    'vibe_v5_message is refused for the unidentifiable caller (' + JSON.stringify(ghostMsg).slice(0, 90) + ')')
+  const memberMsg = await h.callTool('vibe_v5_message', { to: 'all', content: '成员冒充所办通知' }, h.childAgent(h.childOf('r-1')))
+  assert(memberMsg.ok === false && memberMsg.code === 'V5_NOT_OFFICE',
+    'vibe_v5_message is refused for a MEMBER too — the relay is signed as the office, members use vibe_v5_say (' + JSON.stringify(memberMsg).slice(0, 90) + ')')
+  const ghostRm = await h.callTool('vibe_v5_remove_researcher', { id: 'r-1' }, ghost)
+  assert(ghostRm.ok === false && ghostRm.code === 'V5_MEMBER_NOT_FOUND',
+    'vibe_v5_remove_researcher is refused for the unidentifiable caller (' + JSON.stringify(ghostRm).slice(0, 90) + ')')
+  const memberRm = await h.callTool('vibe_v5_remove_researcher', { id: 'r-1' }, h.childAgent(h.childOf('r-1')))
+  assert(memberRm.ok === false && memberRm.code === 'V5_NOT_OFFICE',
+    '...and refused for a member (the tool says Office only), not just for ghosts (' + JSON.stringify(memberRm).slice(0, 90) + ')')
+  const r1Still = (await h.callTool('vibe_v5_members', {})).members.find((m) => m.id === 'r-1')
+  assert(r1Still && r1Still.phase === 'active', 'neither refused call dismissed r-1 (phase=' + JSON.stringify(r1Still && r1Still.phase) + ')')
+  const officeMsg = await h.callTool('vibe_v5_message', { to: 'all', content: '所办通知' })
+  assert(officeMsg.ok === true, 'the office still relays a message (' + JSON.stringify(officeMsg).slice(0, 90) + ')')
+  // The `/v5` SLASH-COMMAND line is the third surface of the same class: it hardcoded 'office' for
+  // every subcommand (`remove`/`fire`/`hire`/`set`/`stop`/`message`…), and a member child maps to
+  // the same institute session — so a member (or an unidentifiable descendant) could drive it. It
+  // now resolves the caller too.
+  const cmdV5 = h.commandRegs.find((c) => c.name === 'v5')
+  const cmdGhost = JSON.parse((await cmdV5.handler({ agent: ghost, rawInput: 'remove r-1' })).text)
+  assert(cmdGhost.ok === false && cmdGhost.code === 'V5_NOT_OFFICE',
+    '/v5 remove is refused for the unidentifiable caller (' + JSON.stringify(cmdGhost).slice(0, 90) + ')')
+  const cmdMember = JSON.parse((await cmdV5.handler({ agent: h.childAgent(h.childOf('r-1')), rawInput: 'remove r-1' })).text)
+  assert(cmdMember.ok === false && cmdMember.code === 'V5_NOT_OFFICE',
+    '/v5 remove is refused for a member child too (' + JSON.stringify(cmdMember).slice(0, 90) + ')')
+  const r1AfterCmd = (await h.callTool('vibe_v5_members', {})).members.find((m) => m.id === 'r-1')
+  assert(r1AfterCmd && r1AfterCmd.phase === 'active', 'the refused /v5 remove did not dismiss r-1 (phase=' + JSON.stringify(r1AfterCmd && r1AfterCmd.phase) + ')')
+  const cmdOffice = JSON.parse((await cmdV5.handler({ agent: h.ROOT, rawInput: 'status' })).text)
+  assert(cmdOffice.ok === true, 'the office still drives the /v5 line (' + JSON.stringify(cmdOffice).slice(0, 90) + ')')
+  const officeRm = await h.callTool('vibe_v5_remove_researcher', { id: 'r-1' })
+  assert(officeRm.ok === true, 'the office can still dismiss a permanent researcher (' + JSON.stringify(officeRm).slice(0, 90) + ')')
+}
+
+// ---------- 22. the office-only LIFECYCLE controls resolve their caller too ----------
+console.log('\n[22] configure/start/resume/pause/stop/set belong to the PROVABLE session root')
+{
+  // A member child and the office share ONE institute session, so `getSession()` alone let a member
+  // (or an unidentifiable descendant of the root) drive these handlers as the office: stop the
+  // institute, or rewrite quorum/params. Absence of a caller is NOT the office either.
+  const h = makeHost({ pluginModule })
+  // (a) the root/UI path keeps working end-to-end: these are exactly the handlers `/v5` drives.
+  const cfg = await h.callTool('vibe_v5_configure', { institute: 'life', problem: PROBLEM })
+  assert(cfg.ok === true, 'the office configures the institute (' + JSON.stringify(cfg).slice(0, 90) + ')')
+  const started = await h.callTool('vibe_v5_start', { researcherCount: 1 })
+  assert(started.ok === true, 'the office founds it (' + JSON.stringify(started).slice(0, 90) + ')')
+  await h.settleSpawns()
+  const setOk = await h.callTool('vibe_v5_set', { maxParallel: 2 })
+  assert(setOk.ok === true && setOk.params.maxParallel === 2, 'the office tunes parameters (' + JSON.stringify(setOk).slice(0, 90) + ')')
+  const pauseOk = await h.callTool('vibe_v5_pause', {})
+  assert(pauseOk.ok === true, 'the office pauses (' + JSON.stringify(pauseOk).slice(0, 90) + ')')
+  const resumeOk = await h.callTool('vibe_v5_resume', {})
+  assert(resumeOk.ok === true, 'the office resumes (' + JSON.stringify(resumeOk).slice(0, 90) + ')')
+  // (b) a MEMBER child and an unidentifiable descendant of the office root are both refused.
+  const member = h.childAgent(h.childOf('r-1'))
+  const ghost = h.childAgent('c-nobody')
+  const officeOnly = [
+    ['vibe_v5_configure', { institute: 'stolen', problem: 'x' }],
+    ['vibe_v5_start', { researcherCount: 3 }],
+    ['vibe_v5_resume', {}],
+    ['vibe_v5_pause', {}],
+    ['vibe_v5_stop', {}],
+    ['vibe_v5_set', { maxParallel: 9 }],
+  ]
+  for (const [name, args] of officeOnly) {
+    const asMember = await h.callTool(name, args, member)
+    assert(asMember.ok === false && asMember.code === 'V5_NOT_OFFICE',
+      name + ' is refused for a MEMBER child (' + JSON.stringify(asMember).slice(0, 80) + ')')
+    const asGhost = await h.callTool(name, args, ghost)
+    assert(asGhost.ok === false && asGhost.code === 'V5_NOT_OFFICE',
+      name + ' is refused for the unidentifiable caller (' + JSON.stringify(asGhost).slice(0, 80) + ')')
+  }
+  // (c) NO caller at all is not the office either — driven through the real registered wrapper (the
+  // harness' callTool defaults to ROOT, so `agent: undefined` is passed explicitly here). The wrapper
+  // refuses it as 'no session' BEFORE the gate, i.e. absence never reaches the office path.
+  const stopSpec = h.toolRegs.find((t) => t.name === 'vibe_v5_stop')
+  const noCaller = JSON.parse(await stopSpec.execute({}, { agent: undefined }))
+  assert(noCaller.ok === false,
+    'an agent-less call never reaches the lifecycle handler as the office (' + JSON.stringify(noCaller).slice(0, 80) + ')')
+  // (d) nothing the refusals asked for took effect.
+  const after = await h.callTool('vibe_v5_status', {})
+  assert(after && after.ok !== false && after.params && after.params.maxParallel === 2,
+    'no refused lifecycle call took effect (maxParallel=' + (after.params && after.params.maxParallel) + ')')
+  assert(after.members && after.members.some((m) => m.phase !== 'dismissed'),
+    'the refused stop did not dissolve the roster (' + (after.members || []).map((m) => m.id + ':' + m.phase).join(',') + ')')
+  const finalStop = await h.callTool('vibe_v5_stop', {})
+  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')
+}
+
 console.log('')
 console.log('passed=' + passed + ' failed=' + failed)
 if (failed) { console.error('FAILURES:'); for (const f of failures) console.error('  - ' + f); process.exit(1) }