@hominis/fireforge 0.43.1 → 0.44.0

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

@@ -223,16 +223,16 @@ export async function reportForeignDrift(args) {
     return false;
 }
 /**
- * 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 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 wording is the fallback.
+ * 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
+ * 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
+ * wording is the fallback.
  */
 async function findFilesEditedSinceLastExport(engineDir, patchBodyPath, files) {
     const recent = new Set();

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

@@ -2,16 +2,15 @@ import { getProjectPaths } from '../core/config.js';
 import type { PatchMetadata, ReExportOptions } from '../types/commands/index.js';
 import type { FireForgeConfig } 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 patch has been replaced with the projected state, gates on
+ * 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
+ * patch has been replaced with the projected state, gates on
  * confirmDestructive, and writes atomically.
  *
  * Lives outside reExportSinglePatch because the --files path has strictly
  * different semantics (authoritative file list, destructive shrink
- * confirmation, cross-patch projection lint) and shoehorning it through
- * the generic single-patch helper is what led to the earlier bug where
- * the projection lint ran against the current (unchanged) queue instead
- * of the projected state.
+ * confirmation, cross-patch projection lint). Shoehorning it through the
+ * 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>;

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

@@ -1,13 +1,13 @@
 // 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 { appendHistory, confirmDestructive, } from '../core/destructive.js';
 import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
-import { computeProjectedLintRegressions } from '../core/lint-projection.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
 import { updatePatchAndMetadata } from '../core/patch-export.js';
 import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, formatPatchLintIssue, lintPatchQueue, } from '../core/patch-lint.js';
+import { computeProjectedLintRegressions } from '../core/patch-lint-projection.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
 import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
@@ -16,17 +16,13 @@ import { pathExists } from '../utils/fs.js';
 import { info, outro, success, warn } from '../utils/logger.js';
 import { runPatchLint } from './export-shared.js';
 /**
- * Computes the effective `tier` and `lintIgnore` carrying both the
- * patch's existing values and the CLI flag overrides. Pure helper —
- * extracted from {@link reExportFilesInPlace} both to share with the
- * standard re-export path conceptually and to keep the orchestrator
- * function under the per-file LOC budget.
+ * Computes the effective `tier` and `lintIgnore` carrying both the patch's
+ * existing values and the CLI flag overrides.
  *
- * Tier resolution: the CLI flag takes precedence; the patch's existing
- * tier is the fallback. Lint-ignore resolution: union of the patch's
- * existing list and the CLI flag values, de-duplicated; an empty
- * result returns `undefined` so the caller can drop the field rather
- * than write an empty array.
+ * Tier resolution: the CLI flag takes precedence; the patch's existing tier
+ * is the fallback. Lint-ignore resolution: union of the patch's existing list
+ * and the CLI flag values, de-duplicated; an empty result returns `undefined`
+ * so the caller can drop the field rather than write an empty array.
  */
 function resolveEffectiveTierAndLintIgnore(target, options) {
     const existingIgnoreSet = new Set(target.lintIgnore ?? []);
@@ -38,12 +34,10 @@ function resolveEffectiveTierAndLintIgnore(target, options) {
 }
 /**
  * Projects the cross-patch context (replace the target entry with its
- * shrunken self), runs the patch-queue lint against the projection,
- * and returns a conflict report only for regressions introduced *by*
- * this shrink. Pre-existing cross-patch errors are surfaced as a
- * non-blocking warning so the user does not walk away thinking the
- * queue is clean. Extracted from {@link reExportFilesInPlace} to keep
- * the orchestrator function under the per-file LOC budget.
+ * shrunken self), runs the patch-queue lint against the projection, and
+ * returns a conflict report only for regressions introduced *by* this
+ * shrink. Pre-existing cross-patch errors are surfaced as a non-blocking
+ * warning so the user does not walk away thinking the queue is clean.
  */
 async function runProjectedCrossPatchLint(patchesDir, targetFilename, projectedDiff) {
     const baseCtx = await buildPatchQueueContext(patchesDir);
@@ -78,9 +72,8 @@ async function runProjectedCrossPatchLint(patchesDir, targetFilename, projectedD
 }
 /**
  * Builds the `Partial<PatchMetadata>` payload for the `--files` write,
- * folding in the CLI flag overrides for `tier` and `lintIgnore` only
- * when the operator actually asked for them. Extracted to keep
- * {@link reExportFilesInPlace} under the per-file LOC budget.
+ * folding in the CLI flag overrides for `tier` and `lintIgnore` only when the
+ * operator actually asked for them.
  */
 function buildFilesModeMetadataUpdates(actualProjectedFiles, options, effectiveLintIgnore, flagIgnoreSet) {
     const updates = {
@@ -132,17 +125,16 @@ async function confirmFilesModeProjection(args) {
     });
 }
 /**
- * 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 patch has been replaced with the projected state, gates on
+ * 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
+ * patch has been replaced with the projected state, gates on
  * confirmDestructive, and writes atomically.
  *
  * Lives outside reExportSinglePatch because the --files path has strictly
  * different semantics (authoritative file list, destructive shrink
- * confirmation, cross-patch projection lint) and shoehorning it through
- * the generic single-patch helper is what led to the earlier bug where
- * the projection lint ran against the current (unchanged) queue instead
- * of the projected state.
+ * confirmation, cross-patch projection lint). Shoehorning it through the
+ * generic single-patch helper is what makes the projection lint run against
+ * the current (unchanged) queue instead of the projected state.
  */
 export async function reExportFilesInPlace(paths, selectedPatches, options, config) {
     const target = selectedPatches[0];
@@ -154,8 +146,8 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         throw new InvalidArgumentError('reExportFilesInPlace called with no --files.', '--files');
     }
     const requested = [...new Set(filesOption)].sort();
-    // Stale-furnace-source gate (0.37.0 item 4): same refusal as the generic
-    // re-export path — the projected diff would capture stale deployed copies.
+    // Stale-furnace-source gate: same refusal as the generic re-export path —
+    // the projected diff would capture stale deployed copies.
     await enforceFreshFurnaceSources(paths.root, requested, options.allowStaleFurnace === true, 're-export');
     const removed = target.filesAffected.filter((f) => !requested.includes(f));
     const added = requested.filter((f) => !target.filesAffected.includes(f));
@@ -193,16 +185,14 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
             'Keeping them in filesAffected would desync patches.json from the patch body. ' +
             'Remove those paths from --files or modify them before retrying.', '--files');
     }
