@hominis/fireforge 0.35.0 → 0.36.0

package/dist/src/commands/import.js

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
 import { confirm } from '@clack/prompts';
+import { Command } from 'commander';
 import { getProjectPaths, loadConfig, loadState, updateState } from '../core/config.js';
 import { getHead } from '../core/git.js';
 import { getDirtyFiles } from '../core/git-status.js';
-import { applyPatchesWithContinue, computePatchedContent, countPatches, discoverPatches, extractAffectedFiles, PatchError, } from '../core/patch-apply.js';
+import { applyPatchesWithContinue, countPatches, createPatchedContentComputer, discoverPatches, extractAffectedFiles, matchesUntilFilename, PatchError, } from '../core/patch-apply.js';
 import { checkVersionCompatibility, loadPatchesManifest, validatePatchesManifestConsistency, validatePatchIntegrity, } from '../core/patch-manifest.js';
 import { getPatchSourceVersion } from '../core/patch-source-metadata.js';
 import { GeneralError } from '../errors/base.js';
@@ -25,11 +26,17 @@ function isSafeIoFallback(error) {
     const code = error?.code;
     return typeof code === 'string' && SAFE_IO_FALLBACK_CODES.has(code);
 }
+/** Concurrency bound for per-file classification (each call spawns git). */
+const UNMANAGED_CLASSIFY_CONCURRENCY = 8;
 async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
-    const classifications = await Promise.all(dirtyFiles.map(async (file) => {
+    // One manifest+patch-discovery load for the whole batch (the per-call
+    // computePatchedContent re-read everything for every file), and bounded
+    // concurrency instead of an unbounded Promise.all over git spawns.
+    const computeExpected = await createPatchedContentComputer(patchesDir, engineDir);
+    const classifications = await mapWithConcurrency(dirtyFiles, UNMANAGED_CLASSIFY_CONCURRENCY, async (file) => {
         try {
             const [expected, exists] = await Promise.all([
-                computePatchedContent(patchesDir, engineDir, file),
+                computeExpected(file),
                 pathExists(join(engineDir, file)),
             ]);
             const actual = exists ? await readText(join(engineDir, file)) : null;
@@ -51,9 +58,24 @@ async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
             verbose(`Treating ${file} as unmanaged because patched-content classification failed with IO error: ${toError(error).message}`);
             return file;
         }
-    }));
+    });
     return classifications.filter((file) => file !== null).sort();
 }
