@boxxy/closeout 0.2.1 → 0.2.3

package/README.md

@@ -11,8 +11,9 @@
   </p>
 </div>
 
-boxxy's phase kinds: triage, design, build and review. Each one gives the input of an attempt,
-checks the close-out the agent sends at the end of it, and settles the attempt from that close-out.
+boxxy's phase kinds: triage, design, build, review and verify. Each one gives the input of an
+attempt, checks the close-out the agent sends at the end of it, and settles the attempt from that
+close-out.
 
 The package does no I/O: the caller passes in the item, its attempts, the attempt's evidence rows
 and what a close-out may name.
@@ -29,11 +30,13 @@ The package runs on [Bun](https://bun.sh) 1.3 or newer.
 
 ## Features
 
-- `triage`, `design`, `build` and `review`, the four phase kinds, and `phaseKinds`, which lists them
-  for the rules loader. Each parser returns the stored close-out, or every problem with it in one
-  pass.
-- `closeOutLimits`, the byte limits of a close-out, and `measureJsonBytes`, which measures a value
-  as stored.
+- `triage`, `design`, `build` and `verify`, and `phaseKinds`, which lists them for the rules loader.
+  Each parser returns the stored close-out, or every problem with it in one pass.
+- `createReviewPhase`, which builds the review phase kind on the review gate's `buildCommand`. The
+  server adds it to `phaseKinds`.
+- `countUnrelatedLines`, the changed lines of a later review in files that had no open finding.
+- `closeOutLimits`, the byte limit of a close-out, and `measureJsonBytes`, which measures a value as
+  stored.
 - `dedupeOpenItems`, which matches each open item the agent reports to an open item with the same
   title.
 

package/dist/build-schema-parser.d.ts

@@ -2,7 +2,7 @@ import type { CloseOutContext, CloseOutParser, CloseOutProblem } from '@boxxy/mo
 import { z } from 'zod';
 interface SchemaParserInput<Raw, Body> {
     readonly schema: z.ZodType<Raw>;
-    readonly toBody: (raw: Raw, frictionDropped: number) => Body;
+    readonly toBody: (raw: Raw, frictionDropped: number, ctx: CloseOutContext) => Body;
     readonly check: (body: Body, ctx: CloseOutContext) => readonly CloseOutProblem[];
 }
 export declare function buildSchemaParser<Raw, Body>(input: SchemaParserInput<Raw, Body>): CloseOutParser<Body>;

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export { measureJsonBytes } from './measure-json-bytes.ts';
 export { phaseKinds } from './phase-kinds.ts';
 export { build } from './phases/build.ts';
 export { design } from './phases/design.ts';
-export { review } from './phases/review.ts';
+export { createReviewPhase } from './phases/create-review-phase.ts';
 export { triage } from './phases/triage.ts';
-export type { CloseOutLimits, NoslopReport } from './types.ts';
+export { verify } from './phases/verify.ts';
+export { countUnrelatedLines } from './review/count-unrelated-lines.ts';
+export type { CloseOutLimits } from './types.ts';

package/dist/phases/create-review-phase.d.ts

@@ -0,0 +1,2 @@
+import type { ReviewGate } from '@boxxy/model';
+export declare function createReviewPhase(deps: Pick<ReviewGate, 'buildCommand'>): import("@boxxy/model").PhaseKind<unknown, import("@boxxy/content-hash").JsonValue, readonly string[]>;

package/dist/phases/{review.d.ts → verify.d.ts}

@@ -1 +1 @@
-export declare const review: import("@boxxy/model").PhaseKind<unknown, import("@boxxy/content-hash").JsonValue, readonly string[]>;
+export declare const verify: import("@boxxy/model").PhaseKind<unknown, import("@boxxy/content-hash").JsonValue, readonly string[]>;

package/dist/review/build-round-cause.d.ts

@@ -0,0 +1,2 @@
+import type { RoundCause, Settled } from '@boxxy/model';
+export declare function buildRoundCause(history: readonly Settled[]): RoundCause;

package/dist/review/count-unrelated-lines.d.ts

@@ -0,0 +1,2 @@
+import type { ChangedFile } from '@boxxy/model';
+export declare function countUnrelatedLines(changed: readonly ChangedFile[], findingPaths: readonly string[]): number;

package/dist/types.d.ts

@@ -1,7 +1,3 @@
-import type { z } from 'zod';
-import type { noslopReportSchema } from './noslop/noslop-report-schema.ts';
 export interface CloseOutLimits {
     readonly closeOutBytes: 120_000;
-    readonly noslopReportBytes: 32_768;
 }
-export type NoslopReport = z.output<typeof noslopReportSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxxy/closeout",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "boxxy's phase kinds: the input, the close-out parser and the settle rule of triage, design, build and review",
   "homepage": "https://github.com/zgeoff/boxxy/tree/main/modules/closeout#readme",
   "bugs": "https://github.com/zgeoff/boxxy/issues",
@@ -20,8 +20,7 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./src/index.ts"
-    },
-    "./test-utils/*": "./src/test-utils/*.ts"
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -31,14 +30,14 @@
     "typecheck": "tsrs --noEmit"
   },
   "dependencies": {
-    "@boxxy/model": "0.2.1",
+    "@boxxy/model": "0.2.3",
     "tiny-invariant": "1.3.3",
     "ts-pattern": "5.9.2",
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@boxxy/planning": "0.2.1",
-    "@boxxy/rules": "0.2.1",
+    "@boxxy/planning": "0.2.3",
+    "@boxxy/rules": "0.2.3",
     "@faker-js/faker": "10.6.0"
   },
   "peerDependencies": {

package/src/build-schema-parser.ts

@@ -8,7 +8,7 @@ import { measureJsonBytes } from './measure-json-bytes.ts';
 interface SchemaParserInput<Raw, Body> {
   // the body as the agent sends it, with no `frictionDropped`: the parser counts that itself
   readonly schema: z.ZodType<Raw>;
-  readonly toBody: (raw: Raw, frictionDropped: number) => Body;
+  readonly toBody: (raw: Raw, frictionDropped: number, ctx: CloseOutContext) => Body;
 
   // the rules of the phase that the schema cannot hold; each problem comes back
   readonly check: (body: Body, ctx: CloseOutContext) => readonly CloseOutProblem[];
@@ -41,7 +41,7 @@ function parseCloseOut<Raw, Body>(
     };
   }
 
-  const body = input.toBody(parsed.data, split.dropped);
+  const body = input.toBody(parsed.data, split.dropped, ctx);
   const problems = input.check(body, ctx);
 
   if (problems.length > 0) {
@@ -71,6 +71,12 @@ function splitFriction(raw: unknown): FrictionSplit {
   }
 
   const { frictionDropped: _, ...rest } = raw;
+
+  // a body with no friction list, such as a review's, keeps no `friction` key for a strict schema
+  if (!('friction' in rest)) {
+    return { candidate: rest, keptRawIndexes: [], dropped: 0 };
+  }
+
   const entries: readonly unknown[] = Array.isArray(rest['friction']) ? rest['friction'] : [];
   const keptRawIndexes = entries.flatMap((entry, index) => (isUntargeted(entry) ? [] : [index]));
 

package/src/close-out-limits.ts

@@ -5,5 +5,4 @@ import type { CloseOutLimits } from './types.ts';
 // so a layer that escapes the JSON once more still fits.
 export const closeOutLimits: CloseOutLimits = {
   closeOutBytes: 120_000,
-  noslopReportBytes: 32_768,
 };

package/src/index.ts

@@ -4,6 +4,8 @@ export { measureJsonBytes } from './measure-json-bytes.ts';
 export { phaseKinds } from './phase-kinds.ts';
 export { build } from './phases/build.ts';
 export { design } from './phases/design.ts';
-export { review } from './phases/review.ts';
+export { createReviewPhase } from './phases/create-review-phase.ts';
 export { triage } from './phases/triage.ts';
-export type { CloseOutLimits, NoslopReport } from './types.ts';
+export { verify } from './phases/verify.ts';
+export { countUnrelatedLines } from './review/count-unrelated-lines.ts';
+export type { CloseOutLimits } from './types.ts';

package/src/phase-kinds.ts

@@ -1,8 +1,9 @@
 import type { PhaseKind } from '@boxxy/model';
 import { build } from './phases/build.ts';
 import { design } from './phases/design.ts';
-import { review } from './phases/review.ts';
 import { triage } from './phases/triage.ts';
+import { verify } from './phases/verify.ts';
 
-// The phase kinds that the server passes to the rules loader, in pipeline order
-export const phaseKinds: readonly PhaseKind[] = [triage, design, build, review];
+// The phase kinds that need no port, in pipeline order. The server adds the review phase kind,
+// which it builds on its review gate.
+export const phaseKinds: readonly PhaseKind[] = [triage, design, build, verify];

package/src/phases/build.ts

@@ -7,12 +7,13 @@ import type {
   Effect,
   ItemView,
   PhaseInputContext,
+  SentBack,
 } from '@boxxy/model';
 import {
   brandSchemas,
   buildCloseOutSchema,
   definePhase,
-  reviewCloseOutSchema,
+  storedReviewCloseOutSchema,
   toJSONValue,
 } from '@boxxy/model';
 import { match } from 'ts-pattern';
@@ -59,19 +60,25 @@ export const build = definePhase({
   }),
 });
 
