dsh-vibe-math 2.7.0 → 2.7.2

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

@@ -22,14 +22,47 @@ export const MATH_ENGINES = {
     candidates: ['python3', 'python', 'py'], winPrefix: ['-3'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+\\.\\d+)',
     scriptArgv: ['<script>'], evalArgv: ['-c', '<expr>'], stdinArgv: ['-'], ext: '.py',
-    probeCode: "import importlib.util,sys;print('|'.join('%s:%s'%(p,'ok' if importlib.util.find_spec(p) else 'missing') for p in sys.argv[1:]))",
-    packageProbe: { argv: ['-c', '<probeCode>', '<pkgs>'], parse: 'pairs' },
+    // 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')",
+    // round-7 (finding 6, found on the real bundled python): the probe code iterates `sys.argv[1:]`,
+    // so the names must be SEPARATE argv items - the old comma-joined `<pkgs>` made it look up one
+    // package literally named "numpy,pandas" and reported everything missing.
+    packageProbe: { argv: ['-c', '<probeCode>', '<pkgs...>'], parse: 'pairs' },
     license: 'free', argErrorHints: ARG_ERROR_HINTS,
     install: {
       manager: 'pip',
       userArgv: ['<exe>', '-m', 'pip', 'install', '--user', '<pkg>'],
       systemArgv: ['<exe>', '-m', 'pip', 'install', '<pkg>'],
       uninstallArgv: ['<exe>', '-m', 'pip', 'uninstall', '-y', '<pkg>'],
+      // Round-6 (B): DISPATCH by the detected interpreter environment. `pip` is the documented
+      // fallback; the module picks conda/mamba/uv only when the interpreter's OWN environment says so
+      // (detect, don't guess) and the plan states which manager it assumed.
+      managers: {
+        conda: {
+          detect: 'conda-markers',
+          userArgv: ['conda', 'install', '-y', '-c', 'conda-forge', '<pkg>'],
+          uninstallArgv: ['conda', 'remove', '-y', '<pkg>'],
+          systemUnsupportedReason: 'conda 环境是用户级的；系统级安装不在 conda 的概念里（本工具只出用户级计划）',
+        },
+        mamba: {
+          detect: 'conda-markers',
+          userArgv: ['mamba', 'install', '-y', '-c', 'conda-forge', '<pkg>'],
+          uninstallArgv: ['mamba', 'remove', '-y', '<pkg>'],
+          systemUnsupportedReason: 'mamba 环境是用户级的；系统级安装不在 mamba 的概念里（本工具只出用户级计划）',
+        },
+        uv: {
+          detect: 'uv-next-to-interpreter',
+          userArgv: ['uv', 'pip', 'install', '<pkg>'],
+          uninstallArgv: ['uv', 'pip', 'uninstall', '<pkg>'],
+          systemUnsupportedReason: 'uv 装进当前虚拟环境（用户级）；系统级需要发行版包管理器，本工具只出用户级计划',
+        },
+        pip: {
+          detect: 'fallback',
+          systemArgv: ['<exe>', '-m', 'pip', 'install', '<pkg>'],
+          uninstallArgv: ['<exe>', '-m', 'pip', 'uninstall', '-y', '<pkg>'],
+        },
+      },
     },
     userInstall: { windows: 'winget install --id Python.Python.3.12', macos: 'brew install python', linux: 'apt install python3' },
   },
