dsh-vibe-math 2.7.1 → 2.7.3

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

@@ -12,6 +12,21 @@ import { MATH_ENGINES, MATH_ENGINE_ORDER, mathEngineCandidates, mathEngineArgErr
 
 export const MATH_TOOL_NAME = 'math_computation'
 
+// Sweep ruling: the cli policy is declared ONCE, in the descriptor (math-engines.js `cli.policy`).
+// These two readers are the only place the rule is applied, so descriptor and behaviour cannot drift.
+const CLI_POLICY = (MATH_ENGINES.cli && MATH_ENGINES.cli.policy) || {}
+
+// Item-2 ruling: a commercial template's "VERIFY" provenance must REACH the user, and it is declared
+// ONCE (descriptor `verify` + `verifyReason`). Assemble the fields ONLY when a reason exists, so an
+// engine that declares nothing prints no empty slot.
+function verifyFields(engine) {
+  const d = MATH_ENGINES[engine] || {}
+  if (!d.verify) return {}
+  const out = { verify: true }
+  if (typeof d.verifyReason === 'string' && d.verifyReason) out.verifyReason = d.verifyReason
+  return out
+}
+
 export const MATH_PARAM_NAMES = Object.freeze([
   'mathComputation', 'mathMode', 'mathEngines', 'mathTimeoutMs', 'mathPackages', 'mathInstallScope',
 ])
@@ -72,11 +87,13 @@ 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>），你可以用普通文件工具打开并编辑它；'
-  + '编辑后用 mode:\'file\' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——'
-  + '报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。'
+export const MATH_ARCHIVE_WORKFLOW_LINE = '- 归档→编辑→重跑：mode:\'code\' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>，**相对项目根**）；'
+  + '**成员的文件工具是按会话 cwd 解析的**，所以读它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）。'
+  + '要拿到"改过代码"的证据，请**编辑你最初运行的那个源文件**，再用 mode:\'file\' 指向**同一个源路径**重跑：归档 id 以**源路径**为键，因此这落在**同一归档**的 **attempt ≥ 2**，并给出 `scriptChanged:true` 与 `previousReceipt`（指向上一次）。'
+  + '**指向归档副本本身**（`receipt.scriptAbs` 那个路径）按设计是**另一份新归档**：新 id、attempt 1、没有 `previousReceipt`、`scriptChanged:false`；旧 attempt 绝不会被覆盖，但它**不是**"同一归档的新 attempt"——工具会用 `fileIsArchivedScript` 与 `ARCHIVED_SCRIPT_RERUN` 警告明确说明。'
+  + '**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 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 READ it via the ABSOLUTE `receipt.scriptAbs`, or join `receipt.cwd` with `receipt.scriptPath` (both are in the receipt). To produce evidence for EDITED code, edit the SOURCE FILE you originally ran and re-run mode:\'file\' pointing at THAT SAME PATH: the archive id is keyed by the SOURCE PATH, so this lands on the SAME archive as attempt >= 2, with `scriptChanged:true` and `previousReceipt` pointing at the previous attempt. Pointing mode:\'file\' at the ARCHIVED COPY itself (the `receipt.scriptAbs` path) is a DIFFERENT archive BY DESIGN - a new id, attempt 1, no `previousReceipt`, `scriptChanged:false`: the earlier attempt is never overwritten, but it is NOT "a new attempt of the same archive", and the tool says so via `fileIsArchivedScript` and the `ARCHIVED_SCRIPT_RERUN` warning. **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
@@ -254,8 +271,10 @@ export function validateMathArgs(args, params) {
     if (mode !== 'code' && mode !== 'file' && mode !== 'expr') return bad('mode must be code|file|expr for op=run')
     const engine = args.engine || 'auto'
     if (engine === 'cli') {
-      if (p.mathMode !== 'typed+shell') return bad('engine=cli is disabled while mathMode=' + p.mathMode, 'MATH_REFUSED', next('reason', { reason: 'policy' }))
-      if (p.mathEngines.indexOf('cli') === -1) return bad('engine=cli is not in mathEngines', 'MATH_REFUSED', next('reason', { reason: 'engine-not-allowed' }))
+      // Sweep ruling (single source): the cli policy lives in the DESCRIPTOR; the code reads it here
+      // rather than hard-coding 'typed+shell', so the two can no longer drift apart.
+      if (CLI_POLICY.requiresMathMode && p.mathMode !== CLI_POLICY.requiresMathMode) return bad('engine=cli is disabled while mathMode=' + p.mathMode + ' (requires ' + CLI_POLICY.requiresMathMode + ')', 'MATH_REFUSED', next('reason', { reason: 'policy', requiresMathMode: CLI_POLICY.requiresMathMode }))
+      if (CLI_POLICY.requiresEngineInList && p.mathEngines.indexOf('cli') === -1) return bad('engine=cli is not in mathEngines', 'MATH_REFUSED', next('reason', { reason: 'engine-not-allowed', requiresEngineInList: true }))
       if (!isObj(args.cli)) return bad('engine=cli requires cli:{command,argv}', 'MATH_REFUSED', next('reason', { reason: 'missing-cli-command' }))
       if (mode === 'expr') return bad('cli does not support mode=expr', 'MATH_REFUSED', next('reason', { reason: 'expr-not-supported' }))
     }
@@ -276,6 +295,19 @@ export function validateMathArgs(args, params) {
 
 // ── failure / return shells ─────────────────────────────────────────────────────────────────────
 function next(kind, extra) { return Object.assign({ kind: kind }, extra || {}) }
+/**
+ * S6: ONE wording for the version policy, so the install plan, the run path and the missing-package
+ * failure cannot drift into different sentences describing the same rule. Grep anchor:
+ * MATH_VERSION_POLICY (and its single call site family mathVersionPolicy).
+ */
+/** S6: the ONE short clause that states the policy; the long sentence and the two human messages
+ * below are all built from it, so the semantics cannot drift. Grep anchor: MATH_VERSION_POLICY_CLAUSE. */
+const MATH_VERSION_POLICY_CLAUSE = '只检查是否存在；版本求解交给包管理器'
+const MATH_VERSION_POLICY = 'version-constraints-are-existence-only: 只按 base name 检查是否存在，约束本身从不校验（' + MATH_VERSION_POLICY_CLAUSE + '）'
+function mathVersionPolicy(pinned) {
+  return MATH_VERSION_POLICY + ((pinned && pinned.length) ? '；本次未校验的约束：' + pinned.join(', ') : '；本次没有版本约束')
+}
+
 function fail(code, engine, message, extra) {
   const out = { ok: false, op: null, engine: engine || null, code: code, message: message }
   if (extra && extra.next) out.next = extra.next
@@ -284,18 +316,47 @@ function fail(code, engine, message, extra) {
   if (extra && extra.missing) out.missing = extra.missing
   if (extra && extra.engines) out.engines = extra.engines
   if (extra && extra.available !== undefined) out.available = extra.available
+  if (extra && extra.configured) out.configured = extra.configured
+  if (extra && Array.isArray(extra.absent)) out.absent = extra.absent
   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,
+    // Item-2: the not-found guidance carries the same provenance when the descriptor declares it.
+    ...verifyFields(engine),
+    note: (mgr && !available)
+      ? ('本机没有检测到包管理器 ' + mgr + '：建议命令无法运行，请按上面的官方地址手动安装（或先自行安装一个包管理器）。')
+      : null,
+  })
 }
 
 // ── host adaptation ─────────────────────────────────────────────────────────────────────────────
@@ -319,6 +380,9 @@ function adaptHost(host) {
     // 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,
+    // round-B (F4): an OPTIONAL host field - a host (or a test) that knows its own install layout can
+    // supply the per-engine candidate roots, so discovery never has to trust this process's environment.
+    installRoots: typeof h.installRoots === 'function' ? h.installRoots : null,
     log: typeof h.log === 'function' ? h.log : function () {},
   }
   adapted.__mathHost = true
@@ -346,13 +410,81 @@ export async function probeMathEngines(host, opts) {
       if (d.license === 'commercial') continue // installed but not usable: reported by op=run as LICENSE_REQUIRED
       continue
     }
-    engines.push({ name: name, version: v.version, path: hit, license: d.license })
+    engines.push(Object.assign({ name: name, version: v.version, path: hit, license: d.license }, verifyFields(name)))
   }
   const result = { ok: true, engines: engines, available: engines.length > 0 }
   PROBE_CACHE.set(H, result)
   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.
+// round-B (F4/F3): the candidate roots come from the HOST when it can supply them (`H.installRoots`),
+// and only otherwise from this process's environment - so a test (or a host with its own layout) never
+// depends on the ambient machine. ONE generic walker serves every engine: adding an engine is a table
+// entry (roots + descriptor candidates), never a new code path. Existence is always proven by LISTING.
+export function mathInstallRoots(engineName, env, win) {
+  const pf = String(env.ProgramFiles || 'C:/Program Files')
+  const pf86 = String(env['ProgramFiles(x86)'] || 'C:/Program Files (x86)')
+  const local = env.LOCALAPPDATA ? String(env.LOCALAPPDATA) : null
+  const home = env.USERPROFILE || env.HOME || null
+  const table = {
+    r: win
+      ? [pf + '/R', pf86 + '/R', local ? local + '/Programs/R' : null]
+      : ['/usr/lib/R', '/usr/lib64/R', '/Library/Frameworks/R.framework/Resources', '/usr/local/lib/R', '/opt/R'],
+    python: win
+      ? [local ? local + '/Programs/Python' : null, pf]
+      : ['/usr/local', '/usr', '/opt/python', '/opt/homebrew'],
+    octave: win
+      ? [pf + '/GNU Octave', local ? local + '/Programs/GNU Octave' : null]
+      : ['/usr/lib/octave', '/usr/local/octave', '/opt/octave', '/usr/share/octave'],
+    julia: win
+      ? [local ? local + '/Programs' : null, pf, home ? home + '/.juliaup/bin' : null]
+      : ['/opt', '/usr/local', home ? home + '/.juliaup/bin' : null],
+    matlab: win ? [pf + '/MATLAB'] : ['/usr/local/MATLAB', '/Applications'],
+  }
+  return (table[engineName] || []).filter((x) => typeof x === 'string' && x)
+}
+
+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')
+  let injected = null
+  if (typeof H.installRoots === 'function') {
+    try {
+      const r = await H.installRoots(engineName)
+      if (Array.isArray(r)) injected = r.filter((x) => typeof x === 'string' && x)
+    } catch (e) { injected = null }
+  }
+  const roots = injected || mathInstallRoots(engineName, env, win)
+  const exts = win ? ['', '.exe', '.cmd'] : ['']
+  const out = []
+  const listNames = async (dir, kind) => {
+    try { return ((await H.listDirAbs(dir)) || []).filter((e) => e && e.type === kind).map((e) => e.name) } catch (e) { return [] }
+  }
+  const match = async (dir) => {
+    const files = await listNames(dir, 'file')
+    for (const c of cands) for (const x of exts) if (files.indexOf(c + x) !== -1) out.push(dir + '/' + c + x)
+  }
+  for (const root of roots) {
+    await match(root)                                                      // flat layout (juliaup, /usr/local)
+    await match(root + '/bin')                                             // unix / framework layout
+    for (const d of await listNames(root, 'directory')) {
+      await match(root + '/' + d)                                          // versioned flat (Python312, Julia-1.10)
+      await match(root + '/' + d + '/bin')                                 // versioned install (R-4.6.1/bin)
+      for (const s of await listNames(root + '/' + d, 'directory')) {
+        await match(root + '/' + d + '/' + s + '/bin')                     // nested layout (Octave-9.2.0/mingw64/bin)
+      }
+    }
+  }
+  return Array.from(new Set(out))
+}
+
 async function resolveCandidate(H, d) {
   const cands = mathEngineCandidates(d.name)
   if (!cands) return null
@@ -362,11 +494,15 @@ 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 the LAST resort. The
+  // 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
 }
 