-    // Run the per-patch lint against the projected diff. This mirrors what
+    // Run the per-patch lint against the projected diff, mirroring what
     // runPatchLint does in the standard re-export path. The target patch's
     // `lintIgnore` threads through so a shrink of an advisory-noisy-but-
     // intentional patch (branding bundle, localised-resource pack) does not
     // have to choose between `--skip-lint` (blunt) and the full rebase path.
-    // `target.tier` threads the explicit branding-threshold opt-in for
-    // the branding patch that also touches a non-allowlisted sibling.
-    // CLI flags `--tier` and `--lint-ignore` participate too, with
-    // append/union semantics on the lint-ignore list (matching the
-    // standard re-export path).
+    // `target.tier` threads the explicit branding-threshold opt-in. CLI flags
+    // `--tier` and `--lint-ignore` participate too, with append/union
+    // semantics on the lint-ignore list.
     const { effectiveTier, effectiveLintIgnore, flagIgnoreSet } = resolveEffectiveTierAndLintIgnore(target, options);
     const ignoreChecks = effectiveLintIgnore ? new Set(effectiveLintIgnore) : undefined;
     const patchQueueCtx = (await pathExists(paths.patches))
@@ -230,7 +220,7 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         options,
         conflicts,
     });
-    if (decision === 'cancelled') {
+    if (decision === 'declined') {
         outro('Re-export cancelled');
         return;
     }
@@ -239,13 +229,13 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         outro('Dry run complete — no changes made');
         return;
     }
-    // Execute the write. At this point the projected diff is guaranteed to
-    // be non-empty and `actualProjectedFiles` is guaranteed to match the
-    // paths the body really touches, so the manifest cannot drift from the
-    // regenerated patch body. The history append runs inside the same patch
-    // directory lock 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.
+    // Execute the write. At this point the projected diff is guaranteed
+    // non-empty and `actualProjectedFiles` is guaranteed to match the paths the
+    // body really touches, so the manifest cannot drift from the regenerated
+    // patch body. The history append runs inside the same patch directory lock
+    // 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',

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

