@hominis/fireforge 0.49.2 → 0.50.0

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

@@ -15,15 +15,26 @@ import { mapWithConcurrency } from '../utils/concurrency.js';
 import { pathExists } from '../utils/fs.js';
 import { cancel, info, isCancel, warn } from '../utils/logger.js';
 import { isContainedRelativePath, normalizePathSlashes, stripEnginePrefix, } from '../utils/paths.js';
+import { formatForwardImportRemedy } from './forward-import-remedy.js';
+import { joinScanFileOwner, splitScanFileOwner } from './re-export-scan-owner.js';
 const SCAN_ADD_COUNT_THRESHOLD = 3;
 /** Concurrency bound for existence probes (matches the classify/lint pools). */
 const PATH_PROBE_CONCURRENCY = 8;
 const SCAN_DIR_COUNT_THRESHOLD = 2;
-/** Normalizes repeatable `--scan-file` inputs into safe engine-relative paths. */
+/**
+ * Normalizes repeatable `--scan-file` inputs into safe engine-relative
+ * paths, keeping an optional `<patch>:` owner prefix intact.
+ */
 export function normalizeScanFiles(scanFiles) {
-    const normalized = [...new Set(scanFiles ?? [])]
-        .map((file) => normalizeEngineRelativeInput(file, '--scan-file'))
-        .sort();
+    const normalized = [
+        ...new Set((scanFiles ?? []).map((file) => {
+            const spec = splitScanFileOwner(file);
+            return joinScanFileOwner({
+                owner: spec.owner,
+                path: normalizeEngineRelativeInput(spec.path, '--scan-file'),
+            });
+        })),
+    ].sort();
     return normalized.length > 0 ? normalized : undefined;
 }
 /** Normalizes one CLI-provided path into a safe engine-relative path. */