@@ -510,10 +646,10 @@ async function resolveEngine(H, requested, params, args) {
     const d = applyOverride({ name: name, desc: d0 }, params, args)
     if (params.mathEngines.indexOf(name) === -1) return fail('MATH_REFUSED', name, '引擎 ' + name + ' 不在 mathEngines 允许列表内', { next: next('reason', { reason: 'engine-not-allowed' }) })
     if (name === 'cli') {
-      if (params.mathMode !== 'typed+shell') return fail('MATH_REFUSED', name, 'cli 被策略禁用（mathMode=' + params.mathMode + '）', { next: next('reason', { reason: 'policy' }) })
+      if (CLI_POLICY.requiresMathMode && params.mathMode !== CLI_POLICY.requiresMathMode) return fail('MATH_REFUSED', name, 'cli 被策略禁用（需要 mathMode=' + CLI_POLICY.requiresMathMode + '，当前 ' + params.mathMode + '）', { next: next('reason', { reason: 'policy', requiresMathMode: CLI_POLICY.requiresMathMode }) })
       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') })
+      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'
@@ -532,7 +668,7 @@ async function resolveEngine(H, requested, params, args) {
     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 || '' }) })
+        if (!lic.ok) return fail('MATH_ENGINE_LICENSE_REQUIRED', name, name + ' 已安装但许可不可用（仅厂商可激活）', { next: next('vendor', Object.assign({ engine: name, url: d.vendor || '' }, verifyFields(name))) })
         return { ok: true, name: name, desc: d, exe: hit, version: 'unknown' }
       }
       // round-7 (live-session fix): the engine WAS found - so an install guide would be misleading
