@hominis/fireforge 0.45.0 → 0.46.0

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

@@ -15,24 +15,21 @@
  * the worktree.
  */
 import { join } from 'node:path';
-import { appendHistory, assertConfirmationAvailable, confirmDestructive, } from '../../core/destructive.js';
-import { normalizePatchArtifact } from '../../core/patch-artifact-normalize.js';
-import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, collectForwardImportEdges, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
+import { assertConfirmationAvailable, confirmDestructive, } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
+import { buildPatchQueueContext, collectForwardImportEdges, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
 import { computeProjectedLintRegressions } from '../../core/patch-lint-projection.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, savePatchesManifest, validatePatchesManifest, } from '../../core/patch-manifest.js';
-import { buildNewFileTextProjection } from '../../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
 import { readText, writeText } from '../../utils/fs.js';
 import { info, outro, success, warn } from '../../utils/logger.js';
 import { resolveWaitLockSeconds } from '../../utils/options.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
 import { runPatchLint } from '../export-shared.js';
+import { projectEntryBody } from './entry-projection.js';
 import { buildSplitDiff, findOwnerRewriteHolders, mergeStagedForwardImports, rewriteSplitOwners, } from './split-plan.js';
-function projectEntryBody(diff) {
-    const newFiles = buildNewFileTextProjection(diff);
-    return { diff, newFiles, modifiedFileAdditions: buildModifiedFileAdditionsFromDiff(diff) };
-}
 /**
  * Projects the post-move queue through cross-patch lint, auto-declaring the
  * forward edges the move introduces into the target (an importer that used
@@ -121,9 +118,9 @@ async function commitMoveInto(patchesDir, plan, waitLockSeconds) {
         let sourceWritten = false;
         let targetWritten = false;
         try {
-            await writeText(sourcePath, normalizePatchArtifact(plan.sourceDiff));
+            await writeText(sourcePath, plan.sourceDiff);
             sourceWritten = true;
-            await writeText(targetPath, normalizePatchArtifact(plan.targetDiff));
+            await writeText(targetPath, plan.targetDiff);
             targetWritten = true;
             const updatedPatches = manifest.patches.map((patch) => {
                 let updated = rewriteSplitOwners(patch, plan.source.filename, movedSet, plan.target.filename);
@@ -140,21 +137,16 @@ async function commitMoveInto(patchesDir, plan, waitLockSeconds) {
             });
             const updated = validatePatchesManifest({ ...manifest, patches: updatedPatches });
             await savePatchesManifest(patchesDir, updated);
-            try {
-                await appendHistory(patchesDir, {
-                    operation: 'patch-move-files',
-                    args: {
-                        source: plan.source.filename,
-                        target: plan.target.filename,
-                        files: plan.movedFiles,
-                        ownerRewrites: plan.ownerRewrites,
-                    },
-                    result: 'ok',
-                });
-            }
-            catch (historyError) {
-                warn(`History log append failed after patch move-files committed: ${toError(historyError).message}`);
-            }
+            await appendHistoryBestEffort(patchesDir, {
+                operation: 'patch-move-files',
+                args: {
+                    source: plan.source.filename,
+                    target: plan.target.filename,
+                    files: plan.movedFiles,
+                    ownerRewrites: plan.ownerRewrites,
+                },
+                result: 'ok',
+            }, `patch move-files committed`);
         }
         catch (error) {
             if (targetWritten) {
@@ -199,8 +191,26 @@ export async function runMoveFilesInto(args) {
     // parity) resolves cross-patch imports and sibling head.js harness roots
     // instead of linting each projected body blind.
     const patchQueueCtx = await buildPatchQueueContext(patchesDir, args.config);
-    await runPatchLint(enginePath, sourceAfter, sourceDiff, args.config, options.skipLint, patchQueueCtx, source.lintIgnore ? new Set(source.lintIgnore) : undefined, source.tier);
-    await runPatchLint(enginePath, targetAfter, targetDiff, args.config, options.skipLint, patchQueueCtx, target.lintIgnore ? new Set(target.lintIgnore) : undefined, target.tier);
+    await runPatchLint({
+        engineDir: enginePath,
+        filesAffected: sourceAfter,
+        diffContent: sourceDiff,
+        config: args.config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks: source.lintIgnore ? new Set(source.lintIgnore) : undefined,
+        patchTier: source.tier,
+    });
+    await runPatchLint({
+        engineDir: enginePath,
+        filesAffected: targetAfter,
+        diffContent: targetDiff,
+        config: args.config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks: target.lintIgnore ? new Set(target.lintIgnore) : undefined,
+        patchTier: target.tier,
+    });
     const manifest = await loadPatchesManifest(patchesDir);
     const plan = {
         source,
@@ -231,14 +241,8 @@ export async function runMoveFilesInto(args) {
         unsafeOverride: options.forceUnsafe === true,
         conflicts,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    if (decision === 'declined') {
-        outro('Move cancelled');
+    if (!proceedAfterDecision(decision, 'Move cancelled'))
         return;
-    }
     await commitMoveInto(patchesDir, plan, resolveWaitLockSeconds(options.waitLock));
     success(`Moved ${files.length} file(s) from ${source.filename} to ${target.filename}`);
     if (plan.ownerRewrites.length > 0) {

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

@@ -13,13 +13,10 @@ import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-ma
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, note, warn } from '../../utils/logger.js';
-import { addWaitLockOption, commanderArgParser, pickDefined } from '../../utils/options.js';
+import { addWaitLockOption, commanderArgParser, pickDefined, stringListOption, } from '../../utils/options.js';
+import { parsePositiveIntegerFlag } from '../../utils/validation.js';
 import { patchMoveFilesCreateCommand } from './move-files-create.js';
 import { runMoveFilesInto } from './move-files-into.js';
-function collectOption(value, previous) {
-    previous.push(value);
-    return previous;
-}
 function normalizeFileList(files) {
     const cleaned = (files ?? []).map((file) => file.trim()).filter((file) => file.length > 0);
     return [...new Set(cleaned)].sort((left, right) => left.localeCompare(right));
@@ -165,15 +162,9 @@ export function registerPatchMoveFiles(parent, context) {
         .command('move-files <from> <to>')
         .description('Preview the re-export commands needed to move file ownership between patches, ' +
         'or create the target patch and move the files in one transaction with --create --order <n>.')
-        .option('--file <path>', 'File path relative to engine/ to move (repeatable)', collectOption, [])
+        .option('--file <path>', 'File path relative to engine/ to move (repeatable)', ...stringListOption())
         .option('--create', 'Create <to> as a new patch and move the files into it (requires --order)')
-        .option('--order <n>', 'Exact sparse order for the created patch (only valid with --create)', commanderArgParser((raw) => {
-        const n = Number.parseInt(raw, 10);
-        if (!Number.isInteger(n) || n <= 0) {
-            throw new InvalidArgumentError(`--order must be a positive integer, got "${raw}".`, '--order');
-        }
-        return n;
-    }))
+        .option('--order <n>', 'Exact sparse order for the created patch (only valid with --create)', commanderArgParser((raw) => parsePositiveIntegerFlag('--order', raw)))
         .option('--category <category>', "Category for the created patch (default: the source patch's)")
         .option('-d, --description <desc>', 'Description for the created patch')
         .option('--dry-run', 'Show what would happen without writing')

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

@@ -19,7 +19,8 @@ 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 { confirmDestructive } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 import { patchNameSlug } from '../../core/patch-export.js';
 import { buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
@@ -30,6 +31,8 @@ import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
 import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
+import { parsePositiveIntegerFlag } from '../../utils/validation.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 import { projectReorder } from './reorder.js';
 /**
@@ -76,7 +79,7 @@ async function commitRenameUnderLock(input) {
         if (orderChanging && input.newOrder !== undefined) {
             const orderHolder = fresh.patches.find((p) => p.order === input.newOrder && p.filename !== target.filename);
             if (orderHolder) {
-                throw new InvalidArgumentError(`Order ${String(input.newOrder)} was claimed by ${orderHolder.filename} concurrently. Pick an unused order, or use "fireforge patch reorder" to renumber siblings.`, '--order');
+                throw new InvalidArgumentError(`Order ${input.newOrder} was claimed by ${orderHolder.filename} concurrently. Pick an unused order, or use "fireforge patch reorder" to renumber siblings.`, '--order');
             }
         }
         let oldPath;
@@ -136,28 +139,23 @@ async function commitRenameUnderLock(input) {
         else {
             await savePatchesManifest(patchesDir, fresh);
         }
-        try {
-            await appendHistory(patchesDir, {
-                operation: 'patch-rename',
-                args: {
-                    oldFilename: target.filename,
-                    newFilename,
-                    oldName: target.name,
-                    newName,
-                    ...(descriptionChanging ? { oldDescription: target.description, newDescription } : {}),
-                    ...(orderChanging ? { oldOrder: target.order, newOrder: input.newOrder } : {}),
-                    ...(categoryChanging
-                        ? { oldCategory: target.category, newCategory: input.newCategory }
-                        : {}),
-                },
-                ...(input.yes === true ? { yes: true } : {}),
-                ...(input.forceUnsafe === true ? { unsafeOverride: true } : {}),
-                result: 'ok',
-            });
-        }
-        catch (historyError) {
-            warn(`History log append failed after patch rename committed (${newFilename}): ${toError(historyError).message}`);
-        }
+        await appendHistoryBestEffort(patchesDir, {
+            operation: 'patch-rename',
+            args: {
+                oldFilename: target.filename,
+                newFilename,
+                oldName: target.name,
+                newName,
+                ...(descriptionChanging ? { oldDescription: target.description, newDescription } : {}),
+                ...(orderChanging ? { oldOrder: target.order, newOrder: input.newOrder } : {}),
+                ...(categoryChanging
+                    ? { oldCategory: target.category, newCategory: input.newCategory }
+                    : {}),
+            },
+            ...(input.yes === true ? { yes: true } : {}),
+            ...(input.forceUnsafe === true ? { unsafeOverride: true } : {}),
+            result: 'ok',
+        }, `patch rename committed (${newFilename})`);
     }, { waitLockSeconds: input.waitLockSeconds, command: 'patch rename' });
 }
 /** Validates the flags and resolves the new filename/identity fields. */
@@ -215,14 +213,14 @@ async function assertRenamePreconditions(patchesDir, manifest, target, plan, opt
     if (plan.orderChanging && options.order !== undefined) {
         const holder = manifest.patches.find((p) => p.order === options.order && p.filename !== target.filename);
         if (holder) {
-            throw new InvalidArgumentError(`Order ${String(options.order)} is already used by ${holder.filename}. Pick an unused order, or use "fireforge patch reorder ${target.filename} --to ${String(options.order)}" to renumber siblings.`, '--order');
+            throw new InvalidArgumentError(`Order ${options.order} is already used by ${holder.filename}. Pick an unused order, or use "fireforge patch reorder ${target.filename} --to ${options.order}" to renumber siblings.`, '--order');
         }
         if (options.forceUnsafe !== true) {
             const baseCtx = await buildPatchQueueContext(patchesDir, config);
             const projected = projectReorder(baseCtx, new Map([[target.filename, { newFilename: plan.newFilename, newOrder: options.order }]]));
             const projectedErrors = lintPatchQueue(projected).filter((i) => i.severity === 'error');
             if (projectedErrors.length > 0) {
-                throw new InvalidArgumentError(`Refusing to run patch rename: the order change would introduce ${String(projectedErrors.length)} cross-patch lint error(s):\n  ${projectedErrors
+                throw new InvalidArgumentError(`Refusing to run patch rename: the order change would introduce ${projectedErrors.length} cross-patch lint error(s):\n  ${projectedErrors
                     .map(formatPatchLintIssue)
                     .join('\n  ')}\nPass --force-unsafe to override.`, '--force-unsafe');
             }
@@ -248,7 +246,7 @@ function buildRenameSummary(target, plan, options) {
         summary.push(`description: "${target.description || '(none)'}" → "${options.description ?? '(none)'}"`);
     }
     if (plan.orderChanging && options.order !== undefined) {
-        summary.push(`order: ${String(target.order)} → ${String(options.order)}`);
+        summary.push(`order: ${target.order} → ${options.order}`);
     }
     if (plan.categoryChanging) {
         summary.push(`category: ${target.category} → ${plan.newCategory}`);
@@ -309,14 +307,8 @@ export async function patchRenameCommand(projectRoot, identifier, options = {})
         dryRun: isDryRun,
         conflicts: null,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    if (decision === 'declined') {
-        outro('Rename cancelled');
+    if (!proceedAfterDecision(decision, 'Rename cancelled'))
         return;
-    }
     await commitRenameUnderLock({
         patchesDir: paths.patches,
         target,
@@ -356,13 +348,7 @@ export function registerPatchRename(parent, context) {
         .description('Rename a patch: filename, manifest name, category, order, and/or description update in one transaction without rewriting the .patch body.')
         .option('--to <new-name>', 'New human-readable name, category-prefixed slug, or full filename stem (normalised into the filename slug)')
         .option('--category <category>', 'New category for the patch (validated against configured categories); rewrites the filename prefix and manifest row in one transaction')
-        .option('--order <n>', 'Move the patch to this exact unused order; refuses on collision — use "patch reorder" to renumber siblings', commanderArgParser((raw) => {
-        const n = Number.parseInt(raw, 10);
-        if (!Number.isInteger(n) || n <= 0) {
-            throw new InvalidArgumentError(`--order must be a positive integer, got "${raw}".`, '--order');
-        }
-        return n;
-    }))
+        .option('--order <n>', 'Move the patch to this exact unused order; refuses on collision — use "patch reorder" to renumber siblings', commanderArgParser((raw) => parsePositiveIntegerFlag('--order', raw)))
         .option('-d, --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)')

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

@@ -10,16 +10,18 @@
  */
 import { Command, Option } from 'commander';
 import { loadConfig } from '../../core/config.js';
-import { appendHistory, confirmDestructive, } from '../../core/destructive.js';
+import { confirmDestructive, } from '../../core/destructive.js';
+import { appendHistoryBestEffort } from '../../core/history-log.js';
 import { buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
 import { loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, rewriteStagedDependencyOwners, } from '../../core/patch-manifest.js';
 import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { info, intro, outro, warn } from '../../utils/logger.js';
+import { info, intro, outro } from '../../utils/logger.js';
 import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
 import { parsePositiveIntegerFlag } from '../../utils/validation.js';
+import { proceedAfterDecision } from '../destructive-decision.js';
+import { getSortedRenameEntries, renameMapsEqual } from '../patch-rename-map.js';
 import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /** Zero-pads an ordinal number to the given width. */
 function padOrder(value, width) {
@@ -98,25 +100,6 @@ function computeRenameMap(manifestPatches, target, destinationOrder) {
     });
     return renames;
 }
-function getSortedRenameEntries(renameMap) {
-    return Array.from(renameMap.entries()).sort((a, b) => a[1].newOrder - b[1].newOrder);
-}
-function renameMapsEqual(left, right) {
-    const leftEntries = getSortedRenameEntries(left);
-    const rightEntries = getSortedRenameEntries(right);
-    if (leftEntries.length !== rightEntries.length) {
-        return false;
-    }
-    return leftEntries.every(([leftFilename, leftEntry], index) => {
-        const rightTuple = rightEntries[index];
-        if (!rightTuple)
-            return false;
-        const [rightFilename, rightEntry] = rightTuple;
-        return (leftFilename === rightFilename &&
-            leftEntry.newFilename === rightEntry.newFilename &&
-            leftEntry.newOrder === rightEntry.newOrder);
-    });
-}
 /**
  * Applies a rename map to a {@link PatchQueueContext} so cross-patch lint
  * can run against the projected state without touching disk. Exported for
@@ -159,7 +142,7 @@ function resolveDestination(target, manifestPatches, options) {
         // integers, but the function is reachable from tests that may pass
         // `{ to: NaN }` directly.
         if (!Number.isInteger(options.to) || options.to <= 0) {
-            throw new InvalidArgumentError(`--to must be a positive integer, got ${String(options.to)}.`, '--to');
+            throw new InvalidArgumentError(`--to must be a positive integer, got ${options.to}.`, '--to');
         }
         return { destinationOrder: options.to, anchorFilename: undefined };
     }
@@ -195,7 +178,14 @@ function resolveDestination(target, manifestPatches, options) {
     }
     return { destinationOrder: anchor.order + 1, anchorFilename: anchor.filename };
 }
-async function commitReorderPlan(patchesDir, target, renameMap, anchorFilename, options, config, buildHistoryEntry) {
+/**
+ * Re-validates the reorder against the freshly-loaded manifest and commits
+ * it, all under the patch directory lock.
+ *
+ * @param commitOptions - See {@link CommitReorderPlanOptions}
+ */
+async function commitReorderPlan(commitOptions) {
+    const { patchesDir, target, renameMap, anchorFilename, options, config, buildHistoryEntry } = commitOptions;
     await withPatchDirectoryLock(patchesDir, async () => {
         const currentManifest = await loadPatchesManifest(patchesDir);
         if (!currentManifest || currentManifest.patches.length === 0) {
@@ -248,12 +238,7 @@ async function commitReorderPlan(patchesDir, target, renameMap, anchorFilename,
         // permissions) is warned but not re-thrown: the mutation has already
         // succeeded and is not reversible, so surfacing it as a command
         // failure would mislead.
-        try {
-            await appendHistory(patchesDir, buildHistoryEntry(currentRenameMap));
-        }
-        catch (historyError) {
-            warn(`History log append failed after patch reorder committed: ${toError(historyError).message}`);
-        }
+        await appendHistoryBestEffort(patchesDir, buildHistoryEntry(currentRenameMap), `patch reorder committed`);
     }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch reorder' });
 }
 /**
@@ -329,14 +314,8 @@ export async function patchReorderCommand(projectRoot, identifier, options = {})
         unsafeOverride: options.forceUnsafe === true,
         conflicts,
     });
-    if (decision === 'dry-run') {
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    if (decision === 'declined') {
-        outro('Reorder cancelled');
+    if (!proceedAfterDecision(decision, 'Reorder cancelled'))
         return;
-    }
     // The history entry is built inside commitReorderPlan (still under the
     // lock) from the *final* rename map, not the pre-confirmation one, so
     // the destinationOrder and renames mirror what actually landed on disk.
@@ -359,7 +338,15 @@ export async function patchReorderCommand(projectRoot, identifier, options = {})
             result: 'ok',
         };
     };
-    await commitReorderPlan(paths.patches, target, renameMap, anchorFilename, options, config, buildHistoryEntry);
+    await commitReorderPlan({
+        patchesDir: paths.patches,
+        target,
+        renameMap,
+        anchorFilename,
+        options,
+        config,
+        buildHistoryEntry,
+    });
     info(`Reordered ${renameMap.size} patch(es).`);
     outro('Reorder complete');
 }

package/dist/src/commands/patch/split-plan.d.ts

@@ -6,10 +6,9 @@
  * budget; consumed only by the split command.
  */
 import { type ConflictReport } from '../../core/destructive.js';
-import { buildPatchQueueContext } from '../../core/patch-lint.js';
-import { buildProjectedManifest } from '../../core/patch-policy.js';
+import type { PatchQueueContext } from '../../core/patch-lint-cross.js';
 import type { PatchStagedForwardImport } from '../../types/commands/index.js';
-import type { PatchCategory, PatchMetadata } from '../../types/commands/index.js';
+import type { PatchCategory, PatchesManifest, PatchMetadata } from '../../types/commands/index.js';
 import type { FireForgeConfig } from '../../types/config.js';
 import { type PlacementPlan } from '../export-flow.js';
 /** Everything the commit step needs, computed and confirmed up front. */
@@ -68,7 +67,7 @@ export declare function mergeStagedForwardImports(patch: PatchMetadata, decls: r
  * patch are auto-declared (and the declarations returned) so the projection
  * matches the real per-patch gate the split leaves behind.
  */
-export declare function runProjectedSplitLint(plan: SplitPlan, baseCtx: Awaited<ReturnType<typeof buildPatchQueueContext>>): {
+export declare function runProjectedSplitLint(plan: SplitPlan, baseCtx: PatchQueueContext): {
     conflicts: ConflictReport | null;
     stagedDependencyAdditions: Map<string, PatchStagedForwardImport[]>;
 };
@@ -76,7 +75,7 @@ export declare function runProjectedSplitLint(plan: SplitPlan, baseCtx: Awaited<
 export declare function projectSplitManifest(manifest: {
     version: 1;
     patches: PatchMetadata[];
-}, plan: SplitPlan, newMetadata: PatchMetadata): ReturnType<typeof buildProjectedManifest>;
+}, plan: SplitPlan, newMetadata: PatchMetadata): PatchesManifest;
 /**
  * Builds the manifest row for the patch created by a split, carrying the
  * source's provenance (product, version, category) onto the new patch.

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

@@ -10,16 +10,16 @@ import { join } from 'node:path';
 import {} from '../../core/destructive.js';
 import { getDiffForFilesAgainstHead } from '../../core/git-diff.js';
 import { extractAffectedFiles } from '../../core/patch-apply.js';
-import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, collectForwardImportEdges, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
+import { collectForwardImportEdges, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
 import { computeProjectedLintRegressions } from '../../core/patch-lint-projection.js';
 import { rewriteStagedDependencyOwners } from '../../core/patch-manifest.js';
 import { applyRenameMapToManifest, buildProjectedManifest } from '../../core/patch-policy.js';
 import { buildPatchSourceMetadata } from '../../core/patch-source-metadata.js';
-import { buildNewFileTextProjection } 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';
+import { projectEntryBody } from './entry-projection.js';
 /**
  * Refuses the split unless the source patch currently owns every requested
  * file. Splitting out a file the source does not own would produce a new patch
@@ -81,10 +81,6 @@ export function rewriteSplitOwners(patch, sourceFilename, movedSet, newFilename)
         },
     };
 }
-function buildEntryProjection(diff) {
-    const newFiles = buildNewFileTextProjection(diff);
-    return { diff, newFiles, modifiedFileAdditions: buildModifiedFileAdditionsFromDiff(diff) };
-}
 /** Builds the projected post-split queue entries (renumber + shrunken source + new patch). */
 function buildProjectedSplitEntries(baseCtx, plan) {
     const movedSet = new Set(plan.movedFiles);
@@ -101,13 +97,13 @@ function buildProjectedSplitEntries(baseCtx, plan) {
             : { ...entry, metadata };
         if (entry.filename !== plan.source.filename)
             return base;
-        return { ...base, ...buildEntryProjection(plan.remainingDiff) };
+        return { ...base, ...projectEntryBody(plan.remainingDiff) };
     });
     entries.push({
         filename: plan.placement.newFilename,
         order: plan.placement.insertionOrder,
         metadata: null,
-        ...buildEntryProjection(plan.movedDiff),
+        ...projectEntryBody(plan.movedDiff),
     });
     entries.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
     return entries;

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

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