paperlint 3.1.0 → 3.1.1

package/skills/paper-pipeline/scripts/consumer.mutations.mjs

@@ -1,190 +0,0 @@
-/**
- * consumer.mutations.mjs — plant each defect `consumer.harness.mjs` claims to catch, and require
- * it to die BY ITS OWN assertion.
- *
- * Run: `node skills/paper-pipeline/scripts/consumer.mutations.mjs` (it rewrites `consumer.mjs` and
- * restores it, so it is not part of the plain test run).
- *
- * 🔴 WHY THIS ONE MATTERS MORE THAN MOST. Every resolution in `consumer.mjs` fails toward SILENCE:
- * a ledger under `node_modules` still accepts appends, a main guard that never fires still exits 0,
- * a root that does not exist still hashes to a stable value. That is exactly the shape a harness
- * cannot be seen catching — so the four cases below are the only evidence that its assertions can
- * fail at all. Each `expect` is the harness's OWN message for that defect, not a generic failure
- * string: a case killed by somebody else's assertion says nothing about the defect it planted.
- */
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { runMutations } from "../../../lib/mutation-driver.mjs";
-import { consumerRoot } from "./consumer.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SRC = join(HERE, "consumer.mjs");
-const HARNESS = join(HERE, "consumer.harness.mjs");
-
-const MUTATIONS = [
-  [
-    "a declared `null` is read as an absence",
-    [
-      [
-        SRC,
-        "if (declared !== undefined) {",
-        "if (declared !== undefined && declared !== null) {",
-      ],
-    ],
-    'a `"ledger": null` was accepted',
-    "the absence/keystroke distinction — a typed null silently picks a different file",
-  ],
-  [
-    "`node_modules` is detected by substring instead of by path segment",
-    [
-      [
-        SRC,
-        'return dir.split(sep).includes("node_modules");',
-        'return dir.includes("node_modules");',
-      ],
-    ],
-    "naming coincidence",
-    "a consumer whose own directory merely contains the word is refused its ledger",
-  ],
-  [
-    "the ledger default inside node_modules is no longer refused",
-    [
-      [
-        SRC,
-        "  if (insideNodeModules(hereDir))",
-        "  if (false && insideNodeModules(hereDir))",
-      ],
-    ],
-    "ledgerPath RETURNED A PATH INSIDE node_modules",
-    "the one guard against silent data loss: appends succeed until `npm ci` deletes them",
-  ],
-  [
-    "the main guard stops resolving the entry point's realpath",
-    [[SRC, "    real = realpathSync(entry);", "    real = entry;"]],
-    "isMain is false through a symlink",
-    "every CLI in this directory when a consumer runs it at the path its skills document",
-  ],
-
-  // ── the fourth carrier. Its defects are worse than the three above: the value is a PREFIX a
-  // caller filters prose with, so a wrong one matches nothing and every check built on it
-  // reports zero findings — the green zero this package has a dedicated guard against.
-  [
-    "a declared `null` scripts path is read as an absence",
-    [
-      [
-        SRC,
-        "const rel = declared === undefined ? DEFAULT_SCRIPTS_ROOT : declared;",
-        "const rel = declared ?? DEFAULT_SCRIPTS_ROOT;",
-      ],
-    ],
-    'a `"scripts": null` was accepted',
-    "the absence/keystroke distinction — a typed null is ignored and the default silently wins",
-  ],
-  [
-    "a scripts path inside node_modules is no longer refused",
-    [
-      [
-        SRC,
-        "  if (insideNodeModules(abs))",
-        "  if (false && insideNodeModules(abs))",
-      ],
-    ],
-    "scriptsRoot ACCEPTED a path inside node_modules",
-    "the guard against naming a path `npm ci` deletes and git does not track",
-  ],
-  [
-    "a scripts path that is not on disk is no longer refused",
-    [[SRC, "  if (!existsSync(abs))", "  if (false && !existsSync(abs))"]],
-    "scriptsRoot accepted a path that does not exist",
-    "the only net under the wrong prefix, whose symptom is zero findings and exit 0",
-  ],
-  [
-    "the scripts root is returned resolved instead of as declared",
-    [[SRC, "  return rel;", "  return abs;"]],
-    "scriptsRoot returned an ABSOLUTE path",
-    "prose comparison — every `startsWith` against a SKILL.md becomes false",
-  ],
-  [
-    "a declared trailing slash is no longer normalised",
-    [[SRC, 'const base = root.replace(/\\/+$/, "");', "const base = root;"]],
-    "a declared trailing slash doubled the separator",
-    "the one input a consumer types by habit, whose doubled prefix matches nothing",
-  ],
-  [
-    "the prefix loses its trailing separator",
-    [[SRC, "    prefix: `${base}/`,", "    prefix: `${base}`,"]],
-    "the prefix matched a sibling directory sharing the root's name",
-    "the boundary between the pipeline's scripts and a directory merely named like them",
-  ],
-
-  // ── `installedSkills` (paperlint#62). Its defects fail toward a WRONG ROSTER, not an error: a reader
-  // that does not follow links sees zero skills in every consumer; one that skips a dangling link
-  // reports a broken install as "not installed"; one that counts it hands out an unreadable skill.
-  [
-    "installed skills are listed by `Dirent.isDirectory()` again, which does not follow links",
-    [
-      [
-        SRC,
-        "  for (const name of readdirSync(dir)) {",
-        "  for (const dirent of readdirSync(dir, { withFileTypes: true })) {\n    const name = dirent.name;",
-      ],
-      [
-        SRC,
-        '    if (st.isDirectory() && existsSync(join(entry, "SKILL.md")))',
-        '    if (dirent.isDirectory() && existsSync(join(entry, "SKILL.md")))',
-      ],
-    ],
-    "a SYMLINKED skill was not counted as installed",
-    "every installed skill in every consumer — `paperlint init` makes links, and the evals refuse to start",
-  ],
-  [
-    "a dangling skill link is skipped silently",
-    [
-      [
-        SRC,
-        '      dangling.push({\n        name,\n        target: readlinkOr(entry),\n        cause: e.code ?? "error",\n      });',
-        "",
-      ],
-    ],
-    "a DANGLING skill link was silently accepted",
-    "the report of a broken install — a retired skill's stale link reads as one never installed",
-  ],
-  [
-    "a dangling skill link is counted as installed",
-    [
-      [
-        SRC,
-        '      dangling.push({\n        name,\n        target: readlinkOr(entry),\n        cause: e.code ?? "error",\n      });',
-        "      names.push(name);",
-      ],
-    ],
-    "a DANGLING skill link was silently accepted",
-    "the guarantee that every name returned has a SKILL.md a caller can open",
-  ],
-  [
-    "any directory counts as an installed skill",
-    [
-      [
-        SRC,
-        '    if (st.isDirectory() && existsSync(join(entry, "SKILL.md")))',
-        "    if (st.isDirectory())",
-      ],
-    ],
-    "installedSkills must return exactly the entries that lead to a directory holding SKILL.md",
-    "the definition of a skill — a helper directory beside the skills joins the roster",
-  ],
-];
-
-process.exit(
-  runMutations({
-    root: consumerRoot(),
-    runner: "vigiles",
-    cases: MUTATIONS.map(([name, edits, expect, disables]) => ({
-      name,
-      disables,
-      edits,
-      harness: HARNESS,
-      expect,
-    })),
-  }),
-);

