@hominis/fireforge 0.36.0 → 0.37.0

package/dist/src/core/mach-known-noise-filter.js

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Terminal-echo filter for the KNOWN upstream mozsystemmonitor teardown
+ * traceback (0.37.0 item 8).
+ *
+ * Every headless test run against the 153-beta engine ends with an
+ * `AttributeError: 'SystemResourceMonitor' object has no attribute
+ * 'stop_time'` traceback at harness teardown — upstream noise that sits
+ * exactly where a reader looks for the failure summary. 0.36.0 already made
+ * real failure lines beat this traceback in CLASSIFICATION; this filter
+ * closes the PRESENTATION gap by collapsing the echoed traceback to one
+ * labeled line.
+ *
+ * Scope is deliberately narrow:
+ *   - Only the terminal ECHO is filtered. The captured stdout/stderr strings
+ *     stay raw — the classifier (`test-harness-crash.ts`) depends on the
+ *     raw traceback for its green-summary override and secondary-noise
+ *     detection.
+ *   - Only the exact documented incident is collapsed, and every condition
+ *     must hold: an `AttributeError` on `SystemResourceMonitor` naming one
+ *     of the two known attributes (`stop_time`, `poll_interval` — the
+ *     0.34.0 guard family), AND a `mozsystemmonitor/resourcemonitor.py`
+ *     stack frame, AND a previously-seen SUITE_END shutdown marker (shared
+ *     across the run's stdout/stderr filter instances — the marker usually
+ *     lands on stdout while the traceback lands on stderr). A novel
+ *     attribute, a novel exception type in resourcemonitor.py, or a
+ *     pre-shutdown occurrence is echoed verbatim, always.
+ *   - The hold buffer is bounded; on overflow the block is flushed verbatim
+ *     and the filter returns to pass-through, so output is never lost.
+ */
+const TRACEBACK_HEADER_PATTERN = /^Traceback \(most recent call last\)/;
+const CHAINED_EXCEPTION_CONNECTOR_PATTERN = /^(?:During handling of the above exception, another exception occurred:|The above exception was the direct cause of the following exception:)\s*$/;
+/**
+ * Closed allowlist of the documented teardown family's attributes:
+ * `stop_time` (the 0.37.0 item-8 incident) and `poll_interval` (the same
+ * mozsystemmonitor init failure the 0.34.0 resource-guard family covers —
+ * `test-harness-crash.ts` already classifies it as recognized noise). Any
+ * other missing attribute is a NEW upstream defect and must print verbatim.
+ */
+const KNOWN_TEARDOWN_ATTRIBUTE_ERROR_PATTERN = /AttributeError: 'SystemResourceMonitor' object has no attribute '(?:stop_time|poll_interval)'/;
+const RESOURCEMONITOR_FRAME_PATTERN = /mozsystemmonitor[/\\]resourcemonitor\.py/;
+/**
+ * Shutdown marker: the harness's SUITE_END line. Matches the shape
+ * `test-harness-crash.ts` keys its summary parsing on (module-private
+ * there; duplicated here with this cross-reference rather than exported).
+ */
+const SHUTDOWN_MARKER_PATTERN = /\bSUITE_END\b/;
+/** Whole-block recognition — every signal must hold (see module doc). */
+function isRecognizedTeardownNoise(block) {
+    return (KNOWN_TEARDOWN_ATTRIBUTE_ERROR_PATTERN.test(block) && RESOURCEMONITOR_FRAME_PATTERN.test(block));
+}
+/** Fresh per-run context — hand the same instance to both stream filters. */
+export function createTeardownNoiseContext() {
+    return { shutdownSeen: false };
+}
+/** One line replaces the whole recognized traceback block in the echo. */
+export const KNOWN_TEARDOWN_NOISE_ANNOTATION = '[FireForge] Known upstream mozsystemmonitor teardown noise (SystemResourceMonitor ' +
+    'AttributeError at harness shutdown) — not a test failure. See FireForge docs.\n';
+/** Bounds on the held traceback block before flushing verbatim. */
+const HOLD_LINE_LIMIT = 100;
+const HOLD_BYTE_LIMIT = 16 * 1024;
+/**
+ * Creates a stateful filter for one output stream. Complete lines outside a
+ * traceback pass straight through (only the trailing partial line is held
+ * back); a `Traceback (most recent call last)` header switches to hold mode
+ * until the block ends, then either the one-line annotation (recognized
+ * signature after a seen shutdown marker) or the verbatim block (anything
+ * else) is emitted. Pass the run's shared {@link TeardownNoiseContext} so
+ * both stream filters see the same shutdown flag.
+ */
+export function createKnownTeardownNoiseFilter(context = createTeardownNoiseContext()) {
+    /** Partial (no trailing newline yet) input line. */
+    let partial = '';
+    /** Held traceback lines (each WITH its newline) while in hold mode. */
+    let held = [];
+    let heldBytes = 0;
+    /**
+     * State machine:
+     *   'pass'    — outside any traceback; lines echo through.
+     *   'inside'  — between a Traceback header and its closing exception line.
+     *   'closed'  — saw the closing `SomeError: …` line; still holding in
+     *               case a chained-exception connector continues the block
+     *               (the real fixture chains two tracebacks — the whole
+     *               chain must be evaluated as ONE block or the second half
+     *               would print raw after the annotation).
+     */
+    let state = 'pass';
+    const resetHold = () => {
+        const block = held.join('');
+        held = [];
+        heldBytes = 0;
+        state = 'pass';
+        return block;
+    };
+    const releaseHeld = () => {
+        const block = resetHold();
+        if (block.length === 0)
+            return '';
+        return context.shutdownSeen && isRecognizedTeardownNoise(block)
+            ? KNOWN_TEARDOWN_NOISE_ANNOTATION
+            : block;
+    };
+    const hold = (line) => {
+        held.push(line);
+        heldBytes += line.length;
+        if (held.length > HOLD_LINE_LIMIT || heldBytes > HOLD_BYTE_LIMIT) {
+            // Pathological block: flush verbatim rather than risk withholding
+            // output; do not attempt recognition on oversized blocks.
+            return { out: resetHold(), overflowed: true };
+        }
+        return { out: '', overflowed: false };
+    };
+    const processLine = (line) => {
+        const content = line.replace(/\r?\n$/, '');
+        if (state === 'pass') {
+            if (TRACEBACK_HEADER_PATTERN.test(content)) {
+                state = 'inside';
+                return hold(line).out;
+            }
+            if (SHUTDOWN_MARKER_PATTERN.test(content))
+                context.shutdownSeen = true;
+            return line;
+        }
+        if (state === 'inside') {
+            const isContinuation = content.trim().length === 0 ||
+                /^[ \t]/.test(content) ||
+                TRACEBACK_HEADER_PATTERN.test(content);
+            const { out, overflowed } = hold(line);
+            // The first unindented line is the closing `SomeError: …` line; keep
+            // holding in case a chained connector extends the block.
+            if (!overflowed && !isContinuation) {
+                state = 'closed';
+            }
+            return out;
+        }
+        // state === 'closed': only a blank line, a chained-exception connector,
+        // or another Traceback header continues the block.
+        if (content.trim().length === 0 || CHAINED_EXCEPTION_CONNECTOR_PATTERN.test(content)) {
+            return hold(line).out;
+        }
+        if (TRACEBACK_HEADER_PATTERN.test(content)) {
+            const { out, overflowed } = hold(line);
+            if (!overflowed)
+                state = 'inside';
+            return out;
+        }
+        return releaseHeld() + processLineInPass(line);
+    };
+    // Re-dispatch a line through pass-mode handling after a block release —
+    // the line that ended the block may itself start a new traceback.
+    const processLineInPass = (line) => {
+        const content = line.replace(/\r?\n$/, '');
+        if (TRACEBACK_HEADER_PATTERN.test(content)) {
+            state = 'inside';
+            return hold(line).out;
+        }
+        if (SHUTDOWN_MARKER_PATTERN.test(content))
+            context.shutdownSeen = true;
+        return line;
+    };
+    return {
+        transform(chunk) {
+            let out = '';
+            let buffer = partial + chunk;
+            partial = '';
+            let newlineIndex = buffer.indexOf('\n');
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex + 1);
+                buffer = buffer.slice(newlineIndex + 1);
+                out += processLine(line);
+                newlineIndex = buffer.indexOf('\n');
+            }
+            partial = buffer;
+            return out;
+        },
+        flush() {
+            let out = '';
+            if (state !== 'pass') {
+                // A stream that closes mid-block: fold the trailing partial line in
+                // and evaluate — the final exception line is often the last thing
+                // printed, without a trailing newline.
+                if (partial.length > 0) {
+                    held.push(partial);
+                    partial = '';
+                }
+                out += releaseHeld();
+            }
+            out += partial;
+            partial = '';
+            return out;
+        },
+    };
+}

