dsh-vibe-math 2.7.2 → 2.8.0

package/vibe-math-v2/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',
 ])
@@ -73,11 +88,12 @@ export const MATH_PERSONA_TOOL_LINE = '- math_computation {op: probe|run|receipt
 // 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>，**相对项目根**）；'
-  + '**成员的文件工具是按会话 cwd 解析的**，所以打开它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）；'
-  + '编辑后用 mode:\'file\' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——'
-  + '报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。'
+  + '**成员的文件工具是按会话 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>, **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.'
+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
@@ -255,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' }))
     }
@@ -277,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
@@ -285,6 +316,8 @@ 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).
@@ -318,6 +351,8 @@ async function userInstallNext(H, engine) {
     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,
@@ -345,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
@@ -367,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({ name: name, version: v.version, path: hit, license: d.license })
+    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)
@@ -383,34 +421,68 @@ export async function probeMathEngines(host, opts) {
 // 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 }
+  }
+  // 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 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 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 listFiles(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)
   }
-  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
+  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)
+      }
     }
-  } 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))
 }
@@ -421,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
 }
@@ -576,7 +648,7 @@ 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: await userInstallNext(H, 'cli') })
@@ -590,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)
-        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' }
+        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.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
@@ -609,9 +681,9 @@ async function resolveEngine(H, requested, params, args) {
         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 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.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) })
@@ -709,11 +781,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' }
 }
@@ -865,6 +940,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)
@@ -876,7 +959,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: await userInstallNext(H, 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
   }
@@ -884,18 +967,15 @@ 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 })
+    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) ? { name: chosen.name, path: chosen.exe, version: chosen.version } : 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)
   // 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' }
-  })
+  const absent = absentFor(foundNames)
   return {
     ok: true, op: 'probe', engine: engineInfo ? engineInfo.name : null, engineInfo: engineInfo,
     engines: engines, available: true, packages: packages,
@@ -922,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 : ''
@@ -931,7 +1011,7 @@ async function opRun(H, args, params) {
   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 = 'version-constraints-are-existence-only: 只按 base name 检查是否存在，约束本身从不校验（版本求解交给包管理器）' + (pinnedSpecs.length ? '；本次未校验的约束：' + pinnedSpecs.join(', ') : '；本次没有版本约束')
+  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.
@@ -942,7 +1022,7 @@ 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,
@@ -1040,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
@@ -1058,6 +1138,9 @@ async function opRun(H, args, params) {
     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),
@@ -1119,11 +1202,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())
   }
@@ -1212,7 +1297,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
@@ -1248,7 +1333,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)
@@ -1269,12 +1354,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 ──────────────────────────────
@@ -1287,7 +1378,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-v2/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,
   },

package/vibe-math-v2/preset.yml

@@ -1,2 +1,2 @@
-name: Vibe Math V2
-description: 多代理数学问题求解与验证框架（经典）：概率驱动调度 —— qs.json 问题清单 + Propos/ 命题库 + Reliable/ 参考文献，explorer 拆方向 → 逐方向 Solver 迭代 → 多验证器独立审查→辩论→裁决；断点续跑、人工/自动干预、file/push 双模式进度汇报。
+name: Vibe Math V2
+description: 多代理数学问题求解与验证框架（经典）：概率驱动调度 —— qs.json 问题清单 + Propos/ 命题库 + Reliable/ 参考文献，explorer 拆方向 → 逐方向 Solver 迭代 → 多验证器独立审查→辩论→裁决；断点续跑、人工/自动干预、file/push 双模式进度汇报。

package/vibe-math-v2/v2/347/232/204/351/242/235/345/244/226/350/246/201/346/261/202.txt

