paperlint 3.0.0 → 3.1.1

package/src/cli.mutations.mjs

@@ -1,414 +0,0 @@
-/**
- * Battery for the utility. Three of the first five mutations reintroduce defects it ALREADY
- * had, found by the first run rather than by reading — so without these assertions the
- * regression would be silent.
- */
-import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
-import { runMutations } from "../lib/mutation-driver.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..");
-const CLI = join(HERE, "cli.ts");
-const HARNESS = join(HERE, "cli.harness.mjs");
-// The `bin/paperlint.mjs` shim — the package's EXECUTABLE file, and after the move to TypeScript the
-// "was I run or was I imported" check lives right there: `dist/cli.js` is now always imported,
-// so a mutation in it about the symlink proves nothing. The first run after the move showed
-// this literally — the mutation SURVIVED, and it looked like a hole in the harness, when the
-// hole was in what the mutation was aimed at.
-const SHIM = join(HERE, "..", "bin", "paperlint.mjs");
-// `init` stopped being twenty lines inside `cli.ts` and became its own module: it has four
-// decisions, and each must be able to break in a way that EXACTLY its own assertion notices.
-const INIT = join(HERE, "init.ts");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "the main-module check goes back to comparing STRINGS",
-        harness: HARNESS,
-        expect:
-          "through a SYMLINK the utility works, rather than silently exiting zero",
-        disables:
-          "the only way a consumer ever calls the utility. npm puts a SYMLINK in .bin, for " +
-          "which process.argv[1] and import.meta.url are different paths; comparing strings " +
-          "makes the condition false and the utility SILENTLY exits zero. A direct " +
-          "`node bin/paperlint.mjs` still works, meanwhile, so the defect is invisible in exactly the " +
-          "way it is normally checked",
-        edits: [
-          [
-            SHIM,
-            "if (isMain(import.meta.url))",
-            "if (import.meta.url === `file://${process.argv[1]}`)",
-          ],
-        ],
-      },
-      {
-        name: "argv[0] unconditionally becomes the command again",
-        harness: HARNESS,
-        expect: "`--help` as the first argument — is a FLAG, not a command",
-        disables:
-          "parsing a flag in the command position. The real defect: `paperlint --help` used to " +
-          'answer "unknown command `--help`" — i.e. the very first command a new user types ' +
-          "told them it did not exist",
-        edits: [
-          [
-            CLI,
-            'if (rest[0] && !rest[0].startsWith("-")) out.cmd = rest.shift() ?? null;',
-            "out.cmd = rest.shift() ?? null;",
-          ],
-        ],
-      },
-      {
-        name: "a valueless flag silently turns into a default again",
-        harness: HARNESS,
-        expect: "a flag with no value — a FAILURE, not a silent default",
-        disables:
-          'the distinction between "no config was set" and "a config was set, but its value ' +
-          'got lost". The latter happens from a typo and from a CI substitution collapsing to ' +
-          "empty, and without a failure the run falls into autodiscovery and lints the WRONG " +
-          "file without saying a word about it",
-        edits: [[CLI, "  if (a.missingValue) {", "  if (false) {"]],
-      },
-      {
-        name: "no papers where the config points reads as a clean run",
-        harness: HARNESS,
-        expect:
-          "`lint` with NO path, no config and no papers/ refuses and names BOTH ways out",
-        disables:
-          "the guard that makes the `papers` default safe. Without it, a project whose papers " +
-          "live elsewhere gets a run over an empty or missing directory instead of the sentence " +
-          "naming both ways out",
-        edits: [[CLI, "    if (empty !== undefined) {", "    if (false) {"]],
-      },
-      {
-        name: "the GUARD AGAINST A GREEN ZERO is removed",
-        harness: HARNESS,
-        expect: "an empty set — a FAILURE, not a green zero",
-        disables:
-          'the distinction between "no findings" and "not one rule got a single file". These ' +
-          "two states are byte-for-byte identical in the output, and the second reads as success",
-        edits: [[CLI, "if (results.length === 0) {", "if (false) {"]],
-      },
-      {
-        name: "ESLint's exception stops being caught again",
-        harness: HARNESS,
-        expect:
-          "the utility does NOT let an exception escape — a failure is declared by the exit code",
-        disables:
-          "the explainability of a failure. The real defect: on an empty set ESLint THROWS a " +
-          "NoFilesFoundError, the guard never lived long enough to reach its own check, and " +
-          "instead of a message a stack trace flew out of the depths of eslint-helpers.js",
-        edits: [
-          [
-            CLI,
-            "    if (isEmptySet(e)) results = [];\n    else throw e;",
-            "    throw e;",
-          ],
-        ],
-      },
-      {
-        name: "the declaration stops reaching paperlint.json again",
-        harness: HARNESS,
-        expect:
-          "🔴 THE DECLARATION SHOWS UP IN paperlint.json — the file the hooks read",
-        disables:
-          "the whole reason this command was rewritten (#33). A hook does not import code and " +
-          "cannot walk up the tree — it reads a path it is able to name, and that path is the " +
-          "root paperlint.json. Without writing there, the install looks like it succeeded, " +
-          "while `paper-edit-guard` guards the default",
-        edits: [
-          [
-            INIT,
-            "  writeFileSync(\n    path,\n    JSON.stringify(\n      { ...settings, [PAPERS_DIR_FIELD]: choice.papers },",
-            "  (() => {})(\n    path,\n    JSON.stringify(\n      { ...settings, [PAPERS_DIR_FIELD]: choice.papers },",
-          ],
-        ],
-      },
-      {
-        name: "the papers directory is GUESSED again instead of measured",
-        harness: HARNESS,
-        expect:
-          "and it says HOW it was measured — otherwise a guess reads as a fact",
-        disables:
-          "measuring instead of guessing. The declaration still gets WRITTEN — i.e. the failure " +
-          "is one-sided and points toward a confident wrong answer: the file says `papers`, the " +
-          "papers live somewhere else, and both commands stay silent about it",
-        edits: [
-          [
-            INIT,
-            "  const candidates = detectPapers(root);",
-            "  const candidates = [];",
-          ],
-        ],
-      },
-      {
-        name: "someone else's value in the declaration gets overwritten again",
-        harness: HARNESS,
-        expect:
-          "🔴 an already-declared value stays intact byte for byte — silently replacing a setting is worse than doing nothing",
-        disables:
-          "the ban on silently replacing a consumer's setting. They keep trusting the old " +
-          "value, because nobody told them it changed",
-        edits: [
-          [
-            INIT,
-            '    if (existing !== undefined)\n      return { status: "kept"',
-            '    if (false)\n      return { status: "kept"',
-          ],
-        ],
-      },
-      {
-        name: "the default that was taken stops being named",
-        harness: HARNESS,
-        expect:
-          "🔴 not a terminal — the question is NOT asked, and the default taken is NAMED",
-        disables:
-          'half the "don\'t ask in CI" rule: not asking is not enough, it must say WHICH ' +
-          'default was taken. A silent skip reads as "there was never a question"',
-        edits: [
-          [
-            INIT,
-            "      `  · ${why}, so nothing was asked. Default taken: NO file written.`,",
-            "      `  · skipped`,",
-          ],
-        ],
-      },
-      {
-        name: "the answer to the question is ignored",
-        harness: HARNESS,
-        expect:
-          "🔴 the human's answer DECIDES, it does not just decorate the output",
-        disables:
-          "the point of the one question that gets asked. The prompt is printed, the answer is " +
-          "read and discarded — i.e. there is an interface with no decision behind it",
-        edits: [
-          [
-            INIT,
-            '  const picked = candidates[Number((answer ?? "").trim()) - 1];',
-            "  const picked = candidates[0];",
-          ],
-        ],
-      },
-      {
-        name: "an interrupted question crashes the command again",
-        harness: HARNESS,
-        expect:
-          "🔴 an interrupted question does NOT crash the command — it means the default",
-        disables:
-          "handling Ctrl+D. MEASURED 09-18 on a real pseudo-terminal: readline's `question()` " +
-          "REJECTS with `AbortError: Aborted with Ctrl+D`, and the exception used to escape " +
-          "AFTER the declaration had been written — the install both succeeded and looked like " +
-          "a crash",
-        edits: [
-          [
-            INIT,
-            "  try {\n    return await ask(question);\n  } catch {\n    return null;\n  }",
-            "  return await ask(question);",
-          ],
-        ],
-      },
-      {
-        name: "init stops ending with doctor",
-        harness: HARNESS,
-        expect:
-          "init ends with doctor's report: the install vouches for its OWN state",
-        disables:
-          'the one thing that distinguishes "installed" from "actually guarding": ' +
-          "`paper-edit-guard` is silent both when it works and when it guards nothing. Without " +
-          "the final doctor, init reports cheerfully on a state it never measured",
-        edits: [
-          [
-            INIT,
-            "  const code = doctor({ log, cwd: root, projectDir: root, run, cliPapers });",
-            "  const code = 0;",
-          ],
-        ],
-      },
-      {
-        name: "a paperlint.json is written for the default again",
-        harness: HARNESS,
-        expect:
-          "🔴 nothing to measure — the default is taken, and NO paperlint.json is written for it",
-        disables:
-          "the rule that a project on the defaults needs no config file. Every init would leave " +
-          "a file restating the default, and a reader could no longer tell a choice from a default",
-        edits: [
-          [
-            INIT,
-            '  if (choice.papers === DEFAULT_PAPERS_ROOT)\n    return { status: "default"',
-            '  if (false)\n    return { status: "default"',
-          ],
-        ],
-      },
-      {
-        name: "a missing program is named with no remedy",
-        harness: HARNESS,
-        expect:
-          "🔴 and it carries the INSTALL COMMAND — a remedy, not just a diagnosis",
-        disables:
-          'the second half of the "install nothing on the user\'s behalf" rule. A diagnosis ' +
-          "with no remedy leaves the person exactly where they stood: the program is missing, " +
-          "and what to type is unknown",
-        edits: [
-          [
-            INIT,
-            "    for (const cmd of [...new Set(missing.map((p) => p.install))])\n      log(`        ${cmd}`);",
-            "    void missing;",
-          ],
-        ],
-      },
-      {
-        name: "absences stop being named by name",
-        harness: HARNESS,
-        expect: "every absence is NAMED, and the count matches the names",
-        disables:
-          'the link between the NUMBER and the NAMES in one line. "Programs are missing" with ' +
-          "no names means going to hunt for them in another report, and a counter with no names " +
-          "is exactly the counter that promises coverage and renders no verdict",
-        edits: [
-          [
-            INIT,
-            '    log(\n      `  ✗ ${String(missing.length)} of ${String(PROGRAMS.length)} missing: ` +\n        missing.map((p) => p.bin).join(", "),\n    );',
-            "    log(`  ✗ some programs are missing`);",
-          ],
-        ],
-      },
-      {
-        name: "the utility stops reading paperlint.json",
-        harness: HARNESS,
-        expect:
-          "🔴 THE UTILITY READS THE DECLARATION FROM paperlint.json — the file `paperlint init` writes and the hooks read",
-        disables:
-          "the link between the install command and the check command. `init` writes the " +
-          "declaration into paperlint.json, while `lint` would run on the default — right after " +
-          "install it reports on a directory the papers are not in",
-        edits: [
-          [
-            CLI,
-            "  const configPath = existsSync(found) ? found : null;",
-            "  const configPath = existsSync(found) ? null : null;",
-          ],
-        ],
-      },
-      {
-        name: "init stops naming the skills it skipped",
-        harness: HARNESS,
-        expect: "a skipped skill is NAMED with what occupies it",
-        disables:
-          "the only way a consumer learns WHICH skill is missing from Claude Code. A count of " +
-          "skipped entries says something is wrong and not what, so nobody goes to fix it",
-        edits: [
-          [
-            INIT,
-            '    for (const l of skipped)\n      out.push(`        ${l.name} — ${l.reason ?? "occupied"}`);',
-            "",
-          ],
-        ],
-      },
-      {
-        name: "a skipped skill link fails init",
-        harness: HARNESS,
-        expect: "a name init refused to take does not fail the install",
-        disables:
-          "init being safe to run on a real project. A consumer who keeps their own skill under " +
-          "the same name would get a red install for a decision init itself respected",
-        edits: [
-          [
-            INIT,
-            "  for (const line of reportSkillLinks(link(root), here)) log(line);",
-            '  const linked = link(root);\n  for (const line of reportSkillLinks(linked, here)) log(line);\n  if (linked.ok && linked.links.some((l) => l.status === "foreign")) return 2;',
-          ],
-        ],
-      },
-
-      {
-        name: "CI stops counting as 'no human'",
-        harness: HARNESS,
-        expect: "CI set → NOT interactive",
-        disables:
-          "the one signal a CI runner with a pseudo-terminal gives. init would print a question " +
-          "into a log nobody reads and wait for an answer that never comes",
-        edits: [
-          [
-            INIT,
-            '  if (env["CI"]) return { interactive: false, why: "CI is set" };\n',
-            "",
-          ],
-        ],
-      },
-      {
-        name: "stdout is no longer consulted",
-        harness: HARNESS,
-        expect: "stdout piped",
-        disables:
-          "the agent case. An agent piping init's output has a terminal-less stdout; with only " +
-          "stdin checked it is asked a question it will never see",
-        edits: [
-          [
-            INIT,
-            '  if (!stdoutTTY)\n    return { interactive: false, why: "stdout is not a terminal" };\n',
-            "",
-          ],
-        ],
-      },
-      {
-        name: "without a human the hooks default to NO",
-        harness: HARNESS,
-        expect: "without a human the hooks default to YES",
-        disables:
-          "the install an agent performs. The agent cannot type /plugin and is never asked, so a " +
-          "NO default leaves every agent-made install without the edit guard, silently",
-        edits: [
-          [
-            INIT,
-            '  if (!hooks) return { status: "skipped" };',
-            '  if (!hooks || !interactive) return { status: "skipped" };',
-          ],
-        ],
-      },
-      {
-        name: "a human's no is ignored",
-        harness: HARNESS,
-        expect: "and a no is respected",
-        disables:
-          "the question itself. A prompt whose answer does not decide anything is decoration, " +
-          "and the file is written into a repository whose owner said no",
-        edits: [
-          [
-            INIT,
-            '    if (answer === "n" || answer === "no") return { status: "declined" };',
-            '    if (false) return { status: "declined" };',
-          ],
-        ],
-      },
-      {
-        name: "a first paper is offered where one already exists",
-        harness: HARNESS,
-        expect:
-          "a papers directory that already holds a paper is not offered another",
-        disables:
-          "the condition that makes the offer an offer. Every re-run of init on a working project " +
-          "would ask for a new paper",
-        edits: [
-          [
-            INIT,
-            "  if (wanted === null && !hasPaper && interactive && createPaper) {",
-            "  if (wanted === null && interactive && createPaper) {",
-          ],
-        ],
-      },
-      {
-        name: "the project's paper template is linted as a paper",
-        harness: HARNESS,
-        expect: "the project's paper TEMPLATE directory is ignored",
-        disables:
-          "the override slot `paperlint new` reads. Flat config does not skip dot-directories, so a " +
-          "richer house template — placeholder stages and all — would fail every `paperlint lint`",
-        edits: [[CLI, '    { ignores: ["**/.template/"] },\n', ""]],
-      },
-    ],
-  }),
-);

