@hominis/fireforge 0.44.4 → 0.46.0

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

@@ -18,8 +18,8 @@
 import { join } from 'node:path';
 import { Command } from 'commander';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { appendHistory, assertConfirmationAvailable, confirmDestructive, } from '../../core/destructive.js';
-import { normalizePatchArtifact } from '../../core/patch-artifact-normalize.js';
+import { assertConfirmationAvailable, confirmDestructive } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { buildPatchQueueContext } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
@@ -30,7 +30,8 @@ import { toError } from '../../utils/errors.js';
 import { readText, removeFile, writeText } from '../../utils/fs.js';
 import { info, intro, outro, success, warn } from '../../utils/logger.js';
 import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
-import { normalizePatchDisplayName } from '../../utils/validation.js';
+import { normalizePatchDisplayName, parsePositiveIntegerFlag } from '../../utils/validation.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
 import { placementPlansEqual, resolvePlacementPlan } from '../export-flow.js';
 import { runPatchLint } from '../export-shared.js';
 import { assertSourceOwnsFiles, buildNewPatchMetadata, buildSplitDiff, buildSplitSummary, findOwnerRewriteHolders, mergeStagedForwardImports, projectSplitManifest, rewriteSplitOwners, runProjectedSplitLint, } from './split-plan.js';
@@ -68,9 +69,9 @@ export async function commitPatchSplit(patchesDir, plan, newMetadata, options, c
                 await renumberPatchesInManifest(patchesDir, plan.placement.renameMap);
                 renumberApplied = true;
             }
-            await writeText(newPatchPath, normalizePatchArtifact(plan.movedDiff));
+            await writeText(newPatchPath, plan.movedDiff);
             newPatchWritten = true;
-            await writeText(sourcePathAfter, normalizePatchArtifact(plan.remainingDiff));
+            await writeText(sourcePathAfter, plan.remainingDiff);
             sourceRewritten = true;
             const fresh = await loadPatchesManifest(patchesDir);
             if (!fresh)
