@dzhechkov/harness-core 0.3.149 → 0.4.1

package/dist/mutation-gate.js

@@ -0,0 +1,535 @@
+// Mutation gate (feature ha-mutation-gate — features/ha-mutation-gate/SPEC.md).
+//
+// A test that passes proves the code works; it does NOT prove the test would have noticed the
+// protection being deleted. Three QE rounds on @dzhechkov/health-advisor produced 53 → 14 → 14
+// findings while the whole suite stayed green — including the exact exploit string a code comment
+// records as MEASURED. The gate generalises the one measurement that proved a protection real in
+// those rounds: DELETE the protection, run the suite, REQUIRE red.
+//
+// This module is PURE, in the house style of discrimination-gate.ts / challenge-panel.ts: it
+// parses the declarative registry, applies a mutation to file TEXT, parses failing-test counts
+// from runner output, and classifies observed outcomes. The copy-tree / run-suite / restore I/O is
+// performed by the CLI executor (`dz mutation-gate` in harness-cli), which feeds observations back
+// into `classifyMutationOutcome`. Deterministic and unit-testable without a filesystem or runner.
+//
+// The four rules the gate itself must obey (SPEC.md §"Four rules"):
+//   1. A mutation that does not apply — `find` absent, or present more than once — is a FAILURE,
+//      never a skip (inconclusive ≠ pass, the dz skills-verify lesson).
+//   2. A mutation whose suite stays GREEN is a FAILURE, and the report names the property.
+//   3. Never mutate the working tree (enforced by the executor: scratch copy only).
+//   4. The gate has its own discrimination proof (the deliberately-undefended fixture in
+//      harness-cli/test/fixtures/mutation-gate-undefended — excluded from any real registry).
+// ── Registry parsing — declarative DATA, validated loudly ─────────────────────────────────────
+const SAFE_ID = /^[a-z0-9][a-z0-9-]{0,79}$/;
+/** same shape as discrimination-gate's path rule: package-relative, no traversal, no metacharacters. */
+const UNSAFE_FILE = /(^\/)|(^[A-Za-z]:)|(^~)|(^-)|(\/-)|(\.\.(\/|\\|$))|[\0`$;&|<>*?"'\n\r\t\\]/;
+/** Parse + validate a registry JSON text. Accepts a bare array of entries or `{testCommand, entries}`. */
+export function parseMutationRegistry(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (e) {
+        return { registry: null, errors: [`registry is not valid JSON: ${String(e.message).slice(0, 120)}`] };
+    }
+    let entriesRaw;
+    let testCommand;
+    if (Array.isArray(raw)) {
+        entriesRaw = raw;
+    }
+    else if (raw && typeof raw === 'object') {
+        const obj = raw;
+        entriesRaw = obj.entries;
+        if (obj.testCommand !== undefined) {
+            if (typeof obj.testCommand !== 'string' || obj.testCommand.trim() === '') {
+                return { registry: null, errors: ['testCommand must be a non-empty string when present'] };
+            }
+            testCommand = obj.testCommand.trim();
+        }
+    }
+    if (!Array.isArray(entriesRaw)) {
+        return { registry: null, errors: ['registry must be an array of entries or {testCommand?, entries: [...]}'] };
+    }
+    if (entriesRaw.length === 0) {
+        // An empty registry "passes" by testing nothing — the same silent hole as a skipped mutation.
+        return { registry: null, errors: ['registry has no entries — an empty registry proves nothing and is refused'] };
+    }
+    const errors = [];
+    const entries = [];
+    const seen = new Set();
+    entriesRaw.forEach((e, i) => {
+        const at = `entries[${i}]`;
+        if (!e || typeof e !== 'object') {
+            errors.push(`${at}: not an object`);
+            return;
+        }
+        const o = e;
+        const id = typeof o['id'] === 'string' ? o['id'] : '';
+        if (!SAFE_ID.test(id)) {
+            errors.push(`${at}: id must be kebab-case [a-z0-9-], got ${JSON.stringify(o['id'])}`);
+            return;
+        }
+        if (seen.has(id)) {
+            errors.push(`${at}: duplicate id '${id}'`);
+            return;
+        }
+        seen.add(id);
+        if (typeof o['property'] !== 'string' || o['property'].trim() === '') {
+            errors.push(`${id}: property (the claimed sentence) is required`);
+            return;
+        }
+        const file = typeof o['file'] === 'string' ? o['file'] : '';
+        if (file === '' || UNSAFE_FILE.test(file)) {
+            errors.push(`${id}: file must be a plain package-relative path, got ${JSON.stringify(o['file'])}`);
+            return;
+        }
+        // A registry file under node_modules/ is refused OUTRIGHT (F-2): the registry names protections
+        // in the package's OWN code — a dependency's file is not this package's protection — and the
+        // scratch copy intentionally SHARES node_modules with the real tree (symlinked for
+        // runnability), so such an entry could never be mutated without writing through the link into
+        // the real working tree (SPEC rule 3). The executor's realpath containment is the belt; this
+        // is the cheaper layer-1 refusal for the case that is always a mistake.
+        if (file.split('/').includes('node_modules')) {
+            errors.push(`${id}: file targets node_modules/ (${JSON.stringify(file)}) — refused: a dependency file is not this package's protection, and the scratch copy shares node_modules with the REAL tree (rule 3: never mutate the working tree)`);
+            return;
+        }
+        const mut = o['mutation'];
+        if (!mut || typeof mut !== 'object' || typeof mut.find !== 'string' || mut.find.length === 0 || typeof mut.replace !== 'string') {
+            errors.push(`${id}: mutation must be {find: <non-empty string>, replace: <string>}`);
+            return;
+        }
+        if (mut.find === mut.replace) {
+            errors.push(`${id}: mutation.replace equals mutation.find — a no-op mutation tests nothing`);
+            return;
+        }
+        let minFailing = 1;
+        if (o['minFailing'] !== undefined) {
+            if (typeof o['minFailing'] !== 'number' || !Number.isInteger(o['minFailing']) || o['minFailing'] < 1) {
+                errors.push(`${id}: minFailing must be a positive integer`);
+                return;
+            }
+            minFailing = o['minFailing'];
+        }
+        let observed;
+        if (o['observed'] !== undefined) {
+            if (typeof o['observed'] !== 'number' || !Number.isInteger(o['observed']) || o['observed'] < 1) {
+                errors.push(`${id}: observed must be a positive integer when present`);
+                return;
+            }
+            observed = o['observed'];
+        }
+        let maxFailing;
+        if (o['maxFailing'] !== undefined) {
+            if (typeof o['maxFailing'] !== 'number' || !Number.isInteger(o['maxFailing']) || o['maxFailing'] < 1) {
+                errors.push(`${id}: maxFailing must be a positive integer when present`);
+                return;
+            }
+            if (o['maxFailing'] < minFailing) {
+                errors.push(`${id}: maxFailing (${o['maxFailing']}) must be >= minFailing (${minFailing}) — a contradictory bound can never pass`);
+                return;
+            }
+            maxFailing = o['maxFailing'];
+        }
+        const entry = {
+            id,
+            property: o['property'].trim(),
+            file,
+            mutation: { find: mut.find, replace: mut.replace },
+            minFailing,
+            ...(observed !== undefined ? { observed } : {}),
+            ...(maxFailing !== undefined ? { maxFailing } : {}),
+        };
+        entries.push(entry);
+    });
+    if (errors.length > 0)
+        return { registry: null, errors };
+    return testCommand !== undefined
+        ? { registry: { testCommand, entries }, errors: [] }
+        : { registry: { entries }, errors: [] };
+}
+/** Count NON-OVERLAPPING occurrences and apply only when the count is exactly 1. */
+export function applyMutationToText(source, find, replace) {
+    if (find.length === 0)
+        return { ok: false, occurrences: 0 };
+    const occurrences = source.split(find).length - 1;
+    if (occurrences !== 1)
+        return { ok: false, occurrences };
+    // The replacer FUNCTION makes the replacement LITERAL: with a plain string, `$&`/`` $` ``/`$'`/
+    // `$$` are substitution patterns and the gate would silently apply a DIFFERENT mutation than
+    // declared (G-3, MEASURED: replace 'X$&Y' on find 'GUARD' produced 'XGUARDY').
+    return { ok: true, occurrences, text: source.replace(find, () => replace) };
+}
+/**
+ * The route-c upper bound: the most failing tests a mutation may cause and still be read as
+ * BEHAVIOURAL redness attributable to this one protection. Explicit `maxFailing` wins; otherwise
+ * `max(anchor*5, anchor+10)` where anchor = `observed` (the measured blast radius) falling back to
+ * `minFailing`. k=5 / N=10 justification, MEASURED on the live data: every health-advisor registry
+ * entry has observed 1–4 ⇒ bounds 11–20, so legitimate growth (more tests covering the property —
+ * 5× proportional, or +10 absolute so tiny `observed` is not strangled) still passes, while the
+ * two measured structural blow-ups (route a: whole 484-test suite dead on a parse error; route c:
+ * 200+ failing vs observed 1) exceed the bound by an order of magnitude. NEVER unbounded — an
+ * entry with no `observed` anchors on its own minFailing contract.
+ */
+export function effectiveMaxFailing(entry) {
+    if (entry.maxFailing !== undefined)
+        return entry.maxFailing;
+    const anchor = entry.observed ?? entry.minFailing ?? 1;
+    return Math.max(anchor * 5, anchor + 10);
+}
+// ── Failing-test count — best-effort SECONDARY signal (never decides red/green) ───────────────
+/**
+ * Parse a failing-test count from runner output. Order of preference:
+ *   1. node --test / TAP summary `# fail N` (authoritative for TAP);
+ *   2. vitest/jest summary `Tests  N failed` / `N failed`;
+ *   3. top-level (unindented) `not ok` line count.
+ * Returns null when nothing parses — the verdict then rests on the exit code ALONE, by design:
+ * count parsing failure must never flip red/green (SPEC design decision).
+ */
+export function countFailingTests(rawOutput) {
+    // vitest colours its summary even when piped (MEASURED: `npm test` piped still carries SGR
+    // codes), which would hide `Tests N failed` from every regex below — strip SGR first.
+    const output = stripSgr(rawOutput);
+    const tap = /^#\s*fail(?:ing)?\s+(\d+)\s*$/m.exec(output);
+    if (tap && tap[1] !== undefined)
+        return Number(tap[1]);
+    // the `Tests` line, NOT `Test Files` — a failed file count under-reports the failing tests.
+    const vitest = /^\s*Tests\s+[^|\n]*?(\d+)\s+failed/m.exec(output);
+    if (vitest && vitest[1] !== undefined)
+        return Number(vitest[1]);
+    const jest = /^\s*Tests:\s+(?:[^,\n]+,\s*)?(\d+)\s+failed/m.exec(output);
+    if (jest && jest[1] !== undefined)
+        return Number(jest[1]);
+    const notOk = output.match(/^not ok\b/gm);
+    if (notOk !== null && notOk.length > 0)
+        return notOk.length;
+    return null;
+}
+// ── Run-failure classification — the route-a′ signal, from THE RUN ITSELF (round-6 rework) ────
+/** ANSI SGR sequences (colour). vitest emits them even when piped. */
+// eslint-disable-next-line no-control-regex
+const SGR = /\x1b\[[0-9;]*m/g;
+function stripSgr(s) {
+    return s.replace(SGR, '');
+}
+/**
+ * Classify a RED suite run's output: did a test FILE fail to LOAD (structural) or did test
+ * ASSERTIONS fail (behavioural)? This is the round-6 replacement for the isolated-child
+ * `import()` load-check, whose three false-PASS routes were ALL artifacts of the isolated import
+ * being a DIFFERENT environment than the test runner (env-dependent module goals, unsettled
+ * top-level await draining a child's event loop, non-deterministic load aborts dodging a second
+ * spawn). The correct signal comes from the SAME run that produced the failing count — no second
+ * child, no environment mismatch, nothing to disagree with itself.
+ *
+ * Runner shapes, both MEASURED (node v22.22.0, vitest 3.2.4 — reproducers in
+ * harness-cli/test/mutation-gate-cli.test.ts and this file's unit tests):
+ *
+ * node --test (flat TAP): every failure is a column-0 `not ok N - <name>` followed by an indented
+ * YAML diagnostic block. A test FILE that dies (throw at load, `process.exit` at import, unsettled
+ * top-level await ⇒ exit 13, dead require) is reported as a file-named test point whose block
+ * carries an `exitCode:` field (and `signal:` when killed) — `failureType: 'testCodeFailure'`,
+ * `error: 'test failed'`, `code: 'ERR_TEST_FAILURE'`. An ASSERTION failure — and equally a plain
+ * throw INSIDE a running test — NEVER carries `exitCode:`/`signal:`: those fields describe the
+ * spawned per-file process, which only appears when the file itself died. That asymmetry is the
+ * discriminator, and it is exactly the honest-mutation boundary: delete a guard clause and the
+ * file loads, assertions fire, no `exitCode:` field ⇒ behavioural.
+ *
+ * vitest (`vitest run`): a load/transform/collection error is reported under a `Failed Suites N`
+ * section as `FAIL <path> [ <path> ]` (the bracketed suite name repeats the path) with the error
+ * where a test name would be, and the summary counts it under `Test Files N failed` while `Tests`
+ * shows `no tests` for that file. Assertion failures appear under `Failed Tests N` as
+ * `FAIL <path> > <test name>` with `Tests N failed` in the summary. (An unsettled top-level await
+ * HANGS vitest rather than failing the file — the suite times out, exitCode null, INCONCLUSIVE —
+ * measured, and honestly out of scope for this classifier.)
+ *
+ * Runner detection is from the OUTPUT SHAPE, not the command (a `npm test` alias hides the
+ * runner): node --test requires the TAP header AND node's `# duration_ms` trailer (tape emits TAP
+ * + `# fail` but not `# duration_ms`); vitest requires its `RUN v<semver>` banner or `Test Files`
+ * summary line. Anything else — jest, mocha, tape, a bare script — is 'unknown'/'unrecognised':
+ * the honest, narrowed gap. It is about THIS TOOL's runner coverage, fails LOUD (INCONCLUSIVE),
+ * and never silently passes on output it cannot read.
+ */
+export function classifyRunFailure(rawOutput) {
+    const output = stripSgr(rawOutput);
+    // node --test (flat TAP, node ≥ 20 shape measured on v22.22.0)
+    if (/^TAP version \d+/m.test(output) && /^#\s*duration_ms\s+[\d.]+/m.test(output)) {
+        const lines = output.split('\n');
+        let sawNotOk = false;
+        for (let i = 0; i < lines.length; i++) {
+            const point = /^not ok \d+ - (.*)$/.exec(lines[i] ?? '');
+            if (point === null)
+                continue;
+            sawNotOk = true;
+            // Scan this point's YAML diagnostic block (indented, closed by `  ...`) for the per-file
+            // process fields. Nested subtest points are indented and never match the column-0 anchor.
+            for (let j = i + 1; j < lines.length; j++) {
+                const l = lines[j] ?? '';
+                if (!/^\s{2}/.test(l) || /^\s{2}\.\.\.\s*$/.test(l))
+                    break;
+                const exit = /^\s+exitCode:\s*(-?\d+)/.exec(l);
+                const signal = /^\s+signal:\s*'([^']+)'/.exec(l);
+                if (exit !== null || signal !== null) {
+                    const how = exit !== null ? `exitCode ${exit[1]}` : `signal ${signal?.[1]}`;
+                    return {
+                        runner: 'node-test',
+                        kind: 'file-load',
+                        evidence: `node --test reported the test FILE '${(point[1] ?? '').trim()}' failing as a whole (${how}) — the file (or a module it imports) died at load, not an assertion`,
+                    };
+                }
+            }
+        }
+        const tapFail = /^#\s*fail(?:ing)?\s+(\d+)\s*$/m.exec(output);
+        if (sawNotOk || (tapFail !== null && Number(tapFail[1]) > 0)) {
+            return { runner: 'node-test', kind: 'assertions' };
+        }
+        return { runner: 'node-test', kind: 'unrecognised', evidence: 'red node --test run with no failing TAP test point — the redness has no classifiable source' };
+    }
+    // vitest (`vitest run`, shape measured on 3.2.4)
+    if (/^\s*RUN\s+v\d+\./m.test(output) || /^\s*Test Files\s/m.test(output)) {
+        const failedSuites = /\bFailed Suites\s+(\d+)\b/.exec(output);
+        const suiteFail = /^\s*FAIL\s+(\S+)\s+\[\s*\1\s*\]/m.exec(output);
+        if (failedSuites !== null || suiteFail !== null) {
+            const what = suiteFail !== null ? `'${suiteFail[1]}'` : `${failedSuites?.[1]} suite(s)`;
+            return {
+                runner: 'vitest',
+                kind: 'file-load',
+                evidence: `vitest reported ${what} failing to load (Failed Suites — a collection/import error, not a test assertion)`,
+            };
+        }
+        if (/^\s*Tests\s+[^|\n]*?\d+\s+failed/m.test(output) || /\bFailed Tests\s+\d+\b/.test(output)) {
+            return { runner: 'vitest', kind: 'assertions' };
+        }
+        return { runner: 'vitest', kind: 'unrecognised', evidence: 'red vitest run with neither Failed Suites nor failed tests in the output — the redness has no classifiable source (unhandled error outside any test?)' };
+    }
+    return {
+        runner: 'unknown',
+        kind: 'unrecognised',
+        evidence: 'output matches neither node --test (TAP + # duration_ms) nor vitest (RUN v / Test Files) — no classifier for this runner; structural-vs-behavioural redness cannot be told apart, so the verdict may not be PROVEN',
+    };
+}
+/**
+ * A RED baseline in the scratch copy is a SETUP error, never a mutation result: every subsequent
+ * "red under mutation" would be noise, and every "green" a lie about an unrunnable copy.
+ */
+export function classifyBaseline(exitCode) {
+    if (exitCode === 0)
+        return { ok: true, detail: 'baseline suite green in the scratch copy' };
+    if (exitCode === null) {
+        return { ok: false, detail: 'baseline suite produced no exit code (timeout/spawn failure) — the copy is not runnable; fix the copy, do not read this as a mutation result' };
+    }
+    return { ok: false, detail: `baseline suite RED (exit ${exitCode}) in the UNMUTATED scratch copy — a broken copy cannot prove anything; fix the copy (node_modules link? path-dependent test?) before trusting any verdict` };
+}
+// ── Classification (rules 1 + 2, and the drop decision) ───────────────────────────────────────
+/**
+ * Classify one entry's observation.
+ *
+ * PRECEDENCE LATTICE (checked top to bottom; each verdict is justified by what it invalidates
+ * BELOW it — a verdict may only outrank another when it makes that other's evidence meaningless):
+ *   1. NOT_APPLIED            — nothing was mutated, so no run observation means anything;
+ *   2. MUTATION_UNPARSEABLE   — the mutated file is not even syntactically a module; a non-parsing
+ *                               file never RUNS, so no load- or count-signal can exist (which is
+ *                               why it sits above MUTATION_LOAD_FATAL);
+ *   3. MUTATION_LOAD_FATAL    — the run happened, but its own output says a test FILE died at
+ *                               load: the redness is structural and every count from that same run
+ *                               is non-attributable — so it outranks every count-based verdict AND
+ *                               the flaky-rebaseline check (a structurally-broken run needs no
+ *                               attribution analysis);
+ *   4. INCONCLUSIVE (no exit) — the run produced nothing to classify at all;
+ *   5. UNDEFENDED (exit 0)    — the disjoint GREEN arm: mutually exclusive with every red-based
+ *                               verdict below;
+ *   6. INCONCLUSIVE (unrecognised output) — red, but the shape is unreadable: counts parsed out of
+ *                               unrecognised output must not reach BELOW_MIN/OVER_FAILING/PROVEN;
+ *   7. INCONCLUSIVE (flaky rebaseline)    — red, readable, but not attributable;
+ *   8. BELOW_MIN → 9. OVER_FAILING        — reliable-count contract checks, both failing;
+ *  10. PROVEN                 — applied, red, behavioural, attributable, within bounds.
+ *
+ * THE DROP DECISION (SPEC §Reporting, decided here + justified): `failing < observed` but still
+ * `>= minFailing` is a LOUD WARNING, not a failure. Two reasons, both load-bearing:
+ *   • the count is a BEST-EFFORT secondary parsed from runner output — making it verdict-deciding
+ *    would let a count-parse failure flip red/green, which the design decisions forbid;
+ *   • `observed` is a historical measurement, `minFailing` is the entry's declared CONTRACT. A
+ *     contract violation fails (BELOW_MIN — only ever on a reliable count); history drifting down
+ *     while the contract still holds is the early warning, reported loudly so a human re-pins
+ *     `observed` or investigates — silently normalising it would erase the signal.
+ */
+export function classifyMutationOutcome(obs) {
+    const e = obs.entry;
+    const minFailing = e.minFailing ?? 1;
+    const base = {
+        id: e.id,
+        property: e.property,
+        file: e.file,
+        occurrences: obs.occurrences,
+        exitCode: obs.exitCode,
+        failingCount: obs.failingCount,
+        // an `observed` anchor is the ONLY thing that makes a drop detectable at all (round-7 honesty)
+        dropComparable: e.observed !== undefined,
+    };
+    if (obs.occurrences !== 1) {
+        return {
+            ...base,
+            applied: false,
+            verdict: 'NOT_APPLIED',
+            drop: false,
+            detail: obs.occurrences === 0
+                ? `mutation did not apply: find-text absent from ${e.file} (code drifted?) — NOTHING was tested; a skipped mutation may not report the property as proven (rule 1)`
+                : `mutation did not apply: find-text occurs ${obs.occurrences} times in ${e.file} (must be exactly once) — ambiguous surgery is refused, not guessed (rule 1)`,
+        };
+    }
+    // Route (a) — STRUCTURAL redness: the mutated file does not parse, so the suite (or its import
+    // chain) dies wholesale. That says nothing about the named protection. A registry mutation must
+    // delete the protection while keeping the file loadable; this is a bad entry, and it wins even
+    // over a red exit + a count, because that red is exactly the false signal being refused.
+    if (obs.parseError !== undefined) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'MUTATION_UNPARSEABLE',
+            drop: false,
+            detail: `the MUTATED ${e.file} does not parse (${obs.parseError.slice(0, 160)}) — a SETUP/registry error, not a discrimination proof: whole-suite redness from a load failure is not attributable to the protection; rewrite the mutation to delete the protection while keeping the file loadable`,
+        };
+    }
+    // Route (a′) — the run-derived file-load signal (round-6 rework): THE SUITE RUN's own output
+    // reported a test FILE failing to load under the mutation. Structural redness — the mutation
+    // broke the module, every count the same run produced is not attributable to the protection —
+    // so this outranks every count-based verdict AND the rebaseline check, exactly like
+    // MUTATION_UNPARSEABLE does. Unlike the replaced isolated-import load-check there is no second
+    // environment to disagree: the signal and the count come from ONE run.
+    if (obs.fileLoadFailure !== undefined) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'MUTATION_LOAD_FATAL',
+            drop: false,
+            detail: `the suite run reports a test FILE failing to LOAD under the mutation (${obs.fileLoadFailure.slice(0, 220)}) — structural, not behavioural: the mutation broke the module, so the redness is not attributable to the protection; rewrite the mutation to delete the protection while keeping the module evaluable`,
+        };
+    }
+    if (obs.exitCode === null) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'INCONCLUSIVE',
+            drop: false,
+            detail: 'suite produced NO exit code under the mutation (timeout / spawn failure) — inconclusive is a FAILURE, never a pass',
+        };
+    }
+    if (obs.exitCode === 0) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'UNDEFENDED',
+            drop: false,
+            detail: `suite stayed GREEN with the protection deleted — property UNDEFENDED: "${e.property}" (${e.file}). The suite would not notice this protection regressing (rule 2).`,
+        };
+    }
+    // Unrecognised output shape on a RED run — a runner-coverage gap of THIS TOOL (jest, mocha, an
+    // opaque wrapper script…): structural-vs-behavioural cannot be told apart, so nothing below
+    // (counts, bounds, PROVEN) may run. INCONCLUSIVE, loud, before every count-based branch.
+    if (obs.outputUnrecognised !== undefined) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'INCONCLUSIVE',
+            drop: false,
+            detail: `suite red but the runner output is UNRECOGNISED (${obs.outputUnrecognised.slice(0, 220)}) — this tool has no classifier for the output shape, so file-load redness cannot be told from assertion redness; INCONCLUSIVE is a FAILURE, never a pass (run the gate with a node --test or vitest test command, or extend classifyRunFailure)`,
+        };
+    }
+    // Route (b) — SPURIOUS redness: the suite went red under the mutation, but the RESTORED tree did
+    // not come back green, so the suite is flaky and an unrelated neighbour may be what went red.
+    // Not attributable ⇒ INCONCLUSIVE (a failure, never a pass).
+    if (obs.rebaselineExitCode !== undefined && obs.rebaselineExitCode !== 0) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'INCONCLUSIVE',
+            drop: false,
+            detail: `suite red under the mutation BUT the restored baseline did not reproduce green (${obs.rebaselineExitCode === null ? 'no exit code' : `exit ${obs.rebaselineExitCode}`}) — the suite is flaky; the redness is not attributable to the protection and may be an unrelated neighbour`,
+        };
+    }
+    if (obs.failingCount !== null && obs.failingCount < minFailing) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'BELOW_MIN',
+            drop: false,
+            detail: `suite red, but only ${obs.failingCount} failing test(s) — below the entry's own minFailing contract of ${minFailing}`,
+        };
+    }
+    // Route (c) — the symmetric arm of the drop warning: a RELIABLE count wildly ABOVE the entry's
+    // bound means the mutation broke far more than the protection's own tests (a structural blow-up
+    // that still parsed — dead export surface, poisoned shared helper). Not attributable ⇒ FAILURE.
+    const bound = effectiveMaxFailing(e);
+    if (obs.failingCount !== null && obs.failingCount > bound) {
+        return {
+            ...base,
+            applied: true,
+            verdict: 'OVER_FAILING',
+            drop: false,
+            detail: `suite red with ${obs.failingCount} failing test(s) — far more than this protection's own tests (bound ${bound}${e.maxFailing !== undefined ? ', explicit maxFailing' : `, default from ${e.observed !== undefined ? `observed ${e.observed}` : `minFailing ${minFailing}`}`}); the redness is not attributable to the protection — narrow the mutation or pin maxFailing if the blast radius is genuinely this large`,
+        };
+    }
+    const drop = obs.failingCount !== null && e.observed !== undefined && obs.failingCount < e.observed;
+    return {
+        ...base,
+        applied: true,
+        verdict: 'PROVEN',
+        drop,
+        detail: drop
+            ? `suite red (${obs.failingCount} failing vs ${e.observed} observed when written) — COVERAGE DROP: still defended, but fewer tests notice; investigate or re-pin observed`
+            : `suite red under the mutation (${obs.failingCount === null ? 'failing count unavailable — exit code is the verdict' : `${obs.failingCount} failing`}) — the test discriminates`,
+    };
+}
+/** Verdicts that fail the gate. INCONCLUSIVE and NOT_APPLIED fail (inconclusive ≠ pass). */
+const FAILING_VERDICTS = new Set(['UNDEFENDED', 'NOT_APPLIED', 'BELOW_MIN', 'MUTATION_UNPARSEABLE', 'MUTATION_LOAD_FATAL', 'OVER_FAILING', 'INCONCLUSIVE']);
+/** Exit contract: 0 all proven · 1 any entry failed (or red baseline) · (2 = usage/setup, CLI-side). */
+export function mutationGateExitCode(results, baselineOk) {
+    if (!baselineOk)
+        return 1;
+    if (results.length === 0)
+        return 1; // nothing ran ⇒ nothing proven
+    return results.some((r) => FAILING_VERDICTS.has(r.verdict)) ? 1 : 0;
+}
+export function summarizeMutationResults(results) {
+    return {
+        total: results.length,
+        proven: results.filter((r) => r.verdict === 'PROVEN').length,
+        undefended: results.filter((r) => r.verdict === 'UNDEFENDED').length,
+        notApplied: results.filter((r) => r.verdict === 'NOT_APPLIED').length,
+        belowMin: results.filter((r) => r.verdict === 'BELOW_MIN').length,
+        unparseable: results.filter((r) => r.verdict === 'MUTATION_UNPARSEABLE').length,
+        loadFatal: results.filter((r) => r.verdict === 'MUTATION_LOAD_FATAL').length,
+        overFailing: results.filter((r) => r.verdict === 'OVER_FAILING').length,
+        inconclusive: results.filter((r) => r.verdict === 'INCONCLUSIVE').length,
+        drops: results.filter((r) => r.drop).length,
+        dropComparable: results.filter((r) => r.dropComparable).length,
+    };
+}
+const VERDICT_MARK = {
+    PROVEN: '✓',
+    UNDEFENDED: '✗',
+    NOT_APPLIED: '✗',
+    BELOW_MIN: '✗',
+    MUTATION_UNPARSEABLE: '✗',
+    MUTATION_LOAD_FATAL: '✗',
+    OVER_FAILING: '✗',
+    INCONCLUSIVE: '✗',
+};
+export function renderMutationReport(results, baseline, packageDir) {
+    const lines = [];
+    lines.push(`mutation-gate: ${packageDir}`);
+    lines.push(`  baseline: ${baseline.ok ? 'GREEN' : 'ERROR'} — ${baseline.detail}`);
+    if (!baseline.ok)
+        return lines.join('\n');
+    for (const r of results) {
+        const count = r.failingCount === null ? 'n/a' : String(r.failingCount);
+        lines.push(`  ${VERDICT_MARK[r.verdict]} ${r.id}  applied=${r.applied ? 'yes' : 'no'}  failing=${count}  ${r.verdict}${r.drop ? ' (COVERAGE DROP)' : ''}`);
+        if (r.verdict !== 'PROVEN' || r.drop)
+            lines.push(`      ${r.detail}`);
+    }
+    const s = summarizeMutationResults(results);
+    lines.push(`  summary: ${s.proven}/${s.total} proven · ${s.undefended} undefended · ${s.notApplied} not-applied · ${s.belowMin} below-min · ${s.unparseable} unparseable · ${s.loadFatal} load-fatal · ${s.overFailing} over-failing · ${s.inconclusive} inconclusive · ${s.drops} coverage drop(s) among ${s.dropComparable}/${s.total} observed-anchored entries (a drop is undetectable without an \`observed\` anchor)`);
+    lines.push(mutationGateExitCode(results, baseline.ok) === 0
+        ? '  verdict: PASS — every named protection has a test that goes red when the protection is deleted'
+        : '  verdict: FAIL — at least one named protection is undefended, unmutable, or unproven');
+    return lines.join('\n');
+}
+//# sourceMappingURL=mutation-gate.js.map