@@ -544,11 +680,11 @@ async function resolveEngine(H, requested, params, args) {
       })
     }
     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 || '' }) })
+    if (!lic.ok) return fail('MATH_ENGINE_LICENSE_REQUIRED', name, name + ' 已安装但许可不可用（仅厂商可激活）', { next: next('vendor', Object.assign({ engine: name, url: d.vendor || '' }, verifyFields(name))) })
     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 ───────────────────────────────────────────────────────────────────────────────
@@ -643,11 +779,14 @@ function assembleArgv(det, mode, payload) {
     }
   }
   if (mode === 'code' || mode === 'file') {
-    return { argv: [det.exe].concat((d.scriptArgv || []).map((a) => a === '<script>' ? payload.scriptAbs : a)) }
+    // Sweep finding (HIGH): substitution must be STRING-level, not exact-element equality - matlab's
+    // descriptor embeds the placeholder (`run('<script>')`), so an exact match let the literal
+    // `run('<script>')` reach the engine and the archived script never ran.
+    return { argv: [det.exe].concat((d.scriptArgv || []).map((a) => String(a).split('<script>').join(payload.scriptAbs))) }
   }
   if (mode === 'expr') {
     if (!d.evalArgv) return { refused: 'engine does not support mode=expr' }
-    return { argv: [det.exe].concat(d.evalArgv.map((a) => a === '<expr>' ? payload.expr : a)) }
+    return { argv: [det.exe].concat(d.evalArgv.map((a) => String(a).split('<expr>').join(payload.expr))) }
   }
   return { refused: 'unknown mode' }
 }
