@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/parent-exit-watchdog.js

@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Detects the death of FireForge's own parent while a harness runs.
- *
- * A supervisor that SIGKILLs the process above `fireforge test` (the
- * 2026-09-13 incident: a gate killed its `npm` step at the 15-minute bound)
- * signals nothing below it. FireForge is not told; its stdout pipe merely
- * breaks, and the broken-pipe handler swallows EPIPE on purpose so `| head`
- * works. The mach tree it spawned as a separate process group keeps running
- * under nobody's supervision, and the httpd in that tree spun at 100% CPU
- * for hours.
- *
- * SIGKILL cannot be caught, but reparenting can be observed: once the parent
- * is gone, `process.ppid` changes (to launchd/init, or to a subreaper). This
- * watchdog polls for that while a dispatch is in flight and fires once. It
- * does not decide what to do about it; the test command tears down the
- * harness tree and ends the run.
- *
- * Off on Windows: `process.ppid` is not refreshed there after the parent
- * exits, and there is no process group to signal in response anyway.
- */
-/** How often the parent is probed. Cheap (one syscall), so a short interval is fine. */
-const DEFAULT_INTERVAL_MS = 2000;
-let parentExitObserved = false;
-/**
- * True once any watchdog in this process has seen the parent die. The
- * dispatch loop reads it to end the run instead of classifying the killed
- * harness as a crash and retrying it under a parent that no longer exists.
- */
-export function parentExited() {
-    return parentExitObserved;
-}
-/**
- * Forgets an observed parent exit.
- *
- * @internal Exported only so tests can reach it. It is not part of the
- * public surface.
- */
-export function resetParentExitForTests() {
-    parentExitObserved = false;
-}
-/**
- * Starts probing `process.ppid`. The timer is unref'd so the watchdog can
- * never be the thing keeping FireForge alive; while a child runs, the child
- * does that.
- */
-export function startParentExitWatchdog(options) {
-    if (process.platform === 'win32') {
-        return { stop: () => undefined };
-    }
-    const readPpid = options.readPpid ?? (() => process.ppid);
-    const originalPpid = readPpid();
-    let timer = setInterval(() => {
-        const currentPpid = readPpid();
-        if (currentPpid === originalPpid)
-            return;
-        stop();
-        parentExitObserved = true;
-        options.onParentExit({ originalPpid, currentPpid });
-    }, options.intervalMs ?? DEFAULT_INTERVAL_MS);
-    timer.unref();
-    function stop() {
-        if (timer === undefined)
-            return;
-        clearInterval(timer);
-        timer = undefined;
-    }
-    return { stop };
-}

package/dist/src/core/park-store.d.ts

@@ -1,63 +0,0 @@
-/** One parked file: both sides, null meaning absent. */
-export interface ParkedFile {
-    /** Engine-relative path. */
-    path: string;
-    /** The file as the session left it. */
-    before: string | null;
-    /** The file the park wrote in its place. */
-    after: string | null;
-}
-/** The record of one park. */
-export interface ParkRecord {
-    label: string;
-    /** The patch whose files were parked. */
-    patch: string;
-    createdAt: string;
-    /** `baseline` parks every drifted hunk, `hunks` only those a diff named. */
-    mode: 'baseline' | 'hunks';
-    files: ParkedFile[];
-}
-/** What `park.json` holds: the record without file contents. */
-interface ParkIndex extends Omit<ParkRecord, 'files'> {
-    files: {
-        path: string;
-        before: boolean;
-        after: boolean;
-    }[];
-}
-/** The outcome of restoring one file. */
-export type RestoreOutcome = 'restored' | 'unchanged' | 'merged' | 'conflict';
-/** Writes a park; refuses to overwrite an existing label. */
-export declare function writePark(projectRoot: string, record: ParkRecord): Promise<string>;
-/** Reads a park back, contents included. */
-export declare function readPark(projectRoot: string, label: string): Promise<ParkRecord>;
-/** Every park of the project, oldest first. */
-export declare function listParks(projectRoot: string): Promise<ParkIndex[]>;
-/** Deletes a park. */
-export declare function dropPark(projectRoot: string, label: string): Promise<void>;
-/** Reads an engine file, null when absent. */
-export declare function readEngineFile(engineDir: string, path: string): Promise<string | null>;
-/** Writes an engine file, removing it for null. */
-export declare function writeEngineFile(engineDir: string, path: string, content: string | null): Promise<void>;
-/**
- * Three-way merges `ours` and `theirs` over `base` with `git merge-file`.
- * Conflicts come back as marker blocks.
- */
-export declare function mergeThreeWay(ours: string, base: string, theirs: string, path: string): Promise<{
-    content: string;
-    conflicts: number;
-}>;
-/**
- * What restoring one parked file writes: `before` when the file is still
- * as the park left it, nothing when it already matches `before`, and a
- * three-way merge otherwise. Absence only merges with absence.
- */
-export declare function planRestore(file: ParkedFile, now: string | null): Promise<{
-    outcome: RestoreOutcome;
-    content: string | null;
-}>;
-/** Message ids a Fluent file's lines declare (`id = …`, `-term = …`). */
-export declare function fluentIds(lines: readonly string[]): string[];
-/** Lines `before` has that `after` lacks, as a multiset difference. */
-export declare function removedLines(before: string | null, after: string | null): string[];
-export {};

