dsh-vibe-math 2.7.3 → 2.8.0

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

@@ -405,12 +405,12 @@ export async function probeMathEngines(host, opts) {
     if (name === 'cli') continue // cli needs a caller-supplied command, so it is not auto-detected
     const hit = await resolveCandidate(H, d)
     if (!hit) continue
-    const v = await probeVersion(H, d, hit)
+    const v = await probeVersion(H, d, hit.exe)
     if (!v.ok) {
       if (d.license === 'commercial') continue // installed but not usable: reported by op=run as LICENSE_REQUIRED
       continue
     }
-    engines.push(Object.assign({ name: name, version: v.version, path: hit, license: d.license }, verifyFields(name)))
+    engines.push(Object.assign({ name: name, version: v.version, path: hit.exe, foundVia: hit.via, license: d.license }, verifyFields(name)))
   }
   const result = { ok: true, engines: engines, available: engines.length > 0 }
   PROBE_CACHE.set(H, result)
@@ -461,7 +461,9 @@ async function knownInstallCandidates(H, engineName) {
       if (Array.isArray(r)) injected = r.filter((x) => typeof x === 'string' && x)
     } catch (e) { injected = null }
   }
-  const roots = injected || mathInstallRoots(engineName, env, win)
+  // A JS empty array is TRUTHY: a host that answers `[]` must fall back to the built-in table,
+  // otherwise the whole per-OS stage is silently suppressed (task-2).
+  const roots = (Array.isArray(injected) && injected.length) ? injected : mathInstallRoots(engineName, env, win)
   const exts = win ? ['', '.exe', '.cmd'] : ['']
   const out = []
   const listNames = async (dir, kind) => {
@@ -491,17 +493,17 @@ async function resolveCandidate(H, d) {
   for (const c of cands) {
     try {
       const p = await H.resolveExecutable(c)
-      if (typeof p === 'string' && p) return p
+      if (typeof p === 'string' && p) return { exe: p, via: 'path' }
     } 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
+    if (typeof p === 'string' && p) return { exe: p, via: 'host-runtime' }
   }
   // 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
+    if (typeof p === 'string' && p) return { exe: p, via: 'known-install' }
   }
   return null
 }
@@ -660,16 +662,16 @@ async function resolveEngine(H, requested, params, args) {
         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 }
+      return { ok: true, name: name, desc: d, exe: exe, version: cliVersion, family: fam || null, probe: cliProbe, via: 'cli' }
     }
     const hit = await resolveCandidate(H, d)
     if (!hit) continue
-    const v = await probeVersionWithRetry(H, d, hit)
+    const v = await probeVersionWithRetry(H, d, hit.exe)
     if (!v.ok) {
       if (d.license === 'commercial' || d.versionOptional) {
-        const lic = await checkLicence(H, d, hit)
+        const lic = await checkLicence(H, d, hit.exe)
         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' }
+        return { ok: true, name: name, desc: d, exe: hit.exe, version: 'unknown', via: hit.via }
       }
       // 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
@@ -679,9 +681,9 @@ async function resolveEngine(H, requested, params, args) {
         next: next('note', { guidance: '引擎已找到但探测失败：请检查宿主 subprocess 通路（冷启动/超时/权限），或用 mathEngineOverride 调整 versionArgv 模板；已装的引擎不需要重装。' }),
       })
     }
-    const lic = await checkLicence(H, d, hit)
+    const lic = await checkLicence(H, d, hit.exe)
     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 }
+    return { ok: true, name: name, desc: d, exe: hit.exe, version: v.version, via: hit.via }
   }
   const first = requested === 'auto' ? (params.mathEngines[0] || 'python') : requested
   return fail('MATH_ENGINE_NOT_FOUND', first, '本机没有可用的计算引擎（试过：' + names.join(', ') + '）', { next: await userInstallNext(H, first) })