@@ -799,6 +938,14 @@ async function opProbe(H, args, params) {
   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：无法从命令名判断引擎族（不阻塞）' }
+  // S2 + round-9 F3: the absence list must exist BEFORE the early failure return, because the
+  // failure a user actually hits must carry the same evidence as the success shape.
+  const absentFor = (names) => params.mathEngines
+    .filter((e) => names.indexOf(e) === -1)
+    .map((e) => ((MATH_ENGINES[e] && MATH_ENGINES[e].resolveFrom === 'cli.command')
+      ? { engine: e, why: 'needs-a-caller-supplied-command' }
+      : { engine: e, why: 'not-found-on-this-machine' }))
+
   if (requested && chosen && !chosen.ok) {
     // Policy/absence refusal for the REQUESTED engine, with its own guidance.
     const out = Object.assign({}, chosen)
@@ -810,7 +957,7 @@ async function opProbe(H, args, params) {
   }
   if (!probe.available && !(chosen && chosen.ok)) {
     const first = requested || params.mathEngines[0] || 'python'
-    const out = fail('MATH_ENGINE_NOT_FOUND', first, '本机没有可用的计算引擎（请求：' + first + '）', { next: userInstallNext(first), engines: [], available: false, packages: packages })
+    const out = fail('MATH_ENGINE_NOT_FOUND', first, '本机没有可用的计算引擎（请求：' + first + '）', { next: await userInstallNext(H, first), engines: [], available: false, configured: params.mathEngines.slice(), absent: absentFor(probe.engines.map((e) => e.name)), packages: packages })
     out.op = 'probe'
     return out
   }
@@ -818,13 +965,22 @@ async function opProbe(H, args, params) {
   // 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
+    engines.push(Object.assign({ name: chosen.name, path: chosen.exe, version: chosen.version, license: (MATH_ENGINES[chosen.name] || {}).license }, verifyFields(chosen.name)))
+  }
+  const engineInfo = (chosen && chosen.ok) ? Object.assign({ name: chosen.name, path: chosen.exe, version: chosen.version }, verifyFields(chosen.name)) : 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 = absentFor(foundNames)
   return {
     ok: true, op: 'probe', engine: engineInfo ? engineInfo.name : null, engineInfo: engineInfo,
     engines: engines, available: true, packages: packages,
-    message: '可用引擎：' + engines.map((e) => e.name + ' ' + e.version).join('、') + (engineInfo ? '（请求 ' + engineInfo.name + '：' + engineInfo.version + '）' : ''),
+    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('、') : '；已配置的引擎都在'),
   }
 }
 
