@hominis/fireforge 0.38.0 → 0.39.0

package/dist/src/commands/test.js

@@ -10,7 +10,6 @@ import { formatMarionettePreflightLine, reportMarionettePreflight, runMarionette
 import { buildHarnessCrashMessage } from '../core/test-harness-crash.js';
 import { createPostRebuildFailureContext } from '../core/test-harness-output.js';
 import { analyzeTestPathScopes, formatScopeNotice, } from '../core/test-path-scope.js';
-import { findNearestXpcshellManifest } from '../core/xpcshell-appdir.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { toError } from '../utils/errors.js';
@@ -18,7 +17,7 @@ import { pathExists } from '../utils/fs.js';
 import { info, intro, outro, spinner, success, verbose } from '../utils/logger.js';
 import { stripEnginePrefix } from '../utils/paths.js';
 import { diagnoseShardOutcome, finalizeSingleRunOutcome } from './test-diagnose.js';
-import { assertPathlessTestMode, assertTestModeCombinations, canaryTimeoutSeconds, reportCanaryOutcome, resolveCanaryPath, } from './test-modes.js';
+import { assertPathlessTestMode, assertTestModeCombinations, canaryTimeoutSeconds, classifyBeforeDispatch, reportCanaryOutcome, resolveCanaryPath, } from './test-modes.js';
 import { DEFAULT_HARNESS_RETRIES, runShardedTests, runTestsWithRetries, } from './test-run.js';
 import { enforceStaleBuildGate, enforceStaticComponentsGate } from './test-stale-gate.js';
 async function assertTestPathsExist(engineDir, testPaths) {
@@ -34,19 +33,6 @@ async function assertTestPathsExist(engineDir, testPaths) {
     throw new GeneralError(`Test path${missingPaths.length === 1 ? '' : 's'} not found under engine/: ${missingPaths.join(', ')}\n\n` +
         'If you expected these files to come from your patch stack, run "fireforge import" first.');
 }
-async function classifyTestHarnesses(engineDir, normalizedPaths) {
-    const result = { xpcshell: [], nonXpcshell: [] };
-    for (const testPath of normalizedPaths) {
-        const manifest = await findNearestXpcshellManifest(engineDir, testPath);
-        if (manifest) {
-            result.xpcshell.push(testPath);
-        }
-        else {
-            result.nonXpcshell.push(testPath);
-        }
-    }
-    return result;
-}
 /**
  * Picks the mach dispatch target for a (non-mixed) run. A single-suite run
  * auto-routes to the suite-specific command (`mach xpcshell-test` /
@@ -66,12 +52,6 @@ function resolveTestSuite(classification, forceGeneric) {
     }
     return 'generic';
 }
-function buildMixedHarnessMessage(classification) {
-    return ('FireForge cannot run xpcshell and browser/mochitest paths in the same mach invocation.\n\n' +
-        'Split this into separate `fireforge test` commands so each manifest selects its own harness:\n' +
-        `  - xpcshell: ${classification.xpcshell.join(', ')}\n` +
-        `  - browser/mochitest: ${classification.nonXpcshell.join(', ')}`);
-}
 function filterRedundantXpcshellFlavorArgs(machArgs, classification) {
     if (classification.xpcshell.length === 0 || classification.nonXpcshell.length > 0) {
         return [...machArgs];
@@ -140,7 +120,9 @@ async function runPreTestBuild(projectRoot, paths, projectConfig, harnessRetries
             // anchor forward (a `mach build faster` does not rebake
             // components.conf into the compiled table).
             try {
-                await writeBuildBaseline(projectRoot, paths.engine, projectConfig.binaryName, testPackagingCoverage, previousBaseline);
+                await writeBuildBaseline(projectRoot, paths.engine, projectConfig.binaryName, testPackagingCoverage, previousBaseline, testPackagingCoverage === 'full'
+                    ? 'fireforge test --build'
+                    : `fireforge test --build ${testPackagingCoverage.join(' ')}`);
             }
             catch (baselineError) {
                 verbose(`Could not persist build baseline: ${toError(baselineError).message}`);
@@ -239,7 +221,7 @@ async function runDoctorPreflight(args) {
  * `--mach-arg` and the xpcshell flavor that ignores the pref entirely.
  * Mutates `extraArgs` in place.
  */
-function appendMarionetteForwardingArgs(extraArgs, options, forwardedPort) {
+function appendMarionetteForwardingArgs(extraArgs, options, forwardedPort, xpcshellOnly = false) {
     // Auto-forward the Marionette port to mach when `--marionette-port` is
     // set. `--setpref=marionette.port=<n>` configures where the browser
     // listener binds; `--marionette=127.0.0.1:<n>` tells the mochitest harness
@@ -258,6 +240,14 @@ function appendMarionetteForwardingArgs(extraArgs, options, forwardedPort) {
     // `--marionette=...` (or two-token `--marionette host:port`).
     if (options.marionettePort === undefined)
         return;
+    if (xpcshellOnly) {
+        // Manifest classification says every requested path is xpcshell —
+        // xpcshell ignores the browser Marionette path entirely, and the
+        // mochitest client flags previously forwarded here made mach reject
+        // the dispatch (FORGE F10).
+        info(`--marionette-port=${options.marionettePort} applied to the preflight probe only: the requested paths are xpcshell-only, and xpcshell ignores the browser Marionette port. Not forwarding --setpref=marionette.port or --marionette to mach.`);
+        return;
+    }
     {
         const operatorAlreadyForwarded = forwardedPort !== undefined;
         const machArgs = options.machArg ?? [];
@@ -276,8 +266,23 @@ function appendMarionetteForwardingArgs(extraArgs, options, forwardedPort) {
         }
     }
 }
-async function ensureTestMarionettePortAvailable(port, binaryName, killStaleBrowser) {
-    if (killStaleBrowser) {
+async function ensureTestMarionettePortAvailable(port, binaryName, options, skip) {
+    if (skip.xpcshellOnly && !skip.doctor) {
+        // xpcshell does not bind the browser Marionette port, so a developer's
+        // interactive browser holding 2828 must not kill an xpcshell run
+        // (FORGE F10). --doctor keeps the preflight: its probe launches a
+        // Marionette browser regardless of the requested harness.
+        const message = 'Skipping the Marionette stale-port preflight: all requested paths are xpcshell ' +
+            '(xpcshell does not bind the browser Marionette port).';
+        if (options.marionettePort !== undefined || options.killStaleMarionette === true) {
+            info(message);
+        }
+        else {
+            verbose(message);
+        }
+        return;
+    }
+    if (options.killStaleMarionette === true) {
         await ensureMarionettePortAvailable(port, { binaryName, killStaleBrowser: true });
         return;
     }
@@ -321,6 +326,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // stale/coverage refusals keep precedence over missing-path errors.)
     const requestedPaths = canaryPath !== undefined ? [canaryPath] : testPaths;
     const normalizedPaths = requestedPaths.map((p) => stripEnginePrefix(p).trim());
+    const { classification, xpcshellOnly } = await classifyBeforeDispatch(paths.engine, normalizedPaths);
     // Run incremental build if requested
     if (options.build) {
         // A path-less `test --build` runs (and packages for) the full suite;
@@ -361,7 +367,10 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // generic bind failure. 2026-04-21 eval (Finding #20): a stale
     // `-marionette` process from `fresh/` poisoned a later test run in
     // the sibling `mybrowser/` workspace.
-    await ensureTestMarionettePortAvailable(effectivePort, projectConfig.binaryName, options.killStaleMarionette === true);
+    await ensureTestMarionettePortAvailable(effectivePort, projectConfig.binaryName, options, {
+        xpcshellOnly,
+        doctor: options.doctor === true,
+    });
     if (options.doctor) {
         const doctorOutcome = await runDoctorPreflight({
             engineDir: paths.engine,
@@ -375,10 +384,6 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
             return;
     }
     await assertTestPathsExist(paths.engine, normalizedPaths);
-    const classification = await classifyTestHarnesses(paths.engine, normalizedPaths);
-    if (classification.xpcshell.length > 0 && classification.nonXpcshell.length > 0) {
-        throw new GeneralError(buildMixedHarnessMessage(classification));
-    }
     const suite = resolveTestSuite(classification, options.genericMachTest === true);
     const forwardedMachArgs = options.machArg && options.machArg.length > 0
         ? filterRedundantXpcshellFlavorArgs(options.machArg, classification)
@@ -401,7 +406,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     if (forwardedMachArgs.length > 0) {
         extraArgs.push(...forwardedMachArgs);
     }
-    appendMarionetteForwardingArgs(extraArgs, options, forwardedPort);
+    appendMarionetteForwardingArgs(extraArgs, options, forwardedPort, xpcshellOnly);
     // Directory arguments mean EXACTLY that directory: mozbuild's test
     // resolver matches paths by string prefix, so a bare directory arg
     // silently swept in prefix-named siblings (152.0b7 → 153.0b8 drill:
@@ -437,6 +442,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
         suite,
         baseExtraArgs: extraArgs,
         harnessRetries,
+        headless: options.headless === true,
         ...(perfSampleEnv ? { env: perfSampleEnv } : {}),
     };
     const postRebuildContext = options.build
@@ -482,7 +488,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
         reportCanaryOutcome(outcome);
         return;
     }
-    finalizeSingleRunOutcome(outcome, normalizedPaths, projectConfig.binaryName, postRebuildContext);
+    finalizeSingleRunOutcome(outcome, normalizedPaths, projectConfig.binaryName, postRebuildContext, options.headless === true);
 }
 /**
  * Builds the perf-sample env contract for the harness run (field report

package/dist/src/core/build-baseline-types.d.ts

@@ -76,6 +76,13 @@ export interface BuildBaseline {
      * static-components stale check degrades to "fresh" in that case.
      */
     staticComponentsBaseline?: StaticComponentsBaseline;
+    /**
+     * Invocation shape that recorded this baseline (`'fireforge build'`,
+     * `'fireforge build --ui'`, `'fireforge test --build [paths]'`).
+     * Informational — surfaced by `fireforge status --test-coverage`.
+     * Missing on pre-0.39.0 baselines; render as "unknown".
+     */
+    recordedBy?: string;
 }
 /**
  * State of the engine at the last FULL build, as far as compiled-in XPCOM

package/dist/src/core/build-baseline.d.ts

@@ -48,4 +48,4 @@ export declare function readBuildBaseline(projectRoot: string): Promise<BuildBas
  *   does not rebake `components.conf` registrations, so the last FULL
  *   build stays the honest anchor for the compiled StaticComponents table.
  */
-export declare function writeBuildBaseline(projectRoot: string, engineDir: string, binaryName: string, testPackagingCoverage?: TestPackagingCoverage, previousBaseline?: BuildBaseline): Promise<void>;
+export declare function writeBuildBaseline(projectRoot: string, engineDir: string, binaryName: string, testPackagingCoverage?: TestPackagingCoverage, previousBaseline?: BuildBaseline, recordedBy?: string): Promise<void>;

package/dist/src/core/build-baseline.js

@@ -74,7 +74,7 @@ export async function readBuildBaseline(projectRoot) {
  *   does not rebake `components.conf` registrations, so the last FULL
  *   build stays the honest anchor for the compiled StaticComponents table.
  */
-export async function writeBuildBaseline(projectRoot, engineDir, binaryName, testPackagingCoverage, previousBaseline) {
+export async function writeBuildBaseline(projectRoot, engineDir, binaryName, testPackagingCoverage, previousBaseline, recordedBy) {
     let engineHeadSha = '';
     try {
         engineHeadSha = await getHead(engineDir);
@@ -103,6 +103,7 @@ export async function writeBuildBaseline(projectRoot, engineDir, binaryName, tes
         ...(packageableFingerprints !== undefined ? { packageableFingerprints } : {}),
         ...(testPackagingCoverage !== undefined ? { testPackagingCoverage } : {}),
         ...(staticComponentsBaseline !== undefined ? { staticComponentsBaseline } : {}),
+        ...(recordedBy !== undefined ? { recordedBy } : {}),
     };
     await writeJson(getBuildBaselinePath(projectRoot), baseline);
 }

package/dist/src/core/build-prepare.d.ts

@@ -24,6 +24,15 @@ export interface PrepareBuildOptions {
      */
     previousBaseline?: BuildBaseline | undefined;
 }
+/**
+ * Describes an exit code in the shell's 128+N signal convention. Truncated
+ * configure/build logs with a signal-shaped exit (e.g. 144 = 128+16, SIGURG
+ * on macOS) are environmental interruptions, not compiler failures — naming
+ * that in the failure text saves the operator a fruitless log hunt
+ * (FORGE F16). Returns undefined for codes <= 128 (regular failures) and
+ * for codes past the conventional signal range, so callers append nothing.
+ */
+export declare function describeSignalShapedExit(exitCode: number): string | undefined;
 /**
  * Returns true when the file path matches a pattern that forces
  * `mach configure` to regenerate the backend. Exported for testing.

package/dist/src/core/build-prepare.js

@@ -3,6 +3,7 @@
  * Shared pre-flight logic for build and package commands:
  * story cleanup, branding setup, Furnace component application, and mozconfig generation.
  */
+import { constants as osConstants } from 'node:os';
 import { BuildError } from '../errors/build.js';
 import { FurnaceError } from '../errors/furnace.js';
 import { toError } from '../utils/errors.js';
@@ -33,6 +34,27 @@ function extractMachConfigureError(result) {
         return '';
     return combined.split('\n').slice(-40).join('\n').trim();
 }
+/**
+ * Describes an exit code in the shell's 128+N signal convention. Truncated
+ * configure/build logs with a signal-shaped exit (e.g. 144 = 128+16, SIGURG
+ * on macOS) are environmental interruptions, not compiler failures — naming
+ * that in the failure text saves the operator a fruitless log hunt
+ * (FORGE F16). Returns undefined for codes <= 128 (regular failures) and
+ * for codes past the conventional signal range, so callers append nothing.
+ */
+export function describeSignalShapedExit(exitCode) {
+    if (exitCode <= 128 || exitCode > 192)
+        return undefined;
+    const signalNumber = exitCode - 128;
+    const names = Object.entries(osConstants.signals)
+        .filter(([, value]) => value === signalNumber)
+        .map(([name]) => name);
+    const label = names.length > 0 ? names.join('/') : `signal ${signalNumber}`;
+    return (`Exit ${exitCode} is signal-shaped (${exitCode} - 128 = ${signalNumber}, ${label} on this host): ` +
+        'the process was likely interrupted externally (OOM-killer, terminal disconnect, ' +
+        'display/session teardown) rather than failing on its own, and the log may be ' +
+        'truncated mid-step.');
+}
 /**
  * Builds the `BuildError` for a non-zero auto-configure exit: the output
  * tail (so the underlying mozbuild failure survives), any matched
@@ -43,8 +65,10 @@ function extractMachConfigureError(result) {
 function buildConfigureFailureError(captured) {
     const detail = extractMachConfigureError(captured);
     const hints = explainMachError(`${captured.stderr}\n${captured.stdout}`);
+    const signalNote = describeSignalShapedExit(captured.exitCode);
     return new BuildError(`Backend regeneration failed: mach configure exited with code ${captured.exitCode}.` +
         (detail ? `\n\nmach configure output (tail):\n${detail}` : '') +
+        (signalNote ? `\n\n${signalNote}` : '') +
         (hints.length > 0 ? `\n\n${hints.map((hint) => `Hint: ${hint}`).join('\n')}` : '') +
         '\n\nBuild stopped because continuing would hide the real configure failure.', 'mach configure');
 }

package/dist/src/core/config-validate.js

@@ -348,6 +348,10 @@ function parsePatchLintBlock(rec) {
     if (chromeScriptJsDoc !== undefined) {
         out.chromeScriptJsDoc = chromeScriptJsDoc;
     }
+    const undefinedIdentifiers = parseSeverityGate(rec.raw('undefinedIdentifiers'), 'patchLint.undefinedIdentifiers');
+    if (undefinedIdentifiers !== undefined) {
+        out.undefinedIdentifiers = undefinedIdentifiers;
+    }
     if (out.checkJsStrict === true && out.checkJs !== true) {
         throw new ConfigError('Config field "patchLint.checkJsStrict" requires "patchLint.checkJs": true');
     }
@@ -413,6 +417,10 @@ function parseTypecheckBlock(rec) {
     if (overrides) {
         out.projectOverrides = overrides;
     }
+    const undefinedIdentifiers = parseSeverityGate(rec.raw('undefinedIdentifiers'), 'typecheck.undefinedIdentifiers');
+    if (undefinedIdentifiers !== undefined) {
+        out.undefinedIdentifiers = undefinedIdentifiers;
+    }
     return out;
 }
 /**

package/dist/src/core/discard-baseline.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Patch-aware restore planning for `fireforge discard` (FORGE F1, P0).
+ *
+ * The engine convention is: HEAD = pristine upstream Firefox, and the
+ * applied patch queue lives as UNCOMMITTED worktree changes on top of it
+ * (`git apply` without `--index` → patch-edited tracked files are unstaged
+ * modifications, patch-created files are untracked). The pre-0.39.0
+ * `discard` was purely git-mechanical — it restored to HEAD and deleted
+ * untracked files, silently reverting patch-backed files PAST their owning
+ * patch and deleting patch-created files outright.
+ *
+ * This module classifies each status entry against the patch manifest's
+ * ownership claims and plans the correct restore target: the PATCH-APPLIED
+ * baseline (HEAD content folded through every affecting patch in order) for
+ * claimed files, and the legacy git mechanics for unmanaged ones.
+ */
+import type { GitStatusEntry } from './git-base.js';
+/** How one status entry's canonical path will be restored. */
+export type DiscardKind = 'unmanaged' | 'patch-backed' | 'patch-created' | 'patch-deleted';
+/** Restore plan for one git status entry. */
+export interface DiscardBaselinePlan {
+    entry: GitStatusEntry;
+    kind: DiscardKind;
+    /** Claiming patch filenames for `entry.file` ∪ `entry.originalPath`. */
+    owners: string[];
+    /** True when more than one patch claims the path (ownership conflict). */
+    conflicted: boolean;
+    /** Baseline content for `entry.file`; null = absent at baseline. Unset for 'unmanaged'. */
+    expectedContent?: string | null;
+    /** Rename/copy only: baseline content for `originalPath` when that side is claimed. */
+    expectedOriginalContent?: string | null;
+}
+/** Builds an all-unmanaged plan set — the `--to-upstream` (legacy) shape. */
+export declare function planUpstreamDiscards(entries: readonly GitStatusEntry[]): DiscardBaselinePlan[];
+/**
+ * Plans the restore target for each status entry. Entries claimed by the
+ * patch manifest restore to the patch-applied baseline; unclaimed entries
+ * keep the legacy git mechanics. A missing patches dir or empty manifest
+ * degrades every plan to `unmanaged` (identical to pre-0.39.0 behavior).
+ *
+ * A corrupt manifest or an unreconstructible patch baseline REFUSES with a
+ * GeneralError naming `--to-upstream` — silently falling back to pristine
+ * HEAD is exactly the data-loss path this module exists to close.
+ */
+export declare function planDiscardBaselines(patchesDir: string, engineDir: string, entries: readonly GitStatusEntry[]): Promise<DiscardBaselinePlan[]>;
+/**
+ * Applies one restore plan. Patch-claimed paths end up exactly as `import`
+ * leaves them: patched content as an unstaged worktree state (tracked files
+ * read ` M`, created files `??`), nothing staged. Unmanaged plans delegate
+ * to the legacy {@link discardStatusEntry} mechanics.
+ */
+export declare function applyDiscardBaseline(engineDir: string, plan: DiscardBaselinePlan): Promise<void>;
+/** One-line annotation for dry-run listings and confirmation summaries. */
+export declare function describeDiscardBaseline(plan: DiscardBaselinePlan): string;
+/** Single-file outro naming the baseline that was restored. */
+export declare function describeDiscardOutcome(plan: DiscardBaselinePlan, toUpstream: boolean): string;
+/** Batch outro summarising how many files restored to which baseline. */
+export declare function summarizeDiscardBaselines(plans: readonly DiscardBaselinePlan[], succeeded: number): string;
+/** Warn text for a multi-owner (conflicted) restore. */
+export declare function describeConflictWarning(plan: DiscardBaselinePlan): string;

package/dist/src/core/discard-baseline.js

@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Patch-aware restore planning for `fireforge discard` (FORGE F1, P0).
+ *
+ * The engine convention is: HEAD = pristine upstream Firefox, and the
+ * applied patch queue lives as UNCOMMITTED worktree changes on top of it
+ * (`git apply` without `--index` → patch-edited tracked files are unstaged
+ * modifications, patch-created files are untracked). The pre-0.39.0
+ * `discard` was purely git-mechanical — it restored to HEAD and deleted
+ * untracked files, silently reverting patch-backed files PAST their owning
+ * patch and deleting patch-created files outright.
+ *
+ * This module classifies each status entry against the patch manifest's
+ * ownership claims and plans the correct restore target: the PATCH-APPLIED
+ * baseline (HEAD content folded through every affecting patch in order) for
+ * claimed files, and the legacy git mechanics for unmanaged ones.
+ */
+import { join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { toError } from '../utils/errors.js';
+import { readText, removeFile, writeText } from '../utils/fs.js';
+import { discardStatusEntry, fileExistsInHead, listTrackedInHead, restoreTrackedPath, unstageFiles, } from './git-file-ops.js';
+import { createPatchedContentComputer } from './patch-apply.js';
+import { loadPatchesManifestState } from './patch-manifest-io.js';
+import { parseDiffSections } from './patch-parse.js';
+import { buildPatchClaims } from './status-classify.js';
+/** Builds an all-unmanaged plan set — the `--to-upstream` (legacy) shape. */
+export function planUpstreamDiscards(entries) {
+    return entries.map((entry) => ({ entry, kind: 'unmanaged', owners: [], conflicted: false }));
+}
+/**
+ * Plans the restore target for each status entry. Entries claimed by the
+ * patch manifest restore to the patch-applied baseline; unclaimed entries
+ * keep the legacy git mechanics. A missing patches dir or empty manifest
+ * degrades every plan to `unmanaged` (identical to pre-0.39.0 behavior).
+ *
+ * A corrupt manifest or an unreconstructible patch baseline REFUSES with a
+ * GeneralError naming `--to-upstream` — silently falling back to pristine
+ * HEAD is exactly the data-loss path this module exists to close.
+ */
+export async function planDiscardBaselines(patchesDir, engineDir, entries) {
+    const state = await loadPatchesManifestState(patchesDir);
+    if (state.exists && state.parseError) {
+        throw new GeneralError('patches/patches.json is unreadable — refusing to discard while patch ownership cannot be ' +
+            'determined. Fix the manifest, or pass --to-upstream to explicitly revert to pristine ' +
+            'upstream (HEAD).');
+    }
+    const claims = state.manifest
+        ? buildPatchClaims(state.manifest.patches)
+        : new Map();
+    const plans = [];
+    const claimedEntries = entries.filter((entry) => claims.has(entry.file) || (entry.originalPath !== undefined && claims.has(entry.originalPath)));
+    if (claimedEntries.length === 0) {
+        return planUpstreamDiscards(entries);
+    }
+    const computePatched = await createPatchedContentComputer(patchesDir, engineDir);
+    const claimedFiles = [
+        ...new Set(claimedEntries.flatMap((entry) => entry.originalPath !== undefined ? [entry.file, entry.originalPath] : [entry.file])),
+    ];
+    const trackedInHead = await listTrackedInHead(engineDir, claimedFiles);
+    const computeExpected = async (path) => {
+        try {
+            return await computePatched(path);
+        }
+        catch (error) {
+            throw new GeneralError(`Cannot reconstruct the patch baseline for ${path} (${toError(error).message}). ` +
+                'Fix the owning patch, or pass --to-upstream to explicitly revert to pristine ' +
+                'upstream (HEAD).');
+        }
+    };
+    // `computePatchedContent` folds a deletion into an empty string (an
+    // apply-to-content limitation), which is indistinguishable from a
+    // legitimately empty file. Consult the owning patches' diff sections
+    // directly: the LAST section (highest-ordered owner) naming the path
+    // decides whether the baseline is "absent".
+    const sectionCache = new Map();
+    const isDeletedAtBaseline = async (path, owners) => {
+        for (let i = owners.length - 1; i >= 0; i--) {
+            const owner = owners[i];
+            if (owner === undefined)
+                continue;
+            let sections = sectionCache.get(owner);
+            if (!sections) {
+                try {
+                    sections = parseDiffSections(await readText(join(patchesDir, owner)));
+                }
+                catch {
+                    sections = [];
+                }
+                sectionCache.set(owner, sections);
+            }
+            for (const section of sections) {
+                if (section.targetPath === path || section.sourcePath === path) {
+                    return section.isDeletedFile;
+                }
+            }
+        }
+        return false;
+    };
+    for (const entry of entries) {
+        const owners = [
+            ...new Set([
+                ...(claims.get(entry.file) ?? []),
+                ...(entry.originalPath !== undefined ? (claims.get(entry.originalPath) ?? []) : []),
+            ]),
+        ];
+        if (owners.length === 0) {
+            plans.push({ entry, kind: 'unmanaged', owners, conflicted: false });
+            continue;
+        }
+        let expectedContent = claims.has(entry.file) ? await computeExpected(entry.file) : null;
+        if (expectedContent !== null &&
+            (await isDeletedAtBaseline(entry.file, claims.get(entry.file) ?? []))) {
+            expectedContent = null;
+        }
+        const expectedOriginalContent = entry.originalPath !== undefined && claims.has(entry.originalPath)
+            ? await computeExpected(entry.originalPath)
+            : undefined;
+        const kind = expectedContent === null
+            ? 'patch-deleted'
+            : trackedInHead.has(entry.file)
+                ? 'patch-backed'
+                : 'patch-created';
+        plans.push({
+            entry,
+            kind,
+            owners,
+            conflicted: owners.length > 1,
+            expectedContent,
+            ...(expectedOriginalContent !== undefined ? { expectedOriginalContent } : {}),
+        });
+    }
+    return plans;
+}
+/**
+ * Applies one restore plan. Patch-claimed paths end up exactly as `import`
+ * leaves them: patched content as an unstaged worktree state (tracked files
+ * read ` M`, created files `??`), nothing staged. Unmanaged plans delegate
+ * to the legacy {@link discardStatusEntry} mechanics.
+ */
+export async function applyDiscardBaseline(engineDir, plan) {
+    if (plan.kind === 'unmanaged') {
+        await discardStatusEntry(engineDir, plan.entry);
+        return;
+    }
+    const { entry } = plan;
+    // Drop any staged edits/adds/renames first so the rewritten content is a
+    // plain worktree state (harmless when nothing is staged; skipped for
+    // purely-untracked entries which have no index footprint).
+    if (!entry.isUntracked) {
+        const indexPaths = entry.originalPath !== undefined ? [entry.file, entry.originalPath] : [entry.file];
+        await unstageFiles(engineDir, indexPaths);
+    }
+    if (plan.expectedContent === null || plan.expectedContent === undefined) {
+        await removeFile(join(engineDir, entry.file));
+    }
+    else {
+        await writeText(join(engineDir, entry.file), plan.expectedContent);
+    }
+    // A rename/copy's original side restores to ITS baseline too: the patch
+    // baseline when claimed, else the legacy HEAD restore (matching what
+    // discardStatusEntry does for that side).
+    if (entry.originalPath !== undefined) {
+        if (plan.expectedOriginalContent !== undefined) {
+            if (plan.expectedOriginalContent === null) {
+                await removeFile(join(engineDir, entry.originalPath));
+            }
+            else {
+                await writeText(join(engineDir, entry.originalPath), plan.expectedOriginalContent);
+            }
+        }
+        else if (await fileExistsInHead(engineDir, entry.originalPath)) {
+            await restoreTrackedPath(engineDir, entry.originalPath);
+        }
+    }
+}
+/** One-line annotation for dry-run listings and confirmation summaries. */
+export function describeDiscardBaseline(plan) {
+    const owners = plan.owners.join(' + ');
+    switch (plan.kind) {
+        case 'unmanaged':
+            return plan.entry.isUntracked ? 'unmanaged — delete' : 'unmanaged — revert to upstream';
+        case 'patch-backed':
+            return `patch baseline: ${owners}${plan.conflicted ? ' (conflict)' : ''}`;
+        case 'patch-created':
+            return `re-materialize from ${owners}${plan.conflicted ? ' (conflict)' : ''}`;
+        case 'patch-deleted':
+            return `delete — ${owners} removes it`;
+    }
+}
+/** Single-file outro naming the baseline that was restored. */
+export function describeDiscardOutcome(plan, toUpstream) {
+    if (toUpstream)
+        return 'File restored to pristine upstream (HEAD)';
+    const owners = plan.owners.join(' + ');
+    switch (plan.kind) {
+        case 'unmanaged':
+            return 'File restored to original state';
+        case 'patch-backed':
+            return `File restored to patch baseline (${owners})`;
+        case 'patch-created':
+            return `File re-materialized from patch baseline (${owners})`;
+        case 'patch-deleted':
+            return `File removed to match patch baseline (${owners} deletes it)`;
+    }
+}
+/** Batch outro summarising how many files restored to which baseline. */
+export function summarizeDiscardBaselines(plans, succeeded) {
+    const patchBacked = plans.filter((p) => p.kind === 'patch-backed').length;
+    const created = plans.filter((p) => p.kind === 'patch-created').length;
+    const deleted = plans.filter((p) => p.kind === 'patch-deleted').length;
+    const unmanaged = plans.filter((p) => p.kind === 'unmanaged').length;
+    if (patchBacked + created + deleted === 0) {
+        return `${String(succeeded)} file(s) restored to upstream state`;
+    }
+    const parts = [];
+    if (patchBacked > 0)
+        parts.push(`${String(patchBacked)} to patch baseline`);
+    if (created > 0)
+        parts.push(`${String(created)} re-materialized`);
+    if (deleted > 0)
+        parts.push(`${String(deleted)} removed per patch baseline`);
+    if (unmanaged > 0)
+        parts.push(`${String(unmanaged)} to upstream state`);
+    return `${String(succeeded)} file(s) restored: ${parts.join(', ')}`;
+}
+/** Warn text for a multi-owner (conflicted) restore. */
+export function describeConflictWarning(plan) {
+    return (`${plan.entry.file} is claimed by ${String(plan.owners.length)} patches ` +
+        `(${plan.owners.join(', ')}). Restored the cumulative baseline; run ` +
+        '"fireforge status --ownership" to resolve ownership.');
+}

package/dist/src/core/license-headers.d.ts

@@ -81,6 +81,18 @@ export declare function hasAnyLicenseHeaderAnyStyle(content: string): boolean;
  * @param maxLines - Number of leading lines to inspect (default 10)
  */
 export declare function containsUpstreamLicenseText(content: string, maxLines?: number): boolean;
+/**
+ * Returns true when the head of `content` carries a recognized THIRD-PARTY
+ * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0), in any
+ * comment style. Used by `export` to treat such files as vendored: offering
+ * to prepend the project's own license header onto a byte-identity-pinned
+ * upstream bundle would mislicense third-party code (FORGE F15).
+ *
+ * @param content  - File content to check
+ * @param maxLines - Number of leading lines to inspect (default 30 — full
+ *   MIT/BSD license texts run longer than the 10-line project-header scan)
+ */
+export declare function hasThirdPartyPermissiveBanner(content: string, maxLines?: number): boolean;
 /**
  * Prepends the license header to a file on disk if it is not already present.
  *

package/dist/src/core/license-headers.js

@@ -252,6 +252,33 @@ export function containsUpstreamLicenseText(content, maxLines = 10) {
     ];
     return markers.some((marker) => scanText.includes(marker));
 }
+/**
+ * Returns true when the head of `content` carries a recognized THIRD-PARTY
+ * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0), in any
+ * comment style. Used by `export` to treat such files as vendored: offering
+ * to prepend the project's own license header onto a byte-identity-pinned
+ * upstream bundle would mislicense third-party code (FORGE F15).
+ *
+ * @param content  - File content to check
+ * @param maxLines - Number of leading lines to inspect (default 30 — full
+ *   MIT/BSD license texts run longer than the 10-line project-header scan)
+ */
+export function hasThirdPartyPermissiveBanner(content, maxLines = 30) {
+    const head = content.split('\n').slice(0, maxLines).join('\n');
+    const scanText = normalizeLicenseHeadForScan(head).toLowerCase();
+    const markers = [
+        'mit license',
+        'permission is hereby granted, free of charge',
+        'isc license',
+        'permission to use, copy, modify',
+        'redistribution and use in source and binary forms',
+        'apache license',
+        'licensed under the apache license',
+    ];
+    if (markers.some((marker) => scanText.includes(marker)))
+        return true;
+    return /spdx-license-identifier:\s*(mit|isc|bsd-2-clause|bsd-3-clause|apache-2\.0)\b/.test(scanText);
+}
 /**
  * Prepends the license header to a file on disk if it is not already present.
  *

package/dist/src/core/patch-export.d.ts

@@ -30,7 +30,16 @@ export declare function sanitizeName(name: string): string;
  * double-prefix incident) also collapses. Exported for direct testing.
  */
 export declare function stripRedundantCategoryPrefix(sanitizedName: string, category: string): string;
-/** Sanitizes a patch name and drops redundant category/full-stem prefixes. */
+/**
+ * Sanitizes a patch name and drops redundant category/full-stem prefixes.
+ *
+ * A single trailing `.patch` extension is stripped before sanitisation:
+ * operators frequently pass a full patch FILENAME where a name is expected
+ * (`move-files <from> 348-ui-foo.patch --create`, `rename --to foo.patch`),
+ * and 0.38.0 slugged the extension into `-patch`, producing double-suffixed
+ * `...-patch.patch` files. A name that deliberately ends in a literal
+ * `-patch` slug segment must now be written without the dot form.
+ */
 export declare function patchNameSlug(name: string, category: string): string;
 /**
  * Generates the next patch filename with category.