@hominis/fireforge 0.45.0 → 0.46.0

package/dist/src/commands/furnace/validation-output.d.ts

@@ -1,4 +1,4 @@
-import type { getFurnacePaths } from '../../core/furnace-config.js';
+import type { FurnacePaths } from '../../core/furnace-config.js';
 import type { DryRunAction, FurnaceConfig, ValidationIssue } from '../../types/furnace.js';
 import { type SpinnerHandle } from '../../utils/logger.js';
 /**
@@ -16,15 +16,27 @@ export type ValidationResult = {
     componentCount: number;
     skippedValidationCount: number;
 };
+export interface RunDeployValidationOptions {
+    /** Active spinner handle for progress display. */
+    validateSpinner: SpinnerHandle;
+    /** Optional component name (validates all if omitted). */
+    name: string | undefined;
+    /** Loaded Furnace configuration. */
+    config: FurnaceConfig;
+    /** Resolved Furnace workspace paths. */
+    furnacePaths: FurnacePaths;
+    /** Names of components whose apply step failed. */
+    failedComponents: Set<string>;
+    /** Whether deploy is running in dry-run mode. */
+    isDryRun: boolean;
+    /** Root directory of the project. */
+    projectRoot: string;
+    /** Projected actions of a dry run, used to filter projected issues. */
+    dryRunActions?: DryRunAction[] | undefined;
+}
 /**
  * Runs the validation phase of a furnace deploy, checking all or a single component.
- * @param validateSpinner - Active spinner handle for progress display
- * @param name - Optional component name (validates all if omitted)
- * @param config - Loaded Furnace configuration
- * @param furnacePaths - Resolved Furnace workspace paths
- * @param failedComponents - Names of components whose apply step failed
- * @param isDryRun - Whether deploy is running in dry-run mode
- * @param projectRoot - Root directory of the project
+ * @param options - See {@link RunDeployValidationOptions}
  * @returns Validation counts, or `done: true` if the caller should early-return
  */
-export declare function runDeployValidation(validateSpinner: SpinnerHandle, name: string | undefined, config: FurnaceConfig, furnacePaths: ReturnType<typeof getFurnacePaths>, failedComponents: Set<string>, isDryRun: boolean, projectRoot: string, dryRunActions?: DryRunAction[]): Promise<ValidationResult>;
+export declare function runDeployValidation(options: RunDeployValidationOptions): Promise<ValidationResult>;

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

@@ -56,16 +56,11 @@ function resolveNamedValidationTarget(name, config, furnacePaths) {
 }
 /**
  * Runs the validation phase of a furnace deploy, checking all or a single component.
- * @param validateSpinner - Active spinner handle for progress display
- * @param name - Optional component name (validates all if omitted)
- * @param config - Loaded Furnace configuration
- * @param furnacePaths - Resolved Furnace workspace paths
- * @param failedComponents - Names of components whose apply step failed
- * @param isDryRun - Whether deploy is running in dry-run mode
- * @param projectRoot - Root directory of the project
+ * @param options - See {@link RunDeployValidationOptions}
  * @returns Validation counts, or `done: true` if the caller should early-return
  */
