dsh-vibe-math 2.4.1 → 2.5.0

package/tests/formal-verify-v3.test.mjs

@@ -72,11 +72,43 @@ const corpus = []
 // same class of bug is recorded in AUDIT-CHECKLIST §2.4 as a real accident): the random plan id in
 // the label, epoch-millisecond `at` timestamps, child ids, and the free-slot count. They are run
 // metadata, not the text under review, so they are normalised to placeholders.
-const scrub = (s) => String(s == null ? '' : s)
+//
+// The brief is not only run metadata, it is a LIVE SNAPSHOT of mutable scheduler state
+// (`buildBrief()` reads `agentRegistry`, `activityLog`, the verify candidates and the free-slot
+// count at the instant the planner is spawned). This suite drives the plugin from OUTSIDE, and the
+// plugin's own scheduler keeps running concurrently: `vibe_math_start` fires `scheduleTick()`
+// without awaiting it, and the plugin's 1s tick timer calls `scheduleTick()` on its own schedule, so
+// a background tick can register the explorer (or append its activity event, or close a verify)
+// BETWEEN the forced planner's snapshot and the next one. Two runs then legitimately disagree about
+// `active_agents` (the explorer is in flight or it is not), about `recent_events` (the last-eight
+// window and its order), and about every other instant-dependent field of the brief.
+//
+// A byte-stable corpus therefore cannot carry that snapshot's values — the disagreement is a
+// property of the INSTANT, not of the prompt text a human must review (this is exactly the "语料
+// 每次运行都变" accident §2.4 records). What the corpus carries is the brief's CONTRACT: the same
+// keys in the same order, with the instant-dependent values canonically placeholdered and the
+// stable configuration scalars kept. The prompt TEXT under review — the persona, the ACTION
+// VOCABULARY, and the HARD RULES that name `brief.problems[].running_solver_dirs`,
+// `brief.active_agents` and `brief.free_slots` — is untouched.
+const SNAPSHOT_KEYS = ['problems', 'verify_candidates', 'active_agents', 'methods', 'pending_inventions', 'last_plan', 'recent_events']
+/** Replace every instant-dependent collection of the planner's state brief with a canonical
+ *  placeholder, keeping the key set, the key order and the configuration scalars. Only called on a
+ *  valid-JSON brief (`buildBrief` is serialised with JSON.stringify(brief, null, 2)); anything that
+ *  does not match the exact planner framing is returned unchanged, so the suite can never silently
+ *  mangle an unrelated prompt. */
+const canonBrief = (s) => {
+  const m = s.match(/(CURRENT STATE BRIEF \(JSON\):\n)(\{[\s\S]*?\n\})(\n\nACTION VOCABULARY)/)
+  if (!m) return s
+  let brief
+  try { brief = JSON.parse(m[2]) } catch (e) { return s }
+  for (const k of SNAPSHOT_KEYS) if (Object.prototype.hasOwnProperty.call(brief, k)) brief[k] = '<' + k.toUpperCase() + '>'
+  return s.slice(0, m.index) + m[1] + JSON.stringify(brief, null, 2) + m[3] + s.slice(m.index + m[0].length)
+}
+const scrub = (s) => canonBrief(String(s == null ? '' : s)
   .split(VIBE).join('<VIBEMATH>')
   .split(VIBE.replace(/\\/g, '/')).join('<VIBEMATH>')
   .split(WS).join('<WS>')
-  .split(WS.replace(/\\/g, '/')).join('<WS>')
+  .split(WS.replace(/\\/g, '/')).join('<WS>'))
   .replace(/plan-[0-9a-f]{8}/g, 'plan-<ID>')
   .replace(/("at"\s*:\s*)\d{10,16}/g, '$1"<TIME>"')
   .replace(/("childId"\s*:\s*")c\d+(")/g, '$1<CHILD>$2')
@@ -1246,6 +1278,35 @@ section('10 the captured prompt corpus is written for human review')
   assert(volatile.length === 0, '★ no captured prompt/label keeps volatile run metadata (random plan id / epoch timestamps / child ids / slot count) — the corpus is byte-deterministic: ' + volatile.map((b) => b.label).join(','))
   assert(corpus.some((c) => /"free_slots": <SLOTS>/.test(c.prompt)) && corpus.some((c) => /plan-<ID>/.test(c.label)),
     '★ and the normalisation actually fired (a planner brief and its plan id were captured)')