+/** Maps items with at most `limit` in-flight promises. Preserves order. */
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            results[index] = await fn(items[index]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
 function reportForcedOverwriteRisk(unmanagedDirtyFiles) {
     warn(`--force will overwrite ${unmanagedDirtyFiles.length} unmanaged change${unmanagedDirtyFiles.length === 1 ? '' : 's'} in patch-touched file${unmanagedDirtyFiles.length === 1 ? '' : 's'}:`);
     for (const file of unmanagedDirtyFiles) {
@@ -150,7 +172,7 @@ async function checkEngineDrift(engineDir, baseCommit, forceImport) {
     const currentHead = await getHead(engineDir);
     if (currentHead === baseCommit)
         return true;
-    if (!process.stdin.isTTY) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
         if (!forceImport) {
             throw new GeneralError('Engine HEAD has drifted from base commit. Re-run with --force to bypass drift check.');
         }
@@ -189,8 +211,13 @@ function buildUntilFilenameSet(patches, until) {
     const set = new Set();
     if (until === undefined)
         return set;
-    const normalized = until.endsWith('.patch') ? until : `${until}.patch`;
-    const target = patches.find((p) => p.filename === until || p.filename === normalized);
+    // Resolve the identifier with the SAME matcher the apply loop uses
+    // (`matchesUntilFilename` accepts filenames, extension-less names, AND
+    // bare ordinals). The previous filename-only match meant
+    // `import --until 5` produced an EMPTY scope set — the UI previewed
+    // "0 patches", the integrity gates filtered every in-range issue away —
+    // and then the apply loop happily applied patches 1..5 anyway.
+    const target = patches.find((p) => matchesUntilFilename(p.filename, until));
     if (!target)
         return set;
     for (const patch of patches) {
@@ -266,7 +293,7 @@ async function gateImportIntegrity(paths, untilFilenameSet, until, forceImport)
         if (forceImport) {
             warn('Continuing because --force was provided. Integrity issues were not resolved.\n');
         }
-        else if (!process.stdin.isTTY) {
+        else if (!(process.stdin.isTTY && process.stdout.isTTY)) {
             throw new GeneralError(`Refusing to import while ${integrityIssues.length} patch integrity issue(s) are unresolved. ` +
                 `Fix the issues reported above (see "fireforge doctor") or re-run with --force to continue anyway.`);
         }
@@ -421,4 +448,3 @@ export function registerImport(program, { getProjectRoot, withErrorHandling }) {
         await importCommand(getProjectRoot(), pickDefined(merged));
     }));
 }
-//# sourceMappingURL=import.js.map

package/dist/src/commands/lint-per-patch.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { loadConfig } from '../core/config.js';
+import { getProjectPaths, loadConfig } from '../core/config.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, getPerPatchLintCacheHeadSha, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/lint-cache.js';
 import { buildPatchQueueContext, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
@@ -215,13 +215,26 @@ function reportPerPatchOutcome(issues, linted, skipped, options) {
  * than silently linting nothing.
  */
 function selectPatchSubset(manifest, requested) {
-    const matches = (p, name) => p.filename === name ||
-        p.filename === `${name}.patch` ||
-        p.filename.replace(/\.patch$/, '') === name.replace(/\.patch$/, '') ||
-        p.name === name;
+    const normalizedRequests = requested
+        .flatMap((entry) => entry.split(','))
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    const patchAliases = (p) => {
+        const aliases = new Set([p.filename, p.filename.replace(/\.patch$/, ''), p.name]);
+        const match = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(p.filename);
+        if (match?.[2] && match[3]) {
+            aliases.add(`${match[2]}-${match[3]}`);
+            aliases.add(match[3]);
+        }
+        return aliases;
+    };
+    const matches = (p, name) => {
+        const stem = name.replace(/\.patch$/, '');
+        return (patchAliases(p).has(name) || patchAliases(p).has(stem) || patchAliases(p).has(`${stem}.patch`));
+    };
     const selected = [];
     const seen = new Set();
-    for (const name of requested) {
+    for (const name of normalizedRequests) {
         const found = manifest.patches.filter((p) => matches(p, name));
         if (found.length === 0) {
             const available = manifest.patches.map((p) => p.filename).join(', ');
@@ -340,4 +353,3 @@ export async function lintPerPatch(projectRoot, paths, options = {}) {
     }
     reportPerPatchOutcome(issues, linted, skipped, options);
 }
-//# sourceMappingURL=lint-per-patch.js.map

package/dist/src/commands/lint.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { isBrandingManagedPath } from '../core/branding.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
@@ -510,7 +511,7 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         .option('--since <git-rev>', 'Tag issues as [introduced] or [cumulative] based on whether the file changed since <git-rev> (e.g. HEAD, a branch, a SHA)')
         .option('--only-introduced', 'Fail only on issues tagged [introduced] (requires --since). Cumulative errors still print but do not set a non-zero exit.')
         .option('--per-patch', "Lint each patch in the queue as its own isolated diff. Rescopes patch-size rules so they fire against individual patches rather than the aggregate. Honours each patch's `lintIgnore` entries.")
-        .option('--patches <names...>', 'With --per-patch, lint only the named patches (by filename or manifest name) instead of the whole queue. Queue-level findings are scoped to files those patches touch.')
+        .option('--patches <names...>', 'With --per-patch, lint only the named patches. Accepts repeated flags, comma lists, full filenames/stems, manifest names, category-prefixed slugs, or bare slugs.')
         .option('--max-warnings <n>', 'Fail when lint reports more than <n> warning(s); use 0 for warning-clean release gates.')
         .option('--no-cache', 'Bypass per-patch lint result cache reads and writes.')
         .action(withErrorHandling(async (paths, options) => {
@@ -539,9 +540,19 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         }
         await lintCommand(getProjectRoot(), paths, lintOptions);
     }));
-    lint
+    const lintCache = lint
         .command('cache')
         .description('Manage the per-patch lint result cache')
+        // Commander routes `fireforge lint cache` here even when the operator
+        // meant to lint an engine directory literally named `cache`. A bare
+        // `lint cache` (no subcommand) used to silently do nothing — make the
+        // ambiguity explicit instead of doing the wrong operation quietly.
+        .action(withErrorHandling(() => {
+        info('Nothing to do: "lint cache" manages the lint result cache (try "lint cache clear"). ' +
+            'To lint a directory named cache/, disambiguate with a trailing slash: "fireforge lint cache/".');
+        return Promise.resolve();
+    }));
+    lintCache
         .command('clear')
         .description('Clear cached per-patch lint results')
         .action(withErrorHandling(async () => {
@@ -551,4 +562,3 @@ export function registerLint(program, { getProjectRoot, withErrorHandling }) {
         outro('Lint cache cleared');
     }));
 }
-//# sourceMappingURL=lint.js.map

package/dist/src/commands/manifest.js

@@ -20,7 +20,7 @@ import { registerRun } from './run.js';
 import { registerSetup } from './setup.js';
 import { registerSource } from './source.js';
 import { registerStatus } from './status.js';
-import { registerTest } from './test.js';
+import { registerTest } from './test-register.js';
 import { registerToken } from './token.js';
 import { registerTypecheck } from './typecheck.js';
 import { registerVerify } from './verify.js';
@@ -60,4 +60,3 @@ export const COMMAND_MANIFEST = [
     { name: 'verify', group: 'diagnostics', register: registerVerify },
     { name: 'furnace', group: 'components', register: registerFurnace },
 ];
-//# sourceMappingURL=manifest.js.map

package/dist/src/commands/package.js

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Command } from 'commander';
 import { validateBrandOverride } from '../core/brand-validation.js';
 import { prepareBuildEnvironment } from '../core/build-prepare.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
@@ -88,4 +90,3 @@ export function registerPackage(program, { getProjectRoot, withErrorHandling })
         await packageCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=package.js.map

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

@@ -9,6 +9,7 @@
  * compaction is range-aware (each category range compacts independently,
  * reserved ranges and out-of-range strays are left untouched).
  */
+import { Command } from 'commander';
 import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
@@ -206,4 +207,3 @@ export function registerPatchCompact(parent, context) {
         await patchCompactCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=compact.js.map

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

@@ -8,6 +8,7 @@
  * `--dry-run`, and appends to `patches/.fireforge-history.jsonl` on success.
  */
 import { basename } from 'node:path';
+import { Command } from 'commander';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { buildPatchQueueContext, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, isForwardImportableFile, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
@@ -202,4 +203,3 @@ export function registerPatchDelete(parent, context) {
         await patchDeleteCommand(getProjectRoot(), name, pickDefined(options));
     }));
 }
-//# sourceMappingURL=delete.js.map

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

@@ -7,6 +7,7 @@
  * Queue-level verbs like `lint`, `export`, `verify`, and `status` stay
  * flat.
  */
+import { Command } from 'commander';
 import { registerPatchCompact } from './compact.js';
 import { registerPatchDelete } from './delete.js';
 import { registerPatchLintIgnore } from './lint-ignore.js';
@@ -45,4 +46,3 @@ export function registerPatch(program, context) {
     registerPatchStagedDependency(patch, context);
     registerPatchTier(patch, context);
 }
-//# sourceMappingURL=index.js.map

package/dist/src/commands/patch/lint-ignore.js

@@ -19,7 +19,8 @@
  * write — important when an operator scripts repeated invocations or
  * runs `--add` and `--remove` back-to-back.
  */
-import { appendHistory } from '../../core/destructive.js';
+import { Command } from 'commander';
+import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { mutatePatchMetadata } from '../../core/patch-export.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
@@ -107,13 +108,28 @@ export async function patchLintIgnoreCommand(projectRoot, identifier, options =
     const values = mode === 'add' ? (options.add ?? []) : mode === 'remove' ? (options.remove ?? []) : [];
     const { paths, manifest } = await requirePatchQueue(projectRoot);
     const target = requirePatchTarget(identifier, manifest.patches);
-    if (isDryRun) {
-        const existing = target.lintIgnore ?? [];
-        const projected = applyMode(existing, mode, values) ?? [];
-        info(`[dry-run] ${target.filename}: ${describeChange(existing, projected, mode, values)}.`);
+    // Destructive-operation contract (docs/lifecycle-invariants.md): manifest
+    // metadata mutations get summary + dry-run + confirmation/--yes + history
+    // uniformly. This command used to accept --yes without ever prompting, so
+    // the flag only appeared in the history record — and suppressing lint
+    // findings is precisely the mutation an operator should consciously
+    // approve.
+    const projectedSummary = describeChange(target.lintIgnore ?? [], applyMode(target.lintIgnore ?? [], mode, values) ?? [], mode, values);
+    const decision = await confirmDestructive({
+        operation: 'patch-lint-ignore',
+        title: `Patch lint-ignore: ${target.filename}`,
+        summary: [`${target.filename}: ${projectedSummary}`],
+        yes: options.yes === true,
+        dryRun: isDryRun,
+    });
+    if (decision === 'dry-run') {
         outro('Dry run complete — no changes made');
         return;
     }
+    if (decision === 'cancelled') {
+        outro('Cancelled — no changes made');
+        return;
+    }
     const result = await mutatePatchMetadata(paths.patches, target.filename, (existing) => {
         const next = applyMode(existing.lintIgnore ?? [], mode, values);
         // Either set the new list when non-empty or unset the field
@@ -186,4 +202,3 @@ export function registerPatchLintIgnore(parent, context) {
         await patchLintIgnoreCommand(getProjectRoot(), name, normalized);
     }));
 }
-//# sourceMappingURL=lint-ignore.js.map

package/dist/src/commands/patch/move-files.js

@@ -4,6 +4,7 @@
  * re-export choreography needed to move file ownership between two patches.
  */
 import { relative } from 'node:path';
+import { Command } from 'commander';
 import { getProjectPaths } from '../../core/config.js';
 import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
@@ -136,4 +137,3 @@ export function registerPatchMoveFiles(parent, context) {
         await patchMoveFilesCommand(getProjectRoot(), from, to, options);
     }));
 }
-//# sourceMappingURL=move-files.js.map

package/dist/src/commands/patch/patch-context.js

@@ -50,4 +50,3 @@ export function requirePatchTarget(identifier, patches) {
     }
     return target;
 }
-//# sourceMappingURL=patch-context.js.map

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

@@ -18,9 +18,10 @@
  */
 import { rename as fsRename } from 'node:fs/promises';
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
-import { sanitizeName } from '../../core/patch-export.js';
+import { patchNameSlug } from '../../core/patch-export.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from '../../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
@@ -163,7 +164,7 @@ export async function patchRenameCommand(projectRoot, identifier, options = {})
     if (!split) {
         throw new GeneralError(`Cannot rename ${target.filename}: filename does not match the expected {ordinal}-{category}-{slug}.patch convention. Re-export the patch instead.`);
     }
-    const newSlug = sanitizeName(options.to);
+    const newSlug = patchNameSlug(options.to, split.category);
     if (newSlug === '') {
         throw new InvalidArgumentError('--to must contain at least one alphanumeric character after sanitisation.', 'patch rename');
     }
@@ -258,7 +259,7 @@ export function registerPatchRename(parent, context) {
     parent
         .command('rename <name>')
         .description('Rename a patch: filename + manifest name (and optional description) update without rewriting the .patch body.')
-        .requiredOption('--to <new-name>', 'New human-readable name (sanitised into the filename slug)')
+        .requiredOption('--to <new-name>', 'New human-readable name, category-prefixed slug, or full filename stem (normalised into the filename slug)')
         .option('--description <text>', 'Replacement description (omit to leave description unchanged)')
         .option('--dry-run', 'Show what would change without writing')
         .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
@@ -267,4 +268,3 @@ export function registerPatchRename(parent, context) {
         await patchRenameCommand(getProjectRoot(), name, pickDefined(options));
     }));
 }
-//# sourceMappingURL=rename.js.map

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

@@ -8,7 +8,7 @@
  * `lintPatchQueue` so reorders that would introduce a forward-import fail
  * before any bytes move.
  */
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
 import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive, } from '../../core/destructive.js';
 import { buildPatchQueueContext, lintPatchQueue, } from '../../core/patch-lint.js';
