@hominis/fireforge 0.45.0 → 0.46.1

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

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * `fireforge patch rename <name>` — relabels a patch's filename, manifest
+ * `fireforge patch rename <name>`: relabels a patch's filename, manifest
  * `name`, and (optionally) `description` without rewriting the `.patch` file
  * body.
  *
  * Companion to `re-export --files <subset>`. Re-export shrinks the body and
  * `filesAffected` but leaves the patch's identity describing the pre-shrink
  * scope. The only alternative for that drift is `delete` + re-export, which
- * briefly removes the patch from the queue — any forward-import dependent
- * then refuses the re-export until the deleted patch's siblings are
- * rewritten.
+ * briefly removes the patch from the queue, and any forward-import
+ * dependent then refuses the re-export until the deleted patch's siblings
+ * are rewritten.
  *
  * The filename rename and the manifest mutation happen under the patch
  * directory lock so concurrent exports cannot allocate the new filename, and
@@ -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';
 /**
@@ -51,7 +54,7 @@ function splitPatchFilename(filename) {
  * renames the `.patch` file on disk (when applicable), writes the
  * updated manifest, and appends a history entry. Filesystem rename
  * happens before the manifest save so an interrupted run never leaves
- * the manifest pointing at a missing file; a manifest-save failure
+ * the manifest pointing at a missing file. A manifest-save failure
  * rolls the filesystem rename back.
  */
 async function commitRenameUnderLock(input) {
@@ -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;
@@ -99,7 +102,7 @@ async function commitRenameUnderLock(input) {
                 ...(descriptionChanging ? { description: newDescription ?? '' } : {}),
             };
             // Staged-dependency owners on other patches reference the old
-            // filename; remap them so forward-import declarations survive the
+            // filename. Remap them so forward-import declarations survive the
             // rename instead of dangling.
             const ownerLookup = (old) => old === target.filename ? newFilename : undefined;
             fresh.patches = fresh.patches.map((p) => rewriteStagedDependencyOwners(p, ownerLookup));
@@ -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. */
@@ -184,7 +182,7 @@ function resolveRenamePlan(target, options, config) {
     if (newSlug === '') {
         throw new InvalidArgumentError('--to must contain at least one alphanumeric character after sanitisation.', 'patch rename');
     }
-    // Preserve the ordinal's zero-padding width; a wider order simply
+    // Preserve the ordinal's zero-padding width. A wider order simply
     // prints unpadded-longer.
     const newOrdinalStr = options.order !== undefined
         ? String(options.order).padStart(split.ordinalStr.length, '0')
@@ -205,7 +203,7 @@ function resolveRenamePlan(target, options, config) {
 }
 /**
  * Pre-flight refusals: order collision (with a pointer to the verb that
- * renumbers siblings — `--order` means "this exact unused sparse slot",
+ * renumbers siblings, and `--order` means "this exact unused sparse slot",
  * mirroring `export --order`), projected cross-patch lint on an order
  * change (forward imports resolve by queue position), and the
  * filename collision. The authoritative collision checks run again inside
@@ -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) {
@@ -39,10 +41,10 @@ export function rebuildFilenameForOrder(existing, newOrder) {
  * blocks the destination slot is renumbered, so intentional gaps left by
  * prior `patch delete` calls survive the reorder.
  *
- * Algorithm: remove target from the sorted list, then cascade: if any
- * patch sits at the destination order, bump it to order+1; if that
- * collides with the next patch, bump that one too; continue until a free
- * slot is reached. The direction is symmetric — moving a patch earlier
+ * Algorithm: remove target from the sorted list, then cascade. If any
+ * patch sits at the destination order, bump it to order+1. If that
+ * collides with the next patch, bump that one too. Continue until a free
+ * slot is reached. The direction is symmetric: moving a patch earlier
  * and moving it later both reduce to "find a free slot at destination by
  * shifting the contiguous conflicting run upward".
  */
@@ -60,7 +62,7 @@ function computeRenameMap(manifestPatches, target, destinationOrder) {
     if (clampedDest === target.order)
         return renames;
     // Build a mutable order-for-each map so cascading bumps compose. Keys are
-    // filenames; values start as current order and get rewritten as bumps
+    // filenames. Values start as current order and get rewritten as bumps
     // propagate. Only patches whose value changes end up in the rename map.
     const currentOrder = new Map();
     for (const patch of withoutTarget)
@@ -68,7 +70,7 @@ function computeRenameMap(manifestPatches, target, destinationOrder) {
     // Cascade from the destination: while any surviving patch occupies the
     // slot we want, bump it to slot+1 and advance. Patches are processed in
     // ascending order so each bump's collision (if any) is with the immediate
-    // successor in the sort — no back-tracking needed.
+    // successor in the sort, so no back-tracking is needed.
     let slot = clampedDest;
     for (const patch of withoutTarget) {
         const order = currentOrder.get(patch.filename);
@@ -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
@@ -126,7 +109,7 @@ export function projectReorder(base, renameMap) {
     const ownerLookup = (oldFilename) => renameMap.get(oldFilename)?.newFilename;
     const projectedEntries = base.entries.map((entry) => {
         // Project staged-dependency owner references through the rename map on
-        // every entry — owners point at *other* patches' filenames, so a
+        // every entry. Owners point at other patches' filenames, so a
         // projection that skips non-renamed entries would lint against stale
         // owners and report false forward-import regressions.
         const metadata = entry.metadata
@@ -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 };
     }
@@ -169,7 +152,7 @@ function resolveDestination(target, manifestPatches, options) {
             throw new InvalidArgumentError(`--before anchor "${options.before}" not found.`, '--before');
         }
         // Reject self-reference. `--before <target>` resolves to the target's
-        // current order, so computeRenameMap would take its no-op branch — but
+        // current order, so computeRenameMap would take its no-op branch, but
         // that masks a user-facing typo or scripted mistake instead of
         // surfacing it. The symmetric `--after` case is worse (mutates the
         // queue), so both reject for consistency.
@@ -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' });
 }
 /**
@@ -290,7 +275,7 @@ export async function patchReorderCommand(projectRoot, identifier, options = {})
         return;
     }
     // Project the reorder through cross-patch lint. Forward-import violations
-    // that are introduced *by* the reorder become hard refusals.
+    // that the reorder itself introduces become hard refusals.
     const baseCtx = await buildPatchQueueContext(paths.patches);
     const projected = projectReorder(baseCtx, renameMap);
     const projectedIssues = lintPatchQueue(projected);
@@ -329,16 +314,10 @@ 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
+    // lock) from the final rename map rather than the pre-confirmation one, so
     // the destinationOrder and renames mirror what actually landed on disk.
     const buildHistoryEntry = (finalRenameMap) => {
         const finalEntries = getSortedRenameEntries(finalRenameMap);
@@ -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

@@ -3,13 +3,12 @@
  * construction from the worktree, staged-dependency owner-rewrite
  * discovery, cross-patch lint projection, and policy-manifest projection.
  * Split out of `split.ts` to keep both files within the per-file line
- * budget; consumed only by the split command.
+ * budget. It is 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. */
@@ -34,7 +33,7 @@ export interface SplitPlan {
     /**
      * Staged forward-import declarations the split introduces, keyed by the
      * importing patch's post-rename filename. These are the new forward edges
-     * from existing patches into the freshly-created patch (owner known); they
+     * from existing patches into the freshly-created patch (owner known). They
      * are injected into the projected lint so dry-run matches the real gate,
      * and persisted on commit so the real per-patch gate stays clean.
      */
@@ -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,14 +75,14 @@ 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.
  */
 export declare function buildNewPatchMetadata(plan: SplitPlan, config: FireForgeConfig): PatchMetadata;
 /**
- * Renders the operator-facing summary lines for a planned split — the text
+ * Renders the operator-facing summary lines for a planned split: the text
  * shown by `--dry-run` and by the destructive-operation confirmation prompt.
  */
 export declare function buildSplitSummary(plan: SplitPlan): string[];

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

@@ -4,22 +4,22 @@
  * construction from the worktree, staged-dependency owner-rewrite
  * discovery, cross-patch lint projection, and policy-manifest projection.
  * Split out of `split.ts` to keep both files within the per-file line
- * budget; consumed only by the split command.
+ * budget. It is consumed only by the split command.
  */
 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;
@@ -115,11 +111,12 @@ function buildProjectedSplitEntries(baseCtx, plan) {
 /**
  * Computes the staged forward-import declarations the split introduces:
  * forward edges from existing patches into the freshly-created patch (its
- * `creates` files are the moved files; the owner is the new patch, so it is
- * known). Keyed by the importing patch's projected (post-rename) filename.
+ * `creates` files are the moved files, and the owner is the new patch, so
+ * it is known). Keyed by the importing patch's projected (post-rename)
+ * filename.
  *
  * These edges did not exist before the split (importer and imported file
- * lived in the same patch), so they have no declaration yet — without this
+ * lived in the same patch), so they have no declaration yet. Without this
  * the projected lint flags them while the real per-patch gate would resolve
  * them once declared. Auto-declaring keeps the two in lock-step and lets a
  * sound split read as sound.
@@ -237,7 +234,7 @@ export function buildNewPatchMetadata(plan, config) {
     };
 }
 /**
- * Renders the operator-facing summary lines for a planned split — the text
+ * Renders the operator-facing summary lines for a planned split: the text
  * shown by `--dry-run` and by the destructive-operation confirmation prompt.
  */
 export function buildSplitSummary(plan) {

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

@@ -1,11 +1,11 @@
 /**
- * `fireforge patch split <source> --files <p...> --name <n>` — moves files
+ * `fireforge patch split <source> --files <p...> --name <n>` moves files
  * out of an existing patch into a brand-new patch as one transaction.
  *
  * Splitting a patch whose files have inbound forward-imports otherwise
  * requires a precise manual order: re-point each staged-dependency owner at
  * a not-yet-created patch, shrink the source via
- * `re-export --files --allow-shrink`, then `export --order` — any other
+ * `re-export --files --allow-shrink`, then `export --order`. Any other
  * order refuses or needs `--force-unsafe`. Split performs the shrink, the
  * new-patch creation, and the dependent owner rewrites under one
  * patch-directory lock with rollback, validating only the final projection.