package/src/doctor.mutations.mjs

@@ -1,175 +0,0 @@
-/**
- * Battery for `paperlint doctor`.
- *
- * The subject here is unusual and therefore fragile: doctor is a check ABOUT A CHECK. Broken,
- * it prints a column of checkmarks and exits zero — i.e. it fails in exactly the way it was
- * written to catch. Every case below reintroduces one of those silent failures.
- */
-import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
-import { runMutations } from "../lib/mutation-driver.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..");
-const SRC = join(HERE, "doctor.ts");
-const HARNESS = join(HERE, "doctor.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "comparing the two roots stops meaning anything",
-        harness: HARNESS,
-        expect: "writes pass the guard unseen",
-        disables:
-          "the only reason this command exists. A mismatch between what the CLI lints and what " +
-          "the hook guards is a silent hole: both sides look installed and green, while writes " +
-          "into real papers pass the gate unseen",
-        edits: [
-          [
-            SRC,
-            "    const same = resolve(root, cliPapers) === resolve(root, hookSays);",
-            "    const same = true;",
-          ],
-        ],
-      },
-      {
-        name: "the hook's root is retold instead of asked for",
-        harness: HARNESS,
-        expect: "doctor prints EXACTLY what the hook returned",
-        disables:
-          "the defense against a SECOND COPY OF THE LOGIC — exactly the defect this command " +
-          "exists to report. A retelling drifts from the original silently and prints a " +
-          "confident wrong answer: here it loses the trailing-slash trim the hook does on purpose",
-        edits: [
-          [
-            SRC,
-            '  const hookRoot = papersRoot(raw ?? "{}");',
-            '  const hookRoot = raw === null ? "papers" : (() => { try { return JSON.parse(raw)?.papersDir ?? "papers"; } catch { return "papers"; } })();',
-          ],
-        ],
-      },
-      {
-        name: "a missing external program starts failing the run",
-        harness: HARNESS,
-        expect: "a missing tex install does NOT fail the run",
-        disables:
-          "the distinction between a fact and a verdict. Which programs are needed depends on " +
-          "which skills you use; a command that fails on advice gets piped into `|| true` or " +
-          "/dev/null entirely, taking the real binary findings it was written for down with it",
-        edits: [
-          [
-            SRC,
-            "      out.push(`      ${p.install}`);",
-            "      out.push(`      ${p.install}`);\n      bad++;",
-          ],
-        ],
-      },
-      {
-        name: "detection loses the root and returns the papers themselves",
-        harness: HARNESS,
-        expect: "finds the root by a marker inside a subdirectory",
-        disables:
-          "the whole point of the hint. A config pointing at ONE document instead of a " +
-          "directory passes every check and lints one paper out of ten — while reporting clean",
-        edits: [
-          [
-            SRC,
-            "      if (isPapersRoot) hits.push(relative(cwd, here));",
-            "      if (isPapersRoot) hits.push(...children.filter((c) => c.isDirectory()).map((c) => relative(cwd, join(here, c.name))));",
-          ],
-        ],
-      },
-      {
-        name: "the papers themselves get mixed into the found root",
-        harness: HARNESS,
-        expect: "it is the ROOT, not the paper itself",
-        disables:
-          "the distinction between a papers directory and a paper. The root stays in the list, " +
-          'so the neighboring "found by marker" check notices nothing — while a config built ' +
-          "from such a hint points at one document and lints one paper out of ten, reporting clean",
-        edits: [
-          [
-            SRC,
-            "      if (isPapersRoot) hits.push(relative(cwd, here));",
-            "      if (isPapersRoot) hits.push(relative(cwd, here), ...children.filter((c) => c.isDirectory()).map((c) => relative(cwd, join(here, c.name))));",
-          ],
-        ],
-      },
-      {
-        name: "the walk stops skipping node_modules",
-        harness: HARNESS,
-        expect: "node_modules is not searched",
-        disables:
-          "the boundary between your own papers and someone else's. Any installed dependency " +
-          "carrying paper examples gets mistaken for the consumer's directory, and the hint " +
-          "points the config into node_modules",
-        edits: [
-          [
-            SRC,
-            'const skip = new Set(["node_modules", ".git", "dist", "_build", ".claude"]);',
-            "const skip = new Set();",
-          ],
-        ],
-      },
-      {
-        name: "an unparsable paperlint.json is reported as all-clear",
-        harness: HARNESS,
-        expect: "an unparsable paperlint.json — a FAILURE",
-        disables:
-          "the one failure left in the settings file: while it does not parse, the edit guard " +
-          "refuses every Bash command. A doctor that counts it as fine sends the reader looking " +
-          "everywhere but the file",
-        edits: [
-          [
-            SRC,
-            "        `      the edit guard refuses every Bash command until it parses — fix it with Edit or Write`,\n      ],\n      bad: 1,",
-            "        `      the edit guard refuses every Bash command until it parses — fix it with Edit or Write`,\n      ],\n      bad: 0,",
-          ],
-        ],
-      },
-      {
-        name: "an unlinked skill is folded into the checkmark",
-        harness: HARNESS,
-        expect: "an unlinked skill is NAMED",
-        disables:
-          "the one place a consumer learns that `/paper-pipeline` is missing. Claude Code does not " +
-          "look in node_modules, so an install without links has no skills at all and says nothing",
-        edits: [
-          [
-            SRC,
-            '    const gaps = links.links.filter((l) => l.status !== "present");',
-            '    const gaps = links.links.filter((l) => l.status === "foreign");',
-          ],
-        ],
-      },
-      {
-        name: "an unlinked skill starts failing the run",
-        harness: HARNESS,
-        expect: "an unlinked skill does NOT fail the run",
-        disables:
-          "the line between a fact and a verdict. A consumer who keeps their own skill under the " +
-          "same name would get a red doctor — and a red `init` — for a decision init itself respected",
-        edits: [
-          [
-            SRC,
-            "      out.push(\n        `      \\`npx paperlint init\\` links the missing ones; it never replaces an entry it did not make`,\n      );",
-            "      out.push(\n        `      \\`npx paperlint init\\` links the missing ones; it never replaces an entry it did not make`,\n      );\n      bad++;",
-          ],
-        ],
-      },
-      {
-        name: "a .template child makes a papers root",
-        harness: HARNESS,
-        expect:
-          "a directory whose only marked child is .template/ is NOT a papers root",
-        disables:
-          "the override slot being invisible to discovery. `paperlint init` in a project that has only " +
-          "a house template would declare the template's parent as the papers directory, measured",
-        edits: [[SRC, '          !c.name.startsWith(".") &&\n', ""]],
-      },
-    ],
-  }),
-);