-export async function runDeployValidation(validateSpinner, name, config, furnacePaths, failedComponents, isDryRun, projectRoot, dryRunActions) {
+export async function runDeployValidation(options) {
+    const { validateSpinner, name, config, furnacePaths, failedComponents, isDryRun, projectRoot, dryRunActions, } = options;
     let totalErrors = 0;
     let totalWarnings = 0;
     let componentCount = 0;

package/dist/src/commands/import.js

@@ -437,16 +437,9 @@ export function registerImport(program, { getProjectRoot, withErrorHandling }) {
         // prompt, so a scripted import can run unattended while the integrity
         // refusal stays armed — which is the guard you actually want in CI.
         .option('-y, --yes', 'Answer the drift prompt non-interactively. Unlike --force, this does NOT waive the patch-integrity gate.')
-        .option('--until <patch>', 'Apply patches only up to and including this patch (alias: --stop-at)')
-        .option('--stop-at <patch>', 'Alias for --until')
+        .option('--until <patch>', 'Apply patches only up to and including this patch')
         .option('--dry-run', 'Preview which patches would be applied without modifying the engine')
         .action(withErrorHandling(async (options) => {
-        // Accept both spellings; --until wins when both are passed.
-        const merged = { ...options };
-        if (merged.until === undefined && merged.stopAt !== undefined) {
-            merged.until = merged.stopAt;
-        }
-        delete merged.stopAt;
-        await importCommand(getProjectRoot(), pickDefined(merged));
+        await importCommand(getProjectRoot(), pickDefined(options));
     }));
 }

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

@@ -1,5 +1,5 @@
-import { getProjectPaths } from '../core/config.js';
 import type { LintCommandOptions } from '../types/commands/index.js';
+import type { ProjectPaths } from '../types/config.js';
 /**
  * Lints each patch in the queue as its own isolated diff, honouring
  * per-patch `lintIgnore` entries. Cross-patch rules still run once over
@@ -7,4 +7,4 @@ import type { LintCommandOptions } from '../types/commands/index.js';
  * With `options.patches` set, only the named subset is linted (and the
  * queue-level findings are scoped to files those patches touch).
  */
-export declare function lintPerPatch(projectRoot: string, paths: ReturnType<typeof getProjectPaths>, options?: LintCommandOptions): Promise<void>;
+export declare function lintPerPatch(projectRoot: string, paths: ProjectPaths, options?: LintCommandOptions): Promise<void>;

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../core/config.js';
+import { loadConfig } from '../core/config.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { withPrivateGitIndex } from '../core/git-readonly-index.js';
 import { buildPatchQueueContext, countNonBinaryDiffLines, formatPatchLintIssue, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
@@ -169,7 +169,15 @@ async function applyPerPatchResults(subset, results, issues, checkJs, cache) {
             issues.push(...(await checkJs.getGlobal()));
         }
         if (result.cacheWrite && cache) {
-            setCachedPerPatchLintIssues(cache, patch.filename, result.cacheWrite.key, result.rawIssues, result.suppressedIssues, result.lineCount, result.cacheWrite.lintIgnore);
+            setCachedPerPatchLintIssues({
+                cache,
+                patchFilename: patch.filename,
+                key: result.cacheWrite.key,
+                issues: result.rawIssues,
+                suppressed: result.suppressedIssues,
+                lineCount: result.lineCount,
+                lintIgnore: result.cacheWrite.lintIgnore,
+            });
             totals.cacheDirty = true;
         }
         for (const issue of result.rawIssues) {
@@ -267,7 +275,7 @@ function reportPerPatchOutcome(issues, linted, skipped, options) {
 /**
  * Resolves the `--patches <name…>` subset filter against the manifest,
  * matching each requested name tolerantly (exact filename, filename ±
- * `.patch`, or the manifest `name` field). Throws listing the available
+ * `.patch`, the bare order number, or the manifest `name` field). Throws listing the available
  * patches when a requested name matches none, so a typo fails loud rather
  * than silently linting nothing.
  */
@@ -278,7 +286,14 @@ function selectPatchSubset(manifest, requested) {
         .filter((entry) => entry.length > 0);
     const patchAliases = (p) => {
         const aliases = new Set([p.filename, p.filename.replace(/\.patch$/, ''), p.name]);
+        // The bare order number, both as the manifest records it and as the
+        // filename spells it (`2` and `002`). The refusal message offers stems,
+        // and an operator reading `102-ui-canvas-tiles.patch` in a lint finding
+        // reaches for `102` first.
+        aliases.add(String(p.order));
         const match = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(p.filename);
+        if (match?.[1])
+            aliases.add(match[1]);
         if (match?.[2] && match[3]) {
             aliases.add(`${match[2]}-${match[3]}`);
             aliases.add(match[3]);
@@ -296,7 +311,7 @@ function selectPatchSubset(manifest, requested) {
         if (found.length === 0) {
             const available = manifest.patches.map((p) => p.filename).join(', ');
             throw new GeneralError(`No patch in the queue matches "${name}". In --per-patch mode, positional arguments ` +
-                `and --patches select patches (filename, stem, manifest name, or slug) — not engine ` +
+                `and --patches select patches (filename, stem, order number, manifest name, or slug) — not engine ` +
                 `files; drop --per-patch to lint engine paths. Available patches: ${available}`);
         }
         for (const p of found) {

package/dist/src/commands/lint-per-run-checkjs.d.ts

@@ -20,10 +20,10 @@
  *   less than cold" via `probeCheckJsGlobalIssues` instead of building
  *   anything.
  */
-import type { getProjectPaths, loadConfig } from '../core/config.js';
 import { type GroupedCheckJsResult } from '../core/patch-lint-checkjs.js';
 import type { PatchQueueContext } from '../core/patch-lint-cross.js';
 import type { PatchLintIssue } from '../types/commands/index.js';
+import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
 /**
  * Queue-wide checkJs program built once per run and sliced per patch, so a
  * single type regression surfaces once against its owning patch instead of
@@ -61,4 +61,4 @@ export interface PerRunCheckJs {
  * subset's owned files and the test-file pass runs only the subset's own
  * scripts (head.js discovery still spans the queue).
  */
-export declare function buildPerRunCheckJs(projectRoot: string, paths: ReturnType<typeof getProjectPaths>, config: Awaited<ReturnType<typeof loadConfig>>, ctx: PatchQueueContext, rootScopePatches?: ReadonlySet<string>): PerRunCheckJs | undefined;
+export declare function buildPerRunCheckJs(projectRoot: string, paths: ProjectPaths, config: FireForgeConfig, ctx: PatchQueueContext, rootScopePatches?: ReadonlySet<string>): PerRunCheckJs | undefined;

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

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { type PatchQueueContext } from '../core/patch-lint.js';
 import type { CommandContext } from '../types/cli.js';
 import type { LintCommandOptions, PatchLintIssue } from '../types/commands/index.js';
 /**
@@ -34,7 +35,7 @@ export interface AggregateLintIgnoreResult {
  * @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;
+export declare function applyAggregateLintIgnoreSuppression(issues: PatchLintIssue[], ctx: 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

@@ -495,7 +495,7 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         .option('--since <git-rev>', 'Tag issues as [introduced] or [cumulative] based on whether the file changed since <git-rev> (e.g. HEAD, a branch, a SHA)')
         .option('--only-introduced', 'Fail only on issues tagged [introduced] (requires --since). Cumulative errors still print but do not set a non-zero exit.')
         .option('--per-patch', "Lint each patch in the queue as its own isolated diff. Rescopes patch-size rules so they fire against individual patches rather than the aggregate. Honours each patch's `lintIgnore` entries.")
-        .option('--patches <names...>', 'With --per-patch, lint only the named patches. Accepts repeated flags, comma lists, full filenames/stems, manifest names, category-prefixed slugs, or bare slugs. Positional arguments after --per-patch are treated the same way.')
+        .option('--patches <names...>', 'With --per-patch, lint only the named patches. Accepts repeated flags, comma lists, full filenames/stems, bare order numbers, manifest names, category-prefixed slugs, or bare slugs. Positional arguments after --per-patch are treated the same way.')
         .option('--max-warnings <n>', 'Fail when lint reports more than <n> warning(s); use 0 for warning-clean release gates.')
         .option('--no-cache', 'Bypass per-patch lint result cache reads and writes.')
         .option('--report <path>', 'With --per-patch, write a machine-readable JSON report (per-patch size metrics, tier, thresholds, issues, and lintIgnore-suppressed issues) to <path>.')

package/dist/src/commands/manifest.js

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

package/dist/src/commands/package.js

@@ -8,6 +8,7 @@ import { hasBuildArtifacts, machPackageCapture } from '../core/mach.js';
 import { assertBuildArtifacts } from '../core/mach-build-artifacts.js';
 import { explainMachError } from '../core/mach-error-hints.js';
 import { BuildError } from '../errors/build.js';
+import { elapsedSince } from '../utils/elapsed.js';
 import { error, info, intro, outro, verbose } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 /**
@@ -54,10 +55,7 @@ export async function packageCommand(projectRoot, options) {
     catch (error) {
         throw new BuildError('Package process failed to start', 'mach package', error instanceof Error ? error : undefined);
     }
-    const duration = Date.now() - startTime;
-    const minutes = Math.floor(duration / 60000);
-    const seconds = Math.floor((duration % 60000) / 1000);
-    const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+    const timeStr = elapsedSince(startTime);
     if (result.exitCode !== 0) {
         error(`Packaging failed after ${timeStr}`);
         const combinedOutput = `${result.stdout}\n${result.stderr}`;

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

@@ -11,14 +11,16 @@
  */
 import { Command } from 'commander';
 import { loadConfig } from '../../core/config.js';
-import { appendHistory, confirmDestructive } from '../../core/destructive.js';
+import { confirmDestructive } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, renumberPatchesInManifest, } from '../../core/patch-manifest.js';
 import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
 import { GeneralError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
 import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
+import { renameMapsEqual } from '../patch-rename-map.js';
 import { requirePatchQueue } from './patch-context.js';
 import { rebuildFilenameForOrder } from './reorder.js';
 /** True when `order` falls inside a configured reserved range. */
@@ -139,14 +141,8 @@ export async function patchCompactCommand(projectRoot, options = {}) {
         dryRun: options.dryRun === true,
         unsafeOverride: options.forceUnsafe === true,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
+    if (!proceedAfterDecision(decision, 'Compact cancelled'))
         return;
-    }
-    if (decision === 'declined') {
-        outro('Compact cancelled');
-        return;
-    }
     await withPatchDirectoryLock(paths.patches, async () => {
         const currentManifest = await loadPatchesManifest(paths.patches);
         if (!currentManifest) {
@@ -157,6 +153,14 @@ export async function patchCompactCommand(projectRoot, options = {}) {
             info('Patch queue was compacted by another process. Nothing to do.');
             return;
         }
+        // The operator confirmed a specific plan. A queue that changed between
+        // the prompt and the lock (an export landing a new patch, a delete)
+        // yields a different plan whose renames were never shown — refuse
+        // rather than commit them under a history entry that says "ok", the
+        // same gate `patch reorder` applies.
+        if (!renameMapsEqual(renameMap, currentRenameMap)) {
+            throw new GeneralError('Patch queue changed while waiting for confirmation. Re-run compact to recompute the rename plan.');
+        }
         enforcePatchPolicy({
             config,
             manifest: applyRenameMapToManifest(currentManifest, currentRenameMap),
@@ -179,12 +183,7 @@ export async function patchCompactCommand(projectRoot, options = {}) {
             ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
             result: 'ok',
         };
-        try {
-            await appendHistory(paths.patches, historyEntry);
-        }
-        catch (historyError) {
-            warn(`History log append failed after patch compact committed: ${toError(historyError).message}`);
-        }
+        await appendHistoryBestEffort(paths.patches, historyEntry, `patch compact committed`);
     }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch compact' });
     info(`Compacted ${renameMap.size} patch(es).`);
     outro('Compact complete');

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

@@ -9,13 +9,14 @@
  */
 import { basename } from 'node:path';
 import { Command } from 'commander';
-import { appendHistory, confirmDestructive } from '../../core/destructive.js';
+import { confirmDestructive } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 import { buildPatchQueueContext, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, isForwardImportableFile, } from '../../core/patch-lint.js';
 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 { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /**
  * Runs the `patch delete` command: removes a patch file and its manifest
@@ -138,14 +139,8 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
         unsafeOverride: options.forceUnsafe === true,
         conflicts,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
+    if (!proceedAfterDecision(decision, 'Delete cancelled'))
         return;
-    }
-    if (decision === 'declined') {
-        outro('Delete cancelled');
-        return;
-    }
     // Proceed: remove under the patch directory lock so concurrent exports
     // cannot race us into the same manifest row. The history append lives
     // inside the same lock so two concurrent deletes cannot interleave history
@@ -156,22 +151,17 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     // failure to the caller would mislead.
     await withPatchDirectoryLock(paths.patches, async () => {
         await removePatchFileAndManifest(paths.patches, target.filename);
-        try {
-            await appendHistory(paths.patches, {
-                operation: 'patch-delete',
-                args: {
-                    filename: target.filename,
-                    order: target.order,
-                    filesAffected: target.filesAffected,
-                },
-                ...(options.yes === true ? { yes: true } : {}),
-                ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-                result: 'ok',
-            });
-        }
-        catch (historyError) {
-            warn(`History log append failed after patch delete committed (${target.filename}): ${toError(historyError).message}`);
-        }
+        await appendHistoryBestEffort(paths.patches, {
+            operation: 'patch-delete',
+            args: {
+                filename: target.filename,
+                order: target.order,
+                filesAffected: target.filesAffected,
+            },
+            ...(options.yes === true ? { yes: true } : {}),
+            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
+            result: 'ok',
+        }, `patch delete committed (${target.filename})`);
     }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch delete' });
     info(`Deleted ${target.filename}.`);
     outro('Delete complete');

package/dist/src/commands/patch/entry-projection.d.ts

@@ -0,0 +1,13 @@
+import type { PatchQueueEntry } from '../../core/patch-lint.js';
+/**
+ * Projects a rewritten patch body into the three fields cross-patch lint reads
+ * off a queue entry.
+ *
+ * `patch split` and `patch move-files` each had a byte-identical copy of this
+ * (`buildEntryProjection` / `projectEntryBody`). Both feed the same linter, so
+ * a change to what the projection carries has to reach both or the two
+ * commands start refusing different things for the same queue.
+ * @param diff - The rewritten patch body.
+ * @returns The diff plus its derived new-file and modified-file projections.
+ */
+export declare function projectEntryBody(diff: string): Pick<PatchQueueEntry, 'diff' | 'newFiles' | 'createdFiles' | 'modifiedFileAdditions'>;

package/dist/src/commands/patch/entry-projection.js

@@ -0,0 +1,24 @@
+import { buildModifiedFileAdditionsFromDiff } from '../../core/patch-lint.js';
+import { detectNewFilesInDiff } from '../../core/patch-lint-diff.js';
+import { buildNewFileTextProjection } from '../../core/patch-transform.js';
+/**
+ * Projects a rewritten patch body into the three fields cross-patch lint reads
+ * off a queue entry.
+ *
+ * `patch split` and `patch move-files` each had a byte-identical copy of this
+ * (`buildEntryProjection` / `projectEntryBody`). Both feed the same linter, so
+ * a change to what the projection carries has to reach both or the two
+ * commands start refusing different things for the same queue.
+ * @param diff - The rewritten patch body.
+ * @returns The diff plus its derived new-file and modified-file projections.
+ */
+export function projectEntryBody(diff) {
+    const newFiles = buildNewFileTextProjection(diff);
+    return {
+        diff,
+        newFiles,
+        // Body-kind agnostic: a binary creation is still a creation.
+        createdFiles: detectNewFilesInDiff(diff),
+        modifiedFileAdditions: buildModifiedFileAdditionsFromDiff(diff),
+    };
+}

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

@@ -21,13 +21,6 @@
 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.
@@ -44,4 +37,3 @@ 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

@@ -20,12 +20,13 @@
  * runs `--add` and `--remove` back-to-back.
  */
 import { Command } from 'commander';
-import { appendHistory, confirmDestructive } from '../../core/destructive.js';
+import { confirmDestructive } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 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, stringListOption, } from '../../utils/options.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /**
  * Printed whenever `--add` lands a new check id. The waiver this command
@@ -65,7 +66,7 @@ function applyMode(existing, mode, values) {
  * `info()` / dry-run / history args. Exported for unit-testing the
  * message format directly without mocking the logger transport.
  */
-export function describeChange(before, after, mode, values) {
+function describeChange(before, after, mode, values) {
     const beforeSet = new Set(before);
     const afterSet = new Set(after);
     if (mode === 'clear') {
@@ -135,17 +136,11 @@ export async function patchLintIgnoreCommand(projectRoot, identifier, options =
         yes: options.yes === true,
         dryRun: isDryRun,
     });
-    if (decision === 'dry-run') {
-        if (addsNewIds) {
-            warn(LINT_IGNORE_REVIEW_WARNING);
-        }
-        outro('Dry run complete — no changes made');
-        return;
+    if (decision === 'dry-run' && addsNewIds) {
+        warn(LINT_IGNORE_REVIEW_WARNING);
     }
-    if (decision === 'declined') {
-        outro('Cancelled — no changes made');
+    if (!proceedAfterDecision(decision, 'Cancelled — no changes made'))
         return;
-    }
     const result = await mutatePatchMetadata(paths.patches, target.filename, (existing) => {
         const next = applyMode(existing.lintIgnore ?? [], mode, values);
         // Either set the new list when non-empty or unset the field
@@ -167,23 +162,18 @@ export async function patchLintIgnoreCommand(projectRoot, identifier, options =
     if (mode === 'add' && projected.length > existing.length) {
         warn(LINT_IGNORE_REVIEW_WARNING);
     }
-    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}`);
-    }
+    await appendHistoryBestEffort(paths.patches, {
+        operation: 'patch-lint-ignore',
+        args: {
+            filename: target.filename,
+            mode,
+            values: [...values],
+            before: existing,
+            after: projected,
+        },
+        ...(options.yes === true ? { yes: true } : {}),
+        result: 'ok',
+    }, `patch lint-ignore committed (${target.filename})`);
     outro('Patch lint-ignore complete');
 }
 /**

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

@@ -15,10 +15,12 @@ import { assertConfirmationAvailable, confirmDestructive } from '../../core/dest
 import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { buildPatchQueueContext } from '../../core/patch-lint.js';
 import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
+import { formatPatchOrder } from '../../core/patch-parse.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 { proceedAfterDecision } from '../destructive-decision.js';
 import { resolvePlacementPlan } from '../export-flow.js';
 import { runPatchLint } from '../export-shared.js';
 import { commitPatchSplit } from './split.js';
@@ -95,8 +97,26 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
     // 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);
-    await runPatchLint(paths.engine, movedFiles, movedDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, source.tier);
+    await runPatchLint({
+        engineDir: paths.engine,
+        filesAffected: remainingFiles,
+        diffContent: remainingDiff,
+        config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks,
+        patchTier: source.tier,
+    });
+    await runPatchLint({
+        engineDir: paths.engine,
+        filesAffected: movedFiles,
+        diffContent: movedDiff,
+        config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks,
+        patchTier: source.tier,
+    });
     const { conflicts, stagedDependencyAdditions } = runProjectedSplitLint(plan, patchQueueCtx);
     plan.stagedDependencyAdditions = stagedDependencyAdditions;
     const newMetadata = buildNewPatchMetadata(plan, config);
@@ -118,16 +138,10 @@ export async function patchMoveFilesCreateCommand(projectRoot, fromIdentifier, n
         unsafeOverride: options.forceUnsafe === true,
         conflicts,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
+    if (!proceedAfterDecision(decision, 'Move cancelled'))
         return;
-    }
-    if (decision === 'declined') {
-        outro('Move cancelled');
-        return;
-    }
     await commitPatchSplit(paths.patches, plan, newMetadata, options, config);
-    success(`Created ${placement.newFilename} (order ${String(placement.insertionOrder).padStart(3, '0')}) ` +
+    success(`Created ${placement.newFilename} (order ${formatPatchOrder(placement.insertionOrder)}) ` +
         `and moved ${plan.movedFiles.length} file(s) out of ${source.filename}`);
     if (plan.ownerRewrites.length > 0) {
         info(`Re-pointed staged-dependency owners in: ${plan.ownerRewrites.join(', ')}`);