package/skills/paper-pipeline/scripts/extract-ref-facts.mutations.mjs

@@ -1,54 +0,0 @@
-/**
- * extract-ref-facts.mutations.mjs — plant the defect `extract-ref-facts.harness.mjs` claims to catch, and require it to die.
- *
- * Run: `node skills/paper-pipeline/scripts/extract-ref-facts.mutations.mjs` (it rewrites the source and restores
- * it, so it is not part of the plain test run).
- *
- * WHY IT EXISTS. A harness whose success state is silence cannot be observed working: «it passed»
- * and «it cannot fail» produce identical output. Written 2026-09-12, when the mechanism moved into
- * this package and `scripts/run-mutations.mjs` reported this harness as one nothing could kill.
- *
- * ⚠️ HONEST SCOPE: ONE case. It kills the checker outright — the shape that makes every other
- * assertion in the harness vacuous at once — and that is the property worth holding first, not the
- * only one worth holding. Narrower cases were probed and left out DELIBERATELY: the assertions
- * they trip carry no message of their own (a bare deepEqual diff), so `expect` could only match
- * text any unrelated failure also prints, and a case killed by someone else's assertion is not
- * evidence about its own defect. Adding one means giving that assertion a message first.
- */
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { runMutations } from "../../../lib/mutation-driver.mjs";
-import { consumerRoot } from "./consumer.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SRC = join(HERE, "extract-ref-facts.mjs");
-const HARNESS = join(HERE, "extract-ref-facts.harness.mjs");
-
-const MUTATIONS = [
-  [
-    "the markdown reference list is never parsed",
-    [
-      [
-        SRC,
-        "export function parseMarkdownRefs(text) {",
-        "export function parseMarkdownRefs(text) {\n  if (1) return [];",
-      ],
-    ],
-    "heading must close the reference list",
-    "the markdown leg entirely — a paper whose bibliography is prose yields zero refs and no complaint",
-  ],
-];
-
-process.exit(
-  runMutations({
-    root: consumerRoot(),
-    runner: "vigiles",
-    cases: MUTATIONS.map(([name, edits, expect, disables]) => ({
-      name,
-      disables,
-      edits,
-      harness: HARNESS,
-      expect,
-    })),
-  }),
-);