+  // The brief's instant-dependent snapshot is placeholdered, but its CONTRACT (key set + order) and
+  // the stable configuration scalars stay, and the instruction text that references the brief is
+  // untouched — so the human reviewer still sees the real planner prompt, not a blank.
+  const briefEntries = corpus.filter((c) => /CURRENT STATE BRIEF \(JSON\):/.test(c.prompt))
+  assert(briefEntries.length >= 3 && briefEntries.every((c) => SNAPSHOT_KEYS.every((k) => c.prompt.indexOf('"' + k + '": "<' + k.toUpperCase() + '>"') !== -1)),
+    '★ every captured planner brief keeps all ' + SNAPSHOT_KEYS.length + ' contract keys with canonically placeholdered snapshot values (' + briefEntries.length + ' briefs)')
+  assert(briefEntries.every((c) => /"horizon": \d+/.test(c.prompt) && /"free_slots": <SLOTS>/.test(c.prompt) && /"maxParallelThreshold": \d+/.test(c.prompt)),
+    '★ the brief keeps its real configuration scalars (horizon / free_slots / maxParallelThreshold), not just placeholders')
+  assert(briefEntries.every((c) => /brief\.problems\[\]\.running_solver_dirs and brief\.active_agents/.test(c.prompt) && /ACTION VOCABULARY/.test(c.prompt)),
+    '★ and the planner INSTRUCTION text under review (ACTION VOCABULARY + the HARD RULES naming brief fields) is verbatim')
+  {
+    // Direct witness of the race the normaliser exists for: the two shapes a background tick can
+    // produce (explorer registered before vs. after the forced planner read the brief, activity log
+    // one entry longer, free slots one lower) must normalise to ONE byte-identical text. Without
+    // this the corpus could only be checked by hoping the race fires.
+    const briefText = (agents, events, slots, horizon) => 'PERSONA\nCURRENT STATE BRIEF (JSON):\n' + JSON.stringify({
+      at: 1759200000000, horizon: horizon, free_slots: slots, maxParallelThreshold: 64,
+      problems: [{ id: 'qE', 状态: '求解中', 方向数: agents.length, 活跃方向: agents.length ? ['d1'] : [], running_solver_dirs: [], 最高存活率: agents.length ? 0.7 : null, 解法数: 0 }],
+      verify_candidates: agents.length ? [{ rId: 'r-qE', kind: 'problem', target: 'qE', prob: 0.5, priority: 1 }] : [],
+      active_agents: agents, methods: [], pending_inventions: 0, last_plan: null, recent_events: events,
+    }, null, 2) + '\n\nACTION VOCABULARY:\n- x'
+    const withExplorer = briefText([{ childId: 'c7', role: 'explorer', target: 'qE', direction: '', round: '' }],
+      [{ at: 1759200000001, event: 'start', detail: 'scheduler started' }, { at: 1759200000002, event: 'explorer', detail: 'problem qE explorer spawned (plan)' }], 63, 5)
+    const withoutExplorer = briefText([], [{ at: 1759200000009, event: 'plan', detail: 'planner plan-abcdef12 called with 1 problem(s)' }], 64, 5)
+    assert(scrub(withExplorer) === scrub(withoutExplorer),
+      '★ the planner-brief normaliser maps the two racing snapshots (explorer present/absent, different activity order and free slots) to ONE byte-identical text')
+    assert(scrub(withExplorer) !== withExplorer && /"active_agents": "<ACTIVE_AGENTS>"/.test(scrub(withExplorer)),
+      '★ and it really rewrote the snapshot (the test above cannot pass just because nothing was normalised)')
+  }
 }
 
 console.log('')

package/tests/formal-verify-v4.test.mjs

@@ -965,6 +965,11 @@ const K = await establish()
   const scrub = (s) => String(s == null ? '' : s)
     .split(vibe).join('<VIBEMATH>').split(vibe.replace(/\\/g, '/')).join('<VIBEMATH>')
     .split(K.WS).join('<WS>').split(K.WS.replace(/\\/g, '/')).join('<WS>')
+    // `propose_task` mints `t-<8 hex>` from Math.random (vibe-math-v4.js:1317 + shortId :2582).
+    // The task-frame entry embeds that id, so without this the SHIPPED corpus changed on every
+    // run (AUDIT-CHECKLIST §2.4: two consecutive runs must hash identically) and `git status`
+    // always showed prompt-corpus-v4/* as modified. Normalise it like the machine paths.
+    .replace(/\bt-[0-9a-f]{8}\b/g, '<TASKID>')
   const corpus = []
   const add = (kind, label, prompt) => corpus.push({ kind, label, prompt: scrub(prompt) })
   // (a) off: a TRUE no-op must be visible in the corpus, not merely asserted
@@ -1008,6 +1013,91 @@ const K = await establish()
   // (h) the tool hints are injected text too (docs §6 hard requirement 1)
   add('hint', 'lean_run hint (green)', (await K.callTool('vibe_v4_lean_run', { file: 'Formal/p-corpus-passed.lean' }, k1)).hint)
   add('hint', 'lean_lib hint', (await K.callTool('vibe_v4_lean_lib', {}, k1)).hint)
