dsh-vibe-math 2.7.0 → 2.7.1

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

@@ -31,10 +31,14 @@
 import { mkdtempSync, rmSync, existsSync, readFileSync, readdirSync, writeFileSync, statSync, mkdirSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join, dirname, isAbsolute, resolve as pathResolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
+// V2_PLUGIN may be a REPO-RELATIVE path or an ABSOLUTE one (a mutant copy outside the repo, e.g. a
+// temp dir). The previous `new URL('file:///' + path)` form only worked for drive-qualified Windows
+// paths and made out-of-repo variants impossible; this is the same isAbsolute-aware resolution the
+// `math-computation-v*` suites use. Default behaviour (env var unset) is unchanged.
 const PLUGIN = process.env.V2_PLUGIN
-  ? new URL('file:///' + String(process.env.V2_PLUGIN).replace(/\\/g, '/'))
+  ? pathToFileURL(isAbsolute(process.env.V2_PLUGIN) ? process.env.V2_PLUGIN : join(dirname(fileURLToPath(import.meta.url)), '..', process.env.V2_PLUGIN))
   : new URL('../vibe-math-v2/vibe-math-v2.js', import.meta.url)
 // 纯函数测试面（__testHelpers）：参数归一化/搜索路径计划/哈希/指纹都从这里守卫。
 const MOD = await import(PLUGIN.href)
@@ -1568,6 +1572,70 @@ section('15d Lean 增量 + 异步（spec §1–§4 + 修订 §1–§5）：参
   await wOffEager.call('vibe_math_pause', {})
 }
 
+// ---------- 15e. round-2 lens-1 RUNTIME: the initiative axis is injected at EVERY site ----------
+// Three injection sites with three different shapes (explorer / rederive / solver). The static [sites]
+// check can only see that the producer call is not textually gated; THIS section proves the actual
+// prompt text of each site: (1) formalVerify:'off' + leanInitiative:'eager' must carry the daily line
+// at that site (and keep the verification block closed), (2) leanInitiative:'off' must drop it there
+// while the verification phase still follows formalVerify. Assertion names carry the site name, so a
+// single-site regression names itself instead of hiding behind a sibling site's coverage.
+const SITE_DAILY = /三条筛选判据/
+const SITE_VERIFY = /【Lean 形式化验证（/
+const FENCE = '`'.repeat(3)
+const jsonReply = (obj) => FENCE + 'json\n' + JSON.stringify(obj) + '\n' + FENCE
+/** Drive one problem through explorer -> solver(dead-end) -> re-derive and collect each site's prompt. */
+async function driveSites(h, opts, qid) {
+  const q = qid || 'qSite'
+  await h.call('vibe_math_set_params', Object.assign({ tickIntervalMs: 200, verifierCount: 2, leanAsync: false, maxExplorerRetries: 5, maxParallelThreshold: 4 }, opts))
+  await h.call('vibe_math_add_problem', { id: q, description: '站点级运行时用例' })
+  await startScheduler(h)
+  const label = (n) => h.spawns.filter((s) => s.label.startsWith(n + ':' + q))
+  const ex1 = await waitFor(() => label('explorer')[0], 80, 200)
+  const out = { explorer: (ex1 && ex1.prompt) || '' }
+  if (ex1) h.fireEnd({ id: ex1.childId, runId: 'rS1', provider: 'spawn', local: true, stopReason: 'completed', lastAssistantMessage: [{ type: 'text', text: jsonReply({ directions: [{ id: 'd1', title: 'D', method: 'm', core_assumption: 'c', feasibility: 0.8 }] }) }] })
+  const so = await waitFor(() => label('solver')[0], 80, 200)
+  out.solver = (so && so.prompt) || ''
+  if (so) h.fireEnd({ id: so.childId, runId: 'rS2', provider: 'spawn', local: true, stopReason: 'completed', lastAssistantMessage: [{ type: 'text', text: jsonReply({ status: 'dead-end', dead_end_reason: '站点用例：本方向不可行', solution: '', solution_probability: 0.1, lemmas: [], routes: [], lessons: [], survival_probability: 0.2, sub_questions: [], new_inventions: [{ 类型: '工具', 标题: '站点工具', 内容描述: 'x', 是否已入库: false }] }) }] })
+  // every direction is now dead-end ⇒ the NEXT explorer for this problem is built by rederivePrompt
+  await waitFor(() => label('explorer').length >= 2 && label('explorer')[1], 80, 200)
+  const exs = label('explorer')
+  out.rederive = (exs[1] && exs[1].prompt) || ''
+  out.distinct = !!out.explorer && !!out.rederive && out.explorer !== out.rederive
+  await h.call('vibe_math_abort', {})
+  return out
+}
+{
+  // (1) eager 在 formalVerify:'off' 下也必须在**每一个**站点注入日线
+  const he = await makeCase('site-eager-off')
+  const A = await driveSites(he, { formalVerify: 'off', leanInitiative: 'eager' })
+  assert(SITE_DAILY.test(A.explorer), '★ [explorer site] formalVerify:off + leanInitiative:eager injects the daily line')
+  assert(SITE_DAILY.test(A.solver), '★ [solver site] formalVerify:off + leanInitiative:eager injects the daily line')
+  assert(SITE_DAILY.test(A.rederive), '★ [rederive site] formalVerify:off + leanInitiative:eager injects the daily line')
+  assert(A.distinct, '★ [rederive site] the re-explore prompt really is the rederive builder (differs from the first explorer wave)')
+  assert(A.explorer.indexOf('【Lean 形式化验证（') === -1 && A.solver.indexOf('【Lean 形式化验证（') === -1 && A.rederive.indexOf('【Lean 形式化验证（') === -1, '★ [all sites] formalVerify:off keeps the verification-phase block closed while eager still injects the daily line')
+
+  // (2) leanInitiative:'off' ⇒ 每个站点都没有日线（同一驱动）
+  const ho = await makeCase('site-init-off')
+  const B = await driveSites(ho, { formalVerify: 'encourage', leanInitiative: 'off' }, 'qSiteOff')
+  assert(!SITE_DAILY.test(B.explorer) && !/【顺手形式化/.test(B.explorer), '★ [explorer site] leanInitiative:off drops the daily line')
+  assert(!SITE_DAILY.test(B.solver) && !/【顺手形式化/.test(B.solver), '★ [solver site] leanInitiative:off drops the daily line')
+  assert(!SITE_DAILY.test(B.rederive) && !/【顺手形式化/.test(B.rederive), '★ [rederive site] leanInitiative:off drops the daily line')
+
+  // (2b) …而验证段仍按 formalVerify 出现（同一参数下的另一个 root，驱动到 verifier）
+  const hv = await makeCase('site-init-off-verify')
+  await hv.call('vibe_math_set_params', { tickIntervalMs: 200, verifierCount: 2, leanAsync: false, formalVerify: 'encourage', leanInitiative: 'off' })
+  await hv.call('vibe_math_add_problem', { id: 'qV', description: '验证段仍在' })
+  await startScheduler(hv)
+  const exv = await waitFor(() => hv.spawns.find((s) => s.label.startsWith('explorer:qV')), 80, 200)
+  assert(!!exv && !SITE_DAILY.test(exv.prompt || ''), '★ [explorer site] 第二个 root：initiative off 时 explorer 仍无日线')
+  if (exv) hv.fireEnd({ id: exv.childId, runId: 'rV1', provider: 'spawn', local: true, stopReason: 'completed', lastAssistantMessage: [{ type: 'text', text: jsonReply({ directions: [{ id: 'd1', title: 'D', method: 'm', core_assumption: 'c', feasibility: 0.8 }] }) }] })
+  const sov = await waitFor(() => hv.spawns.find((s) => s.label.startsWith('solver:qV')), 80, 200)
+  if (sov) hv.fireEnd({ id: sov.childId, runId: 'rV2', provider: 'spawn', local: true, stopReason: 'completed', lastAssistantMessage: [{ type: 'text', text: jsonReply({ status: 'success', solution: 'complete solution', solution_probability: 0.9, lemmas: [], routes: [], lessons: [], survival_probability: 0.9, dead_end_reason: null, sub_questions: [] }) }] })
+  const vv = await waitFor(() => hv.spawns.find((s) => /^verifier:/.test(s.label)), 100, 250)
+  assert(!!vv && SITE_VERIFY.test(vv.prompt || ''), '★ leanInitiative:off 时验证段仍按 formalVerify 注入（verifier 提示词含【Lean 形式化验证（）')
+  await hv.call('vibe_math_abort', {})
+}
+
 section('16 the captured prompt corpus is written for human review')
 {
   // Freeze the scheduler in every case FIRST: a still-running tick loop could emit one more

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

@@ -22,10 +22,14 @@
 import { mkdtempSync, rmSync, existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join, dirname, isAbsolute, resolve as pathResolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
+// V3_PLUGIN may be a REPO-RELATIVE path or an ABSOLUTE one (a mutant copy outside the repo, e.g. a
+// temp dir). The previous `new URL('file:///' + path)` form only worked for drive-qualified Windows
+// paths and made out-of-repo variants impossible; this is the same isAbsolute-aware resolution the
+// `math-computation-v*` suites use. Default behaviour (env var unset) is unchanged.
 const PLUGIN = process.env.V3_PLUGIN
-  ? new URL('file:///' + String(process.env.V3_PLUGIN).replace(/\\/g, '/'))
+  ? pathToFileURL(isAbsolute(process.env.V3_PLUGIN) ? process.env.V3_PLUGIN : join(dirname(fileURLToPath(import.meta.url)), '..', process.env.V3_PLUGIN))
   : new URL('../vibe-math-v3/vibe-math-v3.js', import.meta.url)
 const HERE = dirname(fileURLToPath(import.meta.url))
 // AUDIT-CHECKLIST §2.4: the suite must also keep the INTERACTION TEXT it drove, so a human can
@@ -1495,6 +1499,84 @@ section('9b Lean 增量 + 异步：参数/argv/队列/去重/只读面/主动性
 // 10. interaction corpus (AUDIT-CHECKLIST §2.4) — a HUMAN must be able to re-read
 //     every prompt the framework emitted, not just the assertions about them.
 // ===============================================================
+// ===============================================================
+// 5b. round-2 lens-1 RUNTIME: the initiative axis at EVERY v3 site
+// ===============================================================
+// Four sites: the three formalDailySection() call sites (explorer / rederive / solver) plus the
+// INLINE formalWorkLine() site inside methodKeeperPrompt. (1) formalVerify:'off' + leanInitiative:
+// 'eager' must carry the daily line at that site; (2) leanInitiative:'off' must drop it there while
+// the verification phase still follows formalVerify. Names carry the site so a single-site
+// regression names itself.
+const SITE_DAILY = /三条筛选判据/
+const SITE_VERIFY = /【Lean 形式化验证（/
+async function driveSiteV3(rw, opts, qid) {
+  const q = qid
+  await callTool('vibe_math_set_params', Object.assign({}, VPARAMS, { methodKeepEvery: 1, maxExplorerRetries: 5 }, opts), rw)
+  await callTool('vibe_math_add_problem', { id: q, 陈述: '站点级运行时用例' }, rw)
+  await callTool('vibe_math_start', {}, rw)
+  const exs = () => spawnOf(rw, 'explorer:' + q)
+  await drive(rw, () => exs().length >= 1, 'explorer site ' + q)
+  const out = { explorer: (exs()[0] || {}).prompt || '' }
+  // answer explorers with directions until the solver appears (v3's fallback scheduler re-derives)
+  fireEnd(exs()[0].childId, { meta: { kind: 'directions', qid: q, directions: [{ id: 'd1', title: 'D', method: 'm', core_assumption: '', feasibility: 0.8 }] } })
+  for (let guard = 0; guard < 30 && !lastSpawn(rw, 'solver:' + q + ':d1'); guard++) {
+    const pend = exs().filter((s) => !firedChildren.has(s.childId)).slice(-1)[0]
+    if (pend) { firedChildren.add(pend.childId); fireEnd(pend.childId, { meta: { kind: 'directions', qid: q, directions: [{ id: 'd1', title: 'D', method: 'm', core_assumption: '', feasibility: 0.8 }] } }) }
+    await pump(rw); await sleep(80)
+  }
+  const so = lastSpawn(rw, 'solver:' + q + ':d1')
+  out.solver = (so && so.prompt) || ''
+  // dead-end + a pending invention: the direction is exhausted (⇒ re-derive) AND the method keeper fires
+  if (so) fireEnd(so.childId, { status: 'dead-end', survival_probability: 0.2, dead_end_reason: '站点用例：不可行', new_inventions: [{ 类型: '工具', 标题: '站点工具', 内容描述: 'x', 是否已入库: false }] })
+  await drive(rw, () => exs().length >= 2, 'rederive site ' + q)
+  out.rederive = (exs()[1] || {}).prompt || ''
+  out.distinct = !!out.explorer && !!out.rederive && out.explorer !== out.rederive
+  await drive(rw, () => !!lastSpawn(rw, 'method-keeper'), 'method-keeper site ' + q)
+  out.methodKeeper = (lastSpawn(rw, 'method-keeper') || {}).prompt || ''
+  await callTool('vibe_math_abort', {}, rw)
+  return out
+}
+{
+  const re = makeRoot()
+  await callTool('vibe_math_new_project', { name: 'site-eager-off' }, re)
+  const A = await driveSiteV3(re, { formalVerify: 'off', leanInitiative: 'eager' }, 'qS')
+  assert(SITE_DAILY.test(A.explorer), '★ [explorer site] formalVerify:off + leanInitiative:eager injects the daily line')
+  assert(SITE_DAILY.test(A.solver), '★ [solver site] formalVerify:off + leanInitiative:eager injects the daily line')
+  assert(SITE_DAILY.test(A.rederive), '★ [rederive site] formalVerify:off + leanInitiative:eager injects the daily line')
+  assert(SITE_DAILY.test(A.methodKeeper), '★ [methodKeeper site] formalVerify:off + leanInitiative:eager injects the daily line (inline site)')
+  assert(A.explorer.indexOf('【Lean 形式化验证（') === -1 && A.solver.indexOf('【Lean 形式化验证（') === -1 && A.rederive.indexOf('【Lean 形式化验证（') === -1 && A.methodKeeper.indexOf('【Lean 形式化验证（') === -1, '★ [all sites] formalVerify:off keeps the verification-phase block closed while eager still injects the daily line')
+
+  const ro = makeRoot()
+  await callTool('vibe_math_new_project', { name: 'site-init-off' }, ro)
+  const B = await driveSiteV3(ro, { formalVerify: 'encourage', leanInitiative: 'off' }, 'qO')
+  assert(!SITE_DAILY.test(B.explorer) && !/【顺手形式化/.test(B.explorer), '★ [explorer site] leanInitiative:off drops the daily line')
+  assert(!SITE_DAILY.test(B.solver) && !/【顺手形式化/.test(B.solver), '★ [solver site] leanInitiative:off drops the daily line')
+  assert(!SITE_DAILY.test(B.rederive) && !/【顺手形式化/.test(B.rederive), '★ [rederive site] leanInitiative:off drops the daily line')
+  assert(!SITE_DAILY.test(B.methodKeeper) && !/【顺手形式化/.test(B.methodKeeper), '★ [methodKeeper site] leanInitiative:off drops the daily line (inline site)')
+
+  // verification phase still follows formalVerify under leanInitiative:'off'
+  const rvv = makeRoot()
+  await callTool('vibe_math_new_project', { name: 'site-init-off-verify' }, rvv)
+  await callTool('vibe_math_set_params', Object.assign({}, VPARAMS, { formalVerify: 'encourage', leanInitiative: 'off' }), rvv)
+  await callTool('vibe_math_add_problem', { id: 'qV', 陈述: '验证段仍在' }, rvv)
+  await callTool('vibe_math_start', {}, rvv)
+  await drive(rvv, () => !!lastSpawn(rvv, 'explorer:qV'), 'explorer qV')
+  const exv = lastSpawn(rvv, 'explorer:qV')
+  assert(!!exv && !SITE_DAILY.test(exv.prompt || ''), '★ [explorer site] 第二个 root：initiative off 时 explorer 仍无日线')
+  if (exv) fireEnd(exv.childId, { meta: { kind: 'directions', qid: 'qV', directions: [{ id: 'd1', title: 'D', method: 'm', core_assumption: '', feasibility: 0.8 }] } })
+  for (let guard = 0; guard < 30 && !lastSpawn(rvv, 'solver:qV:d1'); guard++) {
+    const pend = spawnOf(rvv, 'explorer:qV').filter((s) => !firedChildren.has(s.childId)).slice(-1)[0]
+    if (pend) { firedChildren.add(pend.childId); fireEnd(pend.childId, { meta: { kind: 'directions', qid: 'qV', directions: [{ id: 'd1', title: 'D', method: 'm', core_assumption: '', feasibility: 0.8 }] } }) }
+    await pump(rvv); await sleep(80)
+  }
+  const sovv = lastSpawn(rvv, 'solver:qV:d1')
+  if (sovv) fireEnd(sovv.childId, { status: 'success', solution: 'complete solution', survival_probability: 0.9 })
+  await drive(rvv, () => spawnOf(rvv, 'verifier:').length >= 1, 'verifier qV')
+  const vsp = spawnOf(rvv, 'verifier:')[0]
+  assert(!!vsp && SITE_VERIFY.test(vsp.prompt || ''), '★ leanInitiative:off 时验证段仍按 formalVerify 注入（verifier 提示词含【Lean 形式化验证（）')
+  await callTool('vibe_math_abort', {}, rvv)
+}
+
 section('10 the captured prompt corpus is written for human review')
 {
   mkdirSync(CORPUS_DIR, { recursive: true })

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: '' }
       }

package/tests/math-computation-shared.test.mjs

@@ -175,10 +175,15 @@ console.log('-- math_computation shared contract --')
   await withHost({}, async (state) => {
     const r = await state.call({ op: 'run', engine: 'cli', mode: 'code', code: 'echo hi', cli: { command: '/fake/bin/mytool', argv: ['--flag', 'x'] } })
     ok(r.ok === true, 'cli runs with DEFAULT params (default-on)')
-    eq(r.argv, ['/fake/bin/mytool', '--flag', 'x'], 'cli argv is command + user argv verbatim')
+    // round-7 (finding 4): mode:'code' append the archived script so the code actually RUNS (the
+    // caller cannot know the runId up front). The user argv stays verbatim in receipt.cli.argv.
+    eq(r.argv.slice(0, 3), ['/fake/bin/mytool', '--flag', 'x'], 'cli argv starts with command + user argv')
+    ok(/Computation\/.*script\.txt$/.test(String(r.argv[3] || '')), 'mode:code appends the archived script path to the effective argv')
+    ok(r.cliScriptAppended === true, 'the return shell flags cliScriptAppended')
     ok(r.engine === 'cli:/fake/bin/mytool' && r.engineInfo.name === 'cli:/fake/bin/mytool', 'cli is labelled cli:<command> in the shell and engineInfo')
     const rj = JSON.parse(state.file(r.receipt.json))
-    ok(rj.engine.name === 'cli:/fake/bin/mytool' && rj.engine.source === 'cli' && rj.cli && rj.cli.argv.length === 2, 'cli receipt records cli:<command>, source=cli and argv')
+    ok(rj.engine.name === 'cli:/fake/bin/mytool' && rj.engine.source === 'cli' && rj.cli && rj.cli.argv.length === 2, 'cli receipt records cli:<command>, source=cli and the USER argv')
+    ok(rj.cli.scriptAppended === true && rj.argv[rj.argv.length - 1] === r.argv[3], 'the receipt records scriptAppended and the executed argv')
   })
   await withHost({ params: { mathMode: 'typed' } }, async (state) => {
     const r = await state.call({ op: 'run', engine: 'cli', mode: 'code', code: 'x', cli: { command: '/fake/bin/mytool' } })
@@ -498,6 +503,303 @@ console.log('-- math_computation shared contract --')
   }
 }
 
+// ── 18. round-6: substitution honesty (A), manager dispatch (B), scope policy (C), version syntax (D)
+{
+  // 18a (A): the rule is part of the frozen rule block and reaches both language lines.
+  ok(M.MATH_RULE_LINES.join('\n').indexOf(M.MATH_SUBSTITUTION_RULE_LINE) !== -1, 'MATH_RULE_LINES carries the substitution-honesty rule (zh)')
+  ok(M.MATH_RULE_LINES_EN.join('\n').indexOf(M.MATH_SUBSTITUTION_RULE_LINE_EN) !== -1, 'MATH_RULE_LINES_EN carries the substitution-honesty rule (en)')
+  ok(/替代方案若改变精确性/.test(String(M.MATH_TOOL_DESCRIPTION)), 'the tool description states the substitution duty (paraphrase)')
+  {
+    const p = await M.probeMathEngines(makeFakeHost({ installed: ['python3'] }).host)
+    const zh = M.mathAvailabilityLine(p, 'zh', 'typed+shell')
+    const en = M.mathAvailabilityLine(p, 'en', 'typed+shell')
+    ok(zh.indexOf('替代必须声明') !== -1, 'the injected (zh) availability line carries the substitution rule')
+    ok(en.indexOf('Declare substitutions') !== -1, 'the injected (en) availability line carries the substitution rule')
+  }
+
+  // 18b (B): python dispatch follows the DETECTED environment, never a guess.
+  {
+    const condaHost = makeFakeHost({ resolveMap: { python3: 'C:/miniconda3/envs/math/python.exe', conda: 'C:/miniconda3/Scripts/conda.exe' } })
+    M.registerMathComputation(condaHost.host)
+    const c = await condaHost.call({ op: 'install', engine: 'python', packages: ['numpy'] })
+    ok(c.ok === true && c.plan.manager === 'conda' && c.plan.managerAssumed === false, 'a conda-style interpreter plans with conda (not guessed)')
+    eq(c.plan.commands[0].argv, ['conda', 'install', '-y', '-c', 'conda-forge', 'numpy'], 'conda install comes from conda-forge')
+    ok(/conda/.test(String(c.message)), 'the plan message names the manager')
+
+    const uvHost = makeFakeHost({ resolveMap: { python3: '/venv/bin/python3', uv: '/venv/bin/uv' } })
+    M.registerMathComputation(uvHost.host)
+    const u = await uvHost.call({ op: 'install', engine: 'python', packages: ['numpy'] })
+    ok(u.ok === true && u.plan.manager === 'uv', 'a uv next to the interpreter plans with uv')
+    eq(u.plan.commands[0].argv, ['uv', 'pip', 'install', 'numpy'], 'uv install uses `uv pip install`')
+
+    const pipHost = makeFakeHost({ resolveMap: { python3: '/usr/bin/python3' } })
+    M.registerMathComputation(pipHost.host)
+    const d = await pipHost.call({ op: 'install', engine: 'python', packages: ['numpy'] })
+    ok(d.ok === true && d.plan.manager === 'pip' && d.plan.managerAssumed === true, 'no marker -> pip fallback, flagged as an ASSUMPTION')
+    eq(d.plan.commands[0].argv, ['/usr/bin/python3', '-m', 'pip', 'install', '--user', 'numpy'], 'the pip fallback keeps the user-scope form')
+    ok(/假设|assum/i.test(String(d.message)), 'the message says the manager is an assumption')
+  }
+
+  // 18c (C): R/Octave/Julia refuse system scope WITH a per-engine reason; conda too.
+  {
+    const h = makeFakeHost({ resolveMap: { Rscript: '/usr/bin/Rscript', octave: '/usr/bin/octave', julia: '/usr/bin/julia' } })
+    M.registerMathComputation(h.host)
+    for (const [engine, marker] of [['r', 'R_LIBS_USER'], ['octave', 'share/packages'], ['julia', 'JULIA_DEPOT_PATH']]) {
+      const r = await h.call({ op: 'install', engine: engine, packages: ['x'], scope: 'system' })
+      ok(r.ok === false && r.code === 'MATH_REFUSED' && r.next && r.next.reason === 'system-scope-unsupported', engine + ': system scope -> MATH_REFUSED(system-scope-unsupported)')
+      ok(String(r.message).indexOf(marker) !== -1, engine + ': the refusal states WHY (mentions ' + marker + ')')
+    }
+    const condaHost = makeFakeHost({ resolveMap: { python3: 'C:/miniconda3/envs/math/python.exe', conda: 'C:/miniconda3/Scripts/conda.exe' } })
+    M.registerMathComputation(condaHost.host)
+    const cs = await condaHost.call({ op: 'install', engine: 'python', packages: ['numpy'], scope: 'system' })
+    ok(cs.ok === false && cs.next.reason === 'system-scope-unsupported' && /conda/.test(String(cs.message)), 'conda has no system scope and says so')
+  }
+
+  // 18d (D): version syntax is passed through where the manager understands it, refused otherwise.
+  {
+    ok(M.validateMathArgs({ op: 'run', mode: 'code', code: 'x', packages: ['numpy==1.2'] }, {}).ok === true, 'pkg==1.2 is accepted (pass-through)')
+    ok(M.validateMathArgs({ op: 'run', mode: 'code', code: 'x', packages: ['numpy=1.2'] }, {}).ok === true, 'pkg=1.2 (conda form) is accepted')
+    ok(M.validateMathArgs({ op: 'run', mode: 'code', code: 'x', packages: ['numpy[extra]>=1.2'] }, {}).ok === true, 'extras + comparator are accepted')
+    const badSpec = M.validateMathArgs({ op: 'run', mode: 'code', code: 'x', packages: ['numpy; rm -rf /'] }, {})
+    ok(badSpec.ok === false && badSpec.code === 'MATH_INVALID_ARGUMENT' && badSpec.next && badSpec.next.reason === 'unsupported-version-syntax', 'a shell-ish spec is refused with unsupported-version-syntax')
+
+    const ph = makeFakeHost({ packages: { sympy: 'present' } })
+    M.registerMathComputation(ph.host)
+    await ph.call({ op: 'run', engine: 'python', mode: 'code', code: 'print(1)\n', packages: ['sympy==1.12'] })
+    const pkgSpawns = ph.spawns.filter((s) => s.argv.join(' ').indexOf('sympy') !== -1)
+    ok(pkgSpawns.length > 0 && pkgSpawns.every((s) => s.argv.join(' ').indexOf('sympy==1.12') === -1), 'presence is probed by BASE NAME (the constraint never reaches the probe)')
+    const plan = await ph.call({ op: 'install', engine: 'python', packages: ['sympy==1.12'] })
+    ok(plan.ok === true && plan.plan.commands[0].argv[plan.plan.commands[0].argv.length - 1] === 'sympy==1.12', 'the install plan passes the spec through verbatim')
+    ok(!!plan.plan.versionPolicy, 'the plan states the version policy (solving belongs to the manager)')
+  }
+}
+
+// ── 19. round-7: probe reports the REQUESTED engine (fix 1) + DSH bundled-runtime discovery (fix 2)
+{
+  // 19a (fix 1): `probe {engine:'r'}` must describe r - not the first allowed engine (python).
+  {
+    const hr = makeFakeHost({ installed: ['python3', 'python', 'Rscript'] })
+    M.registerMathComputation(hr.host)
+    const p = await hr.call({ op: 'probe', engine: 'r' })
+    ok(p.ok === true && p.engine === 'r', 'probe with engine:r reports engine:r (not python)')
+    ok(!!p.engineInfo && p.engineInfo.name === 'r' && !!p.engineInfo.version, "probe reports the requested engine's version/path")
+    ok(!p.next, 'a usable requested engine yields no install guidance')
+    const pp = await hr.call({ op: 'probe', engine: 'python' })
+    ok(pp.ok === true && pp.engine === 'python' && pp.engineInfo.name === 'python', 'probe with engine:python reports python (each request is honoured)')
+  }
+  // 19b (fix 1): a MISSING requested engine must not blame python in the guidance.
+  {
+    const hm = makeFakeHost({ installed: ['python3', 'python'] })
+    M.registerMathComputation(hm.host)
+    const p = await hm.call({ op: 'probe', engine: 'r' })
+    ok(p.ok === false && p.code === 'MATH_ENGINE_NOT_FOUND' && p.engine === 'r', 'a missing requested engine is reported as THAT engine (r, not python)')
+    ok(p.next && p.next.kind === 'user-install' && p.next.engine === 'r' && !!p.next.perOs, 'the install guidance is for the REQUESTED engine (r), with per-OS commands')
+    const msg = String(p.message)
+    ok(/试过：r|请求：r/.test(msg) && !/python/i.test(msg), 'the message names the requested engine (r), never a python fallback')
+  }
+  // 19c (fix 2): a DSH-bundled runtime is discovered as a LAST resort and used like any engine.
+  {
+    const absTree = {
+      'X:/home/.dsh/dsh-runtimes': [{ name: 'dsh-primary-runtime', type: 'directory' }, { name: 'dsh-other-runtime', type: 'directory' }],
+      'X:/home/.dsh/dsh-runtimes/dsh-primary-runtime/dependencies/python': [{ name: 'python.exe', type: 'file' }, { name: 'python3.exe', type: 'file' }],
+      'X:/home/.dsh/dsh-runtimes/dsh-other-runtime/dependencies/python': [],
+    }
+    const hb = makeFakeHost({ installed: [], runtimeRoots: ['X:/home/.dsh'], absTree: absTree })
+    M.registerMathComputation(hb.host)
+    const p = await hb.call({ op: 'probe', engine: 'python' })
+    ok(p.ok === true && p.engine === 'python' && p.engineInfo.name === 'python', 'a bundled DSH runtime is found when PATH has nothing')
+    ok(/dsh-runtimes\/dsh-primary-runtime\/dependencies\/python\/python/.test(p.engineInfo.path), 'the discovered path comes from the generically globbed runtime tree')
+    const r = await hb.call({ op: 'run', engine: 'python', mode: 'code', code: 'print(1)\n' })
+    ok(r.ok === true && !!r.engineInfo.version, 'a run on the bundled runtime succeeds and reports its version')
+    ok(!r.next, 'a found bundled runtime emits NO install guidance')
+    // The bundled runtime must not be invented when the tree is absent.
+    const hn = makeFakeHost({ installed: [] })
+    M.registerMathComputation(hn.host)
+    const n = await hn.call({ op: 'probe', engine: 'python' })
+    ok(n.ok === false && n.code === 'MATH_ENGINE_NOT_FOUND' && n.next && n.next.kind === 'user-install', 'with no PATH engine and no runtime tree the per-OS guidance still fires')
+  }
+  // 19d (finding 3): the cli package precheck runs against the FAMILY of `cli.command`, not the
+  // generic cli descriptor (which has no packageProbe and therefore reported a false "missing").
+  {
+    const hc = makeFakeHost({ installed: [], packages: { numpy: 'present' } })
+    M.registerMathComputation(hc.host)
+    const r = await hc.call({ op: 'run', engine: 'cli', mode: 'code', code: 'print(1)\n', cli: { command: '/fake/bin/python3' }, packages: ['numpy'] })
+    ok(r.ok === true, 'cli + packages: a python-family command prechecks with the python probe (numpy present => the run proceeds)')
+    const probes = hc.spawns.filter((s) => s.argv.join(' ').indexOf('numpy') !== -1)
+    ok(probes.length > 0 && probes.every((s) => String(s.argv[0]).indexOf('python3') !== -1), 'the package precheck ran against cli.command itself')
+    // An unrecognisable command must SKIP the precheck (never a false missing) and say so.
+    const hu = makeFakeHost({ installed: [] })
+    M.registerMathComputation(hu.host)
+    const ru = await hu.call({ op: 'run', engine: 'cli', mode: 'code', code: 'print(1)\n', cli: { command: '/fake/bin/mytool' }, packages: ['numpy'] })
+    ok(ru.ok === true && (ru.warnings || []).some((w) => w.code === 'PACKAGE_PRECHECK_SKIPPED'), 'an unknown cli family skips the precheck with an explicit warning (no false missing-packages)')
+  }
+  // 19e (finding 5): cli reports the REAL version of the resolved command when its family is known.
+  {
+    const hv = makeFakeHost({ installed: [] })
+    M.registerMathComputation(hv.host)
+    const p = await hv.call({ op: 'probe', engine: 'cli', cli: { command: '/fake/bin/python3' } })
+    ok(p.ok === true && p.engineInfo && p.engineInfo.version === '1.2.3', 'probe(engine:cli) reports the real version of the resolved command')
+    const r = await hv.call({ op: 'run', engine: 'cli', mode: 'code', code: 'print(1)\n', cli: { command: '/fake/bin/python3' } })
+    ok(r.engineInfo.version === '1.2.3', 'run(engine:cli) reports the real command version (not "unknown")')
+  }
+  // 19f (finding 6, found on the real bundled python): the probe code iterates `sys.argv[1:]`, so the
+  // names must arrive as SEPARATE argv items - a comma-joined single item makes python look up one
+  // package literally named "numpy,pandas" and report everything missing.
+  {
+    const hp = makeFakeHost({ installed: ['python3'], packages: { numpy: 'present', pandas: 'present' } })
+    M.registerMathComputation(hp.host)
+    await hp.call({ op: 'run', engine: 'python', mode: 'code', code: 'print(1)\n', packages: ['numpy', 'pandas'] })
+    const probe = hp.spawns.find((s) => s.argv.join(' ').indexOf('numpy') !== -1)
+    ok(!!probe && probe.argv.indexOf('numpy') !== -1 && probe.argv.indexOf('pandas') !== -1, 'the python package probe passes ONE argv item per package (sys.argv-based probe)')
+    ok(!!probe && probe.argv.join(' ').indexOf('numpy,pandas') === -1, 'the probe never passes the comma-joined list as a single argv item')
+    // round-7 (live): a real host rejected probe argv containing shell metacharacters (| %), so no
+    // probe argv may carry them - the parsers accept both `name:state` and `name state` shapes.
+    ok(!!probe && !/[|%]/.test(probe.argv.join(' ')), 'no probe argv contains a shell metacharacter (| or %)')
+    for (const name of ['python', 'r', 'octave', 'julia']) {
+      const d = (await import('../vibe-math-v2/math-engines.js')).MATH_ENGINES[name]
+      for (const a of (d.packageProbe.argv || [])) ok(!/[|%]/.test(String(a)), name + ' probe template has no | or %: ' + String(a).slice(0, 40))
+      ok(!/[|%]/.test(String(d.probeCode || 'numpy ok line')), name + ' probeCode has no | or %')
+    }
+  }
+  // 19f-bis: cli + mode:'code' actually PASSES the script (finding 4) - verified through argv shape.
+  {
+    const hs = makeFakeHost({ installed: [] })
+    M.registerMathComputation(hs.host)
+    const r = await hs.call({ op: 'run', engine: 'cli', mode: 'code', code: 'print(1)\n', cli: { command: '/fake/bin/python3' } })
+    const last = String(r.argv[r.argv.length - 1] || '')
+    ok(r.ok === true && /script\.txt$/.test(last), 'cli + code: the archived script is last in argv (it is really executed, not a REPL)')
+    const runSpawn = hs.spawns.filter((s) => String(s.argv[s.argv.length - 1] || '').indexOf('script.txt') !== -1)
+    ok(runSpawn.length === 1, 'the executed argv carried the script path to the process')
+    // …but when the CALLER's argv already runs code (-c/-m/-e/--eval), the caller's argv wins: the
+    // archived script must NOT be appended after it (python would read it as sys.argv[1]).
+    const rc = await hs.call({ op: 'run', engine: 'cli', mode: 'code', code: 'print(1)\n', cli: { command: '/fake/bin/python3', argv: ['-c', 'print(1)'] } })
+    ok(rc.ok === true && rc.cliScriptAppended === false, 'cli + code with a caller program slot (-c) does NOT append the archived script')
+    ok(rc.argv.join(' ').indexOf('script.txt') === -1, 'the executed argv is exactly the caller argv (no script path)')
+    ok(!!rc.receipt && !!rc.receipt.json, 'the skipped-append run still writes a receipt')
+  }
+  // 19g (live-session fix): an engine that RESOLVED but whose version probe failed must NOT come with
+  // install guidance (the user does not need to install anything) and must carry the diagnostic.
+  {
+    const hh = makeFakeHost({ installed: ['python3', 'python'], versionProbeFails: true })
+    M.registerMathComputation(hh.host)
+    const p = await hh.call({ op: 'probe', engine: 'python' })
+    ok(p.ok === false && p.code === 'MATH_ENGINE_UNUSABLE', 'a resolved engine whose probe fails => MATH_ENGINE_UNUSABLE')
+    ok(!p.next || p.next.kind !== 'user-install', 'unusable (but FOUND) engine carries NO install guidance')
+    ok(!!p.probe && Array.isArray(p.probe.argv) && p.probe.argv[0].indexOf('python3') !== -1, 'the failure carries the probe diagnostic (argv)')
+    ok(!!p.probe && p.probe.exit === 1 && p.probe.stderrTail === 'probe boom', 'the diagnostic carries exit + stderr tail')
+    ok(/MATH_ENGINE_UNUSABLE/.test(p.code) && /exit=1/.test(String(p.message)), 'the message states the probe exit code (never an opaque "unusable")')
+    // A deterministic failure is NOT retried (no retryDiag, no retry storm), only a cold/null/timeout
+    // signature is - see 19h.
+    ok(!(p.probe && p.probe.retried), 'a deterministic probe failure is NOT retried (no retryDiag)')
+  }
+  // 19h (live-session fix): the real host intermittently returns a NULL spawn early in a session.
+  // The retry must cover spawned:false / exit:null (not just timeouts) so the probe still succeeds.
+  {
+    const hN = makeFakeHost({ installed: ['python3', 'python'], nullSpawnTimes: 2 })
+    M.registerMathComputation(hN.host)
+    const p = await hN.call({ op: 'probe', engine: 'python' })
+    ok(p.ok === true && p.engine === 'python' && p.engineInfo.version === '1.2.3', 'a transient NULL spawn is retried and the probe still succeeds')
+    ok(hN.spawns.filter((s) => s.nullSpawn).length === 2, 'the null spawns are visible in the seam (2 consumed)')
+  }
+  // 19i (live-session fix): a package precheck that could not RUN must never be reported as
+  // "missing package", and the skip must be explicit (fail-open + named warning).
+  {
+    const hP = makeFakeHost({ installed: ['python3'], packageProbeNullTimes: 9 })
+    M.registerMathComputation(hP.host)
+    const r = await hP.call({ op: 'run', engine: 'python', mode: 'code', code: 'print(1)\n', packages: ['numpy'] })
+    ok(r.ok !== false || r.code !== 'MATH_MISSING_PACKAGES', 'a precheck that could not run is NEVER reported as a missing package')
+    ok((r.warnings || []).some((w) => w.code === 'PACKAGE_PRECHECK_UNKNOWN'), 'the un-runnable precheck is reported explicitly (PACKAGE_PRECHECK_UNKNOWN)')
+  }
+}
+
+// ── 20. round-7 cross-cutting invariant: EVERY response must be JSON-serialisable
+// (a real session got `Converting circular structure to JSON ... property 'retryDiag' closes the
+// circle` from a probe/run response, which meant the caller saw no result at all). This applies to
+// all four presets because they all ship this module.
+{
+  const cases = []
+  const push = (label, r) => cases.push({ label, r })
+  {
+    const h = makeFakeHost({ installed: ['python3', 'python', 'Rscript'], packages: { numpy: 'present' } })
+    M.registerMathComputation(h.host)
+    push('probe ok', await h.call({ op: 'probe', engine: 'python' }))
+    push('probe missing engine', await h.call({ op: 'probe', engine: 'octave' }))
+    push('run ok', await h.call({ op: 'run', engine: 'python', mode: 'code', code: 'print(1)\n' }))
+    push('run bad mode', await h.call({ op: 'run', engine: 'python', mode: 'nope' }))
+    push('run missing pkg', await h.call({ op: 'run', engine: 'python', mode: 'code', code: 'x\n', packages: ['pandas'] }))
+    push('receipt missing', await h.call({ op: 'receipt', id: 'nope' }))
+    push('install plan', await h.call({ op: 'install', engine: 'python', packages: ['numpy'] }))
+    push('install commercial', await h.call({ op: 'install', engine: 'matlab', packages: ['MATLAB'] }))
+    push('install system scope r', await h.call({ op: 'install', engine: 'r', packages: ['x'], scope: 'system' }))
+    push('unsupported spec', await h.call({ op: 'run', engine: 'python', mode: 'code', code: 'x\n', packages: ['numpy; rm -rf /'] }))
+    push('unknown engine', await h.call({ op: 'run', engine: 'nope', mode: 'code', code: 'x\n' }))
+  }
+  {
+    const h = makeFakeHost({ installed: ['python3'], versionProbeFails: true })
+    M.registerMathComputation(h.host)
+    push('probe unusable (probe diagnostics)', await h.call({ op: 'probe', engine: 'python' }))
+  }
+  {
+    // A RETRIED probe carries retryDiag: that is exactly where the circular payload came from.
+    const h = makeFakeHost({ installed: ['python3'], nullSpawnTimes: 40 })
+    M.registerMathComputation(h.host)
+    push('probe unusable after retries (retryDiag present)', await h.call({ op: 'probe', engine: 'python' }))
+  }
+  {
+    const h = makeFakeHost({ installed: ['python3'], packageProbeNullTimes: 9 })
+    M.registerMathComputation(h.host)
+    push('run with un-runnable precheck', await h.call({ op: 'run', engine: 'python', mode: 'code', code: 'x\n', packages: ['numpy'] }))
+  }
+  {
+    const h = makeFakeHost({ installed: [] })
+    M.registerMathComputation(h.host)
+    push('probe nothing', await h.call({ op: 'probe', engine: 'python' }))
+  }
+  {
+    const h = makeFakeHost({ resolveThrows: true })
+    M.registerMathComputation(h.host)
+    push('probe resolve throws', await h.call({ op: 'probe', engine: 'python' }))
+  }
+  for (const c of cases) {
+    let json = null
+    let err = null
+    try { json = JSON.stringify(c.r) } catch (e) { err = String((e && e.message) || e) }
+    ok(json !== null, '★ response is JSON-serialisable: ' + c.label + (err ? ' (' + err + ')' : ''))
+  }
+  // The diagnostics themselves must never carry a back-reference.
+  {
+    const h = makeFakeHost({ installed: ['python3'], nullSpawnTimes: 2 })
+    M.registerMathComputation(h.host)
+    const r = await h.call({ op: 'probe', engine: 'python' })
+    ok(r.ok === true, 'the null-spawn retry recovers (JSON invariant context)')
+    const h2 = makeFakeHost({ installed: ['python3'], versionProbeFails: true })
+    M.registerMathComputation(h2.host)
+    const u = await h2.call({ op: 'probe', engine: 'python' })
+    ok(!!u.probe && JSON.stringify(u.probe).indexOf('retryDiag') === -1 ? true : !!u.probe, 'a deterministic failure still exposes its probe diagnostics')
+  }
+}
+
+// ── 21. round-7 (live root cause): probes must not depend on the project root EXISTING
+// The real host answers a spawn whose cwd does not exist with `spawned:true, exit:null` (retries
+// cannot help). On a brand-new session the project root does not exist yet, so the version probe and
+// the package precheck must run from a cwd that is guaranteed to exist.
+{
+  const FRESH = '/fresh/nonexistent/workspace'
+  const h = makeFakeHost({ installed: ['python3', 'python'], projectRoot: FRESH, packages: { numpy: 'present' } })
+  M.registerMathComputation(h.host)
+  const p = await h.call({ op: 'probe', engine: 'python' })
+  ok(p.ok === true && p.engine === 'python' && p.engineInfo.version === '1.2.3', '★ a probe on a FRESH (non-existent) project root still succeeds with a real version')
+  const versionSpawns = h.spawns.filter((s) => /--version/.test(s.argv.join(' ')))
+  ok(versionSpawns.length > 0, 'the version probe actually spawned')
+  ok(versionSpawns.every((s) => String(s.cwd) !== FRESH), '★ no version probe spawn uses the non-existent project root as cwd')
+  ok(versionSpawns.every((s) => !s.nullSpawn), 'no version probe spawn reported exit:null (fresh-root signature)')
+  const r = await h.call({ op: 'run', engine: 'python', mode: 'code', code: 'print(1)\n', packages: ['numpy'] })
+  const pkgSpawns = h.spawns.filter((s) => s.argv.join(' ').indexOf('numpy') !== -1)
+  ok(r.ok === true, 'a run with packages on a FRESH root passes the precheck')
+  ok(pkgSpawns.length > 0 && pkgSpawns.every((s) => String(s.cwd) !== FRESH), '★ the package precheck also avoids the non-existent project root')
+  ok(!(r.warnings || []).some((w) => w.code === 'PACKAGE_PRECHECK_UNKNOWN'), 'the precheck RAN (no PACKAGE_PRECHECK_UNKNOWN on a fresh root)')
+}
+
 console.log('')
 console.log('=== MATH COMPUTATION SHARED: ' + passed + ' passed, ' + failed + ' failed ===')
 if (failures.length) for (const f of failures) console.error('  - ' + f)

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

@@ -41,6 +41,7 @@
         mode.
 
       - math_computation {op: probe|run|receipt|install, engine, mode: code|file|expr, …} — 先 probe 预检引擎/包/许可，再调引擎计算并把脚本与输出归档成可复核回执；缺引擎/缺包只报告与给安装指引/计划；shell 兜底不算归档。
+      - 替代必须声明（诚实性）：当替代方案改变了**精确性或结论强度**时（精确符号解 → 数值近似、闭式解 → 采样/求积、改了精度/容差/假设、换了算法类），结论里**必须写明**，不得读起来像得到了原本（精确/所要求的）结果；拿不到精确结果就直说。
       - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>），你可以用普通文件工具打开并编辑它；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
 
       Final paper: strict termination writes Paper/<project>/{paper.md,paper.tex,paper.pdf,paper.meta.json,paper.log.md}
@@ -118,6 +119,7 @@
         mode.
 
       - math_computation {op: probe|run|receipt|install, engine, mode: code|file|expr, …} — 先 probe 预检引擎/包/许可，再调引擎计算并把脚本与输出归档成可复核回执；缺引擎/缺包只报告与给安装指引/计划；shell 兜底不算归档。
+      - 替代必须声明（诚实性）：当替代方案改变了**精确性或结论强度**时（精确符号解 → 数值近似、闭式解 → 采样/求积、改了精度/容差/假设、换了算法类），结论里**必须写明**，不得读起来像得到了原本（精确/所要求的）结果；拿不到精确结果就直说。
       - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>），你可以用普通文件工具打开并编辑它；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
 
       Final paper: strict termination writes Paper/<project>/{paper.md,paper.tex,paper.pdf,paper.meta.json,paper.log.md}