@hominis/fireforge 0.43.0 → 0.44.0

package/dist/src/commands/patch/move-files-create.d.ts

@@ -1,13 +1,13 @@
 /**
  * `fireforge patch move-files <from> <to> --create --order <n>` — creates
- * the target patch at the requested sparse order and moves the files into
- * it as one transaction. This is the transactional bootstrap of a split:
- * without it, moving files into a not-yet-existing patch required a manual
+ * the target patch at the requested sparse order and moves the files into it
+ * as one transaction. This is the transactional bootstrap of a split:
+ * without it, moving files into a not-yet-existing patch requires a manual
  * shrink-then-export dance with hand-repointed staged-dependency owners.
  *
- * Mirrors `patch split` end-to-end (same planning, projection lint,
- * policy enforcement, and locked commit); the `<to>` argument becomes the
- * new patch's name/slug the way `split --name` does.
+ * Mirrors `patch split` end-to-end (same planning, projection lint, policy
+ * enforcement, and locked commit); the `<to>` argument becomes the new
+ * patch's name/slug the way `split --name` does.
  */
 import type { PatchMoveFilesOptions } from '../../types/commands/index.js';
 /**

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

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * `fireforge patch move-files <from> <to> --create --order <n>` — creates
- * the target patch at the requested sparse order and moves the files into
- * it as one transaction. This is the transactional bootstrap of a split:
- * without it, moving files into a not-yet-existing patch required a manual
+ * the target patch at the requested sparse order and moves the files into it
+ * as one transaction. This is the transactional bootstrap of a split:
+ * without it, moving files into a not-yet-existing patch requires a manual
  * shrink-then-export dance with hand-repointed staged-dependency owners.
  *
- * Mirrors `patch split` end-to-end (same planning, projection lint,
- * policy enforcement, and locked commit); the `<to>` argument becomes the
- * new patch's name/slug the way `split --name` does.
+ * Mirrors `patch split` end-to-end (same planning, projection lint, policy
+ * enforcement, and locked commit); the `<to>` argument becomes the new
+ * patch's name/slug the way `split --name` does.
  */
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { assertConfirmationAvailable, confirmDestructive } from '../../core/destructive.js';
@@ -92,7 +92,7 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
     // same patch-policy shape as the committed `lint --per-patch` gate) makes
     // cross-patch `resource:///` imports and sibling head.js harness roots
     // resolve exactly as they will after the move lands — without it the
-    // projection lint was blind.
+    // projection lint is blind.
     const patchQueueCtx = await buildPatchQueueContext(paths.patches, config);
     const ignoreChecks = source.lintIgnore ? new Set(source.lintIgnore) : undefined;
     await runPatchLint(paths.engine, remainingFiles, remainingDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, source.tier);
@@ -122,7 +122,7 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
         outro('Dry run complete — no changes made');
         return;
     }