package/skills/paper-pipeline/scripts/generated-code.mutations.mjs

@@ -1,254 +0,0 @@
-/**
- * generated-code.mutations.mjs — proof that every rule and every guard in `generated-code.mjs` is
- * watched FAILING. Run: `node .claude/skills/paper-pipeline/scripts/generated-code.mutations.mjs`
- *
- * This is not a test. It is the evidence behind the claim that the tests test something.
- *
- * WHY IT MATTERS MORE HERE THAN FOR A NORMAL CHECKER. Half of what this file asserts is that the
- * checker STAYS QUIET — on a seeded script, on a lowercase route, on a reused variable name. A quiet
- * assertion is the easiest kind to write vacuously: delete the rule it is guarding and the fixture
- * still passes, because a checker that does nothing is quiet about everything. Only a mutation can
- * tell those apart, and the ignore set has the same shape: an over-wide allow rule and a working one
- * produce identical output.
- *
- * WHAT IT DOES. For each rule, it neuters exactly that rule in the source, runs the harness, and
- * requires the harness to go RED at the named assertion. Then it restores the file.
- *
- * 🔴 The quiet cases need INVERTED mutations. Disabling a rule cannot make a "stays quiet" case go
- * red — it makes it quieter. So those rows LOOSEN the guard instead (drop the anchor, add the `i`
- * flag, accept any file mode), which is the mistake a future editor would actually make.
- *
- * The source is restored in a `finally`, and the run refuses to start on a dirty working tree.
- */
-import { runMutations } from "../../../lib/mutation-driver.mjs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { consumerRoot } from "./consumer.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = consumerRoot();
-const SRC = join(HERE, "generated-code.mjs");
-const HARNESS = join(HERE, "generated-code.harness.mjs");
-
-/** [name, what it disables or loosens, exact source substring, replacement, expected red assertion] */
-const MUTATIONS = [
-  // ── the three rules fire ──
-  [
-    "no-seed/rule",
-    "the unseeded-randomness rule",
-    "  if (DRAWS.test(code) && !SEEDS.test(src))",
-    "  if (false)",
-    "a sampling script with no seed passed",
-  ],
-  [
-    "no-seed/python-draws",
-    "recognising `random.sample` as a draw",
-    "\\brandom\\.(?:random|sample|",
-    "\\brandom\\.(?:random|nope|",
-    "a sampling script with no seed passed",
-  ],
-  [
-    "abs/rule",
-    "the hard-coded-absolute-path rule",
-    "  const abs = code.match(\n    new RegExp(ABS.source",
-    "  const abs = false && code.match(\n    new RegExp(ABS.source",
-    "a script that only runs on its author's laptop",
-  ],
-  [
-    "abs/home",
-    "recognising /home/ as an absolute path",
-    "(?:\\/home\\/|\\/Users\\/",
-    "(?:\\/nope\\/|\\/Users\\/",
-    "a script that only runs on its author's laptop",
-  ],
-  [
-    "inplace/rule",
-    "the in-place-overwrite rule",
-    "  const both = [...operands(code, READS)].filter((p) =>\n    operands(code, WRITES).has(p),\n  );",
-    "  const both = [];",
-    "a script that clobbers its own input passed",
-  ],
-  [
-    "inplace/argv",
-    "the argv form of an in-place rewrite",
-    "  /open\\(\\s*((?:sys\\.argv|process\\.argv)\\[\\d\\])\\s*\\)/g,",
-    "  /never-matches-anything-x/g,",
-    "argv form of an in-place rewrite was not caught",
-  ],
-
-  // ── the guards that keep it quiet on correct code (LOOSENED, not disabled) ──
-  [
-    "quiet/seed-recognised",
-    "recognising that a seed was set at all",
-    "  if (DRAWS.test(code) && !SEEDS.test(src))",
-    "  if (DRAWS.test(code))",
-    "a properly seeded script (explicit) was reported as unseeded",
-  ],
-  // Disables BOTH alternations that could credit a seed threaded through argparse. Naming only
-  // `--seed` left the row alive on `\bSEED\b`, and a partial disable that another alternation
-  // covers is the same as no disable at all.
-  [
-    "quiet/seed-argparse",
-    "recognising a seed threaded through argparse (the leading-\\b regression)",
-    "--seed|\\bSEED\\b|Random",
-    "\\b--seed|\\bNOSUCHSEED\\b|Random",
-    "a properly seeded script (argparse) was reported as unseeded",
-  ],
-  [
-    "quiet/abs-anchor",
-    "the left anchor that keeps a RELATIVE third-party path out",
-    "const ABS =\n  /(?<![\\w./-])(?:",
-    "const ABS =\n  /(?:",
-    "reported as absolute local paths",
-  ],
-  [
-    "quiet/abs-case",
-    "case sensitivity, so an Express route /users/ stops matching /Users/",
-    "|[A-Z]:\\\\\\\\?[A-Za-z])/;",
-    "|[A-Z]:\\\\\\\\?[A-Za-z])/i;", // ← only bites since ABS.flags is threaded through
-    "reported as absolute local paths",
-  ],
-  [
-    "quiet/read-mode",
-    "requiring a READ to not be a write (the prototype's vacuity bug)",
-    "  /open\\(\\s*(['\"])([^'\"]+)\\1\\s*(?:,\\s*(['\"])r[b+]*\\3\\s*)?\\)/g,",
-    "  /open\\(\\s*(['\"])([^'\"]+)\\1\\s*(?:,[^)]*)?\\)/g,",
-    "was reported as clobbering its input",
-  ],
-  // 🔴 SPANS BOTH ARRAYS ON PURPOSE. Loosening only the READ side survived: the WRITE side still
-  // demanded a quoted literal, so no operand could ever pair and the verdict did not move. A
-  // mutation that cannot change the answer is not a mutation, and this is the second one this file
-  // caught in itself.
-  [
-    "quiet/literal-only",
-    "matching literals rather than operand expressions (17 false positives)",
-    "  /readFileSync\\(\\s*(['\"])([^'\"]+)\\1/g,\n  /Path\\(\\s*(['\"])([^'\"]+)\\1\\s*\\)\\s*\\.read/g,\n  /open\\(\\s*((?:sys\\.argv|process\\.argv)\\[\\d\\])\\s*\\)/g,\n];\nconst WRITES = [\n  /open\\(\\s*(['\"])([^'\"]+)\\1\\s*,\\s*['\"][wa]/g,\n  /writeFileSync\\(\\s*(['\"])([^'\"]+)\\1/g,",
-    "  /readFileSync\\(\\s*([^,)]+?)\\s*[,)]/g,\n  /Path\\(\\s*(['\"])([^'\"]+)\\1\\s*\\)\\s*\\.read/g,\n  /open\\(\\s*((?:sys\\.argv|process\\.argv)\\[\\d\\])\\s*\\)/g,\n];\nconst WRITES = [\n  /open\\(\\s*(['\"])([^'\"]+)\\1\\s*,\\s*['\"][wa]/g,\n  /writeFileSync\\(\\s*([^,)]+?)\\s*,/g,",
-    "reused across two loops was mistaken for dataflow",
-  ],
-
-  // ── the boundary with check-anon.sh ──
-  [
-    "bundle/excluded",
-    "excluding the released bundle, which check-anon.sh cat. 5 owns",
-    "      if (depth === 1 && name === bundleName) {\n        swallowed.get(RULE[0]).push(name);\n        continue;\n      }",
-    "      if (false) {\n        swallowed.get(RULE[0]).push(name);\n        continue;\n      }",
-    "reported an absolute path inside the RELEASED bundle",
-  ], // case 8, its own assertion
-  [
-    "bundle/named-in-ledger",
-    "naming that exclusion in the ledger",
-    '  [\n    "the released bundle — `check-anon.sh` cat. 5 owns it, and it asks a different question there " +\n      "(does it leak an identity, not will it run elsewhere)",\n    [],\n  ],',
-    '  [\n    "a tree we do not enter",\n    [],\n  ],',
-    "the boundary invisible",
-  ],
-
-  // ── the ignore set ──
-  [
-    "allow/applied",
-    "applying an allow row at all",
-    "    if (reason !== undefined) {\n      ignored.push(",
-    "    if (false) {\n      ignored.push(",
-    "the allowed kind still fired",
-  ],
-  [
-    "allow/per-kind",
-    "scoping an allowance to ONE KIND rather than to the whole file",
-    "    const reason = allowed.get(key) ?? allowed.get(`${relative(repro, f)}\\t*`);",
-    "    const reason = allowed.get(key) ?? [...allowed.entries()].find(([k]) => k.startsWith(relative(repro, f)))?.[1];",
-    "also silenced its unseeded sampling",
-  ],
-  [
-    "allow/reason-printed",
-    "printing each allowance's reason",
-    "for (const [key, reason] of ignored) ledger.push(`       ${key}  →  ${reason}`);",
-    "for (const [key, reason] of ignored) ledger.push(`       ${key}`);",
-    "its reason was not printed",
-  ],
-  [
-    "allow/stale",
-    "reporting a row that names no script",
-    "  if (!live.has(key))",
-    "  if (false)",
-    "sat unreported, so the list never shrinks",
-  ],
-  [
-    "allow/empty-said",
-    "saying so when nothing is being waved through",
-    'if (!ignored.length) ledger.push("       (nothing is being waved through)");',
-    'if (false) ledger.push("       (nothing is being waved through)");',
-    "an empty allow file printed nothing",
-  ],
-
-  // ── WHERE repro/ IS, and what silence is allowed to mean ──
-  // 🔴 These three guard a defect that was LIVE until 2026-08-26 and produced no symptom: pointed
-  // at `<paper-e>`, the check exited 0 with no output while 18 findings sat in
-  // `typed-shell/repro/`. A missed directory is worse than a missed finding, because it is
-  // reported in exactly the words of a clean paper.
-  [
-    "scope/nested-root",
-    "looking for repro/ one level below the paper directory",
-    '      .map((e) => join(dir, e.name, "repro"))',
-    '      .map((e) => join(dir, e.name, "nope"))',
-    "a repro/ one level below the paper directory was not scanned",
-  ],
-  [
-    "scope/loud-empty",
-    "saying so when there is no repro/ to scan (silence would read as clean)",
-    "  if (!flagsOnly)\n    console.log(\n      `🧪 generated-code — 0 finding(s) in ${dir}\\n   NOTHING WAS SCANNED:",
-    "  if (false)\n    console.log(\n      `🧪 generated-code — 0 finding(s) in ${dir}\\n   NOTHING WAS SCANNED:",
-    "produced no output at all",
-  ],
-  [
-    "scope/second-root-named",
-    "naming a SECOND repro/ root in the ledger instead of dropping it",
-    "for (const other of roots.slice(1))\n  swallowed.get(RULE[3]).push(relative(dir, other));",
-    "for (const other of [])\n  swallowed.get(RULE[3]).push(relative(dir, other));",
-    "was dropped without being named",
-  ],
-
-  // ── the machine-readable contract with run-mechanical.mjs ──
-  [
-    "out/stated-count",
-    "the stated finding count in the header",
-    "const header = `🧪 generated-code — ${findings.length} finding(s) in ${dir}`;",
-    "const header = `🧪 generated-code — ${dir}`;",
-    "does not state `— 0 finding(s)`",
-  ],
-  [
-    "out/ledger-on-clean",
-    "printing the ignore ledger when there are no findings",
-    '  console.log(\n    "   every analysis script seeds its randomness, names only relative paths, and does not clobber its input",\n  );\n  ledger.forEach((l) => console.log(l));',
-    '  console.log(\n    "   every analysis script seeds its randomness, names only relative paths, and does not clobber its input",\n  );',
-    // Killed by case 8's ledger assertion rather than case 11's: case 8 is also a 0-finding
-    // report-mode run and it runs first. Both assert the property; the row records WHICH one caught
-    // it so this is not misread as an off-target kill.
-    "the boundary invisible",
-  ],
-  [
-    "out/flags-quiet",
-    "the silence of --flags-only on a clean tree",
-    "if (!flagsOnly) {\n  console.log(header);",
-    "if (true) {\n  console.log(header);",
-    "--flags-only printed something about a clean tree",
-  ],
-];
-
-// The table above is DATA about this checker; the engine below is shared with the other mutation
-// files (`mutation-driver.mjs`). The split gave this file two protections it never had: the no-op
-// guard (a replacement equal to the original leaves a green harness proving nothing) and one retry
-// on a non-kill (a flake reported as a survivor sends the next reader to rewrite a working
-// assertion). It also refuses to start when a named harness does not exist — the defect that made
-// three files report SURVIVED for every case after the 2026-08-11 colocation.
-process.exit(
-  runMutations({
-    root: ROOT,
-    cases: MUTATIONS.map(([name, disables, find, replace, expect]) => ({
-      name,
-      disables,
-      edits: [[SRC, find, replace]],
-      harness: HARNESS,
-      expect,
-    })),
-  }),
-);

