@hominis/fireforge 0.43.1 → 0.44.0

package/dist/src/commands/build.js

@@ -5,14 +5,15 @@ import { auditBuildArtifacts } from '../core/build-audit.js';
 import { readBuildBaseline, writeBuildBaseline } from '../core/build-baseline.js';
 import { describeSignalShapedExit, prepareBuildEnvironment } from '../core/build-prepare.js';
 import { getProjectPaths, loadConfig } from '../core/config.js';
+import { assertEngineExists } from '../core/engine-precondition.js';
 import { withEngineSessionLock } from '../core/engine-session-lock.js';
 import { attemptMozinfoRewrite, build, buildArtifactMismatchMessage, buildUI, hasBuildArtifacts, hasRunnableBundle, runMach, withBuildLock, } from '../core/mach.js';
 import { buildHarnessCrashMessage } from '../core/test-harness-crash.js';
 import { formatToolchainMismatchMessage, runToolchainPreflight, } from '../core/toolchain-preflight.js';
-import { GeneralError } from '../errors/base.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { toError } from '../utils/errors.js';
-import { checkDiskSpace, pathExists } from '../utils/fs.js';
+import { checkDiskSpace } from '../utils/fs.js';
 import { error, info, intro, outro, spinner, verbose, warn } from '../utils/logger.js';
 import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../utils/options.js';
 import { isPositiveInteger } from '../utils/validation.js';
@@ -68,7 +69,7 @@ function resolveJobCount(options, configJobs) {
         return undefined;
     }
     if (!isPositiveInteger(jobs)) {
-        throw new GeneralError('Build jobs must be a positive integer');
+        throw new InvalidArgumentError('Build jobs must be a positive integer', '--jobs');
     }
     return jobs;
 }
