@mjasnikovs/pi-task 0.18.30 → 0.18.32

package/dist/task/runner-globs.d.ts

@@ -0,0 +1,74 @@
+/**
+ * runner-globs — deterministic detection of TWO TEST RUNNERS FIGHTING OVER THE SAME
+ * FILES, checked as soon as a project declares both rather than discovered at run end.
+ *
+ * The failure this closes — SECOND occurrence, runs 7 AND 13: a project declares both
+ * `bun test` and `playwright test`. Bun's runner scans the whole project for
+ * `*.test.*` / `*.spec.*`; Playwright's component/e2e specs ARE `*.spec.tsx`. So
+ * `bun test` imports Playwright spec files, which import `@playwright/test` outside a
+ * Playwright runner, and the whole suite dies on a module it was never meant to load.
+ *
+ * Run 7 found it in the final gate. Run 13 found it in the final gate AGAIN — and the
+ * fix (a `pathIgnorePatterns` line in bunfig.toml) was still sitting UNCOMMITTED in
+ * the working tree when the run ended, so HEAD shipped with `bun run test` broken. A
+ * defect that recurs across runs and survives its own fix is not a discovery problem;
+ * it is a missing invariant. This module states the invariant so it can be checked the
+ * moment both runners are declared:
+ *
+ *     if two runners are declared, their file sets must be provably DISJOINT
+ *
+ * Disjointness has exactly two mechanical forms, and this module accepts either:
+ *   - EXCLUSION: the scanning runner is configured to ignore the other's files
+ *     (bunfig `[test] pathIgnorePatterns`), or
+ *   - NAMING: the other runner's files are named so the scanner never claims them
+ *     (Playwright `testMatch` on a suffix outside `*.test.*` / `*.spec.*`, e.g. `.e2e.ts`).
+ *
+ * Guard direction: UNKNOWN steps aside. A missing/unparseable manifest, one runner
+ * only, or a Playwright config whose testMatch cannot be read all return `unknown` —
+ * the check may cost time, never work.
+ */
+export type GlobCollisionStatus = 'collision' | 'disjoint' | 'unknown';
+export interface GlobCollisionAssessment {
+    status: GlobCollisionStatus;
+    /** Human- and prompt-readable explanation; '' when there is nothing to say. */
+    detail: string;
+    /** The script names that invoke each runner (for naming the finding). */
+    scanningScripts: string[];
+    otherScripts: string[];
+}
+export interface RunnerGlobInputs {
+    /** The manifest's `scripts` map. */
+    scripts: Record<string, string>;
+    /** bunfig.toml text, or null when absent. */
+    bunfig: string | null;
+    /** playwright config text (any of the playwright*.config.* files), or null. */
+    playwrightConfig: string | null;
+}
+/**
+ * Bun's declared ignore patterns (`[test] pathIgnorePatterns = [...]`). Returns null
+ * when bunfig is absent or the key is not present — absent is not "empty", it is
+ * unknown-shaped, and the caller distinguishes them.
+ */
+export declare function parsePathIgnorePatterns(bunfig: string | null): string[] | null;
+/**
+ * Playwright's `testMatch`, when the config states one. Null → the default, which
+ * matches `*.spec.*` and `*.test.*` — precisely Bun's claimed set.
+ */
+export declare function parseTestMatch(playwrightConfig: string | null): string[] | null;
+/** Playwright's `testDir`, when stated (used to explain the collision concretely). */
+export declare function parseTestDir(playwrightConfig: string | null): string | null;
+/**
+ * Assess whether the declared runners can collide. See the module doc for the
+ * invariant and the two accepted forms of disjointness.
+ */
+export declare function assessRunnerGlobs(input: RunnerGlobInputs): GlobCollisionAssessment;
+/**
+ * Verify-child prompt lines for a collision. Empty for any non-collision status —
+ * the caller emits no block.
+ */
+export declare function runnerGlobVerifyFindings(a: GlobCollisionAssessment): string[];
+/**
+ * A plan-time contract line: the invariant, recorded so slices that add a runner
+ * inherit it instead of rediscovering the collision. Empty when not applicable.
+ */
+export declare function runnerGlobContractLine(a: GlobCollisionAssessment): string;

package/dist/task/runner-globs.js

