@hominis/fireforge 0.40.0 → 0.42.0

package/dist/src/commands/lint-per-run-checkjs.js

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Per-run checkJs program controller, shared by `lint --per-patch` and
+ * `re-export` (FORGE J1).
+ *
+ * The dominant fixed cost of patch lint is one `ts.createProgram` over the
+ * queue's patch-owned `.sys.mjs` files (~37 s on a 290-patch consumer
+ * queue). This controller builds that program at most ONCE per command
+ * invocation (lazily, promise-memoised) and lets callers slice per-patch
+ * findings out of the grouped result. Three levers keep the cost paid only
+ * when it buys something:
+ *
+ * - **Lazy build**: nothing is built until the first cache miss asks.
+ * - **Root scoping** (`rootScopePatches`): with `--patches <subset>` the
+ *   program's roots are only the subset's owned files; the full queue
+ *   stays resolvable, so cross-patch imports type-check identically while
+ *   unrelated files are never parsed (FORGE J1c).
+ * - **Warm-run probe**: run-level ("global") checkJs findings come only
+ *   from a missing `typescript` package or an unreadable shim — never
+ *   from the built program — so an all-cache-hit run satisfies "warm
+ *   never reports less than cold" (FORGE F5) via
+ *   `probeCheckJsGlobalIssues` instead of building anything.
+ */
+import { invokePatchLintCheckJsGrouped, probeCheckJsGlobalIssues, runCheckJsTestFilesGrouped, } from '../core/patch-lint-checkjs.js';
+import { isTestScriptFile, resolvePatchOwnedSysMjs, resolvePatchOwnedTestScripts, } from '../core/patch-lint-ownership.js';
+/**
+ * Builds the per-run checkJs program controller when `patchLint.checkJs` is
+ * enabled, or returns undefined. With `rootScopePatches` set (the
+ * `--patches` subset, by patch filename), the program roots at only the
+ * subset's owned files and the test-file pass runs only the subset's own
+ * scripts (head.js discovery still spans the queue).
+ */
+export function buildPerRunCheckJs(projectRoot, paths, config, ctx, rootScopePatches) {
+    const patchLint = config.patchLint;
+    if (!patchLint?.checkJs)
+        return undefined;
+    const testFilesEnabled = patchLint.checkJsTestFiles === true;
+    const ownedByPatch = new Map();
+    for (const entry of ctx.entries) {
+        const owned = new Set();
+        for (const f of entry.newFiles.keys()) {
+            if (f.endsWith('.sys.mjs'))
+                owned.add(f);
+            else if (testFilesEnabled && isTestScriptFile(f))
+                owned.add(f);
+        }
+        if (owned.size > 0)
+            ownedByPatch.set(entry.filename, owned);
+    }
+    const resolutionSet = new Set();
+    for (const files of ownedByPatch.values()) {
+        for (const f of files)
+            resolutionSet.add(f);
+    }
+    // The subset's owned files, split by program kind; undefined = full queue.
+    let scopedRoots;
+    if (rootScopePatches !== undefined) {
+        scopedRoots = new Set();
+        for (const [patchFilename, files] of ownedByPatch) {
+            if (!rootScopePatches.has(patchFilename))
+                continue;
+            for (const f of files)
+                scopedRoots.add(f);
+        }
+    }
+    // One build for the whole run: the queue-wide `.sys.mjs` program plus —
+    // when `patchLint.checkJsTestFiles` is on (FORGE G5) — one small
+    // script-scope program per patch-owned test file, merged by file.
+    const buildAll = async () => {
+        const sys = await invokePatchLintCheckJsGrouped(paths.engine, resolvePatchOwnedSysMjs(new Set(), ctx), patchLint, projectRoot, scopedRoots);
+        if (!testFilesEnabled)
+            return sys;
+        const tests = await runCheckJsTestFilesGrouped(paths.engine, resolvePatchOwnedTestScripts(new Set(), ctx), patchLint, projectRoot, scopedRoots);
+        const byFile = new Map(sys.byFile);
+        for (const [rel, list] of tests.byFile) {
+            byFile.set(rel, [...(byFile.get(rel) ?? []), ...list]);
+        }
+        return { byFile, global: [...sys.global, ...tests.global] };
+    };
+    // Memoise the *promise*, not the resolved value: under the bounded pool
+    // several patches can reach `getGrouped` before the first build resolves, and
+    // `??=` on the promise (a synchronous expression) guarantees a single build.
+    let groupedPromise;
+    const getGrouped = () => (groupedPromise ??= buildAll());
+    return {
+        ownedByPatch,
+        resolutionSet,
+        getGrouped,
+        getGlobal: async () => groupedPromise !== undefined
+            ? (await groupedPromise).global
+            : probeCheckJsGlobalIssues(patchLint, projectRoot),
+        sliceFor: async (files) => {
+            const grouped = await getGrouped();
+            const issues = [];
+            for (const rel of files) {
+                issues.push(...(grouped.byFile.get(rel) ?? []));
+            }
+            return issues;
+        },
+        isRelevant: (file) => file.endsWith('.sys.mjs') || (testFilesEnabled && isTestScriptFile(file)),
+    };
+}

