@hominis/fireforge 0.47.1 → 0.49.0

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

@@ -94,6 +94,7 @@ async function runWatchLoop(projectRoot) {
     // because the post-apply checksum snapshot already reflects the edit so
     // the 30s poll also sees no diff.
     let pendingChange = false;
+    let retryNeeded = false;
     let lastChecksums = new Map();
     let pollTimer = null;
     const runApplyCycle = async () => {
@@ -102,18 +103,21 @@ async function runWatchLoop(projectRoot) {
             info('\nChange detected — re-applying...');
             const result = await runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, false, { operationContext: ctx }));
             logApplyResult(result, false);
+            if (result.errors.length > 0 || countEntriesWithBlockingStepErrors(result.applied) > 0) {
+                throw new FurnaceError('Watch apply did not complete; retrying on the next poll.');
+            }
             const applied = result.applied.length;
             const skipped = result.skipped.length;
             info(`Re-applied: ${applied} applied, ${skipped} skipped`);
+            retryNeeded = false;
+            lastChecksums = await snapshotWatchedChecksums(watchDirs);
         }
         catch (err) {
+            retryNeeded = true;
             warn(classifyWatchApplyError(err));
         }
         finally {
             applyInFlight = false;
-            // Update checksums after apply so the next poll does not re-trigger
-            // for changes that are already reflected in the engine.
-            lastChecksums = await snapshotWatchedChecksums(watchDirs);
         }
         // Another change arrived while we were applying, so run again and the
         // edit is not silently absorbed into the post-apply checksum bump.
@@ -224,7 +228,9 @@ async function runWatchLoop(projectRoot) {
                     return;
                 }
                 const current = await snapshotWatchedChecksums(watchDirs);
-                if (!checksumMapsEqual(current, lastChecksums)) {
+                // A failed apply remains dirty even if source checksums did not
+                // change. The polling interval bounds retries without a busy loop.
+                if (retryNeeded || !checksumMapsEqual(current, lastChecksums)) {
                     triggerApply();
                 }
             }

package/dist/src/commands/furnace/create-templates.js