@@ -851,6 +1007,9 @@ 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
+  // 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 = mathVersionPolicy(pinnedSpecs)
   // 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.
@@ -861,10 +1020,11 @@ async function opRun(H, args, params) {
   // 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(', ') + '（' + MATH_VERSION_POLICY_CLAUSE + '）', {
       missing: missing,
       next: next('agent-install', { engine: det.name, packages: missing, specs: want.slice(), dryRun: true }),
       packages: pk,
+      versionPolicy: versionPolicy, constraintsNotEnforced: pinnedSpecs.slice(),
     })
   }
 
@@ -872,10 +1032,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
@@ -939,6 +1106,7 @@ 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'))
@@ -953,13 +1121,24 @@ 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,
     argv: assembled.argv.slice(),
     cwd: root,
     packages: { requested: want.slice(), found: pk.found },
+    // round-B (F6): the constraint policy is durable evidence too - a receipt read months later must
+    // show that constraints were existence-only and WHICH ones were not checked.
+    versionPolicy: versionPolicy, constraintsNotEnforced: pinnedSpecs.slice(),
     exit: r.timedOut ? null : (r.exit === undefined ? null : r.exit),
     timedOut: !!r.timedOut,
     ms: Number(r.ms || 0),
@@ -979,12 +1158,20 @@ 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,
@@ -994,8 +1181,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
@@ -1008,11 +1200,13 @@ async function opRun(H, args, params) {
         next: next('engine-override', { engine: det.name, argv: assembled.argv.slice(), hint: MATH_BAD_ARGV_HINT }),
       })
       out.exit = r.exit
