dsh-vibe-math 2.7.1 → 2.7.2

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

@@ -72,11 +72,12 @@ export const MATH_PERSONA_TOOL_LINE = '- math_computation {op: probe|run|receipt
 // P2a: the archive -> edit -> re-run workflow. Injected into every preset's rule block (and appended
 // to both persona blocks) so an agent cannot miss that (a) the script is archived, (b) it may edit
 // it, and (c) re-running is what produces evidence for the edited code.
-export const MATH_ARCHIVE_WORKFLOW_LINE = '- 归档→编辑→重跑：mode:\'code\' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>），你可以用普通文件工具打开并编辑它；'
+export const MATH_ARCHIVE_WORKFLOW_LINE = '- 归档→编辑→重跑：mode:\'code\' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>，**相对项目根**）；'
+  + '**成员的文件工具是按会话 cwd 解析的**，所以打开它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）；'
   + '编辑后用 mode:\'file\' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——'
   + '报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。'
 
-export const MATH_ARCHIVE_WORKFLOW_LINE_EN = '- Archive -> edit -> re-run: for mode:\'code\' the script original is at the receipt\'s scriptPath (Computation/<id>/script.<ext>) and you may open/edit it with your normal file tools; after editing, re-run it with mode:\'file\' to write a NEW receipt/attempt with a NEW scriptHash. **An old receipt is NOT evidence for edited code** - cite the receipt whose scriptHash matches the current code; the tool warns explicitly via scriptChanged / scriptChangedDuringRun.'
+export const MATH_ARCHIVE_WORKFLOW_LINE_EN = '- Archive -> edit -> re-run: for mode:\'code\' the script original is at the receipt\'s scriptPath (Computation/<id>/script.<ext>, **relative to the project root**); member file tools resolve paths against the SESSION CWD, so open it via the ABSOLUTE `receipt.scriptAbs`, or join `receipt.cwd` with `receipt.scriptPath` (both are in the receipt); after editing, re-run it with mode:\'file\' to write a NEW receipt/attempt with a NEW scriptHash. **An old receipt is NOT evidence for edited code** - cite the receipt whose scriptHash matches the current code; the tool warns explicitly via scriptChanged / scriptChangedDuringRun.'
 
 // Round-6 (A): honesty about SUBSTITUTIONS. An alternative that weakens exactness or conclusion
 // strength must be declared, and the conclusion must never read as if the requested (exact) result
@@ -288,14 +289,39 @@ function fail(code, engine, message, extra) {
   // round-7 (live-session fix): the probe diagnostic must survive into the response, otherwise
   // "存在但不可用" is opaque (a real session showed exactly that).
   if (extra && extra.probe) out.probe = jsonSafeDiag(extra.probe)
+  // round-9 (F7): the version-constraint policy travels with failures too (no silent drop).
+  if (extra && extra.versionPolicy) out.versionPolicy = extra.versionPolicy
+  if (extra && extra.constraintsNotEnforced) out.constraintsNotEnforced = extra.constraintsNotEnforced
   return out
 }
 