package/dist/src/core/mach.d.ts

@@ -17,6 +17,14 @@ export interface MachOptions {
     env?: Record<string, string>;
     /** Whether to inherit stdio (show output directly) */
     inherit?: boolean;
+    /**
+     * Collapse the KNOWN mozsystemmonitor teardown traceback to one labeled
+     * line in the terminal ECHO (capture-only option). The captured
+     * stdout/stderr stay raw — the harness classifier depends on the raw
+     * traceback. Unrecognized tracebacks always echo verbatim. Opted into by
+     * the test dispatchers only.
+     */
+    annotateKnownTeardownNoise?: boolean;
 }
 /**
  * Result of running a mach command while capturing streamed output.

package/dist/src/core/mach.js

@@ -7,6 +7,7 @@ import { exec, execInherit, execInheritCapture, execSmokeRun, execStream, } from
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
 import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
 import { explainMachError } from './mach-error-hints.js';
+import { createKnownTeardownNoiseFilter, createTeardownNoiseContext, } from './mach-known-noise-filter.js';
 import { getPython } from './mach-python.js';
 import { installMachResourceGuard } from './mach-resource-shim.js';
 import { detectHarnessCrashSignature } from './test-harness-crash.js';
@@ -42,7 +43,12 @@ export async function runMach(args, engineDir, options = {}) {
         ...(options.env ? { env: options.env } : {}),
     };
     if (options.inherit) {
-        return execInherit(python, [machPath, ...args], execOptions);
+        // Group-reap every long-lived inherited mach dispatch (bootstrap, run,
+        // watch): a mach dying at startup must not strand multiprocessing
+        // workers. Short-lived metadata queries below stay on plain exec() —
+        // adding groups there would touch every non-mach exec consumer's path
+        // for no reaping benefit.
+        return execInherit(python, [machPath, ...args], { ...execOptions, processGroup: true });
     }
     const result = await exec(python, [machPath, ...args], execOptions);
     return result.exitCode;
@@ -67,24 +73,47 @@ export async function runMachCapture(args, engineDir, options = {}) {
     const machPath = join(engineDir, 'mach');
     let stdout = '';
     let stderr = '';
+    // Echo-path filters only: the captured strings above accumulate RAW so the
+    // classifier still sees the full teardown traceback. When the option is
+    // off, the filters are absent and echo is a straight write (unchanged).
+    // One shutdown context per run, shared by both stream filters: the
+    // SUITE_END marker usually arrives on stdout while the teardown traceback
+    // lands on stderr, so the shutdown-seen flag must span the pair.
+    const noiseContext = options.annotateKnownTeardownNoise === true ? createTeardownNoiseContext() : undefined;
+    const stdoutFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
+    const stderrFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
     const exitCode = await execStream(python, [machPath, ...args], {
         cwd: engineDir,
         ...(options.env ? { env: options.env } : {}),
+        // Every capture dispatch (test suites, protected builds, package,
+        // storybook) runs as a process-group leader and is group-reaped on
+        // exit/abort — see ExecOptions.processGroup (0.37.0 item 9a).
+        processGroup: true,
         onStdout: (data) => {
             stdout += data;
             if (stdout.length > CAPTURE_TAIL_LIMIT) {
                 stdout = stdout.slice(-CAPTURE_TAIL_LIMIT);
             }
-            process.stdout.write(data);
+            process.stdout.write(stdoutFilter ? stdoutFilter.transform(data) : data);
         },
         onStderr: (data) => {
             stderr += data;
             if (stderr.length > CAPTURE_TAIL_LIMIT) {
                 stderr = stderr.slice(-CAPTURE_TAIL_LIMIT);
             }
-            process.stderr.write(data);
+            process.stderr.write(stderrFilter ? stderrFilter.transform(data) : data);
         },
     });
+    if (stdoutFilter) {
+        const residue = stdoutFilter.flush();
+        if (residue.length > 0)
+            process.stdout.write(residue);
+    }
+    if (stderrFilter) {
+        const residue = stderrFilter.flush();
+        if (residue.length > 0)
+            process.stderr.write(residue);
+    }
     return { stdout, stderr, exitCode };
 }
 /**
@@ -99,6 +128,7 @@ export async function runMachInheritCapture(args, engineDir, options = {}) {
     return execInheritCapture(python, [machPath, ...args], {
         cwd: engineDir,
         ...(options.env ? { env: options.env } : {}),
+        processGroup: true,
     });
 }
 /**
@@ -363,6 +393,7 @@ export async function testWithOutput(engineDir, testPaths = [], args = [], env)
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['test', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }
 /**
@@ -379,6 +410,7 @@ export async function xpcshellTestWithOutput(engineDir, testPaths = [], args = [
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['xpcshell-test', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }
 /**
@@ -390,5 +422,6 @@ export async function mochitestWithOutput(engineDir, testPaths = [], args = [],
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['mochitest', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }

package/dist/src/core/patch-lint-cross.js

@@ -343,6 +343,14 @@ function findMatchingStagedDependency(entry, sitePath, specifier, laterOwners) {
         laterOwners.some((owner) => owner.fullPath === dependency.creates &&
             (dependency.owner === undefined || dependency.owner === owner.filename)));
 }
+/**
+ * Later-in-apply-order predicate shared by the forward-import scan and the
+ * registration validation: strictly higher ordinal, or same ordinal with a
+ * lexicographically later filename (the apply loop's tiebreak).
+ */
+function isLaterOwner(owner, entry) {
+    return (owner.order > entry.order || (owner.order === entry.order && owner.filename > entry.filename));
+}
 /** Builds the basename → later-creators index used by the forward-import scan. */
 function buildNewFileIndex(ctx) {
     const newFileIndex = new Map();
@@ -382,8 +390,7 @@ function eachForwardImportSite(ctx, newFileIndex, visit) {
             const owners = newFileIndex.get(leaf);
             if (!owners)
                 continue;
-            const laterOwners = owners.filter((owner) => owner.order > entry.order ||
-                (owner.order === entry.order && owner.filename > entry.filename));
+            const laterOwners = owners.filter((owner) => isLaterOwner(owner, entry));
             if (laterOwners.length === 0)
                 continue;
             visit(entry, sitePath, specifier, cleaned, laterOwners);
@@ -477,9 +484,80 @@ export function lintPatchQueueForwardImports(ctx) {
                 severity: 'warning',
             });
         }