@@ -1,30 +1,27 @@
 /**
  * Hoisted + cached lint context for `re-export`.
  *
- * The per-patch loop used to rebuild the whole patch-queue context AND a
- * fresh queue-wide checkJs TypeScript program for every patch — ~37 s of
- * fixed setup per patch (measured on a 290-patch consumer queue), so an
- * N-patch re-export cost N×37 s. This module:
+ * Rebuilding the whole patch-queue context AND a fresh queue-wide checkJs
+ * TypeScript program for every patch costs tens of seconds of fixed setup
+ * per patch, so an N-patch re-export pays it N times. This module:
  *
  * - builds the queue context and the {@link PerRunCheckJs} program
  *   controller ONCE per invocation (`buildReExportLintContext`) and slices
- * per-patch findings out of it (the shape `move-files`/`split`
- *   already use, plus the program-level hoist `lint --per-patch` has);
+ *   per-patch findings out of it;
  * - reuses the existing per-patch lint RESULT cache
  *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations —
- *   re-export lints the identical input `lint --per-patch` does (the
- *   fresh `git diff HEAD` of the owned files), and the key already
- *   hashes engine HEAD, per-file content, patch body, config, shims, and
- *   ownership, so a repeat single re-export is a warm hit (~4 s instead
- *   of ~41 s). `--no-cache` opts out; run-level checkJs globals are
- * never cached and are emitted once per invocation;
+ *   re-export lints the identical input `lint --per-patch` does (the fresh
+ *   `git diff HEAD` of the owned files), and the key already hashes engine
+ *   HEAD, per-file content, patch body, config, shims, and ownership, so a
+ *   repeat single re-export is a warm hit. `--no-cache` opts out; run-level
+ *   checkJs globals are never cached and are emitted once per invocation;
  * - keeps the in-memory queue context honest after each write
  *   (`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 PerPatchLintCacheFile } from '../core/lint-cache.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 PerRunCheckJs } from './lint-per-run-checkjs.js';

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

@@ -2,30 +2,27 @@
 /**
  * Hoisted + cached lint context for `re-export`.
  *
- * The per-patch loop used to rebuild the whole patch-queue context AND a
- * fresh queue-wide checkJs TypeScript program for every patch — ~37 s of
- * fixed setup per patch (measured on a 290-patch consumer queue), so an
- * N-patch re-export cost N×37 s. This module:
+ * Rebuilding the whole patch-queue context AND a fresh queue-wide checkJs
+ * TypeScript program for every patch costs tens of seconds of fixed setup
+ * per patch, so an N-patch re-export pays it N times. This module:
  *
  * - builds the queue context and the {@link PerRunCheckJs} program
  *   controller ONCE per invocation (`buildReExportLintContext`) and slices
- * per-patch findings out of it (the shape `move-files`/`split`
- *   already use, plus the program-level hoist `lint --per-patch` has);
+ *   per-patch findings out of it;
  * - reuses the existing per-patch lint RESULT cache
  *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations —
- *   re-export lints the identical input `lint --per-patch` does (the
- *   fresh `git diff HEAD` of the owned files), and the key already
- *   hashes engine HEAD, per-file content, patch body, config, shims, and
- *   ownership, so a repeat single re-export is a warm hit (~4 s instead
- *   of ~41 s). `--no-cache` opts out; run-level checkJs globals are
- * never cached and are emitted once per invocation;
+ *   re-export lints the identical input `lint --per-patch` does (the fresh
+ *   `git diff HEAD` of the owned files), and the key already hashes engine
+ *   HEAD, per-file content, patch body, config, shims, and ownership, so a
+ *   repeat single re-export is a warm hit. `--no-cache` opts out; run-level
+ *   checkJs globals are never cached and are emitted once per invocation;
  * - keeps the in-memory queue context honest after each write
  *   (`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 { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, getPerPatchLintCacheHeadSha, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/lint-cache.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';
 import { extractAddedLinesPerFile } from '../core/patch-lint-diff.js';
 import { resolvePatchOwnedSysMjs } from '../core/patch-lint-ownership.js';
@@ -138,7 +135,12 @@ export async function lintReExportedPatch(args) {
     else if (patchQueueCtx) {
         lintOptions.checkJsReportScope = resolvePatchOwnedSysMjs(detectNewFilesInDiff(diffContent));
     }
-    const issues = await lintExportedPatch(paths.engine, existingFiles, diffContent, config, patchQueueCtx, args.ignoreChecks, args.patchTier, lintOptions);
+    const issues = await lintExportedPatch(paths.engine, existingFiles, diffContent, config, {
+        ...lintOptions,
+        ...(patchQueueCtx ? { patchQueueCtx } : {}),
+        ...(args.ignoreChecks ? { ignoreChecks: args.ignoreChecks } : {}),
+        ...(args.patchTier ? { patchTier: args.patchTier } : {}),
+    });
     reportPatchLintOutcome([...globalIssues, ...issues], args.skipLint);
     return {
         issues,

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

@@ -8,12 +8,12 @@ export interface NormalizedReExportArguments {
 }
 /**
  * Accepts the `export`-style space-separated path shape for
- * `re-export <patch> --files` (0.34.0 field report): commander's
- * `--files <paths>` consumes one comma-separated value, so
- * `re-export 006-x --files a/b.js c/d.js` used to park `c/d.js` in the
- * positional patches and fail with "--files operates on exactly one
- * target patch" — pointing at the wrong argument. When every positional
- * beyond the first looks like a file path, fold them into the file list.
+ * `re-export <patch> --files`. Commander's `--files <paths>` consumes one
+ * comma-separated value, so `re-export 006-x --files a/b.js c/d.js` parks
+ * `c/d.js` in the positional patches and fails with "--files operates on
+ * exactly one target patch" — pointing at the wrong argument. When every
+ * positional beyond the first looks like a file path, fold them into the
+ * file list.
  */
 export declare function normalizeReExportFilesPositionals(patches: readonly string[], options: ReExportOptions): NormalizedReExportArguments;
 /**

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

@@ -11,12 +11,12 @@ function looksLikeFilePath(value) {
 }
 /**
  * Accepts the `export`-style space-separated path shape for
- * `re-export <patch> --files` (0.34.0 field report): commander's
- * `--files <paths>` consumes one comma-separated value, so
- * `re-export 006-x --files a/b.js c/d.js` used to park `c/d.js` in the
- * positional patches and fail with "--files operates on exactly one
- * target patch" — pointing at the wrong argument. When every positional
- * beyond the first looks like a file path, fold them into the file list.
+ * `re-export <patch> --files`. Commander's `--files <paths>` consumes one
+ * comma-separated value, so `re-export 006-x --files a/b.js c/d.js` parks
+ * `c/d.js` in the positional patches and fails with "--files operates on
+ * exactly one target patch" — pointing at the wrong argument. When every
+ * positional beyond the first looks like a file path, fold them into the
+ * file list.
  */
 export function normalizeReExportFilesPositionals(patches, options) {
     if (options.files === undefined || patches.length <= 1) {

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

@@ -1,16 +1,10 @@
 /**
  * CLI registration for `fireforge re-export`.
  *
- * Split out of `re-export.ts` in 0.41.0. That file was the only one in `src/`
- * carrying a file-level `eslint-disable max-lines` — it measured 526 against
- * the 500 cap with the rule suppressed — and its own suppression comment named
- * this block as the obvious thing to move ("splitting register plumbing is
- * unrelated to this fix"). Moving it drops the file under the cap and removes
- * the suppression.
- *
- * §7 of the quality survey forbids folding `re-export-files.ts` back INTO the
- * orchestrator; this splits in the other direction, matching the existing
- * `re-export-scan.ts` / `re-export-options.ts` boundary.
+ * Split out of `re-export.ts`, which was otherwise over the per-file line
+ * cap. The split direction matches the existing `re-export-scan.ts` /
+ * `re-export-options.ts` boundary; folding `re-export-files.ts` back into
+ * the orchestrator would go the wrong way.
  */
 import { Command } from 'commander';
 import type { CommandContext } from '../types/cli.js';

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

@@ -2,16 +2,10 @@
 /**
  * CLI registration for `fireforge re-export`.
  *
- * Split out of `re-export.ts` in 0.41.0. That file was the only one in `src/`
- * carrying a file-level `eslint-disable max-lines` — it measured 526 against
- * the 500 cap with the rule suppressed — and its own suppression comment named
- * this block as the obvious thing to move ("splitting register plumbing is
- * unrelated to this fix"). Moving it drops the file under the cap and removes
- * the suppression.
- *
- * §7 of the quality survey forbids folding `re-export-files.ts` back INTO the
- * orchestrator; this splits in the other direction, matching the existing
- * `re-export-scan.ts` / `re-export-options.ts` boundary.
+ * Split out of `re-export.ts`, which was otherwise over the per-file line
+ * cap. The split direction matches the existing `re-export-scan.ts` /
+ * `re-export-options.ts` boundary; folding `re-export-files.ts` back into
+ * the orchestrator would go the wrong way.
  */
 import { Command, Option } from 'commander';
 import { withEngineSessionLock } from '../core/engine-session-lock.js';
@@ -34,7 +28,7 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .filter((v) => v.length > 0))
         .option('--refuse-adjacent-unmanaged', 'Refuse a scan-less re-export (non-zero exit, patch not written) when unmanaged files exist adjacent to the patch ownership, instead of warning. Mutually exclusive with --scan and --files.')
         .option('--refuse-foreign-drift', "Refuse a scan-less re-export (non-zero exit, patch not written) when the refreshed body would absorb engine lines not present in the old patch body — protects multi-session checkouts from silently capturing another session's uncommitted edits. Mutually exclusive with --scan and --files.")
-        .option('--expect <path>', "With --refuse-foreign-drift, name an engine-relative file whose drift is this session's intended edit: drift confined to --expect files proceeds, drift anywhere else still refuses. Repeatable.", ...stringListOption())
+        .option('--expect <path>', "With --refuse-foreign-drift, name an engine-relative file whose drift is this session's intended edit: drift confined to --expect files proceeds, drift anywhere else still refuses. Repeatable, and the whitelist applies across EVERY patch in this invocation, not per patch — so pass all the patches and all their --expect paths in one call rather than looping one patch at a time.", ...stringListOption())
         .option('--dry-run', 'Show what would change without writing')
         .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
         .option('--no-cache', 'Bypass per-patch lint result cache reads and writes for this re-export')

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

@@ -3,9 +3,9 @@ import { dirname, join } from 'node:path';
 import { confirm } from '@clack/prompts';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { getModifiedFilesInDir, getUntrackedFilesInDir } from '../core/git-status.js';
-import { computeProjectedLintRegressions } from '../core/lint-projection.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
 import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, lintPatchQueue, } from '../core/patch-lint.js';
