dsh-vibe-math 2.7.0 → 2.7.2

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

@@ -270,6 +270,24 @@ async function proposeAndVote(h, target, opts = {}) {
   // The verification may only have been QUEUED by the proposal round; finish it.
   return await settleVerify(h, opts.plan || (() => (opts.verdict === undefined ? 1 : opts.verdict)))
 }
+/**
+ * Start a verification and KEEP IT IN FLIGHT (the first half of `proposeAndVote`): record a card, have
+ * r-1 propose verifying it, and stop driving as soon as the verify view is ACTIVE. Note the trap:
+ * `verifyInProgress` is already true while the verification is merely QUEUED, so `consensus.kind`
+ * is the only reliable "it is really running" signal.
+ */
+async function startVerifyOnly(h, target) {
+  const card = { id: target, title: target, statement: '待验证对象 ' + target, prob: 0.8, value: 0.6, motivation: 'm' }
+  await h.callTool('vibe_v4_record_proposition', card, h.resAgent(h.childOf('r-1')))
+  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)
+  await drive(h, () => ({ summary: '提议验证 ' + target + '。', solved: false, propose_verify: target, contextPct: 20 }), async () => {
+    const s = await h.callTool('vibe_v4_status', {})
+    return !!(s.consensus && s.consensus.kind === 'verify')
+  })
+  return await h.callTool('vibe_v4_status', {})
+}
 /** Wake exactly the given resident with an ordinary work round and return that wake. */
 async function workWake(h, rId) {
   const before = h.followups.length
@@ -1479,6 +1497,75 @@ section('18 every daily-line injection site (coreRules/normal/heartbeat) obeys t
   await N.callTool('vibe_v4_set', { formalVerify: 'off', leanInitiative: 'normal' })
 }
 
+// ===============================================================
+// 22. cross-preset audit P0 (v4 station): the member-visible library text must state that the
+//     residents' file tools resolve against the SESSION CWD, so the listed sub-paths must be used
+//     with the ABSOLUTE prefix (and computation artifacts via receipt.scriptAbs / receipt.cwd).
+// ===============================================================
+section('22 audit P0: member-facing paths carry the session-cwd / absolute-prefix instruction')
+{
+  const N = await establish()
+  const texts = [await N.prompts('brainstorm', 'r-1'), await N.prompts('coreRules'), await N.prompts('normal', 'r-1')]
+  const ok = texts.filter((t) => t.indexOf('会话 cwd') !== -1 && t.indexOf('绝对前缀') !== -1)
+  assert(ok.length >= 1, '★ the member-visible library text says file tools resolve against the SESSION CWD and that listed paths need the ABSOLUTE prefix (found in ' + ok.length + '/3 variants)')
+  assert(ok.some((t) => t.indexOf('receipt.scriptAbs') !== -1 || t.indexOf('receipt.cwd') !== -1), '★ …and names the absolute receipt field (receipt.scriptAbs / receipt.cwd) for computation artifacts')
+}
+
+// ===============================================================
+// 23. cross-preset audit P1 (v4 stations): a member-facing not-found must be diagnosable — code +
+//     live roster status + an actionable next step — including `removeMember` (previously a bare
+//     {ok:false}) and the not-yet-started case.
+// ===============================================================
+section('23 audit P1: member-facing not-found carries code + status + next')
+{
+  const N = await establish()
+  const wrong = await N.callTool('vibe_v4_send_message', { to: 'r-404', content: 'hi' }, N.resAgent(N.childOf('r-1')))
+  assert(wrong.ok === false && wrong.code === 'V4_NO_SUCH_RESIDENT' && !!wrong.next && !!wrong.next.tool, '★ wrong resident id ⇒ code V4_NO_SUCH_RESIDENT + next{tool} (not a bare message)')
+  assert(wrong.status && wrong.status.residentCount >= 1 && wrong.status.running === true, '★ …plus LIVE roster status, so "wrong id" is distinguishable from "not started"')
+  const kicked = await N.callTool('vibe_v4_remove_member', { id: 'r-404' })
+  assert(kicked.ok === false && kicked.code === 'V4_NO_SUCH_RESIDENT' && !!kicked.next && kicked.next.tool === 'vibe_v4_remove_member', '★ vibe_v4_remove_member {id:r-404} ⇒ code + next naming that tool (was a bare {ok:false})')
+  const fresh = await mount()
+  const notStarted = await fresh.callTool('vibe_v4_publish_progress', { content: 'x' })
+  assert(notStarted.ok === false && notStarted.code === 'V4_NO_SUCH_RESIDENT' && !!notStarted.next && !!notStarted.status && notStarted.status.running === false, '★ run not started ⇒ code + next + status.running=false')
+}
+
+// ---------- D4 cross-view: mid-verify hire/fire must not split the views ----------
+section('D4 cross-view: one frozen participant set, seen identically by every view')
+{
+  const h = await establish()
+  const st = await startVerifyOnly(h, 'p-d4')
+  assert(st.consensus && st.consensus.kind === 'verify', 'precondition: an ACTIVE verification for the cross-view check (' + JSON.stringify({ c: st.consensus && st.consensus.kind, ip: st.verifyInProgress }) + ')')
+  const c0 = st.consensus
+  const rp0 = await h.callTool('vibe_v4_report', {})
+  const rv0 = rp0.verify
+  assert(Array.isArray(st.frozenParticipants) && rv0, 'the frozen participant set and the report() verify view are both exposed')
+  assert(c0.expected === st.frozenParticipants.length, '★ consensus.expected === the frozen participant set size')
+  assert(Number(String(rv0.voted).split('/')[1]) === c0.expected, '★ the two views agree on the DENOMINATOR (status().consensus.expected vs report().verify k/N)')
+  assert(rv0.rosterVersion === c0.rosterVersion && c0.rosterVersion === st.rosterVersion, '★ both views (and status) report the SAME rosterVersion')
+  // HIRE mid-verify: the newcomer must NOT join the frozen set (that is what freezing means).
+  const hire = await h.callTool('vibe_v4_add_member', { direction: 'D4 cross-view assertion' })
+  const st2 = await h.callTool('vibe_v4_status', {})
+  const rv2 = (await h.callTool('vibe_v4_report', {})).verify
+  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(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,
+    '★ …while status().rosterVersion is the LIVE counter and has moved past the snapshot (staleness is visible)')
+  // FIRE mid-verify: the frozen set is pruned so the in-flight verification can still conclude.
+  if (hire && hire.ok && hire.id) await h.callTool('vibe_v4_remove_member', { id: hire.id })
+  const st3 = await h.callTool('vibe_v4_status', {})
+  const rv3 = (await h.callTool('vibe_v4_report', {})).verify
+  assert(st3.consensus.expected === st3.frozenParticipants.length && Number(String(rv3.voted).split('/')[1]) === st3.consensus.expected && rv3.rosterVersion === st3.consensus.rosterVersion,
+    '★ after a mid-verify FIRE the two views STILL agree (the frozen set was pruned together)')
+  assert(st3.frozenParticipants.indexOf(hire && hire.id) === -1, '★ the removed member is not in the frozen set any more (pruned on removal)')
+  // …and the verification really does conclude after that churn (T26/T31 contract).
+  await settleVerify(h, () => 1)
+  const st4 = await h.callTool('vibe_v4_status', {})
+  assert(st4.verifyInProgress === false, '★ the mid-verify hire/fire did NOT prevent the verification from concluding')
+}
+
 // ===============================================================
 console.log('')
 console.log('passed=' + passed + ' failed=' + failed)

package/tests/helpers/math-computation-fake-seam.mjs

@@ -38,6 +38,18 @@ export function makeFakeHost(opts = {}) {
     exit: opts.exit === undefined ? 0 : opts.exit,
     hang: !!opts.hang,
     hangProbe: !!opts.hangProbe,
+    versionProbeFails: !!opts.versionProbeFails,
+    // round-7: the real host intermittently answers a spawn with NULL early in a session. The first
+    // `nullSpawnTimes` spawns return null so a test can prove the retry recovers from it.
+    nullSpawnTimes: Number(opts.nullSpawnTimes) || 0,
+    // round-7 (live root cause): the real host answers a spawn whose cwd does NOT exist with
+    // `spawned:true, exit:null` (retries cannot help). `projectRoot` can be pointed at a
+    // non-existent path to emulate a FRESH workspace.
+    projectRoot: opts.projectRoot || '/fake/project',
+    freshRoot: opts.projectRoot || null,
+    // round-7: null answers ONLY for package probes (classify === 'packages'), so a test can isolate
+    // "the precheck could not run" from "the engine could not be probed".
+    packageProbeNullTimes: Number(opts.packageProbeNullTimes) || 0,
     stdoutBytes: opts.stdoutBytes || 0,
     argError: opts.argError || null,
     probeCalls: 0,
@@ -56,9 +68,9 @@ export function makeFakeHost(opts = {}) {
       state.registrations.push({ name, description, parameters, handler })
     },
     params: () => (typeof opts.params === 'function' ? opts.params() : (opts.params || {})),
-    projectRoot: () => opts.root || FAKE_ROOT,
+    projectRoot: () => state.freshRoot || opts.root || FAKE_ROOT,
     designator: opts.designator || 'vibe-math-v2',
-    writeText: async (rel, text) => { files.set(String(rel).replace(/\\/g, '/'), String(text)); return true },
+    writeText: async (rel, text) => { files.set(String(rel).replace(/\\/g, '/'), String(text)); state.rootCreated = true; return true },
     // Optional capability flag (INTERFACE-FREEZE §4): a host that knows it has no subprocess service
     // says so, and the module reports MATH_NO_SUBPROCESS instead of a misleading ENGINE_NOT_FOUND.
     hasSubprocess: ('hasSubprocess' in opts) ? (() => opts.hasSubprocess) : undefined,
@@ -72,10 +84,18 @@ export function makeFakeHost(opts = {}) {
       if (typeof opts.listDir === 'function') return opts.listDir(rel)
       return (opts.listDir || []).slice()
     }) : undefined,
+    // round-7 (fix 2): OPTIONAL bundled-runtime discovery. `runtimeRoots` are absolute roots and
+    // `absTree` maps an absolute directory to its entries, so a test can fake DSH's layout
+    // (`<root>/dsh-runtimes/<tree>/dependencies/python/python.exe`).
+    runtimeRoots: ('runtimeRoots' in opts) ? (async () => (opts.runtimeRoots || [])) : undefined,
+    listDirAbs: opts.absTree ? (async (abs) => (opts.absTree[String(abs).replace(/\\/g, '/')] || [])) : undefined,
     resolveExecutable: async (cmd) => {
       if (opts.resolveThrows) throw new Error('resolve failed: ' + cmd)
       const raw = String(cmd)
       const base = raw.split(/[\\/]/).pop()
+      // round-6 (B): an explicit path map lets a test place the interpreter in a conda-style
+      // directory or next to a `uv` binary - the manager dispatch reads those facts.
+      if (opts.resolveMap && Object.prototype.hasOwnProperty.call(opts.resolveMap, base)) return opts.resolveMap[base]
       // A caller-supplied path (engine='cli') is accepted as-is: that is the whole point of the
       // escape hatch - the tool only has to resolve the command, not know the engine.
       if (raw.indexOf('/') !== -1 || raw.indexOf('\\') !== -1) return raw
@@ -85,10 +105,18 @@ export function makeFakeHost(opts = {}) {
       return '/fake/bin/' + base
     },
     spawn: async ({ argv, cwd, timeoutMs, stdoutCap, stderrCap }) => {
+      if (state.nullSpawnTimes > 0) { state.nullSpawnTimes--; state.spawns.push({ argv: argv.slice(), cwd, timeoutMs, stdoutCap, stderrCap, nullSpawn: true }); return null }
       state.spawns.push({ argv: argv.slice(), cwd, timeoutMs, stdoutCap, stderrCap })
+      // Emulate the real host: a spawn whose cwd does not exist answers with exit:null. Note the
+      // host's writeText creates parent directories (writeFileAtomic), so a RUN (which writes the
+      // receipt first) legitimately makes the project root exist before it spawns.
+      if (state.freshRoot && !state.rootCreated && String(cwd) === String(state.freshRoot)) return { exit: null, timedOut: false, killed: false, ms: 130, stdout: '', stderr: '' }
       const kind = classify(argv)
+      if (kind === 'packages' && state.packageProbeNullTimes > 0) { state.packageProbeNullTimes--; state.spawns[state.spawns.length - 1].nullSpawn = true; return null }
       if (kind === 'version') {
         if (state.hangProbe) return { exit: null, timedOut: true, killed: true, ms: timeoutMs, stdout: '', stderr: '' }
+        // round-7: a DETERMINISTIC probe failure (engine resolved, probe exits non-zero, no version).
+        if (state.versionProbeFails) return { exit: 1, timedOut: false, killed: false, ms: 5, stdout: '', stderr: 'probe boom' }
         const exeName = String(argv[0] || 'engine').split(/[\\/]/).pop()
         return { exit: 0, timedOut: false, killed: false, ms: 5, stdout: exeName + ' ' + state.version + '\n', stderr: '' }
       }