@@ -171,7 +182,7 @@ function scanAdditionsNeedConfirmation(added) {
  * (all adopt through the same scan result), including dry-run.
  */
 export async function assertScanAdoptionsHaveNoForwardImports(args) {
-    const { patchesDir, engineDir, patchFilename, added } = args;
+    const { patchesDir, engineDir, patchFilename, added, config } = args;
     if (added.length === 0)
         return;
     const candidateDiff = await getDiffForFilesAgainstHead(engineDir, [...added]);
@@ -180,7 +191,7 @@ export async function assertScanAdoptionsHaveNoForwardImports(args) {
     const candidateNewFiles = buildNewFileTextProjection(candidateDiff);
     const candidateCreations = detectNewFilesInDiff(candidateDiff);
     const candidateAdditions = buildModifiedFileAdditionsFromDiff(candidateDiff);
-    const baseCtx = await buildPatchQueueContext(patchesDir);
+    const baseCtx = await buildPatchQueueContext(patchesDir, config);
     const projectedEntries = baseCtx.entries.map((entry) => {
         if (entry.filename !== patchFilename)
             return entry;
@@ -193,27 +204,49 @@ export async function assertScanAdoptionsHaveNoForwardImports(args) {
         };
     });
     const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
-    const projectedIssues = lintPatchQueue({ entries: projectedEntries }).filter((i) => i.severity === 'error');
+    const projectedIssues = lintPatchQueue({ ...baseCtx, entries: projectedEntries }).filter((i) => i.severity === 'error');
     const addedSet = new Set(added);
-    const offending = computeProjectedLintRegressions(baselineIssues, projectedIssues).filter((issue) => issue.check === 'forward-import' && addedSet.has(issue.file));
-    if (offending.length === 0)
+    const regressions = computeProjectedLintRegressions(baselineIssues, projectedIssues);
+    const offending = regressions.filter((issue) => issue.check === 'forward-import' && addedSet.has(issue.file));
+    // A forward registration (jar.mn packaging, a test manifest, ...) only
+    // regresses here because the candidates moved the registered file's
+    // creation to this patch, or because a candidate registers it: either way
+    // the adoption caused it, and the operator should declare it in the same
+    // pass as the import instead of meeting it later in the queue audit.
+    const registrations = regressions.filter((issue) => issue.check === 'forward-registration');
+    if (offending.length === 0 && registrations.length === 0)
         return;
     const details = offending.map((issue) => `  - ${issue.file}: ${issue.message}`).join('\n');
-    throw new GeneralError(`Refusing to adopt ${offending.length} scanned file${offending.length === 1 ? '' : 's'} into ${patchFilename} ` +
-        `because they import modules created by later patches:\n${details}\n` +
-        formatForwardImportRemedy('re-running the scan'));
+    const registrationDetails = registrations
+        .map((issue) => `  - ${issue.file}: ${issue.message}`)
+        .join('\n');
+    const parts = [];
+    if (offending.length > 0) {
+        parts.push(`${offending.length} scanned file${offending.length === 1 ? '' : 's'} import modules created by later patches:\n${details}`);
+    }
+    if (registrations.length > 0) {
+        parts.push(`${registrations.length} forward registration${registrations.length === 1 ? '' : 's'} the adoption would leave dangling:\n${registrationDetails}`);
+    }
+    throw new GeneralError(`Refusing to adopt scanned files into ${patchFilename}: ${parts.join('\n')}\n` +
+        formatForwardImportRemedy({
+            reRunHint: 're-running the scan',
+            issues: [...offending, ...registrations],
+            manifest: manifestFromQueue(baseCtx),
+            ...(args.config !== undefined ? { config: args.config } : {}),
+            ...categoryOf(baseCtx, patchFilename),
+        }));
 }
-/**
- * The one remedy sentence for a forward import a patch body cannot carry.
- * Shared by the `--scan` adoption gate and the plain re-export projection
- * gate so both refusals point at the same commands.
- *
- * @param reRunHint - What to do after the fix ("re-running the scan")
- */
-export function formatForwardImportRemedy(reRunHint) {
-    return ('Export those files as their own later patch ("fireforge export --order <n>" / ' +
-        '"fireforge patch split --order <n>") or declare the intentional dependency with ' +
-        `"fireforge patch staged-dependency --add" before ${reRunHint}.`);
+/** The manifest rows a queue context carries, for remedy computations. */
+export function manifestFromQueue(ctx) {
+    return {
+        version: 1,
+        patches: ctx.entries.flatMap((entry) => (entry.metadata ? [entry.metadata] : [])),
+    };
+}
+/** `{ category }` of the named queue entry, or `{}` when it has no metadata. */
+export function categoryOf(ctx, filename) {
+    const category = ctx.entries.find((entry) => entry.filename === filename)?.metadata?.category;
+    return category !== undefined ? { category } : {};
 }
 /** Refuses explicit `--scan-file` additions that did not produce patch hunks. */
 export function assertScanFileAdditionsHaveDiffHunks(args) {

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

@@ -10,6 +10,7 @@ import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { listTrackedInHead } from '../core/git-file-ops.js';
 import { updatePatchAndMetadata } from '../core/patch-export.js';
+import { buildLintIgnoreChecks, lintIgnoreRule, mergeLintIgnoreIds, } from '../core/patch-lint-ignore.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
 import { isGitIndexLockConflict } from '../errors/git.js';
 import { info, success, warn } from '../utils/logger.js';
@@ -42,7 +43,9 @@ export async function reExportSinglePatchWithIndexLockRetry(args) {
 async function reExportSinglePatch(args) {
     const { patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx } = args;
     const removed = new Set(options.expectRemoved ?? []);
-    let currentFilesAffected = patch.filesAffected.filter((file) => !removed.has(file));
+    const retainedFiles = patch.filesAffected.filter((file) => !removed.has(file));
+    let currentFilesAffected = retainedFiles;
+    let adoptedFiles = [];
     for (const file of patch.filesAffected.filter((path) => removed.has(path)))
         info(`  - ${file} (--expect-removed)`);
     // --- Scan for new/removed files ---
@@ -65,6 +68,7 @@ async function reExportSinglePatch(args) {
             engineDir: paths.engine,
             patchFilename: patch.filename,
             added: scanResult.added,
+            config,
         });
         if (options.scanFiles === undefined) {
             const isInteractive = stdioIsInteractive();
@@ -80,6 +84,7 @@ async function reExportSinglePatch(args) {
             }
         }
         currentFilesAffected = scanResult.updated;
+        adoptedFiles = scanResult.added;
     }
     else if (options.files === undefined) {
         // When neither `--scan` nor `--files` is set and some of the manifest's
@@ -153,13 +158,17 @@ async function reExportSinglePatch(args) {
     // payload lines are about to enter the body that the old body did not
     // carry, the case where a concurrent session's uncommitted edits in
     // owned files would be silently absorbed. Always previews (including
-    // dry-run and --scan). Refuses only under --refuse-foreign-drift.
+    // dry-run and --scan). Refuses only under --refuse-foreign-drift. Covers
+    // the files the patch already owned; adopted and retired files are the
+    // run's stated intent, not drift.
     if (await reportForeignDrift({
         patch,
         patchesDir: paths.patches,
         engineDir: paths.engine,
         newDiffContent: diffContent,
         ctx: driftCtx,
+        ownedFiles: retainedFiles,
+        adoptedFiles,
     })) {
         return false;
     }
@@ -228,6 +237,13 @@ function enforceProjectedManifestPolicy(args) {
         manifest: buildProjectedManifest(manifest, manifest.patches.map((entry) => entry.filename === patch.filename ? { ...entry, ...updates } : entry)),
         command: 're-export',
         forceUnsafe: options.forceUnsafe === true,
+        // A re-export changes only this row's contents, so only its findings
+        // can be new; another patch's stale row must not fail this one.
+        scope: [patch.filename],
+        hints: {
+            'reserved-files': 'A path whose engine copy is back at HEAD can be dropped from the patch with ' +
+                '--expect-removed <path>; any other path needs its reserved allowlist entry.',
+        },
     });
 }
 /**
@@ -252,6 +268,7 @@ async function commitRefreshedPatch(args) {
             config,
             command: 're-export',
             forceUnsafe: options.forceUnsafe === true,
+            scope: [patch.filename],
         },
     });
     refreshQueueCtxEntry(lintCtx, patch.filename, diffContent);
@@ -289,10 +306,9 @@ async function commitRefreshedPatch(args) {
  * pass so the new intent takes effect on this invocation.
  */
 function computeReExportUpdates(patch, options, currentFilesAffected) {
-    const existingIgnoreSet = new Set(patch.lintIgnore ?? []);
+    const existingIgnoreSet = new Set((patch.lintIgnore ?? []).map(lintIgnoreRule));
     const flagIgnoreSet = new Set(options.lintIgnore ?? []);
-    const mergedIgnoreSet = new Set([...existingIgnoreSet, ...flagIgnoreSet]);
-    const effectiveLintIgnore = mergedIgnoreSet.size > 0 ? [...mergedIgnoreSet] : undefined;
+    const effectiveLintIgnore = mergeLintIgnoreIds(patch.lintIgnore, [...flagIgnoreSet]);
     const updates = {
         filesAffected: currentFilesAffected,
     };
@@ -304,7 +320,7 @@ function computeReExportUpdates(patch, options, currentFilesAffected) {
     }
     return {
         updates,
-        ignoreChecks: effectiveLintIgnore ? new Set(effectiveLintIgnore) : undefined,
+        ignoreChecks: buildLintIgnoreChecks(effectiveLintIgnore),
         effectiveTier: options.tier ?? patch.tier,
         existingIgnoreSet,
         flagIgnoreSet,

package/dist/src/commands/re-export-summary.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The one-line end-of-run summary of a multi-patch `re-export`.
+ *
+ * A long run interleaves per-patch lint output, drift previews and
+ * refusals, and the patches it wrote were easy to confuse with the one it
+ * did not. The summary names both sets and why each unwritten patch was
+ * not written, so the re-run list is one line to read.
+ */
+/** What became of each selected patch. */
+export interface ReExportRunTally {
+    /** Selected patches, in run order. */
+    selected: readonly string[];
+    /** Patches written (or, in a dry run, that would be written). */
+    written: readonly string[];
+    /** Patches whose re-export threw. */
+    failed: readonly string[];
+    /** Patches refused by `--refuse-adjacent-unmanaged`. */
+    refusedAdjacent: readonly string[];
+    /** Patches refused by `--refuse-foreign-drift`. */
+    refusedDrift: readonly string[];
+    /** Whether the run is a dry run. */
+    isDryRun: boolean;
+}
+/**
+ * Renders the summary, or undefined for a single-patch run, where the
+ * outcome line already says everything.
+ */
+export declare function formatReExportRunSummary(tally: ReExportRunTally): string | undefined;

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

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * The one-line end-of-run summary of a multi-patch `re-export`.
+ *
+ * A long run interleaves per-patch lint output, drift previews and
+ * refusals, and the patches it wrote were easy to confuse with the one it
+ * did not. The summary names both sets and why each unwritten patch was
+ * not written, so the re-run list is one line to read.
+ */
+/**
+ * Renders the summary, or undefined for a single-patch run, where the
+ * outcome line already says everything.
+ */
+export function formatReExportRunSummary(tally) {
+    if (tally.selected.length <= 1)
+        return undefined;
+    const written = new Set(tally.written);
+    const reasons = new Map();
+    for (const name of tally.failed)
+        reasons.set(name, 'failed');
+    for (const name of tally.refusedAdjacent)
+        reasons.set(name, 'refused: adjacent unmanaged');
+    for (const name of tally.refusedDrift)
+        reasons.set(name, 'refused: foreign drift');
+    const notWritten = tally.selected
+        .filter((name) => !written.has(name))
+        .map((name) => `${name} (${reasons.get(name) ?? 'skipped'})`);
+    const verb = tally.isDryRun ? 'would write' : 'wrote';
+    const writtenPart = tally.written.length > 0
+        ? `${verb} ${tally.written.length} of ${tally.selected.length}: ${tally.written.join(', ')}`
+        : `${verb} 0 of ${tally.selected.length}`;
+    const notWrittenPart = notWritten.length > 0
+        ? `; ${tally.isDryRun ? 'would NOT write' : 'NOT written'}: ${notWritten.join(', ')}`
+        : '';
+    return `Re-export summary: ${writtenPart}${notWrittenPart}.`;
+}

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

@@ -10,6 +10,7 @@ import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { elapsedSince } from '../utils/elapsed.js';
 import { toError } from '../utils/errors.js';
 import { cancel, info, intro, isCancel, outro, spinner, success, warn, } from '../utils/logger.js';
+import { ADJACENT_MEANS, buildAdjacentUnmanagedContext, reportAdjacentCarveOutUsage, } from './re-export-adjacent.js';
 import { loadScanFilesAssignments, withDryRunPurityGuard, withDryRunReExportLock, } from './re-export-bulk-scan.js';
 import { warnUnseenExpectedDrift } from './re-export-drift.js';
 import { reExportFilesInPlace } from './re-export-files.js';
@@ -17,7 +18,9 @@ import { buildReExportLintContext, finishReExportLint } from './re-export-lint.j
 import { applyReExportFilesPositionalFolding, validateReExportOptionCombinations, } from './re-export-options.js';
 import { validateExpectedRemovals } from './re-export-removed.js';
 import { normalizeEngineRelativeInput, normalizeScanFiles } from './re-export-scan.js';
+import { assignScanFileOwners, scanOptionsForPatch } from './re-export-scan-owner.js';
 import { reExportSinglePatchWithIndexLockRetry } from './re-export-single.js';
+import { formatReExportRunSummary } from './re-export-summary.js';
 async function resolveSelectedPatches(patches, options, manifest) {
     if (options.all) {
         return [...manifest.patches];
@@ -73,7 +76,9 @@ export async function reExportCommand(projectRoot, patches, options) {
         options = cleanedOptions;
     }
     const isDryRun = options.dryRun === true;
-    intro(isDryRun ? 'FireForge Re-export (dry run)' : 'FireForge Re-export');
+    // The banner says which mode is in force: a path flag that swallowed
+    // `--dry-run` as its value once turned a preview into a write unnoticed.
+    intro(isDryRun ? 'FireForge Re-export (DRY RUN)' : 'FireForge Re-export (WRITING)');
     // Accept export-style space-separated paths after --files by folding
     // path-shaped extra positionals into the file list.
     ({ patches, options } = applyReExportFilesPositionalFolding(patches, options));
@@ -94,6 +99,7 @@ export async function reExportCommand(projectRoot, patches, options) {
         : await resolveSelectedPatches(patches, options, manifest);
     if (!selectedPatches)
         return;
+    const scanAssignments = scanFilesByPatch ?? assignScanFileOwners(options.scanFiles, selectedPatches, manifest);
     if (selectedPatches.length === 0) {
         warn('No patches selected');
         outro('Nothing to re-export');
@@ -125,14 +131,7 @@ export async function reExportCommand(projectRoot, patches, options) {
     const config = await loadConfig(projectRoot);
     // Classification inputs for the scan-less adjacency advisory, computed
     // once for the whole run.
-    const adjacentCtx = {
-        binaryName: config.binaryName,
-        furnacePrefixes: await collectFurnaceManagedPrefixes(paths.root),
-        refuseAdjacentUnmanaged: options.refuseAdjacentUnmanaged === true,
-        approvedUnmanaged: new Set((options.expectUnmanaged ?? []).map((file) => normalizeEngineRelativeInput(file, '--expect-unmanaged'))),
-        approvedSeen: new Set(),
-        refusals: [],
-    };
+    const adjacentCtx = buildAdjacentUnmanagedContext(options, config.binaryName, await collectFurnaceManagedPrefixes(paths.root));
     const driftCtx = buildForeignDriftContext(options);
     // Hoisted lint context, one per run: queue context + checkJs
     // program + per-patch result cache, shared across every loop iteration.
@@ -146,8 +145,7 @@ export async function reExportCommand(projectRoot, patches, options) {
     const progress = spinner('Preparing re-export...');
     await withDryRunReExportLock(paths.fireforgeDir, isDryRun, async () => withDryRunPurityGuard(paths.engine, paths.patches, isDryRun, async () => {
         for (const [index, patch] of selectedPatches.entries()) {
-            const assignedScanFiles = scanFilesByPatch?.get(patch.filename);
-            const patchOptions = assignedScanFiles !== undefined ? { ...options, scanFiles: assignedScanFiles } : options;
+            const patchOptions = scanOptionsForPatch(options, patch.filename, scanAssignments);
             progress.message(`Re-exporting ${index + 1}/${selectedPatches.length}: ${patch.filename} (${patch.filesAffected.length} file(s), ${elapsedSince(startedAt)} elapsed)...`);
             try {
                 const exported = await reExportSinglePatchWithIndexLockRetry({
@@ -176,6 +174,16 @@ export async function reExportCommand(projectRoot, patches, options) {
     await finishReExportLint(lintCtx);
     warnUnseenExpectedDrift(driftCtx);
     warnUnseenApprovedUnmanaged(adjacentCtx);
+    const summary = formatReExportRunSummary({
+        selected: selectedPatches.map((patch) => patch.filename),
+        written: reExportedFilenames,
+        failed: failedFilenames,
+        refusedAdjacent: adjacentCtx.refusals.map((r) => r.patchFilename),
+        refusedDrift: driftCtx.refusals.map((r) => r.patchFilename),
+        isDryRun,
+    });
+    if (summary !== undefined)
+        info(summary);
     throwRunLevelRefusals(adjacentCtx, driftCtx, progress);
     if (reExported === 0 && selectedPatches.length > 0) {
         progress.error('Re-export failed');
@@ -198,6 +206,7 @@ export async function reExportCommand(projectRoot, patches, options) {
         selectedCount: selectedPatches.length,
         reExportedFilenames,
         failedFilenames,
+        selectedFilenames: selectedPatches.map((patch) => patch.filename),
         shouldStamp,
         stampRequested: options.stamp === true,
         config,
@@ -224,9 +233,11 @@ function buildForeignDriftContext(options) {
  * admit, and reads as an approval that is in force when it is not.
  * A warning rather than a refusal: an approved path legitimately goes unmet
  * when the reviewed file has since been adopted into a patch, which is the
- * outcome the carve-out exists to be retired by.
+ * outcome the carve-out exists to be retired by. The `--expect-new` and
+ * `--adjacent-ignore` accounting is reported first, alongside.
  */
 function warnUnseenApprovedUnmanaged(adjacentCtx) {
+    reportAdjacentCarveOutUsage(adjacentCtx);
     const unseen = [...adjacentCtx.approvedUnmanaged].filter((file) => !adjacentCtx.approvedSeen.has(file));
     if (unseen.length === 0)
         return;
@@ -244,17 +255,18 @@ function warnUnseenApprovedUnmanaged(adjacentCtx) {
 function throwRunLevelRefusals(adjacentCtx, driftCtx, progress) {
     if (adjacentCtx.refusals.length > 0) {
         progress.error('Re-export refused');
-        // Each offender is named with the owned directory that made it
-        // adjacent: an unattended run reads only this line, and without the
-        // anchor it cannot tell which of a multi-directory patch's locations
-        // the file sits beside.
+        // Each offender is named with the owned directory (or registering
+        // carrier) that made it adjacent: an unattended run reads only this
+        // line, and without the anchor it cannot tell which of a
+        // multi-directory patch's locations the file belongs to.
         const offenders = adjacentCtx.refusals
             .map((r) => `${r.patchFilename} (${r.anchored.join(', ')})`)
             .join('; ');
         throw new GeneralError(`Refused ${adjacentCtx.refusals.length} patch(es) with adjacent unmanaged files ` +
-            `(--refuse-adjacent-unmanaged): ${offenders}. Adjacent means the file sits in a ` +
-            `directory the patch already owns a file in. Adopt reviewed files with ` +
-            `--scan --scan-file, or export them as a new patch.`);
+            `(--refuse-adjacent-unmanaged): ${offenders}. ${ADJACENT_MEANS} ` +
+            `Adopt reviewed files with --scan --scan-file, or export them as a new patch ` +
+            `(name a file your next export adopts with --expect-new, and a reviewed, deliberately ` +
+            `unmanaged file with --expect-unmanaged or --adjacent-ignore).`);
     }
     if (driftCtx.refusals.length > 0) {
         progress.error('Re-export refused');
@@ -263,11 +275,11 @@ function throwRunLevelRefusals(adjacentCtx, driftCtx, progress) {
         const unreadablePart = unreadable.length > 0
             ? ` ${unreadable.length} of these refused because the old patch body was missing or unreadable, so the drift comparison could not run (fail-closed).`
             : '';
-        throw new GeneralError(`Refused ${driftCtx.refusals.length} patch(es) whose refreshed body would absorb ` +
-            `engine edits not present in the old patch body (--refuse-foreign-drift): ${names}.${unreadablePart}\n\n` +
+        throw new GeneralError(`Refused ${driftCtx.refusals.length} patch(es) whose refreshed body would add or drop ` +
+            `lines relative to the old patch body (--refuse-foreign-drift): ${names}.${unreadablePart}\n\n` +
             'The flag cannot tell WHO wrote those lines, and the two populations have opposite ' +
             'remedies:\n' +
-            '  - Lines you added yourself since the last export (the per-file report tags these ' +
+            '  - Lines you changed yourself since the last export (the per-file report tags these ' +
             '"edited since your last export"): name them with --expect <path> so this run captures ' +
             'them, or re-run without the flag to capture every drifting file.\n' +
             "  - Lines another session owns: do NOT proceed — commit or stash that session's work " +
@@ -305,9 +317,10 @@ function reportReExportOutcome(args) {
         outro('Re-export complete');
     }
     if (reExported < selectedCount) {
-        const skippedCount = selectedCount - reExported - args.failedFilenames.length;
         const failedPart = args.failedFilenames.length > 0 ? ` Failed: ${args.failedFilenames.join(', ')}.` : '';
-        const skippedPart = skippedCount > 0 ? ` Skipped: ${skippedCount} patch(es) (see warnings above).` : '';
+        const accounted = new Set([...args.reExportedFilenames, ...args.failedFilenames]);
+        const skipped = args.selectedFilenames.filter((name) => !accounted.has(name));
+        const skippedPart = skipped.length > 0 ? ` Skipped: ${skipped.join(', ')} (see warnings above).` : '';
         throw new GeneralError(`${isDryRun ? '[dry-run] Would re-export' : 'Re-exported'} only ${reExported} of ` +
             `${selectedCount} selected patch(es).${failedPart}${skippedPart} ` +
             'Partial re-export exits non-zero so it cannot pass as success in scripts; ' +

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

@@ -19,12 +19,13 @@ import { discoverPatches } from '../../core/patch-files.js';
 import { loadPatchesManifest } from '../../core/patch-manifest.js';
 import { getPatchSourceVersion } from '../../core/patch-source-metadata.js';
 import { replayQueueIndexOnly } from '../../core/rebase-dry-run.js';
+import { formatPatchStampSpread, readCommittedFirefoxPin, resolveRebaseFromVersion, tallyPatchStamps, } from '../../core/rebase-from-version.js';
 import { getRebaseSessionPath, readRebaseSession, saveRebaseSession, } from '../../core/rebase-session.js';
 import { GeneralError } from '../../errors/base.js';
 import { CorruptRebaseSessionError, RebaseDryRunRejectError, RebaseSessionExistsError, } from '../../errors/rebase.js';
 import { info, intro, outro, spinner, warn } from '../../utils/logger.js';
 import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
-import { compareFirefoxVersions, parsePositiveIntegerFlag } from '../../utils/validation.js';
+import { parsePositiveIntegerFlag } from '../../utils/validation.js';
 import { handleAbort } from './abort.js';
 import { confirmDirtyEngineReset } from './confirm.js';
 import { handleContinue } from './continue.js';
@@ -58,27 +59,26 @@ async function handleFreshStart(projectRoot, options) {
     if (!manifest || manifest.patches.length === 0) {
         throw new GeneralError('No patches found in manifest. Nothing to rebase.');
     }
-    // Determine the "from" version from the patch stamps. A queue can carry
-    // several: patches re-exported since the last hop are stamped newer than
-    // untouched ones. The oldest stamp is "from", compared semantically (a
-    // lexical sort put 153.10.0esr before 153.2.0esr).
-    const versionCounts = new Map();
-    for (const patch of manifest.patches) {
-        const version = getPatchSourceVersion(patch);
-        versionCounts.set(version, (versionCounts.get(version) ?? 0) + 1);
-    }
-    const sortedVersions = [...versionCounts.keys()].sort(compareFirefoxVersions);
-    const fromVersion = sortedVersions[0] ?? currentVersion;
-    const fromProduct = manifest.patches.find((p) => getPatchSourceVersion(p) === fromVersion)?.sourceProduct ??
-        config.firefox.product;
-    if (versionCounts.size === 1 && fromVersion === currentVersion) {
+    // The queue can carry several stamps: patches re-exported since the last
+    // hop are stamped newer than untouched ones. "Nothing to rebase" is a fact
+    // about the stamps; the "from" label is the previous pin (the committed
+    // `firefox.version`), with the oldest stamp only as the fallback.
+    const spread = tallyPatchStamps(manifest.patches.map((p) => getPatchSourceVersion(p)));
+    const oldestStamp = spread.versions[0] ?? currentVersion;
+    const from = resolveRebaseFromVersion(currentVersion, await readCommittedFirefoxPin(projectRoot), spread, manifest.patches.find((p) => getPatchSourceVersion(p) === oldestStamp)?.sourceProduct);
+    const fromVersion = from.version;
+    const fromProduct = from.product ?? config.firefox.product;
+    if (spread.versions.length === 1 && oldestStamp === currentVersion) {
         info('All patches already match the current Firefox version. Nothing to rebase.');
         outro('Rebase not needed');
         return;
     }
     info(`Rebasing patches: ${fromVersion} → ${currentVersion}`);
-    if (versionCounts.size > 1) {
-        info(`Patch stamps: ${sortedVersions.map((v) => `${versionCounts.get(v)} at ${v}`).join(', ')}`);
+    if (from.origin === 'patch-stamps') {
+        info('From-version is the oldest patch stamp: no committed fireforge.json pin precedes the target.');
+    }
+    if (from.origin === 'committed-pin' || spread.versions.length > 1) {
+        info(`Patch stamps: ${formatPatchStampSpread(spread)}`);
     }
     // The rebase replays onto whatever engine/ holds. The pin is the target,
     // so an engine still on another version means the download step has not

package/dist/src/commands/run.js

@@ -9,7 +9,7 @@ import { warnIfFurnaceStale } from '../core/furnace-staleness.js';
 import { hasBuildArtifacts, hasRunnableBundle, run, runMachSmoke } from '../core/mach.js';
 import { assertBuildArtifacts } from '../core/mach-build-artifacts.js';
 import { resolveRunProfile, sweepAbandonedRunProfiles, } from '../core/run-profile.js';
-import { compileAllowlistFromFile, compileAllowlistFromStrings, findOverCapAllowlistEntries, matchAllowlist, matchesSmokeError, } from '../core/smoke-patterns.js';
+import { compileAllowlistFromFile, compileAllowlistFromStrings, findOverCapAllowlistEntries, isBrowserConsoleLine, matchAllowlist, matchesSmokeError, } from '../core/smoke-patterns.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { BuildError } from '../errors/build.js';
 import { ExitCode } from '../errors/codes.js';
@@ -105,6 +105,7 @@ export async function runCommand(projectRoot, options = {}) {
     const profile = await resolveRunProfile({
         profile: options.profile,
         tempProfile: options.tempProfile,
+        purgeCaches: options.purgeCaches,
         smoke: options.smokeExit !== undefined,
     });
     try {
@@ -188,6 +189,7 @@ async function runSmokeExit(engineDir, options, profile) {
         warn(`--capture-console stream error: ${err.message}`);
     });
     const findings = [];
+    let browserConsoleLines = 0;
     let allowlistedErrorHits = 0;
     let allowlistedTotalHits = 0;
     const allowlistHits = new Array(allowlist.length).fill(0);
@@ -197,6 +199,8 @@ async function runSmokeExit(engineDir, options, profile) {
         // mirror preserves stdout/stderr separation for downstream piping.
         const sink = stream === 'stdout' ? process.stdout : process.stderr;
         sink.write(`${line}\n`);
+        if (isBrowserConsoleLine(line))
+            browserConsoleLines += 1;
         // Count allowlist hits up-front, regardless of error-pattern match.
         // Incrementing only when the line also matches an error pattern makes an
         // allowlist regex that visibly matches `console.warn: RSLoader:` report 0
@@ -269,6 +273,15 @@ async function runSmokeExit(engineDir, options, profile) {
         return;
     }
     if (result.exitCode === 0 || result.exitCode === 130 || result.exitCode === 143) {
+        // A clean status before the window with no browser output at all is a
+        // launch that never reached a window (a profile lock, a startup-crash
+        // streak's silent exit, a self-restart), not a clean run.
+        if (browserConsoleLines === 0) {
+            throw new SmokeRunError(`Browser exited with code ${result.exitCode} after ${(elapsedMs / 1000).toFixed(1)}s, ` +
+                'before the smoke-exit window elapsed, without any console output. A silent early ' +
+                'exit means the launch never reached a window: check the profile for a stale ' +
+                '.parentlock or a startup-crash streak (toolkit.startup.recent_crashes).', ExitCode.SMOKE_LAUNCH_FAILURE);
+        }
         return;
     }
     throw new SmokeRunError(`Browser exited with code ${result.exitCode} before smoke-exit window elapsed.`, ExitCode.SMOKE_LAUNCH_FAILURE);
@@ -392,7 +405,8 @@ export function registerRun(program, { getProjectRoot, withErrorHandling }) {
         .option('--console-allow-file <path>', 'Newline-delimited allowlist regex file. Blank lines and # comments are ignored. A "# max-hits: N" comment directly above an entry caps how many lines it may match in one run; more than that fails the run with exit 12.')
         .option('--capture-console <file>', 'Mirror captured console output to <file> for post-exit inspection.')
         .option('--headless', 'Launch the browser with --headless. Recommended for --smoke-exit on a shared desktop: input into a headed smoke window contaminates the console capture.')
-        .option('--profile <path>', 'Launch with this profile directory (passed to Firefox as -profile). Left in place after the run. With --smoke-exit it replaces the default fresh profile.')
+        .option('--profile <path>', 'Launch with this profile directory (passed to Firefox as -profile). Left in place after the run. With --smoke-exit it replaces the default fresh profile. Firefox gets -purgecaches too, so the profile does not run chrome scripts an earlier build cached.')
+        .option('--no-purge-caches', 'With --profile, keep the profile startup cache (do not pass -purgecaches).')
         .option('--temp-profile', 'Launch with a fresh temporary profile that is removed when the run ends. The default for --smoke-exit.')
         .action(withErrorHandling(
     // `args` is the variadic positional, not a Commander flag, so it