mandrel 2.31.0 → 2.32.0

package/.agents/scripts/lib/dead-exports-knip.js

@@ -75,11 +75,80 @@ export function readKnipOutput(filePath) {
   }
 }
 
+/**
+ * Sentinel `symbol` recorded for a **whole-file death** row.
+ *
+ * Knip's `files` category names a module nothing in the graph imports. There
+ * is no per-export identity to record — the whole file is the finding — so the
+ * ratchet encodes exactly one row per dead file carrying this symbol. `*` is
+ * not a legal JavaScript identifier, so a whole-file row can never collide
+ * with a real export row for the same path.
+ */
+const WHOLE_FILE_SYMBOL = '*';
+
+/**
+ * Pull the dead-file paths out of one knip issue's `files` category.
+ *
+ * Knip emits `files: [{ name: '<path>' }]`, but tolerate a bare string and
+ * fall back to the issue's own `file` so a reporter-shape change degrades to
+ * "one row for this path" rather than to silence.
+ *
+ * @param {{ files?: unknown }} issue
+ * @param {string} fallbackFile The issue's own `file` path.
+ * @returns {string[]}
+ */
+function extractDeadFileNames(issue, fallbackFile) {
+  const entries = Array.isArray(issue.files) ? issue.files : [];
+  const names = [];
+  for (const entry of entries) {
+    const name =
+      (typeof entry === 'string' && entry) ||
+      (entry && typeof entry.name === 'string' && entry.name) ||
+      fallbackFile;
+    if (typeof name === 'string' && name.length > 0) names.push(name);
+  }
+  return names;
+}
+
+/**
+ * Pull the dead-export symbol names out of one knip issue's `exports`
+ * category. Knip emits `exports: [{ name, ... }]`; older shapes used `symbol`.
+ *
+ * @param {{ exports?: unknown }} issue
+ * @returns {string[]}
+ */
+function extractDeadExportSymbols(issue) {
+  const entries = Array.isArray(issue.exports) ? issue.exports : [];
+  const symbols = [];
+  for (const e of entries) {
+    const symbol =
+      (e && typeof e.name === 'string' && e.name) ||
+      (e && typeof e.symbol === 'string' && e.symbol) ||
+      null;
+    if (symbol) symbols.push(symbol);
+  }
+  return symbols;
+}
+
 /**
  * Flatten knip's `--reporter json` output into `{ file, symbol }` rows. Knip
- * emits `{ issues: [{ file, exports: [{ name, ... }], ... }, ...] }`. Only
- * `exports` rows are mapped — the ratchet ignores file-, dependency- and
- * duplicate-level issues, which knip surfaces under separate `rules` keys.
+ * emits `{ issues: [{ file, files: [...], exports: [{ name, ... }], ... }] }`.
+ *
+ * Two categories are mapped, and the ratchet treats their rows identically:
+ *
+ * - **`exports`** → one row per unused export, `{ file, symbol: '<name>' }`.
+ * - **`files`** → one row per module nothing imports,
+ *   `{ file, symbol: '*' }`. Story #5001 added this leg: mapping only
+ *   `exports` made the ratchet structurally blind to *whole-file* death, so a
+ *   module could lose its last caller and every one of its exports go unused
+ *   without a single row changing. Knip reports such a module once, under
+ *   `files`, and suppresses its per-export rows — which is exactly why the
+ *   export-only reading saw nothing.
+ *
+ * Whole-file rows are de-duplicated by path so the row set is stable across
+ * runs regardless of how many issue records mention the same file. Dependency-
+ * and duplicate-level issues stay ignored; knip surfaces those under their own
+ * `rules` keys and they are not a code-death signal.
  *
  * @param {unknown} knipEnvelope The parsed knip JSON report.
  * @returns {Array<{ file: string, symbol: string }>}
@@ -88,16 +157,16 @@ export function extractRowsFromKnip(knipEnvelope) {
   const rows = [];
   if (!knipEnvelope || typeof knipEnvelope !== 'object') return rows;
   const issues = Array.isArray(knipEnvelope.issues) ? knipEnvelope.issues : [];
+  const seenDeadFiles = new Set();
   for (const issue of issues) {
     const file = issue?.file;
     if (typeof file !== 'string' || file.length === 0) continue;
-    const exports_ = Array.isArray(issue.exports) ? issue.exports : [];
-    for (const e of exports_) {
-      const symbol =
-        (e && typeof e.name === 'string' && e.name) ||
-        (e && typeof e.symbol === 'string' && e.symbol) ||
-        null;
-      if (!symbol) continue;
+    for (const name of extractDeadFileNames(issue, file)) {
+      if (seenDeadFiles.has(name)) continue;
+      seenDeadFiles.add(name);
+      rows.push({ file: name, symbol: WHOLE_FILE_SYMBOL });
+    }
+    for (const symbol of extractDeadExportSymbols(issue)) {
       rows.push({ file, symbol });
     }
   }

package/.agents/scripts/lib/degraded-mode.js

@@ -3,8 +3,8 @@
  *
  * Tech Spec #819 §"Degraded-mode contract (Story 3)" — three soft-fail sites
  * (audit-suite selector diff-timeout, lint-baseline JSON-parse, baseline-refresh
- * guardrail git-diff) historically returned a silent zero/empty result. The
- * new contract is:
+ * guardrail git-diff) historically returned a silent zero/empty result. Two
+ * remain; the lint-baseline site left with its CLI. The contract is:
  *
  *   { ok: false, degraded: true, reason: <code>, detail: <human> }
  *

package/.agents/scripts/lib/doc-tiers.js

@@ -201,9 +201,9 @@ export function resolveAlwaysLoadedClosure(root, { fs = nodeFs } = {}) {
 
 /**
  * Read the resolved `project.docsContextFiles` list from a config object,
- * prefixed by `project.paths.docsRoot`. Mirrors the `contextDocs` half of
- * `resolveDocList` in `validate-docs-freshness.js` (new-shape first, legacy
- * top-level fallback).
+ * prefixed by `project.paths.docsRoot`. Resolves new-shape
+ * `project.docsContextFiles` first and falls back to the legacy top-level
+ * key, so a config written against either shape yields the same list.
  *
  * @param {object} config resolved config (`resolveConfig()` output)
  * @returns {string[]} repo-relative posix doc paths (existence not yet checked)

package/.agents/scripts/lib/feedback-loop/graduator-core.js

@@ -1,15 +1,19 @@
 /**
  * graduator-core.js — shared mechanism for the feedback-loop graduators.
  *
- * Story #3845 / Epic #3823. The audit-results graduator
- * (`audit-results-graduator.js`) and the code-review graduator
- * (the since-retired `code-review-graduator.js`) duplicated ~90% of their mechanism: a
+ * Story #3845 / Epic #3823. The since-retired audit-results and code-review
+ * graduators duplicated ~90% of their mechanism: a
  * `spawn`-based child runner, the `git cat-file` path probe, the
  * `gh search issues` idempotency probe, the `gh issue create` filer, the
  * `isAutoFileEnabled` toggle reader, and the route → probe → file
- * envelope walk. This module folds all of that into one place so the two
- * graduators become thin shells that inject the bits that genuinely
- * differ (the finding parser and the body/title/label builders).
+ * envelope walk. This module folds all of that into one place so a
+ * graduator becomes a thin shell that injects the bits that genuinely
+ * differ (the body/title/label builders).
+ *
+ * Story #5003 removed the structured-comment read limb. Both comment-reading
+ * graduators were Epic-era — they walked an Epic's `verification-results`
+ * comment, and v2 has no Epics — leaving `retro-proposals-graduator.js` and
+ * its pre-parsed `findings[]` as the one live caller.
  *
  * The third `runGh` spawn copy in `prior-feedback-fetcher.js` is also
  * collapsed onto the single `runChild` helper here.
@@ -34,11 +38,10 @@
  *   - **Per-run filing cap.** `graduate()` stops filing once
  *     `maxFilingsPerRun` issues are created and records the excess as
  *     skipped `cap-reached`.
- *   - **Pre-parsed / path-less seam.** `graduate()` accepts a pre-parsed
- *     `findings` array (bypassing structured-comment parsing), and a
- *     path-less finding skips the path-exists gate instead of being
- *     misclassified `file-removed` — the seam the retro auto-filer
- *     consumes.
+ *   - **Pre-parsed / path-less seam.** `graduate()` takes its findings as a
+ *     pre-parsed array, and a path-less finding skips the path-exists gate
+ *     instead of being misclassified `file-removed` — the seam the retro
+ *     auto-filer consumes.
  *   - **Durable cross-repo deferral.** Cross-repo-deferred findings are
  *     upserted into a structured comment on the Epic instead of only a
  *     log line.
@@ -50,34 +53,7 @@ import { createHash } from 'node:crypto';
 import { inNodeTestContext } from '../config/temp-paths.js';
 import { LABEL_COLORS } from '../label-constants.js';
 import { classifyPathSource as defaultClassifier } from '../observability/source-classifier.js';
-import {
-  structuredCommentMarker,
-  upsertStructuredComment,
-} from '../orchestration/ticketing.js';
-
-/**
- * The single structured-comment marker for the unified `verification-results`
- * findings contract (Story #4411, Epic #4405). It replaces the two retired
- * per-graduator markers (the former code-review and audit-results
- * structured-comment markers). Both feedback-loop graduators
- * search the Epic's comments for this one marker so they file follow-ups
- * from the same unified source comment that `runCodeReview` upserts (comment
- * type `verification-results`). Derived from the canonical
- * `structuredCommentMarker` builder so the read-side marker stays byte-stable
- * with the write side rather than being hand-copied.
- */
-export const VERIFICATION_RESULTS_MARKER = structuredCommentMarker(
-  'verification-results',
-);
-
-/**
- * The single "no source comment" skip reason for the unified contract. Both
- * graduators surface this reason when the Epic carries no
- * `verification-results` comment, replacing the two retired
- * `no-code-review-comment` / `no-audit-results-comment` reasons.
- */
-export const NO_VERIFICATION_RESULTS_COMMENT_REASON =
-  'no-verification-results-comment';
+import { upsertStructuredComment } from '../orchestration/ticketing.js';
 
 /**
  * Default child-process timeout. A hung `gh`/`git` spawn previously blocked
@@ -814,28 +790,24 @@ export async function createFollowUpIssue({
 }
 
 /**
- * Validate the `graduate` preconditions (toggle, epicId, provider shape,
- * currentRepo shape). Returns `null` when all preconditions pass, or a
- * `{ skipped?, errors? }` partial-envelope the caller short-circuits on.
- * Story #4075 — extracted from `graduate` so the orchestrating body holds
- * no guard-chain branching.
+ * Validate the `graduate` preconditions (toggle, epicId, currentRepo shape).
+ * Returns `null` when all preconditions pass, or a `{ skipped?, errors? }`
+ * partial-envelope the caller short-circuits on. Story #4075 — extracted from
+ * `graduate` so the orchestrating body holds no guard-chain branching.
+ *
+ * Story #5003 dropped the `provider.getTicketComments` gate with the
+ * structured-comment read limb. The provider is now consulted only by the
+ * best-effort cross-repo-deferred upsert, which reports its own faults into
+ * `errors[]` — gating the whole walk on a shape only that path needs would
+ * refuse work the walk can complete.
  */