+        // Registration-kind declarations (0.37.0 item 5): a jar.mn packaging
+        // line, customElements registration, or actor registration referencing
+        // a later-created file. There is no import specifier to match — the
+        // declaration is "used" when the declared line (whitespace-trimmed)
+        // appears among the lines this patch adds to the declaring file AND
+        // its `creates` resolves to a file a later-ordered patch actually
+        // creates (with `owner`, when set, naming that patch) — mirroring
+        // findMatchingStagedDependency for the import kind.
+        for (const registration of entry.metadata?.stagedDependencies?.registrations ?? []) {
+            const failure = findStagedRegistrationFailure(entry, registration, newFileIndex);
+            if (failure === undefined)
+                continue;
+            issues.push({
+                file: registration.file,
+                check: 'staged-dependency-unused',
+                fingerprint: `staged-dependency-unused|${entry.filename}|${registration.file}|reg:${registration.line}|${registration.creates}|${registration.owner ?? ''}`,
+                message: `${entry.filename} declares a staged registration in ${registration.file} ` +
+                    `("${registration.line}") for ${registration.creates}, but ${describeRegistrationFailure(failure)} ` +
+                    'Remove the stale declaration with "fireforge patch staged-dependency --remove --kind registration" or update it to match the patch and queue.',
+                severity: 'warning',
+            });
+        }
     }
     return issues;
 }
