@hominis/fireforge 0.45.0 → 0.46.0

package/dist/src/commands/patch/staged-dependency.js

@@ -4,11 +4,10 @@
  * PatchMetadata.stagedDependencies without rewriting the .patch body.
  */
 import { Command } from 'commander';
-import { appendHistory } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 import { mutatePatchMetadata } from '../../core/patch-export.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { info, intro, outro, warn } from '../../utils/logger.js';
+import { info, intro, outro } from '../../utils/logger.js';
 import { addWaitLockOption, resolveWaitLockSeconds } from '../../utils/options.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 import { validateStagedDependencyAdd } from './staged-dependency-validate.js';
@@ -113,7 +112,7 @@ function resolveImportRemovalTarget(options, staged) {
         const list = candidates
             .map((entry) => `  - ${dependencyLabel('import', importView(entry))}`)
             .join('\n');
-        throw new GeneralError(`--remove matches ${String(candidates.length)} staged forward-imports on this patch; ` +
+        throw new GeneralError(`--remove matches ${candidates.length} staged forward-imports on this patch; ` +
             `pass --creates to pick one:\n${list}`);
     }
     return { file, specifier, creates: '(no match)' };
@@ -142,7 +141,7 @@ function resolveRegistrationRemovalTarget(options, staged) {
         const list = candidates
             .map((entry) => `  - ${dependencyLabel('registration', registrationView(entry))}`)
             .join('\n');
-        throw new GeneralError(`--remove matches ${String(candidates.length)} staged registrations on this patch; ` +
+        throw new GeneralError(`--remove matches ${candidates.length} staged registrations on this patch; ` +
             `pass --creates to pick one:\n${list}`);
     }
     return { file, line, creates: '(no match)' };
@@ -280,23 +279,18 @@ export async function patchStagedDependencyCommand(projectRoot, identifier, opti
     const before = result.before.stagedDependencies;
     const after = result.after.stagedDependencies;
     info(`${targetPatch.filename}: ${describeStagedDependencyChange(countStagedEntries(before), countStagedEntries(after), mode, kind, target)}.`);
-    try {
-        await appendHistory(paths.patches, {
-            operation: 'patch-staged-dependency',
-            args: {
-                filename: targetPatch.filename,
-                mode,
-                kind,
-                before: before ?? {},
-                after: after ?? {},
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            result: 'ok',
-        });
-    }
-    catch (historyError) {
-        warn(`History log append failed after patch staged-dependency committed (${targetPatch.filename}): ${toError(historyError).message}`);
-    }
+    await appendHistoryBestEffort(paths.patches, {
+        operation: 'patch-staged-dependency',
+        args: {
+            filename: targetPatch.filename,
+            mode,
+            kind,
+            before: before ?? {},
+            after: after ?? {},
+        },
+        ...(options.yes === true ? { yes: true } : {}),
+        result: 'ok',
+    }, `patch staged-dependency committed (${targetPatch.filename})`);
     outro('Patch staged-dependency complete');
 }
 /**

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

@@ -15,12 +15,13 @@
  * `--clear` must be supplied per invocation.
  */
 import { Command, Option } from 'commander';
-import { appendHistory, confirmDestructive } from '../../core/destructive.js';
+import { confirmDestructive } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 import { updatePatchMetadata } from '../../core/patch-export.js';
 import { InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { info, intro, outro, warn } from '../../utils/logger.js';
+import { info, intro, outro } from '../../utils/logger.js';
 import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /**
  * Runs the `patch tier` command: updates `PatchMetadata.tier` on the
@@ -71,14 +72,8 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
         yes: options.yes === true,
         dryRun: isDryRun,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
+    if (!proceedAfterDecision(decision, 'Cancelled — no changes made'))
         return;
-    }
-    if (decision === 'declined') {
-        outro('Cancelled — no changes made');
-        return;
-    }
     // Single write under the patch directory lock (delegated inside
     // updatePatchMetadata). Setting routes through `updates`; clearing
     // routes through `unsetFields` so TypeScript's exact optional types
@@ -92,21 +87,16 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
     else {
         await updatePatchMetadata(paths.patches, target.filename, {}, ['tier']);
     }
-    try {
-        await appendHistory(paths.patches, {
-            operation: 'patch-tier',
-            args: {
-                filename: target.filename,
-                ...(before !== undefined ? { before } : {}),
-                ...(after !== undefined ? { after } : {}),
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            result: 'ok',
-        });
-    }
-    catch (historyError) {
-        warn(`History log append failed after patch tier committed (${target.filename}): ${toError(historyError).message}`);
-    }
+    await appendHistoryBestEffort(paths.patches, {
+        operation: 'patch-tier',
+        args: {
+            filename: target.filename,
+            ...(before !== undefined ? { before } : {}),
+            ...(after !== undefined ? { after } : {}),
+        },
+        ...(options.yes === true ? { yes: true } : {}),
+        result: 'ok',
+    }, `patch tier committed (${target.filename})`);
     info(`${target.filename}: ${action}.`);
     outro('Patch tier complete');
 }

package/dist/src/commands/patch-rename-map.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Structural equality for patch rename maps, shared by the placement-mode
+ * export preview/commit check (`export-flow.ts`) and `patch reorder`'s
+ * under-lock drift check. Both previously carried a byte-identical copy of
+ * the sorted-entries comparison; one helper keeps the two commit gates from
+ * drifting.
+ */
+import type { PatchRenameEntry } from '../core/patch-manifest.js';
+/**
+ * Rename-map entries ordered by target order, so previews, history entries
+ * and equality checks all walk the queue in its final on-disk order.
+ */
+export declare function getSortedRenameEntries(renameMap: Map<string, PatchRenameEntry>): Array<[string, PatchRenameEntry]>;
+/**
+ * Compares two rename maps entry by entry after sorting both by target
+ * order. Equal when every (current filename, new filename, new order)
+ * triple matches positionally.
+ */
+export declare function renameMapsEqual(left: Map<string, PatchRenameEntry>, right: Map<string, PatchRenameEntry>): boolean;

package/dist/src/commands/patch-rename-map.js

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Structural equality for patch rename maps, shared by the placement-mode
+ * export preview/commit check (`export-flow.ts`) and `patch reorder`'s
+ * under-lock drift check. Both previously carried a byte-identical copy of
+ * the sorted-entries comparison; one helper keeps the two commit gates from
+ * drifting.
+ */
+/**
+ * Rename-map entries ordered by target order, so previews, history entries
+ * and equality checks all walk the queue in its final on-disk order.
+ */
+export function getSortedRenameEntries(renameMap) {
+    return Array.from(renameMap.entries()).sort((a, b) => a[1].newOrder - b[1].newOrder);
+}
+/**
+ * Compares two rename maps entry by entry after sorting both by target
+ * order. Equal when every (current filename, new filename, new order)
+ * triple matches positionally.
+ */
+export function renameMapsEqual(left, right) {
+    const leftEntries = getSortedRenameEntries(left);
+    const rightEntries = getSortedRenameEntries(right);
+    if (leftEntries.length !== rightEntries.length) {
+        return false;
+    }
+    return leftEntries.every(([leftFilename, leftEntry], index) => {
+        const rightTuple = rightEntries[index];
+        if (!rightTuple)
+            return false;
+        const [rightFilename, rightEntry] = rightTuple;
+        return (leftFilename === rightFilename &&
+            leftEntry.newFilename === rightEntry.newFilename &&
+            leftEntry.newOrder === rightEntry.newOrder);
+    });
+}

package/dist/src/commands/pending-resolution.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Clears `pendingResolution` from `state.json` transactionally.
+ *
+ * Five commands (`doctor --clear-resolution`, `resolve`, `rebase --continue`,
+ * `rebase --abort`, and the rebase patch loop) had each copied the same
+ * spread-then-`delete` updater. Routing the clear through `updateState` rather
+ * than a load/modify/save pair is the load-bearing part: the updater runs
+ * inside the state-file lock against the freshest on-disk state, so a
+ * concurrent write to an unrelated key (`buildMode`, `baseCommit`) is not
+ * clobbered by a stale reload. Copies of that reasoning drift; one does not.
+ *
+ * A no-op when nothing is pending, so callers need no guard of their own.
+ * @param projectRoot - Project root holding `.fireforge/state.json`.
+ */
+export declare function clearPendingResolution(projectRoot: string): Promise<void>;

package/dist/src/commands/pending-resolution.js

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { updateState } from '../core/config.js';
+/**
+ * Clears `pendingResolution` from `state.json` transactionally.
+ *
+ * Five commands (`doctor --clear-resolution`, `resolve`, `rebase --continue`,
+ * `rebase --abort`, and the rebase patch loop) had each copied the same
+ * spread-then-`delete` updater. Routing the clear through `updateState` rather
+ * than a load/modify/save pair is the load-bearing part: the updater runs
+ * inside the state-file lock against the freshest on-disk state, so a
+ * concurrent write to an unrelated key (`buildMode`, `baseCommit`) is not
+ * clobbered by a stale reload. Copies of that reasoning drift; one does not.
+ *
+ * A no-op when nothing is pending, so callers need no guard of their own.
+ * @param projectRoot - Project root holding `.fireforge/state.json`.
+ */
+export async function clearPendingResolution(projectRoot) {
+    await updateState(projectRoot, (current) => {
+        if (!current.pendingResolution)
+            return current;
+        const next = { ...current };
+        delete next.pendingResolution;
+        return next;
+    });
+}

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

@@ -1,5 +1,5 @@
-import type { getProjectPaths } from '../core/config.js';
 import type { PatchesManifest, PatchMetadata } from '../types/commands/index.js';
+import type { ProjectPaths } from '../types/config.js';
 /**
  * Shared per-run context for the adjacency advisory: the classification
  * inputs computed once by `reExportCommand`, plus the collection of
@@ -18,13 +18,35 @@ export interface AdjacentUnmanagedContext {
     approvedUnmanaged: ReadonlySet<string>;
     /** Approved paths actually met this run, so unused ones can be surfaced. */
     approvedSeen: Set<string>;
+    /**
+     * Offenders collected across the loop. `files` stays the bare paths that
+     * downstream consumers already read; `anchored` carries the same entries
+     * with the owned directory that made each one adjacent, so the run-level
+     * refusal can name the anchor without re-deriving it.
+     */
     refusals: {
         patchFilename: string;
         files: string[];
+        anchored: string[];
     }[];
 }
 /** Returns the subset of `files` that no longer exist under `engineDir`. */
 export declare function findMissingFiles(engineDir: string, files: readonly string[]): Promise<string[]>;
+/**
+ * One unmanaged file and the owned directory that made it adjacent.
+ *
+ * The anchor is what an unattended run could not previously recover: the
+ * notice named the offending file and the patch, but not WHICH of the
+ * patch's owned locations the file sits beside, so triaging a refusal on a
+ * patch that owns files in several directories meant re-deriving the
+ * adjacency by hand from the manifest.
+ */
+export interface AdjacentUnmanagedFile {
+    /** Engine-relative path of the unmanaged file. */
+    file: string;
+    /** Directory holding at least one file this patch owns. */
+    anchorDir: string;
+}
 /**
  * Emits the scan-less advisory for one patch: missing manifest files and
  * unmanaged files adjacent to the patch's ownership. When
@@ -35,7 +57,7 @@ export declare function findMissingFiles(engineDir: string, files: readonly stri
  */
 export declare function reportAdjacentUnmanagedFiles(args: {
     patch: PatchMetadata;
-    paths: ReturnType<typeof getProjectPaths>;
+    paths: ProjectPaths;
     manifest: PatchesManifest;
     currentFilesAffected: readonly string[];
     ctx: AdjacentUnmanagedContext;

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

@@ -47,7 +47,9 @@ async function findAdjacentUnmanagedFiles(args) {
     const parentDirs = [...new Set(currentFilesAffected.map((file) => dirname(file)))];
     const currentSet = new Set(currentFilesAffected);
     const claimedByOthers = getClaimedFiles(manifest, patchFilename);
-    const candidates = new Set();
+    // First anchor wins: the dirs are scanned in ownership order and a file
+    // lives in exactly one of them, so the map is a dedupe, not a choice.
+    const candidates = new Map();
     for (const dir of parentDirs) {
         const [modifiedFiles, untrackedFiles] = await Promise.all([
             getModifiedFilesInDir(engineDir, dir),
@@ -59,10 +61,13 @@ async function findAdjacentUnmanagedFiles(args) {
                 continue;
             if (isToolManagedPath(file, untrackedSet.has(file), ctx))
                 continue;
-            candidates.add(file);
+            if (!candidates.has(file))
+                candidates.set(file, dir);
         }
     }
-    return [...candidates].sort();
+    return [...candidates.entries()]
+        .map(([file, anchorDir]) => ({ file, anchorDir }))
+        .sort((a, b) => a.file.localeCompare(b.file));
 }
 /**
  * Splits the candidates into the ones that refuse and the ones a
@@ -73,17 +78,21 @@ async function findAdjacentUnmanagedFiles(args) {
 function partitionApproved(files, ctx) {
     const refusing = [];
     const approved = [];
-    for (const file of files) {
-        if (ctx.approvedUnmanaged.has(file)) {
-            ctx.approvedSeen.add(file);
-            approved.push(file);
+    for (const entry of files) {
+        if (ctx.approvedUnmanaged.has(entry.file)) {
+            ctx.approvedSeen.add(entry.file);
+            approved.push(entry);
         }
         else {
-            refusing.push(file);
+            refusing.push(entry);
         }
     }
     return { refusing, approved };
 }
+/** Renders `<file> (beside engine/<dir>)` for a notice line. */
+function describeAnchored(entry) {
+    return `${entry.file} (beside engine/${entry.anchorDir})`;
+}
 /**
  * Emits the scan-less advisory for one patch: missing manifest files and
  * unmanaged files adjacent to the patch's ownership. When
@@ -112,19 +121,26 @@ export async function reportAdjacentUnmanagedFiles(args) {
     });
     const { refusing: unmanagedFiles, approved } = partitionApproved(allUnmanaged, ctx);
     if (approved.length > 0) {
-        info(`${patch.filename}: ${String(approved.length)} adjacent unmanaged file(s) admitted by ` +
-            `--expect-unmanaged (${approved.join(', ')}) — reported, not refused.`);
+        info(`${patch.filename}: ${approved.length} adjacent unmanaged file(s) admitted by ` +
+            `--expect-unmanaged (${approved.map(describeAnchored).join(', ')}) — reported, not refused.`);
     }
     if (unmanagedFiles.length === 0)
         return false;
-    const firstFew = unmanagedFiles.slice(0, 3).join(', ');
-    const more = unmanagedFiles.length > 3 ? `, +${String(unmanagedFiles.length - 3)} more` : '';
-    warn(`${patch.filename}: found ${String(unmanagedFiles.length)} unmanaged file(s) adjacent to this patch's ownership (${firstFew}${more}); plain re-export keeps filesAffected unchanged — use --scan-file to include reviewed files.`);
-    for (const file of unmanagedFiles) {
-        info(`  ${file} — fireforge re-export ${patch.filename} --scan --scan-file ${file}`);
+    const firstFew = unmanagedFiles.slice(0, 3).map(describeAnchored).join(', ');
+    const more = unmanagedFiles.length > 3 ? `, +${unmanagedFiles.length - 3} more` : '';
+    warn(`${patch.filename}: found ${unmanagedFiles.length} unmanaged file(s) adjacent to this patch's ownership (${firstFew}${more}); ` +
+        `adjacent means the file sits in a directory this patch already owns a file in. ` +
+        `Plain re-export keeps filesAffected unchanged — use --scan-file to include reviewed files.`);
+    for (const entry of unmanagedFiles) {
+        info(`  ${entry.file} — beside engine/${entry.anchorDir} — ` +
+            `fireforge re-export ${patch.filename} --scan --scan-file ${entry.file}`);
     }
     if (ctx.refuseAdjacentUnmanaged) {
-        ctx.refusals.push({ patchFilename: patch.filename, files: unmanagedFiles });
+        ctx.refusals.push({
+            patchFilename: patch.filename,
+            files: unmanagedFiles.map((entry) => entry.file),
+            anchored: unmanagedFiles.map(describeAnchored),
+        });
         return true;
     }
     return false;

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

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { createHash } from 'node:crypto';
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isUnavailableGenerationToken, snapshotEngineGeneration, unavailableGenerationReason, } from '../core/engine-session-lock.js';
@@ -10,12 +9,11 @@ import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { mapWithConcurrency } from '../utils/concurrency.js';
 import { getNodeErrorCode, toError } from '../utils/errors.js';
 import { readText } from '../utils/fs.js';
+import { sha256Hex } from '../utils/hash.js';
+import { isObject } from '../utils/validation.js';
 import { normalizeEngineRelativeInput } from './re-export-scan.js';
 /** Concurrency bound for patch-body hashing (matches the classify/lint pools). */
 const PATCH_HASH_CONCURRENCY = 8;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 function parseScanFilesManifest(raw, manifestPath) {
     let parsed;
     try {
@@ -24,12 +22,12 @@ function parseScanFilesManifest(raw, manifestPath) {
     catch (error) {
         throw new InvalidArgumentError(`--scan-files manifest is not valid JSON (${manifestPath}): ${toError(error).message}`, '--scan-files');
     }
-    if (!isRecord(parsed) || !Array.isArray(parsed['assignments'])) {
+    if (!isObject(parsed) || !Array.isArray(parsed['assignments'])) {
         throw new InvalidArgumentError('--scan-files manifest must contain an assignments array.', '--scan-files');
     }
     const assignments = [];
     for (const [index, assignment] of parsed['assignments'].entries()) {
-        if (!isRecord(assignment)) {
+        if (!isObject(assignment)) {
             throw new InvalidArgumentError(`--scan-files assignments[${index}] must be an object.`, '--scan-files');
         }
         const { patch, files } = assignment;
@@ -99,7 +97,7 @@ async function fingerprintDryRunState(engineDir, patchesDir) {
         throw new GeneralError(`[dry-run] cannot fingerprint the engine working tree for the purity guard: ` +
             unavailableGenerationReason(generation));
     }
-    fingerprint.set('the engine working tree', createHash('sha256').update(generation).digest('hex'));
+    fingerprint.set('the engine working tree', sha256Hex(generation));
     let names = [];
     try {
         const entries = await readdir(patchesDir, { withFileTypes: true });
@@ -122,9 +120,7 @@ async function fingerprintDryRunState(engineDir, patchesDir) {
     const results = await mapWithConcurrency(names, PATCH_HASH_CONCURRENCY, async (name) => {
         try {
             return {
-                hash: createHash('sha256')
-                    .update(await readFile(join(patchesDir, name)))
-                    .digest('hex'),
+                hash: sha256Hex(await readFile(join(patchesDir, name))),
             };
         }
         catch (error) {

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) {

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, 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 { buildNewFileTextProjection } 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,17 +41,11 @@ function resolveEffectiveTierAndLintIgnore(target, options) {
  */
 async function runProjectedCrossPatchLint(patchesDir, targetFilename, projectedDiff) {
     const baseCtx = await buildPatchQueueContext(patchesDir);
-    const projectedNewFiles = buildNewFileTextProjection(projectedDiff);
-    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');
@@ -235,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);
@@ -273,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;
 }
 /**