@hominis/fireforge 0.18.0 → 0.18.2

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

@@ -6,7 +6,7 @@ import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { removeCustomFtlJarMnEntry } from '../../core/furnace-apply-ftl.js';
 import { extractComponentChecksums, getOverrideEngineTargetPath, isOverrideCopyCandidate, restoreOverrideFileToBaseline, } from '../../core/furnace-apply-helpers.js';
 import { getFurnacePaths, loadFurnaceConfig, loadFurnaceState, updateFurnaceState, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { resolveFtlDir } from '../../core/furnace-constants.js';
+import { resolveFtlDir, xpcshellTestParentDir } from '../../core/furnace-constants.js';
 import { recordFurnaceRollbackFailure, runFurnaceMutation } from '../../core/furnace-operation.js';
 import { removeCustomElementRegistration, removeJarMnEntries, } from '../../core/furnace-registration.js';
 import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
@@ -212,6 +212,64 @@ async function cleanupCustomTestFiles(name, projectRoot, journal) {
     }
     return { partialFailures };
 }
+/**
+ * Removes generated xpcshell test scaffolds associated with a custom
+ * component. 2026-04-24 eval Finding 5: `furnace remove` handled
+ * browser mochitests via `cleanupCustomTestFiles` but never touched the
+ * xpcshell scaffold tree, so an operator who ran
+ * `furnace create --with-tests --xpcshell` followed by `furnace remove`
+ * was left with orphan `xpcshell.toml` + `test_<name>_packaged.js`
+ * files still referencing the removed component. This cleanup pass
+ * mirrors the mochitest one — snapshot before removal, warn-and-
+ * continue semantics, explicit summary when partial failures occur.
+ */
+async function cleanupCustomXpcshellTestFiles(name, projectRoot, journal) {
+    const partialFailures = [];
+    let forgeConfig;
+    try {
+        forgeConfig = await loadConfig(projectRoot);
+    }
+    catch (error) {
+        const msg = `Could not load config for xpcshell test cleanup — ${toError(error).message}. Remove xpcshell test files manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
+        return { partialFailures };
+    }
+    const paths = getProjectPaths(projectRoot);
+    const xpcshellRoot = join(paths.engine, xpcshellTestParentDir(forgeConfig.binaryName));
+    const componentXpcshellDir = join(xpcshellRoot, name);
+    if (!(await pathExists(componentXpcshellDir)))
+        return { partialFailures };
+    try {
+        await snapshotDir(journal, componentXpcshellDir);
+        await removeDir(componentXpcshellDir);
+        info(`Deleted xpcshell test scaffold directory: ${componentXpcshellDir.replace(paths.engine + '/', 'engine/')}`);
+    }
+    catch (error) {
+        const msg = `Could not delete xpcshell test scaffold — ${toError(error).message}. Remove it manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
+    }
+    // If the xpcshell parent directory is now empty (no other components
+    // had scaffolds), drop it too so `furnace validate` stays quiet about
+    // the empty per-binary tree. Warn-and-continue on any failure.
+    try {
+        if (await pathExists(xpcshellRoot)) {
+            const remaining = await readdir(xpcshellRoot);
+            if (remaining.length === 0) {
+                await snapshotDir(journal, xpcshellRoot);
+                await removeDir(xpcshellRoot);
+                info(`Deleted empty xpcshell parent directory: ${xpcshellRoot.replace(paths.engine + '/', 'engine/')}`);
+            }
+        }
+    }
+    catch (error) {
+        const msg = `Could not clean up xpcshell parent directory — ${toError(error).message}. Remove it manually if needed.`;
+        warn(msg);
+        partialFailures.push(msg);
+    }
+    return { partialFailures };
+}
 function dropChecksumsByPrefix(state, prefix) {
     const result = { ...state };
     if (state.appliedChecksums) {
@@ -367,6 +425,14 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
             if (type === 'custom') {
                 const result = await cleanupCustomTestFiles(name, projectRoot, journal);
                 testCleanupFailures = result.partialFailures;
+                // 2026-04-24 eval Finding 5: also clean up xpcshell scaffolds
+                // generated by `furnace create --with-tests --xpcshell`. The
+                // mochitest cleanup above covers `browser/base/content/test/
+                // <binary>/`, but xpcshell scaffolds live in the sibling
+                // `<binary>-xpcshell/` directory and were orphaned by prior
+                // versions.
+                const xpcshellResult = await cleanupCustomXpcshellTestFiles(name, projectRoot, journal);
+                testCleanupFailures.push(...xpcshellResult.partialFailures);
             }
             // Remove entry from furnace.json
             if (type === 'stock') {

package/dist/src/commands/furnace/rename-xpcshell.d.ts

@@ -0,0 +1,35 @@
+/**
+ * xpcshell scaffold rename helper extracted from `rename.ts`.
+ *
+ * 2026-04-24 eval Finding 5: `furnace create --with-tests --xpcshell`
+ * writes a scaffold at `browser/base/content/test/<binary>-xpcshell/
+ * <name>/` and `furnace rename` did not update it. The helper below
+ * renames the directory, updates the test filename, rewrites the
+ * `xpcshell.toml` section header, and re-writes the test body so word-
+ * boundary occurrences of the old tag / underscored name map to the new
+ * ones.
+ *
+ * Extracted to keep `rename.ts` under the per-file LOC budget —
+ * `rename.ts` already carries mochikit + browser-mochitest + FTL
+ * handling, and tacking xpcshell onto that tree pushed the file past
+ * the limit.
+ */
+import { type RollbackJournal } from '../../core/furnace-rollback.js';
+/**
+ * Renames an xpcshell test scaffold in place. Moves the directory,
+ * rewrites the test filename, updates the `[test_name]` section header
+ * in `xpcshell.toml`, and word-boundary-rewrites occurrences of the
+ * old tag / old underscored name inside the test body.
+ *
+ * Best-effort: any failure logs a warning through the shared logger
+ * but never throws — the component rename itself has already succeeded
+ * at this point, and blocking on a test rewrite would leave the
+ * operator with a half-renamed component.
+ *
+ * @param engineDir - Absolute path to the engine directory under the project.
+ * @param projectRoot - Absolute path to the project root, used to load the binary name.
+ * @param oldName - Pre-rename component tag name.
+ * @param newName - Post-rename component tag name.
+ * @param journal - Rollback journal that the rename mutation writes to before touching files.
+ */
+export declare function renameXpcshellTestFiles(engineDir: string, projectRoot: string, oldName: string, newName: string, journal: RollbackJournal): Promise<void>;

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

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * xpcshell scaffold rename helper extracted from `rename.ts`.
+ *
+ * 2026-04-24 eval Finding 5: `furnace create --with-tests --xpcshell`
+ * writes a scaffold at `browser/base/content/test/<binary>-xpcshell/
+ * <name>/` and `furnace rename` did not update it. The helper below
+ * renames the directory, updates the test filename, rewrites the
+ * `xpcshell.toml` section header, and re-writes the test body so word-
+ * boundary occurrences of the old tag / underscored name map to the new
+ * ones.
+ *
+ * Extracted to keep `rename.ts` under the per-file LOC budget —
+ * `rename.ts` already carries mochikit + browser-mochitest + FTL
+ * handling, and tacking xpcshell onto that tree pushed the file past
+ * the limit.
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { loadConfig } from '../../core/config.js';
+import { xpcshellTestParentDir } from '../../core/furnace-constants.js';
+import { snapshotFile } from '../../core/furnace-rollback.js';
+import { toError } from '../../utils/errors.js';
+import { ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
+import { info, warn } from '../../utils/logger.js';
+/** Escapes regex metacharacters so a user-supplied name stays literal. */
+function escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Renames an xpcshell test scaffold in place. Moves the directory,
+ * rewrites the test filename, updates the `[test_name]` section header
+ * in `xpcshell.toml`, and word-boundary-rewrites occurrences of the
+ * old tag / old underscored name inside the test body.
+ *
+ * Best-effort: any failure logs a warning through the shared logger
+ * but never throws — the component rename itself has already succeeded
+ * at this point, and blocking on a test rewrite would leave the
+ * operator with a half-renamed component.
+ *
+ * @param engineDir - Absolute path to the engine directory under the project.
+ * @param projectRoot - Absolute path to the project root, used to load the binary name.
+ * @param oldName - Pre-rename component tag name.
+ * @param newName - Post-rename component tag name.
+ * @param journal - Rollback journal that the rename mutation writes to before touching files.
+ */
+export async function renameXpcshellTestFiles(engineDir, projectRoot, oldName, newName, journal) {
+    let forgeConfig;
+    try {
+        forgeConfig = await loadConfig(projectRoot);
+    }
+    catch {
+        return; // Cannot determine scaffold path without config.
+    }
+    const parentDir = join(engineDir, xpcshellTestParentDir(forgeConfig.binaryName));
+    if (!(await pathExists(parentDir)))
+        return;
+    const oldScaffoldDir = join(parentDir, oldName);
+    const newScaffoldDir = join(parentDir, newName);
+    if (!(await pathExists(oldScaffoldDir)))
+        return;
+    const oldUnderscored = oldName.replace(/-/g, '_');
+    const newUnderscored = newName.replace(/-/g, '_');
+    const oldTestFileName = `test_${oldUnderscored}_packaged.js`;
+    const newTestFileName = `test_${newUnderscored}_packaged.js`;
+    try {
+        await ensureDir(newScaffoldDir);
+        const entries = await readdir(oldScaffoldDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const oldFilePath = join(oldScaffoldDir, entry.name);
+            const renamedFileName = entry.name === oldTestFileName ? newTestFileName : entry.name;
+            const newFilePath = join(newScaffoldDir, renamedFileName);
+            await snapshotFile(journal, oldFilePath);
+            const body = await readText(oldFilePath);
+            let updated = body;
+            if (entry.name === 'xpcshell.toml') {
+                updated = updated.replace(new RegExp(`\\[${escapeRegex(`"${oldTestFileName}"`)}\\]`, 'g'), `["${newTestFileName}"]`);
+            }
+            else if (entry.name === oldTestFileName) {
+                const oldTagPattern = new RegExp(`(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, 'g');
+                updated = updated.replace(oldTagPattern, newName);
+                const oldUnderscoredPattern = new RegExp(`(?<![\\w])${escapeRegex(oldUnderscored)}(?![\\w])`, 'g');
+                updated = updated.replace(oldUnderscoredPattern, newUnderscored);
+            }
+            await writeText(newFilePath, updated);
+            await removeFile(oldFilePath);
+        }
+        await removeDir(oldScaffoldDir);
+        info(`Renamed xpcshell scaffold directory: ${xpcshellTestParentDir(forgeConfig.binaryName)}/${oldName} → ${xpcshellTestParentDir(forgeConfig.binaryName)}/${newName}`);
+    }
+    catch (error) {
+        warn(`Could not rename xpcshell scaffold — ${toError(error).message}. Rename the scaffold files manually if needed.`);
+    }
+}
+//# sourceMappingURL=rename-xpcshell.js.map

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

@@ -14,6 +14,7 @@ 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 { 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, '\\$&');
@@ -299,6 +300,14 @@ async function performRenameMutations(args) {
                 // either failed the test run outright or (worse) passed for the
                 // wrong component.
                 await renameMochikitTestFiles(args.engineDir, oldName, newName, journal);
+                // 2026-04-24 eval Finding 5: xpcshell scaffolds live in yet
+                // another tree (`browser/base/content/test/<binary>-xpcshell/
+                // <name>/`). Before this call, renaming a component scaffolded
+                // with `--with-tests --xpcshell` left a directory whose name
+                // still referenced the pre-rename component, plus a test file
+                // whose underscored name referenced the old tag — both of
+                // which then failed to match the new component.
+                await renameXpcshellTestFiles(args.engineDir, projectRoot, oldName, newName, journal);
                 // Clear the stale deployed component directory so the next
                 // `furnace apply` is the single writer of the new name's
                 // deployment. Without this, eval runs showed the old widget

package/dist/src/commands/patch/index.d.ts

@@ -1,14 +1,16 @@
 /**
  * `fireforge patch <verb>` parent command. Groups single-patch
- * mutations (`delete`, `reorder`) so they do not clutter the top-level
- * command list. Queue-level verbs like `lint`, `export`, `verify`, and
- * `status` stay flat.
+ * mutations (`compact`, `delete`, `lint-ignore`, `reorder`, `tier`) so
+ * they do not clutter the top-level command list. Queue-level verbs
+ * like `lint`, `export`, `verify`, and `status` stay flat.
  */
 import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';
 export { patchCompactCommand } from './compact.js';
 export { patchDeleteCommand } from './delete.js';
+export { patchLintIgnoreCommand } from './lint-ignore.js';
 export { patchReorderCommand } from './reorder.js';
+export { patchTierCommand } from './tier.js';
 /**
  * Registers the `patch` subcommand parent and its verbs on the CLI.
  *

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

@@ -1,16 +1,20 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * `fireforge patch <verb>` parent command. Groups single-patch
- * mutations (`delete`, `reorder`) so they do not clutter the top-level
- * command list. Queue-level verbs like `lint`, `export`, `verify`, and
- * `status` stay flat.
+ * mutations (`compact`, `delete`, `lint-ignore`, `reorder`, `tier`) so
+ * they do not clutter the top-level command list. Queue-level verbs
+ * like `lint`, `export`, `verify`, and `status` stay flat.
  */
 import { registerPatchCompact } from './compact.js';
 import { registerPatchDelete } from './delete.js';
+import { registerPatchLintIgnore } from './lint-ignore.js';
 import { registerPatchReorder } from './reorder.js';
+import { registerPatchTier } from './tier.js';
 export { patchCompactCommand } from './compact.js';
 export { patchDeleteCommand } from './delete.js';
+export { patchLintIgnoreCommand } from './lint-ignore.js';
 export { patchReorderCommand } from './reorder.js';
+export { patchTierCommand } from './tier.js';
 /**
  * Registers the `patch` subcommand parent and its verbs on the CLI.
  *
@@ -20,7 +24,7 @@ export { patchReorderCommand } from './reorder.js';
 export function registerPatch(program, context) {
     const patch = program
         .command('patch')
-        .description('Manage individual patches in the queue (compact, delete, reorder)')
+        .description('Manage individual patches in the queue (compact, delete, lint-ignore, reorder, tier)')
         // Match `fireforge furnace`'s no-args contract: print the group's help and
         // exit 0. Without this default action, commander routes `fireforge patch`
         // (no subcommand) through its own help-then-exit-1 path, so scripts that
@@ -32,6 +36,8 @@ export function registerPatch(program, context) {
     });
     registerPatchCompact(patch, context);
     registerPatchDelete(patch, context);
+    registerPatchLintIgnore(patch, context);
     registerPatchReorder(patch, context);
+    registerPatchTier(patch, context);
 }
 //# sourceMappingURL=index.js.map

package/dist/src/commands/patch/lint-ignore.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `fireforge patch lint-ignore <name>` — adds, removes, or clears entries
+ * in `PatchMetadata.lintIgnore` without rewriting the `.patch` file body.
+ *
+ * Companion to `fireforge re-export <name> --lint-ignore <id>` (which is
+ * append-only). Existence is justified by the cases re-export cannot
+ * express:
+ * - Removing a single entry without dropping the rest of the list.
+ * - Clearing the entire list when the operator wants the rule(s) to
+ *   start firing again.
+ * - Editing metadata when the patch body is already correct, so the
+ *   re-export's engine read + diff regeneration roundtrip is wasted.
+ *
+ * Modes are mutually exclusive: exactly one of `--add`, `--remove`, or
+ * `--clear` must be supplied per invocation. The read-modify-write
+ * happens inside the patch directory lock via {@link mutatePatchMetadata}
+ * so a concurrent writer cannot interleave between the read and the
+ * write — important when an operator scripts repeated invocations or
+ * runs `--add` and `--remove` back-to-back.
+ */
+import { Command } from 'commander';
+import type { CommandContext } from '../../types/cli.js';
+import type { PatchLintIgnoreOptions } from '../../types/commands/index.js';
+/**
+ * Runs the `patch lint-ignore` command: reads the patch's existing
+ * `lintIgnore`, applies the requested mode, and writes the manifest.
+ *
+ * @param projectRoot - Project root directory
+ * @param identifier - Patch filename, ordinal, or manifest `name`
+ * @param options - Command options (exactly one of `add`/`remove`/`clear`)
+ */
+export declare function patchLintIgnoreCommand(projectRoot: string, identifier: string, options?: PatchLintIgnoreOptions): Promise<void>;
+/**
+ * Registers the `patch lint-ignore` subcommand on the `patch` parent.
+ *
+ * @param parent - Parent Commander command
+ * @param context - Shared CLI registration context
+ */
+export declare function registerPatchLintIgnore(parent: Command, context: CommandContext): void;

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

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `fireforge patch lint-ignore <name>` — adds, removes, or clears entries
+ * in `PatchMetadata.lintIgnore` without rewriting the `.patch` file body.
+ *
+ * Companion to `fireforge re-export <name> --lint-ignore <id>` (which is
+ * append-only). Existence is justified by the cases re-export cannot
+ * express:
+ * - Removing a single entry without dropping the rest of the list.
+ * - Clearing the entire list when the operator wants the rule(s) to
+ *   start firing again.
+ * - Editing metadata when the patch body is already correct, so the
+ *   re-export's engine read + diff regeneration roundtrip is wasted.
+ *
+ * Modes are mutually exclusive: exactly one of `--add`, `--remove`, or
+ * `--clear` must be supplied per invocation. The read-modify-write
+ * happens inside the patch directory lock via {@link mutatePatchMetadata}
+ * so a concurrent writer cannot interleave between the read and the
+ * write — important when an operator scripts repeated invocations or
+ * runs `--add` and `--remove` back-to-back.
+ */
+import { getProjectPaths } from '../../core/config.js';
+import { appendHistory } from '../../core/destructive.js';
+import { mutatePatchMetadata } from '../../core/patch-export.js';
+import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
+import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
+import { toError } from '../../utils/errors.js';
+import { pathExists } from '../../utils/fs.js';
+import { info, intro, outro, warn } from '../../utils/logger.js';
+/**
+ * Computes the post-mutation `lintIgnore` list for a given mode.
+ * Returns `undefined` when the result should drop the field from the
+ * manifest entirely (matching the validator's "preserve only when
+ * present" contract).
+ */
+function applyMode(existing, mode, values) {
+    const existingSet = new Set(existing);
+    if (mode === 'add') {
+        for (const v of values)
+            existingSet.add(v);
+        const merged = [...existingSet];
+        return merged.length > 0 ? merged : undefined;
+    }
+    if (mode === 'remove') {
+        for (const v of values)
+            existingSet.delete(v);
+        const remaining = [...existingSet];
+        return remaining.length > 0 ? remaining : undefined;
+    }
+    // mode === 'clear'
+    return undefined;
+}
+/**
+ * Renders a one-line summary of the planned change for use in
+ * `info()` / dry-run / history args.
+ */
+function describeChange(before, after, mode, values) {
+    const beforeSet = new Set(before);
+    const afterSet = new Set(after);
+    if (mode === 'clear') {
+        return before.length === 0
+            ? 'lintIgnore was already empty — no change'
+            : `lintIgnore cleared (was ${before.join(', ')})`;
+    }
+    if (mode === 'add') {
+        const added = values.filter((v) => !beforeSet.has(v));
+        if (added.length === 0) {
+            return 'lintIgnore unchanged (all requested IDs were already present)';
+        }
+        return `lintIgnore += ${added.join(', ')} → ${[...afterSet].join(', ') || '(empty)'}`;
+    }
+    // mode === 'remove'
+    const removed = values.filter((v) => beforeSet.has(v));
+    if (removed.length === 0) {
+        return 'lintIgnore unchanged (none of the requested IDs were present)';
+    }
+    return `lintIgnore −= ${removed.join(', ')} → ${[...afterSet].join(', ') || '(empty)'}`;
+}
+/**
+ * Runs the `patch lint-ignore` command: reads the patch's existing
+ * `lintIgnore`, applies the requested mode, and writes the manifest.
+ *
+ * @param projectRoot - Project root directory
+ * @param identifier - Patch filename, ordinal, or manifest `name`
+ * @param options - Command options (exactly one of `add`/`remove`/`clear`)
+ */
+export async function patchLintIgnoreCommand(projectRoot, identifier, options = {}) {
+    const isDryRun = options.dryRun === true;
+    intro(isDryRun ? 'FireForge patch lint-ignore (dry run)' : 'FireForge patch lint-ignore');
+    // Mode mutex: exactly one mode per invocation. Combinations like
+    // `--add foo --remove bar` are rejected — an operator who needs both
+    // runs the command twice (clearer audit trail) and `--clear` plus a
+    // mode is contradictory.
+    const adding = (options.add?.length ?? 0) > 0;
+    const removing = (options.remove?.length ?? 0) > 0;
+    const clearing = options.clear === true;
+    const modeCount = [adding, removing, clearing].filter(Boolean).length;
+    if (modeCount > 1) {
+        throw new InvalidArgumentError('--add, --remove, and --clear are mutually exclusive. Pick one mode per invocation.', 'patch lint-ignore');
+    }
+    if (modeCount === 0) {
+        throw new InvalidArgumentError('Specify --add <id>, --remove <id>, or --clear.', 'patch lint-ignore');
+    }
+    const mode = adding ? 'add' : removing ? 'remove' : 'clear';
+    const values = mode === 'add' ? (options.add ?? []) : mode === 'remove' ? (options.remove ?? []) : [];
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.patches))) {
+        throw new GeneralError('Patches directory not found.');
+    }
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest || manifest.patches.length === 0) {
+        throw new GeneralError('No patches in manifest.');
+    }
+    const target = resolvePatchIdentifier(identifier, manifest.patches);
+    if (!target) {
+        const available = manifest.patches
+            .map((p) => p.name && p.name !== p.filename ? `${p.filename} (name: ${p.name})` : p.filename)
+            .join(', ');
+        throw new InvalidArgumentError(`Patch "${identifier}" not found. Accepted identifiers: ordinal (e.g. 2), filename (e.g. 002-ui-foo.patch), or manifest name (e.g. ui-foo). Available: ${available}`, identifier);
+    }
+    if (isDryRun) {
+        const existing = target.lintIgnore ?? [];
+        const projected = applyMode(existing, mode, values) ?? [];
+        info(`[dry-run] ${target.filename}: ${describeChange(existing, projected, mode, values)}.`);
+        outro('Dry run complete — 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
+        // entirely. The mutation API splits these to keep the
+        // exactOptionalPropertyTypes contract clean — only set values land
+        // in the typed `Partial<PatchMetadata>`, and the unset list is
+        // applied via `delete` after spread.
+        return next !== undefined ? { set: { lintIgnore: next } } : { unset: ['lintIgnore'] };
+    });
+    if (!result) {
+        // Race: target vanished between the manifest read above and the
+        // locked mutate. Surfacing as a hard error rather than a silent
+        // no-op — the operator's intent did not land.
+        throw new GeneralError(`Patch ${target.filename} disappeared from the manifest during the update. Re-run after investigating.`);
+    }
+    const existing = result.before.lintIgnore ?? [];
+    const projected = result.after.lintIgnore ?? [];
+    info(`${target.filename}: ${describeChange(existing, projected, mode, values)}.`);
+    try {
+        await appendHistory(paths.patches, {
+            operation: 'patch-lint-ignore',
+            args: {
+                filename: target.filename,
+                mode,
+                values: [...values],
+                before: existing,
+                after: projected,
+            },
+            ...(options.yes === true ? { yes: true } : {}),
+            result: 'ok',
+        });
+    }
+    catch (historyError) {
+        warn(`History log append failed after patch lint-ignore committed (${target.filename}): ${toError(historyError).message}`);
+    }
+    outro('Patch lint-ignore complete');
+}
+/**
+ * Registers the `patch lint-ignore` subcommand on the `patch` parent.
+ *
+ * @param parent - Parent Commander command
+ * @param context - Shared CLI registration context
+ */
+export function registerPatchLintIgnore(parent, context) {
+    const { getProjectRoot, withErrorHandling } = context;
+    parent
+        .command('lint-ignore <name>')
+        .description('Edit PatchMetadata.lintIgnore on a single patch (no .patch body rewrite). One mode per invocation.')
+        .option('--add <check-id>', 'Lint check ID to add to the patch lintIgnore list (repeatable)', (value, prev) => [...prev, value], [])
+        .option('--remove <check-id>', 'Lint check ID to remove from the patch lintIgnore list (repeatable)', (value, prev) => [...prev, value], [])
+        .option('--clear', 'Drop the lintIgnore field entirely')
+        .option('--dry-run', 'Show what would change without writing')
+        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
+        .action(withErrorHandling(async (name, options) => {
+        // Commander defaults `--add`/`--remove` to `[]` so they appear in
+        // the options object even when unused. Strip empty arrays so
+        // `pickDefined` sees them as absent — otherwise the mode-count
+        // mutex would treat zero-length arrays as a present mode.
+        const normalized = {};
+        if (options.add !== undefined && options.add.length > 0)
+            normalized.add = options.add;
+        if (options.remove !== undefined && options.remove.length > 0)
+            normalized.remove = options.remove;
+        if (options.clear === true)
+            normalized.clear = true;
+        if (options.dryRun === true)
+            normalized.dryRun = true;
+        if (options.yes === true)
+            normalized.yes = true;
+        await patchLintIgnoreCommand(getProjectRoot(), name, normalized);
+    }));
+}
+//# sourceMappingURL=lint-ignore.js.map

package/dist/src/commands/patch/tier.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `fireforge patch tier <name>` — sets or clears `PatchMetadata.tier` on
+ * a single patch without rewriting the `.patch` file body.
+ *
+ * Companion to `fireforge re-export <name> --tier <tier>`. Re-export is
+ * the right tool when the patch body itself needs to be regenerated; this
+ * subcommand exists for the metadata-only adjustment, where the operator
+ * has discovered (e.g. from a `lint --per-patch` warning) that the
+ * threshold-tier override should be set but the patch body is already
+ * correct. Avoiding the re-export saves the engine read + diff
+ * regeneration roundtrip and leaves the `.patch` file's mtime alone.
+ *
+ * Modes are mutually exclusive: exactly one of `--tier <branding>` or
+ * `--clear` must be supplied per invocation.
+ */
+import { Command } from 'commander';
+import type { CommandContext } from '../../types/cli.js';
+import type { PatchTierOptions } from '../../types/commands/index.js';
+/**
+ * Runs the `patch tier` command: updates `PatchMetadata.tier` on the
+ * named patch (or clears the field) and writes the manifest.
+ *
+ * @param projectRoot - Project root directory
+ * @param identifier - Patch filename, ordinal, or manifest `name`
+ * @param options - Command options
+ */
+export declare function patchTierCommand(projectRoot: string, identifier: string, options?: PatchTierOptions): Promise<void>;
+/**
+ * Registers the `patch tier` subcommand on the `patch` parent.
+ *
+ * @param parent - Parent Commander command
+ * @param context - Shared CLI registration context
+ */
+export declare function registerPatchTier(parent: Command, context: CommandContext): void;