@@ -18,7 +18,7 @@ import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-p
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
-import { pickDefined } from '../../utils/options.js';
+import { commanderArgParser, pickDefined } from '../../utils/options.js';
 import { parsePositiveIntegerFlag } from '../../utils/validation.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /** Zero-pads an ordinal number to the given width. */
@@ -372,7 +372,7 @@ export function registerPatchReorder(parent, context) {
     parent
         .command('reorder <name>')
         .description('Move a patch to a different position in the queue (destructive)')
-        .addOption(new Option('--to <order>', 'Destination ordinal').argParser((v) => parsePositiveIntegerFlag('--to', v)))
+        .addOption(new Option('--to <order>', 'Destination ordinal').argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--to', v))))
         .option('--before <anchor>', 'Place the patch immediately before <anchor>')
         .option('--after <anchor>', 'Place the patch immediately after <anchor>')
         .option('--dry-run', 'Show what would happen without writing')
@@ -382,4 +382,3 @@ export function registerPatchReorder(parent, context) {
         await patchReorderCommand(getProjectRoot(), name, pickDefined(options));
     }));
 }
-//# sourceMappingURL=reorder.js.map

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

@@ -7,6 +7,7 @@
  * budget; consumed only by the split command.
  */
 import { join } from 'node:path';