+      out.stdout = fullOut.slice(0, MATH_CAPS.stdout)
       out.stderr = fullErr.slice(0, MATH_CAPS.stderr)
       return Object.assign(out, archiveFields())
     }
     const out = fail('MATH_NONZERO_EXIT', engineLabel, '引擎以非零退出码结束：' + r.exit, { argv: assembled.argv.slice(), receipt: receiptRef })
     out.exit = r.exit
+    out.stdout = fullOut.slice(0, MATH_CAPS.stdout)
     out.stderr = fullErr.slice(0, MATH_CAPS.stderr)
     return Object.assign(out, archiveFields())
   }
@@ -1101,7 +1295,7 @@ async function opInstall(H, args, params) {
   if (!d) return fail('MATH_INVALID_ARGUMENT', engineName, 'unknown engine: ' + engineName)
   if (d.license === 'commercial' || !d.install) {
     return fail('MATH_REFUSED', engineName, engineName + ' 永不代装（商业引擎只给厂商指引）', {
-      next: next('vendor', { engine: engineName, url: d.vendor || '' }),
+      next: next('vendor', Object.assign({ engine: engineName, url: d.vendor || '' }, verifyFields(engineName))),
     })
   }
   const scope = args.scope || params.mathInstallScope || 'user' // per-call only; never persisted anywhere
@@ -1137,7 +1331,7 @@ async function opInstall(H, args, params) {
   const plan = {
     engine: engineName, scope: scope, manager: activeManager, commands: commands,
     managerAssumed: !!(managerInfo && managerInfo.assumed), managerWhy: managerInfo ? managerInfo.why : '',
-    versionPolicy: '版本求解交给包管理器（本工具只检查是否已安装，并把 pkg<op>version 原样透传）',
+    versionPolicy: mathVersionPolicy(args.packages || []),
     note: scope === 'user' ? '将安装到用户级目录' : '仅本次系统作用域（不会被记住）',
   }
   const planToken = sha256(JSON.stringify({ engine: engineName, packages: args.packages, scope: scope, commands: commands }) + '|planVersion=1').slice(0, 32)
@@ -1158,12 +1352,18 @@ async function opInstall(H, args, params) {
       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' }) })
       out.audit = 'Computation/installs/' + planToken + '.json'
+      // S4/S5 (non-breaking): install failures are discriminated by op + installedSoFar + timedOut,
+      // NOT by a new failure code (MATH_FAILURE_CODES is frozen). Mirrors the `out.audit`
+      // post-assignment and needs nothing from fail()'s key whitelist.
+      out.op = 'install'
+      out.timedOut = !!(r && r.timedOut)
+      out.installedSoFar = results.filter((x) => x.exit === 0).map((x) => x.argv)
       return out
     }
   }
   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）' }
+  return { ok: true, op: 'install', engine: engineName, executed: true, scope: scope, installedSoFar: commands.map((c) => c.argv), audit: 'Computation/installs/' + planToken + '.json', message: '已安装：' + args.packages.join(', ') + '（审计：Computation/installs/' + planToken + '.json）' }
 }
 
 // ── round-6 (B/D): package specs + Python package-manager dispatch ──────────────────────────────
