dsh-vibe-math 2.7.2 → 2.7.3

package/tests/formal-verify-v4.test.mjs

@@ -1,4 +1,96 @@
 // ============================================================
+// Defect class: F-6 (durability surfacing). A swallowed durable write / index rebuild / compaction
+// failure must be NAMED once, with its consequence, instead of disappearing silently.
+// Run: node tests/formal-verify-v4.test.mjs
+//
+// RECORDED BOUNDARY - all four product warnings EXIST (commit d02bdbf: warnedWriteFormalTodo,
+// warnedDeferFormalTodo, warnedIndexRebuild, warnedCompaction; each once-per-process and each stating
+// its consequence) but are NOT captured automatically by this suite. NOT REPRODUCED != NOT
+// IMPLEMENTED: the reasons below are measured on the mock host, not assumed.
+//   site 1 closeVerify      - guarded by `if(formalOn() && formalTodos.some(id===target))` (unreachable
+//                             in off mode); the close is finalised by finalizeVerify's ASYNC chain
+//                             AFTER proposeAndVote() returns, so a deterministic assertion would need
+//                             a product-side fault hook (rejected: it would become a new
+//                             agent-settable parameter) or dedicated verify orchestration.
+//   site 2 deferForFormal   - KNOWN COVERAGE HOLE (measured). Payload-anchored injection (fail the
+//                             Formal/TODO.md write whose payload mentions the target) is CONSUMED by an
+//                             earlier TODO write in require mode (recording the proposition also writes
+//                             that file and names the target), so the induced failure lands OUTSIDE
+//                             deferForFormal's try: the run is derailed (Formal/TODO.md never created,
+//                             section 9's own TODO assertions fail) and NO warning is emitted
+//                             (`matched=0 of 0`). Anchoring by State/formal.json as a precursor was also
+//                             measured imprecise (armed=9, failed=1, no warning). The warning itself
+//                             exists and is exercised by the F-2-style unit surface at
+//                             tests/audit-f1-compact-fix.test.mjs; only the in-suite capture is missing.
+//   site 2 (old note)       - same async-finalisation problem (require mode only).
+//   site 3 settleLeanJob    - the injected index-write failure is consumed by whichever
+//                             rebuildLeanLibIndexes() caller fires first (measured: armed=3,
+//                             failed=1, warning not emitted), so the mock cannot discriminate the
+//                             caller that this site guards. Caller-discriminating injection was
+//                             attempted (run every other rebuild caller first, then arm): the settle
+//                             path's index write was still never reached (measured failed=0) -
+//                             caller-discriminating injection attempted, still not reached.
+//                             AUTHOR-MEASURED, NOT INDEPENDENTLY REPRODUCED: R17 could not reproduce the
+//                             `armed=3 failed=1` / `failed=0` instrumentation numbers (it marked them
+//                             still-unsure). It DID verify the STRUCTURE this boundary rests on: the
+//                             single-line best-effort wrapper, all six callers (settleLeanJob,
+//                             writeLeanLibIndexesSafe, the three leanArchive paths, the lean_lib tool)
+//                             now covered by the one-shot naming inside rebuildLeanLibIndexes, and every
+//                             later rebuild rewriting the index => self-healing. The boundary stands on
+//                             that structural evidence; the two raw numbers above are author-measured only.
+//   site 4 realCompact      - SURFACED (section N15): the mock resolves the child agent and exposes a
+//                             THROWING compaction service only under an injection switch, so a completed
+//                             resident turn reaches realCompact and its catch is asserted to NAME the
+//                             failure exactly once with its consequence (mutant: the warning guard
+//                             disabled => `460/2`, red on N15/4).
+//   site 4 (old note)       - realCompact returns early unless liveAgentOf(r.childId) resolves; this
+//                             mock's agents.get() maps only sess-A, so a resident turn never reaches
+//                             the compaction call (probe: the service is never invoked).
+// F1 COVERAGE HOLE (window) - measured, not assumed. The consensus-membership fix (predicate + roster
+// guard) is covered by the SOURCE-LEVEL guards in section N13 (both single-site mutants redden by name:
+// count predicate => 457/2; `_inRoster=true` => 458/1). The behavioural WINDOW the v2/v3 owner proposed
+// (a removed, still-in-flight frozen voter's late ballot) was driven inside section D4 and measured
+// unobservable through the public API: fixed => `before=0/2 after=0/1 card=false`; guard deleted (M2) =>
+// the SAME `0/1`; count predicate (M1) => the SAME `0/1`. The late ballot therefore never reaches the
+// recording site in this composition, so a windowed assertion could not be reddened by M2 and would be
+// vacuous - it was NOT landed. Regression coverage for F1 is N13 (source level).
+
+// F-6 (:786) FIXED, not merely bounded: a failed build-context comparison now records
+// `contextChanged=null` (unknown != unchanged) and emits a one-time named warning (warnedContextProbe,
+// wording states the consequence). It carries NO automated assertion here: the branch is UNREACHABLE
+// from this host mock - `leanBuildContext()` is non-throwing by construction (its only host call,
+// resolveExecutable, is wrapped and degrades to the configured name) and every other step is a
+// defensive coercion over agent-settable params (leanSearchPaths/leanArgs are Array.isArray-guarded and
+// String()-coerced). A mutant without an assertion would prove nothing, so none is claimed.
+// Consumer check (repo-wide grep of `contextChanged`): only 4 references, all in v4's settle paths -
+// the field is write-only for the JSON reader, so `null` cannot be mis-read as `false`.
+// Sites 3/4 carry test-side injection switches in the F-6 work branch (_oneoff/tw-patch.mjs) which
+// can be re-landed together with a host-side caller discriminator.
+// ---------------------------------------------------------------
+// SHIPPED ASSERTION RULES (the rules behind N13-N17; the authoring ledger lives outside the package,
+// so the essentials ship HERE, next to the guards they govern).
+//   (A) LIVENESS BEFORE SILENCE (governs N17/F-5, especially case 1c): every "no warning / no write /
+//       no re-anchor" assertion must ALSO prove that the code under test RAN, and the proof must be
+//       taken at the step CLOSEST to that branch. Measured counter-examples on this mock: "the policy
+//       service was queried" is NOT proof (`sandboxPolicyOf()` is read by BOTH workspaceRoot() and
+//       getPolicy()), and "the write succeeded" is NOT proof either (with an unknown cwd the same call
+//       returns ok:false for an UNRELATED path reason). The workable instrument is the resolve() call
+//       count - `LIVENESS: resolve calls=11` - because resolve({session}) runs immediately before
+//       fenceRootDriftNote(). Mutant "unknown cwd => warn" reddens `F-5/1c ... stays SILENT (drift=1)`.
+//   (B) A SYMBOL'S EXISTENCE IS NOT ITS USE (governs the F-3/F-4c verdicts recorded in-product at
+//       vibe-math-v4.js:3553): a count is a LEAD, never a verdict - the verdict must be read at the
+//       SEMANTIC UNIT. Measured: `registerTool(` appears 36 times but there is exactly ONE registration
+//       unit (the ctx.effect inside the registerTool helper), so no call site needs its own wrapper;
+//       and a failed mkdir is named ONCE INSIDE ensureDirs (warnedMkdir), which covers every caller -
+//       including the bare `await ensureDirs()` - so no caller-side return check is required.
+//   (C) G-6 HOST CONCURRENCY CAP, assertion level: when the host's live-child cap refuses a spawn, the
+//       assertion must require the cap to be NAMED together with the knob that raises it, the durable
+//       marker to survive (hostChildLimit / failReason), and the freed capacity to be spent on exactly
+//       ONE deferred member. Field-level semantics: docs/status-report-fields.md (pendingSpawns).
+//   (D) A2 WAKE/WATCHDOG, assertion level: ack only AFTER a successful delivery, and advance the round
+//       counter only AFTER a successful send - asserted under INJECTED send failures, never on the
+//       happy path (where build == send == success hides the defect). Shipped families: v5 G1/G2.
+// ---------------------------------------------------------------
 // V4 LEAN FORMAL VERIFICATION SUITE  (docs/formal-verification.md)
 //
 // Asserts the whole contract of the `formalVerify` knob for the v4 preset:
@@ -43,6 +135,7 @@ function pluginUrl() {
   return pathToFileURL(fileURLToPath(new URL('file:///' + s.replace(/\\/g, '/'))))
 }
 const PLUGIN = pluginUrl()
+function PLUGIN_SRC() { return readFileSync(process.env.V4_PLUGIN ? String(process.env.V4_PLUGIN) : fileURLToPath(new URL('../vibe-math-v4/vibe-math-v4.js', import.meta.url)), 'utf8') }   // protocol 搂9: ONE seam-aware resolution for source-text guards
 // docs §10 item 10: the Lean prompt corpus is shipped under prompt-corpus-v4/ so a HUMAN can read
 // the exact text the framework sends. V4_CORPUS_DIR overrides the destination (same convention v3
 // and v5 use for V3_CORPUS_DIR / V5_CORPUS_DIR).
@@ -70,6 +163,13 @@ let subprocessAvailable = true
 // Used by §13 to prove the withdrawal is not a best-effort delete: the framework must confirm the
 // file is gone through the fs service and fall back to overwriting it with a withdrawal notice.
 let shellDeletesFiles = true
+let shellMkdirExit = 0
+let fsWriteFailPred = null   // F-6/N18: (targetKey) => boolean; the first matching write FAILS (payload/path anchored)
+let fsWriteFailOnce = false
+let sandboxDriftRoot = null   // F-5: when set, the mock policy resolves THIS root (drift/containment harness)
+let sandboxNoRoot = false     // F-5: when set, the mock policy exposes NO interpretable root (no-op path)
+let sandboxUnknownCwd = false   // F-5/1c: the captured root agent has NO cwd (unknown => `.` guard)
+let compactionFails = false   // F-6 site 4: expose a THROWING compaction service + resolve child agents
 const leanRuns = []          // every spawn the framework made, for cwd/argv assertions
 const terminated = []        // files whose handle the framework actively terminate()d (docs §7)
 const shellCalls = []        // every platform-shell script (mkdir at mount, Remove-Item on defect)
