@mjasnikovs/pi-task 0.18.29 → 0.18.31

package/dist/task/gate-deps.js

@@ -13,6 +13,7 @@
  * path-revisit disabled because re-running the same check IS the job), each with a
  * status widget and a per-gate debug log under .pi-tasks/.
  */
+import { existsSync } from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { tasksDir, readTaskFile, appendGateRecord } from './task-io.js';
@@ -21,7 +22,7 @@ import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
 import { readEnvNotes, appendEnvNotes } from './env-notes.js';
 import { readContracts } from './contracts.js';
-import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt } from './accept-debt.js';
+import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt, recordYoloAcceptDebt } from './accept-debt.js';
 import { runRepoHealthCheck } from './repo-health-check.js';
 import { runFinalIntegrationGate, discoverGateCommandLabels } from './final-gate.js';
 import { runFinalGateAutofix } from './final-gate-fix.js';
@@ -34,6 +35,9 @@ import { parseTreeChanges, parseNameStatusChanges, formatTreeChanges } from './w
 import { taskThatIntroduced, findCrossTaskDeletions } from './task-provenance.js';
 import { findTestRebuiltAssemblies, testAssemblyVerifyFindings } from './test-assembly.js';
 import { runBoundedLintFix } from './lint-fix.js';
+import { findForeignPaths, foreignPathVerifyFindings, repairForeignPaths } from './foreign-path.js';
+import { findScriptEscapesInManifest, scriptEscapeVerifyFindings } from './script-escape.js';
+import { assessRunnerGlobs, runnerGlobVerifyFindings } from './runner-globs.js';
 import { captureGitState, reconcileGitState } from './git-state-guard.js';
 import { runWorker } from '../workers/pi-worker-core.js';
 import { formatLoopHint } from './child-runner.js';
@@ -123,6 +127,121 @@ export async function collectAddedLines(cwd, signal) {
     }
     return lines;
 }