package/skills/paper-pipeline/scripts/pipeline-check.mutations.mjs

@@ -1,54 +0,0 @@
-/**
- * pipeline-check.mutations.mjs — plant the defect `pipeline-check.harness.mjs` claims to catch, and require it to die.
- *
- * Run: `node skills/paper-pipeline/scripts/pipeline-check.mutations.mjs` (it rewrites the source and restores
- * it, so it is not part of the plain test run).
- *
- * WHY IT EXISTS. A harness whose success state is silence cannot be observed working: «it passed»
- * and «it cannot fail» produce identical output. Written 2026-09-12, when the mechanism moved into
- * this package and `scripts/run-mutations.mjs` reported this harness as one nothing could kill.
- *
- * ⚠️ HONEST SCOPE: ONE case. It kills the checker outright — the shape that makes every other
- * assertion in the harness vacuous at once — and that is the property worth holding first, not the
- * only one worth holding. Narrower cases were probed and left out DELIBERATELY: the assertions
- * they trip carry no message of their own (a bare deepEqual diff), so `expect` could only match
- * text any unrelated failure also prints, and a case killed by someone else's assertion is not
- * evidence about its own defect. Adding one means giving that assertion a message first.
- */
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { runMutations } from "../../../lib/mutation-driver.mjs";
-import { consumerRoot } from "./consumer.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SRC = join(HERE, "pipeline-check.mjs");
-const HARNESS = join(HERE, "pipeline-check.harness.mjs");
-
-const MUTATIONS = [
-  [
-    "check() goes blind",
-    [
-      [
-        SRC,
-        "export function check({ sections, header }, { sourceDate, today, dir }) {",
-        "export function check({ sections, header }, { sourceDate, today, dir }) {\n  if (1) return [];",
-      ],
-    ],
-    "stale-continuous: wrong finding set",
-    "every gate-staleness finding: a PIPELINE-STATUS that reports nothing reads as a clean one",
-  ],
-];
-
-process.exit(
-  runMutations({
-    root: consumerRoot(),
-    runner: "vigiles",
-    cases: MUTATIONS.map(([name, edits, expect, disables]) => ({
-      name,
-      disables,
-      edits,
-      harness: HARNESS,
-      expect,
-    })),
-  }),
-);