@@ -0,0 +1,155 @@
+/**
+ * runner-globs — deterministic detection of TWO TEST RUNNERS FIGHTING OVER THE SAME
+ * FILES, checked as soon as a project declares both rather than discovered at run end.
+ *
+ * The failure this closes — SECOND occurrence, runs 7 AND 13: a project declares both
+ * `bun test` and `playwright test`. Bun's runner scans the whole project for
+ * `*.test.*` / `*.spec.*`; Playwright's component/e2e specs ARE `*.spec.tsx`. So
+ * `bun test` imports Playwright spec files, which import `@playwright/test` outside a
+ * Playwright runner, and the whole suite dies on a module it was never meant to load.
+ *
+ * Run 7 found it in the final gate. Run 13 found it in the final gate AGAIN — and the
+ * fix (a `pathIgnorePatterns` line in bunfig.toml) was still sitting UNCOMMITTED in
+ * the working tree when the run ended, so HEAD shipped with `bun run test` broken. A
+ * defect that recurs across runs and survives its own fix is not a discovery problem;
+ * it is a missing invariant. This module states the invariant so it can be checked the
+ * moment both runners are declared:
+ *
+ *     if two runners are declared, their file sets must be provably DISJOINT
+ *
+ * Disjointness has exactly two mechanical forms, and this module accepts either:
+ *   - EXCLUSION: the scanning runner is configured to ignore the other's files
+ *     (bunfig `[test] pathIgnorePatterns`), or
+ *   - NAMING: the other runner's files are named so the scanner never claims them
+ *     (Playwright `testMatch` on a suffix outside `*.test.*` / `*.spec.*`, e.g. `.e2e.ts`).
+ *
+ * Guard direction: UNKNOWN steps aside. A missing/unparseable manifest, one runner
+ * only, or a Playwright config whose testMatch cannot be read all return `unknown` —
+ * the check may cost time, never work.
+ */
+/** `bun test` — the scanning runner: it claims every `*.test.*` / `*.spec.*` it finds. */
+const BUN_TEST_RE = /\bbun\s+(?:--\S+\s+)*test\b/;
+/** `playwright test` (incl. `bunx`/`npx`/`pnpm exec` prefixes). */
+const PLAYWRIGHT_RE = /\bplaywright\s+test\b/;
+/** The suffixes Bun's test runner claims by default. */
+const BUN_CLAIMED_SUFFIX_RE = /\.(?:test|spec)\./;
+/** Scripts that invoke a given runner, by name. */
+function scriptsMatching(scripts, re) {
+    return Object.entries(scripts)
+        .filter(([, body]) => typeof body === 'string' && re.test(body))
+        .map(([name]) => name);
+}
+/**
+ * Bun's declared ignore patterns (`[test] pathIgnorePatterns = [...]`). Returns null
+ * when bunfig is absent or the key is not present — absent is not "empty", it is
+ * unknown-shaped, and the caller distinguishes them.
+ */
+export function parsePathIgnorePatterns(bunfig) {
+    if (bunfig === null)
+        return null;
+    const m = /^[ \t]*pathIgnorePatterns[ \t]*=[ \t]*\[([\s\S]*?)\]/m.exec(bunfig);
+    if (!m)
+        return null;
+    return [...m[1].matchAll(/["']([^"']+)["']/g)].map(x => x[1]);
+}
+/**
+ * Playwright's `testMatch`, when the config states one. Null → the default, which
+ * matches `*.spec.*` and `*.test.*` — precisely Bun's claimed set.
+ */
+export function parseTestMatch(playwrightConfig) {
+    if (playwrightConfig === null)
+        return null;
+    const m = /\btestMatch\s*:\s*(\[[\s\S]*?\]|['"][^'"]+['"]|\/[^/\n]+\/[gimsuy]*)/.exec(playwrightConfig);
+    if (!m)
+        return null;
+    const found = [...m[1].matchAll(/["']([^"']+)["']/g)].map(x => x[1]);
+    return found.length > 0 ? found : [m[1]];
+}
+/** Playwright's `testDir`, when stated (used to explain the collision concretely). */
+export function parseTestDir(playwrightConfig) {
+    if (playwrightConfig === null)
+        return null;
+    const m = /\btestDir\s*:\s*['"]([^'"]+)['"]/.exec(playwrightConfig);
+    return m ? m[1].replace(/^\.\//, '').replace(/\/+$/, '') : null;
+}
+/**
+ * Does an ignore pattern plausibly cover Playwright's spec files? Deliberately
+ * generous — this decides whether to STAY SILENT, and a guard that may only cost
+ * time should resolve ambiguity toward silence. A pattern naming a `spec`/`test`
+ * suffix, or the Playwright testDir, counts.
+ */
+function ignoreCoversSpecs(patterns, testDir) {
+    return patterns.some(p => {
+        if (BUN_CLAIMED_SUFFIX_RE.test(p) || /\bspec\b|\btest\b/.test(p))
+            return true;
+        return testDir !== null && testDir.length > 0 && p.includes(testDir);
+    });
+}
+/**
+ * Assess whether the declared runners can collide. See the module doc for the
+ * invariant and the two accepted forms of disjointness.
+ */
+export function assessRunnerGlobs(input) {
+    const scripts = input.scripts ?? {};
+    const scanningScripts = scriptsMatching(scripts, BUN_TEST_RE);
+    const otherScripts = scriptsMatching(scripts, PLAYWRIGHT_RE);
+    const base = { scanningScripts, otherScripts };
+    // Only one runner (or none) — nothing to collide.
+    if (scanningScripts.length === 0 || otherScripts.length === 0) {
+        return { status: 'unknown', detail: '', ...base };
+    }
+    // NAMING form: Playwright's own testMatch keeps its files outside Bun's claim.
+    const testMatch = parseTestMatch(input.playwrightConfig);
+    if (testMatch !== null && !testMatch.some(p => BUN_CLAIMED_SUFFIX_RE.test(p))) {
+        return {
+            status: 'disjoint',
+            detail: `playwright testMatch (${testMatch.join(', ')}) names files outside bun test's `
+                + `\`*.test.*\` / \`*.spec.*\` claim — the two runners cannot pick up each other's files`,
+            ...base
+        };
+    }
+    // EXCLUSION form: bun is told to ignore them.
+    const ignore = parsePathIgnorePatterns(input.bunfig);
+    const testDir = parseTestDir(input.playwrightConfig);
+    if (ignore !== null && ignoreCoversSpecs(ignore, testDir)) {
+        return {
+            status: 'disjoint',
+            detail: `bunfig [test] pathIgnorePatterns (${ignore.join(', ')}) excludes the playwright `
+                + `spec files from bun test's scan`,
+            ...base
+        };
+    }
+    // Both declared, neither form of disjointness present.
+    return {
+        status: 'collision',
+        detail: `\`${scanningScripts.join('`, `')}\` runs bun test, which scans the whole project for `
+            + '`*.test.*` / `*.spec.*`, and `'
+            + otherScripts.join('`, `')
+            + '` runs playwright, whose specs use those same suffixes'
+            + (testDir ? ` (testDir: ${testDir})` : '')
+            + '. bun test will import the playwright specs and die on `@playwright/test` outside '
+            + 'its runner. Declare disjoint file sets: add a bunfig.toml `[test] '
+            + 'pathIgnorePatterns` entry excluding the playwright specs, or give them a suffix '
+            + 'bun does not claim (e.g. `*.e2e.ts` via playwright `testMatch`)',
+        ...base
+    };
+}
+/**
+ * Verify-child prompt lines for a collision. Empty for any non-collision status —
+ * the caller emits no block.
+ */
+export function runnerGlobVerifyFindings(a) {
+    return a.status === 'collision' ? [a.detail] : [];
+}
+/**
+ * A plan-time contract line: the invariant, recorded so slices that add a runner
+ * inherit it instead of rediscovering the collision. Empty when not applicable.
+ */
+export function runnerGlobContractLine(a) {
+    if (a.scanningScripts.length === 0 || a.otherScripts.length === 0)
+        return '';
+    return (`Test-runner file sets MUST be disjoint: \`${a.scanningScripts.join('`, `')}\` (bun test, `
+        + `scans \`*.test.*\`/\`*.spec.*\` project-wide) and \`${a.otherScripts.join('`, `')}\` `
+        + `(playwright) must not claim the same files — enforce via bunfig \`[test] `
+        + `pathIgnorePatterns\` or a playwright \`testMatch\` suffix bun does not scan.`);
+}

package/dist/task/script-escape.d.ts

@@ -0,0 +1,83 @@
+/**
+ * script-escape — deterministic detection of CHECK SCRIPTS THAT CANNOT FAIL.
+ *
+ * The failure this closes (mx5 run 13, PROMPT 4 item 4): the shipped package.json
+ * declared, verbatim,
+ *     "lint": "prettier … && eslint --fix … && (tsc --noEmit 2>&1 | grep -qv 'TS18003' || true)"
+ * The typecheck is neutered twice over — its output is piped into an INVERTED grep
+ * (so the status becomes "some line did not match", never tsc's verdict), and the
+ * whole group is closed with `|| true` (so the script exits 0 unconditionally). Every
+ * consumer of that script — the repo-health verify gate, the final integration gate,
+ * a human reading a green CI line — is reading a constant, not a measurement.
+ *
+ * It was harmless in run 13 only by luck: tsc happened to be clean (validated). The
+ * class is not harmless — this is the same defect as run-8's F2 skip-escape, moved
+ * one level out. findSkipEscapes (skip-escape.ts) scans a spec's own VERIFY block;
+ * nothing scanned the SCRIPT DEFINITIONS those VERIFY blocks then invoke by name, so
+ * `bun run lint` could be authored into a no-op and every gate would salute it.
+ *
+ * TWO SHAPES, both crisp, both scoped to CHECK-CLASS script names:
+ *
+ *   A. ALWAYS-ZERO TAIL — the script's last command cannot fail (`… || true`,
+ *      `… || :`, `… || exit 0`, `…; exit 0`, a trailing `|| echo` fallback). A
+ *      shell script's status is its last command's status, so this is a proof, not
+ *      a heuristic: the script exits 0 no matter what the checker found.
+ *
+ *   B. INVERTED-GREP LAUNDERING — a checker piped into `grep -qv` / `grep -vq`.
+ *      "Some line of the output does NOT match X" is never a checker's verdict; it
+ *      is true of virtually any non-empty output, including a wall of errors.
+ *
+ * Deliberately NOT flagged, because each is legitimate and FP-measured against the
+ * real corpus (pi-task, aiz-server, aiz-client, gofer, mx5):
+ *   - `|| exit 1` — a HARDENING, the opposite of an escape (aiz-server).
+ *   - any `||`/pipe in a NON-check script (`clean`, `dev`, `start`, `copy-fonts`) —
+ *     a teardown `rm -rf dist || true` is correct and common.
+ *   - pipes into formatters/reporters (`| tap-spec`, `| tee`) — those propagate
+ *     status or are presentational; only inverted grep is unambiguous.
+ *   - a plain `| grep -q "expected"` — that is a real assertion on output.
+ */
+/** One neutered check script. */
+export interface ScriptEscapeFinding {
+    /** The script's name as declared (e.g. `lint`). */
+    name: string;
+    /** The script's body, verbatim. */
+    body: string;
+    /** Why it cannot fail (human- and prompt-readable). */
+    reason: string;
+}
+/**
+ * Judge one script definition. Returns null when the script is not check-class, or
+ * is check-class but can genuinely fail.
+ */
+export declare function judgeScript(name: string, body: string): ScriptEscapeFinding | null;
+/**
+ * Scan a parsed `scripts` map (package.json shape) for neutered check scripts.
+ * A non-object, or a map with no check-class scripts, yields no findings.
+ */
+export declare function findScriptEscapes(scripts: unknown): ScriptEscapeFinding[];
+/**
+ * Scan a package.json's TEXT. Invalid JSON yields no findings — a manifest that does
+ * not parse is a different problem, and guessing at its contents is how a scanner
+ * earns false positives.
+ */
+export declare function findScriptEscapesInManifest(manifestText: string): ScriptEscapeFinding[];
+/**
+ * Scan ARBITRARY text (a spec, a design doc) for script definitions written as JSON
+ * pairs — the form a spec uses when it dictates a script for the implementer to add
+ * (`"lint": "tsc --noEmit || true"`). This is what lets the critique catch the
+ * neutered script at SPEC time, before any task writes it into a manifest.
+ *
+ * Deliberately narrow: only `"name": "body"` pairs on one line, only check-class
+ * names. Prose describing a script in words extracts nothing.
+ */
+export declare function findScriptEscapesInText(text: string): ScriptEscapeFinding[];
+/**
+ * Verify-child prompt lines (probe+rule pattern): one per neutered script, naming
+ * the script, its body, and why it cannot fail.
+ */
+export declare function scriptEscapeVerifyFindings(findings: ScriptEscapeFinding[]): string[];
+/**
+ * Render findings as a critique/rewrite defect block — same shape as
+ * skipEscapeDefectText: a numbered list the rewrite must resolve.
+ */
+export declare function scriptEscapeDefectText(findings: ScriptEscapeFinding[]): string;

package/dist/task/script-escape.js

@@ -0,0 +1,189 @@
+/**
+ * script-escape — deterministic detection of CHECK SCRIPTS THAT CANNOT FAIL.
+ *
+ * The failure this closes (mx5 run 13, PROMPT 4 item 4): the shipped package.json
+ * declared, verbatim,
+ *     "lint": "prettier … && eslint --fix … && (tsc --noEmit 2>&1 | grep -qv 'TS18003' || true)"
+ * The typecheck is neutered twice over — its output is piped into an INVERTED grep
+ * (so the status becomes "some line did not match", never tsc's verdict), and the
+ * whole group is closed with `|| true` (so the script exits 0 unconditionally). Every
+ * consumer of that script — the repo-health verify gate, the final integration gate,
+ * a human reading a green CI line — is reading a constant, not a measurement.
+ *
+ * It was harmless in run 13 only by luck: tsc happened to be clean (validated). The
+ * class is not harmless — this is the same defect as run-8's F2 skip-escape, moved
+ * one level out. findSkipEscapes (skip-escape.ts) scans a spec's own VERIFY block;
+ * nothing scanned the SCRIPT DEFINITIONS those VERIFY blocks then invoke by name, so
+ * `bun run lint` could be authored into a no-op and every gate would salute it.
+ *
+ * TWO SHAPES, both crisp, both scoped to CHECK-CLASS script names:
+ *
+ *   A. ALWAYS-ZERO TAIL — the script's last command cannot fail (`… || true`,
+ *      `… || :`, `… || exit 0`, `…; exit 0`, a trailing `|| echo` fallback). A
+ *      shell script's status is its last command's status, so this is a proof, not
+ *      a heuristic: the script exits 0 no matter what the checker found.
+ *
+ *   B. INVERTED-GREP LAUNDERING — a checker piped into `grep -qv` / `grep -vq`.
+ *      "Some line of the output does NOT match X" is never a checker's verdict; it
+ *      is true of virtually any non-empty output, including a wall of errors.
+ *
+ * Deliberately NOT flagged, because each is legitimate and FP-measured against the
+ * real corpus (pi-task, aiz-server, aiz-client, gofer, mx5):
+ *   - `|| exit 1` — a HARDENING, the opposite of an escape (aiz-server).
+ *   - any `||`/pipe in a NON-check script (`clean`, `dev`, `start`, `copy-fonts`) —
+ *     a teardown `rm -rf dist || true` is correct and common.
+ *   - pipes into formatters/reporters (`| tap-spec`, `| tee`) — those propagate
+ *     status or are presentational; only inverted grep is unambiguous.
+ *   - a plain `| grep -q "expected"` — that is a real assertion on output.
+ */
+/**
+ * Script names whose whole purpose is to FAIL when something is wrong. A neutered
+ * `clean` or `dev` is nobody's business; a neutered `lint` silently disarms every
+ * gate that runs it. Suffixed variants (`test:ct`, `lint:fix`, `check-types`) match.
+ */
+const CHECK_SCRIPT_RE = /^(?:lint|test|check|verify|validate|typecheck|types?|tsc|ci|audit|coverage|e2e|build|compile|fmt:check|format:check)(?:[:_-].*)?$/i;
+/** `|| exit 1` and friends HARDEN a script — never mistake one for an escape. */
+const HARDENING_TAIL_RE = /\|\|\s*exit\s+[1-9]\d*\s*$/;
+/** Tails that make the script's exit status unconditionally 0. */
+const ALWAYS_ZERO_TAILS = [
+    { re: /\|\|\s*true\s*$/, what: '`|| true`' },
+    { re: /\|\|\s*:\s*$/, what: '`|| :`' },
+    { re: /\|\|\s*exit\s+0\s*$/, what: '`|| exit 0`' },
+    { re: /;\s*true\s*$/, what: '`; true`' },
+    { re: /;\s*exit\s+0\s*$/, what: '`; exit 0`' },
+    { re: /\|\|\s*echo\b[^|&;]*$/, what: 'a trailing `|| echo …` fallback' }
+];
+/** A checker piped into an INVERTED grep: status becomes "something didn't match". */
+const INVERTED_GREP_RE = /\|\s*grep\s+(?:-\w*v\w*|-\w+\s+-\w*v\w*)/;
+/**
+ * Strip trailing subshell/group closers and separators so the tail patterns see the
+ * real last command. mx5's script ends `… || true)` — without this the `)` hides it.
+ */
+function tailOf(body) {
+    let s = body.trim();
+    while (true) {
+        const next = s.replace(/[)\s;]+$/, '').trimEnd();
+        if (next === s)
+            return s;
+        s = next;
+    }
+}
+/**
+ * Judge one script definition. Returns null when the script is not check-class, or
+ * is check-class but can genuinely fail.
+ */
+export function judgeScript(name, body) {
+    if (!CHECK_SCRIPT_RE.test(name))
+        return null;
+    if (typeof body !== 'string' || body.trim().length === 0)
+        return null;
+    const reasons = [];
+    const tail = tailOf(body);
+    if (!HARDENING_TAIL_RE.test(tail)) {
+        for (const { re, what } of ALWAYS_ZERO_TAILS) {
+            if (re.test(tail)) {
+                reasons.push(`it ends in ${what}, so the script exits 0 whatever the check reports`);
+                break;
+            }
+        }
+    }
+    if (INVERTED_GREP_RE.test(body)) {
+        reasons.push('it pipes a check into an INVERTED grep (`grep -v`), so the exit status becomes '
+            + '"some output line did not match" — true of almost any output, including errors');
+    }
+    if (reasons.length === 0)
+        return null;
+    return {
+        name,
+        body: body.trim(),
+        reason: reasons.join('; ')
+    };
+}
+/**
+ * Scan a parsed `scripts` map (package.json shape) for neutered check scripts.
+ * A non-object, or a map with no check-class scripts, yields no findings.
+ */
+export function findScriptEscapes(scripts) {
+    if (typeof scripts !== 'object' || scripts === null || Array.isArray(scripts))
+        return [];
+    const out = [];
+    for (const [name, body] of Object.entries(scripts)) {
+        const f = judgeScript(name, typeof body === 'string' ? body : '');
+        if (f)
+            out.push(f);
+    }
+    return out;
+}
+/**
+ * Scan a package.json's TEXT. Invalid JSON yields no findings — a manifest that does
+ * not parse is a different problem, and guessing at its contents is how a scanner
+ * earns false positives.
+ */
+export function findScriptEscapesInManifest(manifestText) {
+    try {
+        const parsed = JSON.parse(manifestText);
+        if (typeof parsed !== 'object' || parsed === null)
+            return [];
+        return findScriptEscapes(parsed.scripts);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Scan ARBITRARY text (a spec, a design doc) for script definitions written as JSON
+ * pairs — the form a spec uses when it dictates a script for the implementer to add
+ * (`"lint": "tsc --noEmit || true"`). This is what lets the critique catch the
+ * neutered script at SPEC time, before any task writes it into a manifest.
+ *
+ * Deliberately narrow: only `"name": "body"` pairs on one line, only check-class
+ * names. Prose describing a script in words extracts nothing.
+ */
+export function findScriptEscapesInText(text) {
+    const out = [];
+    const seen = new Set();
+    for (const m of text.matchAll(/"([A-Za-z0-9:_-]{1,40})"\s*:\s*"((?:[^"\\]|\\.)*)"/g)) {
+        const name = m[1];
+        // Unescape the JSON string body so shell operators read normally.
+        let body;
+        try {
+            body = JSON.parse(`"${m[2]}"`);
+        }
+        catch {
+            continue;
+        }
+        const key = `${name}=${body}`;
+        if (seen.has(key))
+            continue;
+        const f = judgeScript(name, body);
+        if (!f)
+            continue;
+        seen.add(key);
+        out.push(f);
+    }
+    return out;
+}
+/**
+ * Verify-child prompt lines (probe+rule pattern): one per neutered script, naming
+ * the script, its body, and why it cannot fail.
+ */
+export function scriptEscapeVerifyFindings(findings) {
+    return findings.map(f => `\`${f.name}\`: ${f.body} — ${f.reason}`);
+}
+/**
+ * Render findings as a critique/rewrite defect block — same shape as
+ * skipEscapeDefectText: a numbered list the rewrite must resolve.
+ */
+export function scriptEscapeDefectText(findings) {
+    return [
+        'NEUTERED CHECK SCRIPT — this spec defines a check script that CANNOT FAIL, so every',
+        'gate that runs it reads a constant instead of a measurement (mx5 run 13 shipped',
+        '`"lint": "… && (tsc --noEmit 2>&1 | grep -qv \'TS18003\' || true)"` — the typecheck',
+        'was fully disarmed, and it went unnoticed only because tsc happened to be clean).',
+        "Rewrite each so it PROPAGATES the checker's exit status: drop the `|| true` /",
+        '`; exit 0` tail, and never launder a checker through an inverted grep. If a',
+        'specific diagnostic must genuinely be tolerated, suppress THAT diagnostic in the',
+        "checker's own config — never blanket-zero the whole script's exit code:",
+        ...findings.map((f, i) => `  ${i + 1}. "${f.name}": "${f.body}" — ${f.reason}`)
+    ].join('\n');
+}