package/dist/src/core/park-store.js

@@ -1,216 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Storage and merge logic behind `fireforge park`.
- *
- * Several sessions edit the same Hominis files on one engine, and a peer's
- * `re-export --refuse-foreign-drift` refuses while another session's hunks
- * sit in its patch's files. Setting those hunks aside meant reversing each
- * one by hand. A park records, for every file of one patch that drifted:
- *
- *  - `before`: the file as the session left it (what the park takes away),
- *  - `after`: what the park writes in its place (the queue-applied
- *    baseline, or the working tree minus the named hunks).
- *
- * Restoring is a three-way merge of the file as it is now (ours) with
- * `before` (theirs) over `after` (base), so the owner's commit in between
- * is kept and the parked hunks come back on top of it.
- *
- * A park lives under `.fireforge/park/<label>/`: `park.json` plus one copy
- * of each side per file. Absent files are recorded as absent, never as
- * empty.
- */
-import { mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { InvalidArgumentError } from '../errors/base.js';
-import { getNodeErrorCode } from '../utils/errors.js';
-import { ensureDir, pathExists, readJson, readText, removeFile, writeJson, writeText, } from '../utils/fs.js';
-import { exec } from '../utils/process.js';
-import { FIREFORGE_DIR } from './config-paths.js';
-const LABEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-/** The directory holding every park of a project. */
-function parkRoot(projectRoot) {
-    return join(projectRoot, FIREFORGE_DIR, 'park');
-}
-/** Refuses a label that is not a plain file-name segment. */
-function assertParkLabel(label) {
-    if (!LABEL_PATTERN.test(label)) {
-        throw new InvalidArgumentError(`Park label "${label}" must be letters, digits, ".", "_" or "-", starting with a letter or digit.`, '--label');
-    }
-}
-function sideDir(dir, side) {
-    return join(dir, side);
-}
-/** Writes a park; refuses to overwrite an existing label. */
-export async function writePark(projectRoot, record) {
-    assertParkLabel(record.label);
-    const dir = join(parkRoot(projectRoot), record.label);
-    if (await pathExists(dir)) {
-        throw new InvalidArgumentError(`A park named "${record.label}" already exists. Restore or drop it first, or pass another --label.`, '--label');
-    }
-    for (const file of record.files) {
-        for (const side of ['before', 'after']) {
-            const content = file[side];
-            if (content === null)
-                continue;
-            const target = join(sideDir(dir, side), file.path);
-            await ensureDir(dirname(target));
-            await writeText(target, content);
-        }
-    }
-    const index = {
-        label: record.label,
-        patch: record.patch,
-        createdAt: record.createdAt,
-        mode: record.mode,
-        files: record.files.map((file) => ({
-            path: file.path,
-            before: file.before !== null,
-            after: file.after !== null,
-        })),
-    };
-    await writeJson(join(dir, 'park.json'), index);
-    return dir;
-}
-/** Reads a park back, contents included. */
-export async function readPark(projectRoot, label) {
-    assertParkLabel(label);
-    const dir = join(parkRoot(projectRoot), label);
-    if (!(await pathExists(join(dir, 'park.json')))) {
-        throw new InvalidArgumentError(`No park named "${label}". List them with "fireforge park --list".`, label);
-    }
-    const index = await readJson(join(dir, 'park.json'));
-    const files = [];
-    for (const entry of index.files) {
-        files.push({
-            path: entry.path,
-            before: entry.before ? await readText(join(sideDir(dir, 'before'), entry.path)) : null,
-            after: entry.after ? await readText(join(sideDir(dir, 'after'), entry.path)) : null,
-        });
-    }
-    return { ...index, files };
-}
-/** Every park of the project, oldest first. */
-export async function listParks(projectRoot) {
-    let names;
-    try {
-        names = (await readdir(parkRoot(projectRoot), { withFileTypes: true }))
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name);
-    }
-    catch (error) {
-        if (getNodeErrorCode(error) === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const parks = [];
-    for (const name of names) {
-        const path = join(parkRoot(projectRoot), name, 'park.json');
-        if (await pathExists(path))
-            parks.push(await readJson(path));
-    }
-    return parks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-}
-/** Deletes a park. */
-export async function dropPark(projectRoot, label) {
-    assertParkLabel(label);
-    const dir = join(parkRoot(projectRoot), label);
-    if (!(await pathExists(dir))) {
-        throw new InvalidArgumentError(`No park named "${label}".`, label);
-    }
-    await rm(dir, { recursive: true, force: true });
-}
-/** Reads an engine file, null when absent. */
-export async function readEngineFile(engineDir, path) {
-    const full = join(engineDir, path);
-    return (await pathExists(full)) ? await readText(full) : null;
-}
-/** Writes an engine file, removing it for null. */
-export async function writeEngineFile(engineDir, path, content) {
-    const full = join(engineDir, path);
-    if (content === null) {
-        if (await pathExists(full))
-            await removeFile(full);
-        return;
-    }
-    await ensureDir(dirname(full));
-    await writeText(full, content);
-}
-/**
- * Three-way merges `ours` and `theirs` over `base` with `git merge-file`.
- * Conflicts come back as marker blocks.
- */
-export async function mergeThreeWay(ours, base, theirs, path) {
-    const scratch = await mkdtemp(join(tmpdir(), 'fireforge-park-'));
-    try {
-        const files = {
-            ours: join(scratch, 'ours'),
-            base: join(scratch, 'base'),
-            theirs: join(scratch, 'theirs'),
-        };
-        await writeFile(files.ours, ours);
-        await writeFile(files.base, base);
-        await writeFile(files.theirs, theirs);
-        const result = await exec('git', [
-            'merge-file',
-            '-p',
-            '-L',
-            `${path} (now)`,
-            '-L',
-            `${path} (parked from)`,
-            '-L',
-            `${path} (parked)`,
-            files.ours,
-            files.base,
-            files.theirs,
-        ]);
-        if (result.exitCode < 0 || result.exitCode > 127) {
-            throw new Error(`git merge-file failed for ${path}: ${result.stderr.trim()}`);
-        }
-        return { content: result.stdout, conflicts: result.exitCode };
-    }
-    finally {
-        await rm(scratch, { recursive: true, force: true });
-    }
-}
-/**
- * What restoring one parked file writes: `before` when the file is still
- * as the park left it, nothing when it already matches `before`, and a
- * three-way merge otherwise. Absence only merges with absence.
- */
-export async function planRestore(file, now) {
-    if (now === file.after)
-        return { outcome: 'restored', content: file.before };
-    if (now === file.before)
-        return { outcome: 'unchanged', content: now };
-    if (now === null || file.before === null || file.after === null) {
-        return { outcome: 'conflict', content: now };
-    }
-    const merged = await mergeThreeWay(now, file.after, file.before, file.path);
-    return { outcome: merged.conflicts > 0 ? 'conflict' : 'merged', content: merged.content };
-}
-/** Message ids a Fluent file's lines declare (`id = …`, `-term = …`). */
-export function fluentIds(lines) {
-    const ids = [];
-    for (const line of lines) {
-        const match = /^(-?[A-Za-z][\w-]*)\s*=/.exec(line);
-        if (match?.[1] !== undefined)
-            ids.push(match[1]);
-    }
-    return ids;
-}
-/** Lines `before` has that `after` lacks, as a multiset difference. */
-export function removedLines(before, after) {
-    const remaining = new Map();
-    for (const line of (after ?? '').split('\n'))
-        remaining.set(line, (remaining.get(line) ?? 0) + 1);
-    const removed = [];
-    for (const line of (before ?? '').split('\n')) {
-        const count = remaining.get(line) ?? 0;
-        if (count > 0)
-            remaining.set(line, count - 1);
-        else
-            removed.push(line);
-    }
-    return removed;
-}

package/dist/src/core/parser-fallback.d.ts

@@ -1,50 +0,0 @@
-export interface ParserFallbackEvent {
-    context: string;
-    reason: string;
-}
-/** Returns recorded parser fallback events without clearing the event buffer. */
-/** Returns and clears the recorded parser fallback events. */
-export declare function consumeParserFallbackEvents(): ParserFallbackEvent[];
-/**
- * Result of a parser-with-fallback invocation, carrying both the computed
- * value and metadata about which code path produced it.
- */
-/**
- * The `rethrowIf` predicate every AST-primary caller wants.
- *
- * Rethrows internal-invariant `GeneralError`s ("Unexpected empty …array"):
- * those are programming bugs, and retrying the fallback scanner cannot fix a
- * broken invariant, it just buries the stack. Everything else still falls
- * back, which matters: the AST path raises a raw acorn SyntaxError
- * on chrome sources acorn cannot parse (preprocessor directives), and
- * BuildError when the file's shape is unexpected. Both are exactly what the
- * fallback scanner is here to handle.
- *
- * @param error - The error the primary parser threw
- * @returns True when the error must propagate instead of falling back
- */
-export declare function isInternalInvariantFailure(error: unknown): boolean;
-export interface ParserResult<T> {
-    /** The computed value (from either the primary or fallback path). */
-    value: T;
-    /** True when the primary parser failed and the fallback was used. */
-    usedFallback: boolean;
-    /** The error that caused the primary parser to fail (undefined when primary succeeded). */
-    fallbackReason?: string;
-}
-/**
- * Wraps a primary (AST/tokenizer) parser with a regex/line-based
- * fallback. If the primary throws, a warning is logged and the fallback is
- * used instead.
- *
- * Returns a {@link ParserResult} so callers (and tests) can detect which
- * code path was taken and surface it in logs or assertions.
- *
- * @param primary - The primary parser implementation
- * @param fallback - The regex/line-based fallback implementation
- * @param context - File/context name used in the warning message
- * @param rethrowIf - Optional predicate. If it returns true for the caught
- *   error the error is re-thrown instead of falling back (useful for
- *   domain-specific errors that should not be swallowed).
- */
-export declare function withParserFallback<T>(primary: () => T, fallback: () => T, context: string, rethrowIf?: (error: unknown) => boolean): ParserResult<T>;

package/dist/src/core/parser-fallback.js

@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { GeneralError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { warn } from '../utils/logger.js';
-const parserFallbackEvents = [];
-/** Returns recorded parser fallback events without clearing the event buffer. */
-/** Returns and clears the recorded parser fallback events. */
-export function consumeParserFallbackEvents() {
-    const events = [...parserFallbackEvents];
-    parserFallbackEvents.length = 0;
-    return events;
-}
-/**
- * Result of a parser-with-fallback invocation, carrying both the computed
- * value and metadata about which code path produced it.
- */
-/**
- * The `rethrowIf` predicate every AST-primary caller wants.
- *
- * Rethrows internal-invariant `GeneralError`s ("Unexpected empty …array"):
- * those are programming bugs, and retrying the fallback scanner cannot fix a
- * broken invariant, it just buries the stack. Everything else still falls
- * back, which matters: the AST path raises a raw acorn SyntaxError
- * on chrome sources acorn cannot parse (preprocessor directives), and
- * BuildError when the file's shape is unexpected. Both are exactly what the
- * fallback scanner is here to handle.
- *
- * @param error - The error the primary parser threw
- * @returns True when the error must propagate instead of falling back
- */
-export function isInternalInvariantFailure(error) {
-    return error instanceof GeneralError;
-}
-/**
- * Wraps a primary (AST/tokenizer) parser with a regex/line-based
- * fallback. If the primary throws, a warning is logged and the fallback is
- * used instead.
- *
- * Returns a {@link ParserResult} so callers (and tests) can detect which
- * code path was taken and surface it in logs or assertions.
- *
- * @param primary - The primary parser implementation
- * @param fallback - The regex/line-based fallback implementation
- * @param context - File/context name used in the warning message
- * @param rethrowIf - Optional predicate. If it returns true for the caught
- *   error the error is re-thrown instead of falling back (useful for
- *   domain-specific errors that should not be swallowed).
- */
-export function withParserFallback(primary, fallback, context, rethrowIf) {
-    try {
-        return { value: primary(), usedFallback: false };
-    }
-    catch (error) {
-        if (rethrowIf?.(error))
-            throw error;
-        const reason = toError(error).message;
-        parserFallbackEvents.push({ context, reason });
-        warn(`AST/tokenizer parsing failed for ${context}, falling back to legacy. Error: ${reason}`);
-        return { value: fallback(), usedFallback: true, fallbackReason: reason };
-    }
-}

package/dist/src/core/patch-apply-fuzz.d.ts

@@ -1,57 +0,0 @@
-/**
- * Fuzz-like patch application with escalating context reduction.
- *
- * Tries an exact `git apply` first, then retries with git's real
- * drift-tolerance knob: `-C<n>` (reduced context matching). `git apply` has
- * no `--fuzz` option. That flag belongs to GNU `patch(1)`, and passing it
- * makes git exit 129 with a usage error that an escalation loop will happily
- * swallow, so every "fuzzy" attempt silently fails and patches that would
- * have applied with context drift are reported as hard conflicts. If all
- * context-reduction levels fail, falls through to `git apply --reject` so
- * the user gets `.rej` files for manual resolution.
- *
- * Semantics note: GNU fuzz *fuzzily matches* context. `-C<n>` *ignores*
- * outer context lines instead. Step k maps to `-C(3-k)` (git's default
- * context width is 3), so the final step `-C0` matches on line positions and
- * -/+ content alone, the rough analogue of GNU `--fuzz=3` on a 3-context
- * patch.
- */
-export interface FuzzyApplyResult {
-    /** Whether the patch was applied successfully. */
-    success: boolean;
-    /** Context-reduction steps taken (0 = exact match, k = applied with `-C(3-k)`). */
-    fuzzFactor: number;
-    /** Error description when `success` is false. */
-    error?: string;
-    /** List of `.rej` files created (when falling through to --reject). */
-    rejectFiles?: string[];
-}
-/**
- * The context-reduction ladder shared by the real apply and the dry-run
- * replay: step 0 is an exact apply, step k passes `-C(3-k)`.
- * @param maxFuzz - Maximum context-reduction steps (validated by callers)
- * @returns One `git apply` argument list per step, in order
- */
-export declare function contextReductionSteps(maxFuzz: number): string[][];
-/**
- * Validates a `maxFuzz` value.
- * @throws InvalidArgumentError when `maxFuzz` is not a non-negative integer
- */
-export declare function assertValidMaxFuzz(maxFuzz: number): void;
-/**
- * Attempts to apply a patch with escalating context reduction.
- *
- * 1. `git apply --check` exact, then with `-C2`, `-C1`, `-C0`
- * 2. `git apply` (same flags) at the first passing level
- * 3. Fall through to `git apply --reject` if nothing succeeds
- *
- * @param patchPath - Absolute path to the `.patch` file
- * @param engineDir - Working directory (engine/)
- * @param maxFuzz   - Maximum context-reduction steps to try (default 3,
- *   0 = exact only). Values above 3 are capped: git cannot reduce below
- *   `-C0`.
- * @throws InvalidArgumentError when `maxFuzz` is not a non-negative integer.
- *   A NaN or negative value would silently skip every apply attempt
- *   (including the exact-match one) and fall straight through to `--reject`
- */
-export declare function applyPatchWithFuzz(patchPath: string, engineDir: string, maxFuzz?: number): Promise<FuzzyApplyResult>;

package/dist/src/core/patch-apply-fuzz.js

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Fuzz-like patch application with escalating context reduction.
- *
- * Tries an exact `git apply` first, then retries with git's real
- * drift-tolerance knob: `-C<n>` (reduced context matching). `git apply` has
- * no `--fuzz` option. That flag belongs to GNU `patch(1)`, and passing it
- * makes git exit 129 with a usage error that an escalation loop will happily
- * swallow, so every "fuzzy" attempt silently fails and patches that would
- * have applied with context drift are reported as hard conflicts. If all
- * context-reduction levels fail, falls through to `git apply --reject` so
- * the user gets `.rej` files for manual resolution.
- *
- * Semantics note: GNU fuzz *fuzzily matches* context. `-C<n>` *ignores*
- * outer context lines instead. Step k maps to `-C(3-k)` (git's default
- * context width is 3), so the final step `-C0` matches on line positions and
- * -/+ content alone, the rough analogue of GNU `--fuzz=3` on a 3-context
- * patch.
- */
-import { InvalidArgumentError } from '../errors/base.js';
-import { verbose } from '../utils/logger.js';
-import { exec } from '../utils/process.js';
-import { ensureGit } from './git-base.js';
-/** Git's default diff context width, the ceiling for reduction steps. */
-const GIT_DEFAULT_CONTEXT = 3;
-/**
- * The context-reduction ladder shared by the real apply and the dry-run
- * replay: step 0 is an exact apply, step k passes `-C(3-k)`.
- * @param maxFuzz - Maximum context-reduction steps (validated by callers)
- * @returns One `git apply` argument list per step, in order
- */
-export function contextReductionSteps(maxFuzz) {
-    const maxSteps = Math.min(maxFuzz, GIT_DEFAULT_CONTEXT);
-    const steps = [];
-    for (let step = 0; step <= maxSteps; step++) {
-        steps.push(step > 0 ? [`-C${GIT_DEFAULT_CONTEXT - step}`] : []);
-    }
-    return steps;
-}
-/**
- * Validates a `maxFuzz` value.
- * @throws InvalidArgumentError when `maxFuzz` is not a non-negative integer
- */
-export function assertValidMaxFuzz(maxFuzz) {
-    if (!Number.isInteger(maxFuzz) || maxFuzz < 0) {
-        throw new InvalidArgumentError(`maxFuzz must be a non-negative integer, got ${maxFuzz}.`, 'maxFuzz');
-    }
-}
-// ── Implementation ──
-/**
- * Attempts to apply a patch with escalating context reduction.
- *
- * 1. `git apply --check` exact, then with `-C2`, `-C1`, `-C0`
- * 2. `git apply` (same flags) at the first passing level
- * 3. Fall through to `git apply --reject` if nothing succeeds
- *
- * @param patchPath - Absolute path to the `.patch` file
- * @param engineDir - Working directory (engine/)
- * @param maxFuzz   - Maximum context-reduction steps to try (default 3,
- *   0 = exact only). Values above 3 are capped: git cannot reduce below
- *   `-C0`.
- * @throws InvalidArgumentError when `maxFuzz` is not a non-negative integer.
- *   A NaN or negative value would silently skip every apply attempt
- *   (including the exact-match one) and fall straight through to `--reject`
- */
-export async function applyPatchWithFuzz(patchPath, engineDir, maxFuzz = 3) {
-    assertValidMaxFuzz(maxFuzz);
-    await ensureGit();
-    // Try exact match first, then escalate context reduction.
-    const ladder = contextReductionSteps(maxFuzz);
-    const maxSteps = ladder.length - 1;
-    for (const [step, contextArgs] of ladder.entries()) {
-        const check = await exec('git', ['apply', '--check', ...contextArgs, '--', patchPath], {
-            cwd: engineDir,
-        });
-        if (check.exitCode === 0) {
-            // --check passed: apply for real
-            const apply = await exec('git', ['apply', ...contextArgs, '--', patchPath], {
-                cwd: engineDir,
-            });
-            if (apply.exitCode === 0) {
-                if (step > 0) {
-                    verbose(`Patch applied with reduced context (-C${GIT_DEFAULT_CONTEXT - step}): ${patchPath}`);
-                }
-                return { success: true, fuzzFactor: step };
-            }
-            // Unlikely: --check passed but apply failed. Fall through to next step
-            verbose(`git apply -C${GIT_DEFAULT_CONTEXT - step} --check passed but apply failed: ${apply.stderr.trim()}`);
-        }
-    }
-    // All context-reduction levels failed → generate .rej files for manual resolution
-    const rejectResult = await exec('git', ['apply', '--reject', '--', patchPath], {
-        cwd: engineDir,
-    });
-    const errorMessage = rejectResult.stderr.trim() || 'All context-reduction levels failed';
-    return {
-        success: false,
-        fuzzFactor: maxSteps,
-        error: errorMessage,
-        rejectFiles: extractRejectFiles(rejectResult.stderr),
-    };
-}
-/**
- * Extracts `.rej` file paths from `git apply --reject` stderr.
- *
- * Git's output shape:
- *
- *   Applying patch f.txt with 1 reject...
- *   Rejected hunk #1.
- *
- * The reject file is `<file>.rej` next to the target. Matching GNU
- * `patch(1)`'s "saving rejects to file X.rej" phrasing instead, which git
- * never prints, leaves `rejectFiles` always empty and the
- * conflict-summary ".rej files created" hint never fires.
- */
-function extractRejectFiles(stderr) {
-    const rejectFiles = [];
-    for (const line of stderr.split('\n')) {
-        const match = /^Applying patch (.+) with \d+ rejects?\.\.\./.exec(line);
-        if (match?.[1]) {
-            rejectFiles.push(`${match[1]}.rej`);
-        }
-    }
-    return rejectFiles;
-}