@boxxy/closeout 0.2.2 → 0.2.4

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,8 +30,8 @@ The package runs on [Bun](https://bun.sh) 1.3 or newer.
 
 ## Features
 
-- `triage`, `design` and `build`, and `phaseKinds`, which lists them for the rules loader. Each
-  parser returns the stored close-out, or every problem with it in one pass.
+- `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.

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

@@ -6,5 +6,6 @@ export { build } from './phases/build.ts';
 export { design } from './phases/design.ts';
 export { createReviewPhase } from './phases/create-review-phase.ts';
 export { triage } from './phases/triage.ts';
+export { verify } from './phases/verify.ts';
 export { countUnrelatedLines } from './review/count-unrelated-lines.ts';
 export type { CloseOutLimits } from './types.ts';

package/dist/phases/verify.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxxy/closeout",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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",
@@ -30,14 +30,14 @@
     "typecheck": "tsrs --noEmit"
   },
   "dependencies": {
-    "@boxxy/model": "0.2.2",
+    "@boxxy/model": "0.2.4",
     "tiny-invariant": "1.3.3",
     "ts-pattern": "5.9.2",
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@boxxy/planning": "0.2.2",
-    "@boxxy/rules": "0.2.2",
+    "@boxxy/planning": "0.2.4",
+    "@boxxy/rules": "0.2.4",
     "@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) {

package/src/index.ts

@@ -6,5 +6,6 @@ export { build } from './phases/build.ts';
 export { design } from './phases/design.ts';
 export { createReviewPhase } from './phases/create-review-phase.ts';
 export { triage } from './phases/triage.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

@@ -2,7 +2,8 @@ import type { PhaseKind } from '@boxxy/model';
 import { build } from './phases/build.ts';
 import { design } from './phases/design.ts';
 import { triage } from './phases/triage.ts';
+import { verify } from './phases/verify.ts';
 
 // 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];
+export const phaseKinds: readonly PhaseKind[] = [triage, design, build, verify];

package/src/phases/build.ts

@@ -1,4 +1,5 @@
 import type {
+  AttemptRow,
   BuildCloseOut,
   BuildInput,
   CloseOutContext,
@@ -15,6 +16,8 @@ import {
   definePhase,
   storedReviewCloseOutSchema,
   toJSONValue,
+  verifyCloseOutSchema,
+  verifyInputSchema,
 } from '@boxxy/model';
 import { match } from 'ts-pattern';
 import type { z } from 'zod';
@@ -64,21 +67,43 @@ function buildBuildInput(ctx: PhaseInputContext): BuildInput {
   return {
     acceptance: buildCriterionTexts(ctx.item),
     design: findLatestDesign(ctx.history),
-    sentBack: findReviewSentBack(ctx),
+    sentBack: findSentBack(ctx.history),
     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;
+// The latest grading of the work decides the send-back: a review that asked for changes sends
+// its findings, and a failed verify sends its features. A build after a passed review or a
+// verified verify, sent back by the owner, gets none.
+function findSentBack(history: readonly AttemptRow[]): SentBack | null {
+  const graded = history.findLast(
+    (row) => (row.phase === 'review' || row.phase === 'verify') && row.state === 'succeeded',
+  );
+
+  if (graded?.phase === 'verify') {
+    return findVerifySentBack(graded);
+  }
+
+  const reading = findLatestCloseOut(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 findVerifySentBack(verify: AttemptRow): SentBack | null {
+  const closeOut = verifyCloseOutSchema.safeParse(verify.closeOut);
+  const input = verifyInputSchema.safeParse(verify.input);
+
+  return closeOut.success && closeOut.data.result.kind === 'failed'
+    ? {
+        from: 'verify',
+        head: input.success ? input.data.head : null,
+        features: closeOut.data.result.features,
+      }
+    : 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/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',
+  };
+}