@hominis/fireforge 0.27.1 → 0.27.2

package/dist/src/commands/status-output.js

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { isFileRegistered, matchesRegistrablePattern } from '../core/manifest-rules.js';
+import { GeneralError } from '../errors/base.js';
+import { info, outro, warn } from '../utils/logger.js';
+const STATUS_DESCRIPTIONS = {
+    M: 'modified',
+    A: 'added',
+    D: 'deleted',
+    R: 'renamed',
+    C: 'copied',
+    U: 'unmerged',
+    '?': 'untracked',
+    '!': 'ignored',
+};
+function getStatusDescription(code) {
+    return STATUS_DESCRIPTIONS[code] ?? 'changed';
+}
+function getPrimaryStatusCode(status) {
+    if (status.includes('?'))
+        return '?';
+    if (status.includes('!'))
+        return '!';
+    for (const code of status) {
+        if (code !== ' ')
+            return code;
+    }
+    return status;
+}
+function isNewFileStatus(status) {
+    const code = getPrimaryStatusCode(status);
+    return code === '?' || code === 'A';
+}
+function groupFilesByStatus(files) {
+    const grouped = new Map();
+    for (const { status, file } of files) {
+        const code = getPrimaryStatusCode(status);
+        const existing = grouped.get(code) ?? [];
+        existing.push(file);
+        grouped.set(code, existing);
+    }
+    return grouped;
+}
+function printStatusGroups(files) {
+    const grouped = groupFilesByStatus(files);
+    for (const [status, fileList] of grouped) {
+        warn(`${getStatusDescription(status)}:`);
+        for (const file of fileList)
+            info(`  ${file}`);
+    }
+}
+async function printUnregisteredWarnings(files, projectRoot, binaryName) {
+    const newFiles = files.filter((f) => isNewFileStatus(f.status));
+    if (newFiles.length === 0)
+        return;
+    const registrableFiles = newFiles.filter((f) => matchesRegistrablePattern(f.file, binaryName));
+    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:');
+        for (const f of unregistered)
+            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) {
+            info(`  ${f.file} — ${f.manifestMissingMessage}`);
+            info(`    Create the parent manifest, then run 'fireforge register ${f.file}'.`);
+        }
+    }
+}
+/** Renders the unmanaged-only status view and registration hints. */
+export async function renderUnmanagedOnly(unmanagedFiles, totalModified, projectRoot, binaryName) {
+    info(`${unmanagedFiles.length} unmanaged file${unmanagedFiles.length === 1 ? '' : 's'} (${totalModified} total modified):\n`);
+    if (unmanagedFiles.length > 0) {
+        printStatusGroups(unmanagedFiles);
+        await printUnregisteredWarnings(unmanagedFiles, projectRoot, binaryName);
+    }
+    else {
+        info('No unmanaged changes');
+    }
+    outro(unmanagedFiles.length === 0
+        ? 'No unmanaged changes'
+        : `${unmanagedFiles.length} unmanaged change${unmanagedFiles.length === 1 ? '' : 's'}`);
+}
+/** Renders the default classified status buckets. */
+export async function renderDefaultStatus(totalModified, buckets, projectRoot, binaryName) {
+    const { conflict, unmanaged, patchBacked, patchOwnedDrift, branding, furnace } = buckets;
+    info(`${totalModified} modified file${totalModified === 1 ? '' : 's'}:\n`);
+    if (conflict.length > 0) {
+        warn('Cross-patch ownership conflicts (same file claimed by multiple patches):');
+        printStatusGroups(conflict);
+        for (const entry of conflict) {
+            if (entry.claimedBy && entry.claimedBy.length > 0) {
+                info(`  ${entry.file} — claimed by ${entry.claimedBy.join(', ')}`);
+            }
+        }
+        info('Run "fireforge status --ownership" for the full conflict table, then repartition with "fireforge re-export --files <paths> <patch>".');
+    }
+    if (unmanaged.length > 0) {
+        if (conflict.length > 0)
+            info('');
+        warn('Unmanaged changes:');
+        printStatusGroups(unmanaged);
+        await printUnregisteredWarnings(unmanaged, projectRoot, binaryName);
+    }
+    if (patchBacked.length > 0) {
+        if (conflict.length > 0 || unmanaged.length > 0)
+            info('');
+        warn('Patch-backed materialized changes:');
+        printStatusGroups(patchBacked);
+    }
+    if (patchOwnedDrift.length > 0) {
+        if (conflict.length > 0 || unmanaged.length > 0 || patchBacked.length > 0)
+            info('');
+        warn('Patch-owned drift:');
+        printStatusGroups(patchOwnedDrift);
+        info('These files are claimed by exactly one patch, but engine/ no longer matches that patch output. Re-export the owning patch after reviewing the manual resolution.');
+    }
+    if (branding.length > 0) {
+        if (conflict.length > 0 ||
+            unmanaged.length > 0 ||
+            patchBacked.length > 0 ||
+            patchOwnedDrift.length > 0) {
+            info('');
+        }
+        warn('Tool-managed branding changes:');
+        printStatusGroups(branding);
+    }
+    if (furnace.length > 0) {
+        if (conflict.length > 0 ||
+            unmanaged.length > 0 ||
+            patchBacked.length > 0 ||
+            patchOwnedDrift.length > 0 ||
+            branding.length > 0) {
+            info('');
+        }
+        warn('Furnace-managed component changes:');
+        printStatusGroups(furnace);
+    }
+    if (conflict.length === 0 &&
+        unmanaged.length === 0 &&
+        patchBacked.length === 0 &&
+        patchOwnedDrift.length === 0 &&
+        branding.length === 0 &&
+        furnace.length === 0) {
+        info('No changes');
+    }
+    const parts = [];
+    if (conflict.length > 0)
+        parts.push(`${conflict.length} conflict`);
+    if (unmanaged.length > 0)
+        parts.push(`${unmanaged.length} unmanaged`);
+    if (patchBacked.length > 0)
+        parts.push(`${patchBacked.length} patch-backed`);
+    if (patchOwnedDrift.length > 0)
+        parts.push(`${patchOwnedDrift.length} patch-owned drift`);
+    if (branding.length > 0)
+        parts.push(`${branding.length} branding`);
+    if (furnace.length > 0)
+        parts.push(`${furnace.length} furnace`);
+    outro(parts.join(', '));
+}
+//# sourceMappingURL=status-output.js.map