+/**
+ * Deterministic sandbox-path-leak pass (see foreign-path.ts, mx5 run 13 PROMPT 4
+ * item 1): find absolute paths the task committed that resolve nowhere on this
+ * machine while the real file sits in the repo, REPAIR the ones whose relative
+ * form provably resolves, and return verify findings for whatever is left.
+ *
+ * The repair runs here, before the verify child, for the same reason lint-fix
+ * does: the defect is mechanical and the correct target is already known, so
+ * spending an AUTOFIX round (or a human) on a path substitution is waste. What it
+ * cannot repair still reaches the child under rule 4e. Failures degrade to no
+ * findings — a sharpener, never a blocker.
+ */
+async function collectForeignPathFindings(cwd, signal, logDebug) {
+    const lines = await collectAddedLines(cwd, signal);
+    if (lines.length === 0)
+        return [];
+    const findings = findForeignPaths(lines, abs => existsSync(abs), rel => existsSync(path.join(cwd, rel)));
+    if (findings.length === 0)
+        return [];
+    const { repaired, remaining } = await repairForeignPaths(findings, {
+        readFile: rel => fsp.readFile(path.join(cwd, rel), 'utf8'),
+        writeFile: (rel, text) => fsp.writeFile(path.join(cwd, rel), text, 'utf8'),
+        existsInRepo: rel => existsSync(path.join(cwd, rel))
+    });
+    for (const r of repaired)
+        logDebug?.(`sandbox path leak repaired — ${r}`);
+    for (const f of remaining) {
+        logDebug?.(`sandbox path leak NOT repaired — ${f.file}: ${f.absolute}`);
+    }
+    return foreignPathVerifyFindings(remaining);
+}
+/** Manifests whose `scripts` the check-script scanner understands. */
+const MANIFEST_RE = /(^|\/)package\.json$/;
+/**
+ * Deterministic neutered-check-script pass (see script-escape.ts, mx5 run 13 PROMPT
+ * 4 item 4): check-class scripts that cannot report failure, in a manifest THIS
+ * task changed.
+ *
+ * Scoped to manifests the task touched, so the finding lands on the task that
+ * authored the script rather than being re-served to every later task. A script
+ * neutered by an earlier task is the whole-repo final gate's business, which
+ * re-checks the shipped manifest at run end regardless of who wrote it.
+ *
+ * Failures degrade to no findings — a sharpener, never a blocker.
+ */
+async function collectScriptEscapeFindings(cwd, signal) {
+    const changed = await collectChangedFiles(cwd, signal);
+    const manifests = changed.map(f => f.path).filter(p => MANIFEST_RE.test(p));
+    const findings = [];
+    for (const rel of manifests) {
+        try {
+            findings.push(...findScriptEscapesInManifest(await fsp.readFile(path.join(cwd, rel), 'utf8')));
+        }
+        catch {
+            // unreadable/absent manifest — nothing to report
+        }
+    }
+    return scriptEscapeVerifyFindings(findings);
+}
+/** Playwright config filenames, in the order playwright itself resolves them. */
+const PLAYWRIGHT_CONFIGS = [
+    'playwright.config.ts',
+    'playwright.config.js',
+    'playwright.config.mts',
+    'playwright-ct.config.ts',
+    'playwright-ct.config.js'
+];
+/** Read a repo file as text, or null when absent/unreadable. */
+async function readOrNull(cwd, rel) {
+    try {
+        return await fsp.readFile(path.join(cwd, rel), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Deterministic test-runner glob-collision pass (see runner-globs.ts, mx5 runs 7 AND
+ * 13, PROMPT 4 item 2): the manifest declares both `bun test` and `playwright test`
+ * without a provably disjoint file set, so `bun test` imports the playwright specs
+ * and dies during collection.
+ *
+ * Whole-repo rather than diff-scoped, unlike the neutered-script probe: a collision
+ * is a property of the PAIR of declarations, and the task that completes the pair is
+ * rarely the one that will be blamed by a diff. It is cheap (two small file reads)
+ * and silent unless both runners are actually declared. Failures degrade to no
+ * findings — a sharpener, never a blocker.
+ */
+async function collectRunnerGlobFindings(cwd) {
+    const manifestText = await readOrNull(cwd, 'package.json');
+    if (manifestText === null)
+        return [];
+    let scripts;
+    try {
+        const parsed = JSON.parse(manifestText);
+        const raw = parsed?.scripts;
+        if (typeof raw !== 'object' || raw === null)
+            return [];
+        scripts = raw;
+    }
+    catch {
+        return [];
+    }
+    let playwrightConfig = null;
+    for (const name of PLAYWRIGHT_CONFIGS) {
+        playwrightConfig = await readOrNull(cwd, name);
+        if (playwrightConfig !== null)
+            break;
+    }
+    return runnerGlobVerifyFindings(assessRunnerGlobs({
+        scripts,
+        bunfig: await readOrNull(cwd, 'bunfig.toml'),
+        playwrightConfig
+    }));
+}
 /**
  * The working tree's current changes as a summary (write-guard shape): what a
  * write-capable gate child changed, given the tree was clean when it started.
@@ -337,6 +456,7 @@ export function buildGateDeps(params) {
         // Durable ACCEPT-despite-verify-FAIL ledger under .pi-tasks/ (survives
         // discardEdits): the final integration gate re-checks each debt at run end.
         recordAcceptDebt: (cwd2, taskId, reason) => recordAcceptDebt(cwd2, taskId, reason),
+        recordYoloAcceptDebt: (cwd2, taskId, reason) => recordYoloAcceptDebt(cwd2, taskId, reason),
         recordEnforceRevertDebt: (cwd2, taskId, reason) => recordEnforceRevertDebt(cwd2, taskId, reason),
         // Durable cross-task-contradiction ledger (PROMPT 1 layer B): a repo-health
         // FAIL whose only fix is an edit to a path this task's spec froze — recorded
@@ -496,6 +616,28 @@ export function buildGateDeps(params) {
                 // destroyed (typically to green a check). Injected under rule 4d and
                 // carried on a FAIL so an ACCEPT records durable debts.
                 crossTaskDeletionProbe: () => collectTaskTreeChanges(cwd2, signal).then(changes => findCrossTaskDeletions(changes, taskId, rel => taskThatIntroduced(cwd2, rel))),
+                // Deterministic sandbox-path-leak probe (mx5 run 13 PROMPT 4 item
+                // 1): absolute paths committed from the authoring child's own
+                // environment (`/workspace/src/shared`) that resolve nowhere here.
+                // Repaired deterministically where the relative form provably
+                // resolves; the remainder is injected under rule 4e, whose point is
+                // that such a path breaks the BUILD — so the checks that would have
+                // caught it report nothing rather than failing.
+                foreignPathProbe: () => collectForeignPathFindings(cwd2, signal, msg => void fsp
+                    .appendFile(path.join(tasksDir(cwd2), 'verify-debug.log'), `${new Date().toISOString()} ${msg}\n`)
+                    .catch(() => { })),
+                // Deterministic neutered-check-script probe (mx5 run 13 PROMPT 4
+                // item 4): a check script this task authored that cannot fail
+                // (`… || true`, an inverted-grep launder). Injected under rule 4f,
+                // because the child provably cannot find this by running the
+                // script — it passes, which IS the defect.
+                scriptEscapeProbe: () => collectScriptEscapeFindings(cwd2, signal),
+                // Deterministic runner glob-collision probe (mx5 runs 7 AND 13,
+                // PROMPT 4 item 2): both `bun test` and `playwright test` declared
+                // with no proof their file sets are disjoint. Injected under rule
+                // 4g — the collision kills the suite during COLLECTION, which does
+                // not look like a test failure.
+                runnerGlobProbe: () => collectRunnerGlobFindings(cwd2),
                 // Deterministic prohibition probe: paths the spec forbids modifying
                 // that the task's diff modified anyway become prompt-level findings
                 // under the no-waiver rule — the child otherwise rarely runs `git

package/dist/task/parsers.d.ts

@@ -3,6 +3,23 @@
  *
  * Pure functions that parse raw model output into structured data.
  */
+/**
+ * WHY an auto-answer came back `unknown` — the producers are otherwise
+ * indistinguishable at the call site, and they are NOT equivalent: only
+ * 'api-synthesis' marks a recommendation a machine must never take (see
+ * task/yolo.ts). Mechanical tag, never a text pattern-match:
+ *   - 'model-unknown' — the child itself emitted UNKNOWN (or the parser salvaged a
+ *     bare recommendation): a genuine open fork carrying a best-effort suggestion.
+ *   - 'api-synthesis' — the answer was ANSWERED, then DEMOTED because it names an
+ *     API identifier absent from the research and the question, in a namespace the
+ *     research covers (mx5 run 13: an invented `Bun.mkdirSync` reached requirements
+ *     AND the VERIFY block). The suggestion rides along for a HUMAN to judge.
+ *   - 'integration' — an integration/build-wiring unknown no fetched doc grounded;
+ *     a wrong guess is a structural landmine, so the model's answer is offered as
+ *     a recommendation instead of being taken silently.
+ *   - 'threw' — the child failed; there is no recommendation at all.
+ */
+export type AutoAnswerUnknownReason = 'model-unknown' | 'api-synthesis' | 'integration' | 'threw';
 export type AutoAnswer = {
     kind: 'answered';
     text: string;
@@ -12,6 +29,7 @@ export type AutoAnswer = {
     suggested?: string;
     alt?: string;
     raw: string;
+    reason?: AutoAnswerUnknownReason;
 };
 /** One /task-auto clarify question with its model-recommended default answer. */
 export interface ClarifyQuestion {

package/dist/task/parsers.js

@@ -148,7 +148,8 @@ export function parseAutoAnswer(raw) {
             kind: 'unknown',
             ...(suggested !== undefined && { suggested }),
             ...(alt !== undefined && { alt }),
-            raw
+            raw,
+            reason: 'model-unknown'
         };
     }
     // Last-resort salvage: the model emitted no tag at all. Take the first line
@@ -159,8 +160,8 @@ export function parseAutoAnswer(raw) {
     // answer than to pre-fill a meaningless preamble.
     const salvaged = lines.find(l => !l.endsWith(':'));
     if (salvaged)
-        return { kind: 'unknown', suggested: salvaged, raw };
-    return { kind: 'unknown', raw };
+        return { kind: 'unknown', suggested: salvaged, raw, reason: 'model-unknown' };
+    return { kind: 'unknown', raw, reason: 'model-unknown' };
 }
 // ─── Verify tooling output parser ────────────────────────────────────────────
 export function parseVerifyToolingOutput(output) {

package/dist/task/phases.js

@@ -27,6 +27,7 @@ import { parseGrillQuestions, parseAutoAnswer, autoAnswerHasTag, parseVerifyTool
 import { compressTitle } from './title-label.js';
 import { parseVerifyBlock, validateSpecShape, stripSpecPreamble, isCritiqueClean } from './spec-validation.js';
 import { findSkipEscapes, skipEscapeDefectText } from './skip-escape.js';
+import { findScriptEscapesInText, scriptEscapeDefectText } from './script-escape.js';
 import { findSynthesizedWiring, wiringProbeText, readReferencedDocs } from './wiring-claims.js';
 import { findAbsenceConflicts, absenceProbeText, siblingTitlesFromPlanContext } from './verify-reconcile.js';
 import { findFrozenPathConflicts, frozenConflictProbeText } from './frozen-conflict.js';
@@ -37,6 +38,7 @@ import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from '.
 import { readRequirements, buildRequirementsBlock } from './requirements.js';
 import { runPhaseChild, runPhaseWithLoopGuard, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
 import { SessionUI } from '../remote/bridge.js';
+import { isYoloMode, yoloPickAutoAnswer, YOLO_STAMP } from './yolo.js';
 // ─── Re-export constants from their home modules ────────────────────────────
 export { MAX_GRILL_QUESTIONS };
 // ─── Tooling helpers ─────────────────────────────────────────────────────────
@@ -665,7 +667,15 @@ export async function phaseAutoAnswer(deps, refined, research, question, autoDep
                     const still = reasked ?? parsed;
                     const suggested = still.kind === 'answered' ? still.text : parsed.text;
                     deps.logDebug?.('grill-auto: answer still carries an unverified API — surfacing to user');
-                    parsed = { kind: 'unknown', suggested, raw: still.raw };
+                    parsed = {
+                        kind: 'unknown',
+                        suggested,
+                        raw: still.raw,
+                        // Tagged so a call site can tell this producer from the other
+                        // two: the suggestion is PROVEN to name an unverified API, so
+                        // it may only be judged by a human (yolo.ts must not take it).
+                        reason: 'api-synthesis'
+                    };
                 }
                 else {
                     parsed = reasked;
@@ -683,13 +693,13 @@ export async function phaseAutoAnswer(deps, refined, research, question, autoDep
         if (parsed.kind === 'answered' && !docResolved && isIntegrationUnknown(question)) {
             deps.logDebug?.(`grill-auto: integration unknown unresolved by fetch — surfacing to user `
                 + `instead of auto-answering: ${question.replace(/\s+/g, ' ').slice(0, 120)}`);
-            return { kind: 'unknown', suggested: parsed.text, raw: parsed.raw };
+            return { kind: 'unknown', suggested: parsed.text, raw: parsed.raw, reason: 'integration' };
         }
         return parsed;
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return { kind: 'unknown', raw: `(threw: ${msg})` };
+        return { kind: 'unknown', raw: `(threw: ${msg})`, reason: 'threw' };
     }
 }
 export async function phaseGrill(deps, ctx, widgetState, refined, research) {
@@ -755,6 +765,21 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
             // locally — each answer in its own bounding box, the recommended one
             // tinted green; an open question shows the bare text prompt.
             const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
+            // YOLO: take the recommended option and never build the prompt (which
+            // is also what suppresses its notification — see yolo.ts). An answer the
+            // anti-synthesis guard demoted, or a question with no recommendation at
+            // all, is SKIPPED instead: costing the spec one unanswered fork is the
+            // guard direction, promoting a hallucination is not.
+            const yolo = yoloPickAutoAnswer(isYoloMode(), auto);
+            if (yolo !== null) {
+                answer =
+                    yolo.kind === 'answer' ?
+                        stripInlineMarkdown(yolo.answer)
+                        : `(skipped — ${yolo.note})`;
+                out.push(`A${n + 1}: ${answer} ${YOLO_STAMP}`);
+                qa.push(`Q${n + 1}: ${plainQ}\nA${n + 1}: ${answer} ${YOLO_STAMP}`);
+                continue;
+            }
             const options = twoOption ?
                 [
                     {
@@ -915,6 +940,17 @@ export async function phaseCritique(deps, spec, refined, qa, planContext, resear
     if (grepOnlyProbe) {
         deps.logDebug?.('grep-theater VERIFY flagged in spec: ' + grepOnly.map(f => f.target).join(' | '));
     }
+    // DETERMINISTIC neutered-check-script probe (mx5 run 13, PROMPT 4 item 4): a
+    // spec that DICTATES a check script which cannot fail — `"lint": "… || true"`,
+    // or a checker laundered through an inverted grep. Whatever task implements
+    // that spec writes the disarmed script into package.json, and from then on
+    // every gate that runs it (repo-health verify, the final integration gate)
+    // reads a constant. Cheapest to kill here, in the spec, before it is authored.
+    const scriptEscapes = findScriptEscapesInText(spec);
+    const scriptProbe = scriptEscapes.length > 0 ? scriptEscapeDefectText(scriptEscapes) : null;
+    if (scriptProbe) {
+        deps.logDebug?.('neutered check script dictated by spec: ' + scriptEscapes.map(f => f.name).join(' | '));
+    }
     let triageDefects = null;
     if (parseVerifyBlock(spec) !== null) {
         const tTriage = Date.now();
@@ -932,15 +968,17 @@ export async function phaseCritique(deps, spec, refined, qa, planContext, resear
         deps.recordSubStep?.('triage', Date.now() - tTriage);
         if (verdict !== null) {
             // A deterministic skip-escape, synthesized-wiring, plan-contradiction,
-            // unsatisfiable-pair, or grep-theater finding overrides a CLEAN triage: the draft must
-            // be rewritten to resolve it even if the model judged the rest clean
-            // (the model does not self-discover any of them reliably).
+            // unsatisfiable-pair, grep-theater, or neutered-check-script finding
+            // overrides a CLEAN triage: the draft must be rewritten to resolve it
+            // even if the model judged the rest clean (the model does not
+            // self-discover any of them reliably).
             if (isCritiqueClean(verdict)) {
                 if (skipDefects === null
                     && wiringProbe === null
                     && absenceProbe === null
                     && frozenProbe === null
-                    && grepOnlyProbe === null) {
+                    && grepOnlyProbe === null
+                    && scriptProbe === null) {
                     return spec;
                 }
             }
@@ -950,9 +988,17 @@ export async function phaseCritique(deps, spec, refined, qa, planContext, resear
         }
     }
     // Merge the deterministic skip-escape + synthesized-wiring + plan-contradiction
-    // + unsatisfiable-pair + grep-theater defects with any triage defects for the
-    // rewrite (all are forced FOCUS items).
-    const rewriteDefects = [skipDefects, wiringProbe, absenceProbe, frozenProbe, grepOnlyProbe, triageDefects]
+    // + unsatisfiable-pair + grep-theater + neutered-script defects with any triage
+    // defects for the rewrite (all are forced FOCUS items).
+    const rewriteDefects = [
+        skipDefects,
+        wiringProbe,
+        absenceProbe,
+        frozenProbe,
+        grepOnlyProbe,
+        scriptProbe,
+        triageDefects
+    ]
         .filter(Boolean)
         .join('\n\n') || null;
     const tRewrite = Date.now();

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.`);
+}