+import { computeProjectedLintRegressions } from '../core/patch-lint-projection.js';
 import { getClaimedFiles } from '../core/patch-manifest.js';
 import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';

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

@@ -1,8 +1,8 @@
 /**
  * Single-patch refresh core for `fireforge re-export`, split out of
- * `re-export.ts` (at the per-file line budget after the
- * hoisted-lint and foreign-drift wiring). The orchestrator loop calls
- * {@link reExportSinglePatchWithIndexLockRetry} per selected patch.
+ * `re-export.ts` to stay under the per-file line budget. The orchestrator
+ * loop calls {@link reExportSinglePatchWithIndexLockRetry} per selected
+ * patch.
  */
 import { getProjectPaths } from '../core/config.js';
 import type { PatchesManifest, PatchMetadata, ReExportOptions } from '../types/commands/index.js';

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

@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * Single-patch refresh core for `fireforge re-export`, split out of
- * `re-export.ts` (at the per-file line budget after the
- * hoisted-lint and foreign-drift wiring). The orchestrator loop calls
- * {@link reExportSinglePatchWithIndexLockRetry} per selected patch.
+ * `re-export.ts` to stay under the per-file line budget. The orchestrator
+ * loop calls {@link reExportSinglePatchWithIndexLockRetry} per selected
+ * patch.
  */
 import { getProjectPaths } from '../core/config.js';
