@hominis/fireforge 0.18.9 → 0.18.11

package/README.md

@@ -24,7 +24,7 @@ Inspired by [fern.js](https://github.com/ghostery/user-agent-desktop) and [Melon
 
 - **Design token management** Track CSS custom property coverage across your modified files.
 
-- **Quality checks** `fireforge lint` catches fork-specific issues (raw colours, missing licence headers, relative imports, large patches, cross-patch ordering problems) before you export. `fireforge verify` runs a read-only integrity check over the whole patch queue. `fireforge doctor` diagnoses project health including Furnace component validation.
+- **Quality checks** `fireforge lint` catches fork-specific issues (raw colours, missing licence headers, relative imports, large patches, cross-patch ordering problems) before you export. `fireforge typecheck` runs CI-grade JS type checking against project-supplied jsconfig.json files (web components, chrome scripts) — separate from `lint`'s patch-hygiene checkJs pass. `fireforge verify` runs a read-only integrity check over the whole patch queue. `fireforge doctor` diagnoses project health including Furnace component validation.
 
 - **Built and validated against real Firefox code** Developed by editing a real Firefox ESR codebase, learning from existing patch tools, observing the breakages and edge cases that surfaced and turning those findings into a realistic test suite. In-repo tests are thus grounded in actual development scenarios. Yes, we mock quite a bit, but when building a tool that modifies a separate code base, I think it's a solid compromise for the time being. Full end-to-end runs are currently run locally, as they require about 30 GB of disk and significant compute for multiple full builds. Full end-to-end via Github Actions will be added soonishlyTM.
 
@@ -57,7 +57,7 @@ Your project now has `fireforge.json`, an `engine/` directory with Firefox sourc
 
 #### Known upstream build issues
 
-- **macOS 15 (Darwin 25+) — `gecko-profiler` bindgen error `cannot find type _CharT in this scope`.** An Apple toolchain update changed `std::__CharT_pointer` to `_CharT_pointer` in the libc++ headers Firefox's bindgen walks, so `toolkit/library/rust/target-objects` fails during `mach build` even on a clean `fireforge bootstrap`. This is an upstream Firefox issue, not a FireForge bug. Two workarounds: pin Xcode's command line tools to a pre-September-2025 release via `xcode-select --install` / [Apple developer downloads](https://developer.apple.com/download/all/), or apply a one-line bindgen-basic-string-workaround patch (Hominis ships one in its patch queue). If you interrupt the resulting `fireforge build` and re-run `fireforge doctor`, the download/engine state is unaffected — the failure is isolated to the Rust compile phase.
+- **macOS 15 (Darwin 25+) — `gecko-profiler` bindgen error `cannot find type _CharT in this scope`.** An Apple toolchain update changed `std::__CharT_pointer` to `_CharT_pointer` in the libc++ headers Firefox's bindgen walks, so `toolkit/library/rust/target-objects` fails during `mach build` even on a clean `fireforge bootstrap`. This is an upstream Firefox issue, not a FireForge bug. Two workarounds: pin Xcode's command line tools to a pre-September-2025 release via `xcode-select --install` / [Apple developer downloads](https://developer.apple.com/download/all/), or apply a one-line bindgen-basic-string-workaround patch (a downstream consumer may ship one in its patch queue). If you interrupt the resulting `fireforge build` and re-run `fireforge doctor`, the download/engine state is unaffected — the failure is isolated to the Rust compile phase.
 
 ### Workflow Overview
 
@@ -255,7 +255,20 @@ By default, a standalone `fireforge lint` (no arguments) lints the **aggregate**
 
 **JSDoc validation** uses AST-based analysis (Acorn) to validate exported APIs in patch-owned `.sys.mjs` files. A file is "patch-owned" if it was newly created by the current diff or by an existing patch in the queue. Functions must document every `@param` (names must match) and include `@returns` when the function returns a value. Exported constants and classes require a JSDoc block.
 
-**Optional `checkJs` pass.** Enable a TypeScript-esque bastardization of type checking for patch-owned `.sys.mjs` files by adding `"patchLint": { "checkJs": true }` to `fireforge.json`. This uses the TypeScript compiler API with `allowJs + checkJs + noEmit`, scoped only to patch-owned files. Firefox globals (`Services`, `ChromeUtils`, `lazy`, etc.) are shimmed automatically. Module-resolution errors from Firefox's `resource://` and `chrome://` URL schemes are suppressed since TypeScript cannot follow these. This pass solely focuses on type errors within the patch-owned code itself (mismatched JSDoc types, wrong argument counts, unreachable code, etc.).
+**Optional `checkJs` pass.** Enable a TypeScript-esque bastardization of type checking for patch-owned `.sys.mjs` files by adding `"patchLint": { "checkJs": true }` to `fireforge.json`. This uses the TypeScript compiler API with `allowJs + checkJs + noEmit`, scoped only to patch-owned files. Firefox globals (`Services`, `ChromeUtils`, `lazy`, etc.) are shimmed automatically. Module-resolution errors from Firefox's `resource://` and `chrome://` URL schemes are suppressed since TypeScript cannot follow these. This pass solely focuses on type errors within the patch-owned code itself (mismatched JSDoc types, wrong argument counts, unreachable code, etc.). Projects that need to extend the built-in shim (e.g. for `MozLitElement`, `MozXULElement`, or fork-specific component bases) can point at an additional `.d.ts` via `"patchLint": { "checkJsExtraShim": "tools/types/<fork>-globals.d.ts" }`; the file is concatenated to the built-in shim — augment, don't redeclare.
+
+**Whole-project type checking — `fireforge typecheck`.** `patchLint.checkJs` is patch-hygiene: scoped to patch-owned `.sys.mjs`, suppresses module-resolution noise, and runs every time `fireforge lint` runs. `fireforge typecheck` is the CI-grade complement: it runs whole projects you point at via `typecheck.projects` in `fireforge.json`, honours each jsconfig's strictness/include/exclude/`paths`, and is intended as a CI gate. The two are complementary; the recommended setup is `fireforge lint` on every patch export and `fireforge typecheck` on CI for the project-level baseline.
+
+```jsonc
+{
+  "typecheck": {
+    "projects": ["components/custom/jsconfig.json", "engine/browser/base/content/jsconfig.json"],
+    "extraShim": "tools/types/<fork>-globals.d.ts",
+  },
+}
+```
+
+The command resolves each `projects` entry through TypeScript's own config parser (`readConfigFile` + `parseJsonConfigFileContent`), so `paths` mappings, `include`/`exclude` globs, and `lib` settings all behave the same as `tsc --noEmit -p <path>`. FireForge forces `noEmit: true` and defaults `allowJs`/`checkJs` to `true` only when the user has not set them — explicit `"checkJs": false` in a jsconfig is honoured (one notice, no diagnostics) so the IDE-noise opt-out remains an opt-out. The same `FIREFOX_GLOBALS_SHIM` and the same eight suppressed diagnostic codes (2304 / 2305 / 2306 / 2307 / 2552 / 2580 / 2792 / 7016 — module-resolution + global-name noise) apply, so a file that lints clean cannot fail typecheck for an inferable-only-from-source reason. Pass `--project <path>` for a one-off run against a single jsconfig (replaces the configured list, preserves `extraShim`). Exits non-zero on any error-severity diagnostic; warnings print but do not fail. TypeScript stays a dev-dependency — install it (`npm i -D typescript`) before running. The command does not honour `--since` or any patch-diff filter: it is whole-project by design.
 
 **Optional `jsdocClassMethods` enforcement.** Set `"patchLint": { "jsdocClassMethods": "warning" | "error" }` in `fireforge.json` to extend JSDoc validation to class-method exports inside patch-owned `.sys.mjs` files. Every public method (instance and static), parameter-bearing constructor, getter, and setter must carry a leading JSDoc block; `@param` names must match the parameter list, and `@returns` is required when a method returns a value (getters and setters are exempt from `@returns`). Methods whose name starts with `_` or `#`, methods carrying `@private` or `@internal` in their JSDoc, and zero-parameter constructors are exempt. Defaults to `"off"`, so upgrading is a no-op until the knob is set.
 
@@ -667,10 +680,10 @@ The summary block reports two allowlist counters so operators can tell whether a
 A feature with multiple components (e.g. an eight-component dock) typically wants one shared `.ftl` per feature rather than eight per-component stubs. `furnace create <tag> --localized --shared-ftl <chrome-uri>` participates in an existing feature-scoped bundle:
 
 ```bash
-fireforge furnace create hominis-dock-button --localized --shared-ftl browser/hominis-dock.ftl
+fireforge furnace create mybrowser-dock-button --localized --shared-ftl browser/mybrowser-dock.ftl
 ```
 
-The generated `.mjs` calls `insertFTLIfNeeded("browser/hominis-dock.ftl")` instead of the per-component path. No `<tag>.ftl` stub is written. The `furnace.json` `custom` entry carries a new `sharedFtl` field so apply, validate, and remove all honour the participation:
+The generated `.mjs` calls `insertFTLIfNeeded("browser/mybrowser-dock.ftl")` instead of the per-component path. No `<tag>.ftl` stub is written. The `furnace.json` `custom` entry carries a new `sharedFtl` field so apply, validate, and remove all honour the participation:
 
 - `furnace apply` does not copy a per-component `.ftl` into the FTL tree nor add a locale `jar.mn` entry — the shared file is registered by whoever owns the feature bundle.
 - `furnace remove` early-returns from the locale `jar.mn` cleanup, so dropping our component's reference does not orphan the bundle for every other participant.
@@ -685,9 +698,9 @@ The generated `.mjs` calls `insertFTLIfNeeded("browser/hominis-dock.ftl")` inste
 When the wrapped inner element is hand-authored or is a non-stock `moz-*` widget that does not appear in `composes`, the explicit `keyboardCovered: true` field on the component's `furnace.json` entry forces the same skip:
 
 ```json
-"hominis-dock-button": {
+"mybrowser-dock-button": {
   "description": "Dock button wrapper",
-  "targetPath": "components/custom/hominis-dock-button",
+  "targetPath": "components/custom/mybrowser-dock-button",
   "register": true,
   "localized": false,
   "composes": ["moz-button"],

package/dist/src/commands/doctor.js

@@ -337,7 +337,7 @@ const DOCTOR_CHECKS = [
                     for (const filename of repaired.recoveredFilenames) {
                         // 2026-04-24 eval Finding 6: the repair path used to tell the
                         // operator to hand-edit patches.json, which contradicts the
-                        // README + Hominis docs that treat the manifest as
+                        // README + downstream docs that treat the manifest as
                         // FireForge-owned. Point at the existing `re-export` /
                         // `export` workflow instead so the fix stays inside the tool:
                         // re-exporting the same files with an explicit `--description`

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

@@ -81,7 +81,7 @@ function registerFurnaceInfoCommands(furnace, context) {
         return value;
     })
         .option('--compose <tags>', 'Record stock tags composed internally (metadata only, comma-separated)', (val) => val.split(',').map((s) => s.trim()))
-        .option('--shared-ftl <path>', 'Participate in an existing feature-scoped .ftl at this path (e.g. "browser/hominis-dock.ftl"); skips the per-component .ftl scaffold (implies --localized)')
+        .option('--shared-ftl <path>', 'Participate in an existing feature-scoped .ftl at this path (e.g. "browser/mybrowser-dock.ftl"); skips the per-component .ftl scaffold (implies --localized)')
         .option('--dry-run', 'Show the planned file set and furnace.json changes without writing')
         .option('--allow-prefix-mismatch', 'Create the component even when its name does not start with the configured `componentPrefix` in furnace.json. Without this flag the command refuses to write anything on a prefix mismatch.')
         .action(withErrorHandling(async (name, options) => {

package/dist/src/commands/lint.d.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import type { CommandContext } from '../types/cli.js';
+import type { PatchLintIssue } from '../types/commands/index.js';
 /** Options controlling how the lint command filters and tags its output. */
 export interface LintCommandOptions {
     /**
@@ -46,6 +47,41 @@ export interface LintCommandOptions {
      */
     perPatch?: boolean;
 }
+/**
+ * Result of {@link applyAggregateLintIgnoreSuppression}.
+ */
+export interface AggregateLintIgnoreResult {
+    /** Issues remaining after suppression. */
+    issues: PatchLintIssue[];
+    /** Number of issues dropped because an owning patch listed the check in `lintIgnore`. */
+    dropped: number;
+}
+/**
+ * Filters aggregate-mode lint issues against per-patch `lintIgnore`
+ * lists drawn from the manifest. An issue is dropped when at least one
+ * patch whose `filesAffected` covers `issue.file` lists `issue.check`
+ * in its `lintIgnore`.
+ *
+ * Mirrors the per-patch contract: `--per-patch` mode threads each
+ * patch's `lintIgnore` directly into `lintExportedPatch`, so a check
+ * the operator explicitly waived in `patches.json` does not surface.
+ * Aggregate `--since` mode previously rediscovered the suppressed
+ * warning every CI run because the diff was treated as a single unit
+ * with no patch-level scope. Attributing each issue's file to its
+ * owning patch via `filesAffected` re-establishes the same suppression
+ * semantics. Cross-patch findings (forward-import, duplicate-creation)
+ * still attribute via `issue.file` because the `file` field is the
+ * offending site, which is owned by some patch.
+ *
+ * Multiple owners: an issue is dropped if **any** owning patch waived
+ * the rule. Conservative — never adds new findings, only drops
+ * already-explicitly-waived ones.
+ *
+ * @param issues - Issues collected from the aggregate lint run.
+ * @param ctx - Patch queue context used to attribute file → patch.
+ * @returns Filtered issue list and the count of dropped findings.
+ */
+export declare function applyAggregateLintIgnoreSuppression(issues: PatchLintIssue[], ctx: import('../core/patch-lint.js').PatchQueueContext): AggregateLintIgnoreResult;
 /**
  * Runs the lint command to check engine changes against patch quality rules.
  * @param projectRoot - Root directory of the project

package/dist/src/commands/lint.js

@@ -160,6 +160,53 @@ async function resolveLintDiff(engineDir, files, binaryName, furnacePrefixes) {
     }
     return diff;
 }
+/**
+ * Filters aggregate-mode lint issues against per-patch `lintIgnore`
+ * lists drawn from the manifest. An issue is dropped when at least one
+ * patch whose `filesAffected` covers `issue.file` lists `issue.check`
+ * in its `lintIgnore`.
+ *
+ * Mirrors the per-patch contract: `--per-patch` mode threads each
+ * patch's `lintIgnore` directly into `lintExportedPatch`, so a check
+ * the operator explicitly waived in `patches.json` does not surface.
+ * Aggregate `--since` mode previously rediscovered the suppressed
+ * warning every CI run because the diff was treated as a single unit
+ * with no patch-level scope. Attributing each issue's file to its
+ * owning patch via `filesAffected` re-establishes the same suppression
+ * semantics. Cross-patch findings (forward-import, duplicate-creation)
+ * still attribute via `issue.file` because the `file` field is the
+ * offending site, which is owned by some patch.
+ *
+ * Multiple owners: an issue is dropped if **any** owning patch waived
+ * the rule. Conservative — never adds new findings, only drops
+ * already-explicitly-waived ones.
+ *
+ * @param issues - Issues collected from the aggregate lint run.
+ * @param ctx - Patch queue context used to attribute file → patch.
+ * @returns Filtered issue list and the count of dropped findings.
+ */
+export function applyAggregateLintIgnoreSuppression(issues, ctx) {
+    const suppressionsByFile = new Map();
+    for (const entry of ctx.entries) {
+        const ignoreList = entry.metadata?.lintIgnore;
+        if (!ignoreList || ignoreList.length === 0)
+            continue;
+        for (const f of entry.metadata?.filesAffected ?? []) {
+            let bucket = suppressionsByFile.get(f);
+            if (!bucket) {
+                bucket = new Set();
+                suppressionsByFile.set(f, bucket);
+            }
+            for (const id of ignoreList)
+                bucket.add(id);
+        }
+    }
+    if (suppressionsByFile.size === 0) {
+        return { issues, dropped: 0 };
+    }
+    const filtered = issues.filter((issue) => !suppressionsByFile.get(issue.file)?.has(issue.check));
+    return { issues: filtered, dropped: issues.length - filtered.length };
+}
 /**
  * Runs the lint command to check engine changes against patch quality rules.
  * @param projectRoot - Root directory of the project
@@ -217,7 +264,7 @@ export async function lintCommand(projectRoot, files, options = {}) {
     if (await pathExists(paths.patches)) {
         ctx = await buildPatchQueueContext(paths.patches);
     }
-    const issues = [
+    let issues = [
         ...(await lintExportedPatch(paths.engine, filesAffected, diff, config, ctx)),
     ];
     // Cross-patch rules operate over the whole queue, so run them whenever a
@@ -226,6 +273,19 @@ export async function lintCommand(projectRoot, files, options = {}) {
     if (ctx) {
         issues.push(...lintPatchQueue(ctx));
     }
+    // Honor per-patch `lintIgnore` in aggregate mode by attributing each
+    // issue's file to its owning patches via the manifest's
+    // `filesAffected`. Per-patch mode threads `lintIgnore` directly into
+    // `lintExportedPatch`; aggregate mode previously had no patch-level
+    // scope to consult, so a check an operator had explicitly waived in
+    // `patches.json` re-surfaced on every `--since` run (CI default).
+    if (ctx) {
+        const result = applyAggregateLintIgnoreSuppression(issues, ctx);
+        issues = result.issues;
+        if (result.dropped > 0) {
+            info(`Suppressed ${result.dropped} issue(s) via per-patch lintIgnore (aggregate mode).`);
+        }
+    }
     // When a queue manifest exists AND files were NOT scoped explicitly, the
     // "diff" we just linted is every applied patch summed together. Patch-
     // size rules (`large-patch-lines`, `large-patch-files`) then fire against

package/dist/src/commands/manifest.js

@@ -21,6 +21,7 @@ import { registerSetup } from './setup.js';
 import { registerStatus } from './status.js';
 import { registerTest } from './test.js';
 import { registerToken } from './token.js';
+import { registerTypecheck } from './typecheck.js';
 import { registerVerify } from './verify.js';
 import { registerWatch } from './watch.js';
 import { registerWire } from './wire.js';
@@ -53,6 +54,7 @@ export const COMMAND_MANIFEST = [
     { name: 'wire', group: 'workflow', register: registerWire },
     { name: 'token', group: 'components', register: registerToken },
     { name: 'lint', group: 'diagnostics', register: registerLint },
+    { name: 'typecheck', group: 'diagnostics', register: registerTypecheck },
     { name: 'verify', group: 'diagnostics', register: registerVerify },
     { name: 'furnace', group: 'components', register: registerFurnace },
 ];

package/dist/src/commands/package.js

@@ -57,7 +57,7 @@ export async function packageCommand(projectRoot, options) {
         // only, so a targeted hint translator could not see the failure text.
         // The captured stderr is fed through `explainMachError` below so
         // recognised failure modes (notably the `packager.py` NoneType trip
-        // the evaluator hit on `hominis/`) get an actionable hint prepended
+        // the evaluator hit on `mybrowser/`) get an actionable hint prepended
         // to the raw mach output the operator already saw.
         result = await machPackageCapture(paths.engine);
     }

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

@@ -1,14 +1,16 @@
 /**
  * `fireforge patch <verb>` parent command. Groups single-patch
- * 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.
+ * mutations (`compact`, `delete`, `lint-ignore`, `rename`, `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 { patchRenameCommand } from './rename.js';
 export { patchReorderCommand } from './reorder.js';
 export { patchTierCommand } from './tier.js';
 /**

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

@@ -1,18 +1,21 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * `fireforge patch <verb>` parent command. Groups single-patch
- * 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.
+ * mutations (`compact`, `delete`, `lint-ignore`, `rename`, `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 { registerPatchRename } from './rename.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 { patchRenameCommand } from './rename.js';
 export { patchReorderCommand } from './reorder.js';
 export { patchTierCommand } from './tier.js';
 /**
@@ -24,7 +27,7 @@ export { patchTierCommand } from './tier.js';
 export function registerPatch(program, context) {
     const patch = program
         .command('patch')
-        .description('Manage individual patches in the queue (compact, delete, lint-ignore, reorder, tier)')
+        .description('Manage individual patches in the queue (compact, delete, lint-ignore, rename, 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
@@ -37,6 +40,7 @@ export function registerPatch(program, context) {
     registerPatchCompact(patch, context);
     registerPatchDelete(patch, context);
     registerPatchLintIgnore(patch, context);
+    registerPatchRename(patch, context);
     registerPatchReorder(patch, context);
     registerPatchTier(patch, context);
 }

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

@@ -21,6 +21,13 @@
 import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';
 import type { PatchLintIgnoreOptions } from '../../types/commands/index.js';
+type LintIgnoreMode = 'add' | 'remove' | 'clear';
+/**
+ * Renders a one-line summary of the planned change for use in
+ * `info()` / dry-run / history args. Exported for unit-testing the
+ * message format directly without mocking the logger transport.
+ */
+export declare function describeChange(before: ReadonlyArray<string>, after: ReadonlyArray<string>, mode: LintIgnoreMode, values: ReadonlyArray<string>): string;
 /**
  * Runs the `patch lint-ignore` command: reads the patch's existing
  * `lintIgnore`, applies the requested mode, and writes the manifest.
@@ -37,3 +44,4 @@ export declare function patchLintIgnoreCommand(projectRoot: string, identifier:
  * @param context - Shared CLI registration context
  */
 export declare function registerPatchLintIgnore(parent: Command, context: CommandContext): void;
+export {};

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

@@ -53,9 +53,10 @@ function applyMode(existing, mode, values) {
 }
 /**
  * Renders a one-line summary of the planned change for use in
- * `info()` / dry-run / history args.
+ * `info()` / dry-run / history args. Exported for unit-testing the
+ * message format directly without mocking the logger transport.
  */
-function describeChange(before, after, mode, values) {
+export function describeChange(before, after, mode, values) {
     const beforeSet = new Set(before);
     const afterSet = new Set(after);
     if (mode === 'clear') {
@@ -63,17 +64,20 @@ function describeChange(before, after, mode, values) {
             ? 'lintIgnore was already empty — no change'
             : `lintIgnore cleared (was ${before.join(', ')})`;
     }
+    const currentLabel = before.length > 0 ? `[${before.join(', ')}]` : '(empty)';
     if (mode === 'add') {
         const added = values.filter((v) => !beforeSet.has(v));
         if (added.length === 0) {
-            return 'lintIgnore unchanged (all requested IDs were already present)';
+            // Surface the existing list so a no-op `--add` does not require a
+            // follow-up `patches.json` read to confirm what was already present.
+            return `lintIgnore unchanged (current: ${currentLabel}; all requested IDs 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 unchanged (current: ${currentLabel}; none of the requested IDs were present)`;
     }
     return `lintIgnore −= ${removed.join(', ')} → ${[...afterSet].join(', ') || '(empty)'}`;
 }

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

@@ -0,0 +1,36 @@
+/**
+ * `fireforge patch rename <name>` — relabels a patch's filename, manifest
+ * `name`, and (optionally) `description` without rewriting the `.patch`
+ * file body.
+ *
+ * Companion to `re-export --files <subset>`. Re-export shrinks the body
+ * + `filesAffected`, but leaves the patch's identity describing the
+ * pre-shrink scope. Before this verb existed, the only workaround for
+ * that drift was `delete` + re-export, which briefly removed the patch
+ * from the queue (any forward-import dependent would refuse the
+ * re-export until the deleted patch's siblings were rewritten).
+ *
+ * The filename rename and the manifest mutation happen under the patch
+ * directory lock so concurrent exports cannot allocate the new
+ * filename, and a filesystem rename failure rolls back before the
+ * manifest is touched.
+ */
+import { Command } from 'commander';
+import type { CommandContext } from '../../types/cli.js';
+import type { PatchRenameOptions } from '../../types/commands/index.js';
+/**
+ * Runs the `patch rename` command: relabels filename + manifest entry
+ * for a single patch atomically.
+ *
+ * @param projectRoot - Project root directory
+ * @param identifier - Patch filename, ordinal, or manifest `name`
+ * @param options - Command options (`--to <new-name>` is required)
+ */
+export declare function patchRenameCommand(projectRoot: string, identifier: string, options?: PatchRenameOptions): Promise<void>;
+/**
+ * Registers the `patch rename` subcommand on the `patch` parent.
+ *
+ * @param parent - Parent Commander command
+ * @param context - Shared CLI registration context
+ */
+export declare function registerPatchRename(parent: Command, context: CommandContext): void;