@hominis/fireforge 0.35.0 → 0.37.0

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

@@ -2,25 +2,22 @@
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { getFurnacePaths, loadFurnaceConfig, updateFurnaceState, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { isComponentSourceFile, resolveFtlChromeSubPath, resolveFtlDir, resolveFtlLocaleJarMnPath, tagNameToClassName, } from '../../core/furnace-constants.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation } from '../../core/furnace-operation.js';
 import { addCustomElementRegistration, addJarMnEntries, addLocaleFtlJarMnEntry, removeCustomElementRegistration, removeJarMnEntries, removeLocaleFtlJarMnEntry, } from '../../core/furnace-registration.js';
 import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
-import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
+import { createRollbackJournal, recordCreatedDir, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { getStoriesDir } from '../../core/furnace-stories.js';
 import { InvalidArgumentError } from '../../errors/base.js';
 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';
+import { escapeRegex } from '../../utils/regex.js';
 import { updateBrowserChromeTestContent } from './rename-browser-test.js';
-import { renameComponentFileName, updateConfigForCustomRename, updateConfigForOverrideRename, } from './rename-helpers.js';
+import { rekeyStateChecksums, renameComponentFileName, updateConfigForCustomRename, updateConfigForOverrideRename, } from './rename-helpers.js';
 import { renameXpcshellTestFiles } from './rename-xpcshell.js';
-/** Escapes regex metacharacters so a user-supplied name is literal inside a RegExp. */
-function escapeRegex(input) {
-    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 /**
  * Derives the test file name for a component, matching the convention used by
  * `furnace create --with-tests`.
@@ -58,6 +55,7 @@ async function renameTestFiles(engineDir, projectRoot, oldName, newName, journal
     if (await pathExists(oldTestPath)) {
         try {
             await snapshotFile(journal, oldTestPath);
+            await snapshotFile(journal, newTestPath);
             const content = await readText(oldTestPath);
             await writeText(newTestPath, updateBrowserChromeTestContent(content, oldName, newName, binaryName));
             await removeFile(oldTestPath);
@@ -144,6 +142,7 @@ async function renameMochikitTestFiles(engineDir, oldName, newName, journal) {
                 .replace(new RegExp(`Test the ${escapeRegex(oldName)} `, 'g'), `Test the ${newName} `)
                 .replace(new RegExp(`add_task\\(async function test_${escapeRegex(oldName.replace(/-/g, '_'))}_defined\\(`, 'g'), `add_task(async function test_${newName.replace(/-/g, '_')}_defined(`)
                 .replace(new RegExp(`"${escapeRegex(oldName)} custom element`, 'g'), `"${newName} custom element`);
+            await snapshotFile(journal, newTestPath);
             await writeText(newTestPath, updatedContent);
             await removeFile(oldTestPath);
             info(`Renamed mochikit test: ${oldTestFileName} → ${newTestFileName}`);
@@ -209,7 +208,14 @@ async function performRenameMutations(args) {
             }
             await snapshotDir(journal, oldDir);
             await snapshotFile(journal, args.furnaceConfigPath);
+            // Journal the state file BEFORE step 4 re-keys its checksums, plus
+            // the new dir and every new-name destination below (a snapshot of a
+            // missing path records {existed: false} → rollback DELETES it).
+            // Without these, a failed or SIGINT'd rename stranded the new-name
+            // scaffold and kept re-keyed state for a nonexistent component.
+            await snapshotFile(journal, getFurnacePaths(projectRoot).furnaceState);
             // 1. Create new directory with renamed files and updated content
+            recordCreatedDir(journal, newDir);
             await ensureDir(newDir);
             const entries = await readdir(oldDir, { withFileTypes: true });
             for (const entry of entries) {
@@ -227,6 +233,7 @@ async function performRenameMutations(args) {
                 const newFileName = renameComponentFileName(oldFileName, oldName, newName);
                 const oldPath = join(oldDir, oldFileName);
                 const newPath = join(newDir, newFileName);
+                await snapshotFile(journal, newPath);
                 if (isComponentSourceFile(oldFileName)) {
                     let content = await readText(oldPath);
                     // Use word-boundary-aware patterns so substrings in other
@@ -320,34 +327,6 @@ async function performRenameMutations(args) {
         }
     });
 }
-/**
- * Re-keys checksum entries in furnace-state.json from the old component name
- * to the new name so that `doctor` doesn't flag stale entries and the next
- * `apply` can correctly detect whether the renamed component has changed.
- */
-async function rekeyStateChecksums(projectRoot, componentType, oldName, newName) {
-    const oldPrefix = `${componentType}/${oldName}/`;
-    const newPrefix = `${componentType}/${newName}/`;
-    await updateFurnaceState(projectRoot, (state) => {
-        const result = { ...state };
-        for (const field of ['appliedChecksums', 'engineChecksums']) {
-            const checksums = state[field];
-            if (!checksums)
-                continue;
-            const updated = {};
-            for (const [key, value] of Object.entries(checksums)) {
-                if (key.startsWith(oldPrefix)) {
-                    updated[newPrefix + key.slice(oldPrefix.length)] = value;
-                }
-                else {
-                    updated[key] = value;
-                }
-            }
-            result[field] = updated;
-        }
-        return result;
-    });
-}
 async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal) {
     const customElementsPath = join(engineDir, 'toolkit/content/customElements.js');
     const jarMnPath = join(engineDir, 'toolkit/content/jar.mn');
@@ -372,6 +351,7 @@ async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ft
     const newFtlPath = join(ftlDirPath, `${newName}.ftl`);
     if (await pathExists(oldFtlPath)) {
         await snapshotFile(journal, oldFtlPath);
+        await snapshotFile(journal, newFtlPath);
         const ftlContent = await readText(oldFtlPath);
         await writeText(newFtlPath, ftlContent);
         await removeFile(oldFtlPath);
@@ -463,4 +443,3 @@ export async function furnaceRenameCommand(projectRoot, oldName, newName) {
         '  3. Run "fireforge furnace apply" to update the engine', newName);
     outro('Rename complete');
 }
-//# sourceMappingURL=rename.js.map

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

@@ -208,4 +208,3 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
     }
     outro('Scan complete');
 }
-//# sourceMappingURL=scan.js.map

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

@@ -199,4 +199,3 @@ export async function furnaceStatusCommand(projectRoot, name) {
     info('Tip: run `fireforge furnace status <name>` for detailed component info, or `fireforge furnace --help` for all subcommands.');
     outro('Status complete');
 }
-//# sourceMappingURL=status.js.map

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

@@ -1,15 +1,56 @@
 // SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { applyAllComponents } from '../../core/furnace-apply.js';
 import { logApplyResult } from '../../core/furnace-apply-output.js';
-import { furnaceConfigExists, loadFurnaceConfig } from '../../core/furnace-config.js';
+import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../core/furnace-config.js';
 import { reportJsconfigPathsSync } from '../../core/furnace-jsconfig.js';
 import { runFurnaceMutation } from '../../core/furnace-operation.js';
+import { countEntriesWithBlockingStepErrors } from '../../core/furnace-step-errors.js';
+import { containsMergeConflictMarkers } from '../../core/furnace-validate-structure.js';
 import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
 import { FurnaceError } from '../../errors/furnace.js';
-import { pathExists } from '../../utils/fs.js';
+import { pathExists, readText } from '../../utils/fs.js';
 import { info, intro, outro, spinner, warn } from '../../utils/logger.js';
 import { furnaceRefreshCommand } from './refresh.js';
+/**
+ * Scans every configured override/custom component workspace for files
+ * carrying unresolved merge conflict markers. Returns the component names
+ * (sorted, unique) that must be resolved before an apply may run.
+ */
+async function findComponentsWithConflictMarkers(furnacePaths, config) {
+    const conflicted = new Set();
+    const componentDirs = [
+        ...Object.keys(config.overrides).map((name) => ({
+            name,
+            dir: join(furnacePaths.overridesDir, name),
+        })),
+        ...Object.keys(config.custom).map((name) => ({
+            name,
+            dir: join(furnacePaths.customDir, name),
+        })),
+    ];
+    for (const { name, dir } of componentDirs) {
+        if (!(await pathExists(dir)))
+            continue;
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.endsWith('.mjs') &&
+                !entry.name.endsWith('.css') &&
+                !entry.name.endsWith('.ftl')) {
+                continue;
+            }
+            if (containsMergeConflictMarkers(await readText(join(dir, entry.name)))) {
+                conflicted.add(name);
+                break;
+            }
+        }
+    }
+    return [...conflicted].sort();
+}
 /**
  * Runs the furnace sync command: detects overrides with baseVersion drift,
  * refreshes them (three-way merge), and re-applies all components.
@@ -57,6 +98,38 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
     else {
         info('All overrides are up-to-date with the current Firefox version.');
     }
+    // Phase 2.5: post-refresh gates. Refresh deliberately leaves conflict
+    // markers in workspace files and does NOT bump baseVersion on conflict —
+    // so before this gate existed, sync would warn about conflicts and then
+    // copy the marker-laden files straight into the engine via Phase 3,
+    // producing a broken build from the one command whose whole purpose is a
+    // safe upgrade. Apply/deploy both enforce a drift gate; sync must not be
+    // the back door around it.
+    if (!options.dryRun) {
+        const refreshedConfig = await loadFurnaceConfig(projectRoot);
+        const furnacePaths = getFurnacePaths(projectRoot);
+        const conflicted = await findComponentsWithConflictMarkers(furnacePaths, refreshedConfig);
+        const remainingDrift = findOverrideBaseVersionDrift(refreshedConfig, forgeConfig.firefox.version);
+        if (conflicted.length > 0 || remainingDrift.length > 0) {
+            if (conflicted.length > 0) {
+                warn(`Unresolved merge conflicts in: ${conflicted.join(', ')}`);
+            }
+            for (const entry of remainingDrift) {
+                warn(formatOverrideBaseVersionDriftWarning(entry));
+            }
+            throw new FurnaceError('Sync stopped before applying: ' +
+                (conflicted.length > 0
+                    ? `${conflicted.length} component(s) contain unresolved merge conflict markers` +
+                        (remainingDrift.length > 0 ? ' and ' : '')
+                    : '') +
+                (remainingDrift.length > 0
+                    ? `${remainingDrift.length} override(s) still have baseVersion drift`
+                    : '') +
+                '. Resolve the conflicts in the component workspace files, re-run ' +
+                '"fireforge furnace refresh <name>" to update baseVersion, then run ' +
+                '"fireforge furnace sync" again. Nothing was applied to the engine.');
+        }
+    }
     // Phase 3: Re-apply all components to the engine
     if (!options.dryRun) {
         info('\nApplying all components to engine...');
@@ -64,7 +137,7 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
         const result = await runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, false, { operationContext: ctx }), { dryRun: false });
         applySpinner.stop('Components applied');
         logApplyResult(result, false);
-        const appliedWithStepErrorsCount = result.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+        const appliedWithStepErrorsCount = countEntriesWithBlockingStepErrors(result.applied);
         const totalFailures = result.errors.length + appliedWithStepErrorsCount;
         if (totalFailures > 0) {
             throw new FurnaceError(`${totalFailures} component${totalFailures === 1 ? '' : 's'} failed to apply cleanly`);
@@ -76,4 +149,3 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
         outro('Dry run complete');
     }
 }
-//# sourceMappingURL=sync.js.map

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

@@ -263,4 +263,3 @@ async function reValidateComponents(projectRoot, config, furnacePaths, component
     }
     return { issues, totalErrors, totalWarnings };
 }
-//# sourceMappingURL=validate.js.map

package/dist/src/commands/furnace/validation-output.js

@@ -127,4 +127,3 @@ export async function runDeployValidation(validateSpinner, name, config, furnace
     }
     return { done: false, totalErrors, totalWarnings, componentCount, skippedValidationCount };
 }
-//# sourceMappingURL=validation-output.js.map

package/dist/src/commands/import.js

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
 import { confirm } from '@clack/prompts';
+import { Command } from 'commander';
 import { getProjectPaths, loadConfig, loadState, updateState } from '../core/config.js';
 import { getHead } from '../core/git.js';
 import { getDirtyFiles } from '../core/git-status.js';
-import { applyPatchesWithContinue, computePatchedContent, countPatches, discoverPatches, extractAffectedFiles, PatchError, } from '../core/patch-apply.js';
+import { applyPatchesWithContinue, countPatches, createPatchedContentComputer, discoverPatches, extractAffectedFiles, matchesUntilFilename, PatchError, } from '../core/patch-apply.js';
 import { checkVersionCompatibility, loadPatchesManifest, validatePatchesManifestConsistency, validatePatchIntegrity, } from '../core/patch-manifest.js';
 import { getPatchSourceVersion } from '../core/patch-source-metadata.js';
 import { GeneralError } from '../errors/base.js';
@@ -25,11 +26,17 @@ function isSafeIoFallback(error) {
     const code = error?.code;
     return typeof code === 'string' && SAFE_IO_FALLBACK_CODES.has(code);
 }
+/** Concurrency bound for per-file classification (each call spawns git). */
+const UNMANAGED_CLASSIFY_CONCURRENCY = 8;
 async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
