@hominis/fireforge 0.45.0 → 0.46.1

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

@@ -6,12 +6,12 @@
  * brand-new file an author just created beside a patch's owned files is
  * silently left out of the refreshed body. This module detects such adjacent
  * files, filters out tool-managed paths (branding, furnace) so the notice
- * names only genuinely unmanaged candidates, and — under
- * `--refuse-adjacent-unmanaged` — lets the caller turn the notice into a
+ * names only genuinely unmanaged candidates, and, under
+ * `--refuse-adjacent-unmanaged`, lets the caller turn the notice into a
  * non-zero refusal.
  *
- * Split out of re-export.ts to keep that file inside the max-lines budget;
- * exports helpers consumed by re-export.ts, no registrar.
+ * Split out of re-export.ts to keep that file inside the max-lines budget.
+ * Exports helpers consumed by re-export.ts, no registrar.
  */
 import { dirname, join } from 'node:path';
 import { isBrandingManagedPath } from '../core/branding.js';
@@ -30,7 +30,7 @@ export async function findMissingFiles(engineDir, files) {
 }
 function isToolManagedPath(file, isNewFile, ctx) {
     // Mirrors status-classify: a generated branding path is tool-managed
-    // outright; a brand-new unowned file under the branding root is still a
+    // outright. A brand-new unowned file under the branding root is still a
     // patch candidate (the Assets.car precedent) and must stay listed.
     if (isBrandingManagedPath(file, ctx.binaryName) &&
         (!isNewFile || isGeneratedBrandingPath(file, ctx.binaryName))) {
@@ -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,36 +61,43 @@ 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.
+ * so an unused carve-out can be reported, and are returned rather than
+ * dropped, so the exception stays visible instead of quietly widening.
  */
 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
  * `--refuse-adjacent-unmanaged` is set and any unmanaged adjacent file
- * exists, records the patch into `ctx.refusals` and returns true — the
+ * exists, records the patch into `ctx.refusals` and returns true. The
  * caller then skips the write for this patch and converts the collection
  * into one run-level non-zero refusal after the loop.
  */
@@ -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.d.ts

@@ -7,9 +7,9 @@ export declare function loadScanFilesAssignments(manifestPath: string, manifest:
  * a dry-run changed anything it promised only to inspect. That turns a
  * "dry-run reverted a just-written export" incident into a hard, named
  * failure instead of silent data loss discovered only when a later gate
- * fails. The post-fingerprint runs whether `operation` resolves or rejects —
- * a dry-run that mutates state and THEN fails is exactly the case where a
- * rollback defect must not go unreported; a rejection with a purity
+ * fails. The post-fingerprint runs whether `operation` resolves or rejects,
+ * because a dry-run that mutates state and then fails is exactly the case
+ * where a rollback defect must not go unreported. A rejection with a purity
  * violation surfaces the violation with the original error as `cause`.
  * No-op outside dry-run.
  */

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;
@@ -56,7 +54,7 @@ export async function loadScanFilesAssignments(manifestPath, manifest) {
     for (const assignment of parsed.assignments) {
         const patch = resolvePatchIdentifier(assignment.patch, manifest.patches);
         if (!patch) {
-            // Suggest, never dump.
+            // Suggest close matches instead of dumping the whole queue.
             throw new InvalidArgumentError(`--scan-files: ${formatPatchNotFoundError(assignment.patch, manifest.patches)}`, '--scan-files');
         }
         const patchFiles = filesByPatch.get(patch.filename) ?? new Set();
@@ -77,29 +75,29 @@ export async function loadScanFilesAssignments(manifestPath, manifest) {
  * Fingerprints every piece of state a `re-export --dry-run` promises not to
  * disturb: the engine's commit + working-tree status (via the same
  * generation token `fireforge test` uses) and the byte content of every
- * regular file under `patches/` — ALL of them, not just the selected
- * patches, because a dry-run of patch B can revert a just-written export of
- * patch A.
+ * regular file under `patches/`. That covers all of them, not just the
+ * selected patches, because a dry-run of patch B can revert a just-written
+ * export of patch A.
  *
- * A missing patches directory (ENOENT/ENOTDIR) fingerprints as empty — there
- * is nothing there to protect — but any other listing failure (EACCES, EIO,
+ * A missing patches directory (ENOENT/ENOTDIR) fingerprints as empty, since
+ * there is nothing there to protect. Any other listing failure (EACCES, EIO,
  * …) throws: an unreadable directory is not evidence it is empty, and
  * treating it as such lets the guard silently vouch for state it never saw.
  * The same rule covers an unmeasurable engine generation and an unreadable
- * individual patch file; a before-pass failure aborts the dry run before it
+ * individual patch file. A before-pass failure aborts the dry run before it
  * starts, since a guard that measured nothing cannot vouch for anything.
  */
 async function fingerprintDryRunState(engineDir, patchesDir) {
     const fingerprint = new Map();
     const generation = await snapshotEngineGeneration(engineDir);
     if (isUnavailableGenerationToken(generation)) {
-        // A failed probe measured nothing — hashing the failure token would let
+        // A failed probe measured nothing. Hashing the failure token would let
         // two identical failures compare "unchanged" (vouching for unmeasured
         // state) and two differing messages report a spurious violation.
         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 });
@@ -109,9 +107,9 @@ async function fingerprintDryRunState(engineDir, patchesDir) {
             .sort();
     }
     catch (error) {
-        // No patches directory — nothing there to protect; the same condition on
-        // the post-run pass produces the same empty set, and a directory that
-        // appears mid-dry-run correctly reports as a violation. Any OTHER failure
+        // No patches directory, so nothing there to protect. The same condition
+        // on the post-run pass produces the same empty set, and a directory that
+        // appears mid-dry-run correctly reports as a violation. Any other failure
         // must not read as "empty": the guard would be vouching for state it
         // never saw.
         const code = getNodeErrorCode(error);
@@ -122,14 +120,12 @@ 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) {
             // A file that vanished between the listing and the read is omitted, so
-            // a dry run that DELETED a patch artifact reports as the violation it
+            // a dry run that deleted a patch artifact reports as the violation it
             // is (key present before, absent after) instead of hiding behind a
             // fingerprinting error. Every other failure fails closed: a constant
             // placeholder would make unreadable-before equal unreadable-after even
@@ -159,9 +155,9 @@ async function fingerprintDryRunState(engineDir, patchesDir) {
  * a dry-run changed anything it promised only to inspect. That turns a
  * "dry-run reverted a just-written export" incident into a hard, named
  * failure instead of silent data loss discovered only when a later gate
- * fails. The post-fingerprint runs whether `operation` resolves or rejects —
- * a dry-run that mutates state and THEN fails is exactly the case where a
- * rollback defect must not go unreported; a rejection with a purity
+ * fails. The post-fingerprint runs whether `operation` resolves or rejects,
+ * because a dry-run that mutates state and then fails is exactly the case
+ * where a rollback defect must not go unreported. A rejection with a purity
  * violation surfaces the violation with the original error as `cause`.
  * No-op outside dry-run.
  */
@@ -185,9 +181,9 @@ export async function withDryRunPurityGuard(engineDir, patchesDir, isDryRun, ope
     }
     catch (fingerprintError) {
         // The post-run fingerprint failing must not swallow the dry run's own
-        // failure — an operation that mutated state, broke it, AND made it
+        // failure: an operation that mutated state, broke it, and made it
         // unreadable is exactly the case where both facts matter. The combined
-        // message carries both; the operation error stays the `cause`.
+        // message carries both. The operation error stays the `cause`.
         if (failed) {
             throw new GeneralError(`[dry-run] this dry run failed (${toError(operationError).message}), and its purity could ` +
                 `not be verified afterwards: ${toError(fingerprintError).message}. Inspect engine/ and ` +

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

@@ -2,21 +2,21 @@
  * Foreign-drift preview + `--refuse-foreign-drift` gate for `re-export`.
  *
  * A scan-less re-export rebuilds each patch body as a whole-file
- * `git diff HEAD` over the owned files — so a CONCURRENT session's
+ * `git diff HEAD` over the owned files, so a concurrent session's
  * uncommitted lines inside a file the patch already owns are silently
  * absorbed into the refreshed body. The adjacency advisory
- * (`re-export-adjacent.ts`) warns about unmanaged NEIGHBOUR files but is
+ * (`re-export-adjacent.ts`) warns about unmanaged neighbour files but is
  * structurally blind to drift inside owned files. This module compares
  * the old body against the refreshed body per file and reports the
- * payload lines that are about to ENTER the body; under
+ * payload lines that are about to enter the body. Under
  * `--refuse-foreign-drift` the patch is skipped and the run exits
  * non-zero, mirroring `--refuse-adjacent-unmanaged`.
  *
  * "Foreign" is decided by content, not authorship: re-export's legitimate
  * job is capturing intentional engine edits, so the preview always prints
  * and the hard stop is an explicit opt-in for multi-session checkouts.
- * The comparison is offset-insensitive — per-file MULTISETS of `+`/`-`
- * payload lines — because a refresh legitimately shifts hunk offsets and
+ * The comparison is offset-insensitive, using per-file multisets of `+`/`-`
+ * payload lines, because a refresh legitimately shifts hunk offsets and
  * context without changing what the patch does.
  */
 import type { PatchMetadata } from '../types/commands/index.js';
@@ -55,14 +55,14 @@ export interface FileForeignDrift {
 }
 /**
  * Pure comparison: per owned file, which `+`/`-` payload lines the
- * refreshed body carries that the old body did not. Files NOT in
- * `previousFilesAffected` are skipped — those are intentional adoptions
- * (`--scan`), not drift.
+ * refreshed body carries that the old body did not. Files not in
+ * `previousFilesAffected` are skipped, since those are intentional
+ * adoptions (`--scan`) rather than drift.
  */
 export declare function computeForeignDrift(oldBody: string, newBody: string, previousFilesAffected: readonly string[]): FileForeignDrift[];
 /**
  * Reads the old body, prints the always-on drift preview (including under
- * dry-run and `--scan`), and — when `ctx.refuseForeignDrift` is set —
+ * dry-run and `--scan`), and, when `ctx.refuseForeignDrift` is set,
  * records a refusal and returns `true` so the caller skips the write.
  */
 export declare function reportForeignDrift(args: {
@@ -75,7 +75,7 @@ export declare function reportForeignDrift(args: {
 /**
  * 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
+ * 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.
  */

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

@@ -3,21 +3,21 @@
  * Foreign-drift preview + `--refuse-foreign-drift` gate for `re-export`.
  *
  * A scan-less re-export rebuilds each patch body as a whole-file
- * `git diff HEAD` over the owned files — so a CONCURRENT session's
+ * `git diff HEAD` over the owned files, so a concurrent session's
  * uncommitted lines inside a file the patch already owns are silently
  * absorbed into the refreshed body. The adjacency advisory
- * (`re-export-adjacent.ts`) warns about unmanaged NEIGHBOUR files but is
+ * (`re-export-adjacent.ts`) warns about unmanaged neighbour files but is
  * structurally blind to drift inside owned files. This module compares
  * the old body against the refreshed body per file and reports the
- * payload lines that are about to ENTER the body; under
+ * payload lines that are about to enter the body. Under
  * `--refuse-foreign-drift` the patch is skipped and the run exits
  * non-zero, mirroring `--refuse-adjacent-unmanaged`.
  *
  * "Foreign" is decided by content, not authorship: re-export's legitimate
  * job is capturing intentional engine edits, so the preview always prints
  * and the hard stop is an explicit opt-in for multi-session checkouts.
- * The comparison is offset-insensitive — per-file MULTISETS of `+`/`-`
- * payload lines — because a refresh legitimately shifts hunk offsets and
+ * The comparison is offset-insensitive, using per-file multisets of `+`/`-`
+ * payload lines, because a refresh legitimately shifts hunk offsets and
  * context without changing what the patch does.
  */
 import { stat } from 'node:fs/promises';
@@ -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})`);
             }
         }
     }
@@ -115,9 +115,9 @@ function countExcess(excess) {
 }
 /**
  * Pure comparison: per owned file, which `+`/`-` payload lines the
- * refreshed body carries that the old body did not. Files NOT in
- * `previousFilesAffected` are skipped — those are intentional adoptions
- * (`--scan`), not drift.
+ * refreshed body carries that the old body did not. Files not in
+ * `previousFilesAffected` are skipped, since those are intentional
+ * adoptions (`--scan`) rather than drift.
  */
 export function computeForeignDrift(oldBody, newBody, previousFilesAffected) {
     const owned = new Set(previousFilesAffected);
@@ -156,7 +156,7 @@ export function computeForeignDrift(oldBody, newBody, previousFilesAffected) {
 }
 /**
  * Reads the old body, prints the always-on drift preview (including under
- * dry-run and `--scan`), and — when `ctx.refuseForeignDrift` is set —
+ * dry-run and `--scan`), and, when `ctx.refuseForeignDrift` is set,
  * records a refusal and returns `true` so the caller skips the write.
  */
 export async function reportForeignDrift(args) {
@@ -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) {
@@ -225,13 +225,13 @@ export async function reportForeignDrift(args) {
 /**
  * Splits the drifting files into "you probably wrote this" and "this predates
  * your last export". `--refuse-foreign-drift` calls every absorbed line
- * "foreign" — including the operator's OWN additions from the same session —
- * and "foreign" reads as "another session's", which is precisely the case
- * where proceeding would be wrong. Authorship is unknowable, but RECENCY is
- * not: a file whose mtime is newer than the patch body this run is refreshing
+ * "foreign", including the operator's own additions from the same session,
+ * and "foreign" reads as "another session's", which is the case where
+ * proceeding would be wrong. Authorship is unknowable, but recency is not:
+ * a file whose mtime is newer than the patch body this run is refreshing
  * changed after the last export, which on a single-operator slice is the
- * operator's own edit. Returns the subset of `files` that qualifies; an
- * unstattable path is reported as NOT recently edited, so the cautious
+ * operator's own edit. Returns the subset of `files` that qualifies. An
+ * unstattable path is reported as not recently edited, so the cautious
  * wording is the fallback.
  */
 async function findFilesEditedSinceLastExport(engineDir, patchBodyPath, files) {
@@ -257,7 +257,7 @@ async function findFilesEditedSinceLastExport(engineDir, patchBodyPath, files) {
 }
 /**
  * Fail-closed baseline handling: a missing or unreadable old
- * patch body means the drift comparison CANNOT run, so under
+ * patch body means the drift comparison cannot run, so under
  * `--refuse-foreign-drift` the patch is refused rather than written on the
  * strength of a check that never happened. Without the flag this stays the
  * historical advisory skip (the preview is best-effort there).
@@ -272,28 +272,28 @@ function refuseUnreadableBaseline(ctx, patchFilename, detail) {
     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
+ * 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
+ * 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
+ *  - 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.
+ *    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
+ * engine file makes the refreshed body drop that file's `+` line. Nothing
+ * is absorbed, so 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. Stating that 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 ' +
@@ -302,7 +302,7 @@ const EXPECT_MEASUREMENT_NOTE = '--expect is evaluated against CONTENT, before t
 /**
  * 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
+ * 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.
  */

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>;