@@ -38,13 +71,16 @@ export const MATH_ENGINES = {
     candidates: ['Rscript', 'R'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+\\.\\d+)',
     scriptArgv: ['<script>'], evalArgv: ['-e', '<expr>'], stdinArgv: ['--no-save', '--slave'], ext: '.R',
-    probeCode: "cat(paste(sapply(strsplit('__PKGS__',',')[[1]],function(p) paste0(p,':',requireNamespace(p,quietly=TRUE))),collapse='|'))",
+    // 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' },
     license: 'free', argErrorHints: ARG_ERROR_HINTS,
     install: {
       manager: 'r',
       userArgv: ['<exe>', '-e', "install.packages('__PKG__',lib=Sys.getenv('R_LIBS_USER'),repos='https://cloud.r-project.org')"],
       uninstallArgv: ['<exe>', '-e', "remove.packages('__PKG__',lib=Sys.getenv('R_LIBS_USER'))"],
+      // Round-6 (C): user-only BY DESIGN, and the refusal now says why per engine.
+      systemUnsupportedReason: 'R 的用户库是 R_LIBS_USER；系统级安装要写发行版的包目录（需 root 或发行版包管理器），本工具只出用户级计划',
     },
     userInstall: { windows: 'winget install --id RProject.R', macos: 'brew install r', linux: 'apt install r-base' },
   },
@@ -54,13 +90,15 @@ export const MATH_ENGINES = {
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+\\.\\d+)',
     scriptArgv: ['--no-gui', '--quiet', '<script>'], evalArgv: ['--no-gui', '--quiet', '--eval', '<expr>'],
     stdinArgv: ['--no-gui', '--quiet'], ext: '.m',
-    probeCode: "s=pkg('list'); n={'__QPKGS__'}; for i=1:numel(n); printf('%s:%s|',n{i},merge(any(cellfun(@(x) strcmp(x.name,n{i}),s)),'ok','missing')); end",
+    // 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' },
     license: 'free', argErrorHints: ARG_ERROR_HINTS,
     install: {
       manager: 'octave-pkg',
       userArgv: ['<exe>', '--no-gui', '--quiet', '--eval', "pkg install -forge __PKG__"],
       uninstallArgv: ['<exe>', '--no-gui', '--quiet', '--eval', 'pkg uninstall __PKG__'],
+      systemUnsupportedReason: 'Octave 的 pkg install 装进用户包目录；系统级要写 Octave 的 share/packages（需 root），本工具只出用户级计划',
     },
     userInstall: { windows: 'winget install --id GNU.Octave', macos: 'brew install octave', linux: 'apt install octave' },
   },
@@ -76,6 +114,7 @@ export const MATH_ENGINES = {
       manager: 'julia-pkg',
       userArgv: ['<exe>', '-e', 'using Pkg; Pkg.add("__PKG__")'],
       uninstallArgv: ['<exe>', '-e', 'using Pkg; Pkg.rm("__PKG__")'],
+      systemUnsupportedReason: 'Julia 的 Pkg.add 装进当前活动环境 / 用户 depot（JULIA_DEPOT_PATH）；系统级不是 Julia 的概念，本工具只出用户级计划',
     },
     userInstall: { windows: 'winget install --id Julialang.Julia', macos: 'brew install julia', linux: 'apt install julia' },
   },