+import { stdioIsInteractive } from '../core/destructive.js';
 import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { updatePatchAndMetadata } from '../core/patch-export.js';
@@ -61,7 +62,7 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
             added: scanResult.added,
         });
         if (options.scanFiles === undefined) {
-            const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+            const isInteractive = stdioIsInteractive();
             const proceed = await confirmBroadScanAdditions({
                 patchFilename: patch.filename,
                 added: scanResult.added,
@@ -76,15 +77,14 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
         currentFilesAffected = scanResult.updated;
     }
     else if (options.files === undefined) {
-        // Finding #16: when neither `--scan` nor `--files` is set and some
-        // of the manifest's claimed files no longer exist on disk, the
-        // re-export silently writes a refreshed body whose filesAffected
-        // still names the vanished paths. That is the documented contract,
-        // but it is also a footgun — a later `verify` then fails on
-        // manifest-consistency with no obvious trigger. Emit one advisory
-        // warning up-front when we can detect the drift cheaply, so the
-        // operator has a chance to re-run with `--scan` or `--files`
-        // before the stale filesAffected lands in patches.json.
+        // When neither `--scan` nor `--files` is set and some of the manifest's
+        // claimed files no longer exist on disk, the re-export silently writes a
+        // refreshed body whose filesAffected still names the vanished paths.
+        // That is the documented contract, but it is also a footgun — a later
+        // `verify` then fails on manifest-consistency with no obvious trigger.
+        // Emit one advisory warning up-front when the drift is cheap to detect,
+        // so the operator can re-run with `--scan` or `--files` before the stale
+        // filesAffected lands in patches.json.
         const args = { patch, paths, manifest, currentFilesAffected, ctx: adjacentCtx };
         if (await reportAdjacentUnmanagedFiles(args))
             return false;
@@ -105,11 +105,11 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
         for (const f of removed)
             info(`  - ${f}`);
     }
-    // Stale-furnace-source gate (0.37.0 item 4): re-export captures deployed
-    // engine copies, so a component source edited after the last furnace
-    // apply would land in the patch as its OLD deployed content. Refuse (or
-    // warn under --allow-stale-furnace) before diffing. Runs in dry-run too
-    // so the failure surfaces early.
+    // Stale-furnace-source gate: re-export captures deployed engine copies, so
+    // a component source edited after the last furnace apply would land in the
+    // patch as its OLD deployed content. Refuse (or warn under
+    // --allow-stale-furnace) before diffing. Runs in dry-run too so the failure
+    // surfaces early.
     await enforceFreshFurnaceSources(paths.root, currentFilesAffected, options.allowStaleFurnace === true, 're-export');
     const missingFiles = await findMissingFiles(paths.engine, currentFilesAffected);
     if (missingFiles.length === currentFilesAffected.length) {
@@ -207,7 +207,7 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
  */
 async function commitRefreshedPatch(args) {
     const { patch, paths, manifest, options, config, lintCtx, diffContent, updates } = args;
-    await updatePatchAndMetadata(paths.patches, patch.filename, diffContent, updates, undefined, {
+    const bodyChanged = await updatePatchAndMetadata(paths.patches, patch.filename, diffContent, updates, undefined, {
         config,
         command: 're-export',
         forceUnsafe: options.forceUnsafe === true,
@@ -226,17 +226,25 @@ async function commitRefreshedPatch(args) {
             };
         }
     }
-    success(`Re-exported ${patch.filename}`);
+    // A bulk run refreshes every patch; saying "Re-exported" for one whose body
+    // did not move buries the patches that DID move. The run still counts this
+    // patch as successfully refreshed, so `--stamp` completeness is unaffected.
+    if (bodyChanged) {
+        success(`Re-exported ${patch.filename}`);
+    }
+    else {
+        info(`Unchanged ${patch.filename}`);
+    }
 }
 /**
  * Threads the patch's own `lintIgnore` list through so the per-patch
  * suppression honoured by export/export-all is also honoured here — a
  * re-export could otherwise not refresh an advisory-noisy but intentional
- * patch without the blunt `--skip-lint`. The paired `patch.tier` threads
- * the explicit branding-threshold opt-in the same way. The CLI flags
- * `--tier` and `--lint-ignore` participate with append/union semantics
- * (explicit removal lives on `fireforge patch lint-ignore`), computed
- * before the lint pass so the new intent takes effect on this invocation.
+ * patch without the blunt `--skip-lint`. The paired `patch.tier` threads the
+ * explicit branding-threshold opt-in the same way. The CLI flags `--tier`
+ * and `--lint-ignore` participate with append/union semantics (explicit
+ * removal lives on `fireforge patch lint-ignore`), computed before the lint
+ * pass so the new intent takes effect on this invocation.
  */
 function computeReExportUpdates(patch, options, currentFilesAffected) {
     const existingIgnoreSet = new Set(patch.lintIgnore ?? []);

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

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { multiselect } from '@clack/prompts';
 import { getProjectPaths, loadConfig } from '../core/config.js';
+import { stdioIsInteractive } from '../core/destructive.js';
+import { assertEngineGitReady } from '../core/engine-precondition.js';
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
-import { isGitRepository } from '../core/git.js';
 import { formatPatchNotFoundError } from '../core/patch-identifier-suggest.js';
 import { loadPatchesManifest, resolvePatchIdentifier, stampPatchVersions, } from '../core/patch-manifest.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { elapsedSince } from '../utils/elapsed.js';
 import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
 import { cancel, info, intro, isCancel, outro, spinner, success, warn } from '../utils/logger.js';
 import { loadScanFilesAssignments, withDryRunPurityGuard, withDryRunReExportLock, } from './re-export-bulk-scan.js';
 import { reExportFilesInPlace } from './re-export-files.js';
@@ -25,7 +25,7 @@ async function resolveSelectedPatches(patches, options, manifest) {
         for (const identifier of patches) {
             const match = resolvePatchIdentifier(identifier, manifest.patches);
             if (!match) {
-                // Suggest, never dump: a wrong guess used to print the
+                // Suggest, never dump: a wrong guess would otherwise print the
                 // whole ~300-entry manifest, burying the error it was reporting.
                 throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
             }
@@ -34,7 +34,7 @@ async function resolveSelectedPatches(patches, options, manifest) {
         return selectedPatches;
     }
     // No patches specified — prompt or error
-    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    const isInteractive = stdioIsInteractive();
     if (!isInteractive) {
         throw new InvalidArgumentError('Specify patch identifiers or use --all in non-interactive mode.\n\n' +
             'Usage: fireforge re-export [patches...] or fireforge re-export --all', 'patches');
@@ -72,18 +72,11 @@ export async function reExportCommand(projectRoot, patches, options) {
     const isDryRun = options.dryRun === true;
     intro(isDryRun ? 'FireForge Re-export (dry run)' : 'FireForge Re-export');
     // Accept export-style space-separated paths after --files by folding
-    // path-shaped extra positionals into the file list (0.34.0 field report).
+    // path-shaped extra positionals into the file list.
     ({ patches, options } = applyReExportFilesPositionalFolding(patches, options));
     validateReExportOptionCombinations(patches, options);
     const paths = getProjectPaths(projectRoot);
-    // Check if engine exists
-    if (!(await pathExists(paths.engine))) {
-        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
-    }
-    // Check if it's a git repository
-    if (!(await isGitRepository(paths.engine))) {
-        throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
-    }
+    await assertEngineGitReady(paths.engine);
     // Load the manifest
     const manifest = await loadPatchesManifest(paths.patches);
     if (!manifest || manifest.patches.length === 0) {
@@ -258,14 +251,13 @@ function throwRunLevelRefusals(adjacentCtx, driftCtx, progress) {
     }
 }
 /**
- * Prints the end-of-run summary and enforces the exit contract:
- * a partial run exits non-zero BY DEFAULT (adjudicated for 0.41.0, per the
- * follow-up 0.40.0's G7 recorded). "Re-exported 2 of 3" used to print and
- * exit 0, letting a partial refresh ride an `&&` chain as success. The
- * summary still prints first so the honest "N of M" accounting stays
- * visible; the throw then carries the failed/skipped breakdown. Dry-run
- * included: a preview reporting that the real run would partially fail
- * must not read as a passing preview in scripts.
+ * Prints the end-of-run summary and enforces the exit contract: a partial run
+ * exits non-zero by default. "Re-exported 2 of 3" printing with exit 0 lets a
+ * partial refresh ride an `&&` chain as success. The summary still prints
+ * first so the honest "N of M" accounting stays visible; the throw then
+ * carries the failed/skipped breakdown. Dry-run included: a preview
+ * reporting that the real run would partially fail must not read as a passing
+ * preview in scripts.
  */
 function reportReExportOutcome(args) {
     const { isDryRun, reExported, selectedCount, config, progress } = args;