+  // (i) ── THE NON-FORMAL SURFACES (audit M6/F15) ─────────────────────────────────────────────
+  // The corpus used to cover ONLY Lean/formal variants, so the meeting prompt — this preset's ONLY
+  // group-chat / task-allocation / stop-vote carrier — and every message frame had NO reviewable
+  // artefact at all: a defect in `meetingPrompt` (e.g. its stop-vote contract) could not be read by
+  // a human reviewer. These entries close that gap. `st` is passed explicitly so the capture does
+  // not depend on the scheduler's state, and both the meeting's two perspectives (first speaker with
+  // no prior speech / a later speaker seeing a relayed contribution) are captured.
+  {
+    const st = {
+      id: 'mt-corpus', agenda: '分工与是否需要验证', type: 'general', targetId: null, round: 0, asked: [], order: ['r-1', 'r-2'],
+      inputs: { 'r-1': { input: '我建议先验证 p-corpus，并认领引理 A 的整理。', voteSolved: false, propose_verify: 'p-corpus', propose_task: '整理引理 A', task_desc: '把已有引理写成可复用形式', claim_task: null } },
+      transcript: [], at: Date.now(), lastInputAt: Date.now(),
+    }
+    add('meeting', 'meeting/first speaker (no prior speech)', await K.prompts('meeting', 'r-2', { meeting: { agenda: st.agenda, type: st.type, inputs: {}, order: st.order } }))
+    add('meeting', 'meeting/later speaker (others relayed)', await K.prompts('meeting', 'r-2', { meeting: st }))
+  }
+  // (i) ── the private-message frame ──────────────────────────────────────────────────────────────
+  // A resident reads a message in TWO shapes, and both must be reviewable:
+  //   · `[MESSAGE from <sender>] <content>` — the frame `deliverNextMailbox` prepends when it wakes an
+  //     idle recipient with a QUEUED message (captured here from a REAL delivery, not re-typed);
+  //   · `[<sender>] <content>` — the inbox line every prompt's "New items:" block renders.
+  // r-1 is put in flight first (a message to an IDLE resident is delivered immediately as its own
+  // wake instead of queueing), so the second message is queued and the prompt shows the inbox line.
+  {
+    const before = K.followups.length
+    await K.callTool('vibe_v4_message', { to: 'r-1', content: '先做一轮常规工作。' })
+    for (let i = 0; i < 200 && K.followups.length === before; i++) await sleep(10)
+    const inFlight = K.followups[K.followups.length - 1]
+    assert(!!inFlight, 'corpus: r-1 is in flight so the next message is QUEUED (mailbox frame prerequisite)')
+    await K.callTool('vibe_v4_message', { to: 'r-1', content: '请优先核对引理 B 的假设条件。' })
+    add('work', 'normal + queued inbox line ([<sender>] content)', await K.prompts('normal', 'r-1'))
+    K.fireEnd(inFlight.childId, { summary: '推进。', solved: false, input: '我对引理 B 的假设有异议：需要 n≥1。', contextPct: 20 })
+    await sleep(60)
+  }
+  // the REAL delivery frames. A message that arrives while its recipient is idle is delivered as a
+  // wake whose body is `<ordinary round>\n\n[MESSAGE from <sender>]\n<content>`, and a message that
+  // was relayed by a teammate (`relayToGroup` posts it with the sender's own id and the `[群聊]`
+  // prefix — the exact same `postMessage` path the human messenger uses) renders as `[群聊] …`.
+  // Each frame is captured from a REAL delivery on its own host, so the corpus text is generated by
+  // the code under review rather than re-typed here.
+  const deliveredFrame = async (content, sender) => {
+    const L = await establish()
+    await L.callTool('vibe_v4_set', { activityTimeoutMs: 600000 })   // keep the heartbeat out of the way
+    const before = L.followups.length
+    await (sender === 'facilitator'
+      ? L.callTool('vibe_v4_message', { to: 'r-1', content })
+      : L.callTool('vibe_v4_send_message', { to: 'r-1', content }, L.resAgent(L.childOf(sender))))
+    let hit = null
+    for (let i = 0; i < 300 && !hit; i++) { hit = L.followups.slice(before).find((f) => /\[(NEW )?MESSAGE from /.test(promptOf(f))) || null; if (!hit) await sleep(10) }
+    assert(!!hit, 'corpus: a real delivery wake carrying "' + content.slice(0, 16) + '…" was produced (saw ' + L.followups.slice(before).map((f) => promptOf(f).slice(-90).replace(/\n/g, ' ')).join(' | ') + ')')
+    if (hit) L.fireEnd(hit.childId, { summary: '收到。', solved: false, contextPct: 20 })
+    await sleep(30)
+    return hit ? promptOf(hit) : ''
+  }
+  add('work', 'normal + delivered message frame ([NEW MESSAGE from ...])', await deliveredFrame('请优先核对引理 B 的假设条件。', 'facilitator'))
+  // the group-chat frame: the recipient's inbox line for a message RELAYED by a teammate
+  // (`relayToGroup` pushes `[群聊] <text>` into every other resident's mailbox with the speaker's own
+  // id, and the next delivery renders `[<sender>] [群聊] <text>` — the same `postMessage` path, run
+  // with the sender the resident actually sees). Deterministic on the same host: the speaker's own
+  // end handler is what triggers the relay, and reading the recipient's next prompt shows it.
+  {
+    const L = await establish()
+    await L.callTool('vibe_v4_set', { activityTimeoutMs: 600000 })
+    const before = L.followups.length
+    await L.callTool('vibe_v4_message', { to: 'r-2', content: '先做一轮常规工作。' })
+    for (let i = 0; i < 300 && L.followups.length === before; i++) await sleep(10)
+    const speaker = L.followups[L.followups.length - 1]
+    assert(!!speaker, 'corpus: the relaying resident is in flight')
+    const mark = L.followups.length
+    L.fireEnd(speaker.childId, { summary: '推进。', solved: false, input: '我对引理 B 的假设有异议：需要 n≥1。', contextPct: 20 })
+    let relay = null
+    for (let i = 0; i < 300 && !relay; i++) { relay = L.followups.slice(mark).find((f) => /群聊/.test(promptOf(f))) || null; if (!relay) await sleep(10) }
+    assert(!!relay, 'corpus: the relayed group-chat message was really delivered (saw ' + L.followups.slice(mark).map((f) => promptOf(f).slice(-90).replace(/\n/g, ' ')).join(' | ') + ')')
+    add('work', 'normal + group-chat frame ([群聊])', relay ? promptOf(relay) : '')
+    if (relay) L.fireEnd(relay.childId, { summary: '收到。', solved: false, contextPct: 20 })
+    await sleep(30)
+  }
+  // the task-claim frame. The task is claimed while its claimer is idle, so the claim wake carries
+  // `[YOU CLAIMED TASK …]`; the corpus entry is the ordinary round plus that exact frame.
+  {
+    const pt = await K.callTool('vibe_v4_propose_task', { title: '核对引理 B 的假设', description: '确认 n≥1 是否必要' })
+    assert(pt.ok === true && !!pt.id, 'corpus: a task was proposed for the task-frame entry')
+    const claimed = await K.callTool('vibe_v4_claim_task', { id: pt.id }, k1)
+    add('work', 'task frame ([YOU CLAIMED TASK ...])', claimed.ok === true ? (await K.prompts('normal', 'r-1')) + '\n\n[YOU CLAIMED TASK ' + pt.id + '] 核对引理 B 的假设 — 确认 n≥1 是否必要' : '')
+  }
 
   // The corpus is REGENERATED on every run. Dumping it while V4_PLUGIN points at a MUTATED copy
   // would let a sensitivity probe overwrite the SHIPPED corpus with mutated text (the probe's job
@@ -1018,13 +1108,16 @@ const K = await establish()
   if (writeCorpus) {
     mkdirSync(CORPUS_DIR, { recursive: true })
     writeFileSync(join(CORPUS_DIR, 'formal-verify-v4.json'), JSON.stringify({ entries: corpus }, null, 2), 'utf8')
-    const md = ['# V4 形式化验证交互语料（prompt corpus）', '',
-      '> 由 `formal-verify-v4.test.mjs` 落盘：非 `off` 模式下常驻**真正会读到**的 Lean 提示词原文',
+    const md = ['# V4 交互语料（prompt corpus）', '',
+      '> 由 `formal-verify-v4.test.mjs` 落盘：常驻**真正会读到**的提示词原文',
       '> （`vibe_v4_prompts` 的只读回显 + 一条真实投递的工作轮 + 工具 `hint`）。',
-      '> 工作区路径归一化为 `<WS>`，VibeMath 根归一化为 `<VIBEMATH>`：确定、可 diff、不含任何本机路径。', '',
+      '> 工作区路径归一化为 `<WS>`，VibeMath 根归一化为 `<VIBEMATH>`，随机任务号归一化为',
+      '> `<TASKID>`（`propose_task` 的 `t-<8 位 hex>` 来自 `Math.random`）：确定、可 diff、不含任何本机路径或随机数。', '',
       '> 覆盖：`off`（无 Lean 文本）、`encourage`、**`require`**、对象 `passed` 后的**忠实性分支**',
       '> （`encourage` / `require` 两种措辞各一份：只有 `require` 会声称"不定论"）、',
-      '> `blocked` 分支、平时工作轮的「顺手形式化」，以及回执契约里的 `formal` 字段。', '']
+      '> `blocked` 分支、平时工作轮的「顺手形式化」，以及回执契约里的 `formal` 字段；',
+      '> **以及非形式化的交互面**：会议提示（首位发言者 / 已看到他人发言者各一份，含停止表决契约）、',
+      '> 私信框头 `[MESSAGE from …]`、群聊框头 `[群聊]`、认领任务框头 `[YOU CLAIMED TASK …]`。', '']
     for (let i = 0; i < corpus.length; i++) {
       const c = corpus[i]
       md.push('## [' + i + '] ' + c.kind + ' · ' + c.label)
@@ -1049,8 +1142,31 @@ const K = await establish()
   assert(/【顺手形式化（强制）】/.test(byLabel('require/normal').prompt), 'the corpus carries the ordinary work-round line')
   assert(/"decision":"used\|blocked\|defect"/.test(byLabel('formal reply contract (voting prompt)').prompt), '★ the corpus carries the `formal` reply contract line with decision=defect')
   assert(/【顺手形式化/.test(byLabel('require/real work wake').prompt), 'the corpus also keeps a prompt the framework REALLY delivered')
+  // ---- the non-formal interaction surfaces (audit M6 / F15) --------------------------------
+  // The corpus used to be Lean-only, so `meetingPrompt` (the ONLY group-chat / allocation /
+  // stop-vote carrier this preset has) had no reviewable artefact. These assertions pin both the
+  // coverage and the CONTENT of the stop-vote contract that `finalizeMeeting` now enforces.
+  {
+    const first = byLabel('meeting/first speaker (no prior speech)')
+    const later = byLabel('meeting/later speaker (others relayed)')
+    assert(!!first && !!later, '★ the corpus carries the MEETING prompt (two perspectives: no prior speech / others already relayed)')
+    assert(/meeting is in progress/.test(first.prompt) && /meeting is in progress/.test(later.prompt), 'the meeting entries are built by the real meeting prompt builder')
+    assert(/目前还没人发言/.test(first.prompt), 'the first-speaker entry shows the "nobody has spoken yet" branch')
+    assert(/已有发言（他人 input，已转发给你）/.test(later.prompt) && /我建议先验证 p-corpus/.test(later.prompt), '★ the later-speaker entry carries a teammate contribution VERBATIM (the group-chat relay is reviewable)')
+    assert(/\[r-1\]/.test(later.prompt) && !/\[r-2\]/.test(later.prompt), 'the relayed-speech list excludes the reader and names the real sender id')
+    assert(/voteSolved/.test(first.prompt) && /停止表决必须是绝对票/.test(first.prompt), '★ the meeting prompt states the stop-vote contract the code enforces (every speaker must answer true)')
+    assert(!!byLabel('normal + queued inbox line ([<sender>] content)') && /\[facilitator（框架\/人类信使/.test(byLabel('normal + queued inbox line ([<sender>] content)').prompt) && /请优先核对引理 B 的假设条件。/.test(byLabel('normal + queued inbox line ([<sender>] content)').prompt), '★ the corpus carries the inbox line that names the real sender of a queued message')
+    assert(/\[(NEW )?MESSAGE from facilitator\]/.test(byLabel('normal + delivered message frame ([NEW MESSAGE from ...])').prompt), '★ the corpus carries the [NEW MESSAGE from …] delivery frame, captured from a REAL delivery')
+    assert(/\[群聊\] 我对引理 B 的假设有异议/.test(byLabel('normal + group-chat frame ([群聊])').prompt), '★ the corpus carries the group-chat frame relayed by a teammate (and the recipient is not the speaker)')
+    assert(/facilitator（框架\/人类信使，不是常驻成员，不要向它回信/.test(byLabel('normal + queued inbox line ([<sender>] content)').prompt), '★ the frame DEFINES `facilitator` on the very wake that shows it, so it is not an unaddressable stranger')
+  }
   const joined = corpus.map((c) => c.prompt).join('\n')
   assert(joined.indexOf(K.WS) === -1 && joined.indexOf(K.WS.replace(/\\/g, '/')) === -1 && joined.indexOf(vibe) === -1 && joined.indexOf(vibe.replace(/\\/g, '/')) === -1, '★ every captured prompt normalises <WS> and <VIBEMATH> (diffable, no machine paths)')
+  // The random `t-<hex8>` must be normalised too, and NON-vacuously: the task-frame entry has to
+  // CARRY the normalised token (a scrub that quietly blanked the whole frame would also pass the
+  // absence check below).
+  assert(/\[YOU CLAIMED TASK <TASKID>\]/.test(byLabel('task frame ([YOU CLAIMED TASK ...])').prompt), '★ the task-frame corpus entry really carries the normalised `<TASKID>` token')
+  assert(!/\bt-[0-9a-f]{8}\b/.test(joined), '★ no captured prompt leaks a random `t-<hex8>` id (the corpus is byte-stable across runs)')
   assert(!/\[object Object\]|\bNaN\b|:\s*undefined|["']undefined["']|undefined\s*[,}\]]/.test(joined), 'no captured prompt contains placeholder garbage')
   assert(corpus.every((c) => c.prompt && c.prompt.length > 20), 'every corpus entry carries real prompt text')
 }

package/tests/run-tests.mjs

@@ -1,27 +1,40 @@
 #!/usr/bin/env node
 /**
- * PARALLEL TEST RUNNER — run every shipped suite (or a filtered subset) concurrently and report
- * per-suite timings, so the strategy for the next run is chosen from DATA instead of guesswork.
+ * PARALLEL TEST RUNNER — run every shipped suite AND every probe (or a filtered subset)
+ * concurrently and report per-suite timings, so the strategy for the next run is chosen
+ * from DATA instead of guesswork.
  *
  * Why this exists: the suites are wildly uneven (one suite is ~160 s, most are under 2 s), so a
  * sequential sweep spends almost all of its wall time waiting for the slowest one. Running them
  * with a worker pool makes the sweep bounded by the slowest SUITE rather than by their SUM.
  * On this machine (4 cores) the sweep went from ~5.5 min to ~2 min; see ../docs/test-timing.md.
  *
+ * WHAT IS COLLECTED (Round B): `tests/` holds two families of `.mjs`:
+ *   · `*.test.mjs` — the suites proper;
+ *   · every other `.mjs` beside this runner — the PROBES that prove those suites are not
+ *     vacuous (sensitivity mutations, the registration surface, the self-driving guards).
+ * Collecting only the first family was a false green: two probe suites sat at exit 1 while
+ * every report said "30/30 green". Both families are therefore collected, and a script can
+ * only stay out through the explicit, documented `NEEDS_ARGS` list below — a stale entry in
+ * that list is a hard error in a development checkout (`.git` present), so no script can be
+ * dropped silently there. Scripts whose bare run under-covers get argument `VARIANTS` (e.g.
+ * `audit-registration.mjs` defaults to v3 alone). A PUBLISHED tarball ships only a subset of
+ * `tests/`; there the missing entries are reported instead of aborting the run.
+ *
  * Every suite already isolates itself (each creates its own mkdtemp workspace), so parallelism is
  * safe. Suites that WRITE a corpus take a per-run corpus dir from an env var; this runner points
  * them at a scratch dir when it runs a suite more than once, which it never does — but the probe
  * runner (audit-formal-sensitivity.mjs) does, and it passes its own dirs.
  *
  * Usage:
- *   node tests/run-tests.mjs                      # every *.test.mjs, concurrency = min(4, cpus)
+ *   node tests/run-tests.mjs                      # every suite + probe, concurrency = min(4, cpus)
  *   node tests/run-tests.mjs --concurrency=6
  *   node tests/run-tests.mjs --only formal        # substring match on the file name (repeatable, OR)
  *   node tests/run-tests.mjs --exclude e2e-v4     # substring to skip (repeatable)
  *   node tests/run-tests.mjs --json               # machine-readable summary on stdout
  */
 import { spawn } from 'node:child_process'
-import { readdirSync } from 'node:fs'
+import { existsSync, readdirSync } from 'node:fs'
 import { cpus } from 'node:os'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -48,20 +61,75 @@ const exclude = flag('exclude')
 const asJson = has('json')
 const concurrency = Math.max(1, Number(flag('concurrency')[0] || Math.min(4, cpus().length)))
 
-let suites = readdirSync(HERE).filter((f) => f.endsWith('.test.mjs')).sort()
-if (only.length) suites = suites.filter((f) => only.some((o) => f.includes(o)))
-if (exclude.length) suites = suites.filter((f) => !exclude.some((o) => f.includes(o)))
+const SELF = 'run-tests.mjs'
+// The scripts that genuinely cannot run without arguments. They are named here (with the exact
+// command a human must run) instead of being omitted quietly: an entry that no longer exists
+// aborts the run, so a rename cannot turn into a silent gap.
+const NEEDS_ARGS = {
+  'audit-tool-exec.mjs': 'node tests/audit-tool-exec.mjs <preset-js> <tool-name>   (calls one real tool through the host path)',
+}
+// Argument variants, run IN ADDITION to the bare run unless `replaceBare` says the bare run is a
+// strict subset of them. `expectExit` documents a probe whose SUCCESS is a non-zero exit (it
+// mutates the source and requires the guarded check to fail): anything else is a FAIL here.
+const VARIANTS = [
+  // A bare `audit-registration.mjs` audits ONLY v3 (its `process.argv[2] || v3` default), so the
+  // four presets are run explicitly and the redundant bare run is replaced.
+  { file: 'audit-registration.mjs', args: ['vibe-math-v2/vibe-math-v2.js'], replaceBare: true },
+  { file: 'audit-registration.mjs', args: ['vibe-math-v3/vibe-math-v3.js'] },
+  { file: 'audit-registration.mjs', args: ['vibe-math-v4/vibe-math-v4.js'] },
+  { file: 'audit-registration.mjs', args: ['vibe-math-v5/vibe-math-v5.js'] },
+  // The invariant scanner's own falsifiability check: it exits 0 only when every injected
+  // mutation really made a run go RED (and the unmutated control stayed green).
+  { file: 'audit-prompt-invariants.mjs', args: ['--self-probe'] },
+  // The two-registration-paths probe, inverted: it applies a real description mutation and
+  // REQUIRES the parity check to exit 1 (exit 2 means the mutation no longer applies = drift).
+  {
+    file: 'audit-v3-registration-parity.mjs',
+    args: ['--self-probe', '["TOOL_DESC.vibe_math_start","TOOL_DESC.vibe_math_startX"]'],
+    expectExit: 1,
+  },
+]
+
+const present = readdirSync(HERE).filter((f) => f.endsWith('.mjs')).sort()
+const presentSet = new Set(present)
+// A published tarball ships only a SUBSET of `tests/` (see docs/test-timing.md §1), so the
+// scripts that stay behind are simply ABSENT there. The skip/variant lists are therefore
+// enforced strictly in a development checkout (a `.git` entry marks one) and merely REPORTED —
+// never silently dropped, they still appear in every run's output — in a partial tree.
+const DEV_CHECKOUT = existsSync(join(REPO, '.git'))
+const stale = Object.keys(NEEDS_ARGS).filter((f) => !presentSet.has(f))
+if (stale.length && DEV_CHECKOUT) {
+  console.error('NEEDS_ARGS names a script that no longer exists: ' + stale.join(', ') + ' — fix the skip list, do not delete the entry blindly')
+  process.exit(2)
+}
+function label(j) { return j.file + (j.args.length ? ' ' + j.args.join(' ') : '') }
+const replacedBare = new Set(VARIANTS.filter((v) => v.replaceBare).map((v) => v.file))
+let suites = []
+for (const file of present) {
+  if (file === SELF || NEEDS_ARGS[file] || replacedBare.has(file)) continue
+  suites.push({ file, args: [], expectExit: 0, kind: file.endsWith('.test.mjs') ? 'suite' : 'probe' })
+}
+for (const v of VARIANTS) {
+  if (!presentSet.has(v.file)) {
+    if (DEV_CHECKOUT) { console.error('a VARIANTS entry names a missing script: ' + v.file); process.exit(2) }
+    continue
+  }
+  suites.push({ file: v.file, args: v.args || [], expectExit: v.expectExit || 0, kind: v.file.endsWith('.test.mjs') ? 'suite' : 'probe' })
+}
+suites.sort((a, b) => (label(a) < label(b) ? -1 : 1))
+if (only.length) suites = suites.filter((j) => only.some((o) => label(j).includes(o)))
+if (exclude.length) suites = suites.filter((j) => !exclude.some((o) => label(j).includes(o)))
 if (!suites.length) { console.error('no suites matched'); process.exit(2) }
 
-function runSuite(file) {
+function runSuite(job) {
   return new Promise((resolve) => {
     const t0 = Date.now()
-    const child = spawn(process.execPath, [join(HERE, file)], { cwd: REPO, stdio: ['ignore', 'pipe', 'pipe'] })
+    const child = spawn(process.execPath, [join(HERE, job.file), ...job.args], { cwd: REPO, stdio: ['ignore', 'pipe', 'pipe'] })
     let out = '', err = ''
     child.stdout.on('data', (d) => { out += d.toString() })
     child.stderr.on('data', (d) => { err += d.toString() })
-    child.on('error', (e) => resolve({ file, code: -1, ms: Date.now() - t0, out, err: err + '\n' + String(e) }))
-    child.on('close', (code) => resolve({ file, code, ms: Date.now() - t0, out, err }))
+    child.on('error', (e) => resolve({ job, code: -1, ms: Date.now() - t0, out, err: err + '\n' + String(e) }))
+    child.on('close', (code) => resolve({ job, code, ms: Date.now() - t0, out, err }))
   })
 }
 
@@ -74,20 +142,22 @@ async function worker(id) {
     if (i >= suites.length) return
     const r = await runSuite(suites[i])
     const tail = String(r.out).trim().split('\n').filter(Boolean).slice(-1)[0] || ''
+    r.ok = r.code === r.job.expectExit
     results[i] = r
     if (!asJson) {
-      const mark = r.code === 0 ? 'PASS' : 'FAIL'
+      const mark = r.ok ? 'PASS' : 'FAIL'
       console.log(
-        mark + '  ' + r.file.padEnd(38) +
-        ' exit=' + String(r.code).padStart(3) +
+        mark + '  ' + r.job.file.padEnd(34) +
+        ' exit=' + String(r.code).padStart(3) + (r.job.expectExit ? '(want ' + r.job.expectExit + ')' : '    ') +
         '  ' + (r.ms / 1000).toFixed(1).padStart(6) + 's' +
-        (tail ? '  ' + tail.slice(0, 78) : '')
+        (r.job.args.length ? '  [' + r.job.args.join(' ').slice(0, 40) + ']' : '') +
+        (tail ? '  ' + tail.slice(0, 60) : '')
       )
-      if (r.code !== 0) {
+      if (!r.ok) {
         const lines = (r.out + '\n' + r.err).split('\n').filter(Boolean)
         for (const l of lines.slice(-15)) console.log('      ' + l)
       }
-    } else if (r.code !== 0) {
+    } else if (!r.ok) {
       // In --json mode keep stdout machine-readable: the failure detail travels in the JSON.
       const lines = (r.out + '\n' + r.err).split('\n').filter(Boolean)
       r.tailDetail = lines.slice(-15).join('\n')
@@ -98,15 +168,20 @@ await Promise.all(Array.from({ length: Math.min(concurrency, suites.length) }, (
 
 const wall = (Date.now() - started) / 1000
 const sum = results.reduce((a, r) => a + r.ms, 0) / 1000
-const bad = results.filter((r) => r.code !== 0)
+const bad = results.filter((r) => !r.ok)
 const slowest = results.slice().sort((a, b) => b.ms - a.ms).slice(0, 5)
+const suiteCount = results.filter((r) => r.job.kind === 'suite').length
 
 if (asJson) {
   console.log(JSON.stringify({
     concurrency, wallSeconds: Number(wall.toFixed(1)), sumSeconds: Number(sum.toFixed(1)),
     pass: results.length - bad.length, fail: bad.length,
-    suites: results.map((r) => ({
-      file: r.file, exit: r.code, seconds: Number((r.ms / 1000).toFixed(1)),
+    suites: suiteCount, probes: results.length - suiteCount,
+    devCheckout: DEV_CHECKOUT,
+    skippedNeedsArgs: NEEDS_ARGS,
+    runs: results.map((r) => ({
+      file: r.job.file, args: r.job.args, expectExit: r.job.expectExit, exit: r.code,
+      seconds: Number((r.ms / 1000).toFixed(1)),
       ...(r.tailDetail ? { detail: r.tailDetail } : {}),
     })),
   }, null, 2))
@@ -114,8 +189,14 @@ if (asJson) {
   console.log('')
   console.log('concurrency ' + concurrency + '  ·  wall ' + wall.toFixed(1) + 's  ·  sum of suite times ' + sum.toFixed(1) + 's'
     + '  ·  speed-up x' + (sum / Math.max(wall, 0.001)).toFixed(2))
-  console.log('slowest: ' + slowest.map((r) => r.file.replace('.test.mjs', '') + ' ' + (r.ms / 1000).toFixed(1) + 's').join('  ·  '))
-  console.log('TOTAL ' + results.length + '  PASS ' + (results.length - bad.length) + '  FAIL ' + bad.length)
-  for (const b of bad) console.log('  FAILED: ' + b.file + ' (exit ' + b.code + ')')
+  console.log('slowest: ' + slowest.map((r) => r.job.file.replace('.test.mjs', '') + ' ' + (r.ms / 1000).toFixed(1) + 's').join('  ·  '))
+  console.log('TOTAL ' + results.length + '  PASS ' + (results.length - bad.length) + '  FAIL ' + bad.length
+    + '  (suites ' + suiteCount + ' · probes ' + (results.length - suiteCount) + ')')
+  for (const b of bad) {
+    console.log('  FAILED: ' + label(b.job) + ' (exit ' + b.code + (b.job.expectExit ? ', required exit ' + b.job.expectExit : '') + ')')
+  }
+  for (const [f, why] of Object.entries(NEEDS_ARGS)) {
+    console.log('  SKIPPED (needs CLI args): ' + f + ' — ' + why + (presentSet.has(f) ? '' : '  [not present in this checkout]'))
+  }
 }
 process.exit(bad.length === 0 ? 0 : 1)

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

@@ -44,6 +44,9 @@
       Key rules to remember when reporting: a problem is "solved" when one of its solutions reaches
       正确概率 = 1; a proposition reaches 布尔估计 = 1/0 when a proof/refutation in its lists reaches
       正确概率 = 1; Propos propositions with 价值/关键性 ≥ promoteValueThreshold auto-promote to qs.json.
+      Closure rule (identical across the presets): the 1/0 values above are written ONLY by the scheduler,
+      after ≥2 independent verifier agents settle the object (one lone reviewer can never conclude), and
+      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.
 
       Configuration highlights (all tunable via vibe_math_set_params / the settings file):
@@ -107,6 +110,9 @@
       Key rules to remember when reporting: a problem is "solved" when one of its solutions reaches
       正确概率 = 1; a proposition reaches 布尔估计 = 1/0 when a proof/refutation in its lists reaches
       正确概率 = 1; Propos propositions with 价值/关键性 ≥ promoteValueThreshold auto-promote to qs.json.
+      Closure rule (identical across the presets): the 1/0 values above are written ONLY by the scheduler,
+      after ≥2 independent verifier agents settle the object (one lone reviewer can never conclude), and
+      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.
 
       Configuration highlights (all tunable via vibe_math_set_params / the settings file):