@@ -1176,7 +1376,7 @@ 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；本工具只检查是否已安装）' }
+    return { ok: false, problem: 'unsupported version syntax: "' + raw + '"（' + MATH_VERSION_POLICY_CLAUSE + '：请用它能理解的形式，例如 pip 的 pkg==1.2 或 conda 的 pkg=1.2）' }
   }
   const name = raw.replace(/(?:==|>=|<=|~=|!=|>|<|=).*$/, '').replace(/\[.*$/, '')
   return { ok: true, name: name, spec: raw, pinned: raw !== name }

package/vibe-math-v4/math-engines.js

@@ -6,7 +6,7 @@
 // No repo imports — node builtins only (this file imports nothing at all).
 //
 // Placeholders used in the argv templates (each substitutes into ONE argv element only):
-//   <script> <expr> <pkgs> <probeCode> <exe> <pkg> <cliArgv...>
+//   <script> <expr> <pkgs> <probeCode> <exe> <pkg>
 // A descriptor is pure data; every template can be overridden by the user via mathEngineOverride.
 
 export const MATH_ENGINE_ORDER = ['python', 'r', 'octave', 'julia', 'matlab', 'maple', 'wolfram', 'cli']
@@ -19,9 +19,9 @@ const ARG_ERROR_HINTS = ['unknown option', 'invalid option', 'unrecognized optio
 export const MATH_ENGINES = {
   python: {
     name: 'python', phase: 'P1',
-    candidates: ['python3', 'python', 'py'], winPrefix: ['-3'],
+    candidates: ['python3', 'python', 'py'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+\\.\\d+)',
-    scriptArgv: ['<script>'], evalArgv: ['-c', '<expr>'], stdinArgv: ['-'], ext: '.py',
+    scriptArgv: ['<script>'], evalArgv: ['-c', '<expr>'], ext: '.py',
     // round-7 (live): NO shell metacharacters (`|`, `%`) in any probe argv - a real host rejected
     // them with a null spawn. One line per package: "name ok|missing".
     probeCode: "import importlib.util,sys\nfor p in sys.argv[1:]: print(p, 'ok' if importlib.util.find_spec(p) is not None else 'missing')",
@@ -70,7 +70,7 @@ export const MATH_ENGINES = {
     name: 'r', phase: 'P1',
     candidates: ['Rscript', 'R'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+\\.\\d+)',
-    scriptArgv: ['<script>'], evalArgv: ['-e', '<expr>'], stdinArgv: ['--no-save', '--slave'], ext: '.R',
+    scriptArgv: ['<script>'], evalArgv: ['-e', '<expr>'], ext: '.R',
     // round-7 (live): line-per-package, no `|` in the argv.
     probeCode: "for (p in strsplit('__PKGS__',',')[[1]]) cat(p, if (requireNamespace(p, quietly=TRUE)) 'ok' else 'missing', '\\n')",
     packageProbe: { argv: ['-e', '<probeCode>'], parse: 'pairs' },
@@ -89,7 +89,7 @@ export const MATH_ENGINES = {
     candidates: ['octave', 'octave-cli'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+\\.\\d+)',
     scriptArgv: ['--no-gui', '--quiet', '<script>'], evalArgv: ['--no-gui', '--quiet', '--eval', '<expr>'],
-    stdinArgv: ['--no-gui', '--quiet'], ext: '.m',
+    ext: '.m',
     // round-7 (live): line-per-package via disp, no `|` and no `%` in the argv.
     probeCode: "s=pkg('list'); n={'__QPKGS__'}; for i=1:numel(n); if any(cellfun(@(x) strcmp(x.name,n{i}),s)); disp([n{i} ' ok']); else; disp([n{i} ' missing']); end; end",
     packageProbe: { argv: ['--no-gui', '--quiet', '--eval', '<probeCode>'], parse: 'pairs' },
@@ -106,7 +106,7 @@ export const MATH_ENGINES = {
     name: 'julia', phase: 'P1',
     candidates: ['julia'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+\\.\\d+)',
-    scriptArgv: ['<script>'], evalArgv: ['-e', '<expr>'], stdinArgv: ['-'], ext: '.jl',
+    scriptArgv: ['<script>'], evalArgv: ['-e', '<expr>'], ext: '.jl',
     probeCode: 'for p in [__QPKGS__]; println(p, ":", Base.find_package(p) === nothing ? "missing" : "ok"); end',
     packageProbe: { argv: ['-e', '<probeCode>'], parse: 'pairs' },
     license: 'free', argErrorHints: ARG_ERROR_HINTS,
@@ -122,7 +122,7 @@ export const MATH_ENGINES = {
     name: 'matlab', phase: 'P1',
     candidates: ['matlab'],
     versionArgv: ['-batch', 'disp(version)'], versionRe: '(\\d+\\.\\d+)',
-    scriptArgv: ['-batch', "run('<script>')"], evalArgv: ['-batch', '<expr>'], stdinArgv: null, ext: '.m',
+    scriptArgv: ['-batch', "run('<script>')"], evalArgv: ['-batch', '<expr>'], ext: '.m',
     // round-7 (live): no `|`/`%` in any probe argv (a real host rejected such argv with a null spawn).
     probeCode: "t={'__QPKGS__'}; for i=1:numel(t); if license('test',t{i}); disp([t{i} ' ok']); else; disp([t{i} ' missing']); end; end",
     packageProbe: { argv: ['-batch', '<probeCode>'], parse: 'pairs' },
@@ -135,7 +135,7 @@ export const MATH_ENGINES = {
     name: 'maple', phase: 'P1',
     candidates: ['maple'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+)',
-    scriptArgv: ['-q', '<script>'], evalArgv: ['-q', '-c', '<expr>'], stdinArgv: null, ext: '.mpl',
+    scriptArgv: ['-q', '<script>'], evalArgv: ['-q', '-c', '<expr>'], ext: '.mpl',
     // round-7 (live): `print` instead of printf so the argv carries no `|`/`%`.
     probeCode: 'for p in ["__PKGS__"] do try with(p) catch: print(p, " missing"); next end try; print(p, " ok") end do',
     packageProbe: { argv: ['-q', '-c', '<probeCode>'], parse: 'pairs' },
@@ -149,7 +149,7 @@ export const MATH_ENGINES = {
     name: 'wolfram', phase: 'P1',
     candidates: ['wolframscript', 'WolframKernel', 'math'],
     versionArgv: ['-code', '$Version'], versionRe: '(\\d+\\.\\d+(\\.\\d+)?)',
-    scriptArgv: ['-file', '<script>'], evalArgv: ['-code', '<expr>'], stdinArgv: null, ext: '.wl',
+    scriptArgv: ['-file', '<script>'], evalArgv: ['-code', '<expr>'], ext: '.wl',
     probeCode: 'Do[Print[p,":",If[Quiet[Check[Needs[p];True,False]],"ok","missing"]],{p,{__QPKGS__}}]',
     packageProbe: { argv: ['-code', '<probeCode>'], parse: 'pairs' },
     license: 'commercial', argErrorHints: ARG_ERROR_HINTS,
@@ -158,10 +158,10 @@ export const MATH_ENGINES = {
     userInstall: { windows: 'vendor installer + activation', macos: 'vendor installer + activation', linux: 'vendor installer + activation' },
   },
   cli: {
-    name: 'cli', phase: 'P1', defaultOn: true,
+    name: 'cli', phase: 'P1',
     candidates: [], resolveFrom: 'cli.command',
     versionArgv: ['--version'], versionRe: '([^\\s]+)', versionOptional: true,
-    scriptArgv: ['<cliArgv...>'], evalArgv: null, stdinArgv: null, ext: '.txt',
+    evalArgv: null, ext: '.txt',
     probeCode: null, packageProbe: null,
     license: 'user', argErrorHints: ARG_ERROR_HINTS,
     install: null, vendor: null,
@@ -175,7 +175,7 @@ export const MATH_P2_ENGINES = {
   sage: {
     name: 'sage', phase: 'P2', candidates: ['sage'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+)',
-    scriptArgv: ['<script>'], evalArgv: ['-c', '<expr>'], stdinArgv: ['-'], ext: '.sage',
+    scriptArgv: ['<script>'], evalArgv: ['-c', '<expr>'], ext: '.sage',
     probeCode: null, packageProbe: { argv: ['-pip', 'list'], parse: 'lines' },
     license: 'free', argErrorHints: ARG_ERROR_HINTS, install: null,
   },