package/dist/src/commands/lint.js

@@ -10,7 +10,7 @@ import { getAllDiff, getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { expandUntrackedDirectoryEntries, getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, getWorkingTreeStatus, } from '../core/git-status.js';
 import { clearPerPatchLintCache } from '../core/lint-cache.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
-import { buildPatchQueueContext, countNonBinaryDiffLines, lintExportedPatch, lintPatchQueue, lintPatchSize, } from '../core/patch-lint.js';
+import { buildPatchQueueContext, countNonBinaryDiffLines, formatPatchLintIssue, lintExportedPatch, lintPatchQueue, lintPatchSize, } from '../core/patch-lint.js';
 import { collectDiffFilePaths, tagLintIssues } from '../core/patch-lint-diff-tag.js';
 import { GeneralError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
@@ -361,13 +361,13 @@ async function reportLintOutcome(engineDir, issues, options) {
     const notices = issues.filter((i) => i.severity === 'notice');
     const tagPrefix = (issue) => sinceActive && issue.tag ? `[${issue.tag}] ` : '';
     for (const issue of notices) {
-        info(`${tagPrefix(issue)}NOTICE [${issue.check}] ${issue.file}: ${issue.message}`);
+        info(`${tagPrefix(issue)}NOTICE ${formatPatchLintIssue(issue)}`);
     }
     for (const issue of warnings) {
-        warn(`${tagPrefix(issue)}[${issue.check}] ${issue.file}: ${issue.message}`);
+        warn(`${tagPrefix(issue)}${formatPatchLintIssue(issue)}`);
     }
     for (const issue of errors) {
-        warn(`${tagPrefix(issue)}ERROR [${issue.check}] ${issue.file}: ${issue.message}`);
+        warn(`${tagPrefix(issue)}ERROR ${formatPatchLintIssue(issue)}`);
     }
     if (sinceActive) {
         const introducedErrors = errors.filter((i) => i.tag === 'introduced').length;

package/dist/src/commands/manifest.js

@@ -11,7 +11,7 @@ import { registerImport } from './import.js';
 import { registerLint } from './lint.js';
 import { registerPackage } from './package.js';
 import { registerPatch } from './patch/index.js';
-import { registerReExport } from './re-export.js';
+import { registerReExport } from './re-export-register.js';
 import { registerRebase } from './rebase.js';
 import { registerRegister } from './register.js';
 import { registerReset } from './reset.js';

package/dist/src/commands/package.js

@@ -3,10 +3,11 @@ import { Command } from 'commander';
 import { validateBrandOverride } from '../core/brand-validation.js';
 import { prepareBuildEnvironment } from '../core/build-prepare.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
-import { buildArtifactMismatchMessage, hasBuildArtifacts, machPackageCapture, } from '../core/mach.js';
+import { hasBuildArtifacts, machPackageCapture } from '../core/mach.js';
+import { assertBuildArtifacts } from '../core/mach-build-artifacts.js';
 import { explainMachError } from '../core/mach-error-hints.js';
 import { GeneralError } from '../errors/base.js';
-import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
+import { BuildError } from '../errors/build.js';
 import { pathExists } from '../utils/fs.js';
 import { error, info, intro, outro, verbose } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
@@ -27,20 +28,12 @@ export async function packageCommand(projectRoot, options) {
         throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
     }
     const buildCheck = await hasBuildArtifacts(paths.engine);
-    if (buildCheck.ambiguous && buildCheck.objDirs && buildCheck.objDirs.length > 0) {
-        throw new AmbiguousBuildArtifactsError(buildCheck.objDirs);
-    }
-    const mismatchMessage = buildArtifactMismatchMessage(paths.engine, buildCheck, 'Package');
-    if (mismatchMessage) {
-        throw new GeneralError(mismatchMessage);
-    }
-    if (!buildCheck.exists) {
-        const detail = buildCheck.objDir
-            ? `Build artifacts incomplete in ${buildCheck.objDir}/`
-            : 'No build artifacts found (obj-*/ directory missing)';
-        throw new GeneralError(`Packaging requires a completed build. ${detail}\n\n` +
-            "Run 'fireforge build' first, then rerun 'fireforge package'.");
-    }
+    assertBuildArtifacts(paths.engine, buildCheck, {
+        label: 'Package',
+        requirement: 'Packaging requires a completed build.',
+        remediation: "Run 'fireforge build' first, then rerun 'fireforge package'.",
+        requireExisting: true,
+    });
     // Log brand info if specified
     if (options.brand) {
         verbose(`Packaging with brand: ${options.brand}`);

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

@@ -18,7 +18,7 @@ import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-p
 import { GeneralError } 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 } from './patch-context.js';
 import { rebuildFilenameForOrder } from './reorder.js';
 /** True when `order` falls inside a configured reserved range. */
@@ -185,7 +185,7 @@ export async function patchCompactCommand(projectRoot, options = {}) {
         catch (historyError) {
             warn(`History log append failed after patch compact committed: ${toError(historyError).message}`);
         }
-    });
+    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch compact' });
     info(`Compacted ${renameMap.size} patch(es).`);
     outro('Compact complete');
 }
@@ -197,13 +197,13 @@ export async function patchCompactCommand(projectRoot, options = {}) {
  */
 export function registerPatchCompact(parent, context) {
     const { getProjectRoot, withErrorHandling } = context;
-    parent
+    const command = parent
         .command('compact')
         .description('Close ordinal gaps in the patch queue (range-aware when patchPolicy.ranges is configured)')
         .option('--dry-run', 'Show what would happen without writing')
         .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--force-unsafe', 'Bypass force-mode patchPolicy refusals')
-        .action(withErrorHandling(async (options) => {
+        .option('--force-unsafe', 'Bypass force-mode patchPolicy refusals');
+    addWaitLockOption(command).action(withErrorHandling(async (options) => {
         await patchCompactCommand(getProjectRoot(), pickDefined(options));
     }));
 }

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

@@ -15,7 +15,7 @@ import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { removePatchFileAndManifest } from '../../core/patch-manifest.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 delete` command: removes a patch file and its manifest
@@ -181,7 +181,7 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
         catch (historyError) {
             warn(`History log append failed after patch delete committed (${target.filename}): ${toError(historyError).message}`);
         }
-    });
+    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch delete' });
     info(`Deleted ${target.filename}.`);
     outro('Delete complete');
 }
@@ -193,13 +193,13 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
  */
 export function registerPatchDelete(parent, context) {
     const { getProjectRoot, withErrorHandling } = context;
-    parent
+    const command = parent
         .command('delete <name>')
         .description('Delete a patch from the queue (destructive)')
         .option('--dry-run', 'Show what would happen without writing')
         .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--force-unsafe', 'Bypass the refusal when a later patch depends on this patch (last resort)')
-        .action(withErrorHandling(async (name, options) => {
+        .option('--force-unsafe', 'Bypass the refusal when a later patch depends on this patch (last resort)');
+    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
         await patchDeleteCommand(getProjectRoot(), name, pickDefined(options));
     }));
 }

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

@@ -25,6 +25,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 { stringListOption } from '../../utils/options.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /**
  * Printed whenever `--add` lands a new check id. The waiver this command
@@ -197,8 +198,8 @@ export function registerPatchLintIgnore(parent, 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('--add <check-id>', 'Lint check ID to add to the patch lintIgnore list (repeatable)', ...stringListOption())
+        .option('--remove <check-id>', 'Lint check ID to remove from the patch lintIgnore list (repeatable)', ...stringListOption())
         .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)')

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

@@ -13,10 +13,12 @@
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { confirmDestructive } from '../../core/destructive.js';
 import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
+import { buildPatchQueueContext } from '../../core/patch-lint.js';
 import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
 import { enforcePatchPolicy } from '../../core/patch-policy.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { info, intro, outro, success } from '../../utils/logger.js';
+import { normalizePatchDisplayName } from '../../utils/validation.js';
 import { resolvePlacementPlan } from '../export-flow.js';
 import { runPatchLint } from '../export-shared.js';
 import { commitPatchSplit } from './split.js';
@@ -60,6 +62,13 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
     const category = options.category ?? source.category;
     const placementOptions = { order: options.order };
     const placement = await resolvePlacementPlan(paths.patches, placementOptions, category, newPatchName, config);
+    // The filename slug pipeline (resolvePlacementPlan above) strips redundant
+    // category prefixes; the manifest display name must agree with the bare-slug
+    // naming policy, exactly as `export --name` already does (FORGE G13/H4).
+    const displayName = normalizePatchDisplayName(newPatchName, category);
+    if (displayName !== newPatchName) {
+        info(`Patch name normalized: "${newPatchName}" → "${displayName}" (the filename carries the order and category prefix).`);
+    }
     const plan = {
         source,
         movedFiles,
@@ -69,7 +78,7 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
         placement,
         placementOptions,
         category,
-        name: newPatchName,
+        name: displayName,
         description: options.description ?? '',
         ownerRewrites: findOwnerRewriteHolders(manifest.patches, source.filename, movedSet),
         // Populated by runProjectedSplitLint below (forward edges into the new patch).
@@ -77,10 +86,16 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
     };
     // Per-patch lint both projected bodies, threading the source patch's
     // tier/lintIgnore so an intentional-advisory patch can still move files.
+    // The whole-queue context (built once, with the config so it carries the
+    // 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 (FORGE I3).
+    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, undefined, ignoreChecks, source.tier);
-    await runPatchLint(paths.engine, movedFiles, movedDiff, config, options.skipLint, undefined, ignoreChecks, source.tier);
-    const { conflicts, stagedDependencyAdditions } = await runProjectedSplitLint(paths.patches, plan);
+    await runPatchLint(paths.engine, remainingFiles, remainingDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, source.tier);
+    await runPatchLint(paths.engine, movedFiles, movedDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, source.tier);
+    const { conflicts, stagedDependencyAdditions } = runProjectedSplitLint(plan, patchQueueCtx);
     plan.stagedDependencyAdditions = stagedDependencyAdditions;
     const newMetadata = buildNewPatchMetadata(plan, config);
     enforcePatchPolicy({
@@ -88,6 +103,9 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
         manifest: projectSplitManifest(manifest, plan, newMetadata),
         command: 'patch move-files --create',
         forceUnsafe: options.forceUnsafe === true,
+        hints: {
+            'description-required': 'Pass --description "<text>" (or -d) on this command to set the created patch\'s description.',
+        },
     });
     const decision = await confirmDestructive({
         operation: 'patch-move-files-create',

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

@@ -18,7 +18,7 @@ import { join } from 'node:path';
 import { appendHistory, 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, lintPatchQueue, } from '../../core/patch-lint.js';
+import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, collectForwardImportEdges, detectNewFilesInDiff, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, savePatchesManifest, validatePatchesManifest, } from '../../core/patch-manifest.js';
 import { extractNewFileContentFromDiff } from '../../core/patch-transform.js';
@@ -26,6 +26,7 @@ import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
 import { readText, writeText } from '../../utils/fs.js';
 import { info, outro, success, warn } from '../../utils/logger.js';
+import { resolveWaitLockSeconds } from '../../utils/options.js';
 import { runPatchLint } from '../export-shared.js';
 import { buildSplitDiff, findOwnerRewriteHolders, mergeStagedForwardImports, rewriteSplitOwners, } from './split-plan.js';
 function projectEntryBody(diff) {
@@ -41,9 +42,8 @@ function projectEntryBody(diff) {
  * to live in the same patch as the moved file gains a forward edge when the
  * target is later-ordered). Reports only regressions the move itself adds.
  */
-async function runProjectedMoveLint(patchesDir, plan) {
+function runProjectedMoveLint(plan, baseCtx) {
     const movedSet = new Set(plan.movedFiles);
-    const baseCtx = await buildPatchQueueContext(patchesDir);
     const entries = baseCtx.entries.map((entry) => {
         let metadata = entry.metadata;
         if (metadata) {
@@ -93,7 +93,7 @@ async function runProjectedMoveLint(patchesDir, plan) {
         ? null
         : {
             reason: `move would introduce ${regressions.length} cross-patch lint error(s)`,
-            details: regressions.map((i) => `[${i.check}] ${i.file}: ${i.message}`),
+            details: regressions.map(formatPatchLintIssue),
         };
     return { conflicts, stagedDependencyAdditions };
 }
@@ -103,7 +103,7 @@ async function runProjectedMoveLint(patchesDir, plan) {
  * owner rewrites + auto-declared forward imports). Rolled back in reverse
  * order on any failure.
  */
-async function commitMoveInto(patchesDir, plan) {
+async function commitMoveInto(patchesDir, plan, waitLockSeconds) {
     await withPatchDirectoryLock(patchesDir, async () => {
         const manifest = await loadPatchesManifest(patchesDir);
         if (!manifest)
@@ -184,7 +184,7 @@ async function commitMoveInto(patchesDir, plan) {
             }
             throw error;
         }
-    });
+    }, { waitLockSeconds, command: 'patch move-files' });
 }
 /**
  * Plans, lints, confirms, and commits a file-ownership move into an
@@ -196,8 +196,12 @@ export async function runMoveFilesInto(args) {
     const sourceDiff = await buildSplitDiff(enginePath, sourceAfter, 'remaining', source.filename);
     const targetDiff = await buildSplitDiff(enginePath, targetAfter, 'moved', target.filename);
     // Per-patch lint both projected bodies with each patch's own waivers.
-    await runPatchLint(enginePath, sourceAfter, sourceDiff, args.config, options.skipLint, undefined, source.lintIgnore ? new Set(source.lintIgnore) : undefined, source.tier);
-    await runPatchLint(enginePath, targetAfter, targetDiff, args.config, options.skipLint, undefined, target.lintIgnore ? new Set(target.lintIgnore) : undefined, target.tier);
+    // The whole-queue context (built once, with the config for committed-gate
+    // parity) resolves cross-patch imports and sibling head.js harness roots
+    // instead of linting each projected body blind (FORGE I3).
+    const patchQueueCtx = await buildPatchQueueContext(patchesDir, args.config);
+    await runPatchLint(enginePath, sourceAfter, sourceDiff, args.config, options.skipLint, patchQueueCtx, source.lintIgnore ? new Set(source.lintIgnore) : undefined, source.tier);
+    await runPatchLint(enginePath, targetAfter, targetDiff, args.config, options.skipLint, patchQueueCtx, target.lintIgnore ? new Set(target.lintIgnore) : undefined, target.tier);
     const manifest = await loadPatchesManifest(patchesDir);
     const plan = {
         source,
@@ -210,7 +214,7 @@ export async function runMoveFilesInto(args) {
         ownerRewrites: findOwnerRewriteHolders(manifest?.patches ?? [], source.filename, new Set(files)),
         stagedDependencyAdditions: new Map(),
     };
-    const { conflicts, stagedDependencyAdditions } = await runProjectedMoveLint(patchesDir, plan);
+    const { conflicts, stagedDependencyAdditions } = runProjectedMoveLint(plan, patchQueueCtx);
     plan.stagedDependencyAdditions = stagedDependencyAdditions;
     const decision = await confirmDestructive({
         operation: 'patch-move-files',
@@ -236,7 +240,7 @@ export async function runMoveFilesInto(args) {
         outro('Move cancelled');
         return;
     }
-    await commitMoveInto(patchesDir, plan);
+    await commitMoveInto(patchesDir, plan, resolveWaitLockSeconds(options.waitLock));
     success(`Moved ${files.length} file(s) from ${source.filename} to ${target.filename}`);
     if (plan.ownerRewrites.length > 0) {
         info(`Re-pointed staged-dependency owners in: ${plan.ownerRewrites.join(', ')}`);

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

@@ -13,7 +13,7 @@ import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-ma
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, note, warn } from '../../utils/logger.js';
-import { commanderArgParser, pickDefined } from '../../utils/options.js';
+import { addWaitLockOption, commanderArgParser, pickDefined } from '../../utils/options.js';
 import { patchMoveFilesCreateCommand } from './move-files-create.js';
 import { runMoveFilesInto } from './move-files-into.js';
 function collectOption(value, previous) {
@@ -161,7 +161,7 @@ export async function patchMoveFilesCommand(projectRoot, fromIdentifier, toIdent
  */
 export function registerPatchMoveFiles(parent, context) {
     const { getProjectRoot, withErrorHandling } = context;
-    parent
+    const command = parent
         .command('move-files <from> <to>')
         .description('Preview the re-export commands needed to move file ownership between patches, ' +
         'or create the target patch and move the files in one transaction with --create --order <n>.')
@@ -175,12 +175,12 @@ export function registerPatchMoveFiles(parent, context) {
         return n;
     }))
         .option('--category <category>', "Category for the created patch (default: the source patch's)")
-        .option('--description <desc>', 'Description for the created patch')
+        .option('-d, --description <desc>', 'Description for the created patch')
         .option('--dry-run', 'Show what would happen without writing')
         .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
         .option('--force-unsafe', 'Bypass projected-lint refusals')
-        .option('--skip-lint', 'Skip per-patch lint of the projected bodies')
-        .action(withErrorHandling(async (from, to, options) => {
+        .option('--skip-lint', 'Skip per-patch lint of the projected bodies');
+    addWaitLockOption(command).action(withErrorHandling(async (from, to, options) => {
         await patchMoveFilesCommand(getProjectRoot(), from, to, {
             ...pickDefined({
                 file: options.file,
@@ -192,6 +192,7 @@ export function registerPatchMoveFiles(parent, context) {
                 yes: options.yes,
                 forceUnsafe: options.forceUnsafe,
                 skipLint: options.skipLint,
+                waitLock: options.waitLock,
             }),
         });
     }));

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

@@ -20,11 +20,11 @@ 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.
+ * (name, category, order, description) 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)
+ * @param options - Command options (at least one change flag required)
  */
 export declare function patchRenameCommand(projectRoot: string, identifier: string, options?: PatchRenameOptions): Promise<void>;
 /**