+import {} from '../../core/destructive.js';
 import { getDiffForFilesAgainstHead } from '../../core/git-diff.js';
 import { computeProjectedLintRegressions } from '../../core/lint-projection.js';
 import { extractAffectedFiles } from '../../core/patch-apply.js';
@@ -18,6 +19,7 @@ import { extractNewFileContentFromDiff } from '../../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { pathExists } from '../../utils/fs.js';
 import { warn } from '../../utils/logger.js';
+import {} from '../export-flow.js';
 /**
  *
  */
@@ -249,4 +251,3 @@ export function buildSplitSummary(plan) {
     }
     return summary;
 }
-//# sourceMappingURL=split-plan.js.map

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

@@ -18,6 +18,7 @@
  * the worktree.
  */
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { normalizePatchArtifact } from '../../core/patch-artifact-normalize.js';
@@ -29,7 +30,7 @@ import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 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 { pickDefined } from '../../utils/options.js';
+import { commanderArgParser, pickDefined } from '../../utils/options.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';
@@ -258,13 +259,13 @@ 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', (raw) => {
+        .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('--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')
@@ -289,4 +290,3 @@ export function registerPatchSplit(parent, context) {
         });
     }));
 }
-//# sourceMappingURL=split.js.map

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

@@ -3,6 +3,7 @@
  * `fireforge patch staged-dependency <name>` — edits
  * PatchMetadata.stagedDependencies without rewriting the .patch body.
  */
