dsh-vibe-math 2.7.0 → 2.7.2

package/vibe-math-v3/math-computation.js

@@ -62,7 +62,9 @@ export const MATH_TOOL_DESCRIPTION = '数学计算：先用 op:\'probe\' 预检
   + '且结论必须标注未经工具归档））。每次执行都会归档成可复核回执（Computation/<id>/），回执里含 scriptPath/scriptHash 与**实际 argv**；'
   + '脚本原件就在那个归档目录里，你可以用普通文件工具打开/编辑它，编辑后用 mode:\'file\' 重跑会得到一份**新回执**——'
   + '**不得**拿旧回执当作修改后代码的证据。缺引擎/缺包只报告并给"用户自装指引"或"代理代装计划"（先计划、再确认）；'
-  + '商业引擎只给厂商指引；引擎选项报错时会回显 argv 并提示用 mathEngineOverride。计算结果是经验证据，不是证明。'
+  + '商业引擎只给厂商指引；引擎选项报错时会回显 argv 并提示用 mathEngineOverride。'
+  + '替代方案若改变精确性或结论强度（精确解→数值近似、闭式解→采样/求积、改精度/容差/假设、换算法类）**必须在结论里声明**，不得读起来像得到了原本的结果。'
+  + '计算结果是经验证据，不是证明。'
 
 export const MATH_PERSONA_TOOL_LINE = '- math_computation {op: probe|run|receipt|install, engine, mode: code|file|expr, …} — '
   + '先 probe 预检引擎/包/许可，再调引擎计算并把脚本与输出归档成可复核回执；缺引擎/缺包只报告与给安装指引/计划；shell 兜底不算归档。'
@@ -70,11 +72,20 @@ export const MATH_PERSONA_TOOL_LINE = '- math_computation {op: probe|run|receipt
 // P2a: the archive -> edit -> re-run workflow. Injected into every preset's rule block (and appended
 // to both persona blocks) so an agent cannot miss that (a) the script is archived, (b) it may edit
 // it, and (c) re-running is what produces evidence for the edited code.
-export const MATH_ARCHIVE_WORKFLOW_LINE = '- 归档→编辑→重跑：mode:\'code\' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>），你可以用普通文件工具打开并编辑它；'
+export const MATH_ARCHIVE_WORKFLOW_LINE = '- 归档→编辑→重跑：mode:\'code\' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>，**相对项目根**）；'
+  + '**成员的文件工具是按会话 cwd 解析的**，所以打开它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）；'
   + '编辑后用 mode:\'file\' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——'
   + '报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。'
 