-    const classifications = await Promise.all(dirtyFiles.map(async (file) => {
+    // One manifest+patch-discovery load for the whole batch (the per-call
+    // computePatchedContent re-read everything for every file), and bounded
+    // concurrency instead of an unbounded Promise.all over git spawns.
+    const computeExpected = await createPatchedContentComputer(patchesDir, engineDir);
+    const classifications = await mapWithConcurrency(dirtyFiles, UNMANAGED_CLASSIFY_CONCURRENCY, async (file) => {
         try {
             const [expected, exists] = await Promise.all([
-                computePatchedContent(patchesDir, engineDir, file),
+                computeExpected(file),
                 pathExists(join(engineDir, file)),
             ]);
             const actual = exists ? await readText(join(engineDir, file)) : null;
@@ -51,9 +58,24 @@ async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
             verbose(`Treating ${file} as unmanaged because patched-content classification failed with IO error: ${toError(error).message}`);
             return file;
         }
-    }));
+    });
     return classifications.filter((file) => file !== null).sort();
 }
+/** Maps items with at most `limit` in-flight promises. Preserves order. */
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            results[index] = await fn(items[index]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
 function reportForcedOverwriteRisk(unmanagedDirtyFiles) {
     warn(`--force will overwrite ${unmanagedDirtyFiles.length} unmanaged change${unmanagedDirtyFiles.length === 1 ? '' : 's'} in patch-touched file${unmanagedDirtyFiles.length === 1 ? '' : 's'}:`);
     for (const file of unmanagedDirtyFiles) {
@@ -150,7 +172,7 @@ async function checkEngineDrift(engineDir, baseCommit, forceImport) {
     const currentHead = await getHead(engineDir);
     if (currentHead === baseCommit)
         return true;
-    if (!process.stdin.isTTY) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
         if (!forceImport) {
             throw new GeneralError('Engine HEAD has drifted from base commit. Re-run with --force to bypass drift check.');
         }
@@ -189,8 +211,13 @@ function buildUntilFilenameSet(patches, until) {
     const set = new Set();
     if (until === undefined)
         return set;
-    const normalized = until.endsWith('.patch') ? until : `${until}.patch`;
-    const target = patches.find((p) => p.filename === until || p.filename === normalized);
+    // Resolve the identifier with the SAME matcher the apply loop uses
+    // (`matchesUntilFilename` accepts filenames, extension-less names, AND
+    // bare ordinals). The previous filename-only match meant
+    // `import --until 5` produced an EMPTY scope set — the UI previewed
+    // "0 patches", the integrity gates filtered every in-range issue away —
+    // and then the apply loop happily applied patches 1..5 anyway.
+    const target = patches.find((p) => matchesUntilFilename(p.filename, until));
     if (!target)
         return set;
     for (const patch of patches) {
@@ -266,7 +293,7 @@ async function gateImportIntegrity(paths, untilFilenameSet, until, forceImport)
         if (forceImport) {
             warn('Continuing because --force was provided. Integrity issues were not resolved.\n');
         }
-        else if (!process.stdin.isTTY) {
+        else if (!(process.stdin.isTTY && process.stdout.isTTY)) {
             throw new GeneralError(`Refusing to import while ${integrityIssues.length} patch integrity issue(s) are unresolved. ` +
                 `Fix the issues reported above (see "fireforge doctor") or re-run with --force to continue anyway.`);
         }
@@ -421,4 +448,3 @@ export function registerImport(program, { getProjectRoot, withErrorHandling }) {
         await importCommand(getProjectRoot(), pickDefined(merged));
     }));
 }
-//# sourceMappingURL=import.js.map

package/dist/src/commands/lint-per-patch.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { loadConfig } from '../core/config.js';
+import { getProjectPaths, loadConfig } from '../core/config.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, getPerPatchLintCacheHeadSha, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/lint-cache.js';
 import { buildPatchQueueContext, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
@@ -215,13 +215,26 @@ function reportPerPatchOutcome(issues, linted, skipped, options) {
  * than silently linting nothing.
  */
 function selectPatchSubset(manifest, requested) {
-    const matches = (p, name) => p.filename === name ||
-        p.filename === `${name}.patch` ||
-        p.filename.replace(/\.patch$/, '') === name.replace(/\.patch$/, '') ||
-        p.name === name;
+    const normalizedRequests = requested
+        .flatMap((entry) => entry.split(','))
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    const patchAliases = (p) => {
+        const aliases = new Set([p.filename, p.filename.replace(/\.patch$/, ''), p.name]);
+        const match = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(p.filename);
+        if (match?.[2] && match[3]) {
+            aliases.add(`${match[2]}-${match[3]}`);
+            aliases.add(match[3]);
+        }
+        return aliases;
+    };
+    const matches = (p, name) => {
+        const stem = name.replace(/\.patch$/, '');
+        return (patchAliases(p).has(name) || patchAliases(p).has(stem) || patchAliases(p).has(`${stem}.patch`));
+    };
     const selected = [];
     const seen = new Set();
-    for (const name of requested) {
+    for (const name of normalizedRequests) {
         const found = manifest.patches.filter((p) => matches(p, name));
         if (found.length === 0) {
             const available = manifest.patches.map((p) => p.filename).join(', ');
@@ -340,4 +353,3 @@ export async function lintPerPatch(projectRoot, paths, options = {}) {
     }
     reportPerPatchOutcome(issues, linted, skipped, options);
 }
-//# sourceMappingURL=lint-per-patch.js.map

package/dist/src/commands/lint.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { isBrandingManagedPath } from '../core/branding.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
@@ -510,7 +511,7 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         .option('--since <git-rev>', 'Tag issues as [introduced] or [cumulative] based on whether the file changed since <git-rev> (e.g. HEAD, a branch, a SHA)')
         .option('--only-introduced', 'Fail only on issues tagged [introduced] (requires --since). Cumulative errors still print but do not set a non-zero exit.')
         .option('--per-patch', "Lint each patch in the queue as its own isolated diff. Rescopes patch-size rules so they fire against individual patches rather than the aggregate. Honours each patch's `lintIgnore` entries.")
-        .option('--patches <names...>', 'With --per-patch, lint only the named patches (by filename or manifest name) instead of the whole queue. Queue-level findings are scoped to files those patches touch.')
+        .option('--patches <names...>', 'With --per-patch, lint only the named patches. Accepts repeated flags, comma lists, full filenames/stems, manifest names, category-prefixed slugs, or bare slugs.')
         .option('--max-warnings <n>', 'Fail when lint reports more than <n> warning(s); use 0 for warning-clean release gates.')
         .option('--no-cache', 'Bypass per-patch lint result cache reads and writes.')
         .action(withErrorHandling(async (paths, options) => {
@@ -539,9 +540,19 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         }
         await lintCommand(getProjectRoot(), paths, lintOptions);
     }));
-    lint
+    const lintCache = lint
         .command('cache')
         .description('Manage the per-patch lint result cache')
+        // Commander routes `fireforge lint cache` here even when the operator
+        // meant to lint an engine directory literally named `cache`. A bare
+        // `lint cache` (no subcommand) used to silently do nothing — make the
+        // ambiguity explicit instead of doing the wrong operation quietly.
+        .action(withErrorHandling(() => {
+        info('Nothing to do: "lint cache" manages the lint result cache (try "lint cache clear"). ' +
+            'To lint a directory named cache/, disambiguate with a trailing slash: "fireforge lint cache/".');
+        return Promise.resolve();
+    }));
+    lintCache
         .command('clear')
         .description('Clear cached per-patch lint results')
         .action(withErrorHandling(async () => {
@@ -551,4 +562,3 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         outro('Lint cache cleared');
     }));
 }
-//# sourceMappingURL=lint.js.map

package/dist/src/commands/manifest.js

@@ -20,7 +20,7 @@ import { registerRun } from './run.js';
 import { registerSetup } from './setup.js';
 import { registerSource } from './source.js';
 import { registerStatus } from './status.js';
-import { registerTest } from './test.js';
+import { registerTest } from './test-register.js';
 import { registerToken } from './token.js';
 import { registerTypecheck } from './typecheck.js';
 import { registerVerify } from './verify.js';
@@ -60,4 +60,3 @@ export const COMMAND_MANIFEST = [
     { name: 'verify', group: 'diagnostics', register: registerVerify },
     { name: 'furnace', group: 'components', register: registerFurnace },
 ];
-//# sourceMappingURL=manifest.js.map

package/dist/src/commands/package.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Command } from 'commander';
 import { validateBrandOverride } from '../core/brand-validation.js';
 import { prepareBuildEnvironment } from '../core/build-prepare.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
@@ -88,4 +90,3 @@ export function registerPackage(program, { getProjectRoot, withErrorHandling })
         await packageCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=package.js.map

package/dist/src/commands/patch/compact.js

@@ -9,6 +9,7 @@
  * compaction is range-aware (each category range compacts independently,
  * reserved ranges and out-of-range strays are left untouched).
  */
+import { Command } from 'commander';
 import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
@@ -206,4 +207,3 @@ export function registerPatchCompact(parent, context) {
         await patchCompactCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=compact.js.map

package/dist/src/commands/patch/delete.js

@@ -8,6 +8,7 @@
  * `--dry-run`, and appends to `patches/.fireforge-history.jsonl` on success.
  */
 import { basename } from 'node:path';
+import { Command } from 'commander';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { buildPatchQueueContext, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, isForwardImportableFile, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
@@ -202,4 +203,3 @@ export function registerPatchDelete(parent, context) {
         await patchDeleteCommand(getProjectRoot(), name, pickDefined(options));
     }));
 }
-//# sourceMappingURL=delete.js.map

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

@@ -7,6 +7,7 @@
  * Queue-level verbs like `lint`, `export`, `verify`, and `status` stay
  * flat.
  */
+import { Command } from 'commander';
 import { registerPatchCompact } from './compact.js';
 import { registerPatchDelete } from './delete.js';
 import { registerPatchLintIgnore } from './lint-ignore.js';
@@ -45,4 +46,3 @@ export function registerPatch(program, context) {
     registerPatchStagedDependency(patch, context);
     registerPatchTier(patch, context);
 }
-//# sourceMappingURL=index.js.map

package/dist/src/commands/patch/lint-ignore.js

@@ -19,7 +19,8 @@
  * write — important when an operator scripts repeated invocations or
  * runs `--add` and `--remove` back-to-back.
  */
-import { appendHistory } from '../../core/destructive.js';
+import { Command } from 'commander';
+import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { mutatePatchMetadata } from '../../core/patch-export.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
@@ -107,13 +108,28 @@ export async function patchLintIgnoreCommand(projectRoot, identifier, options =
     const values = mode === 'add' ? (options.add ?? []) : mode === 'remove' ? (options.remove ?? []) : [];
     const { paths, manifest } = await requirePatchQueue(projectRoot);
     const target = requirePatchTarget(identifier, manifest.patches);
-    if (isDryRun) {
-        const existing = target.lintIgnore ?? [];
-        const projected = applyMode(existing, mode, values) ?? [];
-        info(`[dry-run] ${target.filename}: ${describeChange(existing, projected, mode, values)}.`);
+    // Destructive-operation contract (docs/lifecycle-invariants.md): manifest
+    // metadata mutations get summary + dry-run + confirmation/--yes + history
+    // uniformly. This command used to accept --yes without ever prompting, so
+    // the flag only appeared in the history record — and suppressing lint
+    // findings is precisely the mutation an operator should consciously
+    // approve.
+    const projectedSummary = describeChange(target.lintIgnore ?? [], applyMode(target.lintIgnore ?? [], mode, values) ?? [], mode, values);
+    const decision = await confirmDestructive({
+        operation: 'patch-lint-ignore',
+        title: `Patch lint-ignore: ${target.filename}`,
+        summary: [`${target.filename}: ${projectedSummary}`],
+        yes: options.yes === true,
+        dryRun: isDryRun,
+    });
+    if (decision === 'dry-run') {
         outro('Dry run complete — no changes made');
         return;
     }
+    if (decision === 'cancelled') {
+        outro('Cancelled — no changes made');
+        return;
+    }
     const result = await mutatePatchMetadata(paths.patches, target.filename, (existing) => {
         const next = applyMode(existing.lintIgnore ?? [], mode, values);
         // Either set the new list when non-empty or unset the field
@@ -186,4 +202,3 @@ export function registerPatchLintIgnore(parent, context) {
         await patchLintIgnoreCommand(getProjectRoot(), name, normalized);
     }));
 }
-//# sourceMappingURL=lint-ignore.js.map

package/dist/src/commands/patch/move-files.js

@@ -4,6 +4,7 @@
  * re-export choreography needed to move file ownership between two patches.
  */
 import { relative } from 'node:path';
+import { Command } from 'commander';
 import { getProjectPaths } from '../../core/config.js';
 import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
@@ -136,4 +137,3 @@ export function registerPatchMoveFiles(parent, context) {
         await patchMoveFilesCommand(getProjectRoot(), from, to, options);
     }));
 }
-//# sourceMappingURL=move-files.js.map

package/dist/src/commands/patch/patch-context.js

@@ -50,4 +50,3 @@ export function requirePatchTarget(identifier, patches) {
     }
     return target;
 }
-//# sourceMappingURL=patch-context.js.map

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

@@ -18,9 +18,10 @@
  */
 import { rename as fsRename } from 'node:fs/promises';
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
-import { sanitizeName } from '../../core/patch-export.js';
+import { patchNameSlug } from '../../core/patch-export.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from '../../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
@@ -163,7 +164,7 @@ export async function patchRenameCommand(projectRoot, identifier, options = {})
     if (!split) {
         throw new GeneralError(`Cannot rename ${target.filename}: filename does not match the expected {ordinal}-{category}-{slug}.patch convention. Re-export the patch instead.`);
     }
-    const newSlug = sanitizeName(options.to);
+    const newSlug = patchNameSlug(options.to, split.category);
     if (newSlug === '') {
         throw new InvalidArgumentError('--to must contain at least one alphanumeric character after sanitisation.', 'patch rename');
     }
@@ -258,7 +259,7 @@ export function registerPatchRename(parent, context) {
     parent
         .command('rename <name>')
         .description('Rename a patch: filename + manifest name (and optional description) update without rewriting the .patch body.')
-        .requiredOption('--to <new-name>', 'New human-readable name (sanitised into the filename slug)')
+        .requiredOption('--to <new-name>', 'New human-readable name, category-prefixed slug, or full filename stem (normalised into the filename slug)')
         .option('--description <text>', 'Replacement description (omit to leave description unchanged)')
         .option('--dry-run', 'Show what would change without writing')
         .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
@@ -267,4 +268,3 @@ export function registerPatchRename(parent, context) {
         await patchRenameCommand(getProjectRoot(), name, pickDefined(options));
     }));
 }
