@hominis/fireforge 0.10.1 → 0.11.0

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

@@ -0,0 +1,17 @@
+import { getProjectPaths } from '../core/config.js';
+import type { PatchMetadata, ReExportOptions } from '../types/commands/index.js';
+import type { FireForgeConfig } from '../types/config.js';
+/**
+ * Handles `re-export --files` end-to-end: computes the projected diff,
+ * runs the per-patch and cross-patch lint against a context in which the
+ * target patch has been replaced with the projected state, gates on
+ * confirmDestructive, and writes atomically.
+ *
+ * Lives outside reExportSinglePatch because the --files path has strictly
+ * different semantics (authoritative file list, destructive shrink
+ * confirmation, cross-patch projection lint) and shoehorning it through
+ * the generic single-patch helper is what led to the earlier bug where
+ * the projection lint ran against the current (unchanged) queue instead
+ * of the projected state.
+ */
+export declare function reExportFilesInPlace(paths: ReturnType<typeof getProjectPaths>, selectedPatches: PatchMetadata[], options: ReExportOptions, config: FireForgeConfig): Promise<void>;

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

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { appendHistory, confirmDestructive } from '../core/destructive.js';
+import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
+import { computeProjectedLintRegressions } from '../core/lint-projection.js';
+import { extractAffectedFiles } from '../core/patch-apply.js';
+import { updatePatchAndMetadata } from '../core/patch-export.js';
+import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, lintPatchQueue, } from '../core/patch-lint.js';
+import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
+import { InvalidArgumentError } from '../errors/base.js';
+import { pathExists } from '../utils/fs.js';
+import { info, outro, success, warn } from '../utils/logger.js';
+import { runPatchLint } from './export-shared.js';
+/**
+ * Handles `re-export --files` end-to-end: computes the projected diff,
+ * runs the per-patch and cross-patch lint against a context in which the
+ * target patch has been replaced with the projected state, gates on
+ * confirmDestructive, and writes atomically.
+ *
+ * Lives outside reExportSinglePatch because the --files path has strictly
+ * different semantics (authoritative file list, destructive shrink
+ * confirmation, cross-patch projection lint) and shoehorning it through
+ * the generic single-patch helper is what led to the earlier bug where
+ * the projection lint ran against the current (unchanged) queue instead
+ * of the projected state.
+ */
+export async function reExportFilesInPlace(paths, selectedPatches, options, config) {
+    const isDryRun = options.dryRun === true;
+    const target = selectedPatches[0];
+    if (!target) {
+        throw new InvalidArgumentError('--files requires a target patch.', '--files');
+    }
+    const filesOption = options.files;
+    if (filesOption === undefined) {
+        throw new InvalidArgumentError('reExportFilesInPlace called with no --files.', '--files');
+    }
+    const requested = [...new Set(filesOption)].sort();
+    const removed = target.filesAffected.filter((f) => !requested.includes(f));
+    const added = requested.filter((f) => !target.filesAffected.includes(f));
+    // Filter out paths that no longer exist on disk; we cannot include
+    // them in the new diff because getDiffForFilesAgainstHead would fail.
+    // Missing files are still dropped from the manifest so the resulting
+    // filesAffected reflects reality.
+    const missingFiles = [];
+    for (const file of requested) {
+        const filePath = join(paths.engine, file);
+        if (!(await pathExists(filePath))) {
+            missingFiles.push(file);
+        }
+    }
+    const missingSet = new Set(missingFiles);
+    const diffableFiles = requested.filter((f) => !missingSet.has(f));
+    for (const file of missingFiles) {
+        warn(`${target.filename}: requested file is missing on disk and will be dropped: ${file}`);
+    }
+    // Compute the projected diff up front. This is the same diff the real
+    // write would produce, so we get an exact preview through the lint
+    // gate and avoid computing it twice.
+    const projectedDiff = diffableFiles.length > 0 ? await getDiffForFilesAgainstHead(paths.engine, diffableFiles) : '';
+    if (!projectedDiff.trim()) {
+        throw new InvalidArgumentError(`Refusing to re-export ${target.filename} with --files because the projected scope ` +
+            'produces an empty patch. FireForge does not write zero-hunk patch files; ' +
+            `use "fireforge patch delete ${target.filename}" if this patch should be removed entirely.`, '--files');
+    }
+    const actualProjectedFiles = extractAffectedFiles(projectedDiff);
+    const actualProjectedSet = new Set(actualProjectedFiles);
+    const noDiffFiles = diffableFiles.filter((file) => !actualProjectedSet.has(file));
+    if (noDiffFiles.length > 0) {
+        throw new InvalidArgumentError(`Refusing to re-export ${target.filename} with --files because ${noDiffFiles.length} requested path${noDiffFiles.length === 1 ? '' : 's'} produced no diff hunks (${noDiffFiles.join(', ')}). ` +
+            'Keeping them in filesAffected would desync patches.json from the patch body. ' +
+            'Remove those paths from --files or modify them before retrying.', '--files');
+    }
+    // Run the per-patch lint against the projected diff. This mirrors what
+    // runPatchLint does in the standard re-export path.
+    await runPatchLint(paths.engine, actualProjectedFiles, projectedDiff, config, options.skipLint);
+    // Project the cross-patch context: replace the target entry with its
+    // would-be shrunken self (new diff + new newFiles + new
+    // modifiedFileAdditions). The projected entry must repopulate both
+    // source-site maps so the forward-import rule sees imports the
+    // shrunken diff would add — or stop adding — consistently with how a
+    // real rebuild would see them.
+    const baseCtx = await buildPatchQueueContext(paths.patches);
+    const projectedNewFiles = new Map();
+    for (const path of detectNewFilesInDiff(projectedDiff)) {
+        projectedNewFiles.set(path, extractNewFileContentFromDiff(projectedDiff, path));
+    }
+    const projectedModifiedFileAdditions = buildModifiedFileAdditionsFromDiff(projectedDiff);
+    const projectedEntries = baseCtx.entries.map((entry) => {
+        if (entry.filename !== target.filename)
+            return entry;
+        return {
+            ...entry,
+            diff: projectedDiff,
+            newFiles: projectedNewFiles,
+            modifiedFileAdditions: projectedModifiedFileAdditions,
+        };
+    });
+    // Baseline-vs-projected diffing: only regressions introduced *by* this
+    // shrink should block. A pre-existing cross-patch error elsewhere in
+    // the queue must not prevent the user from shrinking an unrelated
+    // patch (which is often exactly the tool they reach for to repair
+    // such a queue).
+    const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
+    const projectedIssues = lintPatchQueue({ entries: projectedEntries }).filter((i) => i.severity === 'error');
+    const regressions = computeProjectedLintRegressions(baselineIssues, projectedIssues);
+    const conflicts = regressions.length > 0
+        ? {
+            reason: `projected --files state introduces ${regressions.length} new cross-patch lint error(s)`,
+            details: regressions.map((i) => `[${i.check}] ${i.file}: ${i.message}`),
+        }
+        : null;
+    // Surface pre-existing errors as a non-blocking warning so the user
+    // doesn't walk away thinking the queue is clean.
+    if (baselineIssues.length > 0 && regressions.length === 0) {
+        warn(`Note: projected queue still has ${baselineIssues.length} pre-existing ` +
+            `cross-patch error(s) unrelated to this shrink. Run "fireforge verify" to list them.`);
+    }
+    // Shrinks are destructive (previously-owned files become unmanaged).
+    // Additive-only changes still deserve a prompt because --files asserts
+    // an authoritative file set.
+    const summary = [
+        `re-export ${target.filename} with --files scope`,
+        `current files (${target.filesAffected.length}): ${target.filesAffected.join(', ') || '(none)'}`,
+        `new files (${actualProjectedFiles.length}): ${actualProjectedFiles.join(', ') || '(none)'}`,
+    ];
+    if (removed.length > 0) {
+        summary.push(`would drop (become unmanaged): ${removed.join(', ')}`);
+    }
+    if (added.length > 0) {
+        summary.push(`would add: ${added.join(', ')}`);
+    }
+    if (missingFiles.length > 0) {
+        summary.push(`missing on disk (will be dropped): ${missingFiles.join(', ')}`);
+    }
+    const decision = await confirmDestructive({
+        operation: 're-export-files',
+        title: `Re-export ${target.filename} with --files`,
+        summary,
+        yes: options.yes === true,
+        dryRun: isDryRun,
+        unsafeOverride: options.forceUnsafe === true,
+        conflicts,
+    });
+    if (decision === 'cancelled') {
+        outro('Re-export cancelled');
+        return;
+    }
+    if (decision === 'dry-run') {
+        info(`[dry-run] ${target.filename}: ${actualProjectedFiles.length} file(s) in projected scope`);
+        outro('Dry run complete — no changes made');
+        return;
+    }
+    // Execute the write. At this point the projected diff is guaranteed to
+    // be non-empty and `actualProjectedFiles` is guaranteed to match the
+    // paths the body really touches, so the manifest cannot drift from the
+    // regenerated patch body. The history append runs inside the same patch
+    // directory lock as the mutation (via the onCommitted hook) so two
+    // concurrent re-exports cannot interleave records and a crash between
+    // mutation and append cannot orphan the audit trail.
+    await updatePatchAndMetadata(paths.patches, target.filename, projectedDiff, { filesAffected: actualProjectedFiles }, async () => {
+        await appendHistory(paths.patches, {
+            operation: 're-export-files',
+            args: {
+                filename: target.filename,
+                files: actualProjectedFiles,
+                previousFiles: target.filesAffected,
+                missingFilesDropped: missingFiles,
+            },
+            ...(options.yes === true ? { yes: true } : {}),
+            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
+            result: 'ok',
+        });
+    });
+    success(`Re-exported ${target.filename}`);
+    outro('Re-export complete');
+}
+//# sourceMappingURL=re-export-files.js.map

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

