@hominis/fireforge 0.27.1 → 0.27.3

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-archive.js

@@ -6,9 +6,13 @@ import { ConfigError } from '../errors/config.js';
 import { parseObject } from '../utils/parse.js';
 import { isValidFirefoxProduct } from '../utils/validation.js';
 /**
- * Base URL for Firefox releases on archive.mozilla.org.
+ * Base URLs for Firefox source archives on archive.mozilla.org.
  */
-const ARCHIVE_BASE_URL = 'https://archive.mozilla.org/pub/firefox/releases';
+const FIREFOX_ARCHIVE_BASE_URL = 'https://archive.mozilla.org/pub/firefox/releases';
+const DEVEDITION_ARCHIVE_BASE_URL = 'https://archive.mozilla.org/pub/devedition/releases';
+function getArchiveBaseUrl(product) {
+    return product === 'firefox-devedition' ? DEVEDITION_ARCHIVE_BASE_URL : FIREFOX_ARCHIVE_BASE_URL;
+}
 /**
  * Validates raw JSON data as ArchiveMetadata.
  * @param data - Unknown data to validate
@@ -55,7 +59,7 @@ export function resolveArchive(version, product = 'firefox') {
         requestedVersion: version,
         product,
         archiveVersion,
-        url: `${ARCHIVE_BASE_URL}/${archiveVersion}/source/firefox-${archiveVersion}.source.tar.xz`,
+        url: `${getArchiveBaseUrl(product)}/${archiveVersion}/source/firefox-${archiveVersion}.source.tar.xz`,
         filename: `firefox-${safeProduct}-${archiveVersion}.source.tar.xz`,
         metadataFilename: `firefox-${safeProduct}-${archiveVersion}.source.tar.xz.json`,
     };

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

package/dist/src/core/firefox-cache.js

@@ -7,7 +7,7 @@ import { createReadStream } from 'node:fs';
 import { rename } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
-import { DownloadError } from '../errors/download.js';
+import { ChecksumMismatchError } from '../errors/download.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readJson, removeFile, writeJson } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
@@ -30,19 +30,22 @@ export async function sha256File(filePath) {
  * @param cacheDir - Cache directory
  * @param onProgress - Optional progress callback
  */
