@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,375 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch reorder <name> --to <N> | --before <name> | --after <name>`
- *
- * Renames the target .patch file and rewrites manifest rows so the target
- * moves to the requested ordinal slot. Any subsequent patches are
- * renumbered to make room. Pre-flights the projected order through
- * `lintPatchQueue` so reorders that would introduce a forward-import fail
- * before any bytes move.
- *
- * `fireforge patch reorder --shift <n> --from <order> [--through <order>]`
- * renumbers a whole run instead (see reorder-shift.ts). Every mode takes
- * `--map-out <file>` for the committed old-to-new filename map.
- */
-import { Command, Option } from 'commander';
-import { loadConfig } from '../../core/config.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, } from '../../core/patch-manifest.js';
-import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.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, writeRenameMapFile, } from '../patch-rename-map.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-import { projectReorder, rebuildFilenameForOrder } from './reorder-projection.js';
-import { patchReorderShiftCommand } from './reorder-shift.js';
-/**
- * Computes a rename map that moves `target` to `destinationOrder` with a
- * minimal shift: only the contiguous run of patches whose current order
- * 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
- * and moving it later both reduce to "find a free slot at destination by
- * shifting the contiguous conflicting run upward".
- */
-function computeRenameMap(manifestPatches, target, destinationOrder) {
-    const renames = new Map();
-    if (destinationOrder === target.order)
-        return renames;
-    const sorted = [...manifestPatches].sort((a, b) => a.order - b.order);
-    const withoutTarget = sorted.filter((p) => p.filename !== target.filename);
-    // Clamp destination into the meaningful range. `--to 0` snaps to
-    // minOrder, `--to 99` to maxOrder+1 (append past the tail).
-    const minOrder = Math.min(...sorted.map((p) => p.order));
-    const maxOrderAfterRemoval = withoutTarget.length > 0 ? Math.max(...withoutTarget.map((p) => p.order)) : minOrder;
-    const clampedDest = Math.max(minOrder, Math.min(destinationOrder, maxOrderAfterRemoval + 1));
-    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
-    // propagate. Only patches whose value changes end up in the rename map.
-    const currentOrder = new Map();
-    for (const patch of withoutTarget)
-        currentOrder.set(patch.filename, patch.order);
-    // 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, so no back-tracking is needed.
-    let slot = clampedDest;
-    for (const patch of withoutTarget) {
-        const order = currentOrder.get(patch.filename);
-        if (order === undefined)
-            continue;
-        if (order < slot)
-            continue;
-        if (order > slot)
-            break;
-        // Collision at `slot`: bump this patch to slot+1 and continue scanning,
-        // because slot+1 may also be occupied by the next patch in sequence.
-        currentOrder.set(patch.filename, slot + 1);
-        slot = slot + 1;
-    }
-    for (const patch of withoutTarget) {
-        const newOrder = currentOrder.get(patch.filename);
-        if (newOrder === undefined || newOrder === patch.order)
-            continue;
-        renames.set(patch.filename, {
-            newOrder,
-            newFilename: rebuildFilenameForOrder(patch, newOrder),
-        });
-    }
-    renames.set(target.filename, {
-        newOrder: clampedDest,
-        newFilename: rebuildFilenameForOrder(target, clampedDest),
-    });
-    return renames;
-}
-/**
- * Resolves `--to <N>`, `--before <anchor>`, and `--after <anchor>` into a
- * concrete destination order and, for the anchor variants, the anchor
- * filename the reorder should position against. Extracted from
- * {@link patchReorderCommand} so the command body stays inside the
- * project's per-function line budget.
- */
-function resolveDestination(target, manifestPatches, options) {
-    if (options.to !== undefined) {
-        // Defense-in-depth: the argParser should have rejected non-positive
-        // 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 ${options.to}.`, '--to');
-        }
-        return { destinationOrder: options.to, anchorFilename: undefined };
-    }
-    if (options.before !== undefined) {
-        const anchor = resolvePatchIdentifier(options.before, manifestPatches);
-        if (!anchor) {
-            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
-        // 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.
-        if (anchor.filename === target.filename) {
-            throw new InvalidArgumentError(`Cannot reorder patch "${target.filename}" relative to itself.`, '--before');
-        }
-        return { destinationOrder: anchor.order, anchorFilename: anchor.filename };
-    }
-    const afterId = options.after;
-    if (afterId === undefined) {
-        throw new InvalidArgumentError('Reached --after resolver with no value set.', '--after');
-    }
-    const anchor = resolvePatchIdentifier(afterId, manifestPatches);
-    if (!anchor) {
-        throw new InvalidArgumentError(`--after anchor "${afterId}" not found.`, '--after');
-    }
-    // See the --before branch above: self-reference is a logical
-    // contradiction. In the --after case, the previous `anchor.order + 1`
-    // bypassed computeRenameMap's no-op short-circuit and silently
-    // renumbered the target and every patch after it.
-    if (anchor.filename === target.filename) {
-        throw new InvalidArgumentError(`Cannot reorder patch "${target.filename}" relative to itself.`, '--after');
-    }
-    return { destinationOrder: anchor.order + 1, anchorFilename: anchor.filename };
-}
-/**
- * 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;
-    return withPatchDirectoryLock(patchesDir, async () => {
-        const currentManifest = await loadPatchesManifest(patchesDir);
-        if (!currentManifest || currentManifest.patches.length === 0) {
-            throw new GeneralError('Patch queue changed while waiting for confirmation. Re-run reorder.');
-        }
-        const currentTarget = currentManifest.patches.find((p) => p.filename === target.filename);
-        if (!currentTarget) {
-            throw new GeneralError(`Patch queue changed while waiting for confirmation. ${target.filename} no longer exists; re-run reorder.`);
-        }
-        let currentDestinationOrder;
-        if (options.to !== undefined) {
-            currentDestinationOrder = options.to;
-        }
-        else if (options.before !== undefined) {
-            const currentAnchor = currentManifest.patches.find((p) => p.filename === anchorFilename);
-            if (!currentAnchor) {
-                throw new GeneralError('Patch queue changed while waiting for confirmation. The reorder anchor moved or disappeared; re-run reorder.');
-            }
-            currentDestinationOrder = currentAnchor.order;
-        }
-        else {
-            const currentAnchor = currentManifest.patches.find((p) => p.filename === anchorFilename);
-            if (!currentAnchor) {
-                throw new GeneralError('Patch queue changed while waiting for confirmation. The reorder anchor moved or disappeared; re-run reorder.');
-            }
-            currentDestinationOrder = currentAnchor.order + 1;
-        }
-        const currentRenameMap = computeRenameMap(currentManifest.patches, currentTarget, currentDestinationOrder);
-        if (!renameMapsEqual(renameMap, currentRenameMap)) {
-            throw new GeneralError('Patch queue changed while waiting for confirmation. Re-run reorder to recompute the rename plan.');
-        }
-        enforcePatchPolicy({
-            config,
-            manifest: applyRenameMapToManifest(currentManifest, currentRenameMap),
-            command: 'patch reorder',
-            forceUnsafe: options.forceUnsafe === true,
-        });
-        const currentProjected = projectReorder(await buildPatchQueueContext(patchesDir), currentRenameMap);
-        const currentConflicts = lintPatchQueue(currentProjected).filter((i) => i.severity === 'error');
-        if (currentConflicts.length > 0 && options.forceUnsafe !== true) {
-            throw new InvalidArgumentError(`Refusing to run patch reorder: reorder would introduce ${currentConflicts.length} cross-patch lint error(s):\n  ${currentConflicts
-                .map(formatPatchLintIssue)
-                .join('\n  ')}\nPass --force-unsafe to override.`, '--force-unsafe');
-        }
-        await renumberPatchesInManifest(patchesDir, currentRenameMap);
-        // Append the history record inside the lock so two concurrent reorders
-        // cannot interleave mutation and history writes, and so a crash
-        // between the rename and the history write cannot orphan a committed
-        // reorder with no audit trail. An append failure (disk full,
-        // 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.
-        await appendHistoryBestEffort(patchesDir, buildHistoryEntry(currentRenameMap), `patch reorder committed`);
-        return currentRenameMap;
-    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch reorder' });
-}
-/**
- * Validates the `--shift` flag set and runs the shift, or returns false
- * when no shift flag was given.
- */
-async function runShiftMode(projectRoot, identifier, options) {
-    const { shift, from } = options;
-    if (shift === undefined && from === undefined && options.through === undefined)
-        return false;
-    if (shift === undefined || from === undefined) {
-        throw new InvalidArgumentError('--shift <n> and --from <order> go together (--through <order> is optional).', shift === undefined ? '--shift' : '--from');
-    }
-    if (identifier !== undefined ||
-        options.to !== undefined ||
-        options.before !== undefined ||
-        options.after !== undefined) {
-        throw new InvalidArgumentError('--shift renumbers a run of orders and takes no patch name, --to, --before or --after.', '--shift');
-    }
-    await patchReorderShiftCommand(projectRoot, { ...options, shift, from });
-    return true;
-}
-/**
- * Runs the `patch reorder` command: computes a rename map moving the
- * target patch to the requested slot, projects the new order through
- * cross-patch lint, confirms, and then renames under the patch directory
- * lock. With `--shift` it renumbers a run instead (see reorder-shift.ts).
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename or ordinal number to move (none with `--shift`)
- * @param options - Command options (mutually exclusive --to/--before/--after/--shift)
- */
-export async function patchReorderCommand(projectRoot, identifier, options = {}) {
-    if (await runShiftMode(projectRoot, identifier, options))
-        return;
-    if (identifier === undefined) {
-        throw new InvalidArgumentError('Name the patch to move, or renumber a run with --shift <n> --from <order>.', 'patch reorder');
-    }
-    intro(options.dryRun ? 'FireForge patch reorder (dry run)' : 'FireForge patch reorder');
-    const specifiedTargets = [
-        options.to !== undefined,
-        options.before !== undefined,
-        options.after !== undefined,
-    ].filter(Boolean).length;
-    if (specifiedTargets === 0) {
-        throw new InvalidArgumentError('Specify --to <N>, --before <name>, or --after <name>.', 'patch reorder');
-    }
-    if (specifiedTargets > 1) {
-        throw new InvalidArgumentError('--to, --before, and --after are mutually exclusive.', 'patch reorder');
-    }
-    const config = await loadConfig(projectRoot);
-    const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const target = requirePatchTarget(identifier, manifest.patches);
-    const { destinationOrder, anchorFilename } = resolveDestination(target, manifest.patches, options);
-    const renameMap = computeRenameMap(manifest.patches, target, destinationOrder);
-    if (renameMap.size === 0) {
-        info('Target is already at the requested position. Nothing to do.');
-        outro('Reorder complete (no-op)');
-        return;
-    }
-    // Project the reorder through cross-patch lint. Forward-import violations
-    // that the reorder itself introduces become hard refusals.
-    const baseCtx = await buildPatchQueueContext(paths.patches);
-    const projected = projectReorder(baseCtx, renameMap);
-    const projectedIssues = lintPatchQueue(projected);
-    const errorIssues = projectedIssues.filter((i) => i.severity === 'error');
-    enforcePatchPolicy({
-        config,
-        manifest: applyRenameMapToManifest(manifest, renameMap),
-        command: 'patch reorder',
-        forceUnsafe: options.forceUnsafe === true,
-    });
-    const conflicts = errorIssues.length > 0
-        ? {
-            reason: `reorder would introduce ${errorIssues.length} cross-patch lint error(s)`,
-            details: errorIssues.map(formatPatchLintIssue),
-        }
-        : null;
-    const renameEntries = getSortedRenameEntries(renameMap);
-    const targetRename = renameMap.get(target.filename);
-    if (!targetRename) {
-        throw new GeneralError('Reorder plan did not include the target patch.');
-    }
-    const actualDestinationOrder = targetRename.newOrder;
-    const summary = [
-        `move ${target.filename}  →  order ${actualDestinationOrder}`,
-        `${renameMap.size} patch(es) would be renamed:`,
-    ];
-    for (const [oldFilename, entry] of renameEntries) {
-        summary.push(`  ${oldFilename}  →  ${entry.newFilename}  (order ${entry.newOrder})`);
-    }
-    const decision = await confirmDestructive({
-        operation: 'patch-reorder',
-        title: `Reorder ${target.filename} to position ${actualDestinationOrder}`,
-        summary,
-        yes: options.yes === true,
-        dryRun: options.dryRun === true,
-        unsafeOverride: options.forceUnsafe === true,
-        conflicts,
-    });
-    if (!proceedAfterDecision(decision, 'Reorder cancelled'))
-        return;
-    // The history entry is built inside commitReorderPlan (still under the
-    // 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);
-        const finalTarget = finalRenameMap.get(target.filename);
-        return {
-            operation: 'patch-reorder',
-            args: {
-                target: target.filename,
-                destinationOrder: finalTarget?.newOrder ?? actualDestinationOrder,
-                renames: finalEntries.map(([from, entry]) => ({
-                    from,
-                    to: entry.newFilename,
-                    order: entry.newOrder,
-                })),
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-            result: 'ok',
-        };
-    };
-    const committed = await commitReorderPlan({
-        patchesDir: paths.patches,
-        target,
-        renameMap,
-        anchorFilename,
-        options,
-        config,
-        buildHistoryEntry,
-    });
-    if (options.mapOut !== undefined) {
-        const written = await writeRenameMapFile(options.mapOut, committed);
-        info(`Wrote the old-to-new filename map (${committed.size} rename(s)) to ${written}`);
-    }
-    info(`Reordered ${renameMap.size} patch(es).`);
-    outro('Reorder complete');
-}
-/**
- * Registers the `patch reorder` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchReorder(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('reorder [name]')
-        .description('Move a patch to a different position in the queue, or shift a run of patches up with ' +
-        '--shift <n> --from <order> (destructive)')
-        .addOption(new Option('--to <order>', 'Destination ordinal').argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--to', v))))
-        .option('--before <anchor>', 'Place the patch immediately before <anchor>')
-        .option('--after <anchor>', 'Place the patch immediately after <anchor>')
-        .addOption(new Option('--shift <n>', 'Renumber the run starting at --from up by <n> orders (no patch name); under ' +
-        'patchPolicy.allowGaps: false the opened orders are reserved').argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--shift', v))))
-        .addOption(new Option('--from <order>', 'First order of the run --shift moves').argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--from', v))))
-        .addOption(new Option('--through <order>', 'Last order of the run --shift moves (default: the end of the run of consecutive ' +
-        "orders of --from's category)").argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--through', v))))
-        .option('--map-out <file>', 'Write the committed old-to-new filename map as JSON')
-        .option('--dry-run', 'Show what would happen without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--force-unsafe', 'Bypass the refusal when the projected order introduces a lint error');
-    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
-        await patchReorderCommand(getProjectRoot(), name, pickDefined(options));
-    }));
-}

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

@@ -1,33 +0,0 @@
-/**
- * `fireforge patch reserve <order>`: holds an order number for a patch a
- * session has agreed to export but has not exported yet.
- *
- * The case it exists for: under `patchPolicy.allowGaps: false`, a session
- * cannot `export --order 571` while a peer has claimed 569 and 570 but not
- * exported them, because the unfilled orders read as a gap. A reservation
- * is a placeholder in `patches.json#reserved` that the gap check counts as
- * occupied and the earliest-legal-order search counts as taken. The export
- * that lands on the order fills it (see `core/patch-retired.ts`), and
- * `--release` drops a reservation whose patch will not come.
- *
- * Metadata-only: no `.patch` file is written and no row is added, so
- * apply, lint and rebase never see a reservation.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchReserveOptions } from '../../types/commands/index.js';
-/**
- * Runs the `patch reserve` command.
- *
- * @param projectRoot - Project root directory
- * @param order - Order number to reserve or release
- * @param options - Command options
- */
-export declare function patchReserveCommand(projectRoot: string, order: number, options?: PatchReserveOptions): Promise<void>;
-/**
- * Registers the `patch reserve` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchReserve(parent: Command, context: CommandContext): void;

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

@@ -1,152 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch reserve <order>`: holds an order number for a patch a
- * session has agreed to export but has not exported yet.
- *
- * The case it exists for: under `patchPolicy.allowGaps: false`, a session
- * cannot `export --order 571` while a peer has claimed 569 and 570 but not
- * exported them, because the unfilled orders read as a gap. A reservation
- * is a placeholder in `patches.json#reserved` that the gap check counts as
- * occupied and the earliest-legal-order search counts as taken. The export
- * that lands on the order fills it (see `core/patch-retired.ts`), and
- * `--release` drops a reservation whose patch will not come.
- *
- * Metadata-only: no `.patch` file is written and no row is added, so
- * apply, lint and rebase never see a reservation.
- */
-import { Command } from 'commander';
-import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { loadPatchesManifestForWrite, savePatchesManifest } from '../../core/patch-manifest.js';
-import { formatPatchOrder } from '../../core/patch-parse.js';
-import { categoryRangeForOrder, categoryRangeLabel, isCategoryAllowedByConfig, } from '../../core/patch-policy.js';
-import { InvalidArgumentError } from '../../errors/base.js';
-import { info, intro, outro } from '../../utils/logger.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
-import { parsePositiveIntegerFlag } from '../../utils/validation.js';
-/**
- * Refuses a reservation the manifest or the policy cannot hold: an order a
- * patch, a retired slot or another reservation already takes, or one
- * outside the category's configured ranges.
- */
-function assertReservable(manifest, config, order, category) {
-    const label = formatPatchOrder(order);
-    const patch = manifest.patches.find((entry) => entry.order === order);
-    if (patch !== undefined) {
-        throw new InvalidArgumentError(`Order ${label} is taken by ${patch.filename}.`, '<order>');
-    }
-    if ((manifest.retired ?? []).some((slot) => slot.order === order)) {
-        throw new InvalidArgumentError(`Order ${label} is a retired slot; "fireforge export --order ${label}" fills it without a reservation.`, '<order>');
-    }
-    const held = manifest.reserved?.find((slot) => slot.order === order);
-    if (held !== undefined) {
-        throw new InvalidArgumentError(`Order ${label} is already reserved by ${held.owner} (since ${held.reservedAt}).`, '<order>');
-    }
-    const policy = config.patchPolicy;
-    if (policy !== undefined && categoryRangeForOrder(policy, category, order) === null) {
-        throw new InvalidArgumentError(`Order ${label} is outside the ${category} range (${categoryRangeLabel(policy.ranges, category)}).`, '<order>');
-    }
-}
-/**
- * Runs the `patch reserve` command.
- *
- * @param projectRoot - Project root directory
- * @param order - Order number to reserve or release
- * @param options - Command options
- */
-export async function patchReserveCommand(projectRoot, order, options = {}) {
-    const releasing = options.release === true;
-    const verb = releasing ? 'release' : 'reserve';
-    intro(options.dryRun ? `FireForge patch ${verb} (dry run)` : `FireForge patch ${verb}`);
-    const config = await loadConfig(projectRoot);
-    const label = formatPatchOrder(order);
-    let category;
-    let owner;
-    if (!releasing) {
-        category = options.category;
-        owner = options.owner?.trim();
-        if (category === undefined || owner === undefined || owner === '') {
-            throw new InvalidArgumentError('patch reserve requires --category and --owner (or --release to drop a reservation).', [category === undefined ? '--category' : '', owner ? '' : '--owner']
-                .filter(Boolean)
-                .join(', '));
-        }
-        if (!isCategoryAllowedByConfig(config, category)) {
-            throw new InvalidArgumentError(`Unknown patch category "${category}".`, '--category');
-        }
-    }
-    else if (options.category !== undefined || options.owner !== undefined) {
-        throw new InvalidArgumentError('--release takes only the order; --category and --owner apply when reserving.', '--release');
-    }
-    const { patches: patchesDir } = getProjectPaths(projectRoot);
-    await withPatchDirectoryLock(patchesDir, async () => {
-        const manifest = (await loadPatchesManifestForWrite(patchesDir)) ?? {
-            version: 1,
-            patches: [],
-        };
-        const reserved = manifest.reserved ?? [];
-        let slot;
-        let next;
-        if (releasing) {
-            const held = reserved.find((entry) => entry.order === order);
-            if (held === undefined) {
-                throw new InvalidArgumentError(`Order ${label} is not reserved.`, '<order>');
-            }
-            slot = held;
-            next = reserved.filter((entry) => entry.order !== order);
-        }
-        else {
-            assertReservable(manifest, config, order, category);
-            slot = {
-                order,
-                category: category,
-                owner: owner,
-                reservedAt: new Date().toISOString(),
-                ...(options.reason !== undefined ? { reason: options.reason } : {}),
-            };
-            next = [...reserved, slot].sort((a, b) => a.order - b.order);
-        }
-        const summary = releasing
-            ? `release order ${label} (reserved by ${slot.owner})`
-            : `reserve order ${label} for ${slot.owner} (category: ${slot.category})`;
-        if (options.dryRun === true) {
-            info(`[dry-run] ${summary}`);
-            return;
-        }
-        if (next.length > 0)
-            manifest.reserved = next;
-        else
-            delete manifest.reserved;
-        await savePatchesManifest(patchesDir, manifest);
-        await appendHistoryBestEffort(patchesDir, {
-            operation: releasing ? 'patch-reserve-release' : 'patch-reserve',
-            args: { ...slot },
-            result: 'ok',
-        }, `patch ${verb} committed (${label})`);
-        info(releasing
-            ? `Released order ${label}.`
-            : `Reserved order ${label} for ${slot.owner}; "fireforge export --order ${label}" fills it.`);
-    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: `patch ${verb}` });
-    outro(options.dryRun ? 'Dry run complete — no changes made' : `Patch ${verb} complete`);
-}
-/**
- * Registers the `patch reserve` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchReserve(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('reserve <order>')
-        .description('Hold an order number for a patch not exported yet, so patchPolicy.allowGaps: false ' +
-        'sees no gap; the export that takes the order fills it (metadata only)')
-        .option('--category <category>', 'Category the reserved patch will carry')
-        .option('--owner <label>', 'Who holds the reservation (a session label or planned filename)')
-        .option('--reason <text>', 'Rationale recorded on the reserved slot')
-        .option('--release', 'Drop the reservation at <order> instead of creating one')
-        .option('--dry-run', 'Show what would change without writing');
-    addWaitLockOption(command).action(withErrorHandling(async (rawOrder, options) => {
-        await patchReserveCommand(getProjectRoot(), parsePositiveIntegerFlag('<order>', rawOrder), pickDefined(options));
-    }));
-}

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

@@ -1,34 +0,0 @@
-/**
- * `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 type { CommandContext } from '../../types/cli.js';
-import type { PatchRetireOptions } from '../../types/commands/index.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 declare function patchRetireCommand(projectRoot: string, identifier: string, options?: PatchRetireOptions): Promise<void>;
-/**
- * Registers the `patch retire` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchRetire(parent: Command, context: CommandContext): void;