-function userInstallNext(engine) {
+// round-9 (real-engine finding): the suggested install command may not be runnable on this machine
+// (e.g. `winget` is absent), and handing a user a command that cannot run is misleading. So the
+// command is emitted ONLY when its package manager is actually resolvable; otherwise we return the
+// official vendor/download pointer plus an explicit note. Async because resolution goes through the host.
+async function userInstallNext(H, engine) {
   const d = MATH_ENGINES[engine] || {}
   const per = d.userInstall || {}
   const platform = process && process.platform === 'win32' ? 'windows' : (process && process.platform === 'darwin' ? 'macos' : 'linux')
-  return next('user-install', { engine: engine, perOs: per, command: per[platform] || '', platform: platform })
+  const raw = per[platform] || ''
+  const mgr = (function () { const m = /^\s*(winget|brew|apt-get|apt|choco|scoop|dnf|pacman|zypper)\b/.exec(String(raw)); return m ? m[1] : null })()
+  let available = true
+  if (mgr) {
+    try { available = !!(await H.resolveExecutable(mgr)) } catch (e) { available = false }
+  }
+  return next('user-install', {
+    engine: engine,
+    perOs: per,
+    command: (mgr && !available) ? '' : raw,
+    suggestedCommand: raw,
+    platform: platform,
+    packageManager: mgr,
+    packageManagerAvailable: mgr ? available : null,
+    vendorUrl: d.vendor || null,
+    note: (mgr && !available)
+      ? ('本机没有检测到包管理器 ' + mgr + '：建议命令无法运行，请按上面的官方地址手动安装（或先自行安装一个包管理器）。')
+      : null,
+  })
 }
 
 // ── host adaptation ─────────────────────────────────────────────────────────────────────────────
@@ -353,6 +379,42 @@ export async function probeMathEngines(host, opts) {
   return result
 }
 
+// round-9 (real-engine finding): an engine can be INSTALLED yet invisible, because discovery only
+// looked at the server process's PATH (R 4.6.1 landed in C:\Program Files\R\R-4.6.1\bin and was NOT
+// added to PATH). Add the known per-OS INSTALL locations, globbed by version, still AFTER PATH and
+// after the bundled runtime; existence is always proven by LISTING, never assumed.
+async function knownInstallCandidates(H, engineName) {
+  if (typeof H.listDirAbs !== 'function') return []
+  const cands = mathEngineCandidates(engineName)
+  if (!cands) return []
+  const env = (typeof process !== 'undefined' && process.env) || {}
+  const win = !!(typeof process !== 'undefined' && process.platform === 'win32')
+  const exts = win ? ['', '.exe', '.cmd'] : ['']
+  const out = []
+  const listDirs = async (dir) => { try { return ((await H.listDirAbs(dir)) || []).filter((e) => e && e.type === 'directory').map((e) => e.name) } catch (e) { return [] } }
+  const listFiles = async (dir) => { try { return ((await H.listDirAbs(dir)) || []).filter((e) => e && e.type === 'file').map((e) => e.name) } catch (e) { return [] } }
+  const match = async (dir) => {
+    const files = await listFiles(dir)
+    for (const c of cands) for (const x of exts) if (files.indexOf(c + x) !== -1) out.push(dir + '/' + c + x)
+  }
+  if (engineName === 'r') {
+    const roots = win
+      ? [String(env.ProgramFiles || 'C:/Program Files') + '/R', String(env['ProgramFiles(x86)'] || 'C:/Program Files (x86)') + '/R', env.LOCALAPPDATA ? String(env.LOCALAPPDATA) + '/Programs/R' : null]
+      : ['/usr/lib/R', '/Library/Frameworks/R.framework/Resources', '/usr/local/lib/R', '/opt/R', '/usr/lib64/R']
+    for (const root of roots) {
+      if (!root) continue
+      for (const d of await listDirs(root)) await match(root + '/' + d + '/bin') // windows versioned dirs
+      await match(root + '/bin')                                                 // unix / framework layout
+    }
+  } else if (engineName === 'python' && win) {
+    const local = env.LOCALAPPDATA ? String(env.LOCALAPPDATA) + '/Programs/Python' : null
+    for (const d of (local ? await listDirs(local) : [])) await match(local + '/' + d)
+    const pf = String(env.ProgramFiles || 'C:/Program Files')
+    for (const d of await listDirs(pf)) if (/^Python[0-9]/i.test(d)) await match(pf + '/' + d)
+  }
+  return Array.from(new Set(out))
+}
+
 async function resolveCandidate(H, d) {
   const cands = mathEngineCandidates(d.name)
   if (!cands) return null
@@ -362,11 +424,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
 }
 
@@ -513,7 +579,7 @@ async function resolveEngine(H, requested, params, args) {
       if (params.mathMode !== 'typed+shell') return fail('MATH_REFUSED', name, 'cli 被策略禁用（mathMode=' + params.mathMode + '）', { next: next('reason', { reason: 'policy' }) })
       let exe = null
       try { exe = await H.resolveExecutable(args.cli.command) } catch (e) { exe = null }
-      if (!exe) return fail('MATH_ENGINE_NOT_FOUND', name, 'cli 命令无法解析：' + args.cli.command, { next: userInstallNext('cli') })
+      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'
@@ -548,7 +614,7 @@ async function resolveEngine(H, requested, params, args) {
     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 ───────────────────────────────────────────────────────────────────────────────
@@ -810,7 +876,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, packages: packages })
     out.op = 'probe'
     return out
   }
@@ -821,10 +887,22 @@ async function opProbe(H, args, params) {
     engines.push({ name: chosen.name, path: chosen.exe, version: chosen.version, license: (MATH_ENGINES[chosen.name] || {}).license })
   }
   const engineInfo = (chosen && chosen.ok) ? { name: chosen.name, path: chosen.exe, version: chosen.version } : null