package/skills/paper-pipeline/scripts/population-map.mutations.mjs

@@ -1,65 +0,0 @@
-/**
- * population-map.mutations.mjs — plant each defect `population-map.harness.mjs` claims to catch, and require it to die.
- *
- * Run: `node skills/paper-pipeline/scripts/population-map.mutations.mjs` (~1 min; it rewrites the source and
- * restores it, so it is not part of the plain test run).
- *
- * WHY IT EXISTS. A harness whose success state is silence cannot be observed working: «it passed»
- * and «it cannot fail» produce identical output. This battery is the difference. It was written on
- * 2026-09-12, when the mechanism moved into this package and `scripts/run-mutations.mjs` reported
- * this harness as one nothing could kill — a gap that had been open for as long as the harness had
- * existed, invisible because nothing asked the question.
- *
- * Every replacement below differs from the text it replaces (the driver refuses a no-op, which
- * would leave a green harness proving nothing), every case names the assertion that must fire, and
- * the driver verifies the patch actually landed before believing a result.
- */
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { runMutations } from "../../../lib/mutation-driver.mjs";
-import { consumerRoot } from "./consumer.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SRC = join(HERE, "population-map.mjs");
-const HARNESS = join(HERE, "population-map.harness.mjs");
-
-const MUTATIONS = [
-  [
-    "findings() goes blind",
-    [
-      [
-        SRC,
-        "export function findings(md, tsv) {",
-        "export function findings(md, tsv) {\n  if (1) return [];",
-      ],
-    ],
-    "population-map.selftest.mjs failed",
-    "the whole checker: a registry map that reports nothing reads exactly like a clean paper",
-  ],
-  [
-    "the registry is never parsed",
-    [
-      [
-        SRC,
-        "export function parseRegistry(tsv) {",
-        "export function parseRegistry(tsv) {\n  if (1) return [];",
-      ],
-    ],
-    "population-map.selftest.mjs failed",
-    "every row-level finding — an empty registry makes stale rows and dangling refs unrepresentable",
-  ],
-];
-
-process.exit(
-  runMutations({
-    root: consumerRoot(),
-    runner: "vigiles",
-    cases: MUTATIONS.map(([name, edits, expect, disables]) => ({
-      name,
-      disables,
-      edits,
-      harness: HARNESS,
-      expect,
-    })),
-  }),
-);