@@ -967,7 +969,7 @@ async function opProbe(H, args, params) {
   if (chosen && chosen.ok && !engines.some((e) => e.name === chosen.name)) {
     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
+  const engineInfo = (chosen && chosen.ok) ? Object.assign({ name: chosen.name, path: chosen.exe, version: chosen.version, foundVia: chosen.via }, 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)
@@ -1000,7 +1002,7 @@ async function opRun(H, args, params) {
   const det = await resolveEngine(H, args.engine || 'auto', params, args)
   if (!det.ok) return det
   const desc = applyOverride(det, params, args)
-  const det2 = { ok: true, name: det.name, desc: desc, exe: det.exe, version: det.version }
+  const det2 = { ok: true, name: det.name, desc: desc, exe: det.exe, version: det.version, via: det.via }
   // The generic escape hatch is recorded as `cli:<command>` (spec §4.3 / guards §18): the model and
   // the receipt must be able to tell WHICH command was run, not just that it was "cli".
   const cliCommand = args.cli && typeof args.cli.command === 'string' ? args.cli.command : ''
@@ -1118,7 +1120,7 @@ async function opRun(H, args, params) {
     schema: 'vibe-math/math-computation-receipt@1',
     runId: runId, preset: H.designator, project: slug(root), op: 'run', mode: mode,
     attempt: attempt, attemptDir: dir, baseRunDir: baseDir,
-    engine: { name: engineLabel, path: det.exe, version: det.version, source: det.name === 'cli' ? 'cli' : 'path' },
+    engine: { name: engineLabel, path: det.exe, version: det.version, source: det.name === 'cli' ? 'cli' : 'path', foundVia: det2.via },
     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

package/vibe-math-v5/vibe-math-v5.js

@@ -50,6 +50,69 @@
 // to a host session log: DSH's session persistence refuses to load a session that carries an unknown
 // event type unless the writer marked it `ignorable: true`, and `Session.append` cannot set that
 // field — so the old projection-based primary made the user's own session unresumable.
+
+// ── task-4: known-location fallback (math-engine parity) ────────────────────────────────────────────
+// Resolution order: an EXPLICIT command (leanCommand / paperLatexCommand) is used alone and never
+// guessed; otherwise the host resolver (PATH) is tried first, then the known install locations for this
+// platform. Provenance is returned so the caller can report \`leanFoundVia: 'explicit'|'path'|'known-install'\`,
+// and the probed list travels on failure ("I looked here too"), never just "not found on PATH".
+async function resolveKnownTool(sub, opts) {
+  const name = String((opts && opts.name) || '')
+  const explicit = String((opts && opts.explicit) || '').trim()
+  const kind = String((opts && opts.kind) || 'lean')
+  const tried = []
+  const env = (typeof process !== 'undefined' && process.env) || {}
+  const win = !!(typeof process !== 'undefined' && process.platform === 'win32')
+  const home = String(env.USERPROFILE || env.HOME || (win ? 'C:/Users/Default' : '/root'))
+  const local = String(env.LOCALAPPDATA || '')
+  const pf = String(env.ProgramFiles || 'C:/Program Files')
+  const pf86 = String(env['ProgramFiles(x86)'] || 'C:/Program Files (x86)')
+  const elan = String(env.ELAN_HOME || '')
+  const exts = win ? ['', '.exe', '.cmd', '.bat'] : ['']
+  const resolvePath = async (p) => {
+    tried.push(p)
+    try { const fs = await import('node:fs'); for (const e of exts) { const q = p + e; try { if (fs.existsSync(q) && fs.statSync(q).isFile()) return q } catch (err) { /* keep looking */ } } } catch (err) { /* no fs */ }
+    return null
+  }
+  const listDirs = async (p) => { try { const fs = await import('node:fs'); return fs.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) } catch (err) { return [] } }
+  const knownLean = win
+    ? [elan ? elan + '/bin' : null, home + '/.elan/bin', local ? local + '/Programs/lean' : null, pf + '/lean/bin']
+    : [elan ? elan + '/bin' : null, home + '/.elan/bin', home + '/.local/bin', '/usr/local/bin', '/opt/lean/bin']
+  const knownTex = win
+    ? [pf + '/texlive', pf86 + '/texlive', local ? local + '/Programs/MiKTeX/miktex/bin/x64' : null, pf + '/MiKTeX/miktex/bin/x64']
+    : [home + '/Library/TeX/texbin', '/usr/local/texlive', home + '/.TinyTeX/bin', '/opt/texlive']
+  const list = kind === 'tex' ? knownTex : knownLean
+  // 1) EXPLICIT: only it, never a guess.
+  if (explicit) {
+    if (typeof sub.resolveExecutable === 'function') { try { const p = await sub.resolveExecutable(explicit); if (p) return { exe: String(p), via: 'explicit', tried, name: explicit } } catch (e) { /* fall through to PATH */ } }
+    const p = await resolvePath(explicit)
+    if (p) return { exe: p, via: 'explicit', tried, name: explicit }
+    return { exe: null, via: null, tried, name: explicit, reason: 'explicit command not resolvable: ' + explicit }
+  }
+  // 2) PATH via the host resolver.
+  if (typeof sub.resolveExecutable === 'function') {
+    try { const p = await sub.resolveExecutable(name); if (p) return { exe: String(p), via: 'path', tried, name } } catch (e) { /* PATH miss is expected */ }
+  }
+  // 3) KNOWN INSTALL LOCATIONS (Windows TeX roots are globbed per release: <root>/<year>/bin/windows).
+  for (const base of list) {
+    if (!base) continue
+    if (kind === 'tex' && !/bin/i.test(base)) {
+      for (const year of await listDirs(base)) {
+        for (const sub2 of ['bin/windows', 'bin/x86_64-linux', 'bin/universal-darwin', 'bin']) {
+          const p = await resolvePath(base + '/' + year + '/' + sub2 + '/' + name)
+          if (p) return { exe: p, via: 'known-install', tried, name }
+        }
+      }
+      continue
+    }
+    const p = await resolvePath(base + '/' + name)
+    if (p) return { exe: p, via: 'known-install', tried, name }
+  }
+  return { exe: null, via: null, tried, name, reason: 'not found on PATH or in the known install locations' }
+}
+
+export { resolveKnownTool }
+
 export const inject = ['subagents', 'agents', 'fs', 'tools', 'commands', 'timer']
 
 // ── math_computation (docs/math-computation.md) ──────────────────────────────
@@ -2367,6 +2430,7 @@ export function apply(ctx) {
       if (initialTask) { L.push(resume ? '恢复说明：' : '你的初始任务/用途：'); L.push('  ' + initialTask); L.push('') }
       if (member.direction && !resume) { L.push('给你的起点方向：' + member.direction); L.push('') }
       mathPushLine(L)
+      paperPushLine(L)
       L.push('------------')
       L.push(stateBlock(member, roundNo))
       L.push('------------')
@@ -2386,6 +2450,7 @@ export function apply(ctx) {
       }
       if (leanDailyOn()) { L.push(''); L.push(formalWorkLine()) }
       mathPushLine(L)
+      paperPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2403,6 +2468,7 @@ export function apply(ctx) {
       L.push('如果你确实已无路可走或认为原问题接近解决，请说明你的判断与理由。')
       if (leanDailyOn()) { L.push(''); L.push(formalWorkLine()) }
       mathPushLine(L)
+      paperPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2438,6 +2504,7 @@ export function apply(ctx) {
       L.push('如果你认为原问题已解决，请填 "vote_solved": true —— 只有当**全体有表决权者**都')
       L.push('一致认为是真时，本所才会停下来。')
       mathPushLine(L)
+      paperPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2483,6 +2550,7 @@ export function apply(ctx) {
       L.push('**不要为了配合别人而改票，也不要为了让流程往前走而给出你不相信的 1 或 0。**')
       L.push('本所宁可留下未定论，也不要一个骗人的结论。')
       mathPushLine(L)
+      paperPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2673,9 +2741,10 @@ export function apply(ctx) {
         return { ok: false, code: 'NO_SUBPROCESS', message: 'the host exposes no subprocess service; Lean cannot be executed here', file: rel, ms: 0 }
       }
       const cap = Math.max(1000, Number(timeoutMs) || Number(params.leanTimeoutMs) || 120000)
+      let leanVia = null
       let exe
       try {
-        exe = await sub.resolveExecutable(String(params.leanCommand || 'lean'))
+        { const _lc = String(params.leanCommand || 'lean').trim(); const _r = await resolveKnownTool(sub, { name: 'lean', explicit: (_lc && _lc !== 'lean') ? _lc : '', kind: 'lean' }); exe = _r.exe; leanVia = _r.via; if (!exe) return { ok: false, code: 'LEAN_NOT_FOUND', message: 'cannot resolve "' + _lc + '": ' + String(_r.reason || 'not found') + ' — 仍可把形式化代码写下来归档，但无法在此宿主上执行', file: rel, ms: now() - started, next: { kind: 'note', tried: _r.tried } } }
       } catch (e) {
         return { ok: false, code: 'LEAN_NOT_FOUND', message: 'cannot resolve "' + String(params.leanCommand || 'lean') + '": ' + String((e && e.message) || e) + ' — 仍可把形式化代码写下来归档，但无法在此宿主上执行', file: rel, ms: now() - started }
       }
@@ -2740,7 +2809,7 @@ export function apply(ctx) {
       const ok = exitCode === 0
       return {
         ok, exitCode, signal: (outcome && outcome.signal) || null, ms,
-        command: argv.join(' '), file: rel,
+        command: argv.join(' '), file: rel, leanFoundVia: leanVia,
         stdout: tail(out, 4000), stderr: tail(err, 4000),
         timedOut: timedOut || ms >= cap,
         code: ok ? undefined : ((timedOut || ms >= cap) ? 'LEAN_TIMEOUT' : 'LEAN_FAILED'),
@@ -2959,7 +3028,7 @@ export function apply(ctx) {
       if (sub === undefined || typeof sub.spawn !== 'function') {
         return { ok: false, code: 'NO_SUBPROCESS', message: 'the host exposes no subprocess service; Lean cannot be executed here', file: rel }
       }
-      try { await sub.resolveExecutable(String(params.leanCommand || 'lean')) } catch (e) {
+      try { const _lc2 = String(params.leanCommand || 'lean').trim(); const _r2 = await resolveKnownTool(sub, { name: 'lean', explicit: (_lc2 && _lc2 !== 'lean') ? _lc2 : '', kind: 'lean' }); if (!_r2.exe) return { ok: false, code: 'LEAN_NOT_FOUND', message: 'cannot resolve "' + _lc2 + '": ' + String(_r2.reason || 'not found') + ' — 仍可把形式化代码写下来归档，但无法在此宿主上执行', file: rel, next: { kind: 'note', tried: _r2.tried } } } catch (e) {
         return { ok: false, code: 'LEAN_NOT_FOUND', message: 'cannot resolve "' + String(params.leanCommand || 'lean') + '": ' + String((e && e.message) || e) + ' — 仍可把形式化代码写下来归档，但无法在此宿主上执行', file: rel }
       }
       return { ok: true, rel, abs }
@@ -3462,6 +3531,15 @@ export function apply(ctx) {
     // is the "off means zero mention" discipline).
     function mathPushLine(L) { const b = mathPromptBlock('zh'); if (b) L.push(b) }
 
+    // task-9 2b: the LaTeX-missing guidance (four bounded steps + three hard boundaries). Kept
+    // BYTE-IDENTICAL with the other presets; per-preset voice may only follow this block.
+    function paperHintBlock(lang) {
+      return lang === 'en'
+        ? '\nWhen no LaTeX engine is detected: (1) probe only the documented common TeX roots and PATH (e.g. where xelatex, latexmk --version) - never scan whole drives; (2) once the absolute path is found, write it into paperLatexCommand, re-detect, then continue; (3) if it is still missing, ask the user once (installing TeX requires the user\'s explicit approval); (4) with no answer, degrade exactly as today (deliver paper.tex and paper.md only). Hard boundaries: never auto-install; never write outside the workspace; never treat "not detected" as a failure.'
+        : '\n检测不到 LaTeX 引擎时：① 只在文档化的常见 TeX 根与 PATH 上做有界核查（如 where xelatex、latexmk --version），不要全盘扫描；② 找到绝对路径后写入 paperLatexCommand 并重新检测，再继续；③ 仍找不到就向用户问一次（安装 TeX 需用户明确同意）；④ 无应答则照旧降级（只交付 paper.tex 与 paper.md）。硬边界：绝不自动安装；绝不写工作区之外；绝不把"未检测到"当失败。'
+    }
+    function paperPushLine(L) { const b = paperHintBlock('zh'); if (b) L.push(b) }
+
     function formalPromptBlock(target) {
       if (!formalOn()) return ''
       const mode = formalMode()
@@ -5803,18 +5881,22 @@ export function apply(ctx) {
       const order = PAPER_ENGINE_ORDER[lang === 'en' ? 'en' : 'zh'].slice()
       const forced = String(params.paperLatexCommand || '').trim()
       if (!forced) return order
-      return [forced].concat(order.filter((n) => n !== forced))
+      // task-10: an EXPLICIT paperLatexCommand is used ALONE (docs/final-paper.md §B) - no fall-through.
+      return [forced]
     }
     async function latexEngines(lang) {
       const sub = subprocessOf()
-      if (!sub || typeof sub.resolveExecutable !== 'function') {
-        return { engines: [], reason: '宿主没有 subprocess 服务：无法检测或调用 LaTeX' }
+      // task-4: only a missing subprocess short-circuits - a host without resolveExecutable is still
+      // served by the known-location stage (resolveKnownTool tolerates that host).
+      if (!sub) {
+        return { engines: [], reason: '宿主没有 subprocess 服务：无法检测或调用 LaTeX', triedPaths: [] }
       }
       const engines = []
+      const triedPaths = []   // task-9: union of the known-root candidates probed across THIS detection
       for (const name of paperEngineCandidates(lang)) {
-        try { const exe = await sub.resolveExecutable(name); if (exe) engines.push({ name: String(name), exe: String(exe) }) } catch (e) { /* not installed */ }
+        try { const _vr = await resolveKnownTool(sub, { name, explicit: '', kind: 'tex' }); triedPaths.push(..._vr.tried); const exe = _vr.exe; if (exe) engines.push({ name: String(name), exe: String(exe), via: _vr.via }) } catch (e) { /* not installed */ }
       }
-      return { engines, reason: engines.length ? '' : ('未检测到 LaTeX 引擎（' + paperEngineCandidates(lang).join('/') + '）') }
+      return { engines, triedPaths, reason: engines.length ? '' : ('未检测到 LaTeX 引擎（' + paperEngineCandidates(lang).join('/') + '）') }
     }
     // ONE engine invocation. NEVER throws: every failure becomes a readable result (the Lean
     // seam's discipline) and a timeout really terminates the process.
@@ -5852,7 +5934,7 @@ export function apply(ctx) {
         return { status: 'kept-existing', engine: '', reason: 'Paper/' + id + '/paper.pdf 已存在：不覆盖（docs/final-paper.md §5）', attempts: [] }
       }
       const det = await latexEngines(lang)
-      if (!det.engines.length) return { status: 'not-detected', engine: '', reason: det.reason, attempts: [] }
+      if (!det.engines.length) return { status: 'not-detected', engine: '', reason: det.reason, triedPaths: det.triedPaths || [], attempts: [] }
       const e0 = det.engines[0], e1 = det.engines[1] || e0
       const plan = [
         { label: 'full', engine: e0, text: tex, nonstopOnly: false },
@@ -5986,12 +6068,12 @@ export function apply(ctx) {
       if (await fileExistsAbs(paperAbs(id, 'paper.pdf'))) files.push('paper.pdf')
       const warnings = (p.warnings || []).slice()
       if (compile.status === 'failed') warnings.push('LaTeX 编译失败（已保留 paper.tex 与 paper.md，不阻塞定稿）：' + (compile.attempts || []).map((a) => a.engine + '/' + a.label + ' exit=' + a.exitCode + (a.message ? '(' + a.message + ')' : '')).join('；'))
-      if (compile.status === 'not-detected') warnings.push('未检测到 LaTeX 引擎（' + (compile.reason || '') + '）：只交付 paper.tex 与 paper.md。')
+      if (compile.status === 'not-detected') warnings.push('未检测到 LaTeX 引擎（' + (compile.reason || '') + '）：只交付 paper.tex 与 paper.md。已探测 PATH 与文档化的常见 TeX 根；可用 paperLatexCommand 指定绝对路径。')
       // F6: the failed REQUIRED writes are named ONCE (for this finalisation), before the meta is built,
       // so the warning lands in `meta.warnings`, in the flow log, in the state and in the return value.
       if (writeFailures.length) warnings.push(paperWriteFailureWarning(writeFailures))
       const meta = paperMeta(Object.assign({}, p, { finalizedAt, compile: compile.status, engine: compile.engine || '' }), {
-        finalizedAt, warnings, compile: { status: compile.status, engine: compile.engine || '', reason: compile.reason || '', attempts: compile.attempts || [] }, files,
+        finalizedAt, warnings, compile: { status: compile.status, engine: compile.engine || '', reason: compile.reason || '', triedPaths: compile.triedPaths || [], attempts: compile.attempts || [] }, files,
       })
       if (await writeTextRel(PAPER_FILE(id, 'paper.meta.json'), JSON.stringify(meta, null, 2) + '\n')) files.push('paper.meta.json')
       // `meta.warnings` is the SAME array, so a meta write failure still reaches the state, the log and