@@ -95,7 +195,7 @@ function makeSubprocess() {
         if (shellDeletesFiles && /Remove-Item/.test(script) && m) rmSync(m[1].replace(/''/g, "'"), { force: true })
         if (shellDeletesFiles && /^rm -f /.test(script)) for (const q of script.slice(6).match(/'[^']*'/g) || []) rmSync(q.slice(1, -1), { force: true })
         return {
-          done: Promise.resolve({ exitCode: 0, signal: null }),
+          done: Promise.resolve({ exitCode: (/New-Item|^mkdir -p /.test(script) ? shellMkdirExit : 0), signal: null }),
           collected: { stdout: { readFrom: () => ({ text: '', nextOffset: 0, lossy: false }) }, stderr: { readFrom: () => ({ text: '', nextOffset: 0, lossy: false }) } },
           terminate() {},
         }
@@ -135,9 +235,21 @@ function makeHost() {
   const WS = mkdtempSync(join(tmpdir(), 'vibe-v4-lean-'))
   const listeners = {}, toolRegs = [], spawns = [], followups = [], cmdRegs = []
   const subprocess = makeSubprocess()
+let sandboxPolicyQueries = 0   // F-5/1c: how many times the policy service was queried
+let sandboxResolveCalls = 0     // F-5/1c: resolve({session}) calls = fenceRootDriftNote invocations
   let ROOT
   const ctx = {
-    get(name) { return name === 'subprocess' && subprocessAvailable ? subprocess : undefined },
+    get(name) {
+      if (name === 'subprocess' && subprocessAvailable) return subprocess
+      if (name === 'sandboxPolicy') sandboxPolicyQueries += 1   // F-5/1c liveness: the policy path really ran
+      if (name === 'sandboxPolicy' && sandboxUnknownCwd) return { resolve: () => { sandboxResolveCalls += 1; return { workspaceRoot: WS + '/fenced-elsewhere' } } }   // NO top-level root: workspaceRoot() falls back to '.'
+      if (name === 'sandboxPolicy' && (sandboxDriftRoot || sandboxNoRoot)) return sandboxNoRoot ? { allow: ['x'], deny: [], resolve: () => ({ allow: ['x'], deny: [] }) } : { workspaceRoot: sandboxDriftRoot, resolve: () => ({ workspaceRoot: sandboxDriftRoot }) }
+      if (name === 'compaction' && compactionFails) return {
+        async compactIfNeeded() { throw new Error('COMPACTION_FAIL (injected)') },
+        async compactNow() { throw new Error('COMPACTION_FAIL (injected)') },
+      }
+      return undefined
+    },
     on(e, fn) { (listeners[e] = listeners[e] || []).push(fn) },
     effect(fn) { const d = fn(); return () => { if (typeof d === 'function') d() } },
     logger: { info() {}, warn() {}, error() {} },
@@ -151,21 +263,28 @@ function makeHost() {
       async sendMessage(parent, childId, blocks) { followups.push({ childId, blocks }) },
       interrupt() {},
     },
-    agents: { roots() { return [] }, get(id) { return id === 'sess-A' ? ROOT : undefined } },
+    agents: { roots() { return [] }, get(id) {
+      if (compactionFails && id && id !== 'sess-A') return { id, session: { id, header: { cwd: WS, parentSession: 'sess-A' } } }
+      return id === 'sess-A' ? ROOT : undefined
+    } },
     fs: {
       async resolve(rel, opts) { const b = (opts && opts.cwd) || WS; const p = (typeof rel === 'string' && isAbsolute(rel)) ? rel.replace(/\//g, '\\') : join(b, ...String(rel).split('/')); return { targetKey: p, displayPath: p } },
       async stat(t) { return existsSync(t.targetKey) ? { version: 'v1', type: 'file', size: 1 } : undefined },
       async readText(t) { return readFileSync(t.targetKey, 'utf8') },
-      async writeText(t, c) { mkdirSync(dirname(t.targetKey), { recursive: true }); writeFileSync(t.targetKey, c, 'utf8') },
+      async writeText(t, c) { if (fsWriteFailOnce && fsWriteFailPred && fsWriteFailPred(String(t.targetKey), String(c))) { fsWriteFailOnce = false; throw new Error('FS_WRITE_FAIL (injected): ' + t.targetKey) } mkdirSync(dirname(t.targetKey), { recursive: true }); writeFileSync(t.targetKey, c, 'utf8') },
       async listDir(t) { if (!existsSync(t.targetKey)) return []; return readdirSync(t.targetKey, { withFileTypes: true }).map(e => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file' })) },
     },
   }
   ROOT = { id: 'sess-A', options: { provider: 'mock', model: 'm' }, session: { id: 'sess-A', header: { cwd: WS, parentSession: undefined } }, followup() {}, ctx: undefined }
+if (sandboxUnknownCwd) ROOT.session.header.cwd = ''   // F-5/1c: unknown session cwd
   const projectRoot = join(WS, 'VibeMath', 'Projects', 'default')
   const vibeRoot = join(WS, 'VibeMath')
   let consumed = 0
   const h = {
     WS, ctx, toolRegs, spawns, followups, ROOT, projectRoot, vibeRoot, cmdRegs,
+policyQueries: () => sandboxPolicyQueries,
+resolveCalls: () => sandboxResolveCalls,
+resetResolveCalls: () => { sandboxResolveCalls = 0 },
     /** Drive the registered `/v4` slash command — the OTHER parameter surface the spec §B names. */
     async cmd(rawInput) { const c = cmdRegs.find(x => x.name === 'v4'); if (!c) throw new Error('no /v4 command'); return await c.handler({ agent: ROOT, rawInput }) },
     async callTool(n, a, agent) {
@@ -590,8 +709,8 @@ assert(existsSync(join(provedPath, 'sq_odd.lean')), 'the lemma exists under Vibe
 assert(/ZMod5/.test(readIf(join(libPath, 'Index.md'))), 'Lib/Index.md lists the new definition')
 assert(/sq_odd/.test(readIf(join(provedPath, 'Index.md'))), 'Proved/Index.md lists the new lemma')
 // `from` copies an existing workspace .lean file instead of inline content
-writeFileSync(join(D.projectRoot, 'Formal', 'src.lean'), 'def copied := 7\n', 'utf8')
-const fromRes = await D.callTool('vibe_v4_lean_archive', { kind: 'def', name: 'Copied', from: 'Formal/src.lean' }, r1)
+writeFileSync(join(D.projectRoot, 'Formal', 'PLUGIN_SRC().lean'), 'def copied := 7\n', 'utf8')
+const fromRes = await D.callTool('vibe_v4_lean_archive', { kind: 'def', name: 'Copied', from: 'Formal/PLUGIN_SRC().lean' }, r1)
 assert(fromRes.ok === true && readIf(join(libPath, 'Copied.lean')) === 'def copied := 7\n', "kind='def' accepts from=<existing .lean file>")
 const fromEsc = await D.callTool('vibe_v4_lean_archive', { kind: 'def', name: 'Evil', from: '../../../../etc/passwd' }, r1)
 assert(fromEsc.ok === false && fromEsc.code === 'V4_INVALID_ARGUMENT', "★ kind='def' refuses a `from` outside the VibeMath root")
@@ -1176,7 +1295,7 @@ const K = await establish()
     const later = byLabel('meeting/later speaker (others relayed)')
     assert(!!first && !!later, '★ the corpus carries the MEETING prompt (two perspectives: no prior speech / others already relayed)')
     assert(/meeting is in progress/.test(first.prompt) && /meeting is in progress/.test(later.prompt), 'the meeting entries are built by the real meeting prompt builder')
-    assert(/目前还没人发言/.test(first.prompt), 'the first-speaker entry shows the "nobody has spoken yet" branch')
+    assert(/并行独立发言/.test(first.prompt), 'the first-speaker entry states the parallel-statements semantics (nobody has spoken yet)')
     assert(/已有发言（他人 input，已转发给你）/.test(later.prompt) && /我建议先验证 p-corpus/.test(later.prompt), '★ the later-speaker entry carries a teammate contribution VERBATIM (the group-chat relay is reviewable)')
     assert(/\[r-1\]/.test(later.prompt) && !/\[r-2\]/.test(later.prompt), 'the relayed-speech list excludes the reader and names the real sender id')
     assert(/voteSolved/.test(first.prompt) && /停止表决必须是绝对票/.test(first.prompt), '★ the meeting prompt states the stop-vote contract the code enforces (every speaker must answer true)')
@@ -1324,12 +1443,22 @@ section('20 crash recovery: queued re-driven, changed content never verified, se
   await N.callTool('vibe_v4_start', { problem: '恢复扫描', residentCount: 1 })
   const a = await N.callTool('vibe_v4_lean_job', { jobId: 'p-rec-aaaaaaaaaaaa' })
   const b = await N.callTool('vibe_v4_lean_job', { jobId: 'p-stale-bbbbbbbbbbbb' })
-  assert(a.state === 'queued' || a.state === 'running' || a.state === 'settled', '★ recovery re-drives a `running` job whose content still matches (state=' + a.state + ')')
+  assert(a.attempts >= 2 && (a.state === 'queued' || a.state === 'running' || a.state === 'settled'), '* a hash-matching interrupted job is RE-DRIVEN (never adopted): attempts 1 -> ' + a.attempts + ', state=' + a.state)
+  // (cold-state liveness, code path recoverLeanJobs:911): with NO explicit followup the armed heartbeat
+  // must drain the re-queued job on a later tick - poll with the diagnostic triple in the message.
+  {
+    const t0 = Date.now()
+    let cur = a, tries = 0
+    while (tries < 60 && cur.state === 'queued') { tries++; await new Promise((r) => setTimeout(r, 100)); cur = await N.callTool('vibe_v4_lean_job', { jobId: 'p-rec-aaaaaaaaaaaa' }) }
+    assert(cur.state !== 'queued', '* the next tick DRAINS the re-queued job without any explicit followup (state=' + cur.state + ', window=6000ms, waited=' + (Date.now() - t0) + 'ms, attempts=' + tries + ')')
+    const stLive = await N.callTool('vibe_v4_status', {})
+    assert(stLive.running === true, '* the institute clock keeps running after a stale-only recovery: recoverLeanJobs:911 arms ONE idle pass even when nothing is drainable (documented behaviour - if a future change stops arming on stale-only, THIS reddens)')
+  }
   assert(b.state === 'interrupted', '★ a `running` job whose file CHANGED is interrupted, not verified (state=' + b.state + ')')
   const st = await N.callTool('vibe_v4_status', {})
   assert(!st.formal.passed.includes('p-stale'), '★ the changed-content job never reaches `passed`')
   assert(!st.formal.passed.includes('p-done') && !existsSync(join(N.projectRoot, 'Verified', 'Lean', 'p-done.lean')), '★ a fresh run does NOT adopt a previous run’s `settled` record (no stale passed, no minted proof)')
-  assert(N.followups.map(promptOf).join('\n').length >= 0, 'recovery ran without throwing')
+  assert(N.followups.length === 0, '* the stale-job recovery path wakes NO new resident (followups=' + N.followups.length + ') - the wake decision belongs to the watchdog; this line is falsifiable, so a future change of that contract reddens HERE')
 }
 
 // ===============================================================
@@ -1549,6 +1678,7 @@ section('D4 cross-view: one frozen participant set, seen identically by every vi
   assert(st2.rosterVersion > c0.rosterVersion, 'hiring mid-verify bumps rosterVersion (' + c0.rosterVersion + ' -> ' + st2.rosterVersion + ')')
   assert(st2.consensus.expected === st2.frozenParticipants.length && st2.consensus.expected === c0.expected,
     '★ after a mid-verify HIRE the frozen set is UNCHANGED and both views still agree (newcomer did not join)')
+  assert(typeof rv2.rosterVersion === 'number' && typeof st2.consensus.rosterVersion === 'number', 'non-vacuous: both frozen views EXPOSE a numeric rosterVersion (a relative === passes when both are absent)')
   assert(rv2.rosterVersion === st2.consensus.rosterVersion,
     '★ after the HIRE the two FROZEN views (status().consensus + report().verify) still report the SAME rosterVersion')
   assert(st2.rosterVersion > rv2.rosterVersion,
@@ -1566,8 +1696,410 @@ section('D4 cross-view: one frozen participant set, seen identically by every vi
   assert(st4.verifyInProgress === false, '★ the mid-verify hire/fire did NOT prevent the verification from concluding')
 }
 
+
+
+// ===============================================================
+// 24. round A F2 (design-preserving): a HIRE never extends the frozen set, so the live counter may
+//     drift ahead of it (that drift IS the staleness signal). A FIRE prunes the frozen set, so the
+//     snapshot must be re-stamped — otherwise the same version would denote two different sets.
+// ===============================================================
+section('24 round A F2: hire keeps the snapshot stale-able; fire re-stamps it (version ≡ set)')
+{
+  const N = await establish()
+  await N.callTool('vibe_v4_meeting', { agenda: 'round A 快照一致性' })
+  const s1 = await N.callTool('vibe_v4_status', {})
+  assert(!!s1.frozen && Array.isArray(s1.frozen.participants) && s1.frozen.participants.length >= 1, '★ an active consensus exposes frozen{version,participants} (additive)')
+  assert(s1.frozen.version === s1.rosterVersion, 'at freeze time the snapshot version equals the live counter')
+  assert(typeof s1.consensus.rosterVersion === 'number' && Array.isArray(s1.consensus.participants) && s1.consensus.rosterVersion === s1.frozen.version, '\u2605 F3 (absolute first, unguarded): status().consensus EXPOSES rosterVersion + participants and it equals the frozen snapshot version')
+  const v1 = s1.rosterVersion
+  await N.callTool('vibe_v4_add_member', { direction: 'round A 新增成员' })
+  const s2 = await N.callTool('vibe_v4_status', {})
+  assert(s2.rosterVersion > v1, 'hiring bumps the numeric rosterVersion (monotone)')
+  assert(s2.frozen.version === v1, '★ a HIRE leaves the frozen snapshot version untouched (its set did not change)')
+  assert(s2.frozen.participants.length === s1.frozen.participants.length, '★ …and the frozen requirement set is unchanged (frozen means frozen)')
+  assert(s2.rosterVersion > s2.frozen.version, '★ the live-vs-frozen drift remains the visible staleness signal')
+  const removed = s1.frozen.participants[0]
+  await N.callTool('vibe_v4_remove_member', { id: removed })
+  const s3 = await N.callTool('vibe_v4_status', {})
+  assert(s3.frozen.participants.indexOf(removed) === -1, '★ a FIRE prunes the frozen set (the wait is released)')
+  assert(s3.frozen.version === s3.rosterVersion && s3.frozen.version > v1, '★ F2: the pruned set carries a NEW version — no window where a changed set keeps the old version')
+}
+// ===============================================================
+// ===============================================================
+// N4. F-PROMPT: a documented 'true no-op' must be asserted on the DELIVERED prompt, not on the
+//     config path. Under formalVerify:'off' the verify prompt must carry NO formalization clause
+//     and NO forward reference to a segment that is not delivered.
+// ===============================================================
+section('N4 off: the DELIVERED verify prompt has no formalization content or dangling pointer')
+{
+  const P = await establish()
+  const off = await P.prompts('verify', 'r-1', { target: 'p-fprompt', stage: 'independent' })
+  assert(off.length > 100 && /\u9a8c\u8bc1/.test(off), '* the delivered verify prompt is non-trivial (non-vacuity: a missing/empty prompt must not pass the negations below)')
+  assert(!/\u5f62\u5f0f\u5316\u6bb5/.test(off), '* the off-mode verify prompt contains no forward reference to the formalization segment (\u5f62\u5f0f\u5316\u6bb5)')
+  assert(!/formal/.test(off), '* and no formalization content at all (no `formal` receipt clause) - the documented true no-op')
+  await P.callTool('vibe_v4_set', { formalVerify: 'encourage' })
+  const enc = await P.prompts('verify', 'r-1', { target: 'p-fprompt', stage: 'independent' })
+  assert(/Lean|formal/.test(enc), '* under encourage the delivered prompt DOES carry the formalization block (the gate is a gate, not a deletion)')
+}
 // ===============================================================
+// N5. v4 path basis - CORRECTED CONTRACT (the earlier comment here pinned the OLD, WRONG shape:
+//     it demanded a member root. v4's writers/readers live at the PROJECT ROOT: publishProgress writes
+//     Progress/<rId>/progress.md, the record tools write Propos|Methods|Subproblems/<rId>/<id>.md, and
+//     countArtifacts() scans exactly those bases under frameworkRoot(). A Members/<placeholder>/... path
+//     is therefore a path nothing scans - the realistic documented example is base + '/Propos/r-1/p-1.md'.
+//     (Named in the report as the "comment pinning old behaviour" case.)
+// ===============================================================
+section('N5 v4 member-facing paths are PROJECT-ROOT (the shape the framework scans), and no Members/ shape')
+{
+  const P = await establish()
+  const text = (await P.prompts('brainstorm', 'r-1')) + '\n' + (await P.prompts('normal', 'r-1'))
+  // INVERTED (critical correction): the framework's writer/reader live at the PROJECT ROOT
+  // (publishProgress writes Progress/<rId>/progress.md; countArtifacts scans Propos|Methods|Subproblems
+  // under frameworkRoot()). The delivered text must document THOSE paths, never Members/<x>/...
+  const decls = (text.match(/(?:^|[^A-Za-z0-9/_.-])(?:Progress|Propos|Methods|Subproblems)\/<[^>]+>\//g) || [])
+  assert(decls.length >= 4, '* every member-visible library declaration is PROJECT-ROOT relative (Progress/<you>/, Propos/<you>/, ...) - the shape the framework scans (found ' + decls.length + ')')
+  const wrongMembers = (text.match(/Members\/<[^>]+>\//g) || [])
+  assert(wrongMembers.length === 0, '* NO member-facing declaration uses the Members/<x>/ shape (the framework never scans it) - found ' + JSON.stringify(wrongMembers))
+  assert(/Progress\/<你>\/progress\.md/.test(text), '* the documented progress path matches publishProgress (Progress/<rId>/progress.md)')
+  assert(/Propos\/<你>\//.test(text) && /Methods\/<你>\//.test(text) && /Subproblems\/<你>\//.test(text), '* the documented card paths match the record tools (Propos|Methods|Subproblems/<rId>/<id>.md)')
+  // CLASS GUARD (one level above v3's): what the prompt documents must be what the code reads/scans
+  const src4 = readFileSync(fileURLToPath(new URL('../vibe-math-v4/vibe-math-v4.js', import.meta.url)), 'utf8')
+  for (const base of ['Progress', 'Propos', 'Methods', 'Subproblems']) {
+    assert(new RegExp("'" + base + "'").test(src4), '* class guard: the framework reads/scans ' + base + ' - every documented write path must map onto a scanned base')
+  }
+  assert(/['"]Members\/['"]\s*\+/.test(src4) === false, '* class guard: no code path (writer) builds a Members/<id>/... path in v4')
+}
+section('N6 four-preset path discipline (member root / prefix-note)')
+{
+  const { readFileSync } = await import('node:fs')
+  const { fileURLToPath } = await import('node:url')
+  const pick = (env, rel) => process.env[env] ? process.env[env] : fileURLToPath(new URL(rel, import.meta.url))
+  const files = {
+    v2: pick('V2_PLUGIN', '../vibe-math-v2/vibe-math-v2.js'),
+    v3: pick('V3_PLUGIN', '../vibe-math-v3/vibe-math-v3.js'),
+    v4: pick('V4_PLUGIN', '../vibe-math-v4/vibe-math-v4.js'),
+    v5: pick('V5_PLUGIN', '../vibe-math-v5/vibe-math-v5.js'),
+  }
+  const ROOT = /Members\/<[^>]+>\/(?:Progress|Propos|Methods|Subproblems)\//g
+  const LEGACY = /(?:^|[^/>])(?:Progress|Propos|Methods|Subproblems)\/<[^>]+>\//g
+  for (const k of ['v5']) {   // v5 pending vm-v5's re-verification; v4 handled explicitly below
+    const src = readFileSync(files[k], 'utf8')
+    const root = (src.match(ROOT) || []).length
+    const legacy = (src.match(LEGACY) || []).length
+    assert(root >= 4, '* ' + k + ': every member-visible library declaration carries the member root (found ' + root + ')')
+    assert(legacy === 0, '* ' + k + ': no declaration keeps the legacy project-root-relative shape (found ' + legacy + ')')
+  }
+  // v4 (critical correction): the framework writes/reads at the PROJECT ROOT - publishProgress writes
+  // Progress/<rId>/progress.md and countArtifacts scans Propos|Methods|Subproblems under frameworkRoot(),
+  // so a Members/<x>/... declaration is a path NOTHING scans.
+  {
+    const src4 = files.v4 ? readFileSync(files.v4, 'utf8') : ''
+    const decl4 = (src4.match(/(?:^|[^A-Za-z0-9/_.-])(?:Progress|Propos|Methods|Subproblems)\/<[^>]+>\//g) || [])
+    const bad4 = (src4.match(/Members\/<[^>]+>\//g) || [])
+    assert(!/Members\/<[^>]+>\//.test(src4), '* v4: NO member-facing declaration/code claim uses the Members/<x>/ shape (found ' + bad4.length + ')')
+    assert(/Progress|<rId>|progress\.md/.test(src4), '* v4: the writer/reader bases are the project-root Progress/Propos/Methods/Subproblems')
+  }
+  // v3 (v2/v3 deep review D1): the writer `applyAgentWrites` accepts ONLY Problems|Progress|Propos|Methods|Notes
+  // at the PROJECT ROOT, so a `Members/<x>/...` declaration is a write it SILENTLY DISCARDS. v3's member-facing
+  // text must therefore stay root-relative - the opposite of v4/v5, which really do have a member subtree.
+  const v3 = readFileSync(files.v3, 'utf8')
+  assert(!/Members\/<[^>]+>\//.test(v3), '* v3: no member-facing declaration keeps the Members/<x>/ shape (the writer would discard that write)')
+  const v3decl = [...v3.matchAll(/(?:^|[^/>])([A-Za-z]+)\/<[^>]+>\//g)].map((m) => m[1])
+  const WL = ['Problems', 'Progress', 'Propos', 'Methods', 'Notes']
+  const v3ok = v3decl.filter((x) => WL.indexOf(x) !== -1)
+  assert(v3ok.length >= 1, '* v3: its declarations use the project-root-relative sections the writer accepts (found ' + v3ok.length + ' of ' + JSON.stringify(v3decl) + ')')
+  // CLASS GUARD (covers v2/v3/v4/v5): whatever sections the persona/prompts tell an agent to write must be
+  // accepted by that preset's writer - this is the invariant that would have caught both D1 and the v4/v5 cases.
+  assert(/applyAgentWrites[\s\S]{0,600}?(Problems|Progress|Propos|Methods|Notes)/.test(v3), '* class guard: applyAgentWrites whitelists the sections the member-facing text names (v3)')
+  const v2 = readFileSync(files.v2, 'utf8')
+  assert(!/Members\/<[^>]+>\//.test(v2), '* v2: no Members/<x>/ shape either (anti-vacuity for the class, without over-claiming v2 has no path vocabulary)')
+  assert(/PAPER_PATH_NOTE/.test(v2) && /\u4f1a\u8bdd cwd/.test(v2) && /\u7edd\u5bf9\u524d\u7f00/.test(v2), '* v2 uses the OTHER mechanism: one PAPER_PATH_NOTE stating the session-cwd + absolute-prefix rule')
+  const uses = (v2.match(/PAPER_PATH_NOTE/g) || []).length
+  // (D3 fixed the duplicate: the note no longer belongs in the evidence ENTRY list.) Assert the
+  // STRUCTURE, not an occurrence count: defined once, appended by each member-facing material text,
+  // and never embedded in a bare data entry.
+  const noteDef = (v2.match(/const PAPER_PATH_NOTE/g) || []).length
+  assert(noteDef === 1, '* v2 defines PAPER_PATH_NOTE exactly once (found ' + noteDef + ')')
+  const noteLines = v2.split(/\r?\n/).filter((l) => l.includes('PAPER_PATH_NOTE'))
+  const embeds = noteLines.filter((l) => !/const PAPER_PATH_NOTE/.test(l) && !/[+]|push\(/.test(l))
+  assert(embeds.length === 0, '* v2 never embeds the prose rule in a bare data entry (' + JSON.stringify(embeds).slice(0, 80) + ')')
+  const bodyOf = (src, fn) => {
+    const a = src.indexOf('function ' + fn)
+    if (a < 0) return null
+    const b = src.slice(a + 10).search(/\n {2}(?:async )?function /)
+    if (b < 0) return null            // STRICT bound: no fixed-length fallback (window bleed lesson)
+    return src.slice(a, a + 10 + b)
+  }
+  // RULING (B): the index is a DATA LIST (prose-free); the delivered member-facing material that carries
+  // the paths is the digest, and it must append the note. (The other consumer, paperEmitArtifacts ->
+  // paperBuildMarkdown, produces the FINAL PAPER ARTIFACT for humans, not a member prompt.)
+  assert(!/PAPER_PATH_NOTE/.test(bodyOf(v2, 'paperEvidenceIndex') || ''), '* v2: the evidence-index DATA LIST embeds no prose rule')
+  assert(/PAPER_PATH_NOTE/.test(bodyOf(v2, 'buildPaperDigest') || ''), '* v2: the delivered digest material appends PAPER_PATH_NOTE')
+  assert(bodyOf(v2, 'buildPaperDigest') !== null && bodyOf(v2, 'paperEvidenceIndex') !== null, '* v2: both windows are bounded strictly (no fixed-length fallback)')
+}
+section('N7 delivered prompts carry no labelled-but-empty slot (proposer/agenda/target)')
+{
+  const P = await establish()
+  const txt = await P.prompts('verify', 'r-1', { target: 'p-nopowner', stage: 'independent' })
+  assert(txt.length > 100 && /verifying object p-nopowner/.test(txt), '* the delivered verify prompt is non-trivial and names the target (non-vacuity: an empty prompt must not pass below)')
+  assert(!/\u63d0\u51fa\u8005\s*\uff09/.test(txt), '* no labelled-but-empty proposer slot in the delivered frame (\u63d0\u51fa\u8005 + ) )')
+  assert(!/agenda:\s*[)\uff09]/.test(txt), '* no labelled-but-empty agenda slot in the delivered frame')
+  // protocol 搂9 (path-alias family): resolve the plugin ONCE from the loader's own URL, read THAT, and
+  // assert the read path equals the V4_PLUGIN seam when it is set - a guard must never print one path
+  // and read another.
+  const _pu = pluginUrl()                                   // the loader's own resolution (seam-aware)
+  const _href = typeof _pu === 'string' ? _pu : String(_pu && _pu.href ? _pu.href : _pu)
+  const _loaderPath = _href.indexOf('file:') === 0 ? fileURLToPath(new URL(_href.split('?')[0])) : String(_href).split('?')[0]
+  if (process.env.V4_PLUGIN) {
+    const _a = _loaderPath.replace(/\\/g, '/').toLowerCase()
+    const _b = String(process.env.V4_PLUGIN).replace(/\\/g, '/').toLowerCase()
+    assert(_a === _b, '* N10 reads the SAME file the loader imports (readPath === V4_PLUGIN seam): ' + _a + ' vs ' + _b)
+  }
+  assert(/String\(vs\.targetOwner\|\|''\)\.trim\(\)\?/.test(PLUGIN_SRC()), '* the proposer segment is assembled ONLY when a value exists (source-level: the office is never invented)')
+}
+section('N8 the meeting frame\'s relay claim matches reality (no promise of speeches that do not exist)')
+{
+  const P = await establish()
+  const noPrior = await P.prompts('meeting', 'r-1')
+  assert(noPrior.length > 100 && /A meeting is in progress/.test(noPrior), '* the meeting frame is non-trivial (non-vacuity)')
+  assert(!/\u4e0b\u9762\u5df2\u6709\u4eba\u53d1\u8a00/.test(noPrior), '* with NO prior statements the frame does not claim that others have spoken (\u4e0b\u9762\u5df2\u6709\u4eba\u53d1\u8a00)')
+  assert(/\u5e76\u884c\u72ec\u7acb\u53d1\u8a00/.test(noPrior), '* …instead it states the real semantics: this round is parallel independent statements')
+  assert(/\(prior\?'\\n\u8fd9\u662f\u4e00\u573a\u771f\u5b9e\u8ba8\u8bba/.test(PLUGIN_SRC()), '* the relay claim is gated on prior existing (source-level)')
+  assert(/\(prior\?\(\'\\n\\n### \u5df2\u6709\u53d1\u8a00/.test(PLUGIN_SRC()), '* the forwarded-speech block is still delivered whenever prior exists')
+}
+section('N9 behavioural: a write to the DOCUMENTED path is counted by countArtifacts (auto-meeting basis)')
+{
+  const P = await establish()
+  const st0 = await P.callTool('vibe_v4_status', {})
+  assert(typeof st0.artifactCount === 'number', '* status exposes artifactCount (the auto-meeting basis) - keys: ' + JSON.stringify(Object.keys(st0).slice(0, 14)))
+  const rec = await P.callTool('vibe_v4_record_proposition', { id: 'p-docpath', statement: '文档路径行为证明', value: 0.5, motive: 'm', p: 0.5 }, P.resAgent(P.childOf('r-1')))
+  assert(rec.ok === true, '* a member card is recorded through the tool (returned ' + JSON.stringify(rec).slice(0, 120) + ')')
+  const st1 = await P.callTool('vibe_v4_status', {})
+  assert(st1.artifactCount > st0.artifactCount, '* the card written to the DOCUMENTED path (Propos/<id>/<id>.md at the project root) IS counted by countArtifacts (' + st0.artifactCount + ' -> ' + st1.artifactCount + ')')
+  const files = P.host && P.host.fsWrites ? P.host.fsWrites.map((w) => String(w.path || '')).join(',') : ''
+  assert(files.indexOf('Members/') === -1, '* no write landed under Members/ (the shape nothing scans) - writes: ' + files.slice(0, 160))
+}
+section('N10 G-7 class guard: agent-facing compaction takes the AGENT-LOCAL instance')
+{
+  const { readFileSync } = await import('node:fs')
+  const { fileURLToPath } = await import('node:url')
+  assert(/function compactionForAgent\(/.test(PLUGIN_SRC()), '* v4 defines compactionForAgent (the agent-local accessor)')
+  // F2 (HIGH): a named, BOUNDED anchor. The old window ran to the next two-space function (109,191 chars)
+  // and swallowed unrelated code, which is why a line-located mutant escaped unnoticed.
+  const CALL = 'const compaction = compactionForAgent(agent)'
+  const at = PLUGIN_SRC().indexOf(CALL)
+  assert(at > 0, '* the agent-facing compaction call exists verbatim (anchor: ' + CALL + ')')
+  const _ls = PLUGIN_SRC().lastIndexOf('\n', at)
+  const _le = PLUGIN_SRC().indexOf('\n', at)
+  const win = PLUGIN_SRC().slice(_ls, _le > 0 ? _le : at + 200)
+  assert(win.length <= 400, '* the inspected window is BOUNDED (the call line only; got ' + win.length + ')')
+  assert(win.indexOf(CALL) !== -1, '* the window really contains the agent-facing call')
+  if (process.env.V4_DEBUG) { const _lp = (function(){ try { const u = pluginUrl(); const h = typeof u === 'string' ? u : String(u && u.href ? u.href : u); return h.indexOf('file:') === 0 ? fileURLToPath(new URL(h.split('?')[0])) : h.split('?')[0] } catch (e) { return 'ERR:' + e.message } })(); console.log('  [N10-diag] read=' + _lp + ' | seam=' + String(process.env.V4_PLUGIN || '(none)') + ' | srcHasAnchor=' + (PLUGIN_SRC().indexOf(CALL) !== -1) + ' | win=' + win.length) }
+  assert(!/compactionOf\(\)/.test(win), '* the agent-facing path does NOT call the host-root compactionOf() (a realm never falls back)')
+}
 console.log('')
+section('N11 F-4c: a failed mkdir is NAMED exactly once (deferred/distorted diagnosis fixed)')
+{
+  const h = await mount()
+  const seen = []
+  const realErr = console.error
+  console.error = (...a) => { seen.push(a.map(String).join(' ')); realErr(...a) }   // protocol 搂6.4: capture AND still name a red
+  shellMkdirExit = 1
+  try {
+    await h.callTool('vibe_v4_start', { problem: 'F-4c mkdir 失败可见', residentCount: 1 })
+    const mk = shellCalls.filter(s => /New-Item|^mkdir -p /.test(String(s)))
+    assert(mk.length >= 1, '* N11: the mkdir script was actually issued (shellCalls=' + shellCalls.length + ', mkdir=' + mk.length + ')')
+    const warned = seen.filter(l => /ensureDirs: mkdir failed \(exit 1\) under/.test(l))
+    assert(warned.length === 1, '* N11: the mkdir failure is NAMED exactly once (matched=' + warned.length + ' of ' + seen.length + ' captured stderr lines)')
+  } finally { console.error = realErr; shellMkdirExit = 0 }
+}
+
+section('N13 F1 invariant guards: membership predicates + roster-only ballots (source level)')
+{
+  const srcF1 = PLUGIN_SRC()
+  const bodyOfF1 = (name) => { const a = srcF1.indexOf('function ' + name + '('); if (a < 0) return null; let d = 0; for (let i = a; i < srcF1.length; i++) { const ch = srcF1[i]; if (ch === '{') d++; else if (ch === '}') { d--; if (d === 0) return srcF1.slice(a, i + 1) } } return null }
+  const cvrF1 = bodyOfF1('continueVerifyRound'), fvF1 = bodyOfF1('finalizeVerify')
+  assert(!!cvrF1 && !!fvF1, '* F1/1 both consensus functions are found (bounded, brace-balanced windows)')
+  assert(cvrF1.length < 20000 && fvF1.length < 20000, '* F1/1 the inspected windows are BOUNDED (cvr=' + cvrF1.length + ', fv=' + fvF1.length + ') - a runaway window is itself a failure')
+  const MEMF1 = 'ids.every(id=>vs.verdicts[id]!==undefined)'
+  assert(cvrF1.indexOf(MEMF1) !== -1, '* F1/1 continueVerifyRound requires MEMBERSHIP of the frozen ids')
+  assert(fvF1.indexOf(MEMF1) !== -1, '* F1/1 finalizeVerify uses the SAME membership predicate (the two views cannot disagree)')
+  assert(!/Object\.keys\(vs\.verdicts\)\.length>=/.test(fvF1), '* F1/1 finalizeVerify does NOT use the count-only predicate (that is the F1 regression: a non-roster ballot could satisfy it)')
+  assert(/const vals=ids\.filter\(id=>vs\.verdicts\[id\]!==undefined\)\.map\(id=>vs\.verdicts\[id\]\)/.test(fvF1), '* F1/1 finalizeVerify takes `vals` ONLY from the frozen ids (never Object.values of the live map)')
+  assert(/_inRoster\s*=\s*!Array\.isArray\(verifyState\.rosterSnapshot\)\s*\|\|\s*verifyState\.rosterSnapshot\.indexOf\(r\.rId\)!==-1/.test(srcF1), '* F1/2 the ballot recording site is guarded by the FROZEN roster (verdicts keys are a subset of rosterSnapshot)')
+  const gF1 = srcF1.indexOf('if(!_inRoster)'), aF1 = srcF1.indexOf('verifyState.verdicts[r.rId]={prob:p')
+  assert(gF1 !== -1 && aF1 > gF1 && (aF1 - gF1) < 400, '* F1/2 the verdict assignment sits INSIDE that guard (distance=' + (aF1 - gF1) + ' chars)')
+}
+
+section('N15 F-6 site 4: a failed compaction is NAMED exactly once (realCompact -> onResidentEnd)')
+{
+  const h = await establish()
+  const seen = []
+  const realErr = console.error
+  console.error = (...a) => { seen.push(a.map(String).join(' ')); realErr(...a) }
+  try {
+    compactionFails = true
+    // the turn end is only processed for a BUSY resident (`if(!busy.delete(r.rId)) return`), so
+    // wake it first, exactly like the suite's workWake() helper does.
+    const before = h.followups.length
+    await h.callTool('vibe_v4_message', { to: 'r-1', content: '请继续推进。' })
+    for (let i = 0; i < 300 && h.followups.length === before; i++) await sleep(10)
+    const cid = h.followups[h.followups.length - 1].childId
+    assert(!!cid, '* N15/4 the resident was woken so the turn end reaches onResidentEnd (childId=' + cid + ')')
+    h.fireEnd(cid, { summary: '推进本轮。', solved: false, contextPct: 20 })
+    for (let i = 0; i < 80 && !seen.some(l => /realCompact: the compaction call failed/.test(l)); i++) await sleep(10)
+    const w = seen.filter(l => /realCompact: the compaction call failed/.test(l))
+    assert(w.length === 1, '* N15/4 realCompact: a failed compaction is NAMED exactly once (matched=' + w.length + ' of ' + seen.length + ' stderr within 800ms)')
+    assert(/NOT compacted/.test(w[0] || ''), '* N15/4 the warning STATES THE CONSEQUENCE (context pressure was NOT compacted)')
+  } finally { console.error = realErr; compactionFails = false }
+}
+
+section('N14 F2 compaction policy: policy verb only, re-anchor only after a REAL compaction (source level)')
+{
+  const srcC = PLUGIN_SRC()
+  const aC = srcC.indexOf('async function realCompact(')
+  assert(aC > 0, '* F2/a realCompact is found through the seam')
+  let dC = 0, eC = aC
+  for (let i = aC; i < srcC.length; i++) { const ch = srcC[i]; if (ch === '{') dC++; else if (ch === '}') { dC--; if (dC === 0) { eC = i; break } } }
+  const bodyC = srcC.slice(aC, eC + 1)
+  assert(bodyC.length > 100 && bodyC.length < 4000, '* F2/a the inspected window is BOUNDED (' + bodyC.length + ' chars) - a runaway window is itself a failure')
+  assert(bodyC.indexOf('compactIfNeeded(agent, ') !== -1, '* F2/a realCompact calls the POLICY verb compactIfNeeded (threshold-driven)')
+  assert(bodyC.indexOf('compactNow(') === -1, '* F2/a realCompact contains NO compactNow( call: a host offering the forcing verb must NOT be forced (user ruling)')
+  assert(!/const force\s*=/.test(bodyC), '* F2/a the capability-based forcing branch is GONE, not merely deprioritised')
+  assert(/const didCompact\s*=/.test(bodyC), '* F2/a the re-anchor is gated on didCompact (evidence that the policy call ACTUALLY compacted)')
+  assert(/if\(didCompact\)\{/.test(bodyC), '* F2/a and the gate is the if(didCompact){ branch (mutant: if(true){ => this reddens)')
+}
+
+section('N17 F-5 fence-root drift: containment, no-op boundary, one-shot naming both roots')
+{
+  const h = await establish()
+  const seen = []
+  const realErr = console.error
+  console.error = (...a) => { seen.push(a.map(String).join(' ')); realErr(...a) }
+  const drift = () => seen.filter(l => /fence root does not CONTAIN this session workspace/.test(l))
+  // NOTE: case (0) is 'no sandboxPolicy SERVICE'; case 1b is 'service present, root uninterpretable'.
+  const ws = () => String(h.WS).replace(/\\/g, '/')
+  try {
+    const r1 = await h.callTool('vibe_v4_publish_progress', { content: 'F-5 case 1' }, h.resAgent(h.childOf('r-1')))
+    await sleep(50)
+    assert(drift().length === 0, '* F-5/i NO sandboxPolicy SERVICE at all => the policy path never runs and NO warning appears (drift=' + drift().length + '; the uninterpretable-root no-op is case 1b)')
+    assert(r1 && r1.ok !== false, '* F-5/i and getPolicy() still returns a usable policy (the write went through)')
+    // F-5/1b: a policy SERVICE that resolves to a shape with NO interpretable root ({allow,deny}) -
+    // the helper IS invoked and must stay silent (uninterpretable => no-op, today's behaviour).
+    seen.length = 0   // F-5: observe ONLY this case's window (no cascade from earlier cases)
+    sandboxNoRoot = true
+    const r1b = await h.callTool('vibe_v4_publish_progress', { content: 'F-5 case 1b' }, h.resAgent(h.childOf('r-1')))
+    await sleep(50)
+    assert(drift().length === 0, '* F-5/1b an UNINTERPRETABLE resolved policy ({allow,deny}) produces NO warning (documented no-op, not a dead branch) (' + drift().length + ')')
+    const w1b = await h.callTool('vibe_v4_status', {})
+    assert(r1b && r1b.ok !== false && !!w1b, '* F-5/1b getPolicy() still RESOLVES for that shape (the write succeeds, no throw path)')
+    // F-5/1c: the session cwd is UNKNOWN (no cwd on the captured root agent) and the policy exposes no
+    // top-level root, so workspaceRoot() is `'.'`; resolve({session}) still yields a root. The `.` clause
+    // of the product guard is the ONLY reason this stays silent - a mutant that warns on an unknown cwd
+    // reddens here by name.
+    sandboxNoRoot = false
+    sandboxDriftRoot = null
+    sandboxUnknownCwd = true
+    const seenC = []
+    const realErrC = console.error
+    console.error = (...a) => { seenC.push(a.map(String).join(' ')); realErrC(...a) }
+    let hc = null
+    try {
+      // FOUNDING under an unknown cwd: the founding writes go through writeTextAbs -> getPolicy(),
+      // so the window below both reaches the helper and proves it stayed silent
+      hc = await mount()
+      hc.resetResolveCalls()
+      await hc.callTool('vibe_v4_start', { problem: 'F-5 case 1c', residentCount: 1 })
+      await sleep(80)
+    } finally { console.error = realErrC; sandboxUnknownCwd = false }
+    const driftC = seenC.filter(l => /fence root does not CONTAIN this session workspace/.test(l))
+    assert(driftC.length === 0, '* F-5/1c an UNKNOWN session cwd stays SILENT (the `.` guard: drift=' + driftC.length + ')')
+    assert(hc.resolveCalls() >= 1, '* F-5/1c LIVENESS: the helper really ran with an unknown cwd (resolve calls=' + hc.resolveCalls() + ', policy queries=' + hc.policyQueries() + '), so the silence is not an unreached branch')
+    sandboxNoRoot = false
+    // (iv) agreeing roots => silence (anti-vacuity)
+    seen.length = 0   // F-5: observe ONLY this case's window
+    sandboxDriftRoot = ws()
+    await h.callTool('vibe_v4_publish_progress', { content: 'F-5 case 4' }, h.resAgent(h.childOf('r-1')))
+    await sleep(50)
+    assert(drift().length === 0, '* F-5/iv an AGREEING resolved root produces NO warning (not vacuous)')
+    // (iii) containment: an ANCESTOR root is legitimate => silence
+    seen.length = 0   // F-5: observe ONLY this case's window
+    sandboxDriftRoot = ws().replace(/\/[^/]+$/, '')
+    await h.callTool('vibe_v4_publish_progress', { content: 'F-5 case 3' }, h.resAgent(h.childOf('r-1')))
+    await sleep(50)
+    assert(drift().length === 0, '* F-5/iii a root that CONTAINS the session workspace is accepted (no per-session false alarm)')
+    // (ii) real drift => exactly one named warning naming BOTH sides
+    seen.length = 0   // F-5: observe ONLY this case's window
+    sandboxDriftRoot = ws() + '/somewhere-else'
+    await h.callTool('vibe_v4_publish_progress', { content: 'F-5 case 2' }, h.resAgent(h.childOf('r-1')))
+    await sleep(50)
+    // a SECOND drift-triggering resolution: the one-shot must keep the warning at exactly one
+    await h.callTool('vibe_v4_publish_progress', { content: 'F-5 case 2b' }, h.resAgent(h.childOf('r-1')))
+    await sleep(50)
+    const w = drift()
+    assert(w.length === 1, '* F-5/ii the drift is NAMED exactly once (matched=' + w.length + ' of ' + seen.length + ' stderr lines)')
+    assert(/resolved=/.test(w[0] || '') && /session=/.test(w[0] || ''), '* F-5/ii the warning names BOTH the resolved root and the session workspace')
+  } finally { console.error = realErr; sandboxDriftRoot = null; sandboxNoRoot = false }
+}
+
+
+section('N18 F-6: a failed current-project marker write is NAMED exactly once')
+{
+  // PRE-START: configure() refuses while a run is live and returns BEFORE writeCurrentProject
+  // (measured with establish(): the injection never fired), so this section mounts without starting.
+  const h = await mount()
+  const seen = []
+  const realErr = console.error
+  console.error = (...a) => { seen.push(a.map(String).join(' ')); realErr(...a) }
+  const hits = () => seen.filter((l) => /current-project marker was NOT persisted/.test(l))
+  try {
+    // ONE injected failure, only for the `.current` marker write (path-anchored, existing hook)
+    fsWriteFailPred = (p) => /[\\/]\.current$/.test(String(p))
+    fsWriteFailOnce = true
+    await h.callTool('vibe_v4_configure', { project: 'n18-proj' })
+    await sleep(50)
+    assert(hits().length === 1, '* N18 the failed `.current` write is NAMED exactly once (matched=' + hits().length + ' of ' + seen.length + ' stderr lines)')
+    assert(/next session may load the previous project/.test(hits()[0] || ''), '* N18 the warning STATES THE CONSEQUENCE (the next session may load the previous project)')
+    // anti-vacuity: a SUCCESSFUL marker write stays silent
+    fsWriteFailPred = null
+    fsWriteFailOnce = false
+    seen.length = 0
+    await h.callTool('vibe_v4_configure', { project: 'n18-proj-2' })
+    await sleep(50)
+    assert(hits().length === 0, '* N18 a SUCCESSFUL marker write is silent (the assertion is not vacuous)')
+  } finally { console.error = realErr; fsWriteFailPred = null; fsWriteFailOnce = false }
+}
+
+
+section('N20-3b rebuildLeanLibIndexes: a failed INDEX WRITE is NAMED once (covers all six callers)')
+{
+  // ③ callsite enumeration (measured at this revision) and verdicts:
+  //   · settleLeanJob (:893)           - own try/catch naming (in-suite capture = measured boundary)
+  //   · writeLeanLibIndexesSafe (:1006) - boundary: cold-recovery convenience, rebuilt again later
+  //   · leanArchive def/proof/blocked (:1394/:1438/:1452) - silent because the FUNCTION swallowed
+  //   · the lean_lib tool (:4139)      - silent for the same reason (measured: ok:true + counts)
+  //   => ONE fix inside the function covers all six; this asserts the naming.
+  const h = await mount()
+  const seen = []
+  const realErr = console.error
+  console.error = (...a) => { seen.push(a.map(String).join(' ')); realErr(...a) }
+  const hits = () => seen.filter(l => /rebuildLeanLibIndexes: the Lean library index could NOT be written/.test(l))
+  try {
+    // (a) anti-vacuity: a healthy rebuild is SILENT
+    await h.callTool('vibe_v4_lean_lib', {})
+    await sleep(30)
+    assert(hits().length === 0, '* N20-3b a healthy index rebuild is silent (the case is not vacuous)')
+    // (b) one injected index-write failure => exactly one NAMED warning WITH its consequence
+    fsWriteFailPred = (p) => /(?:Lib|Proved)[\\/]Index\.md$/i.test(String(p))
+    fsWriteFailOnce = true
+    const r = await h.callTool('vibe_v4_lean_lib', {})
+    await sleep(30)
+    assert(hits().length === 1, '* N20-3b a failed index write is NAMED exactly once (matched=' + hits().length + ' of ' + seen.length + ' stderr lines)')
+    assert(/STALE until the next successful rebuild/.test(hits()[0] || ''), '* N20-3b the warning STATES THE CONSEQUENCE (the index is stale until the next successful rebuild)')
+    assert(!!r && r.ok === true, '* N20-3b and the tool still answers with the scanned counts (the naming is additive, not a new failure mode)')
+  } finally { console.error = realErr; fsWriteFailPred = null; fsWriteFailOnce = false }
+}
+
 console.log('passed=' + passed + ' failed=' + failed)
 if (failed) { console.error('FAILURES:'); for (const f of failures) console.error('  - ' + f); process.exit(1) }
 console.log('ALL GREEN')