@@ -176,16 +177,13 @@ export async function buildCommand(projectRoot, options) {
     // Disk space pre-flight: a full Firefox build can be ~20 GB
     await checkDiskSpace(projectRoot, 20 * 1024 * 1024 * 1024, warn);
     // Check if engine exists
-    if (!(await pathExists(paths.engine))) {
-        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
-    }
+    await assertEngineExists(paths.engine);
     // Toolchain preflight: compare the minimums the tree itself declares
-    // (cbindgen / rust) against the host binaries mach configure will
-    // resolve, and fail fast naming `fireforge bootstrap` instead of dying
-    // ~8s into configure with mach's "./mach bootstrap" remediation text
-    // (152.0b7 → 153.0b8 source-refresh drill). Fail-soft by design: only
-    // a definitively parsed minimum vs a definitively probed host version
-    // can fail here; anything uncertain proceeds to mach, where the
+    // (cbindgen / rust) against the host binaries mach configure will resolve,
+    // and fail fast naming `fireforge bootstrap` instead of dying ~8s into
+    // configure with mach's "./mach bootstrap" remediation text. Fail-soft by
+    // design: only a definitively parsed minimum vs a definitively probed host
+    // version can fail here; anything uncertain proceeds to mach, where the
     // mach-error-hints translator still names the right remedy.
     const toolchainMismatches = await runToolchainPreflight(paths.engine);
     if (toolchainMismatches.length > 0) {
@@ -257,13 +255,12 @@ export async function buildCommand(projectRoot, options) {
     try {
         // Hold the per-project build lock across the mach invocation so two
         // overlapping `fireforge build` / `fireforge build --ui` commands
-        // against the same engine tree serialise instead of racing through
-        // the same obj-*. 2026-04-21 eval: a `build --ui` launched during
-        // an in-progress full build hit `No rule to make target 'XUL'` in
-        // mach, which is the downstream consequence of an incomplete
-        // backend — not a clue that a concurrent build was the cause. The
-        // lock turns the second invocation's failure into an explicit
-        // refusal naming the holder PID.
+        // against the same engine tree serialise instead of racing through the
+        // same obj-*. A `build --ui` launched during an in-progress full build
+        // otherwise hits `No rule to make target 'XUL'` in mach — the
+        // downstream consequence of an incomplete backend, with no clue that a
+        // concurrent build caused it. The lock turns the second invocation's
+        // failure into an explicit refusal naming the holder PID.
         result = await withBuildLock(projectRoot, async () => {
             if (options.ui) {
                 return buildUI(paths.engine);
@@ -290,24 +287,20 @@ export async function buildCommand(projectRoot, options) {
             : '';
         throw new BuildError(crashPreamble + buildFailureDiagnostics(result, paths.engine, buildCheck.objDir, machCommand), machCommand);
     }
-    // Tool-managed branding edits that land on `browser/moz.configure`
-    // before the build cause mach's post-build guard to print one of two
-    // banners that read like build failures even though the build
-    // completed cleanly:
+    // Tool-managed branding edits that land on `browser/moz.configure` before
+    // the build cause mach's post-build guard to print one of two banners that
+    // read like build failures even though the build completed cleanly:
     //
     //   1) "config.status is out of date with respect to ..."
     //   2) "Config object not found by mach. / Configure complete! /
     //      Be sure to run |mach build| to pick up any changes."
     //
-    // 2026-04-21 eval covered (1); 2026-04-26 eval Finding 8 reproduced
-    // (2) on a successful build. The pre-fix pattern only matched (1),
-    // so operators on the (2) path saw mach's own "Configure complete!"
-    // and "run |mach build|" lines unexplained between mach's
-    // "Your build was successful!" and FireForge's own "Build completed
-    // in Xm Ys" outro — a contradictory tail. Both shapes now route
-    // through the same annotation, emitted BEFORE FireForge's outro so
-    // the operator's last terminal line is the explanation, not the
-    // confusing mach guard text.
+    // Matching only (1) leaves operators on the (2) path seeing mach's own
+    // "Configure complete!" and "run |mach build|" lines unexplained between
+    // mach's "Your build was successful!" and FireForge's "Build completed in
+    // Xm Ys" outro — a contradictory tail. Both shapes route through the same
+    // annotation, emitted BEFORE FireForge's outro so the operator's last
+    // terminal line is the explanation, not the confusing mach guard text.
     const staleConfigurePatterns = [
         /config\.status is out of date/i,
         /Config object not found by mach\.[\s\S]*Configure complete!/i,

package/dist/src/commands/config.js

@@ -91,10 +91,10 @@ export async function configCommand(projectRoot, key, value, options = {}) {
     if (value === undefined) {
         // Get mode — read the raw document rather than the validated config so
         // keys persisted via `fireforge config <key> --force` remain readable.
-        // `validateConfig` builds a typed clone containing only the known
-        // schema fields; relying on it here would silently hide forced-write
-        // keys and surface "Unknown config key" on the read even though the
-        // key is sitting plainly inside fireforge.json.
+        // `validateConfig` builds a typed clone containing only the known schema
+        // fields, so relying on it here would hide forced-write keys and surface
+        // "Unknown config key" even though the key sits plainly inside
+        // fireforge.json.
         const rawConfig = await loadRawConfigDocument(projectRoot);
         const currentValue = getNestedValue(rawConfig, key);
         if (currentValue === undefined) {
@@ -124,43 +124,36 @@ export async function configCommand(projectRoot, key, value, options = {}) {
         let unchanged;
         try {
             // Serialise the read → mutate → write round-trip behind the sidecar
-            // config lock so two concurrent `fireforge config` invocations can't
+            // config lock so two concurrent `fireforge config` invocations cannot
             // each read the pre-state, mutate their own copy, and clobber each
-            // other on write. Before the lock, the 2026-04-21 eval reproduced
-            // silent data loss with two parallel `fireforge config <key>
-            // <value>` commands writing different keys: both exited 0, one key
-            // survived, the other vanished. Atomic file writes (temp + rename)
-            // were never enough on their own — the lost update happens before
-            // the rename, inside the read-modify step. Readers stay lock-free
-            // (see `withConfigFileLock` docstring).
+            // other on write — both exiting 0 with one key silently lost. Atomic
+            // file writes (temp + rename) are not enough on their own: the lost
+            // update happens before the rename, inside the read-modify step.
+            // Readers stay lock-free (see `withConfigFileLock`).
             unchanged = await withConfigFileLock(projectRoot, async () => {
-                // 2026-04-26 eval Finding 11: short-circuit when the new value
-                // matches the current on-disk value. Pre-fix, every set ran
-                // through `mutateConfig` + `writeConfig`, which round-trips
-                // through `JSON.stringify` and rewrites the file even when no
-                // semantic change happened — the rewrite reorders top-level
-                // keys (`license`, `markerComment`, etc.) on every harmless
-                // re-set, producing diff churn for no reason. The check uses
-                // the raw on-disk document so forced-keys round-trip the same
-                // as known keys.
+                // Short-circuit when the new value matches the current on-disk
+                // value. Running every set through `mutateConfig` + `writeConfig`
+                // round-trips through `JSON.stringify` and rewrites the file even
+                // when nothing changed semantically, reordering top-level keys
+                // (`license`, `markerComment`, …) on every harmless re-set. The
+                // check uses the raw on-disk document so forced keys round-trip the
+                // same as known keys.
                 const rawConfig = await loadRawConfigDocument(projectRoot);
                 const currentValue = getNestedValue(rawConfig, key);
                 if (deepEqual(currentValue, parsedValue)) {
                     return true;
                 }
-                // `--force` is intended as an escape hatch for *unknown* keys; it
-                // should not also let the user write a structurally invalid value
-                // for a *known* key. Apply strict validation whenever the key is
-                // listed in SUPPORTED_CONFIG_PATHS, regardless of --force, and only
-                // skip validation for genuinely unknown key paths.
+                // `--force` is an escape hatch for *unknown* keys; it must not also
+                // let the user write a structurally invalid value for a *known* key.
+                // Strict validation applies whenever the key is listed in
+                // SUPPORTED_CONFIG_PATHS, regardless of --force.
                 //
                 // BOTH branches seed the mutation from the raw on-disk document.
-                // The known-key branch used to round-trip through `loadConfig` →
-                // `validateConfig`, which builds a typed clone containing only the
-                // known schema fields — so any ordinary `fireforge config <key>
-                // <value>` silently dropped every previously --force-written key
-                // from fireforge.json (2026-07-05 review, finding H4; the --force
-                // branch's comment described this exact hazard for its own path).
+                // Round-tripping the known-key branch through `loadConfig` →
+                // `validateConfig` builds a typed clone containing only the known
+                // schema fields, so any ordinary `fireforge config <key> <value>`
+                // would silently drop every previously --force-written key from
+                // fireforge.json.
                 if (options.force && !keyIsKnown) {
                     const updatedConfig = mutateConfig(rawConfig, key, parsedValue, true);
                     await writeConfigDocument(projectRoot, updatedConfig);
@@ -181,10 +174,10 @@ export async function configCommand(projectRoot, key, value, options = {}) {
         catch (error) {
             // Only value/validation problems are the user's "invalid value".
             // Lock-acquisition timeouts and I/O failures must keep their own
-            // types/messages — re-labelling a lock timeout as `Invalid value for
-            // "<key>"` used to point diagnosis at the value (and return the
-            // wrong exit-code class) when the actual problem was a concurrent
-            // fireforge process holding the config lock.
+            // types and messages — re-labelling a lock timeout as `Invalid value
+            // for "<key>"` points diagnosis at the value (and returns the wrong
+            // exit-code class) when the real problem is a concurrent fireforge
+            // process holding the config lock.
             if (error instanceof ConfigError) {
                 throw new InvalidArgumentError(`Invalid value for "${key}": ${toError(error).message}`, key);
             }
@@ -200,11 +193,11 @@ export async function configCommand(projectRoot, key, value, options = {}) {
     outro('');
 }
 /**
- * Structural equality check covering the shapes that
- * `fireforge config` accepts: primitives (strings, numbers, booleans),
- * `null`, arrays of primitives, and nested objects. Used to short-circuit
- * no-op writes (Finding 11) — when the parsed value matches the current
- * on-disk value, skip the mutate + write step entirely.
+ * Structural equality check covering the shapes `fireforge config` accepts:
+ * primitives (strings, numbers, booleans), `null`, arrays of primitives, and
+ * nested objects. Used to short-circuit no-op writes — when the parsed value
+ * matches the current on-disk value, the mutate + write step is skipped
+ * entirely.
  */
 function deepEqual(a, b) {
     if (a === b)

package/dist/src/commands/discard.js

@@ -2,6 +2,7 @@
 import { confirm } from '@clack/prompts';
 import { Command } from 'commander';
 import { getProjectPaths } from '../core/config.js';
+import { stdioIsInteractive } from '../core/destructive.js';
 import { applyDiscardBaseline, describeConflictWarning, describeDiscardBaseline, describeDiscardOutcome, planDiscardBaselines, planUpstreamDiscards, summarizeDiscardBaselines, } from '../core/discard-baseline.js';
 import { assertEngineGitReady } from '../core/engine-precondition.js';
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
@@ -18,7 +19,7 @@ import { pickDefined } from '../utils/options.js';
 async function confirmDiscard(message, hint, options) {
     if (options.yes || options.dryRun)
         return true;
-    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    const isInteractive = stdioIsInteractive();
     if (!isInteractive) {
         throw new InvalidArgumentError('Interactive confirmation not available. Use --yes flag to discard without confirmation.', hint);
     }
@@ -130,14 +131,12 @@ export async function discardCommand(projectRoot, file, options = {}) {
     const statusEntries = await expandUntrackedDirectoryEntries(paths.engine, await getWorkingTreeStatus(paths.engine));
     const statusEntry = statusEntries.find((entry) => entry.file === file || entry.originalPath === file);
     // Directory recursion fallback: when the explicit path does not match a
-    // single status entry but DOES correspond to one or more entries below
-    // it, treat the input as a directory and discard everything inside.
-    // 2026-04-25 eval Finding 20: `discard browser/components/storybook/
-    // stories/furnace --yes` failed with "no changes to discard" even
-    // though `status --unmanaged` listed 23 files under that directory —
-    // operators were forced to discard each file individually or fall
-    // back to non-FireForge cleanup commands. Match against the
-    // directory-with-trailing-slash form so a path like `foo/bar` doesn't
+    // single status entry but DOES correspond to one or more entries below it,
+    // treat the input as a directory and discard everything inside. Otherwise
+    // `discard <dir> --yes` fails with "no changes to discard" even though
+    // `status --unmanaged` lists files under that directory, forcing the
+    // operator to discard each file individually. Match against the
+    // directory-with-trailing-slash form so a path like `foo/bar` does not
     // accidentally match `foo/bar2/file`.
     if (!statusEntry) {
         // Normalize the operator's input once: `discard foo/` (or `foo//`) must

package/dist/src/commands/doctor-check-core.d.ts

@@ -88,29 +88,15 @@ export interface DoctorCheckDefinition {
     fix?: string;
 }
 /**
- * Resolves a {@link DoctorCheck} to its effective severity, implementing the
- * field-precedence contract documented on the interface
- * (`src/types/commands/project.ts`):
- *
- *   1. `severity`, when present, is authoritative — regardless of `passed`.
- *   2. Without `severity`, `passed: false` is an error unless `warning: true`
- *      downgrades it to a warning.
- *
- * This is the single implementation on purpose. Before 0.41.0 there were two
- * and they disagreed on exactly one cell: `reportDoctorResults` consulted
- * `warning` only inside the `passed === true` branch, so the documented
- * downgrade produced an error and a non-zero doctor exit, while
- * `bootstrap.ts` — reading the same array one line earlier — classified it as
- * a warning. No in-tree producer emitted that combination (`failure()` always
- * sets `severity: 'error'`), so the contradiction was latent rather than
- * observable; the interface is exported, so the next hand-rolled check would
- * have hit it.
+ * Resolves a {@link DoctorCheck} to its effective severity. `severity` is the
+ * single source of truth; this exists so every consumer of a
+ * `DoctorCheck[]` reads it the same way.
  */
 export declare function resolveDoctorSeverity(check: DoctorCheck): 'ok' | 'warning' | 'error';
 /**
  * Builds a DoctorCheck object representing a successful "OK" check.
  */
-export declare function ok(name: string): DoctorCheck;
+export declare function ok(name: string, message?: string): DoctorCheck;
 /**
  * Builds a DoctorCheck object representing a warning result.
  */

package/dist/src/commands/doctor-check-core.js

@@ -5,55 +5,28 @@
  * these symbols without creating cycles through `doctor.ts`.
  */
 /**
- * Resolves a {@link DoctorCheck} to its effective severity, implementing the
- * field-precedence contract documented on the interface
- * (`src/types/commands/project.ts`):
- *
- *   1. `severity`, when present, is authoritative — regardless of `passed`.
- *   2. Without `severity`, `passed: false` is an error unless `warning: true`
- *      downgrades it to a warning.
- *
- * This is the single implementation on purpose. Before 0.41.0 there were two
- * and they disagreed on exactly one cell: `reportDoctorResults` consulted
- * `warning` only inside the `passed === true` branch, so the documented
- * downgrade produced an error and a non-zero doctor exit, while
- * `bootstrap.ts` — reading the same array one line earlier — classified it as
- * a warning. No in-tree producer emitted that combination (`failure()` always
- * sets `severity: 'error'`), so the contradiction was latent rather than
- * observable; the interface is exported, so the next hand-rolled check would
- * have hit it.
+ * Resolves a {@link DoctorCheck} to its effective severity. `severity` is the
+ * single source of truth; this exists so every consumer of a
+ * `DoctorCheck[]` reads it the same way.
  */
 export function resolveDoctorSeverity(check) {
-    if (check.severity !== undefined) {
-        return check.severity;
-    }
-    if (check.warning) {
-        return 'warning';
-    }
-    return check.passed ? 'ok' : 'error';
+    return check.severity;
 }
 /**
  * Builds a DoctorCheck object representing a successful "OK" check.
  */
-export function ok(name) {
-    return { name, passed: true, severity: 'ok', message: 'OK' };
+export function ok(name, message = 'OK') {
+    return { name, severity: 'ok', message };
 }
 /**
  * Builds a DoctorCheck object representing a warning result.
  */
 export function warning(name, message, fix) {
-    return {
-        name,
-        passed: true,
-        severity: 'warning',
-        warning: true,
-        message,
-        ...(fix ? { fix } : {}),
-    };
+    return { name, severity: 'warning', message, ...(fix ? { fix } : {}) };
 }
 /**
  * Builds a DoctorCheck object representing a failure result.
  */
 export function failure(name, message, fix) {
-    return { name, passed: false, severity: 'error', message, ...(fix ? { fix } : {}) };
+    return { name, severity: 'error', message, ...(fix ? { fix } : {}) };
 }

package/dist/src/commands/doctor-external-toolchains.js

@@ -2,7 +2,7 @@
 import { isAbsolute, resolve } from 'node:path';
 import { pathExists } from '../utils/fs.js';
 import { exec, findExecutable } from '../utils/process.js';
-import { failure, warning } from './doctor-check-core.js';
+import { failure, ok, warning } from './doctor-check-core.js';
 async function resolveDeclaredTool(projectRoot, tool) {
     if (tool.path !== undefined) {
         const candidate = isAbsolute(tool.path) ? tool.path : resolve(projectRoot, tool.path);
@@ -32,7 +32,7 @@ async function runExternalToolchainChecks(ctx) {
             const label = `External toolchain: ${toolchain.name}/${tool.name}`;
             const found = await resolveDeclaredTool(ctx.projectRoot, tool);
             if (found !== undefined) {
-                rows.push({ name: label, passed: true, severity: 'ok', message: `OK (${found})` });
+                rows.push(ok(label, `OK (${found})`));
                 continue;
             }
             const required = tool.required !== false;

package/dist/src/commands/doctor-furnace-config-sync.d.ts

@@ -0,0 +1,18 @@
+/**
+ * "Furnace config sync" doctor check.
+ *
+ * Surfaces orphaned component directories on disk whose names are missing
+ * from `furnace.json` — typically the concurrent-override race, where two
+ * parallel `furnace override` commands both leave their directory on disk
+ * but only the second reaches `writeFurnaceConfig`. Under
+ * `--repair-furnace`, override orphans are re-registered from the
+ * `override.json` sidecar the command wrote during the copy phase; custom
+ * orphans are listed for the operator to either re-run `furnace create`
+ * against or delete manually, because custom components have no similar
+ * persisted metadata.
+ *
+ * Lives in a sibling module to keep `doctor-furnace.ts` under the per-file
+ * LOC budget.
+ */
+import type { DoctorCheckDefinition } from './doctor-check-core.js';
+export declare const furnaceConfigSyncCheck: DoctorCheckDefinition;

package/dist/src/commands/{doctor-furnace-manifest-sync.js → doctor-furnace-config-sync.js}

@@ -1,19 +1,19 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * "Furnace manifest sync" doctor check.
+ * "Furnace config sync" doctor check.
  *
  * Surfaces orphaned component directories on disk whose names are missing
- * from `furnace.json`. The motivating eval case is the concurrent-override
- * race (eval 2) where two parallel `furnace override` commands both left
- * their directory on disk but only the second reached
- * `writeFurnaceConfig`. Under `--repair-furnace`, override orphans are
- * re-registered from the `override.json` sidecar the command wrote during
- * the copy phase; custom orphans are listed for the operator to either
- * re-run `furnace create` against or delete manually, because custom
- * components have no similar persisted metadata.
+ * from `furnace.json` — typically the concurrent-override race, where two
+ * parallel `furnace override` commands both leave their directory on disk
+ * but only the second reaches `writeFurnaceConfig`. Under
+ * `--repair-furnace`, override orphans are re-registered from the
+ * `override.json` sidecar the command wrote during the copy phase; custom
+ * orphans are listed for the operator to either re-run `furnace create`
+ * against or delete manually, because custom components have no similar
+ * persisted metadata.
  *
- * Lives in a sibling module to keep `doctor-furnace.ts` under the
- * per-file LOC budget.
+ * Lives in a sibling module to keep `doctor-furnace.ts` under the per-file
+ * LOC budget.
  */
 import { readdir, rmdir } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -43,12 +43,13 @@ async function listComponentDirs(dir) {
 }
 async function recoverOverrideConfig(overrideDir, name) {
     // `furnace override` writes `override.json` alongside the copied files.
-    // That sidecar is enough to reconstruct the furnace.json entry lost to
-    // a concurrent-write race (eval 2: second override wrote back the
-    // outer-snapshot config, dropping the sibling write's addition).
-    // No `pathExists` precheck: it collapses "absent" and "unreadable" into the
-    // same `false`, and both outcomes lead here anyway — a missing file lands in
-    // the catch below with the same `undefined` result.
+    // That sidecar is enough to reconstruct the furnace.json entry lost to a
+    // concurrent-write race, where the second override writes back the
+    // outer-snapshot config and drops the sibling write's addition.
+    //
+    // No `pathExists` precheck: it collapses "absent" and "unreadable" into
+    // the same `false`, and both outcomes lead here anyway — a missing file
+    // lands in the catch below with the same `undefined` result.
     const sidecarPath = join(overrideDir, name, 'override.json');
     try {
         const raw = await readJson(sidecarPath);
@@ -148,12 +149,12 @@ async function repairOrphans(projectRoot, orphans) {
         return outcome;
     const lockPath = getFurnaceLockPath(projectRoot);
     // One catch covers four distinct phases; naming the one that failed keeps
-    // the report honest — a lock timeout used to render as "failed while
+    // the report honest — a lock timeout otherwise renders as "failed while
     // writing furnace.json", the phase least likely to have been reached.
     // Held in an object rather than two `let`s: the lock callback mutates them
     // from inside a closure, and TS's control-flow analysis does not propagate
-    // that through the call — it would narrow both to their initial literals in
-    // the catch below.
+    // that through the call — it would narrow both to their initial literals
+    // in the catch below.
     const progress = { phase: 'waiting for the furnace lock', persisted: false };
     try {
         await withFileLock(lockPath, async () => {
@@ -246,8 +247,8 @@ async function deleteEmptyCustomOrphans(projectRoot, freshConfig, customNames, o
         }
     }
 }
-export const furnaceManifestSyncCheck = {
-    name: 'Furnace manifest sync',
+export const furnaceConfigSyncCheck = {
+    name: 'Furnace config sync',
     dependsOn: ['Furnace configuration'],
     skipIf: (ctx) => !ctx.furnaceConfigExists || !ctx.furnaceConfig,
     run: async (ctx) => {
@@ -258,15 +259,15 @@ export const furnaceManifestSyncCheck = {
         const overrideCount = orphans.overrides.length;
         const customCount = orphans.customNames.length;
         if (overrideCount === 0 && customCount === 0) {
-            return ok('Furnace manifest sync');
+            return ok('Furnace config sync');
         }
         const summary = formatOrphanSummary(orphans);
         if (!ctx.options.repairFurnace) {
-            return warning('Furnace manifest sync', summary, 'Run "fireforge doctor --repair-furnace" to re-register override orphans from their override.json sidecars (custom orphans are listed for manual follow-up).');
+            return warning('Furnace config sync', summary, 'Run "fireforge doctor --repair-furnace" to re-register override orphans from their override.json sidecars (custom orphans are listed for manual follow-up).');
         }
         const repairResult = await repairOrphans(ctx.projectRoot, orphans);
         if (repairResult.repairError) {
-            return failure('Furnace manifest sync', `Repair failed ${repairResult.repairError}`, 'Fix the underlying error and retry the doctor command.');
+            return failure('Furnace config sync', `Repair failed ${repairResult.repairError}`, 'Fix the underlying error and retry the doctor command.');
         }
         const customRepair = repairResult;
         const { restored, unrecoverable, reconciled } = repairResult;
@@ -288,7 +289,7 @@ export const furnaceManifestSyncCheck = {
         const customErrorDetail = customRepair.errors.length > 0
             ? ` Could not inspect or delete ${customRepair.errors.length} custom orphan ${customRepair.errors.length === 1 ? 'directory' : 'directories'} (${customRepair.errors.join('; ')}).`
             : '';
-        return warning('Furnace manifest sync', `${restoreDetail}${unrecoverableDetail}${customDetail}${retainedCustomDetail}${customErrorDetail}${reconciledDetail}`.trim() ||
+        return warning('Furnace config sync', `${restoreDetail}${unrecoverableDetail}${customDetail}${retainedCustomDetail}${customErrorDetail}${reconciledDetail}`.trim() ||
             'Nothing to repair (orphans surfaced but all were already recoverable).');
     },
 };

package/dist/src/commands/doctor-furnace-jar.d.ts

@@ -1,16 +1,14 @@
 /**
- * `doctor` check for stale furnace jar.mn registrations (0.34.0 field
- * report): a component-file rename left the old toolkit jar.mn line
- * pointing at the deleted file, every build failed at packaging, and
- * `doctor --repair-furnace` reported success without pruning. Split out
- * of `doctor-furnace.ts` to keep that file within the line budget.
+ * `doctor` check for stale furnace jar.mn registrations: a component-file
+ * rename can leave the old toolkit jar.mn line pointing at the deleted file,
+ * failing every build at packaging. Split out of `doctor-furnace.ts` to keep
+ * that file within the line budget.
  */
 import type { DoctorCheckDefinition } from './doctor-check-core.js';
 /**
  * "Furnace jar.mn registrations" check: detect widget registration lines
- * pointing at component files that no longer exist in the workspace
- * (typically left by a rename under an older FireForge). These break
- * `mach build` at packaging; `--repair-furnace` prunes them (0.34.0 field
- * report: doctor --repair-furnace reported success without pruning).
+ * pointing at component files that no longer exist in the workspace,
+ * typically left by a rename. These break `mach build` at packaging;
+ * `--repair-furnace` prunes them.
  */
 export declare const furnaceStaleJarRegistrationCheck: DoctorCheckDefinition;

package/dist/src/commands/doctor-furnace-jar.js

@@ -1,10 +1,9 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * `doctor` check for stale furnace jar.mn registrations (0.34.0 field
- * report): a component-file rename left the old toolkit jar.mn line
- * pointing at the deleted file, every build failed at packaging, and
- * `doctor --repair-furnace` reported success without pruning. Split out
- * of `doctor-furnace.ts` to keep that file within the line budget.
+ * `doctor` check for stale furnace jar.mn registrations: a component-file
+ * rename can leave the old toolkit jar.mn line pointing at the deleted file,
+ * failing every build at packaging. Split out of `doctor-furnace.ts` to keep
+ * that file within the line budget.
  */
 import { getFurnacePaths } from '../core/furnace-config.js';
 import { findStaleJarMnEntries, pruneStaleJarMnEntries } from '../core/furnace-registration.js';
@@ -12,10 +11,9 @@ import { toError } from '../utils/errors.js';
 import { failure, ok, warning } from './doctor-check-core.js';
 /**
  * "Furnace jar.mn registrations" check: detect widget registration lines
- * pointing at component files that no longer exist in the workspace
- * (typically left by a rename under an older FireForge). These break
- * `mach build` at packaging; `--repair-furnace` prunes them (0.34.0 field
- * report: doctor --repair-furnace reported success without pruning).
+ * pointing at component files that no longer exist in the workspace,
+ * typically left by a rename. These break `mach build` at packaging;
+ * `--repair-furnace` prunes them.
  */
 export const furnaceStaleJarRegistrationCheck = {
     name: 'Furnace jar.mn registrations',