package/dist/task/verify-work.d.ts

@@ -68,7 +68,20 @@ export declare function extractSpecForVerification(taskBody: string): string | n
  * Guard: honest-clean fixture (prohibition in spec, probe silent) 5/5 PASS — no
  * paranoia. Reverted-violation ≡ clean at the diff level (no entry → no finding).
  */
-export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[], crossTaskDeletionFindings?: string[]): string;
+export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[], crossTaskDeletionFindings?: string[], 
+/**
+ * The mx5 run-13 (PROMPT 4) probes, grouped rather than appended as three more
+ * positional parameters — this signature was already at its limit. Each key is
+ * an independent finding list; absent/empty emits no block.
+ */
+projectSurface?: {
+    /** Sandbox-leaked absolute paths (rule 4e) — see foreign-path.ts. */
+    foreignPaths?: string[];
+    /** Check scripts that cannot fail (rule 4f) — see script-escape.ts. */
+    scriptEscapes?: string[];
+    /** Colliding test-runner globs (rule 4g) — see runner-globs.ts. */
+    runnerGlobs?: string[];
+}): string;
 /**
  * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL|UNOBSERVED`
  * marker (the model discusses before concluding, and bash output may echo the word
@@ -146,6 +159,31 @@ export interface VerificationDeps {
      * 0/5), and carried structurally on a FAIL outcome so an ACCEPT records each as
      * a durable debt. ABSENT or empty → no block. */
     crossTaskDeletionProbe?: () => Promise<CrossTaskDeletion[]>;
