mandrel 1.76.0 → 1.78.0

package/.agents/scripts/evidence-gate.js

@@ -13,7 +13,7 @@
  *
  * Usage:
  *   node .agents/scripts/evidence-gate.js \
- *     --epic-id <epicId> --scope-id <storyOrEpicId> --gate <name> \
+ *     (--epic-id <epicId> | --standalone) --scope-id <storyOrEpicId> --gate <name> \
  *     [--worktree <path>] [--no-evidence] -- <cmd> [args...]
  *
  * Examples:
@@ -21,11 +21,18 @@
  *   node .agents/scripts/evidence-gate.js --epic-id 1030 --scope-id 1030 --gate test -- npm test
  *   node .agents/scripts/evidence-gate.js --epic-id 1114 --scope-id 1120 --gate test \
  *     --worktree .worktrees/story-1120 -- npm test
+ *   node .agents/scripts/evidence-gate.js --standalone --scope-id 4250 --gate lint \
+ *     --worktree .worktrees/story-4250 -- npm run lint
  *
- * `--epic-id` is required. When `scope-id === epic-id` the evidence file is
- * Epic-scoped (`<tempRoot>/epic-<eid>/validation-evidence.json`); when
- * `scope-id !== epic-id` it is Story-scoped under
- * `<tempRoot>/epic-<eid>/story-<sid>/validation-evidence.json`.
+ * Either `--epic-id` or `--standalone` is required. When `scope-id ===
+ * epic-id` the evidence file is Epic-scoped
+ * (`<tempRoot>/epic-<eid>/validation-evidence.json`); when `scope-id !==
+ * epic-id` it is Story-scoped under
+ * `<tempRoot>/epic-<eid>/story-<sid>/validation-evidence.json`. With
+ * `--standalone` (Story #4250) the file is anchored on the Story id alone at
+ * `<tempRoot>/standalone/stories/story-<sid>/validation-evidence.json` — the
+ * same keyspace the standalone close consults, so the acceptance-self-eval
+ * critic's verify[] runs (lint / typecheck) are shared with the close.
  *
  * **Worktree-aware spawn (Story #1120).** `--cwd` (default `PROJECT_ROOT`)
  * is the *evidence cwd* — it locates the per-Epic temp tree under the main
@@ -84,6 +91,7 @@ export function parseWrapperArgs(argv) {
       'epic-id': { type: 'string' },
       gate: { type: 'string' },
       'no-evidence': { type: 'boolean', default: false },
+      standalone: { type: 'boolean', default: false },
       cwd: { type: 'string' },
       worktree: { type: 'string' },
     },
@@ -94,6 +102,7 @@ export function parseWrapperArgs(argv) {
   return {
     scopeId: Number.isNaN(scopeId) || scopeId <= 0 ? null : scopeId,
     epicId: Number.isNaN(epicId) || epicId <= 0 ? null : epicId,
+    standalone: values.standalone === true,
     gate: values.gate ?? null,
     useEvidence: values['no-evidence'] !== true,
     cwd: values.cwd ?? PROJECT_ROOT,
@@ -118,7 +127,11 @@ function resolveHeadShaDefault(cwd, gitSpawnFn) {
  *
  * @param {object} params
  * @param {number}   params.scopeId      — Story / Epic ID (positive integer).
- * @param {string}   params.gate         — Logical gate name (`lint`, `test`, …).
+ * @param {number|null} [params.epicId]  — Parent Epic id (Epic-keyed path).
+ * @param {boolean}  [params.standalone] — When true, route to the
+ *   storyId-anchored standalone keyspace instead of the Epic-keyed path
+ *   (Story #4250). Substitutes for `epicId`.
+ * @param {string}   params.gate         — Logical gate name (`lint`, `typecheck`, …).
  * @param {boolean}  params.useEvidence  — When false, force the runner.
  * @param {string}   params.cwd          — Evidence cwd (locates the per-Epic
  *   temp tree). The runner is spawned in `worktreePath` when set, else `cwd`.
@@ -144,15 +157,38 @@ export async function runEvidenceGate(params, deps = {}) {
     recordPassFn = recordPass,
     logger = Logger,
   } = deps;
-  const { scopeId, epicId, gate, useEvidence, cwd, worktreePath, runnerArgs } =
-    params ?? {};
+  const {
+    scopeId,
+    epicId,
+    standalone = false,
+    gate,
+    useEvidence,
+    cwd,
+    worktreePath,
+    runnerArgs,
+  } = params ?? {};
 
-  if (!scopeId || !epicId || !gate || !runnerArgs || runnerArgs.length === 0) {
+  // `--epic-id` is required for the Epic-keyed path; `--standalone` (Story
+  // #4250) substitutes for it and routes the evidence file to the
+  // storyId-anchored standalone keyspace so the acceptance-self-eval critic
+  // can record verify[] evidence into the same keyspace the standalone close
+  // consults.
+  if (
+    !scopeId ||
+    (!epicId && !standalone) ||
+    !gate ||
+    !runnerArgs ||
+    runnerArgs.length === 0
+  ) {
     logger.fatal(
-      'Usage: node evidence-gate.js --epic-id <epicId> --scope-id <id> --gate <name> [--worktree <path>] [--no-evidence] -- <cmd> [args...]',
+      'Usage: node evidence-gate.js (--epic-id <epicId> | --standalone) --scope-id <id> --gate <name> [--worktree <path>] [--no-evidence] -- <cmd> [args...]',
     );
     return { status: 1, skipped: false };
   }
+  // Evidence-store opts shared by shouldSkip + recordPass below. `standalone`
+  // routes to the storyId-anchored keyspace; otherwise the Epic-keyed path
+  // resolves under `epicId`.
+  const evidenceStoreOpts = { cwd, epicId, standalone };
 
   // Spawn cwd is the worktree when supplied — every gate command sees the
   // Story branch's tree, not the main checkout. Evidence cwd stays anchored
@@ -174,7 +210,7 @@ export async function runEvidenceGate(params, deps = {}) {
         currentSha: headSha,
         configHash,
       },
-      { cwd, epicId },
+      evidenceStoreOpts,
     );
     if (verdict.skip) {
       const ts = verdict.record?.timestamp ?? 'n/a';
@@ -215,7 +251,7 @@ export async function runEvidenceGate(params, deps = {}) {
           exitCode: 0,
           durationMs: Date.now() - startedAt,
         },
-        { cwd, epicId },
+        evidenceStoreOpts,
       );
     } catch (err) {
       logger.warn?.(

package/.agents/scripts/generate-workflows-doc.js

@@ -34,7 +34,7 @@ import { fileURLToPath } from 'node:url';
 import { parseArgs } from 'node:util';
 import { runAsCli } from './lib/cli-utils.js';
 import { Logger } from './lib/Logger.js';
-import { buildCatalog } from './lib/mandrel-catalog.js';
+import { buildCatalog, buildLoopCatalog } from './lib/mandrel-catalog.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -66,12 +66,14 @@ function cellEscape(description) {
 }
 
 /**
- * Render the full generated `workflows.md` content from a catalog.
+ * Render the full generated `workflows.md` content from the flat command
+ * catalog and the loop-unit catalog.
  *
  * @param {Array<{ name: string, description: string | null, vague: boolean }>} catalog
+ * @param {Array<{ name: string, description: string | null, vague: boolean }>} [loopCatalog]
  * @returns {string}
  */
-export function renderWorkflowsDoc(catalog) {
+export function renderWorkflowsDoc(catalog, loopCatalog = []) {
   const lines = [
     '<!--',
     '  GENERATED FILE — do not edit by hand.',
@@ -95,6 +97,13 @@ export function renderWorkflowsDoc(catalog) {
     '`.claude/commands/<name>.md` — there is no plugin manifest and no',
     'marketplace listing. The commands load in every Claude Code environment.',
     '',
+    'Loop units are the one namespaced exception: files under',
+    '`.agents/workflows/loops/<name>.md` project to',
+    '`.claude/commands/loops/<name>.md` and are invoked as the namespaced',
+    '`/loops:<name>` command. On hosts that flatten subdirectory commands the',
+    'same unit surfaces under the flat fallback `/loops-<name>`. They are',
+    'listed separately in the **Loops namespace** section below.',
+    '',
     'This index is regenerated from each workflow’s front-matter `description:`',
     'by `node .agents/scripts/generate-workflows-doc.js`; `npm run docs:check`',
     'fails when it drifts from the on-disk workflow set. To change a command’s',
@@ -110,6 +119,29 @@ export function renderWorkflowsDoc(catalog) {
     lines.push(`| \`/${entry.name}\` | ${cellEscape(entry.description)} |`);
   }
 
+  lines.push('');
+  lines.push(`## Loops namespace (${loopCatalog.length})`);
+  lines.push('');
+  lines.push(
+    'Loop units project to `.claude/commands/loops/<name>.md` and are invoked',
+  );
+  lines.push(
+    'as `/loops:<name>` (flat fallback `/loops-<name>` on hosts that flatten',
+  );
+  lines.push('subdirectory commands).');
+  lines.push('');
+  if (loopCatalog.length === 0) {
+    lines.push('> No loop units are shipped yet.');
+  } else {
+    lines.push('| Command | Description |');
+    lines.push('| --- | --- |');
+    for (const entry of loopCatalog) {
+      lines.push(
+        `| \`/loops:${entry.name}\` | ${cellEscape(entry.description)} |`,
+      );
+    }
+  }
+
   lines.push('');
   return lines.join('\n');
 }
@@ -121,7 +153,8 @@ export function renderWorkflowsDoc(catalog) {
  */
 export function buildExpected() {
   const catalog = buildCatalog(WORKFLOWS_DIR);
-  const generated = renderWorkflowsDoc(catalog);
+  const loopCatalog = buildLoopCatalog(WORKFLOWS_DIR);
+  const generated = renderWorkflowsDoc(catalog, loopCatalog);
   const original = fs.existsSync(DOC_PATH)
     ? fs.readFileSync(DOC_PATH, 'utf8')
     : null;

package/.agents/scripts/lib/audit-to-stories/build-story-body.js

@@ -1,10 +1,11 @@
 /**
  * lib/audit-to-stories/build-story-body.js
  *
- * Render the canonical Story body for the standalone grouping mode. The
- * body follows the contract spelled out in Story #2583 acceptance
- * criteria #8: Title (caller), Summary, Acceptance Criteria, Agent
- * Prompts, Context block, fingerprint footer.
+ * Render the canonical Story body for the standalone grouping mode so a
+ * generated audit Story clears the same inline-contract bar the decomposer
+ * enforces (`assertEveryStoryHasInlineContract`): a clean goal, observable
+ * `acceptance[]`, a populated `changes[]` footprint, and a non-empty,
+ * tier-tagged `verify[]` (Story #4270).
  *
  * Pure: returns { title, body, labels }. Labels carry one canonical
  * `audit::<lens>` per distinct source report represented in the merge
@@ -14,10 +15,11 @@
  * `risk::high`.
  *
  * The body is serialized via the canonical story-body serializer
- * (`.agents/scripts/lib/story-body/story-body.js`) so the output is
- * parseable by `parse()` and round-trippable. Audit-specific content
- * (agent prompts, context links, fingerprint footer) is appended after
- * the canonical sections as extended markdown.
+ * (`.agents/scripts/lib/story-body/story-body.js`) so the output round-trips
+ * through `parse()` / `serialize()`. Audit-specific content (agent prompts,
+ * context links, fingerprint footer) is appended after the canonical sections
+ * as extended markdown — it is informational only and is not part of the
+ * structured contract.
  */
 
 import { serialize } from '../story-body/story-body.js';
@@ -26,36 +28,128 @@ import { renderFingerprintFooter } from './finding-adapter.js';
 
 const STATIC_LABELS = Object.freeze(['type::story', 'agent::ready']);
 
+// The verify[] contract every generated audit Story carries. These commands
+// exist in this repo's harness (package.json scripts) so the Story satisfies
+// the inline-contract bar with runnable, tier-tagged gates rather than
+// placeholder prose. Kept as a frozen constant so the same contract is
+// asserted by the unit suite.
+const DEFAULT_VERIFY = Object.freeze([
+  'npm run lint (validate)',
+  'npm test (unit)',
+]);
+
 function uniq(items) {
   return [...new Set(items)];
 }
 
-function summaryFromGroup(group) {
-  const lines = group.findings.map((f, idx) => {
-    const sev = f.severity ? `[${f.severity.toUpperCase()}]` : '[—]';
-    const dim = f.dimension ? `(${f.dimension})` : '';
-    return `${idx + 1}. ${sev} ${dim} **${f.title}** — ${
-      f.currentState || '_(no current-state captured)_'
-    }`;
-  });
-  return lines.join('\n');
+/**
+ * The goal is the group intent only — the synthesized `group.title`. It
+ * carries no leading ordinal (`1.`/`2.`) and no `[SEVERITY]` / `(dimension)`
+ * prefix (the polluted shape Story #4270 replaced); those signals live in the
+ * per-finding fingerprint footer and the extended Agent Prompts section, not
+ * in the goal.
+ *
+ * @param {object} group
+ * @returns {string}
+ */
+function goalFromGroup(group) {
+  return (group.title ?? '').trim();
 }
 
-function goalFromGroup(group) {
-  // Derive a concise goal statement from the group title + finding summary.
-  const summary = summaryFromGroup(group);
-  return `${group.title}\n\n${summary}`;
+/**
+ * Map every distinct file mentioned across the merge onto a canonical
+ * `changes[]` PathEntry (`{ path, assumption }`). Audit findings remediate
+ * code that already exists, so the assumption is `refactors-existing`.
+ *
+ * `group.files` is an array post-`groupFindings`; fall back to scanning the
+ * findings' own `files[]` when an upstream caller hands a group whose `files`
+ * aggregate was not materialized.
+ *
+ * @param {object} group
+ * @returns {Array<{ path: string, assumption: string }>}
+ */
+function changesFromGroup(group) {
+  const fromGroup = Array.isArray(group.files) ? group.files : [];
+  const fromFindings = (group.findings ?? []).flatMap((f) =>
+    Array.isArray(f.files) ? f.files : [],
+  );
+  const paths = uniq(
+    [...fromGroup, ...fromFindings].filter(
+      (p) => typeof p === 'string' && p.length > 0,
+    ),
+  );
+  return paths.map((path) => ({ path, assumption: 'refactors-existing' }));
+}
+
+/**
+ * Build an observable acceptance item from a single finding: a checkable
+ * end-state a reviewer can confirm, NOT the verbatim recommendation
+ * paragraph. The recommendation prose is preserved verbatim in the Agent
+ * Prompts / fingerprint footer for the implementer; the acceptance line is
+ * the binding, confirmable outcome.
+ *
+ * Shape: `<title> is remediated in <primary file>: the recommended end-state
+ * holds and the finding is no longer reproducible.` — anchored on the finding
+ * title and primary file so the reviewer knows exactly what to check.
+ *
+ * @param {object} finding
+ * @returns {string}
+ */
+function acceptanceItemFromFinding(finding) {
+  const title = (finding.title ?? 'finding').trim();
+  const primaryFile =
+    Array.isArray(finding.files) && finding.files.length > 0
+      ? finding.files[0]
+      : null;
+  const where = primaryFile ? ` in \`${primaryFile}\`` : '';
+  return `${title} is remediated${where}: the recommended end-state holds and the finding is no longer reproducible`;
 }
 
 function acceptanceCriteriaFromGroup(group) {
-  return group.findings.map((f) => {
-    const rec = f.recommendation || '_(no recommendation captured)_';
-    return `${f.title} — ${rec}`;
-  });
+  return (group.findings ?? []).map(acceptanceItemFromFinding);
+}
+
+/**
+ * Resolve the `edges[]` sequencing anchored on this group. Each edge whose
+ * `fromGroupKey` matches this group's key contributes its `toGroupKey`. Group
+ * keys are the only stable identifier available at emit time — issues are not
+ * numbered yet — so the relationship is preserved as machine-readable keys the
+ * operator can resolve.
+ *
+ * @param {object} group
+ * @param {Array<{ fromGroupKey: string, toGroupKey: string }>} edges
+ * @returns {string[]}
+ */
+function sequencingDepsForGroup(group, edges) {
+  if (!Array.isArray(edges) || edges.length === 0) return [];
+  const deps = edges
+    .filter((e) => e && e.fromGroupKey === group.groupKey)
+    .map((e) => e.toGroupKey)
+    .filter((k) => typeof k === 'string' && k.length > 0);
+  return uniq(deps);
+}
+
+/**
+ * Render the carried-through `edges[]` sequencing as a dedicated extended
+ * markdown block. The canonical `depends_on[]` footer only round-trips `#N`
+ * issue refs (`blocked by #123`), which do not exist before the issues are
+ * opened; rendering the group-key sequencing as its own informational section
+ * keeps the signal in the body (not discarded — Story #4270) and survives
+ * `parse()` / `serialize()` round-tripping (it is preamble/extended content,
+ * not a structured section). Returns the empty string when there is no
+ * sequencing to surface.
+ *
+ * @param {string[]} deps
+ * @returns {string}
+ */
+function sequencingSection(deps) {
+  if (deps.length === 0) return '';
+  const lines = deps.map((k) => `- depends on group \`${k}\``);
+  return ['## Sequencing', '', lines.join('\n'), ''].join('\n');
 }
 
 function agentPromptsSection(group) {
-  const blocks = group.findings
+  const blocks = (group.findings ?? [])
     .filter(
       (f) => typeof f.agentPrompt === 'string' && f.agentPrompt.length > 0,
     )
@@ -65,7 +159,7 @@ function agentPromptsSection(group) {
 
 function contextLinksFromGroup(group) {
   const reports = uniq(
-    group.findings
+    (group.findings ?? [])
       .map((f) => f.sourceReport)
       .filter((s) => typeof s === 'string'),
   );
@@ -93,34 +187,47 @@ function labelsForGroup(group) {
 /**
  * @param {object} params
  * @param {object} params.group — output of `groupFindings` (one entry).
+ * @param {Array<{ fromGroupKey: string, toGroupKey: string }>} [params.edges]
+ *   — the dependency `edges[]` emitted by `groupFindings`. Edges anchored on
+ *   this group are carried through to `depends_on[]`; omit when no sequencing
+ *   is known.
  * @returns {{ title: string, body: string, labels: string[] }}
  */
-export function buildStoryBody({ group }) {
+export function buildStoryBody({ group, edges = [] }) {
   if (!group || !Array.isArray(group.findings)) {
     throw new Error('buildStoryBody: group with findings[] is required');
   }
   const title = group.title;
 
-  // Build the canonical StoryBody object from the audit group data.
+  // Build the canonical StoryBody object from the audit group data. The
+  // acceptance + verify arrays are populated so the body clears the
+  // inline-contract bar; changes[] carries the file footprint. The edges[]
+  // sequencing is carried through as an extended `## Sequencing` block (see
+  // sequencingSection) — group keys are not `#N` refs, so they cannot ride the
+  // canonical depends_on footer.
   const storyBody = {
     goal: goalFromGroup(group),
-    changes: [],
+    changes: changesFromGroup(group),
     acceptance: acceptanceCriteriaFromGroup(group),
-    verify: [],
+    verify: [...DEFAULT_VERIFY],
     references: [],
     wide: null,
+    reason_to_exist: null,
     depends_on: [],
     estimated_test_files: null,
   };
 
-  // Serialize via the canonical serializer.
+  // Serialize via the canonical serializer (no footer — depends_on is empty).
   const canonicalSections = serialize(storyBody);
+  const sequencing = sequencingSection(sequencingDepsForGroup(group, edges));
 
-  // Append audit-specific extended sections (agent prompts, context links,
-  // fingerprint footer) that are not part of the canonical shape.
+  // Append audit-specific extended sections (sequencing, agent prompts,
+  // context links, fingerprint footer) that are not part of the canonical
+  // shape.
   const body = [
     canonicalSections,
     '',
+    ...(sequencing ? [sequencing] : []),
     '## Agent Prompts',
     '',
     agentPromptsSection(group),

package/.agents/scripts/lib/cli-args.js

@@ -60,6 +60,8 @@ export function parseSprintArgs(args = process.argv) {
       'no-full-scope-crap': { type: 'boolean', default: false },
       executor: { type: 'string' },
       cwd: { type: 'string' },
+      prd: { type: 'string' },
+      'tech-spec': { type: 'string' },
       'recut-of': { type: 'string' },
       resume: { type: 'boolean', default: false },
       restart: { type: 'boolean', default: false },
@@ -86,6 +88,10 @@ export function parseSprintArgs(args = process.argv) {
       process.env.AGENT_WORKTREE_ROOT ||
       null,
     recutOf: parseTicketId(values['recut-of']),
+    // Story #4253: pre-resolved Epic linkages threaded by the /deliver
+    // fan-out so `story-init.js` can skip the per-Story `getEpic` round-trip.
+    prdId: parseTicketId(values.prd),
+    techSpecId: parseTicketId(values['tech-spec']),
     resume: values.resume ?? false,
     restart: values.restart ?? false,
     noEvidence: values['no-evidence'] ?? false,

package/.agents/scripts/lib/close-validation/process.js

@@ -53,6 +53,34 @@ export function gateExitCode(code, sig) {
   return sig ? 143 : 1;
 }
 
+/**
+ * Biome's marker for "you handed me a path set, but every one of them is
+ * excluded by my own config (`files.includes` allowlist / `files.ignore` /
+ * `overrides`), so I processed nothing" — biome exits 1 in that case.
+ *
+ * The format gate scopes biome to the changed-file subset (Story #3410). When
+ * that subset is non-empty by extension but every path is biome-config-ignored,
+ * the scoped invocation reports this message and exits 1 even though
+ * `biome format .` over the whole tree is clean — a false negative for the
+ * gate (Story #4292). Detecting the marker lets the runner treat that exit as
+ * a clean skip rather than a formatting failure.
+ */
+const BIOME_NO_FILES_PROCESSED =
+  'No files were processed in the specified paths';
+
+/**
+ * Whether biome's combined gate output carries the "No files were processed"
+ * marker. Pure function — no I/O. Exported for unit coverage (Story #4292).
+ *
+ * @param {string} output - Combined stdout/stderr captured from the gate child.
+ * @returns {boolean}
+ */
+export function isBiomeNoFilesProcessed(output) {
+  return (
+    typeof output === 'string' && output.includes(BIOME_NO_FILES_PROCESSED)
+  );
+}
+
 /**
  * Default async gate runner — used by `runCloseValidation` when no `runner`
  * is injected. Spawns the gate via `child_process.spawn`, prefixes every
@@ -66,13 +94,19 @@ export function gateExitCode(code, sig) {
  * `runCloseValidation` sees a non-zero status and folds it into the
  * already-recorded first-failure.
  *
+ * When `opts.tolerateNoFilesProcessed` is set (the biome-scoped format gate —
+ * Story #4292), a non-zero exit whose combined output carries biome's
+ * "No files were processed" marker is downgraded to a clean `status: 0`,
+ * because that exit means every config-included path was already excluded,
+ * not that formatting drifted.
+ *
  * @param {string} cmd
  * @param {string[]} args
- * @param {{ cwd: string, signal?: AbortSignal, gateName?: string, log?: (m: string) => void, env?: Record<string, string> }} opts
+ * @param {{ cwd: string, signal?: AbortSignal, gateName?: string, log?: (m: string) => void, env?: Record<string, string>, tolerateNoFilesProcessed?: boolean }} opts
  * @returns {Promise<{ status: number }>}
  */
 export function defaultGateRunner(cmd, args, opts = {}) {
-  const { cwd, signal, gateName, log, env } = opts;
+  const { cwd, signal, gateName, log, env, tolerateNoFilesProcessed } = opts;
   const child = spawn(cmd, args, {
     cwd,
     shell: process.platform === 'win32',
@@ -85,13 +119,35 @@ export function defaultGateRunner(cmd, args, opts = {}) {
   const prefix = gateName ? `[${gateName}] ` : '';
   const emit =
     typeof log === 'function' ? log : (m) => process.stdout.write(`${m}\n`);
-  pipePrefixed(child.stdout, prefix, emit);
-  pipePrefixed(child.stderr, prefix, emit);
+  // Capture the combined output only when we may need to inspect it for the
+  // biome "No files were processed" marker — otherwise the stream is purely
+  // piped through to the operator (no retained buffer).
+  let captured = '';
+  const tap = tolerateNoFilesProcessed
+    ? (line) => {
+        captured += `${line}\n`;
+        emit(line);
+      }
+    : emit;
+  pipePrefixed(child.stdout, prefix, tap);
+  pipePrefixed(child.stderr, prefix, tap);
   const detach = attachGateAbortHandler(child, signal);
   return new Promise((resolve) => {
     child.on('exit', (code, sig) => {
       detach();
-      resolve({ status: gateExitCode(code, sig) });
+      const status = gateExitCode(code, sig);
+      if (
+        status !== 0 &&
+        tolerateNoFilesProcessed &&
+        isBiomeNoFilesProcessed(captured)
+      ) {
+        emit(
+          `${prefix}↳ biome processed zero files (all changed paths are config-ignored); treating as a clean skip`,
+        );
+        resolve({ status: 0 });
+        return;
+      }
+      resolve({ status });
     });
     child.on('error', () => {
       detach();