@@ -91,28 +92,23 @@ export async function commitPatchSplit(patchesDir, plan, newMetadata, options, c
             updatedPatches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
             const updated = validatePatchesManifest({ ...fresh, patches: updatedPatches });
             await savePatchesManifest(patchesDir, updated);
-            try {
-                await appendHistory(patchesDir, {
-                    operation: 'patch-split',
-                    args: {
-                        source: effectiveSourceFilename,
-                        newFilename: plan.placement.newFilename,
-                        order: plan.placement.insertionOrder,
-                        files: plan.movedFiles,
-                        ownerRewrites: plan.ownerRewrites,
-                        renames: [...plan.placement.renameMap.entries()].map(([from, entry]) => ({
-                            from,
-                            to: entry.newFilename,
-                        })),
-                    },
-                    ...(options.yes === true ? { yes: true } : {}),
-                    ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-                    result: 'ok',
-                });
-            }
-            catch (historyError) {
-                warn(`History log append failed after patch split committed: ${toError(historyError).message}`);
-            }
+            await appendHistoryBestEffort(patchesDir, {
+                operation: 'patch-split',
+                args: {
+                    source: effectiveSourceFilename,
+                    newFilename: plan.placement.newFilename,
+                    order: plan.placement.insertionOrder,
+                    files: plan.movedFiles,
+                    ownerRewrites: plan.ownerRewrites,
+                    renames: [...plan.placement.renameMap.entries()].map(([from, entry]) => ({
+                        from,
+                        to: entry.newFilename,
+                    })),
+                },
+                ...(options.yes === true ? { yes: true } : {}),
+                ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
+                result: 'ok',
+            }, `patch split committed`);
         }
         catch (error) {
             // Reverse-order rollback; each step warns on its own failure so the
@@ -226,8 +222,26 @@ export async function patchSplitCommand(projectRoot, sourceId, options) {
     // instead of linting each projected body blind.
     const patchQueueCtx = await buildPatchQueueContext(paths.patches, config);
     const ignoreChecks = source.lintIgnore ? new Set(source.lintIgnore) : undefined;
-    await runPatchLint(paths.engine, remainingFiles, remainingDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, source.tier);
-    await runPatchLint(paths.engine, movedFiles, movedDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, source.tier);
+    await runPatchLint({
+        engineDir: paths.engine,
+        filesAffected: remainingFiles,
+        diffContent: remainingDiff,
+        config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks,
+        patchTier: source.tier,
+    });
+    await runPatchLint({
+        engineDir: paths.engine,
+        filesAffected: movedFiles,
+        diffContent: movedDiff,
+        config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks,
+        patchTier: source.tier,
+    });
     const { conflicts, stagedDependencyAdditions } = runProjectedSplitLint(plan, patchQueueCtx);
     plan.stagedDependencyAdditions = stagedDependencyAdditions;
     const newMetadata = buildNewPatchMetadata(plan, config);
@@ -246,14 +260,8 @@ export async function patchSplitCommand(projectRoot, sourceId, options) {
         unsafeOverride: options.forceUnsafe === true,
         conflicts,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    if (decision === 'declined') {
-        outro('Split cancelled');
+    if (!proceedAfterDecision(decision, 'Split cancelled'))
         return;
-    }
     await commitPatchSplit(paths.patches, plan, newMetadata, options, config);
     success(`Split ${source.filename}: ${placement.newFilename} now owns ${plan.movedFiles.length} file(s)`);
     if (plan.ownerRewrites.length > 0) {
@@ -273,13 +281,7 @@ export function registerPatchSplit(parent, context) {
         .requiredOption('--name <name>', 'Name for the new patch')
         .option('--category <category>', "Category for the new patch (default: the source patch's)")
         .option('--description <desc>', 'Description for the new patch')
-        .option('--order <n>', 'Exact sparse order for the new patch', commanderArgParser((raw) => {
-        const n = Number.parseInt(raw, 10);
-        if (!Number.isInteger(n) || n <= 0) {
-            throw new InvalidArgumentError(`--order must be a positive integer, got "${raw}".`, '--order');
-        }
-        return n;
-    }))
+        .option('--order <n>', 'Exact sparse order for the new patch', commanderArgParser((raw) => parsePositiveIntegerFlag('--order', raw)))
         .option('--before <patch>', 'Place the new patch before this patch')
         .option('--after <patch>', 'Place the new patch after this patch (default: the source patch)')
         .option('--dry-run', 'Show what would happen without writing')

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
@@ -10,13 +10,43 @@ export interface AdjacentUnmanagedContext {
     binaryName: string;
     furnacePrefixes: ReadonlySet<string>;
     refuseAdjacentUnmanaged: boolean;
+    /**
+     * Engine-relative paths named by `--expect-unmanaged`: reviewed, recorded
+     * exceptions that are reported but never refuse. Normalized once by the
+     * caller so the comparison matches git's engine-relative output.
+     */
+    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
@@ -27,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,37 @@ 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
+ * `--expect-unmanaged` carve-out admits. Approved paths are recorded as seen
+ * so an unused carve-out can be reported, and are RETURNED rather than
+ * dropped: an exception nobody can see is how a carve-out quietly widens.
+ */
+function partitionApproved(files, ctx) {
+    const refusing = [];
+    const approved = [];
+    for (const entry of files) {
+        if (ctx.approvedUnmanaged.has(entry.file)) {
+            ctx.approvedSeen.add(entry.file);
+            approved.push(entry);
+        }
+        else {
+            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
@@ -83,23 +112,35 @@ export async function reportAdjacentUnmanagedFiles(args) {
             `  Re-run with --scan to reconcile filesAffected with the current worktree, ` +
             `or pass --files <paths> to set the list explicitly.`);
     }
-    const unmanagedFiles = await findAdjacentUnmanagedFiles({
+    const allUnmanaged = await findAdjacentUnmanagedFiles({
         currentFilesAffected,
         engineDir: paths.engine,
         manifest,
         patchFilename: patch.filename,
         ctx,
     });
+    const { refusing: unmanagedFiles, approved } = partitionApproved(allUnmanaged, ctx);
+    if (approved.length > 0) {
+        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.d.ts

@@ -72,3 +72,11 @@ export declare function reportForeignDrift(args: {
     newDiffContent: string;
     ctx: ForeignDriftContext;
 }): Promise<boolean>;
+/**
+ * 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 declare function warnUnseenExpectedDrift(driftCtx: ForeignDriftContext): void;