@@ -1,22 +1,22 @@
-判断当前 v2 的下述是否已实现、当前是否符合下述，若未实现则请实现，过程中有不明确或觉得不合理或有自己建议时请询问我来决策：
-
-1 .当前是否按我说的只允许“命题、命题+证明/证伪、问题+解法”被调度到验证器？以及是否按我说的只允许“问题”被调度到求解器solve。
-
-2 .当前是否实现：当“命题”、“问题”的“证明/证伪/解法”的正确概率为1或0，或“命题”的布尔估计（正确概率）为1或0 或 问题已被解决时，则该证明/证伪/解法永不会被调度到去验证。当 “命题”、“问题”的证明/证伪/解法列表中存在它的正确概率为1的解法/证明/证伪时，则该“命题”、“问题”优先级设为 never，永不调度（到验证器、solve）。命题、问题 如果证明/证伪/解法列表非空且含有正确概率非0的证明/证伪/解法的话 ，则在验证时可优先验证“命题/问题+证明/证伪/解法”而不是“命题/问题”，在验证时优先调度其正确概率高的证明/证伪/解法进行验证。正确概率会动态调整。
-
-3 .允许晋升为问题清单的“问题”的是“命题”，晋升原命题对象为“判断下述命题是否成立：...（原命题）”这样的问题对象，相应证明、证伪列表变为解法列表（并在各个证明证伪过程前面表明是要证明还是证伪），一些合理的、适配的属性也可以对应地转移过去。那些布尔概率为0、1的命题不会被晋升。
-
-4 .那个Verified里需含有所有当前 被证明/证伪的命题和已解决的问题及它们的所有正确概率为1的证明/证伪/解法。
-
-5 .按下述修改文件 实现方案.md 中的那个 q_sub 部分的逻辑（使得我的这个方案更严格化），然后按照下述来实现下述功能：q_sub 需为问题类对象，临时假设（记 p_{q-tmp} ）为对 q_sub 的某种回答/答案的临时假设（是命题类对象）。把临时问题 q_sub 和“判断下述命题是否成立：p_{q-tmp}”交到问题清单（注意交到问题清单后的它们的概述、定义要完整，所涉及的一些依赖、对象等要给出完整定义，以避免断章取义），之后推理过程中发现的命题/结论中那些依赖这个假设的结论/命题在输出时需要把这个假设加上来作为命题/结论，如“若 p_{q-tmp} 成立，则...”（注意，概述、定义要完整，所依赖、基于的一些对象、环境、背景等要给出完整定义，不能断章取义）。
-
-
-6 .是否有对代理通过提示词/上下文按照我实现方案中的定义来解释/告诉它各个参数的完整含义（如progress是指...）？
-要完全对照我的实现方案，来对各提示词/上下文中可能导致代理理解不清楚的地方、对象、要求进行优化、完善、完整解释、举例解释等，优化提示词，使得能让ai/代理完全明确理解含义，使得符合我实现方案中的定义/含义/意思。一定要让代理完全明白、符合实现方案中的理解/要求来进行。
-例如，一个命题、问题或其它各种对象及其各属性的完整定义（按照我实现方案.md中的来），只要1或0那么就视为绝对正确/错误，就可以被代理作为已知成立的结论来使用。
-这样来保证它们在阅读文件时可以有正确的理解，以及保证它们可以明确到底要输出什么、对输出的内容有正确的理解、使得输出的内容符合要求（例如尤其是要求输出的那些对象一定要完整不要断章取义，要把环境/背景、一些依赖的对象/概念都完整补充、补充定义）。
-当前是否有对它们介绍各个文件夹（里文件）的用处、各个文件夹里文件的格式及文件的各参数的含义、完整含义和用处（按我的实现方案来）。
-
-7. 允许调控它们是否可以使用网络、写程序/脚本及其次数等。
-
+判断当前 v2 的下述是否已实现、当前是否符合下述，若未实现则请实现，过程中有不明确或觉得不合理或有自己建议时请询问我来决策：
+
+1 .当前是否按我说的只允许“命题、命题+证明/证伪、问题+解法”被调度到验证器？以及是否按我说的只允许“问题”被调度到求解器solve。
+
+2 .当前是否实现：当“命题”、“问题”的“证明/证伪/解法”的正确概率为1或0，或“命题”的布尔估计（正确概率）为1或0 或 问题已被解决时，则该证明/证伪/解法永不会被调度到去验证。当 “命题”、“问题”的证明/证伪/解法列表中存在它的正确概率为1的解法/证明/证伪时，则该“命题”、“问题”优先级设为 never，永不调度（到验证器、solve）。命题、问题 如果证明/证伪/解法列表非空且含有正确概率非0的证明/证伪/解法的话 ，则在验证时可优先验证“命题/问题+证明/证伪/解法”而不是“命题/问题”，在验证时优先调度其正确概率高的证明/证伪/解法进行验证。正确概率会动态调整。
+
+3 .允许晋升为问题清单的“问题”的是“命题”，晋升原命题对象为“判断下述命题是否成立：...（原命题）”这样的问题对象，相应证明、证伪列表变为解法列表（并在各个证明证伪过程前面表明是要证明还是证伪），一些合理的、适配的属性也可以对应地转移过去。那些布尔概率为0、1的命题不会被晋升。
+
+4 .那个Verified里需含有所有当前 被证明/证伪的命题和已解决的问题及它们的所有正确概率为1的证明/证伪/解法。
+
+5 .按下述修改文件 实现方案.md 中的那个 q_sub 部分的逻辑（使得我的这个方案更严格化），然后按照下述来实现下述功能：q_sub 需为问题类对象，临时假设（记 p_{q-tmp} ）为对 q_sub 的某种回答/答案的临时假设（是命题类对象）。把临时问题 q_sub 和“判断下述命题是否成立：p_{q-tmp}”交到问题清单（注意交到问题清单后的它们的概述、定义要完整，所涉及的一些依赖、对象等要给出完整定义，以避免断章取义），之后推理过程中发现的命题/结论中那些依赖这个假设的结论/命题在输出时需要把这个假设加上来作为命题/结论，如“若 p_{q-tmp} 成立，则...”（注意，概述、定义要完整，所依赖、基于的一些对象、环境、背景等要给出完整定义，不能断章取义）。
+
+
+6 .是否有对代理通过提示词/上下文按照我实现方案中的定义来解释/告诉它各个参数的完整含义（如progress是指...）？
+要完全对照我的实现方案，来对各提示词/上下文中可能导致代理理解不清楚的地方、对象、要求进行优化、完善、完整解释、举例解释等，优化提示词，使得能让ai/代理完全明确理解含义，使得符合我实现方案中的定义/含义/意思。一定要让代理完全明白、符合实现方案中的理解/要求来进行。
+例如，一个命题、问题或其它各种对象及其各属性的完整定义（按照我实现方案.md中的来），只要1或0那么就视为绝对正确/错误，就可以被代理作为已知成立的结论来使用。
+这样来保证它们在阅读文件时可以有正确的理解，以及保证它们可以明确到底要输出什么、对输出的内容有正确的理解、使得输出的内容符合要求（例如尤其是要求输出的那些对象一定要完整不要断章取义，要把环境/背景、一些依赖的对象/概念都完整补充、补充定义）。
+当前是否有对它们介绍各个文件夹（里文件）的用处、各个文件夹里文件的格式及文件的各参数的含义、完整含义和用处（按我的实现方案来）。
+
+7. 允许调控它们是否可以使用网络、写程序/脚本及其次数等。
+
 8. 让对代理的提示词/上下文的一些关键部分（局部提示词/上下文）也作为 setting 值可配置的参数（方便用户自行修改/调控一些关键部分的提示词/上下文）。