-export const MATH_ARCHIVE_WORKFLOW_LINE_EN = '- Archive -> edit -> re-run: for mode:\'code\' the script original is at the receipt\'s scriptPath (Computation/<id>/script.<ext>) and you may open/edit it with your normal file tools; after editing, re-run it with mode:\'file\' to write a NEW receipt/attempt with a NEW scriptHash. **An old receipt is NOT evidence for edited code** - cite the receipt whose scriptHash matches the current code; the tool warns explicitly via scriptChanged / scriptChangedDuringRun.'
+export const MATH_ARCHIVE_WORKFLOW_LINE_EN = '- Archive -> edit -> re-run: for mode:\'code\' the script original is at the receipt\'s scriptPath (Computation/<id>/script.<ext>, **relative to the project root**); member file tools resolve paths against the SESSION CWD, so open it via the ABSOLUTE `receipt.scriptAbs`, or join `receipt.cwd` with `receipt.scriptPath` (both are in the receipt); after editing, re-run it with mode:\'file\' to write a NEW receipt/attempt with a NEW scriptHash. **An old receipt is NOT evidence for edited code** - cite the receipt whose scriptHash matches the current code; the tool warns explicitly via scriptChanged / scriptChangedDuringRun.'
+
+// Round-6 (A): honesty about SUBSTITUTIONS. An alternative that weakens exactness or conclusion
+// strength must be declared, and the conclusion must never read as if the requested (exact) result
+// had been obtained. Injected through mathAvailabilityLine (rule block) AND appended to both persona
+// blocks by the presets - same mechanism as the archive-workflow line.
+export const MATH_SUBSTITUTION_RULE_LINE = '- 替代必须声明（诚实性）：当替代方案改变了**精确性或结论强度**时（精确符号解 → 数值近似、闭式解 → 采样/求积、改了精度/容差/假设、换了算法类），结论里**必须写明**，不得读起来像得到了原本（精确/所要求的）结果；拿不到精确结果就直说。'
+
+export const MATH_SUBSTITUTION_RULE_LINE_EN = '- Declare substitutions (honesty): when an alternative changes EXACTNESS or conclusion strength (exact symbolic solution -> numerical approximation, closed form -> sampling/quadrature, changed precision/tolerances/assumptions, a different algorithm class), the conclusion MUST say so explicitly and must not read as if the original (exact/requested) result had been obtained; if the exact result is unavailable, say so plainly.'
 
 export const MATH_RULE_LINES = Object.freeze([
   '- 需要精确数值、符号化简、反例搜索、统计或线性代数时调用 math_computation：先 probe，再 run。',
@@ -82,6 +93,7 @@ export const MATH_RULE_LINES = Object.freeze([
   '- 归档即引用：报告里带 Computation/<id>/receipt.json；这是"支撑材料"的用法。',
   '- 判断标准：① 有价值或可能复用；② 较为关键或必要；③ 你对该陈述有把握（置信度高）——没把握的先别入库。',
   '- 不得把计算结果当成"已证明"：对象是否已验证仍只由本预设既有的验证/共识路径给出。',
+  MATH_SUBSTITUTION_RULE_LINE,
 ])
 
 // The shell-fallback sentence is deliberately NOT part of MATH_RULE_LINES: it is only advertised
@@ -96,6 +108,7 @@ export const MATH_RULE_LINES_EN = Object.freeze([
   '- Archive means cite: put Computation/<id>/receipt.json in your report - that is what "supporting material" means.',
   '- Criteria: (1) valuable or likely reusable; (2) important or necessary; (3) you are confident in it - do not archive what you are unsure about.',
   '- Never treat a computation result as "proved": whether an object is verified is still decided only by this preset\'s existing verification/consensus path.',
+  MATH_SUBSTITUTION_RULE_LINE_EN,
 ])
 
 export const MATH_SHELL_RULE_LINE_EN = '- Shell fallback: if the tool cannot run you may use the host shell, but mark the conclusion "not tool-archived (shell path)" - shell runs have no receipt and no timeout/output guarantees; only tool-routed computations count as reproducible supporting material.'
@@ -210,7 +223,14 @@ export function validateMathArgs(args, params) {
     if (typeof args.engine !== 'string') return bad('engine must be a string')
     if (args.engine !== 'auto' && !MATH_ENGINES[args.engine]) return bad('unknown engine: ' + args.engine)
   }
-  if (args.packages !== undefined && (!Array.isArray(args.packages) || args.packages.some((x) => typeof x !== 'string'))) return bad('packages must be a string[]')
+  if (args.packages !== undefined) {
+    if (!Array.isArray(args.packages) || args.packages.some((x) => typeof x !== 'string')) return bad('packages must be a string[]')
+    // round-6 (D): accept the manager-understood pass-through forms; refuse anything else explicitly.
+    for (const spec of args.packages) {
+      const parsed = parsePackageSpec(spec)
+      if (!parsed.ok) return bad(parsed.problem, 'MATH_INVALID_ARGUMENT', next('reason', { reason: 'unsupported-version-syntax' }))
+    }
+  }
   if (args.captureFiles !== undefined && (!Array.isArray(args.captureFiles) || args.captureFiles.some((x) => typeof x !== 'string'))) return bad('captureFiles must be a string[]')
   if (args.timeoutMs !== undefined) {
     const n = Number(args.timeoutMs)
@@ -266,14 +286,42 @@ function fail(code, engine, message, extra) {
   if (extra && extra.engines) out.engines = extra.engines
   if (extra && extra.available !== undefined) out.available = extra.available
   if (extra && extra.packages) out.packages = extra.packages
+  // round-7 (live-session fix): the probe diagnostic must survive into the response, otherwise
+  // "存在但不可用" is opaque (a real session showed exactly that).
+  if (extra && extra.probe) out.probe = jsonSafeDiag(extra.probe)
+  // round-9 (F7): the version-constraint policy travels with failures too (no silent drop).
+  if (extra && extra.versionPolicy) out.versionPolicy = extra.versionPolicy
+  if (extra && extra.constraintsNotEnforced) out.constraintsNotEnforced = extra.constraintsNotEnforced
   return out
 }
 
-function userInstallNext(engine) {
+// round-9 (real-engine finding): the suggested install command may not be runnable on this machine
+// (e.g. `winget` is absent), and handing a user a command that cannot run is misleading. So the
+// command is emitted ONLY when its package manager is actually resolvable; otherwise we return the
+// official vendor/download pointer plus an explicit note. Async because resolution goes through the host.
+async function userInstallNext(H, engine) {
   const d = MATH_ENGINES[engine] || {}
   const per = d.userInstall || {}
   const platform = process && process.platform === 'win32' ? 'windows' : (process && process.platform === 'darwin' ? 'macos' : 'linux')
-  return next('user-install', { engine: engine, perOs: per, command: per[platform] || '', platform: platform })
+  const raw = per[platform] || ''
+  const mgr = (function () { const m = /^\s*(winget|brew|apt-get|apt|choco|scoop|dnf|pacman|zypper)\b/.exec(String(raw)); return m ? m[1] : null })()
+  let available = true
+  if (mgr) {
+    try { available = !!(await H.resolveExecutable(mgr)) } catch (e) { available = false }
+  }
+  return next('user-install', {
+    engine: engine,
+    perOs: per,
+    command: (mgr && !available) ? '' : raw,
+    suggestedCommand: raw,
+    platform: platform,
+    packageManager: mgr,
+    packageManagerAvailable: mgr ? available : null,
+    vendorUrl: d.vendor || null,
+    note: (mgr && !available)
+      ? ('本机没有检测到包管理器 ' + mgr + '：建议命令无法运行，请按上面的官方地址手动安装（或先自行安装一个包管理器）。')
+      : null,
+  })
 }
 
 // ── host adaptation ─────────────────────────────────────────────────────────────────────────────
@@ -294,6 +342,9 @@ function adaptHost(host) {
     spawn: h.spawn,
     hasSubprocess: typeof h.hasSubprocess === 'function' ? h.hasSubprocess : null,
     listDir: typeof h.listDir === 'function' ? h.listDir : null,
+    // round-7 (fix 2): optional bundled-runtime discovery (absolute roots + absolute listing).
+    runtimeRoots: typeof h.runtimeRoots === 'function' ? h.runtimeRoots : null,
+    listDirAbs: typeof h.listDirAbs === 'function' ? h.listDirAbs : null,
     log: typeof h.log === 'function' ? h.log : function () {},
   }
   adapted.__mathHost = true
@@ -328,6 +379,42 @@ export async function probeMathEngines(host, opts) {
   return result
 }
 
+// round-9 (real-engine finding): an engine can be INSTALLED yet invisible, because discovery only
+// looked at the server process's PATH (R 4.6.1 landed in C:\Program Files\R\R-4.6.1\bin and was NOT
+// added to PATH). Add the known per-OS INSTALL locations, globbed by version, still AFTER PATH and
+// after the bundled runtime; existence is always proven by LISTING, never assumed.
+async function knownInstallCandidates(H, engineName) {
+  if (typeof H.listDirAbs !== 'function') return []
+  const cands = mathEngineCandidates(engineName)
+  if (!cands) return []
+  const env = (typeof process !== 'undefined' && process.env) || {}
+  const win = !!(typeof process !== 'undefined' && process.platform === 'win32')
+  const exts = win ? ['', '.exe', '.cmd'] : ['']
+  const out = []
+  const listDirs = async (dir) => { try { return ((await H.listDirAbs(dir)) || []).filter((e) => e && e.type === 'directory').map((e) => e.name) } catch (e) { return [] } }
+  const listFiles = async (dir) => { try { return ((await H.listDirAbs(dir)) || []).filter((e) => e && e.type === 'file').map((e) => e.name) } catch (e) { return [] } }
+  const match = async (dir) => {
+    const files = await listFiles(dir)
+    for (const c of cands) for (const x of exts) if (files.indexOf(c + x) !== -1) out.push(dir + '/' + c + x)
+  }
+  if (engineName === 'r') {
+    const roots = win
+      ? [String(env.ProgramFiles || 'C:/Program Files') + '/R', String(env['ProgramFiles(x86)'] || 'C:/Program Files (x86)') + '/R', env.LOCALAPPDATA ? String(env.LOCALAPPDATA) + '/Programs/R' : null]
+      : ['/usr/lib/R', '/Library/Frameworks/R.framework/Resources', '/usr/local/lib/R', '/opt/R', '/usr/lib64/R']
+    for (const root of roots) {
+      if (!root) continue
+      for (const d of await listDirs(root)) await match(root + '/' + d + '/bin') // windows versioned dirs
+      await match(root + '/bin')                                                 // unix / framework layout
+    }
+  } else if (engineName === 'python' && win) {
+    const local = env.LOCALAPPDATA ? String(env.LOCALAPPDATA) + '/Programs/Python' : null
+    for (const d of (local ? await listDirs(local) : [])) await match(local + '/' + d)
+    const pf = String(env.ProgramFiles || 'C:/Program Files')
+    for (const d of await listDirs(pf)) if (/^Python[0-9]/i.test(d)) await match(pf + '/' + d)
+  }
+  return Array.from(new Set(out))
+}
+
 async function resolveCandidate(H, d) {
   const cands = mathEngineCandidates(d.name)
   if (!cands) return null
@@ -337,20 +424,142 @@ async function resolveCandidate(H, d) {
       if (typeof p === 'string' && p) return p
     } catch (e) { /* not this one */ }
   }
+  // round-7 (fix 2): DSH ships its own runtimes; PATH always wins, so this is a LAST resort. The
+  // tree name is globbed (never hard-coded) and executable names come from the descriptor candidates.
+  for (const p of await dshRuntimeCandidates(H, d.name)) {
+    if (typeof p === 'string' && p) return p
+  }
+  // round-9: then the known per-OS install locations (an engine installed without touching PATH).
+  for (const p of await knownInstallCandidates(H, d.name)) {
+    if (typeof p === 'string' && p) return p
+  }
   return null
 }
 
-async function probeVersion(H, d, exe) {
-  const r = await H.spawn({ argv: [exe].concat(d.versionArgv || []), cwd: await H.projectRoot(), timeoutMs: 5000, stdoutCap: 8192, stderrCap: 8192 })
-  if (!r || r.timedOut) return { ok: false }
+// Generic discovery of a DSH-bundled runtime for one engine:
+//   <root>/dsh-runtimes/<tree>/dependencies/<engine>/<candidate><ext>
+// `runtimeRoots` and `listDirAbs` are OPTIONAL host fields (each preset knows its own home and fs);
+// when the host does not provide them this returns [] and behaviour is exactly as before.
+async function dshRuntimeCandidates(H, engineName) {
+  if (typeof H.listDirAbs !== 'function' || typeof H.runtimeRoots !== 'function') return []
+  const cands = mathEngineCandidates(engineName)
+  if (!cands) return []
+  let roots = []
+  try { roots = (await H.runtimeRoots()) || [] } catch (e) { return [] }
+  if (!Array.isArray(roots) || !roots.length) return []
+  const win = !!(typeof process !== 'undefined' && process.platform === 'win32')
+  const exts = win ? ['.exe', '.cmd', ''] : ['']
+  const dirAliases = engineName === 'r' ? ['r', 'R'] : [engineName]
+  const out = []
+  for (const root of roots) {
+    if (!root) continue
+    const base = String(root).replace(/[\\/]+$/, '') + '/dsh-runtimes'
+    let trees = []
+    try { trees = (await H.listDirAbs(base)) || [] } catch (e) { continue }
+    for (const tree of trees) {
+      if (!tree || tree.type !== 'directory' || !tree.name) continue
+      for (const dirName of dirAliases) {
+        const depDir = base + '/' + tree.name + '/dependencies/' + dirName
+        let entries = []
+        try { entries = (await H.listDirAbs(depDir)) || [] } catch (e) { continue }
+        // Only names the descriptor itself would look for (python3/python/py, …), so a bundled
+        // runtime cannot smuggle in an unrelated binary.
+        for (const c of cands) {
+          for (const ext of exts) {
+            const hit = entries.find((e) => e && e.type === 'file' && String(e.name) === c + ext)
+            if (hit) out.push(depDir + '/' + hit.name)
+          }
+        }
+      }
+    }
+  }
+  return Array.from(new Set(out))
+}
+
+// round-7 (live root cause): probe-ish spawns used `projectRoot()` as cwd, but on a BRAND-NEW session
+// that directory does not exist yet, and the host answers such a spawn with `spawned:true, exit:null`
+// (retries cannot help - same cwd, same result). Runs are unaffected because they write the receipt
+// (creating the tree) before spawning. So probes use a cwd that is guaranteed to exist: an explicit
+// host `probeCwd`, else the OS temp dir, else the project root.
+async function probeCwd(H) {
+  if (typeof H.probeCwd === 'function') {
+    try { const p = await H.probeCwd(); if (typeof p === 'string' && p) return p } catch (e) { /* fall through */ }
+  }
+  const env = (typeof process !== 'undefined' && process.env) || {}
+  const tmp = env.TEMP || env.TMPDIR || env.TMP
+  if (typeof tmp === 'string' && tmp) return tmp
+  return await H.projectRoot()
+}
+
+async function probeVersion(H, d, exe, opts) {
+  const o = opts || {}
+  const argv = [exe].concat(d.versionArgv || [])
+  const timeoutMs = Number(o.timeoutMs) || 20000 // a COLD host runner can take seconds; 5s was too tight
+  const r = await H.spawn({ argv: argv, cwd: await probeCwd(H), timeoutMs: timeoutMs, stdoutCap: 8192, stderrCap: 8192 })
+  const diag = {
+    argv: argv.slice(0, 3),
+    exit: r ? (r.exit === undefined ? null : r.exit) : null,
+    timedOut: !!(r && r.timedOut),
+    ms: r ? r.ms : null,
+    spawned: !!r,
+    stderrTail: String((r && r.stderr) || '').slice(-300),
+  }
+  if (!r) return { ok: false, version: 'unknown', diag: diag }
+  if (r.timedOut) return { ok: false, version: 'unknown', diag: diag }
   const m = new RegExp(d.versionRe).exec(String(r.stdout || '') + '\n' + String(r.stderr || ''))
-  return { ok: r.exit === 0 && !!m, version: m ? m[1] : 'unknown' }
+  return { ok: r.exit === 0 && !!m, version: m ? m[1] : 'unknown', diag: diag }
+}
+
+// round-7 (live-session fix): an engine that RESOLVED but whose version probe failed is retried once
+// with a longer budget WHEN the failure looks like a cold-start/timeout (timedOut, or a spawn that
+// produced no exit code). A deterministic failure (non-zero exit, unparsable output) is NOT retried -
+// retrying every failure would double every probe spawn. The diagnostic travels with the result
+// either way, so "存在但不可用" is never opaque.
+// round-7 (live regression): diagnostics must be JSON-SAFE. An earlier version stored a retry diag
+// that was the SAME object as its parent, so `JSON.stringify(response)` threw ("circular structure")
+// and the caller saw no probe result at all. Project plain fields only, never keep back-references.
+function jsonSafeDiag(d) {
+  if (!d || typeof d !== 'object') return null
+  const out = { argv: Array.isArray(d.argv) ? d.argv.map(String).slice(0, 4) : [] }
+  for (const k of ['exit', 'timedOut', 'ms', 'spawned', 'stderrTail', 'attempts', 'retried']) {
+    const v = d[k]
+    if (v === undefined) continue
+    out[k] = (v === null || typeof v === 'number' || typeof v === 'boolean' || typeof v === 'string') ? v : (Array.isArray(v) ? v.map((x) => (x && typeof x === 'object') ? jsonSafeDiag(x) : x) : null)
+  }
+  if (d.retryDiag) out.retryDiag = jsonSafeDiag(d.retryDiag)
+  return out
+}
+
+async function probeVersionWithRetry(H, d, exe) {
+  const attempts = []
+  let last = null
+  for (let i = 0; i < 3; i++) {
+    last = await probeVersion(H, d, exe, { timeoutMs: i === 0 ? 20000 : 45000 })
+    attempts.push(jsonSafeDiag(last.diag))
+    if (last.ok) break
+    // A NULL spawn (host returned nothing usable) and a timeout both look like the session-early
+    // flakiness the live test hit; a deterministic failure (non-zero exit, unparsable output) is not
+    // retried, so a genuinely broken engine is reported immediately instead of three times slower.
+    const looksCold = !!(last.diag && (last.diag.timedOut || last.diag.exit === null || !last.diag.spawned))
+    if (!looksCold) break
+    await new Promise((resolve) => setTimeout(resolve, 250 + i * 400))
+  }
+  if (last && last.diag) {
+    last.diag = jsonSafeDiag(last.diag)
+    last.diag.attempts = attempts.length
+    if (attempts.length > 1) {
+      last.diag.retried = true
+      // COPIES, never a reference to this same object (that produced the circular payload).
+      last.diag.retryDiag = attempts[attempts.length - 1]
+    }
+  }
+  return last
 }
 
 async function checkLicence(H, d, exe) {
   if (d.license !== 'commercial') return { ok: true }
   if (!d.licenseProbe) return { ok: false }
-  const r = await H.spawn({ argv: [exe].concat(d.licenseProbe.argv), cwd: await H.projectRoot(), timeoutMs: 10000, stdoutCap: 8192, stderrCap: 8192 })
+  const r = await H.spawn({ argv: [exe].concat(d.licenseProbe.argv), cwd: await probeCwd(H), timeoutMs: 10000, stdoutCap: 8192, stderrCap: 8192 })
   if (!r || r.timedOut || r.exit !== 0) return { ok: false }
   if (d.licenseProbe.okWhen === 'trim-1') return { ok: String(r.stdout || '').trim() === '1' }
   if (d.licenseProbe.okWhen === 'not-unlicensed') return { ok: !/Unlicensed/i.test(String(r.stdout || '')) }
@@ -370,26 +579,42 @@ async function resolveEngine(H, requested, params, args) {
       if (params.mathMode !== 'typed+shell') return fail('MATH_REFUSED', name, 'cli 被策略禁用（mathMode=' + params.mathMode + '）', { next: next('reason', { reason: 'policy' }) })
       let exe = null
       try { exe = await H.resolveExecutable(args.cli.command) } catch (e) { exe = null }
-      if (!exe) return fail('MATH_ENGINE_NOT_FOUND', name, 'cli 命令无法解析：' + args.cli.command, { next: userInstallNext('cli') })
-      return { ok: true, name: name, desc: d, exe: exe, version: 'unknown' }
+      if (!exe) return fail('MATH_ENGINE_NOT_FOUND', name, 'cli 命令无法解析：' + args.cli.command, { next: await userInstallNext(H, 'cli') })
+      // round-7 (finding 5): report the REAL version when the command's family is recognisable (the
+      // descriptor for that family carries the version probe); unknown commands stay 'unknown'.
+      let cliVersion = 'unknown'
+      let cliProbe = null
+      const fam = engineFamilyForExe(exe)
+      if (fam && MATH_ENGINES[fam]) {
+        const fv = await probeVersionWithRetry(H, MATH_ENGINES[fam], exe)
+        cliProbe = fv.diag || null
+        if (fv.ok) cliVersion = fv.version
+      }
+      return { ok: true, name: name, desc: d, exe: exe, version: cliVersion, family: fam || null, probe: cliProbe }
     }
     const hit = await resolveCandidate(H, d)
     if (!hit) continue
-    const v = await probeVersion(H, d, hit)
+    const v = await probeVersionWithRetry(H, d, hit)
     if (!v.ok) {
       if (d.license === 'commercial' || d.versionOptional) {
         const lic = await checkLicence(H, d, hit)
         if (!lic.ok) return fail('MATH_ENGINE_LICENSE_REQUIRED', name, name + ' 已安装但许可不可用（仅厂商可激活）', { next: next('vendor', { engine: name, url: d.vendor || '' }) })
         return { ok: true, name: name, desc: d, exe: hit, version: 'unknown' }
       }
-      return fail('MATH_ENGINE_UNUSABLE', name, name + ' 存在但不可用（版本探针失败）', { next: userInstallNext(name) })
+      // round-7 (live-session fix): the engine WAS found - so an install guide would be misleading
+      // (the user does not need to install anything; the host path is what failed). Report the probe
+      // diagnostic instead and keep the escape hatch advisory.
+      return fail('MATH_ENGINE_UNUSABLE', name, name + ' 存在但不可用（版本探针失败：exit=' + String(v.diag.exit) + (v.diag.timedOut ? '，超时' : '') + '，argv=' + JSON.stringify(v.diag.argv) + '）', {
+        probe: v.diag,
+        next: next('note', { guidance: '引擎已找到但探测失败：请检查宿主 subprocess 通路（冷启动/超时/权限），或用 mathEngineOverride 调整 versionArgv 模板；已装的引擎不需要重装。' }),
+      })
     }
     const lic = await checkLicence(H, d, hit)
     if (!lic.ok) return fail('MATH_ENGINE_LICENSE_REQUIRED', name, name + ' 已安装但许可不可用（仅厂商可激活）', { next: next('vendor', { engine: name, url: d.vendor || '' }) })
     return { ok: true, name: name, desc: d, exe: hit, version: v.version }
   }
   const first = requested === 'auto' ? (params.mathEngines[0] || 'python') : requested
-  return fail('MATH_ENGINE_NOT_FOUND', first, '本机没有可用的计算引擎（试过：' + names.join(', ') + '）', { next: userInstallNext(first) })
+  return fail('MATH_ENGINE_NOT_FOUND', first, '本机没有可用的计算引擎（试过：' + names.join(', ') + '）', { next: await userInstallNext(H, first) })
 }
 
 // ── package probe ───────────────────────────────────────────────────────────────────────────────
@@ -397,26 +622,63 @@ function buildProbeArgv(d, pkgs) {
   const quoted = pkgs.map((p) => '"' + String(p).replace(/"/g, '') + '"').join(',')
   const plain = pkgs.join(',')
   const code = String(d.probeCode || '').replace(/__QPKGS__/g, quoted).replace(/__PKGS__/g, plain)
-  return (d.packageProbe.argv || []).map((a) => a === '<probeCode>' ? code : a === '<pkgs>' ? plain : a)
+  const out = []
+  for (const a of (d.packageProbe.argv || [])) {
+    // `<pkgs...>` expands to ONE argv item per package (probes that read `sys.argv`); `<pkgs>` stays
+    // the comma-joined string for templates that interpolate it into code (R/Julia/Octave).
+    if (a === '<probeCode>') out.push(code)
+    else if (a === '<pkgs>') out.push(plain)
+    else if (a === '<pkgs...>') for (const p of pkgs) out.push(String(p))
+    else out.push(a)
+  }
+  return out
 }
 
 async function probePackages(H, det, pkgs) {
+  // round-6 (D): presence is probed by BASE NAME (a version constraint is the manager's business);
+  // the full spec is what the install plan passes through.
+  const names = []
+  for (const s of pkgs) { const n = parsePackageSpec(s).name || String(s); if (names.indexOf(n) === -1) names.push(n) }
   const found = {}
-  for (const p of pkgs) found[p] = null
-  if (!pkgs.length || !det.desc.packageProbe) return { requested: pkgs.slice(), found: found }
-  const r = await H.spawn({ argv: [det.exe].concat(buildProbeArgv(det.desc, pkgs)), cwd: await H.projectRoot(), timeoutMs: 15000, stdoutCap: 16384, stderrCap: 16384 })
-  if (r && !r.timedOut) {
-    if (det.desc.packageProbe.parse === 'lines') {
-      const text = String(r.stdout || '')
-      for (const p of pkgs) if (new RegExp('(^|\\s)' + p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '(\\s|$)', 'm').test(text)) found[p] = 'present'
-    } else {
-      for (const tok of String(r.stdout || '').split('|')) {
-        const idx = tok.indexOf(':')
-        if (idx <= 0) continue
-        const name = tok.slice(0, idx).trim()
-        const state = tok.slice(idx + 1).trim()
-        if (Object.prototype.hasOwnProperty.call(found, name)) found[name] = (state === 'ok' || state === '1' || state === 'TRUE' || state === 'True') ? 'present' : null
+  for (const p of names) found[p] = null
+  if (!names.length || !det.desc.packageProbe) return { requested: names, found: found }
+  const argv = [det.exe].concat(buildProbeArgv(det.desc, names))
+  // round-7 (live-session fix): a NULL spawn (the host's subprocess seam returned nothing - seen in
+  // real sessions right after session start) or a timeout must NOT be reported as "package missing".
+  // Retry a couple of times, and if the precheck still cannot run, say so explicitly (fail-open).
+  let r = null
+  const attempts = []
+  for (let i = 0; i < 3; i++) {
+    r = await H.spawn({ argv: argv, cwd: await probeCwd(H), timeoutMs: 15000 + i * 15000, stdoutCap: 16384, stderrCap: 16384 })
+    attempts.push(r ? { exit: r.exit === undefined ? null : r.exit, timedOut: !!r.timedOut } : null)
+    const usable = !!(r && !r.timedOut && r.exit !== null && r.exit !== undefined)
+    if (usable) break
+    await new Promise((resolve) => setTimeout(resolve, 250 + i * 400))
+  }
+  const ran = !!(r && !r.timedOut && r.exit !== null && r.exit !== undefined)
+  if (!ran) return { requested: names, found: found, probeFailed: true, attempts: attempts, argv: argv.slice(0, 3) }
+  if (det.desc.packageProbe.parse === 'lines') {
+    const text = String(r.stdout || '')
+    for (const p of pkgs) if (new RegExp('(^|\\s)' + p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '(\\s|$)', 'm').test(text)) found[p] = 'present'
+  } else {
+    // Accept BOTH shapes: `name:ok|name:missing` (historical) and one-per-line `name ok` (round-7:
+    // the probe codes avoid shell metacharacters such as `|`, which a real host's spawn rejected).
+    for (const rawTok of String(r.stdout || '').split(/[|\n]/)) {
+      const tok = rawTok.trim()
+      if (!tok) continue
+      let name = ''
+      let state = ''
+      const idx = tok.indexOf(':')
+      if (idx > 0) {
+        name = tok.slice(0, idx).trim()
+        state = tok.slice(idx + 1).trim()
+      } else {
+        const m = /^(\S+)\s+(\S+)$/.exec(tok)
+        if (!m) continue
+        name = m[1]
+        state = m[2]
       }
+      if (Object.prototype.hasOwnProperty.call(found, name)) found[name] = (state === 'ok' || state === '1' || state === 'TRUE' || state === 'True') ? 'present' : null
     }
   }
   return { requested: pkgs.slice(), found: found }
@@ -427,7 +689,24 @@ function assembleArgv(det, mode, payload) {
   const d = det.desc
   if (det.name === 'cli') {
     const cliArgv = (payload.cli && Array.isArray(payload.cli.argv)) ? payload.cli.argv : []
-    return { argv: [det.exe].concat(cliArgv), cli: { command: payload.cli.command, argv: cliArgv } }
+    const argv = [det.exe].concat(cliArgv)
+    // round-7 (finding 4): with mode:'code' the script is archived as `script.txt`, but the caller
+    // cannot know the runId in advance - so the archived script path is appended automatically and
+    // the documented "run this code" flow actually RUNS it (instead of dropping into a REPL, exit 0,
+    // empty stdout).
+    // round-7 (live nuance): ONLY when the caller's argv does not already provide a program slot.
+    // `python -c 'print(1)'` runs the caller's code, and appending the archived file would silently
+    // feed it as `sys.argv[1]` - the caller's argv must win there.
+    const runsOwnCode = cliArgv.some((a) => a === '-c' || a === '-m' || a === '-e' || a === '--eval' || a === '--command')
+    const appendScript = !!payload.scriptAbs && (mode === 'code' || mode === 'file') && !runsOwnCode
+    if (appendScript) argv.push(payload.scriptAbs)
+    return {
+      argv: argv,
+      cli: {
+        command: payload.cli.command, argv: cliArgv, scriptAppended: appendScript,
+        scriptSkipped: (!!payload.scriptAbs && (mode === 'code' || mode === 'file') && runsOwnCode) ? 'caller argv already provides a program slot (-c/-m/-e/--eval)' : null,
+      },
+    }
   }
   if (mode === 'code' || mode === 'file') {
     return { argv: [det.exe].concat((d.scriptArgv || []).map((a) => a === '<script>' ? payload.scriptAbs : a)) }
@@ -439,6 +718,19 @@ function assembleArgv(det, mode, payload) {
   return { refused: 'unknown mode' }
 }
 
+// round-7 (findings 3/5): for `engine:'cli'` the descriptor is generic, so the FAMILY of the resolved
+// command has to be inferred from its basename to (a) run the right package precheck and (b) report a
+// real version. Unknown commands are reported as unknown and their package precheck is SKIPPED (a
+// false "missing" must never block the escape hatch).
+function engineFamilyForExe(exe) {
+  const base = String(exe || '').replace(/\\/g, '/').split('/').pop().toLowerCase().replace(/\.(exe|cmd|bat|sh)$/, '')
+  if (/^python[0-9.]*$/.test(base) || base === 'py') return 'python'
+  if (base === 'rscript' || base === 'r') return 'r'
+  if (base === 'octave' || base === 'octave-cli') return 'octave'
+  if (base === 'julia') return 'julia'
+  return null
+}
+
 // AUDIT-B FIX (HIGH): `applyOverride` used to read only `params.mathEngineOverride`, which no preset
 // can ever set (the six frozen params are copied verbatim by effectiveMathParams), while the tool
 // description, MATH_BAD_ARGV_HINT and the BAD_ARGV message all advertised it. The per-call ARGUMENT
@@ -561,18 +853,67 @@ async function opProbe(H, args, params) {
   const probe = await probeMathEngines(H, { refresh: !!(args.packages && args.packages.indexOf('refresh') !== -1) })
   const pkgs = (args.packages || []).filter((p) => p !== 'refresh')
   const want = pkgs.length ? pkgs : params.mathPackages
+  // round-7 (fix 1): a probe that NAMES an engine must describe THAT engine. Previously the response
+  // carried `engine: null` (or the first ALLOWED engine) and the failure path always blamed
+  // `params.mathEngines[0]` (python) - so `probe {engine:'r'}` echoed python and told the user to
+  // install python. Resolve the requested engine up front instead.
+  const requested = (args.engine && args.engine !== 'auto') ? String(args.engine) : null
+  const chosen = requested
+    ? await resolveEngine(H, requested, params, args)
+    : (probe.engines.length ? await resolveEngine(H, probe.engines[0].name, params, args) : null)
   let packages = { requested: want.slice(), found: {} }
-  if (want.length && probe.engines.length) {
-    const det = await resolveEngine(H, args.engine && args.engine !== 'auto' ? args.engine : probe.engines[0].name, params, args)
-    if (det.ok) packages = await probePackages(H, det, want)
+  const probeDet = familyProbeDet(chosen)
+  if (want.length && probeDet) packages = await probePackages(H, probeDet, want)
+  else if (want.length && chosen && chosen.ok && chosen.name === 'cli') packages = { requested: want.map((s) => parsePackageSpec(s).name || s), found: {}, precheckSkipped: 'engine=cli：无法从命令名判断引擎族（不阻塞）' }
+  if (requested && chosen && !chosen.ok) {
+    // Policy/absence refusal for the REQUESTED engine, with its own guidance.
+    const out = Object.assign({}, chosen)
+    out.op = 'probe'
+    out.engines = probe.engines
+    out.available = !!probe.available
+    out.packages = packages
+    return out
   }
-  if (!probe.available) {
-    const first = params.mathEngines[0] || 'python'
-    const out = fail('MATH_ENGINE_NOT_FOUND', first, '本机没有可用的计算引擎', { next: userInstallNext(first), engines: [], available: false, packages: packages })
+  if (!probe.available && !(chosen && chosen.ok)) {
+    const first = requested || params.mathEngines[0] || 'python'
+    const out = fail('MATH_ENGINE_NOT_FOUND', first, '本机没有可用的计算引擎（请求：' + first + '）', { next: await userInstallNext(H, first), engines: [], available: false, packages: packages })
     out.op = 'probe'
     return out
   }
-  return { ok: true, op: 'probe', engine: null, engines: probe.engines, available: true, packages: packages, message: '可用引擎：' + probe.engines.map((e) => e.name + ' ' + e.version).join('、') }
+  // A REQUESTED engine that resolved (e.g. `cli`, or a runtime-discovered interpreter) counts as
+  // available even when auto-detection found nothing - otherwise probe denied what run would do.
+  const engines = probe.engines.slice()
+  if (chosen && chosen.ok && !engines.some((e) => e.name === chosen.name)) {
+    engines.push({ name: chosen.name, path: chosen.exe, version: chosen.version, license: (MATH_ENGINES[chosen.name] || {}).license })
+  }
+  const engineInfo = (chosen && chosen.ok) ? { name: chosen.name, path: chosen.exe, version: chosen.version } : null
+  // round-9 (F3): the availability line must never be silently partial - name the CONFIGURED engines
+  // that were not found (and why), instead of just listing the ones that happened to resolve.
+  const foundNames = engines.map((e) => e.name)
+  // Per-engine absence explanation. The key is `why` (NOT the reserved machine-readable vocabulary
+  // key), so the parity guard's exhaustive `next.reason` set stays exactly the refusal vocabulary.
+  const absent = params.mathEngines.filter((e) => foundNames.indexOf(e) === -1).map((e) => {
+    if (MATH_ENGINES[e] && MATH_ENGINES[e].resolveFrom === 'cli.command') return { engine: e, why: 'needs-a-caller-supplied-command' }
+    return { engine: e, why: 'not-found-on-this-machine' }
+  })
+  return {
+    ok: true, op: 'probe', engine: engineInfo ? engineInfo.name : null, engineInfo: engineInfo,
+    engines: engines, available: true, packages: packages,
+    configured: params.mathEngines.slice(), absent: absent,
+    message: '可用引擎：' + engines.map((e) => e.name + ' ' + e.version).join('、')
+      + (engineInfo ? '（请求 ' + engineInfo.name + '：' + engineInfo.version + '）' : '')
+      + (absent.length ? '；已配置但本机未发现：' + absent.map((a) => a.engine).join('、') : '；已配置的引擎都在'),
+  }
+}
+
+// round-7 (finding 3): a cli command has no package probe of its own, so the FAMILY descriptor of
+// the resolved executable must provide one. Returns null when the family is unknown - the caller then
+// SKIPS the precheck (never a false "missing", which blocked the escape hatch).
+function familyProbeDet(det) {
+  if (!det || det.name !== 'cli') return det
+  const fam = det.family || engineFamilyForExe(det.exe)
+  const fd = fam ? MATH_ENGINES[fam] : null
+  return (fd && fd.packageProbe) ? { ok: true, name: fam, desc: fd, exe: det.exe, version: det.version } : null
 }
 
 // ── op: run ─────────────────────────────────────────────────────────────────────────────────────
@@ -588,13 +929,24 @@ async function opRun(H, args, params) {
   const engineLabel = det.name === 'cli' ? ('cli:' + cliCommand) : det.name
 
   const want = (args.packages && args.packages.length) ? args.packages : params.mathPackages
-  const pk = await probePackages(H, det2, want)
-  const missing = want.filter((p) => Object.prototype.hasOwnProperty.call(pk.found, p) && !pk.found[p])
+  // round-9 (F7): version constraints are NOT enforced - we only check existence by base name.
+  const pinnedSpecs = want.filter((sp) => parsePackageSpec(sp).pinned)
+  const versionPolicy = 'version-constraints-are-existence-only: 只按 base name 检查是否存在，约束本身从不校验（版本求解交给包管理器）' + (pinnedSpecs.length ? '；本次未校验的约束：' + pinnedSpecs.join(', ') : '；本次没有版本约束')
+  // round-7 (finding 3): for cli the precheck runs against the FAMILY of `cli.command` (same
+  // discovery-shaped logic); an unrecognisable command SKIPS the precheck instead of reporting a
+  // false "missing" that would block the escape hatch.
+  const probeDet = familyProbeDet(det2)
+  const pk = probeDet ? await probePackages(H, probeDet, want) : { requested: want.map((s) => parsePackageSpec(s).name || s), found: {} }
+  // Presence is keyed by BASE NAME (round-6 D); the plan keeps the original specs so the manager
+  // receives the version constraint verbatim. round-7: a precheck that could not RUN (null spawn /
+  // timeout) must not be read as "missing" - that misled a real session.
+  const missing = (probeDet && !pk.probeFailed) ? want.map((s) => parsePackageSpec(s).name || s).filter((p) => Object.prototype.hasOwnProperty.call(pk.found, p) && !pk.found[p]) : []
   if (missing.length) {
-    return fail('MATH_MISSING_PACKAGES', det.name, '需要的包未安装：' + missing.join(', '), {
+    return fail('MATH_MISSING_PACKAGES', det.name, '需要的包未安装：' + missing.join(', ') + '（只检查是否存在；版本求解交给包管理器）', {
       missing: missing,
-      next: next('agent-install', { engine: det.name, packages: missing, dryRun: true }),
+      next: next('agent-install', { engine: det.name, packages: missing, specs: want.slice(), dryRun: true }),
       packages: pk,
+      versionPolicy: versionPolicy, constraintsNotEnforced: pinnedSpecs.slice(),
     })
   }
 
@@ -602,10 +954,17 @@ async function opRun(H, args, params) {
   let scriptText = ''
   let fileRel = null
   let sourceHashBefore = null
+  // round-9 (N1): `mode:'file'` is keyed by the SOURCE PATH, so re-running an ORIGINAL source lands on
+  // the same archive id (attempt>=2, scriptChanged). Pointing it at an ARCHIVED script instead targets
+  // a different path and therefore a NEW archive id by design - the prior attempt is never touched, but
+  // there is no previous receipt FOR THAT ID, so scriptChanged/previousReceipt are necessarily empty.
+  // That is not a bug, but it must be SAID rather than looking like broken change detection.
+  let archivedScriptSource = false
   if (mode === 'code') scriptText = args.code
   else if (mode === 'file') {
     fileRel = projectRel('', args.file)
     if (fileRel === null) return fail('MATH_REFUSED', det.name, 'file 必须位于项目内：' + args.file, { next: next('reason', { reason: 'path-outside-project' }) })
+    archivedScriptSource = /^Computation\//.test(String(fileRel))
     const txt = await H.readText(fileRel)
     if (txt === undefined) return fail('MATH_REFUSED', det.name, '找不到文件：' + args.file, { next: next('reason', { reason: 'file-not-found' }) })
     scriptText = txt
@@ -669,6 +1028,9 @@ async function opRun(H, args, params) {
   }
 
   const warnings = []
+  if (archivedScriptSource) warnings.push(warning('ARCHIVED_SCRIPT_RERUN', 'mode:\'file\' 指向的是**归档脚本**（Computation/…）：按设计归档 id 以**源路径**为键，所以这是一次**新归档**（新目录、attempt 1），没有该 id 的历史回执 ⇒ scriptChanged/previousReceipt 为空是**预期**，且**旧 attempt 绝不会被覆盖**。要做"编辑→重跑→attempt≥2 + scriptChanged"的核对，请把 mode:\'file\' 指向**原始源文件**并编辑它，而不是指向归档副本。'))
+  if (!probeDet && want.length) warnings.push(warning('PACKAGE_PRECHECK_SKIPPED', 'engine=cli：无法从命令名判断引擎族，已跳过包预检（不阻塞执行，也不会误报缺包）；如需预检请直接用 python/r/octave/julia 或改用可识别的解释器路径。'))
+  if (pk && pk.probeFailed && want.length) warnings.push(warning('PACKAGE_PRECHECK_UNKNOWN', '包预检未能执行（宿主 subprocess 在这几次尝试里返回空/超时，会话早期常见）：本次不判定缺包、不阻塞执行；如需确定性结论请重试或直接用对应引擎。probe=' + JSON.stringify(pk.argv) + ' attempts=' + JSON.stringify(pk.attempts)))
   if (fullOut.length > MATH_CAPS.stdout) warnings.push(warning('OUTPUT_TRUNCATED', 'stdout 超过 64KB，完整版见 ' + dir + '/stdout.txt'))
   if (scriptChanged) warnings.push(warning(MATH_SCRIPT_CHANGED_WARNING, 'scriptChanged：文件 ' + fileRel + ' 自上一次回执以来已改变（旧回执不再代表当前代码），本次已写出新 attempt ' + attempt + '。'))
   if (scriptChangedDuringRun) warnings.push(warning(MATH_SCRIPT_CHANGED_DURING_RUN_WARNING, 'scriptChangedDuringRun：文件 ' + fileRel + ' 在本次运行期间被改动（可能有另一个成员在编辑）；本次回执的 scriptHash 是运行前版本 ' + String(sourceHashBefore).slice(0, 12) + '…，请重跑后再引用。'))
@@ -681,7 +1043,15 @@ async function opRun(H, args, params) {
     engine: { name: engineLabel, path: det.exe, version: det.version, source: det.name === 'cli' ? 'cli' : 'path' },
     script: { path: scriptRel, sha256: scriptHash, bytes: Buffer.byteLength(scriptText, 'utf8') },
     scriptPath: scriptRel, scriptHash: scriptHash,
+    // round-8 (P0/D3): member file tools are session-cwd relative, so the ABSOLUTE locations must be
+    // in the receipt: `scriptAbs` is directly openable, `cwd` is the project root to join with.
+    scriptAbs: scriptAbs, cwd: root,
     sourceFile: fileRel || null,
+    fileIsArchivedScript: archivedScriptSource,
+    // round-9 (N2): a TIMEOUT must still carry the evidence it produced - the capped partial output
+    // lives in the receipt as well as in stdout.txt/stderr.txt on disk.
+    partialStdout: String(fullOut).slice(-2000),
+    partialStderr: String(fullErr).slice(-2000),
     sourceHashBefore: sourceHashBefore, sourceHashAfter: sourceHashAfter,
     scriptChanged: scriptChanged, scriptChangedDuringRun: scriptChangedDuringRun,
     previousReceipt: prevReceipt ? { runId: prevReceipt.runId, attempt: prevReceipt.attempt || 1, scriptHash: prevReceipt.scriptHash || (prevReceipt.script && prevReceipt.script.sha256) || null } : null,
@@ -698,7 +1068,7 @@ async function opRun(H, args, params) {
     warnings: warnings,
     determinism: { inputSha256: input, packagesSorted: true, noWallClockInId: true },
   }
-  if (assembled.cli) receipt.cli = { command: assembled.cli.command, argv: assembled.cli.argv, stdinUsed: false }
+  if (assembled.cli) receipt.cli = { command: assembled.cli.command, argv: assembled.cli.argv, stdinUsed: false, scriptAppended: !!assembled.cli.scriptAppended, scriptSkipped: assembled.cli.scriptSkipped || null }
   const receiptJson = JSON.stringify(receipt, null, 2)
   await H.writeText(dir + '/receipt.json', receiptJson)
   await H.writeText(dir + '/receipt.md', renderReceiptMd(receipt, fullOut, fullErr))
@@ -707,13 +1077,22 @@ async function opRun(H, args, params) {
 
   const shell = {
     ok: true, op: 'run', engine: engineLabel, mode: mode,
+    runId: runId, attempt: attempt,
+    versionPolicy: versionPolicy, constraintsNotEnforced: pinnedSpecs.slice(),
     engineInfo: receipt.engine,
     argv: assembled.argv.slice(),
     scriptPath: scriptRel, scriptHash: scriptHash,
+    scriptAbs: scriptAbs, cwd: root,
     attempt: attempt, attemptDir: dir, baseRunDir: baseDir,
     scriptChanged: scriptChanged, scriptChangedDuringRun: scriptChangedDuringRun,
     sourceFile: fileRel || null,
+    fileIsArchivedScript: archivedScriptSource,
+    // round-9 (N2): a TIMEOUT must still carry the evidence it produced - the capped partial output
+    // lives in the receipt as well as in stdout.txt/stderr.txt on disk.
+    partialStdout: String(fullOut).slice(-2000),
+    partialStderr: String(fullErr).slice(-2000),
     previousReceipt: receipt.previousReceipt,
+    cliScriptAppended: !!(receipt.cli && receipt.cli.scriptAppended),
     packages: pk.found,
     exit: receipt.exit, timedOut: receipt.timedOut, ms: receipt.ms,
     stdout: fullOut.slice(0, MATH_CAPS.stdout), stderr: fullErr.slice(0, MATH_CAPS.stderr),
@@ -721,8 +1100,13 @@ async function opRun(H, args, params) {
     warnings: warnings,
   }
   if (receipt.timedOut) {
-    return Object.assign(fail('MATH_TIMEOUT', engineLabel, '执行超时（' + timeoutMs + 'ms）已被终止', { argv: assembled.argv.slice(), receipt: receiptRef }),
-      archiveFields(), { ms: receipt.ms, timedOut: true })
+    // round-9 (F5): failure EVIDENCE must be uniform - a timeout carries the SAME fields a non-zero
+    // exit does (exit + stderr), plus timedOut:true.
+    const out = fail('MATH_TIMEOUT', engineLabel, '执行超时（' + timeoutMs + 'ms）已被终止', { argv: assembled.argv.slice(), receipt: receiptRef })
+    out.exit = null
+    out.stdout = String(fullOut).slice(0, MATH_CAPS.stdout)
+    out.stderr = String(fullErr).slice(0, MATH_CAPS.stderr)
+    return Object.assign(out, archiveFields(), { ms: receipt.ms, timedOut: true })
   }
   if (r.exit !== 0) {
     const blob = fullErr + '\n' + fullOut
@@ -832,15 +1216,44 @@ async function opInstall(H, args, params) {
     })
   }
   const scope = args.scope || params.mathInstallScope || 'user' // per-call only; never persisted anywhere
-  const tmpl = scope === 'system' ? d.install.systemArgv : d.install.userArgv
-  if (!tmpl) return fail('MATH_REFUSED', engineName, engineName + ' 不支持 system 作用域（只提供用户级安装）', { next: next('reason', { reason: 'system-scope-unsupported' }) })
+  // round-6 (B): resolve the interpreter the SAME way the run path does (the descriptor's candidate
+  // list, in order) so the plan targets the interpreter that will actually run - and so the manager
+  // detection sees that interpreter's REAL path (a conda `python3` is not a bare `python`).
   let exe = engineName
-  try { exe = (await H.resolveExecutable(engineName === 'r' ? 'Rscript' : engineName)) || engineName } catch (e) { exe = engineName }
+  {
+    const cands = mathEngineCandidates(engineName) || [engineName === 'r' ? 'Rscript' : engineName]
+    for (const c of cands) {
+      try { const hit = await H.resolveExecutable(c); if (hit) { exe = hit; break } } catch (e) { /* try the next candidate */ }
+    }
+  }
+  // round-6 (B): python dispatches on the DETECTED environment; every other engine keeps its own
+  // single template. The chosen manager (and whether it is only an assumption) is part of the plan.
+  let managerInfo = null
+  let mgrTmpl = null
+  if (d.install.managers) {
+    managerInfo = await detectPythonManager(H, exe)
+    mgrTmpl = d.install.managers[managerInfo.manager] || null
+  }
+  const activeManager = managerInfo ? managerInfo.manager : d.install.manager
+  const userTmpl = (mgrTmpl && mgrTmpl.userArgv) || d.install.userArgv
+  const systemTmpl = (mgrTmpl && mgrTmpl.systemArgv) || (mgrTmpl ? null : d.install.systemArgv)
+  const tmpl = scope === 'system' ? systemTmpl : userTmpl
+  if (!tmpl) {
+    // round-6 (C): the refusal says WHY per engine (or per detected manager) instead of a generic line.
+    const why = (mgrTmpl && mgrTmpl.systemUnsupportedReason) || d.install.systemUnsupportedReason || '该引擎只提供用户级安装'
+    return fail('MATH_REFUSED', engineName, engineName + ' 不支持 system 作用域：' + why, { next: next('reason', { reason: 'system-scope-unsupported' }) })
+  }
+  const uninstallTmpl = (mgrTmpl && mgrTmpl.uninstallArgv) || d.install.uninstallArgv
   const commands = args.packages.map((p) => ({ argv: substInstall(tmpl, engineName, exe, p), why: '缺少 ' + p }))
-  const plan = { engine: engineName, scope: scope, manager: d.install.manager, commands: commands, note: scope === 'user' ? '将安装到用户级目录' : '仅本次系统作用域（不会被记住）' }
+  const plan = {
+    engine: engineName, scope: scope, manager: activeManager, commands: commands,
+    managerAssumed: !!(managerInfo && managerInfo.assumed), managerWhy: managerInfo ? managerInfo.why : '',
+    versionPolicy: '版本求解交给包管理器（本工具只检查是否已安装，并把 pkg<op>version 原样透传）',
+    note: scope === 'user' ? '将安装到用户级目录' : '仅本次系统作用域（不会被记住）',
+  }
   const planToken = sha256(JSON.stringify({ engine: engineName, packages: args.packages, scope: scope, commands: commands }) + '|planVersion=1').slice(0, 32)
   if (!args.confirm) {
-    return { ok: true, op: 'install', engine: engineName, plan: plan, planToken: planToken, next: next('agent-install', { dryRun: true }), message: '安装计划（尚未执行）：' + commands.map((c) => c.argv.join(' ')).join(' ; ') }
+    return { ok: true, op: 'install', engine: engineName, plan: plan, planToken: planToken, next: next('agent-install', { dryRun: true, manager: activeManager, managerAssumed: !!plan.managerAssumed }), message: '安装计划（尚未执行，管理器=' + activeManager + (plan.managerAssumed ? '（假设：' + plan.managerWhy + '）' : '') + '）：' + commands.map((c) => c.argv.join(' ')).join(' ; ') }
   }
   if (args.confirm !== planToken) {
     return fail('MATH_REFUSED', engineName, 'planToken 不匹配（计划可能已变），请重新出计划', { next: next('reason', { reason: 'plan-token-mismatch' }) })
@@ -851,7 +1264,7 @@ async function opInstall(H, args, params) {
     const r = await H.spawn({ argv: c.argv, cwd: await H.projectRoot(), timeoutMs: timeoutMs, stdoutCap: MATH_CAPS.file, stderrCap: MATH_CAPS.file })
     results.push({ argv: c.argv, exit: r ? r.exit : null, timedOut: !!(r && r.timedOut), ms: r ? r.ms : 0, stdoutTail: String((r && r.stdout) || '').slice(-2000), stderrTail: String((r && r.stderr) || '').slice(-2000) })
     if (!r || r.timedOut || r.exit !== 0) {
-      const audit0 = { schema: 'vibe-math/math-computation-install@1', planToken: planToken, scope: scope, manager: d.install.manager, commands: commands, results: results, exit: r ? r.exit : null, timedOut: !!(r && r.timedOut), installed: args.packages, rollback: rollbackFor(d, exe, args.packages), network: 'not-enforced-by-plugin' }
+      const audit0 = { schema: 'vibe-math/math-computation-install@1', planToken: planToken, scope: scope, manager: activeManager, commands: commands, results: results, exit: r ? r.exit : null, timedOut: !!(r && r.timedOut), installed: args.packages, rollback: rollbackFor(d, exe, args.packages, uninstallTmpl), network: 'not-enforced-by-plugin' }
       await H.writeText('Computation/installs/' + planToken + '.json', JSON.stringify(audit0, null, 2))
       const code = (r && r.timedOut) ? 'MATH_TIMEOUT' : 'MATH_NONZERO_EXIT'
       const out = fail(code, engineName, '安装失败（' + c.argv.join(' ') + '）：' + (r ? ('exit=' + r.exit) : 'no subprocess'), { next: next('note', { audit: 'Computation/installs/' + planToken + '.json' }) })
@@ -859,13 +1272,54 @@ async function opInstall(H, args, params) {
       return out
     }
   }
-  const audit = { schema: 'vibe-math/math-computation-install@1', planToken: planToken, scope: scope, manager: d.install.manager, commands: commands, results: results, exit: 0, timedOut: false, installed: args.packages, before: {}, after: {}, rollback: rollbackFor(d, exe, args.packages), network: 'not-enforced-by-plugin' }
+  const audit = { schema: 'vibe-math/math-computation-install@1', planToken: planToken, scope: scope, manager: activeManager, commands: commands, results: results, exit: 0, timedOut: false, installed: args.packages, before: {}, after: {}, rollback: rollbackFor(d, exe, args.packages, uninstallTmpl), network: 'not-enforced-by-plugin' }
   await H.writeText('Computation/installs/' + planToken + '.json', JSON.stringify(audit, null, 2))
   return { ok: true, op: 'install', engine: engineName, executed: true, scope: scope, audit: 'Computation/installs/' + planToken + '.json', message: '已安装：' + args.packages.join(', ') + '（审计：Computation/installs/' + planToken + '.json）' }
 }
 
-function rollbackFor(d, exe, packages) {
-  const tmpl = d.install && d.install.uninstallArgv
+// ── round-6 (B/D): package specs + Python package-manager dispatch ──────────────────────────────
+// Version SOLVING is delegated to the package manager: the tool only checks presence (by base name)
+// and passes the spec through. The accepted grammar is small and manager-understood; anything else
+// (spaces, `;`, `|`, `&`, `$`, backticks, `@`, parentheses, empty) is refused with an explicit
+// reason instead of being handed to a shell.
+const PKG_SPEC_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*(\[[A-Za-z0-9._,-]+\])?(?:(?:==|>=|<=|~=|!=|>|<|=)[A-Za-z0-9._*+!-]+)?$/
+export function parsePackageSpec(spec) {
+  const raw = String(spec == null ? '' : spec).trim()
+  if (!raw) return { ok: false, problem: 'empty package spec' }
+  if (!PKG_SPEC_RE.test(raw)) {
+    return { ok: false, problem: 'unsupported version syntax: "' + raw + '"（版本求解交给包管理器：请用它能理解的形式，例如 pip 的 pkg==1.2 或 conda 的 pkg=1.2；本工具只检查是否已安装）' }
+  }
+  const name = raw.replace(/(?:==|>=|<=|~=|!=|>|<|=).*$/, '').replace(/\[.*$/, '')
+  return { ok: true, name: name, spec: raw, pinned: raw !== name }
+}
+
+// Detect WHICH python package manager the interpreter's own environment implies - detect, don't
+// guess. conda/mamba markers live in the interpreter path (…/envs/<name>/… or …/miniconda3/…) and
+// must be confirmed by resolving the manager; uv counts only when it sits NEXT TO the interpreter
+// (a uv-managed venv). Anything ambiguous falls back to pip, and `assumed: true` travels into the
+// plan/message so the operator is told which manager the plan assumes.
+async function detectPythonManager(H, exe) {
+  const p = String(exe || '').replace(/\\/g, '/').toLowerCase()
+  if (/\/envs\/|\/conda|\/miniconda|\/anaconda|\/mambaforge|\/miniforge/.test(p)) {
+    for (const mgr of ['conda', 'mamba']) {
+      try {
+        const found = await H.resolveExecutable(mgr)
+        if (found) return { manager: mgr, assumed: false, why: '解释器路径看起来像 ' + mgr + ' 环境（' + p.split('/').slice(-3).join('/') + '）' }
+      } catch (e) { /* try the next candidate */ }
+    }
+  }
+  try {
+    const uv = await H.resolveExecutable('uv')
+    if (uv) {
+      const dirOf = (x) => String(x).replace(/\\/g, '/').replace(/\/[^/]*$/, '')
+      if (dirOf(uv) === dirOf(exe)) return { manager: 'uv', assumed: false, why: 'uv 与解释器同目录（uv 管理的虚拟环境）' }
+    }
+  } catch (e) { /* fall through to pip */ }
+  return { manager: 'pip', assumed: true, why: '未检测到 conda/mamba 标记，也没有与解释器同目录的 uv ⇒ 按文档回退到 pip（计划中的管理器是**假设**）' }
+}
+
+function rollbackFor(d, exe, packages, uninstallTmpl) {
+  const tmpl = uninstallTmpl || (d.install && d.install.uninstallArgv)
   if (!tmpl) return { supported: 'partial', commands: [], note: '该管理器未提供卸载模板；本工具不做自动回滚' }
   return { supported: 'partial', commands: packages.map((p) => substInstall(tmpl, d.name, exe, p)), note: '包管理器各自支持卸载；本工具不做自动回滚' }
 }