dsh-vibe-math 2.7.0 → 2.7.2

package/vibe-math-v3/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-v3/vibe-math-v3.js

@@ -49,6 +49,7 @@ import {
   MATH_TOOL_DESCRIPTION,
   MATH_TOOL_SCHEMA,
   MATH_ARCHIVE_WORKFLOW_LINE,
+  MATH_SUBSTITUTION_RULE_LINE,
   MATH_PERSONA_TOOL_LINE,
   MATH_RULE_LINES,
   normalizeMathParams,
@@ -524,6 +525,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,
@@ -544,7 +550,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 项）：可用性行必须带"替代必须声明（诚实性）"。引用**常量**而非比对文本：
+      // 模块改措辞不会误报，只有整条规则消失才会响。
+      if (mathProbe && mathAvailabilityLine(mathProbe, 'zh', params.mathMode).indexOf(MATH_SUBSTITUTION_RULE_LINE) === -1) {
+        console.error('vibe-math-v3: 可用性行缺少替代声明规则（MATH_SUBSTITUTION_RULE_LINE）')
+      }
+    } catch (e) { mathProbe = null }
     return mathProbe
   }
   /** 心跳里的 TTL 刷新（每拍一次布尔判断）。 */
@@ -904,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 || ''))
@@ -1295,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') : '' }
@@ -1611,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)) }) }
@@ -1863,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 })
@@ -1877,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
@@ -3742,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
@@ -3824,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
@@ -4039,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 = []
@@ -4074,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]
@@ -4084,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++) {
@@ -4682,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) } })
@@ -4967,6 +5028,8 @@ export function apply(ctx) {
     mathProbe: function () { return mathProbe },
     // P2a：persona 两个文本块必须含的「归档→编辑→重跑」规则（文本取自共享模块常量，persona 不手抄）。
     mathArchiveWorkflowLine: MATH_ARCHIVE_WORKFLOW_LINE,
+    // A 项：替代声明规则（文本由共享模块给出；persona 两块与每轮可用性行都必须带它）。
+    mathSubstitutionRuleLine: MATH_SUBSTITUTION_RULE_LINE,
     // childOwner 裁剪用（审计 L1）：这个会话当前仍"可能再发 subagent/end"的 child
     // = 在册子代理 + 任何任务正在等的那几个。
     referencedChildIds: function () {

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

@@ -73,8 +73,10 @@
           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).
         - vibe_v4_prompts {which: brainstorm|normal|heartbeat|meeting|verify|coreRules, member?, target?, stage?} — read the exact prompt text a resident would receive (prompt auditing; prompt text is the product).
       A /v4 slash command mirrors the main controls (configure|start [problem]|resume|pause|abort|status|report|message <to|all> <content>|meeting|paper [lang=zh|en] [format=md|tex|both] [editor=office|resident:<id>] [force]|members|add|remove|set <k=v>...).
@@ -183,8 +185,10 @@
           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).
         - vibe_v4_prompts {which: brainstorm|normal|heartbeat|meeting|verify|coreRules, member?, target?, stage?} — read the exact prompt text a resident would receive (prompt auditing; prompt text is the product).
       A /v4 slash command mirrors the main controls (configure|start [problem]|resume|pause|abort|status|report|message <to|all> <content>|meeting|paper [lang=zh|en] [format=md|tex|both] [editor=office|resident:<id>] [force]|members|add|remove|set <k=v>...).