-    if (decision === 'cancelled') {
+    if (decision === 'declined') {
         outro('Move cancelled');
         return;
     }

package/dist/src/commands/patch/move-files-into.d.ts

@@ -1,12 +1,12 @@
 /**
  * Transactional file-ownership move into an EXISTING patch.
  *
- * Before 0.39.0, `patch move-files <from> <to>` with an existing target was
- * preview-only: it printed two `re-export --files` commands whose real
- * execution cost three further refusals (`--allow-shrink`, `--yes`, and a
- * projected `duplicate-new-file-creation` unless the SHRINK landed first —
- * while the printed plan listed the grow first). This module performs the
- * same shrink→grow as one transaction under the patch-directory lock with
+ * A preview-only `patch move-files <from> <to>` prints two
+ * `re-export --files` commands whose real execution costs three further
+ * refusals (`--allow-shrink`, `--yes`, and a projected
+ * `duplicate-new-file-creation` unless the SHRINK lands first — while the
+ * printed plan lists the grow first). This module performs the same
+ * shrink→grow as one transaction under the patch-directory lock with
  * rollback, mirroring `patch split` / `move-files --create`.
  *
  * Preconditions match `re-export`: the engine worktree must currently

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

@@ -2,12 +2,12 @@
 /**
  * Transactional file-ownership move into an EXISTING patch.
  *
- * Before 0.39.0, `patch move-files <from> <to>` with an existing target was
- * preview-only: it printed two `re-export --files` commands whose real
- * execution cost three further refusals (`--allow-shrink`, `--yes`, and a
- * projected `duplicate-new-file-creation` unless the SHRINK landed first —
- * while the printed plan listed the grow first). This module performs the
- * same shrink→grow as one transaction under the patch-directory lock with
+ * A preview-only `patch move-files <from> <to>` prints two
+ * `re-export --files` commands whose real execution costs three further
+ * refusals (`--allow-shrink`, `--yes`, and a projected
+ * `duplicate-new-file-creation` unless the SHRINK lands first — while the
+ * printed plan lists the grow first). This module performs the same
+ * shrink→grow as one transaction under the patch-directory lock with
  * rollback, mirroring `patch split` / `move-files --create`.
  *
  * Preconditions match `re-export`: the engine worktree must currently
@@ -16,9 +16,9 @@
  */
 import { join } from 'node:path';
 import { appendHistory, assertConfirmationAvailable, confirmDestructive, } from '../../core/destructive.js';
-import { computeProjectedLintRegressions } from '../../core/lint-projection.js';
 import { normalizePatchArtifact } from '../../core/patch-artifact-normalize.js';
 import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, collectForwardImportEdges, detectNewFilesInDiff, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
+import { computeProjectedLintRegressions } from '../../core/patch-lint-projection.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, savePatchesManifest, validatePatchesManifest, } from '../../core/patch-manifest.js';
 import { extractNewFileContentFromDiff } from '../../core/patch-transform.js';
@@ -238,7 +238,7 @@ export async function runMoveFilesInto(args) {
         outro('Dry run complete — no changes made');
         return;
     }
-    if (decision === 'cancelled') {
+    if (decision === 'declined') {
         outro('Move cancelled');
         return;
     }

package/dist/src/commands/patch/patch-context.d.ts

@@ -1,9 +1,8 @@
 /**
  * Shared preamble for the patch subcommands: every mutation command starts
  * by loading the project paths and the patches manifest and (for the
- * single-patch commands) resolving the operator-supplied identifier. The
- * sequence and its error wording were previously copied into each command;
- * this module is the single source for both.
+ * single-patch commands) resolving the operator-supplied identifier. This
+ * module is the single source for that sequence and its error wording.
  */
 import type { PatchesManifest, PatchMetadata } from '../../types/commands/index.js';
 import type { ProjectPaths } from '../../types/config.js';

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

@@ -2,9 +2,8 @@
 /**
  * Shared preamble for the patch subcommands: every mutation command starts
  * by loading the project paths and the patches manifest and (for the
- * single-patch commands) resolving the operator-supplied identifier. The
- * sequence and its error wording were previously copied into each command;
- * this module is the single source for both.
+ * single-patch commands) resolving the operator-supplied identifier. This
+ * module is the single source for that sequence and its error wording.
  */
 import { getProjectPaths } from '../../core/config.js';
 import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';

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

@@ -1,19 +1,18 @@
 /**
  * `fireforge patch rename <name>` — relabels a patch's filename, manifest
- * `name`, and (optionally) `description` without rewriting the `.patch`
- * file body.
+ * `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).
+ * Companion to `re-export --files <subset>`. Re-export shrinks the body and
+ * `filesAffected` but leaves the patch's identity describing the pre-shrink
+ * scope. The only alternative for that drift is `delete` + re-export, which
+ * briefly removes the patch from the queue — any forward-import dependent
+ * then refuses the re-export until the deleted patch's siblings are
+ * 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.
+ * 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';

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

@@ -1,20 +1,19 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * `fireforge patch rename <name>` — relabels a patch's filename, manifest
- * `name`, and (optionally) `description` without rewriting the `.patch`
- * file body.
+ * `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).
+ * Companion to `re-export --files <subset>`. Re-export shrinks the body and
+ * `filesAffected` but leaves the patch's identity describing the pre-shrink
+ * scope. The only alternative for that drift is `delete` + re-export, which
+ * briefly removes the patch from the queue — any forward-import dependent
+ * then refuses the re-export until the deleted patch's siblings are
+ * 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.
+ * directory lock so concurrent exports cannot allocate the new filename, and
+ * a filesystem rename failure rolls back before the manifest is touched.
  */
 import { rename as fsRename } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -314,7 +313,7 @@ export async function patchRenameCommand(projectRoot, identifier, options = {})
         outro('Dry run complete — no changes made');
         return;
     }
-    if (decision === 'cancelled') {
+    if (decision === 'declined') {
         outro('Rename cancelled');
         return;
     }

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

@@ -241,14 +241,13 @@ async function commitReorderPlan(patchesDir, target, renameMap, anchorFilename,
                 .join('\n  ')}\nPass --force-unsafe to override.`, '--force-unsafe');
         }
         await renumberPatchesInManifest(patchesDir, currentRenameMap);
-        // Append the history record inside the lock so two concurrent
-        // reorders cannot interleave mutation and history writes, and so a
-        // crash between the rename and the history write cannot orphan a
-        // committed reorder with no audit trail. If the append itself
-        // fails (disk full, permissions), we warn but do not re-throw:
-        // the mutation has already succeeded and is not reversible, so
-        // surfacing the history failure as a command failure would
-        // mislead the caller.
+        // Append the history record inside the lock so two concurrent reorders
+        // cannot interleave mutation and history writes, and so a crash
+        // between the rename and the history write cannot orphan a committed
+        // reorder with no audit trail. An append failure (disk full,
+        // permissions) is warned but not re-thrown: the mutation has already
+        // succeeded and is not reversible, so surfacing it as a command
+        // failure would mislead.
         try {
             await appendHistory(patchesDir, buildHistoryEntry(currentRenameMap));
         }
@@ -334,7 +333,7 @@ export async function patchReorderCommand(projectRoot, identifier, options = {})
         outro('Dry run complete — no changes made');
         return;
     }
-    if (decision === 'cancelled') {
+    if (decision === 'declined') {
         outro('Reorder cancelled');
         return;
     }

package/dist/src/commands/patch/split-plan.js

@@ -9,9 +9,9 @@
 import { join } from 'node:path';
 import {} from '../../core/destructive.js';
 import { getDiffForFilesAgainstHead } from '../../core/git-diff.js';
-import { computeProjectedLintRegressions } from '../../core/lint-projection.js';
 import { extractAffectedFiles } from '../../core/patch-apply.js';
 import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, collectForwardImportEdges, detectNewFilesInDiff, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
+import { computeProjectedLintRegressions } from '../../core/patch-lint-projection.js';
 import { rewriteStagedDependencyOwners } from '../../core/patch-manifest.js';
 import { applyRenameMapToManifest, buildProjectedManifest } from '../../core/patch-policy.js';
 import { buildPatchSourceMetadata } from '../../core/patch-source-metadata.js';

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

@@ -1,16 +1,14 @@
 /**
  * `fireforge patch split <source> --files <p...> --name <n>` — moves files
- * out of an existing patch into a brand-new patch as one transaction
- * (field report A4).
+ * out of an existing patch into a brand-new patch as one transaction.
  *
- * Before this command, splitting a patch whose files have inbound
- * forward-imports required a precise manual order: re-point each
- * staged-dependency owner at a not-yet-created patch, shrink the source
- * via `re-export --files --allow-shrink`, then `export --order` — any
- * other order refused or needed `--force-unsafe`. Split performs the
- * shrink, the new-patch creation, and the dependent owner rewrites under
- * one patch-directory lock with rollback, validating only the final
- * projection.
+ * Splitting a patch whose files have inbound forward-imports otherwise
+ * requires a precise manual order: re-point each staged-dependency owner at
+ * a not-yet-created patch, shrink the source via
+ * `re-export --files --allow-shrink`, then `export --order` — any other
+ * order refuses or needs `--force-unsafe`. Split performs the shrink, the
+ * new-patch creation, and the dependent owner rewrites under one
+ * patch-directory lock with rollback, validating only the final projection.
  *
  * Preconditions match `re-export`: the engine worktree must currently
  * reflect both patches' content, because both bodies are regenerated from

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

@@ -1,17 +1,15 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * `fireforge patch split <source> --files <p...> --name <n>` — moves files
- * out of an existing patch into a brand-new patch as one transaction
- * (field report A4).
+ * out of an existing patch into a brand-new patch as one transaction.
  *
- * Before this command, splitting a patch whose files have inbound
- * forward-imports required a precise manual order: re-point each
- * staged-dependency owner at a not-yet-created patch, shrink the source
- * via `re-export --files --allow-shrink`, then `export --order` — any
- * other order refused or needed `--force-unsafe`. Split performs the
- * shrink, the new-patch creation, and the dependent owner rewrites under
- * one patch-directory lock with rollback, validating only the final
- * projection.
+ * Splitting a patch whose files have inbound forward-imports otherwise
+ * requires a precise manual order: re-point each staged-dependency owner at
+ * a not-yet-created patch, shrink the source via
+ * `re-export --files --allow-shrink`, then `export --order` — any other
+ * order refuses or needs `--force-unsafe`. Split performs the shrink, the
+ * new-patch creation, and the dependent owner rewrites under one
+ * patch-directory lock with rollback, validating only the final projection.
  *
  * Preconditions match `re-export`: the engine worktree must currently
  * reflect both patches' content, because both bodies are regenerated from
@@ -252,7 +250,7 @@ export async function patchSplitCommand(projectRoot, sourceId, options) {
         outro('Dry run complete — no changes made');
         return;
     }
-    if (decision === 'cancelled') {
+    if (decision === 'declined') {
         outro('Split cancelled');
         return;
     }

package/dist/src/commands/patch/staged-dependency-validate.js

@@ -2,14 +2,14 @@
 /**
  * Shape validation for `patch staged-dependency --add`.
  *
- * `--creates`/`--file` take engine-relative FILE paths and `--owner`
- * takes a patch FILENAME, but all three were accepted as arbitrary
- * strings — a `--creates <patch-name>` mixup produced a declaration
- * nothing could ever discharge, surfacing only later as a
- * `staged-dependency-unused` warning. Refusals here fire only on a clear
- * patch-name shape (slash-free values that end in `.patch` or match a
- * queue patch filename/stem): legitimate engine paths always contain a
- * `/`, so deep paths can never false-positive.
+ * `--creates`/`--file` take engine-relative FILE paths and `--owner` takes a
+ * patch FILENAME. Accepting all three as arbitrary strings lets a
+ * `--creates <patch-name>` mixup produce a declaration nothing can ever
+ * discharge, surfacing only later as a `staged-dependency-unused` warning.
+ * Refusals here fire only on a clear patch-name shape (slash-free values
+ * that end in `.patch` or match a queue patch filename/stem): legitimate
+ * engine paths always contain a `/`, so deep paths can never
+ * false-positive.
  */
 import { InvalidArgumentError } from '../../errors/base.js';
 import { warn } from '../../utils/logger.js';

package/dist/src/commands/patch/staged-dependency.js

@@ -9,6 +9,7 @@ import { mutatePatchMetadata } from '../../core/patch-export.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
+import { addWaitLockOption, resolveWaitLockSeconds } from '../../utils/options.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 import { validateStagedDependencyAdd } from './staged-dependency-validate.js';
 /** Joins the names of the missing flags for error attribution. */
@@ -269,6 +270,9 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
         if (countStagedEntries(after) === 0)
             return { unset: ['stagedDependencies'] };
         return { set: { stagedDependencies: after } };
+    }, {
+        waitLockSeconds: resolveWaitLockSeconds(options.waitLock),
+        command: 'patch staged-dependency',
     });
     if (!result) {
         throw new GeneralError(`Patch ${targetPatch.filename} disappeared from the manifest during the update. Re-run after investigating.`);
@@ -303,7 +307,7 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
  */
 export function registerPatchStagedDependency(parent, context) {
     const { getProjectRoot, withErrorHandling } = context;
-    parent
+    const command = parent
         .command('staged-dependency <name>')
         .description('Edit PatchMetadata.stagedDependencies on a single patch (no .patch body rewrite).')
         .option('--add', 'Add a staged dependency declaration')
@@ -317,8 +321,8 @@ export function registerPatchStagedDependency(parent, context) {
         .option('--owner <patch>', 'Exact later patch filename expected to create --creates')
         .option('--reason <text>', 'Human-readable rationale stored with the declaration')
         .option('--dry-run', 'Show what would change without writing')
-        .option('-y, --yes', 'Record scripted consent in the destructive-operation history log. This command never prompts; the flag exists for workflow uniformity with commands that do.')
-        .action(withErrorHandling(async (name, options) => {
+        .option('-y, --yes', 'Record scripted consent in the destructive-operation history log. This command never prompts; the flag exists for workflow uniformity with commands that do.');
+    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
         await patchStagedDependencyCommand(getProjectRoot(), name, options);
     }));
 }

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

@@ -1,14 +1,14 @@
 /**
- * `fireforge patch tier <name>` — sets or clears `PatchMetadata.tier` on
- * a single patch without rewriting the `.patch` file body.
+ * `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.
+ * Companion to `fireforge re-export <name> --tier <tier>`. Re-export is the
+ * right tool when the patch body itself needs regenerating; this subcommand
+ * covers the metadata-only adjustment, where the operator has discovered
+ * (from a `lint --per-patch` warning, say) 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.

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

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * `fireforge patch tier <name>` — sets or clears `PatchMetadata.tier` on
- * a single patch without rewriting the `.patch` file body.
+ * `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.
+ * Companion to `fireforge re-export <name> --tier <tier>`. Re-export is the
+ * right tool when the patch body itself needs regenerating; this subcommand
+ * covers the metadata-only adjustment, where the operator has discovered
+ * (from a `lint --per-patch` warning, say) 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.
@@ -20,7 +20,7 @@ import { updatePatchMetadata } from '../../core/patch-export.js';
 import { 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 { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /**
  * Runs the `patch tier` command: updates `PatchMetadata.tier` on the
@@ -75,7 +75,7 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
         outro('Dry run complete — no changes made');
         return;
     }
-    if (decision === 'cancelled') {
+    if (decision === 'declined') {
         outro('Cancelled — no changes made');
         return;
     }
@@ -84,7 +84,10 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
     // routes through `unsetFields` so TypeScript's exact optional types
     // do not have to carry an explicit `undefined` on the `tier` field.
     if (after !== undefined) {
-        await updatePatchMetadata(paths.patches, target.filename, { tier: after });
+        await updatePatchMetadata(paths.patches, target.filename, { tier: after }, [], {
+            waitLockSeconds: resolveWaitLockSeconds(options.waitLock),
+            command: 'patch tier',
+        });
     }
     else {
         await updatePatchMetadata(paths.patches, target.filename, {}, ['tier']);
@@ -115,14 +118,14 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
  */
 export function registerPatchTier(parent, context) {
     const { getProjectRoot, withErrorHandling } = context;
-    parent
+    const command = parent
         .command('tier <name>')
         .description('Set or clear PatchMetadata.tier on a single patch (no .patch body rewrite). Use --tier <branding> to set, --clear to remove.')
         .addOption(new Option('--tier <tier>', 'Force the tier override on the patch (only "branding" recognised)').choices(['branding']))
         .option('--clear', 'Remove the tier override (restores tier auto-detection)')
         .option('--dry-run', 'Show what would change without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .action(withErrorHandling(async (name, options) => {
+        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)');
+    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
         const { tier, ...rest } = options;
         await patchTierCommand(getProjectRoot(), name, {
             ...pickDefined(rest),

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

@@ -1,16 +1,17 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * Scan-less re-export adjacency advisory. A plain `re-export`
- * keeps the manifest's filesAffected unchanged, so a brand-new file an
- * author just created beside a patch's owned files is silently left out
- * of the refreshed body. This module detects such adjacent files, filters
- * out tool-managed paths (branding, furnace) so the notice names only
- * genuinely unmanaged candidates, and — under
+ * Scan-less re-export adjacency advisory.
+ *
+ * A plain `re-export` keeps the manifest's filesAffected unchanged, so a
+ * brand-new file an author just created beside a patch's owned files is
+ * silently left out of the refreshed body. This module detects such adjacent
+ * files, filters out tool-managed paths (branding, furnace) so the notice
+ * names only genuinely unmanaged candidates, and — under
  * `--refuse-adjacent-unmanaged` — lets the caller turn the notice into a
  * non-zero refusal.
  *
- * Split out of re-export.ts to keep that file inside the max-lines
- * budget; exports helpers consumed by re-export.ts, no registrar.
+ * Split out of re-export.ts to keep that file inside the max-lines budget;
+ * exports helpers consumed by re-export.ts, no registrar.
  */
 import { dirname, join } from 'node:path';
 import { isBrandingManagedPath } from '../core/branding.js';

package/dist/src/commands/re-export-bulk-scan.d.ts

@@ -2,15 +2,15 @@ import type { PatchesManifest } from '../types/commands/index.js';
 /** Loads and validates a `re-export --scan-files` assignment manifest. */
 export declare function loadScanFilesAssignments(manifestPath: string, manifest: PatchesManifest): Promise<Map<string, string[]>>;
 /**
- * Runtime enforcement of the dry-run purity contract: fingerprints
- * the engine tree and every patch artifact before and after `operation`, and
- * throws when a dry-run changed anything it promised only to inspect. This
- * turns any recurrence of the 0.40.0 "dry-run reverted a just-written export"
- * incident into a hard, named failure instead of silent data loss discovered
- * only when a later gate fails. The post-fingerprint runs whether `operation`
- * resolves or rejects — a dry-run that mutates state and THEN fails is exactly
- * the case where a rollback defect must not go unreported; a rejection with a
- * purity violation surfaces the violation with the original error as `cause`.
+ * Runtime enforcement of the dry-run purity contract: fingerprints the engine
+ * tree and every patch artifact before and after `operation`, and throws when
+ * a dry-run changed anything it promised only to inspect. That turns a
+ * "dry-run reverted a just-written export" incident into a hard, named
+ * failure instead of silent data loss discovered only when a later gate
+ * fails. The post-fingerprint runs whether `operation` resolves or rejects —
+ * a dry-run that mutates state and THEN fails is exactly the case where a
+ * rollback defect must not go unreported; a rejection with a purity
+ * violation surfaces the violation with the original error as `cause`.
  * No-op outside dry-run.
  */
 export declare function withDryRunPurityGuard<T>(engineDir: string, patchesDir: string, isDryRun: boolean, operation: () => Promise<T>): Promise<T>;

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

@@ -75,18 +75,19 @@ export async function loadScanFilesAssignments(manifestPath, manifest) {
 }
 /**
  * Fingerprints every piece of state a `re-export --dry-run` promises not to
- * disturb: the engine's commit + working-tree status (via the same generation
- * token `fireforge test` uses) and the byte content of every regular file
- * under `patches/` — ALL of them, not just the selected patches, because the
- * field incident was a dry-run of patch B reverting a just-written
- * export of patch A. A missing patches directory (ENOENT/ENOTDIR) fingerprints
- * as empty — there is nothing there to protect — but any other listing failure
- * (EACCES, EIO, …) throws: an unreadable directory is not evidence it is
- * empty, and treating it as such would let the guard silently vouch for state
- * it never saw (fail closed). The same rule covers an unmeasurable engine
- * generation and an unreadable individual patch file; a before-pass failure
- * aborts the dry run before it starts, since a guard that measured nothing
- * cannot vouch for anything.
+ * disturb: the engine's commit + working-tree status (via the same
+ * generation token `fireforge test` uses) and the byte content of every
+ * regular file under `patches/` — ALL of them, not just the selected
+ * patches, because a dry-run of patch B can revert a just-written export of
+ * patch A.
+ *
+ * A missing patches directory (ENOENT/ENOTDIR) fingerprints as empty — there
+ * is nothing there to protect — but any other listing failure (EACCES, EIO,
+ * …) throws: an unreadable directory is not evidence it is empty, and
+ * treating it as such lets the guard silently vouch for state it never saw.
+ * The same rule covers an unmeasurable engine generation and an unreadable
+ * individual patch file; a before-pass failure aborts the dry run before it
+ * starts, since a guard that measured nothing cannot vouch for anything.
  */
 async function fingerprintDryRunState(engineDir, patchesDir) {
     const fingerprint = new Map();
@@ -153,15 +154,15 @@ async function fingerprintDryRunState(engineDir, patchesDir) {
     return fingerprint;
 }
 /**
- * Runtime enforcement of the dry-run purity contract: fingerprints
- * the engine tree and every patch artifact before and after `operation`, and
- * throws when a dry-run changed anything it promised only to inspect. This
- * turns any recurrence of the 0.40.0 "dry-run reverted a just-written export"
- * incident into a hard, named failure instead of silent data loss discovered
- * only when a later gate fails. The post-fingerprint runs whether `operation`
- * resolves or rejects — a dry-run that mutates state and THEN fails is exactly
- * the case where a rollback defect must not go unreported; a rejection with a
- * purity violation surfaces the violation with the original error as `cause`.
+ * Runtime enforcement of the dry-run purity contract: fingerprints the engine
+ * tree and every patch artifact before and after `operation`, and throws when
+ * a dry-run changed anything it promised only to inspect. That turns a
+ * "dry-run reverted a just-written export" incident into a hard, named
+ * failure instead of silent data loss discovered only when a later gate
+ * fails. The post-fingerprint runs whether `operation` resolves or rejects —
+ * a dry-run that mutates state and THEN fails is exactly the case where a
+ * rollback defect must not go unreported; a rejection with a purity
+ * violation surfaces the violation with the original error as `cause`.
  * No-op outside dry-run.
  */
 export async function withDryRunPurityGuard(engineDir, patchesDir, isDryRun, operation) {