@@ -80,9 +80,6 @@ class ${className} extends MozLitElement {
   /** @type {Record<string, unknown>} */
   static properties = {};
 
-  constructor() {
-    super();
-  }
 ${lifecycleHooks}
   render() {
     return html\`

package/dist/src/commands/import.js

@@ -30,13 +30,16 @@ function isSafeIoFallback(error) {
     const code = getNodeErrorCode(error);
     return code !== undefined && SAFE_IO_FALLBACK_CODES.has(code);
 }
-/** Concurrency bound for per-file classification (each call spawns git). */
+/** Concurrency bound for per-file classification (reads and patch replays). */
 const UNMANAGED_CLASSIFY_CONCURRENCY = 8;
 async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
     // One manifest+patch-discovery load for the whole batch (the per-call
     // computePatchedContent re-read everything for every file), and bounded
     // concurrency instead of an unbounded Promise.all over git spawns.
-    const { computePatched: computeExpected } = await createPatchedContentContext(patchesDir, engineDir);
+    const { computePatched: computeExpected, prefetchBase } = await createPatchedContentContext(patchesDir, engineDir);
+    // One `git cat-file --batch` for every HEAD blob instead of a `git show`
+    // per dirty file.
+    await prefetchBase(dirtyFiles);
     const classifications = await mapWithConcurrency(dirtyFiles, UNMANAGED_CLASSIFY_CONCURRENCY, async (file) => {
         try {
             const [expected, exists] = await Promise.all([

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

@@ -138,7 +138,7 @@ const SUPPRESSED_SIZE_CHECKS = new Set([
  * filename-prefixed issue rows, and the cache writes, all in the same
  * sequence a serial run produced. Returns the run tallies.
  */
-async function applyPerPatchResults(subset, results, issues, checkJs, cache) {
+async function applyPerPatchResults(subset, results, issues, checkJs, cache, heldNotices) {
     const totals = {
         linted: 0,
         skipped: 0,
@@ -190,6 +190,10 @@ async function applyPerPatchResults(subset, results, issues, checkJs, cache) {
         for (const suppressedIssue of result.suppressedIssues) {
             if (!SUPPRESSED_SIZE_CHECKS.has(suppressedIssue.check))
                 continue;
+            if (heldNotices !== undefined) {
+                heldNotices.push({ check: suppressedIssue.check, patch: patch.filename, suppressed: true });
+                continue;
+            }
             info(`NOTICE [${suppressedIssue.check}] ${patch.filename}: suppressed by lintIgnore — ${suppressedIssue.message}`);
         }
         totals.suppressed += result.suppressedIssues.length;
@@ -232,7 +236,10 @@ async function lintSubsetConcurrently(subset, lintCtx) {
  * prints the per-patch summary, and applies the failure criteria
  * (errors, `--max-warnings`) by throwing GeneralError.
  */
-function reportPerPatchOutcome(issues, linted, skipped, options) {
+function reportPerPatchOutcome(issues, linted, skipped, options, heldNotices) {
+    if (heldNotices !== undefined) {
+        reportNoticeSummary(heldNotices, issues);
+    }
     if (issues.length === 0) {
         if (linted === 0 && skipped > 0) {
             info(`No patches in the queue have been applied to engine/. Run "fireforge import" first if you want lint findings against the staged hunks; otherwise this is expected.`);
@@ -247,8 +254,10 @@ function reportPerPatchOutcome(issues, linted, skipped, options) {
     const errors = issues.filter((i) => i.severity === 'error');
     const warnings = issues.filter((i) => i.severity === 'warning');
     const notices = issues.filter((i) => i.severity === 'notice');
-    for (const issue of notices)
-        info(`NOTICE ${formatPatchLintIssue(issue)}`);
+    if (heldNotices === undefined) {
+        for (const issue of notices)
+            info(`NOTICE ${formatPatchLintIssue(issue)}`);
+    }
     for (const issue of warnings)
         warn(formatPatchLintIssue(issue));
     for (const issue of errors)
@@ -272,6 +281,34 @@ function reportPerPatchOutcome(issues, linted, skipped, options) {
         outro('Lint passed');
     }
 }
+/**
+ * `--notices summary`: one line per check instead of one per finding, for
+ * a green queue whose hundreds of NOTICE lines are reviewed waivers and
+ * under-threshold measurements. The full list stays in `--report`.
+ * Errors and warnings are never summarised.
+ */
+function reportNoticeSummary(heldNotices, issues) {
+    const byCheck = new Map();
+    const tally = (check, patch, suppressed) => {
+        const entry = byCheck.get(check) ?? { count: 0, suppressed: 0, patches: new Set() };
+        entry.count += 1;
+        if (suppressed)
+            entry.suppressed += 1;
+        entry.patches.add(patch);
+        byCheck.set(check, entry);
+    };
+    for (const held of heldNotices)
+        tally(held.check, held.patch, held.suppressed);
+    for (const issue of issues) {
+        if (issue.severity !== 'notice')
+            continue;
+        tally(issue.check, issue.patches?.[0] ?? issue.file.split(' :: ')[0] ?? issue.file, false);
+    }
+    for (const [check, entry] of [...byCheck].sort(([a], [b]) => a.localeCompare(b))) {
+        const suppressed = entry.suppressed > 0 ? `, ${entry.suppressed} of them suppressed by lintIgnore` : '';
+        info(`NOTICE [${check}]: ${entry.count} across ${entry.patches.size} patch(es)${suppressed} (see --report)`);
+    }
+}
 /**
  * Resolves the `--patches <name…>` subset filter against the manifest,
  * matching each requested name tolerantly (exact filename, filename ±
@@ -394,7 +431,8 @@ async function lintPerPatchInner(projectRoot, paths, options = {}) {
         engineHeadSha,
         checkJs,
     });
-    const { linted, skipped, cacheDirty, reusedCacheEntries, suppressed } = await applyPerPatchResults(subset, results, issues, checkJs, cache);
+    const heldNotices = options.notices === 'summary' ? [] : undefined;
+    const { linted, skipped, cacheDirty, reusedCacheEntries, suppressed } = await applyPerPatchResults(subset, results, issues, checkJs, cache, heldNotices);
     for (const issue of lintPatchQueue(ctx)) {
         if (isSubset && !subsetTouchedFiles.has(issue.file))
             continue;
@@ -411,5 +449,5 @@ async function lintPerPatchInner(projectRoot, paths, options = {}) {
     if (options.report !== undefined) {
         await writePerPatchLintReport(options.report, subset, results);
     }
-    reportPerPatchOutcome(issues, linted, skipped, options);
+    reportPerPatchOutcome(issues, linted, skipped, options, heldNotices);
 }

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

@@ -52,6 +52,9 @@ export interface PerRunCheckJs {
     /** True when this file kind participates in the run's checkJs surface
      *  (`.sys.mjs`, plus test scripts when `checkJsTestFiles` is on). */
     isRelevant: (file: string) => boolean;
+    /** The program's roots under `rootScopePatches`, or undefined for the
+     *  whole queue. A file outside it is resolvable but never checked. */
+    rootScope: ReadonlySet<string> | undefined;
 }
 /**
  * Builds the per-run checkJs program controller when `patchLint.checkJs` is

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

@@ -97,5 +97,6 @@ export function buildPerRunCheckJs(projectRoot, paths, config, ctx, rootScopePat
             return issues;
         },
         isRelevant: (file) => file.endsWith('.sys.mjs') || (testFilesEnabled && isTestScriptFile(file)),
+        rootScope: scopedRoots,
     };
 }

package/dist/src/commands/lint.js

@@ -16,6 +16,7 @@ import { collectDiffFilePaths, tagLintIssues } from '../core/patch-lint-diff-tag
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
 import { info, intro, outro, success, warn } from '../utils/logger.js';
+import { addAcceptedWaitLockOption } from '../utils/options.js';
 import { stripEnginePrefix } from '../utils/paths.js';
 import { lintPerPatch } from './lint-per-patch.js';
 /**
@@ -236,6 +237,9 @@ function validateLintFlags(options) {
     if (options.report !== undefined && !options.perPatch) {
         throw new InvalidArgumentError('--report requires --per-patch.', '--report');
     }
+    if (options.notices !== undefined && !options.perPatch) {
+        throw new InvalidArgumentError('--notices requires --per-patch.', '--notices');
+    }
 }
 /**
  * Aggregate-mode patch-size softening: when the linted diff is every
@@ -499,6 +503,7 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         .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>.')
+        .option('--notices <mode>', 'With --per-patch: "full" (default) prints every NOTICE line; "summary" prints one line per check with its count and patch count. The full list stays in --report. Errors and warnings always print in full.')
         .action(withErrorHandling(async (paths, options) => {
         const lintOptions = {};
         if (options.since !== undefined) {
@@ -526,8 +531,16 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         if (options.report !== undefined) {
             lintOptions.report = options.report;
         }
+        if (options.notices !== undefined) {
+            if (options.notices !== 'summary' && options.notices !== 'full') {
+                throw new InvalidArgumentError(`--notices must be "summary" or "full" (got "${options.notices}").`, '--notices');
+            }
+            lintOptions.notices = options.notices;
+        }
         await lintCommand(getProjectRoot(), paths, lintOptions);
     }));
+    // This action also has subcommands; all its wait flags are accept-only.
+    addAcceptedWaitLockOption(lint);
     const lintCache = lint
         .command('cache')
         .description('Manage the per-patch lint result cache')
@@ -540,6 +553,7 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
             'To lint a directory named cache/, disambiguate with a trailing slash: "fireforge lint cache/".');
         return Promise.resolve();
     }));
+    addAcceptedWaitLockOption(lintCache);
     lintCache
         .command('clear')
         .description('Clear cached per-patch lint results')

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

@@ -25,8 +25,7 @@ export interface CommandManifestEntry {
      */
     name: string;
     /**
-     * Short one-line group label, used purely for grouping in generated
-     * documentation. Not surfaced in the CLI itself.
+     * Group label used by the root CLI help and generated documentation.
      */
     group: 'project' | 'workflow' | 'engine' | 'diagnostics' | 'components';
     /** Registers the command (and any subcommands) on the Commander program. */

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

@@ -15,6 +15,7 @@ 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 { GeneralError } from '../../errors/base.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
 import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
 import { proceedAfterDecision } from '../destructive-decision.js';
@@ -43,11 +44,12 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     // 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();
-    if (targetEntry) {
-        for (const fullPath of targetEntry.newFiles.keys()) {
-            targetNewFileLeaves.add(basename(fullPath));
-        }
+    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.
@@ -161,6 +163,18 @@ export async function patchDeleteCommand(projectRoot, identifier, options = {})
     // re-thrown: by that point the mutation has committed, and reporting
     // failure to the caller would mislead.
     await 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)) {
+            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 appendHistoryBestEffort(paths.patches, {
             operation: 'patch-delete',

package/dist/src/commands/re-export-lint.d.ts

@@ -44,8 +44,23 @@ export interface ReExportLintContext {
     /** The pre-existing-queue-errors note is printed once per invocation. */
     queueBaselineWarned: boolean;
 }
-/** Builds the once-per-invocation lint context. */
-export declare function buildReExportLintContext(projectRoot: string, paths: ProjectPaths, config: FireForgeConfig, noCache: boolean): Promise<ReExportLintContext>;
+/**
+ * Builds the once-per-invocation lint context.
+ *
+ * The checkJs program is rooted at the patches being re-exported, exactly as
+ * `lint --per-patch --patches` roots it at its subset: the rest of the
+ * queue stays resolvable, so cross-patch imports type-check identically,
+ * but nothing else is parsed or checked. Unscoped, a one-patch re-export
+ * that missed the lint cache type-checked the whole queue (76 s on a
+ * 401-patch queue) to report on one patch.
+ *
+ * @param projectRoot - FireForge project root
+ * @param paths - Resolved project paths
+ * @param config - Loaded configuration
+ * @param noCache - Skip the per-patch lint result cache (`--no-cache`)
+ * @param scopePatches - Filenames of the patches this run re-exports
+ */
+export declare function buildReExportLintContext(projectRoot: string, paths: ProjectPaths, config: FireForgeConfig, noCache: boolean, scopePatches: ReadonlySet<string>): Promise<ReExportLintContext>;
 /** Fresh lint payload carried to the post-write cache store. */
 export interface ReExportLintResult {
     issues: PatchLintIssue[];

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

@@ -32,15 +32,39 @@ import { reportPatchLintOutcome } from './export-shared.js';
 import { buildPerRunCheckJs } from './lint-per-run-checkjs.js';
 import { projectEntryBody } from './patch/entry-projection.js';
 import { formatForwardImportRemedy } from './re-export-scan.js';
-/** Builds the once-per-invocation lint context. */
-export async function buildReExportLintContext(projectRoot, paths, config, noCache) {
+/**
+ * Builds the once-per-invocation lint context.
+ *
+ * The checkJs program is rooted at the patches being re-exported, exactly as
+ * `lint --per-patch --patches` roots it at its subset: the rest of the
+ * queue stays resolvable, so cross-patch imports type-check identically,
+ * but nothing else is parsed or checked. Unscoped, a one-patch re-export
+ * that missed the lint cache type-checked the whole queue (76 s on a
+ * 401-patch queue) to report on one patch.
+ *
+ * @param projectRoot - FireForge project root
+ * @param paths - Resolved project paths
+ * @param config - Loaded configuration
+ * @param noCache - Skip the per-patch lint result cache (`--no-cache`)
+ * @param scopePatches - Filenames of the patches this run re-exports
+ */
+export async function buildReExportLintContext(projectRoot, paths, config, noCache, scopePatches) {
     const patchQueueCtx = (await pathExists(paths.patches))
         ? await buildPatchQueueContext(paths.patches, config)
         : undefined;
     const checkJs = patchQueueCtx
-        ? buildPerRunCheckJs(projectRoot, paths, config, patchQueueCtx)
+        ? buildPerRunCheckJs(projectRoot, paths, config, patchQueueCtx, scopePatches)
         : undefined;
     const cache = noCache ? undefined : await loadPerPatchLintCache(projectRoot);
+    if (patchQueueCtx) {
+        // The queue rules and the projection below read every patch, so the
+        // wait is named rather than left behind one spinner line.
+        info(`Lint scope: queue rules over all ${patchQueueCtx.entries.length} patch(es); ` +
+            `checkJs rooted at the ${scopePatches.size} re-exported patch(es); ` +
+            (cache === undefined
+                ? 'lint cache off (--no-cache).'
+                : `lint cache ${Object.keys(cache.entries).length === 0 ? 'empty' : 'loaded'}.`));
+    }
     const engineHeadSha = cache ? await getPerPatchLintCacheHeadSha(paths.engine) : undefined;
     return {
         projectRoot,
@@ -123,7 +147,12 @@ export async function lintReExportedPatch(args) {
     lintOptions.onSuppressed = (suppressed) => suppressedIssues.push(...suppressed);
     if (checkJs) {
         const created = checkJsFilesInDiff(diffContent, checkJs);
-        const allKnown = [...created].every((f) => checkJs.resolutionSet.has(f));
+        if (created.size > 0) {
+            info(`checkJs: type-checking ${created.size} file(s) of ${patch.filename} (lint cache ${cache ? 'miss' : 'off'}).`);
+        }
+        // A file the scoped program does not root at would be resolvable but
+        // never checked, so it takes the per-patch build too.
+        const allKnown = [...created].every((f) => checkJs.resolutionSet.has(f) && (checkJs.rootScope?.has(f) ?? true));
         if (allKnown) {
             // Slice this patch's findings out of the one queue-wide program.
             lintOptions.precomputedCheckJs = await checkJs.sliceFor(created);

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

@@ -63,8 +63,15 @@ function validateWhitelistFlagDependencies(options) {
         throw new InvalidArgumentError('--expect-unmanaged names approved exceptions to --refuse-adjacent-unmanaged and has no effect without it. Pass --refuse-adjacent-unmanaged, or drop --expect-unmanaged.', '--expect-unmanaged');
     }
 }
+function validateExpectedRemovalUsage(patches, options) {
+    if (options.expectRemoved?.length &&
+        (options.scan || options.all || options.files !== undefined || patches.length === 0)) {
+        throw new InvalidArgumentError('--expect-removed requires explicit selected patches and the scan-less path (no --scan, --files, or --all).', '--expect-removed');
+    }
+}
 /** Validates mutually exclusive `re-export` targeting and metadata options. */
 export function validateReExportOptionCombinations(patches, options) {
+    validateExpectedRemovalUsage(patches, options);
     if (options.files !== undefined) {
         if (options.all || options.scan) {
             throw new InvalidArgumentError('--files cannot be combined with --scan or --all.', '--files');

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

@@ -30,6 +30,7 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .option('--refuse-foreign-drift', "Refuse a scan-less re-export (non-zero exit, patch not written) when the refreshed body would absorb engine lines not present in the old patch body — protects multi-session checkouts from silently capturing another session's uncommitted edits. Mutually exclusive with --scan and --files.")
         .option('--expect <path>', "With --refuse-foreign-drift, name an engine-relative file whose drift is this session's intended edit: drift confined to --expect files proceeds, drift anywhere else still refuses. Repeatable, and the whitelist applies across EVERY patch in this invocation, not per patch — so pass all the patches and all their --expect paths in one call rather than looping one patch at a time.", ...stringListOption())
         .option('--expect-unmanaged <path>', 'With --refuse-adjacent-unmanaged, name an engine-relative file that is a REVIEWED, recorded exception to the adjacency refusal: an approved unmanaged path is still listed, but no longer refuses. Repeatable, and the carve-out applies across EVERY patch in this invocation, not per patch. Use it to keep the belt armed for everything else instead of dropping --refuse-adjacent-unmanaged entirely.', ...stringListOption())
+        .option('--expect-removed <path>', 'Retire an absent file created by the selected patch while keeping scan-less refusals armed. Repeatable.', ...stringListOption())
         .option('--dry-run', 'Show what would change without writing')
         .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
         .option('--no-cache', 'Bypass per-patch lint result cache reads and writes for this re-export')

package/dist/src/commands/re-export-removed.d.ts

@@ -0,0 +1,4 @@
+import type { PatchMetadata, ReExportOptions } from '../types/commands/index.js';
+import type { ProjectPaths } from '../types/config.js';
+/** Validates every retirement before any patch is written; typos never silently grant a carve-out. */
+export declare function validateExpectedRemovals(paths: ProjectPaths, patches: PatchMetadata[], options: ReExportOptions): Promise<string[]>;

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

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { lstat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { listTrackedInHead } from '../core/git-file-ops.js';
+import { parseDiffSections } from '../core/patch-parse.js';
+import { InvalidArgumentError } from '../errors/base.js';
+import { getNodeErrorCode } from '../utils/errors.js';
+import { readText } from '../utils/fs.js';
+import { normalizeEngineRelativeInput } from './re-export-scan.js';
+/** Validates every retirement before any patch is written; typos never silently grant a carve-out. */
+export async function validateExpectedRemovals(paths, patches, options) {
+    const removed = [
+        ...new Set((options.expectRemoved ?? []).map((file) => normalizeEngineRelativeInput(file, '--expect-removed'))),
+    ];
+    if (removed.length === 0)
+        return removed;
+    const tracked = await listTrackedInHead(paths.engine, removed);
+    for (const file of removed) {
+        const owners = patches.filter((patch) => patch.filesAffected.includes(file));
+        if (owners.length !== 1 ||
+            tracked.has(file) ||
+            (await removalPathPresent(join(paths.engine, file)))) {
+            throw new InvalidArgumentError(`--expect-removed ${file} must be absent, untracked in engine HEAD, and owned by exactly one selected patch.`, '--expect-removed');
+        }
+        const owner = owners[0];
+        if (!owner)
+            throw new InvalidArgumentError(`No selected owner for ${file}`, '--expect-removed');
+        const body = await readText(join(paths.patches, owner.filename));
+        if (!parseDiffSections(body).some((section) => section.targetPath === file && section.isNewFile)) {
+            throw new InvalidArgumentError(`--expect-removed ${file} was not created by its selected patch.`, '--expect-removed');
+        }
+        if (owner.filesAffected.every((path) => removed.includes(path))) {
+            throw new InvalidArgumentError('Retiring every file would empty the patch; use patch delete instead.', '--expect-removed');
+        }
+    }
+    return removed;
+}
+/** A dangling symlink is still an existing owned path, not an approved absence. */
+async function removalPathPresent(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (getNodeErrorCode(error) === 'ENOENT')
+            return false;
+        throw error;
+    }
+}

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

@@ -41,7 +41,10 @@ export async function reExportSinglePatchWithIndexLockRetry(args) {
 }
 async function reExportSinglePatch(args) {
     const { patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx } = args;
-    let currentFilesAffected = [...patch.filesAffected];
+    const removed = new Set(options.expectRemoved ?? []);
+    let currentFilesAffected = patch.filesAffected.filter((file) => !removed.has(file));
+    for (const file of patch.filesAffected.filter((path) => removed.has(path)))
+        info(`  - ${file} (--expect-removed)`);
     // --- Scan for new/removed files ---
     if (options.scan) {
         const scanResult = await scanPatchFilesForReExport({

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

@@ -15,6 +15,7 @@ import { warnUnseenExpectedDrift } from './re-export-drift.js';
 import { reExportFilesInPlace } from './re-export-files.js';
 import { buildReExportLintContext, finishReExportLint } from './re-export-lint.js';
 import { applyReExportFilesPositionalFolding, validateReExportOptionCombinations, } from './re-export-options.js';
+import { validateExpectedRemovals } from './re-export-removed.js';
 import { normalizeEngineRelativeInput, normalizeScanFiles } from './re-export-scan.js';
 import { reExportSinglePatchWithIndexLockRetry } from './re-export-single.js';
 async function resolveSelectedPatches(patches, options, manifest) {
@@ -98,6 +99,9 @@ export async function reExportCommand(projectRoot, patches, options) {
         outro('Nothing to re-export');
         return;
     }
+    const expectedRemovals = await validateExpectedRemovals(paths, selectedPatches, options);
+    if (expectedRemovals.length > 0)
+        options = { ...options, expectRemoved: expectedRemovals };
     if (scanFilesByPatch !== undefined) {
         info(`Bulk scan assignments from ${options.scanFilesManifest}`);
         for (const patch of selectedPatches) {
@@ -132,12 +136,14 @@ export async function reExportCommand(projectRoot, patches, options) {
     const driftCtx = buildForeignDriftContext(options);
     // Hoisted lint context, one per run: queue context + checkJs
     // program + per-patch result cache, shared across every loop iteration.
-    const lintCtx = await buildReExportLintContext(projectRoot, paths, config, options.noCache === true);
+    // Taken before the context build, so the elapsed time the progress line
+    // reports includes it.
+    const startedAt = Date.now();
+    const lintCtx = await buildReExportLintContext(projectRoot, paths, config, options.noCache === true, new Set(selectedPatches.map((patch) => patch.filename)));
     let reExported = 0;
     const reExportedFilenames = [];
     const failedFilenames = [];
     const progress = spinner('Preparing re-export...');
-    const startedAt = Date.now();
     await withDryRunReExportLock(paths.fireforgeDir, isDryRun, async () => withDryRunPurityGuard(paths.engine, paths.patches, isDryRun, async () => {
         for (const [index, patch] of selectedPatches.entries()) {
             const assignedScanFiles = scanFilesByPatch?.get(patch.filename);

package/dist/src/commands/rebase/confirm.d.ts

@@ -22,10 +22,21 @@ export interface DirtyEngineConfirmationOptions {
     warningMessage: string;
     promptMessage: string;
     cancelMessage: string;
+    /**
+     * Precomputed dirtiness. A caller that already measured what would be
+     * lost (and may count more than the working tree, such as commits made
+     * on top of the base) passes it here instead of the `hasChanges` probe.
+     */
+    dirty?: boolean;
+    /**
+     * Replaces the generic "Engine has uncommitted changes" opening of the
+     * non-interactive refusal, so the refusal names what would be lost.
+     */
+    refusalDetail?: string;
 }
 /**
  * Checks if the engine has uncommitted changes and prompts for confirmation.
  * Returns true if safe to proceed, false if the user cancelled.
  * Throws in non-interactive mode without --yes.
  */
-export declare function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCommand, argumentName, warningMessage, promptMessage, cancelMessage, }: DirtyEngineConfirmationOptions): Promise<boolean>;
+export declare function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCommand, argumentName, warningMessage, promptMessage, cancelMessage, dirty, refusalDetail, }: DirtyEngineConfirmationOptions): Promise<boolean>;

package/dist/src/commands/rebase/confirm.js

@@ -12,13 +12,16 @@ import { cancel, isCancel, warn } from '../../utils/logger.js';
  * Returns true if safe to proceed, false if the user cancelled.
  * Throws in non-interactive mode without --yes.
  */
-export async function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCommand, argumentName, warningMessage, promptMessage, cancelMessage, }) {
-    if (!(await hasChanges(engineDir)) || yes) {
+export async function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCommand, argumentName, warningMessage, promptMessage, cancelMessage, dirty, refusalDetail, }) {
+    if (yes || !(dirty ?? (await hasChanges(engineDir)))) {
         return true;
     }
     const isInteractive = stdioIsInteractive();
     if (!isInteractive) {
-        throw new InvalidArgumentError(`Engine has uncommitted changes and interactive confirmation is not available. Run: ${nonInteractiveCommand}`, argumentName);
+        const opening = refusalDetail !== undefined
+            ? `${refusalDetail} Interactive confirmation is not available.`
+            : 'Engine has uncommitted changes and interactive confirmation is not available.';
+        throw new InvalidArgumentError(`${opening} Run: ${nonInteractiveCommand}`, argumentName);
     }
     warn(warningMessage);
     const confirmed = await confirm({