@@ -84,7 +123,8 @@ export const MATH_ENGINES = {
     candidates: ['matlab'],
     versionArgv: ['-batch', 'disp(version)'], versionRe: '(\\d+\\.\\d+)',
     scriptArgv: ['-batch', "run('<script>')"], evalArgv: ['-batch', '<expr>'], stdinArgv: null, ext: '.m',
-    probeCode: "t={'__QPKGS__'}; for i=1:numel(t); printf('%s:%d|',t{i},license('test',t{i})); end",
+    // 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' },
     license: 'commercial', argErrorHints: ARG_ERROR_HINTS,
     licenseProbe: { argv: ['-batch', "disp(license('test','MATLAB'))"], okWhen: 'trim-1' },
@@ -96,7 +136,8 @@ export const MATH_ENGINES = {
     candidates: ['maple'],
     versionArgv: ['--version'], versionRe: '(\\d+\\.\\d+)',
     scriptArgv: ['-q', '<script>'], evalArgv: ['-q', '-c', '<expr>'], stdinArgv: null, ext: '.mpl',
-    probeCode: 'for p in ["__PKGS__"] do try with(p) catch: printf("%s:missing|", p); next end try; printf("%s:ok|", p) end do',
+    // 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' },
     license: 'commercial', argErrorHints: ARG_ERROR_HINTS,
     licenseProbe: { argv: ['-q', '-c', 'printf("1")'], okWhen: 'exit-0' },

package/vibe-math-v2/vibe-math-v2.js

@@ -30,6 +30,7 @@ import {
   MATH_TOOL_DESCRIPTION,
   MATH_TOOL_SCHEMA,
   MATH_ARCHIVE_WORKFLOW_LINE,
+  MATH_SUBSTITUTION_RULE_LINE,
   MATH_PERSONA_TOOL_LINE,
   MATH_RULE_LINES,
   normalizeMathParams,
@@ -536,6 +537,11 @@ export function apply(ctx) {
     // **可选能力，按宿主实际情况声明**：宿主 fs 没有 listDir 就不给这个回调（模块据此跳过
     // "每项目 run 目录数 >200" 的保留检查，而不是每次运行都白问一次）。
     listDir: (typeof fs.listDir === 'function') ? mathListDir : undefined,
+    // round-7 (fix 2): DSH's own bundled runtimes (`<home>/.dsh/dsh-runtimes/*/dependencies/<engine>/`)
+    // as a LAST resort after PATH. Only generic roots are supplied here; the module globs the tree
+    // name (never `dsh-primary-runtime`) and only accepts the descriptor's own candidate names.
+    runtimeRoots: () => { const env = process.env.DSH_HOME; if (env) return [String(env)]; const home = String(process.env.HOME || process.env.USERPROFILE || ''); return home ? [home.replace(/[\\/]+$/, '') + '/.dsh'] : [] },
+    listDirAbs: async function (abs) { try { const t = await fsTarget(abs); const st = await fs.stat(t); if (!st) return []; return (await fs.listDir(t)) || [] } catch (e) { return [] } },
     writeText: async function (rel, text) { return await writeText(rel, text) },
     readText: async function (rel) { return await readText(rel) },
     exists: mathExists,
@@ -557,7 +563,15 @@ export function apply(ctx) {
   async function refreshMathProbe(force) {
     if (params.mathComputation === 'off') { mathProbe = null; mathProbeAt = 0; return null }
     if (!mathTool) return null
-    try { mathProbe = await mathTool.probe(force ? { refresh: true } : undefined); mathProbeAt = now() } catch (e) { mathProbe = null }
+    try {
+      mathProbe = await mathTool.probe(force ? { refresh: true } : undefined)
+      mathProbeAt = now()
+      // 规则漂移自检（A 项）：可用性行必须带"替代必须声明（诚实性）"这条规则。这里引用**常量**
+      // 而不是比对文本——模块以后改措辞不会误报，只有整条规则从 MATH_RULE_LINES 里消失才会响。
+      if (mathProbe && mathAvailabilityLine(mathProbe, 'zh', params.mathMode).indexOf(MATH_SUBSTITUTION_RULE_LINE) === -1) {
+        console.error('vibe-math-v2: 可用性行缺少替代声明规则（MATH_SUBSTITUTION_RULE_LINE）')
+      }
+    } catch (e) { mathProbe = null }
     return mathProbe
   }
   /** 心跳里的 TTL 刷新（每拍一次布尔判断，成本可忽略）。 */
@@ -2035,6 +2049,8 @@ export function apply(ctx) {
       propositions: { total: propos.length, resolved: propos.filter(function (p) { return p.布尔估计 === 1 || p.布尔估计 === 0 }).length },
       pendingDecisions: decisionQueue.filter(function (d) { return d.status === 'pending' }).map(function (d) { return { id: d.id, node: d.node, context: d.context } }),
       registeredAgents: Object.keys(agentRegistry).length,
+      // D4 审计面：每个在飞验证任务的参与集/票数都由 voteCount 投影出来（两个视图可对照）。
+      verifyTasks: Object.keys(tasks).filter(function (k) { return tasks[k] && tasks[k].type === 'verify' }).map(function (k) { const t = tasks[k]; const v = voteCount(t); return { rId: t.rId, status: t.status, round: v.round, expected: v.expected, dispatched: v.dispatched, reported: v.reportedThisRound, quorum: v.quorum } }),
       recentActivity: activityLog.slice(-Math.min(ACTIVITY_REPORT_MAX, Number(params.activityLogCap) || 100)),
       // Lean 形式化：可调档位与开关同处可读参数表（契约 §1），并附当前形式化记录概况。
       formal: {
@@ -2151,7 +2167,22 @@ export function apply(ctx) {
     // 不再手工累加并发计数：唤醒的是 registry 里已登记的 child，计数已由 registry 长度体现。
     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 solverPersonaText() { return params.solverPersona ? (String(params.solverPersona) + '\n\n') : '' }
@@ -2388,7 +2419,10 @@ export function apply(ctx) {
     if (node === 'verdict') { const overridden = resolution.action === 'override' && (resolution.verdict === 1 || resolution.verdict === 0); const v = overridden ? Number(resolution.verdict) : data.verdict; const applied = await settleVerdict(data.task, v); delete tasks[data.task.id]; return { verdict: v, overridden: overridden, applied: applied } }
     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' } }
   /**
    * 清掉 gate 时**必须结清它指向的那个人工决策**（审计 M10）。start/resume/abort/切项目都会离开
    * 需要那次决策的运行，而决策若仍是 `pending`，它会永远留在 `vibe_math_list_decisions` 里反复出现——
@@ -2680,13 +2714,14 @@ export function apply(ctx) {
   }
   async function backfillVerifiers(t) {
     const cap = reviewerCap()
-    while (t.children.length < t.expectedCount && t.children.length < cap) {
+    const want = voteCount(t).expected // 快照目标（不再直接读 t.expectedCount，保持单一来源）
+    while (t.children.length < want && t.children.length < cap) {
       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 })
       t.children.push(childId)
     }
-    if (t.children.length >= t.expectedCount) t.status = 'debating'
+    if (t.children.length >= want) t.status = 'debating'
   }
   async function reconcileVerify() {
     const ids = Object.keys(tasks)
@@ -2702,7 +2737,7 @@ export function apply(ctx) {
         } else 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).allParticipantsReported
         if (allReported) { t.status = 'debating'; await advanceVerification(t, t.round); continue }
       }
       if (t.status !== 'spawning') continue
@@ -2926,8 +2961,40 @@ export function apply(ctx) {
   }
 
   // ================= verification (验证器) =================
+  /**
+   * 验证任务的**票数/参与集单一来源**（跨预设审计 D4，与 v3 的 voteCount 同型）。
+   *
+   * 定义（本文件里"参与集"只有一个含义）：一个 verify 任务的参与集 = **本轮被派出的评审**，
+   * 也就是 `t.children`（当前 round 的 `childResults` 条目是它们的票）；"需要几票"= **任务创建时的
+   * 快照** `t.expectedCount`（processVerify 建任务时写入），**绝不**读实时 `params.verifierCount`
+   * 或 `params.maxParallelThreshold`。旧实现把这个答案分散在三处——`consensus()` 只看
+   * `Object.keys(t.childResults)`（已报票）且用常量 MIN_REVIEWERS 当下限、`finalizeVerification()`
+   * 又自己数一遍、两处内联 `allReported` 用 `t.children` + round——同一个计数在不同视图里可以不同
+   * （中途增/减评审、某个评审掉线后，辩论视图与裁决视图可能对"这一轮算不算完"给出不同答案）。
+   * 现在所有视图都读这一个函数。
+   */
+  // 契约（P2-v2 修复轮，必须保持）：一致/票数下限仍按 **MIN_REVIEWERS** 判定，一致性的对象是
+  // **所有已报结果**（reportedIds）。`voteCount` 只是把这些读法收拢到一个来源 + 提供审计投影；
+  // 它**不**改变"一票不算共识"的既有语义（v2-fix-probes 的 M11 探针钉着这条）。
+  function voteCount(t, round) {
+    const tt = t || {}
+    const expected = Math.max(MIN_REVIEWERS, 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,
+      // 旧语义的「本轮都报了吗」：只看**已派出的评审**，不额外要求达到快照票数（那一条属于裁决下限）。
+      allParticipantsReported: participants.length > 0 && thisRoundIds.length === participants.length,
+      quorum: participants.length > 0 && participants.length >= expected && thisRoundIds.length === participants.length,
+    }
+  }
   // 一票不算共识：≥MIN_REVIEWERS 份独立评审才可能达成/否决共识（审计 M11；与 v3 的最小票数同型）。
-  function consensus(t) { const cids = Object.keys(t.childResults); if (cids.length < MIN_REVIEWERS) return false; const vs = cids.map(function (cid) { return t.childResults[cid].Result }); return vs.every(function (v) { return v === 1 }) || vs.every(function (v) { return v === 0 }) }
+  function consensus(t) { const v = voteCount(t); if (v.reportedIds.length < MIN_REVIEWERS) return false; const vs = v.reportedIds.map(function (cid) { return t.childResults[cid].Result }); return vs.every(function (x) { return x === 1 }) || vs.every(function (x) { return x === 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') }
   // 说明（审计 L17）：这里曾有一个 `verifierWeight(cid, rigor)`，但全仓只有它的定义、没有任何调用点，
   // 且其公式（clamped ±0.2 rigor 加成、按 childId 取准确率）与 finalVerdict 里真正在用的
@@ -2986,7 +3053,7 @@ export function apply(ctx) {
     if (t.children.indexOf(childId) === -1) t.children.push(childId)
     t.childResults[childId] = { Result: Result, Reason: Reason, round: meta.round, key: meta.verificationKey || verifierIdentityKey() }
     delete agentRegistry[childId]
-    const allReported = t.children.length > 0 && t.children.every(function (cid) { const r = t.childResults[cid]; return r && r.round === meta.round })
+    const allReported = voteCount(t, meta.round).allParticipantsReported
     if (!allReported) { await saveAll(); return }
     await advanceVerification(t, meta.round)
     await saveAll()
@@ -3026,7 +3093,7 @@ export function apply(ctx) {
    * `stalled`，冷却期后重试（任务保留 ⇒ processVerify 不会为同一个 rId 另造任务，也不会每 tick 重试）。
    */
   async function finalizeVerification(t) {
-    const reviews = Object.keys(t.childResults || {}).length
+    const reviews = voteCount(t).reportedIds.length
     if (reviews < MIN_REVIEWERS) {
       const tried = Number(t.reviewerRespawn || 0)
       if (scheduler.running && tried < 2 && reviewerCap() >= MIN_REVIEWERS) {
@@ -3057,7 +3124,8 @@ export function apply(ctx) {
     }
   }
   function finalVerdict(t) {
-    const rs = Object.keys(t.childResults).map(function (cid) { return t.childResults[cid] })
+    const v = voteCount(t)
+    const rs = v.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
@@ -3437,6 +3505,12 @@ export function apply(ctx) {
   /** 证据索引（spec §3.9）：只列**确实存在**的文件；绝不含 Paper/ 自己（否则输入哈希会自我污染）。
    *  off 档必须真的是无操作（formal-verify-v2 的语料守卫会断言"off 的提示词里零 Lean 文本"）：
    *  formal 未启用时，形式化相关的路径与字段一概不写进材料。 */
+  /**
+   * 成员可见路径说明（跨预设审计 P0）。成员/子代理的**文件工具按会话 cwd 解析**相对路径，而下面列出的
+   * 路径都是**项目根相对**的 ⇒ 必须显式说明"先拼绝对前缀"；计算产物用回执里的绝对字段。一处常量、
+   * 五处材料文本各自 append（绝不替换既有行）。
+   */
+  const PAPER_PATH_NOTE = '（路径说明：成员/子代理的文件工具按**会话 cwd** 解析相对路径，因此上面列出的相对路径都必须先拼上**项目根的绝对前缀**再使用；计算产物请用回执里的绝对字段 `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来。）'
   async function paperEvidenceIndex() {
     const formalNow = formalOn()
     const out = ['qs/qs.json']
@@ -3446,6 +3520,7 @@ export function apply(ctx) {
     if (formalNow) for (const f of await listFiles('Verified/Lean')) out.push('Verified/Lean/' + f)
     const dirs = ['Verification_logs', 'Progress_Logs'].concat(formalNow ? ['Formal'] : [])
     for (let i = 0; i < dirs.length; i++) { const files = await listFiles(dirs[i]); for (let j = 0; j < files.length; j++) out.push(dirs[i] + '/' + files[j]) }
+    out.push(PAPER_PATH_NOTE)
     return out.filter(function (x) { return x.indexOf('Paper/') !== 0 }).sort()
   }
   /** 汇总材料（spec §4）：只含既有证据 + 未决/被否证的显式标注。不含时间戳 ⇒ 哈希稳定。 */
@@ -3470,6 +3545,7 @@ export function apply(ctx) {
     const props = await getPropos()
     L.push('')
     L.push('[PROPOSITIONS] (Propos/*.json)')
+    L.push(PAPER_PATH_NOTE)
     if (props.length === 0) L.push('- (none)')
     for (let i = 0; i < props.length; i++) {
       const p = props[i]
@@ -3923,6 +3999,8 @@ export function apply(ctx) {
       propositions: { total: propos.length, resolved: propos.filter(function (p) { return p.布尔估计 === 1 || p.布尔估计 === 0 }).length },
       pendingDecisions: decisionQueue.filter(function (d) { return d.status === 'pending' }).length,
       registeredAgents: Object.keys(agentRegistry).length,
+      // D4 审计面：每个在飞验证任务的参与集/票数都由 voteCount 投影出来（两个视图可对照）。
+      verifyTasks: Object.keys(tasks).filter(function (k) { return tasks[k] && tasks[k].type === 'verify' }).map(function (k) { const t = tasks[k]; const v = voteCount(t); return { rId: t.rId, status: t.status, round: v.round, expected: v.expected, dispatched: v.dispatched, reported: v.reportedThisRound, quorum: v.quorum } }),
       recentActivity: activityLog.slice(-Math.min(ACTIVITY_REPORT_MAX, Number(params.activityLogCap) || 100)), params: params,
       formal: {
         mode: formalMode(), required: formalRequired(),
@@ -3997,10 +4075,10 @@ export function apply(ctx) {
   registerTool('vibe_math_set_project', 'Switch the current math project.', objParams({ name: { type: 'string' } }, ['name']), async function (args) { const slug = slugify(args.name); return await setProject(slug, false) })
   registerTool('vibe_math_list_projects', 'List math projects.', objParams({}), async function () { return { ok: true, current: currentProject, projects: await listDirsAt(vibeRoot(), 'Projects') } })
   registerTool('vibe_math_list_decisions', 'List pending manual 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', 'Resolve a pending manual decision (verdict override uses verdict: 1|0).', 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', 'Resolve a pending manual decision (verdict override uses verdict: 1|0).', 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', 'List tracked sub-agents (child sessions).', 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', 'Send a message to a tracked child agent (next turn).', 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', 'Interrupt a tracked child agent.', objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { await interruptChild(args.childId); return { ok: true, message: 'interrupt requested' } })
+  registerTool('vibe_math_interrupt_agent', 'Interrupt a tracked child agent.', objParams({ childId: { type: 'string' } }, ['childId']), async function (args) { const r = await interruptChild(args.childId); return Object.assign({}, r, { ok: !!(r && r.ok) }) })
   // ---- Lean 形式化验证（契约 §5）----
   registerTool('vibe_math_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the VibeMath root and report the result. Never throws: a missing toolchain returns LEAN_NOT_FOUND, a non-zero exit returns the compiler output. Pass target=<object id> to also record the run against that object.', objParams({ file: { type: 'string' }, target: { type: 'string' }, timeout_ms: { type: 'integer' } }, ['file']), async function (args, agent) { return await leanRunTool(memberIdOf(agent), args) })
   registerTool('vibe_math_lean_archive', '(member) Archive Lean code. kind="def": a REUSABLE definition/object/assumption → the global cross-project library (Formal/Lib). kind="lemma": a machine-checked lemma → Formal/Proved. kind="proof": the formal proof of a project object → Formal/<target>.lean, and (when the run passes) also Verified/Lean/<target>.lean, marking the object Lean-passed. kind="blocked": record an explicit, reasoned "cannot/not worth formalizing" decision (note required).', objParams({ kind: { type: 'string', enum: ['def', 'lemma', 'proof', 'blocked'] }, name: { type: 'string' }, target: { type: 'string' }, content: { type: 'string' }, from: { type: 'string' }, note: { type: 'string' }, run: { type: 'boolean' } }, ['kind']), async function (args, agent) { return await leanArchive(memberIdOf(agent), args) })
@@ -4074,6 +4152,8 @@ export function apply(ctx) {
     mathProbe: function () { return mathProbe },
     // P2a：persona 两个文本块必须含的「归档→编辑→重跑」规则（文本取自共享模块常量，persona 不手抄）。
     mathArchiveWorkflowLine: MATH_ARCHIVE_WORKFLOW_LINE,
+    // A 项：替代声明规则（文本由共享模块给出；persona 两块与每轮可用性行都必须带它）。
+    mathSubstitutionRuleLine: MATH_SUBSTITUTION_RULE_LINE,
     leanQueueSize: function () { return leanQueue.length },
     leanJobsPublic: function () { const out = []; for (const j of leanJobs.values()) out.push(leanJobPublic(j)); return out },
     // childOwner 裁剪用：这个会话当前仍"可能再发 subagent/end"的 child（在册的 + 任务正在等的）。

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

@@ -68,7 +68,8 @@
         mode.
 
       - 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 时显式告警。
+      - 替代必须声明（诚实性）：当替代方案改变了**精确性或结论强度**时（精确符号解 → 数值近似、闭式解 → 采样/求积、改了精度/容差/假设、换了算法类），结论里**必须写明**，不得读起来像得到了原本（精确/所要求的）结果；拿不到精确结果就直说。
+      - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>，**相对项目根**）；**成员的文件工具是按会话 cwd 解析的**，所以打开它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
 
       A /vibe slash command mirrors the main controls (/vibe start [override]|resume [override]|pause|abort|status|report|mode
       <auto|manual>|setup|save|template [global|project]|add <id> <desc>|add-proposition <id> <概述>|list-propositions|methods|index|plan|lock|project [list|new <name>|<name>]|decisions|agents|paper [lang=zh|en] [format=both|md|tex] [force]).
@@ -159,7 +160,8 @@
         mode.
 
       - 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 时显式告警。
+      - 替代必须声明（诚实性）：当替代方案改变了**精确性或结论强度**时（精确符号解 → 数值近似、闭式解 → 采样/求积、改了精度/容差/假设、换了算法类），结论里**必须写明**，不得读起来像得到了原本（精确/所要求的）结果；拿不到精确结果就直说。
+      - 归档→编辑→重跑：mode:'code' 的脚本原件在回执的 scriptPath（Computation/<id>/script.<ext>，**相对项目根**）；**成员的文件工具是按会话 cwd 解析的**，所以打开它要用**绝对路径** `receipt.scriptAbs`，或把 `receipt.cwd` 与 `receipt.scriptPath` 拼起来（回执两个字段都有）；编辑后用 mode:'file' 指向它重跑，会写出一份**新回执/新 attempt**（含新的 scriptHash）。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
 
       A /vibe slash command mirrors the main controls (/vibe start [override]|resume [override]|pause|abort|status|report|mode
       <auto|manual>|setup|save|template [global|project]|add <id> <desc>|add-proposition <id> <概述>|list-propositions|methods|index|plan|lock|project [list|new <name>|<name>]|decisions|agents|paper [lang=zh|en] [format=both|md|tex] [force]).