@hominis/fireforge 0.17.0 → 0.18.1

package/dist/src/core/git.js

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { GitError, GitIndexLockError, PatchApplyError } from '../errors/git.js';
+import { GitError, GitIndexingTimeoutError, GitIndexLockError, PatchApplyError, } from '../errors/git.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, removeFile } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { exec } from '../utils/process.js';
-import { configureGitPerformance, ensureGit, git, GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_TIMEOUT_MS, } from './git-base.js';
+import { configureGitPerformance, ensureGit, git, GIT_ADD_CHUNK_TIMEOUT_ENV_VAR, GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_TIMEOUT_MS, } from './git-base.js';
 import { getWorkingTreeStatus } from './git-status.js';
 // ── Functions that remain in this file ──
 /**
@@ -38,12 +38,22 @@ export async function ensureOriginRemote(dir) {
 const GIT_ADD_ENV = { GIT_INDEX_THREADS: '0' };
 /**
  * Returns true when the error looks like a process killed by the spawn timeout
- * (SIGTERM → exit code 143).
+ * (SIGTERM → exit code 143) OR an AbortError raised by
+ * `AbortSignal.timeout`. The AbortSignal path is the one observed during
+ * the 2026-04-24 eval (Finding 10): Node's `child_process` layer
+ * rejects with an AbortError when the signal fires, so the timeout
+ * detection here needs to recognise that shape too.
  */
 function isTimeoutError(error) {
+    if (error instanceof Error && error.name === 'AbortError')
+        return true;
     if (!(error instanceof GitError))
         return false;
-    return /SIGTERM|timed out|exit code 143/i.test(error.message);
+    if (/SIGTERM|timed out|exit code 143/i.test(error.message))
+        return true;
+    if (error.cause instanceof Error && error.cause.name === 'AbortError')
+        return true;
+    return false;
 }
 /**
  * Removes `.git/index.lock` left behind by a killed git process.
@@ -59,6 +69,12 @@ async function cleanupIndexLock(dir) {
  * Stages every file by walking top-level directories one at a time.
  * This avoids a single monolithic `git add -A` that may time out on
  * very large (~300 K file) trees like Firefox.
+ *
+ * 2026-04-24 eval Finding 10: a chunked pass that hits its own timeout
+ * now raises a typed {@link GitIndexingTimeoutError} rather than the
+ * opaque `AbortError: The operation was aborted` the caller otherwise
+ * saw. The typed error carries the environment-variable override so the
+ * operator can extend the budget and re-run.
  */
 async function stageAllFilesChunked(dir, options = {}) {
     const entries = await readdir(dir, { withFileTypes: true });
@@ -66,21 +82,30 @@ async function stageAllFilesChunked(dir, options = {}) {
         .filter((e) => e.isDirectory() && e.name !== '.git')
         .map((e) => e.name)
         .sort();
+    async function runChunk(args, label) {
+        try {
+            await git(args, dir, {
+                timeout: GIT_ADD_CHUNK_TIMEOUT_MS,
+                env: GIT_ADD_ENV,
+            });
+        }
+        catch (error) {
+            if (isTimeoutError(error)) {
+                throw new GitIndexingTimeoutError('chunked', GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_CHUNK_TIMEOUT_ENV_VAR, error instanceof Error ? error : undefined);
+            }
+            verbose(`Chunked staging failed on ${label}: ${toError(error).message}`);
+            throw error;
+        }
+    }
     for (const dirName of directories) {
         options.onProgress?.(`Staging directory: ${dirName}/...`);
-        await git(['add', '--', dirName], dir, {
-            timeout: GIT_ADD_CHUNK_TIMEOUT_MS,
-            env: GIT_ADD_ENV,
-        });
+        await runChunk(['add', '--', dirName], dirName);
     }
     // Stage any top-level files
     const topLevelFiles = entries.filter((e) => e.isFile()).map((e) => e.name);
     if (topLevelFiles.length > 0) {
         options.onProgress?.('Staging top-level files...');
-        await git(['add', '--', ...topLevelFiles], dir, {
-            timeout: GIT_ADD_CHUNK_TIMEOUT_MS,
-            env: GIT_ADD_ENV,
-        });
+        await runChunk(['add', '--', ...topLevelFiles], 'top-level files');
     }
 }
 /**
@@ -122,11 +147,25 @@ export async function stageAllFiles(dir, options = {}) {
             if (!isTimeoutError(error)) {
                 throw await maybeWrapIndexLockError(dir, error);
             }
-            options.onProgress?.('Monolithic git add timed out; falling back to chunked staging...');
+            // 2026-04-24 eval Finding 10: the fallback transition used to be
+            // an implementation detail invisible to operators watching the
+            // spinner. Emit a loud, one-line banner so non-TTY log scrapers
+            // and TTY operators both see that the monolithic attempt lost and
+            // the chunked pass is starting. This was the missing signal in
+            // the eval log where the heartbeat went quiet for ~600s between
+            // the monolithic timeout and the chunked-pass failure.
+            options.onProgress?.(`Monolithic git add reached the ${Math.round(timeout / 1000)}s timeout; falling back to chunked staging. This pass may take several more minutes on a large tree.`);
         }
         // The killed process may have left an index lock
         await cleanupIndexLock(dir);
-        await stageAllFilesChunked(dir, options);
+        try {
+            await stageAllFilesChunked(dir, options);
+        }
+        catch (error) {
+            if (error instanceof GitIndexingTimeoutError)
+                throw error;
+            throw error;
+        }
     }
     finally {
         if (heartbeatTimer)

package/dist/src/core/mach.d.ts

@@ -60,19 +60,25 @@ export declare function bootstrapWithOutput(engineDir: string): Promise<MachComm
 /**
  * Runs a full mach build. On a non-zero exit, any matched error hints are
  * surfaced on top of the raw mach output so operators get an actionable
- * nudge alongside the cryptic mozbuild traceback.
+ * nudge alongside the cryptic mozbuild traceback. Returns the captured
+ * result so the caller (e.g. `fireforge build`) can inspect the tail
+ * for post-build diagnostics that mach prints AFTER "Your build was
+ * successful!" — notably the stale `config.status is out of date`
+ * notice that mach emits when a tool-managed edit landed on
+ * `moz.configure` before the build.
  * @param engineDir - Path to the engine directory
  * @param jobs - Number of parallel jobs (optional)
- * @returns Exit code
+ * @returns Captured mach result (stdout tail, stderr tail, exit code)
  */
-export declare function build(engineDir: string, jobs?: number): Promise<number>;
+export declare function build(engineDir: string, jobs?: number): Promise<MachCommandResult>;
 /**
  * Runs a fast UI-only build. On a non-zero exit, any matched error hints are
- * surfaced on top of the raw mach output.
+ * surfaced on top of the raw mach output. See {@link build} for why the
+ * full captured result is returned rather than just the exit code.
  * @param engineDir - Path to the engine directory
- * @returns Exit code
+ * @returns Captured mach result
  */
-export declare function buildUI(engineDir: string): Promise<number>;
+export declare function buildUI(engineDir: string): Promise<MachCommandResult>;
 /**
  * Runs an operation while holding a sidecar build lock keyed on the
  * project root. Concurrent `fireforge build` / `fireforge build --ui`
@@ -162,9 +168,21 @@ export declare function watch(engineDir: string): Promise<number>;
 /**
  * Runs mach watch while preserving stdin and capturing emitted output.
  * @param engineDir - Path to the engine directory
+ * @param options - Optional environment overrides merged into the mach subprocess env
  * @returns Captured output and exit code
- */
-export declare function watchWithOutput(engineDir: string): Promise<MachCommandResult>;
+ *
+ * 2026-04-24 eval Finding 12: the pre-0.18.1 shape accepted no options
+ * and so never forwarded the detected watchman path into the mach
+ * subprocess env. `fireforge watch` could locate `watchman` via PATH
+ * (the probe's `which` succeeded) but the mach subprocess spawned with
+ * the parent's PATH only — on macOS that typically omits
+ * `/opt/homebrew/bin`, so `mach watch` failed at the `watch-project`
+ * subscription step. Accepting `env` here lets the caller prepend the
+ * resolved watchman directory to PATH in a way mach inherits.
+ */
+export declare function watchWithOutput(engineDir: string, options?: {
+    env?: Record<string, string>;
+}): Promise<MachCommandResult>;
 /**
  * Runs mach test with the given test paths.
  * @param engineDir - Path to the engine directory

package/dist/src/core/mach.js

@@ -137,10 +137,15 @@ function surfaceMachErrorHints(result) {
 /**
  * Runs a full mach build. On a non-zero exit, any matched error hints are
  * surfaced on top of the raw mach output so operators get an actionable
- * nudge alongside the cryptic mozbuild traceback.
+ * nudge alongside the cryptic mozbuild traceback. Returns the captured
+ * result so the caller (e.g. `fireforge build`) can inspect the tail
+ * for post-build diagnostics that mach prints AFTER "Your build was
+ * successful!" — notably the stale `config.status is out of date`
+ * notice that mach emits when a tool-managed edit landed on
+ * `moz.configure` before the build.
  * @param engineDir - Path to the engine directory
  * @param jobs - Number of parallel jobs (optional)
- * @returns Exit code
+ * @returns Captured mach result (stdout tail, stderr tail, exit code)
  */
 export async function build(engineDir, jobs) {
     const args = ['build'];
@@ -151,20 +156,21 @@ export async function build(engineDir, jobs) {
     if (result.exitCode !== 0) {
         surfaceMachErrorHints(result);
     }
-    return result.exitCode;
+    return result;
 }
 /**
  * Runs a fast UI-only build. On a non-zero exit, any matched error hints are
- * surfaced on top of the raw mach output.
+ * surfaced on top of the raw mach output. See {@link build} for why the
+ * full captured result is returned rather than just the exit code.
  * @param engineDir - Path to the engine directory
- * @returns Exit code
+ * @returns Captured mach result
  */
 export async function buildUI(engineDir) {
     const result = await runMachInheritCapture(['build', 'faster'], engineDir);
     if (result.exitCode !== 0) {
         surfaceMachErrorHints(result);
     }
-    return result.exitCode;
+    return result;
 }
 /**
  * Runs an operation while holding a sidecar build lock keyed on the
@@ -274,10 +280,20 @@ export async function watch(engineDir) {
 /**
  * Runs mach watch while preserving stdin and capturing emitted output.
  * @param engineDir - Path to the engine directory
+ * @param options - Optional environment overrides merged into the mach subprocess env
  * @returns Captured output and exit code
+ *
+ * 2026-04-24 eval Finding 12: the pre-0.18.1 shape accepted no options
+ * and so never forwarded the detected watchman path into the mach
+ * subprocess env. `fireforge watch` could locate `watchman` via PATH
+ * (the probe's `which` succeeded) but the mach subprocess spawned with
+ * the parent's PATH only — on macOS that typically omits
+ * `/opt/homebrew/bin`, so `mach watch` failed at the `watch-project`
+ * subscription step. Accepting `env` here lets the caller prepend the
+ * resolved watchman directory to PATH in a way mach inherits.
  */
-export async function watchWithOutput(engineDir) {
-    return runMachInheritCapture(['watch'], engineDir);
+export async function watchWithOutput(engineDir, options = {}) {
+    return runMachInheritCapture(['watch'], engineDir, options.env ? { env: options.env } : {});
 }
 /**
  * Runs mach test with the given test paths.

package/dist/src/core/manifest-rules.js

@@ -24,7 +24,16 @@ export function getRules(binaryName) {
             // proposed a bogus jar.mn entry. The lookahead blocks the match so
             // `getUnregistrableAdvice` gets a chance to emit the correct
             // guidance for the `.inc.xhtml` case.
-            pattern: /^browser\/base\/content\/(?!.+\.inc\.xhtml$)(.+\.(?:js|mjs|xhtml|css))$/,
+            //
+            // Test implementation files under `browser/base/content/test/` are
+            // also excluded: they belong in the nearest `browser.toml` manifest,
+            // not in jar.mn. 2026-04-23 eval 2: `status --unmanaged` proposed
+            // `fireforge register browser/base/content/test/<dir>/browser_*.js`
+            // which would have clutter-registered a test file as browser
+            // chrome content. The negative lookahead routes those paths to
+            // `getUnregistrableAdvice`, which returns the correct
+            // browser.toml-centric guidance.
+            pattern: /^browser\/base\/content\/(?!.+\.inc\.xhtml$)(?!test\/)(.+\.(?:js|mjs|xhtml|css))$/,
             isRegistered: (engineDir, fileName) => isBrowserContentRegistered(engineDir, fileName),
             register: (engineDir, after, dryRun, fileName) => registerBrowserContent(engineDir, fileName, after, undefined, dryRun),
             extractArgs: (m) => [m[1] ?? ''],

package/dist/src/core/manifest-tokenizers.d.ts

@@ -26,6 +26,12 @@ export declare function tokenizeJarMn(lines: string[]): JarMnToken[];
 /**
  * Tokenizes a moz.build Python list block, returning the tokens and their
  * line range within the file.
+ *
+ * Supports both multi-line lists (the common shape) and single-line
+ * empty lists of the form `EXTRA_JS_MODULES += []` — the eval-2 finding
+ * case where a freshly-scaffolded module directory's `moz.build`
+ * started with an empty list and the tokenizer returned `null`,
+ * leaving `register` unable to add the first entry.
  */
 export declare function tokenizeMozBuildList(lines: string[], listPattern: RegExp): {
     tokens: MozBuildToken[];

package/dist/src/core/manifest-tokenizers.js

@@ -44,6 +44,12 @@ export function tokenizeJarMn(lines) {
 /**
  * Tokenizes a moz.build Python list block, returning the tokens and their
  * line range within the file.
+ *
+ * Supports both multi-line lists (the common shape) and single-line
+ * empty lists of the form `EXTRA_JS_MODULES += []` — the eval-2 finding
+ * case where a freshly-scaffolded module directory's `moz.build`
+ * started with an empty list and the tokenizer returned `null`,
+ * leaving `register` unable to add the first entry.
  */
 export function tokenizeMozBuildList(lines, listPattern) {
     const tokens = [];
@@ -53,6 +59,28 @@ export function tokenizeMozBuildList(lines, listPattern) {
         const raw = lines[i] ?? '';
         if (startLine === -1) {
             if (listPattern.test(raw)) {
+                // Single-line empty-list handling: a fresh scaffold sometimes
+                // writes `EXTRA_JS_MODULES += []` on one line. The pre-fix
+                // tokenizer returned `null` because it never saw a line
+                // starting with `]`, which stranded `register` with a "Could
+                // not find module list section" error against the documented
+                // browser/modules/<fork>/ scaffold (eval 2).
+                //
+                // The in-place split rewrites the single-line form into the
+                // canonical multi-line shape so the caller's
+                // `lines.splice(insertIndex, 0, entry)` lands inside the list
+                // body. The tokens are emitted to mirror the new structure.
+                const singleLineMatch = /^([^[]*\[)\s*\]\s*$/.exec(raw);
+                if (singleLineMatch) {
+                    const openPart = singleLineMatch[1] ?? '';
+                    lines[i] = openPart;
+                    lines.splice(i + 1, 0, ']');
+                    startLine = i;
+                    endLine = i + 1;
+                    tokens.push({ type: 'list-open', raw: openPart, lineIndex: i });
+                    tokens.push({ type: 'list-close', raw: ']', lineIndex: i + 1 });
+                    break;
+                }
                 startLine = i;
                 tokens.push({ type: 'list-open', raw, lineIndex: i });
             }

package/dist/src/core/marionette-preflight.d.ts

@@ -44,3 +44,19 @@ export interface MarionettePreflightOptions {
 export declare function runMarionettePreflight(engineDir: string, options?: MarionettePreflightOptions): Promise<MarionettePreflightResult>;
 /** Renders a PASS/FAIL banner to the CLI using the shared logger helpers. */
 export declare function reportMarionettePreflight(result: MarionettePreflightResult): void;
+/**
+ * Formats the PASS/FAIL banner as a plain string for direct
+ * `process.stdout.write` use — bypasses the clack logger entirely so
+ * operators running `fireforge test --doctor` under a non-TTY (pipe,
+ * CI, `tee`-wrapped capture) always see the final line even when the
+ * clack renderer swallows trailing log output just before process exit.
+ *
+ * 2026-04-24 eval Finding 7 reproducibly captured only the `"Running
+ * marionette preflight..."` intro and no PASS line at all — the
+ * `success()` + `outro()` + direct `stdout.write` belt-and-suspenders
+ * we used to ship still lost the summary under some non-TTY flush
+ * races. Returning the raw string here lets the caller compose a single
+ * authoritative write without any clack layer between the probe and
+ * the captured log.
+ */
+export declare function formatMarionettePreflightLine(result: MarionettePreflightResult): string;

package/dist/src/core/marionette-preflight.js

@@ -288,4 +288,23 @@ export function reportMarionettePreflight(result) {
         warn(`Marionette preflight: FAIL (${result.durationMs}ms) — ${result.detail}`);
     }
 }
+/**
+ * Formats the PASS/FAIL banner as a plain string for direct
+ * `process.stdout.write` use — bypasses the clack logger entirely so
+ * operators running `fireforge test --doctor` under a non-TTY (pipe,
+ * CI, `tee`-wrapped capture) always see the final line even when the
+ * clack renderer swallows trailing log output just before process exit.
+ *
+ * 2026-04-24 eval Finding 7 reproducibly captured only the `"Running
+ * marionette preflight..."` intro and no PASS line at all — the
+ * `success()` + `outro()` + direct `stdout.write` belt-and-suspenders
+ * we used to ship still lost the summary under some non-TTY flush
+ * races. Returning the raw string here lets the caller compose a single
+ * authoritative write without any clack layer between the probe and
+ * the captured log.
+ */
+export function formatMarionettePreflightLine(result) {
+    const status = result.ok ? 'PASS' : 'FAIL';
+    return `Marionette preflight: ${status} (${result.durationMs}ms) — ${result.detail}`;
+}
 //# sourceMappingURL=marionette-preflight.js.map

package/dist/src/core/patch-lint-diff-tag.d.ts

@@ -18,6 +18,13 @@ import type { PatchLintIssue } from '../types/commands/index.js';
  * @param rev Git revision to diff against (e.g. `HEAD`, a branch, a SHA).
  */
 export declare function collectDiffFilePaths(engineDir: string, rev: string): Promise<Set<string>>;
+/**
+ * Synthetic "file" value used by aggregate patch-size rules
+ * (`large-patch-files` / `large-patch-lines`) to flag that a finding
+ * describes the whole diff rather than a single path. Exported so callers
+ * can keep the tagging contract visible in one place.
+ */
+export declare const AGGREGATE_PATCH_FILE = "(patch)";
 /**
  * Annotates a list of lint issues with `introduced` / `cumulative` tags
  * based on whether the issue's file is part of the supplied diff set.
@@ -27,6 +34,19 @@ export declare function collectDiffFilePaths(engineDir: string, rev: string): Pr
  * describe queue-wide state — are always `cumulative` under `--since`
  * because they describe drift accumulated across many commits, not a
  * single current-task edit.
+ *
+ * Aggregate patch-size rules emit `issue.file === AGGREGATE_PATCH_FILE`,
+ * which is a synthetic placeholder that will never appear in a real
+ * `diffFiles` set. Without special-casing, `large-patch-files` /
+ * `large-patch-lines` were always tagged `[cumulative]` under
+ * `--only-introduced` even when the diff WAS the aggregate the rules
+ * measured — the eval (Finding #4) reported a stack of 20+ imported
+ * patches whose aggregate-size warnings printed as `[cumulative]` under
+ * `lint --since HEAD --only-introduced`, which reads as "this pre-existed"
+ * to an operator asking "what did this diff introduce?" We promote the
+ * aggregate tag to `introduced` whenever the diff set has any content —
+ * non-empty `diffFiles` means the operator asked about a specific diff
+ * scope and the aggregate-rule finding describes exactly that scope.
  * @param issues Issues returned by the lint orchestrator.
  * @param diffFiles File paths touched since the user's revision.
  */

package/dist/src/core/patch-lint-diff-tag.js

@@ -58,6 +58,13 @@ export async function collectDiffFilePaths(engineDir, rev) {
     }
     return files;
 }
+/**
+ * Synthetic "file" value used by aggregate patch-size rules
+ * (`large-patch-files` / `large-patch-lines`) to flag that a finding
+ * describes the whole diff rather than a single path. Exported so callers
+ * can keep the tagging contract visible in one place.
+ */
+export const AGGREGATE_PATCH_FILE = '(patch)';
 /**
  * Annotates a list of lint issues with `introduced` / `cumulative` tags
  * based on whether the issue's file is part of the supplied diff set.
@@ -67,15 +74,33 @@ export async function collectDiffFilePaths(engineDir, rev) {
  * describe queue-wide state — are always `cumulative` under `--since`
  * because they describe drift accumulated across many commits, not a
  * single current-task edit.
+ *
+ * Aggregate patch-size rules emit `issue.file === AGGREGATE_PATCH_FILE`,
+ * which is a synthetic placeholder that will never appear in a real
+ * `diffFiles` set. Without special-casing, `large-patch-files` /
+ * `large-patch-lines` were always tagged `[cumulative]` under
+ * `--only-introduced` even when the diff WAS the aggregate the rules
+ * measured — the eval (Finding #4) reported a stack of 20+ imported
+ * patches whose aggregate-size warnings printed as `[cumulative]` under
+ * `lint --since HEAD --only-introduced`, which reads as "this pre-existed"
+ * to an operator asking "what did this diff introduce?" We promote the
+ * aggregate tag to `introduced` whenever the diff set has any content —
+ * non-empty `diffFiles` means the operator asked about a specific diff
+ * scope and the aggregate-rule finding describes exactly that scope.
  * @param issues Issues returned by the lint orchestrator.
  * @param diffFiles File paths touched since the user's revision.
  */
 export function tagLintIssues(issues, diffFiles) {
+    const hasDiffContent = diffFiles.size > 0;
     for (const issue of issues) {
         if (!issue.file) {
             issue.tag = 'cumulative';
             continue;
         }
+        if (issue.file === AGGREGATE_PATCH_FILE) {
+            issue.tag = hasDiffContent ? 'introduced' : 'cumulative';
+            continue;
+        }
         issue.tag = diffFiles.has(issue.file) ? 'introduced' : 'cumulative';
     }
     return issues;

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

@@ -67,10 +67,49 @@ export declare function lintPatchedJs(repoDir: string, affectedFiles: string[],
  * @returns Array of lint issues
  */
 export declare function lintModificationComments(diffContent: string, config: FireForgeConfig): PatchLintIssue[];
+/**
+ * Describes which tier `resolvePatchSizeTier` selected and why.
+ * Consumers that want to surface the tier choice to the operator
+ * (e.g. a one-line `info()` when branding thresholds kick in) read
+ * this alongside the issues array from `lintPatchSize`.
+ */
+export type PatchSizeTierDecision = {
+    tier: 'general';
+} | {
+    tier: 'test';
+} | {
+    tier: 'branding';
+    source: 'auto' | 'explicit';
+};
+/**
+ * Decides which `large-patch-lines` threshold tier applies to a patch.
+ * Exported so `runPatchLint` and the per-patch `lint` command can
+ * surface the tier choice to the operator *without* depending on
+ * `lintPatchSize`'s internal return shape — the rule itself stays a
+ * pure issues-array API, and the decision is computed separately for
+ * the sole purpose of reporting.
+ *
+ * Precedence: test > branding (explicit) > branding (auto) > general.
+ * The test tier beats branding because a table-driven regression test
+ * is legitimately large independent of whether the patch also claims
+ * branding shape, and the test-tier thresholds are already more
+ * permissive than branding — so "tests beat branding" is the
+ * defensive-for-tests choice.
+ */
+export declare function resolvePatchSizeTier(filesAffected: ReadonlyArray<string>, patchTier?: 'branding'): PatchSizeTierDecision;
 /**
  * Checks patch size and emits advisory warnings.
+ *
+ * @param filesAffected - Files touched by the patch
+ * @param lineCount - Non-binary line count of the unified diff
+ * @param patchTier - Optional explicit tier override declared on
+ *   `PatchMetadata.tier`. When `"branding"`, forces the branding
+ *   thresholds regardless of `filesAffected`. Tests still win over
+ *   branding (precedence `test > branding > general`) because the
+ *   test-tier thresholds are already more permissive and an all-tests
+ *   patch that is also branding-shaped is vanishingly rare.
  */
-export declare function lintPatchSize(filesAffected: string[], lineCount: number): PatchLintIssue[];
+export declare function lintPatchSize(filesAffected: string[], lineCount: number, patchTier?: 'branding'): PatchLintIssue[];
 /**
  * Checks that modified (non-new) files with a supported extension still
  * start with a recognized license header.
@@ -94,6 +133,12 @@ export declare function lintModifiedFileHeaders(repoDir: string, affectedFiles:
  *   is advisory-noisy by nature (a cohesive branding bundle, auto-generated
  *   manifest, etc.) can opt out of a specific rule without reaching for the
  *   blunt `--skip-lint` hammer. Not mutated by this function.
+ * @param patchTier - Optional explicit tier override, threaded from
+ *   `PatchMetadata.tier`. When `"branding"` forces the branding
+ *   thresholds on the `large-patch-lines` rule. Callers with a
+ *   per-patch manifest context (re-export, per-patch lint) should
+ *   pass this; aggregate-mode callers without a specific patch
+ *   context skip it and fall through to auto-detection.
  * @returns Array of all lint issues found
  */
-export declare function lintExportedPatch(repoDir: string, affectedFiles: string[], diffContent: string, config: FireForgeConfig, patchQueueCtx?: import('./patch-lint-cross.js').PatchQueueContext, ignoreChecks?: ReadonlySet<string>): Promise<PatchLintIssue[]>;
+export declare function lintExportedPatch(repoDir: string, affectedFiles: string[], diffContent: string, config: FireForgeConfig, patchQueueCtx?: import('./patch-lint-cross.js').PatchQueueContext, ignoreChecks?: ReadonlySet<string>, patchTier?: 'branding'): Promise<PatchLintIssue[]>;