+/**
+ * Validates one registration-kind declaration against the patch content
+ * and the queue, mirroring {@link findMatchingStagedDependency}: the
+ * declared line must be added by this patch, `creates` must exactly match
+ * a file a LATER-ordered patch creates (an earlier-only creator means the
+ * dependency is already satisfied and the declaration is stale), and
+ * `owner`, when set, must name one of those creating patches. Returns
+ * undefined when valid.
+ */
+function findStagedRegistrationFailure(entry, registration, newFileIndex) {
+    if (!isRegistrationLinePresent(entry, registration))
+        return { kind: 'line-absent' };
+    const creators = (newFileIndex.get(basename(registration.creates)) ?? []).filter((owner) => owner.fullPath === registration.creates && isLaterOwner(owner, entry));
+    if (creators.length === 0)
+        return { kind: 'creates-unresolved' };
+    if (registration.owner !== undefined &&
+        !creators.some((owner) => owner.filename === registration.owner)) {
+        return { kind: 'owner-mismatch', creators };
+    }
+    return undefined;
+}
+/** Message tail for each {@link StagedRegistrationFailure} shape. */
+function describeRegistrationFailure(failure) {
+    switch (failure.kind) {
+        case 'line-absent':
+            return 'the patch does not add that line.';
+        case 'creates-unresolved':
+            return ('no later-ordered patch creates that file — the declaration is stale, ' +
+                'or the queue order no longer stages it.');
+        case 'owner-mismatch':
+            return `that file is created by ${failure.creators.map((o) => o.filename).join(', ')}, not the declared owner.`;
+    }
+}
+/**
+ * True when the declared registration/packaging line appears (trimmed)
+ * among the lines the patch introduces in the declaring file — either as a
+ * newly-created file's content or as added lines to an existing file
+ * (where jar.mn / customElements.js / actor-registration edits land).
+ */
+function isRegistrationLinePresent(entry, registration) {
+    const declared = registration.line.trim();
+    if (declared.length === 0)
+        return false;
+    const introduced = [
+        entry.newFiles.get(registration.file),
+        entry.modifiedFileAdditions.get(registration.file),
+    ];
+    return introduced.some((content) => content !== undefined && content.split('\n').some((line) => line.trim() === declared));
+}
 /**
  * Cross-patch lint orchestrator. Runs every cross-patch rule against the
  * provided context and returns combined issues.

package/dist/src/core/patch-manifest-io.d.ts

@@ -102,8 +102,9 @@ export interface PatchRenameEntry {
     newOrder: number;
 }
 /**
- * Rewrites `stagedDependencies.forwardImports[].owner` references on one
- * patch through a rename lookup. Owners embed exact patch filenames, so any
+ * Rewrites `stagedDependencies.forwardImports[].owner` and
+ * `stagedDependencies.registrations[].owner` references on one patch
+ * through a rename lookup. Owners embed exact patch filenames, so any
  * renumber (compact, reorder, placement export, rename) that does not remap
  * them leaves dangling references that surface as false forward-import
  * errors on the next lint.

package/dist/src/core/patch-manifest-io.js

@@ -192,8 +192,9 @@ export async function removePatchFromManifest(patchesDir, filename) {
     return true;
 }
 /**
- * Rewrites `stagedDependencies.forwardImports[].owner` references on one
- * patch through a rename lookup. Owners embed exact patch filenames, so any
+ * Rewrites `stagedDependencies.forwardImports[].owner` and
+ * `stagedDependencies.registrations[].owner` references on one patch
+ * through a rename lookup. Owners embed exact patch filenames, so any
  * renumber (compact, reorder, placement export, rename) that does not remap
  * them leaves dangling references that surface as false forward-import
  * errors on the next lint.
@@ -207,25 +208,35 @@ export async function removePatchFromManifest(patchesDir, filename) {
  * @returns The same row, or a copy with remapped owners
  */
 export function rewriteStagedDependencyOwners(patch, renameLookup) {
-    const forwardImports = patch.stagedDependencies?.forwardImports;
-    if (!forwardImports || forwardImports.length === 0)
+    const staged = patch.stagedDependencies;
+    if (!staged)
         return patch;
-    const rewritten = forwardImports.map((fi) => {
-        if (!fi.owner)
-            return fi;
-        const newOwner = renameLookup(fi.owner);
-        if (newOwner === undefined || newOwner === fi.owner)
-            return fi;
-        return { ...fi, owner: newOwner };
-    });
-    const changed = rewritten.some((fi, index) => fi !== forwardImports[index]);
-    if (!changed)
+    const rewriteOwners = (entries) => {
+        if (!entries || entries.length === 0)
+            return { entries, changed: false };
+        const rewritten = entries.map((entry) => {
+            if (!entry.owner)
+                return entry;
+            const newOwner = renameLookup(entry.owner);
+            if (newOwner === undefined || newOwner === entry.owner)
+                return entry;
+            return { ...entry, owner: newOwner };
+        });
+        return {
+            entries: rewritten,
+            changed: rewritten.some((entry, index) => entry !== entries[index]),
+        };
+    };
+    const forwardImports = rewriteOwners(staged.forwardImports);
+    const registrations = rewriteOwners(staged.registrations);
+    if (!forwardImports.changed && !registrations.changed)
         return patch;
     return {
         ...patch,
         stagedDependencies: {
-            ...patch.stagedDependencies,
-            forwardImports: rewritten,
+            ...staged,
+            ...(forwardImports.entries !== undefined ? { forwardImports: forwardImports.entries } : {}),
+            ...(registrations.entries !== undefined ? { registrations: registrations.entries } : {}),
         },
     };
 }