+import { Command } from 'commander';
 import { appendHistory } from '../../core/destructive.js';
 import { mutatePatchMetadata } from '../../core/patch-export.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
@@ -161,4 +162,3 @@ export function registerPatchStagedDependency(parent, context) {
         await patchStagedDependencyCommand(getProjectRoot(), name, options);
     }));
 }
-//# sourceMappingURL=staged-dependency.js.map

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

@@ -14,8 +14,8 @@
  * Modes are mutually exclusive: exactly one of `--tier <branding>` or
  * `--clear` must be supplied per invocation.
  */
-import { Option } from 'commander';
-import { appendHistory } from '../../core/destructive.js';
+import { Command, Option } from 'commander';
+import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { updatePatchMetadata } from '../../core/patch-export.js';
 import { InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
@@ -60,11 +60,25 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
         : before === undefined
             ? `set tier to "${after}"`
             : `change tier from "${before}" to "${after}"`;
-    if (isDryRun) {
-        info(`[dry-run] ${target.filename}: would ${action}.`);
+    // Destructive-operation contract (docs/lifecycle-invariants.md): manifest
+    // metadata mutations get summary + dry-run + confirmation/--yes + history
+    // uniformly. This command used to accept --yes without ever prompting, so
+    // the flag only appeared in the history record.
+    const decision = await confirmDestructive({
+        operation: 'patch-tier',
+        title: `Patch tier: ${target.filename}`,
+        summary: [`${target.filename}: ${action}`],
+        yes: options.yes === true,
+        dryRun: isDryRun,
+    });
+    if (decision === 'dry-run') {
         outro('Dry run complete — no changes made');
         return;
     }
+    if (decision === 'cancelled') {
+        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
@@ -116,4 +130,3 @@ export function registerPatchTier(parent, context) {
         });
     }));
 }
