dsh-vibe-math 2.7.2 → 2.7.3

package/tests/audit-prompt-invariants.mjs

@@ -60,10 +60,24 @@ const read = readRaw
 const SELF_PROBE_MUTATIONS = [
   { name: 'control (no mutation)', rel: '', from: '', to: '', expect: '', control: true },
   {
-    name: 'v3: one set_params registration loses the Lean params (I13 — the v2.3.1 shipped defect)',
+    name: 'v5: the formal gate is REMOVED but a comment still quotes it (I8 must read code, not comments)',
+    rel: 'vibe-math-v5/vibe-math-v5.js',
+    from: 'formalOn() && p.formal',
+    to: 'true /* removed gate: formalOn() && p.formal */',
+    expect: 'v5 I8: the reply channel is gated on formalOn()',
+  },
+  {
+    name: 'v2: one registration site reverts to a literal without the Lean params (I13, mixed shapes)',
+    rel: 'vibe-math-v2/vibe-math-v2.js',
+    from: "objParams(paramProps()), 'vibe_math_set_params')",
+    to: "objParams({ mode: { type: 'string', enum: ['manual', 'auto'] } }), 'vibe_math_set_params')",
+    expect: 'v2 I13: every vibe_math_set_params schema advertises',
+  },
+  {
+    name: 'v3: one registration site reverts to a literal without the Lean params (I13, mixed shapes)',
     rel: 'vibe-math-v3/vibe-math-v3.js',
-    from: 'formalVerify: { type: \'string\'',
-    to: 'formalVerifyDISABLED: { type: \'string\'',
+    from: "objParams(paramProps()), 'vibe_math_set_params')",
+    to: "objParams({ mode: { type: 'string', enum: ['manual', 'auto'] } }), 'vibe_math_set_params')",
     expect: 'v3 I13: every vibe_math_set_params schema advertises',
   },
   {
@@ -244,6 +258,28 @@ function objectKeys(src, at) {
     .filter(Boolean)
 }
 
+/**
+ * Keys of the `objParams(...)` argument. Two shapes are supported since F-B (see docs/parameter-schema.md):
+ *   objParams({ ...literal... })   — the historical hand-written table
+ *   objParams(paramProps())        — derived from the SINGLE source PARAM_SCHEMA; the machine key set is
+ *                                    pinned by PARAM_PROPS_KEYS (+ PARAM_PROPS_EXTRA for source-unexpressible
+ *                                    entries), so that is where the advertised keys now come from.
+ * Without the second branch the extractor scanned past `objParams(` to the next `{` anywhere in the file and
+ * returned 0 keys — a silent extraction failure, not a product regression.
+ */
+function schemaKeysFor(full, at) {
+  const open = full.indexOf('{', at)
+  const close = full.indexOf(')', at)
+  if (open !== -1 && (close === -1 || open < close)) return objectKeys(full, at)
+  // Derived form: the key set lives at MODULE scope (before the registration), so search the WHOLE file.
+  const km = /const PARAM_PROPS_KEYS = \[([^\]]*)\]/.exec(full)
+  if (!km) return null
+  const keys = km[1].split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
+  const em = /const PARAM_PROPS_EXTRA = \{([\s\S]*?)\n\s*\}/.exec(full)
+  const extra = em ? [...em[1].matchAll(/^\s*([A-Za-z_$][\w$]*)\s*:/gm)].map((m) => m[1]) : []
+  return [...new Set(keys.concat(extra))]
+}
+
 const PRESETS = [
   { tag: 'v2', js: 'vibe-math-v2/vibe-math-v2.js', suite: 'tests/formal-verify-v2.test.mjs', corpus: 'prompt-corpus-v2/formal-verify-v2.md', valueField: 'Result', prefix: 'vibe_math_', setTool: 'vibe_math_set_params' },
   { tag: 'v3', js: 'vibe-math-v3/vibe-math-v3.js', suite: 'tests/formal-verify-v3.test.mjs', corpus: 'prompt-corpus-v3/formal-verify-v3.md', valueField: 'Result', prefix: 'vibe_math_', setTool: 'vibe_math_set_params' },
@@ -318,7 +354,9 @@ for (const P of PRESETS) {
     v4: /applyFormalReply[\s\S]{0,900}!formalOn\(\)/,
     v5: /formalOn\(\)\s*&&\s*p\.formal/,
   }
-  check(offGuards[P.tag].test(js), P.tag + ' I8: the reply channel is gated on formalOn() (off stays a no-op)')
+  // A text gate must read CODE, not comments: a comment quoting `formalOn() && p.formal` satisfied
+  // the raw-source version of this check, which hid a removed gate (self-probe mutation below proves it).
+  check(offGuards[P.tag].test(code), P.tag + ' I8: the reply channel is gated on formalOn() (off stays a no-op)')
 
   // I9 — the corpus covers every mode and is deterministic / machine-path free.
   check(corpus.includes('【Lean 形式化验证（鼓励模式）】'), P.tag + ' I9: corpus covers encourage mode')
@@ -381,7 +419,7 @@ for (const P of PRESETS) {
     while ((m = regRe.exec(code))) {
       const rest = code.slice(m.index)
       const oi = rest.indexOf('objParams(')
-      schemas.push(oi < 0 ? null : objectKeys(rest, oi + 'objParams'.length))
+      schemas.push(oi < 0 ? null : schemaKeysFor(code, m.index + oi + 'objParams('.length))
     }
     check(schemas.length >= 1, P.tag + ' I13: the parameter tool ' + P.setTool + ' is registered',
       'no registerTool(\'' + P.setTool + '\') call found')

package/tests/audit-readme-bilingual.test.mjs

@@ -0,0 +1,152 @@
+// ============================================================================================
+// BILINGUAL README — the Chinese README is the default; README.en.md is a full translation of it.
+// Two documents that are supposed to say the same thing rot apart silently, so this suite pins the
+// parts that must stay identical no matter how either side is edited:
+//
+//   · a switcher line near the top of each file linking to the other;
+//   · identical heading STRUCTURE (same ordered sequence of heading levels, ignoring fenced code —
+//     a `#` shell comment inside a code fence is not a heading);
+//   · identical image lists, identical local link targets, identical table-row and code-fence counts
+//     (a translation preserves rows 1:1, so a mismatch means content was dropped or merged);
+//   · the English file must actually be English outside code (CJK characters are only allowed in
+//     fenced/inline code, where the rules keep user-facing example strings in the original language);
+//   · both files ship in `package.json` `files`;
+//   · the Chinese README is still the default `README.md` (npm and GitHub render that one).
+//
+// Usage: node tests/audit-readme-bilingual.test.mjs
+// ============================================================================================
+import { readFileSync, existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { join, dirname, resolve } from 'node:path'
+
+const HERE = fileURLToPath(new URL('./', import.meta.url))
+const REPO = resolve(HERE, '..')
+const pkg = JSON.parse(readFileSync(join(REPO, 'package.json'), 'utf8'))
+
+let passed = 0, failed = 0
+const failures = []
+function ok(cond, label, detail) {
+  if (cond) { passed++; console.log('  ok   ' + label); return true }
+  failed++; failures.push(label + (detail ? ' — ' + detail : ''))
+  console.error('  FAIL ' + label + (detail ? ' — ' + detail : ''))
+  return false
+}
+
+const ZH = 'README.md'
+const EN = 'README.en.md'
+if (!ok(existsSync(join(REPO, ZH)) && existsSync(join(REPO, EN)), 'both README.md and README.en.md exist')) {
+  console.log('\n=== BILINGUAL README: ' + passed + ' passed, ' + failed + ' failed ===')
+  process.exit(1)
+}
+const zh = readFileSync(join(REPO, ZH), 'utf8')
+const en = readFileSync(join(REPO, EN), 'utf8')
+
+// ---- 1. switcher ------------------------------------------------------------
+{
+  const head = (t) => t.split(/\r?\n/).slice(0, 12).join('\n')
+  ok(/\[English\]\(README\.en\.md\)/.test(head(zh)), 'the Chinese README links to the English one near the top')
+  ok(/\[中文\]\(README\.md\)/.test(head(en)) || /\[简体中文\]\(README\.md\)/.test(head(en)),
+    'the English README links back to the Chinese one near the top')
+  ok(zh.trimStart().startsWith('# ') && en.trimStart().startsWith('# '), 'both files start with an H1 title')
+}
+
+// ---- 2. strip code before structure comparison ------------------------------
+/** Markdown with fenced blocks and inline code replaced by placeholders (so their contents — which
+ *  are allowed to differ in language — cannot influence counting or CJK checks). */
+function stripCode(t) {
+  return t
+    .replace(/```[\s\S]*?```/g, '\n```CODE```\n')
+    .replace(/`[^`\n]*`/g, '`CODE`')
+}
+const zhPlain = stripCode(zh)
+const enPlain = stripCode(en)
+
+// ---- 3. structure -----------------------------------------------------------
+const headingLevels = (t) => [...t.matchAll(/^(#{1,6})\s+/gm)].map((m) => m[1].length)
+const zhH = headingLevels(zhPlain), enH = headingLevels(enPlain)
+ok(zhH.length === enH.length && zhH.every((l, i) => l === enH[i]),
+  `the heading structure matches (${zhH.length} headings, levels in the same order)`,
+  `zh=[${zhH.join(',')}] en=[${enH.join(',')}]`)
+
+const tableRows = (t) => t.split('\n').filter((l) => /^\s*\|/.test(l)).length
+ok(tableRows(zhPlain) === tableRows(enPlain), 'the table-row count matches (translations preserve rows 1:1)',
+  `zh=${tableRows(zhPlain)} en=${tableRows(enPlain)}`)
+
+const fences = (t) => (t.match(/^```/gm) || []).length
+ok(fences(zh) === fences(en), 'the code-fence count matches', `zh=${fences(zh)} en=${fences(en)}`)
+
+// ---- 4. assets and links ----------------------------------------------------
+const images = (t) => [...t.matchAll(/!\[[^\]]*\]\(([^)\s]+)\)/g)].map((m) => m[1])
+const zhImg = images(zh), enImg = images(en)
+// The four architecture diagrams deliberately differ by language: the English README points at the
+// `-en` asset of the same diagram, every other image must be the very same file.
+const enVariant = (p) => p.replace(/^(示例图\/框架图-v[0-9]+)\.(png|svg)$/, '$1-en.svg')
+ok(zhImg.length > 0 && zhImg.length === enImg.length, 'both READMEs show the same number of images',
+  `zh=[${zhImg.join(', ')}] en=[${enImg.join(', ')}]`)
+const imgMismatch = zhImg.filter((p, i) => enImg[i] !== p && enImg[i] !== enVariant(p))
+ok(imgMismatch.length === 0,
+  'every English image is the same asset as the Chinese one, or its -en variant, in the same order',
+  `mismatch=[${imgMismatch.join(', ')}] en=[${enImg.join(', ')}]`)
+const enDiagrams = enImg.filter((p) => /示例图\/框架图-v[0-9]+-en\.svg$/.test(p))
+ok(enDiagrams.length === 4, 'the English README references all four English architecture diagrams',
+  `en=[${enImg.join(', ')}]`)
+
+// Internal anchors must resolve inside their OWN file: translating a heading renames its slug, so
+// an anchor copied from the Chinese README breaks. (GitHub maps EVERY whitespace to a hyphen and
+// does not collapse runs — a slugger that collapses them reports valid anchors as broken.)
+const slug = (heading) => heading.replace(/^#{1,6}\s+/, '').trim().toLowerCase()
+  .replace(/[^\p{L}\p{N}\s-]/gu, '').replace(/\s/g, '-')
+const headingsWithSlugs = (file) => {
+  const text = readFileSync(join(REPO, file), 'utf8')
+  const inFence = []
+  let fence = false
+  for (const l of text.split('\n')) { if (/^```/.test(l)) { fence = !fence; inFence.push(false); continue } inFence.push(fence) }
+  return { text, slugs: text.split('\n').filter((l, i) => !inFence[i] && /^#{1,6}\s+/.test(l)).map(slug) }
+}
+for (const file of [ZH, EN]) {
+  const { text, slugs } = headingsWithSlugs(file)
+  const anchors = [...new Set([...text.matchAll(/\]\(#([^)]+)\)/g)].map((m) => m[1]))]
+  const broken = anchors.filter((a) => !slugs.includes(a))
+  ok(broken.length === 0, `${file}: every internal anchor matches one of its own headings (${anchors.length} anchors)`,
+    'broken: #' + broken.join(', #'))
+}
+
+const localLinks = (t) => [...new Set([...t.matchAll(/\[[^\]]*\]\(([^)\s]+)\)/g)].map((m) => m[1]))]
+  .filter((p) => !/^[a-z][a-z0-9+.-]*:/i.test(p) && !p.startsWith('#'))
+  .filter((p) => p !== 'README.md' && p !== 'README.en.md') // the switcher is intentionally asymmetric
+  .sort()
+const zhLinks = localLinks(zh), enLinks = localLinks(en)
+// The four architecture diagrams are the single documented exception: the English README points at
+// the `-en` asset of the same diagram. Normalizing just that difference keeps the guard strict about
+// every other local target (a genuinely missing or extra link still fails).
+const diagramKey = (p) => {
+  const m = /^示例图\/框架图-(v[0-9]+)(?:-en)?\.(?:png|svg)$/.exec(p)
+  return m ? '示例图/框架图-' + m[1] + '.<diagram>' : p
+}
+const zhKeys = zhLinks.map(diagramKey).sort(), enKeys = enLinks.map(diagramKey).sort()
+ok(zhKeys.join('|') === enKeys.join('|'),
+  'both READMEs link to the same local targets, up to the four language-specific diagrams',
+  'only in zh: ' + zhLinks.filter((p) => !enKeys.includes(diagramKey(p))).join(', ')
+  + ' | only in en: ' + enLinks.filter((p) => !zhKeys.includes(diagramKey(p))).join(', '))
+
+// ---- 5. the English file is actually English outside code --------------------
+{
+  // Link and image TARGETS legitimately stay Chinese (real file and directory names), as do the real
+  // JSON keys, the literal session-rebuild marker and the switcher label. What is left is that small
+  // set of literals — a real untranslated paragraph would be in the hundreds.
+  const withoutTargets = enPlain.replace(/\]\([^)\s]+\)/g, '](TARGET)').replace(/!\[[^\]]*\](\([^)\s]+\))/g, '![img]($1)')
+  const cjk = (withoutTargets.match(/[\u3400-\u9fff\uf900-\ufaff]/g) || []).length
+  ok(cjk <= 150, `no untranslated prose outside code and link targets (${cjk} CJK characters, budget 150)`,
+    'a count in the hundreds means a section was left in Chinese')
+}
+
+// ---- 6. packaging + default -------------------------------------------------
+ok((pkg.files || []).includes(ZH) && (pkg.files || []).includes(EN), 'both READMEs are listed in package.json files',
+  JSON.stringify((pkg.files || []).filter((f) => /^README/.test(f))))
+ok(existsSync(join(REPO, 'README.zh.md')) === false,
+  'the Chinese README is still the default README.md (no README.zh.md duplicate to maintain)')
+
+console.log('')
+console.log('=== BILINGUAL README: ' + passed + ' passed, ' + failed + ' failed ===')
+if (failed) { for (const f of failures) console.error('  - ' + f); process.exit(1) }
+console.log('ALL GREEN')

package/tests/audit-readme-counts.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/**
+ * README/COUNT CONSISTENCY — the numbers quoted in shipped docs are DERIVED, not typed, and each is
+ * labelled as a JOB count or a FILE count.
+ *
+ * DEFECT CLASS: "documented count drifts from the tree" (D1). README quoted `TOTAL 57` (39 suites /
+ * 18 probes, "18 items ship") while the runner produced 65, then 85/86, and docs/test-timing.md and
+ * docs/AUDIT-CHECKLIST.md disagreed with each other. Authority: `node tests/run-tests.mjs --counts`
+ * (the gate's own JOB list — base jobs + VARIANTS jobs) plus `package.json#files` (shipped FILE counts).
+ * Shapes come from tests/helpers/doc-counts-format.mjs, the same module the writer
+ * (scripts/update-doc-counts.mjs) and the mutant harness use, so the three cannot disagree.
+ *
+ * Run: node tests/audit-readme-counts.mjs
+ * Env (mutant harness): COUNTS_README / COUNTS_README_EN / COUNTS_TIMING / COUNTS_CHECKLIST / COUNTS_FIELDS /
+ * COUNTS_PAPER / COUNTS_MATH (absolute or repo-relative). The last three serve the F-C live-doc sweep.
+ */
+import { readFileSync } from 'node:fs'
+import { dirname, isAbsolute, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawnSync } from 'node:child_process'
+import { claims } from './helpers/doc-counts-format.mjs'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const REPO = join(HERE, '..')
+let passed = 0, failed = 0
+const failures = []
+const ok = (cond, label, detail) => { if (cond) passed++; else { failed++; failures.push(label + (detail ? ' — ' + detail : '')) } }
+
+const derivedRaw = spawnSync(process.execPath, [join(HERE, 'run-tests.mjs'), '--counts'], { cwd: REPO, encoding: 'utf8' })
+let derived = null
+try { derived = JSON.parse(String(derivedRaw.stdout || '').trim()) } catch (e) { /* reported below */ }
+ok(!!derived && derived.total > 0 && derived.suites > 0,
+  'the runner --counts mode produces the derived JOB totals (suites/probes/total)', String(derivedRaw.stdout || '').slice(0, 70))
+
+const pkg = JSON.parse(readFileSync(join(REPO, 'package.json'), 'utf8'))
+const shippedFiles = pkg.files.filter((f) => f.startsWith('tests/') && f.endsWith('.mjs'))
+const shipped = { total: shippedFiles.length, suites: shippedFiles.filter((f) => f.endsWith('.test.mjs')).length }
+shipped.probes = shipped.total - shipped.suites
+ok(shipped.total > 0 && shipped.suites > 0, 'package.json#files yields the shipped FILE split',
+  JSON.stringify({ shipped: shipped.total, suites: shipped.suites, probes: shipped.probes }))
+
+const read = (envName, rel) => {
+  const v = process.env[envName]
+  return readFileSync(v ? (isAbsolute(v) ? v : join(REPO, v)) : join(REPO, rel), 'utf8')
+}
+const zh = read('COUNTS_README', 'README.md')
+const en = read('COUNTS_README_EN', 'README.en.md')
+const tt = read('COUNTS_TIMING', 'docs/test-timing.md')
+const ck = read('COUNTS_CHECKLIST', 'docs/AUDIT-CHECKLIST.md')
+
+if (derived) {
+  const c = claims(derived, shipped)
+  const has = (doc, label, needle) => ok(doc.indexOf(needle) !== -1, label, 'looked for ' + needle)
+  has(zh, '★ README.md carries the canonical JOB-count bullet (derived totals + shipped FILE count)', c.zhBullet)
+  has(en, '★ README.en.md carries the canonical JOB-count bullet', c.enBullet)
+  has(tt, '★ docs/test-timing.md carries the canonical runner row (derived JOB counts + output shape)', c.ttRow)
+  has(ck, '★ docs/AUDIT-CHECKLIST.md quotes the derived JOB counts', c.ckClaim)
+  has(ck, '★ docs/AUDIT-CHECKLIST.md quotes the derived shipped FILE counts (published subset)', c.ckShipped)
+  has(ck, '★ docs/AUDIT-CHECKLIST.md D1 row carries the derived counts', c.d1Row)
+  ok(!/TOTAL 57/.test(zh), 'the stale README claim (TOTAL 57) is gone')
+  ok(!/TOTAL 65  PASS 65/.test(tt), 'the old test-timing baseline row (TOTAL 65 PASS 65) is gone')
+  ok(!/\*\*65 项\*\* = 44 套件 \+ 21/.test(tt + ck), 'no bolded stale 65-item claim remains (prose about the migration is fine)')
+
+  // ── F-C: EVERY `TOTAL <n>` in a LIVE doc equals the derived job count ────────────────────────────
+  // Published release notes under `docs/release-notes/**` are FROZEN history: they record what the gate
+  // read at their own release (`TOTAL 65` in 2.7.0/2.7.1), so they are excluded BY NAME — and the
+  // exclusion is asserted non-empty and reported, so the sweep cannot silently skip everything.
+  const FROZEN_EXCLUDED = ['docs/release-notes/RELEASE-NOTES-2.7.0.md', 'docs/release-notes/RELEASE-NOTES-2.7.0.en.md', 'docs/release-notes/RELEASE-NOTES-2.7.1.md', 'docs/release-notes/RELEASE-NOTES-2.7.1.en.md', 'docs/release-notes/RELEASE-NOTES-2.7.2.md']
+  const LIVE_DOCS = [
+    ['COUNTS_README', 'README.md'], ['COUNTS_README_EN', 'README.en.md'], ['COUNTS_TIMING', 'docs/test-timing.md'],
+    ['COUNTS_CHECKLIST', 'docs/AUDIT-CHECKLIST.md'],
+    ['COUNTS_FIELDS', 'docs/status-report-fields.md'], ['COUNTS_PAPER', 'docs/final-paper.md'], ['COUNTS_MATH', 'docs/math-computation.md'],
+  ]
+  let occurrences = 0, scanned = 0
+  for (const [env, rel] of LIVE_DOCS) {
+    let text = ''
+    try { text = read(env, rel) } catch (e) { continue }
+    scanned++
+    for (const m of text.matchAll(/TOTAL\s+(\d+)/g)) {
+      occurrences++
+      ok(Number(m[1]) === derived.total, '★ ' + rel + ': every TOTAL <n> equals the derived job count (' + m[1] + ' vs ' + derived.total + ')',
+        'occurrence: ' + m[0])
+    }
+  }
+  console.log('  live-docs scanned=' + scanned + ' TOTAL-occurrences=' + occurrences + ' frozen-excluded=' + FROZEN_EXCLUDED.length)
+  ok(scanned > 0 && occurrences > 0, '★ the F-C sweep is non-vacuous (it scanned live docs and found TOTAL occurrences)',
+    'scanned=' + scanned + ' occurrences=' + occurrences)
+  ok(FROZEN_EXCLUDED.length > 0, '★ the frozen release notes are excluded BY NAME, not by a pattern that could swallow the sweep',
+    JSON.stringify(FROZEN_EXCLUDED.length))
+}
+
+console.log('')
+console.log('=== README COUNTS: ' + passed + ' passed, ' + failed + ' failed ===')
+for (const f of failures) console.error('  - ' + f)
+process.exit(failed === 0 ? 0 : 1)

package/tests/audit-readme-counts.mutants.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * Mutant harness for tests/audit-readme-counts.mjs (ships: `tests/*.mutants.mjs`).
+ *
+ * It proves the count guard can REDDEN: tamper the quoted TOTAL in a COPY of README.md (via the
+ * guard's COUNTS_README seam) and require the NAMED assertion "README.md quotes the DERIVED totals"
+ * in the failure list. Expected reds must name the LOAD-BEARING assertion, not any substring.
+ *
+ * Run: node tests/audit-readme-counts.mutants.mjs
+ */
+import { mkdtempSync, readFileSync, writeFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { claims } from './helpers/doc-counts-format.mjs'
+
+const HERE = fileURLToPath(new URL('./', import.meta.url))
+const REPO = join(HERE, '..')
+const GUARD = join(HERE, 'audit-readme-counts.mjs')
+let passed = 0, failed = 0
+const ok = (c, l, d) => { if (c) { passed++; console.log('  ok   ' + l) } else { failed++; console.log('  FAIL ' + l + (d ? ' — ' + d : '')) } }
+
+const base = spawnSync(process.execPath, [GUARD], { cwd: REPO, encoding: 'utf8' })
+const baseOut = String(base.stdout || '') + String(base.stderr || '')
+ok(base.status === 0 && /10 passed, 0 failed|passed, 0 failed/.test(baseOut), 'baseline: the count guard is green',
+  (baseOut.trim().split('\n').filter(Boolean).slice(-1)[0] || '').slice(0, 80))
+
+// Tamper the EXACT quoted needle (not a random first match), so the red names the load-bearing check.
+const derived = JSON.parse(spawnSync(process.execPath, [join(HERE, 'run-tests.mjs'), '--counts'], { cwd: REPO, encoding: 'utf8' }).stdout.trim())
+const pkg = JSON.parse(readFileSync(join(REPO, 'package.json'), 'utf8'))
+const dir = mkdtempSync(join(tmpdir(), 'counts-mut-'))
+const zh = readFileSync(join(REPO, 'README.md'), 'utf8')
+const shippedFiles = pkg.files.filter((f) => f.startsWith('tests/') && f.endsWith('.mjs'))
+const shipped = { total: shippedFiles.length, suites: shippedFiles.filter((f) => f.endsWith('.test.mjs')).length }
+shipped.probes = shipped.total - shipped.suites
+const needle = claims(derived, shipped).zhTotal
+if (zh.indexOf(needle) === -1) {
+  ok(false, 'the tamper anchor is present in README.md (the guard and the harness agree on the shape)', 'ANCHOR MISS: ' + needle)
+} else {
+  writeFileSync(join(dir, 'README.md'), zh.replace(needle, '`TOTAL 57`（39 套件 + 18 探针/变体）'))
+  const mut = spawnSync(process.execPath, [GUARD], { cwd: REPO, encoding: 'utf8', env: Object.assign({}, process.env, { COUNTS_README: join(dir, 'README.md') }) })
+  const out = String(mut.stdout || '') + String(mut.stderr || '')
+  const failLines = out.split('\n').filter((l) => /^  - /.test(l))
+  const named = failLines.some((l) => l.indexOf('README.md carries the canonical JOB-count bullet') !== -1)
+  ok(mut.status !== 0 && named, '★ tampering the quoted TOTAL makes the count guard RED by name', 'exit=' + mut.status)
+  if (!named) for (const l of failLines.slice(0, 4)) console.log('      guard failure: ' + l.trim().slice(0, 130))
+}
+rmSync(dir, { recursive: true, force: true })
+console.log('')
+console.log('=== README COUNTS MUTANTS: ' + passed + ' passed, ' + failed + ' failed ===')
+process.exit(failed === 0 ? 0 : 1)

package/tests/audit-registration.mjs

@@ -0,0 +1,78 @@
+/**
+ * ROUND 2 — verify the tool-registration surface against the REAL host contract.
+ *
+ * `dsh-tools` register(): "duplicates within one layer ... fail". So if a preset
+ * registers the same tool name twice in the same scope, the preset cannot mount.
+ * The e2e mocks only push to an array, so they cannot see this. This counts what the
+ * plugin actually registers and reports duplicates.
+ */
+import { mkdtempSync, rmSync, existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname, resolve, isAbsolute } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const WS = mkdtempSync(join(tmpdir(), 'reg-'));
+const toolRegs = [];
+const cmdRegs = [];
+const ctx = {
+  get(n) {
+    if (n === 'subprocess') return { async spawn({ argv }) {
+      const s = argv[argv.length - 1] || '';
+      if (/New-Item/.test(s)) { const m = s.match(/-Path\s+'((?:[^']|'')*)'/); if (m) m[1].split(',').forEach((p) => { if (p) mkdirSync(p.replace(/''/g, "'"), { recursive: true }); }); }
+      return { done: Promise.resolve({ exitCode: 0 }) };
+    } };
+    return undefined;
+  },
+  on() {}, effect(fn) { const d = fn(); return () => { if (typeof d === 'function') d(); } },
+  logger: { info() {}, warn() {}, error() {} },
+  tools: { register(spec) { toolRegs.push(spec); } },
+  commands: { register(spec) { cmdRegs.push(spec); } },
+  subagents: { list() { return ['spawn']; }, async startContinuable() { return { childId: 'c1' }; }, async sendMessage() {}, async followup() {}, interrupt() {} },
+  agents: { roots() { return []; }, get() { return undefined; } },
+  fs: {
+    async resolve(rel, o) { return join((o && o.cwd) || WS, ...String(rel).split('/')); },
+    async stat(t) { return existsSync(t) ? { type: 'file' } : undefined; },
+    async readText(t) { return readFileSync(t, 'utf8'); },
+    async writeText(t, c) { mkdirSync(dirname(t), { recursive: true }); writeFileSync(t, c, 'utf8'); },
+    async listDir(t) { if (!existsSync(t)) return []; return readdirSync(t, { withFileTypes: true }).map((e) => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file' })); },
+  },
+};
+
+const REPO = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const FILE = process.argv[2] || 'vibe-math-v3/vibe-math-v3.js';
+const TARGET = isAbsolute(FILE) ? FILE : resolve(REPO, FILE);
+const mod = await import(pathToFileURL(TARGET).href + '?t=' + Date.now());
+const plugin = mod.default || mod;
+
+console.log(`=== ${FILE} ===`);
+console.log(`exported name   : ${plugin.name}`);
+console.log(`exported inject : ${JSON.stringify(plugin.inject)}`);
+
+let applyError = null;
+try { plugin.apply(ctx); } catch (e) { applyError = e; }
+if (applyError) { console.log(`apply() threw  : ${applyError.message}`); }
+
+console.log(`tools.register calls   : ${toolRegs.length}`);
+console.log(`commands.register calls: ${cmdRegs.length}`);
+
+const dup = (specs) => {
+  const seen = new Map();
+  for (const s of specs) seen.set(s.name, (seen.get(s.name) || 0) + 1);
+  return [...seen.entries()].filter(([, c]) => c > 1);
+};
+const toolDup = dup(toolRegs);
+const cmdDup = dup(cmdRegs);
+
+console.log(`DUPLICATE tool names   : ${toolDup.length === 0 ? 'none' : JSON.stringify(toolDup)}`);
+console.log(`DUPLICATE command names: ${cmdDup.length === 0 ? 'none' : JSON.stringify(cmdDup)}`);
+
+// Every registered tool must satisfy the host's mandatory output contract.
+const missingOutput = toolRegs.filter((s) => !s.output || typeof s.output.render !== 'function' || !s.output.schema);
+console.log(`tools missing output{}/render: ${missingOutput.length === 0 ? 'none' : missingOutput.map((s) => s.name).join(', ')}`);
+const badName = toolRegs.filter((s) => typeof s.name !== 'string' || s.name === '');
+console.log(`tools with a bad name  : ${badName.length === 0 ? 'none' : badName.length}`);
+
+console.log(`\nfirst 8 tool names: ${toolRegs.slice(0, 8).map((s) => s.name).join(', ')}`);
+
+rmSync(WS, { recursive: true, force: true });
+process.exit(toolDup.length > 0 || cmdDup.length > 0 || missingOutput.length > 0 ? 1 : 0);

package/tests/audit-status-report-fields.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * STATUS/REPORT FIELD TABLE vs SOURCE (G-6) — the doc's per-preset field/scope rows must be exactly the
+ * fields the code declares, in BOTH directions, and each row's scope must match the source classification.
+ *
+ * DEFECT CLASS: "machine-face field documented nowhere / documented field that does not exist" (F12/F3):
+ * `实现方案.md §14.9` claimed every `status()` field had a row while >=13 top-level keys had none; and a
+ * table written by hand drifts the moment a field is added. Sources are derived BY MARKER (line numbers
+ * are claims, not anchors):
+ *   v2/v3 -> `fieldScopes: { session: [...], durable: [...] }`  (20 / 25 entries)
+ *   v5    -> the top-level keys of the object literal `status()` returns (its `fieldScopes` is coarse)
+ *   v4    -> has NO `fieldScopes`; the table must say so rather than invent rows
+ *
+ * Run: node tests/audit-status-report-fields.mjs
+ * Env (mutant harness): FIELD_DOC, FIELD_V2_JS, FIELD_V3_JS, FIELD_V5_JS, FIELD_V4_JS (absolute or relative).
+ */
+import { readFileSync } from 'node:fs'
+import { dirname, isAbsolute, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const REPO = join(HERE, '..')
+let passed = 0, failed = 0
+const failures = []
+const ok = (cond, label, detail) => { if (cond) passed++; else { failed++; failures.push(label + (detail ? ' — ' + detail : '')) } }
+const read = (envName, rel) => {
+  const v = process.env[envName]
+  return readFileSync(v ? (isAbsolute(v) ? v : join(REPO, v)) : join(REPO, rel), 'utf8')
+}
+function fieldScopesOf(text) {
+  const lines = text.split(/\r?\n/)
+  const start = lines.findIndex((l) => /^\s*fieldScopes:\s*\{/.test(l))
+  if (start === -1) return null
+  let depth = 0
+  const buf = []
+  for (let i = start; i < lines.length; i++) {
+    buf.push(lines[i]); depth += (lines[i].match(/\{/g) || []).length - (lines[i].match(/\}/g) || []).length
+    if (i > start && depth <= 0) break
+  }
+  const out = {}
+  for (const m of buf.join('\n').matchAll(/(\w+):\s*\[([\s\S]*?)\]/g)) {
+    out[m[1]] = m[2].split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
+  }
+  return out
+}
+function statusKeysOf(text) {
+  // Robust: brace/comment/string aware, and it reads SHORTHAND properties too —
+  // `institute: instituteName, project, key, phase,` is FOUR keys, not one. The earlier line-anchored
+  // version missed 8 real keys (R19 F-A: project/key/phase/running/autoDone/runId/lastProgressAt/params).
+  const fn = text.search(/function\s+status\s*\(/)
+  if (fn === -1) return null
+  const ret = text.indexOf('return {', fn)
+  if (ret === -1) return null
+  const start = text.indexOf('{', ret)
+  let d0 = 0, stop = start, k = start
+  while (k < text.length) {
+    const c = text[k]
+    if (c === '/' && text[k + 1] === '/') { while (k < text.length && text[k] !== '\n') k++; continue }
+    if (c === '/' && text[k + 1] === '*') { k += 2; while (k < text.length && !(text[k] === '*' && text[k + 1] === '/')) k++; k += 2; continue }
+    if (c === '"' || c === "'" || c === '`') { const q = c; k++; while (k < text.length) { if (text[k] === '\\') k += 2; else if (text[k] === q) break; else k++ } k++; continue }
+    if (c === '{' || c === '[' || c === '(') d0++
+    else if (c === '}' || c === ']' || c === ')') { d0--; if (d0 === 0) { stop = k; break } }
+    k++
+  }
+  if (d0 !== 0) return null
+  const body = text.slice(start + 1, stop)
+  const segs = []
+  let buf = '', d = 0, j = 0
+  while (j < body.length) {
+    const c = body[j]
+    if (c === '/' && body[j + 1] === '/') { while (j < body.length && body[j] !== '\n') j++; continue }
+    if (c === '/' && body[j + 1] === '*') { j += 2; while (j < body.length && !(body[j] === '*' && body[j + 1] === '/')) j++; j += 2; continue }
+    if (c === '"' || c === "'" || c === '`') { const q = c; buf += c; j++; while (j < body.length) { buf += body[j]; if (body[j] === '\\') { j++; buf += body[j] } else if (body[j] === q) break; j++ } j++; continue }
+    if (c === '{' || c === '[' || c === '(') d++
+    if (c === '}' || c === ']' || c === ')') d--
+    if (c === ',' && d === 0) { segs.push(buf); buf = ''; j++; continue }
+    buf += c; j++
+  }
+  if (buf.trim()) segs.push(buf)
+  const keys = []
+  for (const seg of segs) {
+    const t = seg.trim()
+    if (!t) continue
+    const m = /^([A-Za-z_$][\w$]*)\s*(?::|$|,)/.exec(t)
+    if (m) keys.push(m[1])
+  }
+  return [...new Set(keys)]
+}
+/** Rows of the doc section that starts with `headingPrefix`, up to the next `### `. */
+function docRows(doc, headingPrefix) {
+  const lines = doc.split(/\r?\n/)
+  const start = lines.findIndex((l) => l.startsWith(headingPrefix))
+  if (start === -1) return null
+  let end = lines.findIndex((l, i) => i > start && /^### /.test(l))
+  if (end === -1) end = lines.length
+  const rows = []
+  for (let i = start; i < end; i++) {
+    const m = /^\|\s*`([^`]+)`\s*\|\s*([^|]+?)\s*\|/.exec(lines[i])
+    if (m) rows.push({ name: m[1], scope: m[2] })
+  }
+  return rows
+}
+const diff = (a, b) => [...a].filter((x) => !b.has(x))
+
+const doc = read('FIELD_DOC', 'docs/status-report-fields.md')
+ok(doc.indexOf('G-6-FIELD-TABLE-START') !== -1 && doc.indexOf('G-6-FIELD-TABLE-END') !== -1,
+  'the doc carries the machine-generated field table between its markers (so the guard knows what to read)')
+
+const f2 = fieldScopesOf(read('FIELD_V2_JS', 'vibe-math-v2/vibe-math-v2.js'))
+const f3 = fieldScopesOf(read('FIELD_V3_JS', 'vibe-math-v3/vibe-math-v3.js'))
+const s5 = statusKeysOf(read('FIELD_V5_JS', 'vibe-math-v5/vibe-math-v5.js'))
+const v4 = read('FIELD_V4_JS', 'vibe-math-v4/vibe-math-v4.js')
+ok(!!f2 && !!f3 && !!s5, 'all three sources are parseable by marker (v2/v3 fieldScopes, v5 status())')
+
+if (f2 && f3 && s5) {
+  const cases = [
+    { preset: 'v2', src: [...(f2.session || []), ...(f2.durable || [])], head: '### v2 的字段与作用域', scopeMap: { session: '会话', durable: '耐久' }, fs: f2 },
+    { preset: 'v3', src: [...(f3.session || []), ...(f3.durable || [])], head: '### v3 的字段与作用域', scopeMap: { session: '会话', durable: '耐久' }, fs: f3 },
+    { preset: 'v5', src: s5, head: '### v5 的字段与作用域', scopeMap: null, fs: null },
+  ]
+  for (const c of cases) {
+    const rows = docRows(doc, c.head)
+    ok(!!rows && rows.length > 0, c.preset + ': the doc section exists and has rows', String(rows && rows.length))
+    if (!rows) continue
+    const docSet = new Set(rows.map((r) => r.name))
+    const srcSet = new Set(c.src)
+    const missingInDoc = diff(srcSet, docSet)
+    const extraInDoc = diff(docSet, srcSet)
+    ok(missingInDoc.length === 0, '★ ' + c.preset + ': every source field has a doc row (doc↔source, source→doc)', JSON.stringify(missingInDoc))
+    ok(extraInDoc.length === 0, '★ ' + c.preset + ': every doc row names a real source field (doc↔source, doc→source)', JSON.stringify(extraInDoc))
+    if (c.scopeMap && c.fs) {
+      const wrong = []
+      for (const scope of ['session', 'durable']) {
+        for (const name of c.fs[scope] || []) {
+          const r = rows.find((x) => x.name === name)
+          if (r && r.scope !== c.scopeMap[scope]) wrong.push(name + '=' + r.scope)
+        }
+      }
+      ok(wrong.length === 0, '★ ' + c.preset + ': every row scope matches the source classification', JSON.stringify(wrong))
+    }
+  }
+  // ---- code -> doc (R19 F-A): EVERY status() top-level key lands in the v5 table OR is an explicit
+  // exception. The exceptions list is empty today; adding one requires a reason HERE, in this file.
+  const V5_EXCEPTIONS = []
+  {
+    const v5DocRows = docRows(doc, '### v5 的字段与作用域') || []
+    const docSet5 = new Set(v5DocRows.map((r) => r.name))
+    const frozen = s5
+    const exceptions = V5_EXCEPTIONS
+    console.log('  counts: frozen=' + frozen.length + ' doc-rows=' + docSet5.size + ' exceptions=' + exceptions.length)
+    ok(frozen.length > 0 && docSet5.size > 0, '★ the three counts are non-zero (the comparison cannot pass vacuously)',
+      'frozen=' + frozen.length + ' doc-rows=' + docSet5.size + ' exceptions=' + exceptions.length)
+    const covered = new Set([...docSet5, ...exceptions])
+    const uncovered = frozen.filter((k) => !covered.has(k))
+    ok(uncovered.length === 0, '★ every status() top-level key is documented or an explicit exception (code->doc)',
+      JSON.stringify(uncovered))
+    const phantom = [...docSet5].filter((k) => frozen.indexOf(k) === -1 && exceptions.indexOf(k) === -1)
+    ok(phantom.length === 0, '★ no v5 doc row names a key status() does not return (doc->code)',
+      JSON.stringify(phantom))
+  }
+  // v4 must be stated as having none, and the source must agree
+  const v4Rows = docRows(doc, '### v4')
+  ok(!v4Rows || v4Rows.length === 0, '★ v4: no rows are invented (it has no fieldScopes to derive from)', String(v4Rows && v4Rows.length))
+  ok(doc.indexOf('**没有** `fieldScopes`') !== -1 || doc.indexOf('不存在** `fieldScopes`') !== -1,
+    '★ v4: the doc says explicitly that v4 has no fieldScopes')
+  ok(!/fieldScopes/.test(v4), '★ v4: the source confirms it (zero occurrences of fieldScopes)')
+}
+
+console.log('')
+console.log('=== STATUS FIELD TABLE: ' + passed + ' passed, ' + failed + ' failed ===')
+for (const f of failures) console.error('  - ' + f)
+process.exit(failed === 0 ? 0 : 1)