@hominis/fireforge 0.35.0 → 0.37.0

package/dist/src/core/status-classify.js

@@ -13,7 +13,29 @@ import { verbose } from '../utils/logger.js';
 import { isBrandingManagedPath } from './branding.js';
 import { computePatchedContent } from './patch-apply.js';
 import { loadPatchesManifest } from './patch-manifest.js';
-function getPrimaryStatusCode(status) {
+/**
+ * Builds the file → owning-patch-filenames multimap from manifest rows.
+ * Single source of truth for cross-patch claim detection — status
+ * classification, verify's cross-claim check, and the ownership table all
+ * consume this builder (they used to each rebuild it, one drift away from
+ * disagreeing about what "claimed" means).
+ */
+export function buildPatchClaims(manifestPatches) {
+    const ownersByPath = new Map();
+    for (const patch of manifestPatches) {
+        for (const file of patch.filesAffected) {
+            const existing = ownersByPath.get(file) ?? [];
+            existing.push(patch.filename);
+            ownersByPath.set(file, existing);
+        }
+    }
+    return ownersByPath;
+}
+/**
+ * Reduces a two-character porcelain XY status to its primary code.
+ * Single source of truth — status-output.ts renders from the same logic.
+ */
+export function getPrimaryStatusCode(status) {
     if (status.includes('?'))
         return '?';
     if (status.includes('!'))
@@ -55,20 +77,7 @@ export async function classifyFiles(files, engineDir, patchesDir, binaryName, fu
     // branch where the expected-vs-actual content comparison then routed
     // them into `unmanaged` when the content didn't match either owner's
     // expectation.
-    const patchClaims = new Map();
-    if (manifest) {
-        for (const patch of manifest.patches) {
-            for (const f of patch.filesAffected) {
-                const owners = patchClaims.get(f);
-                if (owners) {
-                    owners.push(patch.filename);
-                }
-                else {
-                    patchClaims.set(f, [patch.filename]);
-                }
-            }
-        }
-    }
+    const patchClaims = manifest ? buildPatchClaims(manifest.patches) : new Map();
     const results = [];
     for (const entry of files) {
         const owners = patchClaims.get(entry.file);
@@ -145,4 +154,3 @@ export async function classifyFiles(files, engineDir, patchesDir, binaryName, fu
     }
     return results;
 }
-//# sourceMappingURL=status-classify.js.map

package/dist/src/core/test-harness-crash.d.ts

@@ -32,12 +32,42 @@ export interface HarnessCrashSignature {
 export interface HarnessRunVerdict {
     kind: HarnessRunClassification;
     signature?: HarnessCrashSignature;
+    /** First concrete test-failure evidence line, when available. */
+    realFailureLine?: string;
+    /**
+     * First N `TEST-UNEXPECTED-*` lines verbatim, each with its trailing
+     * assertion/diff context lines (`Got …` / `Expected …` / Assert diff /
+     * stack head). Lets the failure summary echo the actual assertion so a
+     * one-off failure that does not reproduce is still diagnosable after the
+     * fact. Only set on `test-failures` verdicts when such lines exist.
+     */
+    realFailureBlocks?: string[];
+    /** Harness noise seen in the same output as a real test failure. */
+    secondaryHarnessSignature?: HarnessCrashSignature;
     /**
      * Set when a non-zero mach exit code was overridden because the output
      * embeds a completed green summary — the exit code followed harness
      * noise, not a test result. Callers should surface a note.
      */
     greenSummaryOverride?: boolean;
+    /**
+     * Set when the output embeds a green-LOOKING summary that was REJECTED:
+     * crash or truncation evidence proves the suite never completed, so the
+     * "green" counts only cover the files that ran before the run died
+     * (field report: a SIGSEGV at the second of eight files left a
+     * `Passed: 2 / Failed: 0` summary that 0.35.0 green-washed into a pass).
+     * Callers must fail the run and surface the evidence.
+     */
+    greenSummaryRejected?: GreenSummaryRejection;
+}
+/** Why a green-looking embedded summary was not trusted. */
+export interface GreenSummaryRejection {
+    /** Crash-marker evidence line (mozcrash / signal kill), if any. */
+    crashLine?: string;
+    /** Requested test files with no `TEST_START`/`TEST-START` line at all. */
+    neverStarted: string[];
+    /** Files whose `TEST_START` has no matching end marker. */
+    neverEnded: string[];
 }
 /**
  * Strips non-signal noise from captured output before crash-signature
@@ -47,17 +77,49 @@ export interface HarnessRunVerdict {
  * classification of test results still reads the full output.
  */
 export declare function stripNonSignalNoise(output: string): string;
+/**
+ * Finds the first crash-marker line in the RAW output (see
+ * {@link CRASH_MARKER_PATTERNS}), or undefined when the run shows no
+ * crash evidence. Exported for direct unit testing.
+ */
+export declare function findCrashMarkerLine(output: string): string | undefined;
 /**
  * True when the output embeds a COMPLETED, GREEN suite summary: an
  * execution signal, `Unexpected results: 0` (and no non-zero unexpected
- * count), a `SUITE_END` marker, and no real `TEST-UNEXPECTED-*` lines.
- * Such a run finished its suite; any startup-traceback-shaped noise in the
- * same output is by definition non-fatal, so this vetoes signature-based
- * crash classification (field report: fully green sharded runs reported
- * `CRASH (N attempts)` because degradation warnings matched the psutil
- * signals). Exported for direct unit testing.
+ * count), a `SUITE_END` marker, no real `TEST-UNEXPECTED-*` lines — and
+ * NO crash marker. Such a run finished its suite; any startup-traceback-
+ * shaped noise in the same output is by definition non-fatal, so this
+ * vetoes signature-based crash classification (field report: fully green
+ * sharded runs reported `CRASH (N attempts)` because degradation warnings
+ * matched the psutil signals). A summary printed after a crash marker is
+ * NOT "completed" — it only covers the files that ran before the crash
+ * (0.35.0 green-wash field report). Exported for direct unit testing.
  */
 export declare function hasCompletedGreenSummary(output: string): boolean;
+/**
+ * Cross-checks run completeness against the requested test files: every
+ * requested file must produce a start marker, and every started test must
+ * produce an end marker (the harness emits both even for failing files).
+ *
+ * Ends are paired with starts POSITIONALLY (last open start is closed by
+ * the next end), not by filename — the xpcshell dialect's `TEST_END: Test
+ * PASS` lines do not name the file. Requested paths that are not
+ * test-file-shaped (directories, manifests) are skipped for the
+ * never-started check; the start/end pairing scan covers them regardless.
+ * Exported for direct unit testing.
+ */
+export declare function analyzeTestCompleteness(output: string, requestedPaths: readonly string[]): {
+    neverStarted: string[];
+    neverEnded: string[];
+};
+/**
+ * Collects the first `limit` TEST-UNEXPECTED-* lines with their trailing
+ * assertion/diff context, one string per block. The shutdown-reentry
+ * artifact is excluded (it is harness noise, not a test result). When more
+ * than `limit` blocks exist, a final `…(+N more …)` note is appended so the
+ * operator knows the echo was truncated. Pure; exported for unit tests.
+ */
+export declare function collectUnexpectedFailureBlocks(output: string, limit?: number): string[];
 /**
  * Detects the known harness-crash shapes in captured mach output.
  * Returns undefined for anything that looks like a genuine test result.
@@ -76,9 +138,20 @@ export declare function detectHarnessCrashSignature(output: string): HarnessCras
  *    dispatch prints no `TEST-START`). Bare `Passed:`/`Failed:` summary
  *    lines are still not trusted as evidence of execution.
  * 3. Exit code zero with tests started is a pass; anything else is a
- *    test failure for the regular diagnosis chain.
+ *    test failure for the regular diagnosis chain — except a non-zero
+ *    exit whose embedded summary completed green AND shows no crash
+ *    marker and no truncated/never-started requested file, which is a
+ *    pass with a `greenSummaryOverride` note (harness noise owns the
+ *    exit code). A green-shaped summary WITH such evidence is rejected
+ *    (`greenSummaryRejected`) and fails.
  */
 export declare function classifyHarnessRun(exitCode: number, output: string, requestedPaths: readonly string[]): HarnessRunVerdict;
+/**
+ * Builds the operator-facing failure message for a green-looking summary
+ * that was rejected on crash or truncation evidence (never trusted as a
+ * pass, regardless of how green the embedded counts look).
+ */
+export declare function buildGreenSummaryRejectedMessage(rejection: GreenSummaryRejection, exitCode: number): string;
 /** Builds the operator-facing failure message after retries are exhausted. */
 export declare function buildHarnessCrashMessage(signature: HarnessCrashSignature, attempts: number, commandLabel?: string): string;
 /**

package/dist/src/core/test-harness-crash.js

@@ -47,10 +47,30 @@ const NONZERO_UNEXPECTED_SUMMARY_PATTERN = /\bUnexpected results:\s*[1-9]/;
  */
 const XPCSHELL_RESULT_SUMMARY_PATTERN = /\bTEST_END\b|\bRan \d+ checks?\b|\bResult summary:/i;
 const UNEXPECTED_LINE_PATTERN = /^.*\bTEST-UNEXPECTED-[A-Z-]+\b.*$/gm;
+const FAIL_LINE_PATTERN = /^.*\bFAIL\b.*$/gm;
+const ASSERTION_LINE_PATTERN = /^.*\b(?:Assertion failure|MOZ_ASSERT|ASSERTION)\b.*$/gim;
 const SHUTDOWN_REENTRY_PATTERN = /Application shut down \(without crashing\) in the middle of a test/i;
 const FOCUS_STALL_PATTERN = /must wait for focus/i;
 const TRACEBACK_PATTERN = /Traceback \(most recent call last\)/;
 const NO_OUTPUT_TIMEOUT_PATTERN = /timed out after \d+ seconds with no output/i;
+/**
+ * Crash-marker lines mozcrash / the mochitest harness print when the
+ * browser process itself died. Matched against the RAW output (never
+ * noise-stripped): any of these proves the run was truncated by a crash,
+ * so an embedded green summary is under-reporting, not a result (field
+ * report: `Main app process: killed by SIGSEGV` at the second of eight
+ * files, summary `Passed: 2 / Failed: 0`, mach exit 1 — 0.35.0 accepted
+ * it as passed and masked a real regression for a whole drill).
+ */
+const CRASH_MARKER_PATTERNS = [
+    /Main app process: killed by SIG\w+/,
+    /\bPROCESS-CRASH\b/,
+    // The minidump-processing header shapes mozcrash emits when it walks a
+    // crash dump after the run.
+    /mozcrash.*minidump/i,
+    /Crash dump filename/i,
+    /Thread \d+ \(crashed\)/,
+];
 /**
  * Startup-traceback fingerprints from the mozlog resource monitor / psutil
  * on macOS. Each is matched per-line so the evidence line in the report is
@@ -165,22 +185,89 @@ function hasExecutionSignal(output) {
         hasXpcshellResultSummary(output));
 }
 /**
- * True when the output embeds a COMPLETED, GREEN suite summary: an
- * execution signal, `Unexpected results: 0` (and no non-zero unexpected
- * count), a `SUITE_END` marker, and no real `TEST-UNEXPECTED-*` lines.
- * Such a run finished its suite; any startup-traceback-shaped noise in the
- * same output is by definition non-fatal, so this vetoes signature-based
- * crash classification (field report: fully green sharded runs reported
- * `CRASH (N attempts)` because degradation warnings matched the psutil
- * signals). Exported for direct unit testing.
+ * Finds the first crash-marker line in the RAW output (see
+ * {@link CRASH_MARKER_PATTERNS}), or undefined when the run shows no
+ * crash evidence. Exported for direct unit testing.
  */
-export function hasCompletedGreenSummary(output) {
+export function findCrashMarkerLine(output) {
+    return findLine(output, CRASH_MARKER_PATTERNS);
+}
+/**
+ * True when the summary lines LOOK green: execution signal, `Unexpected
+ * results: 0` with no non-zero count, `SUITE_END`, no real
+ * `TEST-UNEXPECTED-*` lines. Deliberately blind to crash/truncation
+ * evidence — {@link hasCompletedGreenSummary} layers that on top, and
+ * {@link classifyHarnessRun} needs the distinction to report WHY a
+ * green-shaped summary was rejected.
+ */
+function hasGreenShapedSummary(output) {
     return (hasExecutionSignal(output) &&
         SUITE_END_PATTERN.test(output) &&
         GREEN_UNEXPECTED_SUMMARY_PATTERN.test(output) &&
         !NONZERO_UNEXPECTED_SUMMARY_PATTERN.test(output) &&
         realUnexpectedFailureLines(output).length === 0);
 }
+/**
+ * True when the output embeds a COMPLETED, GREEN suite summary: an
+ * execution signal, `Unexpected results: 0` (and no non-zero unexpected
+ * count), a `SUITE_END` marker, no real `TEST-UNEXPECTED-*` lines — and
+ * NO crash marker. Such a run finished its suite; any startup-traceback-
+ * shaped noise in the same output is by definition non-fatal, so this
+ * vetoes signature-based crash classification (field report: fully green
+ * sharded runs reported `CRASH (N attempts)` because degradation warnings
+ * matched the psutil signals). A summary printed after a crash marker is
+ * NOT "completed" — it only covers the files that ran before the crash
+ * (0.35.0 green-wash field report). Exported for direct unit testing.
+ */
+export function hasCompletedGreenSummary(output) {
+    return hasGreenShapedSummary(output) && findCrashMarkerLine(output) === undefined;
+}
+/** Basename shape of a mozbuild-manifest test implementation file. */
+const TEST_FILE_BASENAME_PATTERN = /^(?:browser|test)_.*\.m?js$/;
+/**
+ * Start/end execution markers, both log dialects: the structured mozlog
+ * `TEST_START`/`TEST_END` pair and the human browser-chrome
+ * `TEST-START`/`TEST-OK` pair. `TEST-UNEXPECTED-*` end shapes are
+ * irrelevant here — any such line already fails the green-summary check
+ * before completeness is consulted.
+ */
+const START_MARKER_PATTERN = /\bTEST[-_]START\b[:| ]*\s*(\S+)?/;
+const END_MARKER_PATTERN = /\bTEST[-_]END\b|\bTEST-OK\b/;
+/**
+ * Cross-checks run completeness against the requested test files: every
+ * requested file must produce a start marker, and every started test must
+ * produce an end marker (the harness emits both even for failing files).
+ *
+ * Ends are paired with starts POSITIONALLY (last open start is closed by
+ * the next end), not by filename — the xpcshell dialect's `TEST_END: Test
+ * PASS` lines do not name the file. Requested paths that are not
+ * test-file-shaped (directories, manifests) are skipped for the
+ * never-started check; the start/end pairing scan covers them regardless.
+ * Exported for direct unit testing.
+ */
+export function analyzeTestCompleteness(output, requestedPaths) {
+    const startedNames = [];
+    const openTests = [];
+    for (const line of output.split(/\r?\n/)) {
+        const startMatch = START_MARKER_PATTERN.exec(line);
+        if (startMatch) {
+            const name = startMatch[1] ?? '(unnamed test)';
+            startedNames.push(name);
+            openTests.push(name);
+            continue;
+        }
+        if (END_MARKER_PATTERN.test(line)) {
+            openTests.pop();
+        }
+    }
+    const neverStarted = requestedPaths.filter((path) => {
+        const base = path.slice(path.lastIndexOf('/') + 1);
+        if (!TEST_FILE_BASENAME_PATTERN.test(base))
+            return false;
+        return !startedNames.some((name) => name.includes(base));
+    });
+    return { neverStarted, neverEnded: openTests };
+}
 /**
  * True when the captured output carries the suite-specific xpcshell
  * result-summary block, which proves tests executed even though the
@@ -193,14 +280,101 @@ function hasXpcshellResultSummary(output) {
 }
 /** Unexpected-failure lines that are NOT the shutdown re-entry artifact. */
 function realUnexpectedFailureLines(output) {
-    const matches = output.match(UNEXPECTED_LINE_PATTERN) ?? [];
-    return matches.filter((line) => !SHUTDOWN_REENTRY_PATTERN.test(line));
+    const matches = [
+        ...(output.match(UNEXPECTED_LINE_PATTERN) ?? []),
+        ...(output.match(FAIL_LINE_PATTERN) ?? []),
+        ...(output.match(ASSERTION_LINE_PATTERN) ?? []),
+    ];
+    if (NONZERO_UNEXPECTED_SUMMARY_PATTERN.test(output)) {
+        const summary = output
+            .split(/\r?\n/)
+            .find((line) => NONZERO_UNEXPECTED_SUMMARY_PATTERN.test(line));
+        if (summary)
+            matches.push(summary);
+    }
+    return [...new Set(matches.map((line) => line.trim()))].filter((line) => !SHUTDOWN_REENTRY_PATTERN.test(line));
+}
+/**
+ * Non-global copies of the unexpected/assertion patterns for per-line use —
+ * the `g`-flagged module patterns carry `lastIndex` state across `.test()`
+ * calls and must never be reused line-by-line.
+ */
+const UNEXPECTED_LINE_SINGLE = /\bTEST-UNEXPECTED-[A-Z-]+\b/;
+/**
+ * Context lines the chrome/xpcshell harnesses print directly under a
+ * TEST-UNEXPECTED line: `Got …` / `Expected …` / `Actual …`, Assert
+ * messages, diff markers, stack-trace heads, and indented continuation
+ * lines.
+ */
+const FAILURE_CONTEXT_LINE_PATTERN = /^(?:\s*(?:Got\b|Expected\b|Actual\b|Assert\w*\b|Stack trace:|[-+]\s)|\s{2,}\S)/;
+/** Cap on context lines echoed under a single TEST-UNEXPECTED line. */
+const FAILURE_BLOCK_CONTEXT_LIMIT = 6;
+/**
+ * Collects the first `limit` TEST-UNEXPECTED-* lines with their trailing
+ * assertion/diff context, one string per block. The shutdown-reentry
+ * artifact is excluded (it is harness noise, not a test result). When more
+ * than `limit` blocks exist, a final `…(+N more …)` note is appended so the
+ * operator knows the echo was truncated. Pure; exported for unit tests.
+ */
+export function collectUnexpectedFailureBlocks(output, limit = 5) {
+    const lines = output.split(/\r?\n/);
+    const blocks = [];
+    let skipped = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        if (!UNEXPECTED_LINE_SINGLE.test(line) || SHUTDOWN_REENTRY_PATTERN.test(line))
+            continue;
+        if (blocks.length >= limit) {
+            skipped++;
+            continue;
+        }
+        const block = [line.trim()];
+        let contextCount = 0;
+        for (let j = i + 1; j < lines.length && contextCount < FAILURE_BLOCK_CONTEXT_LIMIT; j++) {
+            const next = lines[j] ?? '';
+            if (UNEXPECTED_LINE_SINGLE.test(next))
+                break;
+            if (!FAILURE_CONTEXT_LINE_PATTERN.test(next))
+                break;
+            block.push(next.trimEnd());
+            contextCount++;
+        }
+        blocks.push(block.join('\n'));
+    }
+    if (skipped > 0) {
+        blocks.push(`…(+${skipped} more TEST-UNEXPECTED line${skipped === 1 ? '' : 's'} not shown)`);
+    }
+    return blocks;
+}
+function detectSecondaryHarnessNoise(output) {
+    const evidence = stripNonSignalNoise(output);
+    if (TRACEBACK_PATTERN.test(evidence)) {
+        const signalLine = findLine(evidence, STARTUP_TRACEBACK_SIGNALS);
+        if (signalLine) {
+            return {
+                reason: 'harness traceback also present (resource monitor/psutil)',
+                line: signalLine,
+            };
+        }
+    }
+    const timeoutLine = findLine(evidence, [NO_OUTPUT_TIMEOUT_PATTERN]);
+    if (timeoutLine) {
+        return { reason: 'harness no-output timeout also present', line: timeoutLine };
+    }
+    return undefined;
 }
 /**
  * Detects the known harness-crash shapes in captured mach output.
  * Returns undefined for anything that looks like a genuine test result.
  */
 export function detectHarnessCrashSignature(output) {
+    // Browser/app process crashes are deterministic crash evidence, not
+    // retriable environmental harness noise. Leave them to
+    // `classifyHarnessRun` so it can reject green-looking truncated summaries
+    // with the crash line plus never-started/never-ended file evidence.
+    if (findCrashMarkerLine(output) !== undefined) {
+        return undefined;
+    }
     const hasTestStart = hasExecutionSignal(output);
     const realFailures = realUnexpectedFailureLines(output);
     // A completed green embedded summary vetoes signature-based crash
@@ -265,9 +439,18 @@ export function detectHarnessCrashSignature(output) {
  *    dispatch prints no `TEST-START`). Bare `Passed:`/`Failed:` summary
  *    lines are still not trusted as evidence of execution.
  * 3. Exit code zero with tests started is a pass; anything else is a
- *    test failure for the regular diagnosis chain.
+ *    test failure for the regular diagnosis chain — except a non-zero
+ *    exit whose embedded summary completed green AND shows no crash
+ *    marker and no truncated/never-started requested file, which is a
+ *    pass with a `greenSummaryOverride` note (harness noise owns the
+ *    exit code). A green-shaped summary WITH such evidence is rejected
+ *    (`greenSummaryRejected`) and fails.
  */
 export function classifyHarnessRun(exitCode, output, requestedPaths) {
+    const realFailures = realUnexpectedFailureLines(output);
+    const firstRealFailure = realFailures[0];
+    const failureBlocks = collectUnexpectedFailureBlocks(output);
+    const secondaryHarnessSignature = firstRealFailure !== undefined ? detectSecondaryHarnessNoise(output) : undefined;
     const signature = detectHarnessCrashSignature(output);
     if (signature) {
         return { kind: 'harness-crash', signature };
@@ -284,10 +467,64 @@ export function classifyHarnessRun(exitCode, output, requestedPaths) {
     // non-zero on harness noise (field report: a fully green --no-shard run
     // exited 1). Real failures always carry a non-zero unexpected count or
     // TEST-UNEXPECTED lines, both of which fail the green-summary check.
-    if (hasCompletedGreenSummary(output)) {
+    //
+    // The override must never win over crash or truncation evidence
+    // (0.35.0 green-wash field report: a SIGSEGV at the second of eight
+    // files produced a "green" `Passed: 2 / Failed: 0` summary and mach
+    // exit 1 — the summary was green only because the crash prevented the
+    // other six files from producing any results). A crash marker or an
+    // unpaired/never-started requested file rejects the override with the
+    // evidence attached, so the caller can say why.
+    if (hasGreenShapedSummary(output)) {
+        const crashLine = findCrashMarkerLine(output);
+        const completeness = analyzeTestCompleteness(output, requestedPaths);
+        if (crashLine !== undefined ||
+            completeness.neverStarted.length > 0 ||
+            completeness.neverEnded.length > 0) {
+            return {
+                kind: 'test-failures',
+                ...(firstRealFailure !== undefined ? { realFailureLine: firstRealFailure } : {}),
+                ...(failureBlocks.length > 0 ? { realFailureBlocks: failureBlocks } : {}),
+                ...(secondaryHarnessSignature !== undefined ? { secondaryHarnessSignature } : {}),
+                greenSummaryRejected: {
+                    ...(crashLine !== undefined ? { crashLine } : {}),
+                    neverStarted: completeness.neverStarted,
+                    neverEnded: completeness.neverEnded,
+                },
+            };
+        }
         return { kind: 'tests-ran-ok', greenSummaryOverride: true };
     }
-    return { kind: 'test-failures' };
+    return {
+        kind: 'test-failures',
+        ...(firstRealFailure !== undefined ? { realFailureLine: firstRealFailure } : {}),
+        ...(failureBlocks.length > 0 ? { realFailureBlocks: failureBlocks } : {}),
+        ...(secondaryHarnessSignature !== undefined ? { secondaryHarnessSignature } : {}),
+    };
+}
+/**
+ * Builds the operator-facing failure message for a green-looking summary
+ * that was rejected on crash or truncation evidence (never trusted as a
+ * pass, regardless of how green the embedded counts look).
+ */
+export function buildGreenSummaryRejectedMessage(rejection, exitCode) {
+    const evidence = [];
+    if (rejection.crashLine !== undefined) {
+        evidence.push(`  - crash evidence: ${rejection.crashLine}`);
+    }
+    if (rejection.neverStarted.length > 0) {
+        evidence.push(`  - requested test file(s) that never started: ${rejection.neverStarted.join(', ')}`);
+    }
+    if (rejection.neverEnded.length > 0) {
+        evidence.push(`  - test file(s) that started but never finished: ${rejection.neverEnded.join(', ')}`);
+    }
+    return (`mach exited ${exitCode} and the embedded suite summary looks green, but FireForge did NOT ` +
+        'treat the run as passed:\n\n' +
+        `${evidence.join('\n')}\n\n` +
+        'A crash- or truncation-shortened run under-reports: the "green" counts only cover the ' +
+        'files that ran before the run died, so the summary is not a suite result. Treat this as a ' +
+        'FAILED run — check the crash/truncation point in the output above, then re-run the ' +
+        'remaining files.');
 }
 /** Builds the operator-facing failure message after retries are exhausted. */
 export function buildHarnessCrashMessage(signature, attempts, commandLabel = 'mach test') {
@@ -315,4 +552,3 @@ export function buildNoTestsRanMessage(exitCode, requestedPaths) {
         'Check that the paths are registered in their test manifest (browser.toml / xpcshell.toml) ' +
         'and that the manifest is reachable from moz.build, then retry.');
 }
-//# sourceMappingURL=test-harness-crash.js.map

package/dist/src/core/test-harness-output.js

@@ -86,4 +86,3 @@ export function buildHarnessEarlyExitMessage(earlyExit, normalizedPaths) {
         `Requested paths: ${paths}\n\n` +
         'Fix the harness startup/discovery issue above before interpreting this as a test failure.');
 }
-//# sourceMappingURL=test-harness-output.js.map

package/dist/src/core/test-path-scope.d.ts

@@ -5,17 +5,21 @@
  * so `fireforge test browser/base/content/test/hominis` silently also
  * ran the sibling directory `browser/base/content/test/hominis-tiles`
  * (152.0b7 → 153.0b8 source-refresh drill: 1224 tests instead of ~200,
- * with no indication the scope widened). A trailing separator makes the
- * prefix match exact — `hominis/` cannot prefix `hominis-tiles/…`.
+ * with no indication the scope widened).
  *
  * FireForge therefore treats a directory argument as meaning EXACTLY
- * that directory: {@link analyzeTestPathScopes} returns a trailing-`/`
- * dispatch form for every existing directory, plus the sibling
- * directories the raw prefix would have swept in so the command layer
- * can tell the operator what was excluded. Note FireForge already
- * rejects non-existent paths up front, so raw prefix-widening was never
- * something an operator could invoke deliberately — it only ever
- * happened by accident.
+ * that directory: {@link analyzeTestPathScopes} enumerates the test
+ * files of exactly that directory and dispatches THAT explicit file
+ * list to mach — a file list cannot prefix-match anything. (0.35.0
+ * instead normalized the directory with a trailing `/`, assuming the
+ * separator makes the prefix match exact; field verification on Firefox
+ * 153 showed mach still swept in the prefix-named sibling, so the
+ * trailing-slash mechanism was cosmetic and its exclusion echo was
+ * wrong.) The prefix-matching sibling directories are still reported so
+ * the command layer can tell the operator what was excluded. Note
+ * FireForge already rejects non-existent paths up front, so raw
+ * prefix-widening was never something an operator could invoke
+ * deliberately — it only ever happened by accident.
  */
 /** A sibling directory the raw mach prefix match would have included. */
 export interface SiblingPrefixMatch {
@@ -29,13 +33,17 @@ export interface TestPathScope {
     /** The path as the operator passed it (engine-relative, normalized). */
     requestedPath: string;
     /**
-     * The form to hand to mach: directories gain a trailing `/` so
-     * mozbuild's prefix match is exact; files pass through unchanged.
+     * The paths to hand to mach for this argument: the explicit test-file
+     * list for a directory (mach cannot prefix-widen an explicit file
+     * list), or the argument unchanged for files. A directory containing
+     * no enumerable test files falls back to the trailing-`/` directory
+     * form — there is nothing to list, and mach owns the "no tests found"
+     * failure.
      */
-    dispatchPath: string;
+    dispatchPaths: string[];
     /** True when the path resolved to a directory under engine/. */
     isDirectory: boolean;
-    /** Recursive test-file count inside the requested directory (0 for files). */
+    /** Test files enumerated inside the requested directory (empty for files). */
     testFileCount: number;
     /** Sibling directories a raw prefix match would also have selected. */
     siblingPrefixMatches: SiblingPrefixMatch[];