-//# sourceMappingURL=tier.js.map

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

@@ -78,4 +78,3 @@ export async function withDryRunReExportLock(fireforgeDir, isDryRun, operation)
         onStaleLockMessage: (ageMs) => `Removing stale FireForge re-export dry-run lock (age: ${Math.round(ageMs / 1000)}s). A previous dry-run process may have crashed.`,
     });
 }
-//# sourceMappingURL=re-export-bulk-scan.js.map

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

@@ -1,5 +1,6 @@
 // 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 { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { computeProjectedLintRegressions } from '../core/lint-projection.js';
@@ -260,4 +261,3 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     success(`Re-exported ${target.filename}`);
     outro('Re-export complete');
 }
-//# sourceMappingURL=re-export-files.js.map

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

@@ -83,4 +83,3 @@ export function validateReExportOptionCombinations(patches, options) {
         throw new InvalidArgumentError('--tier and --lint-ignore require explicit patch identifiers and cannot be combined with --all (different patches typically need different metadata).', '--all');
     }
 }
-//# sourceMappingURL=re-export-options.js.map

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

@@ -144,4 +144,3 @@ export function assertScanFileAdditionsHaveDiffHunks(args) {
         return;
     throw new InvalidArgumentError(`Refusing to re-export ${patchFilename} with --scan-file because ${noDiffScanFiles.length} explicit added path${noDiffScanFiles.length === 1 ? '' : 's'} produced no diff hunks (${noDiffScanFiles.join(', ')}). Remove unchanged paths or modify them before retrying.`, '--scan-file');
 }
-//# sourceMappingURL=re-export-scan.js.map

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

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: EUPL-1.2
+/* eslint-disable max-lines -- Re-export is at the guardrail; splitting register plumbing is unrelated to this fix. */
 import { dirname, join } from 'node:path';
 import { multiselect } from '@clack/prompts';
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
 import { getProjectPaths, loadConfig } from '../core/config.js';
+import { withEngineSessionLock } from '../core/engine-session-lock.js';
 import { isGitRepository } from '../core/git.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { getModifiedFilesInDir, getUntrackedFilesInDir } from '../core/git-status.js';