-function checkGraduatePreconditions({
-  epicId,
-  provider,
-  currentRepo,
-  config,
-  spec,
-}) {
+function checkGraduatePreconditions({ epicId, currentRepo, config, spec }) {
   if (!spec.isAutoFileEnabled(config)) {
     return { skipped: [{ reason: 'toggle-disabled' }] };
   }
   if (!Number.isInteger(epicId) || epicId < 1) {
     return { errors: [`${spec.fnName}: missing or invalid epicId`] };
   }
-  if (!provider || typeof provider.getTicketComments !== 'function') {
-    return { errors: [`${spec.fnName}: provider lacks getTicketComments`] };
-  }
   if (
     !currentRepo ||
     typeof currentRepo.owner !== 'string' ||
@@ -846,36 +818,6 @@ function checkGraduatePreconditions({
   return null;
 }
 
-/**
- * Read the source structured comment off the Epic and parse its findings.
- * Returns `{ findings }` on success, or `{ skipped?, errors? }` for the
- * no-comment / parse-empty / fetch-error short-circuits. Story #4075 —
- * extracted from `graduate`.
- */
-async function loadGraduateFindings({ epicId, provider, spec }) {
-  let comments;
-  try {
-    comments = await provider.getTicketComments(epicId);
-  } catch (err) {
-    return {
-      errors: [
-        `getTicketComments failed for epic #${epicId}: ${err?.message ?? err}`,
-      ],
-    };
-  }
-  const matched = (Array.isArray(comments) ? comments : []).filter(
-    (c) => typeof c?.body === 'string' && c.body.includes(spec.commentMarker),
-  );
-  if (matched.length === 0) {
-    return { skipped: [{ reason: spec.noCommentReason }] };
-  }
-  const findings = spec.parseFindings(matched[matched.length - 1].body);
-  if (findings.length === 0) {
-    return { skipped: [{ reason: 'no-non-blocking-findings' }] };
-  }
-  return { findings };
-}
-
 /**
  * Probe whether a finding was already filed, checking both the current
  * content-hash marker AND the legacy `(epicId, parse-index)` marker so
@@ -1267,17 +1209,16 @@ async function persistCrossRepoDeferred({
 }
 
 /**
- * Parametrized graduator walk. Parses non-blocking findings (from the
- * Epic's structured comment, or a pre-parsed `findings` array), then for
- * each finding runs the shared route → path probe → idempotency probe →
+ * Parametrized graduator walk. Takes a pre-parsed `findings` array and, for
+ * each finding, runs the shared route → path probe → idempotency probe →
  * cap → file sequence. Never throws — every failure path is captured in
  * `errors[]`.
  *
+ * Each finding MUST carry `{ severity, path, summary, index }` and MAY carry
+ * additional fields (e.g. `category`) that the builders use.
+ *
  * The per-graduator variation lives entirely in the injected callbacks:
  *
- *   - `parseFindings(body)` — turns the rendered comment into findings.
- *     Each finding MUST carry `{ severity, path, summary, index }` and
- *     MAY carry additional fields (e.g. `lens`) that the builder uses.
  *   - `buildContentMarker(epicId, finding)` — the content-hash HTML-comment
  *     marker embedded in (and searched for in) follow-up bodies.
  *   - `buildLegacyMarker(epicId, index)` — the pre-cutover ordinal marker,
@@ -1299,7 +1240,8 @@ async function persistCrossRepoDeferred({
  *
  * @param {object} opts
  * @param {number} opts.epicId
- * @param {object} opts.provider — exposes `getTicketComments(ticketId)`
+ * @param {object} opts.provider — exposes `postComment(ticketId, body)` for
+ *   the durable cross-repo-deferred persistence
  * @param {object} [opts.config]
  * @param {{owner: string, repo: string}} opts.currentRepo
  * @param {{owner: string, repo: string}} [opts.frameworkRepo]
@@ -1310,9 +1252,9 @@ async function persistCrossRepoDeferred({
  * @param {string} [opts.cwd]
  * @param {number} [opts.timeoutMs] — per-spawn watchdog bound
  * @param {number} [opts.maxFilingsPerRun] — per-run filing cap
- * @param {Array<object>} [opts.findings] — pre-parsed findings; when
- *   provided, the structured-comment read/parse is bypassed (the retro
- *   auto-filer seam).
+ * @param {Array<object>} opts.findings — the pre-parsed findings to file.
+ *   Required: a non-array is an `errors[]` short-circuit, never a silent
+ *   no-op.
  * @param {Set<string>} [opts.filedMarkers] — in-process memo of content
  *   markers filed so far. Pass a shared Set across multiple `graduate()`
  *   calls in one logical invocation (e.g. the retro graduator's two source
@@ -1360,23 +1302,23 @@ export async function graduate({
 
   const precondition = checkGraduatePreconditions({
     epicId,
-    provider,
     currentRepo,
     config,
     spec,
   });
   if (precondition) return { ...envelope, ...precondition };
 
-  let findings;
-  if (Array.isArray(preParsedFindings)) {
-    // Pre-parsed seam (retro auto-filer): bypass the structured-comment
-    // read + parse entirely and file the supplied findings directly.
-    findings = preParsedFindings;
-  } else {
-    const loaded = await loadGraduateFindings({ epicId, provider, spec });
-    if (!loaded.findings) return { ...envelope, ...loaded };
-    findings = loaded.findings;
+  // Pre-parsed findings are the only source (Story #5003). The
+  // structured-comment read/parse limb went with the audit-results
+  // graduator: it walked an Epic's `verification-results` comment, and v2
+  // has no Epics, so it could only ever resolve zero findings.
+  if (!Array.isArray(preParsedFindings)) {
+    return {
+      ...envelope,
+      errors: [`${spec.fnName}: findings[] is required and must be an array`],
+    };
   }
+  const findings = preParsedFindings;
 
   // Blast-radius guard (Story #4837): decided ONCE per walk, before the
   // first spawn, so a refused context costs no child process at all.

package/.agents/scripts/lib/feedback-loop/retro-proposals-graduator.js

@@ -138,6 +138,14 @@ function metaSourceLabel(source) {
  * a single source so the constant classifier routes every finding in the
  * bucket to the correct repo (and the label reflects that source).
  *
+ * The bundle carries **only** builders. It used to declare a
+ * `commentMarker` / `noCommentReason` / `parseFindings` trio purely to satisfy
+ * the shared walk's shape — this graduator supplies its findings pre-parsed,
+ * so the walk never consulted any of the three. Story #5003 deleted that limb
+ * from `graduate()` along with the Epic-era graduator that was its only real
+ * consumer, and the placeholder fields went with it: a declared-but-unread
+ * field is a standing invitation to write a parser nothing will call.
+ *
  * @param {'framework'|'consumer'} source
  * @returns {object}
  */
@@ -145,12 +153,6 @@ function makeSpec(source) {
   return {
     fnName: 'graduateRetroProposals',
     isAutoFileEnabled,
-    // Pre-parsed seam: the comment marker / parser are never consulted
-    // (findings are supplied directly), but the fields are declared for the
-    // shared walk's shape.
-    commentMarker: '<!-- structured-comment: retro -->',
-    noCommentReason: 'no-retro-comment',
-    parseFindings: () => [],
     buildContentMarker,
     buildMatchTokens,
     crossRepoCommentAttrs: { graduator: 'retro-proposals' },
@@ -210,8 +212,8 @@ function toFinding(item, source, index) {
  *
  * @param {object} opts
  * @param {number} opts.epicId
- * @param {object} opts.provider — ticketing provider (getTicketComments;
- *   postComment for the cross-repo-deferred persistence).
+ * @param {object} opts.provider — ticketing provider (`postComment`, for the
+ *   cross-repo-deferred persistence).
  * @param {object} [opts.config] — resolved agentrc.
  * @param {{owner: string, repo: string}} opts.currentRepo — the repo the
  *   retro is running inside (the consumer's own repo); the cross-repo guard's

package/.agents/scripts/lib/fs-walk.js

@@ -0,0 +1,52 @@
+/**
+ * fs-walk.js — the one recursive file walker the lint scripts share.
+ *
+ * `check-lifecycle-lint.js` and `lint-label-vocabulary.js` each carried a
+ * private copy of this generator, differing only in the extension they
+ * matched — the second one's comment said so outright ("mirrors the walker
+ * shape in check-lifecycle-lint.js"). Story #5024 extracted it: shrinking
+ * check-lifecycle-lint.js pushed its duplication percentage up on an unchanged
+ * clone count, which is the ratchet correctly pointing at boilerplate that
+ * should not have been copied twice.
+ *
+ * A missing directory yields nothing rather than throwing. That is
+ * load-bearing, not lenient: the lint surfaces are directories a deletion can
+ * legitimately remove (Story #5024 deleted `lifecycle/listeners/`), and a scan
+ * of an absent path is vacuously clean, not an error. Every other `readdir`
+ * failure — a permission error, a file where a directory was expected —
+ * propagates, so a genuinely broken scan cannot read as clean.
+ */
+
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Walk a directory tree synchronously, yielding absolute paths of every file
+ * whose name ends with `extension`.
+ *
+ * @param {string} dir Absolute directory to walk.
+ * @param {string} extension Extension to match, leading dot included (`.js`).
+ * @param {{ readDir?: typeof readdirSync }} [ports] Injectable for tests.
+ * @returns {Generator<string, void, void>}
+ */
+export function* walkFilesByExtension(
+  dir,
+  extension,
+  { readDir = readdirSync } = {},
+) {
+  let entries;
+  try {
+    entries = readDir(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === 'ENOENT') return;
+    throw err;
+  }
+  for (const entry of entries) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkFilesByExtension(p, extension, { readDir });
+    } else if (entry.isFile() && entry.name.endsWith(extension)) {
+      yield p;
+    }
+  }
+}

package/.agents/scripts/lib/git-branch-lifecycle.js

@@ -129,8 +129,8 @@ export function classifyBranchSeed({ localHas, remoteHas }) {
  *     throws (the v2 standalone path has no concurrent creator to race).
  *
  * The asymmetric surrounding wrappers (merged-sweep, fast-forward,
- * donor-prime, workspace-verify, phase-timer) are deliberately NOT folded
- * in — they stay in their respective callers.
+ * donor-prime, workspace-verify) are deliberately NOT folded in — they stay
+ * in their respective callers.
  *
  * Caller-specific log lines and error text are passed in as the `messages`
  * data bag so behaviour stays byte-identical to the pre-extraction switches.

package/.agents/scripts/lib/git-utils.js

@@ -28,6 +28,7 @@
  */
 
 import { execFileSync, spawnSync } from 'node:child_process';
+import { execFileCapture, spawnCapture } from './child-exec.js';
 
 /**
  * Result of a `gitSpawn` invocation. Field semantics match `child_process.spawnSync`
@@ -40,23 +41,6 @@ import { execFileSync, spawnSync } from 'node:child_process';
  * @property {string} stderr - Trimmed stderr.
  */
 
-/**
- * Explicit stdout ceiling for every git invocation in this module.
- *
- * Both child-process runners default `maxBuffer` to 1 MB, at which point the
- * child is killed and the call fails with `ENOBUFS` for a reason unrelated to
- * git. The push path is the sharp edge: `git push` relays the whole `pre-push`
- * hook output, which is unbounded by design — this repo's hook emits a full
- * `check-baselines` envelope, measured at 2,166,643 bytes, so every Story
- * close failed at `phase: push` once hooks became reachable inside worktrees.
- *
- * 64 MB is the bound Story #4914 already set on `baselines/git-base.js` for
- * the identical failure, matching `run-test-profile.js`,
- * `audit-baselines/trend.js` and `audit-baselines/weights.js`. This module was
- * missed by that sweep.
- */
-const MAX_BUFFER_BYTES = 64 * 1024 * 1024;
-
 let _execFileSync = execFileSync;
 let _spawnSync = spawnSync;
 
@@ -129,26 +113,30 @@ export function __setGitRunners(exec, spawn) {
  * the interface returned by {@link createGitInterface} route through this —
  * they differ only in which `execFileSync` they hand it.
  *
+ * Buffer, shell and encoding policy belong to
+ * [`child-exec.js`](child-exec.js); this function contributes only the git
+ * specifics (argv prefix, cwd, scrubbed env).
+ *
  * @param {typeof execFileSync} exec
  * @param {string} cwd
  * @param {string[]} args
  * @returns {string} Trimmed stdout text.
  */
 function runGitSync(exec, cwd, args) {
-  return exec('git', args, {
-    cwd,
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    shell: false,
-    env: cleanGitEnv(),
-    maxBuffer: MAX_BUFFER_BYTES,
-  }).trim();
+  return String(
+    execFileCapture('git', args, {
+      run: exec,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: cleanGitEnv(),
+    }),
+  ).trim();
 }
 
 /**
  * The **single** non-throwing git runner — the `spawnSync` counterpart of
  * {@link runGitSync}, normalising `status`/stdout/stderr into a
- * {@link GitResult}.
+ * {@link GitResult} via the shared exec surface.
  *
  * @param {typeof spawnSync} spawn
  * @param {string} cwd
@@ -156,19 +144,11 @@ function runGitSync(exec, cwd, args) {
  * @returns {GitResult}
  */
 function runGitSpawn(spawn, cwd, args) {
-  const result = spawn('git', args, {
+  return spawnCapture('git', args, {
+    run: spawn,
     cwd,
-    stdio: 'pipe',
-    encoding: 'utf-8',
-    shell: false,
     env: cleanGitEnv(),
-    maxBuffer: MAX_BUFFER_BYTES,
   });
-  return {
-    status: result.status ?? 1,
-    stdout: (result.stdout ?? '').trim(),
-    stderr: (result.stderr ?? '').trim(),
-  };
 }
 
 /**