@hominis/fireforge 0.13.2 → 0.14.0

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

@@ -44,10 +44,25 @@ function getFailedComponentNames(result) {
 }
 function getPersistableAppliedEntry(name, appliedEntry) {
     if (!appliedEntry) {
-        throw new FurnaceError(`Named deploy for "${name}" completed without an applied entry.`);
+        throw new FurnaceError(`Deploy for "${name}" finished without producing an applied component entry; ` +
+            `furnace state was not modified. Run "fireforge doctor --repair-furnace" to ` +
+            `reconcile state, then retry the deploy. If this persists, file a bug with the ` +
+            `output of "fireforge doctor".`);
     }
     if (appliedEntry.type !== 'override' && appliedEntry.type !== 'custom') {
-        throw new FurnaceError(`Named deploy for "${name}" returned unsupported component type "${appliedEntry.type}".`);
+        throw new FurnaceError(`Deploy for "${name}" returned an unsupported component type "${appliedEntry.type}"; ` +
+            `furnace state was not modified. Run "fireforge doctor --repair-furnace" to reconcile, ` +
+            `then verify the component with "fireforge furnace validate" before retrying.`);
+    }
+    // Guard against future refactors that might reorder or misroute the
+    // applied[] array: named deploy persists state under a single component
+    // name, so the first applied entry MUST be that component. Persisting a
+    // different component's checksums here would cause the next status/apply
+    // run to mis-report health for both components involved.
+    if (name !== undefined && appliedEntry.name !== name) {
+        throw new FurnaceError(`Deploy for "${name}" returned an applied entry for a different component ` +
+            `("${appliedEntry.name}"); refusing to persist mismatched state. ` +
+            `Run "fireforge doctor --repair-furnace" to reconcile, then retry the deploy.`);
     }
     return {
         name: appliedEntry.name,

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

@@ -51,7 +51,9 @@ async function diffOverride(name, projectRoot, config) {
     const state = await loadState(projectRoot);
     const baseCommit = overrideConfig.baseCommit ?? state.baseCommit;
     if (!baseCommit) {
-        throw new FurnaceError('Cannot diff: baseCommit not found. Re-run "fireforge download" to establish a baseline.', name);
+        throw new FurnaceError(`Cannot diff "${name}": baseCommit not recorded for this override. ` +
+            `Run "fireforge furnace refresh --reset-base ${name}" to stamp the current engine HEAD as the baseline, ` +
+            `or re-run "fireforge download" to re-establish a project-wide baseline.`, name);
     }
     const entries = await readdir(overrideDir, { withFileTypes: true });
     let hasDifferences = false;

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

@@ -1,8 +1,30 @@
 // SPDX-License-Identifier: EUPL-1.2
+import { isAbsolute, normalize } from 'node:path';
 import { text } from '@clack/prompts';
 import { createDefaultFurnaceConfig, furnaceConfigExists, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { cancel, info, intro, isCancel, note, outro, success } from '../../utils/logger.js';
+/**
+ * Validates an FTL base path before writing it to furnace.json. Rejects
+ * absolute paths, null bytes, and any normalised segment starting with
+ * `..` — the previous `includes('..')` substring check caught the common
+ * case but missed `./../../` and absolute paths that are arguably worse.
+ */
+function validateFtlBasePath(value) {
+    if (value.length === 0) {
+        throw new FurnaceError('ftlBasePath must not be empty.');
+    }
+    if (value.includes('\0')) {
+        throw new FurnaceError('ftlBasePath must not contain null bytes.');
+    }
+    if (isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value)) {
+        throw new FurnaceError(`ftlBasePath "${value}" must be a relative path inside the engine checkout, not absolute.`);
+    }
+    const normalized = normalize(value.replace(/\\/g, '/'));
+    if (normalized === '..' || normalized.startsWith('../')) {
+        throw new FurnaceError(`ftlBasePath "${value}" must not escape the engine checkout via parent-directory segments.`);
+    }
+}
 /**
  * Runs the furnace init command to create a default furnace.json with
  * user-specified settings.
@@ -15,7 +37,7 @@ export async function furnaceInitCommand(projectRoot, options = {}) {
         throw new FurnaceError('furnace.json already exists. Use --force to overwrite it.');
     }
     const config = createDefaultFurnaceConfig();
-    const isInteractive = process.stdin.isTTY;
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
     // Resolve componentPrefix
     if (options.prefix !== undefined) {
         config.componentPrefix = options.prefix;
@@ -38,9 +60,7 @@ export async function furnaceInitCommand(projectRoot, options = {}) {
     }
     // Resolve ftlBasePath
     if (options.ftlBasePath !== undefined) {
-        if (options.ftlBasePath.includes('..')) {
-            throw new FurnaceError('ftlBasePath must not contain ".." (path traversal)');
-        }
+        validateFtlBasePath(options.ftlBasePath);
         config.ftlBasePath = options.ftlBasePath;
     }
     else if (isInteractive) {
@@ -54,9 +74,7 @@ export async function furnaceInitCommand(projectRoot, options = {}) {
         }
         const ftlValue = ftlResult.trim();
         if (ftlValue) {
-            if (ftlValue.includes('..')) {
-                throw new FurnaceError('ftlBasePath must not contain ".." (path traversal)');
-            }
+            validateFtlBasePath(ftlValue);
             config.ftlBasePath = ftlValue;
         }
     }

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

@@ -9,15 +9,23 @@ import { formatErrorText, formatSuccessText, info, intro, note, outro, } from '.
  * its workspace checksums have changed since the last apply.
  */
 async function getHealthIndicator(componentDir, type, name, appliedChecksums) {
-    if (!(await pathExists(componentDir))) {
-        return formatErrorText('missing');
+    try {
+        if (!(await pathExists(componentDir))) {
+            return formatErrorText('missing');
+        }
+        const previous = extractComponentChecksums(appliedChecksums, type, name);
+        if (Object.keys(previous).length === 0) {
+            return formatErrorText('not applied');
+        }
+        const changed = await hasComponentChanged(componentDir, previous);
+        return changed ? formatErrorText('modified') : formatSuccessText('clean');
     }
-    const previous = extractComponentChecksums(appliedChecksums, type, name);
-    if (Object.keys(previous).length === 0) {
-        return formatErrorText('not applied');
+    catch {
+        // A race with `furnace remove`, filesystem permission change, or a
+        // transient IO failure must not crash the entire `list -v` output —
+        // render a degraded state so the rest of the table still shows.
+        return formatErrorText('unavailable');
     }
-    const changed = await hasComponentChanged(componentDir, previous);
-    return changed ? formatErrorText('modified') : formatSuccessText('clean');
 }
 /**
  * Runs the furnace list command to display all registered components.

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { select, text } from '@clack/prompts';
 import { getProjectPaths, loadConfig, loadState } from '../../core/config.js';
 import { createDefaultFurnaceConfig, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
@@ -31,6 +31,24 @@ async function copyOverrideFiles(engineDir, srcDir, destDir, componentName, hasF
     await ensureDir(destDir);
     const entries = await readdir(srcDir, { withFileTypes: true });
     const copiedFiles = [];
+    // Snapshot-then-copy helper: ensures the destination's parent dir exists
+    // before snapshot + copy, and surfaces the failing filename on error so
+    // partial-state rollback has the context needed to report cleanly.
+    const snapshotAndCopy = async (from, dest, displayName) => {
+        await ensureDir(dirname(dest));
+        try {
+            await snapshotFile(journal, dest);
+        }
+        catch (error) {
+            throw new FurnaceError(`Failed to snapshot "${displayName}" before override: ${toError(error).message}`, componentName);
+        }
+        try {
+            await copyFile(from, dest);
+        }
+        catch (error) {
+            throw new FurnaceError(`Failed to copy "${displayName}" into the override: ${toError(error).message}`, componentName);
+        }
+    };
     for (const entry of entries) {
         if (!entry.isFile())
             continue;
@@ -38,8 +56,7 @@ async function copyOverrideFiles(engineDir, srcDir, destDir, componentName, hasF
             // Only copy .css files
             if (entry.name.endsWith('.css')) {
                 const dest = join(destDir, entry.name);
-                await snapshotFile(journal, dest);
-                await copyFile(join(srcDir, entry.name), dest);
+                await snapshotAndCopy(join(srcDir, entry.name), dest, entry.name);
                 copiedFiles.push(entry.name);
             }
         }
@@ -47,8 +64,7 @@ async function copyOverrideFiles(engineDir, srcDir, destDir, componentName, hasF
             // Full override: copy .mjs and .css files
             if (entry.name.endsWith('.mjs') || entry.name.endsWith('.css')) {
                 const dest = join(destDir, entry.name);
-                await snapshotFile(journal, dest);
-                await copyFile(join(srcDir, entry.name), dest);
+                await snapshotAndCopy(join(srcDir, entry.name), dest, entry.name);
                 copiedFiles.push(entry.name);
             }
         }
@@ -57,8 +73,7 @@ async function copyOverrideFiles(engineDir, srcDir, destDir, componentName, hasF
         const ftlName = `${componentName}.ftl`;
         const ftlSrc = join(engineDir, ftlDir, ftlName);
         const dest = join(destDir, ftlName);
-        await snapshotFile(journal, dest);
-        await copyFile(ftlSrc, dest);
+        await snapshotAndCopy(ftlSrc, dest, ftlName);
         copiedFiles.push(ftlName);
     }
     return copiedFiles;
@@ -123,6 +138,24 @@ async function performOverrideMutations(args) {
         }
     });
 }
+/**
+ * Throws if `componentName` is already classified anywhere in the furnace
+ * config. Without this guard, `writeFurnaceConfig` would happily produce a
+ * file where the same tag appears under multiple categories (stock +
+ * override, custom + override) and later commands would no longer be able
+ * to reason about that component cleanly.
+ */
+function assertNoComponentCollision(config, componentName) {
+    if (componentName in config.overrides) {
+        throw new FurnaceError(`An override for "${componentName}" already exists in furnace.json`, componentName);
+    }
+    if (config.stock.includes(componentName)) {
+        throw new FurnaceError(`"${componentName}" is already registered as a stock component. Remove it from config.stock before creating an override.`, componentName);
+    }
+    if (componentName in config.custom) {
+        throw new FurnaceError(`"${componentName}" is already registered as a custom component. Custom components cannot also be overrides.`, componentName);
+    }
+}
 /**
  * Runs the furnace override command to fork an existing engine component.
  * @param projectRoot - Root directory of the project
@@ -179,10 +212,7 @@ export async function furnaceOverrideCommand(projectRoot, name, options = {}) {
         }
         componentName = selected;
     }
-    // Check for existing override
-    if (componentName in config.overrides) {
-        throw new FurnaceError(`An override for "${componentName}" already exists in furnace.json`, componentName);
-    }
+    assertNoComponentCollision(config, componentName);
     // Validate the component exists in engine
     const details = await getComponentDetails(paths.engine, componentName, ftlDir);
     if (!details) {
@@ -292,12 +322,14 @@ export async function furnaceBatchOverrideCommand(projectRoot, names, options =
     const ftlDir = resolveFtlDir(config.ftlBasePath);
     const forgeConfig = await loadConfig(projectRoot);
     const state = await loadState(projectRoot);
-    // Check for duplicates and pre-existing overrides
+    // Check for duplicates and pre-existing classifications across every
+    // bucket in furnace.json. Missing these collisions silently double-
+    // classifies a tag (e.g. both stock and override) and leaves the
+    // workspace in a state that later `furnace status`/`apply` cannot
+    // reason about cleanly.
     const uniqueNames = [...new Set(names)];
     for (const name of uniqueNames) {
-        if (name in config.overrides) {
-            throw new FurnaceError(`An override for "${name}" already exists in furnace.json`, name);
-        }
+        assertNoComponentCollision(config, name);
     }
     const succeeded = [];
     const failed = [];

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

@@ -135,13 +135,16 @@ async function restoreOverrideEngineFiles(engineDir, overrideDir, overrideConfig
  * the failure.
  */
 async function cleanupCustomTestFiles(name, projectRoot, journal) {
+    const partialFailures = [];
     let forgeConfig;
     try {
         forgeConfig = await loadConfig(projectRoot);
     }
     catch (error) {
-        warn(`Could not load config for test cleanup — ${toError(error).message}. Remove test files manually if needed.`);
-        return;
+        const msg = `Could not load config for test cleanup — ${toError(error).message}. Remove test files manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
+        return { partialFailures };
     }
     const paths = getProjectPaths(projectRoot);
     const binaryName = forgeConfig.binaryName;
@@ -153,7 +156,7 @@ async function cleanupCustomTestFiles(name, projectRoot, journal) {
     const testFileName = `browser_${binaryName}_${underscored}.js`;
     const testDir = join(paths.engine, 'browser/base/content/test', binaryName);
     if (!(await pathExists(testDir)))
-        return;
+        return { partialFailures };
     // Step 1: Delete the test file itself
     try {
         const testFilePath = join(testDir, testFileName);
@@ -164,7 +167,9 @@ async function cleanupCustomTestFiles(name, projectRoot, journal) {
         }
     }
     catch (error) {
-        warn(`Could not delete test file ${testFileName} — ${toError(error).message}. Remove it manually if needed.`);
+        const msg = `Could not delete test file ${testFileName} — ${toError(error).message}. Remove it manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
     }
     // Step 2: Remove the test entry from browser.toml
     try {
@@ -180,7 +185,9 @@ async function cleanupCustomTestFiles(name, projectRoot, journal) {
         }
     }
     catch (error) {
-        warn(`Could not update browser.toml — ${toError(error).message}. Remove the test entry manually if needed.`);
+        const msg = `Could not update browser.toml — ${toError(error).message}. Remove the test entry manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
     }
     // Step 3: Clean up empty test directory and deregister from moz.build
     try {
@@ -198,8 +205,11 @@ async function cleanupCustomTestFiles(name, projectRoot, journal) {
         }
     }
     catch (error) {
-        warn(`Could not clean up test directory — ${toError(error).message}. Remove it manually if needed.`);
+        const msg = `Could not clean up test directory — ${toError(error).message}. Remove it manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
     }
+    return { partialFailures };
 }
 function dropChecksumsByPrefix(state, prefix) {
     const result = { ...state };
@@ -211,6 +221,38 @@ function dropChecksumsByPrefix(state, prefix) {
     }
     return result;
 }
+/**
+ * Confirms the remove operation interactively when TTY is available, or
+ * enforces the `--yes` contract in non-interactive mode. Returns `false`
+ * when the user cancelled and the caller should exit silently.
+ */
+async function confirmFurnaceRemove(name, type, options, isInteractive) {
+    if (!isInteractive && !options.yes) {
+        throw new FurnaceError(`Cannot remove "${name}" in non-interactive mode without --yes flag.`, name);
+    }
+    if (!options.yes && isInteractive) {
+        const confirmed = await confirm({
+            message: `Remove ${type} component "${name}"?`,
+        });
+        if (isCancel(confirmed) || !confirmed) {
+            cancel('Remove cancelled');
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Enforces the engine-as-git precondition for both override and custom
+ * removals. Runs BEFORE the lock is acquired or a journal is registered so
+ * the failure path does not involve any rollback infrastructure.
+ */
+async function requireGitEngineForRemove(type, name, engineDir) {
+    if (type !== 'override' && type !== 'custom')
+        return;
+    if (!(await isGitRepository(engineDir))) {
+        throw new FurnaceError(`Cannot remove ${type} component "${name}": engine is not a git repository. Run "fireforge download" to initialise it.`, name);
+    }
+}
 /**
  * Runs the furnace remove command to remove a component from the workspace.
  * @param projectRoot - Root directory of the project
@@ -229,19 +271,8 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
     if (!type) {
         throw new FurnaceError(`Component "${name}" not found in furnace.json. Run "fireforge furnace list" to see registered components.`, name);
     }
-    // Require --yes in non-interactive mode to prevent silent removals
-    if (!isInteractive && !options.yes) {
-        throw new FurnaceError(`Cannot remove "${name}" in non-interactive mode without --yes flag.`, name);
-    }
-    // Confirm removal (skip if --yes)
-    if (!options.yes && isInteractive) {
-        const confirmed = await confirm({
-            message: `Remove ${type} component "${name}"?`,
-        });
-        if (isCancel(confirmed) || !confirmed) {
-            cancel('Remove cancelled');
-            return;
-        }
+    if (!(await confirmFurnaceRemove(name, type, options, isInteractive))) {
+        return;
     }
     // Begin transactional mutation: every file deleted or rewritten is first
     // snapshotted in a rollback journal so any failure mid-removal restores the
@@ -249,6 +280,7 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
     // the furnace-wide lock and is registered with the global SIGINT/SIGTERM
     // rollback pathway.
     const paths = getProjectPaths(projectRoot);
+    await requireGitEngineForRemove(type, name, paths.engine);
     await runFurnaceMutation(projectRoot, 'remove-rollback', async (ctx) => {
         const journal = createRollbackJournal();
         ctx.registerJournal(journal);
@@ -279,6 +311,12 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
             }
             else if (type === 'custom') {
                 const customConfig = config.custom[name];
+                // Custom-component removal mutates engine files (jar.mn,
+                // customElements.js, deployed widgets, optional .ftl) and the
+                // rollback journal is the only safety net for those edits while
+                // the command runs. The git-as-engine precondition is enforced
+                // before the lock is acquired (see furnaceRemoveCommand above)
+                // so if we reach this point, the engine is a git repository.
                 if (customConfig?.register) {
                     // customElements.js is the only file removeCustomElementRegistration touches.
                     await snapshotFile(journal, join(paths.engine, 'toolkit/content/customElements.js'));
@@ -317,8 +355,10 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
                     }
                 }
             }
+            let testCleanupFailures = [];
             if (type === 'custom') {
-                await cleanupCustomTestFiles(name, projectRoot, journal);
+                const result = await cleanupCustomTestFiles(name, projectRoot, journal);
+                testCleanupFailures = result.partialFailures;
             }
             // Remove entry from furnace.json
             if (type === 'stock') {
@@ -337,6 +377,14 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
             // entire remove operation is a single atomic unit.
             await snapshotFile(journal, furnacePaths.furnaceState);
             await updateFurnaceState(projectRoot, (state) => dropChecksumsByPrefix(state, `${type}/${name}/`));
+            // Test-cleanup failures are warn-and-continue by design (test files
+            // are secondary artefacts), but the caller deserves a single summary
+            // line pointing at the residue so they don't have to re-scan earlier
+            // warn output to realise the removal was partial.
+            if (testCleanupFailures.length > 0) {
+                warn(`Component "${name}" removed with ${testCleanupFailures.length} test-cleanup warning(s) above. ` +
+                    `The component is deregistered, but test files may linger in the engine — review and delete manually if needed.`);
+            }
         }
         catch (error) {
             try {

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

@@ -14,6 +14,26 @@ import { FurnaceError } from '../../errors/furnace.js';
 import { toError } from '../../utils/errors.js';
 import { copyFile, ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
 import { info, intro, note, outro, warn } from '../../utils/logger.js';
+/** Escapes regex metacharacters so a user-supplied name is literal inside a RegExp. */
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Applies the component rename to a filename. Only replaces the leading
+ * component name when it is followed by `.` (extension) or equals the
+ * filename exactly; every other filename is returned unchanged so stray
+ * assets, editor backups, or files whose name coincidentally contains the
+ * old component name in the middle or at the end are not accidentally
+ * renamed.
+ */
+function renameComponentFileName(fileName, oldName, newName) {
+    if (fileName === oldName)
+        return newName;
+    if (fileName.startsWith(oldName + '.')) {
+        return newName + fileName.slice(oldName.length);
+    }
+    return fileName;
+}
 function updateConfigForCustomRename(config, oldName, newName) {
     const oldConfig = config.custom[oldName];
     if (!oldConfig)
@@ -122,7 +142,15 @@ async function performRenameMutations(args) {
                 if (!entry.isFile())
                     continue;
                 const oldFileName = entry.name;
-                const newFileName = oldFileName.replace(oldName, newName);
+                // Rename only when the filename starts with the component name — the
+                // scaffolding convention for both create and override is `${name}.ext`.
+                // A plain `replace(oldName, newName)` produced wrong results when the
+                // old name occurred more than once (e.g. `foo-foo.mjs` renamed `foo` →
+                // `bar` became `bar-foo.mjs` instead of `bar-bar.mjs`) and also when
+                // the old name appeared inside a file that was not the component
+                // scaffold itself (e.g. a sibling helper). Unrelated files (stray
+                // assets, editor backups) are copied verbatim.
+                const newFileName = renameComponentFileName(oldFileName, oldName, newName);
                 const oldPath = join(oldDir, oldFileName);
                 const newPath = join(newDir, newFileName);
                 if (isComponentSourceFile(oldFileName)) {
@@ -130,8 +158,8 @@ async function performRenameMutations(args) {
                     // Use word-boundary-aware patterns so substrings in other
                     // identifiers (e.g. "moz-panel" inside "moz-panel-group") are
                     // not replaced.
-                    const tagPattern = new RegExp(`(?<![\\w-])${oldName.replace(/-/g, '\\-')}(?![\\w-])`, 'g');
-                    const classPattern = new RegExp(`\\b${oldClassName}\\b`, 'g');
+                    const tagPattern = new RegExp(`(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, 'g');
+                    const classPattern = new RegExp(`\\b${escapeRegex(oldClassName)}\\b`, 'g');
                     content = content.replace(tagPattern, newName);
                     content = content.replace(classPattern, newClassName);
                     await writeText(newPath, content);

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

@@ -58,6 +58,14 @@ async function promptAddComponents(components, tracked, projectRoot) {
         await snapshotFile(journal, furnacePaths.furnaceConfig);
         try {
             const config = await ensureFurnaceConfig(projectRoot);
+            // Defensive: `selected` is already filtered to exclude components
+            // currently in config.stock (see untrackedComponents above). This
+            // re-filter catches the edge case where the config on disk changed
+            // between the scan's read and the write (concurrent scan / manual
+            // edit). Without it a duplicate scan would introduce duplicate
+            // entries into stock; writeFurnaceConfig's validator would then
+            // reject the write, but the error would be less actionable than
+            // silently de-duplicating here.
             const toAdd = selected.filter((s) => !config.stock.includes(s));
             config.stock.push(...toAdd);
             await writeFurnaceConfig(projectRoot, config);

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

@@ -43,9 +43,17 @@ async function autoFixIssues(projectRoot, issues) {
     // Fix jar.mn entries
     for (const [componentName, files] of jarMnFixesByComponent) {
         try {
-            await addJarMnEntries(engineDir, componentName, files);
-            fixed += files.length;
-            info(`Fixed: added ${files.join(', ')} to jar.mn for ${componentName}`);
+            // addJarMnEntries is idempotent and reports how many entries it
+            // actually wrote. Only count + log the files that were added so the
+            // reported "fixed" number matches the on-disk change.
+            const added = await addJarMnEntries(engineDir, componentName, files);
+            fixed += added;
+            if (added > 0) {
+                info(`Fixed: added ${files.join(', ')} to jar.mn for ${componentName}`);
+            }
+            else {
+                info(`No-op: jar.mn entries for ${componentName} were already present`);
+            }
         }
         catch (err) {
             warn(`Could not fix jar.mn for ${componentName}: ${err instanceof Error ? err.message : String(err)}`);
@@ -162,13 +170,30 @@ export async function furnaceValidateCommand(projectRoot, name, options = {}) {
             }
         }
     }
-    // Auto-fix fixable issues when --fix is passed
+    // Auto-fix fixable issues when --fix is passed. The auto-fix counter
+    // returned by `autoFixIssues` only counts function calls that did not
+    // throw — a write that succeeded but did not actually resolve the issue
+    // (e.g. addJarMnEntries appended to a file mach later ignores) would
+    // still bump the count. Re-validate the affected components and compute
+    // the *actual* drop in fixable issues so the reported number is honest.
     if (options.fix && allIssues.length > 0) {
         const fixableIssues = allIssues.filter((issue) => FIXABLE_CHECKS.has(issue.check));
         if (fixableIssues.length > 0) {
-            const fixedCount = await autoFixIssues(projectRoot, fixableIssues);
-            if (fixedCount > 0) {
-                info(`\nAuto-fixed ${fixedCount} issue(s). Re-run validate to confirm.`);
+            await autoFixIssues(projectRoot, fixableIssues);
+            const reValidated = await reValidateComponents(projectRoot, config, furnacePaths, new Set(fixableIssues.map((issue) => issue.component)));
+            const fixableBefore = fixableIssues.length;
+            const fixableAfter = reValidated.issues.filter((issue) => FIXABLE_CHECKS.has(issue.check)).length;
+            const actuallyFixed = Math.max(0, fixableBefore - fixableAfter);
+            // Replace the pre-fix issue totals with the post-fix view so the
+            // summary reflects current reality. Issues that auto-fix could not
+            // address still count toward totalErrors / totalWarnings.
+            totalErrors = reValidated.totalErrors;
+            totalWarnings = reValidated.totalWarnings;
+            if (actuallyFixed > 0) {
+                info(`\nAuto-fixed ${actuallyFixed} issue(s).`);
+            }
+            if (fixableAfter > 0) {
+                warn(`${fixableAfter} fixable issue(s) remain after auto-fix — investigate manually.`);
             }
         }
         else {
@@ -184,4 +209,42 @@ export async function furnaceValidateCommand(projectRoot, name, options = {}) {
     }
     outro('Validation passed');
 }
+/**
+ * Re-validates a specific set of components after an auto-fix pass and
+ * returns the post-fix issue list with the recomputed error / warning
+ * totals. Used by the `--fix` path to honestly report what auto-fix
+ * actually accomplished.
+ */
+async function reValidateComponents(projectRoot, config, furnacePaths, componentNames) {
+    const issues = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    for (const componentName of componentNames) {
+        let type;
+        let componentDir;
+        if (componentName in config.overrides) {
+            type = 'override';
+            componentDir = join(furnacePaths.overridesDir, componentName);
+        }
+        else if (componentName in config.custom) {
+            type = 'custom';
+            componentDir = join(furnacePaths.customDir, componentName);
+        }
+        else {
+            // Stock or removed components are not local-validated; skip silently.
+            continue;
+        }
+        if (!(await pathExists(componentDir)))
+            continue;
+        const componentIssues = await validateComponent(componentDir, componentName, type, config, projectRoot);
+        issues.push(...componentIssues);
+        for (const issue of componentIssues) {
+            if (issue.severity === 'error')
+                totalErrors += 1;
+            else
+                totalWarnings += 1;
+        }
+    }
+    return { issues, totalErrors, totalWarnings };
+}
 //# sourceMappingURL=validate.js.map