@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch retire <name>`: removes a patch from the queue and keeps
- * its order number spent as a retired slot in `patches.json#retired`.
- *
- * The case it exists for: a rename leaves a patch owning only files that no
- * longer exist. `patch delete` opens a numeric gap that
- * `patchPolicy.allowGaps: false` refuses, and `patch compact` renumbers
- * every later patch, including ones a peer session has in flight. Retiring
- * removes the patch file and row like a delete, and records the order as a
- * placeholder the gap check counts as occupied. Nothing else reads the
- * placeholder (see `core/patch-retired.ts`), and a later
- * `export --order <n>` that takes the number fills it.
- *
- * Shares the delete's dependency refusal, dry-run, confirmation and history
- * contract, so the two differ only in what happens to the order number.
- */
-import { Command } from 'commander';
-import { loadConfig } from '../../core/config.js';
-import { confirmDestructive } from '../../core/destructive.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { buildPatchQueueContext } from '../../core/patch-lint.js';
-import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { removePatchFileAndManifest } from '../../core/patch-manifest.js';
-import { formatPatchOrder } from '../../core/patch-parse.js';
-import { GeneralError } from '../../errors/base.js';
-import { info, intro, outro } from '../../utils/logger.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
-import { proceedAfterDecision } from '../destructive-decision.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-import { deleteCreatedFiles, planClaimedFiles, withCreatedFileLock, } from './removal-created-files.js';
-import { collectRemovalDependents, queueSnapshot, removalConflict, warnDanglingStagedOwners, } from './removal-dependents.js';
-/**
- * Runs the `patch retire` command.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest name to retire
- * @param options - Command options
- */
-export async function patchRetireCommand(projectRoot, identifier, options = {}) {
-    intro(options.dryRun ? 'FireForge patch retire (dry run)' : 'FireForge patch retire');
-    const { paths, manifest } = await requirePatchQueue(projectRoot, {
-        missingDirMessage: 'Patches directory not found. No patches to retire.',
-    });
-    const target = requirePatchTarget(identifier, manifest.patches);
-    const baseCtx = await buildPatchQueueContext(paths.patches);
-    const dependents = collectRemovalDependents(baseCtx, target, {
-        noun: 'retirement',
-        verb: 'retire',
-    });
-    warnDanglingStagedOwners(baseCtx, target, 'retire');
-    const order = formatPatchOrder(target.order);
-    const claimed = await planClaimedFiles(baseCtx, target, paths.engine, options.deleteCreated === true);
-    const summary = [
-        `retire ${target.filename}  (category: ${target.category}, order: ${order})`,
-        `description: ${target.description || '(none)'}`,
-        `order ${order} stays spent as a retired slot in patches.json; ` +
-            `"fireforge export --order ${order}" can fill it later`,
-        ...claimed.summary,
-    ];
-    const decision = await confirmDestructive({
-        operation: 'patch-retire',
-        title: `Retire ${target.filename}`,
-        summary,
-        yes: options.yes === true,
-        dryRun: options.dryRun === true,
-        unsafeOverride: options.forceUnsafe === true,
-        conflicts: removalConflict(dependents, target),
-    });
-    if (!proceedAfterDecision(decision, 'Retire cancelled'))
-        return;
-    const slot = {
-        order: target.order,
-        category: target.category,
-        filename: target.filename,
-        retiredAt: new Date().toISOString(),
-        ...(options.reason !== undefined ? { reason: options.reason } : {}),
-    };
-    // Same locking and history contract as `patch delete`: the dependency
-    // scan approved before the prompt is re-checked under the lock, and the
-    // history record is appended inside it.
-    const waitLockSeconds = resolveWaitLockSeconds(options.waitLock);
-    await withCreatedFileLock(projectRoot, 'patch retire', claimed, waitLockSeconds, () => withPatchDirectoryLock(paths.patches, async () => {
-        const current = await buildPatchQueueContext(paths.patches);
-        if (queueSnapshot(current) !== queueSnapshot(baseCtx)) {
-            throw new GeneralError('Patch queue changed while waiting for confirmation or the lock. Re-run patch retire to review the current dependencies.');
-        }
-        await removePatchFileAndManifest(paths.patches, target.filename, slot);
-        await deleteCreatedFiles(paths.engine, claimed.deleteOnCommit);
-        await appendHistoryBestEffort(paths.patches, {
-            operation: 'patch-retire',
-            args: {
-                filename: target.filename,
-                order: target.order,
-                filesAffected: target.filesAffected,
-                ...(claimed.deleteOnCommit.length > 0
-                    ? { deletedCreatedFiles: claimed.deleteOnCommit }
-                    : {}),
-                ...(options.reason !== undefined ? { reason: options.reason } : {}),
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-            result: 'ok',
-        }, `patch retire committed (${target.filename})`);
-    }, { waitLockSeconds, command: 'patch retire' }));
-    info(`Retired ${target.filename}; order ${order} is kept as a retired slot.`);
-    if ((await loadConfig(projectRoot)).patchPolicy?.allowGaps !== false) {
-        info('patchPolicy.allowGaps is not false, so no check reads the retired slot; ' +
-            '"patch delete" would have had the same effect on this queue.');
-    }
-    outro('Retire complete');
-}
-/**
- * Registers the `patch retire` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchRetire(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('retire <name>')
-        .description('Remove a patch from the queue but keep its order number as a retired slot, ' +
-        'so patchPolicy.allowGaps: false sees no gap and no later patch is renumbered (destructive)')
-        .option('--reason <text>', 'Rationale recorded on the retired slot')
-        .option('--dry-run', 'Show what would happen without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--delete-created', 'Also delete the engine files this patch creates that are still on disk, instead of leaving them unmanaged')
-        .option('--force-unsafe', 'Bypass the refusal when a later patch depends on this patch (last resort)');
-    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
-        await patchRetireCommand(getProjectRoot(), name, pickDefined(options));
-    }));
-}

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

@@ -1,125 +0,0 @@
-/**
- * Planning helpers for `fireforge patch split`: ownership guards, diff
- * 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. It is consumed only by the split command.
- */
-import { type ConflictReport } from '../../core/destructive.js';
-import type { PatchQueueContext } from '../../core/patch-lint-cross.js';
-import type { PatchLintIssue, PatchStagedForwardImport } from '../../types/commands/index.js';
-import type { PatchCategory, PatchesManifest, PatchMetadata } from '../../types/commands/index.js';
-import type { FireForgeConfig } from '../../types/config.js';
-import type { DeclarationRenamer } from '../declarations-report.js';
-import { type PlacementPlan } from '../export-flow.js';
-import { type SplitStagedMaintenance } from './split-staged.js';
-/** Everything the commit step needs, computed and confirmed up front. */
-export interface SplitPlan {
-    source: PatchMetadata;
-    movedFiles: string[];
-    remainingFiles: string[];
-    movedDiff: string;
-    remainingDiff: string;
-    placement: PlacementPlan;
-    /** Effective placement flags (with the after-source default applied). */
-    placementOptions: {
-        order?: number;
-        before?: string;
-        after?: string;
-    };
-    category: PatchCategory;
-    name: string;
-    description: string;
-    /** Patches (by current filename) whose staged-dependency owners re-point to the new patch. */
-    ownerRewrites: string[];
-    /**
-     * 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
-     * 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.
-     */
-    stagedDependencyAdditions: Map<string, PatchStagedForwardImport[]>;
-    /**
-     * Declarations the move re-homes on the new patch or drops as made
-     * unused. Populated by {@link runProjectedSplitLint}.
-     */
-    stagedMaintenance: SplitStagedMaintenance;
-    /**
-     * The command running the plan, named in the `reason` of every
-     * declaration it writes. Absent: `patch split`.
-     */
-    operation?: MoveOperation;
-    /**
-     * New engine files no patch owned that `move-files --scan-file` adopts
-     * into the new patch in the same transaction. Already part of
-     * `movedFiles`; listed apart only for the summary and the commit's
-     * still-unowned check.
-     */
-    adoptedFiles?: string[];
-}
-/** The commands that move files between patches and declare the edges they open. */
-export type MoveOperation = 'patch split' | 'patch move-files';
-/**
- * The `reason` a move records on a forward declaration it writes, so the
- * declaration explains itself in `patches.json` and `staged-dependency
- * --add --from` accepts it without a hand-written `--reason`.
- *
- * @param source - Patch the files left
- * @param destination - Patch the files moved into
- * @param operation - The command that moved them
- */
-export declare function moveDeclarationReason(source: string, destination: string, operation: MoveOperation): string;
-/** The {@link moveDeclarationReason} of a split plan. */
-export declare function splitDeclarationReason(plan: SplitPlan): string;
-/**
- * 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
- * whose diff cannot apply.
- */
-export declare function assertSourceOwnsFiles(source: PatchMetadata, files: readonly string[]): void;
-/**
- * Generates the diff for one side of a split by re-deriving it from the engine
- * working tree, scoped to `files`. Re-derived rather than sliced out of the
- * source patch so hunk context is correct for the new file set.
- */
-export declare function buildSplitDiff(engineDir: string, files: readonly string[], label: string, sourceFilename: string): Promise<string>;
-/** Merges `decls` into a patch's `stagedDependencies.forwardImports` (no duplicates). */
-export declare function mergeStagedForwardImports(patch: PatchMetadata, decls: readonly PatchStagedForwardImport[]): PatchMetadata;
-/**
- * Projects the full split (renumber + shrunken source + synthetic new
- * patch + owner rewrites) through cross-patch lint, reporting only the
- * regressions the split itself would introduce. Forward edges into the new
- * 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: PatchQueueContext): {
-    conflicts: ConflictReport | null;
-    regressions: PatchLintIssue[];
-    stagedDependencyAdditions: Map<string, PatchStagedForwardImport[]>;
-    stagedMaintenance: SplitStagedMaintenance;
-};
-/** Builds the projected manifest for policy enforcement. */
-export declare function projectSplitManifest(manifest: {
-    version: 1;
-    patches: PatchMetadata[];
-}, 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
- * shown by `--dry-run` and by the destructive-operation confirmation prompt.
- */
-export declare function buildSplitSummary(plan: SplitPlan): string[];
-/**
- * Maps a declaration the split projection proposes back onto the queue as
- * it stands: renumbered patches take their current names. An owner that is
- * the patch the split would create keeps the planned filename, so the
- * report declares the owner the rerun creates (`staged-dependency --add`
- * accepts an owner the queue does not hold yet, and the move then lands
- * with the declaration already right).
- */
-export declare function splitDeclarationRenamer(plan: SplitPlan): DeclarationRenamer;

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

@@ -1,313 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Planning helpers for `fireforge patch split`: ownership guards, diff
- * 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. 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 { 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 { 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';
-import { describeStagedMaintenance, findDeclarationsMadeUnused, keptRelocatedDeclarations, relocatedSourceDeclarations, rewriteSplitOwners, withoutRelocatedDeclarations, } from './split-staged.js';
-/**
- * The `reason` a move records on a forward declaration it writes, so the
- * declaration explains itself in `patches.json` and `staged-dependency
- * --add --from` accepts it without a hand-written `--reason`.
- *
- * @param source - Patch the files left
- * @param destination - Patch the files moved into
- * @param operation - The command that moved them
- */
-export function moveDeclarationReason(source, destination, operation) {
-    return `${source} → ${destination} by ${operation}`;
-}
-/** The {@link moveDeclarationReason} of a split plan. */
-export function splitDeclarationReason(plan) {
-    return moveDeclarationReason(plan.source.filename, plan.placement.newFilename, plan.operation ?? 'patch split');
-}
-/**
- * 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
- * whose diff cannot apply.
- */
-export function assertSourceOwnsFiles(source, files) {
-    const owned = new Set(source.filesAffected);
-    const missing = files.filter((file) => !owned.has(file));
-    if (missing.length > 0) {
-        throw new InvalidArgumentError(`${source.filename} does not currently own ${missing.length} requested file(s): ${missing.join(', ')}. ` +
-            'Run "fireforge status --ownership" to inspect current ownership.', '--files');
-    }
-}
-/**
- * Generates the diff for one side of a split by re-deriving it from the engine
- * working tree, scoped to `files`. Re-derived rather than sliced out of the
- * source patch so hunk context is correct for the new file set.
- */
-export async function buildSplitDiff(engineDir, files, label, sourceFilename) {
-    for (const file of files) {
-        if (!(await pathExists(join(engineDir, file)))) {
-            throw new GeneralError(`Cannot split ${sourceFilename}: ${label} file is missing from the engine worktree: ${file}. ` +
-                'Run "fireforge import" (or restore the file) so the worktree reflects the patch content first.');
-        }
-    }
-    const diff = await getDiffForFilesAgainstHead(engineDir, [...files]);
-    if (!diff.trim()) {
-        throw new GeneralError(`Cannot split ${sourceFilename}: the ${label} file set produces an empty diff against HEAD. ` +
-            'The worktree must currently carry the patch content (run "fireforge import" first).');
-    }
-    const actual = new Set(extractAffectedFiles(diff));
-    const noHunks = files.filter((file) => !actual.has(file));
-    if (noHunks.length > 0) {
-        throw new GeneralError(`Cannot split ${sourceFilename}: ${noHunks.length} ${label} file(s) produced no diff hunks ` +
-            `(${noHunks.join(', ')}). The worktree does not carry their patch content.`);
-    }
-    return diff;
-}
-/** Builds the projected post-split queue entries (renumber + shrunken source + new patch). */
-function buildProjectedSplitEntries(baseCtx, plan) {
-    const movedSet = new Set(plan.movedFiles);
-    const ownerLookup = (old) => plan.placement.renameMap.get(old)?.newFilename;
-    const entries = baseCtx.entries.map((entry) => {
-        let metadata = entry.metadata;
-        if (metadata) {
-            metadata = rewriteStagedDependencyOwners(metadata, ownerLookup);
-            metadata = rewriteSplitOwners(metadata, plan.source.filename, movedSet, plan.placement.newFilename);
-            if (entry.filename === plan.source.filename) {
-                metadata = withoutRelocatedDeclarations(metadata, movedSet);
-            }
-        }
-        const rename = plan.placement.renameMap.get(entry.filename);
-        const base = rename
-            ? { ...entry, metadata, filename: rename.newFilename, order: rename.newOrder }
-            : { ...entry, metadata };
-        if (entry.filename !== plan.source.filename)
-            return base;
-        return { ...base, ...projectEntryBody(plan.remainingDiff) };
-    });
-    // Declarations whose declaring file moved travel with it, so the new
-    // patch's projected entry carries them (and only then needs metadata).
-    const relocated = relocatedSourceDeclarations(plan.source, movedSet, ownerLookup);
-    const hasRelocated = (relocated.forwardImports?.length ?? 0) + (relocated.registrations?.length ?? 0) > 0;
-    entries.push({
-        filename: plan.placement.newFilename,
-        order: plan.placement.insertionOrder,
-        metadata: hasRelocated
-            ? {
-                filename: plan.placement.newFilename,
-                order: plan.placement.insertionOrder,
-                category: plan.category,
-                name: plan.name,
-                description: plan.description,
-                createdAt: '',
-                sourceEsrVersion: plan.source.sourceEsrVersion,
-                filesAffected: plan.movedFiles,
-                stagedDependencies: relocated,
-            }
-            : null,
-        ...projectEntryBody(plan.movedDiff),
-    });
-    entries.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    return entries;
-}
-/**
- * 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, 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
- * 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.
- */
-function computeSplitStagedDependencyAdditions(projectedEntries, newFilename, reason) {
-    const additions = new Map();
-    for (const edge of collectForwardImportEdges({ entries: projectedEntries })) {
-        if (edge.owner !== newFilename)
-            continue;
-        const decl = {
-            file: edge.sitePath,
-            specifier: edge.specifier,
-            creates: edge.creates,
-            owner: newFilename,
-            reason,
-        };
-        const list = additions.get(edge.entry) ?? [];
-        const dup = list.some((d) => d.file === decl.file &&
-            d.specifier === decl.specifier &&
-            d.creates === decl.creates &&
-            d.owner === decl.owner);
-        if (!dup)
-            list.push(decl);
-        additions.set(edge.entry, list);
-    }
-    return additions;
-}
-/** Merges `decls` into a patch's `stagedDependencies.forwardImports` (no duplicates). */
-export function mergeStagedForwardImports(patch, decls) {
-    if (decls.length === 0)
-        return patch;
-    const existing = patch.stagedDependencies?.forwardImports ?? [];
-    const merged = [...existing];
-    for (const decl of decls) {
-        const dup = merged.some((d) => d.file === decl.file &&
-            d.specifier === decl.specifier &&
-            d.creates === decl.creates &&
-            (d.owner ?? '') === (decl.owner ?? ''));
-        if (!dup)
-            merged.push(decl);
-    }
-    return {
-        ...patch,
-        stagedDependencies: { ...patch.stagedDependencies, forwardImports: merged },
-    };
-}
-/** Injects the computed staged-dependency additions into projected entries' metadata. */
-function injectStagedDependencyAdditions(entries, additions) {
-    for (const entry of entries) {
-        const decls = additions.get(entry.filename);
-        if (!decls?.length || !entry.metadata)
-            continue;
-        entry.metadata = mergeStagedForwardImports(entry.metadata, decls);
-    }
-}
-/**
- * Projects the full split (renumber + shrunken source + synthetic new
- * patch + owner rewrites) through cross-patch lint, reporting only the
- * regressions the split itself would introduce. Forward edges into the new
- * patch are auto-declared (and the declarations returned) so the projection
- * matches the real per-patch gate the split leaves behind.
- */
-export function runProjectedSplitLint(plan, baseCtx) {
-    const projectedEntries = buildProjectedSplitEntries(baseCtx, plan);
-    // Discover and auto-declare the forward edges this split introduces into
-    // the new patch, then inject them before linting so they resolve.
-    const stagedDependencyAdditions = computeSplitStagedDependencyAdditions(projectedEntries, plan.placement.newFilename, splitDeclarationReason(plan));
-    injectStagedDependencyAdditions(projectedEntries, stagedDependencyAdditions);
-    const baselineAll = lintPatchQueue(baseCtx);
-    // Keep every queue-wide lint setting of the baseline (patch policy,
-    // forward-registration scope, token scales), so
-    // computeProjectedLintRegressions compares symmetric rule sets and a
-    // test-manifest suite entry is projected as the committed gate sees it.
-    const projectedAll = lintPatchQueue({ ...baseCtx, entries: projectedEntries });
-    const baselineIssues = baselineAll.filter((i) => i.severity === 'error');
-    const projectedIssues = projectedAll.filter((i) => i.severity === 'error');
-    const oldNameByNew = new Map([...plan.placement.renameMap].map(([oldName, entry]) => [entry.newFilename, oldName]));
-    const stagedMaintenance = {
-        relocated: relocatedSourceDeclarations(plan.source, new Set(plan.movedFiles), (old) => plan.placement.renameMap.get(old)?.newFilename),
-        dropped: findDeclarationsMadeUnused({
-            baselineEntries: baseCtx.entries,
-            projectedEntries,
-            baselineIssues: baselineAll,
-            projectedIssues: projectedAll,
-            sourceFilename: plan.source.filename,
-            newFilename: plan.placement.newFilename,
-            mapBack: (name) => oldNameByNew.get(name) ?? name,
-            movedSet: new Set(plan.movedFiles),
-        }),
-    };
-    const regressions = computeProjectedLintRegressions(baselineIssues, projectedIssues);
-    if (baselineIssues.length > 0 && regressions.length === 0) {
-        warn(`Note: projected queue still has ${baselineIssues.length} pre-existing cross-patch ` +
-            'error(s) unrelated to this split. Run "fireforge verify" to list them.');
-    }
-    const conflicts = regressions.length === 0
-        ? null
-        : {
-            reason: `split would introduce ${regressions.length} cross-patch lint error(s)`,
-            details: regressions.map(formatPatchLintIssue),
-        };
-    return { conflicts, regressions, stagedDependencyAdditions, stagedMaintenance };
-}
-/** Builds the projected manifest for policy enforcement. */
-export function projectSplitManifest(manifest, plan, newMetadata) {
-    const movedSet = new Set(plan.movedFiles);
-    const renamed = applyRenameMapToManifest(manifest, plan.placement.renameMap);
-    const effectiveSourceFilename = plan.placement.renameMap.get(plan.source.filename)?.newFilename ?? plan.source.filename;
-    const patched = renamed.patches.map((patch) => {
-        const withOwners = rewriteSplitOwners(patch, effectiveSourceFilename, movedSet, plan.placement.newFilename);
-        if (patch.filename !== effectiveSourceFilename)
-            return withOwners;
-        return { ...withOwners, filesAffected: plan.remainingFiles };
-    });
-    return buildProjectedManifest(renamed, [...patched, newMetadata]);
-}
-/**
- * Builds the manifest row for the patch created by a split, carrying the
- * source's provenance (product, version, category) onto the new patch.
- */
-export function buildNewPatchMetadata(plan, config) {
-    const staged = keptRelocatedDeclarations(plan.stagedMaintenance, plan.placement.newFilename);
-    const hasStaged = (staged.forwardImports?.length ?? 0) + (staged.registrations?.length ?? 0) > 0;
-    return {
-        filename: plan.placement.newFilename,
-        order: plan.placement.insertionOrder,
-        category: plan.category,
-        name: plan.name,
-        description: plan.description,
-        createdAt: new Date().toISOString(),
-        ...buildPatchSourceMetadata(config.firefox),
-        filesAffected: plan.movedFiles,
-        ...(hasStaged ? { stagedDependencies: staged } : {}),
-    };
-}
-/**
- * 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) {
-    const summary = [
-        `split ${plan.source.filename}`,
-        `moved files (${plan.movedFiles.length}): ${plan.movedFiles.join(', ')}`,
-        ...(plan.adoptedFiles?.length
-            ? [
-                `of which adopted from the worktree (no patch owned them) (${plan.adoptedFiles.length}): ` +
-                    plan.adoptedFiles.join(', '),
-            ]
-            : []),
-        `source keeps (${plan.remainingFiles.length}): ${plan.remainingFiles.join(', ')}`,
-        `new patch: ${plan.placement.newFilename} (order ${plan.placement.insertionOrder})`,
-    ];
-    if (plan.placement.renameMap.size > 0) {
-        summary.push(`${plan.placement.renameMap.size} existing patch(es) renumbered to make room:`);
-        for (const [oldName, entry] of [...plan.placement.renameMap.entries()].sort((a, b) => a[1].newOrder - b[1].newOrder)) {
-            summary.push(`  ${oldName}  →  ${entry.newFilename}`);
-        }
-    }
-    if (plan.ownerRewrites.length > 0) {
-        summary.push(`staged-dependency owners re-pointed to the new patch in: ${plan.ownerRewrites.join(', ')}`);
-    }
-    summary.push(...describeStagedMaintenance(plan.stagedMaintenance, plan.source.filename, plan.placement.newFilename));
-    return summary;
-}
-/**
- * Maps a declaration the split projection proposes back onto the queue as
- * it stands: renumbered patches take their current names. An owner that is
- * the patch the split would create keeps the planned filename, so the
- * report declares the owner the rerun creates (`staged-dependency --add`
- * accepts an owner the queue does not hold yet, and the move then lands
- * with the declaration already right).
- */
-export function splitDeclarationRenamer(plan) {
-    const oldNameByNew = new Map([...plan.placement.renameMap].map(([oldName, entry]) => [entry.newFilename, oldName]));
-    const current = (name) => oldNameByNew.get(name) ?? name;
-    return ({ owner, ...declaration }) => ({
-        ...declaration,
-        patch: current(declaration.patch),
-        owner: owner === plan.placement.newFilename ? owner : current(owner),
-    });
-}