package/dist/src/commands/status.js

@@ -2,7 +2,6 @@ import { getProjectPaths, loadConfig } from '../core/config.js';
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
 import { getHead, getStatusWithCodes, isGitRepository, isMissingHeadError } from '../core/git.js';
 import { getUntrackedFilesInDir } from '../core/git-status.js';
-import { isFileRegistered, matchesRegistrablePattern } from '../core/manifest-rules.js';
 import { buildOwnershipTable, renderOwnershipTable } from '../core/ownership-table.js';
 import { buildPatchQueueContext, collectNewFileCreatorsByPath } from '../core/patch-lint.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
@@ -11,118 +10,7 @@ import { CommandError, GeneralError } from '../errors/base.js';
 import { ExitCode } from '../errors/codes.js';
 import { FIREFORGE_TMP_PATH_PATTERN, pathExists } from '../utils/fs.js';
 import { info, intro, outro, warn } from '../utils/logger.js';
-/**
- * Status code descriptions for git status.
- */
-const STATUS_DESCRIPTIONS = {
-    M: 'modified',
-    A: 'added',
-    D: 'deleted',
-    R: 'renamed',
-    C: 'copied',
-    U: 'unmerged',
-    '?': 'untracked',
-    '!': 'ignored',
-};
-/**
- * Gets a human-readable description for a git status code.
- */
-function getStatusDescription(code) {
-    return STATUS_DESCRIPTIONS[code] ?? 'changed';
-}
-function getPrimaryStatusCode(status) {
-    if (status.includes('?'))
-        return '?';
-    if (status.includes('!'))
-        return '!';
-    for (const code of status) {
-        if (code !== ' ') {
-            return code;
-        }
-    }
-    return status;
-}
-function isNewFileStatus(status) {
-    const code = getPrimaryStatusCode(status);
-    return code === '?' || code === 'A';
-}
-function groupFilesByStatus(files) {
-    const grouped = new Map();
-    for (const { status, file } of files) {
-        const code = getPrimaryStatusCode(status);
-        const existing = grouped.get(code) ?? [];
-        existing.push(file);
-        grouped.set(code, existing);
-    }
-    return grouped;
-}
-function printStatusGroups(files) {
-    const grouped = groupFilesByStatus(files);
-    for (const [status, fileList] of grouped) {
-        const description = getStatusDescription(status);
-        warn(`${description}:`);
-        for (const file of fileList) {
-            info(`  ${file}`);
-        }
-    }
-}
-async function printUnregisteredWarnings(files, projectRoot, binaryName) {
-    const newFiles = files.filter((f) => isNewFileStatus(f.status));
-    if (newFiles.length === 0)
-        return;
-    const registrableFiles = newFiles.filter((f) => matchesRegistrablePattern(f.file, binaryName));
-    // `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:');
-        for (const f of unregistered) {
-            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}'.`);
-        }
-    }
-}
+import { renderDefaultStatus, renderUnmanagedOnly, } from './status-output.js';
 /**
  * Renders raw worktree status as machine-parseable porcelain-style output.
  * Each line is: STATUS<tab>FILE
@@ -132,19 +20,6 @@ function renderRawStatus(files) {
         process.stdout.write(`${status.trim()}\t${file}\n`);
     }
 }
-/**
- * Default maximum number of files we will materialise from a single
- * untracked directory. Pathological inputs (an accidental dump of build
- * output, a symlink that resolves into a huge unrelated tree, etc.)
- * should not be able to balloon `status` into multi-gigabyte memory or
- * hang the CLI. Going over this cap surfaces a warning so the user knows
- * the listing has been truncated, and it bounds the JSON / default
- * rendering paths.
- *
- * Override via the `FIREFORGE_MAX_UNTRACKED_FILES` environment variable
- * for monorepos or fixture-heavy projects with legitimately large
- * untracked directories.
- */
 const DEFAULT_MAX_UNTRACKED_FILES_PER_DIR = 5000;
 function resolveMaxUntrackedFilesPerDir() {
     const raw = process.env['FIREFORGE_MAX_UNTRACKED_FILES'];
@@ -158,14 +33,6 @@ function resolveMaxUntrackedFilesPerDir() {
     return parsed;
 }
 const MAX_UNTRACKED_FILES_PER_DIR = resolveMaxUntrackedFilesPerDir();
-/**
- * Emits a prominent top-of-output warning when one or more untracked
- * directories were truncated during expansion. Individual per-dir warnings
- * already fired inside expandDirectoryEntries but are easily lost in
- * scrollback for large status outputs; this banner summarises the total
- * hidden count so the user doesn't miss that an export based on this
- * status would be incomplete.
- */
 function renderTruncationBanner(truncations) {
     if (truncations.length === 0)
         return;
@@ -227,10 +94,6 @@ async function renderJsonStatus(files, paths, projectRoot, binaryName) {
             status: f.status.trim(),
             classification: f.classification,
         };
-        // `claimedBy` is an optional field present only on conflict
-        // entries, so non-conflict output stays byte-identical to the
-        // pre-0.16.0 shape (no unconditional schema change for the
-        // 99% of entries that are not cross-patch conflicts).
         if (f.classification === 'conflict' && f.claimedBy && f.claimedBy.length > 0) {
             entry.claimedBy = [...f.claimedBy];
         }
@@ -238,6 +101,7 @@ async function renderJsonStatus(files, paths, projectRoot, binaryName) {
     });
     const byClassification = {
         unmanaged: 0,
+        'patch-owned-drift': 0,
         'patch-backed': 0,
         branding: 0,
         furnace: 0,
@@ -306,25 +170,6 @@ export async function statusCommand(projectRoot, options = {}) {
     }
     const paths = getProjectPaths(projectRoot);
     const config = await loadConfig(projectRoot);
-    // `--json` mode contracts to machine-parseable output on every code path,
-    // including failure modes. Before this guard, errors raised below
-    // ("Firefox source not found", "engine is not a git repository") flowed
-    // through the normal styled error renderer in `withErrorHandling`, so
-    // scripts piping `status --json | jq` broke precisely when the engine was
-    // missing. Surface a structured `{ "error": ..., "code": ... }` payload
-    // and exit non-zero via GeneralError so the exit code still reflects the
-    // failure but stdout remains valid JSON. The same guard runs for
-    // ownership mode below because that path also throws on missing engine.
-    // 2026-04-26 eval Finding 1: throw `CommandError` rather than
-    // `GeneralError` after the JSON line lands on stdout. `GeneralError`
-    // is a `FireForgeError`, so the `withErrorHandling` wrapper in cli.ts
-    // calls `logError(error.userMessage)` on it, which routes the styled
-    // human banner through clack to stdout — `status --json` therefore
-    // emitted both the JSON object AND the `■ Firefox source not found …`
-    // line on stdout, breaking every script that pipes the command into
-    // a JSON parser. `CommandError` is the bin-only sentinel that
-    // `withErrorHandling` does not log: bin/fireforge.ts catches it,
-    // exits with the carried code, and stdout stays a single JSON line.
     const emitJsonError = (code, message) => {
         process.stdout.write(JSON.stringify({ schemaVersion: 1, error: message, code }) + '\n');
         throw new CommandError(ExitCode.GENERAL_ERROR);
@@ -357,7 +202,7 @@ export async function statusCommand(projectRoot, options = {}) {
         const newFileCreatorsByPath = (await pathExists(paths.patches))
             ? collectNewFileCreatorsByPath(await buildPatchQueueContext(paths.patches))
             : new Map();
-        const rows = buildOwnershipTable(manifest?.patches ?? [], rawFilesOwnership, newFileCreatorsByPath);
+        const rows = buildOwnershipTable(manifest?.patches ?? [], rawFilesOwnership, newFileCreatorsByPath, new Map((await classifyFiles(rawFilesOwnership, paths.engine, paths.patches, config.binaryName, await collectFurnaceManagedPrefixes(projectRoot))).map((entry) => [entry.file, entry.classification])));
         renderOwnershipTable(rows);
         const conflictCount = rows.filter((r) => r.conflict).length;
         const unmanagedCount = rows.filter((r) => r.unmanaged).length;
@@ -429,6 +274,7 @@ export async function statusCommand(projectRoot, options = {}) {
     const buckets = {
         conflict: classified.filter((f) => f.classification === 'conflict'),
         unmanaged: classified.filter((f) => f.classification === 'unmanaged'),
+        patchOwnedDrift: classified.filter((f) => f.classification === 'patch-owned-drift'),
         patchBacked: classified.filter((f) => f.classification === 'patch-backed'),
         branding: classified.filter((f) => f.classification === 'branding'),
         furnace: classified.filter((f) => f.classification === 'furnace'),
@@ -440,95 +286,6 @@ export async function statusCommand(projectRoot, options = {}) {
     }
     await renderDefaultStatus(files.length, buckets, projectRoot, config.binaryName);
 }
-async function renderUnmanagedOnly(unmanagedFiles, totalModified, projectRoot, binaryName) {
-    info(`${unmanagedFiles.length} unmanaged file${unmanagedFiles.length === 1 ? '' : 's'} (${totalModified} total modified):\n`);
-    if (unmanagedFiles.length > 0) {
-        printStatusGroups(unmanagedFiles);
-        await printUnregisteredWarnings(unmanagedFiles, projectRoot, binaryName);
-    }
-    else {
-        info('No unmanaged changes');
-    }
-    outro(unmanagedFiles.length === 0
-        ? 'No unmanaged changes'
-        : `${unmanagedFiles.length} unmanaged change${unmanagedFiles.length === 1 ? '' : 's'}`);
-}
-/**
- * Renders the default five-bucket status display: conflicts first
- * (they block export/import/rebase), then unmanaged, patch-backed,
- * branding, and furnace-managed sections. Cross-bucket separators
- * ensure the sections are visually distinct without trailing empty
- * groups. Empty buckets are omitted — the very-empty case surfaces a
- * single `No changes` line.
- */
-async function renderDefaultStatus(totalModified, buckets, projectRoot, binaryName) {
-    const { conflict, unmanaged, patchBacked, branding, furnace } = buckets;
-    info(`${totalModified} modified file${totalModified === 1 ? '' : 's'}:\n`);
-    if (conflict.length > 0) {
-        // Surface cross-patch ownership conflicts at the top of the default
-        // output — they block export/import/rebase and want immediate
-        // attention. The `--ownership` view already renders the full table;
-        // here we just name the files and point the operator at the
-        // canonical recovery path.
-        warn('Cross-patch ownership conflicts (same file claimed by multiple patches):');
-        printStatusGroups(conflict);
-        for (const entry of conflict) {
-            if (entry.claimedBy && entry.claimedBy.length > 0) {
-                info(`  ${entry.file} — claimed by ${entry.claimedBy.join(', ')}`);
-            }
-        }
-        info('Run "fireforge status --ownership" for the full conflict table, then repartition with "fireforge re-export --files <paths> <patch>".');
-    }
-    if (unmanaged.length > 0) {
-        if (conflict.length > 0)
-            info('');
-        warn('Unmanaged changes:');
-        printStatusGroups(unmanaged);
-        await printUnregisteredWarnings(unmanaged, projectRoot, binaryName);
-    }
-    if (patchBacked.length > 0) {
-        if (conflict.length > 0 || unmanaged.length > 0)
-            info('');
-        warn('Patch-backed materialized changes:');
-        printStatusGroups(patchBacked);
-    }
-    if (branding.length > 0) {
-        if (conflict.length > 0 || unmanaged.length > 0 || patchBacked.length > 0) {
-            info('');
-        }
-        warn('Tool-managed branding changes:');
-        printStatusGroups(branding);
-    }
-    if (furnace.length > 0) {
-        if (conflict.length > 0 ||
-            unmanaged.length > 0 ||
-            patchBacked.length > 0 ||
-            branding.length > 0) {
-            info('');
-        }
-        warn('Furnace-managed component changes:');
-        printStatusGroups(furnace);
-    }
-    if (conflict.length === 0 &&
-        unmanaged.length === 0 &&
-        patchBacked.length === 0 &&
-        branding.length === 0 &&
-        furnace.length === 0) {
-        info('No changes');
-    }
-    const parts = [];
-    if (conflict.length > 0)
-        parts.push(`${conflict.length} conflict`);
-    if (unmanaged.length > 0)
-        parts.push(`${unmanaged.length} unmanaged`);
-    if (patchBacked.length > 0)
-        parts.push(`${patchBacked.length} patch-backed`);
-    if (branding.length > 0)
-        parts.push(`${branding.length} branding`);
-    if (furnace.length > 0)
-        parts.push(`${furnace.length} furnace`);
-    outro(parts.join(', '));
-}
 /** Registers the status command on the CLI program. */
 export function registerStatus(program, { getProjectRoot, withErrorHandling }) {
     program

package/dist/src/commands/verify.js

@@ -16,12 +16,14 @@
  */
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../core/config.js';
+import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
 import { isGitRepository } from '../core/git.js';
 import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { buildPatchQueueContext, lintPatchQueue } from '../core/patch-lint.js';
 import { loadPatchesManifest, validatePatchesManifestConsistency } from '../core/patch-manifest.js';
 import { evaluatePatchPolicy } from '../core/patch-policy.js';
 import { collectPatchRegistrationReferences } from '../core/patch-registration-refs.js';
+import { classifyFiles } from '../core/status-classify.js';
 import { GeneralError } from '../errors/base.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { info, intro, outro, success, warn } from '../utils/logger.js';
@@ -102,14 +104,25 @@ function detectCrossPatchFileClaims(manifestPatches) {
     }
     return results;
 }
-async function detectUnownedWorktreeChanges(engineDir, claimedFiles) {
+async function detectWorktreeOwnershipDrift(projectRoot, engineDir, patchesDir, binaryName) {
     if (!(await pathExists(engineDir)) || !(await isGitRepository(engineDir))) {
-        return [];
+        return { unowned: [], patchOwnedDrift: [] };
     }
     const entries = await expandUntrackedDirectoryEntries(engineDir, await getWorkingTreeStatus(engineDir));
-    return [
-        ...new Set(entries.map((entry) => entry.file).filter((file) => !claimedFiles.has(file))),
-    ].sort();
+    const furnacePrefixes = await collectFurnaceManagedPrefixes(projectRoot);
+    const classified = await classifyFiles(entries, engineDir, patchesDir, binaryName, furnacePrefixes);
+    return {
+        unowned: [
+            ...new Set(classified
+                .filter((entry) => entry.classification === 'unmanaged')
+                .map((entry) => entry.file)),
+        ].sort(),
+        patchOwnedDrift: [
+            ...new Set(classified
+                .filter((entry) => entry.classification === 'patch-owned-drift')
+                .map((entry) => entry.file)),
+        ].sort(),
+    };
 }
 /**
  * Collects the same queue-health findings reported by `fireforge verify`
@@ -188,21 +201,24 @@ export async function collectPatchQueueHealth(projectRoot) {
         warningCount += lintWarnings;
     }
     if (manifest) {
-        const claimedFiles = new Set();
-        for (const patch of manifest.patches) {
-            for (const file of patch.filesAffected) {
-                claimedFiles.add(file);
-            }
+        const worktreeDrift = await detectWorktreeOwnershipDrift(projectRoot, paths.engine, paths.patches, config.binaryName);
+        if (worktreeDrift.unowned.length > 0) {
+            groups.push({
+                title: `Unowned worktree changes (${worktreeDrift.unowned.length})`,
+                issues: worktreeDrift.unowned.map((file) => `${file} is changed in engine/ but is not listed in any patch filesAffected entry`),
+                errorCount: 0,
+                warningCount: worktreeDrift.unowned.length,
+            });
+            warningCount += worktreeDrift.unowned.length;
         }
-        const unownedWorktreeChanges = await detectUnownedWorktreeChanges(paths.engine, claimedFiles);
-        if (unownedWorktreeChanges.length > 0) {
+        if (worktreeDrift.patchOwnedDrift.length > 0) {
             groups.push({
-                title: `Unowned worktree changes (${unownedWorktreeChanges.length})`,
-                issues: unownedWorktreeChanges.map((file) => `${file} is changed in engine/ but is not listed in any patch filesAffected entry`),
+                title: `Patch-owned worktree drift (${worktreeDrift.patchOwnedDrift.length})`,
+                issues: worktreeDrift.patchOwnedDrift.map((file) => `${file} is claimed by exactly one patch, but engine/ no longer matches that patch output`),
                 errorCount: 0,
-                warningCount: unownedWorktreeChanges.length,
+                warningCount: worktreeDrift.patchOwnedDrift.length,
             });
-            warningCount += unownedWorktreeChanges.length;
+            warningCount += worktreeDrift.patchOwnedDrift.length;
         }
         const registrationIssues = await detectDanglingRegistrations(paths.patches, paths.engine, manifest.patches);
         if (registrationIssues.length > 0) {

package/dist/src/core/build-prepare.js

@@ -3,6 +3,7 @@
  * Shared pre-flight logic for build and package commands:
  * story cleanup, branding setup, Furnace component application, and mozconfig generation.
  */
+import { BuildError } from '../errors/build.js';
 import { FurnaceError } from '../errors/furnace.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
@@ -103,21 +104,28 @@ export async function prepareBuildEnvironment(projectRoot, paths, config, option
         const changed = await collectBackendRelevantChanges(paths.engine, options.previousBaseline);
         const invalidating = changed.filter(isBackendInvalidatingFile);
         if (invalidating.length > 0) {
-            info(`Backend config changed; running mach configure first... (${invalidating.length} file${invalidating.length === 1 ? '' : 's'} touched)`);
+            info(`Backend config changed; running backend regeneration first (${invalidating.length} file${invalidating.length === 1 ? '' : 's'} touched).`);
+            info(`Backend command: mach configure`);
             const configureSpinner = spinner('Running mach configure...');
             try {
                 const exitCode = await runMach(['configure'], paths.engine);
                 if (exitCode !== 0) {
-                    configureSpinner.error('mach configure exited non-zero; continuing with build anyway');
+                    configureSpinner.error(`mach configure failed with exit code ${exitCode}`);
+                    throw new BuildError(`Backend regeneration failed: mach configure exited with code ${exitCode}. Build stopped because continuing would hide the real configure failure.`, 'mach configure');
                 }
                 else {
-                    configureSpinner.stop('Backend regenerated');
+                    configureSpinner.stop('Backend regenerated successfully (mach configure exit code 0)');
+                    info('Backend regeneration succeeded; continuing with build.');
                     reconfigured = true;
                 }
             }
             catch (error) {
-                configureSpinner.error('mach configure failed; continuing with build anyway');
+                if (error instanceof BuildError) {
+                    throw error;
+                }
+                configureSpinner.error('mach configure failed');
                 verbose(`Auto-configure error: ${toError(error).message}`);
+                throw new BuildError(`Backend regeneration failed while running mach configure: ${toError(error).message}. Build stopped because continuing would hide the real configure failure.`, 'mach configure', error instanceof Error ? error : undefined);
             }
         }
     }

package/dist/src/core/firefox-cache.d.ts

@@ -14,7 +14,7 @@ export declare function sha256File(filePath: string): Promise<string>;
  * @param cacheDir - Cache directory
  * @param onProgress - Optional progress callback
  */
-export declare function ensureCachedArchive(archive: ResolvedArchive, cacheDir: string, onProgress?: ProgressCallback, expectedSha256?: string): Promise<void>;
+export declare function ensureCachedArchive(archive: ResolvedArchive, cacheDir: string, onProgress?: ProgressCallback, expectedSha256?: string, onCacheProgress?: (message: string) => void): Promise<void>;
 /**
  * Removes cached tarball, metadata, and partial download files for an archive.
  * @param archive - Resolved archive descriptor