package/src/hooks-settings.mutations.mjs

@@ -1,99 +0,0 @@
-/**
- * Battery for `hooks-settings.ts`.
- *
- * Every case reintroduces a way the hooks end up wired wrong while every report stays green:
- * twice (a guard that runs two times says nothing about it), rewritten on every run (a committed
- * file that churns for nothing), or reported as fine when doctor was asked about the wrong thing.
- */
-import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
-import { runMutations } from "../lib/mutation-driver.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..");
-const SRC = join(HERE, "hooks-settings.ts");
-const HARNESS = join(HERE, "hooks-settings.harness.mjs");
-
-process.exit(
-  runMutations({
-    root: ROOT,
-    runner: "node",
-    cases: [
-      {
-        name: "every spelling of the bin counts as ours",
-        harness: HARNESS,
-        // The spelling truth table is the first owner: `npx paperlint hook …` must read as NOT ours,
-        // and that row is where it goes red.
-        expect: '→ {"name":"paper-skills-nudge","ours":false}',
-        disables:
-          "the duplicate guard for every bin spelling but ours. A hook wired by hand as " +
-          "`npx paperlint hook …` or through an absolute path to the bin reads as ours, init merges its own " +
-          "copy beside it, and the hook runs twice per event",
-        edits: [[SRC, "ours: t === MANAGED_BY,", "ours: true,"]],
-      },
-      {
-        name: "another spelling no longer stops the write",
-        harness: HARNESS,
-        expect: "a hook wired by hand under another spelling",
-        disables:
-          "the refusal itself: the foreign command is found and then written over anyway",
-        edits: [[SRC, "  if (found.length > 0) {", "  if (false) {"]],
-      },
-      {
-        name: "the settings file is rewritten even when nothing changed",
-        harness: HARNESS,
-        // The fresh project's second run is the first place a rewrite shows: `written` twice.
-        expect: "a second run changes NOTHING",
-        disables:
-          "idempotency as the user sees it. Every init would reformat a committed file the user " +
-          "wrote, and the diff would say nothing happened while showing that everything did",
-        edits: [
-          [
-            SRC,
-            "  if (JSON.stringify(next) === JSON.stringify(read.settings))",
-            "  if (false)",
-          ],
-        ],
-      },
-      {
-        name: "the project-dir prefix is not stripped",
-        harness: HARNESS,
-        expect: "hookRun(",
-        disables:
-          "recognising the spelling init itself writes. `${CLAUDE_PROJECT_DIR}/node_modules/…` " +
-          "stops matching, so a second init sees a foreign hook where its own stands",
-        edits: [
-          [
-            SRC,
-            '  return unquoted.replace(/^\\$\\{?CLAUDE_PROJECT_DIR\\}?[/\\\\]/, "");',
-            "  return unquoted;",
-          ],
-        ],
-      },
-      {
-        name: "doctor stops counting duplicates",
-        harness: HARNESS,
-        expect: "the same hook under two spellings",
-        disables:
-          "the only report of a guard that runs twice. Claude Code dedupes only identical " +
-          "handlers, so two spellings both run and nothing else would say so",
-        edits: [
-          [
-            SRC,
-            "  const twice = wiring.names.filter((n) => total(n) > 1);",
-            "  const twice = wiring.names.filter((n) => total(n) > 2);",
-          ],
-        ],
-      },
-      {
-        name: "doctor offers `paperlint init` even where init refuses to write",
-        harness: HARNESS,
-        expect: "partly wired BY HAND",
-        disables:
-          "a remedy that works. The reader runs init, init writes nothing, and doctor says the " +
-          "same thing again — a loop with no exit",
-        edits: [[SRC, "  const remedy = handWired", "  const remedy = false"]],
-      },
-    ],
-  }),
-);