@hominis/fireforge 0.17.0 → 0.18.1

package/dist/src/commands/furnace/rename-xpcshell.js

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * xpcshell scaffold rename helper extracted from `rename.ts`.
+ *
+ * 2026-04-24 eval Finding 5: `furnace create --with-tests --xpcshell`
+ * writes a scaffold at `browser/base/content/test/<binary>-xpcshell/
+ * <name>/` and `furnace rename` did not update it. The helper below
+ * renames the directory, updates the test filename, rewrites the
+ * `xpcshell.toml` section header, and re-writes the test body so word-
+ * boundary occurrences of the old tag / underscored name map to the new
+ * ones.
+ *
+ * Extracted to keep `rename.ts` under the per-file LOC budget —
+ * `rename.ts` already carries mochikit + browser-mochitest + FTL
+ * handling, and tacking xpcshell onto that tree pushed the file past
+ * the limit.
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { loadConfig } from '../../core/config.js';
+import { xpcshellTestParentDir } from '../../core/furnace-constants.js';
+import { snapshotFile } from '../../core/furnace-rollback.js';
+import { toError } from '../../utils/errors.js';
+import { ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
+import { info, warn } from '../../utils/logger.js';
+/** Escapes regex metacharacters so a user-supplied name stays literal. */
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Renames an xpcshell test scaffold in place. Moves the directory,
+ * rewrites the test filename, updates the `[test_name]` section header
+ * in `xpcshell.toml`, and word-boundary-rewrites occurrences of the
+ * old tag / old underscored name inside the test body.
+ *
+ * Best-effort: any failure logs a warning through the shared logger
+ * but never throws — the component rename itself has already succeeded
+ * at this point, and blocking on a test rewrite would leave the
+ * operator with a half-renamed component.
+ *
+ * @param engineDir - Absolute path to the engine directory under the project.
+ * @param projectRoot - Absolute path to the project root, used to load the binary name.
+ * @param oldName - Pre-rename component tag name.
+ * @param newName - Post-rename component tag name.
+ * @param journal - Rollback journal that the rename mutation writes to before touching files.
+ */
+export async function renameXpcshellTestFiles(engineDir, projectRoot, oldName, newName, journal) {
+    let forgeConfig;
+    try {
+        forgeConfig = await loadConfig(projectRoot);
+    }
+    catch {
+        return; // Cannot determine scaffold path without config.
+    }
+    const parentDir = join(engineDir, xpcshellTestParentDir(forgeConfig.binaryName));
+    if (!(await pathExists(parentDir)))
+        return;
+    const oldScaffoldDir = join(parentDir, oldName);
+    const newScaffoldDir = join(parentDir, newName);
+    if (!(await pathExists(oldScaffoldDir)))
+        return;
+    const oldUnderscored = oldName.replace(/-/g, '_');
+    const newUnderscored = newName.replace(/-/g, '_');
+    const oldTestFileName = `test_${oldUnderscored}_packaged.js`;
+    const newTestFileName = `test_${newUnderscored}_packaged.js`;
+    try {
+        await ensureDir(newScaffoldDir);
+        const entries = await readdir(oldScaffoldDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const oldFilePath = join(oldScaffoldDir, entry.name);
+            const renamedFileName = entry.name === oldTestFileName ? newTestFileName : entry.name;
+            const newFilePath = join(newScaffoldDir, renamedFileName);
+            await snapshotFile(journal, oldFilePath);
+            const body = await readText(oldFilePath);
+            let updated = body;
+            if (entry.name === 'xpcshell.toml') {
+                updated = updated.replace(new RegExp(`\\[${escapeRegex(`"${oldTestFileName}"`)}\\]`, 'g'), `["${newTestFileName}"]`);
+            }
+            else if (entry.name === oldTestFileName) {
+                const oldTagPattern = new RegExp(`(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, 'g');
+                updated = updated.replace(oldTagPattern, newName);
+                const oldUnderscoredPattern = new RegExp(`(?<![\\w])${escapeRegex(oldUnderscored)}(?![\\w])`, 'g');
+                updated = updated.replace(oldUnderscoredPattern, newUnderscored);
+            }
+            await writeText(newFilePath, updated);
+            await removeFile(oldFilePath);
+        }
+        await removeDir(oldScaffoldDir);
+        info(`Renamed xpcshell scaffold directory: ${xpcshellTestParentDir(forgeConfig.binaryName)}/${oldName} → ${xpcshellTestParentDir(forgeConfig.binaryName)}/${newName}`);
+    }
+    catch (error) {
+        warn(`Could not rename xpcshell scaffold — ${toError(error).message}. Rename the scaffold files manually if needed.`);
+    }
+}
+//# sourceMappingURL=rename-xpcshell.js.map

package/dist/src/commands/furnace/rename.js

@@ -3,9 +3,9 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { getFurnacePaths, loadFurnaceConfig, updateFurnaceState, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { isComponentSourceFile, resolveFtlDir, tagNameToClassName, } from '../../core/furnace-constants.js';
+import { isComponentSourceFile, resolveFtlChromeSubPath, resolveFtlDir, resolveFtlLocaleJarMnPath, tagNameToClassName, } from '../../core/furnace-constants.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation } from '../../core/furnace-operation.js';
-import { addCustomElementRegistration, addJarMnEntries, removeCustomElementRegistration, removeJarMnEntries, } from '../../core/furnace-registration.js';
+import { addCustomElementRegistration, addJarMnEntries, addLocaleFtlJarMnEntry, removeCustomElementRegistration, removeJarMnEntries, removeLocaleFtlJarMnEntry, } from '../../core/furnace-registration.js';
 import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
 import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { getStoriesDir } from '../../core/furnace-stories.js';
@@ -14,6 +14,7 @@ import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
 import { copyFile, ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
 import { info, intro, note, outro, warn } from '../../utils/logger.js';
+import { renameXpcshellTestFiles } from './rename-xpcshell.js';
 /** Escapes regex metacharacters so a user-supplied name is literal inside a RegExp. */
 function escapeRegex(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -272,7 +273,8 @@ async function performRenameMutations(args) {
             // 3. Update engine registrations (custom components only)
             if (isCustom && config.custom[newName]?.register && (await pathExists(args.engineDir))) {
                 const ftlDir = resolveFtlDir(config.ftlBasePath);
-                await updateEngineRegistrations(args.engineDir, oldName, newName, newDir, ftlDir, journal);
+                const isLocalized = config.custom[newName].localized;
+                await updateEngineRegistrations(args.engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal);
             }
             // 4. Re-key furnace-state.json checksums from old name to new name
             await rekeyStateChecksums(args.projectRoot, componentType, oldName, newName);
@@ -298,6 +300,14 @@ async function performRenameMutations(args) {
                 // either failed the test run outright or (worse) passed for the
                 // wrong component.
                 await renameMochikitTestFiles(args.engineDir, oldName, newName, journal);
+                // 2026-04-24 eval Finding 5: xpcshell scaffolds live in yet
+                // another tree (`browser/base/content/test/<binary>-xpcshell/
+                // <name>/`). Before this call, renaming a component scaffolded
+                // with `--with-tests --xpcshell` left a directory whose name
+                // still referenced the pre-rename component, plus a test file
+                // whose underscored name referenced the old tag — both of
+                // which then failed to match the new component.
+                await renameXpcshellTestFiles(args.engineDir, projectRoot, oldName, newName, journal);
                 // Clear the stale deployed component directory so the next
                 // `furnace apply` is the single writer of the new name's
                 // deployment. Without this, eval runs showed the old widget
@@ -358,7 +368,7 @@ async function rekeyStateChecksums(projectRoot, componentType, oldName, newName)
         return result;
     });
 }
-async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ftlDir, journal) {
+async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal) {
     const customElementsPath = join(engineDir, 'toolkit/content/customElements.js');
     const jarMnPath = join(engineDir, 'toolkit/content/jar.mn');
     if (await pathExists(customElementsPath)) {
@@ -386,6 +396,24 @@ async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ft
         await writeText(newFtlPath, ftlContent);
         await removeFile(oldFtlPath);
     }
+    // Re-wire the locale jar.mn chrome registration when the component is
+    // localized. Before this, `updateEngineRegistrations` renamed the .ftl
+    // file on disk but left the locale jar.mn pointing at
+    // `locale/.../${oldName}.ftl`, so `furnace validate` passed while the
+    // engine still carried a stale registration for the now-missing file
+    // (eval finding: stale old-name registration after rename).
+    if (isLocalized) {
+        const chromeSubPath = resolveFtlChromeSubPath(ftlDir);
+        const localeJarRel = resolveFtlLocaleJarMnPath(ftlDir);
+        if (chromeSubPath !== undefined && localeJarRel !== undefined) {
+            const localeJarAbs = join(engineDir, localeJarRel);
+            if (await pathExists(localeJarAbs)) {
+                await snapshotFile(journal, localeJarAbs);
+                await removeLocaleFtlJarMnEntry(engineDir, localeJarRel, oldName, chromeSubPath);
+                await addLocaleFtlJarMnEntry(engineDir, localeJarRel, newName, chromeSubPath);
+            }
+        }
+    }
 }
 /**
  * Renames a custom or override component atomically: updates directory name,

package/dist/src/commands/lint.js

@@ -5,9 +5,9 @@ import { isBrandingManagedPath } from '../core/branding.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { getStatusWithCodes, hasChanges, isGitRepository } from '../core/git.js';
 import { getAllDiff, getDiffForFilesAgainstHead } from '../core/git-diff.js';
-import { getModifiedFiles, getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, } from '../core/git-status.js';
+import { expandUntrackedDirectoryEntries, getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, getWorkingTreeStatus, } from '../core/git-status.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
-import { buildPatchQueueContext, lintExportedPatch, lintPatchQueue } from '../core/patch-lint.js';
+import { buildPatchQueueContext, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
 import { collectDiffFilePaths, tagLintIssues } from '../core/patch-lint-diff-tag.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { GeneralError } from '../errors/base.js';
@@ -103,10 +103,17 @@ async function resolveLintDiff(engineDir, files, binaryName) {
     // survive in the patch queue as-is. The exclusion mirrors the
     // `branding` bucket in `fireforge status` so the two views stay
     // consistent.
+    //
+    // `expandUntrackedDirectoryEntries` promotes collapsed `?? dir/`
+    // status rows to individual file entries before the diff pass.
+    // Without it, a patch that introduces a new directory shows up as
+    // `?? browser/modules/<fork>/` and `getDiffForFilesAgainstHead`
+    // crashed with EISDIR reading the directory as if it were a file
+    // (eval finding: aggregate lint unusable on a real imported queue).
     if (binaryName) {
-        const modified = await getModifiedFiles(engineDir);
-        const untracked = await getUntrackedFiles(engineDir);
-        const allPaths = [...new Set([...modified, ...untracked])];
+        const rawStatus = await getWorkingTreeStatus(engineDir);
+        const expanded = await expandUntrackedDirectoryEntries(engineDir, rawStatus);
+        const allPaths = [...new Set(expanded.map((entry) => entry.file))];
         const nonBrandingPaths = allPaths.filter((path) => !isBrandingManagedPath(path, binaryName));
         const excludedCount = allPaths.length - nonBrandingPaths.length;
         if (excludedCount > 0) {
@@ -315,7 +322,13 @@ async function lintPerPatch(projectRoot, paths) {
         if (!diff.trim())
             continue;
         const ignore = patch.lintIgnore?.length ? new Set(patch.lintIgnore) : undefined;
-        const patchIssues = await lintExportedPatch(paths.engine, existing, diff, config, ctx, ignore);
+        const decision = resolvePatchSizeTier(existing, patch.tier);
+        if (decision.tier === 'branding') {
+            info(decision.source === 'explicit'
+                ? `${patch.filename}: branding threshold tier applied via patches.json \`tier: "branding"\` opt-in.`
+                : `${patch.filename}: branding threshold tier applied (all files under browser/branding/ plus registration siblings).`);
+        }
+        const patchIssues = await lintExportedPatch(paths.engine, existing, diff, config, ctx, ignore, patch.tier);
         for (const issue of patchIssues) {
             issues.push({ ...issue, file: `${patch.filename} :: ${issue.file}` });
         }

package/dist/src/commands/patch/delete.js

@@ -39,7 +39,10 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     }
     const target = resolvePatchIdentifier(identifier, manifest.patches);
     if (!target) {
-        throw new InvalidArgumentError(`Patch "${identifier}" not found. Available: ${manifest.patches.map((p) => p.filename).join(', ')}`, identifier);
+        const available = manifest.patches
+            .map((p) => p.name && p.name !== p.filename ? `${p.filename} (name: ${p.name})` : p.filename)
+            .join(', ');
+        throw new InvalidArgumentError(`Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo). Available: ${available}`, identifier);
     }
     // Build the full queue context once so we can scan each patch's newFiles
     // without re-parsing for the dependency check below.

package/dist/src/commands/patch/reorder.js

@@ -270,7 +270,10 @@ export async function patchReorderCommand(projectRoot, identifier, options = {})
     }
     const target = resolvePatchIdentifier(identifier, manifest.patches);
     if (!target) {
-        throw new InvalidArgumentError(`Patch "${identifier}" not found. Available: ${manifest.patches.map((p) => p.filename).join(', ')}`, identifier);
+        const available = manifest.patches
+            .map((p) => p.name && p.name !== p.filename ? `${p.filename} (name: ${p.name})` : p.filename)
+            .join(', ');
+        throw new InvalidArgumentError(`Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo). Available: ${available}`, identifier);
     }
     const { destinationOrder, anchorFilename } = resolveDestination(target, manifest.patches, options);
     const renameMap = computeRenameMap(manifest.patches, target, destinationOrder);

package/dist/src/commands/re-export-files.js

@@ -75,8 +75,10 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     // `lintIgnore` threads through so a shrink of an advisory-noisy-but-
     // intentional patch (branding bundle, localised-resource pack) does not
     // have to choose between `--skip-lint` (blunt) and the full rebase path.
+    // `target.tier` threads the explicit branding-threshold opt-in for
+    // the branding patch that also touches a non-allowlisted sibling.
     const ignoreChecks = target.lintIgnore?.length ? new Set(target.lintIgnore) : undefined;
-    await runPatchLint(paths.engine, actualProjectedFiles, projectedDiff, config, options.skipLint, undefined, ignoreChecks);
+    await runPatchLint(paths.engine, actualProjectedFiles, projectedDiff, config, options.skipLint, undefined, ignoreChecks, target.tier);
     // Project the cross-patch context: replace the target entry with its
     // would-be shrunken self (new diff + new newFiles + new
     // modifiedFileAdditions). The projected entry must repopulate both

package/dist/src/commands/re-export.js

@@ -201,8 +201,11 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
     // intentional patch (a cohesive branding bundle, a localised-resource
     // pack) without either `--skip-lint` (too blunt) or falling through to
     // the full `rebase` flow (which internally skips the lint pipeline).
+    // The paired `patch.tier` threads the explicit branding-threshold
+    // opt-in the same way, for the branding patch that also touches a
+    // non-allowlisted registration sibling.
     const ignoreChecks = patch.lintIgnore?.length ? new Set(patch.lintIgnore) : undefined;
-    await runPatchLint(paths.engine, existingFiles, diffContent, config, options.skipLint, undefined, ignoreChecks);
+    await runPatchLint(paths.engine, existingFiles, diffContent, config, options.skipLint, undefined, ignoreChecks, patch.tier);
     if (isDryRun) {
         info(`[dry-run] ${patch.filename}: ${existingFiles.length} file(s)`);
     }

package/dist/src/commands/rebase/index.js

@@ -12,7 +12,7 @@
  */
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.js';
-import { getHead, isGitRepository, resetChanges } from '../../core/git.js';
+import { getHead, isGitRepository, isMissingHeadError, resetChanges } from '../../core/git.js';
 import { discoverPatches } from '../../core/patch-files.js';
 import { loadPatchesManifest } from '../../core/patch-manifest.js';
 import { hasActiveRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
@@ -40,6 +40,24 @@ async function handleFreshStart(projectRoot, options) {
     if (!(await isGitRepository(paths.engine))) {
         throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
     }
+    // 2026-04-24 eval Finding 11: `rebase --dry-run` used to print
+    // "Dry run complete" without validating that the engine had a valid
+    // HEAD. A previous `download --force` abort could leave `.git/`
+    // initialized but unborn (no baseline commit); the real rebase then
+    // failed immediately with `fatal: ambiguous argument 'HEAD'` on the
+    // first `git rev-parse HEAD` call. Replicate the same baseline check
+    // here so dry-run mirrors the real-run preconditions and operators
+    // cannot mistake a broken baseline for a ready-to-rebase tree.
+    try {
+        await getHead(paths.engine);
+    }
+    catch (err) {
+        if (isMissingHeadError(err)) {
+            throw new GeneralError('Engine repository has no baseline commit yet — a previous "fireforge download" was interrupted before git created the initial Firefox source commit. ' +
+                'Re-run "fireforge download --force" to recreate the baseline repository cleanly, then retry the rebase.');
+        }
+        throw err;
+    }
     const config = await loadConfig(projectRoot);
     const currentVersion = config.firefox.version;
     const manifest = await loadPatchesManifest(paths.patches);

package/dist/src/commands/register.js

@@ -45,6 +45,17 @@ export async function registerCommand(projectRoot, filePath, options = {}) {
     }
     const result = await registerFile(projectRoot, engineRelativePath, options.dryRun, options.after);
     if (options.dryRun) {
+        // 2026-04-21 eval (Finding #8): dry-run always said "Would
+        // register" even when the rule's idempotency check already knew
+        // the entry was present, so automation read the plan as "work to
+        // do" and the following real run then reported "Already
+        // registered". Surface the idempotency decision in dry-run too so
+        // the plan mirrors the real command's outcome.
+        if (result.skipped) {
+            info(`[dry-run] Already registered: ${engineRelativePath} in ${result.manifest}`);
+            outro('Dry run complete');
+            return;
+        }
         info(`[dry-run] Would register ${engineRelativePath}`);
         info(`  manifest: ${result.manifest}`);
         info(`  entry: ${result.entry}`);

package/dist/src/commands/status.js

@@ -70,11 +70,39 @@ async function printUnregisteredWarnings(files, projectRoot, binaryName) {
     if (newFiles.length === 0)
         return;
     const registrableFiles = newFiles.filter((f) => matchesRegistrablePattern(f.file, binaryName));
-    const registrationChecks = await Promise.all(registrableFiles.map(async (f) => ({
-        file: f.file,
-        registered: await isFileRegistered(projectRoot, f.file),
-    })));
-    const unregistered = registrationChecks.filter((f) => !f.registered);
+    // `isFileRegistered` throws `GeneralError("Manifest not found: ...")` when a
+    // rule sees a file whose parent manifest does not yet exist on disk — e.g.
+    // a brand-new `browser/modules/<binary>/` directory with no `moz.build`.
+    // `status` is a read-only reporter; before 0.18.1 the rejected promise
+    // bubbled through `Promise.all` and exited status with code 1, breaking the
+    // "use status --unmanaged to discover new files before running register"
+    // workflow. We now bucket missing-manifest cases into a distinct warning
+    // list while still surfacing the same actionable signal. Other error
+    // shapes continue to propagate (permission denied, corrupt file, etc.) so
+    // we do not silently hide anything surprising.
+    const registrationChecks = await Promise.all(registrableFiles.map(async (f) => {
+        try {
+            return {
+                file: f.file,
+                registered: await isFileRegistered(projectRoot, f.file),
+                manifestMissing: false,
+                manifestMissingMessage: undefined,
+            };
+        }
+        catch (err) {
+            if (err instanceof GeneralError && /^Manifest not found:/i.test(err.message)) {
+                return {
+                    file: f.file,
+                    registered: false,
+                    manifestMissing: true,
+                    manifestMissingMessage: err.message,
+                };
+            }
+            throw err;
+        }
+    }));
+    const unregistered = registrationChecks.filter((f) => !f.registered && !f.manifestMissing);
+    const manifestMissing = registrationChecks.filter((f) => f.manifestMissing);
     if (unregistered.length > 0) {
         info('');
         warn('Potentially unregistered files:');
@@ -82,6 +110,17 @@ async function printUnregisteredWarnings(files, projectRoot, binaryName) {
             info(`  ${f.file} — run 'fireforge register ${f.file}'`);
         }
     }
+    if (manifestMissing.length > 0) {
+        info('');
+        warn('Files whose registration manifest does not exist yet:');
+        for (const f of manifestMissing) {
+            // `manifestMissingMessage` is always the specific
+            // "Manifest not found: <path>" string when manifestMissing is
+            // true (see the catch branch above that sets them together).
+            info(`  ${f.file} — ${f.manifestMissingMessage}`);
+            info(`    Create the parent manifest, then run 'fireforge register ${f.file}'.`);
+        }
+    }
 }
 /**
  * Renders raw worktree status as machine-parseable porcelain-style output.

package/dist/src/commands/test.js

@@ -4,13 +4,13 @@ import { prepareBuildEnvironment } from '../core/build-prepare.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { buildArtifactMismatchMessage, buildUI, hasBuildArtifacts, testWithOutput, } from '../core/mach.js';
 import { assertMarionettePortAvailable } from '../core/marionette-port.js';
-import { reportMarionettePreflight, runMarionettePreflight } from '../core/marionette-preflight.js';
+import { formatMarionettePreflightLine, reportMarionettePreflight, runMarionettePreflight, } from '../core/marionette-preflight.js';
 import { checkStaleBuildForTest, formatStaleBuildWarning } from '../core/test-stale-check.js';
 import { operatorAlreadySetAppPath, resolveXpcshellAppdirArg, } from '../core/xpcshell-appdir.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { pathExists } from '../utils/fs.js';
-import { info, intro, outro, spinner, warn } from '../utils/logger.js';
+import { info, intro, outro, spinner, success, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 import { stripEnginePrefix } from '../utils/paths.js';
 async function assertTestPathsExist(engineDir, testPaths) {
@@ -47,6 +47,32 @@ function hasStaleBuildArtifactsSignal(output) {
     return (/chrome:\/\/branding\/locale\/brand\.properties/i.test(output) ||
         /browser\/branding\/[^/\s]+\/moz\.build/i.test(output));
 }
+/**
+ * Fork-module-not-registered signal. 2026-04-21 eval Finding #14:
+ * a hominis test failed with `Failed to load resource:///modules/hominis/
+ * HominisStore.sys.mjs`. The branding pattern happened to also match
+ * because the test harness printed a branding warning during its
+ * teardown, and the stale-build branch won by precedence — telling the
+ * operator to rebuild when the real fix is to register the module in
+ * the fork's `browser/modules/<binary>/moz.build`. Match a
+ * `resource:///modules/<binaryName>/` pattern so fork-owned module
+ * failures surface the right diagnosis.
+ */
+function hasForkModuleSignal(output, binaryName) {
+    const pattern = new RegExp(`Failed to load resource:\\/\\/\\/modules\\/${binaryName.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}\\/`, 'i');
+    return pattern.test(output);
+}
+function buildForkModuleMessage(binaryName) {
+    return (`Test failed to load a fork-owned module at resource:///modules/${binaryName}/*.sys.mjs.\n\n` +
+        'This is almost always a module-registration issue, not a stale build. The fork module directory is missing an entry that maps its file into the resource URI tree, so `ChromeUtils.importESModule` cannot resolve it.\n\n' +
+        'Check that:\n' +
+        `  - browser/modules/${binaryName}/moz.build lists the missing module in EXTRA_JS_MODULES.\n` +
+        `  - browser/modules/moz.build references the ${binaryName}/ subdirectory (DIRS += [...]).\n` +
+        '  - The last `fireforge build` (or `fireforge build --ui`) completed successfully against the current manifests. If the registration is new, the UI-faster build path may not pick it up — a full build may be required.\n\n' +
+        'Use `fireforge register browser/modules/' +
+        binaryName +
+        '/<file>.sys.mjs` to add the EXTRA_JS_MODULES entry if it is missing.');
+}
 // Detects the broader xpcshell symptom where every `resource:///modules/...`
 // import fails — the signature of xpcshell running with the wrong app-dir on
 // a manifest that sets `firefox-appdir = "browser"`. Checked AFTER the
@@ -56,17 +82,22 @@ function hasXpcshellAppdirSignal(output) {
     return /Failed to load resource:\/\/\/modules\//i.test(output);
 }
 function buildXpcshellAppdirMessage(injectionAttempted) {
+    const isMacos = process.platform === 'darwin';
+    const macosNote = isMacos
+        ? 'Detected: macOS host. On macOS the xpcshell harness binds `-a` to `<obj>/dist/<App>.app/Contents/Resources` by default and frequently ignores `--app-path` overrides when the `.app` bundle is present — the surest fix is the `<appname>-appdir` migration below rather than trying to force a different path.\n\n'
+        : '';
     const triggerLines = injectionAttempted
-        ? 'FireForge auto-injected `--app-path=<absolute>` against the resolved obj-dir before mach test ran, but the failure persists. The injected path either does not match the appdir layout your harness expects, or the harness was built against a layout FireForge cannot probe (omni.ja-packed tree, alternate `dist/` shape).\n\n'
+        ? 'FireForge auto-injected `--app-path=<absolute>` against the resolved obj-dir before mach test ran, but the failure persists. The injected path either does not match the appdir layout your harness expects, or (on macOS) the harness bound `-a` to the `.app/Contents/Resources` default and ignored the override.\n\n'
         : 'Likely triggers:\n' +
             '  - The nearest xpcshell.toml sets `firefox-appdir = "browser"` but the harness reads `<appname>-appdir` instead — the literal `firefox-appdir` directive is silently ignored on rebranded forks (appname != "firefox").\n' +
             '  - FireForge could not find an xpcshell.toml above the test path, so the auto-injection never ran.\n\n';
     return ('xpcshell failed to load core resource:///modules/*.sys.mjs imports.\n\n' +
         'This is the canonical symptom of xpcshell running with the wrong app directory: the runtime resolves `resource:///modules/` against the parent of the expected app root, so every `ChromeUtils.importESModule("resource:///modules/…")` throws.\n\n' +
+        macosNote +
         triggerLines +
         'Options:\n' +
-        '  - Add `<appname>-appdir = "browser"` alongside `firefox-appdir = "browser"` in the xpcshell.toml [DEFAULT] so the harness reads the appname-keyed value directly.\n' +
-        '  - Pass overrides through `fireforge test <path> --mach-arg="--app-path=<absolute>"` to inject the path verbatim (operator overrides always win over auto-injection).\n' +
+        '  - Add `<appname>-appdir = "browser"` alongside `firefox-appdir = "browser"` in the xpcshell.toml [DEFAULT] so the harness reads the appname-keyed value directly. This is the most reliable fix on rebranded macOS builds.\n' +
+        '  - Pass overrides through `fireforge test <path> --mach-arg="--app-path=<absolute>"` to inject the path verbatim (operator overrides always win over auto-injection, but see the macOS caveat above).\n' +
         '  - Remove `firefox-appdir = "browser"` from the xpcshell.toml [DEFAULT] and move browser-chrome dependencies into a browser-chrome mochitest (see `fireforge furnace create --test-style=browser-chrome`).\n' +
         '  - If the test only touches toolkit chrome (chrome://global/*), drop the `firefox-appdir` setting entirely — toolkit chrome is registered without it.');
 }
@@ -87,13 +118,22 @@ function buildMochitestHttp3ServerMessage() {
         "  - The `BROWSER_CHROME_MANIFESTS` entry for your fork's chrome.manifest is registered.\n\n" +
         'This is an upstream Firefox harness interaction; FireForge can only diagnose it.');
 }
-function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted) {
+function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted, binaryName) {
     if (result.exitCode === 0 || result.exitCode === 130)
         return;
     const combinedOutput = `${result.stdout}\n${result.stderr}`;
     if (/UNKNOWN TEST\b/i.test(combinedOutput)) {
         throw new GeneralError(buildUnknownTestMessage(normalizedPaths));
     }
+    // Fork-owned module load failures must beat the branding stale-build
+    // branch: 2026-04-21 eval (Finding #14) saw a hominis test fail with
+    // `Failed to load resource:///modules/hominis/HominisStore.sys.mjs`
+    // while the harness teardown printed a branding warning that the old
+    // stale-build pattern matched, so the operator was told to rebuild
+    // when the real fix is to register the missing module.
+    if (hasForkModuleSignal(combinedOutput, binaryName)) {
+        throw new GeneralError(buildForkModuleMessage(binaryName));
+    }
     // Branding-specific stale-build signals keep priority over the broader
     // xpcshell-appdir hint: when `chrome://branding/locale/brand.properties`
     // fails to resolve, the fix really is "rebuild", not "pass --app-path".
@@ -157,8 +197,8 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     if (options.build) {
         await prepareBuildEnvironment(projectRoot, paths, projectConfig);
         const s = spinner('Running incremental build...');
-        const buildExitCode = await buildUI(paths.engine);
-        if (buildExitCode !== 0) {
+        const buildResult = await buildUI(paths.engine);
+        if (buildResult.exitCode !== 0) {
             s.error('Pre-test build failed');
             throw new BuildError('Pre-test build failed', 'mach build faster');
         }
@@ -193,20 +233,32 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // no paths are supplied this is the only step — it's the fastest way to tell
     // marionette-wedged apart from test-discovery-failure.
     if (options.doctor) {
+        // Write the "Running marionette preflight..." banner via
+        // `process.stdout.write` directly before `info()` so non-TTY captures
+        // always see the banner even if clack's renderer defers output in
+        // pipe mode. `info()` is still called so TTY users keep the normal
+        // clack box-drawing framing.
+        process.stdout.write('Running marionette preflight...\n');
         info('Running marionette preflight...');
         const preflight = await runMarionettePreflight(paths.engine);
+        // 2026-04-24 eval Finding 7: the pre-0.18.1 code used
+        // `success()` + `outro()` + a direct `process.stdout.write` as a
+        // belt-and-suspenders but still reproducibly dropped the PASS summary
+        // under non-TTY capture (observed: `tee`-wrapped eval output saw only
+        // the intro). The fix writes the authoritative PASS/FAIL line via
+        // `process.stdout.write` as the very first output after the probe
+        // returns, so the captured stream has an unambiguous summary no
+        // matter what clack does on top. The clack-rendered banner
+        // (`info`/`warn`) is retained so TTY users keep the visual framing.
+        const directLine = formatMarionettePreflightLine(preflight);
+        process.stdout.write(`${directLine}\n`);
         reportMarionettePreflight(preflight);
         if (testPaths.length === 0) {
             if (!preflight.ok) {
                 throw new GeneralError('Marionette preflight reported FAIL — see output above.');
             }
-            // Close the intro frame explicitly. Without an outro, clack's
-            // grouped-output mode left the PASS line hanging inside an
-            // unclosed tree — in the eval's non-TTY capture the info line
-            // itself failed to render, so `test --doctor` looked like it had
-            // exited silently after the spinner start line. The outro also
-            // gives scripts a deterministic "done" marker to parse.
-            outro(`Marionette preflight: PASS (${preflight.durationMs}ms)`);
+            success(directLine);
+            outro('Test completed');
             return;
         }
         if (!preflight.ok) {
@@ -256,7 +308,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     catch (error) {
         throw new BuildError('Test process failed to start', 'mach test', error instanceof Error ? error : undefined);
     }
-    handleNonZeroTestExit(result, normalizedPaths, appdirInjection);
+    handleNonZeroTestExit(result, normalizedPaths, appdirInjection, projectConfig.binaryName);
 }
 /**
  * Resolves and (when applicable) appends an `--app-path=<abs>` arg to

package/dist/src/commands/token-coverage.js

@@ -2,7 +2,8 @@
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { furnaceConfigExists, loadFurnaceConfig } from '../core/furnace-config.js';
-import { getStatusWithCodes, isGitRepository } from '../core/git.js';
+import { isGitRepository } from '../core/git.js';
+import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { measureTokenCoverage } from '../core/token-coverage.js';
 import { getTokensCssPath } from '../core/token-manager.js';
 import { GeneralError } from '../errors/base.js';
@@ -23,8 +24,14 @@ export async function tokenCoverageCommand(projectRoot) {
     }
     const config = await loadConfig(projectRoot);
     const tokensCssPath = getTokensCssPath(config.binaryName);
-    const files = await getStatusWithCodes(paths.engine);
-    const statusCssFiles = files
+    // Expand collapsed `?? dir/` untracked entries so untracked CSS files
+    // inside a new patch-added directory are included in coverage. Before
+    // this, an imported fork that added a new CSS tree saw "No modified
+    // CSS files" because `git status --porcelain` collapsed the directory
+    // and the file-extension filter could not see the .css inside.
+    const rawStatus = await getWorkingTreeStatus(paths.engine);
+    const expandedStatus = await expandUntrackedDirectoryEntries(paths.engine, rawStatus);
+    const statusCssFiles = expandedStatus
         .filter((f) => f.file.endsWith('.css') && f.file !== tokensCssPath)
         .map((f) => f.file);
     // Also scan CSS files deployed by Furnace custom components. Deployed