-// The findings come from the latest review, and only when it asked for changes: a build after
-// a passed review, sent back by the owner, gets none.
 function buildBuildInput(ctx: PhaseInputContext): BuildInput {
-  const review = findLatestCloseOut(ctx.history, 'review', reviewCloseOutSchema);
-
   return {
     acceptance: buildCriterionTexts(ctx.item),
     design: findLatestDesign(ctx.history),
-    findings: review?.verdict.kind === 'changes-requested' ? review.verdict.findings : [],
+    sentBack: findReviewSentBack(ctx),
     pullRequest: findPullRequestLink(ctx.pullRequests),
   };
 }
 
+// Only a latest review that asked for changes sends the build its findings: a build after a
+// passed review, sent back by the owner, gets none.
+function findReviewSentBack(ctx: PhaseInputContext): SentBack | null {
+  const reading = findLatestCloseOut(ctx.history, 'review', storedReviewCloseOutSchema)?.reading;
+
+  return reading?.status === 'blocked' && reading.why === 'open-findings'
+    ? { from: 'review', head: reading.head, open: reading.open, answerHint: reading.answerHint }
+    : null;
+}
+
 function collectBuildProblems(closeOut: BuildCloseOut, ctx: CloseOutContext): CloseOutProblem[] {
   const acceptance = new Set(ctx.item.acceptance.map((criterion) => criterion.id));
   const own = new Set(ctx.evidence.map((row) => row.factId));

package/src/phases/create-review-phase.ts

@@ -0,0 +1,89 @@
+import type {
+  GateReading,
+  PhaseInputContext,
+  ReviewCloseOut,
+  ReviewGate,
+  ReviewInput,
+} from '@boxxy/model';
+import {
+  brandSchemas,
+  collectSettled,
+  definePhase,
+  reviewCloseOutSchema,
+  toJSONValue,
+} from '@boxxy/model';
+import { match } from 'ts-pattern';
+import { buildSchemaParser } from '../build-schema-parser.ts';
+import { buildRoundCause } from '../review/build-round-cause.ts';
+import { findPullRequestLink } from '../utils/find-pull-request-link.ts';
+
+// The server passes the gate's pure `buildCommand`, so the module never imports an adapter. The
+// session runs the command and sends the tool's raw result; the server builds the stored
+// close-out from it, and this parser reads that.
+export function createReviewPhase(deps: Pick<ReviewGate, 'buildCommand'>) {
+  return definePhase({
+    name: brandSchemas.phaseName.parse('review'),
+    version: 2,
+    worker: brandSchemas.workerKindName.parse('atc.session'),
+    outcomes: ['passed', 'changes-requested', 'failed'],
+    needsAcceptance: true,
+    input: (ctx) => toJSONValue(buildReviewInput(ctx, deps)),
+    closeOut: buildSchemaParser({
+      schema: reviewCloseOutSchema,
+      toBody: (raw): ReviewCloseOut => raw,
+      check: () => [],
+    }),
+    settle: (input) => {
+      const outcome = pickReviewOutcome(input.closeOut.reading);
+
+      return {
+        state: outcome === 'failed' ? 'failed' : 'succeeded',
+        failure: outcome === 'failed' ? 'review-failed' : null,
+        outcome,
+        effects: [],
+        frictionDropped: 0,
+      };
+    },
+  });
+}
+
+// The round counts the reviews since the item's latest retry that asked for changes.
+function buildReviewInput(
+  ctx: PhaseInputContext,
+  deps: Pick<ReviewGate, 'buildCommand'>,
+): ReviewInput {
+  const since = ctx.retries.at(-1)?.at ?? Number.NEGATIVE_INFINITY;
+  const settled = collectSettled(ctx.history).filter((attempt) => attempt.endedAt > since);
+
+  const round =
+    1 +
+    settled.filter(
+      (attempt) => attempt.phase === 'review' && attempt.outcome === 'changes-requested',
+    ).length;
+
+  const cause = buildRoundCause(settled);
+  const link = findPullRequestLink(ctx.pullRequests);
+
+  if (link === null) {
+    return { pullRequest: null, round, cause, command: null };
+  }
+
+  const pullRequest = { repo: link.repo, number: link.number };
+
+  return {
+    pullRequest,
+    round,
+    cause,
+    command: deps.buildCommand({ attempt: ctx.attempt, pullRequest, round, cause }),
+  };
+}
+
+// A failed call, an unreadable result or a reading that covers no head is `failed`: boxxy cannot
+// tell whether the head is clear.
+function pickReviewOutcome(reading: GateReading): 'passed' | 'changes-requested' | 'failed' {
+  return match(reading)
+    .with({ status: 'passed' }, () => 'passed' as const)
+    .with({ status: 'blocked', why: 'open-findings' }, () => 'changes-requested' as const)
+    .with({ status: 'blocked' }, { status: 'not-covered' }, () => 'failed' as const)
+    .exhaustive();
+}

package/src/phases/verify.ts

@@ -0,0 +1,67 @@
+import type { PhaseInputContext, VerifyCloseOut, VerifyInput } from '@boxxy/model';
+import {
+  brandSchemas,
+  definePhase,
+  storedReviewCloseOutSchema,
+  toJSONValue,
+  verifyCloseOutSchema,
+  verifyInputSchema,
+} from '@boxxy/model';
+import { match } from 'ts-pattern';
+import type { z } from 'zod';
+import { buildSchemaParser } from '../build-schema-parser.ts';
+import { findLatestCloseOut } from '../utils/find-latest-close-out.ts';
+import { findPullRequestLink } from '../utils/find-pull-request-link.ts';
+
+// the parser copies `session` from the attempt's input, so the agent never sends it
+const verifyBodySchema = verifyCloseOutSchema.omit({ session: true, frictionDropped: true });
+
+export const verify = definePhase({
+  name: brandSchemas.phaseName.parse('verify'),
+  version: 1,
+  worker: brandSchemas.workerKindName.parse('atc.session'),
+  outcomes: ['verified', 'failed', 'blocked', 'abandoned'],
+  needsAcceptance: true,
+  input: (ctx) => toJSONValue(buildVerifyInput(ctx)),
+  closeOut: buildSchemaParser({
+    schema: verifyBodySchema,
+    toBody: (raw: z.output<typeof verifyBodySchema>, frictionDropped, ctx): VerifyCloseOut => ({
+      ...raw,
+      session: verifyInputSchema.parse(ctx.input).session,
+      frictionDropped,
+    }),
+    check: () => [],
+  }),
+
+  // A failed verify graded the work, so it succeeds, and a `session: builder` grader keeps its
+  // session for the rework. A blocked or abandoned verify graded nothing, and fails.
+  settle: (input) => ({
+    ...match(input.closeOut.result)
+      .with({ kind: 'verified' }, { kind: 'failed' }, () => ({
+        state: 'succeeded' as const,
+        failure: null,
+      }))
+      .with({ kind: 'blocked' }, { kind: 'abandoned' }, (ended) => ({
+        state: 'failed' as const,
+        failure: ended.kind,
+      }))
+      .exhaustive(),
+    outcome: input.closeOut.result.kind,
+    effects: input.closeOut.friction.map((friction) => ({
+      kind: 'record-proposal' as const,
+      friction,
+    })),
+    frictionDropped: input.closeOut.frictionDropped,
+  }),
+});
+
+// A recipe with no `session` field starts a fresh grader.
+function buildVerifyInput(ctx: PhaseInputContext): VerifyInput {
+  const reading = findLatestCloseOut(ctx.history, 'review', storedReviewCloseOutSchema)?.reading;
+
+  return {
+    pullRequest: findPullRequestLink(ctx.pullRequests),
+    head: reading?.status === 'passed' ? reading.head : null,
+    session: ctx.session ?? 'fresh',
+  };
+}

package/src/review/build-round-cause.ts

@@ -0,0 +1,20 @@
+import type { RoundCause, Settled } from '@boxxy/model';
+
+// Why a review round runs, from the item's settled attempts since its latest retry, oldest
+// first. `rework`: the latest settled attempt that is not a build is a review that asked for
+// changes. `recheck`: the item came back from another phase, or the last review failed.
+export function buildRoundCause(history: readonly Settled[]): RoundCause {
+  const reviews = history.filter(
+    (settled) => settled.phase === 'review' && settled.outcome !== 'lost',
+  );
+
+  if (reviews.length === 0) {
+    return 'first';
+  }
+
+  const latestOther = history.findLast((settled) => settled.phase !== 'build');
+
+  return latestOther?.phase === 'review' && latestOther.outcome === 'changes-requested'
+    ? 'rework'
+    : 'recheck';
+}

package/src/review/count-unrelated-lines.ts

@@ -0,0 +1,13 @@
+import type { ChangedFile } from '@boxxy/model';
+
+// The changed lines in the files that had no open finding at the earlier review.
+export function countUnrelatedLines(
+  changed: readonly ChangedFile[],
+  findingPaths: readonly string[],
+): number {
+  const withFindings = new Set(findingPaths);
+
+  return changed
+    .filter((file) => !withFindings.has(file.path))
+    .reduce((sum, file) => sum + file.changedLines, 0);
+}

package/src/types.ts

@@ -1,13 +1,4 @@
-import type { z } from 'zod';
-import type { noslopReportSchema } from './noslop/noslop-report-schema.ts';
-
 export interface CloseOutLimits {
   // a close-out as stored, in any phase
   readonly closeOutBytes: 120_000;
-
-  // the most of noslop's result that a review close-out keeps whole
-  readonly noslopReportBytes: 32_768;
 }
-
-// What `noslop review --json --report json` printed, as the review session sends it
-export type NoslopReport = z.output<typeof noslopReportSchema>;

package/dist/noslop/build-noslop-summary.d.ts

@@ -1,3 +0,0 @@
-import type { NoslopSummary } from '@boxxy/model';
-import type { NoslopReport } from '../types.ts';
-export declare function buildNoslopSummary(report: NoslopReport): NoslopSummary;

package/dist/noslop/noslop-report-schema.d.ts

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-export declare const noslopReportSchema: z.ZodObject<{
-    version: z.ZodNumber;
-    reviewID: z.ZodString;
-    head: z.core.$ZodBranded<z.ZodString, "CommitSha", "out">;
-    findings: z.ZodArray<z.ZodUnknown>;
-    failedCalls: z.ZodArray<z.ZodUnknown>;
-    fixChecks: z.ZodExactOptional<z.ZodArray<z.ZodUnknown>>;
-}, z.core.$loose>;

package/dist/test-utils/build-mock-noslop-report.d.ts

@@ -1,2 +0,0 @@
-import type { NoslopReport } from '../types.ts';
-export declare function buildMockNoslopReport(overrides?: Partial<NoslopReport>): NoslopReport;

package/src/noslop/build-noslop-summary.ts

@@ -1,25 +0,0 @@
-import type { NoslopSummary } from '@boxxy/model';
-import { toJSONValue } from '@boxxy/model';
-import { closeOutLimits } from '../close-out-limits.ts';
-import { measureJsonBytes } from '../measure-json-bytes.ts';
-import type { NoslopReport } from '../types.ts';
-
-// Keeps the counts of noslop's result, and the result whole only when it fits the limit: a cut
-// part of the JSON would be no report at all.
-export function buildNoslopSummary(report: NoslopReport): NoslopSummary {
-  const whole = toJSONValue(report);
-  const reportBytes = measureJsonBytes(whole);
-
-  return {
-    version: report.version,
-    reviewID: report.reviewID,
-    head: report.head,
-    counts: {
-      findings: report.findings.length,
-      failedCalls: report.failedCalls.length,
-      fixChecks: report.fixChecks?.length ?? 0,
-    },
-    reportBytes,
-    report: reportBytes <= closeOutLimits.noslopReportBytes ? whole : null,
-  };
-}

package/src/noslop/noslop-report-schema.ts

@@ -1,13 +0,0 @@
-import { brandSchemas } from '@boxxy/model';
-import { z } from 'zod';
-
-// The fields of `noslop review --json --report json` that the summary reads. Every other field passes
-// through unread, and a list's entries are not checked, so a newer noslop still parses.
-export const noslopReportSchema = z.looseObject({
-  version: z.number().int().positive(),
-  reviewID: z.string().min(1),
-  head: brandSchemas.commitSha,
-  findings: z.array(z.unknown()),
-  failedCalls: z.array(z.unknown()),
-  fixChecks: z.array(z.unknown()).exactOptional(),
-});

package/src/phases/review.ts

@@ -1,50 +0,0 @@
-import type { PhaseInputContext, ReviewCloseOut, ReviewInput } from '@boxxy/model';
-import { brandSchemas, definePhase, reviewCloseOutSchema, toJSONValue } from '@boxxy/model';
-import type { z } from 'zod';
-import { buildSchemaParser } from '../build-schema-parser.ts';
-import { buildNoslopSummary } from '../noslop/build-noslop-summary.ts';
-import { noslopReportSchema } from '../noslop/noslop-report-schema.ts';
-import { buildCriterionTexts } from '../utils/build-criterion-texts.ts';
-import { findLatestDesign } from '../utils/find-latest-design.ts';
-import { findPullRequestLink } from '../utils/find-pull-request-link.ts';
-
-// The session sends noslop's whole result; the stored close-out holds its summary instead.
-const reviewBodySchema = reviewCloseOutSchema
-  .omit({ frictionDropped: true })
-  .extend({ noslop: noslopReportSchema });
-
-export const review = definePhase({
-  name: brandSchemas.phaseName.parse('review'),
-  version: 1,
-  worker: brandSchemas.workerKindName.parse('atc.session'),
-  outcomes: ['passed', 'changes-requested'],
-  needsAcceptance: true,
-  input: (ctx) => toJSONValue(buildReviewInput(ctx)),
-  closeOut: buildSchemaParser({
-    schema: reviewBodySchema,
-    toBody: (raw: z.output<typeof reviewBodySchema>, frictionDropped): ReviewCloseOut => ({
-      ...raw,
-      noslop: buildNoslopSummary(raw.noslop),
-      frictionDropped,
-    }),
-    check: (closeOut) =>
-      closeOut.verdict.kind === 'changes-requested' && closeOut.verdict.findings.length === 0
-        ? [{ kind: 'phase-rule', message: 'changes-requested needs at least one finding' }]
-        : [],
-  }),
-  settle: (input) => ({
-    state: 'succeeded',
-    failure: null,
-    outcome: input.closeOut.verdict.kind,
-    effects: input.closeOut.friction.map((friction) => ({ kind: 'record-proposal', friction })),
-    frictionDropped: input.closeOut.frictionDropped,
-  }),
-});
-
-function buildReviewInput(ctx: PhaseInputContext): ReviewInput {
-  return {
-    acceptance: buildCriterionTexts(ctx.item),
-    design: findLatestDesign(ctx.history),
-    pullRequest: findPullRequestLink(ctx.pullRequests),
-  };
-}

package/src/test-utils/build-mock-noslop-report.ts

@@ -1,30 +0,0 @@
-import { brandSchemas } from '@boxxy/model';
-import { faker } from '@faker-js/faker';
-import type { NoslopReport } from '../types.ts';
-
-// A review result as noslop's schema version 7 prints it, with no findings.
-export function buildMockNoslopReport(overrides: Partial<NoslopReport> = {}): NoslopReport {
-  return {
-    version: 7,
-    reviewID: faker.string.uuid(),
-    repo: `${faker.word.noun()}/${faker.word.noun()}`,
-    pullRequest: null,
-    base: faker.git.commitSha(),
-    head: brandSchemas.commitSha.parse(faker.git.commitSha()),
-    title: faker.lorem.sentence(),
-    depth: 'standard',
-    special: null,
-    riskClasses: [],
-    lenses: [],
-    calls: [],
-    findings: [],
-    dropped: [],
-    failedCalls: [],
-    notReviewed: [],
-    notReviewedByLens: [],
-    configHash: faker.string.hexadecimal({ length: 64, casing: 'lower', prefix: '' }),
-    startedAt: '2026-11-02T10:00:00.000Z',
-    endedAt: '2026-11-02T10:04:00.000Z',
-    ...overrides,
-  };
-}