package/dist/src/core/patch-manifest-validate.js

@@ -24,13 +24,37 @@ function parseForwardImports(data, label) {
         return dependency;
     });
 }
+function parseRegistrations(data, label) {
+    if (!isArray(data)) {
+        throw new Error(`${label} must be an array`);
+    }
+    return data.map((entry, index) => {
+        const rec = parseObject(entry, `${label}[${index}]`);
+        const dependency = {
+            file: rec.string('file'),
+            line: rec.string('line'),
+            creates: rec.string('creates'),
+        };
+        const owner = rec.optionalString('owner');
+        if (owner !== undefined)
+            dependency.owner = owner;
+        const reason = rec.optionalString('reason');
+        if (reason !== undefined)
+            dependency.reason = reason;
+        return dependency;
+    });
+}
 function parseStagedDependencies(data, label) {
     const rec = parseObject(data, label);
     const rawForwardImports = rec.raw('forwardImports');
+    const rawRegistrations = rec.raw('registrations');
     const staged = {};
     if (rawForwardImports !== undefined) {
         staged.forwardImports = parseForwardImports(rawForwardImports, `${label}.forwardImports`);
     }
+    if (rawRegistrations !== undefined) {
+        staged.registrations = parseRegistrations(rawRegistrations, `${label}.registrations`);
+    }
     return staged;
 }
 /**

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

@@ -34,6 +34,14 @@ export interface HarnessRunVerdict {
     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;
     /**
@@ -104,6 +112,14 @@ export declare function analyzeTestCompleteness(output: string, requestedPaths:
     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.

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

@@ -294,6 +294,58 @@ function realUnexpectedFailureLines(output) {
     }
     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)) {
@@ -397,6 +449,7 @@ export function detectHarnessCrashSignature(output) {
 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) {
@@ -431,6 +484,7 @@ export function classifyHarnessRun(exitCode, output, requestedPaths) {
             return {
                 kind: 'test-failures',
                 ...(firstRealFailure !== undefined ? { realFailureLine: firstRealFailure } : {}),
+                ...(failureBlocks.length > 0 ? { realFailureBlocks: failureBlocks } : {}),
                 ...(secondaryHarnessSignature !== undefined ? { secondaryHarnessSignature } : {}),
                 greenSummaryRejected: {
                     ...(crashLine !== undefined ? { crashLine } : {}),
@@ -444,6 +498,7 @@ export function classifyHarnessRun(exitCode, output, requestedPaths) {
     return {
         kind: 'test-failures',
         ...(firstRealFailure !== undefined ? { realFailureLine: firstRealFailure } : {}),
+        ...(failureBlocks.length > 0 ? { realFailureBlocks: failureBlocks } : {}),
         ...(secondaryHarnessSignature !== undefined ? { secondaryHarnessSignature } : {}),
     };
 }