dsh-vibe-math 2.7.1 → 2.7.3

package/tests/v5-institute-fixes.mutants.mjs

@@ -0,0 +1,190 @@
+// Registered mutant harness for the v5 institute fixes — the suite carries its own proof.
+// Each family is a SINGLE content-anchored mutation of the v5 preset (no line numbers); the suite runs
+// through the V5_PLUGIN seam. Child runs are bounded (a timeout is a HANG); skipped families are printed
+// and counted. Exit criterion: every family reddens BY NAME; ALL MUTANTS RED AS REQUIRED + exit 0 only then.
+// Run: node tests/v5-institute-fixes.mutants.mjs
+import { readFileSync, writeFileSync, mkdirSync, copyFileSync, rmSync, readdirSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+const HERE = dirname(fileURLToPath(import.meta.url))
+const REPO = join(HERE, '..')
+const PRESET = 'vibe-math-v5'
+const MAIN = PRESET + '.js'
+const SUITE = 'tests/e2e-v5-round2.test.mjs'
+const ENV = 'V5_PLUGIN'
+// This suite is long, so the default child budget is generous; MUTANT_CHILD_TIMEOUT_MS overrides it.
+const CHILD_TIMEOUT_MS = Number(process.env.MUTANT_CHILD_TIMEOUT_MS || 300000)
+const TIMES = []
+const hangs = []
+const skipped = []
+function copyGraph(file, dest) {
+  const src = join(REPO, PRESET, file)
+  copyFileSync(src, join(dest, file))
+  for (const m of readFileSync(src, 'utf8').matchAll(/from\s+'(\.\/[A-Za-z0-9_.-]+\.js)'/g)) {
+    const dep = m[1].slice(2)
+    if (!readdirSync(dest).includes(dep)) copyGraph(dep, dest)
+  }
+}
+function runFamily(f) {
+  const dest = join(tmpdir(), 'v5fix-mut-' + Math.random().toString(36).slice(2, 10))
+  mkdirSync(dest, { recursive: true })
+  copyGraph(MAIN, dest)
+  const target = join(dest, f.editFile || MAIN)
+  const before = readFileSync(target, 'utf8')
+  const n = before.split(f.from).length - 1
+  const okCount = f.lastOnly || f.all ? n >= 1 : n === 1
+  if (!okCount) {
+    skipped.push(f.name + ' (anchor x' + n + ')')
+    console.error('  SKIP - ' + f.name + ' (anchor x' + n + ')')
+    rmSync(dest, { recursive: true, force: true })
+    return false
+  }
+  const mutated = f.lastOnly
+    ? (() => { const i = before.lastIndexOf(f.from); return before.slice(0, i) + f.to + before.slice(i + f.from.length) })()
+    : before.split(f.from).join(f.to)
+  writeFileSync(target, mutated, 'utf8')
+  try { execFileSync(process.execPath, ['--check', target], { stdio: 'pipe' }) }
+  catch (e) {
+    writeFileSync(target, before, 'utf8')
+    skipped.push(f.name + ' (mutation did not compile)')
+    console.error('  SKIP - ' + f.name + ' (mutation did not compile; restored)')
+    rmSync(dest, { recursive: true, force: true })
+    return false
+  }
+  const t0 = Date.now()
+  let out = ''
+  let code = 0
+  let hang = false
+  try {
+    out = execFileSync(process.execPath, [SUITE], {
+      cwd: REPO, encoding: 'utf8', timeout: CHILD_TIMEOUT_MS, killSignal: 'SIGKILL',
+      env: Object.assign({}, process.env, { [ENV]: join(dest, MAIN) }),
+    })
+  } catch (e) {
+    if (e && (e.killed || e.signal === 'SIGKILL')) hang = true
+    code = (e && e.status) || 1
+    out = String((e && e.stdout) || '') + String((e && e.stderr) || '')
+  }
+  const ms = Date.now() - t0
+  TIMES.push([f.name, ms])
+  if (hang) hangs.push(f.name + '(' + Math.round(ms / 1000) + 's)')
+  const named = out.split(/\r?\n/).filter((l) => /^\s*(FAIL - | {2}- )/.test(l) && f.expect.test(l)).map((l) => l.trim())
+  const ok = !hang && code !== 0 && named.length > 0
+  console.log((hang ? '  HANG - ' : (ok ? '  ok - ' : '  FAIL - ')) + f.name + ' [' + ms + 'ms]' + (named.length ? ' :: ' + named[0].slice(0, 150) : ' :: no named red (exit=' + code + ')'))
+  rmSync(dest, { recursive: true, force: true })
+  return ok
+}
+const FAMILIES = [
+  {
+    // G1: acking at prompt-build time again — a failed wake then consumes the message.
+    name: 'G1: the mailbox is acked BEFORE the wake again',
+    from: 'if (ok && prompt.pending.length) await ackPending(prompt.pending)',
+    to: 'if (prompt.pending.length) await ackPending(prompt.pending)',
+    expect: /\[G1\] a message whose wake FAILED is still pending/,
+  },
+  {
+    // G2: counting the round BEFORE a send that can fail (the historical shape v4 fixed as F10).
+    name: 'G2: the round counter is applied BEFORE the send again',
+    from: 'const nextRound = (rounds.get(member.id) || 0) + 1',
+    to: 'rounds.set(member.id, (rounds.get(member.id) || 0) + 1); const nextRound = (rounds.get(member.id) || 0) + 1',
+    expect: /\[G2\] a failed send must not consume a round/,
+  },
+  {
+    // G4: restoring the second, unprotected whole-object write after the CAS (the lost-update window).
+    name: 'G4: a second task write after the CAS is restored',
+    from: "const r = await taskUpdate(memberId, { task_id: taskId, expected_revision: (cur ? cur.revision : 1), action: 'reassign', owner: to },\n        { assignedBy: isOffice(memberId) ? 'office' : memberId, why, acceptance })",
+    to: "const r = await taskUpdate(memberId, { task_id: taskId, expected_revision: (cur ? cur.revision : 1), action: 'reassign', owner: to })\n      if (r.ok) await putTask(Object.assign({}, inst().tasks.find((t) => t.id === taskId), { assignedBy: isOffice(memberId) ? 'office' : memberId, why, acceptance }))",
+    expect: /\[G4\] the assign path issues NO second, unprotected task write/,
+  },
+  {
+    // A5: a permanent researcher founded with the academician KIND - the count stays 3 but the id
+    // set and the kind multiset both break (the allocator also repeats the academician id).
+    name: 'A5: a permanent researcher is founded with the academician kind',
+    from: "const m = await newMember('researcher', { direction: dir })",
+    to: "const m = await newMember('academician', { direction: dir })",
+    expect: /A5 the founded (ID SET|KIND MULTISET)/,
+  },
+  {
+    // A5-ids: the COUNT stays 3 and the kinds stay right, but the researcher id PREFIX changes, so the
+    // MEASURED (R14): the count assertions stay GREEN and the ID-SET assertion reddens; the run's other
+    // reds (82) are the cascade of the same mutation - not a claim that only the new assertion reddens.
+    // founded ID SET is no longer {acad, r-1, r-2}. This is the discriminator the count cannot catch.
+    name: 'A5-ids: the researcher id prefix is renamed (count still 3)',
+    from: "researcher: 'r-',",
+    to: "researcher: 'rX-',",
+    expect: /A5 the founded ID SET is exactly/,
+  },
+  {
+    // A5-kinds: the COUNT stays 3 and the ids stay right, but a founded researcher's KIND is rewritten,
+    // MEASURED (R14): the count and ID-SET assertions stay GREEN and the KIND assertion reddens; the run's
+    // other reds (21) are the cascade of the same mutation - not a claim that only the new assertion reddens.
+    // so the kind MULTISET is no longer {academician:1, researcher:2}.
+    name: 'A5-kinds: a founded researcher kind is rewritten (count still 3)',
+    from: "id: '', kind,",
+    to: "id: '', kind: kind === 'researcher' ? 'temp' : kind,",
+    expect: /A5 the founded KIND MULTISET is exactly/,
+  },
+  {
+    // spawnMember (G2-class): counting the founding round BEFORE `startContinuable`, so a host-cap
+    // failure consumes a round and the retried founder is told 轮次 2.
+    name: 'spawnMember: the founding round is counted BEFORE the start again',
+    from: 'const startRound = (rounds.get(member.id) || 0) + 1',
+    to: 'rounds.set(member.id, (rounds.get(member.id) || 0) + 1); const startRound = (rounds.get(member.id) || 0) + 1',
+    expect: /\[spawnMember\] a FAILED start must not consume a round/,
+  },
+  {
+    // spawnMember: restoring the destructive rollback — `rounds.delete`/`roundsSinceCompact.delete` in the
+    // catch, which ERASES the count of a member being RESUMED (its numbering then restarts at 1).
+    name: 'spawnMember: the failed-start rollback DELETES the existing round count again',
+    from: "        busy.delete(member.id)\n        wakeKind.delete(member.id)",
+    to: "        busy.delete(member.id)\n        wakeKind.delete(member.id)\n        rounds.delete(member.id)\n        roundsSinceCompact.delete(member.id)",
+    expect: /\[spawnMember\] a FAILED resume must not move the round number backwards/,
+  },
+  {
+    // spawnMember: dropping the explicit next-round argument, so the founding prompt's status block
+    // falls back to the stored counter (still 0 at that point) and announces 轮次 0.
+    name: 'spawnMember: the founding prompt is built without the explicit round',
+    from: 'const prompt = initialPrompt(member, initialTask, mode, startRound)',
+    to: 'const prompt = initialPrompt(member, initialTask, mode)',
+    expect: /\[spawnMember\]|the founding prompt never displays 轮次 0|the FOUNDING prompt announces the round/,
+  },
+  {
+    // F6: quietly dropping a failed REQUIRED artifact write again (the v4-G3 shape): the meta write is
+    // still checked for `files`, but the failure is no longer NAMED in `warnings`.
+    name: 'F6: a failed paper.meta.json write is silently dropped from warnings again',
+    from: "      else warnings.push(paperWriteFailureWarning(['paper.meta.json']))",
+    to: "      else { /* F6 mutant: the failure is silent again */ }",
+    expect: /\[F6\] a failed REQUIRED write is named EXACTLY once/,
+  },
+  {
+    // F6 (log half): discarding the FINALIZE-time log write result again — the log artifact can then go
+    // missing with no warning at all, and the durable meta is not re-written to name it.
+    name: 'F6: the finalize-time paper.log.md write result is discarded again',
+    from: '      if (!logRes.ok) {',
+    to: '      if (false) {',
+    expect: /\[F6\] a failed FINALIZE-time log write is named exactly once/,
+  },
+  {
+    // v5 L1 (`leanPathContractOk`): the tools' short form resolves to a DIFFERENT file, so the load-time
+    // contract check fails and queues 'Lean path contract broken …'; report() must then surface it.
+    name: 'v5 L1: the Lean tools short form resolves to the WRONG file (path contract broken)',
+    from: 'const viaShort = leanAbsPath(probe)',
+    to: "const viaShort = leanAbsPath(probe + 'x')",
+    expect: /\[v5 L1\] a HEALTHY composition surfaces no Lean path contract note/,
+  },
+]
+let red = 0
+for (const f of FAMILIES) { const ok = runFamily(f); if (ok) red++ }
+const totalMs = TIMES.reduce((a, t) => a + t[1], 0)
+console.log('')
+console.log('mutant families reddening the v5 institute fixes by name: ' + red + '/' + FAMILIES.length)
+console.log('timings: ' + TIMES.map((t) => String(t[0]).split(':')[0] + '=' + t[1] + 'ms').join('  '))
+// R15: the audit-checklist row says EVERY family prints this line, and override decisions must quote it
+// rather than an external estimate. Same shape as tests/formal-verify-v3.mutants.mjs.
+console.log('TOTAL WALL TIME (all families + setup): ' + totalMs + 'ms (' + Math.round(totalMs / 1000) + 's)')
+console.log('hangs=[' + hangs.join(' | ') + ']')
+console.log('skipped=[' + skipped.join(' | ') + ']')
+if (red !== FAMILIES.length || skipped.length || hangs.length) process.exit(1)
+console.log('ALL MUTANTS RED AS REQUIRED')

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

@@ -42,7 +42,7 @@
 
       - 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' 指向**同一个源路径**重跑：归档 id 以**源路径**为键，因此这落在**同一归档**的 **attempt ≥ 2**，并给出 `scriptChanged:true` 与 `previousReceipt`（指向上一次）。**指向归档副本本身**（`receipt.scriptAbs` 那个路径）按设计是**另一份新归档**：新 id、attempt 1、没有 `previousReceipt`、`scriptChanged:false`；旧 attempt 绝不会被覆盖，但它**不是**"同一归档的新 attempt"——工具会用 `fileIsArchivedScript` 与 `ARCHIVED_SCRIPT_RERUN` 警告明确说明。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
 
       Final paper: strict termination writes Paper/<project>/{paper.md,paper.tex,paper.pdf,paper.meta.json,paper.log.md}
       automatically — a dedicated paper-writing child assembles the solved material (finalPaper=false disables only that
@@ -61,6 +61,27 @@
       Verified/ is written by that same scheduler path — an agent's own self-reported 1 is never a conclusion.
       When the user asks about progress, call vibe_math_report and summarize in plain language.
 
+      DISCLOSURES (existing behaviour, not rules to follow):
+        - DISCLOSURE (existing behaviour): the FINAL PAPER flow can finish without you — when it hits
+          its round/token cap the framework force-finalises the paper (`forcedAfterCap`) and reaps an
+          in-flight writer that never came back; the activity log says so. You do not lose the paper,
+          you lose the chance to keep iterating on it.
+        - DISCLOSURE (existing behaviour): switching the mode to `auto` immediately resolves EVERY
+          pending decision as auto-decided (the activity log records "auto-resolved N pending
+          decision(s)"). Anything you leave pending will not wait for you.
+        - DISCLOSURE (existing behaviour): the framework itself pushes a progress update to the office
+          (reportMode / reportIntervalMs) — a summary you did not ask for can arrive at a round
+          boundary; it is a report, not a new instruction.
+        - DISCLOSURE (existing behaviour): the framework can adjust problem/proposition priorities
+          itself (priorityAdjust / proposPriorityAdjust) — the activity log records "priorities
+          auto-adjusted (…)"; a problem you deprioritised can come back on its own.
+        - DISCLOSURE (existing behaviour): when mathMode is `typed`, the shell fallback is refused
+          (the math tool returns REFUSED with reason=policy) instead of silently falling back.
+        - math_computation policy: mathComputation = off | auto | on (off = the math surface is
+          not mentioned in prompts at all); mathMode = typed | typed+shell (typed refuses the shell
+          fallback); mathEngines (cli / python / …); mathTimeoutMs; mathPackages + mathInstallScope
+          for preflight package installs (missing packages are reported with an install plan only).
+
       Configuration highlights (all tunable via vibe_math_set_params / the settings file):
       `knowledgeContext` overrides the shared data-model explanation injected into every child prompt
       (empty = built-in full version); `explorerPersona` / `solverPersona` / `verifierPersona` prepend
@@ -79,8 +100,15 @@
           match the proposition as stated) | 'require' (same, plus a gate: a true/false verdict is
           recorded as 未定论 with reason formal-required until the object is Lean-passed or carries an
           explicit, reasoned blocker record; the scheduler is never wedged by it).
-        - Paths: work file Formal/<id>.lean; archived proof Verified/Lean/<id>.lean; reusable
-          definitions VibeMath/Formal/Lib/; proved lemmas VibeMath/Formal/Proved/.
+        - Paths (every path here is resolved against the SESSION WORKING DIRECTORY, i.e. the cwd
+          printed at the end of this prompt; the project root is the `Data lives under …`
+          directory above):
+          institute work file `<project root>/Formal/<id>.lean`;
+          archived proof `<project root>/Verified/Lean/<id>.lean`;
+          reusable definitions `VibeMath/Formal/Lib/` (workspace-root relative);
+          proved lemmas `VibeMath/Formal/Proved/` (workspace-root relative);
+          short form `Formal/<id>.lean` (project-root relative) names the SAME file as
+          `<project root>/Formal/<id>.lean`.
         - The toolchain knobs leanCommand / leanArgs / leanTimeoutMs / leanAsync / leanInitiative / leanSearchPaths / leanJobsMaxParallel are tunable as well
           (e.g. leanCommand='lake' with leanArgs=['env','lean']); a missing Lean binary is
           reported as LEAN_NOT_FOUND and still lets the code be written and archived.
@@ -120,7 +148,7 @@
 
       - 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' 指向**同一个源路径**重跑：归档 id 以**源路径**为键，因此这落在**同一归档**的 **attempt ≥ 2**，并给出 `scriptChanged:true` 与 `previousReceipt`（指向上一次）。**指向归档副本本身**（`receipt.scriptAbs` 那个路径）按设计是**另一份新归档**：新 id、attempt 1、没有 `previousReceipt`、`scriptChanged:false`；旧 attempt 绝不会被覆盖，但它**不是**"同一归档的新 attempt"——工具会用 `fileIsArchivedScript` 与 `ARCHIVED_SCRIPT_RERUN` 警告明确说明。**旧回执对修改后的代码无效**——报告里必须引用与当前代码哈希一致的那份回执；工具会在 scriptChanged / scriptChangedDuringRun 为 true 时显式告警。
 
       Final paper: strict termination writes Paper/<project>/{paper.md,paper.tex,paper.pdf,paper.meta.json,paper.log.md}
       automatically — a dedicated paper-writing child assembles the solved material (finalPaper=false disables only that
@@ -139,6 +167,27 @@
       Verified/ is written by that same scheduler path — an agent's own self-reported 1 is never a conclusion.
       When the user asks about progress, call vibe_math_report and summarize in plain language.
 
+      DISCLOSURES (existing behaviour, not rules to follow):
+        - DISCLOSURE (existing behaviour): the FINAL PAPER flow can finish without you — when it hits
+          its round/token cap the framework force-finalises the paper (`forcedAfterCap`) and reaps an
+          in-flight writer that never came back; the activity log says so. You do not lose the paper,
+          you lose the chance to keep iterating on it.
+        - DISCLOSURE (existing behaviour): switching the mode to `auto` immediately resolves EVERY
+          pending decision as auto-decided (the activity log records "auto-resolved N pending
+          decision(s)"). Anything you leave pending will not wait for you.
+        - DISCLOSURE (existing behaviour): the framework itself pushes a progress update to the office
+          (reportMode / reportIntervalMs) — a summary you did not ask for can arrive at a round
+          boundary; it is a report, not a new instruction.
+        - DISCLOSURE (existing behaviour): the framework can adjust problem/proposition priorities
+          itself (priorityAdjust / proposPriorityAdjust) — the activity log records "priorities
+          auto-adjusted (…)"; a problem you deprioritised can come back on its own.
+        - DISCLOSURE (existing behaviour): when mathMode is `typed`, the shell fallback is refused
+          (the math tool returns REFUSED with reason=policy) instead of silently falling back.
+        - math_computation policy: mathComputation = off | auto | on (off = the math surface is
+          not mentioned in prompts at all); mathMode = typed | typed+shell (typed refuses the shell
+          fallback); mathEngines (cli / python / …); mathTimeoutMs; mathPackages + mathInstallScope
+          for preflight package installs (missing packages are reported with an install plan only).
+
       Configuration highlights (all tunable via vibe_math_set_params / the settings file):
       `knowledgeContext` overrides the shared data-model explanation injected into every child prompt
       (empty = built-in full version); `explorerPersona` / `solverPersona` / `verifierPersona` prepend
@@ -157,8 +206,15 @@
           match the proposition as stated) | 'require' (same, plus a gate: a true/false verdict is
           recorded as 未定论 with reason formal-required until the object is Lean-passed or carries an
           explicit, reasoned blocker record; the scheduler is never wedged by it).
-        - Paths: work file Formal/<id>.lean; archived proof Verified/Lean/<id>.lean; reusable
-          definitions VibeMath/Formal/Lib/; proved lemmas VibeMath/Formal/Proved/.
+        - Paths (every path here is resolved against the SESSION WORKING DIRECTORY, i.e. the cwd
+          printed at the end of this prompt; the project root is the `Data lives under …`
+          directory above):
+          institute work file `<project root>/Formal/<id>.lean`;
+          archived proof `<project root>/Verified/Lean/<id>.lean`;
+          reusable definitions `VibeMath/Formal/Lib/` (workspace-root relative);
+          proved lemmas `VibeMath/Formal/Proved/` (workspace-root relative);
+          short form `Formal/<id>.lean` (project-root relative) names the SAME file as
+          `<project root>/Formal/<id>.lean`.
         - The toolchain knobs leanCommand / leanArgs / leanTimeoutMs / leanAsync / leanInitiative / leanSearchPaths / leanJobsMaxParallel are tunable as well
           (e.g. leanCommand='lake' with leanArgs=['env','lean']); a missing Lean binary is
           reported as LEAN_NOT_FOUND and still lets the code be written and archived.