@hominis/fireforge 0.44.4 → 0.46.0

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

@@ -18,18 +18,7 @@ import { escapeRegex } from '../../utils/regex.js';
 import { updateBrowserChromeTestContent } from './rename-browser-test.js';
 import { rekeyStateChecksums, renameComponentFileName, updateConfigForCustomRename, updateConfigForOverrideRename, } from './rename-helpers.js';
 import { renameXpcshellTestFiles } from './rename-xpcshell.js';
-/**
- * Derives the test file name for a component, matching the convention used by
- * `furnace create --with-tests`.
- */
-function deriveTestFileName(componentName, binaryName) {
-    const strippedName = componentName.startsWith('moz-') ? componentName.slice(4) : componentName;
-    const withoutBinaryPrefix = strippedName.startsWith(binaryName + '-')
-        ? strippedName.slice(binaryName.length + 1)
-        : strippedName;
-    const underscored = withoutBinaryPrefix.replace(/-/g, '_');
-    return `browser_${binaryName}_${underscored}.js`;
-}
+import { browserTestFileName } from './test-file-name.js';
 /**
  * Renames test files created by `furnace create --with-tests` in the engine
  * test directory. Best-effort: failures are logged as warnings but do not
@@ -44,8 +33,8 @@ async function renameTestFiles(engineDir, projectRoot, oldName, newName, journal
         return; // Cannot determine test paths without config.
     }
     const binaryName = forgeConfig.binaryName;
-    const oldTestFileName = deriveTestFileName(oldName, binaryName);
-    const newTestFileName = deriveTestFileName(newName, binaryName);
+    const oldTestFileName = browserTestFileName(oldName, binaryName);
+    const newTestFileName = browserTestFileName(newName, binaryName);
     const testDir = join(engineDir, 'browser/base/content/test', binaryName);
     if (!(await pathExists(testDir)))
         return;
@@ -259,7 +248,15 @@ async function performRenameMutations(args) {
             if (isCustom && config.custom[newName]?.register && (await pathExists(args.engineDir))) {
                 const ftlDir = resolveFtlDir(config.ftlBasePath);
                 const isLocalized = config.custom[newName].localized;
-                await updateEngineRegistrations(args.engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal);
+                await updateEngineRegistrations({
+                    engineDir: args.engineDir,
+                    oldName,
+                    newName,
+                    newDir,
+                    ftlDir,
+                    isLocalized,
+                    journal,
+                });
             }
             // 4. Re-key furnace-state.json checksums from old name to new name
             await rekeyStateChecksums(args.projectRoot, componentType, oldName, newName);
@@ -323,7 +320,14 @@ async function performRenameMutations(args) {
         }
     });
 }
-async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal) {
+/**
+ * Re-points the engine-side registrations (customElements.js, jar.mn, and
+ * the localized `.ftl` entries) from the old tag name to the new one.
+ *
+ * @param options - See {@link UpdateEngineRegistrationsOptions}
+ */
+async function updateEngineRegistrations(options) {
+    const { engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal } = options;
     const customElementsPath = join(engineDir, 'toolkit/content/customElements.js');
     const jarMnPath = join(engineDir, 'toolkit/content/jar.mn');
     if (await pathExists(customElementsPath)) {
@@ -396,15 +400,15 @@ export async function furnaceRenameCommand(projectRoot, oldName, newName) {
     if (newName in config.custom || newName in config.overrides || config.stock.includes(newName)) {
         throw new FurnaceError(`A component named "${newName}" already exists in furnace.json.`, newName);
     }
-    const componentType = isCustom ? 'custom' : 'override';
-    // `componentType` is the furnace-state key (singular: `custom` /
-    // `override`); the on-disk directory label differs — custom components
-    // live under `components/custom/` (singular) while overrides live under
-    // `components/overrides/` (plural). Appending an `s` to `componentType`
-    // produces the wrong label `components/customs/` for custom components
-    // and is correct for overrides only by coincidence. `componentDirLabel`
-    // centralises the pick so every operator-facing string names the
-    // directory that actually exists on disk.
+    // The furnace-state key is singular (`custom` / `override`, derived
+    // inside performRenameMutations); the on-disk directory label differs —
+    // custom components live under `components/custom/` (singular) while
+    // overrides live under `components/overrides/` (plural). Appending an
+    // `s` to the state key produces the wrong label `components/customs/`
+    // for custom components and is correct for overrides only by
+    // coincidence. `componentDirLabel` centralises the pick so every
+    // operator-facing string names the directory that actually exists on
+    // disk.
     const componentDirLabel = isCustom ? 'custom' : 'overrides';
     const baseDir = isCustom ? furnacePaths.customDir : furnacePaths.overridesDir;
     const oldDir = join(baseDir, oldName);
@@ -419,11 +423,7 @@ export async function furnaceRenameCommand(projectRoot, oldName, newName) {
         projectRoot,
         oldName,
         newName,
-        oldDir,
         newDir,
-        isCustom,
-        componentType,
-        config,
         furnaceConfigPath: furnacePaths.furnaceConfig,
         furnacePaths,
         engineDir: paths.engine,

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

@@ -11,15 +11,10 @@ import { pathExists } from '../../utils/fs.js';
 import { info, intro, note, outro, warn } from '../../utils/logger.js';
 /**
  * Displays detailed status for a single Furnace component, including registration drift.
- * @param name - Component tag name to inspect
- * @param config - Loaded Furnace configuration
- * @param state - Loaded furnace state, for applied/engine checksums
- * @param projectRoot - Root directory of the project
- * @param paths - Resolved project paths
- * @param furnacePaths - Resolved Furnace-specific paths
- * @param ftlDir - Engine-relative directory localized components deploy their `.ftl` into
+ * @param options - See {@link DetailedComponentStatusOptions}
  */
-async function showDetailedComponentStatus(name, config, state, projectRoot, paths, furnacePaths, ftlDir) {
+async function showDetailedComponentStatus(options) {
+    const { name, config, state, projectRoot, paths, furnacePaths, ftlDir } = options;
     const customConfig = config.custom[name];
     const overrideConfig = config.overrides[name];
     if (!customConfig && !overrideConfig && !config.stock.includes(name)) {
@@ -113,7 +108,15 @@ export async function furnaceStatusCommand(projectRoot, name) {
     const furnacePaths = getFurnacePaths(projectRoot);
     const ftlDir = resolveFtlDir(config.ftlBasePath);
     if (name) {
-        await showDetailedComponentStatus(name, config, state, projectRoot, paths, furnacePaths, ftlDir);
+        await showDetailedComponentStatus({
+            name,
+            config,
+            state,
+            projectRoot,
+            paths,
+            furnacePaths,
+            ftlDir,
+        });
         return;
     }
     // Surface a pendingRepair marker before the normal summary so it cannot

package/dist/src/commands/furnace/test-file-name.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Derives the underscored stem a component's generated test files are named
+ * after.
+ *
+ * Five modules (`create-browser-test`, `create-dry-run`, `remove`, `rename`,
+ * `rename-browser-test`) had each inlined this three-step transform. The steps
+ * are not arbitrary and must agree exactly, or `furnace rename` and
+ * `furnace remove` compute a different filename than `furnace create` wrote
+ * and silently leave the old test behind:
+ *
+ * 1. drop the upstream `moz-` custom-element prefix, which never appears in a
+ *    test filename;
+ * 2. drop a leading `<binaryName>-`, because the test directory is already
+ *    named after the binary and the prefix would be doubled;
+ * 3. underscore the remaining dashes, matching mozilla-central's
+ *    `browser_*.js` convention.
+ * @param componentName - Custom-element name, e.g. `moz-mybrowser-sidebar`.
+ * @param binaryName - Configured binary name, e.g. `mybrowser`.
+ * @returns The stem, e.g. `sidebar`.
+ */
+export declare function deriveTestStem(componentName: string, binaryName: string): string;
+/**
+ * Builds the browser-chrome test filename for a component.
+ * @param componentName - Custom-element name.
+ * @param binaryName - Configured binary name.
+ * @returns The filename, e.g. `browser_mybrowser_sidebar.js`.
+ */
+export declare function browserTestFileName(componentName: string, binaryName: string): string;

package/dist/src/commands/furnace/test-file-name.js

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Derives the underscored stem a component's generated test files are named
+ * after.
+ *
+ * Five modules (`create-browser-test`, `create-dry-run`, `remove`, `rename`,
+ * `rename-browser-test`) had each inlined this three-step transform. The steps
+ * are not arbitrary and must agree exactly, or `furnace rename` and
+ * `furnace remove` compute a different filename than `furnace create` wrote
+ * and silently leave the old test behind:
+ *
+ * 1. drop the upstream `moz-` custom-element prefix, which never appears in a
+ *    test filename;
+ * 2. drop a leading `<binaryName>-`, because the test directory is already
+ *    named after the binary and the prefix would be doubled;
+ * 3. underscore the remaining dashes, matching mozilla-central's
+ *    `browser_*.js` convention.
+ * @param componentName - Custom-element name, e.g. `moz-mybrowser-sidebar`.
+ * @param binaryName - Configured binary name, e.g. `mybrowser`.
+ * @returns The stem, e.g. `sidebar`.
+ */
+export function deriveTestStem(componentName, binaryName) {
+    const withoutMozPrefix = componentName.startsWith('moz-')
+        ? componentName.slice(4)
+        : componentName;
+    const withoutBinaryPrefix = withoutMozPrefix.startsWith(`${binaryName}-`)
+        ? withoutMozPrefix.slice(binaryName.length + 1)
+        : withoutMozPrefix;
+    return withoutBinaryPrefix.replace(/-/g, '_');
+}
+/**
+ * Builds the browser-chrome test filename for a component.
+ * @param componentName - Custom-element name.
+ * @param binaryName - Configured binary name.
+ * @returns The filename, e.g. `browser_mybrowser_sidebar.js`.
+ */
+export function browserTestFileName(componentName, binaryName) {
+    return `browser_${binaryName}_${deriveTestStem(componentName, binaryName)}.js`;
+}

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 {};