@@ -421,13 +423,13 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .option('--lint-ignore <check-id>', 'Append a lint check ID to the patch\'s PatchMetadata.lintIgnore (union, de-duped, repeatable). Mutually exclusive with --all. Use "fireforge patch lint-ignore" for --remove / --clear.', (value, prev) => [...prev, value], [])
         .action(withErrorHandling(async (patches, options) => {
         const { tier, lintIgnore, scanFile, scanFiles, ...rest } = options;
-        await reExportCommand(getProjectRoot(), patches, {
+        const projectRoot = getProjectRoot();
+        await withEngineSessionLock(projectRoot, 're-export', () => reExportCommand(projectRoot, patches, {
             ...pickDefined(rest),
             ...(scanFile !== undefined && scanFile.length > 0 ? { scanFiles: scanFile } : {}),
             ...(scanFiles !== undefined ? { scanFilesManifest: scanFiles } : {}),
             ...(tier !== undefined ? { tier: tier } : {}),
             ...(lintIgnore !== undefined && lintIgnore.length > 0 ? { lintIgnore } : {}),
-        });
+        }));
     }));
 }
-//# sourceMappingURL=re-export.js.map

package/dist/src/commands/rebase/abort.js

@@ -3,11 +3,10 @@
  * Rebase abort flow.
  */
 import { getProjectPaths, updateState } from '../../core/config.js';
-import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.js';
+import { clearAppliedFurnaceState } from '../../core/furnace-config.js';
 import { resetChanges } from '../../core/git.js';
 import { clearRebaseSession, loadRebaseSession } from '../../core/rebase-session.js';
 import { NoRebaseSessionError } from '../../errors/rebase.js';
-import { pathExists } from '../../utils/fs.js';
 import { intro, outro, spinner, success } from '../../utils/logger.js';
 import { confirmDirtyEngineReset } from './confirm.js';
 /**
@@ -47,12 +46,7 @@ export async function handleAbort(projectRoot, yes) {
     // misleading now that reset already succeeded). The rebase session is
     // still kept on disk so the user can retry the abort and let it
     // idempotently re-clear furnace state.
-    const furnacePaths = getFurnacePaths(projectRoot);
-    if (await pathExists(furnacePaths.furnaceState)) {
-        await updateFurnaceState(projectRoot, (current) => ({
-            ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
-        }));
-    }
+    await clearAppliedFurnaceState(projectRoot);
     // Step 3: clear pending resolution transactionally.
     await updateState(projectRoot, (current) => {
         if (!current.pendingResolution)
@@ -67,4 +61,3 @@ export async function handleAbort(projectRoot, yes) {
     success('Rebase aborted and session cleared.');
     outro('Rebase aborted');
 }
-//# sourceMappingURL=abort.js.map

package/dist/src/commands/rebase/confirm.js

@@ -30,4 +30,3 @@ export async function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCo
     }
     return true;
 }
-//# sourceMappingURL=confirm.js.map

package/dist/src/commands/rebase/conflict-summary.js

@@ -35,4 +35,3 @@ export function buildRebaseConflictSummary(args) {
         ],
     };
 }
-//# sourceMappingURL=conflict-summary.js.map

package/dist/src/commands/rebase/continue.js

@@ -104,4 +104,3 @@ export async function handleContinue(projectRoot, maxFuzz) {
     // Continue applying remaining patches
     await runPatchLoop(projectRoot, session, paths, maxFuzz);
 }
-//# sourceMappingURL=continue.js.map

package/dist/src/commands/rebase/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Orchestrates the full patch-rebase workflow:
  *   1. Reset engine to baseline
- *   2. Apply each patch with escalating fuzz
+ *   2. Apply each patch with escalating context reduction (git apply -C<n>)
  *   3. Pause on failures for manual resolution
  *   4. Re-export successfully applied patches with the new version stamp
  *