-//# sourceMappingURL=rename.js.map

package/dist/src/commands/patch/reorder.js

@@ -8,7 +8,7 @@
  * `lintPatchQueue` so reorders that would introduce a forward-import fail
  * before any bytes move.
  */
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
 import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive, } from '../../core/destructive.js';
 import { buildPatchQueueContext, lintPatchQueue, } from '../../core/patch-lint.js';
@@ -18,7 +18,7 @@ import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-p
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
-import { pickDefined } from '../../utils/options.js';
+import { commanderArgParser, pickDefined } from '../../utils/options.js';
 import { parsePositiveIntegerFlag } from '../../utils/validation.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /** Zero-pads an ordinal number to the given width. */
@@ -372,7 +372,7 @@ export function registerPatchReorder(parent, context) {
     parent
         .command('reorder <name>')
         .description('Move a patch to a different position in the queue (destructive)')
-        .addOption(new Option('--to <order>', 'Destination ordinal').argParser((v) => parsePositiveIntegerFlag('--to', v)))
+        .addOption(new Option('--to <order>', 'Destination ordinal').argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--to', v))))
         .option('--before <anchor>', 'Place the patch immediately before <anchor>')
         .option('--after <anchor>', 'Place the patch immediately after <anchor>')
         .option('--dry-run', 'Show what would happen without writing')
@@ -382,4 +382,3 @@ export function registerPatchReorder(parent, context) {
         await patchReorderCommand(getProjectRoot(), name, pickDefined(options));
     }));
 }
-//# sourceMappingURL=reorder.js.map