@@ -13,6 +13,7 @@ import { pathExists } from '../utils/fs.js';
 import { cancel, info, intro, isCancel, outro, spinner, success, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 import { runPatchLint } from './export-shared.js';
+import { reExportFilesInPlace } from './re-export-files.js';
 /**
  * Resolves patch identifiers (numbers or filenames) to manifest entries.
  * @param identifier - Patch number (e.g. "005") or filename (e.g. "005-ui-storage-modules.patch")
@@ -74,6 +75,22 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
     if (options.scan) {
         currentFilesAffected = await scanPatchFiles(currentFilesAffected, paths.engine, manifest, patch.filename, isDryRun);
     }
+    // --- Explicit file-subset path ---
+    // When --files is given, the target filesAffected is authoritative — drop
+    // anything not in the list, add anything new. This is the surgical repair
+    // primitive that replaces hand-editing patches.json; the user has already
+    // acknowledged via confirmDestructive (done in the caller) that any drop
+    // is intentional.
+    if (options.files !== undefined) {
+        const requested = [...new Set(options.files)].sort();
+        currentFilesAffected = requested;
+        const removed = patch.filesAffected.filter((f) => !requested.includes(f));
+        const added = requested.filter((f) => !patch.filesAffected.includes(f));
+        for (const f of added)
+            info(`  + ${f}`);
+        for (const f of removed)
+            info(`  - ${f}`);
+    }
     const missingFiles = [];
     for (const file of currentFilesAffected) {
         const filePath = join(paths.engine, file);
@@ -165,6 +182,16 @@ async function resolveSelectedPatches(patches, options, manifest) {
 export async function reExportCommand(projectRoot, patches, options) {
     const isDryRun = options.dryRun === true;
     intro(isDryRun ? 'FireForge Re-export (dry run)' : 'FireForge Re-export');
+    // --files is mutually exclusive with --scan and --all: they select
+    // different scope contracts.
+    if (options.files !== undefined) {
+        if (options.all || options.scan) {
+            throw new InvalidArgumentError('--files cannot be combined with --scan or --all.', '--files');
+        }
+        if (patches.length !== 1) {
+            throw new InvalidArgumentError('--files operates on exactly one target patch. Pass a single patch identifier.', '--files');
+        }
+    }
     const paths = getProjectPaths(projectRoot);
     // Check if engine exists
     if (!(await pathExists(paths.engine))) {
@@ -188,6 +215,17 @@ export async function reExportCommand(projectRoot, patches, options) {
         outro('Nothing to re-export');
         return;
     }
+    // --files path: handled end-to-end here so we can lint the *projected*
+    // shrunken state (not the current queue) and skip the generic re-export
+    // loop. The projection substitutes the target patch's diff and newFiles
+    // with the freshly computed content, then runs lintPatchQueue so any
+    // forward-import introduced or uncovered by the shrink is caught before
+    // we write anything.
+    if (options.files !== undefined) {
+        const filesConfig = await loadConfig(projectRoot);
+        await reExportFilesInPlace(paths, selectedPatches, options, filesConfig);
+        return;
+    }
     const config = await loadConfig(projectRoot);
     let reExported = 0;
     const progress = spinner('Preparing re-export...');
@@ -225,8 +263,14 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .description('Re-export existing patches from current engine state')
         .option('-a, --all', 'Re-export all patches')
         .option('-s, --scan', 'Scan directories for new/removed files and update filesAffected')
+        .option('--files <paths>', 'Restrict the re-exported filesAffected to this comma-separated list (single target patch only)', (value) => value
+        .split(',')
+        .map((v) => v.trim())
+        .filter((v) => v.length > 0))
         .option('--dry-run', 'Show what would change without writing')
         .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
+        .option('-y, --yes', 'Skip confirmation when --files shrinks a patch (required for non-TTY)')
+        .option('--force-unsafe', 'Bypass cross-patch lint refusal when --files shrinks a patch')
         .action(withErrorHandling(async (patches, options) => {
         await reExportCommand(getProjectRoot(), patches, pickDefined(options));
     }));

package/dist/src/commands/rebase/abort.d.ts

@@ -4,4 +4,4 @@
 /**
  * Handles `fireforge rebase --abort`.
  */
-export declare function handleAbort(projectRoot: string, force?: boolean): Promise<void>;
+export declare function handleAbort(projectRoot: string, yes?: boolean): Promise<void>;

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

@@ -3,15 +3,17 @@
  * Rebase abort flow.
  */
 import { getProjectPaths, loadState, saveState } from '../../core/config.js';
+import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.js';
 import { resetChanges } from '../../core/git.js';
 import { clearRebaseSession, loadRebaseSession } from '../../core/rebase-session.js';
 import { NoRebaseSessionError } from '../../errors/rebase.js';
+import { pathExists } from '../../utils/fs.js';
 import { intro, outro, spinner, success } from '../../utils/logger.js';
 import { confirmDirtyEngineReset } from './confirm.js';
 /**
  * Handles `fireforge rebase --abort`.
  */
-export async function handleAbort(projectRoot, force) {
+export async function handleAbort(projectRoot, yes) {
     intro('FireForge Rebase — Abort');
     const session = await loadRebaseSession(projectRoot);
     if (!session)
@@ -19,8 +21,8 @@ export async function handleAbort(projectRoot, force) {
     const paths = getProjectPaths(projectRoot);
     if (!(await confirmDirtyEngineReset({
         engineDir: paths.engine,
-        force: force ?? false,
-        nonInteractiveHint: 'Use: fireforge rebase --abort --force',
+        yes: yes ?? false,
+        nonInteractiveHint: 'Use: fireforge rebase --abort --yes',
         warningMessage: 'The engine directory has uncommitted changes that will be lost.',
         promptMessage: 'Discard uncommitted changes and abort rebase?',
         cancelMessage: 'Abort cancelled',
@@ -31,6 +33,13 @@ export async function handleAbort(projectRoot, force) {
     try {
         await resetChanges(paths.engine);
         s.stop('Engine restored');
+        // Clear Furnace state — the engine has been rolled back to pre-rebase state.
+        const furnacePaths = getFurnacePaths(projectRoot);
+        if (await pathExists(furnacePaths.furnaceState)) {
+            await updateFurnaceState(projectRoot, (current) => ({
+                ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
+            }));
+        }
     }
     catch (error) {
         s.error('Failed to restore engine');

package/dist/src/commands/rebase/confirm.d.ts

@@ -4,7 +4,7 @@
 /** Options for the dirty-engine confirmation prompt. */
 export interface DirtyEngineConfirmationOptions {
     engineDir: string;
-    force: boolean;
+    yes: boolean;
     nonInteractiveHint: string;
     warningMessage: string;
     promptMessage: string;
@@ -13,6 +13,6 @@ export interface DirtyEngineConfirmationOptions {
 /**
  * Checks if the engine has uncommitted changes and prompts for confirmation.
  * Returns true if safe to proceed, false if the user cancelled.
- * Throws in non-interactive mode without --force.
+ * Throws in non-interactive mode without --yes.
  */
-export declare function confirmDirtyEngineReset({ engineDir, force, nonInteractiveHint, warningMessage, promptMessage, cancelMessage, }: DirtyEngineConfirmationOptions): Promise<boolean>;
+export declare function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveHint, warningMessage, promptMessage, cancelMessage, }: DirtyEngineConfirmationOptions): Promise<boolean>;

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

@@ -9,15 +9,15 @@ import { cancel, isCancel, warn } from '../../utils/logger.js';
 /**
  * Checks if the engine has uncommitted changes and prompts for confirmation.
  * Returns true if safe to proceed, false if the user cancelled.
- * Throws in non-interactive mode without --force.
+ * Throws in non-interactive mode without --yes.
  */
-export async function confirmDirtyEngineReset({ engineDir, force, nonInteractiveHint, warningMessage, promptMessage, cancelMessage, }) {
-    if (!(await hasChanges(engineDir)) || force) {
+export async function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveHint, warningMessage, promptMessage, cancelMessage, }) {
+    if (!(await hasChanges(engineDir)) || yes) {
         return true;
     }
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
     if (!isInteractive) {
-        throw new InvalidArgumentError('Engine has uncommitted changes and interactive confirmation is not available. Use --force to proceed.', nonInteractiveHint);
+        throw new InvalidArgumentError('Engine has uncommitted changes and interactive confirmation is not available. Use --yes to proceed.', nonInteractiveHint);
     }
     warn(warningMessage);
     const confirmed = await confirm({

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

@@ -11,6 +11,7 @@
  * Supports `--continue` (resume after manual fix) and `--abort` (cancel).
  */
 import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.js';
 import { getHead, isGitRepository, resetChanges } from '../../core/git.js';
 import { discoverPatches } from '../../core/patch-files.js';
 import { loadPatchesManifest } from '../../core/patch-manifest.js';
@@ -64,8 +65,8 @@ async function handleFreshStart(projectRoot, options) {
     }
     if (!(await confirmDirtyEngineReset({
         engineDir: paths.engine,
-        force: options.force ?? false,
-        nonInteractiveHint: 'Use: fireforge rebase --force',
+        yes: options.yes ?? false,
+        nonInteractiveHint: 'Use: fireforge rebase --yes',
         warningMessage: 'The engine directory has uncommitted changes that will be lost by the rebase.',
         promptMessage: 'Discard uncommitted changes and start rebase?',
         cancelMessage: 'Rebase cancelled',
@@ -78,6 +79,14 @@ async function handleFreshStart(projectRoot, options) {
     const resetSpinner = spinner('Resetting engine to baseline...');
     await resetChanges(paths.engine);
     resetSpinner.stop('Engine reset to baseline');
+    // Clear Furnace state — the engine no longer contains deployed components.
+    // Preserve pendingRepair since that tracks authoring-side rollback issues.
+    const furnacePaths = getFurnacePaths(projectRoot);
+    if (await pathExists(furnacePaths.furnaceState)) {
+        await updateFurnaceState(projectRoot, (current) => ({
+            ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
+        }));
+    }
     // Create rebase session
     const allPatches = await discoverPatches(paths.patches);
     const session = {
@@ -103,7 +112,7 @@ async function handleFreshStart(projectRoot, options) {
  */
 export async function rebaseCommand(projectRoot, options = {}) {
     if (options.abort) {
-        return handleAbort(projectRoot, options.force);
+        return handleAbort(projectRoot, options.yes);
     }
     if (options.continue) {
         return handleContinue(projectRoot, options.maxFuzz ?? 3);
@@ -119,7 +128,7 @@ export function registerRebase(program, { getProjectRoot, withErrorHandling }) {
         .option('--abort', 'Cancel the rebase and restore engine to pre-rebase state')
         .option('--dry-run', 'Show what would happen without modifying anything')
         .option('--max-fuzz <n>', 'Maximum fuzz factor for git apply (default: 3)', parseInt)
-        .option('-f, --force', 'Skip dirty-tree confirmation prompt')
+        .option('-y, --yes', 'Skip dirty-tree confirmation prompt')
         .action(withErrorHandling(async (options) => {
         await rebaseCommand(getProjectRoot(), pickDefined(options));
     }));

package/dist/src/commands/reset.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { confirm } from '@clack/prompts';
 import { getProjectPaths } from '../core/config.js';
+import { getFurnacePaths, updateFurnaceState } from '../core/furnace-config.js';
 import { hasChanges, isGitRepository, resetChanges } from '../core/git.js';
 import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
@@ -41,12 +42,12 @@ export async function resetCommand(projectRoot, options) {
         outro('Dry run complete — no changes made');
         return;
     }
-    // Confirm reset unless --force is specified
-    if (!options.force) {
+    // Confirm reset unless --yes is specified
+    if (!options.yes) {
         // Check for non-interactive mode
         const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
         if (!isInteractive) {
-            throw new InvalidArgumentError('Interactive confirmation not available. Use --force flag to reset without confirmation.', 'Use: fireforge reset --force');
+            throw new InvalidArgumentError('Interactive confirmation not available. Use --yes flag to reset without confirmation.', 'Use: fireforge reset --yes');
         }
         warn('This will discard all uncommitted changes in the engine directory, including staged additions and untracked files.');
         const confirmed = await confirm({
@@ -61,6 +62,21 @@ export async function resetCommand(projectRoot, options) {
     const s = spinner('Resetting changes...');
     try {
         await resetChanges(paths.engine);
+        // Clearing furnace-state.json is the honest representation of what just
+        // happened: any previously deployed Furnace files have been discarded
+        // with the engine reset. Without this, a subsequent `furnace apply`
+        // would match on workspace checksums and report "up to date" against
+        // an engine that no longer contains the deployed copies. (The drift
+        // check in apply also catches this, but clearing here keeps state
+        // consistent regardless of the drift oracle.) Preserve pendingRepair:
+        // authoring-side rollback markers are about the workspace/component
+        // tree, not the engine checkout, so reset must not silently forget them.
+        const furnacePaths = getFurnacePaths(projectRoot);
+        if (await pathExists(furnacePaths.furnaceState)) {
+            await updateFurnaceState(projectRoot, (current) => ({
+                ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
+            }));
+        }
         s.stop('Changes reset');
         outro('Working tree restored to clean state');
     }
@@ -74,7 +90,7 @@ export function registerReset(program, { getProjectRoot, withErrorHandling }) {
     program
         .command('reset')
         .description('Reset engine/ to clean state')
-        .option('-f, --force', 'Skip confirmation prompt (required for scripts/CI)')
+        .option('-y, --yes', 'Skip confirmation prompt (required for scripts/CI)')
         .option('--dry-run', 'Show what would be reset without doing it')
         .action(withErrorHandling(async (options) => {
         await resetCommand(getProjectRoot(), pickDefined(options));

package/dist/src/commands/run.js

@@ -2,12 +2,14 @@
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getProjectPaths } from '../core/config.js';
+import { extractComponentChecksums, hasComponentChanged } from '../core/furnace-apply-helpers.js';
+import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from '../core/furnace-config.js';
 import { buildArtifactMismatchMessage, hasBuildArtifacts, run } from '../core/mach.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, removeDir, removeFile } from '../utils/fs.js';
-import { info, intro, verbose } from '../utils/logger.js';
+import { info, intro, verbose, warn } from '../utils/logger.js';
 /**
  * Cleans the dev profile to prevent stale-state startup failures.
  *
@@ -45,6 +47,47 @@ async function cleanDevProfile(engineDir) {
         verbose(`Non-fatal dev profile cleanup failure: ${toError(error).message}`);
     }
 }
+/**
+ * Checks whether any Furnace component has changed since the last apply
+ * and warns the user. The build command auto-applies, but run does not,
+ * so this advisory message prevents the common "forgot to apply" mistake.
+ */
+async function warnIfFurnaceStale(projectRoot) {
+    try {
+        if (!(await furnaceConfigExists(projectRoot)))
+            return;
+        const config = await loadFurnaceConfig(projectRoot);
+        const state = await loadFurnaceState(projectRoot);
+        const furnacePaths = getFurnacePaths(projectRoot);
+        if (!state.appliedChecksums)
+            return;
+        const stale = [];
+        for (const name of Object.keys(config.overrides)) {
+            const dir = `${furnacePaths.overridesDir}/${name}`;
+            if (!(await pathExists(dir)))
+                continue;
+            const prev = extractComponentChecksums(state.appliedChecksums, 'override', name);
+            if (await hasComponentChanged(dir, prev))
+                stale.push(name);
+        }
+        for (const name of Object.keys(config.custom)) {
+            const dir = `${furnacePaths.customDir}/${name}`;
+            if (!(await pathExists(dir)))
+                continue;
+            const prev = extractComponentChecksums(state.appliedChecksums, 'custom', name);
+            if (await hasComponentChanged(dir, prev))
+                stale.push(name);
+        }
+        if (stale.length > 0) {
+            warn(`Furnace component${stale.length === 1 ? '' : 's'} modified since last apply: ${stale.join(', ')}. ` +
+                'Run "fireforge furnace apply" (or "fireforge build" which auto-applies) to update the engine.');
+        }
+    }
+    catch {
+        // Non-fatal: a broken furnace config should not block run.
+        verbose('Furnace staleness check skipped due to an error.');
+    }
+}
 /**
  * Runs the run command to launch the built browser.
  * @param projectRoot - Root directory of the project
@@ -71,6 +114,8 @@ export async function runCommand(projectRoot) {
         throw new GeneralError(`Run requires a completed build. ${detail}\n\n` +
             "Run 'fireforge build' first, then rerun 'fireforge run'.");
     }
+    // Warn if Furnace components changed since the last apply
+    await warnIfFurnaceStale(projectRoot);
     // Clean stale profile state to prevent silent startup failures
     await cleanDevProfile(paths.engine);
     info('Launching browser...\n');

package/dist/src/commands/setup-support.js

@@ -63,7 +63,7 @@ export function validateSetupOptions(options) {
         throw new InvalidArgumentError('Binary name must start with a letter and contain only lowercase letters, numbers, and hyphens', '--binary-name');
     }
     if (options.firefoxVersion !== undefined && !isValidFirefoxVersion(options.firefoxVersion)) {
-        throw new InvalidArgumentError('Invalid Firefox version format (e.g., 146.0, 140.0esr, or 147.0b1)', '--firefox-version');
+        throw new InvalidArgumentError('Invalid Firefox version format (e.g., 146.0, 146.0esr, or 147.0b1)', '--firefox-version');
     }
     if (options.product !== undefined) {
         resolveFirefoxProduct(options.product, '--product');
@@ -127,10 +127,10 @@ async function promptSetupInputs(options) {
             ? Promise.resolve(options.firefoxVersion)
             : text({
                 message: 'Firefox version to base on',
-                placeholder: '140.0esr',
+                placeholder: '146.0esr',
                 validate: (value) => {
                     if (value && !isValidFirefoxVersion(value)) {
-                        return 'Invalid Firefox version format (e.g., 146.0, 140.0esr, or 147.0b1)';
+                        return 'Invalid Firefox version format (e.g., 146.0, 146.0esr, or 147.0b1)';
                     }
                     return undefined;
                 },
@@ -141,7 +141,7 @@ async function promptSetupInputs(options) {
             }
             const effectiveVersion = (typeof results.firefoxVersion === 'string' && results.firefoxVersion.trim()) ||
                 options.firefoxVersion ||
-                '140.0esr';
+                '146.0esr';
             const inferredProduct = inferProductFromVersion(effectiveVersion);
             if (inferredProduct) {
                 return Promise.resolve(inferredProduct);
@@ -183,7 +183,7 @@ async function promptSetupInputs(options) {
     const finalAppId = (typeof project.appId === 'string' ? project.appId.trim() : '') ||
         `org.${sanitizedName}.browser`;
     const finalBinaryName = (typeof project.binaryName === 'string' ? project.binaryName.trim() : '') || sanitizedName;
-    const finalFirefoxVersion = (typeof project.firefoxVersion === 'string' ? project.firefoxVersion.trim() : '') || '140.0esr';
+    const finalFirefoxVersion = (typeof project.firefoxVersion === 'string' ? project.firefoxVersion.trim() : '') || '146.0esr';
     if (!isValidAppId(finalAppId)) {
         throw new InvalidArgumentError(`Derived appId "${finalAppId}" is invalid.`, 'appId');
     }