@hominis/fireforge 0.49.2 → 0.51.0

package/dist/src/commands/lint.js

@@ -10,9 +10,10 @@ import { getStatusWithCodes, hasChanges } from '../core/git.js';
 import { getAllDiff, getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { expandUntrackedDirectoryEntries, getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, getWorkingTreeStatus, } from '../core/git-status.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
-import { buildPatchQueueContext, countNonBinaryDiffLines, formatPatchLintIssue, lintExportedPatch, lintPatchQueue, lintPatchSize, } from '../core/patch-lint.js';
+import { buildPatchQueueContext, formatPatchLintIssue, lintExportedPatch, lintPatchQueue, lintPatchSize, measurePatchSize, } from '../core/patch-lint.js';
 import { clearPerPatchLintCache } from '../core/patch-lint-cache.js';
 import { collectDiffFilePaths, tagLintIssues } from '../core/patch-lint-diff-tag.js';
+import { buildLintIgnoreChecks, filterLintIgnoredByOwners, partitionLintIgnoredIssues, } from '../core/patch-lint-ignore.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
 import { info, intro, outro, success, warn } from '../utils/logger.js';
@@ -186,25 +187,7 @@ function buildMaxWarningsMessage(count, maxWarnings, scope) {
  * @returns Filtered issue list and the count of dropped findings.
  */
 export function applyAggregateLintIgnoreSuppression(issues, ctx) {
-    const suppressionsByFile = new Map();
-    for (const entry of ctx.entries) {
-        const ignoreList = entry.metadata?.lintIgnore;
-        if (!ignoreList || ignoreList.length === 0)
-            continue;
-        for (const f of entry.metadata?.filesAffected ?? []) {
-            let bucket = suppressionsByFile.get(f);
-            if (!bucket) {
-                bucket = new Set();
-                suppressionsByFile.set(f, bucket);
-            }
-            for (const id of ignoreList)
-                bucket.add(id);
-        }
-    }
-    if (suppressionsByFile.size === 0) {
-        return { issues, dropped: 0 };
-    }
-    const filtered = issues.filter((issue) => !suppressionsByFile.get(issue.file)?.has(issue.check));
+    const filtered = filterLintIgnoredByOwners(issues, ctx.entries.map((entry) => entry.metadata));
     return { issues: filtered, dropped: issues.length - filtered.length };
 }
 /**
@@ -283,7 +266,7 @@ function downgradeAggregateSizeRules(issues, files, ctx) {
  * @param ctx - Patch queue context used to attribute file → owning patch
  * @returns Size issues, each attributed to its owning patch by message prefix
  */
-async function lintOwningPatchSizes(engineDir, filesAffected, ctx) {
+async function lintOwningPatchSizes(engineDir, filesAffected, ctx, config) {
     const listed = new Set(filesAffected);
     const owners = new Map();
     const ownedListed = new Set();
@@ -302,26 +285,24 @@ async function lintOwningPatchSizes(engineDir, filesAffected, ctx) {
             owners.set(entry.filename, entry);
     }
     const issues = [];
-    const lineCountForFiles = async (relPaths) => {
+    const sizeForFiles = async (relPaths) => {
         const existing = [];
         for (const f of relPaths) {
             if (await pathExists(join(engineDir, f)))
                 existing.push(f);
         }
-        if (existing.length === 0)
-            return 0;
-        const diff = await getDiffForFilesAgainstHead(engineDir, existing);
-        return countNonBinaryDiffLines(diff).textLines;
+        const diff = existing.length > 0 ? await getDiffForFilesAgainstHead(engineDir, existing) : '';
+        // The file count stays the owner's whole `filesAffected`, as before.
+        return measurePatchSize(engineDir, diff, relPaths, config);
     };
     for (const entry of owners.values()) {
         const md = entry.metadata;
         if (!md)
             continue;
-        const lineCount = await lineCountForFiles(md.filesAffected);
-        const ignore = md.lintIgnore?.length ? new Set(md.lintIgnore) : undefined;
-        for (const issue of lintPatchSize(md.filesAffected, lineCount, md.tier)) {
-            if (ignore?.has(issue.check))
-                continue;
+        const size = await sizeForFiles(md.filesAffected);
+        const ignore = buildLintIgnoreChecks(md.lintIgnore);
+        const sized = lintPatchSize(md.filesAffected, size, md.tier, config);
+        for (const issue of partitionLintIgnoredIssues(sized, ignore).kept) {
             issues.push({ ...issue, message: `${entry.filename}: ${issue.message}` });
         }
     }
@@ -329,8 +310,8 @@ async function lintOwningPatchSizes(engineDir, filesAffected, ctx) {
     // unit so a genuinely oversized fresh change still surfaces.
     const unowned = filesAffected.filter((f) => !ownedListed.has(f));
     if (unowned.length > 0) {
-        const lineCount = await lineCountForFiles(unowned);
-        issues.push(...lintPatchSize(unowned, lineCount));
+        const size = await sizeForFiles(unowned);
+        issues.push(...lintPatchSize(unowned, size, undefined, config));
     }
     return issues;
 }
@@ -460,7 +441,7 @@ export async function lintCommand(projectRoot, files, options = {}) {
         })),
     ];
     if (files.length > 0 && ctx) {
-        issues.push(...(await lintOwningPatchSizes(paths.engine, filesAffected, ctx)));
+        issues.push(...(await lintOwningPatchSizes(paths.engine, filesAffected, ctx, config)));
     }
     // Cross-patch rules operate over the whole queue, so run them whenever a
     // patches directory exists. They surface duplicate /dev/null creations

package/dist/src/commands/manifest.js

@@ -1,5 +1,6 @@
 import { registerBootstrap } from './bootstrap.js';
 import { registerBuild } from './build.js';
+import { registerCheck } from './check.js';
 import { registerConfig } from './config.js';
 import { registerDiscard } from './discard.js';
 import { registerDoctor } from './doctor.js';
@@ -10,6 +11,7 @@ import { registerFurnace } from './furnace/index.js';
 import { registerImport } from './import.js';
 import { registerLint } from './lint.js';
 import { registerPackage } from './package.js';
+import { registerPark } from './park.js';
 import { registerPatch } from './patch/index.js';
 import { registerReExport } from './re-export-register.js';
 import { registerRebase } from './rebase/index.js';
@@ -46,6 +48,7 @@ export const COMMAND_MANIFEST = [
     { name: 'export', group: 'workflow', register: registerExport },
     { name: 'export-all', group: 'workflow', register: registerExportAll },
     { name: 're-export', group: 'workflow', register: registerReExport },
+    { name: 'park', group: 'workflow', register: registerPark },
     { name: 'patch', group: 'workflow', register: registerPatch },
     { name: 'rebase', group: 'workflow', register: registerRebase },
     { name: 'package', group: 'workflow', register: registerPackage },
@@ -60,5 +63,6 @@ export const COMMAND_MANIFEST = [
     { name: 'lint', group: 'diagnostics', register: registerLint },
     { name: 'typecheck', group: 'diagnostics', register: registerTypecheck },
     { name: 'verify', group: 'diagnostics', register: registerVerify },
+    { name: 'check', group: 'diagnostics', register: registerCheck },
     { name: 'furnace', group: 'components', register: registerFurnace },
 ];

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

@@ -0,0 +1,22 @@
+import type { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+/** Options for `fireforge park`. */
+export interface ParkOptions {
+    label?: string;
+    hunks?: string;
+    restore?: string;
+    list?: boolean;
+    drop?: string;
+    dryRun?: boolean;
+    waitLock?: number | boolean;
+}
+/**
+ * Runs `fireforge park`.
+ *
+ * @param projectRoot - Project root
+ * @param identifier - The patch to park (omitted for --restore/--list/--drop)
+ * @param options - See {@link ParkOptions}
+ */
+export declare function parkCommand(projectRoot: string, identifier: string | undefined, options: ParkOptions): Promise<void>;
+/** Registers `fireforge park`. */
+export declare function registerPark(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/park.js

@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `fireforge park`: set one session's edits in a patch's files aside and
+ * put them back after the owner commits.
+ *
+ *   park <patch> [--label <l>] [--hunks <diff>]   park and restore baseline
+ *   park --restore <label>                         three-way merge them back
+ *   park --list | park --drop <label>
+ *
+ * Without `--hunks` every drifted file of the patch goes back to its
+ * queue-applied baseline. With `--hunks` only the named hunks are taken out
+ * of the working tree. Either way the park warns when a hunk it takes out
+ * removes a Fluent message id, or a whole file, that files outside the
+ * patch still reference: a parked string still used by markup another
+ * patch owns makes `document.l10n.ready` reject in every new window.
+ */
+import { basename, join } from 'node:path';
+import { getProjectPaths } from '../core/config.js';
+import { withEngineSessionLock } from '../core/engine-session-lock.js';
+import { appendHistoryBestEffort } from '../core/history-log.js';
+import { dropPark, fluentIds, listParks, planRestore, readEngineFile, readPark, removedLines, writeEngineFile, writePark, } from '../core/park-store.js';
+import { createPatchedContentContext } from '../core/patch-apply.js';
+import { formatPatchNotFoundError } from '../core/patch-identifier-suggest.js';
+import { loadPatchesManifest, resolvePatchIdentifier } from '../core/patch-manifest.js';
+import { parseDiffSections } from '../core/patch-parse.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { pathExists, readText } from '../utils/fs.js';
+import { info, intro, outro, success, warn } from '../utils/logger.js';
+import { addWaitLockOption, resolveWaitLockSeconds } from '../utils/options.js';
+import { applyHunksByContext } from './re-export-hunks.js';
+import { normalizeEngineRelativeInput } from './re-export-scan.js';
+/** The patch-applied baseline of each of `patch`'s files (null = absent). */
+async function baselinesOf(paths, patch) {
+    const { computePatched } = await createPatchedContentContext(paths.patches, paths.engine);
+    const deleted = new Set(parseDiffSections(await readText(join(paths.patches, patch.filename)))
+        .filter((section) => section.isDeletedFile)
+        .map((section) => section.targetPath));
+    const baselines = new Map();
+    for (const file of patch.filesAffected) {
+        baselines.set(file, deleted.has(file) ? null : await computePatched(file));
+    }
+    return baselines;
+}
+/** The files a park would change, with both sides. */
+async function planPark(paths, patch, hunksPath) {
+    if (hunksPath === undefined) {
+        const baselines = await baselinesOf(paths, patch);
+        const files = [];
+        for (const [path, after] of baselines) {
+            const before = await readEngineFile(paths.engine, path);
+            if (before !== after)
+                files.push({ path, before, after });
+        }
+        return files;
+    }
+    if (!(await pathExists(hunksPath))) {
+        throw new InvalidArgumentError(`--hunks ${hunksPath} does not exist.`, '--hunks');
+    }
+    const owned = new Set(patch.filesAffected);
+    const files = [];
+    for (const section of parseDiffSections(await readText(hunksPath))) {
+        const path = normalizeEngineRelativeInput(section.targetPath, '--hunks');
+        if (!owned.has(path)) {
+            throw new InvalidArgumentError(`--hunks names ${path}, which ${patch.filename} does not own.`, '--hunks');
+        }
+        const before = await readEngineFile(paths.engine, path);
+        const after = applyHunksByContext(before ?? '', section.hunks, true, path);
+        if (before !== after)
+            files.push({ path, before, after });
+    }
+    return files;
+}
+/**
+ * Referrers outside the patch of what the park takes away: Fluent ids its
+ * removed lines declare, and files it removes outright.
+ */
+async function findOutsideReferrers(paths, manifest, patch, files) {
+    const needles = new Map();
+    for (const file of files) {
+        if (file.path.endsWith('.ftl')) {
+            for (const id of fluentIds(removedLines(file.before, file.after))) {
+                needles.set(id, `Fluent id "${id}" (${file.path})`);
+            }
+        }
+        if (file.before !== null && file.after === null) {
+            needles.set(basename(file.path), `file ${file.path}`);
+        }
+    }
+    if (needles.size === 0)
+        return [];
+    const own = new Set(patch.filesAffected);
+    const outside = [...new Set(manifest.patches.flatMap((entry) => entry.filesAffected))].filter((file) => !own.has(file));
+    const findings = [];
+    for (const file of outside) {
+        const content = await readEngineFile(paths.engine, file);
+        if (content === null)
+            continue;
+        for (const [needle, label] of needles) {
+            if (content.includes(needle))
+                findings.push(`${label} is still referenced by ${file}`);
+        }
+    }
+    return findings;
+}
+async function runPark(projectRoot, identifier, options) {
+    const paths = getProjectPaths(projectRoot);
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest)
+        throw new GeneralError('No patches/patches.json; nothing to park against.');
+    const patch = resolvePatchIdentifier(identifier, manifest.patches);
+    if (!patch) {
+        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), 'park');
+    }
+    const files = await planPark(paths, patch, options.hunks);
+    if (files.length === 0) {
+        info(`${patch.filename}: nothing to park; its files match ${options.hunks ?? 'the baseline'}.`);
+        return;
+    }
+    for (const finding of await findOutsideReferrers(paths, manifest, patch, files)) {
+        warn(`Parking removes what is still in use: ${finding}. Move it somewhere you own first.`);
+    }
+    const label = options.label ?? `${patch.filename.replace(/\.patch$/, '')}-${Date.now().toString(36)}`;
+    for (const file of files)
+        info(`  ${file.path}`);
+    if (options.dryRun === true) {
+        info(`[dry-run] would park ${files.length} file(s) of ${patch.filename} as "${label}".`);
+        return;
+    }
+    const dir = await writePark(projectRoot, {
+        label,
+        patch: patch.filename,
+        createdAt: new Date().toISOString(),
+        mode: options.hunks === undefined ? 'baseline' : 'hunks',
+        files,
+    });
+    for (const file of files)
+        await writeEngineFile(paths.engine, file.path, file.after);
+    await appendHistoryBestEffort(paths.patches, {
+        operation: 'park',
+        args: { label, patch: patch.filename, files: files.map((file) => file.path) },
+        result: 'ok',
+    }, `park ${label}`);
+    success(`Parked ${files.length} file(s) of ${patch.filename} as "${label}" (${dir}).`);
+    info(`Restore with: fireforge park --restore ${label}`);
+}
+async function runRestore(projectRoot, label, dryRun) {
+    const paths = getProjectPaths(projectRoot);
+    const park = await readPark(projectRoot, label);
+    const conflicts = [];
+    const plans = [];
+    for (const file of park.files) {
+        const now = await readEngineFile(paths.engine, file.path);
+        const plan = await planRestore(file, now);
+        plans.push({ file, ...plan });
+        if (plan.outcome === 'conflict')
+            conflicts.push(file.path);
+    }
+    for (const { file, outcome } of plans)
+        info(`  ${file.path}: ${outcome}`);
+    if (dryRun) {
+        info(`[dry-run] restoring "${label}" would leave ${conflicts.length} conflict(s).`);
+        return;
+    }
+    for (const { file, content, outcome } of plans) {
+        if (outcome !== 'unchanged')
+            await writeEngineFile(paths.engine, file.path, content);
+    }
+    await appendHistoryBestEffort(paths.patches, {
+        operation: 'park-restore',
+        args: { label, patch: park.patch, conflicts },
+        result: conflicts.length === 0 ? 'ok' : 'conflict',
+    }, `park --restore ${label}`);
+    if (conflicts.length > 0) {
+        throw new GeneralError(`Restoring "${label}" left conflict markers in ${conflicts.join(', ')}. Resolve them, ` +
+            `then drop the park with "fireforge park --drop ${label}".`);
+    }
+    await dropPark(projectRoot, label);
+    success(`Restored "${label}" into ${park.files.length} file(s) of ${park.patch}.`);
+}
+/**
+ * Runs `fireforge park`.
+ *
+ * @param projectRoot - Project root
+ * @param identifier - The patch to park (omitted for --restore/--list/--drop)
+ * @param options - See {@link ParkOptions}
+ */
+export async function parkCommand(projectRoot, identifier, options) {
+    intro('FireForge park');
+    const modes = [identifier !== undefined, options.restore, options.list, options.drop].filter((mode) => mode !== undefined && mode !== false);
+    if (modes.length !== 1) {
+        throw new InvalidArgumentError('Pass exactly one of: a patch to park, --restore <label>, --list or --drop <label>.', 'park');
+    }
+    if (options.list === true) {
+        const parks = await listParks(projectRoot);
+        if (parks.length === 0)
+            info('No parks.');
+        for (const park of parks) {
+            info(`${park.label}  ${park.patch}  ${park.files.length} file(s)  ${park.createdAt}`);
+        }
+    }
+    else if (options.drop !== undefined) {
+        await dropPark(projectRoot, options.drop);
+        success(`Dropped park "${options.drop}".`);
+    }
+    else if (options.restore !== undefined) {
+        await runRestore(projectRoot, options.restore, options.dryRun === true);
+    }
+    else if (identifier !== undefined) {
+        await runPark(projectRoot, identifier, options);
+    }
+    outro('Park complete');
+}
+/** Registers `fireforge park`. */
+export function registerPark(program, { getProjectRoot, withErrorHandling }) {
+    const command = program
+        .command('park [patch]')
+        .description("Set a session's edits in a patch's files aside (back to the queue-applied baseline, or minus the hunks a diff names) and three-way merge them back later")
+        .option('--label <label>', 'Name for the park (default: <patch>-<time>)')
+        .option('--hunks <diff>', 'Park only the hunks this diff names, not every drifted line')
+        .option('--restore <label>', 'Three-way merge a park back into the engine, then drop it')
+        .option('--list', 'List the parks')
+        .option('--drop <label>', 'Delete a park without restoring it')
+        .option('--dry-run', 'Show what would be parked or restored');
+    addWaitLockOption(command).action(withErrorHandling(async (patch, options) => {
+        const projectRoot = getProjectRoot();
+        if (options.list === true || options.drop !== undefined || options.dryRun === true) {
+            await parkCommand(projectRoot, patch, options);
+            return;
+        }
+        await withEngineSessionLock(projectRoot, 'park', () => parkCommand(projectRoot, patch, options), { waitLockSeconds: resolveWaitLockSeconds(options.waitLock) });
+    }));
+}

package/dist/src/commands/patch/delete-gap-notice.js

@@ -42,5 +42,7 @@ function formatGapNotice(targetFilename, message) {
     const where = orders ? `a gap at ${orders}` : 'a numeric gap';
     return (`deleting ${targetFilename} leaves ${range} with ${where}; the queue will fail ` +
         'numeric-gap (patchPolicy.allowGaps is false) until ' +
-        `"fireforge export --order ${fill}" fills it or "fireforge patch compact" renumbers.`);
+        `"fireforge export --order ${fill}" fills it or "fireforge patch compact" renumbers. ` +
+        `"fireforge patch retire ${targetFilename}" removes the patch and keeps its order as a ` +
+        'retired slot instead, so no gap opens.');
 }

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

@@ -4,7 +4,7 @@
  * Destructive: refuses when a later patch imports a module owned by the
  * target (that would leave a dangling forward import), prompts for
  * confirmation interactively, requires `--yes` for non-TTY, supports
- * `--dry-run`, and appends to `patches/.fireforge-history.jsonl` on success.
+ * `--dry-run`, and appends to the patch history log on success.
  */
 import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';

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

@@ -5,14 +5,13 @@
  * Destructive: refuses when a later patch imports a module owned by the
  * target (that would leave a dangling forward import), prompts for
  * confirmation interactively, requires `--yes` for non-TTY, supports
- * `--dry-run`, and appends to `patches/.fireforge-history.jsonl` on success.
+ * `--dry-run`, and appends to the patch history log on success.
  */
-import { basename } from 'node:path';
 import { Command } from 'commander';
 import { loadConfig } from '../../core/config.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 { buildPatchQueueContext } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { removePatchFileAndManifest } from '../../core/patch-manifest.js';
 import { GeneralError } from '../../errors/base.js';
@@ -21,6 +20,8 @@ import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../ut
 import { proceedAfterDecision } from '../destructive-decision.js';
 import { describeProjectedGaps } from './delete-gap-notice.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
+import { deleteCreatedFiles, planClaimedFiles, withCreatedFileLock, } from './removal-created-files.js';
+import { collectRemovalDependents, queueSnapshot, removalConflict, warnDanglingStagedOwners, } from './removal-dependents.js';
 /**
  * Runs the `patch delete` command: removes a patch file and its manifest
  * row atomically, refusing when a later patch imports a leaf owned by the
@@ -37,81 +38,15 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     });
     const target = requirePatchTarget(identifier, manifest.patches);
     // Build the full queue context once so we can scan each patch's newFiles
-    // without re-parsing for the dependency check below.
+    // without re-parsing for the dependency check below. Hard refusal: an
+    // import owned by a later patch that points at any of the target's
+    // newly-created files is a dependency on the target.
     const baseCtx = await buildPatchQueueContext(paths.patches);
-    // Hard refusal: an import owned by a later patch that points at any of
-    // the target's newly-created files is a dependency on the target. That
-    // check is built directly from `baseCtx` rather than by diffing lint runs
-    // over a projected state.
-    const targetEntry = baseCtx.entries.find((e) => e.filename === target.filename);
-    if (!targetEntry || JSON.stringify(targetEntry.metadata) !== JSON.stringify(target)) {
-        throw new GeneralError('Patch queue changed while preparing deletion. Re-run patch delete to review the current target.');
-    }
-    const targetNewFileLeaves = new Set();
-    for (const fullPath of targetEntry.newFiles.keys()) {
-        targetNewFileLeaves.add(basename(fullPath));
-    }
-    // Scan every later patch's new files and its added lines on pre-existing
-    // files for import specifiers that resolve to a leaf owned by the target.
-    // Uses the shared specifier extractor so dynamic `import()` and
-    // `ChromeUtils.defineESModuleGetters` are picked up: the forward-import
-    // lint rule already covers those forms, and delete safety must match the
-    // same set or it silently drops dependencies.
-    //
-    // Both source-site maps are covered: `newFiles` (files the later patch
-    // creates) and `modifiedFileAdditions` (added lines against files that
-    // already exist). Scanning only newFiles misses a later patch adding
-    // `import "./TargetHelper.sys.mjs"` to an existing file.
-    const dependents = [];
-    const scanSite = (entryFilename, sitePath, content) => {
-        if (!isForwardImportableFile(sitePath))
-            return false;
-        const ignoredLines = findForwardImportIgnoreLines(content);
-        const specifiers = extractImportSpecifiersWithLines(content);
-        for (const { specifier, line } of specifiers) {
-            if (ignoredLines.has(line))
-                continue;
-            const cleaned = specifier.split(/[?#]/)[0] ?? specifier;
-            const leaf = basename(cleaned);
-            if (!leaf || !isForwardImportableFile(leaf))
-                continue;
-            if (targetNewFileLeaves.has(leaf)) {
-                dependents.push(`${entryFilename} (${sitePath}) imports "${specifier}" which would be deleted`);
-                return true;
-            }
-        }
-        return false;
-    };
-    for (const entry of baseCtx.entries) {
-        if (entry.filename === target.filename)
-            continue;
-        if (entry.order < target.order)
-            continue;
-        let matched = false;
-        for (const [newFile, content] of entry.newFiles) {
-            if (scanSite(entry.filename, newFile, content)) {
-                matched = true;
-                break;
-            }
-        }
-        if (matched)
-            continue;
-        for (const [modifiedPath, addedContent] of entry.modifiedFileAdditions) {
-            if (scanSite(entry.filename, modifiedPath, addedContent))
-                break;
-        }
-    }
-    // Staged-dependency declarations on other patches may name the deleted
-    // patch as their forward-import owner. The dangling reference also
-    // surfaces via cross-patch lint later, but warning here puts the exact
-    // cleanup command in front of the operator at decision time.
-    const danglingOwnerHolders = baseCtx.entries.filter((entry) => entry.filename !== target.filename &&
-        (entry.metadata?.stagedDependencies?.forwardImports ?? []).some((fi) => fi.owner === target.filename));
-    for (const holder of danglingOwnerHolders) {
-        warn(`${holder.filename} declares a staged dependency with owner ${target.filename}; ` +
-            `after the delete, update it via "fireforge patch staged-dependency ${holder.filename} --remove ..." ` +
-            'or re-point the owner at the patch that will create the file.');
-    }
+    const dependents = collectRemovalDependents(baseCtx, target, {
+        noun: 'deletion',
+        verb: 'delete',
+    });
+    warnDanglingStagedOwners(baseCtx, target, 'delete');
     // Under `patchPolicy.allowGaps: false` the removal can open a numeric gap
     // that every later lint and re-export refuses on. Naming it here, in
     // dry-run and at the prompt, puts the refill/compact choice in front of
@@ -120,28 +55,13 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     for (const line of gapNotices) {
         warn(line);
     }
-    const conflicts = dependents.length > 0
-        ? {
-            // The wording spells out the runtime impact: `git apply`
-            // does not resolve imports and succeeds even when a later patch
-            // imports a file the target created, so the queue re-imports
-            // cleanly. The breakage surfaces at browser startup when
-            // `ChromeUtils.importESModule` cannot locate the deleted module.
-            // Operators who plan to re-introduce the imported files (rename,
-            // refactor) need to know this is the impact model rather than a
-            // patch-application failure.
-            reason: `${dependents.length} later patch(es) contain import statements that reference files created by ${target.filename}. Patch application itself will still succeed, but runtime imports will fail at browser startup until those files are re-introduced.`,
-            details: dependents,
-        }
-        : null;
+    const conflicts = removalConflict(dependents, target);
+    const claimed = await planClaimedFiles(baseCtx, target, paths.engine, options.deleteCreated === true);
     const summary = [
         `delete ${target.filename}  (category: ${target.category}, order: ${target.order})`,
         `description: ${target.description || '(none)'}`,
-        `files currently claimed by this patch (${target.filesAffected.length}):`,
+        ...claimed.summary,
     ];
-    for (const file of target.filesAffected) {
-        summary.push(`  ${file}  → will become unmanaged`);
-    }
     summary.push(...gapNotices);
     const decision = await confirmDestructive({
         operation: 'patch-delete',
@@ -162,32 +82,31 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     // mutation with no audit trail. A history append failure is warned but not
     // re-thrown: by that point the mutation has committed, and reporting
     // failure to the caller would mislead.
-    await withPatchDirectoryLock(paths.patches, async () => {
+    const waitLockSeconds = resolveWaitLockSeconds(options.waitLock);
+    await withCreatedFileLock(projectRoot, 'patch delete', claimed, waitLockSeconds, () => withPatchDirectoryLock(paths.patches, async () => {
         const current = await buildPatchQueueContext(paths.patches);
-        const snapshot = (context) => JSON.stringify(context.entries.map(({ filename, order, diff, metadata }) => ({
-            filename,
-            order,
-            diff,
-            metadata,
-        })));
         // A changed body or manifest invalidates the dependency scan approved
         // before the prompt. Recheck all of its inputs while holding the lock.
-        if (snapshot(current) !== snapshot(baseCtx)) {
+        if (queueSnapshot(current) !== queueSnapshot(baseCtx)) {
             throw new GeneralError('Patch queue changed while waiting for confirmation or the lock. Re-run patch delete to review the current dependencies.');
         }
         await removePatchFileAndManifest(paths.patches, target.filename);
+        await deleteCreatedFiles(paths.engine, claimed.deleteOnCommit);
         await appendHistoryBestEffort(paths.patches, {
             operation: 'patch-delete',
             args: {
                 filename: target.filename,
                 order: target.order,
                 filesAffected: target.filesAffected,
+                ...(claimed.deleteOnCommit.length > 0
+                    ? { deletedCreatedFiles: claimed.deleteOnCommit }
+                    : {}),
             },
             ...(options.yes === true ? { yes: true } : {}),
             ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
             result: 'ok',
         }, `patch delete committed (${target.filename})`);
-    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch delete' });
+    }, { waitLockSeconds, command: 'patch delete' }));
     info(`Deleted ${target.filename}.`);
     outro('Delete complete');
 }
@@ -204,6 +123,7 @@ export function registerPatchDelete(parent, context) {
         .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('--delete-created', 'Also delete the engine files this patch creates that are still on disk, instead of leaving them unmanaged')
         .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/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * `fireforge patch <verb>` parent command. Groups single-patch mutations and
  * planners (`compact`, `delete`, `lint-ignore`, `move-files`, `rename`,
- * `reorder`, `staged-dependency`, `tier`) so they do not clutter the
- * top-level command list. Queue-level verbs like `lint`, `export`, `verify`,
- * and `status` stay flat.
+ * `reorder`, `reserve`, `retire`, `split`, `stage`, `staged-dependency`,
+ * `tier`) so they do not clutter the top-level command list. Queue-level
+ * verbs like `lint`, `export`, `verify`, and `status` stay flat.
  */
 import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';