+    /**
+     * DETERMINISTIC sandbox-path-leak probe (see foreign-path.ts, mx5 run 13
+     * PROMPT 4 item 1): absolute paths this task committed that exist only inside
+     * the authoring child's own environment — `/workspace/src/shared` in a vite
+     * alias — while the real file sits at `src/shared` here. The probe REPAIRS
+     * what it can deterministically first; only leaks it could not repair reach
+     * this hook, injected under rule 4e (MANDATORY + verdict-gating, the same
+     * shape as 4d — a leak makes the affected command fail to BUILD, so the
+     * checks that would notice never run at all). ABSENT or empty → no block. */
+    foreignPathProbe?: () => Promise<string[]>;
+    /**
+     * DETERMINISTIC neutered-check-script probe (see script-escape.ts, mx5 run 13
+     * PROMPT 4 item 4): check-class scripts in a manifest THIS task changed whose
+     * exit status cannot be non-zero (`… || true`, an inverted-grep launder). The
+     * damage is second-order — the script still "passes", so the gates that run it
+     * report success without measuring anything — which is exactly why the child
+     * cannot discover it by running the check. ABSENT or empty → no block. */
+    scriptEscapeProbe?: () => Promise<string[]>;
+    /**
+     * DETERMINISTIC test-runner glob-collision probe (see runner-globs.ts, mx5 runs
+     * 7 AND 13, PROMPT 4 item 2): the manifest declares two runners whose file sets
+     * are not provably disjoint, so the scanning one imports the other's specs and
+     * dies during COLLECTION. Injected under rule 4g. UNKNOWN (one runner, or
+     * disjointness proven) yields nothing. ABSENT or empty → no block. */
+    runnerGlobProbe?: () => Promise<string[]>;
     /**
      * Result of the git-state guard for the MOST RECENT runChild call (see
      * git-state-guard.ts): did the child mutate repo state (stash/checkout/file