-export async function ensureCachedArchive(archive, cacheDir, onProgress, expectedSha256) {
+export async function ensureCachedArchive(archive, cacheDir, onProgress, expectedSha256, onCacheProgress) {
     const lockPath = createSiblingLockPath(join(cacheDir, archive.filename), '.fireforge-cache.lock');
     await withFileLock(lockPath, async () => {
+        onCacheProgress?.(`Validating source archive cache metadata for ${archive.filename}...`);
         if (await validateCachedArchive(archive, cacheDir, expectedSha256)) {
+            onCacheProgress?.(`Using validated cached source archive ${archive.filename}`);
             return;
         }
         if (await cacheEntryExists(archive, cacheDir)) {
+            onCacheProgress?.(`Invalid cached source archive metadata; refreshing ${archive.filename}`);
             await invalidateArchiveCache(archive, cacheDir);
         }
         else {
             await removeArchivePartFiles(archive, cacheDir);
         }
-        await downloadToCache(archive, cacheDir, onProgress, expectedSha256);
+        await downloadToCache(archive, cacheDir, onProgress, expectedSha256, onCacheProgress);
     });
 }
 async function cacheEntryExists(archive, cacheDir) {
@@ -97,7 +100,7 @@ async function validateCachedArchive(archive, cacheDir, expectedSha256) {
  * @param cacheDir - Cache directory
  * @param onProgress - Optional progress callback
  */
-async function downloadToCache(archive, cacheDir, onProgress, expectedSha256) {
+async function downloadToCache(archive, cacheDir, onProgress, expectedSha256, onCacheProgress) {
     const tarballPath = join(cacheDir, archive.filename);
     // Use a unique .part path so concurrent downloads for the same archive
     // do not clobber each other's partial files.
@@ -105,13 +108,16 @@ async function downloadToCache(archive, cacheDir, onProgress, expectedSha256) {
     const metadataPath = join(cacheDir, archive.metadataFilename);
     let promotedTarball = false;
     try {
+        onCacheProgress?.(`Downloading source archive to cache: ${archive.filename}`);
         const contentLength = await downloadFile(archive.url, partPath, onProgress);
         await rename(partPath, tarballPath);
         promotedTarball = true;
+        onCacheProgress?.(`Calculating source archive SHA-256 for ${archive.filename}...`);
         const sha256 = await sha256File(tarballPath);
         if (expectedSha256 && sha256 !== expectedSha256) {
-            throw new DownloadError(`Downloaded archive SHA-256 mismatch: expected ${expectedSha256}, got ${sha256}`, archive.url);
+            throw new ChecksumMismatchError(archive.product, expectedSha256, sha256, archive.url);
         }
+        onCacheProgress?.(`Writing source archive cache metadata for ${archive.metadataFilename}...`);
         await writeJson(metadataPath, {
             requestedVersion: archive.requestedVersion,
             product: archive.product,
@@ -121,6 +127,7 @@ async function downloadToCache(archive, cacheDir, onProgress, expectedSha256) {
             sha256,
             downloadedAt: new Date().toISOString(),
         });
+        onCacheProgress?.(`Source archive cache metadata written: ${archive.metadataFilename}`);
     }
     catch (error) {
         await removeFile(partPath);

package/dist/src/core/firefox.js

@@ -50,7 +50,7 @@ export async function downloadFirefoxSource(version, product, destDir, cacheDir,
     // Ensure cache directory exists
     await ensureDir(cacheDir);
     onPhase?.('download');
-    await ensureCachedArchive(archive, cacheDir, onProgress, expectedSha256);
+    await ensureCachedArchive(archive, cacheDir, onProgress, expectedSha256, onPhaseProgress);
     // Extract to a unique temporary directory so concurrent downloads for
     // the same destination do not clobber each other.
     onPhase?.('extract');

package/dist/src/core/git.js

@@ -206,9 +206,10 @@ export async function stageAllFiles(dir, options = {}) {
     heartbeatTimer?.unref();
     try {
         try {
+            reportProgress?.('Git phase: starting git add -A source indexing.');
             reportProgress?.(`Starting monolithic git add -A for ${scan.directories.length} director${scan.directories.length === 1 ? 'y' : 'ies'} and ${scan.topLevelFiles.length} top-level file${scan.topLevelFiles.length === 1 ? '' : 's'}...`);
             await git(['add', '-A'], dir, { timeout, env: GIT_ADD_ENV });
-            reportProgress?.('Monolithic git add -A completed.');
+            reportProgress?.('Git phase complete: git add -A source indexing finished.');
             return;
         }
         catch (error) {
@@ -233,6 +234,7 @@ export async function stageAllFiles(dir, options = {}) {
         phaseStartedAt = Date.now();
         try {
             await stageAllFilesChunked(dir, scan, options);
+            reportProgress?.('Git phase complete: chunked source indexing finished.');
         }
         catch (error) {
             if (error instanceof GitIndexingTimeoutError)
@@ -247,6 +249,7 @@ export async function stageAllFiles(dir, options = {}) {
 }
 async function createInitialSourceCommit(dir, reportProgress) {
     const startedAt = Date.now();
+    reportProgress('Git phase: creating initial source commit.');
     reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
     const heartbeat = setInterval(() => {
         reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
@@ -258,7 +261,7 @@ async function createInitialSourceCommit(dir, reportProgress) {
     finally {
         clearInterval(heartbeat);
     }
-    reportProgress(`Initial Firefox source commit created (${elapsedSince(startedAt)} elapsed).`);
+    reportProgress(`Git phase complete: initial source commit created (${elapsedSince(startedAt)} elapsed).`);
 }
 /**
  * Initializes a new git repository with an orphan branch.
@@ -269,6 +272,7 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
     await ensureGit();
     const reportProgress = options.onProgress ?? (() => { });
     // Initialize repository
+    reportProgress('Git phase: initializing source git repository.');
     reportProgress('Creating git repository...');
     await git(['init'], dir);
     // Create orphan branch
@@ -286,6 +290,7 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
     // fail.  Nothing is ever fetched from or pushed to this remote.
     reportProgress('Configuring origin remote for build compatibility...');
     await git(['remote', 'add', 'origin', 'https://github.com/mozilla-firefox/firefox'], dir);
+    reportProgress('Git phase complete: source git repository metadata initialized.');
     // Add all files
     reportProgress('Indexing Firefox source with git add -A (this can take several minutes on large trees)...');
     await assertNoGitIndexLock(dir);

package/dist/src/core/ownership-table.d.ts

@@ -1,4 +1,5 @@
 import type { PatchMetadata } from '../types/commands/index.js';
+import type { FileClassification } from './status-classify.js';
 /**
  * A row in the flat path → owning-patch ownership table.
  */
@@ -8,6 +9,7 @@ export interface OwnershipRow {
     conflict: boolean;
     conflictReason: 'files-affected' | 'duplicate-create' | null;
     unmanaged: boolean;
+    state: 'owned' | 'patch-backed' | 'patch-owned-drift' | 'unmanaged' | 'conflict';
 }
 interface StatusFile {
     status: string;
@@ -42,7 +44,7 @@ interface StatusFile {
  *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath};
  *   paths with a `.length > 1` owner list become duplicate-create conflicts
  */
-export declare function buildOwnershipTable(manifestPatches: PatchMetadata[], worktreeFiles: StatusFile[], newFileCreatorsByPath: Map<string, string[]>): OwnershipRow[];
+export declare function buildOwnershipTable(manifestPatches: PatchMetadata[], worktreeFiles: StatusFile[], newFileCreatorsByPath: Map<string, string[]>, classifications?: Map<string, FileClassification>): OwnershipRow[];
 /**
  * Renders the ownership table as a GitHub-flavored Markdown pipe table.
  * Using markdown-table's own serializer would require a seed document to