package/dist/mutation-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-gate.js","sourceRoot":"","sources":["../src/mutation-gate.ts"],"names":[],"mappings":"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"}

package/dist/no-stubs.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The bare stub markers, ASSEMBLED so this module never fires on itself. Matched case-SENSITIVELY
+ * (measured: case-insensitivity doubles hits and adds only prose) with hard word boundaries on both
+ * sides, so a marker embedded in a word (a codename, a longer identifier) does not fire.
+ */
+export declare const STUB_MARKERS: readonly string[];
+/**
+ * Stub PHRASES: matched case-insensitively (a phrase is English, not a convention), with letter
+ * boundaries. Assembled for the same self-exemption reason.
+ */
+export declare const STUB_PHRASES: readonly string[];
+/**
+ * File extensions the scan reads. EXPLICIT and testable — never a silent glob. Fixture/test paths
+ * are NOT auto-exempt: a marker you just added to a fixture is still a decision, and the waiver is
+ * where that decision gets its reason.
+ */
+export declare const STUB_SCAN_EXTENSIONS: readonly string[];
+/** Is this path one the stub scan reads? (extension allowlist, case-insensitive on the extension) */
+export declare function scannableStubPath(path: unknown): boolean;
+export interface StubFinding {
+    readonly path: string;
+    /** 1-based line number. */
+    readonly line: number;
+    readonly kind: 'marker' | 'reasonless-waiver';
+    /** which marker/phrase matched (for 'marker'), or the refusal text (for 'reasonless-waiver'). */
+    readonly detail: string;
+}
+/** A config waiver: path-keyed, reason MANDATORY. A reasonless entry is refused, never honoured. */
+export interface StubWaiver {
+    readonly path?: string;
+    readonly reason?: string;
+}
+/**
+ * Scan ONE file's text. Case-sensitive bare markers + case-insensitive phrases, word-bounded.
+ * Markdown gets PROSE scoping: fenced code blocks and inline backtick spans are QUOTES of a marker,
+ * not stubs (the claim-check backtick-literal convention) — a doc explaining this very gate scans
+ * clean, while a naked stub line in doc prose still fires. Code files are scanned in full: a marker
+ * a code file must legitimately carry (another gate's source, a fixture) takes an inline
+ * `no-stubs: <reason>` waiver — visible, reasoned, greppable.
+ */
+export declare function scanStubs(path: string, text: unknown): StubFinding[];
+/**
+ * The aggregate check the guard rule calls: scan the CHANGED files whose contents were gathered,
+ * then apply config waivers. Missing contents for a changed file ⇒ that file reports nothing
+ * (fail-open on missing evidence — the standing guard contract; a deleted file has no contents).
+ *
+ * Config-waiver semantics: an entry with a non-empty `path` AND a non-empty `reason` exempts that
+ * exact repo-relative path. An entry with a path but NO reason is REFUSED as its own finding and
+ * exempts nothing. An entry with no path at all is inert garbage and is ignored (there is nothing
+ * it could exempt, and inventing a finding for it would punish a stray comma).
+ */
+export declare function checkNoStubs(files: readonly string[], contents: Readonly<Record<string, string>> | undefined, waivers: readonly StubWaiver[] | undefined): StubFinding[];
+//# sourceMappingURL=no-stubs.d.ts.map

package/dist/no-stubs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-stubs.d.ts","sourceRoot":"","sources":["../src/no-stubs.ts"],"names":[],"mappings":"AAyDA;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAMzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA6B,CAAC;AAkBxE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAKjD,CAAC;AAEF,qGAAqG;AACrG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAIxD;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,mBAAmB,CAAC;IAC9C,iGAAiG;IACjG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,oGAAoG;AACpG,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAYD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,WAAW,EAAE,CA2BpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,EACtD,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,SAAS,GACzC,WAAW,EAAE,CAgBf"}