@hominis/fireforge 0.44.4 → 0.46.0

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

@@ -101,7 +101,7 @@ function summarizeForeignHunks(payload, foreignAdded, foreignRemoved) {
                 }
             }
             if (added > 0 || removed > 0) {
-                summaries.push(`@@ -${String(hunk.oldStart)},${String(hunk.oldCount)} +${String(hunk.newStart)},${String(hunk.newCount)} @@ (+${String(added)}/-${String(removed)})`);
+                summaries.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@ (+${added}/-${removed})`);
             }
         }
     }
@@ -184,7 +184,7 @@ export async function reportForeignDrift(args) {
     const recentlyEdited = await findFilesEditedSinceLastExport(engineDir, oldPath, drift.map((d) => d.file));
     const totalLines = drift.reduce((sum, d) => sum + d.addedLines + d.removedLines, 0);
     const lineNoun = totalLines === 1 ? 'line' : 'lines';
-    warn(`${patch.filename}: refreshed body absorbs ${String(totalLines)} ${lineNoun} not present in the old patch body (${String(drift.length)} file(s)):`);
+    warn(`${patch.filename}: refreshed body absorbs ${totalLines} ${lineNoun} not present in the old patch body (${drift.length} file(s)):`);
     for (const entry of drift.slice(0, MAX_FILES_REPORTED)) {
         const expectedTag = ctx.expectedDriftFiles.has(entry.file) ? ' (expected via --expect)' : '';
         const authorshipTag = recentlyEdited.has(entry.file)
@@ -194,13 +194,13 @@ export async function reportForeignDrift(args) {
             info(`  ${entry.file}: binary content changed${expectedTag}${authorshipTag}`);
             continue;
         }
-        info(`  ${entry.file}: +${String(entry.addedLines)}/-${String(entry.removedLines)} newly captured line(s)${expectedTag}${authorshipTag}`);
+        info(`  ${entry.file}: +${entry.addedLines}/-${entry.removedLines} newly captured line(s)${expectedTag}${authorshipTag}`);
         for (const summary of entry.hunkSummaries) {
             info(`    ${summary}`);
         }
     }
     if (drift.length > MAX_FILES_REPORTED) {
-        info(`  +${String(drift.length - MAX_FILES_REPORTED)} more file(s)`);
+        info(`  +${drift.length - MAX_FILES_REPORTED} more file(s)`);
     }
     if (ctx.refuseForeignDrift) {
         if (unexpected.length === 0) {
@@ -271,3 +271,64 @@ function refuseUnreadableBaseline(ctx, patchFilename, detail) {
     warn(`${patchFilename}: skipped (--refuse-foreign-drift) — ${detail}; the drift comparison cannot run, refusing fail-closed.`);
     return true;
 }
+/**
+ * States, verbatim in the notice, WHAT the `--expect` whitelist is compared
+ * against and WHEN. This notice is the only feedback an operator gets that
+ * the drift belt looked at the files they named, and a downstream report
+ * showed the previous copy actively misleading: it warned "showed no drift"
+ * over an edit that WAS captured correctly, and none of the causes it named
+ * held, so the operator's only recourse was `grep -c` on the written body.
+ *
+ * The measurement, stated exactly:
+ *
+ *  - COMPARED: for each file already in the patch's `filesAffected`, the
+ *    `+`/`-` payload lines the REFRESHED body carries that the OLD patch
+ *    body did not (`computeForeignDrift`). It is a content comparison, and
+ *    it is ONE-DIRECTIONAL: excess in the new body only.
+ *  - WHEN: per patch, on the body about to be written, BEFORE the write —
+ *    never against post-write state.
+ *
+ * The one-directional half is what the earlier copy hid, and it is the
+ * cause the report's first shape actually hit: deleting a line from an
+ * engine file makes the refreshed body DROP that file's `+` line. Nothing
+ * is absorbed, so by design there is no drift to see — the belt exists to
+ * catch a concurrent session's edits being silently swallowed INTO a body,
+ * not every difference between two bodies. Naming it is the fix; widening
+ * the comparison would turn every ordinary line removal into a refusal.
+ */
+const EXPECT_MEASUREMENT_NOTE = '--expect is evaluated against CONTENT, before the write: for each file already in the ' +
+    "patch's filesAffected, the payload lines the refreshed body carries that the old patch " +
+    'body did not. It never looks at post-write state.';
+/**
+ * Names `--expect` paths that never drifted this run. A typo'd
+ * `--expect` path silently degrades the flag back to refusing the slice it
+ * was meant to admit, so surface the mismatch — but only as a warning: an
+ * expected file legitimately shows no drift in several shapes, all named
+ * below.
+ */
+export function warnUnseenExpectedDrift(driftCtx) {
+    const unseen = [...driftCtx.expectedDriftFiles].filter((file) => !driftCtx.expectedSeen.has(file));
+    if (unseen.length === 0)
+        return;
+    if (driftCtx.evaluationRuns === 0) {
+        warn(`--expect path(s) were not evaluated because no selected patch reached the drift check (for example, an earlier refusal): ${unseen.join(', ')}`);
+        return;
+    }
+    warn('--expect path(s) showed no drift this run: ' +
+        `${unseen.join(', ')}.\n` +
+        `${EXPECT_MEASUREMENT_NOTE}\n` +
+        'Causes, in rough order of likelihood:\n' +
+        '  1. Your edit only REMOVED lines from the body (you deleted a line from the engine ' +
+        'file). The comparison is one-directional — it reports lines ABSORBED into the body — ' +
+        'so a correctly captured deletion is not drift and never will be. Confirm the capture ' +
+        'with "grep -c" on the written patch body.\n' +
+        "  2. A typo in the path, or a path not in the patch's filesAffected (files adopted " +
+        'this run via --scan/--scan-file are excluded from the comparison by design).\n' +
+        '  3. Adoption already captured it: a "re-export <p> --scan --scan-file <f>" run also ' +
+        "captures that patch's other drifted files, so a scan-less re-export afterwards " +
+        'legitimately sees nothing left to absorb. Informational — a chain that treats this ' +
+        'warning as an error will false-red on it.\n' +
+        '  4. The slice was already captured by an earlier export in this session.\n' +
+        '  5. The engine content already matches the patch body — a concurrent session may have ' +
+        'exported the same change, so the drift converged before this run looked.');
+}

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

@@ -1,6 +1,5 @@
-import { getProjectPaths } from '../core/config.js';
 import type { PatchMetadata, ReExportOptions } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
+import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
 /**
  * Handles `re-export --files` end-to-end: computes the projected diff, runs
  * the per-patch and cross-patch lint against a context in which the target
@@ -13,4 +12,4 @@ import type { FireForgeConfig } from '../types/config.js';
  * generic single-patch helper is what makes the projection lint run against
  * the current (unchanged) queue instead of the projected state.
  */
-export declare function reExportFilesInPlace(paths: ReturnType<typeof getProjectPaths>, selectedPatches: PatchMetadata[], options: ReExportOptions, config: FireForgeConfig): Promise<void>;
+export declare function reExportFilesInPlace(paths: ProjectPaths, selectedPatches: PatchMetadata[], options: ReExportOptions, config: FireForgeConfig): Promise<void>;

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

@@ -1,21 +1,20 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { getProjectPaths } from '../core/config.js';
 import { appendHistory, confirmDestructive, } from '../core/destructive.js';
 import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { listTrackedInHead } from '../core/git-file-ops.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
 import { updatePatchAndMetadata } from '../core/patch-export.js';
-import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, formatPatchLintIssue, lintPatchQueue, } from '../core/patch-lint.js';
+import { buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../core/patch-lint.js';
 import { computeProjectedLintRegressions } from '../core/patch-lint-projection.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
-import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
 import { InvalidArgumentError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
 import { info, outro, success, warn } from '../utils/logger.js';
 import { runPatchLint } from './export-shared.js';
+import { projectEntryBody } from './patch/entry-projection.js';
 /**
  * Computes the effective `tier` and `lintIgnore` carrying both the patch's
  * existing values and the CLI flag overrides.
@@ -42,20 +41,11 @@ function resolveEffectiveTierAndLintIgnore(target, options) {
  */
 async function runProjectedCrossPatchLint(patchesDir, targetFilename, projectedDiff) {
     const baseCtx = await buildPatchQueueContext(patchesDir);
-    const projectedNewFiles = new Map();
-    for (const path of detectNewFilesInDiff(projectedDiff)) {
-        projectedNewFiles.set(path, extractNewFileContentFromDiff(projectedDiff, path));
-    }
-    const projectedModifiedFileAdditions = buildModifiedFileAdditionsFromDiff(projectedDiff);
+    const projection = projectEntryBody(projectedDiff);
     const projectedEntries = baseCtx.entries.map((entry) => {
         if (entry.filename !== targetFilename)
             return entry;
-        return {
-            ...entry,
-            diff: projectedDiff,
-            newFiles: projectedNewFiles,
-            modifiedFileAdditions: projectedModifiedFileAdditions,
-        };
+        return { ...entry, ...projection };
     });
     const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
     const projectedIssues = lintPatchQueue({ entries: projectedEntries }).filter((i) => i.severity === 'error');
@@ -238,7 +228,16 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     const patchQueueCtx = (await pathExists(paths.patches))
         ? await buildPatchQueueContext(paths.patches)
         : undefined;
-    await runPatchLint(paths.engine, actualProjectedFiles, projectedDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, effectiveTier);
+    await runPatchLint({
+        engineDir: paths.engine,
+        filesAffected: actualProjectedFiles,
+        diffContent: projectedDiff,
+        config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks,
+        patchTier: effectiveTier,
+    });
     const conflicts = await runProjectedCrossPatchLint(paths.patches, target.filename, projectedDiff);
     const filesUpdates = buildFilesModeMetadataUpdates(actualProjectedFiles, options, effectiveLintIgnore, flagIgnoreSet);
     const manifest = await loadPatchesManifest(paths.patches);
@@ -276,23 +275,30 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     // as the mutation (via the onCommitted hook) so two concurrent re-exports
     // cannot interleave records and a crash between mutation and append cannot
     // orphan the audit trail.
-    await updatePatchAndMetadata(paths.patches, target.filename, projectedDiff, filesUpdates, async () => {
-        await appendHistory(paths.patches, {
-            operation: 're-export-files',
-            args: {
-                filename: target.filename,
-                files: actualProjectedFiles,
-                previousFiles: target.filesAffected,
-                deletionsCaptured: deletedFiles,
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-            result: 'ok',
-        });
-    }, {
-        config,
-        command: 're-export --files',
-        forceUnsafe: options.forceUnsafe === true,
+    await updatePatchAndMetadata({
+        patchesDir: paths.patches,
+        filename: target.filename,
+        newContent: projectedDiff,
+        updates: filesUpdates,
+        onCommitted: async () => {
+            await appendHistory(paths.patches, {
+                operation: 're-export-files',
+                args: {
+                    filename: target.filename,
+                    files: actualProjectedFiles,
+                    previousFiles: target.filesAffected,
+                    deletionsCaptured: deletedFiles,
+                },
+                ...(options.yes === true ? { yes: true } : {}),
+                ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
+                result: 'ok',
+            });
+        },
+        policyGate: {
+            config,
+            command: 're-export --files',
+            forceUnsafe: options.forceUnsafe === true,
+        },
     });
     success(`Re-exported ${target.filename}`);
     outro('Re-export complete');

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

@@ -19,16 +19,15 @@
  *   (`refreshQueueCtxEntry`), so later iterations of an `--all` run lint
  *   against the just-refreshed body instead of the stale one.
  */
-import { getProjectPaths, loadConfig } from '../core/config.js';
 import { type PatchQueueContext } from '../core/patch-lint.js';
 import { type PerPatchLintCacheFile } from '../core/patch-lint-cache.js';
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
+import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
 import { type PerRunCheckJs } from './lint-per-run-checkjs.js';
 /** Per-invocation lint context, built once and threaded through the loop. */
 export interface ReExportLintContext {
     projectRoot: string;
-    paths: ReturnType<typeof getProjectPaths>;
+    paths: ProjectPaths;
     config: FireForgeConfig;
     /** Whole-queue context, built WITH config so the forward-import hints
      * match `lint --per-patch`; undefined when no patches dir. */
@@ -44,7 +43,7 @@ export interface ReExportLintContext {
     globalsEmitted: boolean;
 }
 /** Builds the once-per-invocation lint context. */
-export declare function buildReExportLintContext(projectRoot: string, paths: ReturnType<typeof getProjectPaths>, config: Awaited<ReturnType<typeof loadConfig>>, noCache: boolean): Promise<ReExportLintContext>;
+export declare function buildReExportLintContext(projectRoot: string, paths: ProjectPaths, config: FireForgeConfig, noCache: boolean): 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

@@ -20,7 +20,6 @@
  *   (`refreshQueueCtxEntry`), so later iterations of an `--all` run lint
  *   against the just-refreshed body instead of the stale one.
  */
-import { getProjectPaths, loadConfig } from '../core/config.js';
 import { buildPatchQueueContext, countNonBinaryDiffLines, detectNewFilesInDiff, lintExportedPatch, resolvePatchSizeTier, } from '../core/patch-lint.js';
 import { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, getPerPatchLintCacheHeadSha, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/patch-lint-cache.js';
 import { invalidateNewFileCreatorsCache } from '../core/patch-lint-cross.js';
@@ -169,7 +168,15 @@ export async function storeReExportLintResult(lintCtx, patchFilename, projectedM
         queueContext: patchQueueCtx,
         ...(lintCtx.engineHeadSha === undefined ? {} : { engineHeadSha: lintCtx.engineHeadSha }),
     });
-    setCachedPerPatchLintIssues(cache, patchFilename, cacheKey, result.issues, result.suppressed, result.lineCount, result.lintIgnore);
+    setCachedPerPatchLintIssues({
+        cache,
+        patchFilename,
+        key: cacheKey,
+        issues: result.issues,
+        suppressed: result.suppressed,
+        lineCount: result.lineCount,
+        lintIgnore: result.lintIgnore,
+    });
     lintCtx.cacheDirty = true;
 }
 /**

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

@@ -45,6 +45,24 @@ export function applyReExportFilesPositionalFolding(patches, options) {
     }
     return { patches: normalized.patches, options: normalized.options };
 }
+/**
+ * Each carve-out flag is inert without the refusal it modifies, and a
+ * silently-inert whitelist is the worst shape: the operator believes an
+ * exception is in force while the refusal it was meant to relax was never
+ * armed. Refuse the combination instead of ignoring it.
+ */
+function validateWhitelistFlagDependencies(options) {
+    if (options.expect !== undefined &&
+        options.expect.length > 0 &&
+        options.refuseForeignDrift !== true) {
+        throw new InvalidArgumentError('--expect names files whose drift is expected under --refuse-foreign-drift and has no effect without it. Pass --refuse-foreign-drift, or drop --expect.', '--expect');
+    }
+    if (options.expectUnmanaged !== undefined &&
+        options.expectUnmanaged.length > 0 &&
+        options.refuseAdjacentUnmanaged !== true) {
+        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');
+    }
+}
 /** Validates mutually exclusive `re-export` targeting and metadata options. */
 export function validateReExportOptionCombinations(patches, options) {
     if (options.files !== undefined) {
@@ -83,11 +101,7 @@ export function validateReExportOptionCombinations(patches, options) {
     if (options.refuseForeignDrift === true && (options.scan || options.files !== undefined)) {
         throw new InvalidArgumentError('--refuse-foreign-drift applies to the scan-less path only and cannot be combined with --scan or --files (those explicitly capture the current engine state).', '--refuse-foreign-drift');
     }
-    if (options.expect !== undefined &&
-        options.expect.length > 0 &&
-        options.refuseForeignDrift !== true) {
-        throw new InvalidArgumentError('--expect names files whose drift is expected under --refuse-foreign-drift and has no effect without it. Pass --refuse-foreign-drift, or drop --expect.', '--expect');
-    }
+    validateWhitelistFlagDependencies(options);
     const usingTierFlag = options.tier !== undefined;
     const usingLintIgnoreFlag = options.lintIgnore !== undefined && options.lintIgnore.length > 0;
     if (options.all && (usingTierFlag || usingLintIgnoreFlag)) {

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

@@ -29,6 +29,7 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .option('--refuse-adjacent-unmanaged', 'Refuse a scan-less re-export (non-zero exit, patch not written) when unmanaged files exist adjacent to the patch ownership, instead of warning. Mutually exclusive with --scan and --files.')
         .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('--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')
@@ -40,7 +41,7 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .addOption(new Option('--tier <tier>', 'Force a tier override on the selected patch (only "branding" recognised). Mutually exclusive with --all.').choices(['branding']))
         .option('--lint-ignore <check-id>', 'Append a lint check ID to the patch\'s PatchMetadata.lintIgnore (union, de-duped, repeatable). Mutually exclusive with --all. Use "fireforge patch lint-ignore" for --remove / --clear.', ...stringListOption());
     addWaitLockOption(reExport).action(withErrorHandling(async (patches, options) => {
-        const { tier, lintIgnore, scanFile, scanFiles, cache, expect, ...rest } = options;
+        const { tier, lintIgnore, scanFile, scanFiles, cache, expect, expectUnmanaged, ...rest } = options;
         const projectRoot = getProjectRoot();
         await withEngineSessionLock(projectRoot, 're-export', () => reExportCommand(projectRoot, patches, {
             ...pickDefined(rest),
@@ -49,6 +50,9 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
             ...(tier !== undefined ? { tier: tier } : {}),
             ...(lintIgnore !== undefined && lintIgnore.length > 0 ? { lintIgnore } : {}),
             ...(expect !== undefined && expect.length > 0 ? { expect } : {}),
+            ...(expectUnmanaged !== undefined && expectUnmanaged.length > 0
+                ? { expectUnmanaged }
+                : {}),
             ...(cache === false ? { noCache: true } : {}),
         }), { waitLockSeconds: resolveWaitLockSeconds(options.waitLock) });
     }));

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

@@ -5,10 +5,11 @@ import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { listTrackedInHead } from '../core/git-file-ops.js';
 import { getModifiedFilesInDir, getUntrackedFilesInDir } from '../core/git-status.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
-import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, lintPatchQueue, } from '../core/patch-lint.js';
+import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, lintPatchQueue, } from '../core/patch-lint.js';
+import { detectNewFilesInDiff } from '../core/patch-lint-diff.js';
 import { computeProjectedLintRegressions } from '../core/patch-lint-projection.js';
 import { getClaimedFiles } from '../core/patch-manifest.js';
-import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
+import { buildNewFileTextProjection } from '../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { mapWithConcurrency } from '../utils/concurrency.js';
 import { pathExists } from '../utils/fs.js';
@@ -135,14 +136,14 @@ export async function confirmBroadScanAdditions(args) {
     if (isDryRun || yes || !scanAdditionsNeedConfirmation(added))
         return true;
     const dirCount = new Set(added.map((f) => dirname(f))).size;
-    warn(`${patchFilename}: --scan would add ${String(added.length)} file(s) that span ${String(dirCount)} director${dirCount === 1 ? 'y' : 'ies'}. ` +
+    warn(`${patchFilename}: --scan would add ${added.length} file(s) that span ${dirCount} director${dirCount === 1 ? 'y' : 'ies'}. ` +
         'Broad scans can silently pull adjacent features into a patch — review the diff before continuing.');
     if (!isInteractive) {
         throw new GeneralError(`Refusing to broaden "${patchFilename}" via --scan in non-interactive mode. ` +
             'Pass --yes to acknowledge the expansion, or run with --dry-run first to review.');
     }
     const confirmed = await confirm({
-        message: `Proceed and broaden ${patchFilename} with ${String(added.length)} newly discovered file(s)?`,
+        message: `Proceed and broaden ${patchFilename} with ${added.length} newly discovered file(s)?`,
         initialValue: false,
     });
     if (isCancel(confirmed) || !confirmed) {
@@ -176,10 +177,8 @@ export async function assertScanAdoptionsHaveNoForwardImports(args) {
     const candidateDiff = await getDiffForFilesAgainstHead(engineDir, [...added]);
     if (!candidateDiff.trim())
         return;
-    const candidateNewFiles = new Map();
-    for (const path of detectNewFilesInDiff(candidateDiff)) {
-        candidateNewFiles.set(path, extractNewFileContentFromDiff(candidateDiff, path));
-    }
+    const candidateNewFiles = buildNewFileTextProjection(candidateDiff);
+    const candidateCreations = detectNewFilesInDiff(candidateDiff);
     const candidateAdditions = buildModifiedFileAdditionsFromDiff(candidateDiff);
     const baseCtx = await buildPatchQueueContext(patchesDir);
     const projectedEntries = baseCtx.entries.map((entry) => {
@@ -189,6 +188,7 @@ export async function assertScanAdoptionsHaveNoForwardImports(args) {
             ...entry,
             diff: `${entry.diff}\n${candidateDiff}`,
             newFiles: new Map([...entry.newFiles, ...candidateNewFiles]),
+            createdFiles: new Set([...entry.createdFiles, ...candidateCreations]),
             modifiedFileAdditions: new Map([...entry.modifiedFileAdditions, ...candidateAdditions]),
         };
     });

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

@@ -4,12 +4,31 @@
  * loop calls {@link reExportSinglePatchWithIndexLockRetry} per selected
  * patch.
  */
-import { getProjectPaths } from '../core/config.js';
 import type { PatchesManifest, PatchMetadata, ReExportOptions } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
+import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
 import type { AdjacentUnmanagedContext } from './re-export-adjacent.js';
 import type { ForeignDriftContext } from './re-export-drift.js';
 import { type ReExportLintContext } from './re-export-lint.js';
+export interface ReExportSinglePatchArgs {
+    /** Manifest row for the patch being refreshed. */
+    patch: PatchMetadata;
+    /** Resolved project paths. */
+    paths: ProjectPaths;
+    /** Patch queue manifest as loaded by the orchestrator. */
+    manifest: PatchesManifest;
+    /** Effective re-export options for this patch. */
+    options: ReExportOptions;
+    /** Whether the run is a dry run. */
+    isDryRun: boolean;
+    /** Project configuration. */
+    config: FireForgeConfig;
+    /** Adjacent-unmanaged-file reporting context. */
+    adjacentCtx: AdjacentUnmanagedContext;
+    /** Foreign-drift reporting context. */
+    driftCtx: ForeignDriftContext;
+    /** Per-patch lint context, including the shared lint cache. */
+    lintCtx: ReExportLintContext;
+}
 /**
  * Retries a single patch re-export exactly once when the failure is
  * transient git `index.lock` contention (an external git process holding
@@ -17,4 +36,4 @@ import { type ReExportLintContext } from './re-export-lint.js';
  * from the top, so it re-reads clean state; a second lock failure
  * propagates to the loop's honest "N of M" accounting.
  */
-export declare function reExportSinglePatchWithIndexLockRetry(patch: PatchMetadata, paths: ReturnType<typeof getProjectPaths>, manifest: PatchesManifest, options: ReExportOptions, isDryRun: boolean, config: FireForgeConfig, adjacentCtx: AdjacentUnmanagedContext, driftCtx: ForeignDriftContext, lintCtx: ReExportLintContext): Promise<boolean>;
+export declare function reExportSinglePatchWithIndexLockRetry(args: ReExportSinglePatchArgs): Promise<boolean>;

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

@@ -5,7 +5,6 @@
  * loop calls {@link reExportSinglePatchWithIndexLockRetry} per selected
  * patch.
  */
-import { getProjectPaths } from '../core/config.js';
 import { stdioIsInteractive } from '../core/destructive.js';
 import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
@@ -14,6 +13,7 @@ import { updatePatchAndMetadata } from '../core/patch-export.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
 import { isGitIndexLockConflict } from '../errors/git.js';
 import { info, success, warn } from '../utils/logger.js';
+import { sleep } from '../utils/sleep.js';
 import { findMissingFiles, reportAdjacentUnmanagedFiles } from './re-export-adjacent.js';
 import { reportForeignDrift } from './re-export-drift.js';
 import { lintReExportedPatch, refreshQueueCtxEntry, storeReExportLintResult, } from './re-export-lint.js';
@@ -26,20 +26,21 @@ const GIT_INDEX_LOCK_RETRY_MS = 300;
  * from the top, so it re-reads clean state; a second lock failure
  * propagates to the loop's honest "N of M" accounting.
  */
-export async function reExportSinglePatchWithIndexLockRetry(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx) {
+export async function reExportSinglePatchWithIndexLockRetry(args) {
     try {
-        return await reExportSinglePatch(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx);
+        return await reExportSinglePatch(args);
     }
     catch (error) {
         if (!isGitIndexLockConflict(error)) {
             throw error;
         }
-        warn(`${patch.filename}: git index.lock contention detected — retrying once after ${String(GIT_INDEX_LOCK_RETRY_MS)} ms...`);
-        await new Promise((resolve) => setTimeout(resolve, GIT_INDEX_LOCK_RETRY_MS));
-        return await reExportSinglePatch(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx);
+        warn(`${args.patch.filename}: git index.lock contention detected — retrying once after ${GIT_INDEX_LOCK_RETRY_MS} ms...`);
+        await sleep(GIT_INDEX_LOCK_RETRY_MS);
+        return await reExportSinglePatch(args);
     }
 }
-async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx) {
+async function reExportSinglePatch(args) {
+    const { patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx } = args;
     let currentFilesAffected = [...patch.filesAffected];
     // --- Scan for new/removed files ---
     if (options.scan) {
@@ -219,10 +220,17 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
  */
 async function commitRefreshedPatch(args) {
     const { patch, paths, manifest, options, config, lintCtx, diffContent, updates } = args;
-    const bodyChanged = await updatePatchAndMetadata(paths.patches, patch.filename, diffContent, updates, undefined, {
-        config,
-        command: 're-export',
-        forceUnsafe: options.forceUnsafe === true,
+    const bodyChanged = await updatePatchAndMetadata({
+        patchesDir: paths.patches,
+        filename: patch.filename,
+        newContent: diffContent,
+        updates,
+        onCommitted: undefined,
+        policyGate: {
+            config,
+            command: 're-export',
+            forceUnsafe: options.forceUnsafe === true,
+        },
     });
     refreshQueueCtxEntry(lintCtx, patch.filename, diffContent);
     if (args.lintResult !== null) {