+  // round-9 (F3): the availability line must never be silently partial - name the CONFIGURED engines
+  // that were not found (and why), instead of just listing the ones that happened to resolve.
+  const foundNames = engines.map((e) => e.name)
+  // Per-engine absence explanation. The key is `why` (NOT the reserved machine-readable vocabulary
+  // key), so the parity guard's exhaustive `next.reason` set stays exactly the refusal vocabulary.
+  const absent = params.mathEngines.filter((e) => foundNames.indexOf(e) === -1).map((e) => {
+    if (MATH_ENGINES[e] && MATH_ENGINES[e].resolveFrom === 'cli.command') return { engine: e, why: 'needs-a-caller-supplied-command' }
+    return { engine: e, why: 'not-found-on-this-machine' }
+  })
   return {
     ok: true, op: 'probe', engine: engineInfo ? engineInfo.name : null, engineInfo: engineInfo,
     engines: engines, available: true, packages: packages,
-    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 +929,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 = 'version-constraints-are-existence-only: 只按 base name 检查是否存在，约束本身从不校验（版本求解交给包管理器）' + (pinnedSpecs.length ? '；本次未校验的约束：' + pinnedSpecs.join(', ') : '；本次没有版本约束')
   // round-7 (finding 3): for cli the precheck runs against the FAMILY of `cli.command` (same
   // discovery-shaped logic); an unrecognisable command SKIPS the precheck instead of reporting a
   // false "missing" that would block the escape hatch.
@@ -865,6 +946,7 @@ async function opRun(H, args, params) {
       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 +954,17 @@ async function opRun(H, args, params) {
   let scriptText = ''
   let fileRel = null
   let sourceHashBefore = null
+  // round-9 (N1): `mode:'file'` is keyed by the SOURCE PATH, so re-running an ORIGINAL source lands on
+  // the same archive id (attempt>=2, scriptChanged). Pointing it at an ARCHIVED script instead targets
+  // a different path and therefore a NEW archive id by design - the prior attempt is never touched, but
+  // there is no previous receipt FOR THAT ID, so scriptChanged/previousReceipt are necessarily empty.
+  // That is not a bug, but it must be SAID rather than looking like broken change detection.
+  let archivedScriptSource = false
   if (mode === 'code') scriptText = args.code
   else if (mode === 'file') {
     fileRel = projectRel('', args.file)
     if (fileRel === null) return fail('MATH_REFUSED', det.name, 'file 必须位于项目内：' + args.file, { next: next('reason', { reason: 'path-outside-project' }) })
+    archivedScriptSource = /^Computation\//.test(String(fileRel))
     const txt = await H.readText(fileRel)
     if (txt === undefined) return fail('MATH_REFUSED', det.name, '找不到文件：' + args.file, { next: next('reason', { reason: 'file-not-found' }) })
     scriptText = txt
@@ -939,6 +1028,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,7 +1043,15 @@ async function opRun(H, args, params) {
     engine: { name: engineLabel, path: det.exe, version: det.version, source: det.name === 'cli' ? 'cli' : 'path' },
     script: { path: scriptRel, sha256: scriptHash, bytes: Buffer.byteLength(scriptText, 'utf8') },
     scriptPath: scriptRel, scriptHash: scriptHash,
+    // round-8 (P0/D3): member file tools are session-cwd relative, so the ABSOLUTE locations must be
+    // in the receipt: `scriptAbs` is directly openable, `cwd` is the project root to join with.
+    scriptAbs: scriptAbs, cwd: root,
     sourceFile: fileRel || null,
+    fileIsArchivedScript: archivedScriptSource,
+    // round-9 (N2): a TIMEOUT must still carry the evidence it produced - the capped partial output
+    // lives in the receipt as well as in stdout.txt/stderr.txt on disk.
+    partialStdout: String(fullOut).slice(-2000),
+    partialStderr: String(fullErr).slice(-2000),
     sourceHashBefore: sourceHashBefore, sourceHashAfter: sourceHashAfter,
     scriptChanged: scriptChanged, scriptChangedDuringRun: scriptChangedDuringRun,
     previousReceipt: prevReceipt ? { runId: prevReceipt.runId, attempt: prevReceipt.attempt || 1, scriptHash: prevReceipt.scriptHash || (prevReceipt.script && prevReceipt.script.sha256) || null } : null,
@@ -979,12 +1077,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 +1100,13 @@ async function opRun(H, args, params) {
     warnings: warnings,
   }
   if (receipt.timedOut) {
-    return Object.assign(fail('MATH_TIMEOUT', engineLabel, '执行超时（' + timeoutMs + 'ms）已被终止', { argv: assembled.argv.slice(), receipt: receiptRef }),
-      archiveFields(), { ms: receipt.ms, timedOut: true })
+    // round-9 (F5): failure EVIDENCE must be uniform - a timeout carries the SAME fields a non-zero
+    // exit does (exit + stderr), plus timedOut:true.
+    const out = fail('MATH_TIMEOUT', engineLabel, '执行超时（' + timeoutMs + 'ms）已被终止', { argv: assembled.argv.slice(), receipt: receiptRef })
+    out.exit = null
+    out.stdout = String(fullOut).slice(0, MATH_CAPS.stdout)
+    out.stderr = String(fullErr).slice(0, MATH_CAPS.stderr)
+    return Object.assign(out, archiveFields(), { ms: receipt.ms, timedOut: true })
   }
   if (r.exit !== 0) {
     const blob = fullErr + '\n' + fullOut

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

@@ -918,6 +918,7 @@ export function apply(ctx) {
       // 引理只在摘要给"索引"（id+标题），完整叙述在各方向文件 Progress/<qid>/<dirId>.md（由代理或调度器写入）
       if (d.lemmas && d.lemmas.length) { lines.push('**引理索引**：' + d.lemmas.map(function (l) { return '「' + l.title + '」(' + l.id + ')' }).join('；')) }
       lines.push('**完整叙述**：见 `Progress/' + qid + '/' + d.id + '.md`')
+    lines.push(PAPER_PATH_NOTE)
       for (const j of (d.journal || [])) {
         lines.push('')
         lines.push('### 第 ' + j.round + ' 轮｜' + (j.agent || '') + '｜' + (j.at || ''))
@@ -1309,7 +1310,22 @@ export function apply(ctx) {
     // 并发计数由 agentRegistry 推导，无需手工 +1。
     await saveAll()
   }
-  async function interruptChild(childId) { try { subagents.interrupt(childId, { kind: 'ancestor', agent: rootAgent }) } catch (e) {} }
+  /**
+   * 中断一个**在册**子代理。审计 D1：旧实现 `try{…}catch(e){}` 把"没有这个 child / 宿主拒绝中断"
+   * 都吞成静默成功（调用方拿到 undefined，还以为已经中断）。现在：空/未知 id ⇒ `code` +
+   * `next{tool,hint}`，宿主抛错 ⇒ 保留错误文本并给替代出口；只有真的发出中断才 `ok:true`。
+   */
+  async function interruptChild(childId) {
+    const id = String(childId == null ? '' : childId).trim()
+    if (!id) return { ok: false, code: 'VIBE_MATH_INVALID_ARGUMENT', message: 'interruptChild 失败：childId 为空——无法确定要中断哪个子代理。', next: { kind: 'reason', tool: 'vibe_math_list_agents', hint: '用 vibe_math_list_agents 列出本会话在册子代理的 id，再带 childId 调用。' } }
+    if (!Object.prototype.hasOwnProperty.call(agentRegistry, id)) return { ok: false, code: 'VIBE_MATH_CHILD_NOT_FOUND', message: 'interruptChild 失败：' + id + ' 不在本会话的在册子代理里（在册 ' + Object.keys(agentRegistry).length + ' 个）——可能已经结束，或不是本会话的子代理。', next: { kind: 'reason', tool: 'vibe_math_list_agents', hint: '用 vibe_math_list_agents 取当前在册 id；要停整个会话用 vibe_math_abort。' } }
+    try {
+      await subagents.interrupt(id, { kind: 'ancestor', agent: rootAgent })
+      return { ok: true, childId: id }
+    } catch (e) {
+      return { ok: false, code: 'VIBE_MATH_INTERRUPT_FAILED', message: 'interruptChild 失败：宿主拒绝中断 ' + id + '（' + String((e && e.message) || e) + '）。', next: { kind: 'reason', tool: 'vibe_math_abort', hint: '宿主不接受单点中断时，用 vibe_math_abort 终止整个会话的子代理。' } }
+    }
+  }
 
   // ================= prompts =================
   function personaText(key) { return params[key] ? (String(params[key]) + '\n\n') : '' }
@@ -1625,7 +1641,10 @@ export function apply(ctx) {
     }
     return {}
   }
-  async function resolveDecision(id, resolution) { const d = decisionQueue.find(function (x) { return x.id === id }); if (!d) return { ok: false, message: 'decision not found' }; if (d.status !== 'pending') return { ok: false, message: 'decision already resolved' }; d.status = 'resolved'; d.resolution = resolution; if (scheduler.gate && scheduler.gate.decisionId === id) scheduler.gate = null; logActivity('decide', id + ' resolved: ' + resolution.action + (resolution.verdict !== undefined ? ' ' + resolution.verdict : '')); await saveAll(); scheduleTick(); return { ok: true, message: 'decision resolved' } }
+  async function resolveDecision(id, resolution) {
+    const d = decisionQueue.find(function (x) { return x.id === id })
+    if (!d) return { ok: false, code: 'VIBE_MATH_DECISION_NOT_FOUND', message: 'decision not found：' + String(id == null ? '' : id) + ' 不在人工决策队列里（队列现有 ' + decisionQueue.length + ' 个' + (decisionQueue.length ? ('：' + decisionQueue.map(function (x) { return x.id }).join(', ')) : '') + '）——可能已被 vibe_math_decide 结清，或被 start/resume/abort/换项目作废（作废是终态，不会回到 pending）。', next: { kind: 'reason', tool: 'vibe_math_list_decisions', hint: '先用 vibe_math_list_decisions 取当前 pending 的 id；若期望它还在，检查是否发生过 start/resume/abort/换项目。' } }
+    if (d.status !== 'pending') return { ok: false, code: 'VIBE_MATH_DECISION_ALREADY_RESOLVED', message: 'decision already resolved：' + String(id) + ' 当前状态是 ' + String(d.status) + '——每次决策只生效一次。', next: { kind: 'reason', tool: 'vibe_math_list_decisions', hint: '用 vibe_math_list_decisions 看还有哪些 pending；要重新决策请等框架发起新的决策项。' } }; d.status = 'resolved'; d.resolution = resolution; if (scheduler.gate && scheduler.gate.decisionId === id) scheduler.gate = null; logActivity('decide', id + ' resolved: ' + resolution.action + (resolution.verdict !== undefined ? ' ' + resolution.verdict : '')); await saveAll(); scheduleTick(); return { ok: true, message: 'decision resolved' } }
 
   // ================= scheduler core =================
   function scheduleTick() { tick().catch(function (e) { console.error('vibe-math-v3 tick error: ' + String((e && e.stack) || e)) }) }
@@ -1877,7 +1896,7 @@ export function apply(ctx) {
     return true
   }
   async function backfillVerifiers(t) {
-    while (t.children.length < t.expectedCount) {
+    while (t.children.length < voteCount(t).expected) {
       if (activeCount() >= params.maxParallelThreshold) break
       const index = t.children.length
       const childId = await spawnChild('verifier:' + t.rId + ':' + index, verifierReviewPrompt(t.r), { role: 'verifier', rId: t.rId, round: 1, index: index })
@@ -1891,7 +1910,7 @@ export function apply(ctx) {
       const t = tasks[ids[i]]
       if (t.type !== 'verify') continue
       if (t.status === 'paused') {
-        const allReported = t.children.length > 0 && t.children.every(function (cid) { const r = t.childResults[cid]; return r && r.round === t.round })
+        const allReported = voteCount(t, t.round).quorum
         if (allReported) { t.status = 'debating'; await advanceVerification(t, t.round); continue }
       }
       if (t.status !== 'spawning') continue
@@ -3756,15 +3775,35 @@ export function apply(ctx) {
    * 下限取 max(2, expectedCount)：verifierCount=1 不是"允许单票"，只是"至少 2 个独立验证器"
    * （与 createVerifyTask 的 `Math.max(2, ...)` 一致）。
    */
-  function minVotes(t) { return Math.max(2, Number(t && t.expectedCount) || 0, Number(params.verifierCount) || 0) }
-  function haveEnoughVotes(t) { return Object.keys(t.childResults).length >= minVotes(t) }
+  /**
+   * 票数/参与集的**单一来源**（审计 D4）。一个 verify 任务的参与集与"需要几票"只由**创建时的快照**
+   * `t.expectedCount`（createVerifyTask 写入）与当前 round 决定——**绝不**读实时 `params.verifierCount`
+   * 或实时名册：否则同一个计数会在 quorum 判据 / 裁决聚合 / 任务簿记之间给出不同答案，中途调参会让
+   * 已经在进行中的表决永远凑不够票数而卡死（守卫见 formal-verify-v3 §5c）。
+   */
+  function voteCount(t, round) {
+    const tt = t || {}
+    const expected = Math.max(2, Number(tt.expectedCount) || 0)
+    const r = Number((round === undefined || round === null) ? (tt.round || 1) : round) || 1
+    const participants = Array.isArray(tt.children) ? tt.children.slice() : []
+    const results = tt.childResults || {}
+    const reportedIds = Object.keys(results)
+    const thisRoundIds = participants.filter(function (cid) { const x = results[cid]; return x && Number(x.round) === r })
+    return {
+      round: r, expected: expected, participants: participants,
+      dispatched: participants.length, reported: reportedIds.length, reportedIds: reportedIds,
+      reportedThisRound: thisRoundIds.length,
+      quorum: participants.length > 0 && participants.length >= expected && thisRoundIds.length === participants.length,
+    }
+  }
+  function minVotes(t) { return voteCount(t).expected } // 快照值；**故意**不读实时 params.verifierCount
+  function haveEnoughVotes(t) { const v = voteCount(t); return v.reported >= minVotes(t) } // 单一来源：minVotes 也只读快照
   /** 所有已派出的验证器都报了本轮的票，**且**票数达到下限——否则不得推进/裁决。 */
   function allReportedWithQuorum(t, round) {
-    if (!t || !Array.isArray(t.children) || t.children.length === 0) return false
-    if (t.children.length < Math.max(2, Number(t.expectedCount) || 0)) return false
-    return t.children.every(function (cid) { const r = t.childResults[cid]; return r && r.round === round })
+    const v = voteCount(t, round)
+    return v.dispatched > 0 && v.dispatched >= v.expected && v.quorum
   }
-  function consensus(t) { const vs = Object.keys(t.childResults).map(function (cid) { return t.childResults[cid].Result }); if (vs.length === 0) return false; return vs.every(function (v) { return v === 1 }) || vs.every(function (v) { return v === 0 }) }
+  function consensus(t) { const vs = voteCount(t).reportedIds.map(function (cid) { return t.childResults[cid].Result }); if (vs.length === 0) return false; return vs.every(function (v) { return v === 1 }) || vs.every(function (v) { return v === 0 }) }
   function buildTranscript(t) { const parts = []; const cids = Object.keys(t.childResults); for (let i = 0; i < cids.length; i++) { const r = t.childResults[cids[i]]; parts.push('Reviewer ' + i + ': Result=' + r.Result + ' Reason=' + r.Reason) } return parts.join('\n') }
   async function handleVerifier(childId, meta, output, stopReason) {
     const rId = meta.rId
@@ -3838,7 +3877,7 @@ export function apply(ctx) {
   }
   // 近共识 + forced/flat 裁决（修复 v2 flat 高置信分歧误判：全部同侧且均值≥0.85/≤0.15 取均值）
   function finalVerdict(t) {
-    const rs = Object.keys(t.childResults).map(function (cid) { return t.childResults[cid] })
+    const rs = voteCount(t).reportedIds.map(function (cid) { return t.childResults[cid] })
     if (rs.length === 0) return 0.5
     if (rs.every(function (r) { return r.Result === 1 })) return 1
     if (rs.every(function (r) { return r.Result === 0 })) return 0
@@ -4053,6 +4092,12 @@ export function apply(ctx) {
   /** 证据索引（spec §3.9）：只列**确实存在**的文件；排除 Paper/ 自己（避免自我污染）。
    *  formalVerify=off 必须真的是无操作（formal-verify-v3 的语料守卫断言"off 的提示词里零 Lean 文本"），
    *  所以 off 档不把形式化路径写进材料。 */
+  /**
+   * 成员可见路径说明（跨预设审计 P0）。成员/子代理的**文件工具按会话 cwd 解析**相对路径，而下面列出的
+   * 路径都是**项目根相对**的 ⇒ 必须显式说明"先拼绝对前缀"；计算产物用回执里的绝对字段。一处常量、
+   * 五处材料文本各自 append（绝不替换既有行）。
+   */
+  const PAPER_PATH_NOTE = '（路径说明：成员/子代理的文件工具按**会话 cwd** 解析相对路径，因此上面列出的相对路径都必须先拼上**项目根的绝对前缀**再使用；计算产物请用回执里的绝对字段 `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来。）'
   async function paperEvidenceIndex() {
     const formalNow = formalOn()
     const out = []
@@ -4088,6 +4133,7 @@ export function apply(ctx) {
     const ps = allPropos()
     L.push('')
     L.push('[PROPOSITIONS] (Propos/<分类>/<id>.md)')
+    L.push(PAPER_PATH_NOTE)
     if (ps.length === 0) L.push('- (none)')
     for (let i = 0; i < ps.length; i++) {
       const p = ps[i]
@@ -4098,6 +4144,7 @@ export function apply(ctx) {
     }
     L.push('')
     L.push('[METHODS / ARTEFACTS] (Methods/ + 全局 VibeMath/Methods/)')
+    L.push(PAPER_PATH_NOTE)
     const ms = Array.from(methods.values()).concat(Array.from(globalMethods.values()))
     if (ms.length === 0) L.push('- (none)')
     for (let i = 0; i < ms.length; i++) {
@@ -4696,10 +4743,10 @@ export function apply(ctx) {
   registerTool('vibe_math_set_project', TOOL_DESC.vibe_math_set_project, objParams({ name: { type: 'string' } }, ['name']), async function (args) { const slug = slugify(args.name); return await setProject(slug, false) })
   registerTool('vibe_math_list_projects', TOOL_DESC.vibe_math_list_projects, objParams({}), async function () { return { ok: true, current: currentProject, projects: await listDirsAt(vibeRoot(), 'Projects') } })
   registerTool('vibe_math_list_decisions', TOOL_DESC.vibe_math_list_decisions, objParams({}), async function () { return { ok: true, decisions: decisionQueue.filter(function (d) { return d.status === 'pending' }).map(function (d) { return { id: d.id, node: d.node, context: d.context } }) } })
-  registerTool('vibe_math_decide', TOOL_DESC.vibe_math_decide, objParams({ id: { type: 'string' }, action: { type: 'string', enum: ['approve', 'reject', 'override'] }, verdict: { type: 'number' } }, ['id', 'action']), async function (args) { const d = decisionQueue.find(function (x) { return x.id === args.id }); if (!d) return { ok: false, message: 'decision not found' }; if (d.status !== 'pending') return { ok: false, message: 'decision already resolved' }; const resolution = { action: args.action, verdict: args.verdict }; const applied = await applyDecision(d.node, d.data, resolution); const r = await resolveDecision(args.id, resolution); return Object.assign({ ok: true, applied: applied }, r) })
+  registerTool('vibe_math_decide', TOOL_DESC.vibe_math_decide, objParams({ id: { type: 'string' }, action: { type: 'string', enum: ['approve', 'reject', 'override'] }, verdict: { type: 'number' } }, ['id', 'action']), async function (args) { const d = decisionQueue.find(function (x) { return x.id === args.id }); const resolution = { action: args.action, verdict: args.verdict }; if (!d || d.status !== 'pending') return await resolveDecision(args.id, resolution); const applied = await applyDecision(d.node, d.data, resolution); const r = await resolveDecision(args.id, resolution); return Object.assign({ ok: true, applied: applied }, r) })
   registerTool('vibe_math_list_agents', TOOL_DESC.vibe_math_list_agents, objParams({}), async function () { const out = []; const ids = Object.keys(agentRegistry); for (let i = 0; i < ids.length; i++) { const m = agentRegistry[ids[i]]; out.push({ childId: ids[i], role: m.role, qid: m.qid, direction: m.direction, round: m.round, rId: m.rId }) } return { ok: true, agents: out, count: out.length } })
   registerTool('vibe_math_message_agent', TOOL_DESC.vibe_math_message_agent, objParams({ childId: { type: 'string' }, message: { type: 'string' } }, ['childId', 'message']), async function (args) { if (!agentRegistry[args.childId]) return { ok: false, message: 'unknown childId' }; await followupChild(args.childId, args.message); return { ok: true, message: 'message delivered' } })
-  registerTool('vibe_math_interrupt_agent', TOOL_DESC.vibe_math_interrupt_agent, objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { await interruptChild(args.childId); return { ok: true, message: 'interrupt requested' } })
+  registerTool('vibe_math_interrupt_agent', TOOL_DESC.vibe_math_interrupt_agent, objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { const r = await interruptChild(args.childId); return Object.assign({}, r, { ok: !!(r && r.ok) }) })
   registerTool('vibe_math_plan', TOOL_DESC.vibe_math_plan, objParams({ force: { type: 'boolean' } }), async function (args) { if (args && args.force && scheduler.running && !scheduler.gate) { await callPlanner(); return { ok: true, message: 'planning triggered', queued: planQueue.length } } return { ok: true, queued: planQueue, lastPlan: lastPlanSummary } })
   registerTool('vibe_math_index', TOOL_DESC.vibe_math_index, objParams({}), async function () { await loadKnowledgeBase(); const r = await rebuildIndex(); return { ok: true, index: r, project: currentProject } })
   registerTool('vibe_math_method_add', TOOL_DESC.vibe_math_method_add, objParams({ id: { type: 'string' }, 标题: { type: 'string' }, 类型: { type: 'string' }, 核心内容: { type: 'string' }, 适用场景: { type: 'string' } }, ['id', '标题']), async function (args) { const id = idSafe(args.id); if (methods.has(id)) return { ok: false, message: 'method id already exists' }; const m = { id: id, 标题: args.标题, 类型: args.类型 || '方法', 状态: '经验', 可信断言: [], 上级体系: [], 子方法: [], 相关: [], 适用场景: args.适用场景 || '', 核心内容: args.核心内容 || '', 定义与记号: '', applications: [], improvements: [], 来源: 'user' }; methods.set(m.id, m); await saveMethod(m, false); await rebuildIndex(); return { ok: true, method: m, file: methodRel(m, false) } })

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

@@ -73,8 +73,8 @@
           too; they work in every mode.
         - vibe_v4_formal_report — human-readable Lean formal-verification mirror (mode, Lean-passed
         - math_computation {op: probe|run|receipt|install, engine, mode: code|file|expr, …} — 先 probe 预检引擎/包/许可，再调引擎计算并把脚本与输出归档成可复核回执；缺引擎/缺包只报告与给安装指引/计划；shell 兜底不算归档。
-        - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>），你可以用普通文件工具打开并编辑它；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
-        - 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.
+        - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>，**相对项目根**）；**成员的文件工具是按会话 cwd 解析的**，所以打开它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
+        - 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.
         - 替代必须声明（诚实性）：当替代方案改变了**精确性或结论强度**时（精确符号解 → 数值近似、闭式解 → 采样/求积、改了精度/容差/假设、换了算法类），结论里**必须写明**，不得读起来像得到了原本（精确/所要求的）结果；拿不到精确结果就直说。
         - Declare substitutions (honesty): when an alternative changes EXACTNESS or conclusion strength (exact symbolic solution -> numerical approximation, closed form -> sampling/quadrature, changed precision/tolerances/assumptions, a different algorithm class), the conclusion MUST say so explicitly and must not read as if the original (exact/requested) result had been obtained; if the exact result is unavailable, say so plainly.
           objects, recorded blockers, formalization TODO, library paths).
@@ -185,8 +185,8 @@
           too; they work in every mode.
         - vibe_v4_formal_report — human-readable Lean formal-verification mirror (mode, Lean-passed
         - math_computation {op: probe|run|receipt|install, engine, mode: code|file|expr, …} — 先 probe 预检引擎/包/许可，再调引擎计算并把脚本与输出归档成可复核回执；缺引擎/缺包只报告与给安装指引/计划；shell 兜底不算归档。
-        - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>），你可以用普通文件工具打开并编辑它；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
-        - 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.
+        - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>，**相对项目根**）；**成员的文件工具是按会话 cwd 解析的**，所以打开它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
+        - 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.
         - 替代必须声明（诚实性）：当替代方案改变了**精确性或结论强度**时（精确符号解 → 数值近似、闭式解 → 采样/求积、改了精度/容差/假设、换了算法类），结论里**必须写明**，不得读起来像得到了原本（精确/所要求的）结果；拿不到精确结果就直说。
         - Declare substitutions (honesty): when an alternative changes EXACTNESS or conclusion strength (exact symbolic solution -> numerical approximation, closed form -> sampling/quadrature, changed precision/tolerances/assumptions, a different algorithm class), the conclusion MUST say so explicitly and must not read as if the original (exact/requested) result had been obtained; if the exact result is unavailable, say so plainly.
           objects, recorded blockers, formalization TODO, library paths).